#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*/ 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 getata(const int m, const int n, const int nz, int *colptr, int *rowind,
            int *atanz, int **ata_colptr, int **ata_rowind) {
  register int i, j, k, col, num_nz, ti, trow;
  int *marker, *b_colptr, *b_rowind;
  int *t_colptr, *t_rowind;
  if (!(marker = (int *)superlu_malloc((((m) > (n) ? (m) : (n)) + 1) *
                                       sizeof(int)))) {
    char msg[256];
    sprintf(msg, "%s at line %d in file %s\n",
            "SUPERLU_MALLOC fails for marker[]", 88,
            "/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 (!(t_colptr = (int *)superlu_malloc((m + 1) * sizeof(int)))) {
    char msg[256];
    sprintf(msg, "%s at line %d in file %s\n", "SUPERLU_MALLOC t_colptr[]", 90,
            "/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 (!(t_rowind = (int *)superlu_malloc(nz * sizeof(int)))) {
    char msg[256];
    sprintf(msg, "%s at line %d in file %s\n",
            "SUPERLU_MALLOC fails for t_rowind[]", 92,
            "/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 < m; ++i)
    marker[i] = 0;
  for (j = 0; j < n; ++j) {
    for (i = colptr[j]; i < colptr[j + 1]; ++i)
      ++marker[rowind[i]];
  }
  t_colptr[0] = 0;
  for (i = 0; i < m; ++i) {
    t_colptr[i + 1] = t_colptr[i] + marker[i];
    marker[i] = t_colptr[i];
  }
  for (j = 0; j < n; ++j)
    for (i = colptr[j]; i < colptr[j + 1]; ++i) {
      col = rowind[i];
      t_rowind[marker[col]] = j;
      ++marker[col];
    }
  for (i = 0; i < n; ++i)
    marker[i] = -1;
  num_nz = 0;
  for (j = 0; j < n; ++j) {
    marker[j] = j;
    for (i = colptr[j]; i < colptr[j + 1]; ++i) {
      k = rowind[i];
      for (ti = t_colptr[k]; ti < t_colptr[k + 1]; ++ti) {
        trow = t_rowind[ti];
        if (marker[trow] != j) {
          marker[trow] = j;
          num_nz++;
        }
      }
    }
  }
  *atanz = num_nz;
  if (!(*ata_colptr = (int *)superlu_malloc((n + 1) * sizeof(int)))) {
    char msg[256];
    sprintf(msg, "%s at line %d in file %s\n",
            "SUPERLU_MALLOC fails for ata_colptr[]", 154,
            "/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 (*atanz) {
    if (!(*ata_rowind = (int *)superlu_malloc(*atanz * sizeof(int)))) {
      char msg[256];
      sprintf(msg, "%s at line %d in file %s\n",
              "SUPERLU_MALLOC fails for ata_rowind[]", 157,
              "/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);
    };
  }
  b_colptr = *ata_colptr;
  b_rowind = *ata_rowind;
  for (i = 0; i < n; ++i)
    marker[i] = -1;
  num_nz = 0;
  for (j = 0; j < n; ++j) {
    b_colptr[j] = num_nz;
    marker[j] = j;
    for (i = colptr[j]; i < colptr[j + 1]; ++i) {
      k = rowind[i];
      for (ti = t_colptr[k]; ti < t_colptr[k + 1]; ++ti) {
        trow = t_rowind[ti];
        if (marker[trow] != j) {
          marker[trow] = j;
          b_rowind[num_nz++] = trow;
        }
      }
    }
  }
  b_colptr[n] = num_nz;
  superlu_free(marker);
  superlu_free(t_colptr);
  superlu_free(t_rowind);
}


x86 assembly (clang, -O0):
<getata>:
push   %rbp
mov    %rsp,%rbp
sub    $0x580,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
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    -0x4(%rbp),%eax
cmp    -0x8(%rbp),%eax
jle    1182 <getata+0x42>
mov    -0x4(%rbp),%eax
mov    %eax,-0x574(%rbp)
jmp    118b <getata+0x4b>
mov    -0x8(%rbp),%eax
mov    %eax,-0x574(%rbp)
mov    -0x574(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <superlu_malloc@plt>
mov    %rax,-0x50(%rbp)
cmp    $0x0,%rax
jne    11e1 <getata+0xa1>
lea    -0x170(%rbp),%rdi
lea    0xe43(%rip),%rsi
lea    0xe56(%rip),%rdx
mov    $0x58,%ecx
lea    0xe6c(%rip),%r8
call   1060 <sprintf@plt>
lea    -0x170(%rbp),%rdi
call   1030 <superlu_abort_and_exit@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <superlu_malloc@plt>
mov    %rax,-0x68(%rbp)
cmp    $0x0,%rax
jne    1234 <getata+0xf4>
lea    -0x270(%rbp),%rdi
lea    0xdf0(%rip),%rsi
lea    0xec8(%rip),%rdx
mov    $0x5a,%ecx
lea    0xe19(%rip),%r8
call   1060 <sprintf@plt>
lea    -0x270(%rbp),%rdi
call   1030 <superlu_abort_and_exit@plt>
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <superlu_malloc@plt>
mov    %rax,-0x70(%rbp)
cmp    $0x0,%rax
jne    1283 <getata+0x143>
lea    -0x370(%rbp),%rdi
lea    0xda1(%rip),%rsi
lea    0xe93(%rip),%rdx
mov    $0x5c,%ecx
lea    0xdca(%rip),%r8
call   1060 <sprintf@plt>
lea    -0x370(%rbp),%rdi
call   1030 <superlu_abort_and_exit@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12b3 <getata+0x173>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    128a <getata+0x14a>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1327 <getata+0x1e7>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1314 <getata+0x1d4>
mov    -0x50(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12d4 <getata+0x194>
jmp    1319 <getata+0x1d9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12ba <getata+0x17a>
mov    -0x68(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    138e <getata+0x24e>
mov    -0x68(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1338 <getata+0x1f8>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    141e <getata+0x2de>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    140b <getata+0x2cb>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%edx
mov    -0x70(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x38(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13af <getata+0x26f>
jmp    1410 <getata+0x2d0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1395 <getata+0x255>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    144e <getata+0x30e>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1425 <getata+0x2e5>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1544 <getata+0x404>
mov    -0x30(%rbp),%edx
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1531 <getata+0x3f1>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    151e <getata+0x3de>
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
je     150b <getata+0x3cb>
mov    -0x30(%rbp),%edx
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1510 <getata+0x3d0>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    14b9 <getata+0x379>
jmp    1523 <getata+0x3e3>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1484 <getata+0x344>
jmp    1536 <getata+0x3f6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    145c <getata+0x31c>
mov    -0x3c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <superlu_malloc@plt>
mov    0x10(%rbp),%rcx
mov    %rax,(%rcx)
cmp    $0x0,%rax
jne    15a3 <getata+0x463>
lea    -0x470(%rbp),%rdi
lea    0xa81(%rip),%rsi
lea    0xb97(%rip),%rdx
mov    $0x9a,%ecx
lea    0xaaa(%rip),%r8
call   1060 <sprintf@plt>
lea    -0x470(%rbp),%rdi
call   1030 <superlu_abort_and_exit@plt>
mov    -0x28(%rbp),%rax
cmpl   $0x0,(%rax)
je     160a <getata+0x4ca>
mov    -0x28(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <superlu_malloc@plt>
mov    0x18(%rbp),%rcx
mov    %rax,(%rcx)
cmp    $0x0,%rax
jne    1605 <getata+0x4c5>
lea    -0x570(%rbp),%rdi
lea    0xa1f(%rip),%rsi
lea    0xb5b(%rip),%rdx
mov    $0x9d,%ecx
lea    0xa48(%rip),%r8
call   1060 <sprintf@plt>
lea    -0x570(%rbp),%rdi
call   1030 <superlu_abort_and_exit@plt>
jmp    160a <getata+0x4ca>
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1650 <getata+0x510>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1627 <getata+0x4e7>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1763 <getata+0x623>
mov    -0x3c(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1750 <getata+0x610>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    173d <getata+0x5fd>
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
je     172a <getata+0x5ea>
mov    -0x30(%rbp),%edx
mov    -0x50(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%edx
mov    -0x60(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    172f <getata+0x5ef>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    16c9 <getata+0x589>
jmp    1742 <getata+0x602>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1694 <getata+0x554>
jmp    1755 <getata+0x615>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    165e <getata+0x51e>
mov    -0x3c(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%rdi
call   1050 <superlu_free@plt>
mov    -0x68(%rbp),%rdi
call   1050 <superlu_free@plt>
mov    -0x70(%rbp),%rdi
call   1050 <superlu_free@plt>
add    $0x580,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getata>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r9,%r15
mov    %r8,0x20(%rsp)
mov    %rcx,0x8(%rsp)
mov    %edx,%ebp
mov    %edi,%ebx
cmp    %esi,%edi
mov    %rsi,0x28(%rsp)
mov    %esi,%eax
cmovg  %edi,%eax
lea    0x4(,%rax,4),%edi
call   1050 <superlu_malloc@plt>
mov    %rax,%r12
test   %rax,%rax
jne    11c1 <getata+0x71>
lea    0xe67(%rip),%rsi
lea    0xe7a(%rip),%rdx
lea    0xe95(%rip),%r8
lea    0x30(%rsp),%r13
mov    %r13,%rdi
mov    $0x58,%ecx
call   1070 <sprintf@plt>
mov    %r13,%rdi
call   1030 <superlu_abort_and_exit@plt>
mov    %r15,0x10(%rsp)
mov    %rbx,%r14
lea    0x4(,%rbx,4),%edi
call   1050 <superlu_malloc@plt>
mov    %rax,%r13
test   %rax,%rax
jne    120c <getata+0xbc>
lea    0xe1c(%rip),%rsi
lea    0xef4(%rip),%rdx
lea    0xe4a(%rip),%r8
lea    0x30(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x5a,%ecx
call   1070 <sprintf@plt>
mov    %rbx,%rdi
call   1030 <superlu_abort_and_exit@plt>
shl    $0x2,%ebp
mov    %ebp,%edi
call   1050 <superlu_malloc@plt>
mov    %rax,%r15
test   %rax,%rax
jne    124d <getata+0xfd>
lea    0xddb(%rip),%rsi
lea    0xecd(%rip),%rdx
lea    0xe09(%rip),%r8
lea    0x30(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x5c,%ecx
call   1070 <sprintf@plt>
mov    %rbx,%rdi
call   1030 <superlu_abort_and_exit@plt>
mov    %r14,%rdi
mov    %edi,%r9d
test   %edi,%edi
jle    1272 <getata+0x122>
lea    0x0(,%r9,4),%rdx
mov    %r12,%rdi
xor    %esi,%esi
mov    %r9,%rbx
call   1040 <memset@plt>
mov    %rbx,%r9
mov    %r14,%rdi
mov    0x28(%rsp),%r14
mov    %r14d,%ebp
test   %r14d,%r14d
mov    0x20(%rsp),%r8
mov    0x8(%rsp),%rbx
jle    12c8 <getata+0x178>
mov    (%rbx),%ecx
xor    %eax,%eax
jmp    1297 <getata+0x147>
nop
mov    %edx,%ecx
cmp    %rbp,%rax
je     12c8 <getata+0x178>
mov    0x4(%rbx,%rax,4),%edx
add    $0x1,%rax
cmp    %edx,%ecx
jge    1290 <getata+0x140>
movslq %ecx,%rcx
cs nopw 0x0(%rax,%rax,1)
movslq (%r8,%rcx,4),%rdx
addl   $0x1,(%r12,%rdx,4)
add    $0x1,%rcx
movslq (%rbx,%rax,4),%rdx
cmp    %rdx,%rcx
jl     12b0 <getata+0x160>
jmp    1290 <getata+0x140>
movl   $0x0,0x0(%r13)
test   %edi,%edi
mov    %rbp,0x18(%rsp)
jle    13fb <getata+0x2ab>
mov    (%r12),%eax
mov    %eax,0x4(%r13)
movl   $0x0,(%r12)
cmp    $0x1,%edi
je     13fb <getata+0x2ab>
lea    0x4(%r13),%rcx
lea    (%r12,%r9,4),%rdx
mov    %r12,%rax
add    $0x4,%rax
cmp    %rdx,%rcx
jae    1391 <getata+0x241>
lea    0x4(,%r9,4),%rdx
add    %r13,%rdx
cmp    %rdx,%rax
jae    1391 <getata+0x241>
add    $0xffffffffffffffff,%r9
mov    $0x1,%edx
cmp    $0x2,%edi
je     1378 <getata+0x228>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%edx
nopl   0x0(%rax,%rax,1)
mov    (%rcx),%edi
mov    -0x4(%rax,%rdx,4),%ebp
add    %edi,%ebp
mov    %ebp,0x4(%rcx)
mov    %edi,-0x4(%rax,%rdx,4)
mov    0x4(%rcx),%edi
mov    (%rax,%rdx,4),%ebp
add    %edi,%ebp
mov    %ebp,0x8(%rcx)
mov    %edi,(%rax,%rdx,4)
lea    (%rsi,%rdx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rdx
add    $0x8,%rcx
cmp    $0x1,%rdi
jne    1340 <getata+0x1f0>
mov    0x18(%rsp),%rbp
test   $0x1,%r9b
je     13fb <getata+0x2ab>
mov    (%rcx),%eax
mov    (%r12,%rdx,4),%ecx
add    %eax,%ecx
mov    %ecx,0x4(%r13,%rdx,4)
mov    %eax,(%r12,%rdx,4)
jmp    13fb <getata+0x2ab>
mov    (%rcx),%ecx
add    $0xffffffffffffffff,%r9
mov    $0x1,%esi
cmp    $0x2,%edi
je     13e1 <getata+0x291>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%edi
mov    -0x4(%rax,%rdi,4),%ebp
add    %ecx,%ebp
mov    %ebp,0x4(%r13,%rdi,4)
mov    %ecx,-0x4(%rax,%rdi,4)
mov    (%rax,%rdi,4),%ecx
add    %ebp,%ecx
lea    0x2(%rdi),%rsi
mov    %ecx,0x8(%r13,%rdi,4)
mov    %ebp,(%rax,%rdi,4)
lea    (%rdx,%rdi,1),%rbp
add    $0x2,%rbp
mov    %rsi,%rdi
cmp    $0x1,%rbp
jne    13b0 <getata+0x260>
test   $0x1,%r9b
mov    0x18(%rsp),%rbp
je     13fb <getata+0x2ab>
mov    (%r12,%rsi,4),%eax
add    %ecx,%eax
mov    %eax,0x4(%r13,%rsi,4)
mov    %ecx,(%r12,%rsi,4)
test   %r14d,%r14d
jle    1507 <getata+0x3b7>
mov    (%rbx),%edx
xor    %eax,%eax
jmp    1417 <getata+0x2c7>
nopw   0x0(%rax,%rax,1)
mov    %esi,%edx
cmp    %rbp,%rax
je     1450 <getata+0x300>
mov    %rax,%rcx
add    $0x1,%rax
mov    0x4(%rbx,%rcx,4),%esi
cmp    %esi,%edx
jge    1410 <getata+0x2c0>
movslq %edx,%rdx
nopl   0x0(%rax)
movslq (%r8,%rdx,4),%rsi
movslq (%r12,%rsi,4),%rdi
mov    %ecx,(%r15,%rdi,4)
addl   $0x1,(%r12,%rsi,4)
add    $0x1,%rdx
movslq (%rbx,%rax,4),%rsi
cmp    %rsi,%rdx
jl     1430 <getata+0x2e0>
jmp    1410 <getata+0x2c0>
test   %r14d,%r14d
jle    1507 <getata+0x3b7>
lea    0x0(,%rbp,4),%rdx
mov    %r12,%rdi
mov    $0xff,%esi
call   1040 <memset@plt>
mov    0x20(%rsp),%r11
xor    %r8d,%r8d
xor    %eax,%eax
jmp    148a <getata+0x33a>
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rbp
cmp    %rbp,%r8
je     1509 <getata+0x3b9>
mov    %r8,%rdx
mov    %edx,(%r12,%r8,4)
mov    0x8(%rsp),%rcx
movslq (%rcx,%r8,4),%r10
add    $0x1,%r8
mov    0x4(%rcx,%rdx,4),%r9d
cmp    %r9d,%r10d
jl     14c5 <getata+0x375>
jmp    1480 <getata+0x330>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rcx
mov    (%rcx,%r8,4),%r9d
add    $0x1,%r10
movslq %r9d,%rcx
cmp    %rcx,%r10
jge    1480 <getata+0x330>
movslq (%r11,%r10,4),%rdi
movslq 0x0(%r13,%rdi,4),%rcx
mov    0x4(%r13,%rdi,4),%ebp
cmp    %ebp,%ecx
jl     14ec <getata+0x39c>
jmp    14b9 <getata+0x369>
nopl   0x0(%rax)
add    $0x1,%rcx
movslq %ebp,%rsi
cmp    %rsi,%rcx
jge    14b0 <getata+0x360>
movslq (%r15,%rcx,4),%rbx
mov    (%r12,%rbx,4),%esi
cmp    %rsi,%rdx
je     14e0 <getata+0x390>
mov    %edx,(%r12,%rbx,4)
add    $0x1,%eax
mov    0x4(%r13,%rdi,4),%ebp
jmp    14e0 <getata+0x390>
xor    %eax,%eax
mov    0x10(%rsp),%rbx
mov    %eax,(%rbx)
lea    0x4(,%r14,4),%edi
call   1050 <superlu_malloc@plt>
mov    0x170(%rsp),%rcx
mov    %rax,(%rcx)
test   %rax,%rax
jne    155c <getata+0x40c>
lea    0xacc(%rip),%rsi
lea    0xbe2(%rip),%rdx
lea    0xafa(%rip),%r8
lea    0x30(%rsp),%r14
mov    %r14,%rdi
mov    $0x9a,%ecx
call   1070 <sprintf@plt>
mov    %r14,%rdi
call   1030 <superlu_abort_and_exit@plt>
mov    0x178(%rsp),%r14
mov    (%rbx),%edi
test   %edi,%edi
je     15a9 <getata+0x459>
shl    $0x2,%edi
call   1050 <superlu_malloc@plt>
mov    %rax,(%r14)
test   %rax,%rax
jne    15a9 <getata+0x459>
lea    0xa7f(%rip),%rsi
lea    0xbbb(%rip),%rdx
lea    0xaad(%rip),%r8
lea    0x30(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x9d,%ecx
call   1070 <sprintf@plt>
mov    %rbx,%rdi
call   1030 <superlu_abort_and_exit@plt>
mov    0x170(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x10(%rsp)
cmpl   $0x0,0x28(%rsp)
jle    1691 <getata+0x541>
mov    (%r14),%r14
lea    0x0(,%rbp,4),%rdx
mov    %r12,%rdi
mov    $0xff,%esi
call   1040 <memset@plt>
xor    %r8d,%r8d
xor    %eax,%eax
mov    0x20(%rsp),%r11
jmp    15fb <getata+0x4ab>
nopl   0x0(%rax,%rax,1)
cmp    0x18(%rsp),%r8
je     1693 <getata+0x543>
mov    %r8,%rdx
mov    0x10(%rsp),%rcx
mov    %eax,(%rcx,%r8,4)
mov    %edx,(%r12,%r8,4)
mov    0x8(%rsp),%rcx
movslq (%rcx,%r8,4),%r10
add    $0x1,%r8
mov    0x4(%rcx,%rdx,4),%r9d
cmp    %r9d,%r10d
jl     1645 <getata+0x4f5>
jmp    15f0 <getata+0x4a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%rcx
mov    (%rcx,%r8,4),%r9d
add    $0x1,%r10
movslq %r9d,%rcx
cmp    %rcx,%r10
jge    15f0 <getata+0x4a0>
movslq (%r11,%r10,4),%rdi
movslq 0x0(%r13,%rdi,4),%rcx
mov    0x4(%r13,%rdi,4),%ebp
cmp    %ebp,%ecx
jl     166c <getata+0x51c>
jmp    1639 <getata+0x4e9>
nopl   0x0(%rax)
add    $0x1,%rcx
movslq %ebp,%rsi
cmp    %rsi,%rcx
jge    1630 <getata+0x4e0>
mov    (%r15,%rcx,4),%ebx
movslq %ebx,%rbx
mov    (%r12,%rbx,4),%esi
cmp    %rsi,%rdx
je     1660 <getata+0x510>
mov    %edx,(%r12,%rbx,4)
movslq %eax,%rsi
add    $0x1,%eax
mov    %ebx,(%r14,%rsi,4)
mov    0x4(%r13,%rdi,4),%ebp
jmp    1660 <getata+0x510>
xor    %eax,%eax
movslq 0x28(%rsp),%rcx
mov    0x10(%rsp),%rdx
mov    %eax,(%rdx,%rcx,4)
mov    %r12,%rdi
call   1060 <superlu_free@plt>
mov    %r13,%rdi
call   1060 <superlu_free@plt>
mov    %r15,%rdi
call   1060 <superlu_free@plt>
add    $0x138,%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 = [34 x i8] c"SUPERLU_MALLOC fails for marker[]\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 = [26 x i8] c"SUPERLU_MALLOC t_colptr[]\00"
@.str.4 = [36 x i8] c"SUPERLU_MALLOC fails for t_rowind[]\00"
@.str.5 = [38 x i8] c"SUPERLU_MALLOC fails for ata_colptr[]\00"
@.str.6 = [38 x i8] c"SUPERLU_MALLOC fails for ata_rowind[]\00"
define void @getata(i32 %0, i32 %1, i32 %2, i32* %3, i32* %4, i32* %5, i32** %6, i32** %7) {
%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 i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca i32*
%27 = alloca i32*
%28 = alloca i32*
%29 = alloca [256 x i8]
%30 = alloca [256 x i8]
%31 = alloca [256 x i8]
%32 = alloca [256 x i8]
%33 = alloca [256 x i8]
store i32 %0, i32* %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store i32* %3, i32** %12
store i32* %4, i32** %13
store i32* %5, i32** %14
store i32** %6, i32*** %15
store i32** %7, i32*** %16
%34 = load i32, i32* %9
%35 = load i32, i32* %10
%36 = icmp sgt i32 %34, %35
br i1 %36, label %37, label %39
37: ; preds = %8
%38 = load i32, i32* %9
br label %41
39: ; preds = %8
%40 = load i32, i32* %10
br label %41
41: ; preds = %39, %37
%42 = phi i32 [ %38, %37 ], [ %40, %39 ]
%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** %24
%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]* %29, 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 ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), i32 88, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%53 = getelementptr inbounds [256 x i8], [256 x i8]* %29, i64 0, i64 0
%54 = call i32 @superlu_abort_and_exit(i8* %53)
br label %55
55: ; preds = %50, %41
%56 = load i32, i32* %9
%57 = add nsw i32 %56, 1
%58 = sext i32 %57 to i64
%59 = mul i64 %58, 4
%60 = trunc i64 %59 to i32
%61 = call i64 @superlu_malloc(i32 %60)
%62 = inttoptr i64 %61 to i32*
store i32* %62, i32** %27
%63 = icmp ne i32* %62, null
br i1 %63, label %69, label %64
64: ; preds = %55
%65 = getelementptr inbounds [256 x i8], [256 x i8]* %30, i64 0, i64 0
%66 = call i32 @sprintf(i8* %65, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.3, i64 0, i64 0), i32 90, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%67 = getelementptr inbounds [256 x i8], [256 x i8]* %30, i64 0, i64 0
%68 = call i32 @superlu_abort_and_exit(i8* %67)
br label %69
69: ; preds = %64, %55
%70 = load i32, i32* %11
%71 = sext i32 %70 to i64
%72 = mul i64 %71, 4
%73 = trunc i64 %72 to i32
%74 = call i64 @superlu_malloc(i32 %73)
%75 = inttoptr i64 %74 to i32*
store i32* %75, i32** %28
%76 = icmp ne i32* %75, null
br i1 %76, label %82, label %77
77: ; preds = %69
%78 = getelementptr inbounds [256 x i8], [256 x i8]* %31, i64 0, i64 0
%79 = call i32 @sprintf(i8* %78, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.4, i64 0, i64 0), i32 92, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%80 = getelementptr inbounds [256 x i8], [256 x i8]* %31, i64 0, i64 0
%81 = call i32 @superlu_abort_and_exit(i8* %80)
br label %82
82: ; preds = %77, %69
store i32 0, i32* %17
br label %83
83: ; preds = %92, %82
%84 = load i32, i32* %17
%85 = load i32, i32* %9
%86 = icmp slt i32 %84, %85
br i1 %86, label %87, label %95
87: ; preds = %83
%88 = load i32*, i32** %24
%89 = load i32, i32* %17
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i32, i32* %88, i64 %90
store i32 0, i32* %91
br label %92
92: ; preds = %87
%93 = load i32, i32* %17
%94 = add nsw i32 %93, 1
store i32 %94, i32* %17
br label %83
95: ; preds = %83
store i32 0, i32* %18
br label %96
96: ; preds = %130, %95
%97 = load i32, i32* %18
%98 = load i32, i32* %10
%99 = icmp slt i32 %97, %98
br i1 %99, label %100, label %133
100: ; preds = %96
%101 = load i32*, i32** %12
%102 = load i32, i32* %18
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i32, i32* %101, i64 %103
%105 = load i32, i32* %104
store i32 %105, i32* %17
br label %106
106: ; preds = %126, %100
%107 = load i32, i32* %17
%108 = load i32*, i32** %12
%109 = load i32, i32* %18
%110 = add nsw i32 %109, 1
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i32, i32* %108, i64 %111
%113 = load i32, i32* %112
%114 = icmp slt i32 %107, %113
br i1 %114, label %115, label %129
115: ; preds = %106
%116 = load i32*, i32** %24
%117 = load i32*, i32** %13
%118 = load i32, i32* %17
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i32, i32* %117, i64 %119
%121 = load i32, i32* %120
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %116, i64 %122
%124 = load i32, i32* %123
%125 = add nsw i32 %124, 1
store i32 %125, i32* %123
br label %126
126: ; preds = %115
%127 = load i32, i32* %17
%128 = add nsw i32 %127, 1
store i32 %128, i32* %17
br label %106
129: ; preds = %106
br label %130
130: ; preds = %129
%131 = load i32, i32* %18
%132 = add nsw i32 %131, 1
store i32 %132, i32* %18
br label %96
133: ; preds = %96
%134 = load i32*, i32** %27
%135 = getelementptr inbounds i32, i32* %134, i64 0
store i32 0, i32* %135
store i32 0, i32* %17
br label %136
136: ; preds = %166, %133
%137 = load i32, i32* %17
%138 = load i32, i32* %9
%139 = icmp slt i32 %137, %138
br i1 %139, label %140, label %169
140: ; preds = %136
%141 = load i32*, i32** %27
%142 = load i32, i32* %17
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i32, i32* %141, i64 %143
%145 = load i32, i32* %144
%146 = load i32*, i32** %24
%147 = load i32, i32* %17
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %146, i64 %148
%150 = load i32, i32* %149
%151 = add nsw i32 %145, %150
%152 = load i32*, i32** %27
%153 = load i32, i32* %17
%154 = add nsw i32 %153, 1
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %152, i64 %155
store i32 %151, i32* %156
%157 = load i32*, i32** %27
%158 = load i32, i32* %17
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i32, i32* %157, i64 %159
%161 = load i32, i32* %160
%162 = load i32*, i32** %24
%163 = load i32, i32* %17
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i32, i32* %162, i64 %164
store i32 %161, i32* %165
br label %166
166: ; preds = %140
%167 = load i32, i32* %17
%168 = add nsw i32 %167, 1
store i32 %168, i32* %17
br label %136
169: ; preds = %136
store i32 0, i32* %18
br label %170
170: ; preds = %214, %169
%171 = load i32, i32* %18
%172 = load i32, i32* %10
%173 = icmp slt i32 %171, %172
br i1 %173, label %174, label %217
174: ; preds = %170
%175 = load i32*, i32** %12
%176 = load i32, i32* %18
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i32, i32* %175, i64 %177
%179 = load i32, i32* %178
store i32 %179, i32* %17
br label %180
180: ; preds = %210, %174
%181 = load i32, i32* %17
%182 = load i32*, i32** %12
%183 = load i32, i32* %18
%184 = add nsw i32 %183, 1
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i32, i32* %182, i64 %185
%187 = load i32, i32* %186
%188 = icmp slt i32 %181, %187
br i1 %188, label %189, label %213
189: ; preds = %180
%190 = load i32*, i32** %13
%191 = load i32, i32* %17
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i32, i32* %190, i64 %192
%194 = load i32, i32* %193
store i32 %194, i32* %20
%195 = load i32, i32* %18
%196 = load i32*, i32** %28
%197 = load i32*, i32** %24
%198 = load i32, i32* %20
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i32, i32* %197, i64 %199
%201 = load i32, i32* %200
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds i32, i32* %196, i64 %202
store i32 %195, i32* %203
%204 = load i32*, i32** %24
%205 = load i32, i32* %20
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %204, i64 %206
%208 = load i32, i32* %207
%209 = add nsw i32 %208, 1
store i32 %209, i32* %207
br label %210
210: ; preds = %189
%211 = load i32, i32* %17
%212 = add nsw i32 %211, 1
store i32 %212, i32* %17
br label %180
213: ; preds = %180
br label %214
214: ; preds = %213
%215 = load i32, i32* %18
%216 = add nsw i32 %215, 1
store i32 %216, i32* %18
br label %170
217: ; preds = %170
store i32 0, i32* %17
br label %218
218: ; preds = %227, %217
%219 = load i32, i32* %17
%220 = load i32, i32* %10
%221 = icmp slt i32 %219, %220
br i1 %221, label %222, label %230
222: ; preds = %218
%223 = load i32*, i32** %24
%224 = load i32, i32* %17
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds i32, i32* %223, i64 %225
store i32 -1, i32* %226
br label %227
227: ; preds = %222
%228 = load i32, i32* %17
%229 = add nsw i32 %228, 1
store i32 %229, i32* %17
br label %218
230: ; preds = %218
store i32 0, i32* %21
store i32 0, i32* %18
br label %231
231: ; preds = %305, %230
%232 = load i32, i32* %18
%233 = load i32, i32* %10
%234 = icmp slt i32 %232, %233
br i1 %234, label %235, label %308
235: ; preds = %231
%236 = load i32, i32* %18
%237 = load i32*, i32** %24
%238 = load i32, i32* %18
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i32, i32* %237, i64 %239
store i32 %236, i32* %240
%241 = load i32*, i32** %12
%242 = load i32, i32* %18
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i32, i32* %241, i64 %243
%245 = load i32, i32* %244
store i32 %245, i32* %17
br label %246
246: ; preds = %301, %235
%247 = load i32, i32* %17
%248 = load i32*, i32** %12
%249 = load i32, i32* %18
%250 = add nsw i32 %249, 1
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i32, i32* %248, i64 %251
%253 = load i32, i32* %252
%254 = icmp slt i32 %247, %253
br i1 %254, label %255, label %304
255: ; preds = %246
%256 = load i32*, i32** %13
%257 = load i32, i32* %17
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i32, i32* %256, i64 %258
%260 = load i32, i32* %259
store i32 %260, i32* %19
%261 = load i32*, i32** %27
%262 = load i32, i32* %19
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i32, i32* %261, i64 %263
%265 = load i32, i32* %264
store i32 %265, i32* %22
br label %266
266: ; preds = %297, %255
%267 = load i32, i32* %22
%268 = load i32*, i32** %27
%269 = load i32, i32* %19
%270 = add nsw i32 %269, 1
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i32, i32* %268, i64 %271
%273 = load i32, i32* %272
%274 = icmp slt i32 %267, %273
br i1 %274, label %275, label %300
275: ; preds = %266
%276 = load i32*, i32** %28
%277 = load i32, i32* %22
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds i32, i32* %276, i64 %278
%280 = load i32, i32* %279
store i32 %280, i32* %23
%281 = load i32*, i32** %24
%282 = load i32, i32* %23
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds i32, i32* %281, i64 %283
%285 = load i32, i32* %284
%286 = load i32, i32* %18
%287 = icmp ne i32 %285, %286
br i1 %287, label %288, label %296
288: ; preds = %275
%289 = load i32, i32* %18
%290 = load i32*, i32** %24
%291 = load i32, i32* %23
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i32, i32* %290, i64 %292
store i32 %289, i32* %293
%294 = load i32, i32* %21
%295 = add nsw i32 %294, 1
store i32 %295, i32* %21
br label %296
296: ; preds = %288, %275
br label %297
297: ; preds = %296
%298 = load i32, i32* %22
%299 = add nsw i32 %298, 1
store i32 %299, i32* %22
br label %266
300: ; preds = %266
br label %301
301: ; preds = %300
%302 = load i32, i32* %17
%303 = add nsw i32 %302, 1
store i32 %303, i32* %17
br label %246
304: ; preds = %246
br label %305
305: ; preds = %304
%306 = load i32, i32* %18
%307 = add nsw i32 %306, 1
store i32 %307, i32* %18
br label %231
308: ; preds = %231
%309 = load i32, i32* %21
%310 = load i32*, i32** %14
store i32 %309, i32* %310
%311 = load i32, i32* %10
%312 = add nsw i32 %311, 1
%313 = sext i32 %312 to i64
%314 = mul i64 %313, 4
%315 = trunc i64 %314 to i32
%316 = call i64 @superlu_malloc(i32 %315)
%317 = inttoptr i64 %316 to i32*
%318 = load i32**, i32*** %15
store i32* %317, i32** %318
%319 = icmp ne i32* %317, null
br i1 %319, label %325, label %320
320: ; preds = %308
%321 = getelementptr inbounds [256 x i8], [256 x i8]* %32, i64 0, i64 0
%322 = call i32 @sprintf(i8* %321, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.5, i64 0, i64 0), i32 154, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%323 = getelementptr inbounds [256 x i8], [256 x i8]* %32, i64 0, i64 0
%324 = call i32 @superlu_abort_and_exit(i8* %323)
br label %325
325: ; preds = %320, %308
%326 = load i32*, i32** %14
%327 = load i32, i32* %326
%328 = icmp ne i32 %327, 0
br i1 %328, label %329, label %345
329: ; preds = %325
%330 = load i32*, i32** %14
%331 = load i32, i32* %330
%332 = sext i32 %331 to i64
%333 = mul i64 %332, 4
%334 = trunc i64 %333 to i32
%335 = call i64 @superlu_malloc(i32 %334)
%336 = inttoptr i64 %335 to i32*
%337 = load i32**, i32*** %16
store i32* %336, i32** %337
%338 = icmp ne i32* %336, null
br i1 %338, label %344, label %339
339: ; preds = %329
%340 = getelementptr inbounds [256 x i8], [256 x i8]* %33, i64 0, i64 0
%341 = call i32 @sprintf(i8* %340, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.6, i64 0, i64 0), i32 157, i8* getelementptr inbounds ([163 x i8], [163 x i8]* @.str.2, i64 0, i64 0))
%342 = getelementptr inbounds [256 x i8], [256 x i8]* %33, i64 0, i64 0
%343 = call i32 @superlu_abort_and_exit(i8* %342)
br label %344
344: ; preds = %339, %329
br label %345
345: ; preds = %344, %325
%346 = load i32**, i32*** %15
%347 = load i32*, i32** %346
store i32* %347, i32** %25
%348 = load i32**, i32*** %16
%349 = load i32*, i32** %348
store i32* %349, i32** %26
store i32 0, i32* %17
br label %350
350: ; preds = %359, %345
%351 = load i32, i32* %17
%352 = load i32, i32* %10
%353 = icmp slt i32 %351, %352
br i1 %353, label %354, label %362
354: ; preds = %350
%355 = load i32*, i32** %24
%356 = load i32, i32* %17
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds i32, i32* %355, i64 %357
store i32 -1, i32* %358
br label %359
359: ; preds = %354
%360 = load i32, i32* %17
%361 = add nsw i32 %360, 1
store i32 %361, i32* %17
br label %350
362: ; preds = %350
store i32 0, i32* %21
store i32 0, i32* %18
br label %363
363: ; preds = %446, %362
%364 = load i32, i32* %18
%365 = load i32, i32* %10
%366 = icmp slt i32 %364, %365
br i1 %366, label %367, label %449
367: ; preds = %363
%368 = load i32, i32* %21
%369 = load i32*, i32** %25
%370 = load i32, i32* %18
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds i32, i32* %369, i64 %371
store i32 %368, i32* %372
%373 = load i32, i32* %18
%374 = load i32*, i32** %24
%375 = load i32, i32* %18
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds i32, i32* %374, i64 %376
store i32 %373, i32* %377
%378 = load i32*, i32** %12
%379 = load i32, i32* %18
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds i32, i32* %378, i64 %380
%382 = load i32, i32* %381
store i32 %382, i32* %17
br label %383
383: ; preds = %442, %367
%384 = load i32, i32* %17
%385 = load i32*, i32** %12
%386 = load i32, i32* %18
%387 = add nsw i32 %386, 1
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds i32, i32* %385, i64 %388
%390 = load i32, i32* %389
%391 = icmp slt i32 %384, %390
br i1 %391, label %392, label %445
392: ; preds = %383
%393 = load i32*, i32** %13
%394 = load i32, i32* %17
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i32, i32* %393, i64 %395
%397 = load i32, i32* %396
store i32 %397, i32* %19
%398 = load i32*, i32** %27
%399 = load i32, i32* %19
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds i32, i32* %398, i64 %400
%402 = load i32, i32* %401
store i32 %402, i32* %22
br label %403
403: ; preds = %438, %392
%404 = load i32, i32* %22
%405 = load i32*, i32** %27
%406 = load i32, i32* %19
%407 = add nsw i32 %406, 1
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i32, i32* %405, i64 %408
%410 = load i32, i32* %409
%411 = icmp slt i32 %404, %410
br i1 %411, label %412, label %441
412: ; preds = %403
%413 = load i32*, i32** %28
%414 = load i32, i32* %22
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds i32, i32* %413, i64 %415
%417 = load i32, i32* %416
store i32 %417, i32* %23
%418 = load i32*, i32** %24
%419 = load i32, i32* %23
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds i32, i32* %418, i64 %420
%422 = load i32, i32* %421
%423 = load i32, i32* %18
%424 = icmp ne i32 %422, %423
br i1 %424, label %425, label %437
425: ; preds = %412
%426 = load i32, i32* %18
%427 = load i32*, i32** %24
%428 = load i32, i32* %23
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds i32, i32* %427, i64 %429
store i32 %426, i32* %430
%431 = load i32, i32* %23
%432 = load i32*, i32** %26
%433 = load i32, i32* %21
%434 = add nsw i32 %433, 1
store i32 %434, i32* %21
%435 = sext i32 %433 to i64
%436 = getelementptr inbounds i32, i32* %432, i64 %435
store i32 %431, i32* %436
br label %437
437: ; preds = %425, %412
br label %438
438: ; preds = %437
%439 = load i32, i32* %22
%440 = add nsw i32 %439, 1
store i32 %440, i32* %22
br label %403
441: ; preds = %403
br label %442
442: ; preds = %441
%443 = load i32, i32* %17
%444 = add nsw i32 %443, 1
store i32 %444, i32* %17
br label %383
445: ; preds = %383
br label %446
446: ; preds = %445
%447 = load i32, i32* %18
%448 = add nsw i32 %447, 1
store i32 %448, i32* %18
br label %363
449: ; preds = %363
%450 = load i32, i32* %21
%451 = load i32*, i32** %25
%452 = load i32, i32* %10
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds i32, i32* %451, i64 %453
store i32 %450, i32* %454
%455 = load i32*, i32** %24
%456 = call i32 @superlu_free(i32* %455)
%457 = load i32*, i32** %27
%458 = call i32 @superlu_free(i32* %457)
%459 = load i32*, i32** %28
%460 = call i32 @superlu_free(i32* %459)
ret void
}

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