int invmat4(float i[16], const float m[16]) {
  float x = det4(m);
  if (x == 0)
    return 0;
  i[0] = (-m[13] * m[10] * m[7] + m[9] * m[14] * m[7] + m[13] * m[6] * m[11] -
          m[5] * m[14] * m[11] - m[9] * m[6] * m[15] + m[5] * m[10] * m[15]) /
         x;
  i[4] = (m[12] * m[10] * m[7] - m[8] * m[14] * m[7] - m[12] * m[6] * m[11] +
          m[4] * m[14] * m[11] + m[8] * m[6] * m[15] - m[4] * m[10] * m[15]) /
         x;
  i[8] = (-m[12] * m[9] * m[7] + m[8] * m[13] * m[7] + m[12] * m[5] * m[11] -
          m[4] * m[13] * m[11] - m[8] * m[5] * m[15] + m[4] * m[9] * m[15]) /
         x;
  i[12] = (m[12] * m[9] * m[6] - m[8] * m[13] * m[6] - m[12] * m[5] * m[10] +
           m[4] * m[13] * m[10] + m[8] * m[5] * m[14] - m[4] * m[9] * m[14]) /
          x;
  i[1] = (m[13] * m[10] * m[3] - m[9] * m[14] * m[3] - m[13] * m[2] * m[11] +
          m[1] * m[14] * m[11] + m[9] * m[2] * m[15] - m[1] * m[10] * m[15]) /
         x;
  i[5] = (-m[12] * m[10] * m[3] + m[8] * m[14] * m[3] + m[12] * m[2] * m[11] -
          m[0] * m[14] * m[11] - m[8] * m[2] * m[15] + m[0] * m[10] * m[15]) /
         x;
  i[9] = (m[12] * m[9] * m[3] - m[8] * m[13] * m[3] - m[12] * m[1] * m[11] +
          m[0] * m[13] * m[11] + m[8] * m[1] * m[15] - m[0] * m[9] * m[15]) /
         x;
  i[13] = (-m[12] * m[9] * m[2] + m[8] * m[13] * m[2] + m[12] * m[1] * m[10] -
           m[0] * m[13] * m[10] - m[8] * m[1] * m[14] + m[0] * m[9] * m[14]) /
          x;
  i[2] = (-m[13] * m[6] * m[3] + m[5] * m[14] * m[3] + m[13] * m[2] * m[7] -
          m[1] * m[14] * m[7] - m[5] * m[2] * m[15] + m[1] * m[6] * m[15]) /
         x;
  i[6] = (m[12] * m[6] * m[3] - m[4] * m[14] * m[3] - m[12] * m[2] * m[7] +
          m[0] * m[14] * m[7] + m[4] * m[2] * m[15] - m[0] * m[6] * m[15]) /
         x;
  i[10] = (-m[12] * m[5] * m[3] + m[4] * m[13] * m[3] + m[12] * m[1] * m[7] -
           m[0] * m[13] * m[7] - m[4] * m[1] * m[15] + m[0] * m[5] * m[15]) /
          x;
  i[14] = (m[12] * m[5] * m[2] - m[4] * m[13] * m[2] - m[12] * m[1] * m[6] +
           m[0] * m[13] * m[6] + m[4] * m[1] * m[14] - m[0] * m[5] * m[14]) /
          x;
  i[3] = (m[9] * m[6] * m[3] - m[5] * m[10] * m[3] - m[9] * m[2] * m[7] +
          m[1] * m[10] * m[7] + m[5] * m[2] * m[11] - m[1] * m[6] * m[11]) /
         x;
  i[7] = (-m[8] * m[6] * m[3] + m[4] * m[10] * m[3] + m[8] * m[2] * m[7] -
          m[0] * m[10] * m[7] - m[4] * m[2] * m[11] + m[0] * m[6] * m[11]) /
         x;
  i[11] = (m[8] * m[5] * m[3] - m[4] * m[9] * m[3] - m[8] * m[1] * m[7] +
           m[0] * m[9] * m[7] + m[4] * m[1] * m[11] - m[0] * m[5] * m[11]) /
          x;
  i[15] = (-m[8] * m[5] * m[2] + m[4] * m[9] * m[2] + m[8] * m[1] * m[6] -
           m[0] * m[9] * m[6] - m[4] * m[1] * m[10] + m[0] * m[5] * m[10]) /
          x;
  return 1;
}


