void inverse(float arr[50][50], int n) {
  int i, j;
  float fdet;
  float inv[50][50];
  if (n == 2) {
    fdet = (arr[0][0] * arr[1][1]) - (arr[0][1] * arr[1][0]);
    fdet = 1 / fdet;
    inv[0][0] = (arr[1][1]) * fdet;
    inv[0][1] = (-arr[1][0]) * fdet;
    inv[1][0] = (-arr[0][1]) * fdet;
    inv[1][1] = (arr[0][0]) * fdet;
    for (i = 0; i < 2; i++)
      for (j = 0; j < 2; j++)
        arr[i][j] = inv[i][j];
    goto end;
  }
  fdet = determinant(arr, n);
  if (fdet == 0) {
    printf("\n Matrix is singular, no inverse exists");
    exit(0);
  }
  fdet = 1 / fdet;
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++) {
      inv[i][j] = minorm(arr, i, j, n);
      if ((i + j) % 2 != 0)
        inv[i][j] = -inv[i][j];
      inv[i][j] = inv[i][j] * (fdet);
    }
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++)
      arr[i][j] = inv[i][j];
end:
  printf("");
}


x86 assembly (clang, -O0):
<inverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2730,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x2,-0xc(%rbp)
jne    12a9 <inverse+0x169>
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  0xcc(%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm1
mov    -0x8(%rbp),%rax
mulss  0xc8(%rax),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  0xe59(%rip),%xmm0
divss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movss  0xcc(%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x2730(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0xc8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x272c(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x2668(%rbp)
ff
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm0
mulss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x2664(%rbp)
ff
movl   $0x0,-0x10(%rbp)
cmpl   $0x2,-0x10(%rbp)
jge    12a4 <inverse+0x164>
movl   $0x0,-0x14(%rbp)
cmpl   $0x2,-0x14(%rbp)
jge    1291 <inverse+0x151>
movslq -0x10(%rbp),%rcx
lea    -0x2730(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1240 <inverse+0x100>
jmp    1296 <inverse+0x156>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    122f <inverse+0xef>
jmp    14a1 <inverse+0x361>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    $0x0,%al
call   1050 <determinant@plt>
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x18(%rbp)
movss  -0x18(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    12ec <inverse+0x1ac>
jp     12ec <inverse+0x1ac>
lea    0xd26(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %edi,%edi
call   1060 <exit@plt>
movss  0xd0c(%rip),%xmm0
divss  -0x18(%rbp),%xmm0
movss  %xmm0,-0x18(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    141c <inverse+0x2dc>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1409 <inverse+0x2c9>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0xc(%rbp),%ecx
mov    $0x0,%al
call   1030 <minorm@plt>
cvtsi2ss %eax,%xmm0
movslq -0x10(%rbp),%rcx
lea    -0x2730(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     13ba <inverse+0x27a>
movslq -0x10(%rbp),%rcx
lea    -0x2730(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movslq -0x10(%rbp),%rcx
lea    -0x2730(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x10(%rbp),%rcx
lea    -0x2730(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x18(%rbp),%xmm0
movslq -0x10(%rbp),%rcx
lea    -0x2730(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1318 <inverse+0x1d8>
jmp    140e <inverse+0x2ce>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1305 <inverse+0x1c5>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    149c <inverse+0x35c>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1489 <inverse+0x349>
movslq -0x10(%rbp),%rcx
lea    -0x2730(%rbp),%rax
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
imul   $0xc8,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1436 <inverse+0x2f6>
jmp    148e <inverse+0x34e>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1423 <inverse+0x2e3>
jmp    14a1 <inverse+0x361>
lea    0xb83(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
add    $0x2730,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inverse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2728,%rsp
mov    %rdi,%r14
cmp    $0x2,%esi
jne    11ff <inverse+0xaf>
movss  0xcc(%r14),%xmm0
movss  (%r14),%xmm1
movss  0x4(%r14),%xmm2
movss  0xc8(%r14),%xmm3
movaps 0xe7f(%rip),%xmm4
movaps %xmm3,%xmm5
mulss  %xmm2,%xmm5
xorps  %xmm4,%xmm2
movaps %xmm1,%xmm6
mulss  %xmm0,%xmm6
subss  %xmm5,%xmm6
movss  0xe52(%rip),%xmm5
divss  %xmm6,%xmm5
mulss  %xmm5,%xmm0
movss  %xmm0,0x10(%rsp)
xorps  %xmm4,%xmm3
mulss  %xmm5,%xmm3
movss  %xmm3,0x14(%rsp)
mulss  %xmm5,%xmm2
movss  %xmm2,0xd8(%rsp)
mulss  %xmm1,%xmm5
movss  %xmm5,0xdc(%rsp)
mov    0x10(%rsp),%rax
mov    %rax,(%r14)
mov    0xd8(%rsp),%rax
mov    %rax,0xc8(%r14)
jmp    1335 <inverse+0x1e5>
mov    %esi,%r15d
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <determinant@plt>
test   %eax,%eax
je     1347 <inverse+0x1f7>
test   %r15d,%r15d
jle    1335 <inverse+0x1e5>
mov    %r15d,%r12d
cvtsi2ss %eax,%xmm0
movss  0xdd4(%rip),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,0xc(%rsp)
lea    0x10(%rsp),%r13
xor    %ebx,%ebx
jmp    1250 <inverse+0x100>
nop
add    $0x1,%rbx
add    $0xc8,%r13
cmp    %r12,%rbx
je     129e <inverse+0x14e>
xor    %ebp,%ebp
jmp    1276 <inverse+0x126>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mulss  0xc(%rsp),%xmm0
movss  %xmm0,0x0(%r13,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,%r12
je     1240 <inverse+0xf0>
mov    %r14,%rdi
mov    %ebx,%esi
mov    %ebp,%edx
mov    %r15d,%ecx
xor    %eax,%eax
call   1030 <minorm@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
lea    (%rbx,%rbp,1),%eax
test   $0x1,%al
je     1260 <inverse+0x110>
xorps  0xd74(%rip),%xmm0
jmp    1260 <inverse+0x110>
test   %r15d,%r15d
jle    1335 <inverse+0x1e5>
mov    %r12,%r13
shl    $0x2,%r13
cmp    $0x1,%r12d
jne    12b8 <inverse+0x168>
xor    %ebx,%ebx
jmp    1312 <inverse+0x1c2>
mov    %r12d,%r15d
and    $0xfffffffe,%r15d
xor    %ebp,%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsp,%rbp,1),%rsi
add    $0x10,%rsi
lea    (%r14,%rbp,1),%rdi
mov    %r13,%rdx
call   1050 <memcpy@plt>
lea    (%rsp,%rbp,1),%rsi
add    $0xd8,%rsi
lea    (%r14,%rbp,1),%rdi
add    $0xc8,%rdi
mov    %r13,%rdx
call   1050 <memcpy@plt>
add    $0x2,%rbx
add    $0x190,%rbp
cmp    %rbx,%r15
jne    12d0 <inverse+0x180>
test   $0x1,%r12b
je     1335 <inverse+0x1e5>
imul   $0xc8,%rbx,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x10,%rsi
add    %rax,%r14
mov    %r14,%rdi
mov    %r13,%rdx
call   1050 <memcpy@plt>
add    $0x2728,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xcd2(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %edi,%edi
call   1070 <exit@plt>

LLVM IR (-O0):
@.str = [40 x i8] c"\0A Matrix is singular, no inverse exists\00"
@.str.1 = [1 x i8] zeroinitializer
define void @inverse([50 x float]* %0, i32 %1) {
%3 = alloca [50 x float]*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca float
%8 = alloca [50 x [50 x float]]
store [50 x float]* %0, [50 x float]** %3
store i32 %1, i32* %4
%9 = load i32, i32* %4
%10 = icmp eq i32 %9, 2
br i1 %10, label %11, label %97
11: ; preds = %2
%12 = load [50 x float]*, [50 x float]** %3
%13 = getelementptr inbounds [50 x float], [50 x float]* %12, i64 0
%14 = getelementptr inbounds [50 x float], [50 x float]* %13, i64 0, i64 0
%15 = load float, float* %14
%16 = load [50 x float]*, [50 x float]** %3
%17 = getelementptr inbounds [50 x float], [50 x float]* %16, i64 1
%18 = getelementptr inbounds [50 x float], [50 x float]* %17, i64 0, i64 1
%19 = load float, float* %18
%20 = load [50 x float]*, [50 x float]** %3
%21 = getelementptr inbounds [50 x float], [50 x float]* %20, i64 0
%22 = getelementptr inbounds [50 x float], [50 x float]* %21, i64 0, i64 1
%23 = load float, float* %22
%24 = load [50 x float]*, [50 x float]** %3
%25 = getelementptr inbounds [50 x float], [50 x float]* %24, i64 1
%26 = getelementptr inbounds [50 x float], [50 x float]* %25, i64 0, i64 0
%27 = load float, float* %26
%28 = fmul float %23, %27
%29 = fneg float %28
%30 = call float @llvm.fmuladd.f32(float %15, float %19, float %29)
store float %30, float* %7
%31 = load float, float* %7
%32 = fdiv float 1.000000e+00, %31
store float %32, float* %7
%33 = load [50 x float]*, [50 x float]** %3
%34 = getelementptr inbounds [50 x float], [50 x float]* %33, i64 1
%35 = getelementptr inbounds [50 x float], [50 x float]* %34, i64 0, i64 1
%36 = load float, float* %35
%37 = load float, float* %7
%38 = fmul float %36, %37
%39 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 0
%40 = getelementptr inbounds [50 x float], [50 x float]* %39, i64 0, i64 0
store float %38, float* %40
%41 = load [50 x float]*, [50 x float]** %3
%42 = getelementptr inbounds [50 x float], [50 x float]* %41, i64 1
%43 = getelementptr inbounds [50 x float], [50 x float]* %42, i64 0, i64 0
%44 = load float, float* %43
%45 = fneg float %44
%46 = load float, float* %7
%47 = fmul float %45, %46
%48 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 0
%49 = getelementptr inbounds [50 x float], [50 x float]* %48, i64 0, i64 1
store float %47, float* %49
%50 = load [50 x float]*, [50 x float]** %3
%51 = getelementptr inbounds [50 x float], [50 x float]* %50, i64 0
%52 = getelementptr inbounds [50 x float], [50 x float]* %51, i64 0, i64 1
%53 = load float, float* %52
%54 = fneg float %53
%55 = load float, float* %7
%56 = fmul float %54, %55
%57 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 1
%58 = getelementptr inbounds [50 x float], [50 x float]* %57, i64 0, i64 0
store float %56, float* %58
%59 = load [50 x float]*, [50 x float]** %3
%60 = getelementptr inbounds [50 x float], [50 x float]* %59, i64 0
%61 = getelementptr inbounds [50 x float], [50 x float]* %60, i64 0, i64 0
%62 = load float, float* %61
%63 = load float, float* %7
%64 = fmul float %62, %63
%65 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 1
%66 = getelementptr inbounds [50 x float], [50 x float]* %65, i64 0, i64 1
store float %64, float* %66
store i32 0, i32* %5
br label %67
67: ; preds = %93, %11
%68 = load i32, i32* %5
%69 = icmp slt i32 %68, 2
br i1 %69, label %70, label %96
70: ; preds = %67
store i32 0, i32* %6
br label %71
71: ; preds = %89, %70
%72 = load i32, i32* %6
%73 = icmp slt i32 %72, 2
br i1 %73, label %74, label %92
74: ; preds = %71
%75 = load i32, i32* %5
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 %76
%78 = load i32, i32* %6
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [50 x float], [50 x float]* %77, i64 0, i64 %79
%81 = load float, float* %80
%82 = load [50 x float]*, [50 x float]** %3
%83 = load i32, i32* %5
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [50 x float], [50 x float]* %82, i64 %84
%86 = load i32, i32* %6
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [50 x float], [50 x float]* %85, i64 0, i64 %87
store float %81, float* %88
br label %89
89: ; preds = %74
%90 = load i32, i32* %6
%91 = add nsw i32 %90, 1
store i32 %91, i32* %6
br label %71
92: ; preds = %71
br label %93
93: ; preds = %92
%94 = load i32, i32* %5
%95 = add nsw i32 %94, 1
store i32 %95, i32* %5
br label %67
96: ; preds = %67
br label %207
97: ; preds = %2
%98 = load [50 x float]*, [50 x float]** %3
%99 = load i32, i32* %4
%100 = call i32 ([50 x float]*, i32, ...) bitcast (i32 (...)* @determinant to i32 ([50 x float]*, i32, ...)*)([50 x float]* %98, i32 %99)
%101 = sitofp i32 %100 to float
store float %101, float* %7
%102 = load float, float* %7
%103 = fcmp oeq float %102, 0.000000e+00
br i1 %103, label %104, label %106
104: ; preds = %97
%105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0))
unreachable
106: ; preds = %97
%107 = load float, float* %7
%108 = fdiv float 1.000000e+00, %107
store float %108, float* %7
store i32 0, i32* %5
br label %109
109: ; preds = %171, %106
%110 = load i32, i32* %5
%111 = load i32, i32* %4
%112 = icmp slt i32 %110, %111
br i1 %112, label %113, label %174
113: ; preds = %109
store i32 0, i32* %6
br label %114
114: ; preds = %167, %113
%115 = load i32, i32* %6
%116 = load i32, i32* %4
%117 = icmp slt i32 %115, %116
br i1 %117, label %118, label %170
118: ; preds = %114
%119 = load [50 x float]*, [50 x float]** %3
%120 = load i32, i32* %5
%121 = load i32, i32* %6
%122 = load i32, i32* %4
%123 = call i32 ([50 x float]*, i32, i32, i32, ...) bitcast (i32 (...)* @minorm to i32 ([50 x float]*, i32, i32, i32, ...)*)([50 x float]* %119, i32 %120, i32 %121, i32 %122)
%124 = sitofp i32 %123 to float
%125 = load i32, i32* %5
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 %126
%128 = load i32, i32* %6
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [50 x float], [50 x float]* %127, i64 0, i64 %129
store float %124, float* %130
%131 = load i32, i32* %5
%132 = load i32, i32* %6
%133 = add nsw i32 %131, %132
%134 = srem i32 %133, 2
%135 = icmp ne i32 %134, 0
br i1 %135, label %136, label %151
136: ; preds = %118
%137 = load i32, i32* %5
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 %138
%140 = load i32, i32* %6
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [50 x float], [50 x float]* %139, i64 0, i64 %141
%143 = load float, float* %142
%144 = fneg float %143
%145 = load i32, i32* %5
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 %146
%148 = load i32, i32* %6
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [50 x float], [50 x float]* %147, i64 0, i64 %149
store float %144, float* %150
br label %151
151: ; preds = %136, %118
%152 = load i32, i32* %5
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 %153
%155 = load i32, i32* %6
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds [50 x float], [50 x float]* %154, i64 0, i64 %156
%158 = load float, float* %157
%159 = load float, float* %7
%160 = fmul float %158, %159
%161 = load i32, i32* %5
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 %162
%164 = load i32, i32* %6
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [50 x float], [50 x float]* %163, i64 0, i64 %165
store float %160, float* %166
br label %167
167: ; preds = %151
%168 = load i32, i32* %6
%169 = add nsw i32 %168, 1
store i32 %169, i32* %6
br label %114
170: ; preds = %114
br label %171
171: ; preds = %170
%172 = load i32, i32* %5
%173 = add nsw i32 %172, 1
store i32 %173, i32* %5
br label %109
174: ; preds = %109
store i32 0, i32* %5
br label %175
175: ; preds = %203, %174
%176 = load i32, i32* %5
%177 = load i32, i32* %4
%178 = icmp slt i32 %176, %177
br i1 %178, label %179, label %206
179: ; preds = %175
store i32 0, i32* %6
br label %180
180: ; preds = %199, %179
%181 = load i32, i32* %6
%182 = load i32, i32* %4
%183 = icmp slt i32 %181, %182
br i1 %183, label %184, label %202
184: ; preds = %180
%185 = load i32, i32* %5
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %8, i64 0, i64 %186
%188 = load i32, i32* %6
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [50 x float], [50 x float]* %187, i64 0, i64 %189
%191 = load float, float* %190
%192 = load [50 x float]*, [50 x float]** %3
%193 = load i32, i32* %5
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [50 x float], [50 x float]* %192, i64 %194
%196 = load i32, i32* %6
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [50 x float], [50 x float]* %195, i64 0, i64 %197
store float %191, float* %198
br label %199
199: ; preds = %184
%200 = load i32, i32* %6
%201 = add nsw i32 %200, 1
store i32 %201, i32* %6
br label %180
202: ; preds = %180
br label %203
203: ; preds = %202
%204 = load i32, i32* %5
%205 = add nsw i32 %204, 1
store i32 %205, i32* %5
br label %175
206: ; preds = %175
br label %207
207: ; preds = %206, %96
%208 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0))
ret void
}

LLVM IR (-O2):
@.str = [40 x i8] c"\0A Matrix is singular, no inverse exists\00"
define void @inverse([50 x float]* %0, i32 %1) {
%3 = alloca [50 x [50 x float]]
%4 = bitcast [50 x [50 x float]]* %3 to i8*
%5 = icmp eq i32 %1, 2
br i1 %5, label %6, label %34
6: ; preds = %2
%7 = getelementptr [50 x float], [50 x float]* %0, i64 0, i64 0
%8 = load float, float* %7
%9 = getelementptr inbounds [50 x float], [50 x float]* %0, i64 1, i64 1
%10 = load float, float* %9
%11 = getelementptr inbounds [50 x float], [50 x float]* %0, i64 0, i64 1
%12 = load float, float* %11
%13 = getelementptr [50 x float], [50 x float]* %0, i64 1, i64 0
%14 = load float, float* %13
%15 = fneg float %12
%16 = fmul float %14, %15
%17 = tail call float @llvm.fmuladd.f32(float %8, float %10, float %16)
%18 = fdiv float 1.000000e+00, %17
%19 = fmul float %10, %18
%20 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %3, i64 0, i64 0, i64 0
store float %19, float* %20
%21 = fneg float %14
%22 = fmul float %18, %21
%23 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %3, i64 0, i64 0, i64 1
store float %22, float* %23
%24 = fmul float %18, %15
%25 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %3, i64 0, i64 1, i64 0
store float %24, float* %25
%26 = fmul float %8, %18
%27 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %3, i64 0, i64 1, i64 1
store float %26, float* %27
%28 = bitcast [50 x [50 x float]]* %3 to i64*
%29 = bitcast [50 x float]* %0 to i64*
%30 = load i64, i64* %28
store i64 %30, i64* %29
%31 = bitcast float* %25 to i64*
%32 = bitcast float* %13 to i64*
%33 = load i64, i64* %31
store i64 %33, i64* %32
br label %96
34: ; preds = %2
%35 = tail call i32 ([50 x float]*, i32, ...) bitcast (i32 (...)* @determinant to i32 ([50 x float]*, i32, ...)*)([50 x float]* %0, i32 %1)
%36 = icmp eq i32 %35, 0
br i1 %36, label %37, label %39
37: ; preds = %34
%38 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @.str, i64 0, i64 0))
tail call void @exit(i32 0)
unreachable
39: ; preds = %34
%40 = sitofp i32 %35 to float
%41 = fdiv float 1.000000e+00, %40
%42 = icmp sgt i32 %1, 0
br i1 %42, label %43, label %96
43: ; preds = %39
%44 = zext i32 %1 to i64
br label %45
45: ; preds = %70, %43
%46 = phi i64 [ 0, %43 ], [ %71, %70 ]
%47 = trunc i64 %46 to i32
br label %56
48: ; preds = %70
br i1 %42, label %49, label %96
49: ; preds = %48
%50 = zext i32 %1 to i64
%51 = shl nuw nsw i64 %50, 2
%52 = and i64 %44, 1
%53 = icmp eq i32 %1, 1
br i1 %53, label %88, label %54
54: ; preds = %49
%55 = and i64 %44, 4294967294
br label %73
56: ; preds = %45, %56
%57 = phi i64 [ 0, %45 ], [ %68, %56 ]
%58 = trunc i64 %57 to i32
%59 = tail call i32 ([50 x float]*, i32, i32, i32, ...) bitcast (i32 (...)* @minorm to i32 ([50 x float]*, i32, i32, i32, ...)*)([50 x float]* %0, i32 %47, i32 %58, i32 %1)
%60 = sitofp i32 %59 to float
%61 = getelementptr inbounds [50 x [50 x float]], [50 x [50 x float]]* %3, i64 0, i64 %46, i64 %57
%62 = add nuw nsw i64 %57, %46
%63 = and i64 %62, 1
%64 = icmp eq i64 %63, 0
%65 = fneg float %60
%66 = select i1 %64, float %60, float %65
%67 = fmul float %41, %66
store float %67, float* %61
%68 = add nuw nsw i64 %57, 1
%69 = icmp eq i64 %68, %44
br i1 %69, label %70, label %56
70: ; preds = %56
%71 = add nuw nsw i64 %46, 1
%72 = icmp eq i64 %71, %44
br i1 %72, label %48, label %45
73: ; preds = %73, %54
%74 = phi i64 [ 0, %54 ], [ %85, %73 ]
%75 = phi i64 [ 0, %54 ], [ %86, %73 ]
%76 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %3, i64 0, i64 %74, i64 0
%77 = bitcast float* %76 to i8*
%78 = getelementptr [50 x float], [50 x float]* %0, i64 %74, i64 0
%79 = bitcast float* %78 to i8*
%80 = or i64 %74, 1
%81 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %3, i64 0, i64 %80, i64 0
%82 = bitcast float* %81 to i8*
%83 = getelementptr [50 x float], [50 x float]* %0, i64 %80, i64 0
%84 = bitcast float* %83 to i8*
%85 = add nuw nsw i64 %74, 2
%86 = add i64 %75, 2
%87 = icmp eq i64 %86, %55
br i1 %87, label %88, label %73
88: ; preds = %73, %49
%89 = phi i64 [ 0, %49 ], [ %85, %73 ]
%90 = icmp eq i64 %52, 0
br i1 %90, label %96, label %91
91: ; preds = %88
%92 = getelementptr [50 x [50 x float]], [50 x [50 x float]]* %3, i64 0, i64 %89, i64 0
%93 = bitcast float* %92 to i8*
%94 = getelementptr [50 x float], [50 x float]* %0, i64 %89, i64 0
%95 = bitcast float* %94 to i8*
br label %96
96: ; preds = %91, %88, %39, %6, %48
ret void
}