#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 colamd(int const, int const, int, int *, int *, double *, int *);
int colamd_recommended(int const, int const, int const);
int /*<<< orphan*/ colamd_set_defaults(double *);
int /*<<< orphan*/ sprintf(char *, char *, char *, int, char *);
int /*<<< orphan*/ superlu_abort_and_exit(char *);
int /*<<< orphan*/ superlu_free(int *);
scalar_t__ superlu_malloc(int const);
void get_colamd(const int m, const int n, const int nnz, int *colptr,
                int *rowind, int *perm_c) {
  int Alen, *A, i, info, *p;
  double knobs[20];
  int stats[20];
  Alen = colamd_recommended(nnz, m, n);
  colamd_set_defaults(knobs);
  if (!(A = (int *)superlu_malloc(Alen * sizeof(int)))) {
    char msg[256];
    sprintf(msg, "%s at line %d in file %s\n", "Malloc fails for A[]", 36,
            "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
            "2022-01-22/02-19-57/repos/dribbroc/HONEI/refs/heads/master/honei/"
            "math/SuperLU_4.1/SRC/get_perm_c.c");
    superlu_abort_and_exit(msg);
  };
  if (!(p = (int *)superlu_malloc((n + 1) * sizeof(int)))) {
    char msg[256];
    sprintf(msg, "%s at line %d in file %s\n", "Malloc fails for p[]", 38,
            "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
            "2022-01-22/02-19-57/repos/dribbroc/HONEI/refs/heads/master/honei/"
            "math/SuperLU_4.1/SRC/get_perm_c.c");
    superlu_abort_and_exit(msg);
  };
  for (i = 0; i <= n; ++i)
    p[i] = colptr[i];
  for (i = 0; i < nnz; ++i)
    A[i] = rowind[i];
  info = colamd(m, n, Alen, A, p, knobs, stats);
  if (info == 0) {
    char msg[256];
    sprintf(msg, "%s at line %d in file %s\n", "COLAMD failed", 42,
            "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
            "2022-01-22/02-19-57/repos/dribbroc/HONEI/refs/heads/master/honei/"
            "math/SuperLU_4.1/SRC/get_perm_c.c");
    superlu_abort_and_exit(msg);
  };
  for (i = 0; i < n; ++i)
    perm_c[p[i]] = i;
  superlu_free(A);
  superlu_free(p);
}


