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


x86 assembly (clang, -O0):
<kernel_sgemv_n_8_lib4>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
cmpl   $0x0,-0x4(%rbp)
jg     112a <kernel_sgemv_n_8_lib4+0x2a>
jmp    191c <kernel_sgemv_n_8_lib4+0x81c>
movl   $0x4,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    15f0 <kernel_sgemv_n_8_lib4+0x4f0>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    1178 <kernel_sgemv_n_8_lib4+0x78>
jmp    15f5 <kernel_sgemv_n_8_lib4+0x4f5>
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    173e <kernel_sgemv_n_8_lib4+0x63e>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15f5 <kernel_sgemv_n_8_lib4+0x4f5>
cmpl   $0x0,-0x2c(%rbp)
jne    17bc <kernel_sgemv_n_8_lib4+0x6bc>
movss  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x1c(%rax)
jmp    191c <kernel_sgemv_n_8_lib4+0x81c>
cmpl   $0x1,-0x2c(%rbp)
jne    1861 <kernel_sgemv_n_8_lib4+0x761>
movss  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x10(%rax),%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x5c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x14(%rax),%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x18(%rax),%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
addss  0x1c(%rax),%xmm0
movss  %xmm0,0x1c(%rax)
jmp    1917 <kernel_sgemv_n_8_lib4+0x817>
movss  -0x48(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x50(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x54(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
movss  -0x58(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x10(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x5c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x14(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x60(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x18(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x18(%rax)
movss  -0x64(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  0x1c(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x1c(%rax)
jmp    191c <kernel_sgemv_n_8_lib4+0x81c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_sgemv_n_8_lib4>:
test   %edi,%edi
jle    122d <kernel_sgemv_n_8_lib4+0x12d>
cmp    $0x4,%edi
jb     11de <kernel_sgemv_n_8_lib4+0xde>
lea    -0x3(%rdi),%r10d
xorps  %xmm4,%xmm4
xor    %eax,%eax
xorps  %xmm5,%xmm5
nopl   (%rax)
movups (%rsi),%xmm0
movups 0x10(%rsi),%xmm9
movups 0x20(%rsi),%xmm2
movups 0x30(%rsi),%xmm8
movss  (%rcx),%xmm6
movss  0x4(%rcx),%xmm7
movss  0x8(%rcx),%xmm3
movss  0xc(%rcx),%xmm1
shufps $0x0,%xmm6,%xmm6
mulps  %xmm6,%xmm0
addps  %xmm4,%xmm0
movups (%rdx),%xmm4
movups 0x10(%rdx),%xmm10
movups 0x20(%rdx),%xmm11
movups 0x30(%rdx),%xmm12
mulps  %xmm6,%xmm4
addps  %xmm5,%xmm4
shufps $0x0,%xmm7,%xmm7
mulps  %xmm7,%xmm9
addps  %xmm0,%xmm9
mulps  %xmm10,%xmm7
addps  %xmm4,%xmm7
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm2
addps  %xmm9,%xmm2
mulps  %xmm11,%xmm3
addps  %xmm7,%xmm3
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm8
movaps %xmm8,%xmm4
addps  %xmm2,%xmm4
mulps  %xmm12,%xmm1
movaps %xmm1,%xmm5
addps  %xmm3,%xmm5
add    $0x40,%rsi
add    $0x40,%rdx
add    $0x10,%rcx
add    $0x4,%eax
cmp    %r10d,%eax
jl     1120 <kernel_sgemv_n_8_lib4+0x20>
addps  %xmm3,%xmm1
addps  %xmm2,%xmm8
mov    %edi,%eax
and    $0xfffffffc,%eax
cmp    %edi,%eax
jl     11eb <kernel_sgemv_n_8_lib4+0xeb>
movaps %xmm8,%xmm2
movaps %xmm1,%xmm3
cmp    $0x1,%r9d
jne    1206 <kernel_sgemv_n_8_lib4+0x106>
jmp    12cf <kernel_sgemv_n_8_lib4+0x1cf>
xorps  %xmm8,%xmm8
xor    %eax,%eax
xorps  %xmm1,%xmm1
cmp    %edi,%eax
jge    11cc <kernel_sgemv_n_8_lib4+0xcc>
mov    %eax,%r10d
not    %r10d
test   $0x1,%dil
jne    122e <kernel_sgemv_n_8_lib4+0x12e>
add    %edi,%r10d
jne    1264 <kernel_sgemv_n_8_lib4+0x164>
cmp    $0x1,%r9d
je     12cf <kernel_sgemv_n_8_lib4+0x1cf>
test   %r9d,%r9d
jne    1215 <kernel_sgemv_n_8_lib4+0x115>
movups %xmm2,(%r8)
movups %xmm3,0x10(%r8)
ret
movups (%r8),%xmm0
movups 0x10(%r8),%xmm1
subps  %xmm2,%xmm0
movups %xmm0,(%r8)
subps  %xmm3,%xmm1
movups %xmm1,0x10(%r8)
ret
movups (%rsi),%xmm2
movss  (%rcx),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm2
addps  %xmm8,%xmm2
movups (%rdx),%xmm3
mulps  %xmm4,%xmm3
addps  %xmm1,%xmm3
add    $0x10,%rsi
add    $0x10,%rdx
add    $0x4,%rcx
or     $0x1,%eax
movaps %xmm2,%xmm8
movaps %xmm3,%xmm1
add    %edi,%r10d
je     11fc <kernel_sgemv_n_8_lib4+0xfc>
sub    %eax,%edi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rax,1),%xmm0
movss  0x4(%rcx,%rax,1),%xmm3
shufps $0x0,%xmm0,%xmm0
movups (%rsi,%rax,4),%xmm4
movups 0x10(%rsi,%rax,4),%xmm2
mulps  %xmm0,%xmm4
addps  %xmm8,%xmm4
movups (%rdx,%rax,4),%xmm5
movups 0x10(%rdx,%rax,4),%xmm6
mulps  %xmm0,%xmm5
addps  %xmm1,%xmm5
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm2
movaps %xmm2,%xmm8
addps  %xmm4,%xmm8
mulps  %xmm6,%xmm3
movaps %xmm3,%xmm1
addps  %xmm5,%xmm1
add    $0x8,%rax
add    $0xfffffffe,%edi
jne    1270 <kernel_sgemv_n_8_lib4+0x170>
addps  %xmm5,%xmm3
addps  %xmm4,%xmm2
cmp    $0x1,%r9d
jne    1206 <kernel_sgemv_n_8_lib4+0x106>
movups (%r8),%xmm0
movups 0x10(%r8),%xmm1
addps  %xmm0,%xmm2
movups %xmm2,(%r8)
addps  %xmm1,%xmm3
movups %xmm3,0x10(%r8)
ret

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

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