int m_inverse(const float *m, float *out) {
  float det;
  det = m[0] * m[5] * m[10];
  det += m[4] * m[9] * m[2];
  det += m[8] * m[1] * m[6];
  det -= m[8] * m[5] * m[2];
  det -= m[4] * m[1] * m[10];
  det -= m[0] * m[9] * m[6];
  if (det * det < 1e-6)
    return -1;
  det = 1.0 / det;
  out[0] = (m[5] * m[10] - m[9] * m[6]) * det;
  out[1] = -(m[1] * m[10] - m[9] * m[2]) * det;
  out[2] = (m[1] * m[6] - m[5] * m[2]) * det;
  out[3] = 0.0;
  out[4] = -(m[4] * m[10] - m[8] * m[6]) * det;
  out[5] = (m[0] * m[10] - m[8] * m[2]) * det;
  out[6] = -(m[0] * m[6] - m[4] * m[2]) * det;
  out[7] = 0.0;
  out[8] = (m[4] * m[9] - m[8] * m[5]) * det;
  out[9] = -(m[0] * m[9] - m[8] * m[1]) * det;
  out[10] = (m[0] * m[5] - m[4] * m[1]) * det;
  out[11] = 0.0;
  out[12] = -(m[12] * out[0] + m[13] * out[4] + m[14] * out[8]);
  out[13] = -(m[12] * out[1] + m[13] * out[5] + m[14] * out[9]);
  out[14] = -(m[12] * out[2] + m[13] * out[6] + m[14] * out[10]);
  out[15] = 1.0;
  return 0;
}


