#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ fail(char *, int);
int /*<<< orphan*/ matrix_determinant(float *, float *, int);
int matrix_inverse(float *r, float *a, int n) {
  float det;
  matrix_determinant(&det, a, n);
  switch (n) {
  case 1:
    r[0] = 1 / a[0];
    return 1;
  case 4:
    r[0] = a[3] / det;
    r[1] = -a[1] / det;
    r[2] = -a[2] / det;
    r[3] = a[0] / det;
    return 4;
  case 6:
    r[0] = a[4] / det;
    r[1] = -a[1] / det;
    r[2] = (a[1] * a[5] - a[2] * a[4]) / det;
    r[3] = -a[3] / det;
    r[4] = a[0] / det;
    r[5] = (a[2] * a[3] - a[0] * a[5]) / det;
    return 6;
  case 9:
    r[0] = (a[4] * a[8] - a[5] * a[7]) / det;
    r[1] = (a[2] * a[7] - a[1] * a[8]) / det;
    r[2] = (a[1] * a[5] - a[2] * a[4]) / det;
    r[3] = (a[5] * a[6] - a[3] * a[8]) / det;
    r[4] = (a[0] * a[8] - a[2] * a[6]) / det;
    r[5] = (a[2] * a[3] - a[0] * a[5]) / det;
    r[6] = (a[3] * a[7] - a[4] * a[6]) / det;
    r[7] = (a[1] * a[6] - a[0] * a[7]) / det;
    r[8] = (a[0] * a[4] - a[1] * a[3]) / det;
    return 9;
  default:
    fail("can not compute inversion of object of size %d", n);
  }
}


x86 assembly (clang, -O0):
<matrix_inverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%edx
lea    -0x20(%rbp),%rdi
call   1040 <matrix_determinant@plt>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x28(%rbp)
sub    $0x8,%eax
ja     15a3 <matrix_inverse+0x483>
mov    -0x28(%rbp),%rax
lea    0xea1(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rax
movss  0xe88(%rip),%xmm0
divss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    15b2 <matrix_inverse+0x492>
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
movl   $0x4,-0x4(%rbp)
jmp    15b2 <matrix_inverse+0x492>
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x10(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
movl   $0x6,-0x4(%rbp)
jmp    15b2 <matrix_inverse+0x492>
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x14(%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
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x20(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x10(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x8(%rax)
mov    -0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x20(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x20(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x8(%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
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x14(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x14(%rax)
mov    -0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x1c(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x10(%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
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x18(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  (%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
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x1c(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movss  0x10(%rax),%xmm2
mov    -0x18(%rbp),%rax
movss  0x4(%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
divss  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  %xmm0,0x20(%rax)
movl   $0x9,-0x4(%rbp)
jmp    15b2 <matrix_inverse+0x492>
mov    -0x1c(%rbp),%esi
lea    0xa7b(%rip),%rdi
call   1030 <fail@plt>
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<matrix_inverse>:
push   %r15
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %edx,%ebx
mov    %rsi,%r15
mov    %rdi,%r14
lea    0xc(%rsp),%rdi
call   1040 <matrix_determinant@plt>
lea    -0x1(%rbx),%eax
cmp    $0x8,%eax
ja     116f <matrix_inverse+0x4f>
lea    0xeca(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movss  0xeb5(%rip),%xmm0
divss  (%r15),%xmm0
movss  %xmm0,(%r14)
mov    $0x1,%eax
jmp    13df <matrix_inverse+0x2bf>
lea    0xec2(%rip),%rdi
mov    %ebx,%esi
call   1030 <fail@plt>
jmp    13df <matrix_inverse+0x2bf>
movss  0xc(%r15),%xmm0
movss  0xc(%rsp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,(%r14)
movss  0x4(%r15),%xmm0
movaps 0xe5c(%rip),%xmm2
xorps  %xmm2,%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x4(%r14)
movss  0x8(%r15),%xmm0
xorps  %xmm2,%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x8(%r14)
movss  (%r15),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0xc(%r14)
mov    $0x4,%eax
jmp    13df <matrix_inverse+0x2bf>
movss  0x10(%r15),%xmm1
movss  0xc(%rsp),%xmm0
divss  %xmm0,%xmm1
movss  %xmm1,(%r14)
movss  0x4(%r15),%xmm1
movaps 0xe01(%rip),%xmm2
xorps  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x4(%r14)
movss  0x4(%r15),%xmm1
movss  0x10(%r15),%xmm3
mulss  0x8(%r15),%xmm3
mulss  0x14(%r15),%xmm1
subss  %xmm3,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x8(%r14)
movss  0xc(%r15),%xmm1
xorps  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc(%r14)
movss  (%r15),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x10(%r14)
movss  0x8(%r15),%xmm1
movss  0x14(%r15),%xmm2
mulss  (%r15),%xmm2
mulss  0xc(%r15),%xmm1
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x14(%r14)
mov    $0x6,%eax
jmp    13df <matrix_inverse+0x2bf>
movss  0x10(%r15),%xmm1
movss  0x1c(%r15),%xmm0
mulss  0x14(%r15),%xmm0
mulss  0x20(%r15),%xmm1
subss  %xmm0,%xmm1
movss  0xc(%rsp),%xmm0
divss  %xmm0,%xmm1
movss  %xmm1,(%r14)
movss  0x20(%r15),%xmm1
mulss  0x4(%r15),%xmm1
movss  0x8(%r15),%xmm2
mulss  0x1c(%r15),%xmm2
subss  %xmm1,%xmm2
divss  %xmm0,%xmm2
movss  %xmm2,0x4(%r14)
movss  0x4(%r15),%xmm1
movss  0x10(%r15),%xmm2
mulss  0x8(%r15),%xmm2
mulss  0x14(%r15),%xmm1
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x8(%r14)
movss  0x14(%r15),%xmm1
movss  0x20(%r15),%xmm2
mulss  0xc(%r15),%xmm2
mulss  0x18(%r15),%xmm1
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc(%r14)
movss  0x18(%r15),%xmm1
mulss  0x8(%r15),%xmm1
movss  (%r15),%xmm2
mulss  0x20(%r15),%xmm2
subss  %xmm1,%xmm2
divss  %xmm0,%xmm2
movss  %xmm2,0x10(%r14)
movss  0x8(%r15),%xmm1
movss  0x14(%r15),%xmm2
mulss  (%r15),%xmm2
mulss  0xc(%r15),%xmm1
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x14(%r14)
movss  0xc(%r15),%xmm1
movss  0x18(%r15),%xmm2
mulss  0x10(%r15),%xmm2
mulss  0x1c(%r15),%xmm1
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x18(%r14)
movss  0x1c(%r15),%xmm1
mulss  (%r15),%xmm1
movss  0x4(%r15),%xmm2
mulss  0x18(%r15),%xmm2
subss  %xmm1,%xmm2
divss  %xmm0,%xmm2
movss  %xmm2,0x1c(%r14)
movss  (%r15),%xmm1
movss  0xc(%r15),%xmm2
mulss  0x4(%r15),%xmm2
mulss  0x10(%r15),%xmm1
subss  %xmm2,%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0x20(%r14)
mov    $0x9,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

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