#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 */
scalar_t__ TreePostorder(int const, int *);
int /*<<< orphan*/ ifill(int *, int const, int);
scalar_t__ intMalloc(int);
int /*<<< orphan*/ sprintf(char *, char *, char *, int, char *);
int /*<<< orphan*/ superlu_abort_and_exit(char *);
int /*<<< orphan*/ superlu_free(int *);
void heap_relax_snode(const int n, int *et, const int relax_columns,
                      int *descendants, int *relax_end) {
  register int i, j, k, l, parent;
  register int snode_start;
  int *et_save, *post, *inv_post, *iwork;
  int nsuper_et = 0, nsuper_et_post = 0;
  iwork = (int *)intMalloc(3 * n + 2);
  if (!iwork) {
    char msg[256];
    sprintf(msg, "%s at line %d in file %s\n",
            "SUPERLU_MALLOC fails for iwork[]", 54,
            "/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/heap_relax_snode.c");
    superlu_abort_and_exit(msg);
  };
  inv_post = iwork + n + 1;
  et_save = inv_post + n + 1;
  post = (int *)TreePostorder(n, et);
  for (i = 0; i < n + 1; ++i)
    inv_post[post[i]] = i;
  for (i = 0; i < n; ++i) {
    iwork[post[i]] = post[et[i]];
    et_save[i] = et[i];
  }
  for (i = 0; i < n; ++i)
    et[i] = iwork[i];
  ifill(relax_end, n, (-1));
  for (j = 0; j < n; j++)
    descendants[j] = 0;
  for (j = 0; j < n; j++) {
    parent = et[j];
    if (parent != n)
      descendants[parent] += descendants[j] + 1;
  }
  for (j = 0; j < n;) {
    parent = et[j];
    snode_start = j;
    while (parent != n && descendants[parent] < relax_columns) {
      j = parent;
      parent = et[j];
    }
    ++nsuper_et_post;
    k = n;
    for (i = snode_start; i <= j; ++i)
      k = ((k) < (inv_post[i]) ? (k) : (inv_post[i]));
    l = inv_post[j];
    if ((l - k) == (j - snode_start)) {
      relax_end[k] = l;
      ++nsuper_et;
    } else {
      for (i = snode_start; i <= j; ++i) {
        l = inv_post[i];
        if (descendants[i] == 0) {
          relax_end[l] = l;
          ++nsuper_et;
        }
      }
    }
    j++;
    while (descendants[j] != 0 && j < n)
      j++;
  }
  for (i = 0; i < n; ++i)
    et[i] = et_save[i];
  superlu_free(post);
  superlu_free(iwork);
}