x86 assembly (clang, -O0):
<invmat4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   1030 <det4@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1157 <invmat4+0x47>
jp     1157 <invmat4+0x47>
movl   $0x0,-0x4(%rbp)
jmp    213b <invmat4+0x102b>
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x1c(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x1c(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x3c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x38(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x28(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0xc(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x2c(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x2c(%rax)
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x3c(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<invmat4>:
push   %rbp
push   %r14
push   %rbx
mov    %rsi,%rbx
mov    %rdi,%r14
xor    %ebp,%ebp
mov    %rsi,%rdi
xor    %eax,%eax
call   1030 <det4@plt>
test   %eax,%eax
je     1936 <invmat4+0x826>
cvtsi2ss %eax,%xmm8
movss  0x34(%rbx),%xmm2
movss  0x28(%rbx),%xmm1
movaps %xmm1,%xmm3
mulss  %xmm2,%xmm3
movss  0x1c(%rbx),%xmm4
movss  0x24(%rbx),%xmm5
movss  0x38(%rbx),%xmm6
movss  0x18(%rbx),%xmm7
mulss  %xmm7,%xmm2
mulss  %xmm5,%xmm7
mulss  %xmm6,%xmm5
mulss  %xmm4,%xmm5
mulss  %xmm4,%xmm3
subss  %xmm3,%xmm5
movss  0x14(%rbx),%xmm3
movss  0x2c(%rbx),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm3,%xmm6
mulss  %xmm4,%xmm6
subss  %xmm6,%xmm2
movss  0x3c(%rbx),%xmm4
mulss  %xmm4,%xmm7
subss  %xmm7,%xmm2
mulss  %xmm3,%xmm1
mulss  %xmm4,%xmm1
addss  %xmm2,%xmm1
divss  %xmm8,%xmm1
movss  %xmm1,(%r14)
movss  0x30(%rbx),%xmm3
movss  0x28(%rbx),%xmm1
movaps %xmm3,%xmm4
mulss  %xmm1,%xmm4
movss  0x1c(%rbx),%xmm5
movss  0x20(%rbx),%xmm2
movss  0x38(%rbx),%xmm6
movaps %xmm6,%xmm7
mulss  %xmm2,%xmm7
mulss  %xmm5,%xmm7
mulss  %xmm5,%xmm4
subss  %xmm7,%xmm4
movss  0x10(%rbx),%xmm5
movss  0x18(%rbx),%xmm7
movss  0x2c(%rbx),%xmm0
mulss  %xmm7,%xmm3
mulss  %xmm0,%xmm3
subss  %xmm3,%xmm4
mulss  %xmm5,%xmm6
mulss  %xmm0,%xmm6
addss  %xmm4,%xmm6
mulss  %xmm7,%xmm2
movss  0x3c(%rbx),%xmm0
mulss  %xmm0,%xmm2
addss  %xmm6,%xmm2
mulss  %xmm5,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm2
divss  %xmm8,%xmm2
movss  %xmm2,0x10(%r14)
movss  0x30(%rbx),%xmm2
movss  0x24(%rbx),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  0x1c(%rbx),%xmm3
movss  0x20(%rbx),%xmm4
movss  0x34(%rbx),%xmm5
movss  0x14(%rbx),%xmm6
mulss  %xmm6,%xmm2
mulss  %xmm4,%xmm6
mulss  %xmm5,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm3,%xmm0
subss  %xmm0,%xmm4
movss  0x10(%rbx),%xmm0
movss  0x2c(%rbx),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm4,%xmm2
mulss  %xmm0,%xmm5
mulss  %xmm3,%xmm5
subss  %xmm5,%xmm2
movss  0x3c(%rbx),%xmm3
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm2
mulss  %xmm0,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm8,%xmm1
movss  %xmm1,0x20(%r14)
movss  0x30(%rbx),%xmm0
movss  0x24(%rbx),%xmm1
movaps %xmm0,%xmm3
mulss  %xmm1,%xmm3
movss  0x18(%rbx),%xmm4
movss  0x20(%rbx),%xmm2
movss  0x34(%rbx),%xmm5
movaps %xmm5,%xmm6
mulss  %xmm2,%xmm6
mulss  %xmm4,%xmm6
mulss  %xmm4,%xmm3
subss  %xmm6,%xmm3
movss  0x10(%rbx),%xmm4
movss  0x14(%rbx),%xmm6
movss  0x28(%rbx),%xmm7
mulss  %xmm6,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm7,%xmm5
addss  %xmm3,%xmm5
mulss  %xmm6,%xmm2
movss  0x38(%rbx),%xmm0
mulss  %xmm0,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm2
divss  %xmm8,%xmm2
movss  %xmm2,0x30(%r14)
movss  0x34(%rbx),%xmm0
movss  0x28(%rbx),%xmm1
movaps %xmm0,%xmm3
mulss  %xmm1,%xmm3
movss  0xc(%rbx),%xmm4
movss  0x24(%rbx),%xmm2
movss  0x38(%rbx),%xmm5
movaps %xmm5,%xmm6
mulss  %xmm2,%xmm6
mulss  %xmm4,%xmm6
mulss  %xmm4,%xmm3
subss  %xmm6,%xmm3
movss  0x4(%rbx),%xmm4
movss  0x8(%rbx),%xmm6
movss  0x2c(%rbx),%xmm7
mulss  %xmm6,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm7,%xmm5
addss  %xmm3,%xmm5
mulss  %xmm6,%xmm2
movss  0x3c(%rbx),%xmm0
mulss  %xmm0,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm2
divss  %xmm8,%xmm2
movss  %xmm2,0x4(%r14)
movss  0x30(%rbx),%xmm2
movss  0x28(%rbx),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  0xc(%rbx),%xmm3
movss  0x20(%rbx),%xmm4
movss  0x38(%rbx),%xmm5
movss  0x8(%rbx),%xmm6
mulss  %xmm6,%xmm2
mulss  %xmm4,%xmm6
mulss  %xmm5,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm3,%xmm0
subss  %xmm0,%xmm4
movss  (%rbx),%xmm0
movss  0x2c(%rbx),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm4,%xmm2
mulss  %xmm0,%xmm5
mulss  %xmm3,%xmm5
subss  %xmm5,%xmm2
movss  0x3c(%rbx),%xmm3
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm2
mulss  %xmm0,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm8,%xmm1
movss  %xmm1,0x14(%r14)
movss  0x30(%rbx),%xmm0
movss  0x24(%rbx),%xmm1
movaps %xmm0,%xmm3
mulss  %xmm1,%xmm3
movss  0xc(%rbx),%xmm4
movss  0x20(%rbx),%xmm2
movss  0x34(%rbx),%xmm5
movaps %xmm5,%xmm6
mulss  %xmm2,%xmm6
mulss  %xmm4,%xmm6
mulss  %xmm4,%xmm3
subss  %xmm6,%xmm3
movss  (%rbx),%xmm4
movss  0x4(%rbx),%xmm6
movss  0x2c(%rbx),%xmm7
mulss  %xmm6,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm7,%xmm5
addss  %xmm3,%xmm5
mulss  %xmm6,%xmm2
movss  0x3c(%rbx),%xmm0
mulss  %xmm0,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm2
divss  %xmm8,%xmm2
movss  %xmm2,0x24(%r14)
movss  0x30(%rbx),%xmm2
movss  0x24(%rbx),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  0x8(%rbx),%xmm3
movss  0x20(%rbx),%xmm4
movss  0x34(%rbx),%xmm5
movss  0x4(%rbx),%xmm6
mulss  %xmm6,%xmm2
mulss  %xmm4,%xmm6
mulss  %xmm5,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm3,%xmm0
subss  %xmm0,%xmm4
movss  (%rbx),%xmm0
movss  0x28(%rbx),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm4,%xmm2
mulss  %xmm0,%xmm5
mulss  %xmm3,%xmm5
subss  %xmm5,%xmm2
movss  0x38(%rbx),%xmm3
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm2
mulss  %xmm0,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm8,%xmm1
movss  %xmm1,0x34(%r14)
movss  0x34(%rbx),%xmm2
movss  0x18(%rbx),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  0xc(%rbx),%xmm3
movss  0x14(%rbx),%xmm4
movss  0x38(%rbx),%xmm5
movss  0x8(%rbx),%xmm6
mulss  %xmm6,%xmm2
mulss  %xmm4,%xmm6
mulss  %xmm5,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm3,%xmm0
subss  %xmm0,%xmm4
movss  0x4(%rbx),%xmm0
movss  0x1c(%rbx),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm4,%xmm2
mulss  %xmm0,%xmm5
mulss  %xmm3,%xmm5
subss  %xmm5,%xmm2
movss  0x3c(%rbx),%xmm3
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm2
mulss  %xmm0,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm8,%xmm1
movss  %xmm1,0x8(%r14)
movss  0x30(%rbx),%xmm0
movss  0x18(%rbx),%xmm1
movaps %xmm0,%xmm3
mulss  %xmm1,%xmm3
movss  0xc(%rbx),%xmm4
movss  0x10(%rbx),%xmm2
movss  0x38(%rbx),%xmm5
movaps %xmm5,%xmm6
mulss  %xmm2,%xmm6
mulss  %xmm4,%xmm6
mulss  %xmm4,%xmm3
subss  %xmm6,%xmm3
movss  (%rbx),%xmm4
movss  0x8(%rbx),%xmm6
movss  0x1c(%rbx),%xmm7
mulss  %xmm6,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm7,%xmm5
addss  %xmm3,%xmm5
mulss  %xmm6,%xmm2
movss  0x3c(%rbx),%xmm0
mulss  %xmm0,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm2
divss  %xmm8,%xmm2
movss  %xmm2,0x18(%r14)
movss  0x30(%rbx),%xmm2
movss  0x14(%rbx),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  0xc(%rbx),%xmm3
movss  0x10(%rbx),%xmm4
movss  0x34(%rbx),%xmm5
movss  0x4(%rbx),%xmm6
mulss  %xmm6,%xmm2
mulss  %xmm4,%xmm6
mulss  %xmm5,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm3,%xmm0
subss  %xmm0,%xmm4
movss  (%rbx),%xmm0
movss  0x1c(%rbx),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm4,%xmm2
mulss  %xmm0,%xmm5
mulss  %xmm3,%xmm5
subss  %xmm5,%xmm2
movss  0x3c(%rbx),%xmm3
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm2
mulss  %xmm0,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm8,%xmm1
movss  %xmm1,0x28(%r14)
movss  0x30(%rbx),%xmm0
movss  0x14(%rbx),%xmm1
movaps %xmm0,%xmm3
mulss  %xmm1,%xmm3
movss  0x8(%rbx),%xmm4
movss  0x10(%rbx),%xmm2
movss  0x34(%rbx),%xmm5
movaps %xmm5,%xmm6
mulss  %xmm2,%xmm6
mulss  %xmm4,%xmm6
mulss  %xmm4,%xmm3
subss  %xmm6,%xmm3
movss  (%rbx),%xmm4
movss  0x4(%rbx),%xmm6
movss  0x18(%rbx),%xmm7
mulss  %xmm6,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm7,%xmm5
addss  %xmm3,%xmm5
mulss  %xmm6,%xmm2
movss  0x38(%rbx),%xmm0
mulss  %xmm0,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm2
divss  %xmm8,%xmm2
movss  %xmm2,0x38(%r14)
movss  0x24(%rbx),%xmm0
movss  0x18(%rbx),%xmm1
movaps %xmm0,%xmm3
mulss  %xmm1,%xmm3
movss  0xc(%rbx),%xmm4
movss  0x14(%rbx),%xmm2
movss  0x28(%rbx),%xmm5
movaps %xmm5,%xmm6
mulss  %xmm2,%xmm6
mulss  %xmm4,%xmm6
mulss  %xmm4,%xmm3
subss  %xmm6,%xmm3
movss  0x4(%rbx),%xmm4
movss  0x8(%rbx),%xmm6
movss  0x1c(%rbx),%xmm7
mulss  %xmm6,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm7,%xmm5
addss  %xmm3,%xmm5
mulss  %xmm6,%xmm2
movss  0x2c(%rbx),%xmm0
mulss  %xmm0,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm2
divss  %xmm8,%xmm2
movss  %xmm2,0xc(%r14)
movss  0x20(%rbx),%xmm2
movss  0x18(%rbx),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  0xc(%rbx),%xmm3
movss  0x10(%rbx),%xmm4
movss  0x28(%rbx),%xmm5
movss  0x8(%rbx),%xmm6
mulss  %xmm6,%xmm2
mulss  %xmm4,%xmm6
mulss  %xmm5,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm3,%xmm0
subss  %xmm0,%xmm4
movss  (%rbx),%xmm0
movss  0x1c(%rbx),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm4,%xmm2
mulss  %xmm0,%xmm5
mulss  %xmm3,%xmm5
subss  %xmm5,%xmm2
movss  0x2c(%rbx),%xmm3
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm2
mulss  %xmm0,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm8,%xmm1
movss  %xmm1,0x1c(%r14)
movss  0x20(%rbx),%xmm0
movss  0x14(%rbx),%xmm1
movaps %xmm0,%xmm3
mulss  %xmm1,%xmm3
movss  0xc(%rbx),%xmm4
movss  0x10(%rbx),%xmm2
movss  0x24(%rbx),%xmm5
movaps %xmm5,%xmm6
mulss  %xmm2,%xmm6
mulss  %xmm4,%xmm6
mulss  %xmm4,%xmm3
subss  %xmm6,%xmm3
movss  (%rbx),%xmm4
movss  0x4(%rbx),%xmm6
movss  0x1c(%rbx),%xmm7
mulss  %xmm6,%xmm0
mulss  %xmm7,%xmm0
subss  %xmm0,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm7,%xmm5
addss  %xmm3,%xmm5
mulss  %xmm6,%xmm2
movss  0x2c(%rbx),%xmm0
mulss  %xmm0,%xmm2
addss  %xmm5,%xmm2
mulss  %xmm4,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm2
divss  %xmm8,%xmm2
movss  %xmm2,0x2c(%r14)
movss  0x20(%rbx),%xmm2
movss  0x14(%rbx),%xmm1
movaps %xmm1,%xmm0
mulss  %xmm2,%xmm0
movss  0x8(%rbx),%xmm3
movss  0x10(%rbx),%xmm4
movss  0x24(%rbx),%xmm5
movss  0x4(%rbx),%xmm6
mulss  %xmm6,%xmm2
mulss  %xmm4,%xmm6
mulss  %xmm5,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm3,%xmm0
subss  %xmm0,%xmm4
movss  (%rbx),%xmm0
movss  0x18(%rbx),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm4,%xmm2
mulss  %xmm0,%xmm5
mulss  %xmm3,%xmm5
subss  %xmm5,%xmm2
movss  0x28(%rbx),%xmm3
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm2
mulss  %xmm0,%xmm1
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
divss  %xmm8,%xmm1
movss  %xmm1,0x3c(%r14)
mov    $0x1,%ebp
mov    %ebp,%eax
pop    %rbx
pop    %r14
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @invmat4(float* nocapture writeonly %0, float* %1) {
%3 = tail call i32 (float*, ...) bitcast (i32 (...)* @det4 to i32 (float*, ...)*)(float* %1)
%4 = sitofp i32 %3 to float
%5 = icmp eq i32 %3, 0
br i1 %5, label %437, label %6
6: ; preds = %2
%7 = getelementptr inbounds float, float* %1, i64 13
%8 = load float, float* %7
%9 = fneg float %8
%10 = getelementptr inbounds float, float* %1, i64 10
%11 = load float, float* %10
%12 = fmul float %11, %9
%13 = getelementptr inbounds float, float* %1, i64 7
%14 = load float, float* %13
%15 = getelementptr inbounds float, float* %1, i64 9
%16 = load float, float* %15
%17 = getelementptr inbounds float, float* %1, i64 14
%18 = load float, float* %17
%19 = fmul float %16, %18
%20 = fmul float %14, %19
%21 = tail call float @llvm.fmuladd.f32(float %12, float %14, float %20)
%22 = getelementptr inbounds float, float* %1, i64 6
%23 = load float, float* %22
%24 = fmul float %8, %23
%25 = getelementptr inbounds float, float* %1, i64 11
%26 = load float, float* %25
%27 = tail call float @llvm.fmuladd.f32(float %24, float %26, float %21)
%28 = getelementptr inbounds float, float* %1, i64 5
%29 = load float, float* %28
%30 = fneg float %29
%31 = fmul float %18, %30
%32 = tail call float @llvm.fmuladd.f32(float %31, float %26, float %27)
%33 = getelementptr inbounds float, float* %1, i64 15
%34 = load float, float* %33
%35 = fneg float %16
%36 = fmul float %23, %35
%37 = tail call float @llvm.fmuladd.f32(float %36, float %34, float %32)
%38 = fmul float %11, %29
%39 = tail call float @llvm.fmuladd.f32(float %38, float %34, float %37)
%40 = fdiv float %39, %4
store float %40, float* %0
%41 = getelementptr inbounds float, float* %1, i64 12
%42 = load float, float* %41
%43 = load float, float* %10
%44 = fmul float %42, %43
%45 = load float, float* %13
%46 = getelementptr inbounds float, float* %1, i64 8
%47 = load float, float* %46
%48 = load float, float* %17
%49 = fneg float %47
%50 = fmul float %48, %49
%51 = fmul float %45, %50
%52 = tail call float @llvm.fmuladd.f32(float %44, float %45, float %51)
%53 = load float, float* %22
%54 = load float, float* %25
%55 = fneg float %42
%56 = fmul float %53, %55
%57 = tail call float @llvm.fmuladd.f32(float %56, float %54, float %52)
%58 = getelementptr inbounds float, float* %1, i64 4
%59 = load float, float* %58
%60 = fmul float %48, %59
%61 = tail call float @llvm.fmuladd.f32(float %60, float %54, float %57)
%62 = fmul float %47, %53
%63 = load float, float* %33
%64 = tail call float @llvm.fmuladd.f32(float %62, float %63, float %61)
%65 = fneg float %59
%66 = fmul float %43, %65
%67 = tail call float @llvm.fmuladd.f32(float %66, float %63, float %64)
%68 = fdiv float %67, %4
%69 = getelementptr inbounds float, float* %0, i64 4
store float %68, float* %69
%70 = load float, float* %41
%71 = fneg float %70
%72 = load float, float* %15
%73 = fmul float %72, %71
%74 = load float, float* %13
%75 = load float, float* %46
%76 = load float, float* %7
%77 = fmul float %75, %76
%78 = fmul float %74, %77
%79 = tail call float @llvm.fmuladd.f32(float %73, float %74, float %78)
%80 = load float, float* %28
%81 = fmul float %70, %80
%82 = load float, float* %25
%83 = tail call float @llvm.fmuladd.f32(float %81, float %82, float %79)
%84 = load float, float* %58
%85 = fneg float %84
%86 = fmul float %76, %85
%87 = tail call float @llvm.fmuladd.f32(float %86, float %82, float %83)
%88 = load float, float* %33
%89 = fneg float %75
%90 = fmul float %80, %89
%91 = tail call float @llvm.fmuladd.f32(float %90, float %88, float %87)
%92 = fmul float %72, %84
%93 = tail call float @llvm.fmuladd.f32(float %92, float %88, float %91)
%94 = fdiv float %93, %4
%95 = getelementptr inbounds float, float* %0, i64 8
store float %94, float* %95
%96 = load float, float* %41
%97 = load float, float* %15
%98 = fmul float %96, %97
%99 = load float, float* %22
%100 = load float, float* %46
%101 = load float, float* %7
%102 = fneg float %100
%103 = fmul float %101, %102
%104 = fmul float %99, %103
%105 = tail call float @llvm.fmuladd.f32(float %98, float %99, float %104)
%106 = load float, float* %28
%107 = load float, float* %10
%108 = fneg float %96
%109 = fmul float %106, %108
%110 = tail call float @llvm.fmuladd.f32(float %109, float %107, float %105)
%111 = load float, float* %58
%112 = fmul float %101, %111
%113 = tail call float @llvm.fmuladd.f32(float %112, float %107, float %110)
%114 = fmul float %100, %106
%115 = load float, float* %17
%116 = tail call float @llvm.fmuladd.f32(float %114, float %115, float %113)
%117 = fneg float %111
%118 = fmul float %97, %117
%119 = tail call float @llvm.fmuladd.f32(float %118, float %115, float %116)
%120 = fdiv float %119, %4
%121 = getelementptr inbounds float, float* %0, i64 12
store float %120, float* %121
%122 = load float, float* %7
%123 = load float, float* %10
%124 = fmul float %122, %123
%125 = getelementptr inbounds float, float* %1, i64 3
%126 = load float, float* %125
%127 = load float, float* %15
%128 = load float, float* %17
%129 = fneg float %127
%130 = fmul float %128, %129
%131 = fmul float %126, %130
%132 = tail call float @llvm.fmuladd.f32(float %124, float %126, float %131)
%133 = getelementptr inbounds float, float* %1, i64 2
%134 = load float, float* %133
%135 = load float, float* %25
%136 = fneg float %122
%137 = fmul float %134, %136
%138 = tail call float @llvm.fmuladd.f32(float %137, float %135, float %132)
%139 = getelementptr inbounds float, float* %1, i64 1
%140 = load float, float* %139
%141 = fmul float %128, %140
%142 = tail call float @llvm.fmuladd.f32(float %141, float %135, float %138)
%143 = fmul float %127, %134
%144 = load float, float* %33
%145 = tail call float @llvm.fmuladd.f32(float %143, float %144, float %142)
%146 = fneg float %140
%147 = fmul float %123, %146
%148 = tail call float @llvm.fmuladd.f32(float %147, float %144, float %145)
%149 = fdiv float %148, %4
%150 = getelementptr inbounds float, float* %0, i64 1
store float %149, float* %150
%151 = load float, float* %41
%152 = fneg float %151
%153 = load float, float* %10
%154 = fmul float %153, %152
%155 = load float, float* %125
%156 = load float, float* %46
%157 = load float, float* %17
%158 = fmul float %156, %157
%159 = fmul float %155, %158
%160 = tail call float @llvm.fmuladd.f32(float %154, float %155, float %159)
%161 = load float, float* %133
%162 = fmul float %151, %161
%163 = load float, float* %25
%164 = tail call float @llvm.fmuladd.f32(float %162, float %163, float %160)
%165 = load float, float* %1
%166 = fneg float %165
%167 = fmul float %157, %166
%168 = tail call float @llvm.fmuladd.f32(float %167, float %163, float %164)
%169 = load float, float* %33
%170 = fneg float %156
%171 = fmul float %161, %170
%172 = tail call float @llvm.fmuladd.f32(float %171, float %169, float %168)
%173 = fmul float %153, %165
%174 = tail call float @llvm.fmuladd.f32(float %173, float %169, float %172)
%175 = fdiv float %174, %4
%176 = getelementptr inbounds float, float* %0, i64 5
store float %175, float* %176
%177 = load float, float* %41
%178 = load float, float* %15
%179 = fmul float %177, %178
%180 = load float, float* %125
%181 = load float, float* %46
%182 = load float, float* %7
%183 = fneg float %181
%184 = fmul float %182, %183
%185 = fmul float %180, %184
%186 = tail call float @llvm.fmuladd.f32(float %179, float %180, float %185)
%187 = load float, float* %139
%188 = load float, float* %25
%189 = fneg float %177
%190 = fmul float %187, %189
%191 = tail call float @llvm.fmuladd.f32(float %190, float %188, float %186)
%192 = load float, float* %1
%193 = fmul float %182, %192
%194 = tail call float @llvm.fmuladd.f32(float %193, float %188, float %191)
%195 = fmul float %181, %187
%196 = load float, float* %33
%197 = tail call float @llvm.fmuladd.f32(float %195, float %196, float %194)
%198 = fneg float %192
%199 = fmul float %178, %198
%200 = tail call float @llvm.fmuladd.f32(float %199, float %196, float %197)
%201 = fdiv float %200, %4
%202 = getelementptr inbounds float, float* %0, i64 9
store float %201, float* %202
%203 = load float, float* %41
%204 = fneg float %203
%205 = load float, float* %15
%206 = fmul float %205, %204
%207 = load float, float* %133
%208 = load float, float* %46
%209 = load float, float* %7
%210 = fmul float %208, %209
%211 = fmul float %207, %210
%212 = tail call float @llvm.fmuladd.f32(float %206, float %207, float %211)
%213 = load float, float* %139
%214 = fmul float %203, %213
%215 = load float, float* %10
%216 = tail call float @llvm.fmuladd.f32(float %214, float %215, float %212)
%217 = load float, float* %1
%218 = fneg float %217
%219 = fmul float %209, %218
%220 = tail call float @llvm.fmuladd.f32(float %219, float %215, float %216)
%221 = load float, float* %17
%222 = fneg float %208
%223 = fmul float %213, %222
%224 = tail call float @llvm.fmuladd.f32(float %223, float %221, float %220)
%225 = fmul float %205, %217
%226 = tail call float @llvm.fmuladd.f32(float %225, float %221, float %224)
%227 = fdiv float %226, %4
%228 = getelementptr inbounds float, float* %0, i64 13
store float %227, float* %228
%229 = load float, float* %7
%230 = fneg float %229
%231 = load float, float* %22
%232 = fmul float %231, %230
%233 = load float, float* %125
%234 = load float, float* %28
%235 = load float, float* %17
%236 = fmul float %234, %235
%237 = fmul float %233, %236
%238 = tail call float @llvm.fmuladd.f32(float %232, float %233, float %237)
%239 = load float, float* %133
%240 = fmul float %229, %239
%241 = load float, float* %13
%242 = tail call float @llvm.fmuladd.f32(float %240, float %241, float %238)
%243 = load float, float* %139
%244 = fneg float %243
%245 = fmul float %235, %244
%246 = tail call float @llvm.fmuladd.f32(float %245, float %241, float %242)
%247 = load float, float* %33
%248 = fneg float %234
%249 = fmul float %239, %248
%250 = tail call float @llvm.fmuladd.f32(float %249, float %247, float %246)
%251 = fmul float %231, %243
%252 = tail call float @llvm.fmuladd.f32(float %251, float %247, float %250)
%253 = fdiv float %252, %4
%254 = getelementptr inbounds float, float* %0, i64 2
store float %253, float* %254
%255 = load float, float* %41
%256 = load float, float* %22
%257 = fmul float %255, %256
%258 = load float, float* %125
%259 = load float, float* %58
%260 = load float, float* %17
%261 = fneg float %259
%262 = fmul float %260, %261
%263 = fmul float %258, %262
%264 = tail call float @llvm.fmuladd.f32(float %257, float %258, float %263)
%265 = load float, float* %133
%266 = load float, float* %13
%267 = fneg float %255
%268 = fmul float %265, %267
%269 = tail call float @llvm.fmuladd.f32(float %268, float %266, float %264)
%270 = load float, float* %1
%271 = fmul float %260, %270
%272 = tail call float @llvm.fmuladd.f32(float %271, float %266, float %269)
%273 = fmul float %259, %265
%274 = load float, float* %33
%275 = tail call float @llvm.fmuladd.f32(float %273, float %274, float %272)
%276 = fneg float %270
%277 = fmul float %256, %276
%278 = tail call float @llvm.fmuladd.f32(float %277, float %274, float %275)
%279 = fdiv float %278, %4
%280 = getelementptr inbounds float, float* %0, i64 6
store float %279, float* %280
%281 = load float, float* %41
%282 = fneg float %281
%283 = load float, float* %28
%284 = fmul float %283, %282
%285 = load float, float* %125
%286 = load float, float* %58
%287 = load float, float* %7
%288 = fmul float %286, %287
%289 = fmul float %285, %288
%290 = tail call float @llvm.fmuladd.f32(float %284, float %285, float %289)
%291 = load float, float* %139
%292 = fmul float %281, %291
%293 = load float, float* %13
%294 = tail call float @llvm.fmuladd.f32(float %292, float %293, float %290)
%295 = load float, float* %1
%296 = fneg float %295
%297 = fmul float %287, %296
%298 = tail call float @llvm.fmuladd.f32(float %297, float %293, float %294)
%299 = load float, float* %33
%300 = fneg float %286
%301 = fmul float %291, %300
%302 = tail call float @llvm.fmuladd.f32(float %301, float %299, float %298)
%303 = fmul float %283, %295
%304 = tail call float @llvm.fmuladd.f32(float %303, float %299, float %302)
%305 = fdiv float %304, %4
%306 = getelementptr inbounds float, float* %0, i64 10
store float %305, float* %306
%307 = load float, float* %41
%308 = load float, float* %28
%309 = fmul float %307, %308
%310 = load float, float* %133
%311 = load float, float* %58
%312 = load float, float* %7
%313 = fneg float %311
%314 = fmul float %312, %313
%315 = fmul float %310, %314
%316 = tail call float @llvm.fmuladd.f32(float %309, float %310, float %315)
%317 = load float, float* %139
%318 = load float, float* %22
%319 = fneg float %307
%320 = fmul float %317, %319
%321 = tail call float @llvm.fmuladd.f32(float %320, float %318, float %316)
%322 = load float, float* %1
%323 = fmul float %312, %322
%324 = tail call float @llvm.fmuladd.f32(float %323, float %318, float %321)
%325 = fmul float %311, %317
%326 = load float, float* %17
%327 = tail call float @llvm.fmuladd.f32(float %325, float %326, float %324)
%328 = fneg float %322
%329 = fmul float %308, %328
%330 = tail call float @llvm.fmuladd.f32(float %329, float %326, float %327)
%331 = fdiv float %330, %4
%332 = getelementptr inbounds float, float* %0, i64 14
store float %331, float* %332
%333 = load float, float* %15
%334 = load float, float* %22
%335 = fmul float %333, %334
%336 = load float, float* %125
%337 = load float, float* %28
%338 = load float, float* %10
%339 = fneg float %337
%340 = fmul float %338, %339
%341 = fmul float %336, %340
%342 = tail call float @llvm.fmuladd.f32(float %335, float %336, float %341)
%343 = load float, float* %133
%344 = load float, float* %13
%345 = fneg float %333
%346 = fmul float %343, %345
%347 = tail call float @llvm.fmuladd.f32(float %346, float %344, float %342)
%348 = load float, float* %139
%349 = fmul float %338, %348
%350 = tail call float @llvm.fmuladd.f32(float %349, float %344, float %347)
%351 = fmul float %337, %343
%352 = load float, float* %25
%353 = tail call float @llvm.fmuladd.f32(float %351, float %352, float %350)
%354 = fneg float %348
%355 = fmul float %334, %354
%356 = tail call float @llvm.fmuladd.f32(float %355, float %352, float %353)
%357 = fdiv float %356, %4
%358 = getelementptr inbounds float, float* %0, i64 3
store float %357, float* %358
%359 = load float, float* %46
%360 = fneg float %359
%361 = load float, float* %22
%362 = fmul float %361, %360
%363 = load float, float* %125
%364 = load float, float* %58
%365 = load float, float* %10
%366 = fmul float %364, %365
%367 = fmul float %363, %366
%368 = tail call float @llvm.fmuladd.f32(float %362, float %363, float %367)
%369 = load float, float* %133
%370 = fmul float %359, %369
%371 = load float, float* %13
%372 = tail call float @llvm.fmuladd.f32(float %370, float %371, float %368)
%373 = load float, float* %1
%374 = fneg float %373
%375 = fmul float %365, %374
%376 = tail call float @llvm.fmuladd.f32(float %375, float %371, float %372)
%377 = load float, float* %25
%378 = fneg float %364
%379 = fmul float %369, %378
%380 = tail call float @llvm.fmuladd.f32(float %379, float %377, float %376)
%381 = fmul float %361, %373
%382 = tail call float @llvm.fmuladd.f32(float %381, float %377, float %380)
%383 = fdiv float %382, %4
%384 = getelementptr inbounds float, float* %0, i64 7
store float %383, float* %384
%385 = load float, float* %46
%386 = load float, float* %28
%387 = fmul float %385, %386
%388 = load float, float* %125
%389 = load float, float* %58
%390 = load float, float* %15
%391 = fneg float %389
%392 = fmul float %390, %391
%393 = fmul float %388, %392
%394 = tail call float @llvm.fmuladd.f32(float %387, float %388, float %393)
%395 = load float, float* %139
%396 = load float, float* %13
%397 = fneg float %385
%398 = fmul float %395, %397
%399 = tail call float @llvm.fmuladd.f32(float %398, float %396, float %394)
%400 = load float, float* %1
%401 = fmul float %390, %400
%402 = tail call float @llvm.fmuladd.f32(float %401, float %396, float %399)
%403 = fmul float %389, %395
%404 = load float, float* %25
%405 = tail call float @llvm.fmuladd.f32(float %403, float %404, float %402)
%406 = fneg float %400
%407 = fmul float %386, %406
%408 = tail call float @llvm.fmuladd.f32(float %407, float %404, float %405)
%409 = fdiv float %408, %4
%410 = getelementptr inbounds float, float* %0, i64 11
store float %409, float* %410
%411 = load float, float* %46
%412 = fneg float %411
%413 = load float, float* %28
%414 = fmul float %413, %412
%415 = load float, float* %133
%416 = load float, float* %58
%417 = load float, float* %15
%418 = fmul float %416, %417
%419 = fmul float %415, %418
%420 = tail call float @llvm.fmuladd.f32(float %414, float %415, float %419)
%421 = load float, float* %139
%422 = fmul float %411, %421
%423 = load float, float* %22
%424 = tail call float @llvm.fmuladd.f32(float %422, float %423, float %420)
%425 = load float, float* %1
%426 = fneg float %425
%427 = fmul float %417, %426
%428 = tail call float @llvm.fmuladd.f32(float %427, float %423, float %424)
%429 = load float, float* %10
%430 = fneg float %416
%431 = fmul float %421, %430
%432 = tail call float @llvm.fmuladd.f32(float %431, float %429, float %428)
%433 = fmul float %413, %425
%434 = tail call float @llvm.fmuladd.f32(float %433, float %429, float %432)
%435 = fdiv float %434, %4
%436 = getelementptr inbounds float, float* %0, i64 15
store float %435, float* %436
br label %437
437: ; preds = %2, %6
%438 = phi i32 [ 1, %6 ], [ 0, %2 ]
ret i32 %438
}