#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*/ WriteSLUErrorMessage(char *);
int /*<<< orphan*/ ifill(int *, int const, int);
scalar_t__ intMalloc(int);
int /*<<< orphan*/ sprintf_s(char *, int, char *, 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_s(msg, 256, "Error: %s", "SUPERLU_MALLOC fails for iwork[]");
    WriteSLUErrorMessage(msg);
    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;
      }
    }
    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   1070 <intMalloc@plt>
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
jne    11ed <heap_relax_snode+0x7d>
lea    -0x170(%rbp),%rdi
mov    $0x100,%esi
lea    0xe37(%rip),%rdx
lea    0xe3a(%rip),%rcx
call   1030 <sprintf_s@plt>
lea    -0x170(%rbp),%rdi
call   1060 <WriteSLUErrorMessage@plt>
lea    -0x170(%rbp),%rdi
call   1040 <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   1090 <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    1267 <heap_relax_snode+0xf7>
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    1232 <heap_relax_snode+0xc2>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12c4 <heap_relax_snode+0x154>
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    126e <heap_relax_snode+0xfe>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12fb <heap_relax_snode+0x18b>
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    12cb <heap_relax_snode+0x15b>
mov    -0x28(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    $0xffffffff,%edx
call   1050 <ifill@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    133c <heap_relax_snode+0x1cc>
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    1313 <heap_relax_snode+0x1a3>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1398 <heap_relax_snode+0x228>
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     1385 <heap_relax_snode+0x215>
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    138a <heap_relax_snode+0x21a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1343 <heap_relax_snode+0x1d3>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    156f <heap_relax_snode+0x3ff>
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     13ea <heap_relax_snode+0x27a>
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    13fd <heap_relax_snode+0x28d>
jmp    1416 <heap_relax_snode+0x2a6>
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    13bf <heap_relax_snode+0x24f>
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     1481 <heap_relax_snode+0x311>
mov    -0x34(%rbp),%eax
mov    -0x58(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1459 <heap_relax_snode+0x2e9>
mov    -0x34(%rbp),%eax
mov    %eax,-0x178(%rbp)
jmp    146a <heap_relax_snode+0x2fa>
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    142b <heap_relax_snode+0x2bb>
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    14bf <heap_relax_snode+0x34f>
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    1517 <heap_relax_snode+0x3a7>
mov    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1512 <heap_relax_snode+0x3a2>
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    14ff <heap_relax_snode+0x38f>
mov    -0x38(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1504 <heap_relax_snode+0x394>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14c5 <heap_relax_snode+0x355>
jmp    1517 <heap_relax_snode+0x3a7>
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     1549 <heap_relax_snode+0x3d9>
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
setl   %al
mov    %al,-0x179(%rbp)
mov    -0x179(%rbp),%al
test   $0x1,%al
jne    155c <heap_relax_snode+0x3ec>
jmp    156a <heap_relax_snode+0x3fa>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1520 <heap_relax_snode+0x3b0>
jmp    139f <heap_relax_snode+0x22f>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15a6 <heap_relax_snode+0x436>
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    1576 <heap_relax_snode+0x406>
mov    -0x50(%rbp),%rdi
call   1080 <superlu_free@plt>
mov    -0x60(%rbp),%rdi
call   1080 <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   1080 <intMalloc@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
jne    11e5 <heap_relax_snode+0x65>
lea    0xe44(%rip),%rdx
lea    0xe47(%rip),%rcx
lea    0x50(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x100,%esi
call   1030 <sprintf_s@plt>
mov    %rbx,%rdi
call   1070 <WriteSLUErrorMessage@plt>
mov    %rbx,%rdi
call   1040 <superlu_abort_and_exit@plt>
mov    %ebp,%edi
mov    %r15,%rsi
call   10a0 <TreePostorder@plt>
test   %ebp,%ebp
mov    0x8(%rsp),%r11
mov    0x10(%rsp),%rdi
js     13c4 <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    122b <heap_relax_snode+0xab>
xor    %ecx,%ecx
test   %rbx,%rbx
jne    1270 <heap_relax_snode+0xf0>
jmp    1282 <heap_relax_snode+0x102>
and    $0xfffffffc,%edx
xor    %ecx,%ecx
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    1230 <heap_relax_snode+0xb0>
mov    0x28(%rsp),%rbp
test   %rbx,%rbx
je     1282 <heap_relax_snode+0x102>
nop
movslq (%rax,%rcx,4),%rdx
mov    %ecx,(%r14,%rdx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbx
jne    1270 <heap_relax_snode+0xf0>
test   %ebp,%ebp
jle    13c4 <heap_relax_snode+0x244>
lea    (%r11,%r12,4),%r8
mov    %r9d,%r10d
mov    %r10,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,0x48(%rsp)
je     12eb <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    12b0 <heap_relax_snode+0x130>
jmp    12ed <heap_relax_snode+0x16d>
xor    %ecx,%ecx
lea    (%r8,%r12,4),%rsi
add    $0x8,%rsi
test   $0x1,%r10b
je     1317 <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    13c4 <heap_relax_snode+0x244>
cmp    $0x8,%ebp
mov    %r9,0x20(%rsp)
mov    %rsi,0x38(%rsp)
jb     134d <heap_relax_snode+0x1cd>
lea    (%r11,%r10,4),%rcx
cmp    %r15,%rcx
jbe    13f7 <heap_relax_snode+0x277>
lea    (%r15,%r10,4),%rcx
cmp    %rcx,%r11
jae    13f7 <heap_relax_snode+0x277>
xor    %ebx,%ebx
mov    %rbx,%rcx
not    %rcx
add    %r10,%rcx
mov    %r10,%rdx
and    $0x3,%rdx
je     1382 <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    1370 <heap_relax_snode+0x1f0>
cmp    $0x3,%rcx
jb     14e6 <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    1390 <heap_relax_snode+0x210>
jmp    14e6 <heap_relax_snode+0x366>
mov    %ebp,%esi
mov    $0xffffffff,%edx
mov    %rax,%rbx
call   1060 <ifill@plt>
mov    %rbx,%rdi
call   1090 <superlu_free@plt>
mov    0x8(%rsp),%rdi
call   1090 <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    1420 <heap_relax_snode+0x2a0>
xor    %esi,%esi
jmp    149a <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    1430 <heap_relax_snode+0x2b0>
test   %r8,%r8
je     14dd <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    14c0 <heap_relax_snode+0x340>
cmp    %r10,%rbx
jne    134f <heap_relax_snode+0x1cf>
mov    %r10,0x40(%rsp)
mov    %rax,0x18(%rsp)
mov    %ebp,%esi
mov    $0xffffffff,%edx
call   1060 <ifill@plt>
mov    0x20(%rsp),%rbp
lea    0x0(,%rbp,4),%rdx
xor    %ebx,%ebx
mov    %r13,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
cmpq   $0x0,0x48(%rsp)
je     1584 <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    1549 <heap_relax_snode+0x3c9>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rbx
cmp    %rbx,%rax
je     1591 <heap_relax_snode+0x411>
movslq (%r15,%rbx,4),%rcx
cmp    %ebp,%ecx
je     1565 <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     1540 <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    1540 <heap_relax_snode+0x3c0>
mov    0x8(%rsp),%rdi
mov    %rbp,%r9
mov    0x10(%rsp),%r8
test   $0x1,%r9b
mov    0x28(%rsp),%rsi
je     15b8 <heap_relax_snode+0x438>
movslq (%r15,%rbx,4),%rax
cmp    %esi,%eax
je     15b8 <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    15dd <heap_relax_snode+0x45d>
nopl   (%rax)
mov    0x28(%rsp),%rsi
cmp    %esi,%edx
jge    1889 <heap_relax_snode+0x709>
mov    %edx,%r10d
movslq %edx,%rdi
mov    (%r15,%rdi,4),%eax
cmp    %esi,%eax
je     1622 <heap_relax_snode+0x4a2>
movslq %eax,%rcx
mov    %r10d,%edx
mov    0x34(%rsp),%ebp
cmp    %ebp,0x0(%r13,%rcx,4)
jge    1614 <heap_relax_snode+0x494>
nopl   0x0(%rax)
mov    %eax,%edx
mov    (%r15,%rcx,4),%eax
cmp    %esi,%eax
je     1614 <heap_relax_snode+0x494>
movslq %eax,%rcx
cmp    %ebp,0x0(%r13,%rcx,4)
jl     1600 <heap_relax_snode+0x480>
mov    $0x1,%r11b
mov    %esi,%eax
cmp    %r10d,%edx
jl     17ae <heap_relax_snode+0x62e>
mov    %edx,%r8d
sub    %r10d,%edx
mov    %rdi,%rcx
mov    %esi,%eax
cmp    $0x7,%edx
jb     1781 <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     1870 <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    1680 <heap_relax_snode+0x500>
test   $0x1,%r11b
je     172f <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     17a3 <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    1790 <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    17d0 <heap_relax_snode+0x650>
cltq
mov    %ebp,(%r8,%rax,4)
jmp    1840 <heap_relax_snode+0x6c0>
nopw   0x0(%rax,%rax,1)
test   %r11b,%r11b
jne    1840 <heap_relax_snode+0x6c0>
lea    0x1(%rdx),%ebp
mov    %ebp,%eax
sub    %r10d,%eax
test   $0x1,%al
je     17f7 <heap_relax_snode+0x677>
cmpl   $0x0,0x0(%r13,%rdi,4)
jne    17f3 <heap_relax_snode+0x673>
mov    (%r14,%rdi,4),%eax
cltq
mov    %eax,(%r8,%rax,4)
add    $0x1,%rdi
test   %esi,%esi
je     1840 <heap_relax_snode+0x6c0>
mov    %ebp,%eax
jmp    181c <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     182c <heap_relax_snode+0x6ac>
add    $0x2,%rdi
cmp    %edi,%eax
je     1840 <heap_relax_snode+0x6c0>
cmpl   $0x0,0x0(%r13,%rdi,4)
je     1800 <heap_relax_snode+0x680>
cmpl   $0x0,0x4(%r13,%rdi,4)
jne    1814 <heap_relax_snode+0x694>
mov    -0x2c(%r9,%rdi,4),%esi
movslq %esi,%rsi
mov    %esi,(%r8,%rsi,4)
jmp    1814 <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     15d0 <heap_relax_snode+0x450>
lea    0x1(%rcx),%rax
cmp    %r12,%rcx
mov    %rax,%rcx
jl     1850 <heap_relax_snode+0x6d0>
jmp    15d0 <heap_relax_snode+0x450>
xor    %ebx,%ebx
movdqa %xmm0,%xmm1
movdqa %xmm0,%xmm2
test   $0x1,%r11b
jne    16f7 <heap_relax_snode+0x577>
jmp    172f <heap_relax_snode+0x5af>
cmp    $0x8,%esi
jae    18a9 <heap_relax_snode+0x729>
xor    %eax,%eax
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%rbx
mov    0x40(%rsp),%r8
mov    0x38(%rsp),%r9
jmp    19f8 <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    18e6 <heap_relax_snode+0x766>
lea    (%r15,%r8,4),%rax
cmp    %rax,%r9
jae    18e6 <heap_relax_snode+0x766>
xor    %eax,%eax
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%rbx
jmp    19f8 <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    1912 <heap_relax_snode+0x792>
xor    %esi,%esi
mov    0x18(%rsp),%rdi
jmp    19a4 <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    1940 <heap_relax_snode+0x7c0>
test   %rcx,%rcx
mov    0x20(%rsp),%rbx
je     19ef <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    19d0 <heap_relax_snode+0x850>
cmp    %r8,%rax
je     13d6 <heap_relax_snode+0x256>
mov    %rax,%rcx
not    %rcx
add    %rbx,%rcx
and    $0x3,%rbx
je     1a22 <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    1a10 <heap_relax_snode+0x890>
cmp    $0x3,%rcx
jb     13d6 <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    1a40 <heap_relax_snode+0x8c0>
jmp    13d6 <heap_relax_snode+0x256>

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