int m44invf(const float m[16], float invOut[16]) {
  float inv[16], det;
  int i;
  inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] +
           m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10];
  inv[4] = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15] -
           m[8] * m[7] * m[14] - m[12] * m[6] * m[11] + m[12] * m[7] * m[10];
  inv[8] = m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] +
           m[8] * m[7] * m[13] + m[12] * m[5] * m[11] - m[12] * m[7] * m[9];
  inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14] -
            m[8] * m[6] * m[13] - m[12] * m[5] * m[10] + m[12] * m[6] * m[9];
  inv[1] = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15] -
           m[9] * m[3] * m[14] - m[13] * m[2] * m[11] + m[13] * m[3] * m[10];
  inv[5] = m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] +
           m[8] * m[3] * m[14] + m[12] * m[2] * m[11] - m[12] * m[3] * m[10];
  inv[9] = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] -
           m[8] * m[3] * m[13] - m[12] * m[1] * m[11] + m[12] * m[3] * m[9];
  inv[13] = m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] +
            m[8] * m[2] * m[13] + m[12] * m[1] * m[10] - m[12] * m[2] * m[9];
  inv[2] = m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] +
           m[5] * m[3] * m[14] + m[13] * m[2] * m[7] - m[13] * m[3] * m[6];
  inv[6] = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] -
           m[4] * m[3] * m[14] - m[12] * m[2] * m[7] + m[12] * m[3] * m[6];
  inv[10] = m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] +
            m[4] * m[3] * m[13] + m[12] * m[1] * m[7] - m[12] * m[3] * m[5];
  inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] -
            m[4] * m[2] * m[13] - m[12] * m[1] * m[6] + m[12] * m[2] * m[5];
  inv[3] = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] -
           m[5] * m[3] * m[10] - m[9] * m[2] * m[7] + m[9] * m[3] * m[6];
  inv[7] = m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] +
           m[4] * m[3] * m[10] + m[8] * m[2] * m[7] - m[8] * m[3] * m[6];
  inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] -
            m[4] * m[3] * m[9] - m[8] * m[1] * m[7] + m[8] * m[3] * m[5];
  inv[15] = m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] +
            m[4] * m[2] * m[9] + m[8] * m[1] * m[6] - m[8] * m[2] * m[5];
  det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
  if (det == 0)
    return 0;
  det = 1.0f / det;
  for (i = 0; i < 16; i++)
    invOut[i] = inv[i] * det;
  return 1;
}


