void kernel_sgemv_t_8_lib4(int kmax, int kna, float *A, int sda, float *x,
                           float *y, int alg) {
  if (kmax <= 0)
    return;
  const int lda = 4;
  const int bs = 4;
  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;
    A += sda * bs;
    x += 4;
  }
  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_lib4>:
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_lib4+0x2b>
jmp    1a90 <kernel_sgemv_t_8_lib4+0x990>
movl   $0x4,-0x2c(%rbp)
movl   $0x4,-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    12ec <kernel_sgemv_t_8_lib4+0x1ec>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12d1 <kernel_sgemv_t_8_lib4+0x1d1>
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  0x10(%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  0x20(%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  0x30(%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  0x40(%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  0x50(%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  0x60(%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  0x70(%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_lib4+0x93>
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x2,%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    $0x4,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    176f <kernel_sgemv_t_8_lib4+0x66f>
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  0x10(%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  0x20(%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  0x30(%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  0x40(%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  0x50(%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  0x60(%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  0x70(%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  0x14(%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  0x24(%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  0x34(%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  0x44(%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  0x54(%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  0x64(%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  0x74(%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  0x18(%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  0x28(%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  0x38(%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  0x48(%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  0x58(%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  0x68(%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  0x78(%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  0x1c(%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  0x2c(%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  0x3c(%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  0x4c(%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  0x5c(%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  0x6c(%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  0x7c(%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    $0x2,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x34(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x34(%rbp)
jmp    12f3 <kernel_sgemv_t_8_lib4+0x1f3>
jmp    1774 <kernel_sgemv_t_8_lib4+0x674>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    18b2 <kernel_sgemv_t_8_lib4+0x7b2>
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  0x10(%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  0x20(%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  0x30(%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  0x40(%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  0x50(%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  0x60(%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  0x70(%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    1774 <kernel_sgemv_t_8_lib4+0x674>
cmpl   $0x0,0x10(%rbp)
jne    1930 <kernel_sgemv_t_8_lib4+0x830>
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    1a90 <kernel_sgemv_t_8_lib4+0x990>
cmpl   $0x1,0x10(%rbp)
jne    19d5 <kernel_sgemv_t_8_lib4+0x8d5>
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    1a8b <kernel_sgemv_t_8_lib4+0x98b>
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    1a90 <kernel_sgemv_t_8_lib4+0x990>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_sgemv_t_8_lib4>:
test   %edi,%edi
jle    1410 <kernel_sgemv_t_8_lib4+0x310>
sub    %esi,%edi
test   %esi,%esi
jle    11ac <kernel_sgemv_t_8_lib4+0xac>
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  0x10(%rdx,%rsi,4),%xmm1
unpcklps %xmm1,%xmm0
movss  0x20(%rdx,%rsi,4),%xmm1
movss  0x30(%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  0x70(%rdx,%rsi,4),%xmm1
movss  0x60(%rdx,%rsi,4),%xmm6
unpcklps %xmm1,%xmm6
movss  0x50(%rdx,%rsi,4),%xmm7
movss  0x40(%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_lib4+0x20>
addps  %xmm3,%xmm1
addps  %xmm2,%xmm0
lea    -0x4(,%rcx,4),%esi
movslq %esi,%rsi
lea    (%rdx,%rsi,4),%rdx
sub    %rax,%rdx
sub    %rax,%r8
jmp    11b2 <kernel_sgemv_t_8_lib4+0xb2>
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
cmp    $0x4,%edi
jl     133d <kernel_sgemv_t_8_lib4+0x23d>
lea    -0x3(%rdi),%esi
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
xor    %eax,%eax
nopl   0x0(%rax)
movss  0x30(%rdx),%xmm2
movss  0x20(%rdx),%xmm3
unpcklps %xmm2,%xmm3
movss  0x10(%rdx),%xmm2
movss  (%rdx),%xmm4
unpcklps %xmm2,%xmm4
movlhps %xmm3,%xmm4
movss  0x4(%rdx),%xmm6
movss  0x8(%rdx),%xmm3
movss  0xc(%rdx),%xmm2
movss  (%r8),%xmm5
movss  0x4(%r8),%xmm10
movss  0x8(%r8),%xmm9
movss  0xc(%r8),%xmm8
shufps $0x0,%xmm5,%xmm5
mulps  %xmm5,%xmm4
addps  %xmm0,%xmm4
movss  0x70(%rdx),%xmm0
movss  0x60(%rdx),%xmm7
unpcklps %xmm0,%xmm7
movss  0x50(%rdx),%xmm11
movss  0x40(%rdx),%xmm0
unpcklps %xmm11,%xmm0
movlhps %xmm7,%xmm0
mulps  %xmm5,%xmm0
addps  %xmm1,%xmm0
movss  0x34(%rdx),%xmm1
movss  0x24(%rdx),%xmm5
unpcklps %xmm1,%xmm5
movss  0x14(%rdx),%xmm1
unpcklps %xmm1,%xmm6
movlhps %xmm5,%xmm6
shufps $0x0,%xmm10,%xmm10
mulps  %xmm10,%xmm6
addps  %xmm4,%xmm6
movss  0x74(%rdx),%xmm1
movss  0x64(%rdx),%xmm4
unpcklps %xmm1,%xmm4
movss  0x54(%rdx),%xmm5
movss  0x44(%rdx),%xmm1
unpcklps %xmm5,%xmm1
movlhps %xmm4,%xmm1
mulps  %xmm10,%xmm1
addps  %xmm0,%xmm1
movss  0x38(%rdx),%xmm0
movss  0x28(%rdx),%xmm4
unpcklps %xmm0,%xmm4
movss  0x18(%rdx),%xmm0
unpcklps %xmm0,%xmm3
movlhps %xmm4,%xmm3
shufps $0x0,%xmm9,%xmm9
mulps  %xmm9,%xmm3
addps  %xmm6,%xmm3
movss  0x78(%rdx),%xmm0
movss  0x68(%rdx),%xmm4
unpcklps %xmm0,%xmm4
movss  0x58(%rdx),%xmm0
movss  0x48(%rdx),%xmm6
unpcklps %xmm0,%xmm6
movlhps %xmm4,%xmm6
mulps  %xmm9,%xmm6
addps  %xmm1,%xmm6
movss  0x3c(%rdx),%xmm0
movss  0x2c(%rdx),%xmm1
unpcklps %xmm0,%xmm1
movss  0x1c(%rdx),%xmm0
unpcklps %xmm0,%xmm2
movlhps %xmm1,%xmm2
shufps $0x0,%xmm8,%xmm8
mulps  %xmm8,%xmm2
movaps %xmm2,%xmm0
addps  %xmm3,%xmm0
movss  0x7c(%rdx),%xmm1
movss  0x6c(%rdx),%xmm5
unpcklps %xmm1,%xmm5
movss  0x5c(%rdx),%xmm1
movss  0x4c(%rdx),%xmm4
unpcklps %xmm1,%xmm4
movlhps %xmm5,%xmm4
mulps  %xmm8,%xmm4
movaps %xmm4,%xmm1
addps  %xmm6,%xmm1
add    $0x10,%r8
add    $0x4,%eax
add    %rcx,%rdx
cmp    %esi,%eax
jl     11d0 <kernel_sgemv_t_8_lib4+0xd0>
addps  %xmm6,%xmm4
addps  %xmm3,%xmm2
movaps %xmm2,%xmm0
movaps %xmm4,%xmm1
mov    0x8(%rsp),%r10d
cmp    %edi,%eax
jge    13ca <kernel_sgemv_t_8_lib4+0x2ca>
mov    %eax,%eax
xor    %esi,%esi
xchg   %ax,%ax
movaps %xmm1,%xmm3
movaps %xmm0,%xmm2
movss  (%rdx,%rsi,4),%xmm4
movss  0x10(%rdx,%rsi,4),%xmm0
unpcklps %xmm0,%xmm4
movss  0x20(%rdx,%rsi,4),%xmm0
movss  0x30(%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  0x70(%rdx,%rsi,4),%xmm5
movss  0x60(%rdx,%rsi,4),%xmm6
unpcklps %xmm5,%xmm6
movss  0x50(%rdx,%rsi,4),%xmm7
movss  0x40(%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     1350 <kernel_sgemv_t_8_lib4+0x250>
addps  %xmm3,%xmm5
addps  %xmm2,%xmm4
movaps %xmm4,%xmm0
movaps %xmm5,%xmm1
cmp    $0x1,%r10d
je     13df <kernel_sgemv_t_8_lib4+0x2df>
test   %r10d,%r10d
jne    13f8 <kernel_sgemv_t_8_lib4+0x2f8>
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_lib4(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 %511
34: ; preds = %7
store i32 4, i32* %15
store i32 4, 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 4
%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 8
%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 12
%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 16
%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 20
%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 24
%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 28
%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, 4
%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 = %330, %111
%113 = load i32, i32* %17
%114 = load i32, i32* %18
%115 = sub nsw i32 %114, 4
%116 = add nsw i32 %115, 1
%117 = icmp slt i32 %113, %116
br i1 %117, label %118, label %333
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 4
%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 8
%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 12
%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 16
%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 20
%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 24
%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 28
%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 5
%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 9
%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 13
%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 17
%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 21
%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 25
%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 29
%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 6
%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 10
%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 14
%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 18
%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 22
%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 26
%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 30
%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 7
%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 11
%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 15
%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 19
%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 23
%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 27
%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 31
%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 i32, i32* %11
%324 = mul nsw i32 %323, 4
%325 = load float*, float** %10
%326 = sext i32 %324 to i64
%327 = getelementptr inbounds float, float* %325, i64 %326
store float* %327, float** %10
%328 = load float*, float** %12
%329 = getelementptr inbounds float, float* %328, i64 4
store float* %329, float** %12
br label %330
330: ; preds = %118
%331 = load i32, i32* %17
%332 = add nsw i32 %331, 4
store i32 %332, i32* %17
br label %112
333: ; preds = %112
br label %334
334: ; preds = %394, %333
%335 = load i32, i32* %17
%336 = load i32, i32* %18
%337 = icmp slt i32 %335, %336
br i1 %337, label %338, label %397
338: ; preds = %334
%339 = load float*, float** %12
%340 = getelementptr inbounds float, float* %339, i64 0
%341 = load float, float* %340
store float %341, float* %19
%342 = load float*, float** %10
%343 = getelementptr inbounds float, float* %342, i64 0
%344 = load float, float* %343
%345 = load float, float* %19
%346 = load float, float* %23
%347 = call float @llvm.fmuladd.f32(float %344, float %345, float %346)
store float %347, float* %23
%348 = load float*, float** %10
%349 = getelementptr inbounds float, float* %348, i64 4
%350 = load float, float* %349
%351 = load float, float* %19
%352 = load float, float* %24
%353 = call float @llvm.fmuladd.f32(float %350, float %351, float %352)
store float %353, float* %24
%354 = load float*, float** %10
%355 = getelementptr inbounds float, float* %354, i64 8
%356 = load float, float* %355
%357 = load float, float* %19
%358 = load float, float* %25
%359 = call float @llvm.fmuladd.f32(float %356, float %357, float %358)
store float %359, float* %25
%360 = load float*, float** %10
%361 = getelementptr inbounds float, float* %360, i64 12
%362 = load float, float* %361
%363 = load float, float* %19
%364 = load float, float* %26
%365 = call float @llvm.fmuladd.f32(float %362, float %363, float %364)
store float %365, float* %26
%366 = load float*, float** %10
%367 = getelementptr inbounds float, float* %366, i64 16
%368 = load float, float* %367
%369 = load float, float* %19
%370 = load float, float* %27
%371 = call float @llvm.fmuladd.f32(float %368, float %369, float %370)
store float %371, float* %27
%372 = load float*, float** %10
%373 = getelementptr inbounds float, float* %372, i64 20
%374 = load float, float* %373
%375 = load float, float* %19
%376 = load float, float* %28
%377 = call float @llvm.fmuladd.f32(float %374, float %375, float %376)
store float %377, float* %28
%378 = load float*, float** %10
%379 = getelementptr inbounds float, float* %378, i64 24
%380 = load float, float* %379
%381 = load float, float* %19
%382 = load float, float* %29
%383 = call float @llvm.fmuladd.f32(float %380, float %381, float %382)
store float %383, float* %29
%384 = load float*, float** %10
%385 = getelementptr inbounds float, float* %384, i64 28
%386 = load float, float* %385
%387 = load float, float* %19
%388 = load float, float* %30
%389 = call float @llvm.fmuladd.f32(float %386, float %387, float %388)
store float %389, float* %30
%390 = load float*, float** %10
%391 = getelementptr inbounds float, float* %390, i64 1
store float* %391, float** %10
%392 = load float*, float** %12
%393 = getelementptr inbounds float, float* %392, i64 1
store float* %393, float** %12
br label %394
394: ; preds = %338
%395 = load i32, i32* %17
%396 = add nsw i32 %395, 1
store i32 %396, i32* %17
br label %334
397: ; preds = %334
%398 = load i32, i32* %14
%399 = icmp eq i32 %398, 0
br i1 %399, label %400, label %425
400: ; preds = %397
%401 = load float, float* %23
%402 = load float*, float** %13
%403 = getelementptr inbounds float, float* %402, i64 0
store float %401, float* %403
%404 = load float, float* %24
%405 = load float*, float** %13
%406 = getelementptr inbounds float, float* %405, i64 1
store float %404, float* %406
%407 = load float, float* %25
%408 = load float*, float** %13
%409 = getelementptr inbounds float, float* %408, i64 2
store float %407, float* %409
%410 = load float, float* %26
%411 = load float*, float** %13
%412 = getelementptr inbounds float, float* %411, i64 3
store float %410, float* %412
%413 = load float, float* %27
%414 = load float*, float** %13
%415 = getelementptr inbounds float, float* %414, i64 4
store float %413, float* %415
%416 = load float, float* %28
%417 = load float*, float** %13
%418 = getelementptr inbounds float, float* %417, i64 5
store float %416, float* %418
%419 = load float, float* %29
%420 = load float*, float** %13
%421 = getelementptr inbounds float, float* %420, i64 6
store float %419, float* %421
%422 = load float, float* %30
%423 = load float*, float** %13
%424 = getelementptr inbounds float, float* %423, i64 7
store float %422, float* %424
br label %511
425: ; preds = %397
%426 = load i32, i32* %14
%427 = icmp eq i32 %426, 1
br i1 %427, label %428, label %469
428: ; preds = %425
%429 = load float, float* %23
%430 = load float*, float** %13
%431 = getelementptr inbounds float, float* %430, i64 0
%432 = load float, float* %431
%433 = fadd float %432, %429
store float %433, float* %431
%434 = load float, float* %24
%435 = load float*, float** %13
%436 = getelementptr inbounds float, float* %435, i64 1
%437 = load float, float* %436
%438 = fadd float %437, %434
store float %438, float* %436
%439 = load float, float* %25
%440 = load float*, float** %13
%441 = getelementptr inbounds float, float* %440, i64 2
%442 = load float, float* %441
%443 = fadd float %442, %439
store float %443, float* %441
%444 = load float, float* %26
%445 = load float*, float** %13
%446 = getelementptr inbounds float, float* %445, i64 3
%447 = load float, float* %446
%448 = fadd float %447, %444
store float %448, float* %446
%449 = load float, float* %27
%450 = load float*, float** %13
%451 = getelementptr inbounds float, float* %450, i64 4
%452 = load float, float* %451
%453 = fadd float %452, %449
store float %453, float* %451
%454 = load float, float* %28
%455 = load float*, float** %13
%456 = getelementptr inbounds float, float* %455, i64 5
%457 = load float, float* %456
%458 = fadd float %457, %454
store float %458, float* %456
%459 = load float, float* %29
%460 = load float*, float** %13
%461 = getelementptr inbounds float, float* %460, i64 6
%462 = load float, float* %461
%463 = fadd float %462, %459
store float %463, float* %461
%464 = load float, float* %30
%465 = load float*, float** %13
%466 = getelementptr inbounds float, float* %465, i64 7
%467 = load float, float* %466
%468 = fadd float %467, %464
store float %468, float* %466
br label %510
469: ; preds = %425
%470 = load float, float* %23
%471 = load float*, float** %13
%472 = getelementptr inbounds float, float* %471, i64 0
%473 = load float, float* %472
%474 = fsub float %473, %470
store float %474, float* %472
%475 = load float, float* %24
%476 = load float*, float** %13
%477 = getelementptr inbounds float, float* %476, i64 1
%478 = load float, float* %477
%479 = fsub float %478, %475
store float %479, float* %477
%480 = load float, float* %25
%481 = load float*, float** %13
%482 = getelementptr inbounds float, float* %481, i64 2
%483 = load float, float* %482
%484 = fsub float %483, %480
store float %484, float* %482
%485 = load float, float* %26
%486 = load float*, float** %13
%487 = getelementptr inbounds float, float* %486, i64 3
%488 = load float, float* %487
%489 = fsub float %488, %485
store float %489, float* %487
%490 = load float, float* %27
%491 = load float*, float** %13
%492 = getelementptr inbounds float, float* %491, i64 4
%493 = load float, float* %492
%494 = fsub float %493, %490
store float %494, float* %492
%495 = load float, float* %28
%496 = load float*, float** %13
%497 = getelementptr inbounds float, float* %496, i64 5
%498 = load float, float* %497
%499 = fsub float %498, %495
store float %499, float* %497
%500 = load float, float* %29
%501 = load float*, float** %13
%502 = getelementptr inbounds float, float* %501, i64 6
%503 = load float, float* %502
%504 = fsub float %503, %500
store float %504, float* %502
%505 = load float, float* %30
%506 = load float*, float** %13
%507 = getelementptr inbounds float, float* %506, i64 7
%508 = load float, float* %507
%509 = fsub float %508, %505
store float %509, float* %507
br label %510
510: ; preds = %469, %428
br label %511
511: ; preds = %33, %510, %400
ret void
}

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