void mat4_invert(float *dst) {
  float a00 = dst[0], a01 = dst[1], a02 = dst[2], a03 = dst[3];
  float a10 = dst[4], a11 = dst[5], a12 = dst[6], a13 = dst[7];
  float a20 = dst[8], a21 = dst[9], a22 = dst[10], a23 = dst[11];
  float a30 = dst[12], a31 = dst[13], a32 = dst[14], a33 = dst[15];
  float b00 = (a00 * a11) - (a01 * a10);
  float b01 = (a00 * a12) - (a02 * a10);
  float b02 = (a00 * a13) - (a03 * a10);
  float b03 = (a01 * a12) - (a02 * a11);
  float b04 = (a01 * a13) - (a03 * a11);
  float b05 = (a02 * a13) - (a03 * a12);
  float b06 = (a20 * a31) - (a21 * a30);
  float b07 = (a20 * a32) - (a22 * a30);
  float b08 = (a20 * a33) - (a23 * a30);
  float b09 = (a21 * a32) - (a22 * a31);
  float b10 = (a21 * a33) - (a23 * a31);
  float b11 = (a22 * a33) - (a23 * a32);
  float det = (b00 * b11) - (b01 * b10) + (b02 * b09) + (b03 * b08) -
              (b04 * b07) + (b05 * b06);
  if (!det) {
    return;
  }
  det = 1.0 / det;
  dst[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
  dst[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
  dst[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
  dst[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
  dst[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
  dst[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
  dst[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
  dst[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
  dst[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
  dst[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
  dst[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
  dst[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
  dst[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
  dst[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
  dst[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
  dst[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
}


x86 assembly (clang, -O0):
<mat4_invert>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x24(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movss  0x28(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movss  0x2c(%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  0x30(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
movss  0x34(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movss  0x38(%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%rax
movss  0x3c(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0xc(%rbp),%xmm0
movss  -0x20(%rbp),%xmm2
movss  -0x10(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0xc(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0xc(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x10(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x10(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x14(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x18(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x30(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x34(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x44(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  -0x78(%rbp),%xmm2
movss  -0x50(%rbp),%xmm1
mulss  -0x74(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x54(%rbp),%xmm1
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x58(%rbp),%xmm0
movss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  -0x5c(%rbp),%xmm1
movss  -0x68(%rbp),%xmm2
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14ae <mat4_invert+0x3ae>
jp     14ae <mat4_invert+0x3ae>
jmp    19c3 <mat4_invert+0x8c3>
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xb41(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x20(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
movss  -0x24(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x14(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x10(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x40(%rbp),%xmm1
movss  -0x60(%rbp),%xmm2
movss  -0x44(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x34(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  -0x30(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0xc(%rax)
movss  -0x24(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x10(%rax)
movss  -0xc(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
movss  -0x14(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x14(%rax)
movss  -0x44(%rbp),%xmm1
movss  -0x54(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x18(%rax)
movss  -0x2c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm2
movss  -0x34(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x1c(%rax)
movss  -0x1c(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
movss  -0x20(%rbp),%xmm0
mulss  -0x6c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x20(%rax)
movss  -0x10(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm2
movss  -0xc(%rbp),%xmm0
mulss  -0x74(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x18(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x24(%rax)
movss  -0x3c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm0
mulss  -0x54(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x48(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x28(%rax)
movss  -0x30(%rbp),%xmm1
movss  -0x54(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x38(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x2c(%rax)
movss  -0x20(%rbp),%xmm1
movss  -0x68(%rbp),%xmm2
movss  -0x1c(%rbp),%xmm0
mulss  -0x70(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x24(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x30(%rax)
movss  -0xc(%rbp),%xmm1
movss  -0x70(%rbp),%xmm2
movss  -0x10(%rbp),%xmm0
mulss  -0x68(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x14(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x34(%rax)
movss  -0x40(%rbp),%xmm1
movss  -0x50(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm0
mulss  -0x58(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x38(%rax)
movss  -0x2c(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
movss  -0x30(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x7c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x3c(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<mat4_invert>:
sub    $0x128,%rsp
movss  (%rdi),%xmm4
movsd  0x4(%rdi),%xmm7
movaps %xmm7,-0x60(%rsp)
movd   0xc(%rdi),%xmm0
movdqa %xmm0,0x10(%rsp)
movss  0x10(%rdi),%xmm3
movss  0x1c(%rdi),%xmm5
movaps %xmm5,-0x80(%rsp)
movss  0x20(%rdi),%xmm10
movsd  0x24(%rdi),%xmm2
movd   0x2c(%rdi),%xmm14
movdqa %xmm14,(%rsp)
movss  0x30(%rdi),%xmm6
punpckldq %xmm0,%xmm14
pxor   0xea7(%rip),%xmm14
pshufd $0x55,%xmm14,%xmm1
movaps %xmm3,%xmm0
movdqa %xmm1,0xc0(%rsp)
mulss  %xmm1,%xmm0
movaps %xmm4,%xmm13
mulss  %xmm5,%xmm13
addss  %xmm0,%xmm13
movaps %xmm2,%xmm12
unpcklps %xmm7,%xmm12
movaps %xmm6,%xmm1
movaps %xmm3,0x110(%rsp)
unpcklps %xmm3,%xmm1
movaps %xmm1,%xmm5
mulps  %xmm12,%xmm5
movaps %xmm10,%xmm0
movaps %xmm4,-0x10(%rsp)
unpcklps %xmm4,%xmm0
movss  0x14(%rdi),%xmm8
movsd  0x34(%rdi),%xmm4
movaps %xmm8,%xmm3
movlhps %xmm4,%xmm3
shufps $0xe2,%xmm4,%xmm3
movaps %xmm0,%xmm15
mulps  %xmm3,%xmm15
subps  %xmm5,%xmm15
shufps $0x11,%xmm2,%xmm7
shufps $0xe2,%xmm2,%xmm7
mulps  %xmm7,%xmm1
movss  0x18(%rdi),%xmm9
movaps %xmm9,%xmm11
shufps $0xd4,%xmm4,%xmm11
shufps $0x52,%xmm4,%xmm11
mulps  %xmm11,%xmm0
subps  %xmm1,%xmm0
movaps %xmm6,-0x20(%rsp)
movaps %xmm6,%xmm5
movdqa %xmm14,-0x70(%rsp)
mulss  %xmm14,%xmm5
movss  0x3c(%rdi),%xmm14
movaps %xmm10,0x100(%rsp)
movaps %xmm10,%xmm1
mulss  %xmm14,%xmm1
addss  %xmm5,%xmm1
movaps %xmm7,0xd0(%rsp)
mulps  %xmm7,%xmm3
movaps %xmm12,%xmm10
mulps  %xmm12,%xmm11
subps  %xmm3,%xmm11
movaps %xmm8,-0x30(%rsp)
movaps %xmm9,0xb0(%rsp)
movlhps %xmm9,%xmm8
movaps %xmm0,%xmm6
movaps %xmm4,-0x50(%rsp)
shufps $0x21,%xmm8,%xmm4
movaps (%rsp),%xmm3
shufps $0x0,0x10(%rsp),%xmm3
mulps  %xmm3,%xmm4
movaps %xmm2,%xmm12
shufps $0x11,-0x60(%rsp),%xmm2
movaps %xmm14,%xmm8
shufps $0x0,-0x80(%rsp),%xmm14
mulps  %xmm2,%xmm14
subps  %xmm4,%xmm14
movaps %xmm15,%xmm3
shufps $0x55,%xmm15,%xmm3
movaps %xmm0,%xmm5
shufps $0x55,%xmm0,%xmm5
movaps %xmm14,%xmm0
shufps $0x55,%xmm14,%xmm0
movaps %xmm0,0xe0(%rsp)
mulss  %xmm0,%xmm5
mulss  %xmm14,%xmm3
subss  %xmm5,%xmm3
movaps %xmm13,0xf0(%rsp)
mulss  %xmm11,%xmm13
addss  %xmm3,%xmm13
movaps %xmm11,-0x40(%rsp)
shufps $0x55,%xmm11,%xmm11
mulss  %xmm1,%xmm11
addss  %xmm13,%xmm11
movaps %xmm14,%xmm2
shufps $0xff,%xmm14,%xmm2
movaps %xmm2,%xmm3
movaps %xmm6,0xa0(%rsp)
mulss  %xmm6,%xmm3
subss  %xmm3,%xmm11
movaps %xmm14,%xmm4
unpckhpd %xmm14,%xmm4
movaps %xmm4,%xmm3
mulss  %xmm15,%xmm3
addss  %xmm11,%xmm3
xorps  %xmm7,%xmm7
ucomiss %xmm7,%xmm3
jne    1316 <mat4_invert+0x216>
jnp    15a9 <mat4_invert+0x4a9>
movaps %xmm15,%xmm0
movaps %xmm4,%xmm15
movss  0xcea(%rip),%xmm4
divss  %xmm3,%xmm4
movaps %xmm8,%xmm11
movaps 0xccb(%rip),%xmm6
xorps  %xmm6,%xmm10
movaps %xmm12,0x20(%rsp)
movaps -0x50(%rsp),%xmm9
movaps %xmm9,%xmm13
shufps $0x55,%xmm9,%xmm13
movaps %xmm0,0x40(%rsp)
movaps %xmm10,%xmm5
movaps %xmm10,0x60(%rsp)
movaps 0xb0(%rsp),%xmm10
movaps %xmm10,%xmm8
xorps  %xmm6,%xmm8
movaps %xmm13,%xmm0
xorps  %xmm6,%xmm0
movaps %xmm0,0x90(%rsp)
movaps %xmm5,%xmm7
shufps $0x55,%xmm5,%xmm7
movaps %xmm7,0x50(%rsp)
movaps %xmm8,%xmm3
unpcklps %xmm7,%xmm3
movaps %xmm5,%xmm7
movlhps %xmm0,%xmm7
shufps $0x24,%xmm7,%xmm3
movaps %xmm14,%xmm7
shufps $0xb1,%xmm14,%xmm7
mulps  %xmm7,%xmm3
movaps %xmm2,0x30(%rsp)
movaps -0x60(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm12,%xmm7
shufps $0x55,%xmm12,%xmm7
movaps %xmm7,0x80(%rsp)
movaps -0x30(%rsp),%xmm12
unpcklps %xmm0,%xmm12
movlhps %xmm9,%xmm7
shufps $0x24,%xmm7,%xmm12
mulps  %xmm14,%xmm12
addps  %xmm3,%xmm12
movaps %xmm11,%xmm3
unpcklps -0x70(%rsp),%xmm3
movaps -0x80(%rsp),%xmm7
movaps %xmm7,%xmm0
unpcklps 0xc0(%rsp),%xmm0
movlhps %xmm3,%xmm0
movaps -0x40(%rsp),%xmm3
unpcklps %xmm3,%xmm3
mulps  %xmm0,%xmm3
addps  %xmm12,%xmm3
shufps $0x0,%xmm4,%xmm4
movaps %xmm4,-0x70(%rsp)
mulps  %xmm4,%xmm3
movups %xmm3,(%rdi)
movaps 0xd0(%rsp),%xmm4
xorps  %xmm6,%xmm4
movaps 0x110(%rsp),%xmm12
movaps %xmm12,%xmm3
xorps  %xmm6,%xmm3
xorps  %xmm6,%xmm7
movaps -0x20(%rsp),%xmm5
xorps  %xmm6,%xmm5
movaps %xmm5,%xmm9
movaps %xmm5,-0x80(%rsp)
xorps  %xmm6,%xmm11
movaps %xmm4,%xmm6
movlhps %xmm15,%xmm4
shufps $0xc5,%xmm14,%xmm6
shufps $0x22,%xmm4,%xmm6
movaps %xmm3,%xmm5
unpcklps %xmm1,%xmm5
movaps 0xf0(%rsp),%xmm15
movaps %xmm15,%xmm2
movlhps %xmm9,%xmm2
shufps $0x24,%xmm2,%xmm5
mulps  %xmm6,%xmm5
movaps 0x100(%rsp),%xmm6
unpcklps %xmm6,%xmm13
unpcklps -0x10(%rsp),%xmm10
movlhps %xmm13,%xmm10
movaps %xmm1,%xmm2
unpcklps %xmm14,%xmm2
movaps %xmm14,%xmm4
shufps $0x4e,%xmm15,%xmm4
shufps $0x24,%xmm4,%xmm2
mulps  %xmm10,%xmm2
addps  %xmm5,%xmm2
unpcklps (%rsp),%xmm11
unpcklps 0x10(%rsp),%xmm7
movlhps %xmm11,%xmm7
movaps 0xa0(%rsp),%xmm5
movaps %xmm5,%xmm4
unpcklps %xmm5,%xmm4
mulps  %xmm4,%xmm7
addps  %xmm2,%xmm7
movaps -0x70(%rsp),%xmm9
mulps  %xmm9,%xmm7
movups %xmm7,0x10(%rdi)
movaps -0x30(%rsp),%xmm4
unpcklps -0x10(%rsp),%xmm4
unpcklpd -0x50(%rsp),%xmm6
shufps $0x24,%xmm6,%xmm4
movaps %xmm1,%xmm2
unpcklps 0xe0(%rsp),%xmm2
shufps $0xd4,%xmm14,%xmm1
shufps $0xc7,%xmm15,%xmm14
shufps $0x24,%xmm14,%xmm2
movaps -0x20(%rsp),%xmm6
unpcklpd 0x20(%rsp),%xmm6
unpcklps -0x60(%rsp),%xmm12
shufps $0x84,%xmm6,%xmm12
unpcklpd 0x30(%rsp),%xmm15
shufps $0x22,%xmm15,%xmm1
mulps  %xmm12,%xmm1
mulps  %xmm4,%xmm2
subps  %xmm2,%xmm1
movaps 0x40(%rsp),%xmm2
unpcklps %xmm2,%xmm2
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
mulps  %xmm9,%xmm0
movups %xmm0,0x20(%rdi)
unpcklps 0x50(%rsp),%xmm3
movaps 0x60(%rsp),%xmm0
unpcklpd -0x80(%rsp),%xmm0
shufps $0x24,%xmm0,%xmm3
movaps -0x40(%rsp),%xmm0
movaps %xmm0,%xmm1
unpcklps %xmm5,%xmm1
mulps  %xmm1,%xmm3
unpcklps %xmm0,%xmm5
mulps  %xmm4,%xmm5
addps  %xmm3,%xmm5
unpcklps 0x70(%rsp),%xmm8
movaps 0x80(%rsp),%xmm0
unpcklpd 0x90(%rsp),%xmm0
shufps $0x24,%xmm0,%xmm8
mulps  %xmm2,%xmm8
addps  %xmm5,%xmm8
mulps  %xmm9,%xmm8
movups %xmm8,0x30(%rdi)
add    $0x128,%rsp
ret

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

LLVM IR (-O2):
define void @mat4_invert(float* nocapture %0) {
%2 = load float, float* %0
%3 = getelementptr inbounds float, float* %0, i64 1
%4 = bitcast float* %3 to <2 x float>*
%5 = load <2 x float>, <2 x float>* %4
%6 = getelementptr inbounds float, float* %0, i64 3
%7 = load float, float* %6
%8 = getelementptr inbounds float, float* %0, i64 4
%9 = load float, float* %8
%10 = getelementptr inbounds float, float* %0, i64 5
%11 = load float, float* %10
%12 = getelementptr inbounds float, float* %0, i64 6
%13 = load float, float* %12
%14 = getelementptr inbounds float, float* %0, i64 7
%15 = load float, float* %14
%16 = getelementptr inbounds float, float* %0, i64 8
%17 = load float, float* %16
%18 = getelementptr inbounds float, float* %0, i64 9
%19 = bitcast float* %18 to <2 x float>*
%20 = load <2 x float>, <2 x float>* %19
%21 = getelementptr inbounds float, float* %0, i64 11
%22 = load float, float* %21
%23 = getelementptr inbounds float, float* %0, i64 12
%24 = load float, float* %23
%25 = getelementptr inbounds float, float* %0, i64 13
%26 = bitcast float* %25 to <2 x float>*
%27 = load <2 x float>, <2 x float>* %26
%28 = getelementptr inbounds float, float* %0, i64 15
%29 = load float, float* %28
%30 = extractelement <2 x float> %20, i64 1
%31 = extractelement <2 x float> %5, i64 1
%32 = shufflevector <2 x float> %20, <2 x float> %5, <2 x i32> <i32 1, i32 3>
%33 = fneg <2 x float> %32
%34 = insertelement <2 x float> poison, float %22, i64 0
%35 = insertelement <2 x float> %34, float %7, i64 1
%36 = fneg <2 x float> %35
%37 = shufflevector <2 x float> %36, <2 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%38 = extractelement <2 x float> %36, i64 1
%39 = fmul float %9, %38
%40 = tail call float @llvm.fmuladd.f32(float %2, float %15, float %39)
%41 = shufflevector <2 x float> %20, <2 x float> %5, <2 x i32> <i32 0, i32 2>
%42 = fneg <2 x float> %41
%43 = insertelement <2 x float> poison, float %24, i64 0
%44 = insertelement <2 x float> %43, float %9, i64 1
%45 = fmul <2 x float> %44, %42
%46 = insertelement <2 x float> poison, float %17, i64 0
%47 = insertelement <2 x float> %46, float %2, i64 1
%48 = extractelement <2 x float> %27, i64 0
%49 = insertelement <2 x float> %27, float %11, i64 1
%50 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %47, <2 x float> %49, <2 x float> %45)
%51 = fmul <2 x float> %44, %33
%52 = extractelement <2 x float> %27, i64 1
%53 = insertelement <2 x float> poison, float %52, i64 0
%54 = insertelement <2 x float> %53, float %13, i64 1
%55 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %47, <2 x float> %54, <2 x float> %51)
%56 = extractelement <2 x float> %36, i64 0
%57 = fmul float %24, %56
%58 = tail call float @llvm.fmuladd.f32(float %17, float %29, float %57)
%59 = fmul <2 x float> %49, %33
%60 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %41, <2 x float> %54, <2 x float> %59)
%61 = shufflevector <2 x float> %27, <2 x float> poison, <4 x i32> <i32 1, i32 0, i32 undef, i32 undef>
%62 = insertelement <4 x float> %61, float %13, i64 2
%63 = insertelement <4 x float> %62, float %11, i64 3
%64 = fmul <4 x float> %63, %37
%65 = shufflevector <2 x float> %20, <2 x float> poison, <4 x i32> <i32 1, i32 0, i32 undef, i32 undef>
%66 = shufflevector <2 x float> %5, <2 x float> poison, <4 x i32> <i32 1, i32 0, i32 undef, i32 undef>
%67 = shufflevector <4 x float> %65, <4 x float> %66, <4 x i32> <i32 0, i32 1, i32 4, i32 5>
%68 = insertelement <4 x float> poison, float %29, i64 0
%69 = insertelement <4 x float> %68, float %15, i64 1
%70 = shufflevector <4 x float> %69, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%71 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %67, <4 x float> %70, <4 x float> %64)
%72 = extractelement <2 x float> %55, i64 1
%73 = fneg float %72
%74 = extractelement <4 x float> %71, i64 1
%75 = fmul float %74, %73
%76 = extractelement <4 x float> %71, i64 0
%77 = extractelement <2 x float> %50, i64 1
%78 = tail call float @llvm.fmuladd.f32(float %77, float %76, float %75)
%79 = extractelement <2 x float> %60, i64 0
%80 = tail call float @llvm.fmuladd.f32(float %40, float %79, float %78)
%81 = extractelement <2 x float> %60, i64 1
%82 = tail call float @llvm.fmuladd.f32(float %81, float %58, float %80)
%83 = extractelement <4 x float> %71, i64 3
%84 = fneg float %83
%85 = extractelement <2 x float> %55, i64 0
%86 = tail call float @llvm.fmuladd.f32(float %84, float %85, float %82)
%87 = extractelement <4 x float> %71, i64 2
%88 = extractelement <2 x float> %50, i64 0
%89 = tail call float @llvm.fmuladd.f32(float %87, float %88, float %86)
%90 = fcmp une float %89, 0.000000e+00
br i1 %90, label %91, label %186
91: ; preds = %1
%92 = shufflevector <2 x float> %50, <2 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%93 = shufflevector <2 x float> %55, <2 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%94 = shufflevector <2 x float> %60, <2 x float> poison, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%95 = extractelement <2 x float> %5, i64 0
%96 = extractelement <2 x float> %20, i64 0
%97 = fdiv float 1.000000e+00, %89
%98 = fneg float %13
%99 = fneg float %52
%100 = shufflevector <4 x float> %71, <4 x float> undef, <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>
%101 = shufflevector <4 x float> %100, <4 x float> %71, <4 x i32> <i32 0, i32 4, i32 7, i32 6>
%102 = insertelement <4 x float> poison, float %98, i64 0
%103 = extractelement <2 x float> %42, i64 1
%104 = insertelement <4 x float> %102, float %103, i64 1
%105 = insertelement <4 x float> %104, float %99, i64 2
%106 = extractelement <2 x float> %42, i64 0
%107 = insertelement <4 x float> %105, float %106, i64 3
%108 = fmul <4 x float> %101, %107
%109 = insertelement <4 x float> poison, float %11, i64 0
%110 = insertelement <4 x float> %109, float %31, i64 1
%111 = insertelement <4 x float> %110, float %48, i64 2
%112 = insertelement <4 x float> %111, float %30, i64 3
%113 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %112, <4 x float> %71, <4 x float> %108)
%114 = insertelement <4 x float> poison, float %15, i64 0
%115 = insertelement <4 x float> %114, float %38, i64 1
%116 = insertelement <4 x float> %115, float %29, i64 2
%117 = insertelement <4 x float> %116, float %56, i64 3
%118 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %117, <4 x float> %94, <4 x float> %113)
%119 = insertelement <4 x float> poison, float %97, i64 0
%120 = shufflevector <4 x float> %119, <4 x float> poison, <4 x i32> zeroinitializer
%121 = fmul <4 x float> %118, %120
%122 = bitcast float* %0 to <4 x float>*
store <4 x float> %121, <4 x float>* %122
%123 = fneg float %9
%124 = fneg float %15
%125 = extractelement <2 x float> %33, i64 1
%126 = fneg float %24
%127 = fneg float %29
%128 = extractelement <2 x float> %33, i64 0
%129 = insertelement <4 x float> %71, float %125, i64 1
%130 = insertelement <4 x float> %129, float %87, i64 2
%131 = insertelement <4 x float> %130, float %128, i64 3
%132 = insertelement <4 x float> poison, float %123, i64 0
%133 = insertelement <4 x float> %132, float %58, i64 1
%134 = insertelement <4 x float> %133, float %126, i64 2
%135 = insertelement <4 x float> %134, float %40, i64 3
%136 = fmul <4 x float> %131, %135
%137 = insertelement <4 x float> poison, float %13, i64 0
%138 = insertelement <4 x float> %137, float %2, i64 1
%139 = insertelement <4 x float> %138, float %52, i64 2
%140 = insertelement <4 x float> %139, float %17, i64 3
%141 = insertelement <4 x float> poison, float %58, i64 0
%142 = insertelement <4 x float> %141, float %76, i64 1
%143 = insertelement <4 x float> %142, float %40, i64 2
%144 = shufflevector <4 x float> %143, <4 x float> %71, <4 x i32> <i32 0, i32 1, i32 2, i32 6>
%145 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %140, <4 x float> %144, <4 x float> %136)
%146 = insertelement <4 x float> poison, float %124, i64 0
%147 = insertelement <4 x float> %146, float %7, i64 1
%148 = insertelement <4 x float> %147, float %127, i64 2
%149 = insertelement <4 x float> %148, float %22, i64 3
%150 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %149, <4 x float> %93, <4 x float> %145)
%151 = fmul <4 x float> %150, %120
%152 = bitcast float* %8 to <4 x float>*
store <4 x float> %151, <4 x float>* %152
%153 = insertelement <4 x float> %109, float %2, i64 1
%154 = insertelement <4 x float> %153, float %48, i64 2
%155 = insertelement <4 x float> %154, float %17, i64 3
%156 = fneg <4 x float> %155
%157 = insertelement <4 x float> %141, float %74, i64 1
%158 = insertelement <4 x float> %157, float %40, i64 2
%159 = shufflevector <4 x float> %158, <4 x float> %71, <4 x i32> <i32 0, i32 1, i32 2, i32 7>
%160 = fmul <4 x float> %159, %156
%161 = insertelement <4 x float> poison, float %9, i64 0
%162 = insertelement <4 x float> %161, float %95, i64 1
%163 = insertelement <4 x float> %162, float %24, i64 2
%164 = insertelement <4 x float> %163, float %96, i64 3
%165 = insertelement <4 x float> %100, float %58, i64 1
%166 = insertelement <4 x float> %165, float %83, i64 2
%167 = insertelement <4 x float> %166, float %40, i64 3
%168 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %164, <4 x float> %167, <4 x float> %160)
%169 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %117, <4 x float> %92, <4 x float> %168)
%170 = fmul <4 x float> %169, %120
%171 = bitcast float* %16 to <4 x float>*
store <4 x float> %170, <4 x float>* %171
%172 = shufflevector <2 x float> %60, <2 x float> %55, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
%173 = insertelement <4 x float> %132, float %103, i64 1
%174 = insertelement <4 x float> %173, float %126, i64 2
%175 = insertelement <4 x float> %174, float %106, i64 3
%176 = fmul <4 x float> %172, %175
%177 = shufflevector <2 x float> %55, <2 x float> %60, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
%178 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %155, <4 x float> %177, <4 x float> %176)
%179 = insertelement <4 x float> %102, float %31, i64 1
%180 = insertelement <4 x float> %179, float %99, i64 2
%181 = insertelement <4 x float> %180, float %30, i64 3
%182 = shufflevector <2 x float> %50, <2 x float> undef, <4 x i32> <i32 0, i32 0, i32 1, i32 1>
%183 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %181, <4 x float> %182, <4 x float> %178)
%184 = fmul <4 x float> %183, %120
%185 = bitcast float* %23 to <4 x float>*
store <4 x float> %184, <4 x float>* %185
br label %186
186: ; preds = %1, %91
ret void
}