#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*/ WriteSLUErrorMessage(char *);
int /*<<< orphan*/ sprintf_s(char *, int, char *, char *);
int /*<<< orphan*/ superlu_abort_and_exit(char *);
int /*<<< orphan*/ superlu_free(int *);
scalar_t__ superlu_malloc(int const);
void at_plus_a(const int n, const int nz, int *colptr, int *rowind, int *bnz,
               int **b_colptr, int **b_rowind) {
  register int i, j, k, col, num_nz;
  int *t_colptr, *t_rowind;
  int *marker;
  if (!(marker = (int *)superlu_malloc(n * sizeof(int)))) {
    char msg[256];
    sprintf_s(msg, 256, "Error: %s", "SUPERLU_MALLOC fails for marker[]");
    WriteSLUErrorMessage(msg);
    superlu_abort_and_exit(msg);
  };
  if (!(t_colptr = (int *)superlu_malloc((n + 1) * sizeof(int)))) {
    char msg[256];
    sprintf_s(msg, 256, "Error: %s", "SUPERLU_MALLOC fails for t_colptr[]");
    WriteSLUErrorMessage(msg);
    superlu_abort_and_exit(msg);
  };
  if (!(t_rowind = (int *)superlu_malloc(nz * sizeof(int)))) {
    char msg[256];
    sprintf_s(msg, 256, "Error: %s", "SUPERLU_MALLOC fails t_rowind[]");
    WriteSLUErrorMessage(msg);
    superlu_abort_and_exit(msg);
  };
  for (i = 0; i < n; ++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 < n; ++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];
      if (marker[k] != j) {
        marker[k] = j;
        ++num_nz;
      }
    }
    for (i = t_colptr[j]; i < t_colptr[j + 1]; ++i) {
      k = t_rowind[i];
      if (marker[k] != j) {
        marker[k] = j;
        ++num_nz;
      }
    }
  }
  *bnz = num_nz;
  if (!(*b_colptr = (int *)superlu_malloc((n + 1) * sizeof(int)))) {
    char msg[256];
    sprintf_s(msg, 256, "Error: %s", "SUPERLU_MALLOC fails for b_colptr[]");
    WriteSLUErrorMessage(msg);
    superlu_abort_and_exit(msg);
  };
  if (*bnz) {
    if (!(*b_rowind = (int *)superlu_malloc(*bnz * sizeof(int)))) {
      char msg[256];
      sprintf_s(msg, 256, "Error: %s", "SUPERLU_MALLOC fails for b_rowind[]");
      WriteSLUErrorMessage(msg);
      superlu_abort_and_exit(msg);
    };
  }
  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];
      if (marker[k] != j) {
        marker[k] = j;
        (*b_rowind)[num_nz++] = k;
      }
    }
    for (i = t_colptr[j]; i < t_colptr[j + 1]; ++i) {
      k = t_rowind[i];
      if (marker[k] != j) {
        marker[k] = j;
        (*b_rowind)[num_nz++] = k;
      }
    }
  }
  (*b_colptr)[n] = num_nz;
  superlu_free(marker);
  superlu_free(t_colptr);
  superlu_free(t_rowind);
}


