int sldperm(int job, int n, int nnz, int colptr[], int adjncy[], float nzval[],
            int *perm, float u[], float v[]) {
  int i, liw, ldw, num;
  int *iw, icntl[10], info[10];
  double *dw;
  double *nzval_d = (double *)superlu_malloc(nnz * sizeof(double));
  liw = 5 * n;
  if (job == 3)
    liw = 10 * n + nnz;
  if (!(iw = intMalloc(liw))) {
    char msg[256];
    sprintf(msg, "%s at line %d in file %s\n", "Malloc fails for iw[]", 98,
            "/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/sldperm.c");
    superlu_abort_and_exit(msg);
  };
  ldw = 3 * n + nnz;
  if (!(dw = (double *)superlu_malloc(ldw * sizeof(double)))) {
    char msg[256];
    sprintf(msg, "%s at line %d in file %s\n", "Malloc fails for dw[]", 101,
            "/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/sldperm.c");
    superlu_abort_and_exit(msg);
  };
  for (i = 0; i <= n; ++i)
    ++colptr[i];
  for (i = 0; i < nnz; ++i)
    ++adjncy[i];
  mc64id_(icntl);
  for (i = 0; i < nnz; ++i)
    nzval_d[i] = nzval[i];
  mc64ad_(&job, &n, &nnz, colptr, adjncy, nzval_d, &num, perm, &liw, iw, &ldw,
          dw, icntl, info);
  if (info[0] == 1) {
    printf(".. The last %d permutations:\n", n - num);
    slu_PrintInt10("perm", n - num, &perm[num]);
  }
  for (i = 0; i <= n; ++i)
    --colptr[i];
  for (i = 0; i < nnz; ++i)
    --adjncy[i];
  for (i = 0; i < n; ++i)
    --perm[i];
  if (job == 5)
    for (i = 0; i < n; ++i) {
      u[i] = dw[i];
      v[i] = dw[n + i];
    }
  superlu_free(iw);
  superlu_free(dw);
  superlu_free(nzval_d);
  return info[0];
}


