void kernel_sgemm_nn_4x4_vs_lib4(int kmax, float *alpha, float *A, float *B,
                                 int sdb, float *beta, float *C, float *D,
                                 int km, int kn) {
  const int bs = 4;
  float a_0, a_1, a_2, a_3, b_0, b_1, b_2, b_3,
      c_00 = 0, c_01 = 0, c_02 = 0, c_03 = 0, c_10 = 0, c_11 = 0, c_12 = 0,
      c_13 = 0, c_20 = 0, c_21 = 0, c_22 = 0, c_23 = 0, c_30 = 0, c_31 = 0,
      c_32 = 0, c_33 = 0;
  int k;
  for (k = 0; k < kmax - 3; k += 4) {
    a_0 = A[0];
    a_1 = A[1];
    a_2 = A[2];
    a_3 = A[3];
    b_0 = B[0];
    b_1 = B[4];
    b_2 = B[8];
    b_3 = B[12];
    c_00 += a_0 * b_0;
    c_10 += a_1 * b_0;
    c_20 += a_2 * b_0;
    c_30 += a_3 * b_0;
    c_01 += a_0 * b_1;
    c_11 += a_1 * b_1;
    c_21 += a_2 * b_1;
    c_31 += a_3 * b_1;
    c_02 += a_0 * b_2;
    c_12 += a_1 * b_2;
    c_22 += a_2 * b_2;
    c_32 += a_3 * b_2;
    c_03 += a_0 * b_3;
    c_13 += a_1 * b_3;
    c_23 += a_2 * b_3;
    c_33 += a_3 * b_3;
    a_0 = A[4];
    a_1 = A[5];
    a_2 = A[6];
    a_3 = A[7];
    b_0 = B[1];
    b_1 = B[5];
    b_2 = B[9];
    b_3 = B[13];
    c_00 += a_0 * b_0;
    c_10 += a_1 * b_0;
    c_20 += a_2 * b_0;
    c_30 += a_3 * b_0;
    c_01 += a_0 * b_1;
    c_11 += a_1 * b_1;
    c_21 += a_2 * b_1;
    c_31 += a_3 * b_1;
    c_02 += a_0 * b_2;
    c_12 += a_1 * b_2;
    c_22 += a_2 * b_2;
    c_32 += a_3 * b_2;
    c_03 += a_0 * b_3;
    c_13 += a_1 * b_3;
    c_23 += a_2 * b_3;
    c_33 += a_3 * b_3;
    a_0 = A[8];
    a_1 = A[9];
    a_2 = A[10];
    a_3 = A[11];
    b_0 = B[2];
    b_1 = B[6];
    b_2 = B[10];
    b_3 = B[14];
    c_00 += a_0 * b_0;
    c_10 += a_1 * b_0;
    c_20 += a_2 * b_0;
    c_30 += a_3 * b_0;
    c_01 += a_0 * b_1;
    c_11 += a_1 * b_1;
    c_21 += a_2 * b_1;
    c_31 += a_3 * b_1;
    c_02 += a_0 * b_2;
    c_12 += a_1 * b_2;
    c_22 += a_2 * b_2;
    c_32 += a_3 * b_2;
    c_03 += a_0 * b_3;
    c_13 += a_1 * b_3;
    c_23 += a_2 * b_3;
    c_33 += a_3 * b_3;
    a_0 = A[12];
    a_1 = A[13];
    a_2 = A[14];
    a_3 = A[15];
    b_0 = B[3];
    b_1 = B[7];
    b_2 = B[11];
    b_3 = B[15];
    c_00 += a_0 * b_0;
    c_10 += a_1 * b_0;
    c_20 += a_2 * b_0;
    c_30 += a_3 * b_0;
    c_01 += a_0 * b_1;
    c_11 += a_1 * b_1;
    c_21 += a_2 * b_1;
    c_31 += a_3 * b_1;
    c_02 += a_0 * b_2;
    c_12 += a_1 * b_2;
    c_22 += a_2 * b_2;
    c_32 += a_3 * b_2;
    c_03 += a_0 * b_3;
    c_13 += a_1 * b_3;
    c_23 += a_2 * b_3;
    c_33 += a_3 * b_3;
    A += 16;
    B += 4 * sdb;
  }
  for (; k < kmax; k++) {
    a_0 = A[0];
    a_1 = A[1];
    a_2 = A[2];
    a_3 = A[3];
    b_0 = B[0];
    b_1 = B[4];
    b_2 = B[8];
    b_3 = B[12];
    c_00 += a_0 * b_0;
    c_10 += a_1 * b_0;
    c_20 += a_2 * b_0;
    c_30 += a_3 * b_0;
    c_01 += a_0 * b_1;
    c_11 += a_1 * b_1;
    c_21 += a_2 * b_1;
    c_31 += a_3 * b_1;
    c_02 += a_0 * b_2;
    c_12 += a_1 * b_2;
    c_22 += a_2 * b_2;
    c_32 += a_3 * b_2;
    c_03 += a_0 * b_3;
    c_13 += a_1 * b_3;
    c_23 += a_2 * b_3;
    c_33 += a_3 * b_3;
    A += 4;
    B += 1;
  }
  c_00 = beta[0] * C[0 + bs * 0] + alpha[0] * c_00;
  c_10 = beta[0] * C[1 + bs * 0] + alpha[0] * c_10;
  c_20 = beta[0] * C[2 + bs * 0] + alpha[0] * c_20;
  c_30 = beta[0] * C[3 + bs * 0] + alpha[0] * c_30;
  c_01 = beta[0] * C[0 + bs * 1] + alpha[0] * c_01;
  c_11 = beta[0] * C[1 + bs * 1] + alpha[0] * c_11;
  c_21 = beta[0] * C[2 + bs * 1] + alpha[0] * c_21;
  c_31 = beta[0] * C[3 + bs * 1] + alpha[0] * c_31;
  c_02 = beta[0] * C[0 + bs * 2] + alpha[0] * c_02;
  c_12 = beta[0] * C[1 + bs * 2] + alpha[0] * c_12;
  c_22 = beta[0] * C[2 + bs * 2] + alpha[0] * c_22;
  c_32 = beta[0] * C[3 + bs * 2] + alpha[0] * c_32;
  c_03 = beta[0] * C[0 + bs * 3] + alpha[0] * c_03;
  c_13 = beta[0] * C[1 + bs * 3] + alpha[0] * c_13;
  c_23 = beta[0] * C[2 + bs * 3] + alpha[0] * c_23;
  c_33 = beta[0] * C[3 + bs * 3] + alpha[0] * c_33;
store:
  if (km >= 4) {
    D[0 + bs * 0] = c_00;
    D[1 + bs * 0] = c_10;
    D[2 + bs * 0] = c_20;
    D[3 + bs * 0] = c_30;
    if (kn == 1)
      return;
    D[0 + bs * 1] = c_01;
    D[1 + bs * 1] = c_11;
    D[2 + bs * 1] = c_21;
    D[3 + bs * 1] = c_31;
    if (kn == 2)
      return;
    D[0 + bs * 2] = c_02;
    D[1 + bs * 2] = c_12;
    D[2 + bs * 2] = c_22;
    D[3 + bs * 2] = c_32;
    if (kn == 3)
      return;
    D[0 + bs * 3] = c_03;
    D[1 + bs * 3] = c_13;
    D[2 + bs * 3] = c_23;
    D[3 + bs * 3] = c_33;
  } else if (km >= 3) {
    D[0 + bs * 0] = c_00;
    D[1 + bs * 0] = c_10;
    D[2 + bs * 0] = c_20;
    if (kn == 1)
      return;
    D[0 + bs * 1] = c_01;
    D[1 + bs * 1] = c_11;
    D[2 + bs * 1] = c_21;
    if (kn == 2)
      return;
    D[0 + bs * 2] = c_02;
    D[1 + bs * 2] = c_12;
    D[2 + bs * 2] = c_22;
    if (kn == 3)
      return;
    D[0 + bs * 3] = c_03;
    D[1 + bs * 3] = c_13;
    D[2 + bs * 3] = c_23;
  } else if (km >= 2) {
    D[0 + bs * 0] = c_00;
    D[1 + bs * 0] = c_10;
    if (kn == 1)
      return;
    D[0 + bs * 1] = c_01;
    D[1 + bs * 1] = c_11;
    if (kn == 2)
      return;
    D[0 + bs * 2] = c_02;
    D[1 + bs * 2] = c_12;
    if (kn == 3)
      return;
    D[0 + bs * 3] = c_03;
    D[1 + bs * 3] = c_13;
  } else {
    D[0 + bs * 0] = c_00;
    if (kn == 1)
      return;
    D[0 + bs * 1] = c_01;
    if (kn == 2)
      return;
    D[0 + bs * 2] = c_02;
    if (kn == 3)
      return;
    D[0 + bs * 3] = c_03;
  }
}


