void kernel_ssymv_4_lib4(int kmax, int kna, float *A, int sda, float *x_n,
                         float *y_n, float *x_t, float *y_t, int tri, int alg) {
  if (kmax <= 0)
    return;
  const int bs = 4;
  int k;
  float a_00, a_01, a_02, a_03, x_n_0, x_n_1, x_n_2, x_n_3, y_n_0, x_t_0, y_t_0,
      y_t_1, y_t_2, y_t_3;
  if (alg == 1) {
    x_n_0 = x_n[0];
    x_n_1 = x_n[1];
    x_n_2 = x_n[2];
    x_n_3 = x_n[3];
  } else {
    x_n_0 = -x_n[0];
    x_n_1 = -x_n[1];
    x_n_2 = -x_n[2];
    x_n_3 = -x_n[3];
  }
  y_t_0 = 0;
  y_t_1 = 0;
  y_t_2 = 0;
  y_t_3 = 0;
  k = 0;
  if (tri == 1) {
    y_n_0 = y_n[0];
    x_t_0 = x_t[0];
    a_00 = A[0 + bs * 0];
    y_t_0 += a_00 * x_t_0;
    y_n[0] = y_n_0;
    y_n_0 = y_n[1];
    x_t_0 = x_t[1];
    a_00 = A[1 + bs * 0];
    a_01 = A[1 + bs * 1];
    y_n_0 += a_00 * x_n_0;
    y_t_0 += a_00 * x_t_0;
    y_t_1 += a_01 * x_t_0;
    y_n[1] = y_n_0;
    y_n_0 = y_n[2];
    x_t_0 = x_t[2];
    a_00 = A[2 + bs * 0];
    a_01 = A[2 + bs * 1];
    a_02 = A[2 + bs * 2];
    y_n_0 += a_00 * x_n_0;
    y_t_0 += a_00 * x_t_0;
    y_n_0 += a_01 * x_n_1;
    y_t_1 += a_01 * x_t_0;
    y_t_2 += a_02 * x_t_0;
    y_n[2] = y_n_0;
    y_n_0 = y_n[3];
    x_t_0 = x_t[3];
    a_00 = A[3 + bs * 0];
    a_01 = A[3 + bs * 1];
    a_02 = A[3 + bs * 2];
    a_03 = A[3 + bs * 3];
    y_n_0 += a_00 * x_n_0;
    y_t_0 += a_00 * x_t_0;
    y_n_0 += a_01 * x_n_1;
    y_t_1 += a_01 * x_t_0;
    y_n_0 += a_02 * x_n_2;
    y_t_2 += a_02 * x_t_0;
    y_t_3 += a_03 * x_t_0;
    y_n[3] = y_n_0;
    A += 4;
    y_n += 4;
    x_t += 4;
    k += 4;
  }
  for (; k < kna; k++) {
    y_n_0 = y_n[0];
    x_t_0 = x_t[0];
    a_00 = A[0 + bs * 0];
    a_01 = A[0 + bs * 1];
    a_02 = A[0 + bs * 2];
    a_03 = A[0 + bs * 3];
    y_n_0 += a_00 * x_n_0;
    y_t_0 += a_00 * x_t_0;
    y_n_0 += a_01 * x_n_1;
    y_t_1 += a_01 * x_t_0;
    y_n_0 += a_02 * x_n_2;
    y_t_2 += a_02 * x_t_0;
    y_n_0 += a_03 * x_n_3;
    y_t_3 += a_03 * x_t_0;
    y_n[0] = y_n_0;
    A += 1;
    y_n += 1;
    x_t += 1;
  }
  if (kna > 0 || tri == 1) {
    A += (sda - 1) * bs;
  }
  for (; k < kmax - 3; k += bs) {
    y_n_0 = y_n[0];
    x_t_0 = x_t[0];
    a_00 = A[0 + bs * 0];
    a_01 = A[0 + bs * 1];
    a_02 = A[0 + bs * 2];
    a_03 = A[0 + bs * 3];
    y_n_0 += a_00 * x_n_0;
    y_t_0 += a_00 * x_t_0;
    y_n_0 += a_01 * x_n_1;
    y_t_1 += a_01 * x_t_0;
    y_n_0 += a_02 * x_n_2;
    y_t_2 += a_02 * x_t_0;
    y_n_0 += a_03 * x_n_3;
    y_t_3 += a_03 * x_t_0;
    y_n[0] = y_n_0;
    y_n_0 = y_n[1];
    x_t_0 = x_t[1];
    a_00 = A[1 + bs * 0];
    a_01 = A[1 + bs * 1];
    a_02 = A[1 + bs * 2];
    a_03 = A[1 + bs * 3];
    y_n_0 += a_00 * x_n_0;
    y_t_0 += a_00 * x_t_0;
    y_n_0 += a_01 * x_n_1;
    y_t_1 += a_01 * x_t_0;
    y_n_0 += a_02 * x_n_2;
    y_t_2 += a_02 * x_t_0;
    y_n_0 += a_03 * x_n_3;
    y_t_3 += a_03 * x_t_0;
    y_n[1] = y_n_0;
    y_n_0 = y_n[2];
    x_t_0 = x_t[2];
    a_00 = A[2 + bs * 0];
    a_01 = A[2 + bs * 1];
    a_02 = A[2 + bs * 2];
    a_03 = A[2 + bs * 3];
    y_n_0 += a_00 * x_n_0;
    y_t_0 += a_00 * x_t_0;
    y_n_0 += a_01 * x_n_1;
    y_t_1 += a_01 * x_t_0;
    y_n_0 += a_02 * x_n_2;
    y_t_2 += a_02 * x_t_0;
    y_n_0 += a_03 * x_n_3;
    y_t_3 += a_03 * x_t_0;
    y_n[2] = y_n_0;
    y_n_0 = y_n[3];
    x_t_0 = x_t[3];
    a_00 = A[3 + bs * 0];
    a_01 = A[3 + bs * 1];
    a_02 = A[3 + bs * 2];
    a_03 = A[3 + bs * 3];
    y_n_0 += a_00 * x_n_0;
    y_t_0 += a_00 * x_t_0;
    y_n_0 += a_01 * x_n_1;
    y_t_1 += a_01 * x_t_0;
    y_n_0 += a_02 * x_n_2;
    y_t_2 += a_02 * x_t_0;
    y_n_0 += a_03 * x_n_3;
    y_t_3 += a_03 * x_t_0;
    y_n[3] = y_n_0;
    A += sda * bs;
    y_n += 4;
    x_t += 4;
  }
  for (; k < kmax; k++) {
    y_n_0 = y_n[0];
    x_t_0 = x_t[0];
    a_00 = A[0 + bs * 0];
    a_01 = A[0 + bs * 1];
    a_02 = A[0 + bs * 2];
    a_03 = A[0 + bs * 3];
    y_n_0 += a_00 * x_n_0;
    y_t_0 += a_00 * x_t_0;
    y_n_0 += a_01 * x_n_1;
    y_t_1 += a_01 * x_t_0;
    y_n_0 += a_02 * x_n_2;
    y_t_2 += a_02 * x_t_0;
    y_n_0 += a_03 * x_n_3;
    y_t_3 += a_03 * x_t_0;
    y_n[0] = y_n_0;
    A += 1;
    y_n += 1;
    x_t += 1;
  }
  if (alg == 1) {
    y_t[0] += y_t_0;
    y_t[1] += y_t_1;
    y_t[2] += y_t_2;
    y_t[3] += y_t_3;
  } else {
    y_t[0] -= y_t_0;
    y_t[1] -= y_t_1;
    y_t[2] -= y_t_2;
    y_t[3] -= y_t_3;
  }
}


