#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 */
double **dmatrix(int /*<<< orphan*/, int, int /*<<< orphan*/, int);
int /*<<< orphan*/ free_dmatrix(double **, int /*<<< orphan*/, int,
                                int /*<<< orphan*/, int);
int /*<<< orphan*/ free_ivector(int *, int /*<<< orphan*/, int);
int *ivector(int /*<<< orphan*/, int);
int /*<<< orphan*/ lu_backsub(double **, int, int *, double *);
scalar_t__ lu_decomp(double **, int, int *, double *);
int lu_invert(double **a, int n) {
  int i, j;
  double rip;
  int *pivx, PIVX[10];
  double **y;
  if (n <= 10)
    pivx = PIVX;
  else
    pivx = ivector(0, n - 1);
  if (lu_decomp(a, n, pivx, &rip)) {
    if (pivx != PIVX)
      free_ivector(pivx, 0, n - 1);
    return 1;
  }
  y = dmatrix(0, n - 1, 0, n - 1);
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      y[i][j] = a[i][j];
    }
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++)
      a[i][j] = 0.0;
    a[i][i] = 1.0;
    lu_backsub(y, n, pivx, a[i]);
  }
  free_dmatrix(y, 0, n - 1, 0, n - 1);
  if (pivx != PIVX)
    free_ivector(pivx, 0, n - 1);
  return 0;
}


