#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*/ GCI_ecf_free_matrix(float **);
float **GCI_ecf_matrix(int, int);
int GCI_solve_Gaussian(float **, int, float *);
int GCI_invert_Gaussian(float **a, int n) {
  int returnValue = 0;
  float **identity = GCI_ecf_matrix(n, n);
  float **work = GCI_ecf_matrix(n, n);
  int i, j, k;
  for (j = 0; j < n; ++j) {
    for (i = 0; i < n; ++i) {
      identity[j][i] = 0.0f;
      for (k = 0; k < n; ++k) {
        work[k][i] = a[k][i];
      }
    }
    identity[j][j] = 1.0f;
    returnValue = GCI_solve_Gaussian(work, n, identity[j]);
    if (returnValue < 0) {
      GCI_ecf_free_matrix(identity);
      GCI_ecf_free_matrix(work);
      return returnValue;
    }
  }
  for (j = 0; j < n; ++j) {
    for (i = 0; i < n; ++i) {
      a[j][i] = identity[j][i];
    }
  }
  GCI_ecf_free_matrix(identity);
  GCI_ecf_free_matrix(work);
  return returnValue;
}


x86 assembly (clang, -O0):
<GCI_invert_Gaussian>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1030 <GCI_ecf_matrix@plt>
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x14(%rbp),%esi
call   1030 <GCI_ecf_matrix@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1272 <GCI_invert_Gaussian+0x142>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1200 <GCI_invert_Gaussian+0xd0>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11ed <GCI_invert_Gaussian+0xbd>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a9 <GCI_invert_Gaussian+0x79>
jmp    11f2 <GCI_invert_Gaussian+0xc2>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    117e <GCI_invert_Gaussian+0x4e>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movss  0xde8(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
call   1050 <GCI_solve_Gaussian@plt>
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jge    125f <GCI_invert_Gaussian+0x12f>
mov    -0x20(%rbp),%rdi
call   1040 <GCI_ecf_free_matrix@plt>
mov    -0x28(%rbp),%rdi
call   1040 <GCI_ecf_free_matrix@plt>
mov    -0x18(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    12fb <GCI_invert_Gaussian+0x1cb>
jmp    1264 <GCI_invert_Gaussian+0x134>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    116b <GCI_invert_Gaussian+0x3b>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12e3 <GCI_invert_Gaussian+0x1b3>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12d0 <GCI_invert_Gaussian+0x1a0>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    128c <GCI_invert_Gaussian+0x15c>
jmp    12d5 <GCI_invert_Gaussian+0x1a5>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1279 <GCI_invert_Gaussian+0x149>
mov    -0x20(%rbp),%rdi
call   1040 <GCI_ecf_free_matrix@plt>
mov    -0x28(%rbp),%rdi
call   1040 <GCI_ecf_free_matrix@plt>
mov    -0x18(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<GCI_invert_Gaussian>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %esi,%ebx
mov    %rdi,%r14
mov    %esi,%edi
call   1030 <GCI_ecf_matrix@plt>
mov    %rax,0x10(%rsp)
mov    %ebx,%edi
mov    %ebx,%esi
call   1030 <GCI_ecf_matrix@plt>
mov    %rax,%r12
test   %ebx,%ebx
jle    1490 <GCI_invert_Gaussian+0x360>
mov    %ebx,%esi
mov    %ebx,%r8d
lea    -0x1(%r8),%r9
mov    %r8d,%r13d
and    $0x3,%r13d
mov    %r8d,%r15d
and    $0xfffffffc,%r15d
xor    %r10d,%r10d
mov    %ebx,0xc(%rsp)
mov    %r8,(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x10(%rsp),%rax
mov    (%rax,%r10,8),%rdx
xor    %eax,%eax
jmp    11ad <GCI_invert_Gaussian+0x7d>
nopl   (%rax)
add    $0x1,%rax
cmp    %r8,%rax
je     1260 <GCI_invert_Gaussian+0x130>
movl   $0x0,(%rdx,%rax,4)
xor    %ecx,%ecx
cmp    $0x3,%r9
jb     1217 <GCI_invert_Gaussian+0xe7>
nopl   0x0(%rax)
mov    (%r14,%rcx,8),%rdi
movss  (%rdi,%rax,4),%xmm0
mov    (%r12,%rcx,8),%rdi
movss  %xmm0,(%rdi,%rax,4)
mov    0x8(%r14,%rcx,8),%rdi
movss  (%rdi,%rax,4),%xmm0
mov    0x8(%r12,%rcx,8),%rdi
movss  %xmm0,(%rdi,%rax,4)
mov    0x10(%r14,%rcx,8),%rdi
movss  (%rdi,%rax,4),%xmm0
mov    0x10(%r12,%rcx,8),%rdi
movss  %xmm0,(%rdi,%rax,4)
mov    0x18(%r14,%rcx,8),%rdi
movss  (%rdi,%rax,4),%xmm0
mov    0x18(%r12,%rcx,8),%rdi
movss  %xmm0,(%rdi,%rax,4)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    11c0 <GCI_invert_Gaussian+0x90>
test   %r13,%r13
je     11a0 <GCI_invert_Gaussian+0x70>
lea    (%r12,%rcx,8),%rbp
lea    (%r14,%rcx,8),%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
mov    (%rcx,%rdi,8),%rbx
movss  (%rbx,%rax,4),%xmm0
mov    0x0(%rbp,%rdi,8),%rbx
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rdi
cmp    %rdi,%r13
jne    1230 <GCI_invert_Gaussian+0x100>
jmp    11a0 <GCI_invert_Gaussian+0x70>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r9,%rbx
movl   $0x3f800000,(%rdx,%r10,4)
3f
mov    %r12,%rdi
mov    %r10,%rbp
call   1050 <GCI_solve_Gaussian@plt>
test   %eax,%eax
js     148c <GCI_invert_Gaussian+0x35c>
add    $0x1,%rbp
mov    (%rsp),%r8
cmp    %r8,%rbp
mov    0xc(%rsp),%esi
mov    %rbx,%r9
mov    %rbp,%r10
jne    1190 <GCI_invert_Gaussian+0x60>
test   %esi,%esi
jle    148c <GCI_invert_Gaussian+0x35c>
mov    %eax,0x1c(%rsp)
mov    %r8d,%r10d
and    $0xfffffff8,%r10d
add    $0xfffffffffffffff8,%r10
mov    %r10,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %r8d,%r11d
and    $0xfffffff8,%r11d
mov    %eax,%r9d
and    $0x3,%r9d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x20(%rsp)
and    $0x3,%r8d
mov    %r9,%r15
shl    $0x5,%r15
xor    %r13d,%r13d
jmp    12fd <GCI_invert_Gaussian+0x1cd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r13
cmp    %rbp,%r13
je     1494 <GCI_invert_Gaussian+0x364>
mov    0x10(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    (%r14,%r13,8),%rdx
cmpl   $0x8,0xc(%rsp)
jae    1320 <GCI_invert_Gaussian+0x1f0>
xor    %edi,%edi
mov    (%rsp),%rbp
jmp    1400 <GCI_invert_Gaussian+0x2d0>
nopl   0x0(%rax)
mov    (%rsp),%rbp
lea    (%rax,%rbp,4),%rcx
cmp    %rcx,%rdx
jae    1340 <GCI_invert_Gaussian+0x210>
lea    (%rdx,%rbp,4),%rcx
cmp    %rcx,%rax
jae    1340 <GCI_invert_Gaussian+0x210>
xor    %edi,%edi
jmp    1400 <GCI_invert_Gaussian+0x2d0>
nopl   (%rax)
cmp    $0x18,%r10
jae    134a <GCI_invert_Gaussian+0x21a>
xor    %edi,%edi
jmp    13b8 <GCI_invert_Gaussian+0x288>
mov    0x20(%rsp),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups %xmm0,(%rdx,%rdi,4)
movups %xmm1,0x10(%rdx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm0
movups 0x30(%rax,%rdi,4),%xmm1
movups %xmm0,0x20(%rdx,%rdi,4)
movups %xmm1,0x30(%rdx,%rdi,4)
movups 0x40(%rax,%rdi,4),%xmm0
movups 0x50(%rax,%rdi,4),%xmm1
movups %xmm0,0x40(%rdx,%rdi,4)
movups %xmm1,0x50(%rdx,%rdi,4)
movups 0x60(%rax,%rdi,4),%xmm0
movups 0x70(%rax,%rdi,4),%xmm1
movups %xmm0,0x60(%rdx,%rdi,4)
movups %xmm1,0x70(%rdx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1360 <GCI_invert_Gaussian+0x230>
test   %r9,%r9
je     13eb <GCI_invert_Gaussian+0x2bb>
lea    (%rdx,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%rax,%rdi,4),%rcx
add    $0x10,%rcx
xor    %edi,%edi
nop
movups -0x10(%rcx,%rdi,1),%xmm0
movups (%rcx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r15
jne    13d0 <GCI_invert_Gaussian+0x2a0>
mov    %r11,%rdi
mov    (%rsp),%rbp
cmp    %rbp,%r11
je     12f0 <GCI_invert_Gaussian+0x1c0>
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rsi
not    %rsi
add    %rbp,%rsi
test   %r8,%r8
je     1434 <GCI_invert_Gaussian+0x304>
mov    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rcx
jne    1420 <GCI_invert_Gaussian+0x2f0>
cmp    $0x3,%rsi
mov    (%rsp),%rbp
jb     12f0 <GCI_invert_Gaussian+0x1c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
movss  0x4(%rax,%rdi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rdi,4)
movss  0x8(%rax,%rdi,4),%xmm0
movss  %xmm0,0x8(%rdx,%rdi,4)
movss  0xc(%rax,%rdi,4),%xmm0
movss  %xmm0,0xc(%rdx,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    1450 <GCI_invert_Gaussian+0x320>
jmp    12f0 <GCI_invert_Gaussian+0x1c0>
mov    %eax,%ebx
jmp    1498 <GCI_invert_Gaussian+0x368>
xor    %ebx,%ebx
jmp    1498 <GCI_invert_Gaussian+0x368>
mov    0x1c(%rsp),%ebx
mov    0x10(%rsp),%rdi
call   1040 <GCI_ecf_free_matrix@plt>
mov    %r12,%rdi
call   1040 <GCI_ecf_free_matrix@plt>
mov    %ebx,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @GCI_invert_Gaussian(float** %0, i32 %1) {
%3 = alloca i32
%4 = alloca float**
%5 = alloca i32
%6 = alloca i32
%7 = alloca float**
%8 = alloca float**
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store float** %0, float*** %4
store i32 %1, i32* %5
store i32 0, i32* %6
%12 = load i32, i32* %5
%13 = load i32, i32* %5
%14 = call float** @GCI_ecf_matrix(i32 %12, i32 %13)
store float** %14, float*** %7
%15 = load i32, i32* %5
%16 = load i32, i32* %5
%17 = call float** @GCI_ecf_matrix(i32 %15, i32 %16)
store float** %17, float*** %8
store i32 0, i32* %10
br label %18
18: ; preds = %91, %2
%19 = load i32, i32* %10
%20 = load i32, i32* %5
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %94
22: ; preds = %18
store i32 0, i32* %9
br label %23
23: ; preds = %62, %22
%24 = load i32, i32* %9
%25 = load i32, i32* %5
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %65
27: ; preds = %23
%28 = load float**, float*** %7
%29 = load i32, i32* %10
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds float*, float** %28, i64 %30
%32 = load float*, float** %31
%33 = load i32, i32* %9
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds float, float* %32, i64 %34
store float 0.000000e+00, float* %35
store i32 0, i32* %11
br label %36
36: ; preds = %58, %27
%37 = load i32, i32* %11
%38 = load i32, i32* %5
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %61
40: ; preds = %36
%41 = load float**, float*** %4
%42 = load i32, i32* %11
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float*, float** %41, i64 %43
%45 = load float*, float** %44
%46 = load i32, i32* %9
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %45, i64 %47
%49 = load float, float* %48
%50 = load float**, float*** %8
%51 = load i32, i32* %11
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float*, float** %50, i64 %52
%54 = load float*, float** %53
%55 = load i32, i32* %9
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %54, i64 %56
store float %49, float* %57
br label %58
58: ; preds = %40
%59 = load i32, i32* %11
%60 = add nsw i32 %59, 1
store i32 %60, i32* %11
br label %36
61: ; preds = %36
br label %62
62: ; preds = %61
%63 = load i32, i32* %9
%64 = add nsw i32 %63, 1
store i32 %64, i32* %9
br label %23
65: ; preds = %23
%66 = load float**, float*** %7
%67 = load i32, i32* %10
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float*, float** %66, i64 %68
%70 = load float*, float** %69
%71 = load i32, i32* %10
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
store float 1.000000e+00, float* %73
%74 = load float**, float*** %8
%75 = load i32, i32* %5
%76 = load float**, float*** %7
%77 = load i32, i32* %10
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds float*, float** %76, i64 %78
%80 = load float*, float** %79
%81 = call i32 @GCI_solve_Gaussian(float** %74, i32 %75, float* %80)
store i32 %81, i32* %6
%82 = load i32, i32* %6
%83 = icmp slt i32 %82, 0
br i1 %83, label %84, label %90
84: ; preds = %65
%85 = load float**, float*** %7
%86 = call i32 @GCI_ecf_free_matrix(float** %85)
%87 = load float**, float*** %8
%88 = call i32 @GCI_ecf_free_matrix(float** %87)
%89 = load i32, i32* %6
store i32 %89, i32* %3
br label %135
90: ; preds = %65
br label %91
91: ; preds = %90
%92 = load i32, i32* %10
%93 = add nsw i32 %92, 1
store i32 %93, i32* %10
br label %18
94: ; preds = %18
store i32 0, i32* %10
br label %95
95: ; preds = %126, %94
%96 = load i32, i32* %10
%97 = load i32, i32* %5
%98 = icmp slt i32 %96, %97
br i1 %98, label %99, label %129
99: ; preds = %95
store i32 0, i32* %9
br label %100
100: ; preds = %122, %99
%101 = load i32, i32* %9
%102 = load i32, i32* %5
%103 = icmp slt i32 %101, %102
br i1 %103, label %104, label %125
104: ; preds = %100
%105 = load float**, float*** %7
%106 = load i32, i32* %10
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float*, float** %105, i64 %107
%109 = load float*, float** %108
%110 = load i32, i32* %9
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds float, float* %109, i64 %111
%113 = load float, float* %112
%114 = load float**, float*** %4
%115 = load i32, i32* %10
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float*, float** %114, i64 %116
%118 = load float*, float** %117
%119 = load i32, i32* %9
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float, float* %118, i64 %120
store float %113, float* %121
br label %122
122: ; preds = %104
%123 = load i32, i32* %9
%124 = add nsw i32 %123, 1
store i32 %124, i32* %9
br label %100
125: ; preds = %100
br label %126
126: ; preds = %125
%127 = load i32, i32* %10
%128 = add nsw i32 %127, 1
store i32 %128, i32* %10
br label %95
129: ; preds = %95
%130 = load float**, float*** %7
%131 = call i32 @GCI_ecf_free_matrix(float** %130)
%132 = load float**, float*** %8
%133 = call i32 @GCI_ecf_free_matrix(float** %132)
%134 = load i32, i32* %6
store i32 %134, i32* %3
br label %135
135: ; preds = %129, %84
%136 = load i32, i32* %3
ret i32 %136
}

LLVM IR (-O2):
define i32 @GCI_invert_Gaussian(float** nocapture %0, i32 %1) {
%3 = tail call float** @GCI_ecf_matrix(i32 %1, i32 %1)
%4 = tail call float** @GCI_ecf_matrix(i32 %1, i32 %1)
%5 = icmp sgt i32 %1, 0
br i1 %5, label %6, label %220
6: ; preds = %2
%7 = zext i32 %1 to i64
%8 = add nsw i64 %7, -1
%9 = and i64 %7, 3
%10 = icmp ult i64 %8, 3
%11 = and i64 %7, 4294967292
%12 = icmp eq i64 %9, 0
br label %15
13: ; preds = %93
%14 = icmp eq i64 %97, %7
br i1 %14, label %19, label %15
15: ; preds = %13, %6
%16 = phi i64 [ 0, %6 ], [ %97, %13 ]
%17 = getelementptr inbounds float*, float** %3, i64 %16
%18 = load float*, float** %17
br label %35
19: ; preds = %13
br i1 %5, label %20, label %220
20: ; preds = %19
%21 = zext i32 %1 to i64
%22 = and i64 %21, 4294967288
%23 = add nsw i64 %22, -8
%24 = lshr exact i64 %23, 3
%25 = add nuw nsw i64 %24, 1
%26 = icmp ult i32 %1, 8
%27 = and i64 %7, 4294967288
%28 = and i64 %25, 3
%29 = icmp ult i64 %23, 24
%30 = and i64 %25, 4611686018427387900
%31 = icmp eq i64 %28, 0
%32 = icmp eq i64 %27, %7
%33 = and i64 %21, 3
%34 = icmp eq i64 %33, 0
br label %101
35: ; preds = %90, %15
%36 = phi i64 [ 0, %15 ], [ %91, %90 ]
%37 = getelementptr inbounds float, float* %18, i64 %36
store float 0.000000e+00, float* %37
br i1 %10, label %75, label %38
38: ; preds = %35, %38
%39 = phi i64 [ %72, %38 ], [ 0, %35 ]
%40 = phi i64 [ %73, %38 ], [ 0, %35 ]
%41 = getelementptr inbounds float*, float** %0, i64 %39
%42 = load float*, float** %41
%43 = getelementptr inbounds float, float* %42, i64 %36
%44 = load float, float* %43
%45 = getelementptr inbounds float*, float** %4, i64 %39
%46 = load float*, float** %45
%47 = getelementptr inbounds float, float* %46, i64 %36
store float %44, float* %47
%48 = or i64 %39, 1
%49 = getelementptr inbounds float*, float** %0, i64 %48
%50 = load float*, float** %49
%51 = getelementptr inbounds float, float* %50, i64 %36
%52 = load float, float* %51
%53 = getelementptr inbounds float*, float** %4, i64 %48
%54 = load float*, float** %53
%55 = getelementptr inbounds float, float* %54, i64 %36
store float %52, float* %55
%56 = or i64 %39, 2
%57 = getelementptr inbounds float*, float** %0, i64 %56
%58 = load float*, float** %57
%59 = getelementptr inbounds float, float* %58, i64 %36
%60 = load float, float* %59
%61 = getelementptr inbounds float*, float** %4, i64 %56
%62 = load float*, float** %61
%63 = getelementptr inbounds float, float* %62, i64 %36
store float %60, float* %63
%64 = or i64 %39, 3
%65 = getelementptr inbounds float*, float** %0, i64 %64
%66 = load float*, float** %65
%67 = getelementptr inbounds float, float* %66, i64 %36
%68 = load float, float* %67
%69 = getelementptr inbounds float*, float** %4, i64 %64
%70 = load float*, float** %69
%71 = getelementptr inbounds float, float* %70, i64 %36
store float %68, float* %71
%72 = add nuw nsw i64 %39, 4
%73 = add i64 %40, 4
%74 = icmp eq i64 %73, %11
br i1 %74, label %75, label %38
75: ; preds = %38, %35
%76 = phi i64 [ 0, %35 ], [ %72, %38 ]
br i1 %12, label %90, label %77
77: ; preds = %75, %77
%78 = phi i64 [ %87, %77 ], [ %76, %75 ]
%79 = phi i64 [ %88, %77 ], [ 0, %75 ]
%80 = getelementptr inbounds float*, float** %0, i64 %78
%81 = load float*, float** %80
%82 = getelementptr inbounds float, float* %81, i64 %36
%83 = load float, float* %82
%84 = getelementptr inbounds float*, float** %4, i64 %78
%85 = load float*, float** %84
%86 = getelementptr inbounds float, float* %85, i64 %36
store float %83, float* %86
%87 = add nuw nsw i64 %78, 1
%88 = add i64 %79, 1
%89 = icmp eq i64 %88, %9
br i1 %89, label %90, label %77
90: ; preds = %77, %75
%91 = add nuw nsw i64 %36, 1
%92 = icmp eq i64 %91, %7
br i1 %92, label %93, label %35
93: ; preds = %90
%94 = getelementptr inbounds float, float* %18, i64 %16
store float 1.000000e+00, float* %94
%95 = tail call i32 @GCI_solve_Gaussian(float** %4, i32 %1, float* %18)
%96 = icmp slt i32 %95, 0
%97 = add nuw nsw i64 %16, 1
br i1 %96, label %98, label %13
98: ; preds = %93
%99 = tail call i32 @GCI_ecf_free_matrix(float** %3)
%100 = tail call i32 @GCI_ecf_free_matrix(float** %4)
br label %224
101: ; preds = %217, %20
%102 = phi i64 [ 0, %20 ], [ %218, %217 ]
%103 = getelementptr inbounds float*, float** %3, i64 %102
%104 = load float*, float** %103
%105 = getelementptr inbounds float*, float** %0, i64 %102
%106 = load float*, float** %105
br i1 %26, label %182, label %107
107: ; preds = %101
%108 = getelementptr float, float* %106, i64 %7
%109 = getelementptr float, float* %104, i64 %7
%110 = icmp ult float* %106, %109
%111 = icmp ult float* %104, %108
%112 = and i1 %110, %111
br i1 %112, label %182, label %113
113: ; preds = %107
br i1 %29, label %163, label %114
114: ; preds = %113, %114
%115 = phi i64 [ %160, %114 ], [ 0, %113 ]
%116 = phi i64 [ %161, %114 ], [ 0, %113 ]
%117 = getelementptr inbounds float, float* %104, i64 %115
%118 = bitcast float* %117 to <4 x float>*
%119 = load <4 x float>, <4 x float>* %118
%120 = getelementptr inbounds float, float* %117, i64 4
%121 = bitcast float* %120 to <4 x float>*
%122 = load <4 x float>, <4 x float>* %121
%123 = getelementptr inbounds float, float* %106, i64 %115
%124 = bitcast float* %123 to <4 x float>*
store <4 x float> %119, <4 x float>* %124
%125 = getelementptr inbounds float, float* %123, i64 4
%126 = bitcast float* %125 to <4 x float>*
store <4 x float> %122, <4 x float>* %126
%127 = or i64 %115, 8
%128 = getelementptr inbounds float, float* %104, i64 %127
%129 = bitcast float* %128 to <4 x float>*
%130 = load <4 x float>, <4 x float>* %129
%131 = getelementptr inbounds float, float* %128, i64 4
%132 = bitcast float* %131 to <4 x float>*
%133 = load <4 x float>, <4 x float>* %132
%134 = getelementptr inbounds float, float* %106, i64 %127
%135 = bitcast float* %134 to <4 x float>*
store <4 x float> %130, <4 x float>* %135
%136 = getelementptr inbounds float, float* %134, i64 4
%137 = bitcast float* %136 to <4 x float>*
store <4 x float> %133, <4 x float>* %137
%138 = or i64 %115, 16
%139 = getelementptr inbounds float, float* %104, i64 %138
%140 = bitcast float* %139 to <4 x float>*
%141 = load <4 x float>, <4 x float>* %140
%142 = getelementptr inbounds float, float* %139, i64 4
%143 = bitcast float* %142 to <4 x float>*
%144 = load <4 x float>, <4 x float>* %143
%145 = getelementptr inbounds float, float* %106, i64 %138
%146 = bitcast float* %145 to <4 x float>*
store <4 x float> %141, <4 x float>* %146
%147 = getelementptr inbounds float, float* %145, i64 4
%148 = bitcast float* %147 to <4 x float>*
store <4 x float> %144, <4 x float>* %148
%149 = or i64 %115, 24
%150 = getelementptr inbounds float, float* %104, i64 %149
%151 = bitcast float* %150 to <4 x float>*
%152 = load <4 x float>, <4 x float>* %151
%153 = getelementptr inbounds float, float* %150, i64 4
%154 = bitcast float* %153 to <4 x float>*
%155 = load <4 x float>, <4 x float>* %154
%156 = getelementptr inbounds float, float* %106, i64 %149
%157 = bitcast float* %156 to <4 x float>*
store <4 x float> %152, <4 x float>* %157
%158 = getelementptr inbounds float, float* %156, i64 4
%159 = bitcast float* %158 to <4 x float>*
store <4 x float> %155, <4 x float>* %159
%160 = add nuw i64 %115, 32
%161 = add i64 %116, 4
%162 = icmp eq i64 %161, %30
br i1 %162, label %163, label %114
163: ; preds = %114, %113
%164 = phi i64 [ 0, %113 ], [ %160, %114 ]
br i1 %31, label %181, label %165
165: ; preds = %163, %165
%166 = phi i64 [ %178, %165 ], [ %164, %163 ]
%167 = phi i64 [ %179, %165 ], [ 0, %163 ]
%168 = getelementptr inbounds float, float* %104, i64 %166
%169 = bitcast float* %168 to <4 x float>*
%170 = load <4 x float>, <4 x float>* %169
%171 = getelementptr inbounds float, float* %168, i64 4
%172 = bitcast float* %171 to <4 x float>*
%173 = load <4 x float>, <4 x float>* %172
%174 = getelementptr inbounds float, float* %106, i64 %166
%175 = bitcast float* %174 to <4 x float>*
store <4 x float> %170, <4 x float>* %175
%176 = getelementptr inbounds float, float* %174, i64 4
%177 = bitcast float* %176 to <4 x float>*
store <4 x float> %173, <4 x float>* %177
%178 = add nuw i64 %166, 8
%179 = add i64 %167, 1
%180 = icmp eq i64 %179, %28
br i1 %180, label %181, label %165
181: ; preds = %165, %163
br i1 %32, label %217, label %182
182: ; preds = %107, %101, %181
%183 = phi i64 [ 0, %107 ], [ 0, %101 ], [ %27, %181 ]
%184 = xor i64 %183, -1
%185 = add nsw i64 %184, %21
br i1 %34, label %195, label %186
186: ; preds = %182, %186
%187 = phi i64 [ %192, %186 ], [ %183, %182 ]
%188 = phi i64 [ %193, %186 ], [ 0, %182 ]
%189 = getelementptr inbounds float, float* %104, i64 %187
%190 = load float, float* %189
%191 = getelementptr inbounds float, float* %106, i64 %187
store float %190, float* %191
%192 = add nuw nsw i64 %187, 1
%193 = add i64 %188, 1
%194 = icmp eq i64 %193, %33
br i1 %194, label %195, label %186
195: ; preds = %186, %182
%196 = phi i64 [ %183, %182 ], [ %192, %186 ]
%197 = icmp ult i64 %185, 3
br i1 %197, label %217, label %198
198: ; preds = %195, %198
%199 = phi i64 [ %215, %198 ], [ %196, %195 ]
%200 = getelementptr inbounds float, float* %104, i64 %199
%201 = load float, float* %200
%202 = getelementptr inbounds float, float* %106, i64 %199
store float %201, float* %202
%203 = add nuw nsw i64 %199, 1
%204 = getelementptr inbounds float, float* %104, i64 %203
%205 = load float, float* %204
%206 = getelementptr inbounds float, float* %106, i64 %203
store float %205, float* %206
%207 = add nuw nsw i64 %199, 2
%208 = getelementptr inbounds float, float* %104, i64 %207
%209 = load float, float* %208
%210 = getelementptr inbounds float, float* %106, i64 %207
store float %209, float* %210
%211 = add nuw nsw i64 %199, 3
%212 = getelementptr inbounds float, float* %104, i64 %211
%213 = load float, float* %212
%214 = getelementptr inbounds float, float* %106, i64 %211
store float %213, float* %214
%215 = add nuw nsw i64 %199, 4
%216 = icmp eq i64 %215, %21
br i1 %216, label %217, label %198
217: ; preds = %195, %198, %181
%218 = add nuw nsw i64 %102, 1
%219 = icmp eq i64 %218, %21
br i1 %219, label %220, label %101
220: ; preds = %217, %2, %19
%221 = phi i32 [ %95, %19 ], [ 0, %2 ], [ %95, %217 ]
%222 = tail call i32 @GCI_ecf_free_matrix(float** %3)
%223 = tail call i32 @GCI_ecf_free_matrix(float** %4)
br label %224
224: ; preds = %220, %98
%225 = phi i32 [ %95, %98 ], [ %221, %220 ]
ret i32 %225
}