x86 assembly (clang, -O0):
<kernel_ssymv_4_lib4>:
push   %rbp
mov    %rsp,%rbp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
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     1136 <kernel_ssymv_4_lib4+0x36>
jmp    1e78 <kernel_ssymv_4_lib4+0xd78>
movl   $0x4,-0x2c(%rbp)
cmpl   $0x1,0x28(%rbp)
jne    1183 <kernel_ssymv_4_lib4+0x83>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
jmp    11ee <kernel_ssymv_4_lib4+0xee>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0x1,0x20(%rbp)
jne    153c <kernel_ssymv_4_lib4+0x43c>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x28(%rbp)
mov    0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,0x10(%rbp)
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    1541 <kernel_ssymv_4_lib4+0x441>
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16bd <kernel_ssymv_4_lib4+0x5bd>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,0x10(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1541 <kernel_ssymv_4_lib4+0x441>
cmpl   $0x0,-0x8(%rbp)
jg     16d1 <kernel_ssymv_4_lib4+0x5d1>
cmpl   $0x1,0x20(%rbp)
jne    16ec <kernel_ssymv_4_lib4+0x5ec>
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)
jmp    16f1 <kernel_ssymv_4_lib4+0x5f1>
mov    -0x30(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1c44 <kernel_ssymv_4_lib4+0xb44>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,0xc(%rax)
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    -0x28(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x28(%rbp)
mov    0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,0x10(%rbp)
mov    -0x30(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x30(%rbp)
jmp    16f1 <kernel_ssymv_4_lib4+0x5f1>
jmp    1c49 <kernel_ssymv_4_lib4+0xb49>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1dc5 <kernel_ssymv_4_lib4+0xcc5>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,0x10(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c49 <kernel_ssymv_4_lib4+0xb49>
cmpl   $0x1,0x28(%rbp)
jne    1e1e <kernel_ssymv_4_lib4+0xd1e>
movss  -0x5c(%rbp),%xmm0
mov    0x18(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
addss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x64(%rbp),%xmm0
mov    0x18(%rbp),%rax
addss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
addss  0xc(%rax),%xmm0
movss  %xmm0,0xc(%rax)
jmp    1e78 <kernel_ssymv_4_lib4+0xd78>
movss  -0x5c(%rbp),%xmm1
mov    0x18(%rbp),%rax
movss  (%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x60(%rbp),%xmm1
mov    0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x64(%rbp),%xmm1
mov    0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x68(%rbp),%xmm1
mov    0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,0xc(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_ssymv_4_lib4>:
push   %r14
push   %rbx
test   %edi,%edi
jle    1594 <kernel_ssymv_4_lib4+0x494>
mov    0x30(%rsp),%r10d
mov    0x28(%rsp),%r11d
movss  (%r8),%xmm11
cmp    $0x1,%r10d
jne    112e <kernel_ssymv_4_lib4+0x2e>
movss  0x4(%r8),%xmm12
movsd  0x8(%r8),%xmm2
jmp    114c <kernel_ssymv_4_lib4+0x4c>
movaps 0xecb(%rip),%xmm3
xorps  %xmm3,%xmm11
movss  0x4(%r8),%xmm12
xorps  %xmm3,%xmm12
movsd  0x8(%r8),%xmm2
xorps  %xmm3,%xmm2
mov    0x18(%rsp),%r8
cmp    $0x1,%r11d
jne    126e <kernel_ssymv_4_lib4+0x16e>
movss  (%rdx),%xmm3
movss  0x4(%rdx),%xmm4
mulss  (%r8),%xmm3
xorps  %xmm5,%xmm5
addss  %xmm5,%xmm3
movaps %xmm4,%xmm7
mulss  %xmm11,%xmm7
addss  0x4(%r9),%xmm7
movss  0x4(%r8),%xmm9
mulss  %xmm9,%xmm4
mulss  0x14(%rdx),%xmm9
addss  %xmm3,%xmm4
addss  %xmm5,%xmm9
movss  %xmm7,0x4(%r9)
movss  0x8(%r8),%xmm7
movss  0x8(%rdx),%xmm8
movaps %xmm8,%xmm5
mulss  %xmm11,%xmm5
addss  0x8(%r9),%xmm5
movss  0x18(%rdx),%xmm6
mulss  %xmm7,%xmm8
addss  %xmm4,%xmm8
movaps %xmm6,%xmm3
mulss  %xmm12,%xmm3
addss  %xmm5,%xmm3
movss  0x28(%rdx),%xmm4
unpcklps %xmm4,%xmm6
unpcklps %xmm7,%xmm7
mulps  %xmm6,%xmm7
xorps  %xmm4,%xmm4
xorps  %xmm10,%xmm10
movss  %xmm9,%xmm10
addps  %xmm7,%xmm10
movss  %xmm3,0x8(%r9)
movss  0xc(%rdx),%xmm5
movss  0x1c(%rdx),%xmm6
movss  0x2c(%rdx),%xmm7
movaps %xmm5,%xmm3
mulss  %xmm11,%xmm3
addss  0xc(%r9),%xmm3
unpcklps %xmm6,%xmm5
mulss  %xmm12,%xmm6
addss  %xmm3,%xmm6
movaps %xmm7,%xmm3
mulss  %xmm2,%xmm3
addss  %xmm6,%xmm3
movss  0x3c(%rdx),%xmm6
unpcklps %xmm6,%xmm7
movlhps %xmm7,%xmm5
movss  0xc(%r8),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm5,%xmm6
movss  %xmm8,%xmm4
shufps $0x4c,%xmm10,%xmm4
shufps $0x78,%xmm4,%xmm4
addps  %xmm6,%xmm4
movss  %xmm3,0xc(%r9)
add    $0x10,%rdx
add    $0x10,%r9
add    $0x10,%r8
mov    $0x4,%eax
jmp    1273 <kernel_ssymv_4_lib4+0x173>
xorps  %xmm4,%xmm4
xor    %eax,%eax
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
cmp    %esi,%eax
jge    1314 <kernel_ssymv_4_lib4+0x214>
mov    %esi,%r14d
sub    %eax,%r14d
xor    %eax,%eax
xor    %ebx,%ebx
nopl   0x0(%rax)
movaps %xmm4,%xmm5
movss  (%rdx,%rbx,4),%xmm1
movss  0x10(%rdx,%rbx,4),%xmm6
movss  0x20(%rdx,%rbx,4),%xmm7
movss  0x30(%rdx,%rbx,4),%xmm0
movaps %xmm1,%xmm4
mulss  %xmm11,%xmm4
addss  (%r9,%rbx,4),%xmm4
unpcklps %xmm6,%xmm1
mulss  %xmm12,%xmm6
addss  %xmm4,%xmm6
movaps %xmm7,%xmm4
mulss  %xmm2,%xmm4
addss  %xmm6,%xmm4
unpcklps %xmm0,%xmm7
mulss  %xmm3,%xmm0
addss  %xmm4,%xmm0
movlhps %xmm7,%xmm1
movss  (%r8,%rbx,4),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
movaps %xmm6,%xmm4
addps  %xmm5,%xmm4
movss  %xmm0,(%r9,%rbx,4)
add    $0x1,%rbx
add    $0xfffffffffffffffc,%rax
cmp    %ebx,%r14d
jne    1290 <kernel_ssymv_4_lib4+0x190>
addps  %xmm5,%xmm6
sub    %rax,%rdx
sub    %rax,%r9
sub    %rax,%r8
mov    %esi,%eax
movaps %xmm6,%xmm4
xor    %r14d,%r14d
cmp    $0x1,%r11d
lea    -0x4(,%rcx,4),%ebx
movslq %ebx,%rbx
cmove  %rbx,%r14
test   %esi,%esi
cmovg  %rbx,%r14
lea    (%rdx,%r14,4),%rdx
lea    -0x3(%rdi),%esi
cmp    %esi,%eax
jge    14df <kernel_ssymv_4_lib4+0x3df>
shl    $0x2,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
nopl   0x0(%rax,%rax,1)
movss  (%rdx),%xmm0
movss  0x10(%rdx),%xmm1
movss  0x20(%rdx),%xmm5
movss  0x30(%rdx),%xmm6
movaps %xmm0,%xmm7
mulss  %xmm11,%xmm7
addss  (%r9),%xmm7
unpcklps %xmm1,%xmm0
mulss  %xmm12,%xmm1
addss  %xmm7,%xmm1
movaps %xmm5,%xmm7
mulss  %xmm2,%xmm7
addss  %xmm1,%xmm7
unpcklps %xmm6,%xmm5
mulss  %xmm3,%xmm6
addss  %xmm7,%xmm6
movlhps %xmm5,%xmm0
movss  (%r8),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm0,%xmm5
addps  %xmm4,%xmm5
movss  %xmm6,(%r9)
movss  0x4(%rdx),%xmm0
movss  0x14(%rdx),%xmm1
movss  0x24(%rdx),%xmm4
movss  0x34(%rdx),%xmm6
movaps %xmm0,%xmm7
mulss  %xmm11,%xmm7
addss  0x4(%r9),%xmm7
unpcklps %xmm1,%xmm0
mulss  %xmm12,%xmm1
addss  %xmm7,%xmm1
movaps %xmm4,%xmm7
mulss  %xmm2,%xmm7
addss  %xmm1,%xmm7
unpcklps %xmm6,%xmm4
mulss  %xmm3,%xmm6
addss  %xmm7,%xmm6
movlhps %xmm4,%xmm0
movss  0x4(%r8),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm0,%xmm4
addps  %xmm5,%xmm4
movss  %xmm6,0x4(%r9)
movss  0x8(%rdx),%xmm0
movss  0x18(%rdx),%xmm1
movss  0x28(%rdx),%xmm5
movss  0x38(%rdx),%xmm6
movaps %xmm0,%xmm7
mulss  %xmm11,%xmm7
addss  0x8(%r9),%xmm7
unpcklps %xmm1,%xmm0
mulss  %xmm12,%xmm1
addss  %xmm7,%xmm1
movaps %xmm5,%xmm7
mulss  %xmm2,%xmm7
addss  %xmm1,%xmm7
unpcklps %xmm6,%xmm5
mulss  %xmm3,%xmm6
addss  %xmm7,%xmm6
movlhps %xmm5,%xmm0
movss  0x8(%r8),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm0,%xmm5
addps  %xmm4,%xmm5
movss  %xmm6,0x8(%r9)
movss  0xc(%rdx),%xmm0
movss  0x1c(%rdx),%xmm1
movss  0x2c(%rdx),%xmm4
movaps %xmm0,%xmm6
mulss  %xmm11,%xmm6
addss  0xc(%r9),%xmm6
movss  0x3c(%rdx),%xmm7
unpcklps %xmm1,%xmm0
mulss  %xmm12,%xmm1
addss  %xmm6,%xmm1
movaps %xmm4,%xmm6
mulss  %xmm2,%xmm6
addss  %xmm1,%xmm6
unpcklps %xmm7,%xmm4
mulss  %xmm3,%xmm7
addss  %xmm6,%xmm7
movlhps %xmm4,%xmm0
movss  0xc(%r8),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm0,%xmm6
movaps %xmm6,%xmm4
addps  %xmm5,%xmm4
movss  %xmm7,0xc(%r9)
add    $0x10,%r9
add    $0x10,%r8
add    $0x4,%eax
add    %rcx,%rdx
cmp    %esi,%eax
jl     1350 <kernel_ssymv_4_lib4+0x250>
addps  %xmm5,%xmm6
movaps %xmm6,%xmm4
mov    0x20(%rsp),%rcx
cmp    %edi,%eax
jge    1564 <kernel_ssymv_4_lib4+0x464>
sub    %eax,%edi
xor    %eax,%eax
movaps %xmm4,%xmm5
movss  (%rdx,%rax,4),%xmm0
movss  0x10(%rdx,%rax,4),%xmm1
movss  0x20(%rdx,%rax,4),%xmm4
movss  0x30(%rdx,%rax,4),%xmm7
movaps %xmm0,%xmm6
mulss  %xmm11,%xmm6
addss  (%r9,%rax,4),%xmm6
unpcklps %xmm1,%xmm0
mulss  %xmm12,%xmm1
addss  %xmm6,%xmm1
movaps %xmm4,%xmm6
mulss  %xmm2,%xmm6
addss  %xmm1,%xmm6
unpcklps %xmm7,%xmm4
mulss  %xmm3,%xmm7
addss  %xmm6,%xmm7
movlhps %xmm4,%xmm0
movss  (%r8,%rax,4),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm0,%xmm6
movaps %xmm6,%xmm4
addps  %xmm5,%xmm4
movss  %xmm7,(%r9,%rax,4)
add    $0x1,%rax
cmp    %eax,%edi
jne    14f0 <kernel_ssymv_4_lib4+0x3f0>
addps  %xmm5,%xmm6
movaps %xmm6,%xmm4
movss  (%rcx),%xmm0
cmp    $0x1,%r10d
jne    1582 <kernel_ssymv_4_lib4+0x482>
movss  0x4(%rcx),%xmm1
unpcklps %xmm1,%xmm0
movhps 0x8(%rcx),%xmm0
addps  %xmm0,%xmm4
movups %xmm4,(%rcx)
jmp    1594 <kernel_ssymv_4_lib4+0x494>
movss  0x4(%rcx),%xmm1
unpcklps %xmm1,%xmm0
movhps 0x8(%rcx),%xmm0
subps  %xmm4,%xmm0
movups %xmm0,(%rcx)
pop    %rbx
pop    %r14
ret

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

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