x86 assembly (clang, -O0):
<m_inverse>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x28(%rax),%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
movss  -0x1c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
movss  -0x1c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
movss  -0x1c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x24(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
movss  -0x1c(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x1c(%rbp)
movss  -0x1c(%rbp),%xmm0
mulss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdb8(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    125e <m_inverse+0x15e>
movl   $0xffffffff,-0x4(%rbp)
jmp    1679 <m_inverse+0x579>
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd99(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0xc(%rax)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x18(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x28(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x1c(%rax)
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x14(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x24(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x20(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x24(%rax)
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x28(%rax)
mov    -0x18(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x2c(%rax)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x10(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x30(%rax)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x24(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x34(%rax)
mov    -0x10(%rbp),%rax
movss  0x30(%rax),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mov    -0x10(%rbp),%rax
movss  0x34(%rax),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x18(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movss  0x38(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x28(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movss  %xmm0,0x38(%rax)
mov    -0x18(%rbp),%rax
movss  0x9a3(%rip),%xmm0
movss  %xmm0,0x3c(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<m_inverse>:
movss  0x14(%rdi),%xmm11
movss  (%rdi),%xmm3
movss  0x4(%rdi),%xmm4
movaps %xmm3,%xmm6
mulss  %xmm11,%xmm6
movss  0x28(%rdi),%xmm8
mulss  %xmm8,%xmm6
movss  0x10(%rdi),%xmm7
movss  0x24(%rdi),%xmm2
movss  0x20(%rdi),%xmm1
movaps %xmm1,%xmm5
mulss  %xmm4,%xmm5
mulss  %xmm7,%xmm4
mulss  %xmm2,%xmm7
movss  0x8(%rdi),%xmm0
mulss  %xmm0,%xmm7
addss  %xmm6,%xmm7
movss  0x18(%rdi),%xmm6
mulss  %xmm6,%xmm5
addss  %xmm7,%xmm5
mulss  %xmm11,%xmm1
mulss  %xmm0,%xmm1
subss  %xmm1,%xmm5
mulss  %xmm8,%xmm4
subss  %xmm4,%xmm5
mulss  %xmm2,%xmm3
mulss  %xmm6,%xmm3
subss  %xmm3,%xmm5
movaps %xmm5,%xmm0
mulss  %xmm5,%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0xffffffff,%eax
movsd  0xe6c(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     1370 <m_inverse+0x270>
movss  0xe61(%rip),%xmm10
divss  %xmm5,%xmm10
mulss  %xmm2,%xmm6
mulss  %xmm8,%xmm11
subss  %xmm6,%xmm11
mulss  %xmm10,%xmm11
movss  %xmm11,(%rsi)
movss  0x8(%rdi),%xmm0
mulss  0x24(%rdi),%xmm0
movss  0x4(%rdi),%xmm3
mulss  0x28(%rdi),%xmm3
subss  %xmm0,%xmm3
movaps 0xe2c(%rip),%xmm8
xorps  %xmm8,%xmm3
mulss  %xmm10,%xmm3
movss  %xmm3,0x4(%rsi)
movss  0x4(%rdi),%xmm9
movss  0x8(%rdi),%xmm0
mulss  0x14(%rdi),%xmm0
mulss  0x18(%rdi),%xmm9
subss  %xmm0,%xmm9
mulss  %xmm10,%xmm9
movss  %xmm9,0x8(%rsi)
movl   $0x0,0xc(%rsi)
movss  0x10(%rdi),%xmm6
movss  0x18(%rdi),%xmm0
mulss  0x20(%rdi),%xmm0
mulss  0x28(%rdi),%xmm6
subss  %xmm0,%xmm6
xorps  %xmm8,%xmm6
mulss  %xmm10,%xmm6
movss  %xmm6,0x10(%rsi)
movss  0x8(%rdi),%xmm0
mulss  0x20(%rdi),%xmm0
movss  (%rdi),%xmm7
mulss  0x28(%rdi),%xmm7
subss  %xmm0,%xmm7
mulss  %xmm10,%xmm7
movss  %xmm7,0x14(%rsi)
movss  (%rdi),%xmm5
movss  0x8(%rdi),%xmm0
mulss  0x10(%rdi),%xmm0
mulss  0x18(%rdi),%xmm5
subss  %xmm0,%xmm5
xorps  %xmm8,%xmm5
mulss  %xmm10,%xmm5
movss  %xmm5,0x18(%rsi)
movl   $0x0,0x1c(%rsi)
movss  0x10(%rdi),%xmm4
movss  0x14(%rdi),%xmm0
mulss  0x20(%rdi),%xmm0
mulss  0x24(%rdi),%xmm4
subss  %xmm0,%xmm4
mulss  %xmm10,%xmm4
movss  %xmm4,0x20(%rsi)
movss  (%rdi),%xmm2
movss  0x4(%rdi),%xmm0
mulss  0x20(%rdi),%xmm0
mulss  0x24(%rdi),%xmm2
subss  %xmm0,%xmm2
xorps  %xmm8,%xmm2
mulss  %xmm10,%xmm2
movss  %xmm2,0x24(%rsi)
movss  (%rdi),%xmm1
movss  0x4(%rdi),%xmm0
mulss  0x10(%rdi),%xmm0
mulss  0x14(%rdi),%xmm1
subss  %xmm0,%xmm1
mulss  %xmm10,%xmm1
movss  %xmm1,0x28(%rsi)
movl   $0x0,0x2c(%rsi)
mulss  0x34(%rdi),%xmm6
mulss  0x30(%rdi),%xmm11
addss  %xmm6,%xmm11
mulss  0x38(%rdi),%xmm4
addss  %xmm11,%xmm4
xorps  %xmm8,%xmm4
movss  %xmm4,0x30(%rsi)
mulss  0x34(%rdi),%xmm7
mulss  0x30(%rdi),%xmm3
mulss  0x38(%rdi),%xmm2
addss  %xmm7,%xmm3
addss  %xmm3,%xmm2
xorps  %xmm8,%xmm2
movss  %xmm2,0x34(%rsi)
mulss  0x34(%rdi),%xmm5
mulss  0x30(%rdi),%xmm9
addss  %xmm5,%xmm9
mulss  0x38(%rdi),%xmm1
addss  %xmm9,%xmm1
xorps  %xmm8,%xmm1
movss  %xmm1,0x38(%rsi)
movl   $0x3f800000,0x3c(%rsi)
xor    %eax,%eax
ret

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

LLVM IR (-O2):
define i32 @m_inverse(float* nocapture %0, float* nocapture %1) {
%3 = load float, float* %0
%4 = getelementptr inbounds float, float* %0, i64 5
%5 = load float, float* %4
%6 = fmul float %3, %5
%7 = getelementptr inbounds float, float* %0, i64 10
%8 = load float, float* %7
%9 = fmul float %6, %8
%10 = getelementptr inbounds float, float* %0, i64 4
%11 = load float, float* %10
%12 = getelementptr inbounds float, float* %0, i64 9
%13 = load float, float* %12
%14 = fmul float %11, %13
%15 = getelementptr inbounds float, float* %0, i64 2
%16 = load float, float* %15
%17 = tail call float @llvm.fmuladd.f32(float %14, float %16, float %9)
%18 = getelementptr inbounds float, float* %0, i64 8
%19 = load float, float* %18
%20 = getelementptr inbounds float, float* %0, i64 1
%21 = load float, float* %20
%22 = fmul float %19, %21
%23 = getelementptr inbounds float, float* %0, i64 6
%24 = load float, float* %23
%25 = tail call float @llvm.fmuladd.f32(float %22, float %24, float %17)
%26 = fneg float %19
%27 = fmul float %5, %26
%28 = tail call float @llvm.fmuladd.f32(float %27, float %16, float %25)
%29 = fneg float %11
%30 = fmul float %21, %29
%31 = tail call float @llvm.fmuladd.f32(float %30, float %8, float %28)
%32 = fneg float %3
%33 = fmul float %13, %32
%34 = tail call float @llvm.fmuladd.f32(float %33, float %24, float %31)
%35 = fmul float %34, %34
%36 = fpext float %35 to double
%37 = fcmp olt double %36, 0x3EB0C6F7A0B5ED8D
br i1 %37, label %151, label %38
38: ; preds = %2
%39 = fdiv float 1.000000e+00, %34
%40 = fneg float %13
%41 = fmul float %24, %40
%42 = tail call float @llvm.fmuladd.f32(float %5, float %8, float %41)
%43 = fmul float %42, %39
store float %43, float* %1
%44 = load float, float* %20
%45 = load float, float* %7
%46 = load float, float* %12
%47 = load float, float* %15
%48 = fneg float %46
%49 = fmul float %47, %48
%50 = tail call float @llvm.fmuladd.f32(float %44, float %45, float %49)
%51 = fneg float %50
%52 = fmul float %39, %51
%53 = getelementptr inbounds float, float* %1, i64 1
store float %52, float* %53
%54 = load float, float* %20
%55 = load float, float* %23
%56 = load float, float* %4
%57 = load float, float* %15
%58 = fneg float %56
%59 = fmul float %57, %58
%60 = tail call float @llvm.fmuladd.f32(float %54, float %55, float %59)
%61 = fmul float %39, %60
%62 = getelementptr inbounds float, float* %1, i64 2
store float %61, float* %62
%63 = getelementptr inbounds float, float* %1, i64 3
store float 0.000000e+00, float* %63
%64 = load float, float* %10
%65 = load float, float* %7
%66 = load float, float* %18
%67 = load float, float* %23
%68 = fneg float %66
%69 = fmul float %67, %68
%70 = tail call float @llvm.fmuladd.f32(float %64, float %65, float %69)
%71 = fneg float %70
%72 = fmul float %39, %71
%73 = getelementptr inbounds float, float* %1, i64 4
store float %72, float* %73
%74 = load float, float* %0
%75 = load float, float* %7
%76 = load float, float* %18
%77 = load float, float* %15
%78 = fneg float %76
%79 = fmul float %77, %78
%80 = tail call float @llvm.fmuladd.f32(float %74, float %75, float %79)
%81 = fmul float %39, %80
%82 = getelementptr inbounds float, float* %1, i64 5
store float %81, float* %82
%83 = load float, float* %0
%84 = load float, float* %23
%85 = load float, float* %10
%86 = load float, float* %15
%87 = fneg float %85
%88 = fmul float %86, %87
%89 = tail call float @llvm.fmuladd.f32(float %83, float %84, float %88)
%90 = fneg float %89
%91 = fmul float %39, %90
%92 = getelementptr inbounds float, float* %1, i64 6
store float %91, float* %92
%93 = getelementptr inbounds float, float* %1, i64 7
store float 0.000000e+00, float* %93
%94 = load float, float* %10
%95 = load float, float* %12
%96 = load float, float* %18
%97 = load float, float* %4
%98 = fneg float %96
%99 = fmul float %97, %98
%100 = tail call float @llvm.fmuladd.f32(float %94, float %95, float %99)
%101 = fmul float %39, %100
%102 = getelementptr inbounds float, float* %1, i64 8
store float %101, float* %102
%103 = load float, float* %0
%104 = load float, float* %12
%105 = load float, float* %18
%106 = load float, float* %20
%107 = fneg float %105
%108 = fmul float %106, %107
%109 = tail call float @llvm.fmuladd.f32(float %103, float %104, float %108)
%110 = fneg float %109
%111 = fmul float %39, %110
%112 = getelementptr inbounds float, float* %1, i64 9
store float %111, float* %112
%113 = load float, float* %0
%114 = load float, float* %4
%115 = load float, float* %10
%116 = load float, float* %20
%117 = fneg float %115
%118 = fmul float %116, %117
%119 = tail call float @llvm.fmuladd.f32(float %113, float %114, float %118)
%120 = fmul float %39, %119
%121 = getelementptr inbounds float, float* %1, i64 10
store float %120, float* %121
%122 = getelementptr inbounds float, float* %1, i64 11
store float 0.000000e+00, float* %122
%123 = getelementptr inbounds float, float* %0, i64 12
%124 = load float, float* %123
%125 = getelementptr inbounds float, float* %0, i64 13
%126 = load float, float* %125
%127 = fmul float %72, %126
%128 = tail call float @llvm.fmuladd.f32(float %124, float %43, float %127)
%129 = getelementptr inbounds float, float* %0, i64 14
%130 = load float, float* %129
%131 = tail call float @llvm.fmuladd.f32(float %130, float %101, float %128)
%132 = fneg float %131
%133 = getelementptr inbounds float, float* %1, i64 12
store float %132, float* %133
%134 = load float, float* %123
%135 = load float, float* %125
%136 = fmul float %81, %135
%137 = tail call float @llvm.fmuladd.f32(float %134, float %52, float %136)
%138 = load float, float* %129
%139 = tail call float @llvm.fmuladd.f32(float %138, float %111, float %137)
%140 = fneg float %139
%141 = getelementptr inbounds float, float* %1, i64 13
store float %140, float* %141
%142 = load float, float* %123
%143 = load float, float* %125
%144 = fmul float %91, %143
%145 = tail call float @llvm.fmuladd.f32(float %142, float %61, float %144)
%146 = load float, float* %129
%147 = tail call float @llvm.fmuladd.f32(float %146, float %120, float %145)
%148 = fneg float %147
%149 = getelementptr inbounds float, float* %1, i64 14
store float %148, float* %149
%150 = getelementptr inbounds float, float* %1, i64 15
store float 1.000000e+00, float* %150
br label %151
151: ; preds = %2, %38
%152 = phi i32 [ 0, %38 ], [ -1, %2 ]
ret i32 %152
}