void kernel_sgemv_t_8_lib8(int kmax, int kna, float *A, int sda, float *x,
                           float *y, int alg) {
  if (kmax <= 0)
    return;
  const int lda = 8;
  const int bs = 8;
  int k, ka = kmax - kna;
  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;
  if (kna > 0) {
    k = 0;
    for (; k < kna; k++) {
      x_0 = x[0];
      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;
      A += 1;
      x += 1;
    }
    A += (sda - 1) * lda;
  }
  k = 0;
  for (; k < ka - bs + 1; k += bs) {
    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;
  }
  for (; k < ka; k++) {
    x_0 = x[0];
    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;
    A += 1;
    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_sgemv_t_8_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     112b <kernel_sgemv_t_8_lib8+0x2b>
jmp    1f40 <kernel_sgemv_t_8_lib8+0xe40>
movl   $0x8,-0x2c(%rbp)
movl   $0x8,-0x30(%rbp)
mov    -0x4(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x38(%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)
cmpl   $0x0,-0x8(%rbp)
jle    12f8 <kernel_sgemv_t_8_lib8+0x1f8>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12dd <kernel_sgemv_t_8_lib8+0x1dd>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%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
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1193 <kernel_sgemv_t_8_lib8+0x93>
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x8,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1c13 <kernel_sgemv_t_8_lib8+0xb13>
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    -0x34(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x34(%rbp)
jmp    12ff <kernel_sgemv_t_8_lib8+0x1ff>
jmp    1c18 <kernel_sgemv_t_8_lib8+0xb18>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1d62 <kernel_sgemv_t_8_lib8+0xc62>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x3c(%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
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c18 <kernel_sgemv_t_8_lib8+0xb18>
cmpl   $0x0,0x10(%rbp)
jne    1de0 <kernel_sgemv_t_8_lib8+0xce0>
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    1f40 <kernel_sgemv_t_8_lib8+0xe40>
cmpl   $0x1,0x10(%rbp)
jne    1e85 <kernel_sgemv_t_8_lib8+0xd85>
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    1f3b <kernel_sgemv_t_8_lib8+0xe3b>
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    1f40 <kernel_sgemv_t_8_lib8+0xe40>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_sgemv_t_8_lib8>:
test   %edi,%edi
jle    15bc <kernel_sgemv_t_8_lib8+0x4bc>
sub    %esi,%edi
test   %esi,%esi
jle    11b8 <kernel_sgemv_t_8_lib8+0xb8>
mov    %esi,%r10d
xorps  %xmm4,%xmm4
xor    %esi,%esi
xor    %eax,%eax
xorps  %xmm5,%xmm5
nop
movaps %xmm5,%xmm3
movaps %xmm4,%xmm2
movss  (%rdx,%rsi,4),%xmm0
movss  0x20(%rdx,%rsi,4),%xmm1
unpcklps %xmm1,%xmm0
movss  0x40(%rdx,%rsi,4),%xmm1
movss  0x60(%rdx,%rsi,4),%xmm4
unpcklps %xmm4,%xmm1
movlhps %xmm1,%xmm0
movss  (%r8,%rsi,4),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm5,%xmm0
movaps %xmm0,%xmm4
addps  %xmm2,%xmm4
movss  0xe0(%rdx,%rsi,4),%xmm1
movss  0xc0(%rdx,%rsi,4),%xmm6
unpcklps %xmm1,%xmm6
movss  0xa0(%rdx,%rsi,4),%xmm7
movss  0x80(%rdx,%rsi,4),%xmm1
unpcklps %xmm7,%xmm1
movlhps %xmm6,%xmm1
mulps  %xmm5,%xmm1
movaps %xmm1,%xmm5
addps  %xmm3,%xmm5
add    $0xfffffffffffffffc,%rax
add    $0x1,%rsi
cmp    %esi,%r10d
jne    1120 <kernel_sgemv_t_8_lib8+0x20>
addps  %xmm3,%xmm1
addps  %xmm2,%xmm0
lea    -0x8(,%rcx,8),%esi
movslq %esi,%rsi
lea    (%rdx,%rsi,4),%rdx
sub    %rax,%rdx
sub    %rax,%r8
jmp    11be <kernel_sgemv_t_8_lib8+0xbe>
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
cmp    $0x8,%edi
jl     14de <kernel_sgemv_t_8_lib8+0x3de>
lea    -0x7(%rdi),%esi
shl    $0x3,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  0x60(%rdx),%xmm2
movss  0x40(%rdx),%xmm4
unpcklps %xmm2,%xmm4
movss  0x20(%rdx),%xmm2
movss  (%rdx),%xmm3
unpcklps %xmm2,%xmm3
movlhps %xmm4,%xmm3
movss  0x4(%rdx),%xmm6
movss  0x8(%rdx),%xmm4
movss  0xc(%rdx),%xmm10
movss  (%r8),%xmm5
movss  0x4(%r8),%xmm11
movss  0x8(%r8),%xmm9
movss  0xc(%r8),%xmm8
shufps $0x0,%xmm5,%xmm5
mulps  %xmm5,%xmm3
addps  %xmm0,%xmm3
movss  0xe0(%rdx),%xmm0
movss  0xc0(%rdx),%xmm2
unpcklps %xmm0,%xmm2
movss  0xa0(%rdx),%xmm7
movss  0x80(%rdx),%xmm0
unpcklps %xmm7,%xmm0
movlhps %xmm2,%xmm0
mulps  %xmm5,%xmm0
addps  %xmm1,%xmm0
movss  0x64(%rdx),%xmm1
movss  0x44(%rdx),%xmm2
unpcklps %xmm1,%xmm2
movss  0x24(%rdx),%xmm1
unpcklps %xmm1,%xmm6
movlhps %xmm2,%xmm6
shufps $0x0,%xmm11,%xmm11
mulps  %xmm11,%xmm6
addps  %xmm3,%xmm6
movss  0xe4(%rdx),%xmm1
movss  0xc4(%rdx),%xmm2
unpcklps %xmm1,%xmm2
movss  0xa4(%rdx),%xmm3
movss  0x84(%rdx),%xmm1
unpcklps %xmm3,%xmm1
movlhps %xmm2,%xmm1
mulps  %xmm11,%xmm1
addps  %xmm0,%xmm1
movss  0x68(%rdx),%xmm0
movss  0x48(%rdx),%xmm2
unpcklps %xmm0,%xmm2
movss  0x28(%rdx),%xmm0
unpcklps %xmm0,%xmm4
movlhps %xmm2,%xmm4
shufps $0x0,%xmm9,%xmm9
mulps  %xmm9,%xmm4
addps  %xmm6,%xmm4
movss  0xe8(%rdx),%xmm0
movss  0xc8(%rdx),%xmm2
unpcklps %xmm0,%xmm2
movss  0xa8(%rdx),%xmm3
movss  0x88(%rdx),%xmm0
unpcklps %xmm3,%xmm0
movlhps %xmm2,%xmm0
mulps  %xmm9,%xmm0
addps  %xmm1,%xmm0
movss  0x6c(%rdx),%xmm1
movss  0x4c(%rdx),%xmm2
unpcklps %xmm1,%xmm2
movss  0x2c(%rdx),%xmm1
unpcklps %xmm1,%xmm10
movlhps %xmm2,%xmm10
shufps $0x0,%xmm8,%xmm8
mulps  %xmm8,%xmm10
addps  %xmm4,%xmm10
movss  0xec(%rdx),%xmm1
movss  0xcc(%rdx),%xmm2
unpcklps %xmm1,%xmm2
movss  0xac(%rdx),%xmm3
movss  0x8c(%rdx),%xmm1
unpcklps %xmm3,%xmm1
movlhps %xmm2,%xmm1
mulps  %xmm8,%xmm1
addps  %xmm0,%xmm1
movss  0x70(%rdx),%xmm0
movss  0x50(%rdx),%xmm2
unpcklps %xmm0,%xmm2
movss  0x30(%rdx),%xmm3
movss  0x10(%rdx),%xmm0
unpcklps %xmm3,%xmm0
movlhps %xmm2,%xmm0
movss  0x10(%r8),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm0
addps  %xmm10,%xmm0
movss  0xf0(%rdx),%xmm2
movss  0xd0(%rdx),%xmm4
unpcklps %xmm2,%xmm4
movss  0xb0(%rdx),%xmm5
movss  0x90(%rdx),%xmm2
unpcklps %xmm5,%xmm2
movlhps %xmm4,%xmm2
mulps  %xmm3,%xmm2
addps  %xmm1,%xmm2
movss  0x74(%rdx),%xmm1
movss  0x54(%rdx),%xmm3
unpcklps %xmm1,%xmm3
movss  0x34(%rdx),%xmm4
movss  0x14(%rdx),%xmm1
unpcklps %xmm4,%xmm1
movlhps %xmm3,%xmm1
movss  0x14(%r8),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm1
addps  %xmm0,%xmm1
movss  0xf4(%rdx),%xmm0
movss  0xd4(%rdx),%xmm4
unpcklps %xmm0,%xmm4
movss  0xb4(%rdx),%xmm5
movss  0x94(%rdx),%xmm0
unpcklps %xmm5,%xmm0
movlhps %xmm4,%xmm0
mulps  %xmm3,%xmm0
addps  %xmm2,%xmm0
movss  0x78(%rdx),%xmm2
movss  0x58(%rdx),%xmm3
unpcklps %xmm2,%xmm3
movss  0x38(%rdx),%xmm4
movss  0x18(%rdx),%xmm2
unpcklps %xmm4,%xmm2
movlhps %xmm3,%xmm2
movss  0x18(%r8),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm2
addps  %xmm1,%xmm2
movss  0xf8(%rdx),%xmm1
movss  0xd8(%rdx),%xmm5
unpcklps %xmm1,%xmm5
movss  0xb8(%rdx),%xmm1
movss  0x98(%rdx),%xmm3
unpcklps %xmm1,%xmm3
movlhps %xmm5,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm0,%xmm3
movss  0x7c(%rdx),%xmm0
movss  0x5c(%rdx),%xmm1
unpcklps %xmm0,%xmm1
movss  0x3c(%rdx),%xmm4
movss  0x1c(%rdx),%xmm0
unpcklps %xmm4,%xmm0
movlhps %xmm1,%xmm0
movss  0x1c(%r8),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm0
addps  %xmm2,%xmm0
movss  0xfc(%rdx),%xmm1
movss  0xdc(%rdx),%xmm2
unpcklps %xmm1,%xmm2
movss  0xbc(%rdx),%xmm5
movss  0x9c(%rdx),%xmm1
unpcklps %xmm5,%xmm1
movlhps %xmm2,%xmm1
mulps  %xmm4,%xmm1
addps  %xmm3,%xmm1
add    $0x20,%r8
add    $0x8,%eax
add    %rcx,%rdx
cmp    %esi,%eax
jl     11e0 <kernel_sgemv_t_8_lib8+0xe0>
mov    0x8(%rsp),%r10d
cmp    %edi,%eax
jge    1576 <kernel_sgemv_t_8_lib8+0x476>
mov    %eax,%eax
xor    %esi,%esi
nop
movaps %xmm1,%xmm3
movaps %xmm0,%xmm2
movss  (%rdx,%rsi,4),%xmm4
movss  0x20(%rdx,%rsi,4),%xmm0
unpcklps %xmm0,%xmm4
movss  0x40(%rdx,%rsi,4),%xmm0
movss  0x60(%rdx,%rsi,4),%xmm1
unpcklps %xmm1,%xmm0
movlhps %xmm0,%xmm4
movss  (%r8,%rsi,4),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm4
movaps %xmm4,%xmm0
addps  %xmm2,%xmm0
movss  0xe0(%rdx,%rsi,4),%xmm5
movss  0xc0(%rdx,%rsi,4),%xmm6
unpcklps %xmm5,%xmm6
movss  0xa0(%rdx,%rsi,4),%xmm7
movss  0x80(%rdx,%rsi,4),%xmm5
unpcklps %xmm7,%xmm5
movlhps %xmm6,%xmm5
mulps  %xmm1,%xmm5
movaps %xmm5,%xmm1
addps  %xmm3,%xmm1
add    $0x1,%rsi
lea    (%rax,%rsi,1),%ecx
cmp    %edi,%ecx
jl     14f0 <kernel_sgemv_t_8_lib8+0x3f0>
addps  %xmm3,%xmm5
addps  %xmm2,%xmm4
movaps %xmm4,%xmm0
movaps %xmm5,%xmm1
cmp    $0x1,%r10d
je     158b <kernel_sgemv_t_8_lib8+0x48b>
test   %r10d,%r10d
jne    15a4 <kernel_sgemv_t_8_lib8+0x4a4>
movups %xmm0,(%r9)
movups %xmm1,0x10(%r9)
ret
movups (%r9),%xmm2
movups 0x10(%r9),%xmm3
addps  %xmm2,%xmm0
movups %xmm0,(%r9)
addps  %xmm3,%xmm1
movups %xmm1,0x10(%r9)
ret
movups (%r9),%xmm2
movups 0x10(%r9),%xmm3
subps  %xmm0,%xmm2
movups %xmm2,(%r9)
subps  %xmm1,%xmm3
movups %xmm3,0x10(%r9)
ret

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

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