x86 assembly (clang, -O0):
<kernel_sgemm_nn_4x4_vs_lib4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x4,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1b4f <kernel_sgemm_nn_4x4_vs_lib4+0xa4f>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x18(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x18(%rbp)
mov    -0x24(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x98(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x98(%rbp)
jmp    11cd <kernel_sgemm_nn_4x4_vs_lib4+0xcd>
jmp    1b54 <kernel_sgemm_nn_4x4_vs_lib4+0xa54>
mov    -0x98(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1ddb <kernel_sgemm_nn_4x4_vs_lib4+0xcdb>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x38(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x38(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x44(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
movss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1b54 <kernel_sgemm_nn_4x4_vs_lib4+0xa54>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x78(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x88(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x6c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x8c(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x80(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x30(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x64(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x74(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mulss  -0x94(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
cmpl   $0x4,0x20(%rbp)
jl     21d2 <kernel_sgemm_nn_4x4_vs_lib4+0x10d2>
movss  -0x58(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x78(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x88(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0xc(%rax)
cmpl   $0x1,0x28(%rbp)
jne    20fb <kernel_sgemm_nn_4x4_vs_lib4+0xffb>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x5c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x6c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x7c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x8c(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x1c(%rax)
cmpl   $0x2,0x28(%rbp)
jne    2145 <kernel_sgemm_nn_4x4_vs_lib4+0x1045>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x80(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x90(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x2c(%rax)
cmpl   $0x3,0x28(%rbp)
jne    218f <kernel_sgemm_nn_4x4_vs_lib4+0x108f>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x64(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0x74(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  -0x84(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x38(%rax)
movss  -0x94(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x3c(%rax)
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
cmpl   $0x3,0x20(%rbp)
jl     22b8 <kernel_sgemm_nn_4x4_vs_lib4+0x11b8>
movss  -0x58(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x78(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
cmpl   $0x1,0x28(%rbp)
jne    2214 <kernel_sgemm_nn_4x4_vs_lib4+0x1114>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x5c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x6c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x7c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
cmpl   $0x2,0x28(%rbp)
jne    224d <kernel_sgemm_nn_4x4_vs_lib4+0x114d>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x80(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x28(%rax)
cmpl   $0x3,0x28(%rbp)
jne    2286 <kernel_sgemm_nn_4x4_vs_lib4+0x1186>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x64(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0x74(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  -0x84(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x38(%rax)
jmp    23cc <kernel_sgemm_nn_4x4_vs_lib4+0x12cc>
cmpl   $0x2,0x20(%rbp)
jl     2363 <kernel_sgemm_nn_4x4_vs_lib4+0x1263>
movss  -0x58(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
cmpl   $0x1,0x28(%rbp)
jne    22ec <kernel_sgemm_nn_4x4_vs_lib4+0x11ec>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x5c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x6c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
cmpl   $0x2,0x28(%rbp)
jne    2317 <kernel_sgemm_nn_4x4_vs_lib4+0x1217>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x24(%rax)
cmpl   $0x3,0x28(%rbp)
jne    2342 <kernel_sgemm_nn_4x4_vs_lib4+0x1242>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x64(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0x74(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x34(%rax)
jmp    23c7 <kernel_sgemm_nn_4x4_vs_lib4+0x12c7>
movss  -0x58(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
cmpl   $0x1,0x28(%rbp)
jne    237f <kernel_sgemm_nn_4x4_vs_lib4+0x127f>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x5c(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
cmpl   $0x2,0x28(%rbp)
jne    239c <kernel_sgemm_nn_4x4_vs_lib4+0x129c>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x20(%rax)
cmpl   $0x3,0x28(%rbp)
jne    23b9 <kernel_sgemm_nn_4x4_vs_lib4+0x12b9>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
movss  -0x64(%rbp),%xmm0
mov    0x18(%rbp),%rax
movss  %xmm0,0x30(%rax)
jmp    23cc <kernel_sgemm_nn_4x4_vs_lib4+0x12cc>
jmp    23d1 <kernel_sgemm_nn_4x4_vs_lib4+0x12d1>
add    $0x18,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel_sgemm_nn_4x4_vs_lib4>:
cmp    $0x4,%edi
jl     12cf <kernel_sgemm_nn_4x4_vs_lib4+0x1cf>
lea    -0x3(%rdi),%r10d
shl    $0x2,%r8d
movslq %r8d,%r8
shl    $0x2,%r8
xorps  %xmm10,%xmm10
xor    %eax,%eax
xorps  %xmm4,%xmm4
xorps  %xmm2,%xmm2
xorps  %xmm13,%xmm13
xorps  %xmm14,%xmm14
nopl   0x0(%rax)
movsd  (%rdx),%xmm11
movsd  0x8(%rdx),%xmm12
movsd  0x10(%rdx),%xmm9
movups (%rdx),%xmm1
movss  (%rcx),%xmm6
movss  0x4(%rcx),%xmm0
movss  0x8(%rcx),%xmm5
movss  0xc(%rcx),%xmm8
shufps $0x0,%xmm6,%xmm6
mulps  %xmm1,%xmm6
addps  %xmm14,%xmm6
movss  0x10(%rcx),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm1,%xmm3
addps  %xmm13,%xmm3
movss  0x20(%rcx),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm1,%xmm7
addps  %xmm2,%xmm7
movss  0x30(%rcx),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm11
addps  %xmm10,%xmm11
mulps  %xmm12,%xmm1
addps  %xmm4,%xmm1
movsd  0x18(%rdx),%xmm10
movups 0x10(%rdx),%xmm2
shufps $0x0,%xmm0,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm6,%xmm0
movss  0x14(%rcx),%xmm4
shufps $0x0,%xmm4,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm3,%xmm4
movss  0x24(%rcx),%xmm3
shufps $0x0,%xmm3,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm7,%xmm3
movss  0x34(%rcx),%xmm2
shufps $0x0,%xmm2,%xmm2
mulps  %xmm2,%xmm9
addps  %xmm11,%xmm9
mulps  %xmm10,%xmm2
addps  %xmm1,%xmm2
movsd  0x20(%rdx),%xmm6
movsd  0x28(%rdx),%xmm10
movups 0x20(%rdx),%xmm1
shufps $0x0,%xmm5,%xmm5
mulps  %xmm1,%xmm5
addps  %xmm0,%xmm5
movss  0x18(%rcx),%xmm7
shufps $0x0,%xmm7,%xmm7
mulps  %xmm1,%xmm7
addps  %xmm4,%xmm7
movss  0x28(%rcx),%xmm0
shufps $0x0,%xmm0,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm3,%xmm0
movss  0x38(%rcx),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm6
addps  %xmm9,%xmm6
mulps  %xmm10,%xmm1
addps  %xmm2,%xmm1
movsd  0x30(%rdx),%xmm9
movsd  0x38(%rdx),%xmm3
movups 0x30(%rdx),%xmm2
shufps $0x0,%xmm8,%xmm8
mulps  %xmm2,%xmm8
movaps %xmm8,%xmm14
addps  %xmm5,%xmm14
movss  0x1c(%rcx),%xmm15
shufps $0x0,%xmm15,%xmm15
mulps  %xmm2,%xmm15
movaps %xmm15,%xmm13
addps  %xmm7,%xmm13
movss  0x2c(%rcx),%xmm12
shufps $0x0,%xmm12,%xmm12
mulps  %xmm2,%xmm12
movaps %xmm12,%xmm2
addps  %xmm0,%xmm2
movss  0x3c(%rcx),%xmm11
shufps $0x0,%xmm11,%xmm11
mulps  %xmm11,%xmm9
movaps %xmm9,%xmm10
addps  %xmm6,%xmm10
mulps  %xmm3,%xmm11
movaps %xmm11,%xmm4
addps  %xmm1,%xmm4
add    $0x40,%rdx
add    $0x4,%eax
add    %r8,%rcx
cmp    %r10d,%eax
jl     1130 <kernel_sgemm_nn_4x4_vs_lib4+0x30>
addps  %xmm1,%xmm11
addps  %xmm6,%xmm9
addps  %xmm0,%xmm12
addps  %xmm7,%xmm15
addps  %xmm5,%xmm8
mov    %edi,%eax
and    $0xfffffffc,%eax
jmp    12e5 <kernel_sgemm_nn_4x4_vs_lib4+0x1e5>
xorps  %xmm9,%xmm9
xor    %eax,%eax
xorps  %xmm11,%xmm11
xorps  %xmm12,%xmm12
xorps  %xmm15,%xmm15
xorps  %xmm8,%xmm8
mov    0x18(%rsp),%r8d
mov    0x8(%rsp),%r10
cmp    %edi,%eax
jge    13b6 <kernel_sgemm_nn_4x4_vs_lib4+0x2b6>
sub    %eax,%edi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movaps %xmm8,%xmm10
movaps %xmm15,%xmm13
movaps %xmm12,%xmm14
movaps %xmm11,%xmm1
movaps %xmm9,%xmm0
movsd  (%rdx),%xmm7
movsd  0x8(%rdx),%xmm11
movups (%rdx),%xmm6
movss  (%rcx,%rax,4),%xmm5
movss  0x10(%rcx,%rax,4),%xmm2
movss  0x20(%rcx,%rax,4),%xmm3
movss  0x30(%rcx,%rax,4),%xmm4
shufps $0x0,%xmm5,%xmm5
mulps  %xmm6,%xmm5
movaps %xmm5,%xmm8
addps  %xmm10,%xmm8
shufps $0x0,%xmm2,%xmm2
mulps  %xmm6,%xmm2
movaps %xmm2,%xmm15
addps  %xmm13,%xmm15
shufps $0x0,%xmm3,%xmm3
mulps  %xmm6,%xmm3
movaps %xmm3,%xmm12
addps  %xmm14,%xmm12
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm7
movaps %xmm7,%xmm9
addps  %xmm0,%xmm9
mulps  %xmm11,%xmm4
movaps %xmm4,%xmm11
addps  %xmm1,%xmm11
add    $0x1,%rax
add    $0x10,%rdx
cmp    %eax,%edi
jne    1300 <kernel_sgemm_nn_4x4_vs_lib4+0x200>
addps  %xmm1,%xmm4
addps  %xmm0,%xmm7
addps  %xmm14,%xmm3
addps  %xmm13,%xmm2
addps  %xmm10,%xmm5
movaps %xmm7,%xmm9
movaps %xmm4,%xmm11
movaps %xmm3,%xmm12
movaps %xmm2,%xmm15
movaps %xmm5,%xmm8
mov    0x20(%rsp),%edx
mov    0x10(%rsp),%rcx
movss  (%r9),%xmm6
movss  (%rsi),%xmm4
movaps %xmm8,%xmm2
mulss  %xmm4,%xmm2
movss  (%r10),%xmm0
mulss  %xmm6,%xmm0
addss  %xmm2,%xmm0
movaps %xmm8,%xmm2
shufps $0x55,%xmm8,%xmm2
mulss  %xmm4,%xmm2
movss  0x4(%r10),%xmm5
mulss  %xmm6,%xmm5
addss  %xmm2,%xmm5
movaps %xmm8,%xmm3
unpckhpd %xmm8,%xmm3
mulss  %xmm4,%xmm3
movss  0x8(%r10),%xmm2
mulss  %xmm6,%xmm2
addss  %xmm3,%xmm2
movaps %xmm4,%xmm1
shufps $0x0,%xmm4,%xmm1
mulps  %xmm1,%xmm15
movups 0x10(%r10),%xmm3
movups 0x20(%r10),%xmm10
movaps %xmm6,%xmm7
shufps $0x0,%xmm6,%xmm7
mulps  %xmm7,%xmm3
addps  %xmm15,%xmm3
mulps  %xmm1,%xmm12
mulps  %xmm7,%xmm10
addps  %xmm12,%xmm10
movsd  0x30(%r10),%xmm12
mulps  %xmm1,%xmm9
mulps  %xmm7,%xmm12
addps  %xmm9,%xmm12
movsd  0x38(%r10),%xmm9
mulps  %xmm11,%xmm1
mulps  %xmm7,%xmm9
addps  %xmm1,%xmm9
cmp    $0x4,%r8d
jl     14d7 <kernel_sgemm_nn_4x4_vs_lib4+0x3d7>
shufps $0xff,%xmm8,%xmm8
mulss  %xmm4,%xmm8
mulss  0xc(%r10),%xmm6
addss  %xmm8,%xmm6
movss  %xmm0,(%rcx)
movss  %xmm5,0x4(%rcx)
movss  %xmm2,0x8(%rcx)
movss  %xmm6,0xc(%rcx)
cmp    $0x1,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
movups %xmm3,0x10(%rcx)
cmp    $0x2,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
movups %xmm10,0x20(%rcx)
cmp    $0x3,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
movss  %xmm12,0x30(%rcx)
shufps $0x55,%xmm12,%xmm12
mov    $0xf,%eax
mov    $0xe,%edx
mov    $0xd,%esi
jmp    155a <kernel_sgemm_nn_4x4_vs_lib4+0x45a>
cmp    $0x3,%r8d
jne    1577 <kernel_sgemm_nn_4x4_vs_lib4+0x477>
movss  %xmm0,(%rcx)
movss  %xmm5,0x4(%rcx)
movss  %xmm2,0x8(%rcx)
cmp    $0x1,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
movss  %xmm3,0x10(%rcx)
movaps %xmm3,%xmm0
shufps $0x55,%xmm3,%xmm0
movss  %xmm0,0x14(%rcx)
movhlps %xmm3,%xmm3
movss  %xmm3,0x18(%rcx)
cmp    $0x2,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
movss  %xmm10,0x20(%rcx)
movaps %xmm10,%xmm0
shufps $0x55,%xmm10,%xmm0
movss  %xmm0,0x24(%rcx)
movhlps %xmm10,%xmm10
movss  %xmm10,0x28(%rcx)
cmp    $0x3,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
shufps $0x10,%xmm12,%xmm9
shufps $0xe2,%xmm12,%xmm9
mov    $0xe,%eax
mov    $0xd,%edx
mov    $0xc,%esi
movss  %xmm12,(%rcx,%rsi,4)
movaps %xmm9,%xmm12
movss  %xmm12,(%rcx,%rdx,4)
shufps $0x55,%xmm12,%xmm12
movss  %xmm12,(%rcx,%rax,4)
jmp    15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
movss  %xmm0,(%rcx)
cmp    $0x2,%r8d
jl     15c0 <kernel_sgemm_nn_4x4_vs_lib4+0x4c0>
movss  %xmm5,0x4(%rcx)
cmp    $0x1,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
movss  %xmm3,0x10(%rcx)
shufps $0x55,%xmm3,%xmm3
movss  %xmm3,0x14(%rcx)
cmp    $0x2,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
movss  %xmm10,0x20(%rcx)
shufps $0x55,%xmm10,%xmm10
movss  %xmm10,0x24(%rcx)
cmp    $0x3,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
mov    $0xd,%eax
mov    $0xc,%edx
jmp    1564 <kernel_sgemm_nn_4x4_vs_lib4+0x464>
cmp    $0x1,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
movss  %xmm3,0x10(%rcx)
cmp    $0x2,%edx
je     15da <kernel_sgemm_nn_4x4_vs_lib4+0x4da>
movss  %xmm10,0x20(%rcx)
cmp    $0x3,%edx
jne    15db <kernel_sgemm_nn_4x4_vs_lib4+0x4db>
ret
mov    $0xc,%eax
jmp    156f <kernel_sgemm_nn_4x4_vs_lib4+0x46f>

LLVM IR (-O0):
define void @kernel_sgemm_nn_4x4_vs_lib4(i32 %0, float* %1, float* %2, float* %3, i32 %4, float* %5, float* %6, float* %7, i32 %8, i32 %9) {
%11 = alloca i32
%12 = alloca float*
%13 = alloca float*
%14 = alloca float*
%15 = alloca i32
%16 = alloca float*
%17 = alloca float*
%18 = alloca float*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca float
%39 = alloca float
%40 = alloca float
%41 = alloca float
%42 = alloca float
%43 = alloca float
%44 = alloca float
%45 = alloca float
%46 = alloca i32
store i32 %0, i32* %11
store float* %1, float** %12
store float* %2, float** %13
store float* %3, float** %14
store i32 %4, i32* %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
store i32 4, i32* %21
store float 0.000000e+00, float* %30
store float 0.000000e+00, float* %31
store float 0.000000e+00, float* %32
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 float 0.000000e+00, float* %37
store float 0.000000e+00, float* %38
store float 0.000000e+00, float* %39
store float 0.000000e+00, float* %40
store float 0.000000e+00, float* %41
store float 0.000000e+00, float* %42
store float 0.000000e+00, float* %43
store float 0.000000e+00, float* %44
store float 0.000000e+00, float* %45
store i32 0, i32* %46
br label %47
47: ; preds = %412, %10
%48 = load i32, i32* %46
%49 = load i32, i32* %11
%50 = sub nsw i32 %49, 3
%51 = icmp slt i32 %48, %50
br i1 %51, label %52, label %415
52: ; preds = %47
%53 = load float*, float** %13
%54 = getelementptr inbounds float, float* %53, i64 0
%55 = load float, float* %54
store float %55, float* %22
%56 = load float*, float** %13
%57 = getelementptr inbounds float, float* %56, i64 1
%58 = load float, float* %57
store float %58, float* %23
%59 = load float*, float** %13
%60 = getelementptr inbounds float, float* %59, i64 2
%61 = load float, float* %60
store float %61, float* %24
%62 = load float*, float** %13
%63 = getelementptr inbounds float, float* %62, i64 3
%64 = load float, float* %63
store float %64, float* %25
%65 = load float*, float** %14
%66 = getelementptr inbounds float, float* %65, i64 0
%67 = load float, float* %66
store float %67, float* %26
%68 = load float*, float** %14
%69 = getelementptr inbounds float, float* %68, i64 4
%70 = load float, float* %69
store float %70, float* %27
%71 = load float*, float** %14
%72 = getelementptr inbounds float, float* %71, i64 8
%73 = load float, float* %72
store float %73, float* %28
%74 = load float*, float** %14
%75 = getelementptr inbounds float, float* %74, i64 12
%76 = load float, float* %75
store float %76, float* %29
%77 = load float, float* %22
%78 = load float, float* %26
%79 = load float, float* %30
%80 = call float @llvm.fmuladd.f32(float %77, float %78, float %79)
store float %80, float* %30
%81 = load float, float* %23
%82 = load float, float* %26
%83 = load float, float* %34
%84 = call float @llvm.fmuladd.f32(float %81, float %82, float %83)
store float %84, float* %34
%85 = load float, float* %24
%86 = load float, float* %26
%87 = load float, float* %38
%88 = call float @llvm.fmuladd.f32(float %85, float %86, float %87)
store float %88, float* %38
%89 = load float, float* %25
%90 = load float, float* %26
%91 = load float, float* %42
%92 = call float @llvm.fmuladd.f32(float %89, float %90, float %91)
store float %92, float* %42
%93 = load float, float* %22
%94 = load float, float* %27
%95 = load float, float* %31
%96 = call float @llvm.fmuladd.f32(float %93, float %94, float %95)
store float %96, float* %31
%97 = load float, float* %23
%98 = load float, float* %27
%99 = load float, float* %35
%100 = call float @llvm.fmuladd.f32(float %97, float %98, float %99)
store float %100, float* %35
%101 = load float, float* %24
%102 = load float, float* %27
%103 = load float, float* %39
%104 = call float @llvm.fmuladd.f32(float %101, float %102, float %103)
store float %104, float* %39
%105 = load float, float* %25
%106 = load float, float* %27
%107 = load float, float* %43
%108 = call float @llvm.fmuladd.f32(float %105, float %106, float %107)
store float %108, float* %43
%109 = load float, float* %22
%110 = load float, float* %28
%111 = load float, float* %32
%112 = call float @llvm.fmuladd.f32(float %109, float %110, float %111)
store float %112, float* %32
%113 = load float, float* %23
%114 = load float, float* %28
%115 = load float, float* %36
%116 = call float @llvm.fmuladd.f32(float %113, float %114, float %115)
store float %116, float* %36
%117 = load float, float* %24
%118 = load float, float* %28
%119 = load float, float* %40
%120 = call float @llvm.fmuladd.f32(float %117, float %118, float %119)
store float %120, float* %40
%121 = load float, float* %25
%122 = load float, float* %28
%123 = load float, float* %44
%124 = call float @llvm.fmuladd.f32(float %121, float %122, float %123)
store float %124, float* %44
%125 = load float, float* %22
%126 = load float, float* %29
%127 = load float, float* %33
%128 = call float @llvm.fmuladd.f32(float %125, float %126, float %127)
store float %128, float* %33
%129 = load float, float* %23
%130 = load float, float* %29
%131 = load float, float* %37
%132 = call float @llvm.fmuladd.f32(float %129, float %130, float %131)
store float %132, float* %37
%133 = load float, float* %24
%134 = load float, float* %29
%135 = load float, float* %41
%136 = call float @llvm.fmuladd.f32(float %133, float %134, float %135)
store float %136, float* %41
%137 = load float, float* %25
%138 = load float, float* %29
%139 = load float, float* %45
%140 = call float @llvm.fmuladd.f32(float %137, float %138, float %139)
store float %140, float* %45
%141 = load float*, float** %13
%142 = getelementptr inbounds float, float* %141, i64 4
%143 = load float, float* %142
store float %143, float* %22
%144 = load float*, float** %13
%145 = getelementptr inbounds float, float* %144, i64 5
%146 = load float, float* %145
store float %146, float* %23
%147 = load float*, float** %13
%148 = getelementptr inbounds float, float* %147, i64 6
%149 = load float, float* %148
store float %149, float* %24
%150 = load float*, float** %13
%151 = getelementptr inbounds float, float* %150, i64 7
%152 = load float, float* %151
store float %152, float* %25
%153 = load float*, float** %14
%154 = getelementptr inbounds float, float* %153, i64 1
%155 = load float, float* %154
store float %155, float* %26
%156 = load float*, float** %14
%157 = getelementptr inbounds float, float* %156, i64 5
%158 = load float, float* %157
store float %158, float* %27
%159 = load float*, float** %14
%160 = getelementptr inbounds float, float* %159, i64 9
%161 = load float, float* %160
store float %161, float* %28
%162 = load float*, float** %14
%163 = getelementptr inbounds float, float* %162, i64 13
%164 = load float, float* %163
store float %164, float* %29
%165 = load float, float* %22
%166 = load float, float* %26
%167 = load float, float* %30
%168 = call float @llvm.fmuladd.f32(float %165, float %166, float %167)
store float %168, float* %30
%169 = load float, float* %23
%170 = load float, float* %26
%171 = load float, float* %34
%172 = call float @llvm.fmuladd.f32(float %169, float %170, float %171)
store float %172, float* %34
%173 = load float, float* %24
%174 = load float, float* %26
%175 = load float, float* %38
%176 = call float @llvm.fmuladd.f32(float %173, float %174, float %175)
store float %176, float* %38
%177 = load float, float* %25
%178 = load float, float* %26
%179 = load float, float* %42
%180 = call float @llvm.fmuladd.f32(float %177, float %178, float %179)
store float %180, float* %42
%181 = load float, float* %22
%182 = load float, float* %27
%183 = load float, float* %31
%184 = call float @llvm.fmuladd.f32(float %181, float %182, float %183)
store float %184, float* %31
%185 = load float, float* %23
%186 = load float, float* %27
%187 = load float, float* %35
%188 = call float @llvm.fmuladd.f32(float %185, float %186, float %187)
store float %188, float* %35
%189 = load float, float* %24
%190 = load float, float* %27
%191 = load float, float* %39
%192 = call float @llvm.fmuladd.f32(float %189, float %190, float %191)
store float %192, float* %39
%193 = load float, float* %25
%194 = load float, float* %27
%195 = load float, float* %43
%196 = call float @llvm.fmuladd.f32(float %193, float %194, float %195)
store float %196, float* %43
%197 = load float, float* %22
%198 = load float, float* %28
%199 = load float, float* %32
%200 = call float @llvm.fmuladd.f32(float %197, float %198, float %199)
store float %200, float* %32
%201 = load float, float* %23
%202 = load float, float* %28
%203 = load float, float* %36
%204 = call float @llvm.fmuladd.f32(float %201, float %202, float %203)
store float %204, float* %36
%205 = load float, float* %24
%206 = load float, float* %28
%207 = load float, float* %40
%208 = call float @llvm.fmuladd.f32(float %205, float %206, float %207)
store float %208, float* %40
%209 = load float, float* %25
%210 = load float, float* %28
%211 = load float, float* %44
%212 = call float @llvm.fmuladd.f32(float %209, float %210, float %211)
store float %212, float* %44
%213 = load float, float* %22
%214 = load float, float* %29
%215 = load float, float* %33
%216 = call float @llvm.fmuladd.f32(float %213, float %214, float %215)
store float %216, float* %33
%217 = load float, float* %23
%218 = load float, float* %29
%219 = load float, float* %37
%220 = call float @llvm.fmuladd.f32(float %217, float %218, float %219)
store float %220, float* %37
%221 = load float, float* %24
%222 = load float, float* %29
%223 = load float, float* %41
%224 = call float @llvm.fmuladd.f32(float %221, float %222, float %223)
store float %224, float* %41
%225 = load float, float* %25
%226 = load float, float* %29
%227 = load float, float* %45
%228 = call float @llvm.fmuladd.f32(float %225, float %226, float %227)
store float %228, float* %45
%229 = load float*, float** %13
%230 = getelementptr inbounds float, float* %229, i64 8
%231 = load float, float* %230
store float %231, float* %22
%232 = load float*, float** %13
%233 = getelementptr inbounds float, float* %232, i64 9
%234 = load float, float* %233
store float %234, float* %23
%235 = load float*, float** %13
%236 = getelementptr inbounds float, float* %235, i64 10
%237 = load float, float* %236
store float %237, float* %24
%238 = load float*, float** %13
%239 = getelementptr inbounds float, float* %238, i64 11
%240 = load float, float* %239
store float %240, float* %25
%241 = load float*, float** %14
%242 = getelementptr inbounds float, float* %241, i64 2
%243 = load float, float* %242
store float %243, float* %26
%244 = load float*, float** %14
%245 = getelementptr inbounds float, float* %244, i64 6
%246 = load float, float* %245
store float %246, float* %27
%247 = load float*, float** %14
%248 = getelementptr inbounds float, float* %247, i64 10
%249 = load float, float* %248
store float %249, float* %28
%250 = load float*, float** %14
%251 = getelementptr inbounds float, float* %250, i64 14
%252 = load float, float* %251
store float %252, float* %29
%253 = load float, float* %22
%254 = load float, float* %26
%255 = load float, float* %30
%256 = call float @llvm.fmuladd.f32(float %253, float %254, float %255)
store float %256, float* %30
%257 = load float, float* %23
%258 = load float, float* %26
%259 = load float, float* %34
%260 = call float @llvm.fmuladd.f32(float %257, float %258, float %259)
store float %260, float* %34
%261 = load float, float* %24
%262 = load float, float* %26
%263 = load float, float* %38
%264 = call float @llvm.fmuladd.f32(float %261, float %262, float %263)
store float %264, float* %38
%265 = load float, float* %25
%266 = load float, float* %26
%267 = load float, float* %42
%268 = call float @llvm.fmuladd.f32(float %265, float %266, float %267)
store float %268, float* %42
%269 = load float, float* %22
%270 = load float, float* %27
%271 = load float, float* %31
%272 = call float @llvm.fmuladd.f32(float %269, float %270, float %271)
store float %272, float* %31
%273 = load float, float* %23
%274 = load float, float* %27
%275 = load float, float* %35
%276 = call float @llvm.fmuladd.f32(float %273, float %274, float %275)
store float %276, float* %35
%277 = load float, float* %24
%278 = load float, float* %27
%279 = load float, float* %39
%280 = call float @llvm.fmuladd.f32(float %277, float %278, float %279)
store float %280, float* %39
%281 = load float, float* %25
%282 = load float, float* %27
%283 = load float, float* %43
%284 = call float @llvm.fmuladd.f32(float %281, float %282, float %283)
store float %284, float* %43
%285 = load float, float* %22
%286 = load float, float* %28
%287 = load float, float* %32
%288 = call float @llvm.fmuladd.f32(float %285, float %286, float %287)
store float %288, float* %32
%289 = load float, float* %23
%290 = load float, float* %28
%291 = load float, float* %36
%292 = call float @llvm.fmuladd.f32(float %289, float %290, float %291)
store float %292, float* %36
%293 = load float, float* %24
%294 = load float, float* %28
%295 = load float, float* %40
%296 = call float @llvm.fmuladd.f32(float %293, float %294, float %295)
store float %296, float* %40
%297 = load float, float* %25
%298 = load float, float* %28
%299 = load float, float* %44
%300 = call float @llvm.fmuladd.f32(float %297, float %298, float %299)
store float %300, float* %44
%301 = load float, float* %22
%302 = load float, float* %29
%303 = load float, float* %33
%304 = call float @llvm.fmuladd.f32(float %301, float %302, float %303)
store float %304, float* %33
%305 = load float, float* %23
%306 = load float, float* %29
%307 = load float, float* %37
%308 = call float @llvm.fmuladd.f32(float %305, float %306, float %307)
store float %308, float* %37
%309 = load float, float* %24
%310 = load float, float* %29
%311 = load float, float* %41
%312 = call float @llvm.fmuladd.f32(float %309, float %310, float %311)
store float %312, float* %41
%313 = load float, float* %25
%314 = load float, float* %29
%315 = load float, float* %45
%316 = call float @llvm.fmuladd.f32(float %313, float %314, float %315)
store float %316, float* %45
%317 = load float*, float** %13
%318 = getelementptr inbounds float, float* %317, i64 12
%319 = load float, float* %318
store float %319, float* %22
%320 = load float*, float** %13
%321 = getelementptr inbounds float, float* %320, i64 13
%322 = load float, float* %321
store float %322, float* %23
%323 = load float*, float** %13
%324 = getelementptr inbounds float, float* %323, i64 14
%325 = load float, float* %324
store float %325, float* %24
%326 = load float*, float** %13
%327 = getelementptr inbounds float, float* %326, i64 15
%328 = load float, float* %327
store float %328, float* %25
%329 = load float*, float** %14
%330 = getelementptr inbounds float, float* %329, i64 3
%331 = load float, float* %330
store float %331, float* %26
%332 = load float*, float** %14
%333 = getelementptr inbounds float, float* %332, i64 7
%334 = load float, float* %333
store float %334, float* %27
%335 = load float*, float** %14
%336 = getelementptr inbounds float, float* %335, i64 11
%337 = load float, float* %336
store float %337, float* %28
%338 = load float*, float** %14
%339 = getelementptr inbounds float, float* %338, i64 15
%340 = load float, float* %339
store float %340, float* %29
%341 = load float, float* %22
%342 = load float, float* %26
%343 = load float, float* %30
%344 = call float @llvm.fmuladd.f32(float %341, float %342, float %343)
store float %344, float* %30
%345 = load float, float* %23
%346 = load float, float* %26
%347 = load float, float* %34
%348 = call float @llvm.fmuladd.f32(float %345, float %346, float %347)
store float %348, float* %34
%349 = load float, float* %24
%350 = load float, float* %26
%351 = load float, float* %38
%352 = call float @llvm.fmuladd.f32(float %349, float %350, float %351)
store float %352, float* %38
%353 = load float, float* %25
%354 = load float, float* %26
%355 = load float, float* %42
%356 = call float @llvm.fmuladd.f32(float %353, float %354, float %355)
store float %356, float* %42
%357 = load float, float* %22
%358 = load float, float* %27
%359 = load float, float* %31
%360 = call float @llvm.fmuladd.f32(float %357, float %358, float %359)
store float %360, float* %31
%361 = load float, float* %23
%362 = load float, float* %27
%363 = load float, float* %35
%364 = call float @llvm.fmuladd.f32(float %361, float %362, float %363)
store float %364, float* %35
%365 = load float, float* %24
%366 = load float, float* %27
%367 = load float, float* %39
%368 = call float @llvm.fmuladd.f32(float %365, float %366, float %367)
store float %368, float* %39
%369 = load float, float* %25
%370 = load float, float* %27
%371 = load float, float* %43
%372 = call float @llvm.fmuladd.f32(float %369, float %370, float %371)
store float %372, float* %43
%373 = load float, float* %22
%374 = load float, float* %28
%375 = load float, float* %32
%376 = call float @llvm.fmuladd.f32(float %373, float %374, float %375)
store float %376, float* %32
%377 = load float, float* %23
%378 = load float, float* %28
%379 = load float, float* %36
%380 = call float @llvm.fmuladd.f32(float %377, float %378, float %379)
store float %380, float* %36
%381 = load float, float* %24
%382 = load float, float* %28
%383 = load float, float* %40
%384 = call float @llvm.fmuladd.f32(float %381, float %382, float %383)
store float %384, float* %40
%385 = load float, float* %25
%386 = load float, float* %28
%387 = load float, float* %44
%388 = call float @llvm.fmuladd.f32(float %385, float %386, float %387)
store float %388, float* %44
%389 = load float, float* %22
%390 = load float, float* %29
%391 = load float, float* %33
%392 = call float @llvm.fmuladd.f32(float %389, float %390, float %391)
store float %392, float* %33
%393 = load float, float* %23
%394 = load float, float* %29
%395 = load float, float* %37
%396 = call float @llvm.fmuladd.f32(float %393, float %394, float %395)
store float %396, float* %37
%397 = load float, float* %24
%398 = load float, float* %29
%399 = load float, float* %41
%400 = call float @llvm.fmuladd.f32(float %397, float %398, float %399)
store float %400, float* %41
%401 = load float, float* %25
%402 = load float, float* %29
%403 = load float, float* %45
%404 = call float @llvm.fmuladd.f32(float %401, float %402, float %403)
store float %404, float* %45
%405 = load float*, float** %13
%406 = getelementptr inbounds float, float* %405, i64 16
store float* %406, float** %13
%407 = load i32, i32* %15
%408 = mul nsw i32 4, %407
%409 = load float*, float** %14
%410 = sext i32 %408 to i64
%411 = getelementptr inbounds float, float* %409, i64 %410
store float* %411, float** %14
br label %412
412: ; preds = %52
%413 = load i32, i32* %46
%414 = add nsw i32 %413, 4
store i32 %414, i32* %46
br label %47
415: ; preds = %47
br label %416
416: ; preds = %513, %415
%417 = load i32, i32* %46
%418 = load i32, i32* %11
%419 = icmp slt i32 %417, %418
br i1 %419, label %420, label %516
420: ; preds = %416
%421 = load float*, float** %13
%422 = getelementptr inbounds float, float* %421, i64 0
%423 = load float, float* %422
store float %423, float* %22
%424 = load float*, float** %13
%425 = getelementptr inbounds float, float* %424, i64 1
%426 = load float, float* %425
store float %426, float* %23
%427 = load float*, float** %13
%428 = getelementptr inbounds float, float* %427, i64 2
%429 = load float, float* %428
store float %429, float* %24
%430 = load float*, float** %13
%431 = getelementptr inbounds float, float* %430, i64 3
%432 = load float, float* %431
store float %432, float* %25
%433 = load float*, float** %14
%434 = getelementptr inbounds float, float* %433, i64 0
%435 = load float, float* %434
store float %435, float* %26
%436 = load float*, float** %14
%437 = getelementptr inbounds float, float* %436, i64 4
%438 = load float, float* %437
store float %438, float* %27
%439 = load float*, float** %14
%440 = getelementptr inbounds float, float* %439, i64 8
%441 = load float, float* %440
store float %441, float* %28
%442 = load float*, float** %14
%443 = getelementptr inbounds float, float* %442, i64 12
%444 = load float, float* %443
store float %444, float* %29
%445 = load float, float* %22
%446 = load float, float* %26
%447 = load float, float* %30
%448 = call float @llvm.fmuladd.f32(float %445, float %446, float %447)
store float %448, float* %30
%449 = load float, float* %23
%450 = load float, float* %26
%451 = load float, float* %34
%452 = call float @llvm.fmuladd.f32(float %449, float %450, float %451)
store float %452, float* %34
%453 = load float, float* %24
%454 = load float, float* %26
%455 = load float, float* %38
%456 = call float @llvm.fmuladd.f32(float %453, float %454, float %455)
store float %456, float* %38
%457 = load float, float* %25
%458 = load float, float* %26
%459 = load float, float* %42
%460 = call float @llvm.fmuladd.f32(float %457, float %458, float %459)
store float %460, float* %42
%461 = load float, float* %22
%462 = load float, float* %27
%463 = load float, float* %31
%464 = call float @llvm.fmuladd.f32(float %461, float %462, float %463)
store float %464, float* %31
%465 = load float, float* %23
%466 = load float, float* %27
%467 = load float, float* %35
%468 = call float @llvm.fmuladd.f32(float %465, float %466, float %467)
store float %468, float* %35
%469 = load float, float* %24
%470 = load float, float* %27
%471 = load float, float* %39
%472 = call float @llvm.fmuladd.f32(float %469, float %470, float %471)
store float %472, float* %39
%473 = load float, float* %25
%474 = load float, float* %27
%475 = load float, float* %43
%476 = call float @llvm.fmuladd.f32(float %473, float %474, float %475)
store float %476, float* %43
%477 = load float, float* %22
%478 = load float, float* %28
%479 = load float, float* %32
%480 = call float @llvm.fmuladd.f32(float %477, float %478, float %479)
store float %480, float* %32
%481 = load float, float* %23
%482 = load float, float* %28
%483 = load float, float* %36
%484 = call float @llvm.fmuladd.f32(float %481, float %482, float %483)
store float %484, float* %36
%485 = load float, float* %24
%486 = load float, float* %28
%487 = load float, float* %40
%488 = call float @llvm.fmuladd.f32(float %485, float %486, float %487)
store float %488, float* %40
%489 = load float, float* %25
%490 = load float, float* %28
%491 = load float, float* %44
%492 = call float @llvm.fmuladd.f32(float %489, float %490, float %491)
store float %492, float* %44
%493 = load float, float* %22
%494 = load float, float* %29
%495 = load float, float* %33
%496 = call float @llvm.fmuladd.f32(float %493, float %494, float %495)
store float %496, float* %33
%497 = load float, float* %23
%498 = load float, float* %29
%499 = load float, float* %37
%500 = call float @llvm.fmuladd.f32(float %497, float %498, float %499)
store float %500, float* %37
%501 = load float, float* %24
%502 = load float, float* %29
%503 = load float, float* %41
%504 = call float @llvm.fmuladd.f32(float %501, float %502, float %503)
store float %504, float* %41
%505 = load float, float* %25
%506 = load float, float* %29
%507 = load float, float* %45
%508 = call float @llvm.fmuladd.f32(float %505, float %506, float %507)
store float %508, float* %45
%509 = load float*, float** %13
%510 = getelementptr inbounds float, float* %509, i64 4
store float* %510, float** %13
%511 = load float*, float** %14
%512 = getelementptr inbounds float, float* %511, i64 1
store float* %512, float** %14
br label %513
513: ; preds = %420
%514 = load i32, i32* %46
%515 = add nsw i32 %514, 1
store i32 %515, i32* %46
br label %416
516: ; preds = %416
%517 = load float*, float** %16
%518 = getelementptr inbounds float, float* %517, i64 0
%519 = load float, float* %518
%520 = load float*, float** %17
%521 = getelementptr inbounds float, float* %520, i64 0
%522 = load float, float* %521
%523 = load float*, float** %12
%524 = getelementptr inbounds float, float* %523, i64 0
%525 = load float, float* %524
%526 = load float, float* %30
%527 = fmul float %525, %526
%528 = call float @llvm.fmuladd.f32(float %519, float %522, float %527)
store float %528, float* %30
%529 = load float*, float** %16
%530 = getelementptr inbounds float, float* %529, i64 0
%531 = load float, float* %530
%532 = load float*, float** %17
%533 = getelementptr inbounds float, float* %532, i64 1
%534 = load float, float* %533
%535 = load float*, float** %12
%536 = getelementptr inbounds float, float* %535, i64 0
%537 = load float, float* %536
%538 = load float, float* %34
%539 = fmul float %537, %538
%540 = call float @llvm.fmuladd.f32(float %531, float %534, float %539)
store float %540, float* %34
%541 = load float*, float** %16
%542 = getelementptr inbounds float, float* %541, i64 0
%543 = load float, float* %542
%544 = load float*, float** %17
%545 = getelementptr inbounds float, float* %544, i64 2
%546 = load float, float* %545
%547 = load float*, float** %12
%548 = getelementptr inbounds float, float* %547, i64 0
%549 = load float, float* %548
%550 = load float, float* %38
%551 = fmul float %549, %550
%552 = call float @llvm.fmuladd.f32(float %543, float %546, float %551)
store float %552, float* %38
%553 = load float*, float** %16
%554 = getelementptr inbounds float, float* %553, i64 0
%555 = load float, float* %554
%556 = load float*, float** %17
%557 = getelementptr inbounds float, float* %556, i64 3
%558 = load float, float* %557
%559 = load float*, float** %12
%560 = getelementptr inbounds float, float* %559, i64 0
%561 = load float, float* %560
%562 = load float, float* %42
%563 = fmul float %561, %562
%564 = call float @llvm.fmuladd.f32(float %555, float %558, float %563)
store float %564, float* %42
%565 = load float*, float** %16
%566 = getelementptr inbounds float, float* %565, i64 0
%567 = load float, float* %566
%568 = load float*, float** %17
%569 = getelementptr inbounds float, float* %568, i64 4
%570 = load float, float* %569
%571 = load float*, float** %12
%572 = getelementptr inbounds float, float* %571, i64 0
%573 = load float, float* %572
%574 = load float, float* %31
%575 = fmul float %573, %574
%576 = call float @llvm.fmuladd.f32(float %567, float %570, float %575)
store float %576, float* %31
%577 = load float*, float** %16
%578 = getelementptr inbounds float, float* %577, i64 0
%579 = load float, float* %578
%580 = load float*, float** %17
%581 = getelementptr inbounds float, float* %580, i64 5
%582 = load float, float* %581
%583 = load float*, float** %12
%584 = getelementptr inbounds float, float* %583, i64 0
%585 = load float, float* %584
%586 = load float, float* %35
%587 = fmul float %585, %586
%588 = call float @llvm.fmuladd.f32(float %579, float %582, float %587)
store float %588, float* %35
%589 = load float*, float** %16
%590 = getelementptr inbounds float, float* %589, i64 0
%591 = load float, float* %590
%592 = load float*, float** %17
%593 = getelementptr inbounds float, float* %592, i64 6
%594 = load float, float* %593
%595 = load float*, float** %12
%596 = getelementptr inbounds float, float* %595, i64 0
%597 = load float, float* %596
%598 = load float, float* %39
%599 = fmul float %597, %598
%600 = call float @llvm.fmuladd.f32(float %591, float %594, float %599)
store float %600, float* %39
%601 = load float*, float** %16
%602 = getelementptr inbounds float, float* %601, i64 0
%603 = load float, float* %602
%604 = load float*, float** %17
%605 = getelementptr inbounds float, float* %604, i64 7
%606 = load float, float* %605
%607 = load float*, float** %12
%608 = getelementptr inbounds float, float* %607, i64 0
%609 = load float, float* %608
%610 = load float, float* %43
%611 = fmul float %609, %610
%612 = call float @llvm.fmuladd.f32(float %603, float %606, float %611)
store float %612, float* %43
%613 = load float*, float** %16
%614 = getelementptr inbounds float, float* %613, i64 0
%615 = load float, float* %614
%616 = load float*, float** %17
%617 = getelementptr inbounds float, float* %616, i64 8
%618 = load float, float* %617
%619 = load float*, float** %12
%620 = getelementptr inbounds float, float* %619, i64 0
%621 = load float, float* %620
%622 = load float, float* %32
%623 = fmul float %621, %622
%624 = call float @llvm.fmuladd.f32(float %615, float %618, float %623)
store float %624, float* %32
%625 = load float*, float** %16
%626 = getelementptr inbounds float, float* %625, i64 0
%627 = load float, float* %626
%628 = load float*, float** %17
%629 = getelementptr inbounds float, float* %628, i64 9
%630 = load float, float* %629
%631 = load float*, float** %12
%632 = getelementptr inbounds float, float* %631, i64 0
%633 = load float, float* %632
%634 = load float, float* %36
%635 = fmul float %633, %634
%636 = call float @llvm.fmuladd.f32(float %627, float %630, float %635)
store float %636, float* %36
%637 = load float*, float** %16
%638 = getelementptr inbounds float, float* %637, i64 0
%639 = load float, float* %638
%640 = load float*, float** %17
%641 = getelementptr inbounds float, float* %640, i64 10
%642 = load float, float* %641
%643 = load float*, float** %12
%644 = getelementptr inbounds float, float* %643, i64 0
%645 = load float, float* %644
%646 = load float, float* %40
%647 = fmul float %645, %646
%648 = call float @llvm.fmuladd.f32(float %639, float %642, float %647)
store float %648, float* %40
%649 = load float*, float** %16
%650 = getelementptr inbounds float, float* %649, i64 0
%651 = load float, float* %650
%652 = load float*, float** %17
%653 = getelementptr inbounds float, float* %652, i64 11
%654 = load float, float* %653
%655 = load float*, float** %12
%656 = getelementptr inbounds float, float* %655, i64 0
%657 = load float, float* %656
%658 = load float, float* %44
%659 = fmul float %657, %658
%660 = call float @llvm.fmuladd.f32(float %651, float %654, float %659)
store float %660, float* %44
%661 = load float*, float** %16
%662 = getelementptr inbounds float, float* %661, i64 0
%663 = load float, float* %662
%664 = load float*, float** %17
%665 = getelementptr inbounds float, float* %664, i64 12
%666 = load float, float* %665
%667 = load float*, float** %12
%668 = getelementptr inbounds float, float* %667, i64 0
%669 = load float, float* %668
%670 = load float, float* %33
%671 = fmul float %669, %670
%672 = call float @llvm.fmuladd.f32(float %663, float %666, float %671)
store float %672, float* %33
%673 = load float*, float** %16
%674 = getelementptr inbounds float, float* %673, i64 0
%675 = load float, float* %674
%676 = load float*, float** %17
%677 = getelementptr inbounds float, float* %676, i64 13
%678 = load float, float* %677
%679 = load float*, float** %12
%680 = getelementptr inbounds float, float* %679, i64 0
%681 = load float, float* %680
%682 = load float, float* %37
%683 = fmul float %681, %682
%684 = call float @llvm.fmuladd.f32(float %675, float %678, float %683)
store float %684, float* %37
%685 = load float*, float** %16
%686 = getelementptr inbounds float, float* %685, i64 0
%687 = load float, float* %686
%688 = load float*, float** %17
%689 = getelementptr inbounds float, float* %688, i64 14
%690 = load float, float* %689
%691 = load float*, float** %12
%692 = getelementptr inbounds float, float* %691, i64 0
%693 = load float, float* %692
%694 = load float, float* %41
%695 = fmul float %693, %694
%696 = call float @llvm.fmuladd.f32(float %687, float %690, float %695)
store float %696, float* %41
%697 = load float*, float** %16
%698 = getelementptr inbounds float, float* %697, i64 0
%699 = load float, float* %698
%700 = load float*, float** %17
%701 = getelementptr inbounds float, float* %700, i64 15
%702 = load float, float* %701
%703 = load float*, float** %12
%704 = getelementptr inbounds float, float* %703, i64 0
%705 = load float, float* %704
%706 = load float, float* %45
%707 = fmul float %705, %706
%708 = call float @llvm.fmuladd.f32(float %699, float %702, float %707)
store float %708, float* %45
br label %709
709: ; preds = %516
%710 = load i32, i32* %19
%711 = icmp sge i32 %710, 4
br i1 %711, label %712, label %773
712: ; preds = %709
%713 = load float, float* %30
%714 = load float*, float** %18
%715 = getelementptr inbounds float, float* %714, i64 0
store float %713, float* %715
%716 = load float, float* %34
%717 = load float*, float** %18
%718 = getelementptr inbounds float, float* %717, i64 1
store float %716, float* %718
%719 = load float, float* %38
%720 = load float*, float** %18
%721 = getelementptr inbounds float, float* %720, i64 2
store float %719, float* %721
%722 = load float, float* %42
%723 = load float*, float** %18
%724 = getelementptr inbounds float, float* %723, i64 3
store float %722, float* %724
%725 = load i32, i32* %20
%726 = icmp eq i32 %725, 1
br i1 %726, label %727, label %728
727: ; preds = %712
br label %892
728: ; preds = %712
%729 = load float, float* %31
%730 = load float*, float** %18
%731 = getelementptr inbounds float, float* %730, i64 4
store float %729, float* %731
%732 = load float, float* %35
%733 = load float*, float** %18
%734 = getelementptr inbounds float, float* %733, i64 5
store float %732, float* %734
%735 = load float, float* %39
%736 = load float*, float** %18
%737 = getelementptr inbounds float, float* %736, i64 6
store float %735, float* %737
%738 = load float, float* %43
%739 = load float*, float** %18
%740 = getelementptr inbounds float, float* %739, i64 7
store float %738, float* %740
%741 = load i32, i32* %20
%742 = icmp eq i32 %741, 2
br i1 %742, label %743, label %744
743: ; preds = %728
br label %892
744: ; preds = %728
%745 = load float, float* %32
%746 = load float*, float** %18
%747 = getelementptr inbounds float, float* %746, i64 8
store float %745, float* %747
%748 = load float, float* %36
%749 = load float*, float** %18
%750 = getelementptr inbounds float, float* %749, i64 9
store float %748, float* %750
%751 = load float, float* %40
%752 = load float*, float** %18
%753 = getelementptr inbounds float, float* %752, i64 10
store float %751, float* %753
%754 = load float, float* %44
%755 = load float*, float** %18
%756 = getelementptr inbounds float, float* %755, i64 11
store float %754, float* %756
%757 = load i32, i32* %20
%758 = icmp eq i32 %757, 3
br i1 %758, label %759, label %760
759: ; preds = %744
br label %892
760: ; preds = %744
%761 = load float, float* %33
%762 = load float*, float** %18
%763 = getelementptr inbounds float, float* %762, i64 12
store float %761, float* %763
%764 = load float, float* %37
%765 = load float*, float** %18
%766 = getelementptr inbounds float, float* %765, i64 13
store float %764, float* %766
%767 = load float, float* %41
%768 = load float*, float** %18
%769 = getelementptr inbounds float, float* %768, i64 14
store float %767, float* %769
%770 = load float, float* %45
%771 = load float*, float** %18
%772 = getelementptr inbounds float, float* %771, i64 15
store float %770, float* %772
br label %892
773: ; preds = %709
%774 = load i32, i32* %19
%775 = icmp sge i32 %774, 3
br i1 %775, label %776, label %825
776: ; preds = %773
%777 = load float, float* %30
%778 = load float*, float** %18
%779 = getelementptr inbounds float, float* %778, i64 0
store float %777, float* %779
%780 = load float, float* %34
%781 = load float*, float** %18
%782 = getelementptr inbounds float, float* %781, i64 1
store float %780, float* %782
%783 = load float, float* %38
%784 = load float*, float** %18
%785 = getelementptr inbounds float, float* %784, i64 2
store float %783, float* %785
%786 = load i32, i32* %20
%787 = icmp eq i32 %786, 1
br i1 %787, label %788, label %789
788: ; preds = %776
br label %892
789: ; preds = %776
%790 = load float, float* %31
%791 = load float*, float** %18
%792 = getelementptr inbounds float, float* %791, i64 4
store float %790, float* %792
%793 = load float, float* %35
%794 = load float*, float** %18
%795 = getelementptr inbounds float, float* %794, i64 5
store float %793, float* %795
%796 = load float, float* %39
%797 = load float*, float** %18
%798 = getelementptr inbounds float, float* %797, i64 6
store float %796, float* %798
%799 = load i32, i32* %20
%800 = icmp eq i32 %799, 2
br i1 %800, label %801, label %802
801: ; preds = %789
br label %892
802: ; preds = %789
%803 = load float, float* %32
%804 = load float*, float** %18
%805 = getelementptr inbounds float, float* %804, i64 8
store float %803, float* %805
%806 = load float, float* %36
%807 = load float*, float** %18
%808 = getelementptr inbounds float, float* %807, i64 9
store float %806, float* %808
%809 = load float, float* %40
%810 = load float*, float** %18
%811 = getelementptr inbounds float, float* %810, i64 10
store float %809, float* %811
%812 = load i32, i32* %20
%813 = icmp eq i32 %812, 3
br i1 %813, label %814, label %815
814: ; preds = %802
br label %892
815: ; preds = %802
%816 = load float, float* %33
%817 = load float*, float** %18
%818 = getelementptr inbounds float, float* %817, i64 12
store float %816, float* %818
%819 = load float, float* %37
%820 = load float*, float** %18
%821 = getelementptr inbounds float, float* %820, i64 13
store float %819, float* %821
%822 = load float, float* %41
%823 = load float*, float** %18
%824 = getelementptr inbounds float, float* %823, i64 14
store float %822, float* %824
br label %891
825: ; preds = %773
%826 = load i32, i32* %19
%827 = icmp sge i32 %826, 2
br i1 %827, label %828, label %865
828: ; preds = %825
%829 = load float, float* %30
%830 = load float*, float** %18
%831 = getelementptr inbounds float, float* %830, i64 0
store float %829, float* %831
%832 = load float, float* %34
%833 = load float*, float** %18
%834 = getelementptr inbounds float, float* %833, i64 1
store float %832, float* %834
%835 = load i32, i32* %20
%836 = icmp eq i32 %835, 1
br i1 %836, label %837, label %838
837: ; preds = %828
br label %892
838: ; preds = %828
%839 = load float, float* %31
%840 = load float*, float** %18
%841 = getelementptr inbounds float, float* %840, i64 4
store float %839, float* %841
%842 = load float, float* %35
%843 = load float*, float** %18
%844 = getelementptr inbounds float, float* %843, i64 5
store float %842, float* %844
%845 = load i32, i32* %20
%846 = icmp eq i32 %845, 2
br i1 %846, label %847, label %848
847: ; preds = %838
br label %892
848: ; preds = %838
%849 = load float, float* %32
%850 = load float*, float** %18
%851 = getelementptr inbounds float, float* %850, i64 8
store float %849, float* %851
%852 = load float, float* %36
%853 = load float*, float** %18
%854 = getelementptr inbounds float, float* %853, i64 9
store float %852, float* %854
%855 = load i32, i32* %20
%856 = icmp eq i32 %855, 3
br i1 %856, label %857, label %858
857: ; preds = %848
br label %892
858: ; preds = %848
%859 = load float, float* %33
%860 = load float*, float** %18
%861 = getelementptr inbounds float, float* %860, i64 12
store float %859, float* %861
%862 = load float, float* %37
%863 = load float*, float** %18
%864 = getelementptr inbounds float, float* %863, i64 13
store float %862, float* %864
br label %890
865: ; preds = %825
%866 = load float, float* %30
%867 = load float*, float** %18
%868 = getelementptr inbounds float, float* %867, i64 0
store float %866, float* %868
%869 = load i32, i32* %20
%870 = icmp eq i32 %869, 1
br i1 %870, label %871, label %872
871: ; preds = %865
br label %892
872: ; preds = %865
%873 = load float, float* %31
%874 = load float*, float** %18
%875 = getelementptr inbounds float, float* %874, i64 4
store float %873, float* %875
%876 = load i32, i32* %20
%877 = icmp eq i32 %876, 2
br i1 %877, label %878, label %879
878: ; preds = %872
br label %892
879: ; preds = %872
%880 = load float, float* %32
%881 = load float*, float** %18
%882 = getelementptr inbounds float, float* %881, i64 8
store float %880, float* %882
%883 = load i32, i32* %20
%884 = icmp eq i32 %883, 3
br i1 %884, label %885, label %886
885: ; preds = %879
br label %892
886: ; preds = %879
%887 = load float, float* %33
%888 = load float*, float** %18
%889 = getelementptr inbounds float, float* %888, i64 12
store float %887, float* %889
br label %890
890: ; preds = %886, %858
br label %891
891: ; preds = %890, %815
br label %892
892: ; preds = %727, %743, %759, %788, %801, %814, %837, %847, %857, %871, %878, %885, %891, %760
ret void
}

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