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


x86 assembly (clang, -O0):
<kernel_sgemv_n_8_lib8>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     1126 <kernel_sgemv_n_8_lib8+0x26>
jmp    1904 <kernel_sgemv_n_8_lib8+0x804>
movl   $0x8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    15e3 <kernel_sgemv_n_8_lib8+0x4e3>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x34(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x58(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x70(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x74(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x7c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x2c(%rbp)
jmp    1174 <kernel_sgemv_n_8_lib8+0x74>
jmp    15e8 <kernel_sgemv_n_8_lib8+0x4e8>
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1726 <kernel_sgemv_n_8_lib8+0x626>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15e8 <kernel_sgemv_n_8_lib8+0x4e8>
cmpl   $0x0,-0x24(%rbp)
jne    17a4 <kernel_sgemv_n_8_lib8+0x6a4>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    1904 <kernel_sgemv_n_8_lib8+0x804>
cmpl   $0x1,-0x24(%rbp)
jne    1849 <kernel_sgemv_n_8_lib8+0x749>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x10(%rax),%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x14(%rax),%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x18(%rax),%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addss  0x1c(%rax),%xmm0
movss  %xmm0,0x1c(%rax)
jmp    18ff <kernel_sgemv_n_8_lib8+0x7ff>
movss  -0x40(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x48(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x54(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x58(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x5c(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rax)
jmp    1904 <kernel_sgemv_n_8_lib8+0x804>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_sgemv_n_8_lib8>:
test   %edi,%edi
jle    121a <kernel_sgemv_n_8_lib8+0x11a>
cmp    $0x4,%edi
jb     11d2 <kernel_sgemv_n_8_lib8+0xd2>
lea    -0x3(%rdi),%r9d
xorps  %xmm2,%xmm2
xor    %eax,%eax
xorps  %xmm5,%xmm5
nopl   (%rax)
movups (%rsi),%xmm1
movups 0x10(%rsi),%xmm3
movups 0x20(%rsi),%xmm6
movups 0x30(%rsi),%xmm8
movss  (%rdx),%xmm7
movss  0x4(%rdx),%xmm0
movss  0x8(%rdx),%xmm4
movss  0xc(%rdx),%xmm9
shufps $0x0,%xmm7,%xmm7
mulps  %xmm7,%xmm1
addps  %xmm2,%xmm1
mulps  %xmm3,%xmm7
addps  %xmm5,%xmm7
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm6
addps  %xmm1,%xmm6
mulps  %xmm8,%xmm0
addps  %xmm7,%xmm0
movups 0x40(%rsi),%xmm3
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm3
addps  %xmm6,%xmm3
movups 0x50(%rsi),%xmm6
mulps  %xmm4,%xmm6
addps  %xmm0,%xmm6
movups 0x60(%rsi),%xmm0
shufps $0x0,%xmm9,%xmm9
mulps  %xmm9,%xmm0
movaps %xmm0,%xmm2
addps  %xmm3,%xmm2
movups 0x70(%rsi),%xmm1
mulps  %xmm9,%xmm1
movaps %xmm1,%xmm5
addps  %xmm6,%xmm5
sub    $0xffffffffffffff80,%rsi
add    $0x10,%rdx
add    $0x4,%eax
cmp    %r9d,%eax
jl     1120 <kernel_sgemv_n_8_lib8+0x20>
addps  %xmm6,%xmm1
addps  %xmm3,%xmm0
mov    %edi,%eax
and    $0xfffffffc,%eax
cmp    %edi,%eax
jl     11de <kernel_sgemv_n_8_lib8+0xde>
movaps %xmm0,%xmm3
movaps %xmm1,%xmm2
cmp    $0x1,%r8d
jne    11f9 <kernel_sgemv_n_8_lib8+0xf9>
jmp    12ac <kernel_sgemv_n_8_lib8+0x1ac>
xorps  %xmm0,%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
cmp    %edi,%eax
jge    11c1 <kernel_sgemv_n_8_lib8+0xc1>
mov    %eax,%r9d
not    %r9d
test   $0x1,%dil
jne    121b <kernel_sgemv_n_8_lib8+0x11b>
add    %edi,%r9d
jne    124c <kernel_sgemv_n_8_lib8+0x14c>
cmp    $0x1,%r8d
je     12ac <kernel_sgemv_n_8_lib8+0x1ac>
test   %r8d,%r8d
jne    1206 <kernel_sgemv_n_8_lib8+0x106>
movups %xmm3,(%rcx)
movups %xmm2,0x10(%rcx)
ret
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
subps  %xmm3,%xmm0
movups %xmm0,(%rcx)
subps  %xmm2,%xmm1
movups %xmm1,0x10(%rcx)
ret
movss  (%rdx),%xmm4
shufps $0x0,%xmm4,%xmm4
movups (%rsi),%xmm3
movups 0x10(%rsi),%xmm2
mulps  %xmm4,%xmm3
addps  %xmm0,%xmm3
mulps  %xmm4,%xmm2
addps  %xmm1,%xmm2
add    $0x20,%rsi
add    $0x4,%rdx
or     $0x1,%eax
movaps %xmm3,%xmm0
movaps %xmm2,%xmm1
add    %edi,%r9d
je     11ef <kernel_sgemv_n_8_lib8+0xef>
sub    %eax,%edi
xor    %eax,%eax
movss  (%rdx,%rax,4),%xmm6
movss  0x4(%rdx,%rax,4),%xmm2
shufps $0x0,%xmm6,%xmm6
movups (%rsi),%xmm4
movups 0x10(%rsi),%xmm5
movups 0x20(%rsi),%xmm3
movups 0x30(%rsi),%xmm7
mulps  %xmm6,%xmm4
addps  %xmm0,%xmm4
mulps  %xmm6,%xmm5
addps  %xmm1,%xmm5
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm3
movaps %xmm3,%xmm0
addps  %xmm4,%xmm0
mulps  %xmm7,%xmm2
movaps %xmm2,%xmm1
addps  %xmm5,%xmm1
add    $0x2,%rax
add    $0x40,%rsi
cmp    %eax,%edi
jne    1250 <kernel_sgemv_n_8_lib8+0x150>
addps  %xmm5,%xmm2
addps  %xmm4,%xmm3
cmp    $0x1,%r8d
jne    11f9 <kernel_sgemv_n_8_lib8+0xf9>
movups (%rcx),%xmm0
movups 0x10(%rcx),%xmm1
addps  %xmm0,%xmm3
movups %xmm3,(%rcx)
addps  %xmm1,%xmm2
movups %xmm2,0x10(%rcx)
ret

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

LLVM IR (-O2):
define void @kernel_sgemv_n_8_lib8(i32 %0, float* %1, float* nocapture %2, float* %3, i32 %4) {
%6 = icmp slt i32 %0, 1
br i1 %6, label %175, label %7
7: ; preds = %5
%8 = add nsw i32 %0, -3
%9 = icmp ugt i32 %0, 3
br i1 %9, label %57, label %20
10: ; preds = %57
%11 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %77, <4 x float> %73, <4 x float> %62)
%12 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %87, <4 x float> %83, <4 x float> %11)
%13 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %97, <4 x float> %93, <4 x float> %12)
%14 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %107, <4 x float> %103, <4 x float> %13)
%15 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %71, <4 x float> %73, <4 x float> %61)
%16 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %81, <4 x float> %83, <4 x float> %15)
%17 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %91, <4 x float> %93, <4 x float> %16)
%18 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %101, <4 x float> %103, <4 x float> %17)
%19 = and i32 %0, -4
br label %20
20: ; preds = %10, %7
%21 = phi i32 [ 0, %7 ], [ %19, %10 ]
%22 = phi float* [ %2, %7 ], [ %110, %10 ]
%23 = phi float* [ %1, %7 ], [ %109, %10 ]
%24 = phi <4 x float> [ zeroinitializer, %7 ], [ %18, %10 ]
%25 = phi <4 x float> [ zeroinitializer, %7 ], [ %14, %10 ]
%26 = icmp slt i32 %21, %0
br i1 %26, label %27, label %148
27: ; preds = %20
%28 = xor i32 %21, -1
%29 = and i32 %0, 1
%30 = icmp eq i32 %29, 0
br i1 %30, label %47, label %31
31: ; preds = %27
%32 = load float, float* %22
%33 = bitcast float* %23 to <4 x float>*
%34 = load <4 x float>, <4 x float>* %33
%35 = insertelement <4 x float> poison, float %32, i64 0
%36 = shufflevector <4 x float> %35, <4 x float> poison, <4 x i32> zeroinitializer
%37 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %34, <4 x float> %36, <4 x float> %24)
%38 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %34, <4 x float> %36, <4 x float> %24)
%39 = getelementptr inbounds float, float* %23, i64 4
%40 = bitcast float* %39 to <4 x float>*
%41 = load <4 x float>, <4 x float>* %40
%42 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %41, <4 x float> %36, <4 x float> %25)
%43 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %41, <4 x float> %36, <4 x float> %25)
%44 = getelementptr inbounds float, float* %23, i64 8
%45 = getelementptr inbounds float, float* %22, i64 1
%46 = or i32 %21, 1
br label %47
47: ; preds = %31, %27
%48 = phi <4 x float> [ undef, %27 ], [ %38, %31 ]
%49 = phi <4 x float> [ undef, %27 ], [ %43, %31 ]
%50 = phi float* [ %23, %27 ], [ %44, %31 ]
%51 = phi float* [ %22, %27 ], [ %45, %31 ]
%52 = phi i32 [ %21, %27 ], [ %46, %31 ]
%53 = phi <4 x float> [ %24, %27 ], [ %37, %31 ]
%54 = phi <4 x float> [ %25, %27 ], [ %42, %31 ]
%55 = sub i32 0, %0
%56 = icmp eq i32 %28, %55
br i1 %56, label %148, label %113
57: ; preds = %7, %57
%58 = phi float* [ %109, %57 ], [ %1, %7 ]
%59 = phi float* [ %110, %57 ], [ %2, %7 ]
%60 = phi i32 [ %111, %57 ], [ 0, %7 ]
%61 = phi <4 x float> [ %104, %57 ], [ zeroinitializer, %7 ]
%62 = phi <4 x float> [ %108, %57 ], [ zeroinitializer, %7 ]
%63 = load float, float* %59
%64 = getelementptr inbounds float, float* %59, i64 1
%65 = load float, float* %64
%66 = getelementptr inbounds float, float* %59, i64 2
%67 = load float, float* %66
%68 = getelementptr inbounds float, float* %59, i64 3
%69 = load float, float* %68
%70 = bitcast float* %58 to <4 x float>*
%71 = load <4 x float>, <4 x float>* %70
%72 = insertelement <4 x float> poison, float %63, i64 0
%73 = shufflevector <4 x float> %72, <4 x float> poison, <4 x i32> zeroinitializer
%74 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %71, <4 x float> %73, <4 x float> %61)
%75 = getelementptr inbounds float, float* %58, i64 4
%76 = bitcast float* %75 to <4 x float>*
%77 = load <4 x float>, <4 x float>* %76
%78 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %77, <4 x float> %73, <4 x float> %62)
%79 = getelementptr inbounds float, float* %58, i64 8
%80 = bitcast float* %79 to <4 x float>*
%81 = load <4 x float>, <4 x float>* %80
%82 = insertelement <4 x float> poison, float %65, i64 0
%83 = shufflevector <4 x float> %82, <4 x float> poison, <4 x i32> zeroinitializer
%84 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %81, <4 x float> %83, <4 x float> %74)
%85 = getelementptr inbounds float, float* %58, i64 12
%86 = bitcast float* %85 to <4 x float>*
%87 = load <4 x float>, <4 x float>* %86
%88 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %87, <4 x float> %83, <4 x float> %78)
%89 = getelementptr inbounds float, float* %58, i64 16
%90 = bitcast float* %89 to <4 x float>*
%91 = load <4 x float>, <4 x float>* %90
%92 = insertelement <4 x float> poison, float %67, i64 0
%93 = shufflevector <4 x float> %92, <4 x float> poison, <4 x i32> zeroinitializer
%94 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %91, <4 x float> %93, <4 x float> %84)
%95 = getelementptr inbounds float, float* %58, i64 20
%96 = bitcast float* %95 to <4 x float>*
%97 = load <4 x float>, <4 x float>* %96
%98 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %97, <4 x float> %93, <4 x float> %88)
%99 = getelementptr inbounds float, float* %58, i64 24
%100 = bitcast float* %99 to <4 x float>*
%101 = load <4 x float>, <4 x float>* %100
%102 = insertelement <4 x float> poison, float %69, i64 0
%103 = shufflevector <4 x float> %102, <4 x float> poison, <4 x i32> zeroinitializer
%104 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %101, <4 x float> %103, <4 x float> %94)
%105 = getelementptr inbounds float, float* %58, i64 28
%106 = bitcast float* %105 to <4 x float>*
%107 = load <4 x float>, <4 x float>* %106
%108 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %107, <4 x float> %103, <4 x float> %98)
%109 = getelementptr inbounds float, float* %58, i64 32
%110 = getelementptr inbounds float, float* %59, i64 4
%111 = add nuw nsw i32 %60, 4
%112 = icmp slt i32 %111, %8
br i1 %112, label %57, label %10
113: ; preds = %47, %113
%114 = phi float* [ %141, %113 ], [ %50, %47 ]
%115 = phi float* [ %142, %113 ], [ %51, %47 ]
%116 = phi i32 [ %143, %113 ], [ %52, %47 ]
%117 = phi <4 x float> [ %136, %113 ], [ %53, %47 ]
%118 = phi <4 x float> [ %140, %113 ], [ %54, %47 ]
%119 = load float, float* %115
%120 = bitcast float* %114 to <4 x float>*
%121 = load <4 x float>, <4 x float>* %120
%122 = insertelement <4 x float> poison, float %119, i64 0
%123 = shufflevector <4 x float> %122, <4 x float> poison, <4 x i32> zeroinitializer
%124 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %121, <4 x float> %123, <4 x float> %117)
%125 = getelementptr inbounds float, float* %114, i64 4
%126 = bitcast float* %125 to <4 x float>*
%127 = load <4 x float>, <4 x float>* %126
%128 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %127, <4 x float> %123, <4 x float> %118)
%129 = getelementptr inbounds float, float* %114, i64 8
%130 = getelementptr inbounds float, float* %115, i64 1
%131 = load float, float* %130
%132 = bitcast float* %129 to <4 x float>*
%133 = load <4 x float>, <4 x float>* %132
%134 = insertelement <4 x float> poison, float %131, i64 0
%135 = shufflevector <4 x float> %134, <4 x float> poison, <4 x i32> zeroinitializer
%136 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %133, <4 x float> %135, <4 x float> %124)
%137 = getelementptr inbounds float, float* %114, i64 12
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %139, <4 x float> %135, <4 x float> %128)
%141 = getelementptr inbounds float, float* %114, i64 16
%142 = getelementptr inbounds float, float* %115, i64 2
%143 = add nuw nsw i32 %116, 2
%144 = icmp eq i32 %143, %0
br i1 %144, label %145, label %113
145: ; preds = %113
%146 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %139, <4 x float> %135, <4 x float> %128)
%147 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %133, <4 x float> %135, <4 x float> %124)
br label %148
148: ; preds = %145, %47, %20
%149 = phi <4 x float> [ %24, %20 ], [ %48, %47 ], [ %147, %145 ]
%150 = phi <4 x float> [ %25, %20 ], [ %49, %47 ], [ %146, %145 ]
switch i32 %4, label %165 [
i32 0, label %151
i32 1, label %155
]
151: ; preds = %148
%152 = bitcast float* %3 to <4 x float>*
store <4 x float> %149, <4 x float>* %152
%153 = getelementptr inbounds float, float* %3, i64 4
%154 = bitcast float* %153 to <4 x float>*
store <4 x float> %150, <4 x float>* %154
br label %175
155: ; preds = %148
%156 = bitcast float* %3 to <4 x float>*
%157 = load <4 x float>, <4 x float>* %156
%158 = fadd <4 x float> %149, %157
%159 = bitcast float* %3 to <4 x float>*
store <4 x float> %158, <4 x float>* %159
%160 = getelementptr inbounds float, float* %3, i64 4
%161 = bitcast float* %160 to <4 x float>*
%162 = load <4 x float>, <4 x float>* %161
%163 = fadd <4 x float> %150, %162
%164 = bitcast float* %160 to <4 x float>*
store <4 x float> %163, <4 x float>* %164
br label %175
165: ; preds = %148
%166 = bitcast float* %3 to <4 x float>*
%167 = load <4 x float>, <4 x float>* %166
%168 = fsub <4 x float> %167, %149
%169 = bitcast float* %3 to <4 x float>*
store <4 x float> %168, <4 x float>* %169
%170 = getelementptr inbounds float, float* %3, i64 4
%171 = bitcast float* %170 to <4 x float>*
%172 = load <4 x float>, <4 x float>* %171
%173 = fsub <4 x float> %172, %150
%174 = bitcast float* %170 to <4 x float>*
store <4 x float> %173, <4 x float>* %174
br label %175
175: ; preds = %151, %165, %155, %5
ret void
}