void kernel_strmv_u_t_8_lib8(int kmax, float *A, int sda, float *x, float *y,
                             int alg) {
  const int lda = 8;
  const int bs = 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;
  k = 0;
  for (; k < kmax - 7; k += 8) {
    x_0 = x[0];
    x_1 = x[1];
    x_2 = x[2];
    x_3 = x[3];
    y_0 += A[0 + lda * 0] * x_0;
    y_1 += A[0 + lda * 1] * x_0;
    y_2 += A[0 + lda * 2] * x_0;
    y_3 += A[0 + lda * 3] * x_0;
    y_4 += A[0 + lda * 4] * x_0;
    y_5 += A[0 + lda * 5] * x_0;
    y_6 += A[0 + lda * 6] * x_0;
    y_7 += A[0 + lda * 7] * x_0;
    y_0 += A[1 + lda * 0] * x_1;
    y_1 += A[1 + lda * 1] * x_1;
    y_2 += A[1 + lda * 2] * x_1;
    y_3 += A[1 + lda * 3] * x_1;
    y_4 += A[1 + lda * 4] * x_1;
    y_5 += A[1 + lda * 5] * x_1;
    y_6 += A[1 + lda * 6] * x_1;
    y_7 += A[1 + lda * 7] * x_1;
    y_0 += A[2 + lda * 0] * x_2;
    y_1 += A[2 + lda * 1] * x_2;
    y_2 += A[2 + lda * 2] * x_2;
    y_3 += A[2 + lda * 3] * x_2;
    y_4 += A[2 + lda * 4] * x_2;
    y_5 += A[2 + lda * 5] * x_2;
    y_6 += A[2 + lda * 6] * x_2;
    y_7 += A[2 + lda * 7] * x_2;
    y_0 += A[3 + lda * 0] * x_3;
    y_1 += A[3 + lda * 1] * x_3;
    y_2 += A[3 + lda * 2] * x_3;
    y_3 += A[3 + lda * 3] * x_3;
    y_4 += A[3 + lda * 4] * x_3;
    y_5 += A[3 + lda * 5] * x_3;
    y_6 += A[3 + lda * 6] * x_3;
    y_7 += A[3 + lda * 7] * x_3;
    x_0 = x[4];
    x_1 = x[5];
    x_2 = x[6];
    x_3 = x[7];
    y_0 += A[4 + lda * 0] * x_0;
    y_1 += A[4 + lda * 1] * x_0;
    y_2 += A[4 + lda * 2] * x_0;
    y_3 += A[4 + lda * 3] * x_0;
    y_4 += A[4 + lda * 4] * x_0;
    y_5 += A[4 + lda * 5] * x_0;
    y_6 += A[4 + lda * 6] * x_0;
    y_7 += A[4 + lda * 7] * x_0;
    y_0 += A[5 + lda * 0] * x_1;
    y_1 += A[5 + lda * 1] * x_1;
    y_2 += A[5 + lda * 2] * x_1;
    y_3 += A[5 + lda * 3] * x_1;
    y_4 += A[5 + lda * 4] * x_1;
    y_5 += A[5 + lda * 5] * x_1;
    y_6 += A[5 + lda * 6] * x_1;
    y_7 += A[5 + lda * 7] * x_1;
    y_0 += A[6 + lda * 0] * x_2;
    y_1 += A[6 + lda * 1] * x_2;
    y_2 += A[6 + lda * 2] * x_2;
    y_3 += A[6 + lda * 3] * x_2;
    y_4 += A[6 + lda * 4] * x_2;
    y_5 += A[6 + lda * 5] * x_2;
    y_6 += A[6 + lda * 6] * x_2;
    y_7 += A[6 + lda * 7] * x_2;
    y_0 += A[7 + lda * 0] * x_3;
    y_1 += A[7 + lda * 1] * x_3;
    y_2 += A[7 + lda * 2] * x_3;
    y_3 += A[7 + lda * 3] * x_3;
    y_4 += A[7 + lda * 4] * x_3;
    y_5 += A[7 + lda * 5] * x_3;
    y_6 += A[7 + lda * 6] * x_3;
    y_7 += A[7 + lda * 7] * x_3;
    A += sda * bs;
    x += 8;
  }
  x_0 = x[0];
  x_1 = x[1];
  x_2 = x[2];
  x_3 = x[3];
  y_0 += A[0 + lda * 0] * x_0;
  y_1 += A[0 + lda * 1] * x_0;
  y_2 += A[0 + lda * 2] * x_0;
  y_3 += A[0 + lda * 3] * x_0;
  y_4 += A[0 + lda * 4] * x_0;
  y_5 += A[0 + lda * 5] * x_0;
  y_6 += A[0 + lda * 6] * x_0;
  y_7 += A[0 + lda * 7] * x_0;
  y_1 += A[1 + lda * 1] * x_1;
  y_2 += A[1 + lda * 2] * x_1;
  y_3 += A[1 + lda * 3] * x_1;
  y_4 += A[1 + lda * 4] * x_1;
  y_5 += A[1 + lda * 5] * x_1;
  y_6 += A[1 + lda * 6] * x_1;
  y_7 += A[1 + lda * 7] * x_1;
  y_2 += A[2 + lda * 2] * x_2;
  y_3 += A[2 + lda * 3] * x_2;
  y_4 += A[2 + lda * 4] * x_2;
  y_5 += A[2 + lda * 5] * x_2;
  y_6 += A[2 + lda * 6] * x_2;
  y_7 += A[2 + lda * 7] * x_2;
  y_3 += A[3 + lda * 3] * x_3;
  y_4 += A[3 + lda * 4] * x_3;
  y_5 += A[3 + lda * 5] * x_3;
  y_6 += A[3 + lda * 6] * x_3;
  y_7 += A[3 + lda * 7] * x_3;
  x_0 = x[4];
  x_1 = x[5];
  x_2 = x[6];
  x_3 = x[7];
  y_4 += A[4 + lda * 4] * x_0;
  y_5 += A[4 + lda * 5] * x_0;
  y_6 += A[4 + lda * 6] * x_0;
  y_7 += A[4 + lda * 7] * x_0;
  y_5 += A[5 + lda * 5] * x_1;
  y_6 += A[5 + lda * 6] * x_1;
  y_7 += A[5 + lda * 7] * x_1;
  y_6 += A[6 + lda * 6] * x_2;
  y_7 += A[6 + lda * 7] * x_2;
  y_7 += A[7 + lda * 7] * x_3;
  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_t_8_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x8,-0x30(%rbp)
movl   $0x8,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x7,%ecx
cmp    %ecx,%eax
jge    1a80 <kernel_strmv_u_t_8_lib8+0x980>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%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  0x40(%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  0x60(%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  0x80(%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  0xa0(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc0(%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  0xe0(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%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  0x44(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x84(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xa4(%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  0xc4(%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  0xe4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%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  0x48(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x88(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xa8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0xe8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xac(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xcc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0xec(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%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  0x30(%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  0x50(%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  0x70(%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  0x90(%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  0xb0(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xd0(%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  0xf0(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%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  0x34(%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  0x54(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x74(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x94(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xb4(%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  0xd4(%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  0xf4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%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  0x58(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x98(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xb8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xd8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0xf8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x7c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x9c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xbc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xdc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0xfc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x14(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x38(%rbp)
jmp    116f <kernel_strmv_u_t_8_lib8+0x6f>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%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  0x40(%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  0x60(%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  0x80(%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  0xa0(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc0(%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  0xe0(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%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  0x44(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x84(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xa4(%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  0xc4(%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  0xe4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x88(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xa8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0xe8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8c(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0xac(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xcc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0xec(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x90(%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  0xb0(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0xd0(%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  0xf0(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0xb4(%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  0xd4(%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  0xf4(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0xd8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0xf8(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movss  0xfc(%rax),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jne    203a <kernel_strmv_u_t_8_lib8+0xf3a>
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    219a <kernel_strmv_u_t_8_lib8+0x109a>
cmpl   $0x1,-0x2c(%rbp)
jne    20df <kernel_strmv_u_t_8_lib8+0xfdf>
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x10(%rax),%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x14(%rax),%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x18(%rax),%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x1c(%rax),%xmm0
movss  %xmm0,0x1c(%rax)
jmp    2195 <kernel_strmv_u_t_8_lib8+0x1095>
movss  -0x4c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x54(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x58(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x5c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x10(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x60(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x14(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x64(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x18(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x68(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x1c(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rax)
jmp    219a <kernel_strmv_u_t_8_lib8+0x109a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_strmv_u_t_8_lib8>:
xorps  %xmm4,%xmm4
cmp    $0x8,%edi
jl     1435 <kernel_strmv_u_t_8_lib8+0x335>
add    $0xfffffff9,%edi
shl    $0x3,%edx
movslq %edx,%rax
shl    $0x2,%rax
xorps  %xmm6,%xmm6
xor    %edx,%edx
xorps  %xmm5,%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0xe0(%rsi),%xmm0
movss  0xc0(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movss  0xa0(%rsi),%xmm0
movss  0x80(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movlhps %xmm1,%xmm3
movss  0x60(%rsi),%xmm0
movss  0x40(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movss  0x20(%rsi),%xmm0
movss  (%rsi),%xmm7
unpcklps %xmm0,%xmm7
movlhps %xmm1,%xmm7
movss  0x4(%rsi),%xmm2
movss  0x8(%rsi),%xmm1
movss  0xc(%rsi),%xmm8
movss  (%rcx),%xmm0
movss  0x4(%rcx),%xmm4
movss  0x8(%rcx),%xmm10
movss  0xc(%rcx),%xmm9
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
mulps  %xmm3,%xmm0
addps  %xmm5,%xmm0
movss  0x64(%rsi),%xmm3
movss  0x44(%rsi),%xmm5
unpcklps %xmm3,%xmm5
movss  0x24(%rsi),%xmm3
unpcklps %xmm3,%xmm2
movlhps %xmm5,%xmm2
movss  0xe4(%rsi),%xmm3
movss  0xc4(%rsi),%xmm6
unpcklps %xmm3,%xmm6
movss  0xa4(%rsi),%xmm3
movss  0x84(%rsi),%xmm5
unpcklps %xmm3,%xmm5
movlhps %xmm6,%xmm5
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm5
addps  %xmm0,%xmm5
mulps  %xmm2,%xmm4
addps  %xmm7,%xmm4
movss  0xe8(%rsi),%xmm0
movss  0xc8(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0xa8(%rsi),%xmm0
movss  0x88(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movlhps %xmm2,%xmm3
movss  0x68(%rsi),%xmm0
movss  0x48(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x28(%rsi),%xmm0
unpcklps %xmm0,%xmm1
movlhps %xmm2,%xmm1
shufps $0x0,%xmm10,%xmm10
mulps  %xmm10,%xmm1
addps  %xmm4,%xmm1
mulps  %xmm3,%xmm10
addps  %xmm5,%xmm10
movss  0x6c(%rsi),%xmm0
movss  0x4c(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0x2c(%rsi),%xmm0
unpcklps %xmm0,%xmm8
movlhps %xmm2,%xmm8
movss  0xec(%rsi),%xmm0
movss  0xcc(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movss  0xac(%rsi),%xmm0
movss  0x8c(%rsi),%xmm4
unpcklps %xmm0,%xmm4
movlhps %xmm2,%xmm4
shufps $0x0,%xmm9,%xmm9
mulps  %xmm9,%xmm4
addps  %xmm10,%xmm4
mulps  %xmm8,%xmm9
addps  %xmm1,%xmm9
movss  0xf0(%rsi),%xmm0
movss  0xd0(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movss  0xb0(%rsi),%xmm0
movss  0x90(%rsi),%xmm2
unpcklps %xmm0,%xmm2
movlhps %xmm1,%xmm2
movss  0x70(%rsi),%xmm0
movss  0x50(%rsi),%xmm3
unpcklps %xmm0,%xmm3
movss  0x30(%rsi),%xmm0
movss  0x10(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movlhps %xmm3,%xmm1
movss  0x10(%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm1
addps  %xmm9,%xmm1
mulps  %xmm2,%xmm0
addps  %xmm4,%xmm0
movss  0x74(%rsi),%xmm2
movss  0x54(%rsi),%xmm3
unpcklps %xmm2,%xmm3
movss  0x34(%rsi),%xmm2
movss  0x14(%rsi),%xmm4
unpcklps %xmm2,%xmm4
movlhps %xmm3,%xmm4
movss  0xf4(%rsi),%xmm2
movss  0xd4(%rsi),%xmm3
unpcklps %xmm2,%xmm3
movss  0xb4(%rsi),%xmm5
movss  0x94(%rsi),%xmm2
unpcklps %xmm5,%xmm2
movlhps %xmm3,%xmm2
movss  0x14(%rcx),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm2
addps  %xmm0,%xmm2
mulps  %xmm4,%xmm3
addps  %xmm1,%xmm3
movss  0xf8(%rsi),%xmm0
movss  0xd8(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movss  0xb8(%rsi),%xmm0
movss  0x98(%rsi),%xmm4
unpcklps %xmm0,%xmm4
movlhps %xmm1,%xmm4
movss  0x78(%rsi),%xmm0
movss  0x58(%rsi),%xmm1
unpcklps %xmm0,%xmm1
movss  0x38(%rsi),%xmm5
movss  0x18(%rsi),%xmm0
unpcklps %xmm5,%xmm0
movlhps %xmm1,%xmm0
movss  0x18(%rcx),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm0
addps  %xmm3,%xmm0
mulps  %xmm4,%xmm1
addps  %xmm2,%xmm1
movss  0x7c(%rsi),%xmm2
movss  0x5c(%rsi),%xmm3
unpcklps %xmm2,%xmm3
movss  0x3c(%rsi),%xmm2
movss  0x1c(%rsi),%xmm6
unpcklps %xmm2,%xmm6
movlhps %xmm3,%xmm6
movss  0xfc(%rsi),%xmm2
movss  0xdc(%rsi),%xmm4
unpcklps %xmm2,%xmm4
movss  0xbc(%rsi),%xmm2
movss  0x9c(%rsi),%xmm3
unpcklps %xmm2,%xmm3
movlhps %xmm4,%xmm3
movss  0x1c(%rcx),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm3
movaps %xmm3,%xmm5
addps  %xmm1,%xmm5
mulps  %xmm6,%xmm4
movaps %xmm4,%xmm6
addps  %xmm0,%xmm6
add    $0x20,%rcx
add    $0x8,%edx
add    %rax,%rsi
cmp    %edi,%edx
jl     1130 <kernel_strmv_u_t_8_lib8+0x30>
addps  %xmm0,%xmm4
addps  %xmm1,%xmm3
jmp    1438 <kernel_strmv_u_t_8_lib8+0x338>
xorps  %xmm3,%xmm3
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm8
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
movss  0x20(%rsi),%xmm12
mulss  %xmm0,%xmm12
addss  %xmm1,%xmm12
movaps %xmm4,%xmm1
shufps $0xff,%xmm4,%xmm1
movss  0x60(%rsi),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm1,%xmm2
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
movss  0xa0(%rsi),%xmm10
mulss  %xmm0,%xmm10
addss  %xmm1,%xmm10
movaps %xmm3,%xmm1
shufps $0xff,%xmm3,%xmm1
movss  0xe0(%rsi),%xmm5
mulss  %xmm0,%xmm5
addss  %xmm1,%xmm5
movss  0x64(%rsi),%xmm11
movss  (%rsi),%xmm9
movss  0x24(%rsi),%xmm7
unpcklps %xmm7,%xmm9
movss  0x40(%rsi),%xmm1
unpcklps %xmm11,%xmm1
movss  0x44(%rsi),%xmm7
movaps %xmm4,%xmm6
unpckhpd %xmm4,%xmm6
unpcklps %xmm2,%xmm6
mulps  %xmm0,%xmm1
addps  %xmm6,%xmm1
movss  0xe4(%rsi),%xmm2
movss  0xc0(%rsi),%xmm6
unpcklps %xmm2,%xmm6
movaps %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
unpcklps %xmm5,%xmm2
mulps  %xmm0,%xmm6
addps  %xmm2,%xmm6
movss  0x68(%rsi),%xmm2
unpcklps %xmm2,%xmm7
movaps %xmm0,%xmm2
shufps $0xe9,%xmm0,%xmm2
mulps  %xmm2,%xmm7
addps  %xmm1,%xmm7
movss  0xe8(%rsi),%xmm5
movss  0xc4(%rsi),%xmm1
unpcklps %xmm5,%xmm1
mulps  %xmm2,%xmm1
addps  %xmm6,%xmm1
movss  0x6c(%rsi),%xmm2
movss  0x48(%rsi),%xmm5
unpcklps %xmm2,%xmm5
movlhps %xmm5,%xmm9
movlhps %xmm4,%xmm12
shufps $0x42,%xmm7,%xmm12
mulps  %xmm0,%xmm9
addps  %xmm12,%xmm9
movss  0xec(%rsi),%xmm2
movss  0xc8(%rsi),%xmm4
unpcklps %xmm2,%xmm4
movss  0xa4(%rsi),%xmm2
movss  0x80(%rsi),%xmm5
unpcklps %xmm2,%xmm5
movlhps %xmm4,%xmm5
movlhps %xmm3,%xmm10
shufps $0x42,%xmm1,%xmm10
mulps  %xmm0,%xmm5
addps  %xmm10,%xmm5
movss  0xf0(%rsi),%xmm1
movss  0xcc(%rsi),%xmm2
unpcklps %xmm1,%xmm2
movss  0xa8(%rsi),%xmm1
movss  0x84(%rsi),%xmm3
unpcklps %xmm1,%xmm3
movlhps %xmm2,%xmm3
movaps %xmm8,%xmm1
shufps $0x30,%xmm0,%xmm1
movaps %xmm0,%xmm2
shufps $0x29,%xmm1,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm5,%xmm2
movss  0xf4(%rsi),%xmm1
movss  0xd0(%rsi),%xmm3
unpcklps %xmm1,%xmm3
movss  0xac(%rsi),%xmm1
movss  0x88(%rsi),%xmm4
unpcklps %xmm1,%xmm4
movlhps %xmm3,%xmm4
movaps %xmm0,%xmm1
shufps $0x4e,%xmm8,%xmm1
mulps  %xmm4,%xmm1
addps  %xmm2,%xmm1
movss  0xf8(%rsi),%xmm2
movss  0xd4(%rsi),%xmm3
unpcklps %xmm2,%xmm3
movss  0xb0(%rsi),%xmm2
movss  0x8c(%rsi),%xmm4
unpcklps %xmm2,%xmm4
movlhps %xmm3,%xmm4
shufps $0x3,%xmm8,%xmm0
shufps $0x98,%xmm8,%xmm0
mulps  %xmm4,%xmm0
addps  %xmm1,%xmm0
movss  0xfc(%rsi),%xmm1
movss  0xd8(%rsi),%xmm2
unpcklps %xmm1,%xmm2
movss  0xb4(%rsi),%xmm3
movss  0x90(%rsi),%xmm1
unpcklps %xmm3,%xmm1
movlhps %xmm2,%xmm1
mulps  %xmm8,%xmm1
addps  %xmm0,%xmm1
cmp    $0x1,%r9d
je     166d <kernel_strmv_u_t_8_lib8+0x56d>
test   %r9d,%r9d
jne    1687 <kernel_strmv_u_t_8_lib8+0x587>
movups %xmm9,(%r8)
movups %xmm1,0x10(%r8)
ret
movups (%r8),%xmm0
movups 0x10(%r8),%xmm2
addps  %xmm0,%xmm9
movups %xmm9,(%r8)
addps  %xmm2,%xmm1
movups %xmm1,0x10(%r8)
ret
movups (%r8),%xmm0
movups 0x10(%r8),%xmm2
subps  %xmm9,%xmm0
movups %xmm0,(%r8)
subps  %xmm1,%xmm2
movups %xmm2,0x10(%r8)
ret

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

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