x86 assembly (clang, -O0):
<sldperm>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2e8,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x2c(%rbp)
mov    %esi,-0x30(%rbp)
mov    %edx,-0x34(%rbp)
mov    %rcx,-0x40(%rbp)
mov    %r8,-0x48(%rbp)
mov    %r9,-0x50(%rbp)
movslq -0x34(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1090 <superlu_malloc@plt>
cltq
mov    %rax,-0xd0(%rbp)
imul   $0x5,-0x30(%rbp),%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jne    11f8 <sldperm+0x68>
imul   $0xa,-0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%edi
mov    $0x0,%al
call   1080 <intMalloc@plt>
cltq
mov    %rax,-0x68(%rbp)
cmp    $0x0,%rax
jne    1248 <sldperm+0xb8>
lea    -0x1d0(%rbp),%rdi
lea    0xde0(%rip),%rsi
lea    0xdf3(%rip),%rdx
mov    $0x62,%ecx
lea    0xdfd(%rip),%r8
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x1d0(%rbp),%rdi
mov    $0x0,%al
call   1050 <superlu_abort_and_exit@plt>
imul   $0x3,-0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movslq -0x5c(%rbp),%rdi
shl    $0x3,%rdi
mov    $0x0,%al
call   1090 <superlu_malloc@plt>
cltq
mov    %rax,-0xc8(%rbp)
cmp    $0x0,%rax
jne    12aa <sldperm+0x11a>
lea    -0x2d0(%rbp),%rdi
lea    0xd7e(%rip),%rsi
lea    0xe47(%rip),%rdx
mov    $0x65,%ecx
lea    0xd9b(%rip),%r8
mov    $0x0,%al
call   10b0 <sprintf@plt>
lea    -0x2d0(%rbp),%rdi
mov    $0x0,%al
call   1050 <superlu_abort_and_exit@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     12dc <sldperm+0x14c>
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12b1 <sldperm+0x121>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    130e <sldperm+0x17e>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12e3 <sldperm+0x153>
lea    -0x90(%rbp),%rdi
mov    $0x0,%al
call   1040 <mc64id_@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    135e <sldperm+0x1ce>
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0xd0(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1323 <sldperm+0x193>
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%r8
mov    -0xd0(%rbp),%r9
mov    0x10(%rbp),%r12
mov    -0x68(%rbp),%r14
mov    -0xc8(%rbp),%r11
lea    -0x90(%rbp),%r10
lea    -0xc0(%rbp),%rax
lea    -0x2c(%rbp),%rdi
lea    -0x30(%rbp),%rsi
lea    -0x34(%rbp),%rdx
lea    -0x60(%rbp),%r13
lea    -0x58(%rbp),%r15
lea    -0x5c(%rbp),%rbx
mov    %r13,(%rsp)
mov    %r12,0x8(%rsp)
mov    %r15,0x10(%rsp)
mov    %r14,0x18(%rsp)
mov    %rbx,0x20(%rsp)
mov    %r11,0x28(%rsp)
mov    %r10,0x30(%rsp)
mov    %rax,0x38(%rsp)
mov    $0x0,%al
call   1030 <mc64ad_@plt>
cmpl   $0x1,-0xc0(%rbp)
jne    1414 <sldperm+0x284>
mov    -0x30(%rbp),%esi
sub    -0x60(%rbp),%esi
lea    0xcfc(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    -0x30(%rbp),%esi
sub    -0x60(%rbp),%esi
mov    0x10(%rbp),%rdx
movslq -0x60(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
lea    0xcf7(%rip),%rdi
mov    $0x0,%al
call   1060 <slu_PrintInt10@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1446 <sldperm+0x2b6>
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    141b <sldperm+0x28b>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1478 <sldperm+0x2e8>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    144d <sldperm+0x2bd>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    14aa <sldperm+0x31a>
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    147f <sldperm+0x2ef>
cmpl   $0x5,-0x2c(%rbp)
jne    1521 <sldperm+0x391>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    151c <sldperm+0x38c>
mov    -0xc8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14bb <sldperm+0x32b>
jmp    1521 <sldperm+0x391>
mov    -0x68(%rbp),%rdi
mov    $0x0,%al
call   10a0 <superlu_free@plt>
mov    -0xc8(%rbp),%rdi
mov    $0x0,%al
call   10a0 <superlu_free@plt>
mov    -0xd0(%rbp),%rdi
mov    $0x0,%al
call   10a0 <superlu_free@plt>
mov    -0xc0(%rbp),%eax
add    $0x2e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<sldperm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9,%r14
mov    %r8,%r13
mov    %rcx,%rbx
mov    %esi,%r12d
mov    %edi,%ebp
mov    %edi,0x24(%rsp)
mov    %esi,0xc(%rsp)
mov    %edx,0x20(%rsp)
mov    %edx,0x10(%rsp)
movslq %edx,%r15
lea    0x0(,%r15,8),%rdi
xor    %eax,%eax
call   1090 <superlu_malloc@plt>
mov    %eax,0x30(%rsp)
cmp    $0x3,%ebp
lea    (%r12,%r12,4),%eax
lea    (%r15,%rax,2),%edi
cmovne %eax,%edi
mov    %edi,0x3c(%rsp)
xor    %eax,%eax
call   1080 <intMalloc@plt>
mov    %eax,0x28(%rsp)
test   %eax,%eax
jne    1229 <sldperm+0x99>
lea    0xe03(%rip),%rsi
lea    0xe16(%rip),%rdx
lea    0xe25(%rip),%r8
lea    0x70(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x62,%ecx
xor    %eax,%eax
call   10b0 <sprintf@plt>
mov    %rbp,%rdi
xor    %eax,%eax
call   1050 <superlu_abort_and_exit@plt>
lea    (%r12,%r12,2),%eax
mov    0x10(%rsp),%r15d
add    %r15d,%eax
mov    %eax,0x38(%rsp)
movslq %eax,%rdi
shl    $0x3,%rdi
xor    %eax,%eax
call   1090 <superlu_malloc@plt>
mov    %eax,%r8d
test   %eax,%eax
je     1258 <sldperm+0xc8>
test   %r12d,%r12d
jns    1299 <sldperm+0x109>
jmp    136d <sldperm+0x1dd>
lea    0xda1(%rip),%rsi
lea    0xe6a(%rip),%rdx
mov    %r8d,%ebp
lea    0xdc0(%rip),%r8
lea    0x70(%rsp),%rdi
mov    $0x65,%ecx
xor    %eax,%eax
call   10b0 <sprintf@plt>
lea    0x70(%rsp),%rdi
xor    %eax,%eax
call   1050 <superlu_abort_and_exit@plt>
mov    %ebp,%r8d
test   %r12d,%r12d
js     136d <sldperm+0x1dd>
lea    0x1(%r12),%eax
cmp    $0x7,%r12d
jae    12ab <sldperm+0x11b>
xor    %ecx,%ecx
jmp    1360 <sldperm+0x1d0>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     195e <sldperm+0x7ce>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
pcmpeqd %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%rbx,%rdx,4),%xmm1
movdqu 0x10(%rbx,%rdx,4),%xmm2
movdqu 0x20(%rbx,%rdx,4),%xmm3
movdqu 0x30(%rbx,%rdx,4),%xmm4
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdx,4)
movdqu %xmm2,0x10(%rbx,%rdx,4)
psubd  %xmm0,%xmm3
psubd  %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rdx,4)
movdqu %xmm4,0x30(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    12e0 <sldperm+0x150>
test   $0x1,%sil
je     1350 <sldperm+0x1c0>
movdqu (%rbx,%rdx,4),%xmm0
movdqu 0x10(%rbx,%rdx,4),%xmm1
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm0
psubd  %xmm2,%xmm1
movdqu %xmm0,(%rbx,%rdx,4)
movdqu %xmm1,0x10(%rbx,%rdx,4)
cmp    %rax,%rcx
je     136d <sldperm+0x1dd>
cs nopw 0x0(%rax,%rax,1)
nop
addl   $0x1,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1360 <sldperm+0x1d0>
mov    0x1b0(%rsp),%r12
movslq 0x30(%rsp),%rbp
movslq 0x28(%rsp),%rax
mov    %rax,0x28(%rsp)
movslq %r8d,%rax
test   %r15d,%r15d
mov    %rax,0x30(%rsp)
jle    13a3 <sldperm+0x213>
mov    %r15d,%eax
mov    %r15d,%r15d
cmp    $0x8,%eax
jae    13b4 <sldperm+0x224>
xor    %eax,%eax
jmp    1470 <sldperm+0x2e0>
lea    0x70(%rsp),%rdi
xor    %eax,%eax
call   1040 <mc64id_@plt>
jmp    1549 <sldperm+0x3b9>
mov    %r15d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     196f <sldperm+0x7df>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
pcmpeqd %xmm0,%xmm0
nop
movdqu 0x0(%r13,%rcx,4),%xmm1
movdqu 0x10(%r13,%rcx,4),%xmm2
movdqu 0x20(%r13,%rcx,4),%xmm3
movdqu 0x30(%r13,%rcx,4),%xmm4
psubd  %xmm0,%xmm1
psubd  %xmm0,%xmm2
movdqu %xmm1,0x0(%r13,%rcx,4)
movdqu %xmm2,0x10(%r13,%rcx,4)
psubd  %xmm0,%xmm3
psubd  %xmm0,%xmm4
movdqu %xmm3,0x20(%r13,%rcx,4)
movdqu %xmm4,0x30(%r13,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    13e0 <sldperm+0x250>
test   $0x1,%dl
je     145f <sldperm+0x2cf>
movdqu 0x0(%r13,%rcx,4),%xmm0
movdqu 0x10(%r13,%rcx,4),%xmm1
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm0
psubd  %xmm2,%xmm1
movdqu %xmm0,0x0(%r13,%rcx,4)
movdqu %xmm1,0x10(%r13,%rcx,4)
cmp    %r15,%rax
je     147f <sldperm+0x2ef>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addl   $0x1,0x0(%r13,%rax,4)
add    $0x1,%rax
cmp    %rax,%r15
jne    1470 <sldperm+0x2e0>
lea    0x70(%rsp),%rdi
xor    %eax,%eax
call   1040 <mc64id_@plt>
mov    0x10(%rsp),%eax
test   %eax,%eax
jle    1549 <sldperm+0x3b9>
cmp    $0x4,%eax
jae    14a3 <sldperm+0x313>
xor    %eax,%eax
jmp    1530 <sldperm+0x3a0>
mov    %r15d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     19b1 <sldperm+0x821>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
cvtps2pd (%r14,%rdx,4),%xmm0
cvtps2pd 0x8(%r14,%rdx,4),%xmm1
movups %xmm0,0x0(%rbp,%rdx,8)
movups %xmm1,0x10(%rbp,%rdx,8)
cvtps2pd 0x10(%r14,%rdx,4),%xmm0
cvtps2pd 0x18(%r14,%rdx,4),%xmm1
movdqu %xmm0,0x20(%rbp,%rdx,8)
movdqu %xmm1,0x30(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    14d0 <sldperm+0x340>
test   $0x1,%cl
je     1523 <sldperm+0x393>
cvtps2pd (%r14,%rdx,4),%xmm0
cvtps2pd 0x8(%r14,%rdx,4),%xmm1
movdqu %xmm0,0x0(%rbp,%rdx,8)
movdqu %xmm1,0x10(%rbp,%rdx,8)
cmp    %r15,%rax
je     1549 <sldperm+0x3b9>
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1530 <sldperm+0x3a0>
lea    0x40(%rsp),%r10
lea    0x70(%rsp),%r11
lea    0x38(%rsp),%r14
lea    0x3c(%rsp),%r15
lea    0x24(%rsp),%rdi
lea    0xc(%rsp),%rsi
lea    0x20(%rsp),%rdx
mov    %rbx,%rcx
mov    %r13,%r8
mov    %rbp,0x10(%rsp)
mov    %rbp,%r9
mov    $0x0,%eax
push   %r10
push   %r11
push   0x40(%rsp)
push   %r14
push   0x48(%rsp)
push   %r15
push   %r12
lea    0x54(%rsp),%rbp
push   %rbp
call   1030 <mc64ad_@plt>
add    $0x40,%rsp
cmpl   $0x1,0x40(%rsp)
jne    15da <sldperm+0x44a>
mov    0xc(%rsp),%esi
sub    0x1c(%rsp),%esi
lea    0xb30(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
mov    0xc(%rsp),%esi
movslq 0x1c(%rsp),%rax
sub    %eax,%esi
lea    (%r12,%rax,4),%rdx
lea    0xb31(%rip),%rdi
xor    %eax,%eax
call   1060 <slu_PrintInt10@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
mov    0x30(%rsp),%r14
mov    0x10(%rsp),%rbp
js     16bd <sldperm+0x52d>
lea    0x1(%rax),%rcx
cmp    $0x7,%eax
jae    1600 <sldperm+0x470>
xor    %edx,%edx
jmp    16b0 <sldperm+0x520>
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     197f <sldperm+0x7ef>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
pcmpeqd %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movdqu (%rbx,%rsi,4),%xmm1
movdqu 0x10(%rbx,%rsi,4),%xmm2
movdqu 0x20(%rbx,%rsi,4),%xmm3
movdqu 0x30(%rbx,%rsi,4),%xmm4
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rsi,4)
movdqu %xmm2,0x10(%rbx,%rsi,4)
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rsi,4)
movdqu %xmm4,0x30(%rbx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1630 <sldperm+0x4a0>
test   $0x1,%r8b
je     16a0 <sldperm+0x510>
movdqu (%rbx,%rsi,4),%xmm0
movdqu 0x10(%rbx,%rsi,4),%xmm1
pcmpeqd %xmm2,%xmm2
paddd  %xmm2,%xmm0
paddd  %xmm2,%xmm1
movdqu %xmm0,(%rbx,%rsi,4)
movdqu %xmm1,0x10(%rbx,%rsi,4)
cmp    %rcx,%rdx
je     16bd <sldperm+0x52d>
cs nopw 0x0(%rax,%rax,1)
nop
addl   $0xffffffff,(%rbx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    16b0 <sldperm+0x520>
mov    0x20(%rsp),%ecx
test   %ecx,%ecx
jle    179f <sldperm+0x60f>
cmp    $0x8,%ecx
jae    16d5 <sldperm+0x545>
xor    %edx,%edx
jmp    1790 <sldperm+0x600>
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     1990 <sldperm+0x800>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
pcmpeqd %xmm0,%xmm0
nop
movdqu 0x0(%r13,%rsi,4),%xmm1
movdqu 0x10(%r13,%rsi,4),%xmm2
movdqu 0x20(%r13,%rsi,4),%xmm3
movdqu 0x30(%r13,%rsi,4),%xmm4
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,0x0(%r13,%rsi,4)
movdqu %xmm2,0x10(%r13,%rsi,4)
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm4
movdqu %xmm3,0x20(%r13,%rsi,4)
movdqu %xmm4,0x30(%r13,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1700 <sldperm+0x570>
test   $0x1,%bl
je     177f <sldperm+0x5ef>
movdqu 0x0(%r13,%rsi,4),%xmm0
movdqu 0x10(%r13,%rsi,4),%xmm1
pcmpeqd %xmm2,%xmm2
paddd  %xmm2,%xmm0
paddd  %xmm2,%xmm1
movdqu %xmm0,0x0(%r13,%rsi,4)
movdqu %xmm1,0x10(%r13,%rsi,4)
cmp    %rcx,%rdx
je     179f <sldperm+0x60f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addl   $0xffffffff,0x0(%r13,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1790 <sldperm+0x600>
test   %eax,%eax
jle    1a35 <sldperm+0x8a5>
cmp    $0x8,%eax
jae    17b3 <sldperm+0x623>
xor    %ecx,%ecx
jmp    1870 <sldperm+0x6e0>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     19a0 <sldperm+0x810>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
pcmpeqd %xmm0,%xmm0
nopl   (%rax)
movdqu (%r12,%rdx,4),%xmm1
movdqu 0x10(%r12,%rdx,4),%xmm2
movdqu 0x20(%r12,%rdx,4),%xmm3
movdqu 0x30(%r12,%rdx,4),%xmm4
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%r12,%rdx,4)
movdqu %xmm2,0x10(%r12,%rdx,4)
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm4
movdqu %xmm3,0x20(%r12,%rdx,4)
movdqu %xmm4,0x30(%r12,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    17e0 <sldperm+0x650>
test   $0x1,%sil
je     185c <sldperm+0x6cc>
movdqu (%r12,%rdx,4),%xmm0
movdqu 0x10(%r12,%rdx,4),%xmm1
pcmpeqd %xmm2,%xmm2
paddd  %xmm2,%xmm0
paddd  %xmm2,%xmm1
movdqu %xmm0,(%r12,%rdx,4)
movdqu %xmm1,0x10(%r12,%rdx,4)
cmp    %rax,%rcx
je     187e <sldperm+0x6ee>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addl   $0xffffffff,(%r12,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1870 <sldperm+0x6e0>
cmpl   $0x5,0x24(%rsp)
jne    1a35 <sldperm+0x8a5>
test   %eax,%eax
jle    1a35 <sldperm+0x8a5>
mov    0x1c0(%rsp),%rcx
mov    0x1b8(%rsp),%r8
cmp    $0x4,%eax
jb     18c0 <sldperm+0x730>
lea    (%rcx,%rax,4),%rdx
cmp    %r8,%rdx
jbe    19c1 <sldperm+0x831>
lea    (%r8,%rax,4),%rdx
cmp    %rcx,%rdx
jbe    19c1 <sldperm+0x831>
xor    %esi,%esi
mov    %rsi,%rdx
not    %rdx
test   $0x1,%al
je     18f3 <sldperm+0x763>
movsd  (%r14,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r8,%rsi,4)
lea    (%rsi,%rax,1),%rdi
movsd  (%r14,%rdi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rcx,%rsi,4)
or     $0x1,%rsi
add    %rax,%rdx
je     1a35 <sldperm+0x8a5>
lea    (%r14,%rax,8),%rdx
add    $0x8,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r14,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r8,%rsi,4)
movsd  -0x8(%rdx,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rcx,%rsi,4)
movsd  0x8(%r14,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%r8,%rsi,4)
movsd  (%rdx,%rsi,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rcx,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1910 <sldperm+0x780>
jmp    1a35 <sldperm+0x8a5>
xor    %edx,%edx
test   $0x1,%sil
jne    132e <sldperm+0x19e>
jmp    1350 <sldperm+0x1c0>
xor    %ecx,%ecx
test   $0x1,%dl
jne    1437 <sldperm+0x2a7>
jmp    145f <sldperm+0x2cf>
xor    %esi,%esi
test   $0x1,%r8b
jne    167e <sldperm+0x4ee>
jmp    16a0 <sldperm+0x510>
xor    %esi,%esi
test   $0x1,%bl
jne    1757 <sldperm+0x5c7>
jmp    177f <sldperm+0x5ef>
xor    %edx,%edx
test   $0x1,%sil
jne    1836 <sldperm+0x6a6>
jmp    185c <sldperm+0x6cc>
xor    %edx,%edx
test   $0x1,%cl
jne    150c <sldperm+0x37c>
jmp    1523 <sldperm+0x393>
mov    %eax,%esi
and    $0xfffffffc,%esi
lea    0x10(%r14),%rdi
lea    0x8(%r8),%rbp
lea    0x0(,%rax,4),%rbx
and    $0xfffffffffffffff0,%rbx
xor    %edx,%edx
nopl   0x0(%rax)
movupd -0x10(%rdi),%xmm0
movupd (%rdi),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,-0x8(%rbp)
movupd -0x10(%rdi,%rax,8),%xmm0
movupd (%rdi,%rax,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%rcx,%rdx,1)
add    $0x20,%rdi
add    $0x10,%rbp
add    $0x10,%rdx
cmp    %rdx,%rbx
jne    19e0 <sldperm+0x850>
cmp    %rax,%rsi
mov    0x10(%rsp),%rbp
jne    18c2 <sldperm+0x732>
mov    0x28(%rsp),%rdi
xor    %eax,%eax
call   10a0 <superlu_free@plt>
mov    %r14,%rdi
xor    %eax,%eax
call   10a0 <superlu_free@plt>
mov    %rbp,%rdi
xor    %eax,%eax
call   10a0 <superlu_free@plt>
mov    0x40(%rsp),%eax
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [26 x i8] c"%s at line %d in file %s\0A\00"
@.str.1 = [22 x i8] c"Malloc fails for iw[]\00"
@.str.2 = [160 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/sldperm.c\00"
@.str.3 = [22 x i8] c"Malloc fails for dw[]\00"
@.str.4 = [30 x i8] c".. The last %d permutations:\0A\00"
@.str.5 = [5 x i8] c"perm\00"
define i32 @sldperm(i32 %0, i32 %1, i32 %2, i32* %3, i32* %4, float* %5, i32* %6, float* %7, float* %8) {
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32*
%14 = alloca i32*
%15 = alloca float*
%16 = alloca i32*
%17 = alloca float*
%18 = alloca float*
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32*
%24 = alloca [10 x i32]
%25 = alloca [10 x i32]
%26 = alloca double*
%27 = alloca double*
%28 = alloca [256 x i8]
%29 = alloca [256 x i8]
store i32 %0, i32* %10
store i32 %1, i32* %11
store i32 %2, i32* %12
store i32* %3, i32** %13
store i32* %4, i32** %14
store float* %5, float** %15
store i32* %6, i32** %16
store float* %7, float** %17
store float* %8, float** %18
%30 = load i32, i32* %12
%31 = sext i32 %30 to i64
%32 = mul i64 %31, 8
%33 = call i32 (i64, ...) bitcast (i32 (...)* @superlu_malloc to i32 (i64, ...)*)(i64 %32)
%34 = sext i32 %33 to i64
%35 = inttoptr i64 %34 to double*
store double* %35, double** %27
%36 = load i32, i32* %11
%37 = mul nsw i32 5, %36
store i32 %37, i32* %20
%38 = load i32, i32* %10
%39 = icmp eq i32 %38, 3
br i1 %39, label %40, label %45
40: ; preds = %9
%41 = load i32, i32* %11
%42 = mul nsw i32 10, %41
%43 = load i32, i32* %12
%44 = add nsw i32 %42, %43
store i32 %44, i32* %20
br label %45
45: ; preds = %40, %9
%46 = load i32, i32* %20
%47 = call i32 (i32, ...) bitcast (i32 (...)* @intMalloc to i32 (i32, ...)*)(i32 %46)
%48 = sext i32 %47 to i64
%49 = inttoptr i64 %48 to i32*
store i32* %49, i32** %23
%50 = icmp ne i32* %49, null
br i1 %50, label %56, label %51
51: ; preds = %45
%52 = getelementptr inbounds [256 x i8], [256 x i8]* %28, i64 0, i64 0
%53 = call i32 (i8*, i8*, ...) @sprintf(i8* %52, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.1, i64 0, i64 0), i32 98, i8* getelementptr inbounds ([160 x i8], [160 x i8]* @.str.2, i64 0, i64 0))
%54 = getelementptr inbounds [256 x i8], [256 x i8]* %28, i64 0, i64 0
%55 = call i32 (i8*, ...) bitcast (i32 (...)* @superlu_abort_and_exit to i32 (i8*, ...)*)(i8* %54)
br label %56
56: ; preds = %51, %45
%57 = load i32, i32* %11
%58 = mul nsw i32 3, %57
%59 = load i32, i32* %12
%60 = add nsw i32 %58, %59
store i32 %60, i32* %21
%61 = load i32, i32* %21
%62 = sext i32 %61 to i64
%63 = mul i64 %62, 8
%64 = call i32 (i64, ...) bitcast (i32 (...)* @superlu_malloc to i32 (i64, ...)*)(i64 %63)
%65 = sext i32 %64 to i64
%66 = inttoptr i64 %65 to double*
store double* %66, double** %26
%67 = icmp ne double* %66, null
br i1 %67, label %73, label %68
68: ; preds = %56
%69 = getelementptr inbounds [256 x i8], [256 x i8]* %29, i64 0, i64 0
%70 = call i32 (i8*, i8*, ...) @sprintf(i8* %69, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.3, i64 0, i64 0), i32 101, i8* getelementptr inbounds ([160 x i8], [160 x i8]* @.str.2, i64 0, i64 0))
%71 = getelementptr inbounds [256 x i8], [256 x i8]* %29, i64 0, i64 0
%72 = call i32 (i8*, ...) bitcast (i32 (...)* @superlu_abort_and_exit to i32 (i8*, ...)*)(i8* %71)
br label %73
73: ; preds = %68, %56
store i32 0, i32* %19
br label %74
74: ; preds = %85, %73
%75 = load i32, i32* %19
%76 = load i32, i32* %11
%77 = icmp sle i32 %75, %76
br i1 %77, label %78, label %88
78: ; preds = %74
%79 = load i32*, i32** %13
%80 = load i32, i32* %19
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i32, i32* %79, i64 %81
%83 = load i32, i32* %82
%84 = add nsw i32 %83, 1
store i32 %84, i32* %82
br label %85
85: ; preds = %78
%86 = load i32, i32* %19
%87 = add nsw i32 %86, 1
store i32 %87, i32* %19
br label %74
88: ; preds = %74
store i32 0, i32* %19
br label %89
89: ; preds = %100, %88
%90 = load i32, i32* %19
%91 = load i32, i32* %12
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %103
93: ; preds = %89
%94 = load i32*, i32** %14
%95 = load i32, i32* %19
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i32, i32* %94, i64 %96
%98 = load i32, i32* %97
%99 = add nsw i32 %98, 1
store i32 %99, i32* %97
br label %100
100: ; preds = %93
%101 = load i32, i32* %19
%102 = add nsw i32 %101, 1
store i32 %102, i32* %19
br label %89
103: ; preds = %89
%104 = getelementptr inbounds [10 x i32], [10 x i32]* %24, i64 0, i64 0
%105 = call i32 (i32*, ...) bitcast (i32 (...)* @mc64id_ to i32 (i32*, ...)*)(i32* %104)
store i32 0, i32* %19
br label %106
106: ; preds = %121, %103
%107 = load i32, i32* %19
%108 = load i32, i32* %12
%109 = icmp slt i32 %107, %108
br i1 %109, label %110, label %124
110: ; preds = %106
%111 = load float*, float** %15
%112 = load i32, i32* %19
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float, float* %111, i64 %113
%115 = load float, float* %114
%116 = fpext float %115 to double
%117 = load double*, double** %27
%118 = load i32, i32* %19
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %117, i64 %119
store double %116, double* %120
br label %121
121: ; preds = %110
%122 = load i32, i32* %19
%123 = add nsw i32 %122, 1
store i32 %123, i32* %19
br label %106
124: ; preds = %106
%125 = load i32*, i32** %13
%126 = load i32*, i32** %14
%127 = load double*, double** %27
%128 = load i32*, i32** %16
%129 = load i32*, i32** %23
%130 = load double*, double** %26
%131 = getelementptr inbounds [10 x i32], [10 x i32]* %24, i64 0, i64 0
%132 = getelementptr inbounds [10 x i32], [10 x i32]* %25, i64 0, i64 0
%133 = call i32 (i32*, i32*, i32*, i32*, i32*, double*, i32*, i32*, i32*, i32*, i32*, double*, i32*, i32*, ...) bitcast (i32 (...)* @mc64ad_ to i32 (i32*, i32*, i32*, i32*, i32*, double*, i32*, i32*, i32*, i32*, i32*, double*, i32*, i32*, ...)*)(i32* %10, i32* %11, i32* %12, i32* %125, i32* %126, double* %127, i32* %22, i32* %128, i32* %20, i32* %129, i32* %21, double* %130, i32* %131, i32* %132)
%134 = getelementptr inbounds [10 x i32], [10 x i32]* %25, i64 0, i64 0
%135 = load i32, i32* %134
%136 = icmp eq i32 %135, 1
br i1 %136, label %137, label %150
137: ; preds = %124
%138 = load i32, i32* %11
%139 = load i32, i32* %22
%140 = sub nsw i32 %138, %139
%141 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.4, i64 0, i64 0), i32 %140)
%142 = load i32, i32* %11
%143 = load i32, i32* %22
%144 = sub nsw i32 %142, %143
%145 = load i32*, i32** %16
%146 = load i32, i32* %22
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %145, i64 %147
%149 = call i32 (i8*, i32, i32*, ...) bitcast (i32 (...)* @slu_PrintInt10 to i32 (i8*, i32, i32*, ...)*)(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.5, i64 0, i64 0), i32 %144, i32* %148)
br label %150
150: ; preds = %137, %124
store i32 0, i32* %19
br label %151
151: ; preds = %162, %150
%152 = load i32, i32* %19
%153 = load i32, i32* %11
%154 = icmp sle i32 %152, %153
br i1 %154, label %155, label %165
155: ; preds = %151
%156 = load i32*, i32** %13
%157 = load i32, i32* %19
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i32, i32* %156, i64 %158
%160 = load i32, i32* %159
%161 = add nsw i32 %160, -1
store i32 %161, i32* %159
br label %162
162: ; preds = %155
%163 = load i32, i32* %19
%164 = add nsw i32 %163, 1
store i32 %164, i32* %19
br label %151
165: ; preds = %151
store i32 0, i32* %19
br label %166
166: ; preds = %177, %165
%167 = load i32, i32* %19
%168 = load i32, i32* %12
%169 = icmp slt i32 %167, %168
br i1 %169, label %170, label %180
170: ; preds = %166
%171 = load i32*, i32** %14
%172 = load i32, i32* %19
%173 = sext i32 %172 to i64
%174 = getelementptr inbounds i32, i32* %171, i64 %173
%175 = load i32, i32* %174
%176 = add nsw i32 %175, -1
store i32 %176, i32* %174
br label %177
177: ; preds = %170
%178 = load i32, i32* %19
%179 = add nsw i32 %178, 1
store i32 %179, i32* %19
br label %166
180: ; preds = %166
store i32 0, i32* %19
br label %181
181: ; preds = %192, %180
%182 = load i32, i32* %19
%183 = load i32, i32* %11
%184 = icmp slt i32 %182, %183
br i1 %184, label %185, label %195
185: ; preds = %181
%186 = load i32*, i32** %16
%187 = load i32, i32* %19
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %186, i64 %188
%190 = load i32, i32* %189
%191 = add nsw i32 %190, -1
store i32 %191, i32* %189
br label %192
192: ; preds = %185
%193 = load i32, i32* %19
%194 = add nsw i32 %193, 1
store i32 %194, i32* %19
br label %181
195: ; preds = %181
%196 = load i32, i32* %10
%197 = icmp eq i32 %196, 5
br i1 %197, label %198, label %230
198: ; preds = %195
store i32 0, i32* %19
br label %199
199: ; preds = %226, %198
%200 = load i32, i32* %19
%201 = load i32, i32* %11
%202 = icmp slt i32 %200, %201
br i1 %202, label %203, label %229
203: ; preds = %199
%204 = load double*, double** %26
%205 = load i32, i32* %19
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds double, double* %204, i64 %206
%208 = load double, double* %207
%209 = fptrunc double %208 to float
%210 = load float*, float** %17
%211 = load i32, i32* %19
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds float, float* %210, i64 %212
store float %209, float* %213
%214 = load double*, double** %26
%215 = load i32, i32* %11
%216 = load i32, i32* %19
%217 = add nsw i32 %215, %216
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %214, i64 %218
%220 = load double, double* %219
%221 = fptrunc double %220 to float
%222 = load float*, float** %18
%223 = load i32, i32* %19
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds float, float* %222, i64 %224
store float %221, float* %225
br label %226
226: ; preds = %203
%227 = load i32, i32* %19
%228 = add nsw i32 %227, 1
store i32 %228, i32* %19
br label %199
229: ; preds = %199
br label %230
230: ; preds = %229, %195
%231 = load i32*, i32** %23
%232 = call i32 (i32*, ...) bitcast (i32 (...)* @superlu_free to i32 (i32*, ...)*)(i32* %231)
%233 = load double*, double** %26
%234 = call i32 (double*, ...) bitcast (i32 (...)* @superlu_free to i32 (double*, ...)*)(double* %233)
%235 = load double*, double** %27
%236 = call i32 (double*, ...) bitcast (i32 (...)* @superlu_free to i32 (double*, ...)*)(double* %235)
%237 = getelementptr inbounds [10 x i32], [10 x i32]* %25, i64 0, i64 0
%238 = load i32, i32* %237
ret i32 %238
}

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