x86 assembly (clang, -O0):
<heap_relax_snode>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
imul   $0x3,-0x4(%rbp),%edi
add    $0x2,%edi
call   1050 <intMalloc@plt>
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
jne    11d8 <heap_relax_snode+0x78>
lea    -0x170(%rbp),%rdi
lea    0xe4c(%rip),%rsi
lea    0xe5f(%rip),%rdx
mov    $0x36,%ecx
lea    0xe74(%rip),%r8
call   1070 <sprintf@plt>
lea    -0x170(%rbp),%rdi
call   1030 <superlu_abort_and_exit@plt>
mov    -0x60(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0x4,%rax
mov    %rax,-0x48(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
call   1080 <TreePostorder@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1252 <heap_relax_snode+0xf2>
mov    -0x2c(%rbp),%edx
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x2c(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    121d <heap_relax_snode+0xbd>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12af <heap_relax_snode+0x14f>
mov    -0x50(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x60(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x2c(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1259 <heap_relax_snode+0xf9>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12e6 <heap_relax_snode+0x186>
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b6 <heap_relax_snode+0x156>
mov    -0x28(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    $0xffffffff,%edx
call   1040 <ifill@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1327 <heap_relax_snode+0x1c7>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12fe <heap_relax_snode+0x19e>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1383 <heap_relax_snode+0x223>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
je     1370 <heap_relax_snode+0x210>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1375 <heap_relax_snode+0x215>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    132e <heap_relax_snode+0x1ce>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1563 <heap_relax_snode+0x403>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x4(%rbp),%ecx
mov    %al,-0x171(%rbp)
je     13d5 <heap_relax_snode+0x275>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x171(%rbp)
mov    -0x171(%rbp),%al
test   $0x1,%al
jne    13e8 <heap_relax_snode+0x288>
jmp    1401 <heap_relax_snode+0x2a1>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
jmp    13aa <heap_relax_snode+0x24a>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     146c <heap_relax_snode+0x30c>
mov    -0x34(%rbp),%eax
mov    -0x58(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1444 <heap_relax_snode+0x2e4>
mov    -0x34(%rbp),%eax
mov    %eax,-0x178(%rbp)
jmp    1455 <heap_relax_snode+0x2f5>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x178(%rbp)
mov    -0x178(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1416 <heap_relax_snode+0x2b6>
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jne    14aa <heap_relax_snode+0x34a>
mov    -0x38(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    150b <heap_relax_snode+0x3ab>
mov    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1506 <heap_relax_snode+0x3a6>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    14f3 <heap_relax_snode+0x393>
mov    -0x38(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    14f8 <heap_relax_snode+0x398>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14b0 <heap_relax_snode+0x350>
jmp    150b <heap_relax_snode+0x3ab>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rcx
movslq -0x30(%rbp),%rdx
xor    %eax,%eax
cmpl   $0x0,(%rcx,%rdx,4)
mov    %al,-0x179(%rbp)
je     153d <heap_relax_snode+0x3dd>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
setl   %al
mov    %al,-0x179(%rbp)
mov    -0x179(%rbp),%al
test   $0x1,%al
jne    1550 <heap_relax_snode+0x3f0>
jmp    155e <heap_relax_snode+0x3fe>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1514 <heap_relax_snode+0x3b4>
jmp    138a <heap_relax_snode+0x22a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    159a <heap_relax_snode+0x43a>
mov    -0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    156a <heap_relax_snode+0x40a>
mov    -0x50(%rbp),%rdi
call   1060 <superlu_free@plt>
mov    -0x60(%rbp),%rdi
call   1060 <superlu_free@plt>
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<heap_relax_snode>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r8,0x10(%rsp)
mov    %rcx,%r13
mov    %edx,0x34(%rsp)
mov    %rsi,%r15
mov    %edi,%ebp
lea    0x2(%rbp,%rbp,2),%edi
call   1060 <intMalloc@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
jne    11d4 <heap_relax_snode+0x64>
lea    0xe54(%rip),%rsi
lea    0xe67(%rip),%rdx
lea    0xe81(%rip),%r8
lea    0x50(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x36,%ecx
call   1080 <sprintf@plt>
mov    %rbx,%rdi
call   1030 <superlu_abort_and_exit@plt>
mov    %ebp,%edi
mov    %r15,%rsi
call   1090 <TreePostorder@plt>
test   %ebp,%ebp
mov    0x8(%rsp),%r11
mov    0x10(%rsp),%rdi
js     13b4 <heap_relax_snode+0x244>
movslq %ebp,%r12
lea    (%r11,%r12,4),%r14
add    $0x4,%r14
mov    %ebp,%r9d
lea    0x1(%r9),%rdx
mov    %edx,%ebx
and    $0x3,%ebx
cmp    $0x3,%ebp
mov    %rbp,0x28(%rsp)
jae    121a <heap_relax_snode+0xaa>
xor    %ecx,%ecx
test   %rbx,%rbx
jne    1260 <heap_relax_snode+0xf0>
jmp    1272 <heap_relax_snode+0x102>
and    $0xfffffffc,%edx
xor    %ecx,%ecx
nop
movslq (%rax,%rcx,4),%rsi
mov    %ecx,(%r14,%rsi,4)
movslq 0x4(%rax,%rcx,4),%rsi
lea    0x1(%rcx),%ebp
mov    %ebp,(%r14,%rsi,4)
movslq 0x8(%rax,%rcx,4),%rsi
lea    0x2(%rcx),%ebp
mov    %ebp,(%r14,%rsi,4)
movslq 0xc(%rax,%rcx,4),%rsi
lea    0x3(%rcx),%ebp
mov    %ebp,(%r14,%rsi,4)
add    $0x4,%rcx
cmp    %rdx,%rcx
jne    1220 <heap_relax_snode+0xb0>
mov    0x28(%rsp),%rbp
test   %rbx,%rbx
je     1272 <heap_relax_snode+0x102>
nop
movslq (%rax,%rcx,4),%rdx
mov    %ecx,(%r14,%rdx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbx
jne    1260 <heap_relax_snode+0xf0>
test   %ebp,%ebp
jle    13b4 <heap_relax_snode+0x244>
lea    (%r11,%r12,4),%r8
mov    %r9d,%r10d
mov    %r10,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,0x48(%rsp)
je     12db <heap_relax_snode+0x16b>
mov    %r10d,%edx
and    $0xfffffffe,%edx
lea    (%r11,%r12,8),%rsi
add    $0xc,%rsi
xor    %ecx,%ecx
nop
movslq (%r15,%rcx,4),%rdi
mov    (%rax,%rdi,4),%edi
movslq (%rax,%rcx,4),%rbx
mov    %edi,(%r11,%rbx,4)
mov    (%r15,%rcx,4),%edi
mov    %edi,-0x4(%rsi,%rcx,4)
movslq 0x4(%r15,%rcx,4),%rdi
mov    (%rax,%rdi,4),%edi
movslq 0x4(%rax,%rcx,4),%rbx
mov    %edi,(%r11,%rbx,4)
mov    0x4(%r15,%rcx,4),%edi
mov    %edi,(%rsi,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    12a0 <heap_relax_snode+0x130>
jmp    12dd <heap_relax_snode+0x16d>
xor    %ecx,%ecx
lea    (%r8,%r12,4),%rsi
add    $0x8,%rsi
test   $0x1,%r10b
je     1307 <heap_relax_snode+0x197>
movslq (%r15,%rcx,4),%rdx
mov    %rsi,%rdi
mov    (%rax,%rdx,4),%esi
movslq (%rax,%rcx,4),%rdx
mov    %esi,(%r11,%rdx,4)
mov    %rdi,%rsi
mov    (%r15,%rcx,4),%edx
mov    %edx,(%rdi,%rcx,4)
test   %ebp,%ebp
mov    0x10(%rsp),%rdi
jle    13b4 <heap_relax_snode+0x244>
cmp    $0x8,%ebp
mov    %r9,0x20(%rsp)
mov    %rsi,0x38(%rsp)
jb     133d <heap_relax_snode+0x1cd>
lea    (%r11,%r10,4),%rcx
cmp    %r15,%rcx
jbe    13e7 <heap_relax_snode+0x277>
lea    (%r15,%r10,4),%rcx
cmp    %rcx,%r11
jae    13e7 <heap_relax_snode+0x277>
xor    %ebx,%ebx
mov    %rbx,%rcx
not    %rcx
add    %r10,%rcx
mov    %r10,%rdx
and    $0x3,%rdx
je     1372 <heap_relax_snode+0x202>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r11,%rbx,4),%esi
mov    %esi,(%r15,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdx
jne    1360 <heap_relax_snode+0x1f0>
cmp    $0x3,%rcx
jb     14d6 <heap_relax_snode+0x366>
nopl   0x0(%rax)
mov    (%r11,%rbx,4),%ecx
mov    %ecx,(%r15,%rbx,4)
mov    0x4(%r11,%rbx,4),%ecx
mov    %ecx,0x4(%r15,%rbx,4)
mov    0x8(%r11,%rbx,4),%ecx
mov    %ecx,0x8(%r15,%rbx,4)
mov    0xc(%r11,%rbx,4),%ecx
mov    %ecx,0xc(%r15,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%r10
jne    1380 <heap_relax_snode+0x210>
jmp    14d6 <heap_relax_snode+0x366>
mov    %ebp,%esi
mov    $0xffffffff,%edx
mov    %rax,%rbx
call   1050 <ifill@plt>
mov    %rbx,%rdi
call   1070 <superlu_free@plt>
mov    0x8(%rsp),%rdi
call   1070 <superlu_free@plt>
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r10d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x18,%rsi
jae    1410 <heap_relax_snode+0x2a0>
xor    %esi,%esi
jmp    148a <heap_relax_snode+0x31a>
movabs $0x3ffffffffffffffc,%rcx
ff ff 3f
and    %rcx,%rdx
xor    %esi,%esi
nop
movups (%r11,%rsi,4),%xmm0
movups 0x10(%r11,%rsi,4),%xmm1
movups %xmm0,(%r15,%rsi,4)
movups %xmm1,0x10(%r15,%rsi,4)
movups 0x20(%r11,%rsi,4),%xmm0
movups 0x30(%r11,%rsi,4),%xmm1
movups %xmm0,0x20(%r15,%rsi,4)
movups %xmm1,0x30(%r15,%rsi,4)
movups 0x40(%r11,%rsi,4),%xmm0
movups 0x50(%r11,%rsi,4),%xmm1
movups %xmm0,0x40(%r15,%rsi,4)
movups %xmm1,0x50(%r15,%rsi,4)
movups 0x60(%r11,%rsi,4),%xmm0
movdqu 0x70(%r11,%rsi,4),%xmm1
movups %xmm0,0x60(%r15,%rsi,4)
movdqu %xmm1,0x70(%r15,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1420 <heap_relax_snode+0x2b0>
test   %r8,%r8
je     14cd <heap_relax_snode+0x35d>
lea    (%r15,%rsi,4),%rdx
add    $0x10,%rdx
lea    (%r11,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rsi,%rcx,1),%xmm0
movdqu (%rsi,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdx,%rcx,1)
movdqu %xmm1,(%rdx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r8
jne    14b0 <heap_relax_snode+0x340>
cmp    %r10,%rbx
jne    133f <heap_relax_snode+0x1cf>
mov    %r10,0x40(%rsp)
mov    %rax,0x18(%rsp)
mov    %ebp,%esi
mov    $0xffffffff,%edx
call   1050 <ifill@plt>
mov    0x20(%rsp),%rbp
lea    0x0(,%rbp,4),%rdx
xor    %ebx,%ebx
mov    %r13,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
cmpq   $0x0,0x48(%rsp)
je     1574 <heap_relax_snode+0x404>
mov    %ebp,%eax
and    $0xfffffffe,%eax
xor    %ebx,%ebx
mov    0x8(%rsp),%rdi
mov    %rbp,%r9
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%rbp
jmp    1539 <heap_relax_snode+0x3c9>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rbx
cmp    %rbx,%rax
je     1581 <heap_relax_snode+0x411>
movslq (%r15,%rbx,4),%rcx
cmp    %ebp,%ecx
je     1555 <heap_relax_snode+0x3e5>
mov    0x0(%r13,%rbx,4),%edx
mov    0x0(%r13,%rcx,4),%esi
add    %esi,%edx
add    $0x1,%edx
mov    %edx,0x0(%r13,%rcx,4)
movslq 0x4(%r15,%rbx,4),%rcx
cmp    %ebp,%ecx
je     1530 <heap_relax_snode+0x3c0>
mov    0x4(%r13,%rbx,4),%edx
mov    0x0(%r13,%rcx,4),%esi
add    %esi,%edx
add    $0x1,%edx
mov    %edx,0x0(%r13,%rcx,4)
jmp    1530 <heap_relax_snode+0x3c0>
mov    0x8(%rsp),%rdi
mov    %rbp,%r9
mov    0x10(%rsp),%r8
test   $0x1,%r9b
mov    0x28(%rsp),%rsi
je     15a8 <heap_relax_snode+0x438>
movslq (%r15,%rbx,4),%rax
cmp    %esi,%eax
je     15a8 <heap_relax_snode+0x438>
mov    0x0(%r13,%rbx,4),%ecx
mov    0x0(%r13,%rax,4),%edx
add    %edx,%ecx
add    $0x1,%ecx
mov    %ecx,0x0(%r13,%rax,4)
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    (%rdi,%r12,4),%r9
add    $0x34,%r9
xor    %edx,%edx
jmp    15cd <heap_relax_snode+0x45d>
nopl   (%rax)
mov    0x28(%rsp),%rsi
cmp    %esi,%edx
jge    1879 <heap_relax_snode+0x709>
mov    %edx,%r10d
movslq %edx,%rdi
mov    (%r15,%rdi,4),%eax
cmp    %esi,%eax
je     1612 <heap_relax_snode+0x4a2>
movslq %eax,%rcx
mov    %r10d,%edx
mov    0x34(%rsp),%ebp
cmp    %ebp,0x0(%r13,%rcx,4)
jge    1604 <heap_relax_snode+0x494>
nopl   0x0(%rax)
mov    %eax,%edx
mov    (%r15,%rcx,4),%eax
cmp    %esi,%eax
je     1604 <heap_relax_snode+0x494>
movslq %eax,%rcx
cmp    %ebp,0x0(%r13,%rcx,4)
jl     15f0 <heap_relax_snode+0x480>
mov    $0x1,%r11b
mov    %esi,%eax
cmp    %r10d,%edx
jl     179e <heap_relax_snode+0x62e>
mov    %edx,%r8d
sub    %r10d,%edx
mov    %rdi,%rcx
mov    %esi,%eax
cmp    $0x7,%edx
jb     1771 <heap_relax_snode+0x601>
add    $0x1,%rdx
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rax,%rax
je     1860 <heap_relax_snode+0x6f0>
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
lea    0x2(%rax),%rsi
and    %r11,%rsi
lea    (%r9,%rdi,4),%rax
xor    %ebx,%ebx
movdqa %xmm0,%xmm1
movdqa %xmm0,%xmm2
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rax,%rbx,4),%xmm3
movdqu -0x20(%rax,%rbx,4),%xmm4
movdqu -0x10(%rax,%rbx,4),%xmm5
movdqu (%rax,%rbx,4),%xmm6
movdqa %xmm3,%xmm7
pcmpgtd %xmm1,%xmm7
pand   %xmm7,%xmm1
pandn  %xmm3,%xmm7
por    %xmm1,%xmm7
movdqa %xmm4,%xmm3
pcmpgtd %xmm2,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm4,%xmm3
por    %xmm2,%xmm3
movdqa %xmm5,%xmm1
pcmpgtd %xmm7,%xmm1
pand   %xmm1,%xmm7
pandn  %xmm5,%xmm1
por    %xmm7,%xmm1
movdqa %xmm6,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm6,%xmm2
por    %xmm3,%xmm2
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rsi
jne    1670 <heap_relax_snode+0x500>
test   $0x1,%r11b
je     171f <heap_relax_snode+0x5af>
add    %rdi,%rbx
movdqu (%r14,%rbx,4),%xmm3
movdqu 0x10(%r14,%rbx,4),%xmm4
movdqa %xmm3,%xmm5
pcmpgtd %xmm1,%xmm5
pand   %xmm5,%xmm1
pandn  %xmm3,%xmm5
por    %xmm5,%xmm1
movdqa %xmm4,%xmm3
pcmpgtd %xmm2,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm4,%xmm3
por    %xmm3,%xmm2
movdqa %xmm2,%xmm3
pcmpgtd %xmm1,%xmm3
pand   %xmm3,%xmm1
pandn  %xmm2,%xmm3
por    %xmm1,%xmm3
pshufd $0xee,%xmm3,%xmm1
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
pshufd $0x55,%xmm2,%xmm1
movdqa %xmm1,%xmm3
pcmpgtd %xmm2,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm1,%xmm3
por    %xmm2,%xmm3
movd   %xmm3,%eax
cmp    %rcx,%rdx
je     1793 <heap_relax_snode+0x623>
add    %rdi,%rcx
lea    0x1(%r8),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,%esi
mov    (%r14,%rcx,4),%eax
cmp    %eax,%esi
cmovl  %esi,%eax
add    $0x1,%rcx
cmp    %ecx,%edx
jne    1780 <heap_relax_snode+0x610>
xor    %r11d,%r11d
mov    %r8d,%edx
mov    0x10(%rsp),%r8
movslq %edx,%rcx
mov    (%r14,%rcx,4),%ebp
mov    %ebp,%ebx
sub    %eax,%ebx
mov    %ecx,%esi
sub    %r10d,%esi
cmp    %esi,%ebx
jne    17c0 <heap_relax_snode+0x650>
cltq
mov    %ebp,(%r8,%rax,4)
jmp    1830 <heap_relax_snode+0x6c0>
nopw   0x0(%rax,%rax,1)
test   %r11b,%r11b
jne    1830 <heap_relax_snode+0x6c0>
lea    0x1(%rdx),%ebp
mov    %ebp,%eax
sub    %r10d,%eax
test   $0x1,%al
je     17e7 <heap_relax_snode+0x677>
cmpl   $0x0,0x0(%r13,%rdi,4)
jne    17e3 <heap_relax_snode+0x673>
mov    (%r14,%rdi,4),%eax
cltq
mov    %eax,(%r8,%rax,4)
add    $0x1,%rdi
test   %esi,%esi
je     1830 <heap_relax_snode+0x6c0>
mov    %ebp,%eax
jmp    180c <heap_relax_snode+0x69c>
nop
mov    -0x30(%r9,%rdi,4),%esi
movslq %esi,%rsi
mov    %esi,(%r8,%rsi,4)
cmpl   $0x0,0x4(%r13,%rdi,4)
je     181c <heap_relax_snode+0x6ac>
add    $0x2,%rdi
cmp    %edi,%eax
je     1830 <heap_relax_snode+0x6c0>
cmpl   $0x0,0x0(%r13,%rdi,4)
je     17f0 <heap_relax_snode+0x680>
cmpl   $0x0,0x4(%r13,%rdi,4)
jne    1804 <heap_relax_snode+0x694>
mov    -0x2c(%r9,%rdi,4),%esi
movslq %esi,%rsi
mov    %esi,(%r8,%rsi,4)
jmp    1804 <heap_relax_snode+0x694>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%edx
cmpl   $0x0,0x0(%r13,%rcx,4)
je     15c0 <heap_relax_snode+0x450>
lea    0x1(%rcx),%rax
cmp    %r12,%rcx
mov    %rax,%rcx
jl     1840 <heap_relax_snode+0x6d0>
jmp    15c0 <heap_relax_snode+0x450>
xor    %ebx,%ebx
movdqa %xmm0,%xmm1
movdqa %xmm0,%xmm2
test   $0x1,%r11b
jne    16e7 <heap_relax_snode+0x577>
jmp    171f <heap_relax_snode+0x5af>
cmp    $0x8,%esi
jae    1899 <heap_relax_snode+0x729>
xor    %eax,%eax
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%rbx
mov    0x40(%rsp),%r8
mov    0x38(%rsp),%r9
jmp    19e8 <heap_relax_snode+0x878>
mov    0x40(%rsp),%r8
lea    (%r8,%r12,2),%rax
mov    0x8(%rsp),%rbp
lea    0x8(,%rax,4),%rax
add    %rbp,%rax
cmp    %r15,%rax
mov    0x38(%rsp),%r9
jbe    18d6 <heap_relax_snode+0x766>
lea    (%r15,%r8,4),%rax
cmp    %rax,%r9
jae    18d6 <heap_relax_snode+0x766>
xor    %eax,%eax
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%rbx
jmp    19e8 <heap_relax_snode+0x878>
mov    %r8d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1902 <heap_relax_snode+0x792>
xor    %esi,%esi
mov    0x18(%rsp),%rdi
jmp    1994 <heap_relax_snode+0x824>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
and    %rsi,%rdx
lea    0x78(,%r12,8),%rbx
add    %rbp,%rbx
xor    %esi,%esi
mov    0x18(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x70(%rbx,%rsi,4),%xmm0
movups -0x60(%rbx,%rsi,4),%xmm1
movups %xmm0,(%r15,%rsi,4)
movups %xmm1,0x10(%r15,%rsi,4)
movups -0x50(%rbx,%rsi,4),%xmm0
movups -0x40(%rbx,%rsi,4),%xmm1
movups %xmm0,0x20(%r15,%rsi,4)
movups %xmm1,0x30(%r15,%rsi,4)
movups -0x30(%rbx,%rsi,4),%xmm0
movups -0x20(%rbx,%rsi,4),%xmm1
movups %xmm0,0x40(%r15,%rsi,4)
movups %xmm1,0x50(%r15,%rsi,4)
movdqu -0x10(%rbx,%rsi,4),%xmm0
movdqu (%rbx,%rsi,4),%xmm1
movdqu %xmm0,0x60(%r15,%rsi,4)
movdqu %xmm1,0x70(%r15,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1930 <heap_relax_snode+0x7c0>
test   %rcx,%rcx
mov    0x20(%rsp),%rbx
je     19df <heap_relax_snode+0x86f>
lea    (%r15,%rsi,4),%rdx
add    $0x10,%rdx
lea    (%rsi,%r12,2),%rsi
lea    0x18(,%rsi,4),%rsi
add    %rbp,%rsi
shl    $0x5,%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rsi,%rbp,1),%xmm0
movdqu (%rsi,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rdx,%rbp,1)
movdqu %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rcx
jne    19c0 <heap_relax_snode+0x850>
cmp    %r8,%rax
je     13c6 <heap_relax_snode+0x256>
mov    %rax,%rcx
not    %rcx
add    %rbx,%rcx
and    $0x3,%rbx
je     1a12 <heap_relax_snode+0x8a2>
nopw   0x0(%rax,%rax,1)
mov    (%r9,%rax,4),%edx
mov    %edx,(%r15,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1a00 <heap_relax_snode+0x890>
cmp    $0x3,%rcx
jb     13c6 <heap_relax_snode+0x256>
mov    0x8(%rsp),%rcx
lea    (%rcx,%r12,8),%rcx
add    $0x14,%rcx
nopl   0x0(%rax)
mov    -0xc(%rcx,%rax,4),%edx
mov    %edx,(%r15,%rax,4)
mov    -0x8(%rcx,%rax,4),%edx
mov    %edx,0x4(%r15,%rax,4)
mov    -0x4(%rcx,%rax,4),%edx
mov    %edx,0x8(%r15,%rax,4)
mov    (%rcx,%rax,4),%edx
mov    %edx,0xc(%r15,%rax,4)
add    $0x4,%rax
cmp    %rax,%r8
jne    1a30 <heap_relax_snode+0x8c0>
jmp    13c6 <heap_relax_snode+0x256>

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

LLVM IR (-O2):
@.str = [26 x i8] c"%s at line %d in file %s\0A\00"
@.str.1 = [33 x i8] c"SUPERLU_MALLOC fails for iwork[]\00"
@.str.2 = [169 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/heap_relax_snode.c\00"
define void @heap_relax_snode(i32 %0, i32* %1, i32 %2, i32* nocapture %3, i32* %4) {
%6 = bitcast i32* %3 to i8*
%7 = alloca [256 x i8]
%8 = mul nsw i32 %0, 3
%9 = add nsw i32 %8, 2
%10 = tail call i64 @intMalloc(i32 %9)
%11 = inttoptr i64 %10 to i32*
%12 = inttoptr i64 %10 to i8*
%13 = icmp eq i64 %10, 0
br i1 %13, label %14, label %18
14: ; preds = %5
%15 = getelementptr inbounds [256 x i8], [256 x i8]* %7, i64 0, i64 0
%16 = call i32 @sprintf(i8* %15, i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.1, i64 0, i64 0), i32 54, i8* getelementptr inbounds ([169 x i8], [169 x i8]* @.str.2, i64 0, i64 0))
%17 = call i32 @superlu_abort_and_exit(i8* %15)
br label %18
18: ; preds = %14, %5
%19 = sext i32 %0 to i64
%20 = getelementptr inbounds i32, i32* %11, i64 %19
%21 = getelementptr inbounds i32, i32* %20, i64 1
%22 = getelementptr inbounds i32, i32* %21, i64 %19
%23 = getelementptr i32, i32* %22, i64 1
%24 = call i64 @TreePostorder(i32 %0, i32* %1)
%25 = inttoptr i64 %24 to i32*
%26 = icmp slt i32 %0, 0
br i1 %26, label %258, label %27
27: ; preds = %18
%28 = add nuw i32 %0, 1
%29 = zext i32 %28 to i64
%30 = add nsw i64 %29, -1
%31 = and i64 %29, 3
%32 = icmp ult i64 %30, 3
br i1 %32, label %35, label %33
33: ; preds = %27
%34 = and i64 %29, 4294967292
br label %58
35: ; preds = %58, %27
%36 = phi i64 [ 0, %27 ], [ %84, %58 ]
%37 = icmp eq i64 %31, 0
br i1 %37, label %49, label %38
38: ; preds = %35, %38
%39 = phi i64 [ %46, %38 ], [ %36, %35 ]
%40 = phi i64 [ %47, %38 ], [ 0, %35 ]
%41 = getelementptr inbounds i32, i32* %25, i64 %39
%42 = load i32, i32* %41
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %21, i64 %43
%45 = trunc i64 %39 to i32
store i32 %45, i32* %44
%46 = add nuw nsw i64 %39, 1
%47 = add i64 %40, 1
%48 = icmp eq i64 %47, %31
br i1 %48, label %49, label %38
49: ; preds = %38, %35
%50 = icmp sgt i32 %0, 0
br i1 %50, label %51, label %258
51: ; preds = %49
%52 = zext i32 %0 to i64
%53 = add nsw i64 %52, -1
%54 = and i64 %52, 1
%55 = icmp eq i64 %53, 0
br i1 %55, label %87, label %56
56: ; preds = %51
%57 = and i64 %52, 4294967294
br label %210
58: ; preds = %58, %33
%59 = phi i64 [ 0, %33 ], [ %84, %58 ]
%60 = phi i64 [ 0, %33 ], [ %85, %58 ]
%61 = getelementptr inbounds i32, i32* %25, i64 %59
%62 = load i32, i32* %61
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %21, i64 %63
%65 = trunc i64 %59 to i32
store i32 %65, i32* %64
%66 = or i64 %59, 1
%67 = getelementptr inbounds i32, i32* %25, i64 %66
%68 = load i32, i32* %67
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i32, i32* %21, i64 %69
%71 = trunc i64 %66 to i32
store i32 %71, i32* %70
%72 = or i64 %59, 2
%73 = getelementptr inbounds i32, i32* %25, i64 %72
%74 = load i32, i32* %73
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i32, i32* %21, i64 %75
%77 = trunc i64 %72 to i32
store i32 %77, i32* %76
%78 = or i64 %59, 3
%79 = getelementptr inbounds i32, i32* %25, i64 %78
%80 = load i32, i32* %79
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32, i32* %21, i64 %81
%83 = trunc i64 %78 to i32
store i32 %83, i32* %82
%84 = add nuw nsw i64 %59, 4
%85 = add i64 %60, 4
%86 = icmp eq i64 %85, %34
br i1 %86, label %35, label %58
87: ; preds = %210, %51
%88 = phi i64 [ 0, %51 ], [ %236, %210 ]
%89 = icmp eq i64 %54, 0
br i1 %89, label %102, label %90
90: ; preds = %87
%91 = getelementptr inbounds i32, i32* %1, i64 %88
%92 = load i32, i32* %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i32, i32* %25, i64 %93
%95 = load i32, i32* %94
%96 = getelementptr inbounds i32, i32* %25, i64 %88
%97 = load i32, i32* %96
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i32, i32* %11, i64 %98
store i32 %95, i32* %99
%100 = load i32, i32* %91
%101 = getelementptr inbounds i32, i32* %23, i64 %88
store i32 %100, i32* %101
br label %102
102: ; preds = %87, %90
br i1 %50, label %103, label %258
103: ; preds = %102
%104 = zext i32 %0 to i64
%105 = icmp ult i32 %0, 8
br i1 %105, label %192, label %106
106: ; preds = %103
%107 = getelementptr i32, i32* %1, i64 %52
%108 = bitcast i32* %107 to i8*
%109 = getelementptr i32, i32* %11, i64 %52
%110 = icmp ugt i32* %109, %1
%111 = icmp ult i8* %12, %108
%112 = and i1 %110, %111
br i1 %112, label %192, label %113
113: ; preds = %106
%114 = and i64 %52, 4294967288
%115 = add nsw i64 %114, -8
%116 = lshr exact i64 %115, 3
%117 = add nuw nsw i64 %116, 1
%118 = and i64 %117, 3
%119 = icmp ult i64 %115, 24
br i1 %119, label %171, label %120
120: ; preds = %113
%121 = and i64 %117, 4611686018427387900
br label %122
122: ; preds = %122, %120
%123 = phi i64 [ 0, %120 ], [ %168, %122 ]
%124 = phi i64 [ 0, %120 ], [ %169, %122 ]
%125 = getelementptr inbounds i32, i32* %11, i64 %123
%126 = bitcast i32* %125 to <4 x i32>*
%127 = load <4 x i32>, <4 x i32>* %126
%128 = getelementptr inbounds i32, i32* %125, i64 4
%129 = bitcast i32* %128 to <4 x i32>*
%130 = load <4 x i32>, <4 x i32>* %129
%131 = getelementptr inbounds i32, i32* %1, i64 %123
%132 = bitcast i32* %131 to <4 x i32>*
store <4 x i32> %127, <4 x i32>* %132
%133 = getelementptr inbounds i32, i32* %131, i64 4
%134 = bitcast i32* %133 to <4 x i32>*
store <4 x i32> %130, <4 x i32>* %134
%135 = or i64 %123, 8
%136 = getelementptr inbounds i32, i32* %11, i64 %135
%137 = bitcast i32* %136 to <4 x i32>*
%138 = load <4 x i32>, <4 x i32>* %137
%139 = getelementptr inbounds i32, i32* %136, i64 4
%140 = bitcast i32* %139 to <4 x i32>*
%141 = load <4 x i32>, <4 x i32>* %140
%142 = getelementptr inbounds i32, i32* %1, i64 %135
%143 = bitcast i32* %142 to <4 x i32>*
store <4 x i32> %138, <4 x i32>* %143
%144 = getelementptr inbounds i32, i32* %142, i64 4
%145 = bitcast i32* %144 to <4 x i32>*
store <4 x i32> %141, <4 x i32>* %145
%146 = or i64 %123, 16
%147 = getelementptr inbounds i32, i32* %11, i64 %146
%148 = bitcast i32* %147 to <4 x i32>*
%149 = load <4 x i32>, <4 x i32>* %148
%150 = getelementptr inbounds i32, i32* %147, i64 4
%151 = bitcast i32* %150 to <4 x i32>*
%152 = load <4 x i32>, <4 x i32>* %151
%153 = getelementptr inbounds i32, i32* %1, i64 %146
%154 = bitcast i32* %153 to <4 x i32>*
store <4 x i32> %149, <4 x i32>* %154
%155 = getelementptr inbounds i32, i32* %153, i64 4
%156 = bitcast i32* %155 to <4 x i32>*
store <4 x i32> %152, <4 x i32>* %156
%157 = or i64 %123, 24
%158 = getelementptr inbounds i32, i32* %11, i64 %157
%159 = bitcast i32* %158 to <4 x i32>*
%160 = load <4 x i32>, <4 x i32>* %159
%161 = getelementptr inbounds i32, i32* %158, i64 4
%162 = bitcast i32* %161 to <4 x i32>*
%163 = load <4 x i32>, <4 x i32>* %162
%164 = getelementptr inbounds i32, i32* %1, i64 %157
%165 = bitcast i32* %164 to <4 x i32>*
store <4 x i32> %160, <4 x i32>* %165
%166 = getelementptr inbounds i32, i32* %164, i64 4
%167 = bitcast i32* %166 to <4 x i32>*
store <4 x i32> %163, <4 x i32>* %167
%168 = add nuw i64 %123, 32
%169 = add i64 %124, 4
%170 = icmp eq i64 %169, %121
br i1 %170, label %171, label %122
171: ; preds = %122, %113
%172 = phi i64 [ 0, %113 ], [ %168, %122 ]
%173 = icmp eq i64 %118, 0
br i1 %173, label %190, label %174
174: ; preds = %171, %174
%175 = phi i64 [ %187, %174 ], [ %172, %171 ]
%176 = phi i64 [ %188, %174 ], [ 0, %171 ]
%177 = getelementptr inbounds i32, i32* %11, i64 %175
%178 = bitcast i32* %177 to <4 x i32>*
%179 = load <4 x i32>, <4 x i32>* %178
%180 = getelementptr inbounds i32, i32* %177, i64 4
%181 = bitcast i32* %180 to <4 x i32>*
%182 = load <4 x i32>, <4 x i32>* %181
%183 = getelementptr inbounds i32, i32* %1, i64 %175
%184 = bitcast i32* %183 to <4 x i32>*
store <4 x i32> %179, <4 x i32>* %184
%185 = getelementptr inbounds i32, i32* %183, i64 4
%186 = bitcast i32* %185 to <4 x i32>*
store <4 x i32> %182, <4 x i32>* %186
%187 = add nuw i64 %175, 8
%188 = add i64 %176, 1
%189 = icmp eq i64 %188, %118
br i1 %189, label %190, label %174
190: ; preds = %174, %171
%191 = icmp eq i64 %114, %52
br i1 %191, label %260, label %192
192: ; preds = %106, %103, %190
%193 = phi i64 [ 0, %106 ], [ 0, %103 ], [ %114, %190 ]
%194 = xor i64 %193, -1
%195 = add nsw i64 %194, %52
%196 = and i64 %52, 3
%197 = icmp eq i64 %196, 0
br i1 %197, label %207, label %198
198: ; preds = %192, %198
%199 = phi i64 [ %204, %198 ], [ %193, %192 ]
%200 = phi i64 [ %205, %198 ], [ 0, %192 ]
%201 = getelementptr inbounds i32, i32* %11, i64 %199
%202 = load i32, i32* %201
%203 = getelementptr inbounds i32, i32* %1, i64 %199
store i32 %202, i32* %203
%204 = add nuw nsw i64 %199, 1
%205 = add i64 %200, 1
%206 = icmp eq i64 %205, %196
br i1 %206, label %207, label %198
207: ; preds = %198, %192
%208 = phi i64 [ %193, %192 ], [ %204, %198 ]
%209 = icmp ult i64 %195, 3
br i1 %209, label %260, label %239
210: ; preds = %210, %56
%211 = phi i64 [ 0, %56 ], [ %236, %210 ]
%212 = phi i64 [ 0, %56 ], [ %237, %210 ]
%213 = getelementptr inbounds i32, i32* %1, i64 %211
%214 = load i32, i32* %213
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds i32, i32* %25, i64 %215
%217 = load i32, i32* %216
%218 = getelementptr inbounds i32, i32* %25, i64 %211
%219 = load i32, i32* %218
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %11, i64 %220
store i32 %217, i32* %221
%222 = load i32, i32* %213
%223 = getelementptr inbounds i32, i32* %23, i64 %211
store i32 %222, i32* %223
%224 = or i64 %211, 1
%225 = getelementptr inbounds i32, i32* %1, i64 %224
%226 = load i32, i32* %225
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds i32, i32* %25, i64 %227
%229 = load i32, i32* %228
%230 = getelementptr inbounds i32, i32* %25, i64 %224
%231 = load i32, i32* %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i32, i32* %11, i64 %232
store i32 %229, i32* %233
%234 = load i32, i32* %225
%235 = getelementptr inbounds i32, i32* %23, i64 %224
store i32 %234, i32* %235
%236 = add nuw nsw i64 %211, 2
%237 = add i64 %212, 2
%238 = icmp eq i64 %237, %57
br i1 %238, label %87, label %210
239: ; preds = %207, %239
%240 = phi i64 [ %256, %239 ], [ %208, %207 ]
%241 = getelementptr inbounds i32, i32* %11, i64 %240
%242 = load i32, i32* %241
%243 = getelementptr inbounds i32, i32* %1, i64 %240
store i32 %242, i32* %243
%244 = add nuw nsw i64 %240, 1
%245 = getelementptr inbounds i32, i32* %11, i64 %244
%246 = load i32, i32* %245
%247 = getelementptr inbounds i32, i32* %1, i64 %244
store i32 %246, i32* %247
%248 = add nuw nsw i64 %240, 2
%249 = getelementptr inbounds i32, i32* %11, i64 %248
%250 = load i32, i32* %249
%251 = getelementptr inbounds i32, i32* %1, i64 %248
store i32 %250, i32* %251
%252 = add nuw nsw i64 %240, 3
%253 = getelementptr inbounds i32, i32* %11, i64 %252
%254 = load i32, i32* %253
%255 = getelementptr inbounds i32, i32* %1, i64 %252
store i32 %254, i32* %255
%256 = add nuw nsw i64 %240, 4
%257 = icmp eq i64 %256, %104
br i1 %257, label %260, label %239
258: ; preds = %102, %18, %49
%259 = call i32 @ifill(i32* %4, i32 %0, i32 -1)
br label %627
260: ; preds = %207, %239, %190
%261 = call i32 @ifill(i32* %4, i32 %0, i32 -1)
%262 = zext i32 %0 to i64
%263 = shl nuw nsw i64 %262, 2
%264 = zext i32 %0 to i64
%265 = and i64 %264, 1
%266 = icmp eq i64 %53, 0
br i1 %266, label %300, label %267
267: ; preds = %260
%268 = and i64 %264, 4294967294
br label %269
269: ; preds = %296, %267
%270 = phi i64 [ 0, %267 ], [ %297, %296 ]
%271 = phi i64 [ 0, %267 ], [ %298, %296 ]
%272 = getelementptr inbounds i32, i32* %1, i64 %270
%273 = load i32, i32* %272
%274 = icmp eq i32 %273, %0
br i1 %274, label %283, label %275
275: ; preds = %269
%276 = getelementptr inbounds i32, i32* %3, i64 %270
%277 = load i32, i32* %276
%278 = add nsw i32 %277, 1
%279 = sext i32 %273 to i64
%280 = getelementptr inbounds i32, i32* %3, i64 %279
%281 = load i32, i32* %280
%282 = add nsw i32 %278, %281
store i32 %282, i32* %280
br label %283
283: ; preds = %269, %275
%284 = or i64 %270, 1
%285 = getelementptr inbounds i32, i32* %1, i64 %284
%286 = load i32, i32* %285
%287 = icmp eq i32 %286, %0
br i1 %287, label %296, label %288
288: ; preds = %283
%289 = getelementptr inbounds i32, i32* %3, i64 %284
%290 = load i32, i32* %289
%291 = add nsw i32 %290, 1
%292 = sext i32 %286 to i64
%293 = getelementptr inbounds i32, i32* %3, i64 %292
%294 = load i32, i32* %293
%295 = add nsw i32 %291, %294
store i32 %295, i32* %293
br label %296
296: ; preds = %288, %283
%297 = add nuw nsw i64 %270, 2
%298 = add i64 %271, 2
%299 = icmp eq i64 %298, %268
br i1 %299, label %300, label %269
300: ; preds = %296, %260
%301 = phi i64 [ 0, %260 ], [ %297, %296 ]
%302 = icmp eq i64 %265, 0
br i1 %302, label %315, label %303
303: ; preds = %300
%304 = getelementptr inbounds i32, i32* %1, i64 %301
%305 = load i32, i32* %304
%306 = icmp eq i32 %305, %0
br i1 %306, label %315, label %307
307: ; preds = %303
%308 = getelementptr inbounds i32, i32* %3, i64 %301
%309 = load i32, i32* %308
%310 = add nsw i32 %309, 1
%311 = sext i32 %305 to i64
%312 = getelementptr inbounds i32, i32* %3, i64 %311
%313 = load i32, i32* %312
%314 = add nsw i32 %310, %313
store i32 %314, i32* %312
br label %315
315: ; preds = %303, %307, %300
%316 = insertelement <4 x i32> poison, i32 %0, i64 0
%317 = shufflevector <4 x i32> %316, <4 x i32> poison, <4 x i32> zeroinitializer
br label %430
318: ; preds = %600
%319 = trunc i64 %602 to i32
%320 = icmp slt i32 %319, %0
br i1 %320, label %430, label %321
321: ; preds = %318
%322 = zext i32 %0 to i64
%323 = icmp ult i32 %0, 8
br i1 %323, label %412, label %324
324: ; preds = %321
%325 = getelementptr i32, i32* %1, i64 %52
%326 = shl nsw i64 %19, 1
%327 = add nsw i64 %326, %52
%328 = add nsw i64 %327, 2
%329 = getelementptr i32, i32* %11, i64 %328
%330 = icmp ugt i32* %329, %1
%331 = icmp ult i32* %23, %325
%332 = and i1 %330, %331
br i1 %332, label %412, label %333
333: ; preds = %324
%334 = and i64 %52, 4294967288
%335 = add nsw i64 %334, -8
%336 = lshr exact i64 %335, 3
%337 = add nuw nsw i64 %336, 1
%338 = and i64 %337, 3
%339 = icmp ult i64 %335, 24
br i1 %339, label %391, label %340
340: ; preds = %333
%341 = and i64 %337, 4611686018427387900
br label %342
342: ; preds = %342, %340
%343 = phi i64 [ 0, %340 ], [ %388, %342 ]
%344 = phi i64 [ 0, %340 ], [ %389, %342 ]
%345 = getelementptr inbounds i32, i32* %23, i64 %343
%346 = bitcast i32* %345 to <4 x i32>*
%347 = load <4 x i32>, <4 x i32>* %346
%348 = getelementptr inbounds i32, i32* %345, i64 4
%349 = bitcast i32* %348 to <4 x i32>*
%350 = load <4 x i32>, <4 x i32>* %349
%351 = getelementptr inbounds i32, i32* %1, i64 %343
%352 = bitcast i32* %351 to <4 x i32>*
store <4 x i32> %347, <4 x i32>* %352
%353 = getelementptr inbounds i32, i32* %351, i64 4
%354 = bitcast i32* %353 to <4 x i32>*
store <4 x i32> %350, <4 x i32>* %354
%355 = or i64 %343, 8
%356 = getelementptr inbounds i32, i32* %23, i64 %355
%357 = bitcast i32* %356 to <4 x i32>*
%358 = load <4 x i32>, <4 x i32>* %357
%359 = getelementptr inbounds i32, i32* %356, i64 4
%360 = bitcast i32* %359 to <4 x i32>*
%361 = load <4 x i32>, <4 x i32>* %360
%362 = getelementptr inbounds i32, i32* %1, i64 %355
%363 = bitcast i32* %362 to <4 x i32>*
store <4 x i32> %358, <4 x i32>* %363
%364 = getelementptr inbounds i32, i32* %362, i64 4
%365 = bitcast i32* %364 to <4 x i32>*
store <4 x i32> %361, <4 x i32>* %365
%366 = or i64 %343, 16
%367 = getelementptr inbounds i32, i32* %23, i64 %366
%368 = bitcast i32* %367 to <4 x i32>*
%369 = load <4 x i32>, <4 x i32>* %368
%370 = getelementptr inbounds i32, i32* %367, i64 4
%371 = bitcast i32* %370 to <4 x i32>*
%372 = load <4 x i32>, <4 x i32>* %371
%373 = getelementptr inbounds i32, i32* %1, i64 %366
%374 = bitcast i32* %373 to <4 x i32>*
store <4 x i32> %369, <4 x i32>* %374
%375 = getelementptr inbounds i32, i32* %373, i64 4
%376 = bitcast i32* %375 to <4 x i32>*
store <4 x i32> %372, <4 x i32>* %376
%377 = or i64 %343, 24
%378 = getelementptr inbounds i32, i32* %23, i64 %377
%379 = bitcast i32* %378 to <4 x i32>*
%380 = load <4 x i32>, <4 x i32>* %379
%381 = getelementptr inbounds i32, i32* %378, i64 4
%382 = bitcast i32* %381 to <4 x i32>*
%383 = load <4 x i32>, <4 x i32>* %382
%384 = getelementptr inbounds i32, i32* %1, i64 %377
%385 = bitcast i32* %384 to <4 x i32>*
store <4 x i32> %380, <4 x i32>* %385
%386 = getelementptr inbounds i32, i32* %384, i64 4
%387 = bitcast i32* %386 to <4 x i32>*
store <4 x i32> %383, <4 x i32>* %387
%388 = add nuw i64 %343, 32
%389 = add i64 %344, 4
%390 = icmp eq i64 %389, %341
br i1 %390, label %391, label %342
391: ; preds = %342, %333
%392 = phi i64 [ 0, %333 ], [ %388, %342 ]
%393 = icmp eq i64 %338, 0
br i1 %393, label %410, label %394
394: ; preds = %391, %394
%395 = phi i64 [ %407, %394 ], [ %392, %391 ]
%396 = phi i64 [ %408, %394 ], [ 0, %391 ]
%397 = getelementptr inbounds i32, i32* %23, i64 %395
%398 = bitcast i32* %397 to <4 x i32>*
%399 = load <4 x i32>, <4 x i32>* %398
%400 = getelementptr inbounds i32, i32* %397, i64 4
%401 = bitcast i32* %400 to <4 x i32>*
%402 = load <4 x i32>, <4 x i32>* %401
%403 = getelementptr inbounds i32, i32* %1, i64 %395
%404 = bitcast i32* %403 to <4 x i32>*
store <4 x i32> %399, <4 x i32>* %404
%405 = getelementptr inbounds i32, i32* %403, i64 4
%406 = bitcast i32* %405 to <4 x i32>*
store <4 x i32> %402, <4 x i32>* %406
%407 = add nuw i64 %395, 8
%408 = add i64 %396, 1
%409 = icmp eq i64 %408, %338
br i1 %409, label %410, label %394
410: ; preds = %394, %391
%411 = icmp eq i64 %334, %52
br i1 %411, label %627, label %412
412: ; preds = %324, %321, %410
%413 = phi i64 [ 0, %324 ], [ 0, %321 ], [ %334, %410 ]
%414 = xor i64 %413, -1
%415 = add nsw i64 %414, %264
%416 = and i64 %264, 3
%417 = icmp eq i64 %416, 0
br i1 %417, label %427, label %418
418: ; preds = %412, %418
%419 = phi i64 [ %424, %418 ], [ %413, %412 ]
%420 = phi i64 [ %425, %418 ], [ 0, %412 ]
%421 = getelementptr inbounds i32, i32* %23, i64 %419
%422 = load i32, i32* %421
%423 = getelementptr inbounds i32, i32* %1, i64 %419
store i32 %422, i32* %423
%424 = add nuw nsw i64 %419, 1
%425 = add i64 %420, 1
%426 = icmp eq i64 %425, %416
br i1 %426, label %427, label %418
427: ; preds = %418, %412
%428 = phi i64 [ %413, %412 ], [ %424, %418 ]
%429 = icmp ult i64 %415, 3
br i1 %429, label %627, label %608
430: ; preds = %315, %318
%431 = phi i32 [ %319, %318 ], [ 0, %315 ]
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds i32, i32* %1, i64 %432
%434 = load i32, i32* %433
%435 = icmp eq i32 %434, %0
br i1 %435, label %455, label %436
436: ; preds = %430
%437 = sext i32 %434 to i64
%438 = getelementptr inbounds i32, i32* %3, i64 %437
%439 = load i32, i32* %438
%440 = icmp slt i32 %439, %2
br i1 %440, label %441, label %452
441: ; preds = %436, %447
%442 = phi i64 [ %448, %447 ], [ %437, %436 ]
%443 = phi i32 [ %445, %447 ], [ %434, %436 ]
%444 = getelementptr inbounds i32, i32* %1, i64 %442
%445 = load i32, i32* %444
%446 = icmp eq i32 %445, %0
br i1 %446, label %452, label %447
447: ; preds = %441
%448 = sext i32 %445 to i64
%449 = getelementptr inbounds i32, i32* %3, i64 %448
%450 = load i32, i32* %449
%451 = icmp slt i32 %450, %2
br i1 %451, label %441, label %452
452: ; preds = %441, %447, %436
%453 = phi i32 [ %431, %436 ], [ %443, %447 ], [ %443, %441 ]
%454 = icmp slt i32 %453, %431
br i1 %454, label %542, label %455
455: ; preds = %430, %452
%456 = phi i32 [ %453, %452 ], [ %431, %430 ]
%457 = add i32 %456, 1
%458 = sub i32 %456, %431
%459 = zext i32 %458 to i64
%460 = add nuw nsw i64 %459, 1
%461 = icmp ult i32 %458, 7
br i1 %461, label %529, label %462
462: ; preds = %455
%463 = and i64 %460, 8589934584
%464 = add nsw i64 %463, %432
%465 = add nsw i64 %463, -8
%466 = lshr exact i64 %465, 3
%467 = add nuw nsw i64 %466, 1
%468 = and i64 %467, 1
%469 = icmp eq i64 %465, 0
br i1 %469, label %503, label %470
470: ; preds = %462
%471 = and i64 %467, 4611686018427387902
br label %472
472: ; preds = %472, %470
%473 = phi i64 [ 0, %470 ], [ %500, %472 ]
%474 = phi <4 x i32> [ %317, %470 ], [ %498, %472 ]
%475 = phi <4 x i32> [ %317, %470 ], [ %499, %472 ]
%476 = phi i64 [ 0, %470 ], [ %501, %472 ]
%477 = add i64 %473, %432
%478 = getelementptr inbounds i32, i32* %21, i64 %477
%479 = bitcast i32* %478 to <4 x i32>*
%480 = load <4 x i32>, <4 x i32>* %479
%481 = getelementptr inbounds i32, i32* %478, i64 4
%482 = bitcast i32* %481 to <4 x i32>*
%483 = load <4 x i32>, <4 x i32>* %482
%484 = icmp slt <4 x i32> %474, %480
%485 = icmp slt <4 x i32> %475, %483
%486 = select <4 x i1> %484, <4 x i32> %474, <4 x i32> %480
%487 = select <4 x i1> %485, <4 x i32> %475, <4 x i32> %483
%488 = or i64 %473, 8
%489 = add i64 %488, %432
%490 = getelementptr inbounds i32, i32* %21, i64 %489
%491 = bitcast i32* %490 to <4 x i32>*
%492 = load <4 x i32>, <4 x i32>* %491
%493 = getelementptr inbounds i32, i32* %490, i64 4
%494 = bitcast i32* %493 to <4 x i32>*
%495 = load <4 x i32>, <4 x i32>* %494
%496 = icmp slt <4 x i32> %486, %492
%497 = icmp slt <4 x i32> %487, %495
%498 = select <4 x i1> %496, <4 x i32> %486, <4 x i32> %492
%499 = select <4 x i1> %497, <4 x i32> %487, <4 x i32> %495
%500 = add nuw i64 %473, 16
%501 = add i64 %476, 2
%502 = icmp eq i64 %501, %471
br i1 %502, label %503, label %472
503: ; preds = %472, %462
%504 = phi <4 x i32> [ undef, %462 ], [ %498, %472 ]
%505 = phi <4 x i32> [ undef, %462 ], [ %499, %472 ]
%506 = phi i64 [ 0, %462 ], [ %500, %472 ]
%507 = phi <4 x i32> [ %317, %462 ], [ %498, %472 ]
%508 = phi <4 x i32> [ %317, %462 ], [ %499, %472 ]
%509 = icmp eq i64 %468, 0
br i1 %509, label %522, label %510
510: ; preds = %503
%511 = add i64 %506, %432
%512 = getelementptr inbounds i32, i32* %21, i64 %511
%513 = bitcast i32* %512 to <4 x i32>*
%514 = load <4 x i32>, <4 x i32>* %513
%515 = getelementptr inbounds i32, i32* %512, i64 4
%516 = bitcast i32* %515 to <4 x i32>*
%517 = load <4 x i32>, <4 x i32>* %516
%518 = icmp slt <4 x i32> %507, %514
%519 = icmp slt <4 x i32> %508, %517
%520 = select <4 x i1> %518, <4 x i32> %507, <4 x i32> %514
%521 = select <4 x i1> %519, <4 x i32> %508, <4 x i32> %517
br label %522
522: ; preds = %503, %510
%523 = phi <4 x i32> [ %504, %503 ], [ %520, %510 ]
%524 = phi <4 x i32> [ %505, %503 ], [ %521, %510 ]
%525 = icmp slt <4 x i32> %523, %524
%526 = select <4 x i1> %525, <4 x i32> %523, <4 x i32> %524
%527 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %526)
%528 = icmp eq i64 %460, %463
br i1 %528, label %542, label %529
529: ; preds = %455, %522
%530 = phi i64 [ %432, %455 ], [ %464, %522 ]
%531 = phi i32 [ %0, %455 ], [ %527, %522 ]
br label %532
532: ; preds = %529, %532
%533 = phi i64 [ %539, %532 ], [ %530, %529 ]
%534 = phi i32 [ %538, %532 ], [ %531, %529 ]
%535 = getelementptr inbounds i32, i32* %21, i64 %533
%536 = load i32, i32* %535
%537 = icmp slt i32 %534, %536
%538 = select i1 %537, i32 %534, i32 %536
%539 = add nsw i64 %533, 1
%540 = trunc i64 %539 to i32
%541 = icmp eq i32 %457, %540
br i1 %541, label %542, label %532
542: ; preds = %532, %522, %452
%543 = phi i1 [ true, %452 ], [ false, %522 ], [ false, %532 ]
%544 = phi i32 [ %453, %452 ], [ %456, %522 ], [ %456, %532 ]
%545 = phi i32 [ %0, %452 ], [ %527, %522 ], [ %538, %532 ]
%546 = sext i32 %544 to i64
%547 = getelementptr inbounds i32, i32* %21, i64 %546
%548 = load i32, i32* %547
%549 = sub nsw i32 %548, %545
%550 = sub i32 %544, %431
%551 = icmp eq i32 %549, %550
br i1 %551, label %572, label %552
552: ; preds = %542
br i1 %543, label %599, label %553
553: ; preds = %552
%554 = add i32 %544, 1
%555 = sub i32 %554, %431
%556 = and i32 %555, 1
%557 = icmp eq i32 %556, 0
br i1 %557, label %569, label %558
558: ; preds = %553
%559 = getelementptr inbounds i32, i32* %21, i64 %432
%560 = load i32, i32* %559
%561 = getelementptr inbounds i32, i32* %3, i64 %432
%562 = load i32, i32* %561
%563 = icmp eq i32 %562, 0
br i1 %563, label %564, label %567
564: ; preds = %558
%565 = sext i32 %560 to i64
%566 = getelementptr inbounds i32, i32* %4, i64 %565
store i32 %560, i32* %566
br label %567
567: ; preds = %564, %558
%568 = add nsw i64 %432, 1
br label %569
569: ; preds = %567, %553
%570 = phi i64 [ %432, %553 ], [ %568, %567 ]
%571 = icmp eq i32 %550, 0
br i1 %571, label %599, label %575
572: ; preds = %542
%573 = sext i32 %545 to i64
%574 = getelementptr inbounds i32, i32* %4, i64 %573
store i32 %548, i32* %574
br label %599
575: ; preds = %569, %595
%576 = phi i64 [ %596, %595 ], [ %570, %569 ]
%577 = getelementptr inbounds i32, i32* %21, i64 %576
%578 = load i32, i32* %577
%579 = getelementptr inbounds i32, i32* %3, i64 %576
%580 = load i32, i32* %579
%581 = icmp eq i32 %580, 0
br i1 %581, label %582, label %585
582: ; preds = %575
%583 = sext i32 %578 to i64
%584 = getelementptr inbounds i32, i32* %4, i64 %583
store i32 %578, i32* %584
br label %585
585: ; preds = %575, %582
%586 = add nsw i64 %576, 1
%587 = getelementptr inbounds i32, i32* %21, i64 %586
%588 = load i32, i32* %587
%589 = getelementptr inbounds i32, i32* %3, i64 %586
%590 = load i32, i32* %589
%591 = icmp eq i32 %590, 0
br i1 %591, label %592, label %595
592: ; preds = %585
%593 = sext i32 %588 to i64
%594 = getelementptr inbounds i32, i32* %4, i64 %593
store i32 %588, i32* %594
br label %595
595: ; preds = %592, %585
%596 = add nsw i64 %576, 2
%597 = trunc i64 %596 to i32
%598 = icmp eq i32 %554, %597
br i1 %598, label %599, label %575
599: ; preds = %569, %595, %552, %572
br label %600
600: ; preds = %599, %600
%601 = phi i64 [ %602, %600 ], [ %546, %599 ]
%602 = add nsw i64 %601, 1
%603 = getelementptr inbounds i32, i32* %3, i64 %602
%604 = load i32, i32* %603
%605 = icmp ne i32 %604, 0
%606 = icmp slt i64 %602, %19
%607 = select i1 %605, i1 %606, i1 false
br i1 %607, label %600, label %318
608: ; preds = %427, %608
%609 = phi i64 [ %625, %608 ], [ %428, %427 ]
%610 = getelementptr inbounds i32, i32* %23, i64 %609
%611 = load i32, i32* %610
%612 = getelementptr inbounds i32, i32* %1, i64 %609
store i32 %611, i32* %612
%613 = add nuw nsw i64 %609, 1
%614 = getelementptr inbounds i32, i32* %23, i64 %613
%615 = load i32, i32* %614
%616 = getelementptr inbounds i32, i32* %1, i64 %613
store i32 %615, i32* %616
%617 = add nuw nsw i64 %609, 2
%618 = getelementptr inbounds i32, i32* %23, i64 %617
%619 = load i32, i32* %618
%620 = getelementptr inbounds i32, i32* %1, i64 %617
store i32 %619, i32* %620
%621 = add nuw nsw i64 %609, 3
%622 = getelementptr inbounds i32, i32* %23, i64 %621
%623 = load i32, i32* %622
%624 = getelementptr inbounds i32, i32* %1, i64 %621
store i32 %623, i32* %624
%625 = add nuw nsw i64 %609, 4
%626 = icmp eq i64 %625, %322
br i1 %626, label %627, label %608
627: ; preds = %427, %608, %410, %258
%628 = call i32 @superlu_free(i32* %25)
%629 = call i32 @superlu_free(i32* %11)
ret void
}