void ReArrangeSpt(int nVar, int **Spt, int *SptIdx, int **Vtx, int *VtxIdx,
                  int *SptType, int *OldIdx) {
  int i, i1, icnt, iSpt, ith, j;
  int *iTmp, **SptCopy, *SptIdxCopy, *Nu2OldCopy;
  iTmp = (int *)calloc(nVar, sizeof(int));
  i = 0;
  iSpt = -1;
  while (i < nVar) {
    if (SptType[i] < 0) {
      ++iSpt;
      iTmp[iSpt] = i;
    }
    ++i;
  }
  i = 0;
  ith = -1;
  while (i < nVar) {
    if (SptType[i] < 0) {
      ++ith;
      icnt = 1;
      for (j = i + 1; j < nVar; j++) {
        if (SptType[j] == i) {
          ++iSpt;
          ++icnt;
          iTmp[iSpt] = j;
        }
      }
      SptType[ith] = icnt;
    }
    i = i + 1;
  }
  SptCopy = (int **)calloc(SptIdx[nVar], sizeof(int *));
  for (i = 0; i < SptIdx[nVar]; i++)
    SptCopy[i] = (int *)calloc(nVar, sizeof(int));
  SptIdxCopy = (int *)calloc(nVar + 1, sizeof(int));
  for (j = 0; j < SptIdx[nVar]; j++)
    for (i = 0; i < nVar; i++)
      SptCopy[j][i] = Spt[j][i];
  icnt = -1;
  for (i = 0; i < nVar; i++) {
    for (j = SptIdx[iTmp[i]]; j < SptIdx[iTmp[i] + 1]; j++) {
      ++icnt;
      for (i1 = 0; i1 < nVar; i1++)
        Spt[icnt][i1] = SptCopy[j][i1];
    }
    SptIdxCopy[i + 1] = icnt + 1;
  }
  SptIdxCopy[0] = 0;
  Nu2OldCopy = (int *)calloc(SptIdx[nVar], sizeof(int));
  for (j = 0; j < VtxIdx[nVar]; j++)
    Nu2OldCopy[j] = OldIdx[j];
  icnt = -1;
  for (i = 0; i < nVar; i++)
    for (j = VtxIdx[iTmp[i]]; j < VtxIdx[iTmp[i] + 1]; j++) {
      ++icnt;
      OldIdx[icnt] = Nu2OldCopy[j] - (SptIdx[iTmp[i]] - SptIdxCopy[i]);
    }
  for (i = 0; i <= nVar; i++)
    SptIdx[i] = SptIdxCopy[i];
  for (j = 0; j < VtxIdx[nVar]; j++)
    for (i = 0; i < nVar; i++)
      SptCopy[j][i] = Vtx[j][i];
  icnt = -1;
  for (i = 0; i < nVar; i++) {
    for (j = VtxIdx[iTmp[i]]; j < VtxIdx[iTmp[i] + 1]; j++) {
      ++icnt;
      for (i1 = 0; i1 < nVar; i1++)
        Vtx[icnt][i1] = SptCopy[j][i1];
    }
    SptIdxCopy[i + 1] = icnt + 1;
  }
  VtxIdx[0] = 0;
  for (i = 1; i <= nVar; i++)
    VtxIdx[i] = SptIdxCopy[i];
  free(iTmp);
  free(Nu2OldCopy);
  free(SptIdxCopy);
  for (i = 0; i < SptIdx[nVar]; i++)
    free(SptCopy[i]);
  free(SptCopy);
}


