void kernel_ssymv_4_lib8(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 = 8;
  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 - bs + 1; 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;
    y_n_0 = y_n[4];
    x_t_0 = x_t[4];
    a_00 = A[4 + bs * 0];
    a_01 = A[4 + bs * 1];
    a_02 = A[4 + bs * 2];
    a_03 = A[4 + 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[4] = y_n_0;
    y_n_0 = y_n[5];
    x_t_0 = x_t[5];
    a_00 = A[5 + bs * 0];
    a_01 = A[5 + bs * 1];
    a_02 = A[5 + bs * 2];
    a_03 = A[5 + 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[5] = y_n_0;
    y_n_0 = y_n[6];
    x_t_0 = x_t[6];
    a_00 = A[6 + bs * 0];
    a_01 = A[6 + bs * 1];
    a_02 = A[6 + bs * 2];
    a_03 = A[6 + 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[6] = y_n_0;
    y_n_0 = y_n[7];
    x_t_0 = x_t[7];
    a_00 = A[7 + bs * 0];
    a_01 = A[7 + bs * 1];
    a_02 = A[7 + bs * 2];
    a_03 = A[7 + 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[7] = y_n_0;
    A += sda * bs;
    y_n += 8;
    x_t += 8;
  }
  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_lib8>:
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_lib8+0x36>
jmp    2383 <kernel_ssymv_4_lib8+0x1283>
movl   $0x8,-0x2c(%rbp)
cmpl   $0x1,0x28(%rbp)
jne    1183 <kernel_ssymv_4_lib8+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_lib8+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_lib8+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  0x24(%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  0x28(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%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  0x2c(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%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_lib8+0x441>
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16bd <kernel_ssymv_4_lib8+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  0x20(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%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_lib8+0x441>
cmpl   $0x0,-0x8(%rbp)
jg     16d1 <kernel_ssymv_4_lib8+0x5d1>
cmpl   $0x1,0x20(%rbp)
jne    16ec <kernel_ssymv_4_lib8+0x5ec>
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    16f1 <kernel_ssymv_4_lib8+0x5f1>
mov    -0x30(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x8,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    214f <kernel_ssymv_4_lib8+0x104f>
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  0x20(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%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  0x24(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x44(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x64(%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  0x28(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x48(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x68(%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  0x2c(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4c(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x6c(%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    -0x28(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x50(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x70(%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,0x10(%rax)
mov    -0x28(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x54(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x74(%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,0x14(%rax)
mov    -0x28(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x58(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x78(%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,0x18(%rax)
mov    -0x28(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x5c(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x7c(%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,0x1c(%rax)
mov    -0x14(%rbp),%ecx
shl    $0x3,%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x28(%rbp)
mov    0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,0x10(%rbp)
mov    -0x30(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x30(%rbp)
jmp    16f1 <kernel_ssymv_4_lib8+0x5f1>
jmp    2154 <kernel_ssymv_4_lib8+0x1054>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    22d0 <kernel_ssymv_4_lib8+0x11d0>
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  0x20(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  0x40(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x60(%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    2154 <kernel_ssymv_4_lib8+0x1054>
cmpl   $0x1,0x28(%rbp)
jne    2329 <kernel_ssymv_4_lib8+0x1229>
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    2383 <kernel_ssymv_4_lib8+0x1283>
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_lib8>:
push   %r15
push   %r14
push   %rbx
test   %edi,%edi
jle    1726 <kernel_ssymv_4_lib8+0x626>
mov    0x38(%rsp),%r10d
mov    0x30(%rsp),%r11d
movss  (%r8),%xmm11
cmp    $0x1,%r10d
jne    1130 <kernel_ssymv_4_lib8+0x30>
movss  0x4(%r8),%xmm12
movsd  0x8(%r8),%xmm13
jmp    114f <kernel_ssymv_4_lib8+0x4f>
movaps 0xec9(%rip),%xmm3
xorps  %xmm3,%xmm11
movss  0x4(%r8),%xmm12
xorps  %xmm3,%xmm12
movsd  0x8(%r8),%xmm13
xorps  %xmm3,%xmm13
mov    0x20(%rsp),%r15
cmp    $0x1,%r11d
jne    1273 <kernel_ssymv_4_lib8+0x173>
movss  (%rdx),%xmm3
movss  0x4(%rdx),%xmm4
mulss  (%r15),%xmm3
xorps  %xmm5,%xmm5
addss  %xmm5,%xmm3
movaps %xmm4,%xmm7
mulss  %xmm11,%xmm7
addss  0x4(%r9),%xmm7
movss  0x4(%r15),%xmm9
mulss  %xmm9,%xmm4
mulss  0x24(%rdx),%xmm9
addss  %xmm3,%xmm4
addss  %xmm5,%xmm9
movss  %xmm7,0x4(%r9)
movss  0x8(%r15),%xmm7
movss  0x8(%rdx),%xmm8
movaps %xmm8,%xmm5
mulss  %xmm11,%xmm5
addss  0x8(%r9),%xmm5
movss  0x28(%rdx),%xmm6
mulss  %xmm7,%xmm8
addss  %xmm4,%xmm8
movaps %xmm6,%xmm3
mulss  %xmm12,%xmm3
addss  %xmm5,%xmm3
movss  0x48(%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  0x2c(%rdx),%xmm6
movss  0x4c(%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  %xmm13,%xmm3
addss  %xmm6,%xmm3
movss  0x6c(%rdx),%xmm6
unpcklps %xmm6,%xmm7
movlhps %xmm7,%xmm5
movss  0xc(%r15),%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,%r15
mov    $0x4,%r8d
jmp    1279 <kernel_ssymv_4_lib8+0x179>
xorps  %xmm4,%xmm4
xor    %r8d,%r8d
movaps %xmm13,%xmm8
shufps $0x55,%xmm13,%xmm8
cmp    %esi,%r8d
jge    1327 <kernel_ssymv_4_lib8+0x227>
mov    %esi,%r14d
sub    %r8d,%r14d
xor    %eax,%eax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm4,%xmm5
movss  (%rdx,%rbx,4),%xmm1
movss  0x20(%rdx,%rbx,4),%xmm6
movss  0x40(%rdx,%rbx,4),%xmm7
movss  0x60(%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  %xmm13,%xmm4
addss  %xmm6,%xmm4
unpcklps %xmm0,%xmm7
mulss  %xmm8,%xmm0
addss  %xmm4,%xmm0
movlhps %xmm7,%xmm1
movss  (%r15,%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    12a0 <kernel_ssymv_4_lib8+0x1a0>
addps  %xmm5,%xmm6
sub    %rax,%rdx
sub    %rax,%r9
sub    %rax,%r15
mov    %esi,%r8d
movaps %xmm6,%xmm4
xor    %eax,%eax
cmp    $0x1,%r11d
lea    -0x8(,%rcx,8),%ebx
movslq %ebx,%rbx
cmove  %rbx,%rax
test   %esi,%esi
cmovg  %rbx,%rax
lea    (%rdx,%rax,4),%rdx
lea    -0x7(%rdi),%esi
cmp    %esi,%r8d
jge    166c <kernel_ssymv_4_lib8+0x56c>
shl    $0x3,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
nopl   0x0(%rax,%rax,1)
movss  (%rdx),%xmm0
movss  0x20(%rdx),%xmm1
movss  0x40(%rdx),%xmm6
movss  0x60(%rdx),%xmm7
movaps %xmm0,%xmm5
mulss  %xmm11,%xmm5
addss  (%r9),%xmm5
unpcklps %xmm1,%xmm0
mulss  %xmm12,%xmm1
addss  %xmm5,%xmm1
movaps %xmm6,%xmm5
mulss  %xmm13,%xmm5
unpcklps %xmm7,%xmm6
addss  %xmm1,%xmm5
mulss  %xmm8,%xmm7
addss  %xmm5,%xmm7
movss  (%r15),%xmm5
movlhps %xmm6,%xmm0
shufps $0x0,%xmm5,%xmm5
mulps  %xmm0,%xmm5
movss  %xmm7,(%r9)
addps  %xmm4,%xmm5
movss  0x4(%rdx),%xmm6
movss  0x24(%rdx),%xmm0
movss  0x44(%rdx),%xmm1
movss  0x64(%rdx),%xmm7
movaps %xmm6,%xmm4
mulss  %xmm11,%xmm4
addss  0x4(%r9),%xmm4
unpcklps %xmm0,%xmm6
mulss  %xmm12,%xmm0
addss  %xmm4,%xmm0
movaps %xmm1,%xmm4
mulss  %xmm13,%xmm4
addss  %xmm0,%xmm4
unpcklps %xmm7,%xmm1
mulss  %xmm8,%xmm7
addss  %xmm4,%xmm7
movlhps %xmm1,%xmm6
movss  0x4(%r15),%xmm4
shufps $0x0,%xmm4,%xmm4
movss  %xmm7,0x4(%r9)
mulps  %xmm6,%xmm4
movss  0x8(%rdx),%xmm2
movss  0x28(%rdx),%xmm0
movss  0x48(%rdx),%xmm1
movss  0x68(%rdx),%xmm7
movaps %xmm2,%xmm6
mulss  %xmm11,%xmm6
addss  0x8(%r9),%xmm6
unpcklps %xmm0,%xmm2
mulss  %xmm12,%xmm0
addss  %xmm6,%xmm0
movaps %xmm1,%xmm6
mulss  %xmm13,%xmm6
addss  %xmm0,%xmm6
unpcklps %xmm7,%xmm1
mulss  %xmm8,%xmm7
addss  %xmm6,%xmm7
addps  %xmm5,%xmm4
movss  0x8(%r15),%xmm5
shufps $0x0,%xmm5,%xmm5
movss  %xmm7,0x8(%r9)
movlhps %xmm1,%xmm2
movss  0xc(%rdx),%xmm7
movss  0x2c(%rdx),%xmm0
movss  0x4c(%rdx),%xmm1
movss  0x6c(%rdx),%xmm3
movaps %xmm7,%xmm6
mulss  %xmm11,%xmm6
addss  0xc(%r9),%xmm6
unpcklps %xmm0,%xmm7
mulss  %xmm12,%xmm0
addss  %xmm6,%xmm0
movaps %xmm1,%xmm6
mulss  %xmm13,%xmm6
mulps  %xmm2,%xmm5
addss  %xmm0,%xmm6
unpcklps %xmm3,%xmm1
mulss  %xmm8,%xmm3
addps  %xmm4,%xmm5
addss  %xmm6,%xmm3
movss  0xc(%r15),%xmm6
shufps $0x0,%xmm6,%xmm6
movlhps %xmm1,%xmm7
movss  %xmm3,0xc(%r9)
movss  0x10(%rdx),%xmm0
movss  0x30(%rdx),%xmm1
movss  0x50(%rdx),%xmm2
movaps %xmm0,%xmm3
mulss  %xmm11,%xmm3
addss  0x10(%r9),%xmm3
mulps  %xmm7,%xmm6
movss  0x70(%rdx),%xmm7
unpcklps %xmm1,%xmm0
mulss  %xmm12,%xmm1
addps  %xmm5,%xmm6
addss  %xmm3,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm13,%xmm3
unpcklps %xmm7,%xmm2
addss  %xmm1,%xmm3
mulss  %xmm8,%xmm7
addss  %xmm3,%xmm7
movss  0x10(%r15),%xmm4
movlhps %xmm2,%xmm0
shufps $0x0,%xmm4,%xmm4
mulps  %xmm0,%xmm4
movss  %xmm7,0x10(%r9)
addps  %xmm6,%xmm4
movss  0x14(%rdx),%xmm6
movss  0x34(%rdx),%xmm0
movss  0x54(%rdx),%xmm1
movss  0x74(%rdx),%xmm2
movaps %xmm6,%xmm3
mulss  %xmm11,%xmm3
addss  0x14(%r9),%xmm3
unpcklps %xmm0,%xmm6
mulss  %xmm12,%xmm0
addss  %xmm3,%xmm0
movaps %xmm1,%xmm3
mulss  %xmm13,%xmm3
addss  %xmm0,%xmm3
unpcklps %xmm2,%xmm1
mulss  %xmm8,%xmm2
addss  %xmm3,%xmm2
movlhps %xmm1,%xmm6
movss  0x14(%r15),%xmm5
shufps $0x0,%xmm5,%xmm5
movss  %xmm2,0x14(%r9)
mulps  %xmm6,%xmm5
movss  0x18(%rdx),%xmm0
movss  0x38(%rdx),%xmm1
movss  0x58(%rdx),%xmm2
movss  0x78(%rdx),%xmm3
movaps %xmm0,%xmm6
mulss  %xmm11,%xmm6
addss  0x18(%r9),%xmm6
unpcklps %xmm1,%xmm0
mulss  %xmm12,%xmm1
addss  %xmm6,%xmm1
movaps %xmm2,%xmm6
mulss  %xmm13,%xmm6
addss  %xmm1,%xmm6
unpcklps %xmm3,%xmm2
mulss  %xmm8,%xmm3
addss  %xmm6,%xmm3
addps  %xmm4,%xmm5
movlhps %xmm2,%xmm0
movss  0x18(%r15),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm0,%xmm6
movss  %xmm3,0x18(%r9)
movss  0x1c(%rdx),%xmm0
movss  0x3c(%rdx),%xmm1
movss  0x5c(%rdx),%xmm2
movaps %xmm0,%xmm3
mulss  %xmm11,%xmm3
addss  0x1c(%r9),%xmm3
addps  %xmm5,%xmm6
movss  0x7c(%rdx),%xmm5
unpcklps %xmm1,%xmm0
mulss  %xmm12,%xmm1
movaps %xmm2,%xmm7
addss  %xmm3,%xmm1
mulss  %xmm13,%xmm7
unpcklps %xmm5,%xmm2
mulss  %xmm8,%xmm5
addss  %xmm1,%xmm7
movlhps %xmm2,%xmm0
movss  0x1c(%r15),%xmm4
shufps $0x0,%xmm4,%xmm4
addss  %xmm7,%xmm5
mulps  %xmm0,%xmm4
addps  %xmm6,%xmm4
movss  %xmm5,0x1c(%r9)
add    $0x20,%r9
add    $0x20,%r15
add    $0x8,%r8d
add    %rcx,%rdx
cmp    %esi,%r8d
jl     1360 <kernel_ssymv_4_lib8+0x260>
mov    0x28(%rsp),%rcx
cmp    %edi,%r8d
jge    16f6 <kernel_ssymv_4_lib8+0x5f6>
sub    %r8d,%edi
xor    %eax,%eax
nop
movaps %xmm4,%xmm5
movss  (%rdx,%rax,4),%xmm0
movss  0x20(%rdx,%rax,4),%xmm1
movss  0x40(%rdx,%rax,4),%xmm2
movss  0x60(%rdx,%rax,4),%xmm3
movaps %xmm0,%xmm4
mulss  %xmm11,%xmm4
addss  (%r9,%rax,4),%xmm4
unpcklps %xmm1,%xmm0
mulss  %xmm12,%xmm1
addss  %xmm4,%xmm1
movaps %xmm2,%xmm4
mulss  %xmm13,%xmm4
addss  %xmm1,%xmm4
unpcklps %xmm3,%xmm2
mulss  %xmm8,%xmm3
addss  %xmm4,%xmm3
movlhps %xmm2,%xmm0
movss  (%r15,%rax,4),%xmm6
shufps $0x0,%xmm6,%xmm6
mulps  %xmm0,%xmm6
movaps %xmm6,%xmm4
addps  %xmm5,%xmm4
movss  %xmm3,(%r9,%rax,4)
add    $0x1,%rax
cmp    %eax,%edi
jne    1680 <kernel_ssymv_4_lib8+0x580>
addps  %xmm5,%xmm6
movaps %xmm6,%xmm4
movss  (%rcx),%xmm0
cmp    $0x1,%r10d
jne    1714 <kernel_ssymv_4_lib8+0x614>
movss  0x4(%rcx),%xmm1
unpcklps %xmm1,%xmm0
movhps 0x8(%rcx),%xmm0
addps  %xmm0,%xmm4
movups %xmm4,(%rcx)
jmp    1726 <kernel_ssymv_4_lib8+0x626>
movss  0x4(%rcx),%xmm1
unpcklps %xmm1,%xmm0
movhps 0x8(%rcx),%xmm0
subps  %xmm4,%xmm0
movups %xmm0,(%rcx)
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @kernel_ssymv_4_lib8(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 %853
40: ; preds = %10
store i32 8, 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 9
%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 10
%131 = load float, float* %130
store float %131, float* %24
%132 = load float*, float** %13
%133 = getelementptr inbounds float, float* %132, i64 18
%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 11
%169 = load float, float* %168
store float %169, float* %24
%170 = load float*, float** %13
%171 = getelementptr inbounds float, float* %170, i64 19
%172 = load float, float* %171
store float %172, float* %25
%173 = load float*, float** %13
%174 = getelementptr inbounds float, float* %173, i64 27
%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 8
%232 = load float, float* %231
store float %232, float* %24
%233 = load float*, float** %13
%234 = getelementptr inbounds float, float* %233, i64 16
%235 = load float, float* %234
store float %235, float* %25
%236 = load float*, float** %13
%237 = getelementptr inbounds float, float* %236, i64 24
%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, 8
%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 = %737, %296
%298 = load i32, i32* %22
%299 = load i32, i32* %11
%300 = sub nsw i32 %299, 8
%301 = add nsw i32 %300, 1
%302 = icmp slt i32 %298, %301
br i1 %302, label %303, label %740
303: ; preds = %297
%304 = load float*, float** %16
%305 = getelementptr inbounds float, float* %304, i64 0
%306 = load float, float* %305
store float %306, float* %31
%307 = load float*, float** %17
%308 = getelementptr inbounds float, float* %307, i64 0
%309 = load float, float* %308
store float %309, float* %32
%310 = load float*, float** %13
%311 = getelementptr inbounds float, float* %310, i64 0
%312 = load float, float* %311
store float %312, float* %23
%313 = load float*, float** %13
%314 = getelementptr inbounds float, float* %313, i64 8
%315 = load float, float* %314
store float %315, float* %24
%316 = load float*, float** %13
%317 = getelementptr inbounds float, float* %316, i64 16
%318 = load float, float* %317
store float %318, float* %25
%319 = load float*, float** %13
%320 = getelementptr inbounds float, float* %319, i64 24
%321 = load float, float* %320
store float %321, float* %26
%322 = load float, float* %23
%323 = load float, float* %27
%324 = load float, float* %31
%325 = call float @llvm.fmuladd.f32(float %322, float %323, float %324)
store float %325, float* %31
%326 = load float, float* %23
%327 = load float, float* %32
%328 = load float, float* %33
%329 = call float @llvm.fmuladd.f32(float %326, float %327, float %328)
store float %329, float* %33
%330 = load float, float* %24
%331 = load float, float* %28
%332 = load float, float* %31
%333 = call float @llvm.fmuladd.f32(float %330, float %331, float %332)
store float %333, float* %31
%334 = load float, float* %24
%335 = load float, float* %32
%336 = load float, float* %34
%337 = call float @llvm.fmuladd.f32(float %334, float %335, float %336)
store float %337, float* %34
%338 = load float, float* %25
%339 = load float, float* %29
%340 = load float, float* %31
%341 = call float @llvm.fmuladd.f32(float %338, float %339, float %340)
store float %341, float* %31
%342 = load float, float* %25
%343 = load float, float* %32
%344 = load float, float* %35
%345 = call float @llvm.fmuladd.f32(float %342, float %343, float %344)
store float %345, float* %35
%346 = load float, float* %26
%347 = load float, float* %30
%348 = load float, float* %31
%349 = call float @llvm.fmuladd.f32(float %346, float %347, float %348)
store float %349, float* %31
%350 = load float, float* %26
%351 = load float, float* %32
%352 = load float, float* %36
%353 = call float @llvm.fmuladd.f32(float %350, float %351, float %352)
store float %353, float* %36
%354 = load float, float* %31
%355 = load float*, float** %16
%356 = getelementptr inbounds float, float* %355, i64 0
store float %354, float* %356
%357 = load float*, float** %16
%358 = getelementptr inbounds float, float* %357, i64 1
%359 = load float, float* %358
store float %359, float* %31
%360 = load float*, float** %17
%361 = getelementptr inbounds float, float* %360, i64 1
%362 = load float, float* %361
store float %362, float* %32
%363 = load float*, float** %13
%364 = getelementptr inbounds float, float* %363, i64 1
%365 = load float, float* %364
store float %365, float* %23
%366 = load float*, float** %13
%367 = getelementptr inbounds float, float* %366, i64 9
%368 = load float, float* %367
store float %368, float* %24
%369 = load float*, float** %13
%370 = getelementptr inbounds float, float* %369, i64 17
%371 = load float, float* %370
store float %371, float* %25
%372 = load float*, float** %13
%373 = getelementptr inbounds float, float* %372, i64 25
%374 = load float, float* %373
store float %374, float* %26
%375 = load float, float* %23
%376 = load float, float* %27
%377 = load float, float* %31
%378 = call float @llvm.fmuladd.f32(float %375, float %376, float %377)
store float %378, float* %31
%379 = load float, float* %23
%380 = load float, float* %32
%381 = load float, float* %33
%382 = call float @llvm.fmuladd.f32(float %379, float %380, float %381)
store float %382, float* %33
%383 = load float, float* %24
%384 = load float, float* %28
%385 = load float, float* %31
%386 = call float @llvm.fmuladd.f32(float %383, float %384, float %385)
store float %386, float* %31
%387 = load float, float* %24
%388 = load float, float* %32
%389 = load float, float* %34
%390 = call float @llvm.fmuladd.f32(float %387, float %388, float %389)
store float %390, float* %34
%391 = load float, float* %25
%392 = load float, float* %29
%393 = load float, float* %31
%394 = call float @llvm.fmuladd.f32(float %391, float %392, float %393)
store float %394, float* %31
%395 = load float, float* %25
%396 = load float, float* %32
%397 = load float, float* %35
%398 = call float @llvm.fmuladd.f32(float %395, float %396, float %397)
store float %398, float* %35
%399 = load float, float* %26
%400 = load float, float* %30
%401 = load float, float* %31
%402 = call float @llvm.fmuladd.f32(float %399, float %400, float %401)
store float %402, float* %31
%403 = load float, float* %26
%404 = load float, float* %32
%405 = load float, float* %36
%406 = call float @llvm.fmuladd.f32(float %403, float %404, float %405)
store float %406, float* %36
%407 = load float, float* %31
%408 = load float*, float** %16
%409 = getelementptr inbounds float, float* %408, i64 1
store float %407, float* %409
%410 = load float*, float** %16
%411 = getelementptr inbounds float, float* %410, i64 2
%412 = load float, float* %411
store float %412, float* %31
%413 = load float*, float** %17
%414 = getelementptr inbounds float, float* %413, i64 2
%415 = load float, float* %414
store float %415, float* %32
%416 = load float*, float** %13
%417 = getelementptr inbounds float, float* %416, i64 2
%418 = load float, float* %417
store float %418, float* %23
%419 = load float*, float** %13
%420 = getelementptr inbounds float, float* %419, i64 10
%421 = load float, float* %420
store float %421, float* %24
%422 = load float*, float** %13
%423 = getelementptr inbounds float, float* %422, i64 18
%424 = load float, float* %423
store float %424, float* %25
%425 = load float*, float** %13
%426 = getelementptr inbounds float, float* %425, i64 26
%427 = load float, float* %426
store float %427, float* %26
%428 = load float, float* %23
%429 = load float, float* %27
%430 = load float, float* %31
%431 = call float @llvm.fmuladd.f32(float %428, float %429, float %430)
store float %431, float* %31
%432 = load float, float* %23
%433 = load float, float* %32
%434 = load float, float* %33
%435 = call float @llvm.fmuladd.f32(float %432, float %433, float %434)
store float %435, float* %33
%436 = load float, float* %24
%437 = load float, float* %28
%438 = load float, float* %31
%439 = call float @llvm.fmuladd.f32(float %436, float %437, float %438)
store float %439, float* %31
%440 = load float, float* %24
%441 = load float, float* %32
%442 = load float, float* %34
%443 = call float @llvm.fmuladd.f32(float %440, float %441, float %442)
store float %443, float* %34
%444 = load float, float* %25
%445 = load float, float* %29
%446 = load float, float* %31
%447 = call float @llvm.fmuladd.f32(float %444, float %445, float %446)
store float %447, float* %31
%448 = load float, float* %25
%449 = load float, float* %32
%450 = load float, float* %35
%451 = call float @llvm.fmuladd.f32(float %448, float %449, float %450)
store float %451, float* %35
%452 = load float, float* %26
%453 = load float, float* %30
%454 = load float, float* %31
%455 = call float @llvm.fmuladd.f32(float %452, float %453, float %454)
store float %455, float* %31
%456 = load float, float* %26
%457 = load float, float* %32
%458 = load float, float* %36
%459 = call float @llvm.fmuladd.f32(float %456, float %457, float %458)
store float %459, float* %36
%460 = load float, float* %31
%461 = load float*, float** %16
%462 = getelementptr inbounds float, float* %461, i64 2
store float %460, float* %462
%463 = load float*, float** %16
%464 = getelementptr inbounds float, float* %463, i64 3
%465 = load float, float* %464
store float %465, float* %31
%466 = load float*, float** %17
%467 = getelementptr inbounds float, float* %466, i64 3
%468 = load float, float* %467
store float %468, float* %32
%469 = load float*, float** %13
%470 = getelementptr inbounds float, float* %469, i64 3
%471 = load float, float* %470
store float %471, float* %23
%472 = load float*, float** %13
%473 = getelementptr inbounds float, float* %472, i64 11
%474 = load float, float* %473
store float %474, float* %24
%475 = load float*, float** %13
%476 = getelementptr inbounds float, float* %475, i64 19
%477 = load float, float* %476
store float %477, float* %25
%478 = load float*, float** %13
%479 = getelementptr inbounds float, float* %478, i64 27
%480 = load float, float* %479
store float %480, float* %26
%481 = load float, float* %23
%482 = load float, float* %27
%483 = load float, float* %31
%484 = call float @llvm.fmuladd.f32(float %481, float %482, float %483)
store float %484, float* %31
%485 = load float, float* %23
%486 = load float, float* %32
%487 = load float, float* %33
%488 = call float @llvm.fmuladd.f32(float %485, float %486, float %487)
store float %488, float* %33
%489 = load float, float* %24
%490 = load float, float* %28
%491 = load float, float* %31
%492 = call float @llvm.fmuladd.f32(float %489, float %490, float %491)
store float %492, float* %31
%493 = load float, float* %24
%494 = load float, float* %32
%495 = load float, float* %34
%496 = call float @llvm.fmuladd.f32(float %493, float %494, float %495)
store float %496, float* %34
%497 = load float, float* %25
%498 = load float, float* %29
%499 = load float, float* %31
%500 = call float @llvm.fmuladd.f32(float %497, float %498, float %499)
store float %500, float* %31
%501 = load float, float* %25
%502 = load float, float* %32
%503 = load float, float* %35
%504 = call float @llvm.fmuladd.f32(float %501, float %502, float %503)
store float %504, float* %35
%505 = load float, float* %26
%506 = load float, float* %30
%507 = load float, float* %31
%508 = call float @llvm.fmuladd.f32(float %505, float %506, float %507)
store float %508, float* %31
%509 = load float, float* %26
%510 = load float, float* %32
%511 = load float, float* %36
%512 = call float @llvm.fmuladd.f32(float %509, float %510, float %511)
store float %512, float* %36
%513 = load float, float* %31
%514 = load float*, float** %16
%515 = getelementptr inbounds float, float* %514, i64 3
store float %513, float* %515
%516 = load float*, float** %16
%517 = getelementptr inbounds float, float* %516, i64 4
%518 = load float, float* %517
store float %518, float* %31
%519 = load float*, float** %17
%520 = getelementptr inbounds float, float* %519, i64 4
%521 = load float, float* %520
store float %521, float* %32
%522 = load float*, float** %13
%523 = getelementptr inbounds float, float* %522, i64 4
%524 = load float, float* %523
store float %524, float* %23
%525 = load float*, float** %13
%526 = getelementptr inbounds float, float* %525, i64 12
%527 = load float, float* %526
store float %527, float* %24
%528 = load float*, float** %13
%529 = getelementptr inbounds float, float* %528, i64 20
%530 = load float, float* %529
store float %530, float* %25
%531 = load float*, float** %13
%532 = getelementptr inbounds float, float* %531, i64 28
%533 = load float, float* %532
store float %533, float* %26
%534 = load float, float* %23
%535 = load float, float* %27
%536 = load float, float* %31
%537 = call float @llvm.fmuladd.f32(float %534, float %535, float %536)
store float %537, float* %31
%538 = load float, float* %23
%539 = load float, float* %32
%540 = load float, float* %33
%541 = call float @llvm.fmuladd.f32(float %538, float %539, float %540)
store float %541, float* %33
%542 = load float, float* %24
%543 = load float, float* %28
%544 = load float, float* %31
%545 = call float @llvm.fmuladd.f32(float %542, float %543, float %544)
store float %545, float* %31
%546 = load float, float* %24
%547 = load float, float* %32
%548 = load float, float* %34
%549 = call float @llvm.fmuladd.f32(float %546, float %547, float %548)
store float %549, float* %34
%550 = load float, float* %25
%551 = load float, float* %29
%552 = load float, float* %31
%553 = call float @llvm.fmuladd.f32(float %550, float %551, float %552)
store float %553, float* %31
%554 = load float, float* %25
%555 = load float, float* %32
%556 = load float, float* %35
%557 = call float @llvm.fmuladd.f32(float %554, float %555, float %556)
store float %557, float* %35
%558 = load float, float* %26
%559 = load float, float* %30
%560 = load float, float* %31
%561 = call float @llvm.fmuladd.f32(float %558, float %559, float %560)
store float %561, float* %31
%562 = load float, float* %26
%563 = load float, float* %32
%564 = load float, float* %36
%565 = call float @llvm.fmuladd.f32(float %562, float %563, float %564)
store float %565, float* %36
%566 = load float, float* %31
%567 = load float*, float** %16
%568 = getelementptr inbounds float, float* %567, i64 4
store float %566, float* %568
%569 = load float*, float** %16
%570 = getelementptr inbounds float, float* %569, i64 5
%571 = load float, float* %570
store float %571, float* %31
%572 = load float*, float** %17
%573 = getelementptr inbounds float, float* %572, i64 5
%574 = load float, float* %573
store float %574, float* %32
%575 = load float*, float** %13
%576 = getelementptr inbounds float, float* %575, i64 5
%577 = load float, float* %576
store float %577, float* %23
%578 = load float*, float** %13
%579 = getelementptr inbounds float, float* %578, i64 13
%580 = load float, float* %579
store float %580, float* %24
%581 = load float*, float** %13
%582 = getelementptr inbounds float, float* %581, i64 21
%583 = load float, float* %582
store float %583, float* %25
%584 = load float*, float** %13
%585 = getelementptr inbounds float, float* %584, i64 29
%586 = load float, float* %585
store float %586, float* %26
%587 = load float, float* %23
%588 = load float, float* %27
%589 = load float, float* %31
%590 = call float @llvm.fmuladd.f32(float %587, float %588, float %589)
store float %590, float* %31
%591 = load float, float* %23
%592 = load float, float* %32
%593 = load float, float* %33
%594 = call float @llvm.fmuladd.f32(float %591, float %592, float %593)
store float %594, float* %33
%595 = load float, float* %24
%596 = load float, float* %28
%597 = load float, float* %31
%598 = call float @llvm.fmuladd.f32(float %595, float %596, float %597)
store float %598, float* %31
%599 = load float, float* %24
%600 = load float, float* %32
%601 = load float, float* %34
%602 = call float @llvm.fmuladd.f32(float %599, float %600, float %601)
store float %602, float* %34
%603 = load float, float* %25
%604 = load float, float* %29
%605 = load float, float* %31
%606 = call float @llvm.fmuladd.f32(float %603, float %604, float %605)
store float %606, float* %31
%607 = load float, float* %25
%608 = load float, float* %32
%609 = load float, float* %35
%610 = call float @llvm.fmuladd.f32(float %607, float %608, float %609)
store float %610, float* %35
%611 = load float, float* %26
%612 = load float, float* %30
%613 = load float, float* %31
%614 = call float @llvm.fmuladd.f32(float %611, float %612, float %613)
store float %614, float* %31
%615 = load float, float* %26
%616 = load float, float* %32
%617 = load float, float* %36
%618 = call float @llvm.fmuladd.f32(float %615, float %616, float %617)
store float %618, float* %36
%619 = load float, float* %31
%620 = load float*, float** %16
%621 = getelementptr inbounds float, float* %620, i64 5
store float %619, float* %621
%622 = load float*, float** %16
%623 = getelementptr inbounds float, float* %622, i64 6
%624 = load float, float* %623
store float %624, float* %31
%625 = load float*, float** %17
%626 = getelementptr inbounds float, float* %625, i64 6
%627 = load float, float* %626
store float %627, float* %32
%628 = load float*, float** %13
%629 = getelementptr inbounds float, float* %628, i64 6
%630 = load float, float* %629
store float %630, float* %23
%631 = load float*, float** %13
%632 = getelementptr inbounds float, float* %631, i64 14
%633 = load float, float* %632
store float %633, float* %24
%634 = load float*, float** %13
%635 = getelementptr inbounds float, float* %634, i64 22
%636 = load float, float* %635
store float %636, float* %25
%637 = load float*, float** %13
%638 = getelementptr inbounds float, float* %637, i64 30
%639 = load float, float* %638
store float %639, float* %26
%640 = load float, float* %23
%641 = load float, float* %27
%642 = load float, float* %31
%643 = call float @llvm.fmuladd.f32(float %640, float %641, float %642)
store float %643, float* %31
%644 = load float, float* %23
%645 = load float, float* %32
%646 = load float, float* %33
%647 = call float @llvm.fmuladd.f32(float %644, float %645, float %646)
store float %647, float* %33
%648 = load float, float* %24
%649 = load float, float* %28
%650 = load float, float* %31
%651 = call float @llvm.fmuladd.f32(float %648, float %649, float %650)
store float %651, float* %31
%652 = load float, float* %24
%653 = load float, float* %32
%654 = load float, float* %34
%655 = call float @llvm.fmuladd.f32(float %652, float %653, float %654)
store float %655, float* %34
%656 = load float, float* %25
%657 = load float, float* %29
%658 = load float, float* %31
%659 = call float @llvm.fmuladd.f32(float %656, float %657, float %658)
store float %659, float* %31
%660 = load float, float* %25
%661 = load float, float* %32
%662 = load float, float* %35
%663 = call float @llvm.fmuladd.f32(float %660, float %661, float %662)
store float %663, float* %35
%664 = load float, float* %26
%665 = load float, float* %30
%666 = load float, float* %31
%667 = call float @llvm.fmuladd.f32(float %664, float %665, float %666)
store float %667, float* %31
%668 = load float, float* %26
%669 = load float, float* %32
%670 = load float, float* %36
%671 = call float @llvm.fmuladd.f32(float %668, float %669, float %670)
store float %671, float* %36
%672 = load float, float* %31
%673 = load float*, float** %16
%674 = getelementptr inbounds float, float* %673, i64 6
store float %672, float* %674
%675 = load float*, float** %16
%676 = getelementptr inbounds float, float* %675, i64 7
%677 = load float, float* %676
store float %677, float* %31
%678 = load float*, float** %17
%679 = getelementptr inbounds float, float* %678, i64 7
%680 = load float, float* %679
store float %680, float* %32
%681 = load float*, float** %13
%682 = getelementptr inbounds float, float* %681, i64 7
%683 = load float, float* %682
store float %683, float* %23
%684 = load float*, float** %13
%685 = getelementptr inbounds float, float* %684, i64 15
%686 = load float, float* %685
store float %686, float* %24
%687 = load float*, float** %13
%688 = getelementptr inbounds float, float* %687, i64 23
%689 = load float, float* %688
store float %689, float* %25
%690 = load float*, float** %13
%691 = getelementptr inbounds float, float* %690, i64 31
%692 = load float, float* %691
store float %692, float* %26
%693 = load float, float* %23
%694 = load float, float* %27
%695 = load float, float* %31
%696 = call float @llvm.fmuladd.f32(float %693, float %694, float %695)
store float %696, float* %31
%697 = load float, float* %23
%698 = load float, float* %32
%699 = load float, float* %33
%700 = call float @llvm.fmuladd.f32(float %697, float %698, float %699)
store float %700, float* %33
%701 = load float, float* %24
%702 = load float, float* %28
%703 = load float, float* %31
%704 = call float @llvm.fmuladd.f32(float %701, float %702, float %703)
store float %704, float* %31
%705 = load float, float* %24
%706 = load float, float* %32
%707 = load float, float* %34
%708 = call float @llvm.fmuladd.f32(float %705, float %706, float %707)
store float %708, float* %34
%709 = load float, float* %25
%710 = load float, float* %29
%711 = load float, float* %31
%712 = call float @llvm.fmuladd.f32(float %709, float %710, float %711)
store float %712, float* %31
%713 = load float, float* %25
%714 = load float, float* %32
%715 = load float, float* %35
%716 = call float @llvm.fmuladd.f32(float %713, float %714, float %715)
store float %716, float* %35
%717 = load float, float* %26
%718 = load float, float* %30
%719 = load float, float* %31
%720 = call float @llvm.fmuladd.f32(float %717, float %718, float %719)
store float %720, float* %31
%721 = load float, float* %26
%722 = load float, float* %32
%723 = load float, float* %36
%724 = call float @llvm.fmuladd.f32(float %721, float %722, float %723)
store float %724, float* %36
%725 = load float, float* %31
%726 = load float*, float** %16
%727 = getelementptr inbounds float, float* %726, i64 7
store float %725, float* %727
%728 = load i32, i32* %14
%729 = mul nsw i32 %728, 8
%730 = load float*, float** %13
%731 = sext i32 %729 to i64
%732 = getelementptr inbounds float, float* %730, i64 %731
store float* %732, float** %13
%733 = load float*, float** %16
%734 = getelementptr inbounds float, float* %733, i64 8
store float* %734, float** %16
%735 = load float*, float** %17
%736 = getelementptr inbounds float, float* %735, i64 8
store float* %736, float** %17
br label %737
737: ; preds = %303
%738 = load i32, i32* %22
%739 = add nsw i32 %738, 8
store i32 %739, i32* %22
br label %297
740: ; preds = %297
br label %741
741: ; preds = %805, %740
%742 = load i32, i32* %22
%743 = load i32, i32* %11
%744 = icmp slt i32 %742, %743
br i1 %744, label %745, label %808
745: ; preds = %741
%746 = load float*, float** %16
%747 = getelementptr inbounds float, float* %746, i64 0
%748 = load float, float* %747
store float %748, float* %31
%749 = load float*, float** %17
%750 = getelementptr inbounds float, float* %749, i64 0
%751 = load float, float* %750
store float %751, float* %32
%752 = load float*, float** %13
%753 = getelementptr inbounds float, float* %752, i64 0
%754 = load float, float* %753
store float %754, float* %23
%755 = load float*, float** %13
%756 = getelementptr inbounds float, float* %755, i64 8
%757 = load float, float* %756
store float %757, float* %24
%758 = load float*, float** %13
%759 = getelementptr inbounds float, float* %758, i64 16
%760 = load float, float* %759
store float %760, float* %25
%761 = load float*, float** %13
%762 = getelementptr inbounds float, float* %761, i64 24
%763 = load float, float* %762
store float %763, float* %26
%764 = load float, float* %23
%765 = load float, float* %27
%766 = load float, float* %31
%767 = call float @llvm.fmuladd.f32(float %764, float %765, float %766)
store float %767, float* %31
%768 = load float, float* %23
%769 = load float, float* %32
%770 = load float, float* %33
%771 = call float @llvm.fmuladd.f32(float %768, float %769, float %770)
store float %771, float* %33
%772 = load float, float* %24
%773 = load float, float* %28
%774 = load float, float* %31
%775 = call float @llvm.fmuladd.f32(float %772, float %773, float %774)
store float %775, float* %31
%776 = load float, float* %24
%777 = load float, float* %32
%778 = load float, float* %34
%779 = call float @llvm.fmuladd.f32(float %776, float %777, float %778)
store float %779, float* %34
%780 = load float, float* %25
%781 = load float, float* %29
%782 = load float, float* %31
%783 = call float @llvm.fmuladd.f32(float %780, float %781, float %782)
store float %783, float* %31
%784 = load float, float* %25
%785 = load float, float* %32
%786 = load float, float* %35
%787 = call float @llvm.fmuladd.f32(float %784, float %785, float %786)
store float %787, float* %35
%788 = load float, float* %26
%789 = load float, float* %30
%790 = load float, float* %31
%791 = call float @llvm.fmuladd.f32(float %788, float %789, float %790)
store float %791, float* %31
%792 = load float, float* %26
%793 = load float, float* %32
%794 = load float, float* %36
%795 = call float @llvm.fmuladd.f32(float %792, float %793, float %794)
store float %795, float* %36
%796 = load float, float* %31
%797 = load float*, float** %16
%798 = getelementptr inbounds float, float* %797, i64 0
store float %796, float* %798
%799 = load float*, float** %13
%800 = getelementptr inbounds float, float* %799, i64 1
store float* %800, float** %13
%801 = load float*, float** %16
%802 = getelementptr inbounds float, float* %801, i64 1
store float* %802, float** %16
%803 = load float*, float** %17
%804 = getelementptr inbounds float, float* %803, i64 1
store float* %804, float** %17
br label %805
805: ; preds = %745
%806 = load i32, i32* %22
%807 = add nsw i32 %806, 1
store i32 %807, i32* %22
br label %741
808: ; preds = %741
%809 = load i32, i32* %20
%810 = icmp eq i32 %809, 1
br i1 %810, label %811, label %832
811: ; preds = %808
%812 = load float, float* %33
%813 = load float*, float** %18
%814 = getelementptr inbounds float, float* %813, i64 0
%815 = load float, float* %814
%816 = fadd float %815, %812
store float %816, float* %814
%817 = load float, float* %34
%818 = load float*, float** %18
%819 = getelementptr inbounds float, float* %818, i64 1
%820 = load float, float* %819
%821 = fadd float %820, %817
store float %821, float* %819
%822 = load float, float* %35
%823 = load float*, float** %18
%824 = getelementptr inbounds float, float* %823, i64 2
%825 = load float, float* %824
%826 = fadd float %825, %822
store float %826, float* %824
%827 = load float, float* %36
%828 = load float*, float** %18
%829 = getelementptr inbounds float, float* %828, i64 3
%830 = load float, float* %829
%831 = fadd float %830, %827
store float %831, float* %829
br label %853
832: ; preds = %808
%833 = load float, float* %33
%834 = load float*, float** %18
%835 = getelementptr inbounds float, float* %834, i64 0
%836 = load float, float* %835
%837 = fsub float %836, %833
store float %837, float* %835
%838 = load float, float* %34
%839 = load float*, float** %18
%840 = getelementptr inbounds float, float* %839, i64 1
%841 = load float, float* %840
%842 = fsub float %841, %838
store float %842, float* %840
%843 = load float, float* %35
%844 = load float*, float** %18
%845 = getelementptr inbounds float, float* %844, i64 2
%846 = load float, float* %845
%847 = fsub float %846, %843
store float %847, float* %845
%848 = load float, float* %36
%849 = load float*, float** %18
%850 = getelementptr inbounds float, float* %849, i64 3
%851 = load float, float* %850
%852 = fsub float %851, %848
store float %852, float* %850
br label %853
853: ; preds = %39, %832, %811
ret void
}

LLVM IR (-O2):
define void @kernel_ssymv_4_lib8(i32 %0, i32 %1, float* %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 %422, 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 9
%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 10
%57 = load float, float* %56
%58 = getelementptr inbounds float, float* %2, i64 18
%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 11
%76 = load float, float* %75
%77 = getelementptr inbounds float, float* %2, i64 19
%78 = load float, float* %77
%79 = getelementptr inbounds float, float* %2, i64 27
%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 8
%118 = load float, float* %117
%119 = getelementptr inbounds float, float* %110, i64 16
%120 = load float, float* %119
%121 = getelementptr inbounds float, float* %110, i64 24
%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, 3
%150 = add i32 %149, -8
%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, -7
%155 = icmp slt i32 %145, %154
br i1 %155, label %156, label %160
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 %170
160: ; preds = %170, %141
%161 = phi float* [ %142, %141 ], [ %359, %170 ]
%162 = phi float* [ %143, %141 ], [ %358, %170 ]
%163 = phi float* [ %153, %141 ], [ %357, %170 ]
%164 = phi i32 [ %145, %141 ], [ %360, %170 ]
%165 = phi <4 x float> [ %146, %141 ], [ %356, %170 ]
%166 = icmp slt i32 %164, %0
br i1 %166, label %167, label %395
167: ; preds = %160
%168 = extractelement <2 x float> %33, i64 0
%169 = extractelement <2 x float> %33, i64 1
br label %362
170: ; preds = %156, %170
%171 = phi i32 [ %145, %156 ], [ %360, %170 ]
%172 = phi float* [ %153, %156 ], [ %357, %170 ]
%173 = phi float* [ %143, %156 ], [ %358, %170 ]
%174 = phi float* [ %142, %156 ], [ %359, %170 ]
%175 = phi <4 x float> [ %146, %156 ], [ %356, %170 ]
%176 = load float, float* %173
%177 = load float, float* %174
%178 = load float, float* %172
%179 = getelementptr inbounds float, float* %172, i64 8
%180 = load float, float* %179
%181 = getelementptr inbounds float, float* %172, i64 16
%182 = load float, float* %181
%183 = getelementptr inbounds float, float* %172, i64 24
%184 = load float, float* %183
%185 = tail call float @llvm.fmuladd.f32(float %178, float %31, float %176)
%186 = tail call float @llvm.fmuladd.f32(float %180, float %32, float %185)
%187 = tail call float @llvm.fmuladd.f32(float %182, float %158, float %186)
%188 = tail call float @llvm.fmuladd.f32(float %184, float %159, float %187)
%189 = insertelement <4 x float> poison, float %178, i64 0
%190 = insertelement <4 x float> %189, float %180, i64 1
%191 = insertelement <4 x float> %190, float %182, i64 2
%192 = insertelement <4 x float> %191, float %184, i64 3
%193 = insertelement <4 x float> poison, float %177, i64 0
%194 = shufflevector <4 x float> %193, <4 x float> poison, <4 x i32> zeroinitializer
%195 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %192, <4 x float> %194, <4 x float> %175)
store float %188, float* %173
%196 = getelementptr inbounds float, float* %173, i64 1
%197 = load float, float* %196
%198 = getelementptr inbounds float, float* %174, i64 1
%199 = load float, float* %198
%200 = getelementptr inbounds float, float* %172, i64 1
%201 = load float, float* %200
%202 = getelementptr inbounds float, float* %172, i64 9
%203 = load float, float* %202
%204 = getelementptr inbounds float, float* %172, i64 17
%205 = load float, float* %204
%206 = getelementptr inbounds float, float* %172, i64 25
%207 = load float, float* %206
%208 = tail call float @llvm.fmuladd.f32(float %201, float %31, float %197)
%209 = tail call float @llvm.fmuladd.f32(float %203, float %32, float %208)
%210 = tail call float @llvm.fmuladd.f32(float %205, float %158, float %209)
%211 = tail call float @llvm.fmuladd.f32(float %207, float %159, float %210)
%212 = insertelement <4 x float> poison, float %201, i64 0
%213 = insertelement <4 x float> %212, float %203, i64 1
%214 = insertelement <4 x float> %213, float %205, i64 2
%215 = insertelement <4 x float> %214, float %207, i64 3
%216 = insertelement <4 x float> poison, float %199, i64 0
%217 = shufflevector <4 x float> %216, <4 x float> poison, <4 x i32> zeroinitializer
%218 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %215, <4 x float> %217, <4 x float> %195)
store float %211, float* %196
%219 = getelementptr inbounds float, float* %173, i64 2
%220 = load float, float* %219
%221 = getelementptr inbounds float, float* %174, i64 2
%222 = load float, float* %221
%223 = getelementptr inbounds float, float* %172, i64 2
%224 = load float, float* %223
%225 = getelementptr inbounds float, float* %172, i64 10
%226 = load float, float* %225
%227 = getelementptr inbounds float, float* %172, i64 18
%228 = load float, float* %227
%229 = getelementptr inbounds float, float* %172, i64 26
%230 = load float, float* %229
%231 = tail call float @llvm.fmuladd.f32(float %224, float %31, float %220)
%232 = tail call float @llvm.fmuladd.f32(float %226, float %32, float %231)
%233 = tail call float @llvm.fmuladd.f32(float %228, float %158, float %232)
%234 = tail call float @llvm.fmuladd.f32(float %230, float %159, float %233)
%235 = insertelement <4 x float> poison, float %224, i64 0
%236 = insertelement <4 x float> %235, float %226, i64 1
%237 = insertelement <4 x float> %236, float %228, i64 2
%238 = insertelement <4 x float> %237, float %230, i64 3
%239 = insertelement <4 x float> poison, float %222, i64 0
%240 = shufflevector <4 x float> %239, <4 x float> poison, <4 x i32> zeroinitializer
%241 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %238, <4 x float> %240, <4 x float> %218)
store float %234, float* %219
%242 = getelementptr inbounds float, float* %173, i64 3
%243 = load float, float* %242
%244 = getelementptr inbounds float, float* %174, i64 3
%245 = load float, float* %244
%246 = getelementptr inbounds float, float* %172, i64 3
%247 = load float, float* %246
%248 = getelementptr inbounds float, float* %172, i64 11
%249 = load float, float* %248
%250 = getelementptr inbounds float, float* %172, i64 19
%251 = load float, float* %250
%252 = getelementptr inbounds float, float* %172, i64 27
%253 = load float, float* %252
%254 = tail call float @llvm.fmuladd.f32(float %247, float %31, float %243)
%255 = tail call float @llvm.fmuladd.f32(float %249, float %32, float %254)
%256 = tail call float @llvm.fmuladd.f32(float %251, float %158, float %255)
%257 = tail call float @llvm.fmuladd.f32(float %253, float %159, float %256)
%258 = insertelement <4 x float> poison, float %247, i64 0
%259 = insertelement <4 x float> %258, float %249, i64 1
%260 = insertelement <4 x float> %259, float %251, i64 2
%261 = insertelement <4 x float> %260, float %253, i64 3
%262 = insertelement <4 x float> poison, float %245, i64 0
%263 = shufflevector <4 x float> %262, <4 x float> poison, <4 x i32> zeroinitializer
%264 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %261, <4 x float> %263, <4 x float> %241)
store float %257, float* %242
%265 = getelementptr inbounds float, float* %173, i64 4
%266 = load float, float* %265
%267 = getelementptr inbounds float, float* %174, i64 4
%268 = load float, float* %267
%269 = getelementptr inbounds float, float* %172, i64 4
%270 = load float, float* %269
%271 = getelementptr inbounds float, float* %172, i64 12
%272 = load float, float* %271
%273 = getelementptr inbounds float, float* %172, i64 20
%274 = load float, float* %273
%275 = getelementptr inbounds float, float* %172, i64 28
%276 = load float, float* %275
%277 = tail call float @llvm.fmuladd.f32(float %270, float %31, float %266)
%278 = tail call float @llvm.fmuladd.f32(float %272, float %32, float %277)
%279 = tail call float @llvm.fmuladd.f32(float %274, float %158, float %278)
%280 = tail call float @llvm.fmuladd.f32(float %276, float %159, float %279)
%281 = insertelement <4 x float> poison, float %270, i64 0
%282 = insertelement <4 x float> %281, float %272, i64 1
%283 = insertelement <4 x float> %282, float %274, i64 2
%284 = insertelement <4 x float> %283, float %276, i64 3
%285 = insertelement <4 x float> poison, float %268, i64 0
%286 = shufflevector <4 x float> %285, <4 x float> poison, <4 x i32> zeroinitializer
%287 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %284, <4 x float> %286, <4 x float> %264)
store float %280, float* %265
%288 = getelementptr inbounds float, float* %173, i64 5
%289 = load float, float* %288
%290 = getelementptr inbounds float, float* %174, i64 5
%291 = load float, float* %290
%292 = getelementptr inbounds float, float* %172, i64 5
%293 = load float, float* %292
%294 = getelementptr inbounds float, float* %172, i64 13
%295 = load float, float* %294
%296 = getelementptr inbounds float, float* %172, i64 21
%297 = load float, float* %296
%298 = getelementptr inbounds float, float* %172, i64 29
%299 = load float, float* %298
%300 = tail call float @llvm.fmuladd.f32(float %293, float %31, float %289)
%301 = tail call float @llvm.fmuladd.f32(float %295, float %32, float %300)
%302 = tail call float @llvm.fmuladd.f32(float %297, float %158, float %301)
%303 = tail call float @llvm.fmuladd.f32(float %299, float %159, float %302)
%304 = insertelement <4 x float> poison, float %293, i64 0
%305 = insertelement <4 x float> %304, float %295, i64 1
%306 = insertelement <4 x float> %305, float %297, i64 2
%307 = insertelement <4 x float> %306, float %299, i64 3
%308 = insertelement <4 x float> poison, float %291, i64 0
%309 = shufflevector <4 x float> %308, <4 x float> poison, <4 x i32> zeroinitializer
%310 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %307, <4 x float> %309, <4 x float> %287)
store float %303, float* %288
%311 = getelementptr inbounds float, float* %173, i64 6
%312 = load float, float* %311
%313 = getelementptr inbounds float, float* %174, i64 6
%314 = load float, float* %313
%315 = getelementptr inbounds float, float* %172, i64 6
%316 = load float, float* %315
%317 = getelementptr inbounds float, float* %172, i64 14
%318 = load float, float* %317
%319 = getelementptr inbounds float, float* %172, i64 22
%320 = load float, float* %319
%321 = getelementptr inbounds float, float* %172, i64 30
%322 = load float, float* %321
%323 = tail call float @llvm.fmuladd.f32(float %316, float %31, float %312)
%324 = tail call float @llvm.fmuladd.f32(float %318, float %32, float %323)
%325 = tail call float @llvm.fmuladd.f32(float %320, float %158, float %324)
%326 = tail call float @llvm.fmuladd.f32(float %322, float %159, float %325)
%327 = insertelement <4 x float> poison, float %316, i64 0
%328 = insertelement <4 x float> %327, float %318, i64 1
%329 = insertelement <4 x float> %328, float %320, i64 2
%330 = insertelement <4 x float> %329, float %322, i64 3
%331 = insertelement <4 x float> poison, float %314, i64 0
%332 = shufflevector <4 x float> %331, <4 x float> poison, <4 x i32> zeroinitializer
%333 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %330, <4 x float> %332, <4 x float> %310)
store float %326, float* %311
%334 = getelementptr inbounds float, float* %173, i64 7
%335 = load float, float* %334
%336 = getelementptr inbounds float, float* %174, i64 7
%337 = load float, float* %336
%338 = getelementptr inbounds float, float* %172, i64 7
%339 = load float, float* %338
%340 = getelementptr inbounds float, float* %172, i64 15
%341 = load float, float* %340
%342 = getelementptr inbounds float, float* %172, i64 23
%343 = load float, float* %342
%344 = getelementptr inbounds float, float* %172, i64 31
%345 = load float, float* %344
%346 = tail call float @llvm.fmuladd.f32(float %339, float %31, float %335)
%347 = tail call float @llvm.fmuladd.f32(float %341, float %32, float %346)
%348 = tail call float @llvm.fmuladd.f32(float %343, float %158, float %347)
%349 = tail call float @llvm.fmuladd.f32(float %345, float %159, float %348)
%350 = insertelement <4 x float> poison, float %339, i64 0
%351 = insertelement <4 x float> %350, float %341, i64 1
%352 = insertelement <4 x float> %351, float %343, i64 2
%353 = insertelement <4 x float> %352, float %345, i64 3
%354 = insertelement <4 x float> poison, float %337, i64 0
%355 = shufflevector <4 x float> %354, <4 x float> poison, <4 x i32> zeroinitializer
%356 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %353, <4 x float> %355, <4 x float> %333)
store float %349, float* %334
%357 = getelementptr inbounds float, float* %172, i64 %157
%358 = getelementptr inbounds float, float* %173, i64 8
%359 = getelementptr inbounds float, float* %174, i64 8
%360 = add nuw nsw i32 %171, 8
%361 = icmp slt i32 %360, %154
br i1 %361, label %170, label %160
362: ; preds = %167, %362
%363 = phi i32 [ %391, %362 ], [ %164, %167 ]
%364 = phi float* [ %388, %362 ], [ %163, %167 ]
%365 = phi float* [ %389, %362 ], [ %162, %167 ]
%366 = phi float* [ %390, %362 ], [ %161, %167 ]
%367 = phi <4 x float> [ %387, %362 ], [ %165, %167 ]
%368 = load float, float* %365
%369 = load float, float* %366
%370 = load float, float* %364
%371 = getelementptr inbounds float, float* %364, i64 8
%372 = load float, float* %371
%373 = getelementptr inbounds float, float* %364, i64 16
%374 = load float, float* %373
%375 = getelementptr inbounds float, float* %364, i64 24
%376 = load float, float* %375
%377 = tail call float @llvm.fmuladd.f32(float %370, float %31, float %368)
%378 = tail call float @llvm.fmuladd.f32(float %372, float %32, float %377)
%379 = tail call float @llvm.fmuladd.f32(float %374, float %168, float %378)
%380 = tail call float @llvm.fmuladd.f32(float %376, float %169, float %379)
%381 = insertelement <4 x float> poison, float %370, i64 0
%382 = insertelement <4 x float> %381, float %372, i64 1
%383 = insertelement <4 x float> %382, float %374, i64 2
%384 = insertelement <4 x float> %383, float %376, i64 3
%385 = insertelement <4 x float> poison, float %369, i64 0
%386 = shufflevector <4 x float> %385, <4 x float> poison, <4 x i32> zeroinitializer
%387 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %384, <4 x float> %386, <4 x float> %367)
store float %380, float* %365
%388 = getelementptr inbounds float, float* %364, i64 1
%389 = getelementptr inbounds float, float* %365, i64 1
%390 = getelementptr inbounds float, float* %366, i64 1
%391 = add nuw nsw i32 %363, 1
%392 = icmp eq i32 %391, %0
br i1 %392, label %393, label %362
393: ; preds = %362
%394 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %384, <4 x float> %386, <4 x float> %367)
br label %395
395: ; preds = %393, %160
%396 = phi <4 x float> [ %165, %160 ], [ %394, %393 ]
%397 = load float, float* %7
br i1 %13, label %398, label %410
398: ; preds = %395
%399 = getelementptr inbounds float, float* %7, i64 1
%400 = load float, float* %399
%401 = getelementptr inbounds float, float* %7, i64 2
%402 = bitcast float* %401 to <2 x float>*
%403 = load <2 x float>, <2 x float>* %402
%404 = insertelement <4 x float> poison, float %397, i64 0
%405 = insertelement <4 x float> %404, float %400, i64 1
%406 = shufflevector <2 x float> %403, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%407 = shufflevector <4 x float> %405, <4 x float> %406, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%408 = fadd <4 x float> %396, %407
%409 = bitcast float* %7 to <4 x float>*
store <4 x float> %408, <4 x float>* %409
br label %422
410: ; preds = %395
%411 = getelementptr inbounds float, float* %7, i64 1
%412 = load float, float* %411
%413 = getelementptr inbounds float, float* %7, i64 2
%414 = bitcast float* %413 to <2 x float>*
%415 = load <2 x float>, <2 x float>* %414
%416 = insertelement <4 x float> poison, float %397, i64 0
%417 = insertelement <4 x float> %416, float %412, i64 1
%418 = shufflevector <2 x float> %415, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
%419 = shufflevector <4 x float> %417, <4 x float> %418, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%420 = fsub <4 x float> %419, %396
%421 = bitcast float* %7 to <4 x float>*
store <4 x float> %420, <4 x float>* %421
br label %422
422: ; preds = %398, %410, %10
ret void
}