void kernel_sgemm_nt_4x4_vs_lib4(int kmax, float *alpha, float *A, float *B,
                                 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[1];
    b_2 = B[2];
    b_3 = B[3];
    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[4];
    b_1 = B[5];
    b_2 = B[6];
    b_3 = B[7];
    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[8];
    b_1 = B[9];
    b_2 = B[10];
    b_3 = B[11];
    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[12];
    b_1 = B[13];
    b_2 = B[14];
    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 += 16;
  }
  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[1];
    b_2 = B[2];
    b_3 = B[3];
    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 += 4;
  }
  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_nt_4x4_vs_lib4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x18,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%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    1b3f <kernel_sgemm_nt_4x4_vs_lib4+0xa3f>
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  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%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  0x10(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x1c(%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  0x20(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x2c(%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  0x30(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x38(%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    -0x20(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x20(%rbp)
mov    -0x98(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x98(%rbp)
jmp    11c9 <kernel_sgemm_nt_4x4_vs_lib4+0xc9>
jmp    1b44 <kernel_sgemm_nt_4x4_vs_lib4+0xa44>
mov    -0x98(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1dcb <kernel_sgemm_nt_4x4_vs_lib4+0xccb>
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  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%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    $0x10,%rax
mov    %rax,-0x20(%rbp)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1b44 <kernel_sgemm_nt_4x4_vs_lib4+0xa44>
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x30(%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,0x18(%rbp)
jl     21c2 <kernel_sgemm_nt_4x4_vs_lib4+0x10c2>
movss  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x88(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
cmpl   $0x1,0x20(%rbp)
jne    20eb <kernel_sgemm_nt_4x4_vs_lib4+0xfeb>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x5c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x6c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x7c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x8c(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movss  %xmm0,0x1c(%rax)
cmpl   $0x2,0x20(%rbp)
jne    2135 <kernel_sgemm_nt_4x4_vs_lib4+0x1035>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x90(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movss  %xmm0,0x2c(%rax)
cmpl   $0x3,0x20(%rbp)
jne    217f <kernel_sgemm_nt_4x4_vs_lib4+0x107f>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x64(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0x74(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  -0x84(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movss  %xmm0,0x38(%rax)
movss  -0x94(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movss  %xmm0,0x3c(%rax)
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
cmpl   $0x3,0x18(%rbp)
jl     22a8 <kernel_sgemm_nt_4x4_vs_lib4+0x11a8>
movss  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
cmpl   $0x1,0x20(%rbp)
jne    2204 <kernel_sgemm_nt_4x4_vs_lib4+0x1104>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x5c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x6c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x7c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
cmpl   $0x2,0x20(%rbp)
jne    223d <kernel_sgemm_nt_4x4_vs_lib4+0x113d>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x28(%rax)
cmpl   $0x3,0x20(%rbp)
jne    2276 <kernel_sgemm_nt_4x4_vs_lib4+0x1176>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x64(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0x74(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  -0x84(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movss  %xmm0,0x38(%rax)
jmp    23bc <kernel_sgemm_nt_4x4_vs_lib4+0x12bc>
cmpl   $0x2,0x18(%rbp)
jl     2353 <kernel_sgemm_nt_4x4_vs_lib4+0x1253>
movss  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
cmpl   $0x1,0x20(%rbp)
jne    22dc <kernel_sgemm_nt_4x4_vs_lib4+0x11dc>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x5c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0x6c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
cmpl   $0x2,0x20(%rbp)
jne    2307 <kernel_sgemm_nt_4x4_vs_lib4+0x1207>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x24(%rax)
cmpl   $0x3,0x20(%rbp)
jne    2332 <kernel_sgemm_nt_4x4_vs_lib4+0x1232>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x64(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0x74(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x34(%rax)
jmp    23b7 <kernel_sgemm_nt_4x4_vs_lib4+0x12b7>
movss  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
cmpl   $0x1,0x20(%rbp)
jne    236f <kernel_sgemm_nt_4x4_vs_lib4+0x126f>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x5c(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
cmpl   $0x2,0x20(%rbp)
jne    238c <kernel_sgemm_nt_4x4_vs_lib4+0x128c>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
cmpl   $0x3,0x20(%rbp)
jne    23a9 <kernel_sgemm_nt_4x4_vs_lib4+0x12a9>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
movss  -0x64(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  %xmm0,0x30(%rax)
jmp    23bc <kernel_sgemm_nt_4x4_vs_lib4+0x12bc>
jmp    23c1 <kernel_sgemm_nt_4x4_vs_lib4+0x12c1>
add    $0x18,%rsp
pop    %rbp
ret

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

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

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