x86 assembly (clang, -O0):
<ReArrangeSpt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movslq -0x4(%rbp),%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0xffffffff,-0x40(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11a6 <ReArrangeSpt+0x86>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1198 <ReArrangeSpt+0x78>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x50(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1163 <ReArrangeSpt+0x43>
movl   $0x0,-0x34(%rbp)
movl   $0xffffffff,-0x44(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    125a <ReArrangeSpt+0x13a>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    124c <ReArrangeSpt+0x12c>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    123e <ReArrangeSpt+0x11e>
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x34(%rbp),%eax
jne    122b <ReArrangeSpt+0x10b>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%edx
mov    -0x50(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1230 <ReArrangeSpt+0x110>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11eb <ReArrangeSpt+0xcb>
mov    -0x3c(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11b4 <ReArrangeSpt+0x94>
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
movslq (%rax,%rcx,4),%rdi
mov    $0x8,%esi
call   1040 <calloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    12ba <ReArrangeSpt+0x19a>
movslq -0x4(%rbp),%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%rdx
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    127b <ReArrangeSpt+0x15b>
mov    -0x4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1346 <ReArrangeSpt+0x226>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1333 <ReArrangeSpt+0x213>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12f3 <ReArrangeSpt+0x1d3>
jmp    1338 <ReArrangeSpt+0x218>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12d8 <ReArrangeSpt+0x1b8>
movl   $0xffffffff,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    141e <ReArrangeSpt+0x2fe>
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x50(%rbp),%rdx
movslq -0x34(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    13fa <ReArrangeSpt+0x2da>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13e7 <ReArrangeSpt+0x2c7>
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13a7 <ReArrangeSpt+0x287>
jmp    13ec <ReArrangeSpt+0x2cc>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1376 <ReArrangeSpt+0x256>
mov    -0x3c(%rbp),%edx
add    $0x1,%edx
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1354 <ReArrangeSpt+0x234>
mov    -0x60(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rax
movslq -0x4(%rbp),%rcx
movslq (%rax,%rcx,4),%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1481 <ReArrangeSpt+0x361>
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1449 <ReArrangeSpt+0x329>
movl   $0xffffffff,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1532 <ReArrangeSpt+0x412>
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x28(%rbp),%rcx
mov    -0x50(%rbp),%rdx
movslq -0x34(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    151f <ReArrangeSpt+0x3ff>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x34(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x60(%rbp),%rcx
movslq -0x34(%rbp),%rsi
sub    (%rcx,%rsi,4),%eax
sub    %eax,%edx
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    14b1 <ReArrangeSpt+0x391>
jmp    1524 <ReArrangeSpt+0x404>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    148f <ReArrangeSpt+0x36f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1569 <ReArrangeSpt+0x449>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1539 <ReArrangeSpt+0x419>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    15de <ReArrangeSpt+0x4be>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15cb <ReArrangeSpt+0x4ab>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    158b <ReArrangeSpt+0x46b>
jmp    15d0 <ReArrangeSpt+0x4b0>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1570 <ReArrangeSpt+0x450>
movl   $0xffffffff,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16b6 <ReArrangeSpt+0x596>
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x28(%rbp),%rcx
mov    -0x50(%rbp),%rdx
movslq -0x34(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1692 <ReArrangeSpt+0x572>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    167f <ReArrangeSpt+0x55f>
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    163f <ReArrangeSpt+0x51f>
jmp    1684 <ReArrangeSpt+0x564>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    160e <ReArrangeSpt+0x4ee>
mov    -0x3c(%rbp),%edx
add    $0x1,%edx
mov    -0x60(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15ec <ReArrangeSpt+0x4cc>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16f7 <ReArrangeSpt+0x5d7>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16c7 <ReArrangeSpt+0x5a7>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    174c <ReArrangeSpt+0x62c>
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1719 <ReArrangeSpt+0x5f9>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ReArrangeSpt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,%r12
mov    %r8,0x18(%rsp)
mov    %rcx,0x60(%rsp)
mov    %rdx,%r15
mov    %rsi,0x48(%rsp)
mov    %edi,%ebx
mov    0xa0(%rsp),%rax
mov    %rax,0x58(%rsp)
movslq %edi,%r13
mov    $0x4,%esi
mov    %r13,%rdi
call   1040 <calloc@plt>
mov    %rax,%r14
mov    %rbx,0x8(%rsp)
mov    %ebx,%ebp
test   %r13d,%r13d
jle    1242 <ReArrangeSpt+0x112>
mov    0x8(%rsp),%rsi
cmp    $0x1,%esi
jne    14b3 <ReArrangeSpt+0x383>
mov    $0xffffffff,%eax
xor    %ecx,%ecx
test   $0x1,%bpl
je     11b2 <ReArrangeSpt+0x82>
cmpl   $0x0,(%r12,%rcx,4)
jns    11b2 <ReArrangeSpt+0x82>
movslq %eax,%rdx
add    $0x1,%eax
mov    %ecx,0x4(%r14,%rdx,4)
test   %esi,%esi
jle    1242 <ReArrangeSpt+0x112>
mov    $0xffffffff,%r8d
mov    $0x1,%ecx
xor    %esi,%esi
jmp    11e3 <ReArrangeSpt+0xb3>
nopl   0x0(%rax)
movslq %r8d,%rdx
mov    %ebx,(%r12,%rdx,4)
mov    %r9,%rsi
add    $0x1,%rcx
cmp    %rbp,%r9
je     1242 <ReArrangeSpt+0x112>
cmpl   $0x0,(%r12,%rsi,4)
js     1200 <ReArrangeSpt+0xd0>
add    $0x1,%rsi
mov    %rsi,%r9
jmp    11da <ReArrangeSpt+0xaa>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r8d
lea    0x1(%rsi),%r9
mov    $0x1,%ebx
cmp    %r13,%r9
jge    11d0 <ReArrangeSpt+0xa0>
mov    $0x1,%ebx
mov    %rcx,%rdx
jmp    1229 <ReArrangeSpt+0xf9>
nopl   0x0(%rax)
add    $0x1,%rdx
cmp    %rdx,%rbp
je     11d0 <ReArrangeSpt+0xa0>
mov    (%r12,%rdx,4),%edi
cmp    %rdi,%rsi
jne    1220 <ReArrangeSpt+0xf0>
add    $0x1,%ebx
movslq %eax,%rdi
add    $0x1,%eax
mov    %edx,0x4(%r14,%rdi,4)
jmp    1220 <ReArrangeSpt+0xf0>
movslq (%r15,%r13,4),%rbx
mov    $0x8,%esi
mov    %rbx,%rdi
call   1040 <calloc@plt>
mov    %rax,%r12
test   %rbx,%rbx
mov    %r15,0x20(%rsp)
mov    %r13,0x28(%rsp)
mov    %r14,0x30(%rsp)
mov    %rbx,0x38(%rsp)
jle    1488 <ReArrangeSpt+0x358>
mov    %ebx,%r14d
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    $0x4,%esi
mov    %r13,%rdi
call   1040 <calloc@plt>
mov    %rax,(%r12,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1280 <ReArrangeSpt+0x150>
mov    0x8(%rsp),%rax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,0x10(%rsp)
mov    0x38(%rsp),%rcx
test   %ecx,%ecx
jle    1519 <ReArrangeSpt+0x3e9>
mov    %ebp,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%r8
mov    %r8,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%r10
mov    %ebp,%r14d
and    $0x3,%r14d
mov    %r9,%r13
shl    $0x5,%r13
xor    %r15d,%r15d
mov    0x8(%rsp),%rsi
jmp    1332 <ReArrangeSpt+0x202>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x20(%rsp),%rax
mov    0x28(%rsp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    0x8(%rsp),%rsi
add    $0x1,%r15
movslq %ecx,%rax
cmp    %rax,%r15
jge    146c <ReArrangeSpt+0x33c>
test   %esi,%esi
jle    1322 <ReArrangeSpt+0x1f2>
mov    0x48(%rsp),%rax
mov    (%rax,%r15,8),%rcx
mov    (%r12,%r15,8),%rdx
cmp    $0x8,%esi
jb     135a <ReArrangeSpt+0x22a>
lea    (%rcx,%rbp,4),%rax
cmp    %rax,%rdx
jae    13bc <ReArrangeSpt+0x28c>
lea    (%rdx,%rbp,4),%rax
cmp    %rax,%rcx
jae    13bc <ReArrangeSpt+0x28c>
xor    %eax,%eax
mov    %rax,%rdi
not    %rdi
add    %rbp,%rdi
test   %r14,%r14
je     1380 <ReArrangeSpt+0x250>
mov    %r14,%rsi
nopl   (%rax)
mov    (%rcx,%rax,4),%ebx
mov    %ebx,(%rdx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1370 <ReArrangeSpt+0x240>
cmp    $0x3,%rdi
jb     1310 <ReArrangeSpt+0x1e0>
cs nopw 0x0(%rax,%rax,1)
mov    (%rcx,%rax,4),%esi
mov    %esi,(%rdx,%rax,4)
mov    0x4(%rcx,%rax,4),%esi
mov    %esi,0x4(%rdx,%rax,4)
mov    0x8(%rcx,%rax,4),%esi
mov    %esi,0x8(%rdx,%rax,4)
mov    0xc(%rcx,%rax,4),%esi
mov    %esi,0xc(%rdx,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1390 <ReArrangeSpt+0x260>
jmp    1310 <ReArrangeSpt+0x1e0>
cmp    $0x18,%r8
jae    13c6 <ReArrangeSpt+0x296>
xor    %eax,%eax
jmp    1428 <ReArrangeSpt+0x2f8>
mov    %r10,%rdi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rcx,%rax,4),%xmm0
movups 0x10(%rcx,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rcx,%rax,4),%xmm0
movups 0x30(%rcx,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rcx,%rax,4),%xmm0
movups 0x50(%rcx,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rcx,%rax,4),%xmm0
movups 0x70(%rcx,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rdi
jne    13d0 <ReArrangeSpt+0x2a0>
test   %r9,%r9
je     145b <ReArrangeSpt+0x32b>
lea    (%rdx,%rax,4),%rdi
add    $0x10,%rdi
lea    (%rcx,%rax,4),%rax
add    $0x10,%rax
xor    %esi,%esi
nop
movups -0x10(%rax,%rsi,1),%xmm0
movups (%rax,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdi,%rsi,1)
movups %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r13
jne    1440 <ReArrangeSpt+0x310>
mov    %r11,%rax
cmp    %rbp,%r11
je     1310 <ReArrangeSpt+0x1e0>
jmp    135c <ReArrangeSpt+0x22c>
mov    0x20(%rsp),%r15
mov    0x28(%rsp),%r13
mov    0x30(%rsp),%r14
test   %esi,%esi
jg     152b <ReArrangeSpt+0x3fb>
jmp    176a <ReArrangeSpt+0x63a>
mov    0x8(%rsp),%rbx
lea    0x1(%rbx),%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rbx,%rsi
mov    0x38(%rsp),%rcx
mov    %rax,0x10(%rsp)
test   %esi,%esi
jg     152b <ReArrangeSpt+0x3fb>
jmp    176a <ReArrangeSpt+0x63a>
mov    %ebp,%edx
and    $0xfffffffe,%edx
mov    $0xffffffff,%eax
xor    %ecx,%ecx
jmp    14f5 <ReArrangeSpt+0x3c5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %eax,%rsi
add    $0x1,%eax
mov    %ecx,0x4(%r14,%rsi,4)
mov    0x8(%rsp),%rsi
cmpl   $0x0,0x4(%r12,%rcx,4)
js     1504 <ReArrangeSpt+0x3d4>
add    $0x2,%rcx
cmp    %rcx,%rdx
je     119a <ReArrangeSpt+0x6a>
cmpl   $0x0,(%r12,%rcx,4)
js     14d0 <ReArrangeSpt+0x3a0>
cmpl   $0x0,0x4(%r12,%rcx,4)
jns    14e8 <ReArrangeSpt+0x3b8>
movslq %eax,%rsi
add    $0x1,%eax
lea    0x1(%rcx),%edi
mov    %edi,0x4(%r14,%rsi,4)
mov    0x8(%rsp),%rsi
jmp    14e8 <ReArrangeSpt+0x3b8>
mov    0x30(%rsp),%r14
mov    0x8(%rsp),%rsi
test   %esi,%esi
jle    176a <ReArrangeSpt+0x63a>
mov    %ebp,%r10d
and    $0xfffffff8,%r10d
lea    -0x8(%r10),%rax
mov    %rax,0x38(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%esi
and    $0x3,%esi
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0x40(%rsp)
mov    %ebp,%r15d
and    $0x3,%r15d
mov    %rsi,0x50(%rsp)
shl    $0x5,%rsi
mov    $0xffffffff,%ecx
xor    %r13d,%r13d
jmp    159f <ReArrangeSpt+0x46f>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%r14
lea    0x1(%rcx),%eax
mov    0x10(%rsp),%rdx
mov    %eax,0x4(%rdx,%r13,4)
add    $0x1,%r13
cmp    %rbp,%r13
je     175c <ReArrangeSpt+0x62c>
movslq (%r14,%r13,4),%r14
mov    0x20(%rsp),%rdx
movslq (%rdx,%r14,4),%rax
cmp    0x4(%rdx,%r14,4),%eax
jge    1580 <ReArrangeSpt+0x450>
movslq %ecx,%rcx
jmp    15d7 <ReArrangeSpt+0x4a7>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
mov    0x20(%rsp),%rdx
movslq 0x4(%rdx,%r14,4),%rdx
add    $0x1,%rax
cmp    %rdx,%rax
jge    1580 <ReArrangeSpt+0x450>
mov    (%r12,%rax,8),%r8
mov    0x48(%rsp),%rdx
mov    0x8(%rdx,%rcx,8),%r9
cmpl   $0x8,0x8(%rsp)
jb     1606 <ReArrangeSpt+0x4d6>
lea    (%r8,%rbp,4),%rdx
cmp    %rdx,%r9
jae    1680 <ReArrangeSpt+0x550>
lea    (%r9,%rbp,4),%rdx
cmp    %rdx,%r8
jae    1680 <ReArrangeSpt+0x550>
xor    %r11d,%r11d
mov    %r11,%rdx
not    %rdx
add    %rbp,%rdx
test   %r15,%r15
je     1632 <ReArrangeSpt+0x502>
mov    %r15,%rbx
nopw   0x0(%rax,%rax,1)
mov    (%r8,%r11,4),%edi
mov    %edi,(%r9,%r11,4)
add    $0x1,%r11
add    $0xffffffffffffffff,%rbx
jne    1620 <ReArrangeSpt+0x4f0>
cmp    $0x3,%rdx
jb     15c0 <ReArrangeSpt+0x490>
nopl   0x0(%rax,%rax,1)
mov    (%r8,%r11,4),%edx
mov    %edx,(%r9,%r11,4)
mov    0x4(%r8,%r11,4),%edx
mov    %edx,0x4(%r9,%r11,4)
mov    0x8(%r8,%r11,4),%edx
mov    %edx,0x8(%r9,%r11,4)
mov    0xc(%r8,%r11,4),%edx
mov    %edx,0xc(%r9,%r11,4)
add    $0x4,%r11
cmp    %r11,%rbp
jne    1640 <ReArrangeSpt+0x510>
jmp    15c0 <ReArrangeSpt+0x490>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpq   $0x18,0x38(%rsp)
jae    168c <ReArrangeSpt+0x55c>
xor    %edx,%edx
jmp    1708 <ReArrangeSpt+0x5d8>
mov    0x40(%rsp),%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r8,%rdx,4),%xmm0
movups 0x10(%r8,%rdx,4),%xmm1
movups %xmm0,(%r9,%rdx,4)
movups %xmm1,0x10(%r9,%rdx,4)
movups 0x20(%r8,%rdx,4),%xmm0
movups 0x30(%r8,%rdx,4),%xmm1
movups %xmm0,0x20(%r9,%rdx,4)
movups %xmm1,0x30(%r9,%rdx,4)
movups 0x40(%r8,%rdx,4),%xmm0
movups 0x50(%r8,%rdx,4),%xmm1
movups %xmm0,0x40(%r9,%rdx,4)
movups %xmm1,0x50(%r9,%rdx,4)
movups 0x60(%r8,%rdx,4),%xmm0
movups 0x70(%r8,%rdx,4),%xmm1
movups %xmm0,0x60(%r9,%rdx,4)
movups %xmm1,0x70(%r9,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rbx
jne    16a0 <ReArrangeSpt+0x570>
cmpq   $0x0,0x50(%rsp)
je     174b <ReArrangeSpt+0x61b>
lea    (%r9,%rdx,4),%rbx
add    $0x10,%rbx
lea    (%r8,%rdx,4),%rdx
add    $0x10,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,1)
movups %xmm1,(%rbx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1730 <ReArrangeSpt+0x600>
mov    %r10,%r11
cmp    %rbp,%r10
je     15c0 <ReArrangeSpt+0x490>
jmp    1609 <ReArrangeSpt+0x4d9>
mov    0x20(%rsp),%r15
mov    0x28(%rsp),%r13
mov    (%r15,%r13,4),%ecx
mov    0x10(%rsp),%rax
movl   $0x0,(%rax)
movslq %ecx,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    0x18(%rsp),%r9
mov    (%r9,%r13,4),%edx
test   %edx,%edx
mov    %rax,0x40(%rsp)
jle    17af <ReArrangeSpt+0x67f>
shl    $0x2,%rdx
mov    %rax,%rdi
mov    0x58(%rsp),%rsi
call   1050 <memcpy@plt>
mov    0x40(%rsp),%rax
mov    0x18(%rsp),%r9
cmpl   $0x0,0x8(%rsp)
mov    0x58(%rsp),%r10
jle    1823 <ReArrangeSpt+0x6f3>
add    $0x4,%r10
mov    $0xffffffff,%edi
xor    %r8d,%r8d
jmp    17d9 <ReArrangeSpt+0x6a9>
nopl   0x0(%rax)
add    $0x1,%r8
cmp    %rbp,%r8
je     1823 <ReArrangeSpt+0x6f3>
movslq (%r14,%r8,4),%rdx
movslq (%r9,%rdx,4),%rsi
cmp    0x4(%r9,%rdx,4),%esi
jge    17d0 <ReArrangeSpt+0x6a0>
mov    0x10(%rsp),%rcx
mov    (%rcx,%r8,4),%r11d
movslq %edi,%rbx
lea    (%r10,%rbx,4),%rbx
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rsi,4),%ecx
sub    (%r15,%rdx,4),%ecx
add    %r11d,%ecx
mov    %ecx,(%rbx)
add    $0x1,%rsi
movslq 0x4(%r9,%rdx,4),%rcx
add    $0x1,%edi
add    $0x4,%rbx
cmp    %rcx,%rsi
jl     1800 <ReArrangeSpt+0x6d0>
jmp    17d0 <ReArrangeSpt+0x6a0>
mov    0x8(%rsp),%rsi
test   %esi,%esi
js     184b <ReArrangeSpt+0x71b>
lea    0x4(,%rbp,4),%rdx
mov    %r15,%rdi
mov    0x10(%rsp),%rsi
call   1050 <memcpy@plt>
mov    0x8(%rsp),%rsi
mov    0x18(%rsp),%r9
mov    (%r9,%r13,4),%eax
test   %eax,%eax
jle    1a01 <ReArrangeSpt+0x8d1>
mov    %ebp,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%r8
mov    %r8,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
movabs $0x3ffffffffffffffc,%rcx
ff ff 3f
and    %rcx,%r10
mov    %ebp,%r14d
and    $0x3,%r14d
mov    %r9,%r13
shl    $0x5,%r13
xor    %r15d,%r15d
jmp    18bd <ReArrangeSpt+0x78d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x28(%rsp),%rax
mov    0x18(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
add    $0x1,%r15
movslq %eax,%rcx
cmp    %rcx,%r15
jge    1a01 <ReArrangeSpt+0x8d1>
test   %esi,%esi
jle    18ad <ReArrangeSpt+0x77d>
mov    0x60(%rsp),%rax
mov    (%rax,%r15,8),%rbx
mov    (%r12,%r15,8),%rdx
cmp    $0x8,%esi
jb     18e5 <ReArrangeSpt+0x7b5>
lea    (%rbx,%rbp,4),%rax
cmp    %rax,%rdx
jae    194c <ReArrangeSpt+0x81c>
lea    (%rdx,%rbp,4),%rax
cmp    %rax,%rbx
jae    194c <ReArrangeSpt+0x81c>
xor    %eax,%eax
mov    %rax,%rdi
not    %rdi
add    %rbp,%rdi
test   %r14,%r14
je     1910 <ReArrangeSpt+0x7e0>
mov    %r14,%rsi
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rax,4),%ecx
mov    %ecx,(%rdx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1900 <ReArrangeSpt+0x7d0>
cmp    $0x3,%rdi
mov    0x8(%rsp),%rsi
jb     18a0 <ReArrangeSpt+0x770>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rax,4),%ecx
mov    %ecx,(%rdx,%rax,4)
mov    0x4(%rbx,%rax,4),%ecx
mov    %ecx,0x4(%rdx,%rax,4)
mov    0x8(%rbx,%rax,4),%ecx
mov    %ecx,0x8(%rdx,%rax,4)
mov    0xc(%rbx,%rax,4),%ecx
mov    %ecx,0xc(%rdx,%rax,4)
add    $0x4,%rax
cmp    %rax,%rbp
jne    1920 <ReArrangeSpt+0x7f0>
jmp    18a0 <ReArrangeSpt+0x770>
cmp    $0x18,%r8
jae    1956 <ReArrangeSpt+0x826>
xor    %eax,%eax
jmp    19b8 <ReArrangeSpt+0x888>
mov    %r10,%rdi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups %xmm0,(%rdx,%rax,4)
movups %xmm1,0x10(%rdx,%rax,4)
movups 0x20(%rbx,%rax,4),%xmm0
movups 0x30(%rbx,%rax,4),%xmm1
movups %xmm0,0x20(%rdx,%rax,4)
movups %xmm1,0x30(%rdx,%rax,4)
movups 0x40(%rbx,%rax,4),%xmm0
movups 0x50(%rbx,%rax,4),%xmm1
movups %xmm0,0x40(%rdx,%rax,4)
movups %xmm1,0x50(%rdx,%rax,4)
movups 0x60(%rbx,%rax,4),%xmm0
movups 0x70(%rbx,%rax,4),%xmm1
movups %xmm0,0x60(%rdx,%rax,4)
movups %xmm1,0x70(%rdx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rdi
jne    1960 <ReArrangeSpt+0x830>
test   %r9,%r9
je     19eb <ReArrangeSpt+0x8bb>
lea    (%rdx,%rax,4),%rdi
add    $0x10,%rdi
lea    (%rbx,%rax,4),%rax
add    $0x10,%rax
xor    %esi,%esi
nop
movups -0x10(%rax,%rsi,1),%xmm0
movups (%rax,%rsi,1),%xmm1
movups %xmm0,-0x10(%rdi,%rsi,1)
movups %xmm1,(%rdi,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r13
jne    19d0 <ReArrangeSpt+0x8a0>
mov    %r11,%rax
cmp    %rbp,%r11
mov    0x8(%rsp),%rsi
je     18a0 <ReArrangeSpt+0x770>
jmp    18e7 <ReArrangeSpt+0x7b7>
test   %esi,%esi
jle    1c6e <ReArrangeSpt+0xb3e>
mov    %ebp,%r10d
and    $0xfffffff8,%r10d
lea    -0x8(%r10),%rax
mov    %rax,0x48(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%esi
and    $0x3,%esi
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0x50(%rsp)
mov    %ebp,%r15d
and    $0x3,%r15d
mov    %rsi,0x38(%rsp)
shl    $0x5,%rsi
mov    $0xffffffff,%ecx
xor    %r14d,%r14d
mov    0x18(%rsp),%rdi
jmp    1a7a <ReArrangeSpt+0x94a>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rcx),%eax
mov    0x10(%rsp),%rdx
mov    %eax,0x4(%rdx,%r14,4)
add    $0x1,%r14
cmp    %rbp,%r14
je     1c3c <ReArrangeSpt+0xb0c>
mov    0x30(%rsp),%rax
movslq (%rax,%r14,4),%r13
movslq (%rdi,%r13,4),%rax
cmp    0x4(%rdi,%r13,4),%eax
jge    1a60 <ReArrangeSpt+0x930>
movslq %ecx,%rcx
jmp    1ab7 <ReArrangeSpt+0x987>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rcx
mov    0x18(%rsp),%rdi
movslq 0x4(%rdi,%r13,4),%rdx
add    $0x1,%rax
cmp    %rdx,%rax
jge    1a60 <ReArrangeSpt+0x930>
mov    (%r12,%rax,8),%r8
mov    0x60(%rsp),%rdx
mov    0x8(%rdx,%rcx,8),%r9
cmpl   $0x8,0x8(%rsp)
jb     1ae6 <ReArrangeSpt+0x9b6>
lea    (%r8,%rbp,4),%rdx
cmp    %rdx,%r9
jae    1b60 <ReArrangeSpt+0xa30>
lea    (%r9,%rbp,4),%rdx
cmp    %rdx,%r8
jae    1b60 <ReArrangeSpt+0xa30>
xor    %r11d,%r11d
mov    %r11,%rdx
not    %rdx
add    %rbp,%rdx
test   %r15,%r15
je     1b12 <ReArrangeSpt+0x9e2>
mov    %r15,%rbx
nopw   0x0(%rax,%rax,1)
mov    (%r8,%r11,4),%edi
mov    %edi,(%r9,%r11,4)
add    $0x1,%r11
add    $0xffffffffffffffff,%rbx
jne    1b00 <ReArrangeSpt+0x9d0>
cmp    $0x3,%rdx
jb     1aa0 <ReArrangeSpt+0x970>
nopl   0x0(%rax,%rax,1)
mov    (%r8,%r11,4),%edx
mov    %edx,(%r9,%r11,4)
mov    0x4(%r8,%r11,4),%edx
mov    %edx,0x4(%r9,%r11,4)
mov    0x8(%r8,%r11,4),%edx
mov    %edx,0x8(%r9,%r11,4)
mov    0xc(%r8,%r11,4),%edx
mov    %edx,0xc(%r9,%r11,4)
add    $0x4,%r11
cmp    %r11,%rbp
jne    1b20 <ReArrangeSpt+0x9f0>
jmp    1aa0 <ReArrangeSpt+0x970>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpq   $0x18,0x48(%rsp)
jae    1b6c <ReArrangeSpt+0xa3c>
xor    %edx,%edx
jmp    1be8 <ReArrangeSpt+0xab8>
mov    0x50(%rsp),%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r8,%rdx,4),%xmm0
movups 0x10(%r8,%rdx,4),%xmm1
movups %xmm0,(%r9,%rdx,4)
movups %xmm1,0x10(%r9,%rdx,4)
movups 0x20(%r8,%rdx,4),%xmm0
movups 0x30(%r8,%rdx,4),%xmm1
movups %xmm0,0x20(%r9,%rdx,4)
movups %xmm1,0x30(%r9,%rdx,4)
movups 0x40(%r8,%rdx,4),%xmm0
movups 0x50(%r8,%rdx,4),%xmm1
movups %xmm0,0x40(%r9,%rdx,4)
movups %xmm1,0x50(%r9,%rdx,4)
movups 0x60(%r8,%rdx,4),%xmm0
movups 0x70(%r8,%rdx,4),%xmm1
movups %xmm0,0x60(%r9,%rdx,4)
movups %xmm1,0x70(%r9,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rbx
jne    1b80 <ReArrangeSpt+0xa50>
cmpq   $0x0,0x38(%rsp)
je     1c2b <ReArrangeSpt+0xafb>
lea    (%r9,%rdx,4),%rbx
add    $0x10,%rbx
lea    (%r8,%rdx,4),%rdx
add    $0x10,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,1)
movups %xmm1,(%rbx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1c10 <ReArrangeSpt+0xae0>
mov    %r10,%r11
cmp    %rbp,%r10
je     1aa0 <ReArrangeSpt+0x970>
jmp    1ae9 <ReArrangeSpt+0x9b9>
movl   $0x0,(%rdi)
cmpl   $0x0,0x8(%rsp)
mov    0x20(%rsp),%r14
mov    0x28(%rsp),%r15
jle    1c83 <ReArrangeSpt+0xb53>
add    $0x4,%rdi
mov    0x10(%rsp),%rax
lea    0x4(%rax),%rsi
shl    $0x2,%rbp
mov    %rbp,%rdx
call   1050 <memcpy@plt>
jmp    1c83 <ReArrangeSpt+0xb53>
mov    0x18(%rsp),%rax
movl   $0x0,(%rax)
mov    0x20(%rsp),%r14
mov    0x28(%rsp),%r15
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
cmpl   $0x0,(%r14,%r15,4)
jle    1cc6 <ReArrangeSpt+0xb96>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
movslq (%r14,%r15,4),%rax
cmp    %rax,%rbx
jl     1cb0 <ReArrangeSpt+0xb80>
mov    %r12,%rdi
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

LLVM IR (-O2):
define void @ReArrangeSpt(i32 %0, i32** nocapture %1, i32* nocapture %2, i32** nocapture %3, i32* nocapture %4, i32* nocapture %5, i32* nocapture %6) {
%8 = bitcast i32* %6 to i8*
%9 = bitcast i32* %2 to i8*
%10 = sext i32 %0 to i64
%11 = tail call i8* @calloc(i64 %10, i64 4)
%12 = bitcast i8* %11 to i32*
%13 = icmp sgt i32 %0, 0
br i1 %13, label %14, label %110
14: ; preds = %7
%15 = zext i32 %0 to i64
%16 = and i64 %15, 1
%17 = icmp eq i32 %0, 1
br i1 %17, label %20, label %18
18: ; preds = %14
%19 = and i64 %15, 4294967294
br label %38
20: ; preds = %61, %14
%21 = phi i32 [ undef, %14 ], [ %62, %61 ]
%22 = phi i64 [ 0, %14 ], [ %63, %61 ]
%23 = phi i32 [ -1, %14 ], [ %62, %61 ]
%24 = icmp eq i64 %16, 0
br i1 %24, label %34, label %25
25: ; preds = %20
%26 = getelementptr inbounds i32, i32* %5, i64 %22
%27 = load i32, i32* %26
%28 = icmp slt i32 %27, 0
br i1 %28, label %29, label %34
29: ; preds = %25
%30 = add nsw i32 %23, 1
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i32, i32* %12, i64 %31
%33 = trunc i64 %22 to i32
store i32 %33, i32* %32
br label %34
34: ; preds = %25, %29, %20
%35 = phi i32 [ %21, %20 ], [ %30, %29 ], [ %23, %25 ]
br i1 %13, label %36, label %110
36: ; preds = %34
%37 = zext i32 %0 to i64
br label %66
38: ; preds = %61, %18
%39 = phi i64 [ 0, %18 ], [ %63, %61 ]
%40 = phi i32 [ -1, %18 ], [ %62, %61 ]
%41 = phi i64 [ 0, %18 ], [ %64, %61 ]
%42 = getelementptr inbounds i32, i32* %5, i64 %39
%43 = load i32, i32* %42
%44 = icmp slt i32 %43, 0
br i1 %44, label %45, label %50
45: ; preds = %38
%46 = add nsw i32 %40, 1
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %12, i64 %47
%49 = trunc i64 %39 to i32
store i32 %49, i32* %48
br label %50
50: ; preds = %45, %38
%51 = phi i32 [ %46, %45 ], [ %40, %38 ]
%52 = or i64 %39, 1
%53 = getelementptr inbounds i32, i32* %5, i64 %52
%54 = load i32, i32* %53
%55 = icmp slt i32 %54, 0
br i1 %55, label %56, label %61
56: ; preds = %50
%57 = add nsw i32 %51, 1
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i32, i32* %12, i64 %58
%60 = trunc i64 %52 to i32
store i32 %60, i32* %59
br label %61
61: ; preds = %56, %50
%62 = phi i32 [ %57, %56 ], [ %51, %50 ]
%63 = add nuw nsw i64 %39, 2
%64 = add i64 %41, 2
%65 = icmp eq i64 %64, %19
br i1 %65, label %20, label %38
66: ; preds = %36, %104
%67 = phi i64 [ 0, %36 ], [ %105, %104 ]
%68 = phi i64 [ 1, %36 ], [ %108, %104 ]
%69 = phi i32 [ %35, %36 ], [ %107, %104 ]
%70 = phi i32 [ -1, %36 ], [ %106, %104 ]
%71 = getelementptr inbounds i32, i32* %5, i64 %67
%72 = load i32, i32* %71
%73 = icmp slt i32 %72, 0
br i1 %73, label %76, label %74
74: ; preds = %66
%75 = add nuw nsw i64 %67, 1
br label %104
76: ; preds = %66
%77 = add nsw i32 %70, 1
%78 = add nuw nsw i64 %67, 1
%79 = icmp slt i64 %78, %10
br i1 %79, label %80, label %99
80: ; preds = %76, %94
%81 = phi i64 [ %97, %94 ], [ %68, %76 ]
%82 = phi i32 [ %96, %94 ], [ 1, %76 ]
%83 = phi i32 [ %95, %94 ], [ %69, %76 ]
%84 = getelementptr inbounds i32, i32* %5, i64 %81
%85 = load i32, i32* %84
%86 = zext i32 %85 to i64
%87 = icmp eq i64 %67, %86
br i1 %87, label %88, label %94
88: ; preds = %80
%89 = add nsw i32 %83, 1
%90 = add nsw i32 %82, 1
%91 = sext i32 %89 to i64
%92 = getelementptr inbounds i32, i32* %12, i64 %91
%93 = trunc i64 %81 to i32
store i32 %93, i32* %92
br label %94
94: ; preds = %80, %88
%95 = phi i32 [ %89, %88 ], [ %83, %80 ]
%96 = phi i32 [ %90, %88 ], [ %82, %80 ]
%97 = add nuw nsw i64 %81, 1
%98 = icmp eq i64 %97, %37
br i1 %98, label %99, label %80
99: ; preds = %94, %76
%100 = phi i32 [ %69, %76 ], [ %95, %94 ]
%101 = phi i32 [ 1, %76 ], [ %96, %94 ]
%102 = sext i32 %77 to i64
%103 = getelementptr inbounds i32, i32* %5, i64 %102
store i32 %101, i32* %103
br label %104
104: ; preds = %74, %99
%105 = phi i64 [ %75, %74 ], [ %78, %99 ]
%106 = phi i32 [ %70, %74 ], [ %77, %99 ]
%107 = phi i32 [ %69, %74 ], [ %100, %99 ]
%108 = add nuw nsw i64 %68, 1
%109 = icmp eq i64 %105, %37
br i1 %109, label %110, label %66
110: ; preds = %104, %7, %34
%111 = getelementptr inbounds i32, i32* %2, i64 %10
%112 = load i32, i32* %111
%113 = sext i32 %112 to i64
%114 = tail call i8* @calloc(i64 %113, i64 8)
%115 = bitcast i8* %114 to i32**
%116 = icmp sgt i32 %112, 0
br i1 %116, label %121, label %117
117: ; preds = %110
%118 = add nsw i32 %0, 1
%119 = sext i32 %118 to i64
%120 = tail call i8* @calloc(i64 %119, i64 4)
br label %248
121: ; preds = %110
%122 = zext i32 %112 to i64
br label %123
123: ; preds = %121, %123
%124 = phi i64 [ 0, %121 ], [ %128, %123 ]
%125 = tail call i8* @calloc(i64 %10, i64 4)
%126 = getelementptr inbounds i32*, i32** %115, i64 %124
%127 = bitcast i32** %126 to i8**
store i8* %125, i8** %127
%128 = add nuw nsw i64 %124, 1
%129 = icmp eq i64 %128, %122
br i1 %129, label %130, label %123
130: ; preds = %123
%131 = add nsw i32 %0, 1
%132 = sext i32 %131 to i64
%133 = tail call i8* @calloc(i64 %132, i64 4)
br i1 %116, label %134, label %248
134: ; preds = %130
%135 = zext i32 %0 to i64
%136 = and i64 %135, 4294967288
%137 = add nsw i64 %136, -8
%138 = lshr exact i64 %137, 3
%139 = add nuw nsw i64 %138, 1
%140 = icmp ult i32 %0, 8
%141 = and i64 %135, 4294967288
%142 = and i64 %139, 3
%143 = icmp ult i64 %137, 24
%144 = and i64 %139, 4611686018427387900
%145 = icmp eq i64 %142, 0
%146 = icmp eq i64 %141, %135
%147 = and i64 %135, 3
%148 = icmp eq i64 %147, 0
br label %149
149: ; preds = %134, %288
%150 = phi i32 [ %112, %134 ], [ %289, %288 ]
%151 = phi i64 [ 0, %134 ], [ %290, %288 ]
br i1 %13, label %152, label %288
152: ; preds = %149
%153 = getelementptr inbounds i32*, i32** %1, i64 %151
%154 = load i32*, i32** %153
%155 = getelementptr inbounds i32*, i32** %115, i64 %151
%156 = load i32*, i32** %155
br i1 %140, label %232, label %157
157: ; preds = %152
%158 = getelementptr i32, i32* %156, i64 %135
%159 = getelementptr i32, i32* %154, i64 %135
%160 = icmp ult i32* %156, %159
%161 = icmp ult i32* %154, %158
%162 = and i1 %160, %161
br i1 %162, label %232, label %163
163: ; preds = %157
br i1 %143, label %213, label %164
164: ; preds = %163, %164
%165 = phi i64 [ %210, %164 ], [ 0, %163 ]
%166 = phi i64 [ %211, %164 ], [ 0, %163 ]
%167 = getelementptr inbounds i32, i32* %154, i64 %165
%168 = bitcast i32* %167 to <4 x i32>*
%169 = load <4 x i32>, <4 x i32>* %168
%170 = getelementptr inbounds i32, i32* %167, i64 4
%171 = bitcast i32* %170 to <4 x i32>*
%172 = load <4 x i32>, <4 x i32>* %171
%173 = getelementptr inbounds i32, i32* %156, i64 %165
%174 = bitcast i32* %173 to <4 x i32>*
store <4 x i32> %169, <4 x i32>* %174
%175 = getelementptr inbounds i32, i32* %173, i64 4
%176 = bitcast i32* %175 to <4 x i32>*
store <4 x i32> %172, <4 x i32>* %176
%177 = or i64 %165, 8
%178 = getelementptr inbounds i32, i32* %154, i64 %177
%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* %156, i64 %177
%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 = or i64 %165, 16
%189 = getelementptr inbounds i32, i32* %154, i64 %188
%190 = bitcast i32* %189 to <4 x i32>*
%191 = load <4 x i32>, <4 x i32>* %190
%192 = getelementptr inbounds i32, i32* %189, i64 4
%193 = bitcast i32* %192 to <4 x i32>*
%194 = load <4 x i32>, <4 x i32>* %193
%195 = getelementptr inbounds i32, i32* %156, i64 %188
%196 = bitcast i32* %195 to <4 x i32>*
store <4 x i32> %191, <4 x i32>* %196
%197 = getelementptr inbounds i32, i32* %195, i64 4
%198 = bitcast i32* %197 to <4 x i32>*
store <4 x i32> %194, <4 x i32>* %198
%199 = or i64 %165, 24
%200 = getelementptr inbounds i32, i32* %154, i64 %199
%201 = bitcast i32* %200 to <4 x i32>*
%202 = load <4 x i32>, <4 x i32>* %201
%203 = getelementptr inbounds i32, i32* %200, i64 4
%204 = bitcast i32* %203 to <4 x i32>*
%205 = load <4 x i32>, <4 x i32>* %204
%206 = getelementptr inbounds i32, i32* %156, i64 %199
%207 = bitcast i32* %206 to <4 x i32>*
store <4 x i32> %202, <4 x i32>* %207
%208 = getelementptr inbounds i32, i32* %206, i64 4
%209 = bitcast i32* %208 to <4 x i32>*
store <4 x i32> %205, <4 x i32>* %209
%210 = add nuw i64 %165, 32
%211 = add i64 %166, 4
%212 = icmp eq i64 %211, %144
br i1 %212, label %213, label %164
213: ; preds = %164, %163
%214 = phi i64 [ 0, %163 ], [ %210, %164 ]
br i1 %145, label %231, label %215
215: ; preds = %213, %215
%216 = phi i64 [ %228, %215 ], [ %214, %213 ]
%217 = phi i64 [ %229, %215 ], [ 0, %213 ]
%218 = getelementptr inbounds i32, i32* %154, i64 %216
%219 = bitcast i32* %218 to <4 x i32>*
%220 = load <4 x i32>, <4 x i32>* %219
%221 = getelementptr inbounds i32, i32* %218, i64 4
%222 = bitcast i32* %221 to <4 x i32>*
%223 = load <4 x i32>, <4 x i32>* %222
%224 = getelementptr inbounds i32, i32* %156, i64 %216
%225 = bitcast i32* %224 to <4 x i32>*
store <4 x i32> %220, <4 x i32>* %225
%226 = getelementptr inbounds i32, i32* %224, i64 4
%227 = bitcast i32* %226 to <4 x i32>*
store <4 x i32> %223, <4 x i32>* %227
%228 = add nuw i64 %216, 8
%229 = add i64 %217, 1
%230 = icmp eq i64 %229, %142
br i1 %230, label %231, label %215
231: ; preds = %215, %213
br i1 %146, label %286, label %232
232: ; preds = %157, %152, %231
%233 = phi i64 [ 0, %157 ], [ 0, %152 ], [ %141, %231 ]
%234 = xor i64 %233, -1
%235 = add nsw i64 %234, %135
br i1 %148, label %245, label %236
236: ; preds = %232, %236
%237 = phi i64 [ %242, %236 ], [ %233, %232 ]
%238 = phi i64 [ %243, %236 ], [ 0, %232 ]
%239 = getelementptr inbounds i32, i32* %154, i64 %237
%240 = load i32, i32* %239
%241 = getelementptr inbounds i32, i32* %156, i64 %237
store i32 %240, i32* %241
%242 = add nuw nsw i64 %237, 1
%243 = add i64 %238, 1
%244 = icmp eq i64 %243, %147
br i1 %244, label %245, label %236
245: ; preds = %236, %232
%246 = phi i64 [ %233, %232 ], [ %242, %236 ]
%247 = icmp ult i64 %235, 3
br i1 %247, label %286, label %267
248: ; preds = %288, %117, %130
%249 = phi i8* [ %133, %130 ], [ %120, %117 ], [ %133, %288 ]
%250 = phi i32 [ %112, %130 ], [ %112, %117 ], [ %289, %288 ]
%251 = bitcast i8* %249 to i32*
br i1 %13, label %252, label %442
252: ; preds = %248
%253 = zext i32 %0 to i64
%254 = and i64 %253, 4294967288
%255 = add nsw i64 %254, -8
%256 = lshr exact i64 %255, 3
%257 = add nuw nsw i64 %256, 1
%258 = icmp ult i32 %0, 8
%259 = and i64 %253, 4294967288
%260 = and i64 %257, 3
%261 = icmp ult i64 %255, 24
%262 = and i64 %257, 4611686018427387900
%263 = icmp eq i64 %260, 0
%264 = icmp eq i64 %259, %253
%265 = and i64 %253, 3
%266 = icmp eq i64 %265, 0
br label %293
267: ; preds = %245, %267
%268 = phi i64 [ %284, %267 ], [ %246, %245 ]
%269 = getelementptr inbounds i32, i32* %154, i64 %268
%270 = load i32, i32* %269
%271 = getelementptr inbounds i32, i32* %156, i64 %268
store i32 %270, i32* %271
%272 = add nuw nsw i64 %268, 1
%273 = getelementptr inbounds i32, i32* %154, i64 %272
%274 = load i32, i32* %273
%275 = getelementptr inbounds i32, i32* %156, i64 %272
store i32 %274, i32* %275
%276 = add nuw nsw i64 %268, 2
%277 = getelementptr inbounds i32, i32* %154, i64 %276
%278 = load i32, i32* %277
%279 = getelementptr inbounds i32, i32* %156, i64 %276
store i32 %278, i32* %279
%280 = add nuw nsw i64 %268, 3
%281 = getelementptr inbounds i32, i32* %154, i64 %280
%282 = load i32, i32* %281
%283 = getelementptr inbounds i32, i32* %156, i64 %280
store i32 %282, i32* %283
%284 = add nuw nsw i64 %268, 4
%285 = icmp eq i64 %284, %135
br i1 %285, label %286, label %267
286: ; preds = %245, %267, %231
%287 = load i32, i32* %111
br label %288
288: ; preds = %286, %149
%289 = phi i32 [ %287, %286 ], [ %150, %149 ]
%290 = add nuw nsw i64 %151, 1
%291 = sext i32 %289 to i64
%292 = icmp slt i64 %290, %291
br i1 %292, label %149, label %248
293: ; preds = %252, %434
%294 = phi i64 [ 0, %252 ], [ %437, %434 ]
%295 = phi i32 [ -1, %252 ], [ %435, %434 ]
%296 = getelementptr inbounds i32, i32* %12, i64 %294
%297 = load i32, i32* %296
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds i32, i32* %2, i64 %298
%300 = load i32, i32* %299
%301 = add nsw i32 %297, 1
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds i32, i32* %2, i64 %302
%304 = load i32, i32* %303
%305 = icmp slt i32 %300, %304
br i1 %305, label %306, label %434
306: ; preds = %293
%307 = sext i32 %295 to i64
%308 = sext i32 %300 to i64
br label %309
309: ; preds = %427, %306
%310 = phi i64 [ %308, %306 ], [ %429, %427 ]
%311 = phi i64 [ %307, %306 ], [ %312, %427 ]
%312 = add nsw i64 %311, 1
%313 = getelementptr inbounds i32*, i32** %115, i64 %310
%314 = load i32*, i32** %313
%315 = getelementptr inbounds i32*, i32** %1, i64 %312
%316 = load i32*, i32** %315
br i1 %258, label %392, label %317
317: ; preds = %309
%318 = getelementptr i32, i32* %316, i64 %253
%319 = getelementptr i32, i32* %314, i64 %253
%320 = icmp ult i32* %316, %319
%321 = icmp ult i32* %314, %318
%322 = and i1 %320, %321
br i1 %322, label %392, label %323
323: ; preds = %317
br i1 %261, label %373, label %324
324: ; preds = %323, %324
%325 = phi i64 [ %370, %324 ], [ 0, %323 ]
%326 = phi i64 [ %371, %324 ], [ 0, %323 ]
%327 = getelementptr inbounds i32, i32* %314, i64 %325
%328 = bitcast i32* %327 to <4 x i32>*
%329 = load <4 x i32>, <4 x i32>* %328
%330 = getelementptr inbounds i32, i32* %327, i64 4
%331 = bitcast i32* %330 to <4 x i32>*
%332 = load <4 x i32>, <4 x i32>* %331
%333 = getelementptr inbounds i32, i32* %316, i64 %325
%334 = bitcast i32* %333 to <4 x i32>*
store <4 x i32> %329, <4 x i32>* %334
%335 = getelementptr inbounds i32, i32* %333, i64 4
%336 = bitcast i32* %335 to <4 x i32>*
store <4 x i32> %332, <4 x i32>* %336
%337 = or i64 %325, 8
%338 = getelementptr inbounds i32, i32* %314, i64 %337
%339 = bitcast i32* %338 to <4 x i32>*
%340 = load <4 x i32>, <4 x i32>* %339
%341 = getelementptr inbounds i32, i32* %338, i64 4
%342 = bitcast i32* %341 to <4 x i32>*
%343 = load <4 x i32>, <4 x i32>* %342
%344 = getelementptr inbounds i32, i32* %316, i64 %337
%345 = bitcast i32* %344 to <4 x i32>*
store <4 x i32> %340, <4 x i32>* %345
%346 = getelementptr inbounds i32, i32* %344, i64 4
%347 = bitcast i32* %346 to <4 x i32>*
store <4 x i32> %343, <4 x i32>* %347
%348 = or i64 %325, 16
%349 = getelementptr inbounds i32, i32* %314, i64 %348
%350 = bitcast i32* %349 to <4 x i32>*
%351 = load <4 x i32>, <4 x i32>* %350
%352 = getelementptr inbounds i32, i32* %349, i64 4
%353 = bitcast i32* %352 to <4 x i32>*
%354 = load <4 x i32>, <4 x i32>* %353
%355 = getelementptr inbounds i32, i32* %316, i64 %348
%356 = bitcast i32* %355 to <4 x i32>*
store <4 x i32> %351, <4 x i32>* %356
%357 = getelementptr inbounds i32, i32* %355, i64 4
%358 = bitcast i32* %357 to <4 x i32>*
store <4 x i32> %354, <4 x i32>* %358
%359 = or i64 %325, 24
%360 = getelementptr inbounds i32, i32* %314, i64 %359
%361 = bitcast i32* %360 to <4 x i32>*
%362 = load <4 x i32>, <4 x i32>* %361
%363 = getelementptr inbounds i32, i32* %360, i64 4
%364 = bitcast i32* %363 to <4 x i32>*
%365 = load <4 x i32>, <4 x i32>* %364
%366 = getelementptr inbounds i32, i32* %316, i64 %359
%367 = bitcast i32* %366 to <4 x i32>*
store <4 x i32> %362, <4 x i32>* %367
%368 = getelementptr inbounds i32, i32* %366, i64 4
%369 = bitcast i32* %368 to <4 x i32>*
store <4 x i32> %365, <4 x i32>* %369
%370 = add nuw i64 %325, 32
%371 = add i64 %326, 4
%372 = icmp eq i64 %371, %262
br i1 %372, label %373, label %324
373: ; preds = %324, %323
%374 = phi i64 [ 0, %323 ], [ %370, %324 ]
br i1 %263, label %391, label %375
375: ; preds = %373, %375
%376 = phi i64 [ %388, %375 ], [ %374, %373 ]
%377 = phi i64 [ %389, %375 ], [ 0, %373 ]
%378 = getelementptr inbounds i32, i32* %314, i64 %376
%379 = bitcast i32* %378 to <4 x i32>*
%380 = load <4 x i32>, <4 x i32>* %379
%381 = getelementptr inbounds i32, i32* %378, i64 4
%382 = bitcast i32* %381 to <4 x i32>*
%383 = load <4 x i32>, <4 x i32>* %382
%384 = getelementptr inbounds i32, i32* %316, i64 %376
%385 = bitcast i32* %384 to <4 x i32>*
store <4 x i32> %380, <4 x i32>* %385
%386 = getelementptr inbounds i32, i32* %384, i64 4
%387 = bitcast i32* %386 to <4 x i32>*
store <4 x i32> %383, <4 x i32>* %387
%388 = add nuw i64 %376, 8
%389 = add i64 %377, 1
%390 = icmp eq i64 %389, %260
br i1 %390, label %391, label %375
391: ; preds = %375, %373
br i1 %264, label %427, label %392
392: ; preds = %317, %309, %391
%393 = phi i64 [ 0, %317 ], [ 0, %309 ], [ %259, %391 ]
%394 = xor i64 %393, -1
%395 = add nsw i64 %394, %253
br i1 %266, label %405, label %396
396: ; preds = %392, %396
%397 = phi i64 [ %402, %396 ], [ %393, %392 ]
%398 = phi i64 [ %403, %396 ], [ 0, %392 ]
%399 = getelementptr inbounds i32, i32* %314, i64 %397
%400 = load i32, i32* %399
%401 = getelementptr inbounds i32, i32* %316, i64 %397
store i32 %400, i32* %401
%402 = add nuw nsw i64 %397, 1
%403 = add i64 %398, 1
%404 = icmp eq i64 %403, %265
br i1 %404, label %405, label %396
405: ; preds = %396, %392
%406 = phi i64 [ %393, %392 ], [ %402, %396 ]
%407 = icmp ult i64 %395, 3
br i1 %407, label %427, label %408
408: ; preds = %405, %408
%409 = phi i64 [ %425, %408 ], [ %406, %405 ]
%410 = getelementptr inbounds i32, i32* %314, i64 %409
%411 = load i32, i32* %410
%412 = getelementptr inbounds i32, i32* %316, i64 %409
store i32 %411, i32* %412
%413 = add nuw nsw i64 %409, 1
%414 = getelementptr inbounds i32, i32* %314, i64 %413
%415 = load i32, i32* %414
%416 = getelementptr inbounds i32, i32* %316, i64 %413
store i32 %415, i32* %416
%417 = add nuw nsw i64 %409, 2
%418 = getelementptr inbounds i32, i32* %314, i64 %417
%419 = load i32, i32* %418
%420 = getelementptr inbounds i32, i32* %316, i64 %417
store i32 %419, i32* %420
%421 = add nuw nsw i64 %409, 3
%422 = getelementptr inbounds i32, i32* %314, i64 %421
%423 = load i32, i32* %422
%424 = getelementptr inbounds i32, i32* %316, i64 %421
store i32 %423, i32* %424
%425 = add nuw nsw i64 %409, 4
%426 = icmp eq i64 %425, %253
br i1 %426, label %427, label %408
427: ; preds = %405, %408, %391
%428 = load i32, i32* %303
%429 = add nsw i64 %310, 1
%430 = sext i32 %428 to i64
%431 = icmp slt i64 %429, %430
br i1 %431, label %309, label %432
432: ; preds = %427
%433 = trunc i64 %312 to i32
br label %434
434: ; preds = %432, %293
%435 = phi i32 [ %295, %293 ], [ %433, %432 ]
%436 = add nsw i32 %435, 1
%437 = add nuw nsw i64 %294, 1
%438 = getelementptr inbounds i32, i32* %251, i64 %437
store i32 %436, i32* %438
%439 = icmp eq i64 %437, %253
br i1 %439, label %440, label %293
440: ; preds = %434
%441 = load i32, i32* %111
br label %442
442: ; preds = %440, %248
%443 = phi i32 [ %441, %440 ], [ %250, %248 ]
store i32 0, i32* %251
%444 = sext i32 %443 to i64
%445 = tail call i8* @calloc(i64 %444, i64 4)
%446 = bitcast i8* %445 to i32*
%447 = getelementptr inbounds i32, i32* %4, i64 %10
%448 = load i32, i32* %447
%449 = icmp sgt i32 %448, 0
br i1 %449, label %450, label %453
450: ; preds = %442
%451 = zext i32 %448 to i64
%452 = shl nuw nsw i64 %451, 2
br label %453
453: ; preds = %450, %442
br i1 %13, label %454, label %456
454: ; preds = %453
%455 = zext i32 %0 to i64
br label %462
456: ; preds = %497, %453
%457 = icmp slt i32 %0, 0
br i1 %457, label %501, label %458
458: ; preds = %456
%459 = zext i32 %0 to i64
%460 = shl nuw nsw i64 %459, 2
%461 = add nuw nsw i64 %460, 4
br label %501
462: ; preds = %454, %497
%463 = phi i64 [ 0, %454 ], [ %499, %497 ]
%464 = phi i32 [ -1, %454 ], [ %498, %497 ]
%465 = getelementptr inbounds i32, i32* %12, i64 %463
%466 = load i32, i32* %465
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds i32, i32* %4, i64 %467
%469 = load i32, i32* %468
%470 = add nsw i32 %466, 1
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds i32, i32* %4, i64 %471
%473 = load i32, i32* %472
%474 = icmp slt i32 %469, %473
br i1 %474, label %475, label %497
475: ; preds = %462
%476 = getelementptr inbounds i32, i32* %2, i64 %467
%477 = getelementptr inbounds i32, i32* %251, i64 %463
%478 = load i32, i32* %477
%479 = sext i32 %464 to i64
%480 = sext i32 %469 to i64
br label %481
481: ; preds = %475, %481
%482 = phi i64 [ %480, %475 ], [ %491, %481 ]
%483 = phi i64 [ %479, %475 ], [ %484, %481 ]
%484 = add nsw i64 %483, 1
%485 = getelementptr inbounds i32, i32* %446, i64 %482
%486 = load i32, i32* %485
%487 = load i32, i32* %476
%488 = sub i32 %486, %487
%489 = add i32 %488, %478
%490 = getelementptr inbounds i32, i32* %6, i64 %484
store i32 %489, i32* %490
%491 = add nsw i64 %482, 1
%492 = load i32, i32* %472
%493 = sext i32 %492 to i64
%494 = icmp slt i64 %491, %493
br i1 %494, label %481, label %495
495: ; preds = %481
%496 = trunc i64 %484 to i32
br label %497
497: ; preds = %495, %462
%498 = phi i32 [ %464, %462 ], [ %496, %495 ]
%499 = add nuw nsw i64 %463, 1
%500 = icmp eq i64 %499, %455
br i1 %500, label %456, label %462
501: ; preds = %458, %456
%502 = load i32, i32* %447
%503 = icmp sgt i32 %502, 0
br i1 %503, label %504, label %618
504: ; preds = %501
%505 = zext i32 %0 to i64
%506 = and i64 %505, 4294967288
%507 = add nsw i64 %506, -8
%508 = lshr exact i64 %507, 3
%509 = add nuw nsw i64 %508, 1
%510 = icmp ult i32 %0, 8
%511 = and i64 %505, 4294967288
%512 = and i64 %509, 3
%513 = icmp ult i64 %507, 24
%514 = and i64 %509, 4611686018427387900
%515 = icmp eq i64 %512, 0
%516 = icmp eq i64 %511, %505
%517 = and i64 %505, 3
%518 = icmp eq i64 %517, 0
br label %519
519: ; preds = %504, %656
%520 = phi i32 [ %502, %504 ], [ %657, %656 ]
%521 = phi i64 [ 0, %504 ], [ %658, %656 ]
br i1 %13, label %522, label %656
522: ; preds = %519
%523 = getelementptr inbounds i32*, i32** %3, i64 %521
%524 = load i32*, i32** %523
%525 = getelementptr inbounds i32*, i32** %115, i64 %521
%526 = load i32*, i32** %525
br i1 %510, label %602, label %527
527: ; preds = %522
%528 = getelementptr i32, i32* %526, i64 %505
%529 = getelementptr i32, i32* %524, i64 %505
%530 = icmp ult i32* %526, %529
%531 = icmp ult i32* %524, %528
%532 = and i1 %530, %531
br i1 %532, label %602, label %533
533: ; preds = %527
br i1 %513, label %583, label %534
534: ; preds = %533, %534
%535 = phi i64 [ %580, %534 ], [ 0, %533 ]
%536 = phi i64 [ %581, %534 ], [ 0, %533 ]
%537 = getelementptr inbounds i32, i32* %524, i64 %535
%538 = bitcast i32* %537 to <4 x i32>*
%539 = load <4 x i32>, <4 x i32>* %538
%540 = getelementptr inbounds i32, i32* %537, i64 4
%541 = bitcast i32* %540 to <4 x i32>*
%542 = load <4 x i32>, <4 x i32>* %541
%543 = getelementptr inbounds i32, i32* %526, i64 %535
%544 = bitcast i32* %543 to <4 x i32>*
store <4 x i32> %539, <4 x i32>* %544
%545 = getelementptr inbounds i32, i32* %543, i64 4
%546 = bitcast i32* %545 to <4 x i32>*
store <4 x i32> %542, <4 x i32>* %546
%547 = or i64 %535, 8
%548 = getelementptr inbounds i32, i32* %524, i64 %547
%549 = bitcast i32* %548 to <4 x i32>*
%550 = load <4 x i32>, <4 x i32>* %549
%551 = getelementptr inbounds i32, i32* %548, i64 4
%552 = bitcast i32* %551 to <4 x i32>*
%553 = load <4 x i32>, <4 x i32>* %552
%554 = getelementptr inbounds i32, i32* %526, i64 %547
%555 = bitcast i32* %554 to <4 x i32>*
store <4 x i32> %550, <4 x i32>* %555
%556 = getelementptr inbounds i32, i32* %554, i64 4
%557 = bitcast i32* %556 to <4 x i32>*
store <4 x i32> %553, <4 x i32>* %557
%558 = or i64 %535, 16
%559 = getelementptr inbounds i32, i32* %524, i64 %558
%560 = bitcast i32* %559 to <4 x i32>*
%561 = load <4 x i32>, <4 x i32>* %560
%562 = getelementptr inbounds i32, i32* %559, i64 4
%563 = bitcast i32* %562 to <4 x i32>*
%564 = load <4 x i32>, <4 x i32>* %563
%565 = getelementptr inbounds i32, i32* %526, i64 %558
%566 = bitcast i32* %565 to <4 x i32>*
store <4 x i32> %561, <4 x i32>* %566
%567 = getelementptr inbounds i32, i32* %565, i64 4
%568 = bitcast i32* %567 to <4 x i32>*
store <4 x i32> %564, <4 x i32>* %568
%569 = or i64 %535, 24
%570 = getelementptr inbounds i32, i32* %524, i64 %569
%571 = bitcast i32* %570 to <4 x i32>*
%572 = load <4 x i32>, <4 x i32>* %571
%573 = getelementptr inbounds i32, i32* %570, i64 4
%574 = bitcast i32* %573 to <4 x i32>*
%575 = load <4 x i32>, <4 x i32>* %574
%576 = getelementptr inbounds i32, i32* %526, i64 %569
%577 = bitcast i32* %576 to <4 x i32>*
store <4 x i32> %572, <4 x i32>* %577
%578 = getelementptr inbounds i32, i32* %576, i64 4
%579 = bitcast i32* %578 to <4 x i32>*
store <4 x i32> %575, <4 x i32>* %579
%580 = add nuw i64 %535, 32
%581 = add i64 %536, 4
%582 = icmp eq i64 %581, %514
br i1 %582, label %583, label %534
583: ; preds = %534, %533
%584 = phi i64 [ 0, %533 ], [ %580, %534 ]
br i1 %515, label %601, label %585
585: ; preds = %583, %585
%586 = phi i64 [ %598, %585 ], [ %584, %583 ]
%587 = phi i64 [ %599, %585 ], [ 0, %583 ]
%588 = getelementptr inbounds i32, i32* %524, i64 %586
%589 = bitcast i32* %588 to <4 x i32>*
%590 = load <4 x i32>, <4 x i32>* %589
%591 = getelementptr inbounds i32, i32* %588, i64 4
%592 = bitcast i32* %591 to <4 x i32>*
%593 = load <4 x i32>, <4 x i32>* %592
%594 = getelementptr inbounds i32, i32* %526, i64 %586
%595 = bitcast i32* %594 to <4 x i32>*
store <4 x i32> %590, <4 x i32>* %595
%596 = getelementptr inbounds i32, i32* %594, i64 4
%597 = bitcast i32* %596 to <4 x i32>*
store <4 x i32> %593, <4 x i32>* %597
%598 = add nuw i64 %586, 8
%599 = add i64 %587, 1
%600 = icmp eq i64 %599, %512
br i1 %600, label %601, label %585
601: ; preds = %585, %583
br i1 %516, label %654, label %602
602: ; preds = %527, %522, %601
%603 = phi i64 [ 0, %527 ], [ 0, %522 ], [ %511, %601 ]
%604 = xor i64 %603, -1
%605 = add nsw i64 %604, %505
br i1 %518, label %615, label %606
606: ; preds = %602, %606
%607 = phi i64 [ %612, %606 ], [ %603, %602 ]
%608 = phi i64 [ %613, %606 ], [ 0, %602 ]
%609 = getelementptr inbounds i32, i32* %524, i64 %607
%610 = load i32, i32* %609
%611 = getelementptr inbounds i32, i32* %526, i64 %607
store i32 %610, i32* %611
%612 = add nuw nsw i64 %607, 1
%613 = add i64 %608, 1
%614 = icmp eq i64 %613, %517
br i1 %614, label %615, label %606
615: ; preds = %606, %602
%616 = phi i64 [ %603, %602 ], [ %612, %606 ]
%617 = icmp ult i64 %605, 3
br i1 %617, label %654, label %635
618: ; preds = %656, %501
br i1 %13, label %620, label %619
619: ; preds = %618
store i32 0, i32* %4
br label %816
620: ; preds = %618
%621 = zext i32 %0 to i64
%622 = and i64 %621, 4294967288
%623 = add nsw i64 %622, -8
%624 = lshr exact i64 %623, 3
%625 = add nuw nsw i64 %624, 1
%626 = icmp ult i32 %0, 8
%627 = and i64 %621, 4294967288
%628 = and i64 %625, 3
%629 = icmp ult i64 %623, 24
%630 = and i64 %625, 4611686018427387900
%631 = icmp eq i64 %628, 0
%632 = icmp eq i64 %627, %621
%633 = and i64 %621, 3
%634 = icmp eq i64 %633, 0
br label %661
635: ; preds = %615, %635
%636 = phi i64 [ %652, %635 ], [ %616, %615 ]
%637 = getelementptr inbounds i32, i32* %524, i64 %636
%638 = load i32, i32* %637
%639 = getelementptr inbounds i32, i32* %526, i64 %636
store i32 %638, i32* %639
%640 = add nuw nsw i64 %636, 1
%641 = getelementptr inbounds i32, i32* %524, i64 %640
%642 = load i32, i32* %641
%643 = getelementptr inbounds i32, i32* %526, i64 %640
store i32 %642, i32* %643
%644 = add nuw nsw i64 %636, 2
%645 = getelementptr inbounds i32, i32* %524, i64 %644
%646 = load i32, i32* %645
%647 = getelementptr inbounds i32, i32* %526, i64 %644
store i32 %646, i32* %647
%648 = add nuw nsw i64 %636, 3
%649 = getelementptr inbounds i32, i32* %524, i64 %648
%650 = load i32, i32* %649
%651 = getelementptr inbounds i32, i32* %526, i64 %648
store i32 %650, i32* %651
%652 = add nuw nsw i64 %636, 4
%653 = icmp eq i64 %652, %505
br i1 %653, label %654, label %635
654: ; preds = %615, %635, %601
%655 = load i32, i32* %447
br label %656
656: ; preds = %654, %519
%657 = phi i32 [ %655, %654 ], [ %520, %519 ]
%658 = add nuw nsw i64 %521, 1
%659 = sext i32 %657 to i64
%660 = icmp slt i64 %658, %659
br i1 %660, label %519, label %618
661: ; preds = %620, %802
%662 = phi i64 [ 0, %620 ], [ %805, %802 ]
%663 = phi i32 [ -1, %620 ], [ %803, %802 ]
%664 = getelementptr inbounds i32, i32* %12, i64 %662
%665 = load i32, i32* %664
%666 = sext i32 %665 to i64
%667 = getelementptr inbounds i32, i32* %4, i64 %666
%668 = load i32, i32* %667
%669 = add nsw i32 %665, 1
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds i32, i32* %4, i64 %670
%672 = load i32, i32* %671
%673 = icmp slt i32 %668, %672
br i1 %673, label %674, label %802
674: ; preds = %661
%675 = sext i32 %663 to i64
%676 = sext i32 %668 to i64
br label %677
677: ; preds = %795, %674
%678 = phi i64 [ %676, %674 ], [ %797, %795 ]
%679 = phi i64 [ %675, %674 ], [ %680, %795 ]
%680 = add nsw i64 %679, 1
%681 = getelementptr inbounds i32*, i32** %115, i64 %678
%682 = load i32*, i32** %681
%683 = getelementptr inbounds i32*, i32** %3, i64 %680
%684 = load i32*, i32** %683
br i1 %626, label %760, label %685
685: ; preds = %677
%686 = getelementptr i32, i32* %684, i64 %621
%687 = getelementptr i32, i32* %682, i64 %621
%688 = icmp ult i32* %684, %687
%689 = icmp ult i32* %682, %686
%690 = and i1 %688, %689
br i1 %690, label %760, label %691
691: ; preds = %685
br i1 %629, label %741, label %692
692: ; preds = %691, %692
%693 = phi i64 [ %738, %692 ], [ 0, %691 ]
%694 = phi i64 [ %739, %692 ], [ 0, %691 ]
%695 = getelementptr inbounds i32, i32* %682, i64 %693
%696 = bitcast i32* %695 to <4 x i32>*
%697 = load <4 x i32>, <4 x i32>* %696
%698 = getelementptr inbounds i32, i32* %695, i64 4
%699 = bitcast i32* %698 to <4 x i32>*
%700 = load <4 x i32>, <4 x i32>* %699
%701 = getelementptr inbounds i32, i32* %684, i64 %693
%702 = bitcast i32* %701 to <4 x i32>*
store <4 x i32> %697, <4 x i32>* %702
%703 = getelementptr inbounds i32, i32* %701, i64 4
%704 = bitcast i32* %703 to <4 x i32>*
store <4 x i32> %700, <4 x i32>* %704
%705 = or i64 %693, 8
%706 = getelementptr inbounds i32, i32* %682, i64 %705
%707 = bitcast i32* %706 to <4 x i32>*
%708 = load <4 x i32>, <4 x i32>* %707
%709 = getelementptr inbounds i32, i32* %706, i64 4
%710 = bitcast i32* %709 to <4 x i32>*
%711 = load <4 x i32>, <4 x i32>* %710
%712 = getelementptr inbounds i32, i32* %684, i64 %705
%713 = bitcast i32* %712 to <4 x i32>*
store <4 x i32> %708, <4 x i32>* %713
%714 = getelementptr inbounds i32, i32* %712, i64 4
%715 = bitcast i32* %714 to <4 x i32>*
store <4 x i32> %711, <4 x i32>* %715
%716 = or i64 %693, 16
%717 = getelementptr inbounds i32, i32* %682, i64 %716
%718 = bitcast i32* %717 to <4 x i32>*
%719 = load <4 x i32>, <4 x i32>* %718
%720 = getelementptr inbounds i32, i32* %717, i64 4
%721 = bitcast i32* %720 to <4 x i32>*
%722 = load <4 x i32>, <4 x i32>* %721
%723 = getelementptr inbounds i32, i32* %684, i64 %716
%724 = bitcast i32* %723 to <4 x i32>*
store <4 x i32> %719, <4 x i32>* %724
%725 = getelementptr inbounds i32, i32* %723, i64 4
%726 = bitcast i32* %725 to <4 x i32>*
store <4 x i32> %722, <4 x i32>* %726
%727 = or i64 %693, 24
%728 = getelementptr inbounds i32, i32* %682, i64 %727
%729 = bitcast i32* %728 to <4 x i32>*
%730 = load <4 x i32>, <4 x i32>* %729
%731 = getelementptr inbounds i32, i32* %728, i64 4
%732 = bitcast i32* %731 to <4 x i32>*
%733 = load <4 x i32>, <4 x i32>* %732
%734 = getelementptr inbounds i32, i32* %684, i64 %727
%735 = bitcast i32* %734 to <4 x i32>*
store <4 x i32> %730, <4 x i32>* %735
%736 = getelementptr inbounds i32, i32* %734, i64 4
%737 = bitcast i32* %736 to <4 x i32>*
store <4 x i32> %733, <4 x i32>* %737
%738 = add nuw i64 %693, 32
%739 = add i64 %694, 4
%740 = icmp eq i64 %739, %630
br i1 %740, label %741, label %692
741: ; preds = %692, %691
%742 = phi i64 [ 0, %691 ], [ %738, %692 ]
br i1 %631, label %759, label %743
743: ; preds = %741, %743
%744 = phi i64 [ %756, %743 ], [ %742, %741 ]
%745 = phi i64 [ %757, %743 ], [ 0, %741 ]
%746 = getelementptr inbounds i32, i32* %682, i64 %744
%747 = bitcast i32* %746 to <4 x i32>*
%748 = load <4 x i32>, <4 x i32>* %747
%749 = getelementptr inbounds i32, i32* %746, i64 4
%750 = bitcast i32* %749 to <4 x i32>*
%751 = load <4 x i32>, <4 x i32>* %750
%752 = getelementptr inbounds i32, i32* %684, i64 %744
%753 = bitcast i32* %752 to <4 x i32>*
store <4 x i32> %748, <4 x i32>* %753
%754 = getelementptr inbounds i32, i32* %752, i64 4
%755 = bitcast i32* %754 to <4 x i32>*
store <4 x i32> %751, <4 x i32>* %755
%756 = add nuw i64 %744, 8
%757 = add i64 %745, 1
%758 = icmp eq i64 %757, %628
br i1 %758, label %759, label %743
759: ; preds = %743, %741
br i1 %632, label %795, label %760
760: ; preds = %685, %677, %759
%761 = phi i64 [ 0, %685 ], [ 0, %677 ], [ %627, %759 ]
%762 = xor i64 %761, -1
%763 = add nsw i64 %762, %621
br i1 %634, label %773, label %764
764: ; preds = %760, %764
%765 = phi i64 [ %770, %764 ], [ %761, %760 ]
%766 = phi i64 [ %771, %764 ], [ 0, %760 ]
%767 = getelementptr inbounds i32, i32* %682, i64 %765
%768 = load i32, i32* %767
%769 = getelementptr inbounds i32, i32* %684, i64 %765
store i32 %768, i32* %769
%770 = add nuw nsw i64 %765, 1
%771 = add i64 %766, 1
%772 = icmp eq i64 %771, %633
br i1 %772, label %773, label %764
773: ; preds = %764, %760
%774 = phi i64 [ %761, %760 ], [ %770, %764 ]
%775 = icmp ult i64 %763, 3
br i1 %775, label %795, label %776
776: ; preds = %773, %776
%777 = phi i64 [ %793, %776 ], [ %774, %773 ]
%778 = getelementptr inbounds i32, i32* %682, i64 %777
%779 = load i32, i32* %778
%780 = getelementptr inbounds i32, i32* %684, i64 %777
store i32 %779, i32* %780
%781 = add nuw nsw i64 %777, 1
%782 = getelementptr inbounds i32, i32* %682, i64 %781
%783 = load i32, i32* %782
%784 = getelementptr inbounds i32, i32* %684, i64 %781
store i32 %783, i32* %784
%785 = add nuw nsw i64 %777, 2
%786 = getelementptr inbounds i32, i32* %682, i64 %785
%787 = load i32, i32* %786
%788 = getelementptr inbounds i32, i32* %684, i64 %785
store i32 %787, i32* %788
%789 = add nuw nsw i64 %777, 3
%790 = getelementptr inbounds i32, i32* %682, i64 %789
%791 = load i32, i32* %790
%792 = getelementptr inbounds i32, i32* %684, i64 %789
store i32 %791, i32* %792
%793 = add nuw nsw i64 %777, 4
%794 = icmp eq i64 %793, %621
br i1 %794, label %795, label %776
795: ; preds = %773, %776, %759
%796 = load i32, i32* %671
%797 = add nsw i64 %678, 1
%798 = sext i32 %796 to i64
%799 = icmp slt i64 %797, %798
br i1 %799, label %677, label %800
800: ; preds = %795
%801 = trunc i64 %680 to i32
br label %802
802: ; preds = %800, %661
%803 = phi i32 [ %663, %661 ], [ %801, %800 ]
%804 = add nsw i32 %803, 1
%805 = add nuw nsw i64 %662, 1
%806 = getelementptr inbounds i32, i32* %251, i64 %805
store i32 %804, i32* %806
%807 = icmp eq i64 %805, %621
br i1 %807, label %808, label %661
808: ; preds = %802
store i32 0, i32* %4
%809 = icmp slt i32 %0, 1
br i1 %809, label %816, label %810
810: ; preds = %808
%811 = getelementptr i32, i32* %4, i64 1
%812 = bitcast i32* %811 to i8*
%813 = getelementptr i8, i8* %249, i64 4
%814 = zext i32 %0 to i64
%815 = shl nuw nsw i64 %814, 2
br label %816
816: ; preds = %619, %810, %808
tail call void @free(i8* %11)
tail call void @free(i8* %445)
tail call void @free(i8* %249)
%817 = load i32, i32* %111
%818 = icmp sgt i32 %817, 0
br i1 %818, label %819, label %828
819: ; preds = %816, %819
%820 = phi i64 [ %824, %819 ], [ 0, %816 ]
%821 = getelementptr inbounds i32*, i32** %115, i64 %820
%822 = bitcast i32** %821 to i8**
%823 = load i8*, i8** %822
tail call void @free(i8* %823)
%824 = add nuw nsw i64 %820, 1
%825 = load i32, i32* %111
%826 = sext i32 %825 to i64
%827 = icmp slt i64 %824, %826
br i1 %827, label %819, label %828
828: ; preds = %819, %816
tail call void @free(i8* %114)
ret void
}