x86 assembly (clang, -O0):
<get_colamd>:
push   %rbp
mov    %rsp,%rbp
sub    $0x450,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0xc(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    -0x8(%rbp),%edx
call   1040 <colamd_recommended@plt>
mov    %eax,-0x2c(%rbp)
lea    -0xf0(%rbp),%rdi
call   1080 <colamd_set_defaults@plt>
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <superlu_malloc@plt>
mov    %rax,-0x38(%rbp)
cmp    $0x0,%rax
jne    11fc <get_colamd+0x8c>
lea    -0x240(%rbp),%rdi
lea    0xe28(%rip),%rsi
lea    0xe3b(%rip),%rdx
mov    $0x24,%ecx
lea    0xe44(%rip),%r8
call   1090 <sprintf@plt>
lea    -0x240(%rbp),%rdi
call   1030 <superlu_abort_and_exit@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <superlu_malloc@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
jne    124f <get_colamd+0xdf>
lea    -0x340(%rbp),%rdi
lea    0xdd5(%rip),%rsi
lea    0xea0(%rip),%rdx
mov    $0x26,%ecx
lea    0xdf1(%rip),%r8
call   1090 <sprintf@plt>
lea    -0x340(%rbp),%rdi
call   1030 <superlu_abort_and_exit@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1286 <get_colamd+0x116>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1256 <get_colamd+0xe6>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12bd <get_colamd+0x14d>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    128d <get_colamd+0x11d>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x2c(%rbp),%edx
mov    -0x38(%rbp),%rcx
mov    -0x48(%rbp),%r8
lea    -0xf0(%rbp),%r9
lea    -0x140(%rbp),%rax
mov    %rax,(%rsp)
call   1070 <colamd@plt>
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jne    1324 <get_colamd+0x1b4>
lea    -0x440(%rbp),%rdi
lea    0xd00(%rip),%rsi
lea    0xde0(%rip),%rdx
mov    $0x2a,%ecx
lea    0xd1c(%rip),%r8
call   1090 <sprintf@plt>
lea    -0x440(%rbp),%rdi
call   1030 <superlu_abort_and_exit@plt>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    135b <get_colamd+0x1eb>
mov    -0x3c(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x3c(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    132b <get_colamd+0x1bb>
mov    -0x38(%rbp),%rdi
call   1060 <superlu_free@plt>
mov    -0x48(%rbp),%rdi
call   1060 <superlu_free@plt>
add    $0x450,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_colamd>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
mov    %r9,%r14
mov    %r8,%rbp
mov    %rcx,%r13
mov    %esi,%r12d
mov    %edi,%esi
mov    %edx,0x10(%rsp)
mov    %edx,%edi
mov    %esi,0x14(%rsp)
mov    %r12d,%edx
call   1040 <colamd_recommended@plt>
mov    %eax,%ebx
lea    0x170(%rsp),%rdi
call   1080 <colamd_set_defaults@plt>
mov    %rbx,0x18(%rsp)
lea    0x0(,%rbx,4),%edi
call   1050 <superlu_malloc@plt>
mov    %rax,%r15
test   %rax,%rax
jne    11f8 <get_colamd+0x88>
lea    0xe30(%rip),%rsi
lea    0xe43(%rip),%rdx
lea    0xe51(%rip),%r8
lea    0x20(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x24,%ecx
call   1090 <sprintf@plt>
mov    %rbx,%rdi
call   1030 <superlu_abort_and_exit@plt>
lea    0x4(,%r12,4),%edi
call   1050 <superlu_malloc@plt>
mov    %rax,%rbx
test   %rax,%rax
jne    123b <get_colamd+0xcb>
lea    0xdec(%rip),%rsi
lea    0xeb7(%rip),%rdx
lea    0xe0d(%rip),%r8
lea    0x20(%rsp),%rdi
mov    $0x26,%ecx
call   1090 <sprintf@plt>
lea    0x20(%rsp),%rdi
call   1030 <superlu_abort_and_exit@plt>
test   %r12d,%r12d
js     13a4 <get_colamd+0x234>
lea    0x1(%r12),%eax
cmp    $0x7,%r12d
jb     1268 <get_colamd+0xf8>
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
cmp    %rcx,%rbx
jae    12d1 <get_colamd+0x161>
lea    (%rbx,%rax,4),%rcx
cmp    %r13,%rcx
jbe    12d1 <get_colamd+0x161>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1292 <get_colamd+0x122>
nopl   0x0(%rax)
mov    0x0(%r13,%rcx,4),%edi
mov    %edi,(%rbx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1280 <get_colamd+0x110>
cmp    $0x3,%rdx
jb     13a4 <get_colamd+0x234>
nopl   0x0(%rax)
mov    0x0(%r13,%rcx,4),%edx
mov    %edx,(%rbx,%rcx,4)
mov    0x4(%r13,%rcx,4),%edx
mov    %edx,0x4(%rbx,%rcx,4)
mov    0x8(%r13,%rcx,4),%edx
mov    %edx,0x8(%rbx,%rcx,4)
mov    0xc(%r13,%rcx,4),%edx
mov    %edx,0xc(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    12a0 <get_colamd+0x130>
jmp    13a4 <get_colamd+0x234>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rdx
jae    12f6 <get_colamd+0x186>
xor    %edi,%edi
jmp    1361 <get_colamd+0x1f1>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups 0x0(%r13,%rdi,4),%xmm0
movups 0x10(%r13,%rdi,4),%xmm1
movups %xmm0,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
movups 0x20(%r13,%rdi,4),%xmm0
movups 0x30(%r13,%rdi,4),%xmm1
movups %xmm0,0x20(%rbx,%rdi,4)
movups %xmm1,0x30(%rbx,%rdi,4)
movups 0x40(%r13,%rdi,4),%xmm0
movups 0x50(%r13,%rdi,4),%xmm1
movups %xmm0,0x40(%rbx,%rdi,4)
movups %xmm1,0x50(%rbx,%rdi,4)
movups 0x60(%r13,%rdi,4),%xmm0
movups 0x70(%r13,%rdi,4),%xmm1
movups %xmm0,0x60(%rbx,%rdi,4)
movups %xmm1,0x70(%rbx,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1300 <get_colamd+0x190>
test   %r8,%r8
je     139b <get_colamd+0x22b>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
lea    0x10(,%rdi,4),%rdi
add    %r13,%rdi
shl    $0x5,%r8
xor    %edx,%edx
nop
movups -0x10(%rdi,%rdx,1),%xmm0
movups (%rdi,%rdx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,1)
movups %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1380 <get_colamd+0x210>
cmp    %rax,%rcx
jne    126a <get_colamd+0xfa>
mov    0x10(%rsp),%ecx
test   %ecx,%ecx
jle    1514 <get_colamd+0x3a4>
mov    %ecx,%eax
cmp    $0x8,%ecx
jb     13d0 <get_colamd+0x260>
lea    0x0(,%rax,4),%rcx
add    %rbp,%rcx
cmp    %rcx,%r15
jae    1441 <get_colamd+0x2d1>
lea    (%r15,%rax,4),%rcx
cmp    %rbp,%rcx
jbe    1441 <get_colamd+0x2d1>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1402 <get_colamd+0x292>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%rbp,%rcx,4),%edi
mov    %edi,(%r15,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    13f0 <get_colamd+0x280>
cmp    $0x3,%rdx
jb     1514 <get_colamd+0x3a4>
nopl   0x0(%rax)
mov    0x0(%rbp,%rcx,4),%edx
mov    %edx,(%r15,%rcx,4)
mov    0x4(%rbp,%rcx,4),%edx
mov    %edx,0x4(%r15,%rcx,4)
mov    0x8(%rbp,%rcx,4),%edx
mov    %edx,0x8(%r15,%rcx,4)
mov    0xc(%rbp,%rcx,4),%edx
mov    %edx,0xc(%r15,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1410 <get_colamd+0x2a0>
jmp    1514 <get_colamd+0x3a4>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rdx
jae    1466 <get_colamd+0x2f6>
xor    %edi,%edi
jmp    14d1 <get_colamd+0x361>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movups 0x0(%rbp,%rdi,4),%xmm0
movups 0x10(%rbp,%rdi,4),%xmm1
movups %xmm0,(%r15,%rdi,4)
movups %xmm1,0x10(%r15,%rdi,4)
movups 0x20(%rbp,%rdi,4),%xmm0
movups 0x30(%rbp,%rdi,4),%xmm1
movups %xmm0,0x20(%r15,%rdi,4)
movups %xmm1,0x30(%r15,%rdi,4)
movups 0x40(%rbp,%rdi,4),%xmm0
movups 0x50(%rbp,%rdi,4),%xmm1
movups %xmm0,0x40(%r15,%rdi,4)
movups %xmm1,0x50(%r15,%rdi,4)
movups 0x60(%rbp,%rdi,4),%xmm0
movups 0x70(%rbp,%rdi,4),%xmm1
movups %xmm0,0x60(%r15,%rdi,4)
movups %xmm1,0x70(%r15,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1470 <get_colamd+0x300>
test   %r8,%r8
je     150b <get_colamd+0x39b>
lea    (%r15,%rdi,4),%rsi
add    $0x10,%rsi
lea    0x10(,%rdi,4),%rdi
add    %rbp,%rdi
shl    $0x5,%r8
xor    %edx,%edx
nop
movups -0x10(%rdi,%rdx,1),%xmm0
movups (%rdi,%rdx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,1)
movups %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    14f0 <get_colamd+0x380>
cmp    %rax,%rcx
jne    13d2 <get_colamd+0x262>
lea    0x120(%rsp),%rax
mov    %rax,(%rsp)
lea    0x170(%rsp),%r9
mov    0x14(%rsp),%edi
mov    %r12d,%esi
mov    0x18(%rsp),%rdx
mov    %r15,%rcx
mov    %rbx,%r8
call   1070 <colamd@plt>
test   %eax,%eax
jne    1572 <get_colamd+0x402>
lea    0xab6(%rip),%rsi
lea    0xb96(%rip),%rdx
lea    0xad7(%rip),%r8
lea    0x20(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x2a,%ecx
call   1090 <sprintf@plt>
mov    %rbp,%rdi
call   1030 <superlu_abort_and_exit@plt>
test   %r12d,%r12d
jle    15f2 <get_colamd+0x482>
mov    %r12d,%edx
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    158d <get_colamd+0x41d>
xor    %ecx,%ecx
jmp    15d5 <get_colamd+0x465>
and    $0xfffffffc,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%rbx,%rcx,4),%rsi
mov    %ecx,(%r14,%rsi,4)
movslq 0x4(%rbx,%rcx,4),%rsi
lea    0x1(%rcx),%edi
mov    %edi,(%r14,%rsi,4)
movslq 0x8(%rbx,%rcx,4),%rsi
lea    0x2(%rcx),%edi
mov    %edi,(%r14,%rsi,4)
movslq 0xc(%rbx,%rcx,4),%rsi
lea    0x3(%rcx),%edi
mov    %edi,(%r14,%rsi,4)
add    $0x4,%rcx
cmp    %rdx,%rcx
jne    15a0 <get_colamd+0x430>
test   %rax,%rax
je     15f2 <get_colamd+0x482>
nopw   0x0(%rax,%rax,1)
movslq (%rbx,%rcx,4),%rdx
mov    %ecx,(%r14,%rdx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    15e0 <get_colamd+0x470>
mov    %r15,%rdi
call   1060 <superlu_free@plt>
mov    %rbx,%rdi
call   1060 <superlu_free@plt>
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [26 x i8] c"%s at line %d in file %s\0A\00"
@.str.1 = [21 x i8] c"Malloc fails for A[]\00"
@.str.2 = [163 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/dribbroc/HONEI/refs/heads/master/honei/math/SuperLU_4.1/SRC/get_perm_c.c\00"
@.str.3 = [21 x i8] c"Malloc fails for p[]\00"
@.str.4 = [14 x i8] c"COLAMD failed\00"
define void @get_colamd(i32 %0, i32 %1, i32 %2, i32* %3, i32* %4, i32* %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32
%14 = alloca i32*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32*
%18 = alloca [20 x double]
%19 = alloca [20 x i32]
%20 = alloca [256 x i8]
%21 = alloca [256 x i8]
%22 = alloca [256 x i8]
store i32 %0, i32* %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i32* %3, i32** %10
store i32* %4, i32** %11
store i32* %5, i32** %12
%23 = load i32, i32* %9
%24 = load i32, i32* %7
%25 = load i32, i32* %8
%26 = call i32 @colamd_recommended(i32 %23, i32 %24, i32 %25)
store i32 %26, i32* %13
%27 = getelementptr inbounds [20 x double], [20 x double]* %18, i64 0, i64 0
%28 = call i32 @colamd_set_defaults(double* %27)
%29 = load i32, i32* %13
%30 = sext i32 %29 to i64
%31 = mul i64 %30, 4
%32 = trunc i64 %31 to i32
%33 = call i64 @superlu_malloc(i32 %32)
%34 = inttoptr i64 %33 to i32*
store i32* %34, i32** %14
%35 = icmp ne i32* %34, null
br i1 %35, label %41, label %36
36: ; preds = %6
%37 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 0
%38 = call i32 @sprintf(i8* %37, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), i32 36, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%39 = getelementptr inbounds [256 x i8], [256 x i8]* %20, i64 0, i64 0
%40 = call i32 @superlu_abort_and_exit(i8* %39)
br label %41
41: ; preds = %36, %6
%42 = load i32, i32* %8
%43 = add nsw i32 %42, 1
%44 = sext i32 %43 to i64
%45 = mul i64 %44, 4
%46 = trunc i64 %45 to i32
%47 = call i64 @superlu_malloc(i32 %46)
%48 = inttoptr i64 %47 to i32*
store i32* %48, i32** %17
%49 = icmp ne i32* %48, null
br i1 %49, label %55, label %50
50: ; preds = %41
%51 = getelementptr inbounds [256 x i8], [256 x i8]* %21, i64 0, i64 0
%52 = call i32 @sprintf(i8* %51, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.3, i64 0, i64 0), i32 38, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%53 = getelementptr inbounds [256 x i8], [256 x i8]* %21, i64 0, i64 0
%54 = call i32 @superlu_abort_and_exit(i8* %53)
br label %55
55: ; preds = %50, %41
store i32 0, i32* %15
br label %56
56: ; preds = %70, %55
%57 = load i32, i32* %15
%58 = load i32, i32* %8
%59 = icmp sle i32 %57, %58
br i1 %59, label %60, label %73
60: ; preds = %56
%61 = load i32*, i32** %10
%62 = load i32, i32* %15
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %61, i64 %63
%65 = load i32, i32* %64
%66 = load i32*, i32** %17
%67 = load i32, i32* %15
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %66, i64 %68
store i32 %65, i32* %69
br label %70
70: ; preds = %60
%71 = load i32, i32* %15
%72 = add nsw i32 %71, 1
store i32 %72, i32* %15
br label %56
73: ; preds = %56
store i32 0, i32* %15
br label %74
74: ; preds = %88, %73
%75 = load i32, i32* %15
%76 = load i32, i32* %9
%77 = icmp slt i32 %75, %76
br i1 %77, label %78, label %91
78: ; preds = %74
%79 = load i32*, i32** %11
%80 = load i32, i32* %15
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32, i32* %79, i64 %81
%83 = load i32, i32* %82
%84 = load i32*, i32** %14
%85 = load i32, i32* %15
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i32, i32* %84, i64 %86
store i32 %83, i32* %87
br label %88
88: ; preds = %78
%89 = load i32, i32* %15
%90 = add nsw i32 %89, 1
store i32 %90, i32* %15
br label %74
91: ; preds = %74
%92 = load i32, i32* %7
%93 = load i32, i32* %8
%94 = load i32, i32* %13
%95 = load i32*, i32** %14
%96 = load i32*, i32** %17
%97 = getelementptr inbounds [20 x double], [20 x double]* %18, i64 0, i64 0
%98 = getelementptr inbounds [20 x i32], [20 x i32]* %19, i64 0, i64 0
%99 = call i32 @colamd(i32 %92, i32 %93, i32 %94, i32* %95, i32* %96, double* %97, i32* %98)
store i32 %99, i32* %16
%100 = load i32, i32* %16
%101 = icmp eq i32 %100, 0
br i1 %101, label %102, label %107
102: ; preds = %91
%103 = getelementptr inbounds [256 x i8], [256 x i8]* %22, i64 0, i64 0
%104 = call i32 @sprintf(i8* %103, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i64 0, i64 0), i32 42, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%105 = getelementptr inbounds [256 x i8], [256 x i8]* %22, i64 0, i64 0
%106 = call i32 @superlu_abort_and_exit(i8* %105)
br label %107
107: ; preds = %102, %91
store i32 0, i32* %15
br label %108
108: ; preds = %122, %107
%109 = load i32, i32* %15
%110 = load i32, i32* %8
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %125
112: ; preds = %108
%113 = load i32, i32* %15
%114 = load i32*, i32** %12
%115 = load i32*, i32** %17
%116 = load i32, i32* %15
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i32, i32* %115, i64 %117
%119 = load i32, i32* %118
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i32, i32* %114, i64 %120
store i32 %113, i32* %121
br label %122
122: ; preds = %112
%123 = load i32, i32* %15
%124 = add nsw i32 %123, 1
store i32 %124, i32* %15
br label %108
125: ; preds = %108
%126 = load i32*, i32** %14
%127 = call i32 @superlu_free(i32* %126)
%128 = load i32*, i32** %17
%129 = call i32 @superlu_free(i32* %128)
ret void
}

LLVM IR (-O2):
@.str = [26 x i8] c"%s at line %d in file %s\0A\00"
@.str.1 = [21 x i8] c"Malloc fails for A[]\00"
@.str.2 = [163 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/dribbroc/HONEI/refs/heads/master/honei/math/SuperLU_4.1/SRC/get_perm_c.c\00"
@.str.3 = [21 x i8] c"Malloc fails for p[]\00"
@.str.4 = [14 x i8] c"COLAMD failed\00"
define void @get_colamd(i32 %0, i32 %1, i32 %2, i32* nocapture %3, i32* nocapture %4, i32* nocapture writeonly %5) {
%7 = alloca [20 x double]
%8 = alloca [20 x i32]
%9 = alloca [256 x i8]
%10 = alloca [256 x i8]
%11 = alloca [256 x i8]
%12 = bitcast [20 x double]* %7 to i8*
%13 = bitcast [20 x i32]* %8 to i8*
%14 = tail call i32 @colamd_recommended(i32 %2, i32 %0, i32 %1)
%15 = getelementptr inbounds [20 x double], [20 x double]* %7, i64 0, i64 0
%16 = call i32 @colamd_set_defaults(double* %15)
%17 = shl i32 %14, 2
%18 = call i64 @superlu_malloc(i32 %17)
%19 = inttoptr i64 %18 to i32*
%20 = inttoptr i64 %18 to i8*
%21 = icmp eq i64 %18, 0
br i1 %21, label %22, label %26
22: ; preds = %6
%23 = getelementptr inbounds [256 x i8], [256 x i8]* %9, i64 0, i64 0
%24 = call i32 @sprintf(i8* %23, i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.1, i64 0, i64 0), i32 36, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%25 = call i32 @superlu_abort_and_exit(i8* %23)
br label %26
26: ; preds = %22, %6
%27 = shl i32 %1, 2
%28 = add i32 %27, 4
%29 = call i64 @superlu_malloc(i32 %28)
%30 = inttoptr i64 %29 to i32*
%31 = inttoptr i64 %29 to i8*
%32 = icmp eq i64 %29, 0
br i1 %32, label %33, label %37
33: ; preds = %26
%34 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 0
%35 = call i32 @sprintf(i8* %34, i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.3, i64 0, i64 0), i32 38, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%36 = call i32 @superlu_abort_and_exit(i8* %34)
br label %37
37: ; preds = %33, %26
%38 = icmp slt i32 %1, 0
br i1 %38, label %147, label %39
39: ; preds = %37
%40 = add nuw i32 %1, 1
%41 = zext i32 %40 to i64
%42 = icmp ult i32 %1, 7
br i1 %42, label %129, label %43
43: ; preds = %39
%44 = getelementptr i32, i32* %30, i64 %41
%45 = getelementptr i32, i32* %3, i64 %41
%46 = bitcast i32* %45 to i8*
%47 = icmp ult i8* %31, %46
%48 = icmp ugt i32* %44, %3
%49 = and i1 %47, %48
br i1 %49, label %129, label %50
50: ; preds = %43
%51 = and i64 %41, 4294967288
%52 = add nsw i64 %51, -8
%53 = lshr exact i64 %52, 3
%54 = add nuw nsw i64 %53, 1
%55 = and i64 %54, 3
%56 = icmp ult i64 %52, 24
br i1 %56, label %108, label %57
57: ; preds = %50
%58 = and i64 %54, 4611686018427387900
br label %59
59: ; preds = %59, %57
%60 = phi i64 [ 0, %57 ], [ %105, %59 ]
%61 = phi i64 [ 0, %57 ], [ %106, %59 ]
%62 = getelementptr inbounds i32, i32* %3, i64 %60
%63 = bitcast i32* %62 to <4 x i32>*
%64 = load <4 x i32>, <4 x i32>* %63
%65 = getelementptr inbounds i32, i32* %62, i64 4
%66 = bitcast i32* %65 to <4 x i32>*
%67 = load <4 x i32>, <4 x i32>* %66
%68 = getelementptr inbounds i32, i32* %30, i64 %60
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %64, <4 x i32>* %69
%70 = getelementptr inbounds i32, i32* %68, i64 4
%71 = bitcast i32* %70 to <4 x i32>*
store <4 x i32> %67, <4 x i32>* %71
%72 = or i64 %60, 8
%73 = getelementptr inbounds i32, i32* %3, i64 %72
%74 = bitcast i32* %73 to <4 x i32>*
%75 = load <4 x i32>, <4 x i32>* %74
%76 = getelementptr inbounds i32, i32* %73, i64 4
%77 = bitcast i32* %76 to <4 x i32>*
%78 = load <4 x i32>, <4 x i32>* %77
%79 = getelementptr inbounds i32, i32* %30, i64 %72
%80 = bitcast i32* %79 to <4 x i32>*
store <4 x i32> %75, <4 x i32>* %80
%81 = getelementptr inbounds i32, i32* %79, i64 4
%82 = bitcast i32* %81 to <4 x i32>*
store <4 x i32> %78, <4 x i32>* %82
%83 = or i64 %60, 16
%84 = getelementptr inbounds i32, i32* %3, i64 %83
%85 = bitcast i32* %84 to <4 x i32>*
%86 = load <4 x i32>, <4 x i32>* %85
%87 = getelementptr inbounds i32, i32* %84, i64 4
%88 = bitcast i32* %87 to <4 x i32>*
%89 = load <4 x i32>, <4 x i32>* %88
%90 = getelementptr inbounds i32, i32* %30, i64 %83
%91 = bitcast i32* %90 to <4 x i32>*
store <4 x i32> %86, <4 x i32>* %91
%92 = getelementptr inbounds i32, i32* %90, i64 4
%93 = bitcast i32* %92 to <4 x i32>*
store <4 x i32> %89, <4 x i32>* %93
%94 = or i64 %60, 24
%95 = getelementptr inbounds i32, i32* %3, i64 %94
%96 = bitcast i32* %95 to <4 x i32>*
%97 = load <4 x i32>, <4 x i32>* %96
%98 = getelementptr inbounds i32, i32* %95, i64 4
%99 = bitcast i32* %98 to <4 x i32>*
%100 = load <4 x i32>, <4 x i32>* %99
%101 = getelementptr inbounds i32, i32* %30, i64 %94
%102 = bitcast i32* %101 to <4 x i32>*
store <4 x i32> %97, <4 x i32>* %102
%103 = getelementptr inbounds i32, i32* %101, i64 4
%104 = bitcast i32* %103 to <4 x i32>*
store <4 x i32> %100, <4 x i32>* %104
%105 = add nuw i64 %60, 32
%106 = add i64 %61, 4
%107 = icmp eq i64 %106, %58
br i1 %107, label %108, label %59
108: ; preds = %59, %50
%109 = phi i64 [ 0, %50 ], [ %105, %59 ]
%110 = icmp eq i64 %55, 0
br i1 %110, label %127, label %111
111: ; preds = %108, %111
%112 = phi i64 [ %124, %111 ], [ %109, %108 ]
%113 = phi i64 [ %125, %111 ], [ 0, %108 ]
%114 = getelementptr inbounds i32, i32* %3, i64 %112
%115 = bitcast i32* %114 to <4 x i32>*
%116 = load <4 x i32>, <4 x i32>* %115
%117 = getelementptr inbounds i32, i32* %114, i64 4
%118 = bitcast i32* %117 to <4 x i32>*
%119 = load <4 x i32>, <4 x i32>* %118
%120 = getelementptr inbounds i32, i32* %30, i64 %112
%121 = bitcast i32* %120 to <4 x i32>*
store <4 x i32> %116, <4 x i32>* %121
%122 = getelementptr inbounds i32, i32* %120, i64 4
%123 = bitcast i32* %122 to <4 x i32>*
store <4 x i32> %119, <4 x i32>* %123
%124 = add nuw i64 %112, 8
%125 = add i64 %113, 1
%126 = icmp eq i64 %125, %55
br i1 %126, label %127, label %111
127: ; preds = %111, %108
%128 = icmp eq i64 %51, %41
br i1 %128, label %147, label %129
129: ; preds = %43, %39, %127
%130 = phi i64 [ 0, %43 ], [ 0, %39 ], [ %51, %127 ]
%131 = xor i64 %130, -1
%132 = add nsw i64 %131, %41
%133 = and i64 %41, 3
%134 = icmp eq i64 %133, 0
br i1 %134, label %144, label %135
135: ; preds = %129, %135
%136 = phi i64 [ %141, %135 ], [ %130, %129 ]
%137 = phi i64 [ %142, %135 ], [ 0, %129 ]
%138 = getelementptr inbounds i32, i32* %3, i64 %136
%139 = load i32, i32* %138
%140 = getelementptr inbounds i32, i32* %30, i64 %136
store i32 %139, i32* %140
%141 = add nuw nsw i64 %136, 1
%142 = add i64 %137, 1
%143 = icmp eq i64 %142, %133
br i1 %143, label %144, label %135
144: ; preds = %135, %129
%145 = phi i64 [ %130, %129 ], [ %141, %135 ]
%146 = icmp ult i64 %132, 3
br i1 %146, label %147, label %256
147: ; preds = %144, %256, %127, %37
%148 = icmp sgt i32 %2, 0
br i1 %148, label %149, label %294
149: ; preds = %147
%150 = zext i32 %2 to i64
%151 = icmp ult i32 %2, 8
br i1 %151, label %238, label %152
152: ; preds = %149
%153 = getelementptr i32, i32* %19, i64 %150
%154 = getelementptr i32, i32* %4, i64 %150
%155 = bitcast i32* %154 to i8*
%156 = icmp ult i8* %20, %155
%157 = icmp ugt i32* %153, %4
%158 = and i1 %156, %157
br i1 %158, label %238, label %159
159: ; preds = %152
%160 = and i64 %150, 4294967288
%161 = add nsw i64 %160, -8
%162 = lshr exact i64 %161, 3
%163 = add nuw nsw i64 %162, 1
%164 = and i64 %163, 3
%165 = icmp ult i64 %161, 24
br i1 %165, label %217, label %166
166: ; preds = %159
%167 = and i64 %163, 4611686018427387900
br label %168
168: ; preds = %168, %166
%169 = phi i64 [ 0, %166 ], [ %214, %168 ]
%170 = phi i64 [ 0, %166 ], [ %215, %168 ]
%171 = getelementptr inbounds i32, i32* %4, i64 %169
%172 = bitcast i32* %171 to <4 x i32>*
%173 = load <4 x i32>, <4 x i32>* %172
%174 = getelementptr inbounds i32, i32* %171, i64 4
%175 = bitcast i32* %174 to <4 x i32>*
%176 = load <4 x i32>, <4 x i32>* %175
%177 = getelementptr inbounds i32, i32* %19, i64 %169
%178 = bitcast i32* %177 to <4 x i32>*
store <4 x i32> %173, <4 x i32>* %178
%179 = getelementptr inbounds i32, i32* %177, i64 4
%180 = bitcast i32* %179 to <4 x i32>*
store <4 x i32> %176, <4 x i32>* %180
%181 = or i64 %169, 8
%182 = getelementptr inbounds i32, i32* %4, i64 %181
%183 = bitcast i32* %182 to <4 x i32>*
%184 = load <4 x i32>, <4 x i32>* %183
%185 = getelementptr inbounds i32, i32* %182, i64 4
%186 = bitcast i32* %185 to <4 x i32>*
%187 = load <4 x i32>, <4 x i32>* %186
%188 = getelementptr inbounds i32, i32* %19, i64 %181
%189 = bitcast i32* %188 to <4 x i32>*
store <4 x i32> %184, <4 x i32>* %189
%190 = getelementptr inbounds i32, i32* %188, i64 4
%191 = bitcast i32* %190 to <4 x i32>*
store <4 x i32> %187, <4 x i32>* %191
%192 = or i64 %169, 16
%193 = getelementptr inbounds i32, i32* %4, i64 %192
%194 = bitcast i32* %193 to <4 x i32>*
%195 = load <4 x i32>, <4 x i32>* %194
%196 = getelementptr inbounds i32, i32* %193, i64 4
%197 = bitcast i32* %196 to <4 x i32>*
%198 = load <4 x i32>, <4 x i32>* %197
%199 = getelementptr inbounds i32, i32* %19, i64 %192
%200 = bitcast i32* %199 to <4 x i32>*
store <4 x i32> %195, <4 x i32>* %200
%201 = getelementptr inbounds i32, i32* %199, i64 4
%202 = bitcast i32* %201 to <4 x i32>*
store <4 x i32> %198, <4 x i32>* %202
%203 = or i64 %169, 24
%204 = getelementptr inbounds i32, i32* %4, i64 %203
%205 = bitcast i32* %204 to <4 x i32>*
%206 = load <4 x i32>, <4 x i32>* %205
%207 = getelementptr inbounds i32, i32* %204, i64 4
%208 = bitcast i32* %207 to <4 x i32>*
%209 = load <4 x i32>, <4 x i32>* %208
%210 = getelementptr inbounds i32, i32* %19, i64 %203
%211 = bitcast i32* %210 to <4 x i32>*
store <4 x i32> %206, <4 x i32>* %211
%212 = getelementptr inbounds i32, i32* %210, i64 4
%213 = bitcast i32* %212 to <4 x i32>*
store <4 x i32> %209, <4 x i32>* %213
%214 = add nuw i64 %169, 32
%215 = add i64 %170, 4
%216 = icmp eq i64 %215, %167
br i1 %216, label %217, label %168
217: ; preds = %168, %159
%218 = phi i64 [ 0, %159 ], [ %214, %168 ]
%219 = icmp eq i64 %164, 0
br i1 %219, label %236, label %220
220: ; preds = %217, %220
%221 = phi i64 [ %233, %220 ], [ %218, %217 ]
%222 = phi i64 [ %234, %220 ], [ 0, %217 ]
%223 = getelementptr inbounds i32, i32* %4, i64 %221
%224 = bitcast i32* %223 to <4 x i32>*
%225 = load <4 x i32>, <4 x i32>* %224
%226 = getelementptr inbounds i32, i32* %223, i64 4
%227 = bitcast i32* %226 to <4 x i32>*
%228 = load <4 x i32>, <4 x i32>* %227
%229 = getelementptr inbounds i32, i32* %19, i64 %221
%230 = bitcast i32* %229 to <4 x i32>*
store <4 x i32> %225, <4 x i32>* %230
%231 = getelementptr inbounds i32, i32* %229, i64 4
%232 = bitcast i32* %231 to <4 x i32>*
store <4 x i32> %228, <4 x i32>* %232
%233 = add nuw i64 %221, 8
%234 = add i64 %222, 1
%235 = icmp eq i64 %234, %164
br i1 %235, label %236, label %220
236: ; preds = %220, %217
%237 = icmp eq i64 %160, %150
br i1 %237, label %294, label %238
238: ; preds = %152, %149, %236
%239 = phi i64 [ 0, %152 ], [ 0, %149 ], [ %160, %236 ]
%240 = xor i64 %239, -1
%241 = add nsw i64 %240, %150
%242 = and i64 %150, 3
%243 = icmp eq i64 %242, 0
br i1 %243, label %253, label %244
244: ; preds = %238, %244
%245 = phi i64 [ %250, %244 ], [ %239, %238 ]
%246 = phi i64 [ %251, %244 ], [ 0, %238 ]
%247 = getelementptr inbounds i32, i32* %4, i64 %245
%248 = load i32, i32* %247
%249 = getelementptr inbounds i32, i32* %19, i64 %245
store i32 %248, i32* %249
%250 = add nuw nsw i64 %245, 1
%251 = add i64 %246, 1
%252 = icmp eq i64 %251, %242
br i1 %252, label %253, label %244
253: ; preds = %244, %238
%254 = phi i64 [ %239, %238 ], [ %250, %244 ]
%255 = icmp ult i64 %241, 3
br i1 %255, label %294, label %275
256: ; preds = %144, %256
%257 = phi i64 [ %273, %256 ], [ %145, %144 ]
%258 = getelementptr inbounds i32, i32* %3, i64 %257
%259 = load i32, i32* %258
%260 = getelementptr inbounds i32, i32* %30, i64 %257
store i32 %259, i32* %260
%261 = add nuw nsw i64 %257, 1
%262 = getelementptr inbounds i32, i32* %3, i64 %261
%263 = load i32, i32* %262
%264 = getelementptr inbounds i32, i32* %30, i64 %261
store i32 %263, i32* %264
%265 = add nuw nsw i64 %257, 2
%266 = getelementptr inbounds i32, i32* %3, i64 %265
%267 = load i32, i32* %266
%268 = getelementptr inbounds i32, i32* %30, i64 %265
store i32 %267, i32* %268
%269 = add nuw nsw i64 %257, 3
%270 = getelementptr inbounds i32, i32* %3, i64 %269
%271 = load i32, i32* %270
%272 = getelementptr inbounds i32, i32* %30, i64 %269
store i32 %271, i32* %272
%273 = add nuw nsw i64 %257, 4
%274 = icmp eq i64 %273, %41
br i1 %274, label %147, label %256
275: ; preds = %253, %275
%276 = phi i64 [ %292, %275 ], [ %254, %253 ]
%277 = getelementptr inbounds i32, i32* %4, i64 %276
%278 = load i32, i32* %277
%279 = getelementptr inbounds i32, i32* %19, i64 %276
store i32 %278, i32* %279
%280 = add nuw nsw i64 %276, 1
%281 = getelementptr inbounds i32, i32* %4, i64 %280
%282 = load i32, i32* %281
%283 = getelementptr inbounds i32, i32* %19, i64 %280
store i32 %282, i32* %283
%284 = add nuw nsw i64 %276, 2
%285 = getelementptr inbounds i32, i32* %4, i64 %284
%286 = load i32, i32* %285
%287 = getelementptr inbounds i32, i32* %19, i64 %284
store i32 %286, i32* %287
%288 = add nuw nsw i64 %276, 3
%289 = getelementptr inbounds i32, i32* %4, i64 %288
%290 = load i32, i32* %289
%291 = getelementptr inbounds i32, i32* %19, i64 %288
store i32 %290, i32* %291
%292 = add nuw nsw i64 %276, 4
%293 = icmp eq i64 %292, %150
br i1 %293, label %294, label %275
294: ; preds = %253, %275, %236, %147
%295 = getelementptr inbounds [20 x i32], [20 x i32]* %8, i64 0, i64 0
%296 = call i32 @colamd(i32 %0, i32 %1, i32 %14, i32* %19, i32* %30, double* %15, i32* %295)
%297 = icmp eq i32 %296, 0
br i1 %297, label %298, label %302
298: ; preds = %294
%299 = getelementptr inbounds [256 x i8], [256 x i8]* %11, i64 0, i64 0
%300 = call i32 @sprintf(i8* %299, i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.4, i64 0, i64 0), i32 42, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%301 = call i32 @superlu_abort_and_exit(i8* %299)
br label %302
302: ; preds = %298, %294
%303 = icmp sgt i32 %1, 0
br i1 %303, label %304, label %354
304: ; preds = %302
%305 = zext i32 %1 to i64
%306 = add nsw i64 %305, -1
%307 = and i64 %305, 3
%308 = icmp ult i64 %306, 3
br i1 %308, label %340, label %309
309: ; preds = %304
%310 = and i64 %305, 4294967292
br label %311
311: ; preds = %311, %309
%312 = phi i64 [ 0, %309 ], [ %337, %311 ]
%313 = phi i64 [ 0, %309 ], [ %338, %311 ]
%314 = getelementptr inbounds i32, i32* %30, i64 %312
%315 = load i32, i32* %314
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i32, i32* %5, i64 %316
%318 = trunc i64 %312 to i32
store i32 %318, i32* %317
%319 = or i64 %312, 1
%320 = getelementptr inbounds i32, i32* %30, i64 %319
%321 = load i32, i32* %320
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds i32, i32* %5, i64 %322
%324 = trunc i64 %319 to i32
store i32 %324, i32* %323
%325 = or i64 %312, 2
%326 = getelementptr inbounds i32, i32* %30, i64 %325
%327 = load i32, i32* %326
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i32, i32* %5, i64 %328
%330 = trunc i64 %325 to i32
store i32 %330, i32* %329
%331 = or i64 %312, 3
%332 = getelementptr inbounds i32, i32* %30, i64 %331
%333 = load i32, i32* %332
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds i32, i32* %5, i64 %334
%336 = trunc i64 %331 to i32
store i32 %336, i32* %335
%337 = add nuw nsw i64 %312, 4
%338 = add i64 %313, 4
%339 = icmp eq i64 %338, %310
br i1 %339, label %340, label %311
340: ; preds = %311, %304
%341 = phi i64 [ 0, %304 ], [ %337, %311 ]
%342 = icmp eq i64 %307, 0
br i1 %342, label %354, label %343
343: ; preds = %340, %343
%344 = phi i64 [ %351, %343 ], [ %341, %340 ]
%345 = phi i64 [ %352, %343 ], [ 0, %340 ]
%346 = getelementptr inbounds i32, i32* %30, i64 %344
%347 = load i32, i32* %346
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds i32, i32* %5, i64 %348
%350 = trunc i64 %344 to i32
store i32 %350, i32* %349
%351 = add nuw nsw i64 %344, 1
%352 = add i64 %345, 1
%353 = icmp eq i64 %352, %307
br i1 %353, label %354, label %343
354: ; preds = %340, %343, %302
%355 = call i32 @superlu_free(i32* %19)
%356 = call i32 @superlu_free(i32* %30)
ret void
}