x86 assembly (clang, -O0):
<at_plus_a>:
push   %rbp
mov    %rsp,%rbp
sub    $0x560,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <superlu_malloc@plt>
mov    %rax,-0x58(%rbp)
cmp    $0x0,%rax
jne    11c9 <at_plus_a+0x79>
lea    -0x160(%rbp),%rdi
mov    $0x100,%esi
lea    0xe5b(%rip),%rdx
lea    0xe5e(%rip),%rcx
call   1030 <sprintf_s@plt>
lea    -0x160(%rbp),%rdi
call   1050 <WriteSLUErrorMessage@plt>
lea    -0x160(%rbp),%rdi
call   1040 <superlu_abort_and_exit@plt>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <superlu_malloc@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
jne    1221 <at_plus_a+0xd1>
lea    -0x260(%rbp),%rdi
mov    $0x100,%esi
lea    0xe03(%rip),%rdx
lea    0xe28(%rip),%rcx
call   1030 <sprintf_s@plt>
lea    -0x260(%rbp),%rdi
call   1050 <WriteSLUErrorMessage@plt>
lea    -0x260(%rbp),%rdi
call   1040 <superlu_abort_and_exit@plt>
movslq -0x8(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <superlu_malloc@plt>
mov    %rax,-0x50(%rbp)
cmp    $0x0,%rax
jne    1275 <at_plus_a+0x125>
lea    -0x360(%rbp),%rdi
mov    $0x100,%esi
lea    0xdaf(%rip),%rdx
lea    0xdf8(%rip),%rcx
call   1030 <sprintf_s@plt>
lea    -0x360(%rbp),%rdi
call   1050 <WriteSLUErrorMessage@plt>
lea    -0x360(%rbp),%rdi
call   1040 <superlu_abort_and_exit@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12a5 <at_plus_a+0x155>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    127c <at_plus_a+0x12c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1319 <at_plus_a+0x1c9>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1306 <at_plus_a+0x1b6>
mov    -0x58(%rbp),%rax
mov    -0x18(%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    12c6 <at_plus_a+0x176>
jmp    130b <at_plus_a+0x1bb>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12ac <at_plus_a+0x15c>
mov    -0x48(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1380 <at_plus_a+0x230>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    132a <at_plus_a+0x1da>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1410 <at_plus_a+0x2c0>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    13fd <at_plus_a+0x2ad>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%edx
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x38(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%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    13a1 <at_plus_a+0x251>
jmp    1402 <at_plus_a+0x2b2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1387 <at_plus_a+0x237>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1440 <at_plus_a+0x2f0>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1417 <at_plus_a+0x2c7>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1561 <at_plus_a+0x411>
mov    -0x30(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    14db <at_plus_a+0x38b>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
je     14c8 <at_plus_a+0x378>
mov    -0x30(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14cd <at_plus_a+0x37d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1476 <at_plus_a+0x326>
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x48(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    154e <at_plus_a+0x3fe>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
je     153b <at_plus_a+0x3eb>
mov    -0x30(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1540 <at_plus_a+0x3f0>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14e9 <at_plus_a+0x399>
jmp    1553 <at_plus_a+0x403>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    144e <at_plus_a+0x2fe>
mov    -0x3c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <superlu_malloc@plt>
mov    -0x28(%rbp),%rcx
mov    %rax,(%rcx)
cmp    $0x0,%rax
jne    15c5 <at_plus_a+0x475>
lea    -0x460(%rbp),%rdi
mov    $0x100,%esi
lea    0xa5f(%rip),%rdx
lea    0xac8(%rip),%rcx
call   1030 <sprintf_s@plt>
lea    -0x460(%rbp),%rdi
call   1050 <WriteSLUErrorMessage@plt>
lea    -0x460(%rbp),%rdi
call   1040 <superlu_abort_and_exit@plt>
mov    -0x20(%rbp),%rax
cmpl   $0x0,(%rax)
je     1631 <at_plus_a+0x4e1>
mov    -0x20(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <superlu_malloc@plt>
mov    0x10(%rbp),%rcx
mov    %rax,(%rcx)
cmp    $0x0,%rax
jne    162c <at_plus_a+0x4dc>
lea    -0x560(%rbp),%rdi
mov    $0x100,%esi
lea    0x9f8(%rip),%rdx
lea    0xa85(%rip),%rcx
call   1030 <sprintf_s@plt>
lea    -0x560(%rbp),%rdi
call   1050 <WriteSLUErrorMessage@plt>
lea    -0x560(%rbp),%rdi
call   1040 <superlu_abort_and_exit@plt>
jmp    1631 <at_plus_a+0x4e1>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1661 <at_plus_a+0x511>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1638 <at_plus_a+0x4e8>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17b7 <at_plus_a+0x667>
mov    -0x3c(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    171f <at_plus_a+0x5cf>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
je     170c <at_plus_a+0x5bc>
mov    -0x30(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1711 <at_plus_a+0x5c1>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16a8 <at_plus_a+0x558>
mov    -0x48(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x48(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    17a4 <at_plus_a+0x654>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
je     1791 <at_plus_a+0x641>
mov    -0x30(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1796 <at_plus_a+0x646>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    172d <at_plus_a+0x5dd>
jmp    17a9 <at_plus_a+0x659>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    166f <at_plus_a+0x51f>
mov    -0x3c(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%rdi
call   1070 <superlu_free@plt>
mov    -0x48(%rbp),%rdi
call   1070 <superlu_free@plt>
mov    -0x50(%rbp),%rdi
call   1070 <superlu_free@plt>
add    $0x560,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<at_plus_a>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r9,0x38(%rsp)
mov    %r8,0x30(%rsp)
mov    %rcx,%r15
mov    %rdx,%r12
mov    %esi,%ebp
mov    %rdi,%r14
lea    0x0(,%rdi,4),%ebx
mov    %ebx,%edi
call   1070 <superlu_malloc@plt>
mov    %rax,%r13
test   %rax,%rax
jne    11d4 <at_plus_a+0x74>
lea    0xe5d(%rip),%rdx
lea    0xe60(%rip),%rcx
mov    %ebx,0xc(%rsp)
lea    0x40(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x100,%esi
call   1030 <sprintf_s@plt>
mov    %rbx,%rdi
call   1060 <WriteSLUErrorMessage@plt>
mov    %rbx,%rdi
mov    0xc(%rsp),%ebx
call   1040 <superlu_abort_and_exit@plt>
add    $0x4,%ebx
mov    %ebx,0xc(%rsp)
mov    %ebx,%edi
call   1070 <superlu_malloc@plt>
mov    %rax,0x18(%rsp)
test   %rax,%rax
jne    121c <at_plus_a+0xbc>
lea    0xe0d(%rip),%rdx
lea    0xe32(%rip),%rcx
lea    0x40(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x100,%esi
call   1030 <sprintf_s@plt>
mov    %rbx,%rdi
call   1060 <WriteSLUErrorMessage@plt>
mov    %rbx,%rdi
call   1040 <superlu_abort_and_exit@plt>
shl    $0x2,%ebp
mov    %ebp,%edi
call   1070 <superlu_malloc@plt>
mov    %rax,0x20(%rsp)
test   %rax,%rax
mov    %r14,%rbx
jne    1263 <at_plus_a+0x103>
lea    0xdc6(%rip),%rdx
lea    0xe0f(%rip),%rcx
lea    0x40(%rsp),%r14
mov    %r14,%rdi
mov    $0x100,%esi
call   1030 <sprintf_s@plt>
mov    %r14,%rdi
call   1060 <WriteSLUErrorMessage@plt>
mov    %r14,%rdi
call   1040 <superlu_abort_and_exit@plt>
mov    %ebx,%r14d
test   %ebx,%ebx
mov    %rbx,0x10(%rsp)
jle    13b5 <at_plus_a+0x255>
lea    0x0(,%r14,4),%rdx
xor    %ebp,%ebp
mov    %r13,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
mov    (%r12),%eax
mov    0x18(%rsp),%r11
jmp    12a7 <at_plus_a+0x147>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ecx,%eax
cmp    %r14,%rbp
je     12d9 <at_plus_a+0x179>
mov    0x4(%r12,%rbp,4),%ecx
add    $0x1,%rbp
cmp    %ecx,%eax
jge    12a0 <at_plus_a+0x140>
cltq
cs nopw 0x0(%rax,%rax,1)
movslq (%r15,%rax,4),%rcx
addl   $0x1,0x0(%r13,%rcx,4)
add    $0x1,%rax
movslq (%r12,%rbp,4),%rcx
cmp    %rcx,%rax
jl     12c0 <at_plus_a+0x160>
jmp    12a0 <at_plus_a+0x140>
xor    %r10d,%r10d
movl   $0x0,(%r11)
test   %ebx,%ebx
jle    1559 <at_plus_a+0x3f9>
mov    0x0(%r13),%ecx
mov    %ecx,0x4(%r11)
movl   $0x0,0x0(%r13)
cmp    $0x1,%ebx
mov    0x20(%rsp),%rbx
je     1438 <at_plus_a+0x2d8>
lea    0x4(%r11),%rdx
lea    0x0(,%r14,4),%rsi
add    %r13,%rsi
mov    %r13,%rcx
add    $0x4,%rcx
cmp    %rsi,%rdx
jae    13c8 <at_plus_a+0x268>
lea    (%r11,%r14,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rcx
jae    13c8 <at_plus_a+0x268>
lea    -0x1(%r14),%r8
mov    $0x1,%edi
cmpl   $0x2,0x10(%rsp)
je     1393 <at_plus_a+0x233>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
neg    %r9
mov    $0x1,%edi
nopl   0x0(%rax,%rax,1)
mov    (%rdx),%ebp
mov    -0x4(%rcx,%rdi,4),%esi
add    %ebp,%esi
mov    %esi,0x4(%rdx)
mov    %ebp,-0x4(%rcx,%rdi,4)
mov    0x4(%rdx),%esi
mov    (%rcx,%rdi,4),%ebp
add    %esi,%ebp
mov    %ebp,0x8(%rdx)
mov    %esi,(%rcx,%rdi,4)
lea    (%r9,%rdi,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdi
add    $0x8,%rdx
cmp    $0x1,%rsi
jne    1360 <at_plus_a+0x200>
test   $0x1,%r8b
je     1438 <at_plus_a+0x2d8>
mov    (%rdx),%ecx
mov    0x0(%r13,%rdi,4),%edx
add    %ecx,%edx
mov    %edx,0x4(%r11,%rdi,4)
mov    %ecx,0x0(%r13,%rdi,4)
jmp    1438 <at_plus_a+0x2d8>
mov    0x18(%rsp),%rax
movl   $0x0,(%rax)
xor    %r10d,%r10d
jmp    1559 <at_plus_a+0x3f9>
mov    (%rdx),%edx
lea    -0x1(%r14),%r8
mov    $0x1,%esi
cmpl   $0x2,0x10(%rsp)
je     1421 <at_plus_a+0x2c1>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
neg    %r9
mov    $0x1,%ebp
nopl   0x0(%rax)
mov    -0x4(%rcx,%rbp,4),%edi
add    %edx,%edi
mov    %edi,0x4(%r11,%rbp,4)
mov    %edx,-0x4(%rcx,%rbp,4)
mov    (%rcx,%rbp,4),%edx
add    %edi,%edx
lea    0x2(%rbp),%rsi
mov    %edx,0x8(%r11,%rbp,4)
mov    %edi,(%rcx,%rbp,4)
lea    (%r9,%rbp,1),%rdi
add    $0x2,%rdi
mov    %rsi,%rbp
cmp    $0x1,%rdi
jne    13f0 <at_plus_a+0x290>
test   $0x1,%r8b
je     1438 <at_plus_a+0x2d8>
mov    0x0(%r13,%rsi,4),%ecx
add    %edx,%ecx
mov    %ecx,0x4(%r11,%rsi,4)
mov    %edx,0x0(%r13,%rsi,4)
cmpl   $0x0,0x10(%rsp)
jle    1559 <at_plus_a+0x3f9>
mov    (%r12),%edx
xor    %eax,%eax
jmp    1457 <at_plus_a+0x2f7>
nopl   0x0(%rax,%rax,1)
mov    %esi,%edx
cmp    %r14,%rax
je     1491 <at_plus_a+0x331>
mov    %rax,%rcx
add    $0x1,%rax
mov    0x4(%r12,%rcx,4),%esi
cmp    %esi,%edx
jge    1450 <at_plus_a+0x2f0>
movslq %edx,%rdx
nopw   0x0(%rax,%rax,1)
movslq (%r15,%rdx,4),%rsi
movslq 0x0(%r13,%rsi,4),%rdi
mov    %ecx,(%rbx,%rdi,4)
addl   $0x1,0x0(%r13,%rsi,4)
add    $0x1,%rdx
movslq (%r12,%rax,4),%rsi
cmp    %rsi,%rdx
jl     1470 <at_plus_a+0x310>
jmp    1450 <at_plus_a+0x2f0>
cmpl   $0x0,0x10(%rsp)
jle    13c0 <at_plus_a+0x260>
lea    0x0(,%r14,4),%rdx
mov    %r13,%rdi
mov    $0xff,%esi
call   1050 <memset@plt>
mov    0x20(%rsp),%rbx
mov    0x18(%rsp),%r8
xor    %ecx,%ecx
xor    %r10d,%r10d
jmp    14d9 <at_plus_a+0x379>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r14,%rcx
je     1559 <at_plus_a+0x3f9>
mov    %rcx,%rdx
mov    %edx,0x0(%r13,%rcx,4)
movslq (%r12,%rcx,4),%rsi
add    $0x1,%rcx
mov    0x4(%r12,%rdx,4),%edi
cmp    %edi,%esi
jl     150c <at_plus_a+0x3ac>
movslq (%r8,%rdx,4),%rsi
mov    (%r8,%rcx,4),%edi
cmp    %edi,%esi
jl     153c <at_plus_a+0x3dc>
jmp    14d0 <at_plus_a+0x370>
add    $0x1,%rsi
movslq %edi,%rax
cmp    %rax,%rsi
jge    14f2 <at_plus_a+0x392>
movslq (%r15,%rsi,4),%rbp
mov    0x0(%r13,%rbp,4),%eax
cmp    %rax,%rdx
je     1500 <at_plus_a+0x3a0>
mov    %edx,0x0(%r13,%rbp,4)
add    $0x1,%r10d
mov    (%r12,%rcx,4),%edi
jmp    1500 <at_plus_a+0x3a0>
nopl   0x0(%rax)
add    $0x1,%rsi
movslq %edi,%rax
cmp    %rax,%rsi
jge    14d0 <at_plus_a+0x370>
movslq (%rbx,%rsi,4),%rbp
mov    0x0(%r13,%rbp,4),%eax
cmp    %rax,%rdx
je     1530 <at_plus_a+0x3d0>
mov    %edx,0x0(%r13,%rbp,4)
add    $0x1,%r10d
mov    (%r8,%rcx,4),%edi
jmp    1530 <at_plus_a+0x3d0>
mov    %r14,0x28(%rsp)
mov    0x30(%rsp),%rbp
mov    %r10d,0x0(%rbp)
mov    0xc(%rsp),%edi
call   1070 <superlu_malloc@plt>
mov    0x38(%rsp),%rbx
mov    %rax,(%rbx)
test   %rax,%rax
jne    15ad <at_plus_a+0x44d>
lea    0xa7c(%rip),%rdx
lea    0xae5(%rip),%rcx
lea    0x40(%rsp),%r14
mov    %r14,%rdi
mov    $0x100,%esi
call   1030 <sprintf_s@plt>
mov    %r14,%rdi
call   1060 <WriteSLUErrorMessage@plt>
mov    %r14,%rdi
call   1040 <superlu_abort_and_exit@plt>
mov    0x180(%rsp),%r14
mov    0x0(%rbp),%edi
test   %edi,%edi
je     15fc <at_plus_a+0x49c>
shl    $0x2,%edi
call   1070 <superlu_malloc@plt>
mov    %rax,(%r14)
test   %rax,%rax
jne    15fc <at_plus_a+0x49c>
lea    0xa2d(%rip),%rdx
lea    0xaba(%rip),%rcx
lea    0x40(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x100,%esi
call   1030 <sprintf_s@plt>
mov    %rbp,%rdi
call   1060 <WriteSLUErrorMessage@plt>
mov    %rbp,%rdi
call   1040 <superlu_abort_and_exit@plt>
mov    0x10(%rsp),%rax
test   %eax,%eax
jle    16ff <at_plus_a+0x59f>
mov    0x28(%rsp),%rax
lea    0x0(,%rax,4),%rdx
mov    %r13,%rdi
mov    $0xff,%esi
call   1050 <memset@plt>
mov    (%rbx),%r8
xor    %edx,%edx
xor    %ecx,%ecx
mov    0x18(%rsp),%r9
mov    0x20(%rsp),%r10
jmp    164b <at_plus_a+0x4eb>
cs nopw 0x0(%rax,%rax,1)
cmp    0x28(%rsp),%rdx
je     16f8 <at_plus_a+0x598>
mov    %rdx,%rsi
mov    %ecx,(%r8,%rdx,4)
mov    %esi,0x0(%r13,%rdx,4)
movslq (%r12,%rdx,4),%rdi
add    $0x1,%rdx
mov    0x4(%r12,%rsi,4),%ebp
cmp    %ebp,%edi
jl     168c <at_plus_a+0x52c>
movslq (%r9,%rsi,4),%rdi
mov    (%r9,%rdx,4),%ebp
cmp    %ebp,%edi
jl     16d0 <at_plus_a+0x570>
jmp    1640 <at_plus_a+0x4e0>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdi
movslq %ebp,%rax
cmp    %rax,%rdi
jge    1668 <at_plus_a+0x508>
mov    (%r15,%rdi,4),%eax
cltq
mov    0x0(%r13,%rax,4),%ebx
cmp    %rbx,%rsi
je     1680 <at_plus_a+0x520>
mov    %esi,0x0(%r13,%rax,4)
mov    (%r14),%rbp
movslq %ecx,%rbx
add    $0x1,%ecx
mov    %eax,0x0(%rbp,%rbx,4)
mov    (%r12,%rdx,4),%ebp
jmp    1680 <at_plus_a+0x520>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdi
movslq %ebp,%rax
cmp    %rax,%rdi
jge    1640 <at_plus_a+0x4e0>
mov    (%r10,%rdi,4),%eax
cltq
mov    0x0(%r13,%rax,4),%ebx
cmp    %rbx,%rsi
je     16c0 <at_plus_a+0x560>
mov    %esi,0x0(%r13,%rax,4)
mov    (%r14),%rbp
movslq %ecx,%rbx
add    $0x1,%ecx
mov    %eax,0x0(%rbp,%rbx,4)
mov    (%r9,%rdx,4),%ebp
jmp    16c0 <at_plus_a+0x560>
mov    0x10(%rsp),%rax
jmp    1704 <at_plus_a+0x5a4>
mov    (%rbx),%r8
xor    %ecx,%ecx
cltq
mov    %ecx,(%r8,%rax,4)
mov    %r13,%rdi
call   1080 <superlu_free@plt>
mov    0x18(%rsp),%rdi
call   1080 <superlu_free@plt>
mov    0x20(%rsp),%rdi
call   1080 <superlu_free@plt>
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [10 x i8] c"Error: %s\00"
@.str.1 = [34 x i8] c"SUPERLU_MALLOC fails for marker[]\00"
@.str.2 = [36 x i8] c"SUPERLU_MALLOC fails for t_colptr[]\00"
@.str.3 = [32 x i8] c"SUPERLU_MALLOC fails t_rowind[]\00"
@.str.4 = [36 x i8] c"SUPERLU_MALLOC fails for b_colptr[]\00"
@.str.5 = [36 x i8] c"SUPERLU_MALLOC fails for b_rowind[]\00"
define void @at_plus_a(i32 %0, i32 %1, i32* %2, i32* %3, i32* %4, i32** %5, i32** %6) {
%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 i32
%19 = alloca i32
%20 = alloca i32*
%21 = alloca i32*
%22 = alloca i32*
%23 = alloca [256 x i8]
%24 = alloca [256 x i8]
%25 = alloca [256 x i8]
%26 = alloca [256 x i8]
%27 = alloca [256 x i8]
store i32 %0, i32* %8
store i32 %1, i32* %9
store i32* %2, i32** %10
store i32* %3, i32** %11
store i32* %4, i32** %12
store i32** %5, i32*** %13
store i32** %6, i32*** %14
%28 = load i32, i32* %8
%29 = sext i32 %28 to i64
%30 = mul i64 %29, 4
%31 = trunc i64 %30 to i32
%32 = call i64 @superlu_malloc(i32 %31)
%33 = inttoptr i64 %32 to i32*
store i32* %33, i32** %22
%34 = icmp ne i32* %33, null
br i1 %34, label %42, label %35
35: ; preds = %7
%36 = getelementptr inbounds [256 x i8], [256 x i8]* %23, i64 0, i64 0
%37 = call i32 @sprintf_s(i8* %36, i32 256, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0))
%38 = getelementptr inbounds [256 x i8], [256 x i8]* %23, i64 0, i64 0
%39 = call i32 @WriteSLUErrorMessage(i8* %38)
%40 = getelementptr inbounds [256 x i8], [256 x i8]* %23, i64 0, i64 0
%41 = call i32 @superlu_abort_and_exit(i8* %40)
br label %42
42: ; preds = %35, %7
%43 = load i32, i32* %8
%44 = add nsw i32 %43, 1
%45 = sext i32 %44 to i64
%46 = mul i64 %45, 4
%47 = trunc i64 %46 to i32
%48 = call i64 @superlu_malloc(i32 %47)
%49 = inttoptr i64 %48 to i32*
store i32* %49, i32** %20
%50 = icmp ne i32* %49, null
br i1 %50, label %58, label %51
51: ; preds = %42
%52 = getelementptr inbounds [256 x i8], [256 x i8]* %24, i64 0, i64 0
%53 = call i32 @sprintf_s(i8* %52, i32 256, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0))
%54 = getelementptr inbounds [256 x i8], [256 x i8]* %24, i64 0, i64 0
%55 = call i32 @WriteSLUErrorMessage(i8* %54)
%56 = getelementptr inbounds [256 x i8], [256 x i8]* %24, i64 0, i64 0
%57 = call i32 @superlu_abort_and_exit(i8* %56)
br label %58
58: ; preds = %51, %42
%59 = load i32, i32* %9
%60 = sext i32 %59 to i64
%61 = mul i64 %60, 4
%62 = trunc i64 %61 to i32
%63 = call i64 @superlu_malloc(i32 %62)
%64 = inttoptr i64 %63 to i32*
store i32* %64, i32** %21
%65 = icmp ne i32* %64, null
br i1 %65, label %73, label %66
66: ; preds = %58
%67 = getelementptr inbounds [256 x i8], [256 x i8]* %25, i64 0, i64 0
%68 = call i32 @sprintf_s(i8* %67, i32 256, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.3, i64 0, i64 0))
%69 = getelementptr inbounds [256 x i8], [256 x i8]* %25, i64 0, i64 0
%70 = call i32 @WriteSLUErrorMessage(i8* %69)
%71 = getelementptr inbounds [256 x i8], [256 x i8]* %25, i64 0, i64 0
%72 = call i32 @superlu_abort_and_exit(i8* %71)
br label %73
73: ; preds = %66, %58
store i32 0, i32* %15
br label %74
74: ; preds = %83, %73
%75 = load i32, i32* %15
%76 = load i32, i32* %8
%77 = icmp slt i32 %75, %76
br i1 %77, label %78, label %86
78: ; preds = %74
%79 = load i32*, i32** %22
%80 = load i32, i32* %15
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32, i32* %79, i64 %81
store i32 0, i32* %82
br label %83
83: ; preds = %78
%84 = load i32, i32* %15
%85 = add nsw i32 %84, 1
store i32 %85, i32* %15
br label %74
86: ; preds = %74
store i32 0, i32* %16
br label %87
87: ; preds = %121, %86
%88 = load i32, i32* %16
%89 = load i32, i32* %8
%90 = icmp slt i32 %88, %89
br i1 %90, label %91, label %124
91: ; preds = %87
%92 = load i32*, i32** %10
%93 = load i32, i32* %16
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %92, i64 %94
%96 = load i32, i32* %95
store i32 %96, i32* %15
br label %97
97: ; preds = %117, %91
%98 = load i32, i32* %15
%99 = load i32*, i32** %10
%100 = load i32, i32* %16
%101 = add nsw i32 %100, 1
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i32, i32* %99, i64 %102
%104 = load i32, i32* %103
%105 = icmp slt i32 %98, %104
br i1 %105, label %106, label %120
106: ; preds = %97
%107 = load i32*, i32** %22
%108 = load i32*, i32** %11
%109 = load i32, i32* %15
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %108, i64 %110
%112 = load i32, i32* %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %107, i64 %113
%115 = load i32, i32* %114
%116 = add nsw i32 %115, 1
store i32 %116, i32* %114
br label %117
117: ; preds = %106
%118 = load i32, i32* %15
%119 = add nsw i32 %118, 1
store i32 %119, i32* %15
br label %97
120: ; preds = %97
br label %121
121: ; preds = %120
%122 = load i32, i32* %16
%123 = add nsw i32 %122, 1
store i32 %123, i32* %16
br label %87
124: ; preds = %87
%125 = load i32*, i32** %20
%126 = getelementptr inbounds i32, i32* %125, i64 0
store i32 0, i32* %126
store i32 0, i32* %15
br label %127
127: ; preds = %157, %124
%128 = load i32, i32* %15
%129 = load i32, i32* %8
%130 = icmp slt i32 %128, %129
br i1 %130, label %131, label %160
131: ; preds = %127
%132 = load i32*, i32** %20
%133 = load i32, i32* %15
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i32, i32* %132, i64 %134
%136 = load i32, i32* %135
%137 = load i32*, i32** %22
%138 = load i32, i32* %15
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i32, i32* %137, i64 %139
%141 = load i32, i32* %140
%142 = add nsw i32 %136, %141
%143 = load i32*, i32** %20
%144 = load i32, i32* %15
%145 = add nsw i32 %144, 1
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i32, i32* %143, i64 %146
store i32 %142, i32* %147
%148 = load i32*, i32** %20
%149 = load i32, i32* %15
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %148, i64 %150
%152 = load i32, i32* %151
%153 = load i32*, i32** %22
%154 = load i32, i32* %15
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %153, i64 %155
store i32 %152, i32* %156
br label %157
157: ; preds = %131
%158 = load i32, i32* %15
%159 = add nsw i32 %158, 1
store i32 %159, i32* %15
br label %127
160: ; preds = %127
store i32 0, i32* %16
br label %161
161: ; preds = %205, %160
%162 = load i32, i32* %16
%163 = load i32, i32* %8
%164 = icmp slt i32 %162, %163
br i1 %164, label %165, label %208
165: ; preds = %161
%166 = load i32*, i32** %10
%167 = load i32, i32* %16
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds i32, i32* %166, i64 %168
%170 = load i32, i32* %169
store i32 %170, i32* %15
br label %171
171: ; preds = %201, %165
%172 = load i32, i32* %15
%173 = load i32*, i32** %10
%174 = load i32, i32* %16
%175 = add nsw i32 %174, 1
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i32, i32* %173, i64 %176
%178 = load i32, i32* %177
%179 = icmp slt i32 %172, %178
br i1 %179, label %180, label %204
180: ; preds = %171
%181 = load i32*, i32** %11
%182 = load i32, i32* %15
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds i32, i32* %181, i64 %183
%185 = load i32, i32* %184
store i32 %185, i32* %18
%186 = load i32, i32* %16
%187 = load i32*, i32** %21
%188 = load i32*, i32** %22
%189 = load i32, i32* %18
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i32, i32* %188, i64 %190
%192 = load i32, i32* %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i32, i32* %187, i64 %193
store i32 %186, i32* %194
%195 = load i32*, i32** %22
%196 = load i32, i32* %18
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %195, i64 %197
%199 = load i32, i32* %198
%200 = add nsw i32 %199, 1
store i32 %200, i32* %198
br label %201
201: ; preds = %180
%202 = load i32, i32* %15
%203 = add nsw i32 %202, 1
store i32 %203, i32* %15
br label %171
204: ; preds = %171
br label %205
205: ; preds = %204
%206 = load i32, i32* %16
%207 = add nsw i32 %206, 1
store i32 %207, i32* %16
br label %161
208: ; preds = %161
store i32 0, i32* %15
br label %209
209: ; preds = %218, %208
%210 = load i32, i32* %15
%211 = load i32, i32* %8
%212 = icmp slt i32 %210, %211
br i1 %212, label %213, label %221
213: ; preds = %209
%214 = load i32*, i32** %22
%215 = load i32, i32* %15
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds i32, i32* %214, i64 %216
store i32 -1, i32* %217
br label %218
218: ; preds = %213
%219 = load i32, i32* %15
%220 = add nsw i32 %219, 1
store i32 %220, i32* %15
br label %209
221: ; preds = %209
store i32 0, i32* %19
store i32 0, i32* %16
br label %222
222: ; preds = %312, %221
%223 = load i32, i32* %16
%224 = load i32, i32* %8
%225 = icmp slt i32 %223, %224
br i1 %225, label %226, label %315
226: ; preds = %222
%227 = load i32, i32* %16
%228 = load i32*, i32** %22
%229 = load i32, i32* %16
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i32, i32* %228, i64 %230
store i32 %227, i32* %231
%232 = load i32*, i32** %10
%233 = load i32, i32* %16
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i32, i32* %232, i64 %234
%236 = load i32, i32* %235
store i32 %236, i32* %15
br label %237
237: ; preds = %268, %226
%238 = load i32, i32* %15
%239 = load i32*, i32** %10
%240 = load i32, i32* %16
%241 = add nsw i32 %240, 1
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds i32, i32* %239, i64 %242
%244 = load i32, i32* %243
%245 = icmp slt i32 %238, %244
br i1 %245, label %246, label %271
246: ; preds = %237
%247 = load i32*, i32** %11
%248 = load i32, i32* %15
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %247, i64 %249
%251 = load i32, i32* %250
store i32 %251, i32* %17
%252 = load i32*, i32** %22
%253 = load i32, i32* %17
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i32, i32* %252, i64 %254
%256 = load i32, i32* %255
%257 = load i32, i32* %16
%258 = icmp ne i32 %256, %257
br i1 %258, label %259, label %267
259: ; preds = %246
%260 = load i32, i32* %16
%261 = load i32*, i32** %22
%262 = load i32, i32* %17
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i32, i32* %261, i64 %263
store i32 %260, i32* %264
%265 = load i32, i32* %19
%266 = add nsw i32 %265, 1
store i32 %266, i32* %19
br label %267
267: ; preds = %259, %246
br label %268
268: ; preds = %267
%269 = load i32, i32* %15
%270 = add nsw i32 %269, 1
store i32 %270, i32* %15
br label %237
271: ; preds = %237
%272 = load i32*, i32** %20
%273 = load i32, i32* %16
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds i32, i32* %272, i64 %274
%276 = load i32, i32* %275
store i32 %276, i32* %15
br label %277
277: ; preds = %308, %271
%278 = load i32, i32* %15
%279 = load i32*, i32** %20
%280 = load i32, i32* %16
%281 = add nsw i32 %280, 1
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i32, i32* %279, i64 %282
%284 = load i32, i32* %283
%285 = icmp slt i32 %278, %284
br i1 %285, label %286, label %311
286: ; preds = %277
%287 = load i32*, i32** %21
%288 = load i32, i32* %15
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i32, i32* %287, i64 %289
%291 = load i32, i32* %290
store i32 %291, i32* %17
%292 = load i32*, i32** %22
%293 = load i32, i32* %17
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i32, i32* %292, i64 %294
%296 = load i32, i32* %295
%297 = load i32, i32* %16
%298 = icmp ne i32 %296, %297
br i1 %298, label %299, label %307
299: ; preds = %286
%300 = load i32, i32* %16
%301 = load i32*, i32** %22
%302 = load i32, i32* %17
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i32, i32* %301, i64 %303
store i32 %300, i32* %304
%305 = load i32, i32* %19
%306 = add nsw i32 %305, 1
store i32 %306, i32* %19
br label %307
307: ; preds = %299, %286
br label %308
308: ; preds = %307
%309 = load i32, i32* %15
%310 = add nsw i32 %309, 1
store i32 %310, i32* %15
br label %277
311: ; preds = %277
br label %312
312: ; preds = %311
%313 = load i32, i32* %16
%314 = add nsw i32 %313, 1
store i32 %314, i32* %16
br label %222
315: ; preds = %222
%316 = load i32, i32* %19
%317 = load i32*, i32** %12
store i32 %316, i32* %317
%318 = load i32, i32* %8
%319 = add nsw i32 %318, 1
%320 = sext i32 %319 to i64
%321 = mul i64 %320, 4
%322 = trunc i64 %321 to i32
%323 = call i64 @superlu_malloc(i32 %322)
%324 = inttoptr i64 %323 to i32*
%325 = load i32**, i32*** %13
store i32* %324, i32** %325
%326 = icmp ne i32* %324, null
br i1 %326, label %334, label %327
327: ; preds = %315
%328 = getelementptr inbounds [256 x i8], [256 x i8]* %26, i64 0, i64 0
%329 = call i32 @sprintf_s(i8* %328, i32 256, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.4, i64 0, i64 0))
%330 = getelementptr inbounds [256 x i8], [256 x i8]* %26, i64 0, i64 0
%331 = call i32 @WriteSLUErrorMessage(i8* %330)
%332 = getelementptr inbounds [256 x i8], [256 x i8]* %26, i64 0, i64 0
%333 = call i32 @superlu_abort_and_exit(i8* %332)
br label %334
334: ; preds = %327, %315
%335 = load i32*, i32** %12
%336 = load i32, i32* %335
%337 = icmp ne i32 %336, 0
br i1 %337, label %338, label %356
338: ; preds = %334
%339 = load i32*, i32** %12
%340 = load i32, i32* %339
%341 = sext i32 %340 to i64
%342 = mul i64 %341, 4
%343 = trunc i64 %342 to i32
%344 = call i64 @superlu_malloc(i32 %343)
%345 = inttoptr i64 %344 to i32*
%346 = load i32**, i32*** %14
store i32* %345, i32** %346
%347 = icmp ne i32* %345, null
br i1 %347, label %355, label %348
348: ; preds = %338
%349 = getelementptr inbounds [256 x i8], [256 x i8]* %27, i64 0, i64 0
%350 = call i32 @sprintf_s(i8* %349, i32 256, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.5, i64 0, i64 0))
%351 = getelementptr inbounds [256 x i8], [256 x i8]* %27, i64 0, i64 0
%352 = call i32 @WriteSLUErrorMessage(i8* %351)
%353 = getelementptr inbounds [256 x i8], [256 x i8]* %27, i64 0, i64 0
%354 = call i32 @superlu_abort_and_exit(i8* %353)
br label %355
355: ; preds = %348, %338
br label %356
356: ; preds = %355, %334
store i32 0, i32* %15
br label %357
357: ; preds = %366, %356
%358 = load i32, i32* %15
%359 = load i32, i32* %8
%360 = icmp slt i32 %358, %359
br i1 %360, label %361, label %369
361: ; preds = %357
%362 = load i32*, i32** %22
%363 = load i32, i32* %15
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds i32, i32* %362, i64 %364
store i32 -1, i32* %365
br label %366
366: ; preds = %361
%367 = load i32, i32* %15
%368 = add nsw i32 %367, 1
store i32 %368, i32* %15
br label %357
369: ; preds = %357
store i32 0, i32* %19
store i32 0, i32* %16
br label %370
370: ; preds = %476, %369
%371 = load i32, i32* %16
%372 = load i32, i32* %8
%373 = icmp slt i32 %371, %372
br i1 %373, label %374, label %479
374: ; preds = %370
%375 = load i32, i32* %19
%376 = load i32**, i32*** %13
%377 = load i32*, i32** %376
%378 = load i32, i32* %16
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i32, i32* %377, i64 %379
store i32 %375, i32* %380
%381 = load i32, i32* %16
%382 = load i32*, i32** %22
%383 = load i32, i32* %16
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds i32, i32* %382, i64 %384
store i32 %381, i32* %385
%386 = load i32*, i32** %10
%387 = load i32, i32* %16
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds i32, i32* %386, i64 %388
%390 = load i32, i32* %389
store i32 %390, i32* %15
br label %391
391: ; preds = %427, %374
%392 = load i32, i32* %15
%393 = load i32*, i32** %10
%394 = load i32, i32* %16
%395 = add nsw i32 %394, 1
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds i32, i32* %393, i64 %396
%398 = load i32, i32* %397
%399 = icmp slt i32 %392, %398
br i1 %399, label %400, label %430
400: ; preds = %391
%401 = load i32*, i32** %11
%402 = load i32, i32* %15
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds i32, i32* %401, i64 %403
%405 = load i32, i32* %404
store i32 %405, i32* %17
%406 = load i32*, i32** %22
%407 = load i32, i32* %17
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i32, i32* %406, i64 %408
%410 = load i32, i32* %409
%411 = load i32, i32* %16
%412 = icmp ne i32 %410, %411
br i1 %412, label %413, label %426
413: ; preds = %400
%414 = load i32, i32* %16
%415 = load i32*, i32** %22
%416 = load i32, i32* %17
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds i32, i32* %415, i64 %417
store i32 %414, i32* %418
%419 = load i32, i32* %17
%420 = load i32**, i32*** %14
%421 = load i32*, i32** %420
%422 = load i32, i32* %19
%423 = add nsw i32 %422, 1
store i32 %423, i32* %19
%424 = sext i32 %422 to i64
%425 = getelementptr inbounds i32, i32* %421, i64 %424
store i32 %419, i32* %425
br label %426
426: ; preds = %413, %400
br label %427
427: ; preds = %426
%428 = load i32, i32* %15
%429 = add nsw i32 %428, 1
store i32 %429, i32* %15
br label %391
430: ; preds = %391
%431 = load i32*, i32** %20
%432 = load i32, i32* %16
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds i32, i32* %431, i64 %433
%435 = load i32, i32* %434
store i32 %435, i32* %15
br label %436
436: ; preds = %472, %430
%437 = load i32, i32* %15
%438 = load i32*, i32** %20
%439 = load i32, i32* %16
%440 = add nsw i32 %439, 1
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds i32, i32* %438, i64 %441
%443 = load i32, i32* %442
%444 = icmp slt i32 %437, %443
br i1 %444, label %445, label %475
445: ; preds = %436
%446 = load i32*, i32** %21
%447 = load i32, i32* %15
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds i32, i32* %446, i64 %448
%450 = load i32, i32* %449
store i32 %450, i32* %17
%451 = load i32*, i32** %22
%452 = load i32, i32* %17
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds i32, i32* %451, i64 %453
%455 = load i32, i32* %454
%456 = load i32, i32* %16
%457 = icmp ne i32 %455, %456
br i1 %457, label %458, label %471
458: ; preds = %445
%459 = load i32, i32* %16
%460 = load i32*, i32** %22
%461 = load i32, i32* %17
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds i32, i32* %460, i64 %462
store i32 %459, i32* %463
%464 = load i32, i32* %17
%465 = load i32**, i32*** %14
%466 = load i32*, i32** %465
%467 = load i32, i32* %19
%468 = add nsw i32 %467, 1
store i32 %468, i32* %19
%469 = sext i32 %467 to i64
%470 = getelementptr inbounds i32, i32* %466, i64 %469
store i32 %464, i32* %470
br label %471
471: ; preds = %458, %445
br label %472
472: ; preds = %471
%473 = load i32, i32* %15
%474 = add nsw i32 %473, 1
store i32 %474, i32* %15
br label %436
475: ; preds = %436
br label %476
476: ; preds = %475
%477 = load i32, i32* %16
%478 = add nsw i32 %477, 1
store i32 %478, i32* %16
br label %370
479: ; preds = %370
%480 = load i32, i32* %19
%481 = load i32**, i32*** %13
%482 = load i32*, i32** %481
%483 = load i32, i32* %8
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds i32, i32* %482, i64 %484
store i32 %480, i32* %485
%486 = load i32*, i32** %22
%487 = call i32 @superlu_free(i32* %486)
%488 = load i32*, i32** %20
%489 = call i32 @superlu_free(i32* %488)
%490 = load i32*, i32** %21
%491 = call i32 @superlu_free(i32* %490)
ret void
}

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