x86 assembly (clang, -O0):
<lu_invert>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
cmpl   $0xa,-0x14(%rbp)
jg     1186 <lu_invert+0x26>
lea    -0x60(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1197 <lu_invert+0x37>
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1070 <ivector@plt>
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x30(%rbp),%rdx
lea    -0x28(%rbp),%rcx
call   1060 <lu_decomp@plt>
cmp    $0x0,%rax
je     11e3 <lu_invert+0x83>
mov    -0x30(%rbp),%rax
lea    -0x60(%rbp),%rcx
cmp    %rcx,%rax
je     11d7 <lu_invert+0x77>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1050 <free_ivector@plt>
movl   $0x1,-0x4(%rbp)
jmp    1344 <lu_invert+0x1e4>
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
xor    %edx,%edx
mov    %edx,%edi
call   1030 <dmatrix@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    126d <lu_invert+0x10d>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    125a <lu_invert+0xfa>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1216 <lu_invert+0xb6>
jmp    125f <lu_invert+0xff>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1203 <lu_invert+0xa3>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1300 <lu_invert+0x1a0>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b9 <lu_invert+0x159>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1287 <lu_invert+0x127>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  0xd2f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x30(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
call   1040 <lu_backsub@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1274 <lu_invert+0x114>
mov    -0x68(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
mov    -0x14(%rbp),%r8d
sub    $0x1,%r8d
xor    %ecx,%ecx
mov    %ecx,%esi
call   1080 <free_dmatrix@plt>
mov    -0x30(%rbp),%rax
lea    -0x60(%rbp),%rcx
cmp    %rcx,%rax
je     133d <lu_invert+0x1dd>
mov    -0x30(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1050 <free_ivector@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lu_invert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %esi,%ebx
mov    %rdi,%r13
cmp    $0xa,%esi
jg     118f <lu_invert+0x1f>
lea    0x20(%rsp),%rbp
jmp    119c <lu_invert+0x2c>
lea    -0x1(%rbx),%esi
xor    %edi,%edi
call   1080 <ivector@plt>
mov    %rax,%rbp
lea    0x18(%rsp),%rcx
mov    %r13,%rdi
mov    %ebx,%esi
mov    %rbp,%rdx
call   1070 <lu_decomp@plt>
test   %rax,%rax
je     11cf <lu_invert+0x5f>
lea    0x20(%rsp),%rax
cmp    %rax,%rbp
je     138c <lu_invert+0x21c>
add    $0xffffffff,%ebx
mov    $0x1,%r14d
jmp    1418 <lu_invert+0x2a8>
lea    -0x1(%rbx),%ecx
xor    %edi,%edi
mov    %ecx,%esi
xor    %edx,%edx
mov    %ecx,0xc(%rsp)
call   1040 <dmatrix@plt>
mov    %rax,%r15
test   %ebx,%ebx
mov    %rbp,0x10(%rsp)
jle    13ee <lu_invert+0x27e>
mov    %r15,%r8
mov    %ebx,%r14d
mov    %r14d,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%r9
mov    %r9,(%rsp)
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9d,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%r9
mov    %r14d,%r12d
and    $0x3,%r12d
mov    %r10,%rsi
shl    $0x5,%rsi
xor    %ecx,%ecx
mov    %rbx,%r15
jmp    123d <lu_invert+0xcd>
xchg   %ax,%ax
add    $0x1,%rcx
cmp    %r14,%rcx
je     1397 <lu_invert+0x227>
mov    %r13,%rax
mov    0x0(%r13,%rcx,8),%rdx
mov    %r8,%rax
mov    (%r8,%rcx,8),%rax
cmp    $0x4,%r15d
jb     126c <lu_invert+0xfc>
lea    (%rdx,%r14,8),%rdi
cmp    %rdi,%rax
jae    12e0 <lu_invert+0x170>
lea    (%rax,%r14,8),%rdi
cmp    %rdi,%rdx
jae    12e0 <lu_invert+0x170>
xor    %ebp,%ebp
mov    %rbp,%rbx
not    %rbx
add    %r14,%rbx
test   %r12,%r12
je     1294 <lu_invert+0x124>
mov    %r12,%rdi
nop
movsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdi
jne    1280 <lu_invert+0x110>
cmp    $0x3,%rbx
jb     1230 <lu_invert+0xc0>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rbp,8),%xmm0
movsd  %xmm0,(%rax,%rbp,8)
movsd  0x8(%rdx,%rbp,8),%xmm0
movsd  %xmm0,0x8(%rax,%rbp,8)
movsd  0x10(%rdx,%rbp,8),%xmm0
movsd  %xmm0,0x10(%rax,%rbp,8)
movsd  0x18(%rdx,%rbp,8),%xmm0
movsd  %xmm0,0x18(%rax,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%r14
jne    12a0 <lu_invert+0x130>
jmp    1230 <lu_invert+0xc0>
nopl   0x0(%rax)
cmpq   $0xc,(%rsp)
jae    12eb <lu_invert+0x17b>
xor    %ebp,%ebp
jmp    1348 <lu_invert+0x1d8>
mov    %r9,%rbx
xor    %ebp,%ebp
movups (%rdx,%rbp,8),%xmm0
movups 0x10(%rdx,%rbp,8),%xmm1
movups %xmm0,(%rax,%rbp,8)
movups %xmm1,0x10(%rax,%rbp,8)
movups 0x20(%rdx,%rbp,8),%xmm0
movups 0x30(%rdx,%rbp,8),%xmm1
movups %xmm0,0x20(%rax,%rbp,8)
movups %xmm1,0x30(%rax,%rbp,8)
movups 0x40(%rdx,%rbp,8),%xmm0
movups 0x50(%rdx,%rbp,8),%xmm1
movups %xmm0,0x40(%rax,%rbp,8)
movups %xmm1,0x50(%rax,%rbp,8)
movups 0x60(%rdx,%rbp,8),%xmm0
movups 0x70(%rdx,%rbp,8),%xmm1
movups %xmm0,0x60(%rax,%rbp,8)
movups %xmm1,0x70(%rax,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rbx
jne    12f0 <lu_invert+0x180>
test   %r10,%r10
je     137b <lu_invert+0x20b>
lea    (%rax,%rbp,8),%rbx
add    $0x10,%rbx
lea    (%rdx,%rbp,8),%rdi
add    $0x10,%rdi
xor    %ebp,%ebp
nop
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rbx,%rbp,1)
movups %xmm1,(%rbx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1360 <lu_invert+0x1f0>
mov    %r11,%rbp
cmp    %r14,%r11
je     1230 <lu_invert+0xc0>
jmp    126e <lu_invert+0xfe>
mov    $0x1,%r14d
jmp    1424 <lu_invert+0x2b4>
test   %r15d,%r15d
mov    %r15,(%rsp)
mov    %r8,%r15
jle    13ee <lu_invert+0x27e>
mov    %r13,%rbp
lea    0x0(,%r14,8),%r12
xor    %ebx,%ebx
mov    0x0(%rbp,%rbx,8),%r13
mov    %r13,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memset@plt>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x0(%r13,%rbx,8)
mov    %r15,%rdi
mov    (%rsp),%rsi
mov    0x10(%rsp),%rdx
mov    %r13,%rcx
call   1050 <lu_backsub@plt>
add    $0x1,%rbx
cmp    %rbx,%r14
jne    13b0 <lu_invert+0x240>
mov    %r15,%rdi
xor    %esi,%esi
mov    0xc(%rsp),%ebx
mov    %ebx,%edx
xor    %ecx,%ecx
mov    %ebx,%r8d
call   1090 <free_dmatrix@plt>
lea    0x20(%rsp),%rax
mov    0x10(%rsp),%rbp
cmp    %rax,%rbp
mov    $0x0,%r14d
je     1424 <lu_invert+0x2b4>
mov    %rbp,%rdi
xor    %esi,%esi
mov    %ebx,%edx
call   1060 <free_ivector@plt>
mov    %r14d,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @lu_invert(double** %0, i32 %1) {
%3 = alloca double
%4 = alloca [10 x i32]
%5 = bitcast double* %3 to i8*
%6 = bitcast [10 x i32]* %4 to i8*
%7 = icmp slt i32 %1, 11
br i1 %7, label %8, label %10
8: ; preds = %2
%9 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 0
br label %13
10: ; preds = %2
%11 = add nsw i32 %1, -1
%12 = tail call i32* @ivector(i32 0, i32 %11)
br label %13
13: ; preds = %10, %8
%14 = phi i32* [ %9, %8 ], [ %12, %10 ]
%15 = call i64 @lu_decomp(double** %0, i32 %1, i32* %14, double* %3)
%16 = icmp eq i64 %15, 0
br i1 %16, label %22, label %17
17: ; preds = %13
%18 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 0
%19 = icmp eq i32* %14, %18
br i1 %19, label %181, label %20
20: ; preds = %17
%21 = add nsw i32 %1, -1
br label %177
22: ; preds = %13
%23 = add nsw i32 %1, -1
%24 = call double** @dmatrix(i32 0, i32 %23, i32 0, i32 %23)
%25 = icmp sgt i32 %1, 0
br i1 %25, label %26, label %173
26: ; preds = %22
%27 = zext i32 %1 to i64
%28 = and i64 %27, 4294967292
%29 = add nsw i64 %28, -4
%30 = lshr exact i64 %29, 2
%31 = add nuw nsw i64 %30, 1
%32 = icmp ult i32 %1, 4
%33 = and i64 %27, 4294967292
%34 = and i64 %31, 3
%35 = icmp ult i64 %29, 12
%36 = and i64 %31, 9223372036854775804
%37 = icmp eq i64 %34, 0
%38 = icmp eq i64 %33, %27
%39 = and i64 %27, 3
%40 = icmp eq i64 %39, 0
br label %41
41: ; preds = %161, %26
%42 = phi i64 [ 0, %26 ], [ %162, %161 ]
%43 = getelementptr inbounds double*, double** %0, i64 %42
%44 = load double*, double** %43
%45 = getelementptr inbounds double*, double** %24, i64 %42
%46 = load double*, double** %45
br i1 %32, label %122, label %47
47: ; preds = %41
%48 = getelementptr double, double* %46, i64 %27
%49 = getelementptr double, double* %44, i64 %27
%50 = icmp ult double* %46, %49
%51 = icmp ult double* %44, %48
%52 = and i1 %50, %51
br i1 %52, label %122, label %53
53: ; preds = %47
br i1 %35, label %103, label %54
54: ; preds = %53, %54
%55 = phi i64 [ %100, %54 ], [ 0, %53 ]
%56 = phi i64 [ %101, %54 ], [ 0, %53 ]
%57 = getelementptr inbounds double, double* %44, i64 %55
%58 = bitcast double* %57 to <2 x double>*
%59 = load <2 x double>, <2 x double>* %58
%60 = getelementptr inbounds double, double* %57, i64 2
%61 = bitcast double* %60 to <2 x double>*
%62 = load <2 x double>, <2 x double>* %61
%63 = getelementptr inbounds double, double* %46, i64 %55
%64 = bitcast double* %63 to <2 x double>*
store <2 x double> %59, <2 x double>* %64
%65 = getelementptr inbounds double, double* %63, i64 2
%66 = bitcast double* %65 to <2 x double>*
store <2 x double> %62, <2 x double>* %66
%67 = or i64 %55, 4
%68 = getelementptr inbounds double, double* %44, i64 %67
%69 = bitcast double* %68 to <2 x double>*
%70 = load <2 x double>, <2 x double>* %69
%71 = getelementptr inbounds double, double* %68, i64 2
%72 = bitcast double* %71 to <2 x double>*
%73 = load <2 x double>, <2 x double>* %72
%74 = getelementptr inbounds double, double* %46, i64 %67
%75 = bitcast double* %74 to <2 x double>*
store <2 x double> %70, <2 x double>* %75
%76 = getelementptr inbounds double, double* %74, i64 2
%77 = bitcast double* %76 to <2 x double>*
store <2 x double> %73, <2 x double>* %77
%78 = or i64 %55, 8
%79 = getelementptr inbounds double, double* %44, i64 %78
%80 = bitcast double* %79 to <2 x double>*
%81 = load <2 x double>, <2 x double>* %80
%82 = getelementptr inbounds double, double* %79, i64 2
%83 = bitcast double* %82 to <2 x double>*
%84 = load <2 x double>, <2 x double>* %83
%85 = getelementptr inbounds double, double* %46, i64 %78
%86 = bitcast double* %85 to <2 x double>*
store <2 x double> %81, <2 x double>* %86
%87 = getelementptr inbounds double, double* %85, i64 2
%88 = bitcast double* %87 to <2 x double>*
store <2 x double> %84, <2 x double>* %88
%89 = or i64 %55, 12
%90 = getelementptr inbounds double, double* %44, i64 %89
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = getelementptr inbounds double, double* %90, i64 2
%94 = bitcast double* %93 to <2 x double>*
%95 = load <2 x double>, <2 x double>* %94
%96 = getelementptr inbounds double, double* %46, i64 %89
%97 = bitcast double* %96 to <2 x double>*
store <2 x double> %92, <2 x double>* %97
%98 = getelementptr inbounds double, double* %96, i64 2
%99 = bitcast double* %98 to <2 x double>*
store <2 x double> %95, <2 x double>* %99
%100 = add nuw i64 %55, 16
%101 = add nuw i64 %56, 4
%102 = icmp eq i64 %101, %36
br i1 %102, label %103, label %54
103: ; preds = %54, %53
%104 = phi i64 [ 0, %53 ], [ %100, %54 ]
br i1 %37, label %121, label %105
105: ; preds = %103, %105
%106 = phi i64 [ %118, %105 ], [ %104, %103 ]
%107 = phi i64 [ %119, %105 ], [ 0, %103 ]
%108 = getelementptr inbounds double, double* %44, i64 %106
%109 = bitcast double* %108 to <2 x double>*
%110 = load <2 x double>, <2 x double>* %109
%111 = getelementptr inbounds double, double* %108, i64 2
%112 = bitcast double* %111 to <2 x double>*
%113 = load <2 x double>, <2 x double>* %112
%114 = getelementptr inbounds double, double* %46, i64 %106
%115 = bitcast double* %114 to <2 x double>*
store <2 x double> %110, <2 x double>* %115
%116 = getelementptr inbounds double, double* %114, i64 2
%117 = bitcast double* %116 to <2 x double>*
store <2 x double> %113, <2 x double>* %117
%118 = add nuw i64 %106, 4
%119 = add i64 %107, 1
%120 = icmp eq i64 %119, %34
br i1 %120, label %121, label %105
121: ; preds = %105, %103
br i1 %38, label %161, label %122
122: ; preds = %47, %41, %121
%123 = phi i64 [ 0, %47 ], [ 0, %41 ], [ %33, %121 ]
%124 = xor i64 %123, -1
%125 = add nsw i64 %124, %27
br i1 %40, label %135, label %126
126: ; preds = %122, %126
%127 = phi i64 [ %132, %126 ], [ %123, %122 ]
%128 = phi i64 [ %133, %126 ], [ 0, %122 ]
%129 = getelementptr inbounds double, double* %44, i64 %127
%130 = load double, double* %129
%131 = getelementptr inbounds double, double* %46, i64 %127
store double %130, double* %131
%132 = add nuw nsw i64 %127, 1
%133 = add i64 %128, 1
%134 = icmp eq i64 %133, %39
br i1 %134, label %135, label %126
135: ; preds = %126, %122
%136 = phi i64 [ %123, %122 ], [ %132, %126 ]
%137 = icmp ult i64 %125, 3
br i1 %137, label %161, label %142
138: ; preds = %161
br i1 %25, label %139, label %173
139: ; preds = %138
%140 = zext i32 %1 to i64
%141 = shl nuw nsw i64 %140, 3
br label %164
142: ; preds = %135, %142
%143 = phi i64 [ %159, %142 ], [ %136, %135 ]
%144 = getelementptr inbounds double, double* %44, i64 %143
%145 = load double, double* %144
%146 = getelementptr inbounds double, double* %46, i64 %143
store double %145, double* %146
%147 = add nuw nsw i64 %143, 1
%148 = getelementptr inbounds double, double* %44, i64 %147
%149 = load double, double* %148
%150 = getelementptr inbounds double, double* %46, i64 %147
store double %149, double* %150
%151 = add nuw nsw i64 %143, 2
%152 = getelementptr inbounds double, double* %44, i64 %151
%153 = load double, double* %152
%154 = getelementptr inbounds double, double* %46, i64 %151
store double %153, double* %154
%155 = add nuw nsw i64 %143, 3
%156 = getelementptr inbounds double, double* %44, i64 %155
%157 = load double, double* %156
%158 = getelementptr inbounds double, double* %46, i64 %155
store double %157, double* %158
%159 = add nuw nsw i64 %143, 4
%160 = icmp eq i64 %159, %27
br i1 %160, label %161, label %142
161: ; preds = %135, %142, %121
%162 = add nuw nsw i64 %42, 1
%163 = icmp eq i64 %162, %27
br i1 %163, label %138, label %41
164: ; preds = %139, %164
%165 = phi i64 [ 0, %139 ], [ %171, %164 ]
%166 = getelementptr inbounds double*, double** %0, i64 %165
%167 = load double*, double** %166
%168 = bitcast double* %167 to i8*
%169 = getelementptr inbounds double, double* %167, i64 %165
store double 1.000000e+00, double* %169
%170 = call i32 @lu_backsub(double** %24, i32 %1, i32* %14, double* %167)
%171 = add nuw nsw i64 %165, 1
%172 = icmp eq i64 %171, %140
br i1 %172, label %173, label %164
173: ; preds = %164, %22, %138
%174 = call i32 @free_dmatrix(double** %24, i32 0, i32 %23, i32 0, i32 %23)
%175 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 0
%176 = icmp eq i32* %14, %175
br i1 %176, label %181, label %177
177: ; preds = %173, %20
%178 = phi i32 [ %21, %20 ], [ %23, %173 ]
%179 = phi i32 [ 1, %20 ], [ 0, %173 ]
%180 = call i32 @free_ivector(i32* %14, i32 0, i32 %178)
br label %181
181: ; preds = %177, %173, %17
%182 = phi i32 [ 1, %17 ], [ 0, %173 ], [ %179, %177 ]
ret i32 %182
}