x86 assembly (clang, -O0):
<m44invf>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x38(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x38(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x38(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x38(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x2c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x38(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x38(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x34(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  -0x60(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm1
mulss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm1
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  -0x30(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    20d1 <m44invf+0xfd1>
jp     20d1 <m44invf+0xfd1>
movl   $0x0,-0x4(%rbp)
jmp    2125 <m44invf+0x1025>
movss  0xf27(%rip),%xmm0
divss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x10,-0x68(%rbp)
jge    211e <m44invf+0x101e>
movslq -0x68(%rbp),%rax
movss  -0x60(%rbp,%rax,4),%xmm0
mulss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    20ea <m44invf+0xfea>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<m44invf>:
sub    $0x1a8,%rsp
movss  0x14(%rdi),%xmm3
movaps %xmm3,-0x10(%rsp)
movss  0x28(%rdi),%xmm8
movaps %xmm3,%xmm0
mulss  %xmm8,%xmm0
movaps %xmm8,-0x40(%rsp)
movss  0x3c(%rdi),%xmm13
movss  0x2c(%rdi),%xmm4
movss  0x38(%rdi),%xmm2
movaps %xmm4,%xmm1
movaps %xmm4,%xmm6
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm2,%xmm4
mulss  %xmm13,%xmm0
subss  %xmm1,%xmm0
movss  0x24(%rdi),%xmm2
movaps %xmm2,0xb0(%rsp)
movss  0x18(%rdi),%xmm11
movaps %xmm11,%xmm1
mulss  %xmm2,%xmm1
mulss  %xmm13,%xmm1
subss  %xmm1,%xmm0
movss  0x1c(%rdi),%xmm3
movaps %xmm2,%xmm1
mulss  %xmm3,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm4,%xmm7
addss  %xmm0,%xmm1
movss  0x34(%rdi),%xmm15
movaps %xmm11,%xmm14
mulss  %xmm15,%xmm14
mulss  %xmm6,%xmm14
addss  %xmm1,%xmm14
movaps %xmm3,%xmm0
mulss  %xmm15,%xmm0
mulss  %xmm8,%xmm0
subss  %xmm0,%xmm14
movsd  0xc(%rdi),%xmm1
movaps %xmm1,-0x20(%rsp)
shufps $0x55,%xmm1,%xmm1
movaps %xmm6,%xmm4
movaps %xmm6,%xmm9
movaps %xmm6,-0x50(%rsp)
mulss  %xmm1,%xmm4
movaps %xmm7,%xmm2
movaps %xmm7,%xmm5
movaps %xmm7,(%rsp)
mulss  %xmm4,%xmm2
mulss  %xmm1,%xmm8
movaps %xmm8,%xmm0
mulss  %xmm13,%xmm0
subss  %xmm0,%xmm2
movss  0x20(%rdi),%xmm10
movaps %xmm11,%xmm12
mulss  %xmm10,%xmm12
movaps %xmm12,%xmm6
mulss  %xmm13,%xmm6
addss  %xmm2,%xmm6
movaps %xmm3,%xmm7
mulss  %xmm10,%xmm7
movaps %xmm7,%xmm2
mulss  %xmm5,%xmm2
subss  %xmm2,%xmm6
movss  0x30(%rdi),%xmm0
movaps %xmm11,-0x30(%rsp)
mulss  %xmm0,%xmm11
movaps %xmm11,%xmm5
mulss  %xmm9,%xmm5
subss  %xmm5,%xmm6
movaps %xmm3,0x160(%rsp)
movaps %xmm3,%xmm5
mulss  %xmm0,%xmm5
movaps %xmm5,%xmm9
mulss  -0x40(%rsp),%xmm9
addss  %xmm6,%xmm9
movaps 0xb0(%rsp),%xmm3
movaps %xmm1,-0x80(%rsp)
mulss  %xmm1,%xmm3
mulss  %xmm15,%xmm4
movaps %xmm3,%xmm6
mulss  %xmm13,%xmm6
subss  %xmm4,%xmm6
movaps -0x10(%rsp),%xmm4
movaps %xmm4,%xmm2
movaps %xmm10,-0x60(%rsp)
mulss  %xmm10,%xmm2
movaps %xmm2,%xmm1
movaps %xmm13,0x190(%rsp)
mulss  %xmm13,%xmm1
subss  %xmm1,%xmm6
mulss  %xmm15,%xmm7
addss  %xmm6,%xmm7
movaps %xmm4,%xmm1
movaps %xmm0,-0x70(%rsp)
mulss  %xmm0,%xmm1
movaps %xmm1,%xmm13
mulss  -0x50(%rsp),%xmm13
addss  %xmm7,%xmm13
movaps 0xb0(%rsp),%xmm4
mulss  %xmm4,%xmm5
subss  %xmm5,%xmm13
mulss  %xmm15,%xmm8
movaps (%rsp),%xmm0
mulss  %xmm0,%xmm3
subss  %xmm3,%xmm8
mulss  %xmm0,%xmm2
addss  %xmm8,%xmm2
movaps %xmm15,0xa0(%rsp)
mulss  %xmm15,%xmm12
subss  %xmm12,%xmm2
mulss  -0x40(%rsp),%xmm1
subss  %xmm1,%xmm2
movaps %xmm4,%xmm0
mulss  %xmm4,%xmm11
addss  %xmm2,%xmm11
movss  0x4(%rdi),%xmm12
movaps %xmm12,%xmm0
movaps %xmm9,0x170(%rsp)
mulss  %xmm9,%xmm0
movss  (%rdi),%xmm10
movaps %xmm10,%xmm1
movaps %xmm14,0x140(%rsp)
mulss  %xmm14,%xmm1
addss  %xmm0,%xmm1
movss  0x8(%rdi),%xmm3
movaps %xmm3,%xmm0
movaps %xmm13,0x150(%rsp)
mulss  %xmm13,%xmm0
addss  %xmm1,%xmm0
movaps -0x20(%rsp),%xmm1
movaps %xmm1,%xmm2
movaps %xmm11,0x180(%rsp)
mulss  %xmm11,%xmm1
addss  %xmm0,%xmm1
xor    %eax,%eax
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
jne    139e <m44invf+0x29e>
jp     139e <m44invf+0x29e>
add    $0x1a8,%rsp
ret
movaps %xmm4,%xmm15
movaps 0xc57(%rip),%xmm0
movaps -0x60(%rsp),%xmm8
movaps %xmm8,%xmm6
xorps  %xmm0,%xmm6
movaps %xmm1,0x130(%rsp)
movaps -0x70(%rsp),%xmm1
movaps %xmm1,%xmm7
unpcklps %xmm3,%xmm7
movaps %xmm3,%xmm5
unpcklps %xmm6,%xmm5
mulps  %xmm7,%xmm5
movaps %xmm5,0x90(%rsp)
movaps %xmm1,%xmm5
xorps  %xmm0,%xmm5
movaps %xmm2,%xmm9
movaps %xmm2,%xmm7
shufps $0x0,%xmm2,%xmm7
movaps %xmm8,%xmm2
unpcklps %xmm5,%xmm2
mulps  %xmm7,%xmm2
movaps %xmm2,0x80(%rsp)
movaps %xmm12,%xmm7
unpcklps %xmm8,%xmm7
movaps %xmm5,%xmm2
unpcklps %xmm12,%xmm2
mulps  %xmm7,%xmm2
movaps %xmm2,0x70(%rsp)
movaps %xmm12,%xmm4
unpcklps %xmm1,%xmm4
movaps %xmm9,%xmm7
unpcklps %xmm9,%xmm1
movaps %xmm6,%xmm2
movlhps %xmm7,%xmm2
shufps $0xe2,%xmm7,%xmm2
movaps %xmm7,%xmm9
mulps  %xmm1,%xmm2
movaps %xmm2,0x60(%rsp)
unpcklps %xmm12,%xmm6
mulps  %xmm4,%xmm6
movaps %xmm6,-0x70(%rsp)
movaps %xmm3,%xmm1
unpcklps %xmm8,%xmm1
movaps %xmm5,%xmm7
unpcklps %xmm3,%xmm7
mulps  %xmm1,%xmm7
movaps %xmm7,0x40(%rsp)
movaps %xmm3,0x20(%rsp)
movaps -0x80(%rsp),%xmm8
xorps  %xmm0,%xmm8
movaps %xmm12,%xmm1
shufps $0xd4,%xmm9,%xmm1
shufps $0x52,%xmm9,%xmm1
movaps %xmm12,%xmm5
unpcklps %xmm8,%xmm5
mulps  %xmm1,%xmm5
movaps %xmm5,0x110(%rsp)
movaps %xmm9,%xmm1
movss  %xmm3,%xmm1
movaps %xmm12,%xmm4
movaps %xmm12,0x10(%rsp)
movaps %xmm8,0x100(%rsp)
unpcklps %xmm3,%xmm8
mulps  %xmm1,%xmm8
movaps -0x10(%rsp),%xmm2
movaps %xmm2,%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x120(%rsp)
movaps %xmm15,%xmm9
movaps %xmm15,%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,-0x60(%rsp)
movaps 0xa0(%rsp),%xmm12
movaps %xmm12,%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x50(%rsp)
movaps %xmm4,%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x30(%rsp)
xorps  %xmm10,%xmm0
movaps %xmm10,%xmm3
unpcklps %xmm0,%xmm3
shufps $0x0,%xmm2,%xmm2
movaps %xmm2,%xmm1
movaps -0x40(%rsp),%xmm4
movaps %xmm4,%xmm2
movaps %xmm4,%xmm7
mulss  %xmm0,%xmm2
movaps %xmm2,0xf0(%rsp)
movaps %xmm15,%xmm2
mulss  %xmm0,%xmm2
movaps %xmm2,0xe0(%rsp)
movaps -0x50(%rsp),%xmm2
movaps %xmm2,%xmm4
mulss  %xmm0,%xmm4
movaps %xmm4,0xd0(%rsp)
unpcklps %xmm10,%xmm0
movaps %xmm1,%xmm4
movaps %xmm1,-0x80(%rsp)
mulps  %xmm0,%xmm1
movaps -0x30(%rsp),%xmm14
shufps $0x0,%xmm14,%xmm14
mulps  %xmm14,%xmm0
movaps %xmm0,%xmm5
shufps $0xe1,%xmm0,%xmm5
movaps %xmm2,%xmm13
movaps %xmm10,0xc0(%rsp)
movaps %xmm12,%xmm2
unpcklps %xmm15,%xmm12
mulps  %xmm12,%xmm5
movaps (%rsp),%xmm11
unpcklps %xmm7,%xmm11
movaps %xmm1,%xmm7
mulps  %xmm11,%xmm7
addps  %xmm5,%xmm7
movaps %xmm13,%xmm5
movaps 0x190(%rsp),%xmm13
unpcklps %xmm13,%xmm5
mulps  %xmm5,%xmm1
movaps 0x110(%rsp),%xmm15
mulps  %xmm15,%xmm5
mulps  %xmm11,%xmm15
addps  %xmm7,%xmm15
mulps  %xmm8,%xmm12
addps  %xmm15,%xmm12
movaps 0x70(%rsp),%xmm10
mulps  %xmm14,%xmm10
addps  %xmm12,%xmm10
movaps 0x90(%rsp),%xmm7
mulps  %xmm4,%xmm7
addps  %xmm10,%xmm7
movaps %xmm7,-0x30(%rsp)
movaps 0x160(%rsp),%xmm4
shufps $0x0,%xmm4,%xmm4
movaps %xmm3,%xmm12
mulps  %xmm4,%xmm12
movaps -0x20(%rsp),%xmm10
movaps 0x100(%rsp),%xmm3
unpcklps %xmm10,%xmm3
mulps  %xmm10,%xmm3
movaps %xmm9,%xmm7
unpcklps %xmm2,%xmm7
movaps %xmm2,%xmm6
movaps %xmm3,%xmm15
mulps  %xmm7,%xmm15
mulps  %xmm12,%xmm7
addps  %xmm7,%xmm1
addps  %xmm1,%xmm5
addps  %xmm15,%xmm5
movaps -0x70(%rsp),%xmm1
mulps  %xmm4,%xmm1
addps  %xmm5,%xmm1
movaps -0x80(%rsp),%xmm2
mulps  0x80(%rsp),%xmm2
addps  %xmm1,%xmm2
movaps %xmm2,-0x80(%rsp)
mulps  %xmm11,%xmm12
movaps %xmm13,%xmm1
unpcklps -0x50(%rsp),%xmm1
mulps  %xmm1,%xmm0
addps  %xmm12,%xmm0
shufps $0xe1,%xmm8,%xmm8
mulps  %xmm1,%xmm8
addps  %xmm0,%xmm8
mulps  %xmm11,%xmm3
addps  %xmm8,%xmm3
movaps 0x40(%rsp),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm3,%xmm5
movaps 0x60(%rsp),%xmm15
mulps  %xmm14,%xmm15
addps  %xmm5,%xmm15
movaps %xmm10,%xmm5
unpcklps %xmm9,%xmm5
movaps 0x50(%rsp),%xmm12
unpcklps %xmm10,%xmm12
mulps  %xmm5,%xmm12
movaps %xmm6,%xmm0
movaps 0x20(%rsp),%xmm5
unpcklps %xmm5,%xmm0
movaps -0x60(%rsp),%xmm7
movlhps %xmm5,%xmm7
shufps $0xe2,%xmm5,%xmm7
mulps  %xmm0,%xmm7
movaps -0x10(%rsp),%xmm3
movaps %xmm3,%xmm8
unpcklps %xmm10,%xmm8
movaps 0x120(%rsp),%xmm2
movaps %xmm2,%xmm0
movlhps %xmm10,%xmm0
shufps $0xe2,%xmm10,%xmm0
mulps  %xmm8,%xmm0
movlhps %xmm5,%xmm3
shufps $0xe2,%xmm5,%xmm3
unpcklps %xmm5,%xmm2
mulps  %xmm3,%xmm2
movaps 0x30(%rsp),%xmm3
movaps %xmm3,%xmm5
movaps 0x10(%rsp),%xmm6
movlhps %xmm6,%xmm5
shufps $0xe2,%xmm6,%xmm5
mulps  %xmm14,%xmm5
movaps -0x40(%rsp),%xmm10
unpcklps %xmm6,%xmm3
mulps  %xmm4,%xmm3
mulps  %xmm11,%xmm3
mulps  %xmm1,%xmm5
addps  %xmm3,%xmm5
mulps  %xmm1,%xmm2
addps  %xmm5,%xmm2
mulps  %xmm11,%xmm0
addps  %xmm2,%xmm0
mulps  %xmm4,%xmm7
addps  %xmm0,%xmm7
mulps  %xmm14,%xmm12
addps  %xmm7,%xmm12
movaps %xmm9,%xmm0
movaps 0xc0(%rsp),%xmm6
mulss  %xmm6,%xmm0
movaps 0xa0(%rsp),%xmm8
movaps 0xf0(%rsp),%xmm1
mulss  %xmm8,%xmm1
movaps (%rsp),%xmm11
mulss  %xmm11,%xmm0
addss  %xmm1,%xmm0
movaps -0x70(%rsp),%xmm3
movaps %xmm3,%xmm1
mulss  %xmm11,%xmm1
addss  %xmm0,%xmm1
movaps 0x40(%rsp),%xmm2
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
mulss  %xmm8,%xmm0
addss  %xmm1,%xmm0
shufps $0x55,%xmm3,%xmm3
mulss  %xmm10,%xmm3
addss  %xmm0,%xmm3
mulss  %xmm9,%xmm2
addss  %xmm3,%xmm2
movaps -0x50(%rsp),%xmm4
movaps %xmm4,%xmm0
mulss  %xmm6,%xmm0
mulss  %xmm8,%xmm0
movaps 0xe0(%rsp),%xmm1
mulss  %xmm13,%xmm1
addss  %xmm0,%xmm1
movaps 0x70(%rsp),%xmm5
movaps %xmm5,%xmm0
shufps $0x55,%xmm5,%xmm0
mulss  %xmm13,%xmm0
addss  %xmm1,%xmm0
movaps 0x60(%rsp),%xmm3
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
mulss  %xmm8,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm4,%xmm5
addss  %xmm1,%xmm5
mulss  %xmm9,%xmm3
addss  %xmm5,%xmm3
movaps %xmm3,%xmm5
movaps %xmm6,%xmm1
mulss  %xmm10,%xmm1
movaps 0xd0(%rsp),%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm13,%xmm1
addss  %xmm0,%xmm1
movaps 0x90(%rsp),%xmm7
movaps %xmm7,%xmm0
shufps $0x55,%xmm7,%xmm0
mulss  %xmm13,%xmm0
addss  %xmm1,%xmm0
movaps 0x80(%rsp),%xmm3
movaps %xmm3,%xmm1
mulss  %xmm11,%xmm1
addss  %xmm0,%xmm1
mulss  %xmm4,%xmm7
addss  %xmm1,%xmm7
shufps $0x55,%xmm3,%xmm3
mulss  %xmm10,%xmm3
addss  %xmm7,%xmm3
movaps -0x20(%rsp),%xmm0
mulss  %xmm0,%xmm8
movaps -0x60(%rsp),%xmm6
mulss  %xmm0,%xmm6
movaps 0x50(%rsp),%xmm1
movaps 0x20(%rsp),%xmm0
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm9
movaps 0x30(%rsp),%xmm7
mulss  %xmm10,%xmm7
movaps 0x10(%rsp),%xmm0
mulss  %xmm4,%xmm0
mulss  %xmm11,%xmm0
mulss  %xmm13,%xmm7
addss  %xmm0,%xmm7
mulss  %xmm13,%xmm9
addss  %xmm7,%xmm9
movaps %xmm6,%xmm0
mulss  %xmm11,%xmm0
addss  %xmm9,%xmm0
movaps %xmm0,%xmm6
movaps %xmm1,%xmm0
mulss  %xmm4,%xmm0
addss  %xmm6,%xmm0
mulss  %xmm10,%xmm8
addss  %xmm0,%xmm8
movss  0x72b(%rip),%xmm0
divss  0x130(%rsp),%xmm0
movaps 0x140(%rsp),%xmm1
unpcklps %xmm8,%xmm1
movlhps %xmm12,%xmm1
shufps $0x0,%xmm0,%xmm0
mulps  %xmm0,%xmm1
movups %xmm1,(%rsi)
movaps 0x170(%rsp),%xmm1
unpcklps %xmm3,%xmm1
movlhps %xmm15,%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,0x10(%rsi)
movaps 0x150(%rsp),%xmm1
unpcklps %xmm5,%xmm1
shufps $0x14,-0x80(%rsp),%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,0x20(%rsi)
movaps 0x180(%rsp),%xmm1
unpcklps %xmm2,%xmm1
unpcklpd -0x30(%rsp),%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,0x30(%rsi)
mov    $0x1,%eax
add    $0x1a8,%rsp
ret

LLVM IR (-O0):
define i32 @m44invf(float* %0, float* %1) {
%3 = alloca i32
%4 = alloca float*
%5 = alloca float*
%6 = alloca [16 x float]
%7 = alloca float
%8 = alloca i32
store float* %0, float** %4
store float* %1, float** %5
%9 = load float*, float** %4
%10 = getelementptr inbounds float, float* %9, i64 5
%11 = load float, float* %10
%12 = load float*, float** %4
%13 = getelementptr inbounds float, float* %12, i64 10
%14 = load float, float* %13
%15 = fmul float %11, %14
%16 = load float*, float** %4
%17 = getelementptr inbounds float, float* %16, i64 15
%18 = load float, float* %17
%19 = load float*, float** %4
%20 = getelementptr inbounds float, float* %19, i64 5
%21 = load float, float* %20
%22 = load float*, float** %4
%23 = getelementptr inbounds float, float* %22, i64 11
%24 = load float, float* %23
%25 = fmul float %21, %24
%26 = load float*, float** %4
%27 = getelementptr inbounds float, float* %26, i64 14
%28 = load float, float* %27
%29 = fmul float %25, %28
%30 = fneg float %29
%31 = call float @llvm.fmuladd.f32(float %15, float %18, float %30)
%32 = load float*, float** %4
%33 = getelementptr inbounds float, float* %32, i64 9
%34 = load float, float* %33
%35 = load float*, float** %4
%36 = getelementptr inbounds float, float* %35, i64 6
%37 = load float, float* %36
%38 = fmul float %34, %37
%39 = load float*, float** %4
%40 = getelementptr inbounds float, float* %39, i64 15
%41 = load float, float* %40
%42 = fneg float %38
%43 = call float @llvm.fmuladd.f32(float %42, float %41, float %31)
%44 = load float*, float** %4
%45 = getelementptr inbounds float, float* %44, i64 9
%46 = load float, float* %45
%47 = load float*, float** %4
%48 = getelementptr inbounds float, float* %47, i64 7
%49 = load float, float* %48
%50 = fmul float %46, %49
%51 = load float*, float** %4
%52 = getelementptr inbounds float, float* %51, i64 14
%53 = load float, float* %52
%54 = call float @llvm.fmuladd.f32(float %50, float %53, float %43)
%55 = load float*, float** %4
%56 = getelementptr inbounds float, float* %55, i64 13
%57 = load float, float* %56
%58 = load float*, float** %4
%59 = getelementptr inbounds float, float* %58, i64 6
%60 = load float, float* %59
%61 = fmul float %57, %60
%62 = load float*, float** %4
%63 = getelementptr inbounds float, float* %62, i64 11
%64 = load float, float* %63
%65 = call float @llvm.fmuladd.f32(float %61, float %64, float %54)
%66 = load float*, float** %4
%67 = getelementptr inbounds float, float* %66, i64 13
%68 = load float, float* %67
%69 = load float*, float** %4
%70 = getelementptr inbounds float, float* %69, i64 7
%71 = load float, float* %70
%72 = fmul float %68, %71
%73 = load float*, float** %4
%74 = getelementptr inbounds float, float* %73, i64 10
%75 = load float, float* %74
%76 = fneg float %72
%77 = call float @llvm.fmuladd.f32(float %76, float %75, float %65)
%78 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 0
store float %77, float* %78
%79 = load float*, float** %4
%80 = getelementptr inbounds float, float* %79, i64 4
%81 = load float, float* %80
%82 = fneg float %81
%83 = load float*, float** %4
%84 = getelementptr inbounds float, float* %83, i64 10
%85 = load float, float* %84
%86 = fmul float %82, %85
%87 = load float*, float** %4
%88 = getelementptr inbounds float, float* %87, i64 15
%89 = load float, float* %88
%90 = load float*, float** %4
%91 = getelementptr inbounds float, float* %90, i64 4
%92 = load float, float* %91
%93 = load float*, float** %4
%94 = getelementptr inbounds float, float* %93, i64 11
%95 = load float, float* %94
%96 = fmul float %92, %95
%97 = load float*, float** %4
%98 = getelementptr inbounds float, float* %97, i64 14
%99 = load float, float* %98
%100 = fmul float %96, %99
%101 = call float @llvm.fmuladd.f32(float %86, float %89, float %100)
%102 = load float*, float** %4
%103 = getelementptr inbounds float, float* %102, i64 8
%104 = load float, float* %103
%105 = load float*, float** %4
%106 = getelementptr inbounds float, float* %105, i64 6
%107 = load float, float* %106
%108 = fmul float %104, %107
%109 = load float*, float** %4
%110 = getelementptr inbounds float, float* %109, i64 15
%111 = load float, float* %110
%112 = call float @llvm.fmuladd.f32(float %108, float %111, float %101)
%113 = load float*, float** %4
%114 = getelementptr inbounds float, float* %113, i64 8
%115 = load float, float* %114
%116 = load float*, float** %4
%117 = getelementptr inbounds float, float* %116, i64 7
%118 = load float, float* %117
%119 = fmul float %115, %118
%120 = load float*, float** %4
%121 = getelementptr inbounds float, float* %120, i64 14
%122 = load float, float* %121
%123 = fneg float %119
%124 = call float @llvm.fmuladd.f32(float %123, float %122, float %112)
%125 = load float*, float** %4
%126 = getelementptr inbounds float, float* %125, i64 12
%127 = load float, float* %126
%128 = load float*, float** %4
%129 = getelementptr inbounds float, float* %128, i64 6
%130 = load float, float* %129
%131 = fmul float %127, %130
%132 = load float*, float** %4
%133 = getelementptr inbounds float, float* %132, i64 11
%134 = load float, float* %133
%135 = fneg float %131
%136 = call float @llvm.fmuladd.f32(float %135, float %134, float %124)
%137 = load float*, float** %4
%138 = getelementptr inbounds float, float* %137, i64 12
%139 = load float, float* %138
%140 = load float*, float** %4
%141 = getelementptr inbounds float, float* %140, i64 7
%142 = load float, float* %141
%143 = fmul float %139, %142
%144 = load float*, float** %4
%145 = getelementptr inbounds float, float* %144, i64 10
%146 = load float, float* %145
%147 = call float @llvm.fmuladd.f32(float %143, float %146, float %136)
%148 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 4
store float %147, float* %148
%149 = load float*, float** %4
%150 = getelementptr inbounds float, float* %149, i64 4
%151 = load float, float* %150
%152 = load float*, float** %4
%153 = getelementptr inbounds float, float* %152, i64 9
%154 = load float, float* %153
%155 = fmul float %151, %154
%156 = load float*, float** %4
%157 = getelementptr inbounds float, float* %156, i64 15
%158 = load float, float* %157
%159 = load float*, float** %4
%160 = getelementptr inbounds float, float* %159, i64 4
%161 = load float, float* %160
%162 = load float*, float** %4
%163 = getelementptr inbounds float, float* %162, i64 11
%164 = load float, float* %163
%165 = fmul float %161, %164
%166 = load float*, float** %4
%167 = getelementptr inbounds float, float* %166, i64 13
%168 = load float, float* %167
%169 = fmul float %165, %168
%170 = fneg float %169
%171 = call float @llvm.fmuladd.f32(float %155, float %158, float %170)
%172 = load float*, float** %4
%173 = getelementptr inbounds float, float* %172, i64 8
%174 = load float, float* %173
%175 = load float*, float** %4
%176 = getelementptr inbounds float, float* %175, i64 5
%177 = load float, float* %176
%178 = fmul float %174, %177
%179 = load float*, float** %4
%180 = getelementptr inbounds float, float* %179, i64 15
%181 = load float, float* %180
%182 = fneg float %178
%183 = call float @llvm.fmuladd.f32(float %182, float %181, float %171)
%184 = load float*, float** %4
%185 = getelementptr inbounds float, float* %184, i64 8
%186 = load float, float* %185
%187 = load float*, float** %4
%188 = getelementptr inbounds float, float* %187, i64 7
%189 = load float, float* %188
%190 = fmul float %186, %189
%191 = load float*, float** %4
%192 = getelementptr inbounds float, float* %191, i64 13
%193 = load float, float* %192
%194 = call float @llvm.fmuladd.f32(float %190, float %193, float %183)
%195 = load float*, float** %4
%196 = getelementptr inbounds float, float* %195, i64 12
%197 = load float, float* %196
%198 = load float*, float** %4
%199 = getelementptr inbounds float, float* %198, i64 5
%200 = load float, float* %199
%201 = fmul float %197, %200
%202 = load float*, float** %4
%203 = getelementptr inbounds float, float* %202, i64 11
%204 = load float, float* %203
%205 = call float @llvm.fmuladd.f32(float %201, float %204, float %194)
%206 = load float*, float** %4
%207 = getelementptr inbounds float, float* %206, i64 12
%208 = load float, float* %207
%209 = load float*, float** %4
%210 = getelementptr inbounds float, float* %209, i64 7
%211 = load float, float* %210
%212 = fmul float %208, %211
%213 = load float*, float** %4
%214 = getelementptr inbounds float, float* %213, i64 9
%215 = load float, float* %214
%216 = fneg float %212
%217 = call float @llvm.fmuladd.f32(float %216, float %215, float %205)
%218 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 8
store float %217, float* %218
%219 = load float*, float** %4
%220 = getelementptr inbounds float, float* %219, i64 4
%221 = load float, float* %220
%222 = fneg float %221
%223 = load float*, float** %4
%224 = getelementptr inbounds float, float* %223, i64 9
%225 = load float, float* %224
%226 = fmul float %222, %225
%227 = load float*, float** %4
%228 = getelementptr inbounds float, float* %227, i64 14
%229 = load float, float* %228
%230 = load float*, float** %4
%231 = getelementptr inbounds float, float* %230, i64 4
%232 = load float, float* %231
%233 = load float*, float** %4
%234 = getelementptr inbounds float, float* %233, i64 10
%235 = load float, float* %234
%236 = fmul float %232, %235
%237 = load float*, float** %4
%238 = getelementptr inbounds float, float* %237, i64 13
%239 = load float, float* %238
%240 = fmul float %236, %239
%241 = call float @llvm.fmuladd.f32(float %226, float %229, float %240)
%242 = load float*, float** %4
%243 = getelementptr inbounds float, float* %242, i64 8
%244 = load float, float* %243
%245 = load float*, float** %4
%246 = getelementptr inbounds float, float* %245, i64 5
%247 = load float, float* %246
%248 = fmul float %244, %247
%249 = load float*, float** %4
%250 = getelementptr inbounds float, float* %249, i64 14
%251 = load float, float* %250
%252 = call float @llvm.fmuladd.f32(float %248, float %251, float %241)
%253 = load float*, float** %4
%254 = getelementptr inbounds float, float* %253, i64 8
%255 = load float, float* %254
%256 = load float*, float** %4
%257 = getelementptr inbounds float, float* %256, i64 6
%258 = load float, float* %257
%259 = fmul float %255, %258
%260 = load float*, float** %4
%261 = getelementptr inbounds float, float* %260, i64 13
%262 = load float, float* %261
%263 = fneg float %259
%264 = call float @llvm.fmuladd.f32(float %263, float %262, float %252)
%265 = load float*, float** %4
%266 = getelementptr inbounds float, float* %265, i64 12
%267 = load float, float* %266
%268 = load float*, float** %4
%269 = getelementptr inbounds float, float* %268, i64 5
%270 = load float, float* %269
%271 = fmul float %267, %270
%272 = load float*, float** %4
%273 = getelementptr inbounds float, float* %272, i64 10
%274 = load float, float* %273
%275 = fneg float %271
%276 = call float @llvm.fmuladd.f32(float %275, float %274, float %264)
%277 = load float*, float** %4
%278 = getelementptr inbounds float, float* %277, i64 12
%279 = load float, float* %278
%280 = load float*, float** %4
%281 = getelementptr inbounds float, float* %280, i64 6
%282 = load float, float* %281
%283 = fmul float %279, %282
%284 = load float*, float** %4
%285 = getelementptr inbounds float, float* %284, i64 9
%286 = load float, float* %285
%287 = call float @llvm.fmuladd.f32(float %283, float %286, float %276)
%288 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 12
store float %287, float* %288
%289 = load float*, float** %4
%290 = getelementptr inbounds float, float* %289, i64 1
%291 = load float, float* %290
%292 = fneg float %291
%293 = load float*, float** %4
%294 = getelementptr inbounds float, float* %293, i64 10
%295 = load float, float* %294
%296 = fmul float %292, %295
%297 = load float*, float** %4
%298 = getelementptr inbounds float, float* %297, i64 15
%299 = load float, float* %298
%300 = load float*, float** %4
%301 = getelementptr inbounds float, float* %300, i64 1
%302 = load float, float* %301
%303 = load float*, float** %4
%304 = getelementptr inbounds float, float* %303, i64 11
%305 = load float, float* %304
%306 = fmul float %302, %305
%307 = load float*, float** %4
%308 = getelementptr inbounds float, float* %307, i64 14
%309 = load float, float* %308
%310 = fmul float %306, %309
%311 = call float @llvm.fmuladd.f32(float %296, float %299, float %310)
%312 = load float*, float** %4
%313 = getelementptr inbounds float, float* %312, i64 9
%314 = load float, float* %313
%315 = load float*, float** %4
%316 = getelementptr inbounds float, float* %315, i64 2
%317 = load float, float* %316
%318 = fmul float %314, %317
%319 = load float*, float** %4
%320 = getelementptr inbounds float, float* %319, i64 15
%321 = load float, float* %320
%322 = call float @llvm.fmuladd.f32(float %318, float %321, float %311)
%323 = load float*, float** %4
%324 = getelementptr inbounds float, float* %323, i64 9
%325 = load float, float* %324
%326 = load float*, float** %4
%327 = getelementptr inbounds float, float* %326, i64 3
%328 = load float, float* %327
%329 = fmul float %325, %328
%330 = load float*, float** %4
%331 = getelementptr inbounds float, float* %330, i64 14
%332 = load float, float* %331
%333 = fneg float %329
%334 = call float @llvm.fmuladd.f32(float %333, float %332, float %322)
%335 = load float*, float** %4
%336 = getelementptr inbounds float, float* %335, i64 13
%337 = load float, float* %336
%338 = load float*, float** %4
%339 = getelementptr inbounds float, float* %338, i64 2
%340 = load float, float* %339
%341 = fmul float %337, %340
%342 = load float*, float** %4
%343 = getelementptr inbounds float, float* %342, i64 11
%344 = load float, float* %343
%345 = fneg float %341
%346 = call float @llvm.fmuladd.f32(float %345, float %344, float %334)
%347 = load float*, float** %4
%348 = getelementptr inbounds float, float* %347, i64 13
%349 = load float, float* %348
%350 = load float*, float** %4
%351 = getelementptr inbounds float, float* %350, i64 3
%352 = load float, float* %351
%353 = fmul float %349, %352
%354 = load float*, float** %4
%355 = getelementptr inbounds float, float* %354, i64 10
%356 = load float, float* %355
%357 = call float @llvm.fmuladd.f32(float %353, float %356, float %346)
%358 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 1
store float %357, float* %358
%359 = load float*, float** %4
%360 = getelementptr inbounds float, float* %359, i64 0
%361 = load float, float* %360
%362 = load float*, float** %4
%363 = getelementptr inbounds float, float* %362, i64 10
%364 = load float, float* %363
%365 = fmul float %361, %364
%366 = load float*, float** %4
%367 = getelementptr inbounds float, float* %366, i64 15
%368 = load float, float* %367
%369 = load float*, float** %4
%370 = getelementptr inbounds float, float* %369, i64 0
%371 = load float, float* %370
%372 = load float*, float** %4
%373 = getelementptr inbounds float, float* %372, i64 11
%374 = load float, float* %373
%375 = fmul float %371, %374
%376 = load float*, float** %4
%377 = getelementptr inbounds float, float* %376, i64 14
%378 = load float, float* %377
%379 = fmul float %375, %378
%380 = fneg float %379
%381 = call float @llvm.fmuladd.f32(float %365, float %368, float %380)
%382 = load float*, float** %4
%383 = getelementptr inbounds float, float* %382, i64 8
%384 = load float, float* %383
%385 = load float*, float** %4
%386 = getelementptr inbounds float, float* %385, i64 2
%387 = load float, float* %386
%388 = fmul float %384, %387
%389 = load float*, float** %4
%390 = getelementptr inbounds float, float* %389, i64 15
%391 = load float, float* %390
%392 = fneg float %388
%393 = call float @llvm.fmuladd.f32(float %392, float %391, float %381)
%394 = load float*, float** %4
%395 = getelementptr inbounds float, float* %394, i64 8
%396 = load float, float* %395
%397 = load float*, float** %4
%398 = getelementptr inbounds float, float* %397, i64 3
%399 = load float, float* %398
%400 = fmul float %396, %399
%401 = load float*, float** %4
%402 = getelementptr inbounds float, float* %401, i64 14
%403 = load float, float* %402
%404 = call float @llvm.fmuladd.f32(float %400, float %403, float %393)
%405 = load float*, float** %4
%406 = getelementptr inbounds float, float* %405, i64 12
%407 = load float, float* %406
%408 = load float*, float** %4
%409 = getelementptr inbounds float, float* %408, i64 2
%410 = load float, float* %409
%411 = fmul float %407, %410
%412 = load float*, float** %4
%413 = getelementptr inbounds float, float* %412, i64 11
%414 = load float, float* %413
%415 = call float @llvm.fmuladd.f32(float %411, float %414, float %404)
%416 = load float*, float** %4
%417 = getelementptr inbounds float, float* %416, i64 12
%418 = load float, float* %417
%419 = load float*, float** %4
%420 = getelementptr inbounds float, float* %419, i64 3
%421 = load float, float* %420
%422 = fmul float %418, %421
%423 = load float*, float** %4
%424 = getelementptr inbounds float, float* %423, i64 10
%425 = load float, float* %424
%426 = fneg float %422
%427 = call float @llvm.fmuladd.f32(float %426, float %425, float %415)
%428 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 5
store float %427, float* %428
%429 = load float*, float** %4
%430 = getelementptr inbounds float, float* %429, i64 0
%431 = load float, float* %430
%432 = fneg float %431
%433 = load float*, float** %4
%434 = getelementptr inbounds float, float* %433, i64 9
%435 = load float, float* %434
%436 = fmul float %432, %435
%437 = load float*, float** %4
%438 = getelementptr inbounds float, float* %437, i64 15
%439 = load float, float* %438
%440 = load float*, float** %4
%441 = getelementptr inbounds float, float* %440, i64 0
%442 = load float, float* %441
%443 = load float*, float** %4
%444 = getelementptr inbounds float, float* %443, i64 11
%445 = load float, float* %444
%446 = fmul float %442, %445
%447 = load float*, float** %4
%448 = getelementptr inbounds float, float* %447, i64 13
%449 = load float, float* %448
%450 = fmul float %446, %449
%451 = call float @llvm.fmuladd.f32(float %436, float %439, float %450)
%452 = load float*, float** %4
%453 = getelementptr inbounds float, float* %452, i64 8
%454 = load float, float* %453
%455 = load float*, float** %4
%456 = getelementptr inbounds float, float* %455, i64 1
%457 = load float, float* %456
%458 = fmul float %454, %457
%459 = load float*, float** %4
%460 = getelementptr inbounds float, float* %459, i64 15
%461 = load float, float* %460
%462 = call float @llvm.fmuladd.f32(float %458, float %461, float %451)
%463 = load float*, float** %4
%464 = getelementptr inbounds float, float* %463, i64 8
%465 = load float, float* %464
%466 = load float*, float** %4
%467 = getelementptr inbounds float, float* %466, i64 3
%468 = load float, float* %467
%469 = fmul float %465, %468
%470 = load float*, float** %4
%471 = getelementptr inbounds float, float* %470, i64 13
%472 = load float, float* %471
%473 = fneg float %469
%474 = call float @llvm.fmuladd.f32(float %473, float %472, float %462)
%475 = load float*, float** %4
%476 = getelementptr inbounds float, float* %475, i64 12
%477 = load float, float* %476
%478 = load float*, float** %4
%479 = getelementptr inbounds float, float* %478, i64 1
%480 = load float, float* %479
%481 = fmul float %477, %480
%482 = load float*, float** %4
%483 = getelementptr inbounds float, float* %482, i64 11
%484 = load float, float* %483
%485 = fneg float %481
%486 = call float @llvm.fmuladd.f32(float %485, float %484, float %474)
%487 = load float*, float** %4
%488 = getelementptr inbounds float, float* %487, i64 12
%489 = load float, float* %488
%490 = load float*, float** %4
%491 = getelementptr inbounds float, float* %490, i64 3
%492 = load float, float* %491
%493 = fmul float %489, %492
%494 = load float*, float** %4
%495 = getelementptr inbounds float, float* %494, i64 9
%496 = load float, float* %495
%497 = call float @llvm.fmuladd.f32(float %493, float %496, float %486)
%498 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 9
store float %497, float* %498
%499 = load float*, float** %4
%500 = getelementptr inbounds float, float* %499, i64 0
%501 = load float, float* %500
%502 = load float*, float** %4
%503 = getelementptr inbounds float, float* %502, i64 9
%504 = load float, float* %503
%505 = fmul float %501, %504
%506 = load float*, float** %4
%507 = getelementptr inbounds float, float* %506, i64 14
%508 = load float, float* %507
%509 = load float*, float** %4
%510 = getelementptr inbounds float, float* %509, i64 0
%511 = load float, float* %510
%512 = load float*, float** %4
%513 = getelementptr inbounds float, float* %512, i64 10
%514 = load float, float* %513
%515 = fmul float %511, %514
%516 = load float*, float** %4
%517 = getelementptr inbounds float, float* %516, i64 13
%518 = load float, float* %517
%519 = fmul float %515, %518
%520 = fneg float %519
%521 = call float @llvm.fmuladd.f32(float %505, float %508, float %520)
%522 = load float*, float** %4
%523 = getelementptr inbounds float, float* %522, i64 8
%524 = load float, float* %523
%525 = load float*, float** %4
%526 = getelementptr inbounds float, float* %525, i64 1
%527 = load float, float* %526
%528 = fmul float %524, %527
%529 = load float*, float** %4
%530 = getelementptr inbounds float, float* %529, i64 14
%531 = load float, float* %530
%532 = fneg float %528
%533 = call float @llvm.fmuladd.f32(float %532, float %531, float %521)
%534 = load float*, float** %4
%535 = getelementptr inbounds float, float* %534, i64 8
%536 = load float, float* %535
%537 = load float*, float** %4
%538 = getelementptr inbounds float, float* %537, i64 2
%539 = load float, float* %538
%540 = fmul float %536, %539
%541 = load float*, float** %4
%542 = getelementptr inbounds float, float* %541, i64 13
%543 = load float, float* %542
%544 = call float @llvm.fmuladd.f32(float %540, float %543, float %533)
%545 = load float*, float** %4
%546 = getelementptr inbounds float, float* %545, i64 12
%547 = load float, float* %546
%548 = load float*, float** %4
%549 = getelementptr inbounds float, float* %548, i64 1
%550 = load float, float* %549
%551 = fmul float %547, %550
%552 = load float*, float** %4
%553 = getelementptr inbounds float, float* %552, i64 10
%554 = load float, float* %553
%555 = call float @llvm.fmuladd.f32(float %551, float %554, float %544)
%556 = load float*, float** %4
%557 = getelementptr inbounds float, float* %556, i64 12
%558 = load float, float* %557
%559 = load float*, float** %4
%560 = getelementptr inbounds float, float* %559, i64 2
%561 = load float, float* %560
%562 = fmul float %558, %561
%563 = load float*, float** %4
%564 = getelementptr inbounds float, float* %563, i64 9
%565 = load float, float* %564
%566 = fneg float %562
%567 = call float @llvm.fmuladd.f32(float %566, float %565, float %555)
%568 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 13
store float %567, float* %568
%569 = load float*, float** %4
%570 = getelementptr inbounds float, float* %569, i64 1
%571 = load float, float* %570
%572 = load float*, float** %4
%573 = getelementptr inbounds float, float* %572, i64 6
%574 = load float, float* %573
%575 = fmul float %571, %574
%576 = load float*, float** %4
%577 = getelementptr inbounds float, float* %576, i64 15
%578 = load float, float* %577
%579 = load float*, float** %4
%580 = getelementptr inbounds float, float* %579, i64 1
%581 = load float, float* %580
%582 = load float*, float** %4
%583 = getelementptr inbounds float, float* %582, i64 7
%584 = load float, float* %583
%585 = fmul float %581, %584
%586 = load float*, float** %4
%587 = getelementptr inbounds float, float* %586, i64 14
%588 = load float, float* %587
%589 = fmul float %585, %588
%590 = fneg float %589
%591 = call float @llvm.fmuladd.f32(float %575, float %578, float %590)
%592 = load float*, float** %4
%593 = getelementptr inbounds float, float* %592, i64 5
%594 = load float, float* %593
%595 = load float*, float** %4
%596 = getelementptr inbounds float, float* %595, i64 2
%597 = load float, float* %596
%598 = fmul float %594, %597
%599 = load float*, float** %4
%600 = getelementptr inbounds float, float* %599, i64 15
%601 = load float, float* %600
%602 = fneg float %598
%603 = call float @llvm.fmuladd.f32(float %602, float %601, float %591)
%604 = load float*, float** %4
%605 = getelementptr inbounds float, float* %604, i64 5
%606 = load float, float* %605
%607 = load float*, float** %4
%608 = getelementptr inbounds float, float* %607, i64 3
%609 = load float, float* %608
%610 = fmul float %606, %609
%611 = load float*, float** %4
%612 = getelementptr inbounds float, float* %611, i64 14
%613 = load float, float* %612
%614 = call float @llvm.fmuladd.f32(float %610, float %613, float %603)
%615 = load float*, float** %4
%616 = getelementptr inbounds float, float* %615, i64 13
%617 = load float, float* %616
%618 = load float*, float** %4
%619 = getelementptr inbounds float, float* %618, i64 2
%620 = load float, float* %619
%621 = fmul float %617, %620
%622 = load float*, float** %4
%623 = getelementptr inbounds float, float* %622, i64 7
%624 = load float, float* %623
%625 = call float @llvm.fmuladd.f32(float %621, float %624, float %614)
%626 = load float*, float** %4
%627 = getelementptr inbounds float, float* %626, i64 13
%628 = load float, float* %627
%629 = load float*, float** %4
%630 = getelementptr inbounds float, float* %629, i64 3
%631 = load float, float* %630
%632 = fmul float %628, %631
%633 = load float*, float** %4
%634 = getelementptr inbounds float, float* %633, i64 6
%635 = load float, float* %634
%636 = fneg float %632
%637 = call float @llvm.fmuladd.f32(float %636, float %635, float %625)
%638 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 2
store float %637, float* %638
%639 = load float*, float** %4
%640 = getelementptr inbounds float, float* %639, i64 0
%641 = load float, float* %640
%642 = fneg float %641
%643 = load float*, float** %4
%644 = getelementptr inbounds float, float* %643, i64 6
%645 = load float, float* %644
%646 = fmul float %642, %645
%647 = load float*, float** %4
%648 = getelementptr inbounds float, float* %647, i64 15
%649 = load float, float* %648
%650 = load float*, float** %4
%651 = getelementptr inbounds float, float* %650, i64 0
%652 = load float, float* %651
%653 = load float*, float** %4
%654 = getelementptr inbounds float, float* %653, i64 7
%655 = load float, float* %654
%656 = fmul float %652, %655
%657 = load float*, float** %4
%658 = getelementptr inbounds float, float* %657, i64 14
%659 = load float, float* %658
%660 = fmul float %656, %659
%661 = call float @llvm.fmuladd.f32(float %646, float %649, float %660)
%662 = load float*, float** %4
%663 = getelementptr inbounds float, float* %662, i64 4
%664 = load float, float* %663
%665 = load float*, float** %4
%666 = getelementptr inbounds float, float* %665, i64 2
%667 = load float, float* %666
%668 = fmul float %664, %667
%669 = load float*, float** %4
%670 = getelementptr inbounds float, float* %669, i64 15
%671 = load float, float* %670
%672 = call float @llvm.fmuladd.f32(float %668, float %671, float %661)
%673 = load float*, float** %4
%674 = getelementptr inbounds float, float* %673, i64 4
%675 = load float, float* %674
%676 = load float*, float** %4
%677 = getelementptr inbounds float, float* %676, i64 3
%678 = load float, float* %677
%679 = fmul float %675, %678
%680 = load float*, float** %4
%681 = getelementptr inbounds float, float* %680, i64 14
%682 = load float, float* %681
%683 = fneg float %679
%684 = call float @llvm.fmuladd.f32(float %683, float %682, float %672)
%685 = load float*, float** %4
%686 = getelementptr inbounds float, float* %685, i64 12
%687 = load float, float* %686
%688 = load float*, float** %4
%689 = getelementptr inbounds float, float* %688, i64 2
%690 = load float, float* %689
%691 = fmul float %687, %690
%692 = load float*, float** %4
%693 = getelementptr inbounds float, float* %692, i64 7
%694 = load float, float* %693
%695 = fneg float %691
%696 = call float @llvm.fmuladd.f32(float %695, float %694, float %684)
%697 = load float*, float** %4
%698 = getelementptr inbounds float, float* %697, i64 12
%699 = load float, float* %698
%700 = load float*, float** %4
%701 = getelementptr inbounds float, float* %700, i64 3
%702 = load float, float* %701
%703 = fmul float %699, %702
%704 = load float*, float** %4
%705 = getelementptr inbounds float, float* %704, i64 6
%706 = load float, float* %705
%707 = call float @llvm.fmuladd.f32(float %703, float %706, float %696)
%708 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 6
store float %707, float* %708
%709 = load float*, float** %4
%710 = getelementptr inbounds float, float* %709, i64 0
%711 = load float, float* %710
%712 = load float*, float** %4
%713 = getelementptr inbounds float, float* %712, i64 5
%714 = load float, float* %713
%715 = fmul float %711, %714
%716 = load float*, float** %4
%717 = getelementptr inbounds float, float* %716, i64 15
%718 = load float, float* %717
%719 = load float*, float** %4
%720 = getelementptr inbounds float, float* %719, i64 0
%721 = load float, float* %720
%722 = load float*, float** %4
%723 = getelementptr inbounds float, float* %722, i64 7
%724 = load float, float* %723
%725 = fmul float %721, %724
%726 = load float*, float** %4
%727 = getelementptr inbounds float, float* %726, i64 13
%728 = load float, float* %727
%729 = fmul float %725, %728
%730 = fneg float %729
%731 = call float @llvm.fmuladd.f32(float %715, float %718, float %730)
%732 = load float*, float** %4
%733 = getelementptr inbounds float, float* %732, i64 4
%734 = load float, float* %733
%735 = load float*, float** %4
%736 = getelementptr inbounds float, float* %735, i64 1
%737 = load float, float* %736
%738 = fmul float %734, %737
%739 = load float*, float** %4
%740 = getelementptr inbounds float, float* %739, i64 15
%741 = load float, float* %740
%742 = fneg float %738
%743 = call float @llvm.fmuladd.f32(float %742, float %741, float %731)
%744 = load float*, float** %4
%745 = getelementptr inbounds float, float* %744, i64 4
%746 = load float, float* %745
%747 = load float*, float** %4
%748 = getelementptr inbounds float, float* %747, i64 3
%749 = load float, float* %748
%750 = fmul float %746, %749
%751 = load float*, float** %4
%752 = getelementptr inbounds float, float* %751, i64 13
%753 = load float, float* %752
%754 = call float @llvm.fmuladd.f32(float %750, float %753, float %743)
%755 = load float*, float** %4
%756 = getelementptr inbounds float, float* %755, i64 12
%757 = load float, float* %756
%758 = load float*, float** %4
%759 = getelementptr inbounds float, float* %758, i64 1
%760 = load float, float* %759
%761 = fmul float %757, %760
%762 = load float*, float** %4
%763 = getelementptr inbounds float, float* %762, i64 7
%764 = load float, float* %763
%765 = call float @llvm.fmuladd.f32(float %761, float %764, float %754)
%766 = load float*, float** %4
%767 = getelementptr inbounds float, float* %766, i64 12
%768 = load float, float* %767
%769 = load float*, float** %4
%770 = getelementptr inbounds float, float* %769, i64 3
%771 = load float, float* %770
%772 = fmul float %768, %771
%773 = load float*, float** %4
%774 = getelementptr inbounds float, float* %773, i64 5
%775 = load float, float* %774
%776 = fneg float %772
%777 = call float @llvm.fmuladd.f32(float %776, float %775, float %765)
%778 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 10
store float %777, float* %778
%779 = load float*, float** %4
%780 = getelementptr inbounds float, float* %779, i64 0
%781 = load float, float* %780
%782 = fneg float %781
%783 = load float*, float** %4
%784 = getelementptr inbounds float, float* %783, i64 5
%785 = load float, float* %784
%786 = fmul float %782, %785
%787 = load float*, float** %4
%788 = getelementptr inbounds float, float* %787, i64 14
%789 = load float, float* %788
%790 = load float*, float** %4
%791 = getelementptr inbounds float, float* %790, i64 0
%792 = load float, float* %791
%793 = load float*, float** %4
%794 = getelementptr inbounds float, float* %793, i64 6
%795 = load float, float* %794
%796 = fmul float %792, %795
%797 = load float*, float** %4
%798 = getelementptr inbounds float, float* %797, i64 13
%799 = load float, float* %798
%800 = fmul float %796, %799
%801 = call float @llvm.fmuladd.f32(float %786, float %789, float %800)
%802 = load float*, float** %4
%803 = getelementptr inbounds float, float* %802, i64 4
%804 = load float, float* %803
%805 = load float*, float** %4
%806 = getelementptr inbounds float, float* %805, i64 1
%807 = load float, float* %806
%808 = fmul float %804, %807
%809 = load float*, float** %4
%810 = getelementptr inbounds float, float* %809, i64 14
%811 = load float, float* %810
%812 = call float @llvm.fmuladd.f32(float %808, float %811, float %801)
%813 = load float*, float** %4
%814 = getelementptr inbounds float, float* %813, i64 4
%815 = load float, float* %814
%816 = load float*, float** %4
%817 = getelementptr inbounds float, float* %816, i64 2
%818 = load float, float* %817
%819 = fmul float %815, %818
%820 = load float*, float** %4
%821 = getelementptr inbounds float, float* %820, i64 13
%822 = load float, float* %821
%823 = fneg float %819
%824 = call float @llvm.fmuladd.f32(float %823, float %822, float %812)
%825 = load float*, float** %4
%826 = getelementptr inbounds float, float* %825, i64 12
%827 = load float, float* %826
%828 = load float*, float** %4
%829 = getelementptr inbounds float, float* %828, i64 1
%830 = load float, float* %829
%831 = fmul float %827, %830
%832 = load float*, float** %4
%833 = getelementptr inbounds float, float* %832, i64 6
%834 = load float, float* %833
%835 = fneg float %831
%836 = call float @llvm.fmuladd.f32(float %835, float %834, float %824)
%837 = load float*, float** %4
%838 = getelementptr inbounds float, float* %837, i64 12
%839 = load float, float* %838
%840 = load float*, float** %4
%841 = getelementptr inbounds float, float* %840, i64 2
%842 = load float, float* %841
%843 = fmul float %839, %842
%844 = load float*, float** %4
%845 = getelementptr inbounds float, float* %844, i64 5
%846 = load float, float* %845
%847 = call float @llvm.fmuladd.f32(float %843, float %846, float %836)
%848 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 14
store float %847, float* %848
%849 = load float*, float** %4
%850 = getelementptr inbounds float, float* %849, i64 1
%851 = load float, float* %850
%852 = fneg float %851
%853 = load float*, float** %4
%854 = getelementptr inbounds float, float* %853, i64 6
%855 = load float, float* %854
%856 = fmul float %852, %855
%857 = load float*, float** %4
%858 = getelementptr inbounds float, float* %857, i64 11
%859 = load float, float* %858
%860 = load float*, float** %4
%861 = getelementptr inbounds float, float* %860, i64 1
%862 = load float, float* %861
%863 = load float*, float** %4
%864 = getelementptr inbounds float, float* %863, i64 7
%865 = load float, float* %864
%866 = fmul float %862, %865
%867 = load float*, float** %4
%868 = getelementptr inbounds float, float* %867, i64 10
%869 = load float, float* %868
%870 = fmul float %866, %869
%871 = call float @llvm.fmuladd.f32(float %856, float %859, float %870)
%872 = load float*, float** %4
%873 = getelementptr inbounds float, float* %872, i64 5
%874 = load float, float* %873
%875 = load float*, float** %4
%876 = getelementptr inbounds float, float* %875, i64 2
%877 = load float, float* %876
%878 = fmul float %874, %877
%879 = load float*, float** %4
%880 = getelementptr inbounds float, float* %879, i64 11
%881 = load float, float* %880
%882 = call float @llvm.fmuladd.f32(float %878, float %881, float %871)
%883 = load float*, float** %4
%884 = getelementptr inbounds float, float* %883, i64 5
%885 = load float, float* %884
%886 = load float*, float** %4
%887 = getelementptr inbounds float, float* %886, i64 3
%888 = load float, float* %887
%889 = fmul float %885, %888
%890 = load float*, float** %4
%891 = getelementptr inbounds float, float* %890, i64 10
%892 = load float, float* %891
%893 = fneg float %889
%894 = call float @llvm.fmuladd.f32(float %893, float %892, float %882)
%895 = load float*, float** %4
%896 = getelementptr inbounds float, float* %895, i64 9
%897 = load float, float* %896
%898 = load float*, float** %4
%899 = getelementptr inbounds float, float* %898, i64 2
%900 = load float, float* %899
%901 = fmul float %897, %900
%902 = load float*, float** %4
%903 = getelementptr inbounds float, float* %902, i64 7
%904 = load float, float* %903
%905 = fneg float %901
%906 = call float @llvm.fmuladd.f32(float %905, float %904, float %894)
%907 = load float*, float** %4
%908 = getelementptr inbounds float, float* %907, i64 9
%909 = load float, float* %908
%910 = load float*, float** %4
%911 = getelementptr inbounds float, float* %910, i64 3
%912 = load float, float* %911
%913 = fmul float %909, %912
%914 = load float*, float** %4
%915 = getelementptr inbounds float, float* %914, i64 6
%916 = load float, float* %915
%917 = call float @llvm.fmuladd.f32(float %913, float %916, float %906)
%918 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 3
store float %917, float* %918
%919 = load float*, float** %4
%920 = getelementptr inbounds float, float* %919, i64 0
%921 = load float, float* %920
%922 = load float*, float** %4
%923 = getelementptr inbounds float, float* %922, i64 6
%924 = load float, float* %923
%925 = fmul float %921, %924
%926 = load float*, float** %4
%927 = getelementptr inbounds float, float* %926, i64 11
%928 = load float, float* %927
%929 = load float*, float** %4
%930 = getelementptr inbounds float, float* %929, i64 0
%931 = load float, float* %930
%932 = load float*, float** %4
%933 = getelementptr inbounds float, float* %932, i64 7
%934 = load float, float* %933
%935 = fmul float %931, %934
%936 = load float*, float** %4
%937 = getelementptr inbounds float, float* %936, i64 10
%938 = load float, float* %937
%939 = fmul float %935, %938
%940 = fneg float %939
%941 = call float @llvm.fmuladd.f32(float %925, float %928, float %940)
%942 = load float*, float** %4
%943 = getelementptr inbounds float, float* %942, i64 4
%944 = load float, float* %943
%945 = load float*, float** %4
%946 = getelementptr inbounds float, float* %945, i64 2
%947 = load float, float* %946
%948 = fmul float %944, %947
%949 = load float*, float** %4
%950 = getelementptr inbounds float, float* %949, i64 11
%951 = load float, float* %950
%952 = fneg float %948
%953 = call float @llvm.fmuladd.f32(float %952, float %951, float %941)
%954 = load float*, float** %4
%955 = getelementptr inbounds float, float* %954, i64 4
%956 = load float, float* %955
%957 = load float*, float** %4
%958 = getelementptr inbounds float, float* %957, i64 3
%959 = load float, float* %958
%960 = fmul float %956, %959
%961 = load float*, float** %4
%962 = getelementptr inbounds float, float* %961, i64 10
%963 = load float, float* %962
%964 = call float @llvm.fmuladd.f32(float %960, float %963, float %953)
%965 = load float*, float** %4
%966 = getelementptr inbounds float, float* %965, i64 8
%967 = load float, float* %966
%968 = load float*, float** %4
%969 = getelementptr inbounds float, float* %968, i64 2
%970 = load float, float* %969
%971 = fmul float %967, %970
%972 = load float*, float** %4
%973 = getelementptr inbounds float, float* %972, i64 7
%974 = load float, float* %973
%975 = call float @llvm.fmuladd.f32(float %971, float %974, float %964)
%976 = load float*, float** %4
%977 = getelementptr inbounds float, float* %976, i64 8
%978 = load float, float* %977
%979 = load float*, float** %4
%980 = getelementptr inbounds float, float* %979, i64 3
%981 = load float, float* %980
%982 = fmul float %978, %981
%983 = load float*, float** %4
%984 = getelementptr inbounds float, float* %983, i64 6
%985 = load float, float* %984
%986 = fneg float %982
%987 = call float @llvm.fmuladd.f32(float %986, float %985, float %975)
%988 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 7
store float %987, float* %988
%989 = load float*, float** %4
%990 = getelementptr inbounds float, float* %989, i64 0
%991 = load float, float* %990
%992 = fneg float %991
%993 = load float*, float** %4
%994 = getelementptr inbounds float, float* %993, i64 5
%995 = load float, float* %994
%996 = fmul float %992, %995
%997 = load float*, float** %4
%998 = getelementptr inbounds float, float* %997, i64 11
%999 = load float, float* %998
%1000 = load float*, float** %4
%1001 = getelementptr inbounds float, float* %1000, i64 0
%1002 = load float, float* %1001
%1003 = load float*, float** %4
%1004 = getelementptr inbounds float, float* %1003, i64 7
%1005 = load float, float* %1004
%1006 = fmul float %1002, %1005
%1007 = load float*, float** %4
%1008 = getelementptr inbounds float, float* %1007, i64 9
%1009 = load float, float* %1008
%1010 = fmul float %1006, %1009
%1011 = call float @llvm.fmuladd.f32(float %996, float %999, float %1010)
%1012 = load float*, float** %4
%1013 = getelementptr inbounds float, float* %1012, i64 4
%1014 = load float, float* %1013
%1015 = load float*, float** %4
%1016 = getelementptr inbounds float, float* %1015, i64 1
%1017 = load float, float* %1016
%1018 = fmul float %1014, %1017
%1019 = load float*, float** %4
%1020 = getelementptr inbounds float, float* %1019, i64 11
%1021 = load float, float* %1020
%1022 = call float @llvm.fmuladd.f32(float %1018, float %1021, float %1011)
%1023 = load float*, float** %4
%1024 = getelementptr inbounds float, float* %1023, i64 4
%1025 = load float, float* %1024
%1026 = load float*, float** %4
%1027 = getelementptr inbounds float, float* %1026, i64 3
%1028 = load float, float* %1027
%1029 = fmul float %1025, %1028
%1030 = load float*, float** %4
%1031 = getelementptr inbounds float, float* %1030, i64 9
%1032 = load float, float* %1031
%1033 = fneg float %1029
%1034 = call float @llvm.fmuladd.f32(float %1033, float %1032, float %1022)
%1035 = load float*, float** %4
%1036 = getelementptr inbounds float, float* %1035, i64 8
%1037 = load float, float* %1036
%1038 = load float*, float** %4
%1039 = getelementptr inbounds float, float* %1038, i64 1
%1040 = load float, float* %1039
%1041 = fmul float %1037, %1040
%1042 = load float*, float** %4
%1043 = getelementptr inbounds float, float* %1042, i64 7
%1044 = load float, float* %1043
%1045 = fneg float %1041
%1046 = call float @llvm.fmuladd.f32(float %1045, float %1044, float %1034)
%1047 = load float*, float** %4
%1048 = getelementptr inbounds float, float* %1047, i64 8
%1049 = load float, float* %1048
%1050 = load float*, float** %4
%1051 = getelementptr inbounds float, float* %1050, i64 3
%1052 = load float, float* %1051
%1053 = fmul float %1049, %1052
%1054 = load float*, float** %4
%1055 = getelementptr inbounds float, float* %1054, i64 5
%1056 = load float, float* %1055
%1057 = call float @llvm.fmuladd.f32(float %1053, float %1056, float %1046)
%1058 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 11
store float %1057, float* %1058
%1059 = load float*, float** %4
%1060 = getelementptr inbounds float, float* %1059, i64 0
%1061 = load float, float* %1060
%1062 = load float*, float** %4
%1063 = getelementptr inbounds float, float* %1062, i64 5
%1064 = load float, float* %1063
%1065 = fmul float %1061, %1064
%1066 = load float*, float** %4
%1067 = getelementptr inbounds float, float* %1066, i64 10
%1068 = load float, float* %1067
%1069 = load float*, float** %4
%1070 = getelementptr inbounds float, float* %1069, i64 0
%1071 = load float, float* %1070
%1072 = load float*, float** %4
%1073 = getelementptr inbounds float, float* %1072, i64 6
%1074 = load float, float* %1073
%1075 = fmul float %1071, %1074
%1076 = load float*, float** %4
%1077 = getelementptr inbounds float, float* %1076, i64 9
%1078 = load float, float* %1077
%1079 = fmul float %1075, %1078
%1080 = fneg float %1079
%1081 = call float @llvm.fmuladd.f32(float %1065, float %1068, float %1080)
%1082 = load float*, float** %4
%1083 = getelementptr inbounds float, float* %1082, i64 4
%1084 = load float, float* %1083
%1085 = load float*, float** %4
%1086 = getelementptr inbounds float, float* %1085, i64 1
%1087 = load float, float* %1086
%1088 = fmul float %1084, %1087
%1089 = load float*, float** %4
%1090 = getelementptr inbounds float, float* %1089, i64 10
%1091 = load float, float* %1090
%1092 = fneg float %1088
%1093 = call float @llvm.fmuladd.f32(float %1092, float %1091, float %1081)
%1094 = load float*, float** %4
%1095 = getelementptr inbounds float, float* %1094, i64 4
%1096 = load float, float* %1095
%1097 = load float*, float** %4
%1098 = getelementptr inbounds float, float* %1097, i64 2
%1099 = load float, float* %1098
%1100 = fmul float %1096, %1099
%1101 = load float*, float** %4
%1102 = getelementptr inbounds float, float* %1101, i64 9
%1103 = load float, float* %1102
%1104 = call float @llvm.fmuladd.f32(float %1100, float %1103, float %1093)
%1105 = load float*, float** %4
%1106 = getelementptr inbounds float, float* %1105, i64 8
%1107 = load float, float* %1106
%1108 = load float*, float** %4
%1109 = getelementptr inbounds float, float* %1108, i64 1
%1110 = load float, float* %1109
%1111 = fmul float %1107, %1110
%1112 = load float*, float** %4
%1113 = getelementptr inbounds float, float* %1112, i64 6
%1114 = load float, float* %1113
%1115 = call float @llvm.fmuladd.f32(float %1111, float %1114, float %1104)
%1116 = load float*, float** %4
%1117 = getelementptr inbounds float, float* %1116, i64 8
%1118 = load float, float* %1117
%1119 = load float*, float** %4
%1120 = getelementptr inbounds float, float* %1119, i64 2
%1121 = load float, float* %1120
%1122 = fmul float %1118, %1121
%1123 = load float*, float** %4
%1124 = getelementptr inbounds float, float* %1123, i64 5
%1125 = load float, float* %1124
%1126 = fneg float %1122
%1127 = call float @llvm.fmuladd.f32(float %1126, float %1125, float %1115)
%1128 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 15
store float %1127, float* %1128
%1129 = load float*, float** %4
%1130 = getelementptr inbounds float, float* %1129, i64 0
%1131 = load float, float* %1130
%1132 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 0
%1133 = load float, float* %1132
%1134 = load float*, float** %4
%1135 = getelementptr inbounds float, float* %1134, i64 1
%1136 = load float, float* %1135
%1137 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 4
%1138 = load float, float* %1137
%1139 = fmul float %1136, %1138
%1140 = call float @llvm.fmuladd.f32(float %1131, float %1133, float %1139)
%1141 = load float*, float** %4
%1142 = getelementptr inbounds float, float* %1141, i64 2
%1143 = load float, float* %1142
%1144 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 8
%1145 = load float, float* %1144
%1146 = call float @llvm.fmuladd.f32(float %1143, float %1145, float %1140)
%1147 = load float*, float** %4
%1148 = getelementptr inbounds float, float* %1147, i64 3
%1149 = load float, float* %1148
%1150 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 12
%1151 = load float, float* %1150
%1152 = call float @llvm.fmuladd.f32(float %1149, float %1151, float %1146)
store float %1152, float* %7
%1153 = load float, float* %7
%1154 = fcmp oeq float %1153, 0.000000e+00
br i1 %1154, label %1155, label %1156
1155: ; preds = %2
store i32 0, i32* %3
br label %1177
1156: ; preds = %2
%1157 = load float, float* %7
%1158 = fdiv float 1.000000e+00, %1157
store float %1158, float* %7
store i32 0, i32* %8
br label %1159
1159: ; preds = %1173, %1156
%1160 = load i32, i32* %8
%1161 = icmp slt i32 %1160, 16
br i1 %1161, label %1162, label %1176
1162: ; preds = %1159
%1163 = load i32, i32* %8
%1164 = sext i32 %1163 to i64
%1165 = getelementptr inbounds [16 x float], [16 x float]* %6, i64 0, i64 %1164
%1166 = load float, float* %1165
%1167 = load float, float* %7
%1168 = fmul float %1166, %1167
%1169 = load float*, float** %5
%1170 = load i32, i32* %8
%1171 = sext i32 %1170 to i64
%1172 = getelementptr inbounds float, float* %1169, i64 %1171
store float %1168, float* %1172
br label %1173
1173: ; preds = %1162
%1174 = load i32, i32* %8
%1175 = add nsw i32 %1174, 1
store i32 %1175, i32* %8
br label %1159
1176: ; preds = %1159
store i32 1, i32* %3
br label %1177
1177: ; preds = %1176, %1155
%1178 = load i32, i32* %3
ret i32 %1178
}

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