void Pre4MV(int nVar, int nSpt, int *nS, int *SptType, int **Spt, int *SptIdx,
            int **Vtx, int *VtxIdx, int *OldIdx) {
  int i, j, k, l, icnt, itmp;
  int ynReOrder, *OrderSpt, *iTmp, *iTmp1, **SptCopy, *NuIdx2OldIdxCopy;
  int ibreak;
  if (0 > 0) {
    printf("entering Pre4MV with nVar = %d and nSpt = %d\n", nVar, nSpt);
    printf("indices to supports : ");
    for (i = 0; i <= nVar; i++)
      printf(" %d", SptIdx[i]);
    printf("\n");
    if (0 > 1)
      write_supports(nVar, nSpt, Spt, SptIdx);
  }
  SortSpt(nVar, nSpt, Spt, SptIdx);
  for (i = 0; i < nVar; i++) {
    for (j = SptIdx[i]; j < SptIdx[i + 1] - 1; j++) {
      itmp = 0;
      for (k = 0; k < nVar; k++)
        itmp += abs(Spt[j][k] - Spt[j + 1][k]);
      if (itmp == 0) {
        printf("%d-th and %d-th points in %d-th support are same!\n", j + 1,
               j + 2, i + 1);
        exit(0);
      }
    }
  }
  NonVertex(nVar, nSpt, SptIdx, Spt, OldIdx);
  icnt = -1;
  for (i = 0; i < nVar; i++) {
    for (j = SptIdx[i]; j < SptIdx[i + 1]; j++) {
      if (OldIdx[j] == 1) {
        icnt = icnt + 1;
        for (k = 0; k < nVar; k++)
          Vtx[icnt][k] = Spt[j][k];
        OldIdx[icnt] = j;
      }
    }
    VtxIdx[i + 1] = icnt + 1;
  }
  VtxIdx[0] = 0;
  ynReOrder = 0;
  OrderSpt = (int *)calloc(nVar, sizeof(int));
  iTmp = (int *)calloc(nVar + 1, sizeof(int));
  iTmp1 = (int *)calloc(nVar + 1, sizeof(int));
  SptCopy = (int **)calloc(SptIdx[nVar], sizeof(int *));
  for (i = 0; i < SptIdx[nVar]; i++)
    SptCopy[i] = (int *)calloc(nVar, sizeof(int));
  NuIdx2OldIdxCopy = (int *)calloc(SptIdx[nVar], sizeof(int));
  for (i = 0; i < nVar; i++)
    iTmp[i] = 0;
  for (i = 0; i < nVar; i++) {
    itmp = 1000000;
    for (j = 0; j < nVar; j++) {
      if (iTmp[j] == 0 && VtxIdx[j + 1] - VtxIdx[j] < itmp) {
        itmp = VtxIdx[j + 1] - VtxIdx[j];
        OrderSpt[i] = j;
      }
    }
    if (OrderSpt[i] != i)
      ynReOrder = 1;
    iTmp[OrderSpt[i]] = 1;
  }
  if (ynReOrder == 1) {
    iTmp[0] = 0;
    iTmp1[0] = 0;
    icnt = -1;
    for (i = 0; i < nVar; i++) {
      for (j = SptIdx[OrderSpt[i]]; j < SptIdx[OrderSpt[i] + 1]; j++) {
        icnt = icnt + 1;
        for (k = 0; k < nVar; k++)
          SptCopy[icnt][k] = Spt[j][k];
      }
      iTmp[i + 1] = icnt + 1;
    }
    for (j = 0; j <= icnt; j++)
      for (i = 0; i < nVar; i++)
        Spt[j][i] = SptCopy[j][i];
    icnt = -1;
    for (i = 0; i < nVar; i++) {
      for (j = VtxIdx[OrderSpt[i]]; j < VtxIdx[OrderSpt[i] + 1]; j++) {
        icnt = icnt + 1;
        for (k = 0; k < nVar; k++)
          SptCopy[icnt][k] = Vtx[j][k];
        NuIdx2OldIdxCopy[icnt] = OldIdx[j] - (SptIdx[OrderSpt[i]] - iTmp[i]);
      }
      iTmp1[i + 1] = icnt + 1;
    }
    for (j = 0; j <= icnt; j++) {
      for (i = 0; i < nVar; i++)
        Vtx[j][i] = SptCopy[j][i];
      OldIdx[j] = NuIdx2OldIdxCopy[j];
    }
    for (i = 0; i <= nVar; i++)
      SptIdx[i] = iTmp[i];
    for (i = 0; i <= nVar; i++)
      VtxIdx[i] = iTmp1[i];
  }
  for (i = 0; i < nVar; i++)
    SptType[i] = -1;
  nSpt = 0;
  for (i = 0; i < nVar - 1; i++) {
    if (SptType[i] < 0) {
      nSpt = nSpt + 1;
      for (j = i + 1; j < nVar; j++) {
        if (SptType[j] < 0) {
          if (VtxIdx[j + 1] - VtxIdx[j] != VtxIdx[i + 1] - VtxIdx[i])
            continue;
          ibreak = 0;
          for (k = VtxIdx[i]; k < VtxIdx[i + 1]; k++) {
            for (l = 0; l < nVar; l++) {
              if (Vtx[k][l] != Vtx[k + VtxIdx[j] - VtxIdx[i]][l]) {
                ibreak = 1;
                break;
              }
            }
            if (ibreak)
              break;
          }
          if (ibreak)
            continue;
          SptType[j] = i;
        }
      }
    }
  }
  if (SptType[nVar - 1] < 0)
    nSpt = nSpt + 1;
  if (nSpt < nVar) {
    ReArrangeSpt(nVar, Spt, SptIdx, Vtx, VtxIdx, SptType, OldIdx);
  } else {
    nSpt = nVar;
    for (i = 0; i < nVar; i++)
      SptType[i] = 1;
  }
  *nS = nSpt;
  if (0 > 0) {
    printf("leaving Pre4MV with nS = %d\n", *nS);
    printf("Type of mixture : ");
    for (i = 0; i < *nS; i++)
      printf(" %d", SptType[i]);
    printf("\n");
    printf("indices to supports : ");
    for (i = 0; i <= *nS; i++)
      printf(" %d", VtxIdx[i]);
    printf("\n");
    write_supports(nVar, *nS, Vtx, VtxIdx);
    printf("The old indices : ");
    for (i = 0; i < SptIdx[nVar]; i++)
      printf(" %d", OldIdx[i]);
    printf("\n");
  }
  free(OrderSpt);
  free(iTmp);
  free(iTmp1);
  for (i = 0; i < SptIdx[nVar]; i++)
    free(SptCopy[i]);
  free(SptCopy);
  free(NuIdx2OldIdxCopy);
}


x86 assembly (clang, -O0):
<Pre4MV>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    $0x0,%al
call   1060 <SortSpt@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12b6 <Pre4MV+0x136>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x28(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12a3 <Pre4MV+0x123>
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    125f <Pre4MV+0xdf>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
sub    (%rax,%rcx,4),%edi
call   1040 <abs@plt>
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    120f <Pre4MV+0x8f>
cmpl   $0x0,-0x40(%rbp)
jne    1290 <Pre4MV+0x110>
mov    -0x30(%rbp),%esi
add    $0x1,%esi
mov    -0x30(%rbp),%edx
add    $0x2,%edx
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
lea    0xd7e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
xor    %edi,%edi
call   1090 <exit@plt>
jmp    1295 <Pre4MV+0x115>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11e3 <Pre4MV+0x63>
jmp    12a8 <Pre4MV+0x128>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11c9 <Pre4MV+0x49>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    0x20(%rbp),%r8
mov    $0x0,%al
call   1080 <NonVertex@plt>
movl   $0xffffffff,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13b7 <Pre4MV+0x237>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x28(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1393 <Pre4MV+0x213>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    1380 <Pre4MV+0x200>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1372 <Pre4MV+0x1f2>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
movslq -0x3c(%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    1332 <Pre4MV+0x1b2>
mov    -0x30(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1385 <Pre4MV+0x205>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12f7 <Pre4MV+0x177>
mov    -0x3c(%rbp),%edx
add    $0x1,%edx
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12dd <Pre4MV+0x15d>
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x44(%rbp)
movslq -0x4(%rbp),%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
movslq (%rax,%rcx,4),%rdi
mov    $0x8,%esi
call   1070 <calloc@plt>
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1468 <Pre4MV+0x2e8>
movslq -0x4(%rbp),%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,%rdx
mov    -0x68(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1429 <Pre4MV+0x2a9>
mov    -0x28(%rbp),%rax
movslq -0x4(%rbp),%rcx
movslq (%rax,%rcx,4),%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14b2 <Pre4MV+0x332>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1489 <Pre4MV+0x309>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1594 <Pre4MV+0x414>
movl   $0xf4240,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1554 <Pre4MV+0x3d4>
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1541 <Pre4MV+0x3c1>
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x18(%rbp),%rcx
movslq -0x30(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
cmp    -0x40(%rbp),%eax
jge    1541 <Pre4MV+0x3c1>
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x18(%rbp),%rcx
movslq -0x30(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%edx
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1546 <Pre4MV+0x3c6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14d3 <Pre4MV+0x353>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x2c(%rbp),%eax
je     156f <Pre4MV+0x3ef>
movl   $0x1,-0x44(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14b9 <Pre4MV+0x339>
cmpl   $0x1,-0x44(%rbp)
jne    18f1 <Pre4MV+0x771>
mov    -0x58(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x60(%rbp),%rax
movl   $0x0,(%rax)
movl   $0xffffffff,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    168a <Pre4MV+0x50a>
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x28(%rbp),%rcx
mov    -0x50(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1666 <Pre4MV+0x4e6>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1653 <Pre4MV+0x4d3>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
movslq -0x3c(%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    1613 <Pre4MV+0x493>
jmp    1658 <Pre4MV+0x4d8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15e2 <Pre4MV+0x462>
mov    -0x3c(%rbp),%edx
add    $0x1,%edx
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15c0 <Pre4MV+0x440>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     16f7 <Pre4MV+0x577>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16e4 <Pre4MV+0x564>
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16a4 <Pre4MV+0x524>
jmp    16e9 <Pre4MV+0x569>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1691 <Pre4MV+0x511>
movl   $0xffffffff,-0x3c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1800 <Pre4MV+0x680>
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    -0x50(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    17dc <Pre4MV+0x65c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1798 <Pre4MV+0x618>
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
movslq -0x3c(%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    1758 <Pre4MV+0x5d8>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movslq -0x2c(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x58(%rbp),%rcx
movslq -0x2c(%rbp),%rsi
sub    (%rcx,%rsi,4),%eax
sub    %eax,%edx
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1727 <Pre4MV+0x5a7>
mov    -0x3c(%rbp),%edx
add    $0x1,%edx
mov    -0x60(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1705 <Pre4MV+0x585>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     187e <Pre4MV+0x6fe>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    185a <Pre4MV+0x6da>
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    181a <Pre4MV+0x69a>
mov    -0x70(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1807 <Pre4MV+0x687>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     18b5 <Pre4MV+0x735>
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1885 <Pre4MV+0x705>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     18ec <Pre4MV+0x76c>
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18bc <Pre4MV+0x73c>
jmp    18f1 <Pre4MV+0x771>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1921 <Pre4MV+0x7a1>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18f8 <Pre4MV+0x778>
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1ad3 <Pre4MV+0x953>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1ac0 <Pre4MV+0x940>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1abb <Pre4MV+0x93b>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1aa8 <Pre4MV+0x928>
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x18(%rbp),%rcx
movslq -0x30(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
mov    0x18(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
cmp    %ecx,%eax
je     19c5 <Pre4MV+0x845>
jmp    1aad <Pre4MV+0x92d>
movl   $0x0,-0x74(%rbp)
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x18(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1a8b <Pre4MV+0x90b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1a69 <Pre4MV+0x8e9>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x10(%rbp),%rcx
mov    -0x34(%rbp),%edx
mov    0x18(%rbp),%rsi
movslq -0x30(%rbp),%rdi
add    (%rsi,%rdi,4),%edx
mov    0x18(%rbp),%rsi
movslq -0x2c(%rbp),%rdi
sub    (%rsi,%rdi,4),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     1a56 <Pre4MV+0x8d6>
movl   $0x1,-0x74(%rbp)
jmp    1a69 <Pre4MV+0x8e9>
jmp    1a5b <Pre4MV+0x8db>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19fa <Pre4MV+0x87a>
cmpl   $0x0,-0x74(%rbp)
je     1a78 <Pre4MV+0x8f8>
jmp    1a8b <Pre4MV+0x90b>
jmp    1a7d <Pre4MV+0x8fd>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19da <Pre4MV+0x85a>
cmpl   $0x0,-0x74(%rbp)
je     1a9a <Pre4MV+0x91a>
jmp    1aad <Pre4MV+0x92d>
mov    -0x2c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1aad <Pre4MV+0x92d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1964 <Pre4MV+0x7e4>
jmp    1ac0 <Pre4MV+0x940>
jmp    1ac5 <Pre4MV+0x945>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    192f <Pre4MV+0x7af>
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1af3 <Pre4MV+0x973>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b2a <Pre4MV+0x9aa>
mov    -0x4(%rbp),%edi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    0x10(%rbp),%rcx
mov    0x18(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    0x20(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   10a0 <ReArrangeSpt@plt>
jmp    1b65 <Pre4MV+0x9e5>
mov    -0x4(%rbp),%eax
mov    %eax,-0x8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b60 <Pre4MV+0x9e0>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b37 <Pre4MV+0x9b7>
jmp    1b65 <Pre4MV+0x9e5>
mov    -0x8(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%rcx
movslq -0x4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1bc3 <Pre4MV+0xa43>
mov    -0x68(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b90 <Pre4MV+0xa10>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Pre4MV>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,%r12
mov    %r8,%r13
mov    %rcx,0x70(%rsp)
mov    %rdx,0x50(%rsp)
mov    %esi,%ebp
mov    %edi,%ebx
mov    0xf0(%rsp),%r14
mov    0xe8(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0xe0(%rsp),%rax
mov    %rax,0x68(%rsp)
mov    %r8,%rdx
mov    %r9,%rcx
xor    %eax,%eax
call   1060 <SortSpt@plt>
mov    %ebx,%r15d
test   %ebx,%ebx
mov    %rbx,0x8(%rsp)
mov    %r14,0x28(%rsp)
mov    %r12,0x20(%rsp)
jle    1586 <Pre4MV+0x3f6>
mov    (%r12),%r8d
mov    %r15d,%r9d
and    $0xfffffff8,%r9d
lea    0x0(,%r15,4),%r11
and    $0xffffffffffffffe0,%r11
xor    %ecx,%ecx
mov    %ebp,%r12d
jmp    1229 <Pre4MV+0x99>
nopl   0x0(%rax)
cmp    %r15,%rcx
je     1339 <Pre4MV+0x1a9>
mov    %r8d,%eax
mov    0x20(%rsp),%rdx
mov    0x4(%rdx,%rcx,4),%r8d
add    $0x1,%rcx
lea    -0x1(%r8),%esi
cmp    %esi,%eax
jge    1220 <Pre4MV+0x90>
movslq %eax,%rdx
movslq %esi,%r10
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rdx,8),%rbx
mov    0x8(%r13,%rdx,8),%rax
cmpl   $0x8,0x8(%rsp)
jae    1270 <Pre4MV+0xe0>
xor    %ebp,%ebp
xor    %esi,%esi
jmp    1300 <Pre4MV+0x170>
nopw   0x0(%rax,%rax,1)
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu (%rbx,%rsi,1),%xmm2
movdqu 0x10(%rbx,%rsi,1),%xmm3
movdqu (%rax,%rsi,1),%xmm4
psubd  %xmm4,%xmm2
movdqu 0x10(%rax,%rsi,1),%xmm4
psubd  %xmm4,%xmm3
movdqa %xmm2,%xmm4
psrad  $0x1f,%xmm4
paddd  %xmm4,%xmm2
pxor   %xmm4,%xmm2
paddd  %xmm2,%xmm0
movdqa %xmm3,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm3
pxor   %xmm2,%xmm3
paddd  %xmm3,%xmm1
add    $0x20,%rsi
cmp    %rsi,%r11
jne    1280 <Pre4MV+0xf0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%esi
mov    %r9,%rbp
cmp    %r15,%r9
je     131c <Pre4MV+0x18c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx,%rbp,4),%r14d
sub    (%rax,%rbp,4),%r14d
mov    %r14d,%edi
neg    %edi
cmovs  %r14d,%edi
add    %edi,%esi
add    $0x1,%rbp
cmp    %rbp,%r15
jne    1300 <Pre4MV+0x170>
test   %esi,%esi
je     239b <Pre4MV+0x120b>
add    $0x1,%rdx
cmp    %r10,%rdx
mov    %r12d,%ebp
jne    1250 <Pre4MV+0xc0>
jmp    1220 <Pre4MV+0x90>
mov    0x8(%rsp),%rbx
mov    %ebx,%edi
mov    %ebp,%esi
mov    0x20(%rsp),%r12
mov    %r12,%rdx
mov    %r13,%rcx
mov    0x28(%rsp),%rbp
mov    %rbp,%r8
xor    %eax,%eax
call   1090 <NonVertex@plt>
test   %ebx,%ebx
mov    0x10(%rsp),%rdi
jle    159f <Pre4MV+0x40f>
mov    %r15d,%eax
and    $0xfffffff8,%eax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x18(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %r15d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x40(%rsp)
mov    %eax,%esi
and    $0x3,%esi
and    $0xfffffffffffffffc,%rax
mov    %rax,0x38(%rsp)
mov    %r15d,%r14d
and    $0x3,%r14d
mov    %rsi,0x30(%rsp)
shl    $0x5,%rsi
mov    $0xffffffff,%r8d
xor    %r9d,%r9d
jmp    13d1 <Pre4MV+0x241>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%r8),%eax
mov    %eax,(%rdi,%r9,4)
cmp    %r15,%r9
je     159f <Pre4MV+0x40f>
movslq (%r12,%r9,4),%rdx
mov    0x4(%r12,%r9,4),%ecx
add    $0x1,%r9
cmp    %ecx,%edx
jl     1413 <Pre4MV+0x283>
jmp    13c0 <Pre4MV+0x230>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r8d
mov    0x28(%rsp),%rbp
mov    %edx,0x0(%rbp,%r10,4)
mov    (%r12,%r9,4),%ecx
mov    0x10(%rsp),%rdi
add    $0x1,%rdx
movslq %ecx,%rax
cmp    %rax,%rdx
jge    13c0 <Pre4MV+0x230>
cmpl   $0x1,0x0(%rbp,%rdx,4)
jne    1407 <Pre4MV+0x277>
movslq %r8d,%rax
lea    0x1(%rax),%r10
mov    0x0(%r13,%rdx,8),%rbx
mov    0x68(%rsp),%rcx
mov    0x8(%rcx,%rax,8),%rdi
cmpl   $0x8,0x8(%rsp)
jb     1449 <Pre4MV+0x2b9>
lea    (%rbx,%r15,4),%rax
cmp    %rax,%rdi
jae    14b4 <Pre4MV+0x324>
lea    (%rdi,%r15,4),%rax
cmp    %rax,%rbx
jae    14b4 <Pre4MV+0x324>
xor    %r11d,%r11d
mov    %r11,%rcx
not    %rcx
add    %r15,%rcx
test   %r14,%r14
je     1472 <Pre4MV+0x2e2>
mov    %r14,%rbp
nopl   (%rax)
mov    (%rbx,%r11,4),%eax
mov    %eax,(%rdi,%r11,4)
add    $0x1,%r11
add    $0xffffffffffffffff,%rbp
jne    1460 <Pre4MV+0x2d0>
cmp    $0x3,%rcx
jb     13f0 <Pre4MV+0x260>
nopl   0x0(%rax)
mov    (%rbx,%r11,4),%eax
mov    %eax,(%rdi,%r11,4)
mov    0x4(%rbx,%r11,4),%eax
mov    %eax,0x4(%rdi,%r11,4)
mov    0x8(%rbx,%r11,4),%eax
mov    %eax,0x8(%rdi,%r11,4)
mov    0xc(%rbx,%r11,4),%eax
mov    %eax,0xc(%rdi,%r11,4)
add    $0x4,%r11
cmp    %r11,%r15
jne    1480 <Pre4MV+0x2f0>
jmp    13f0 <Pre4MV+0x260>
cmpq   $0x18,0x18(%rsp)
jae    14c0 <Pre4MV+0x330>
xor    %ecx,%ecx
jmp    152c <Pre4MV+0x39c>
mov    0x38(%rsp),%rbp
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups %xmm0,(%rdi,%rcx,4)
movups %xmm1,0x10(%rdi,%rcx,4)
movups 0x20(%rbx,%rcx,4),%xmm0
movups 0x30(%rbx,%rcx,4),%xmm1
movups %xmm0,0x20(%rdi,%rcx,4)
movups %xmm1,0x30(%rdi,%rcx,4)
movups 0x40(%rbx,%rcx,4),%xmm0
movups 0x50(%rbx,%rcx,4),%xmm1
movups %xmm0,0x40(%rdi,%rcx,4)
movups %xmm1,0x50(%rdi,%rcx,4)
movdqu 0x60(%rbx,%rcx,4),%xmm0
movdqu 0x70(%rbx,%rcx,4),%xmm1
movdqu %xmm0,0x60(%rdi,%rcx,4)
movdqu %xmm1,0x70(%rdi,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rbp
jne    14d0 <Pre4MV+0x340>
cmpq   $0x0,0x30(%rsp)
je     1570 <Pre4MV+0x3e0>
lea    (%rdi,%rcx,4),%rbp
add    $0x10,%rbp
lea    (%rbx,%rcx,4),%rcx
add    $0x10,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movdqu -0x10(%rcx,%rax,1),%xmm0
movdqu (%rcx,%rax,1),%xmm1
movdqu %xmm0,-0x10(%rbp,%rax,1)
movdqu %xmm1,0x0(%rbp,%rax,1)
add    $0x20,%rax
cmp    %rax,%rsi
jne    1550 <Pre4MV+0x3c0>
mov    0x40(%rsp),%rax
mov    %rax,%r11
cmp    %r15,%rax
je     13f0 <Pre4MV+0x260>
jmp    144c <Pre4MV+0x2bc>
mov    %ebx,%edi
mov    %ebp,%esi
mov    %r12,%rdx
mov    %r13,%rcx
mov    %r14,%r8
xor    %eax,%eax
call   1090 <NonVertex@plt>
mov    0x10(%rsp),%rdi
movl   $0x0,(%rdi)
mov    0x8(%rsp),%rbx
movslq %ebx,%rbp
mov    $0x4,%esi
mov    %rbp,%rdi
call   1070 <calloc@plt>
mov    %rax,0x78(%rsp)
lea    0x1(%rbx),%eax
movslq %eax,%rbx
mov    $0x4,%esi
mov    %rbx,%rdi
call   1070 <calloc@plt>
mov    %rax,%r14
mov    $0x4,%esi
mov    %rbx,%rdi
call   1070 <calloc@plt>
mov    %rax,0x88(%rsp)
mov    %rbp,0x48(%rsp)
movslq (%r12,%rbp,4),%rbx
mov    $0x8,%esi
mov    %rbx,%rdi
call   1070 <calloc@plt>
mov    %rax,%r12
mov    %rbx,%rax
mov    %rbx,0x40(%rsp)
test   %rbx,%rbx
jle    163c <Pre4MV+0x4ac>
mov    0x40(%rsp),%ebx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    $0x4,%esi
mov    0x48(%rsp),%rdi
call   1070 <calloc@plt>
mov    %rax,(%r12,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1620 <Pre4MV+0x490>
mov    %r12,0x18(%rsp)
mov    $0x4,%esi
mov    0x40(%rsp),%rdi
call   1070 <calloc@plt>
mov    %rax,0x40(%rsp)
mov    0x8(%rsp),%rdi
test   %edi,%edi
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%r11
mov    0x78(%rsp),%r12
jle    201d <Pre4MV+0xe8d>
mov    %r15d,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
mov    $0x1,%r10d
xor    %r9d,%r9d
jmp    16b2 <Pre4MV+0x522>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq (%r12,%rcx,4),%rdx
mov    %edx,%esi
cmp    %rsi,%rcx
cmovne %r10d,%r9d
movl   $0x1,(%r14,%rdx,4)
add    $0x1,%rcx
cmp    %r15,%rcx
je     1735 <Pre4MV+0x5a5>
mov    $0xf4240,%esi
xor    %ebx,%ebx
cmp    $0x1,%edi
jne    16e5 <Pre4MV+0x555>
test   $0x1,%r15b
je     1690 <Pre4MV+0x500>
cmpl   $0x0,(%r14,%rbx,4)
jne    1690 <Pre4MV+0x500>
mov    0x4(%r8,%rbx,4),%edx
sub    (%r8,%rbx,4),%edx
cmp    %esi,%edx
jge    1690 <Pre4MV+0x500>
mov    %ebx,(%r12,%rcx,4)
jmp    1690 <Pre4MV+0x500>
xchg   %ax,%ax
cmp    %rbx,%rax
je     16be <Pre4MV+0x52e>
mov    %rbx,%rbp
cmpl   $0x0,(%r14,%rbx,4)
jne    1710 <Pre4MV+0x580>
mov    0x4(%r8,%rbp,4),%edx
sub    (%r8,%rbp,4),%edx
cmp    %esi,%edx
jge    1710 <Pre4MV+0x580>
mov    %ebp,(%r12,%rcx,4)
mov    %edx,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x2(%rbp),%rbx
cmpl   $0x0,0x4(%r14,%rbp,4)
jne    16e0 <Pre4MV+0x550>
mov    0x8(%r8,%rbp,4),%edx
sub    0x4(%r8,%rbp,4),%edx
cmp    %esi,%edx
jge    16e0 <Pre4MV+0x550>
add    $0x1,%ebp
mov    %ebp,(%r12,%rcx,4)
mov    %edx,%esi
jmp    16e0 <Pre4MV+0x550>
cmp    $0x1,%r9d
jne    1fd2 <Pre4MV+0xe42>
movl   $0x0,(%r14)
test   %edi,%edi
jle    1f80 <Pre4MV+0xdf0>
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
mov    %rax,0x98(%rsp)
mov    %r15d,%eax
and    $0xfffffff8,%eax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %r15d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x30(%rsp)
mov    %eax,%r8d
and    $0x3,%r8d
mov    %rax,0x80(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x58(%rsp)
mov    %r15d,%r11d
and    $0x3,%r11d
mov    %r8,0x60(%rsp)
shl    $0x5,%r8
mov    $0xffffffff,%r12d
xor    %edx,%edx
mov    0x8(%rsp),%r9
jmp    17df <Pre4MV+0x64f>
nopl   0x0(%rax)
mov    0x90(%rsp),%rdx
lea    0x1(%r12),%r10d
mov    %r10d,0x4(%r14,%rdx,4)
add    $0x1,%rdx
cmp    %r15,%rdx
je     1995 <Pre4MV+0x805>
mov    0x78(%rsp),%rax
movslq (%rax,%rdx,4),%r10
mov    0x20(%rsp),%rcx
movslq (%rcx,%r10,4),%rax
cmp    0x4(%rcx,%r10,4),%eax
jge    17c8 <Pre4MV+0x638>
mov    %rdx,0x90(%rsp)
movslq %r12d,%r12
jmp    1827 <Pre4MV+0x697>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r12
mov    0x20(%rsp),%rcx
movslq 0x4(%rcx,%r10,4),%rcx
add    $0x1,%rax
cmp    %rcx,%rax
jge    17c0 <Pre4MV+0x630>
mov    0x0(%r13,%rax,8),%rbp
mov    0x18(%rsp),%rcx
mov    0x8(%rcx,%r12,8),%rbx
cmp    $0x8,%r9d
jb     1855 <Pre4MV+0x6c5>
lea    0x0(,%r15,4),%rcx
add    %rbp,%rcx
cmp    %rcx,%rbx
jae    18c0 <Pre4MV+0x730>
lea    (%rbx,%r15,4),%rcx
cmp    %rcx,%rbp
jae    18c0 <Pre4MV+0x730>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %r15,%rcx
test   %r11,%r11
je     1881 <Pre4MV+0x6f1>
mov    %r11,%rdi
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rdx,4),%esi
mov    %esi,(%rbx,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1870 <Pre4MV+0x6e0>
cmp    $0x3,%rcx
jb     1810 <Pre4MV+0x680>
nopw   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rdx,4),%ecx
mov    %ecx,(%rbx,%rdx,4)
mov    0x4(%rbp,%rdx,4),%ecx
mov    %ecx,0x4(%rbx,%rdx,4)
mov    0x8(%rbp,%rdx,4),%ecx
mov    %ecx,0x8(%rbx,%rdx,4)
mov    0xc(%rbp,%rdx,4),%ecx
mov    %ecx,0xc(%rbx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r15
jne    1890 <Pre4MV+0x700>
jmp    1810 <Pre4MV+0x680>
nopl   (%rax)
cmpq   $0x18,0x38(%rsp)
jae    18cc <Pre4MV+0x73c>
xor    %edx,%edx
jmp    193d <Pre4MV+0x7ad>
mov    0x58(%rsp),%r9
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%rbp,%rdx,4),%xmm0
movups 0x10(%rbp,%rdx,4),%xmm1
movups %xmm0,(%rbx,%rdx,4)
movups %xmm1,0x10(%rbx,%rdx,4)
movups 0x20(%rbp,%rdx,4),%xmm0
movups 0x30(%rbp,%rdx,4),%xmm1
movups %xmm0,0x20(%rbx,%rdx,4)
movups %xmm1,0x30(%rbx,%rdx,4)
movups 0x40(%rbp,%rdx,4),%xmm0
movups 0x50(%rbp,%rdx,4),%xmm1
movups %xmm0,0x40(%rbx,%rdx,4)
movups %xmm1,0x50(%rbx,%rdx,4)
movdqu 0x60(%rbp,%rdx,4),%xmm0
movdqu 0x70(%rbp,%rdx,4),%xmm1
movdqu %xmm0,0x60(%rbx,%rdx,4)
movdqu %xmm1,0x70(%rbx,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%r9
jne    18e0 <Pre4MV+0x750>
cmpq   $0x0,0x60(%rsp)
mov    0x8(%rsp),%r9
je     197f <Pre4MV+0x7ef>
lea    (%rbx,%rdx,4),%rcx
add    $0x10,%rcx
lea    0x10(,%rdx,4),%rdx
add    %rbp,%rdx
xor    %edi,%edi
nop
movdqu -0x10(%rdx,%rdi,1),%xmm0
movdqu (%rdx,%rdi,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rdi,1)
movdqu %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r8
jne    1960 <Pre4MV+0x7d0>
mov    0x30(%rsp),%rcx
mov    %rcx,%rdx
cmp    %r15,%rcx
je     1810 <Pre4MV+0x680>
jmp    1857 <Pre4MV+0x6c7>
test   %r12d,%r12d
js     1b50 <Pre4MV+0x9c0>
mov    %r15d,%r11d
and    $0xfffffff8,%r11d
mov    0x80(%rsp),%rax
mov    %eax,%r9d
and    $0x3,%r9d
mov    %rax,%rcx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0x30(%rsp)
mov    %r15d,%r8d
and    $0x3,%r8d
mov    %r9,%r12
shl    $0x5,%r12
xor    %edx,%edx
jmp    19ed <Pre4MV+0x85d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r10,%rdx
je     1b50 <Pre4MV+0x9c0>
cmpl   $0x0,0x8(%rsp)
jle    19e0 <Pre4MV+0x850>
mov    0x18(%rsp),%rax
mov    (%rax,%rdx,8),%rbp
mov    0x0(%r13,%rdx,8),%rbx
cmpl   $0x8,0x8(%rsp)
jb     1a22 <Pre4MV+0x892>
lea    0x0(,%r15,4),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1a8d <Pre4MV+0x8fd>
lea    (%rbx,%r15,4),%rax
cmp    %rax,%rbp
jae    1a8d <Pre4MV+0x8fd>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r15,%rcx
test   %r8,%r8
je     1a51 <Pre4MV+0x8c1>
mov    %r8,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%rbp,%rax,4),%edi
mov    %edi,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1a40 <Pre4MV+0x8b0>
cmp    $0x3,%rcx
jb     19e0 <Pre4MV+0x850>
nopw   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rax,4),%ecx
mov    %ecx,(%rbx,%rax,4)
mov    0x4(%rbp,%rax,4),%ecx
mov    %ecx,0x4(%rbx,%rax,4)
mov    0x8(%rbp,%rax,4),%ecx
mov    %ecx,0x8(%rbx,%rax,4)
mov    0xc(%rbp,%rax,4),%ecx
mov    %ecx,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r15
jne    1a60 <Pre4MV+0x8d0>
jmp    19e0 <Pre4MV+0x850>
cmpq   $0x18,0x38(%rsp)
jae    1a99 <Pre4MV+0x909>
xor    %eax,%eax
jmp    1afd <Pre4MV+0x96d>
mov    0x30(%rsp),%rcx
xor    %eax,%eax
movups 0x0(%rbp,%rax,4),%xmm0
movups 0x10(%rbp,%rax,4),%xmm1
movups %xmm0,(%rbx,%rax,4)
movups %xmm1,0x10(%rbx,%rax,4)
movups 0x20(%rbp,%rax,4),%xmm0
movups 0x30(%rbp,%rax,4),%xmm1
movups %xmm0,0x20(%rbx,%rax,4)
movups %xmm1,0x30(%rbx,%rax,4)
movups 0x40(%rbp,%rax,4),%xmm0
movups 0x50(%rbp,%rax,4),%xmm1
movups %xmm0,0x40(%rbx,%rax,4)
movups %xmm1,0x50(%rbx,%rax,4)
movdqu 0x60(%rbp,%rax,4),%xmm0
movdqu 0x70(%rbp,%rax,4),%xmm1
movdqu %xmm0,0x60(%rbx,%rax,4)
movdqu %xmm1,0x70(%rbx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    1aa0 <Pre4MV+0x910>
test   %r9,%r9
je     1b3f <Pre4MV+0x9af>
lea    (%rbx,%rax,4),%rcx
add    $0x10,%rcx
lea    0x10(,%rax,4),%rax
add    %rbp,%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rax,%rsi,1),%xmm0
movdqu (%rax,%rsi,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rsi,1)
movdqu %xmm1,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r12
jne    1b20 <Pre4MV+0x990>
mov    %r11,%rax
cmp    %r15,%r11
je     19e0 <Pre4MV+0x850>
jmp    1a24 <Pre4MV+0x894>
cmpl   $0x0,0x8(%rsp)
jle    1f80 <Pre4MV+0xdf0>
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x60(%rsp)
mov    0x80(%rsp),%rax
mov    %eax,%r12d
and    $0x3,%r12d
mov    %rax,%rcx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,0x90(%rsp)
mov    %r15d,%r10d
and    $0x3,%r10d
mov    %r12,0x58(%rsp)
shl    $0x5,%r12
mov    $0xffffffff,%r8d
xor    %ecx,%ecx
mov    0x10(%rsp),%r11
jmp    1bd6 <Pre4MV+0xa46>
nopl   0x0(%rax)
mov    0xa0(%rsp),%rcx
lea    0x1(%r8),%r9d
mov    0x88(%rsp),%rax
mov    %r9d,0x4(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %r15,%rcx
je     1daa <Pre4MV+0xc1a>
mov    0x78(%rsp),%rax
movslq (%rax,%rcx,4),%r9
movslq (%r11,%r9,4),%rsi
cmp    0x4(%r11,%r9,4),%esi
jge    1bb8 <Pre4MV+0xa28>
mov    %rcx,0xa0(%rsp)
mov    (%r14,%rcx,4),%eax
mov    %eax,0x30(%rsp)
movslq %r8d,%r8
jmp    1c2c <Pre4MV+0xa9c>
nop
movslq 0x4(%r11,%r9,4),%rax
mov    0x28(%rsp),%rcx
mov    (%rcx,%rsi,4),%ecx
mov    0x20(%rsp),%rdx
sub    (%rdx,%r9,4),%ecx
add    0x30(%rsp),%ecx
mov    0x40(%rsp),%rdx
mov    %ecx,(%rdx,%r8,4)
add    $0x1,%rsi
cmp    %rax,%rsi
jge    1bb0 <Pre4MV+0xa20>
mov    0x18(%rsp),%rax
mov    0x8(%rax,%r8,8),%rbp
add    $0x1,%r8
mov    0x68(%rsp),%rax
mov    (%rax,%rsi,8),%rbx
cmpl   $0x8,0x8(%rsp)
jb     1c63 <Pre4MV+0xad3>
lea    (%rbx,%r15,4),%rax
cmp    %rax,%rbp
jae    1cd0 <Pre4MV+0xb40>
lea    0x0(,%r15,4),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1cd0 <Pre4MV+0xb40>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r15,%rax
test   %r10,%r10
je     1c91 <Pre4MV+0xb01>
mov    %r10,%rdx
cs nopw 0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%edi
mov    %edi,0x0(%rbp,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1c80 <Pre4MV+0xaf0>
cmp    $0x3,%rax
jb     1c00 <Pre4MV+0xa70>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%eax
mov    %eax,0x0(%rbp,%rcx,4)
mov    0x4(%rbx,%rcx,4),%eax
mov    %eax,0x4(%rbp,%rcx,4)
mov    0x8(%rbx,%rcx,4),%eax
mov    %eax,0x8(%rbp,%rcx,4)
mov    0xc(%rbx,%rcx,4),%eax
mov    %eax,0xc(%rbp,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    1ca0 <Pre4MV+0xb10>
jmp    1c00 <Pre4MV+0xa70>
nopl   (%rax)
cmpq   $0x18,0x38(%rsp)
jae    1cdc <Pre4MV+0xb4c>
xor    %ecx,%ecx
jmp    1d4d <Pre4MV+0xbbd>
mov    0x90(%rsp),%r11
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups %xmm0,0x0(%rbp,%rcx,4)
movups %xmm1,0x10(%rbp,%rcx,4)
movups 0x20(%rbx,%rcx,4),%xmm0
movups 0x30(%rbx,%rcx,4),%xmm1
movups %xmm0,0x20(%rbp,%rcx,4)
movups %xmm1,0x30(%rbp,%rcx,4)
movups 0x40(%rbx,%rcx,4),%xmm0
movups 0x50(%rbx,%rcx,4),%xmm1
movups %xmm0,0x40(%rbp,%rcx,4)
movups %xmm1,0x50(%rbp,%rcx,4)
movdqu 0x60(%rbx,%rcx,4),%xmm0
movdqu 0x70(%rbx,%rcx,4),%xmm1
movdqu %xmm0,0x60(%rbp,%rcx,4)
movdqu %xmm1,0x70(%rbp,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%r11
jne    1cf0 <Pre4MV+0xb60>
cmpq   $0x0,0x58(%rsp)
je     1d8f <Pre4MV+0xbff>
lea    0x10(,%rcx,4),%rax
add    %rbp,%rax
lea    (%rbx,%rcx,4),%rcx
add    $0x10,%rcx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rcx,%rdx,1),%xmm0
movdqu (%rcx,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rax,%rdx,1)
movdqu %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r12
jne    1d70 <Pre4MV+0xbe0>
mov    0x60(%rsp),%rax
mov    %rax,%rcx
cmp    %r15,%rax
mov    0x10(%rsp),%r11
je     1c00 <Pre4MV+0xa70>
jmp    1c65 <Pre4MV+0xad5>
test   %r8d,%r8d
js     1f80 <Pre4MV+0xdf0>
mov    %r15d,%r10d
and    $0xfffffff8,%r10d
mov    0x80(%rsp),%rax
mov    %eax,%r8d
and    $0x3,%r8d
and    %rax,0x98(%rsp)
mov    %r15d,%r11d
and    $0x3,%r11d
mov    %r8,%r12
shl    $0x5,%r12
xor    %edi,%edi
jmp    1e0d <Pre4MV+0xc7d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x40(%rsp),%rax
mov    (%rax,%rdi,4),%eax
mov    0x28(%rsp),%rcx
mov    %eax,(%rcx,%rdi,4)
add    $0x1,%rdi
cmp    %r9,%rdi
je     1f80 <Pre4MV+0xdf0>
cmpl   $0x0,0x8(%rsp)
jle    1df0 <Pre4MV+0xc60>
mov    0x18(%rsp),%rax
mov    (%rax,%rdi,8),%rbp
mov    0x68(%rsp),%rax
mov    (%rax,%rdi,8),%rbx
cmpl   $0x8,0x8(%rsp)
jb     1e46 <Pre4MV+0xcb6>
lea    0x0(,%r15,4),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1ead <Pre4MV+0xd1d>
lea    (%rbx,%r15,4),%rax
cmp    %rax,%rbp
jae    1ead <Pre4MV+0xd1d>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r15,%rcx
test   %r11,%r11
je     1e71 <Pre4MV+0xce1>
mov    %r11,%rdx
nopl   0x0(%rax)
mov    0x0(%rbp,%rax,4),%esi
mov    %esi,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1e60 <Pre4MV+0xcd0>
cmp    $0x3,%rcx
jb     1df0 <Pre4MV+0xc60>
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rax,4),%ecx
mov    %ecx,(%rbx,%rax,4)
mov    0x4(%rbp,%rax,4),%ecx
mov    %ecx,0x4(%rbx,%rax,4)
mov    0x8(%rbp,%rax,4),%ecx
mov    %ecx,0x8(%rbx,%rax,4)
mov    0xc(%rbp,%rax,4),%ecx
mov    %ecx,0xc(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r15
jne    1e80 <Pre4MV+0xcf0>
jmp    1df0 <Pre4MV+0xc60>
cmpq   $0x18,0x38(%rsp)
jae    1eb9 <Pre4MV+0xd29>
xor    %eax,%eax
jmp    1f2d <Pre4MV+0xd9d>
mov    0x98(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%rbp,%rax,4),%xmm0
movups 0x10(%rbp,%rax,4),%xmm1
movups %xmm0,(%rbx,%rax,4)
movups %xmm1,0x10(%rbx,%rax,4)
movups 0x20(%rbp,%rax,4),%xmm0
movups 0x30(%rbp,%rax,4),%xmm1
movups %xmm0,0x20(%rbx,%rax,4)
movups %xmm1,0x30(%rbx,%rax,4)
movups 0x40(%rbp,%rax,4),%xmm0
movups 0x50(%rbp,%rax,4),%xmm1
movups %xmm0,0x40(%rbx,%rax,4)
movups %xmm1,0x50(%rbx,%rax,4)
movdqu 0x60(%rbp,%rax,4),%xmm0
movdqu 0x70(%rbp,%rax,4),%xmm1
movdqu %xmm0,0x60(%rbx,%rax,4)
movdqu %xmm1,0x70(%rbx,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    1ed0 <Pre4MV+0xd40>
test   %r8,%r8
je     1f6f <Pre4MV+0xddf>
lea    (%rbx,%rax,4),%rcx
add    $0x10,%rcx
lea    0x10(,%rax,4),%rax
add    %rbp,%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rax,%rdx,1),%xmm0
movdqu (%rax,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rdx,1)
movdqu %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r12
jne    1f50 <Pre4MV+0xdc0>
mov    %r10,%rax
cmp    %r15,%r10
je     1df0 <Pre4MV+0xc60>
jmp    1e48 <Pre4MV+0xcb8>
mov    0x8(%rsp),%rdi
test   %edi,%edi
mov    0x20(%rsp),%rbx
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%r11
js     1fd2 <Pre4MV+0xe42>
lea    0x4(,%r15,4),%rbp
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
call   1080 <memcpy@plt>
mov    0x10(%rsp),%rdi
mov    0x88(%rsp),%rsi
mov    %rbp,%rdx
call   1080 <memcpy@plt>
mov    0x28(%rsp),%r11
mov    0x10(%rsp),%r8
mov    0x8(%rsp),%rdi
test   %edi,%edi
jle    201d <Pre4MV+0xe8d>
lea    0x0(,%r15,4),%rdx
mov    0x70(%rsp),%rbx
mov    %rbx,%rdi
mov    $0xff,%esi
call   1050 <memset@plt>
mov    0x8(%rsp),%rdi
lea    -0x1(%rdi),%ecx
cmp    $0x1,%edi
jne    204a <Pre4MV+0xeba>
mov    %rbx,%r9
mov    (%rbx,%rcx,4),%ebx
shr    $0x1f,%ebx
cmp    %edi,%ebx
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%r11
jb     219b <Pre4MV+0x100b>
jmp    21d4 <Pre4MV+0x1044>
lea    -0x1(%rdi),%eax
cltq
mov    0x70(%rsp),%r9
mov    (%r9,%rax,4),%ebx
shr    $0x1f,%ebx
cmp    %edi,%ebx
jl     219b <Pre4MV+0x100b>
mov    0x50(%rsp),%rcx
mov    0x48(%rsp),%r12
mov    0x18(%rsp),%r13
jmp    2321 <Pre4MV+0x1191>
xor    %r12d,%r12d
mov    $0x1,%ebp
xor    %edx,%edx
mov    %rbx,%r9
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%r11
mov    %rcx,0x58(%rsp)
jmp    2087 <Pre4MV+0xef7>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    %r12,%rsi
add    $0x1,%rbp
mov    %rsi,%r12
cmp    %rcx,%rsi
je     218b <Pre4MV+0xffb>
cmpl   $0x0,(%r9,%r12,4)
jns    2070 <Pre4MV+0xee0>
add    $0x1,%edx
lea    0x1(%r12),%rsi
cmp    0x48(%rsp),%rsi
jge    2077 <Pre4MV+0xee7>
mov    %rsi,0x60(%rsp)
mov    %edx,0x30(%rsp)
mov    %rbp,0x38(%rsp)
jmp    20c9 <Pre4MV+0xf39>
mov    %r12d,(%r9,%rdx,4)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r15,%rbp
je     2169 <Pre4MV+0xfd9>
mov    %rbp,%rdx
add    $0x1,%rbp
cmpl   $0x0,(%r9,%rdx,4)
jns    20c0 <Pre4MV+0xf30>
mov    0x10(%rsp),%rcx
mov    (%rcx,%rbp,4),%ebx
mov    (%rcx,%rdx,4),%esi
sub    %esi,%ebx
movslq 0x4(%rcx,%r12,4),%rax
movslq (%rcx,%r12,4),%r11
mov    %eax,%ecx
sub    %r11d,%ecx
cmp    %ecx,%ebx
jne    20c0 <Pre4MV+0xf30>
cmp    %r11d,%eax
jle    20ad <Pre4MV+0xf1d>
sub    %r11d,%esi
mov    $0x1,%bl
mov    0x68(%rsp),%rdi
mov    (%rdi,%r11,8),%r8
lea    (%rsi,%r11,1),%ecx
movslq %ecx,%rcx
mov    (%rdi,%rcx,8),%r9
xor    %r10d,%r10d
nopw   0x0(%rax,%rax,1)
mov    (%r8,%r10,4),%ecx
cmp    (%r9,%r10,4),%ecx
jne    2151 <Pre4MV+0xfc1>
add    $0x1,%r10
cmp    %r10,%r15
jne    2120 <Pre4MV+0xf90>
add    $0x1,%r11
cmp    %rax,%r11
setl   %bl
cmp    %r11d,%eax
mov    0x8(%rsp),%rdi
mov    0x70(%rsp),%r9
jne    2100 <Pre4MV+0xf70>
jmp    20ad <Pre4MV+0xf1d>
test   $0x1,%bl
mov    0x8(%rsp),%rdi
mov    0x70(%rsp),%r9
jne    20c0 <Pre4MV+0xf30>
jmp    20ad <Pre4MV+0xf1d>
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%r11
mov    0x58(%rsp),%rcx
mov    0x30(%rsp),%edx
mov    0x38(%rsp),%rbp
mov    0x60(%rsp),%rsi
jmp    2077 <Pre4MV+0xee7>
movslq %ecx,%rax
mov    (%r9,%rax,4),%ebx
shr    $0x1f,%ebx
add    %edx,%ebx
cmp    %edi,%ebx
jge    21cc <Pre4MV+0x103c>
mov    %r11,(%rsp)
mov    %r13,%rsi
mov    0x20(%rsp),%rbp
mov    %rbp,%rdx
mov    0x68(%rsp),%rcx
xor    %eax,%eax
call   10b0 <ReArrangeSpt@plt>
mov    %ebx,%edi
mov    0x50(%rsp),%rcx
mov    0x48(%rsp),%r12
mov    0x18(%rsp),%r13
jmp    2326 <Pre4MV+0x1196>
test   %edi,%edi
jle    2036 <Pre4MV+0xea6>
cmp    $0x8,%edi
jae    21ef <Pre4MV+0x105f>
xor    %eax,%eax
mov    0x50(%rsp),%rcx
mov    0x48(%rsp),%r12
mov    0x18(%rsp),%r13
jmp    2310 <Pre4MV+0x1180>
mov    %r15d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x38,%rsi
mov    0x48(%rsp),%r12
mov    0x18(%rsp),%r13
jae    2220 <Pre4MV+0x1090>
xor    %esi,%esi
jmp    22d5 <Pre4MV+0x1145>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
add    $0xfffffffffffffffc,%rsi
and    %rsi,%rdx
xor    %esi,%esi
movdqa 0xdc5(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,(%r9,%rsi,4)
movdqu %xmm0,0x10(%r9,%rsi,4)
movdqu %xmm0,0x20(%r9,%rsi,4)
movdqu %xmm0,0x30(%r9,%rsi,4)
movdqu %xmm0,0x40(%r9,%rsi,4)
movdqu %xmm0,0x50(%r9,%rsi,4)
movdqu %xmm0,0x60(%r9,%rsi,4)
movdqu %xmm0,0x70(%r9,%rsi,4)
movdqu %xmm0,0x80(%r9,%rsi,4)
movdqu %xmm0,0x90(%r9,%rsi,4)
movdqu %xmm0,0xa0(%r9,%rsi,4)
movdqu %xmm0,0xb0(%r9,%rsi,4)
movdqu %xmm0,0xc0(%r9,%rsi,4)
movdqu %xmm0,0xd0(%r9,%rsi,4)
movdqu %xmm0,0xe0(%r9,%rsi,4)
movdqu %xmm0,0xf0(%r9,%rsi,4)
add    $0x40,%rsi
add    $0xfffffffffffffff8,%rdx
jne    2240 <Pre4MV+0x10b0>
test   %rcx,%rcx
je     2304 <Pre4MV+0x1174>
lea    (%r9,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movdqa 0xd10(%rip),%xmm0
movdqu %xmm0,-0x10(%rdx,%rsi,1)
movdqu %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    22f0 <Pre4MV+0x1160>
cmp    %r15,%rax
mov    0x50(%rsp),%rcx
je     2321 <Pre4MV+0x1191>
xchg   %ax,%ax
movl   $0x1,(%r9,%rax,4)
add    $0x1,%rax
cmp    %rax,%r15
jne    2310 <Pre4MV+0x1180>
mov    0x20(%rsp),%rbp
mov    %edi,(%rcx)
mov    0x78(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
cmpl   $0x0,0x0(%rbp,%r12,4)
jle    2378 <Pre4MV+0x11e8>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
movslq 0x0(%rbp,%r12,4),%rax
cmp    %rax,%rbx
jl     2360 <Pre4MV+0x11d0>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
lea    0x1(%rdx),%esi
add    $0x2,%edx
lea    0xc68(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
xor    %edi,%edi
call   10a0 <exit@plt>

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

LLVM IR (-O2):
@.str = [51 x i8] c"%d-th and %d-th points in %d-th support are same!\0A\00"
define void @Pre4MV(i32 %0, i32 %1, i32* nocapture writeonly %2, i32* %3, i32** %4, i32* %5, i32** %6, i32* %7, i32* %8) {
%10 = bitcast i32* %5 to i8*
%11 = bitcast i32* %7 to i8*
%12 = bitcast i32* %3 to i8*
%13 = tail call i32 (i32, i32, i32**, i32*, ...) bitcast (i32 (...)* @SortSpt to i32 (i32, i32, i32**, i32*, ...)*)(i32 %0, i32 %1, i32** %4, i32* %5)
%14 = icmp sgt i32 %0, 0
br i1 %14, label %17, label %15
15: ; preds = %9
%16 = tail call i32 (i32, i32, i32*, i32**, i32*, ...) bitcast (i32 (...)* @NonVertex to i32 (i32, i32, i32*, i32**, i32*, ...)*)(i32 %0, i32 %1, i32* %5, i32** %4, i32* %8)
br label %264
17: ; preds = %9
%18 = zext i32 %0 to i64
%19 = load i32, i32* %5
%20 = icmp ult i32 %0, 8
%21 = and i64 %18, 4294967288
%22 = icmp eq i64 %21, %18
br label %25
23: ; preds = %94, %25
%24 = icmp eq i64 %28, %18
br i1 %24, label %97, label %25
25: ; preds = %17, %23
%26 = phi i32 [ %19, %17 ], [ %30, %23 ]
%27 = phi i64 [ 0, %17 ], [ %28, %23 ]
%28 = add nuw nsw i64 %27, 1
%29 = getelementptr inbounds i32, i32* %5, i64 %28
%30 = load i32, i32* %29
%31 = add i32 %30, -1
%32 = icmp slt i32 %26, %31
br i1 %32, label %33, label %23
33: ; preds = %25
%34 = sext i32 %26 to i64
%35 = sext i32 %31 to i64
br label %36
36: ; preds = %94, %33
%37 = phi i64 [ %34, %33 ], [ %95, %94 ]
%38 = getelementptr inbounds i32*, i32** %4, i64 %37
%39 = load i32*, i32** %38
%40 = add nsw i64 %37, 1
%41 = getelementptr inbounds i32*, i32** %4, i64 %40
%42 = load i32*, i32** %41
br i1 %20, label %70, label %43
43: ; preds = %36, %43
%44 = phi i64 [ %65, %43 ], [ 0, %36 ]
%45 = phi <4 x i32> [ %63, %43 ], [ zeroinitializer, %36 ]
%46 = phi <4 x i32> [ %64, %43 ], [ zeroinitializer, %36 ]
%47 = getelementptr inbounds i32, i32* %39, i64 %44
%48 = bitcast i32* %47 to <4 x i32>*
%49 = load <4 x i32>, <4 x i32>* %48
%50 = getelementptr inbounds i32, i32* %47, i64 4
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = getelementptr inbounds i32, i32* %42, i64 %44
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = getelementptr inbounds i32, i32* %53, i64 4
%57 = bitcast i32* %56 to <4 x i32>*
%58 = load <4 x i32>, <4 x i32>* %57
%59 = sub nsw <4 x i32> %49, %55
%60 = sub nsw <4 x i32> %52, %58
%61 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %59, i1 true)
%62 = call <4 x i32> @llvm.abs.v4i32(<4 x i32> %60, i1 true)
%63 = add <4 x i32> %61, %45
%64 = add <4 x i32> %62, %46
%65 = add nuw i64 %44, 8
%66 = icmp eq i64 %65, %21
br i1 %66, label %67, label %43
67: ; preds = %43
%68 = add <4 x i32> %64, %63
%69 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %68)
br i1 %22, label %85, label %70
70: ; preds = %36, %67
%71 = phi i64 [ 0, %36 ], [ %21, %67 ]
%72 = phi i32 [ 0, %36 ], [ %69, %67 ]
br label %73
73: ; preds = %70, %73
%74 = phi i64 [ %83, %73 ], [ %71, %70 ]
%75 = phi i32 [ %82, %73 ], [ %72, %70 ]
%76 = getelementptr inbounds i32, i32* %39, i64 %74
%77 = load i32, i32* %76
%78 = getelementptr inbounds i32, i32* %42, i64 %74
%79 = load i32, i32* %78
%80 = sub nsw i32 %77, %79
%81 = tail call i32 @llvm.abs.i32(i32 %80, i1 true)
%82 = add nuw nsw i32 %81, %75
%83 = add nuw nsw i64 %74, 1
%84 = icmp eq i64 %83, %18
br i1 %84, label %85, label %73
85: ; preds = %73, %67
%86 = phi i32 [ %69, %67 ], [ %82, %73 ]
%87 = icmp eq i32 %86, 0
br i1 %87, label %88, label %94
88: ; preds = %85
%89 = trunc i64 %28 to i32
%90 = trunc i64 %37 to i32
%91 = add nsw i32 %90, 1
%92 = add nsw i32 %90, 2
%93 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str, i64 0, i64 0), i32 %91, i32 %92, i32 %89)
tail call void @exit(i32 0)
unreachable
94: ; preds = %85
%95 = add nsw i64 %37, 1
%96 = icmp eq i64 %95, %35
br i1 %96, label %23, label %36
97: ; preds = %23
%98 = tail call i32 (i32, i32, i32*, i32**, i32*, ...) bitcast (i32 (...)* @NonVertex to i32 (i32, i32, i32*, i32**, i32*, ...)*)(i32 %0, i32 %1, i32* %5, i32** %4, i32* %8)
br i1 %14, label %99, label %264
99: ; preds = %97
%100 = zext i32 %0 to i64
%101 = and i64 %100, 4294967288
%102 = add nsw i64 %101, -8
%103 = lshr exact i64 %102, 3
%104 = add nuw nsw i64 %103, 1
%105 = icmp ult i32 %0, 8
%106 = and i64 %18, 4294967288
%107 = and i64 %104, 3
%108 = icmp ult i64 %102, 24
%109 = and i64 %104, 4611686018427387900
%110 = icmp eq i64 %107, 0
%111 = icmp eq i64 %106, %18
%112 = and i64 %100, 3
%113 = icmp eq i64 %112, 0
br label %114
114: ; preds = %99, %259
%115 = phi i64 [ 0, %99 ], [ %119, %259 ]
%116 = phi i32 [ -1, %99 ], [ %260, %259 ]
%117 = getelementptr inbounds i32, i32* %5, i64 %115
%118 = load i32, i32* %117
%119 = add nuw nsw i64 %115, 1
%120 = getelementptr inbounds i32, i32* %5, i64 %119
%121 = load i32, i32* %120
%122 = icmp slt i32 %118, %121
br i1 %122, label %123, label %259
123: ; preds = %114
%124 = sext i32 %118 to i64
br label %125
125: ; preds = %123, %253
%126 = phi i32 [ %121, %123 ], [ %254, %253 ]
%127 = phi i64 [ %124, %123 ], [ %256, %253 ]
%128 = phi i32 [ %116, %123 ], [ %255, %253 ]
%129 = getelementptr inbounds i32, i32* %8, i64 %127
%130 = load i32, i32* %129
%131 = icmp eq i32 %130, 1
br i1 %131, label %132, label %253
132: ; preds = %125
%133 = add nsw i32 %128, 1
%134 = getelementptr inbounds i32*, i32** %4, i64 %127
%135 = load i32*, i32** %134
%136 = sext i32 %133 to i64
%137 = getelementptr inbounds i32*, i32** %6, i64 %136
%138 = load i32*, i32** %137
br i1 %105, label %214, label %139
139: ; preds = %132
%140 = getelementptr i32, i32* %138, i64 %18
%141 = getelementptr i32, i32* %135, i64 %18
%142 = icmp ult i32* %138, %141
%143 = icmp ult i32* %135, %140
%144 = and i1 %142, %143
br i1 %144, label %214, label %145
145: ; preds = %139
br i1 %108, label %195, label %146
146: ; preds = %145, %146
%147 = phi i64 [ %192, %146 ], [ 0, %145 ]
%148 = phi i64 [ %193, %146 ], [ 0, %145 ]
%149 = getelementptr inbounds i32, i32* %135, i64 %147
%150 = bitcast i32* %149 to <4 x i32>*
%151 = load <4 x i32>, <4 x i32>* %150
%152 = getelementptr inbounds i32, i32* %149, i64 4
%153 = bitcast i32* %152 to <4 x i32>*
%154 = load <4 x i32>, <4 x i32>* %153
%155 = getelementptr inbounds i32, i32* %138, i64 %147
%156 = bitcast i32* %155 to <4 x i32>*
store <4 x i32> %151, <4 x i32>* %156
%157 = getelementptr inbounds i32, i32* %155, i64 4
%158 = bitcast i32* %157 to <4 x i32>*
store <4 x i32> %154, <4 x i32>* %158
%159 = or i64 %147, 8
%160 = getelementptr inbounds i32, i32* %135, i64 %159
%161 = bitcast i32* %160 to <4 x i32>*
%162 = load <4 x i32>, <4 x i32>* %161
%163 = getelementptr inbounds i32, i32* %160, i64 4
%164 = bitcast i32* %163 to <4 x i32>*
%165 = load <4 x i32>, <4 x i32>* %164
%166 = getelementptr inbounds i32, i32* %138, i64 %159
%167 = bitcast i32* %166 to <4 x i32>*
store <4 x i32> %162, <4 x i32>* %167
%168 = getelementptr inbounds i32, i32* %166, i64 4
%169 = bitcast i32* %168 to <4 x i32>*
store <4 x i32> %165, <4 x i32>* %169
%170 = or i64 %147, 16
%171 = getelementptr inbounds i32, i32* %135, i64 %170
%172 = bitcast i32* %171 to <4 x i32>*
%173 = load <4 x i32>, <4 x i32>* %172
%174 = getelementptr inbounds i32, i32* %171, i64 4
%175 = bitcast i32* %174 to <4 x i32>*
%176 = load <4 x i32>, <4 x i32>* %175
%177 = getelementptr inbounds i32, i32* %138, i64 %170
%178 = bitcast i32* %177 to <4 x i32>*
store <4 x i32> %173, <4 x i32>* %178
%179 = getelementptr inbounds i32, i32* %177, i64 4
%180 = bitcast i32* %179 to <4 x i32>*
store <4 x i32> %176, <4 x i32>* %180
%181 = or i64 %147, 24
%182 = getelementptr inbounds i32, i32* %135, i64 %181
%183 = bitcast i32* %182 to <4 x i32>*
%184 = load <4 x i32>, <4 x i32>* %183
%185 = getelementptr inbounds i32, i32* %182, i64 4
%186 = bitcast i32* %185 to <4 x i32>*
%187 = load <4 x i32>, <4 x i32>* %186
%188 = getelementptr inbounds i32, i32* %138, i64 %181
%189 = bitcast i32* %188 to <4 x i32>*
store <4 x i32> %184, <4 x i32>* %189
%190 = getelementptr inbounds i32, i32* %188, i64 4
%191 = bitcast i32* %190 to <4 x i32>*
store <4 x i32> %187, <4 x i32>* %191
%192 = add nuw i64 %147, 32
%193 = add i64 %148, 4
%194 = icmp eq i64 %193, %109
br i1 %194, label %195, label %146
195: ; preds = %146, %145
%196 = phi i64 [ 0, %145 ], [ %192, %146 ]
br i1 %110, label %213, label %197
197: ; preds = %195, %197
%198 = phi i64 [ %210, %197 ], [ %196, %195 ]
%199 = phi i64 [ %211, %197 ], [ 0, %195 ]
%200 = getelementptr inbounds i32, i32* %135, i64 %198
%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* %138, i64 %198
%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 %198, 8
%211 = add i64 %199, 1
%212 = icmp eq i64 %211, %107
br i1 %212, label %213, label %197
213: ; preds = %197, %195
br i1 %111, label %249, label %214
214: ; preds = %139, %132, %213
%215 = phi i64 [ 0, %139 ], [ 0, %132 ], [ %106, %213 ]
%216 = xor i64 %215, -1
%217 = add nsw i64 %216, %100
br i1 %113, label %227, label %218
218: ; preds = %214, %218
%219 = phi i64 [ %224, %218 ], [ %215, %214 ]
%220 = phi i64 [ %225, %218 ], [ 0, %214 ]
%221 = getelementptr inbounds i32, i32* %135, i64 %219
%222 = load i32, i32* %221
%223 = getelementptr inbounds i32, i32* %138, i64 %219
store i32 %222, i32* %223
%224 = add nuw nsw i64 %219, 1
%225 = add i64 %220, 1
%226 = icmp eq i64 %225, %112
br i1 %226, label %227, label %218
227: ; preds = %218, %214
%228 = phi i64 [ %215, %214 ], [ %224, %218 ]
%229 = icmp ult i64 %217, 3
br i1 %229, label %249, label %230
230: ; preds = %227, %230
%231 = phi i64 [ %247, %230 ], [ %228, %227 ]
%232 = getelementptr inbounds i32, i32* %135, i64 %231
%233 = load i32, i32* %232
%234 = getelementptr inbounds i32, i32* %138, i64 %231
store i32 %233, i32* %234
%235 = add nuw nsw i64 %231, 1
%236 = getelementptr inbounds i32, i32* %135, i64 %235
%237 = load i32, i32* %236
%238 = getelementptr inbounds i32, i32* %138, i64 %235
store i32 %237, i32* %238
%239 = add nuw nsw i64 %231, 2
%240 = getelementptr inbounds i32, i32* %135, i64 %239
%241 = load i32, i32* %240
%242 = getelementptr inbounds i32, i32* %138, i64 %239
store i32 %241, i32* %242
%243 = add nuw nsw i64 %231, 3
%244 = getelementptr inbounds i32, i32* %135, i64 %243
%245 = load i32, i32* %244
%246 = getelementptr inbounds i32, i32* %138, i64 %243
store i32 %245, i32* %246
%247 = add nuw nsw i64 %231, 4
%248 = icmp eq i64 %247, %100
br i1 %248, label %249, label %230
249: ; preds = %227, %230, %213
%250 = getelementptr inbounds i32, i32* %8, i64 %136
%251 = trunc i64 %127 to i32
store i32 %251, i32* %250
%252 = load i32, i32* %120
br label %253
253: ; preds = %125, %249
%254 = phi i32 [ %252, %249 ], [ %126, %125 ]
%255 = phi i32 [ %133, %249 ], [ %128, %125 ]
%256 = add nsw i64 %127, 1
%257 = sext i32 %254 to i64
%258 = icmp slt i64 %256, %257
br i1 %258, label %125, label %259
259: ; preds = %253, %114
%260 = phi i32 [ %116, %114 ], [ %255, %253 ]
%261 = add nsw i32 %260, 1
%262 = getelementptr inbounds i32, i32* %7, i64 %119
store i32 %261, i32* %262
%263 = icmp eq i64 %119, %100
br i1 %263, label %264, label %114
264: ; preds = %259, %15, %97
store i32 0, i32* %7
%265 = sext i32 %0 to i64
%266 = tail call i8* @calloc(i64 %265, i64 4)
%267 = bitcast i8* %266 to i32*
%268 = add nsw i32 %0, 1
%269 = sext i32 %268 to i64
%270 = tail call i8* @calloc(i64 %269, i64 4)
%271 = bitcast i8* %270 to i32*
%272 = tail call i8* @calloc(i64 %269, i64 4)
%273 = bitcast i8* %272 to i32*
%274 = getelementptr inbounds i32, i32* %5, i64 %265
%275 = load i32, i32* %274
%276 = sext i32 %275 to i64
%277 = tail call i8* @calloc(i64 %276, i64 8)
%278 = bitcast i8* %277 to i32**
%279 = icmp sgt i32 %275, 0
br i1 %279, label %280, label %289
280: ; preds = %264
%281 = zext i32 %275 to i64
br label %282
282: ; preds = %280, %282
%283 = phi i64 [ 0, %280 ], [ %287, %282 ]
%284 = tail call i8* @calloc(i64 %265, i64 4)
%285 = getelementptr inbounds i32*, i32** %278, i64 %283
%286 = bitcast i32** %285 to i8**
store i8* %284, i8** %286
%287 = add nuw nsw i64 %283, 1
%288 = icmp eq i64 %287, %281
br i1 %288, label %289, label %282
289: ; preds = %282, %264
%290 = tail call i8* @calloc(i64 %276, i64 4)
%291 = bitcast i8* %290 to i32*
br i1 %14, label %292, label %1074
292: ; preds = %289
%293 = zext i32 %0 to i64
%294 = and i64 %293, 1
%295 = icmp eq i32 %0, 1
%296 = and i64 %293, 4294967294
%297 = icmp eq i64 %294, 0
br label %298
298: ; preds = %355, %292
%299 = phi i64 [ 0, %292 ], [ %363, %355 ]
%300 = phi i32 [ 0, %292 ], [ %360, %355 ]
%301 = getelementptr inbounds i32, i32* %267, i64 %299
br i1 %295, label %338, label %302
302: ; preds = %298, %334
%303 = phi i64 [ %324, %334 ], [ 0, %298 ]
%304 = phi i32 [ %335, %334 ], [ 1000000, %298 ]
%305 = phi i64 [ %336, %334 ], [ 0, %298 ]
%306 = getelementptr inbounds i32, i32* %271, i64 %303
%307 = load i32, i32* %306
%308 = icmp eq i32 %307, 0
%309 = or i64 %303, 1
br i1 %308, label %310, label %319
310: ; preds = %302
%311 = getelementptr inbounds i32, i32* %7, i64 %309
%312 = load i32, i32* %311
%313 = getelementptr inbounds i32, i32* %7, i64 %303
%314 = load i32, i32* %313
%315 = sub nsw i32 %312, %314
%316 = icmp slt i32 %315, %304
br i1 %316, label %317, label %319
317: ; preds = %310
%318 = trunc i64 %303 to i32
store i32 %318, i32* %301
br label %319
319: ; preds = %302, %310, %317
%320 = phi i32 [ %304, %310 ], [ %315, %317 ], [ %304, %302 ]
%321 = getelementptr inbounds i32, i32* %271, i64 %309
%322 = load i32, i32* %321
%323 = icmp eq i32 %322, 0
%324 = add nuw nsw i64 %303, 2
br i1 %323, label %325, label %334
325: ; preds = %319
%326 = getelementptr inbounds i32, i32* %7, i64 %324
%327 = load i32, i32* %326
%328 = getelementptr inbounds i32, i32* %7, i64 %309
%329 = load i32, i32* %328
%330 = sub nsw i32 %327, %329
%331 = icmp slt i32 %330, %320
br i1 %331, label %332, label %334
332: ; preds = %325
%333 = trunc i64 %309 to i32
store i32 %333, i32* %301
br label %334
334: ; preds = %332, %325, %319
%335 = phi i32 [ %320, %325 ], [ %330, %332 ], [ %320, %319 ]
%336 = add i64 %305, 2
%337 = icmp eq i64 %336, %296
br i1 %337, label %338, label %302
338: ; preds = %334, %298
%339 = phi i64 [ 0, %298 ], [ %324, %334 ]
%340 = phi i32 [ 1000000, %298 ], [ %335, %334 ]
br i1 %297, label %355, label %341
341: ; preds = %338
%342 = getelementptr inbounds i32, i32* %271, i64 %339
%343 = load i32, i32* %342
%344 = icmp eq i32 %343, 0
br i1 %344, label %345, label %355
345: ; preds = %341
%346 = add nuw nsw i64 %339, 1
%347 = getelementptr inbounds i32, i32* %7, i64 %346
%348 = load i32, i32* %347
%349 = getelementptr inbounds i32, i32* %7, i64 %339
%350 = load i32, i32* %349
%351 = sub nsw i32 %348, %350
%352 = icmp slt i32 %351, %340
br i1 %352, label %353, label %355
353: ; preds = %345
%354 = trunc i64 %339 to i32
store i32 %354, i32* %301
br label %355
355: ; preds = %341, %345, %353, %338
%356 = getelementptr inbounds i32, i32* %267, i64 %299
%357 = load i32, i32* %356
%358 = zext i32 %357 to i64
%359 = icmp eq i64 %299, %358
%360 = select i1 %359, i32 %300, i32 1
%361 = sext i32 %357 to i64
%362 = getelementptr inbounds i32, i32* %271, i64 %361
store i32 1, i32* %362
%363 = add nuw nsw i64 %299, 1
%364 = icmp eq i64 %363, %293
br i1 %364, label %365, label %298
365: ; preds = %355
%366 = icmp eq i32 %360, 1
br i1 %366, label %367, label %980
367: ; preds = %365
store i32 0, i32* %271
br i1 %14, label %368, label %946
368: ; preds = %367
%369 = zext i32 %0 to i64
%370 = and i64 %369, 4294967288
%371 = add nsw i64 %370, -8
%372 = lshr exact i64 %371, 3
%373 = add nuw nsw i64 %372, 1
%374 = icmp ult i32 %0, 8
%375 = and i64 %293, 4294967288
%376 = and i64 %373, 3
%377 = icmp ult i64 %371, 24
%378 = and i64 %373, 4611686018427387900
%379 = icmp eq i64 %376, 0
%380 = icmp eq i64 %375, %293
%381 = and i64 %369, 3
%382 = icmp eq i64 %381, 0
br label %398
383: ; preds = %539
%384 = icmp slt i32 %540, 0
br i1 %384, label %643, label %385
385: ; preds = %383
%386 = add nuw i32 %540, 1
%387 = zext i32 %386 to i64
%388 = zext i32 %0 to i64
%389 = icmp ult i32 %0, 8
%390 = and i64 %293, 4294967288
%391 = and i64 %373, 3
%392 = icmp ult i64 %371, 24
%393 = and i64 %373, 4611686018427387900
%394 = icmp eq i64 %391, 0
%395 = icmp eq i64 %390, %293
%396 = and i64 %369, 3
%397 = icmp eq i64 %396, 0
br label %545
398: ; preds = %368, %539
%399 = phi i64 [ 0, %368 ], [ %542, %539 ]
%400 = phi i32 [ -1, %368 ], [ %540, %539 ]
%401 = getelementptr inbounds i32, i32* %267, i64 %399
%402 = load i32, i32* %401
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds i32, i32* %5, i64 %403
%405 = load i32, i32* %404
%406 = add nsw i32 %402, 1
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds i32, i32* %5, i64 %407
%409 = load i32, i32* %408
%410 = icmp slt i32 %405, %409
br i1 %410, label %411, label %539
411: ; preds = %398
%412 = sext i32 %405 to i64
%413 = sext i32 %400 to i64
br label %414
414: ; preds = %532, %411
%415 = phi i64 [ %413, %411 ], [ %417, %532 ]
%416 = phi i64 [ %412, %411 ], [ %534, %532 ]
%417 = add nsw i64 %415, 1
%418 = getelementptr inbounds i32*, i32** %4, i64 %416
%419 = load i32*, i32** %418
%420 = getelementptr inbounds i32*, i32** %278, i64 %417
%421 = load i32*, i32** %420
br i1 %374, label %497, label %422
422: ; preds = %414
%423 = getelementptr i32, i32* %421, i64 %293
%424 = getelementptr i32, i32* %419, i64 %293
%425 = icmp ult i32* %421, %424
%426 = icmp ult i32* %419, %423
%427 = and i1 %425, %426
br i1 %427, label %497, label %428
428: ; preds = %422
br i1 %377, label %478, label %429
429: ; preds = %428, %429
%430 = phi i64 [ %475, %429 ], [ 0, %428 ]
%431 = phi i64 [ %476, %429 ], [ 0, %428 ]
%432 = getelementptr inbounds i32, i32* %419, i64 %430
%433 = bitcast i32* %432 to <4 x i32>*
%434 = load <4 x i32>, <4 x i32>* %433
%435 = getelementptr inbounds i32, i32* %432, i64 4
%436 = bitcast i32* %435 to <4 x i32>*
%437 = load <4 x i32>, <4 x i32>* %436
%438 = getelementptr inbounds i32, i32* %421, i64 %430
%439 = bitcast i32* %438 to <4 x i32>*
store <4 x i32> %434, <4 x i32>* %439
%440 = getelementptr inbounds i32, i32* %438, i64 4
%441 = bitcast i32* %440 to <4 x i32>*
store <4 x i32> %437, <4 x i32>* %441
%442 = or i64 %430, 8
%443 = getelementptr inbounds i32, i32* %419, i64 %442
%444 = bitcast i32* %443 to <4 x i32>*
%445 = load <4 x i32>, <4 x i32>* %444
%446 = getelementptr inbounds i32, i32* %443, i64 4
%447 = bitcast i32* %446 to <4 x i32>*
%448 = load <4 x i32>, <4 x i32>* %447
%449 = getelementptr inbounds i32, i32* %421, i64 %442
%450 = bitcast i32* %449 to <4 x i32>*
store <4 x i32> %445, <4 x i32>* %450
%451 = getelementptr inbounds i32, i32* %449, i64 4
%452 = bitcast i32* %451 to <4 x i32>*
store <4 x i32> %448, <4 x i32>* %452
%453 = or i64 %430, 16
%454 = getelementptr inbounds i32, i32* %419, i64 %453
%455 = bitcast i32* %454 to <4 x i32>*
%456 = load <4 x i32>, <4 x i32>* %455
%457 = getelementptr inbounds i32, i32* %454, i64 4
%458 = bitcast i32* %457 to <4 x i32>*
%459 = load <4 x i32>, <4 x i32>* %458
%460 = getelementptr inbounds i32, i32* %421, i64 %453
%461 = bitcast i32* %460 to <4 x i32>*
store <4 x i32> %456, <4 x i32>* %461
%462 = getelementptr inbounds i32, i32* %460, i64 4
%463 = bitcast i32* %462 to <4 x i32>*
store <4 x i32> %459, <4 x i32>* %463
%464 = or i64 %430, 24
%465 = getelementptr inbounds i32, i32* %419, i64 %464
%466 = bitcast i32* %465 to <4 x i32>*
%467 = load <4 x i32>, <4 x i32>* %466
%468 = getelementptr inbounds i32, i32* %465, i64 4
%469 = bitcast i32* %468 to <4 x i32>*
%470 = load <4 x i32>, <4 x i32>* %469
%471 = getelementptr inbounds i32, i32* %421, i64 %464
%472 = bitcast i32* %471 to <4 x i32>*
store <4 x i32> %467, <4 x i32>* %472
%473 = getelementptr inbounds i32, i32* %471, i64 4
%474 = bitcast i32* %473 to <4 x i32>*
store <4 x i32> %470, <4 x i32>* %474
%475 = add nuw i64 %430, 32
%476 = add i64 %431, 4
%477 = icmp eq i64 %476, %378
br i1 %477, label %478, label %429
478: ; preds = %429, %428
%479 = phi i64 [ 0, %428 ], [ %475, %429 ]
br i1 %379, label %496, label %480
480: ; preds = %478, %480
%481 = phi i64 [ %493, %480 ], [ %479, %478 ]
%482 = phi i64 [ %494, %480 ], [ 0, %478 ]
%483 = getelementptr inbounds i32, i32* %419, i64 %481
%484 = bitcast i32* %483 to <4 x i32>*
%485 = load <4 x i32>, <4 x i32>* %484
%486 = getelementptr inbounds i32, i32* %483, i64 4
%487 = bitcast i32* %486 to <4 x i32>*
%488 = load <4 x i32>, <4 x i32>* %487
%489 = getelementptr inbounds i32, i32* %421, i64 %481
%490 = bitcast i32* %489 to <4 x i32>*
store <4 x i32> %485, <4 x i32>* %490
%491 = getelementptr inbounds i32, i32* %489, i64 4
%492 = bitcast i32* %491 to <4 x i32>*
store <4 x i32> %488, <4 x i32>* %492
%493 = add nuw i64 %481, 8
%494 = add i64 %482, 1
%495 = icmp eq i64 %494, %376
br i1 %495, label %496, label %480
496: ; preds = %480, %478
br i1 %380, label %532, label %497
497: ; preds = %422, %414, %496
%498 = phi i64 [ 0, %422 ], [ 0, %414 ], [ %375, %496 ]
%499 = xor i64 %498, -1
%500 = add nsw i64 %499, %369
br i1 %382, label %510, label %501
501: ; preds = %497, %501
%502 = phi i64 [ %507, %501 ], [ %498, %497 ]
%503 = phi i64 [ %508, %501 ], [ 0, %497 ]
%504 = getelementptr inbounds i32, i32* %419, i64 %502
%505 = load i32, i32* %504
%506 = getelementptr inbounds i32, i32* %421, i64 %502
store i32 %505, i32* %506
%507 = add nuw nsw i64 %502, 1
%508 = add i64 %503, 1
%509 = icmp eq i64 %508, %381
br i1 %509, label %510, label %501
510: ; preds = %501, %497
%511 = phi i64 [ %498, %497 ], [ %507, %501 ]
%512 = icmp ult i64 %500, 3
br i1 %512, label %532, label %513
513: ; preds = %510, %513
%514 = phi i64 [ %530, %513 ], [ %511, %510 ]
%515 = getelementptr inbounds i32, i32* %419, i64 %514
%516 = load i32, i32* %515
%517 = getelementptr inbounds i32, i32* %421, i64 %514
store i32 %516, i32* %517
%518 = add nuw nsw i64 %514, 1
%519 = getelementptr inbounds i32, i32* %419, i64 %518
%520 = load i32, i32* %519
%521 = getelementptr inbounds i32, i32* %421, i64 %518
store i32 %520, i32* %521
%522 = add nuw nsw i64 %514, 2
%523 = getelementptr inbounds i32, i32* %419, i64 %522
%524 = load i32, i32* %523
%525 = getelementptr inbounds i32, i32* %421, i64 %522
store i32 %524, i32* %525
%526 = add nuw nsw i64 %514, 3
%527 = getelementptr inbounds i32, i32* %419, i64 %526
%528 = load i32, i32* %527
%529 = getelementptr inbounds i32, i32* %421, i64 %526
store i32 %528, i32* %529
%530 = add nuw nsw i64 %514, 4
%531 = icmp eq i64 %530, %369
br i1 %531, label %532, label %513
532: ; preds = %510, %513, %496
%533 = load i32, i32* %408
%534 = add nsw i64 %416, 1
%535 = sext i32 %533 to i64
%536 = icmp slt i64 %534, %535
br i1 %536, label %414, label %537
537: ; preds = %532
%538 = trunc i64 %417 to i32
br label %539
539: ; preds = %537, %398
%540 = phi i32 [ %400, %398 ], [ %538, %537 ]
%541 = add nsw i32 %540, 1
%542 = add nuw nsw i64 %399, 1
%543 = getelementptr inbounds i32, i32* %271, i64 %542
store i32 %541, i32* %543
%544 = icmp eq i64 %542, %369
br i1 %544, label %383, label %398
545: ; preds = %385, %674
%546 = phi i64 [ 0, %385 ], [ %675, %674 ]
br i1 %14, label %547, label %674
547: ; preds = %545
%548 = getelementptr inbounds i32*, i32** %278, i64 %546
%549 = load i32*, i32** %548
%550 = getelementptr inbounds i32*, i32** %4, i64 %546
%551 = load i32*, i32** %550
br i1 %389, label %627, label %552
552: ; preds = %547
%553 = getelementptr i32, i32* %551, i64 %293
%554 = getelementptr i32, i32* %549, i64 %293
%555 = icmp ult i32* %551, %554
%556 = icmp ult i32* %549, %553
%557 = and i1 %555, %556
br i1 %557, label %627, label %558
558: ; preds = %552
br i1 %392, label %608, label %559
559: ; preds = %558, %559
%560 = phi i64 [ %605, %559 ], [ 0, %558 ]
%561 = phi i64 [ %606, %559 ], [ 0, %558 ]
%562 = getelementptr inbounds i32, i32* %549, i64 %560
%563 = bitcast i32* %562 to <4 x i32>*
%564 = load <4 x i32>, <4 x i32>* %563
%565 = getelementptr inbounds i32, i32* %562, i64 4
%566 = bitcast i32* %565 to <4 x i32>*
%567 = load <4 x i32>, <4 x i32>* %566
%568 = getelementptr inbounds i32, i32* %551, i64 %560
%569 = bitcast i32* %568 to <4 x i32>*
store <4 x i32> %564, <4 x i32>* %569
%570 = getelementptr inbounds i32, i32* %568, i64 4
%571 = bitcast i32* %570 to <4 x i32>*
store <4 x i32> %567, <4 x i32>* %571
%572 = or i64 %560, 8
%573 = getelementptr inbounds i32, i32* %549, i64 %572
%574 = bitcast i32* %573 to <4 x i32>*
%575 = load <4 x i32>, <4 x i32>* %574
%576 = getelementptr inbounds i32, i32* %573, i64 4
%577 = bitcast i32* %576 to <4 x i32>*
%578 = load <4 x i32>, <4 x i32>* %577
%579 = getelementptr inbounds i32, i32* %551, i64 %572
%580 = bitcast i32* %579 to <4 x i32>*
store <4 x i32> %575, <4 x i32>* %580
%581 = getelementptr inbounds i32, i32* %579, i64 4
%582 = bitcast i32* %581 to <4 x i32>*
store <4 x i32> %578, <4 x i32>* %582
%583 = or i64 %560, 16
%584 = getelementptr inbounds i32, i32* %549, i64 %583
%585 = bitcast i32* %584 to <4 x i32>*
%586 = load <4 x i32>, <4 x i32>* %585
%587 = getelementptr inbounds i32, i32* %584, i64 4
%588 = bitcast i32* %587 to <4 x i32>*
%589 = load <4 x i32>, <4 x i32>* %588
%590 = getelementptr inbounds i32, i32* %551, i64 %583
%591 = bitcast i32* %590 to <4 x i32>*
store <4 x i32> %586, <4 x i32>* %591
%592 = getelementptr inbounds i32, i32* %590, i64 4
%593 = bitcast i32* %592 to <4 x i32>*
store <4 x i32> %589, <4 x i32>* %593
%594 = or i64 %560, 24
%595 = getelementptr inbounds i32, i32* %549, i64 %594
%596 = bitcast i32* %595 to <4 x i32>*
%597 = load <4 x i32>, <4 x i32>* %596
%598 = getelementptr inbounds i32, i32* %595, i64 4
%599 = bitcast i32* %598 to <4 x i32>*
%600 = load <4 x i32>, <4 x i32>* %599
%601 = getelementptr inbounds i32, i32* %551, i64 %594
%602 = bitcast i32* %601 to <4 x i32>*
store <4 x i32> %597, <4 x i32>* %602
%603 = getelementptr inbounds i32, i32* %601, i64 4
%604 = bitcast i32* %603 to <4 x i32>*
store <4 x i32> %600, <4 x i32>* %604
%605 = add nuw i64 %560, 32
%606 = add i64 %561, 4
%607 = icmp eq i64 %606, %393
br i1 %607, label %608, label %559
608: ; preds = %559, %558
%609 = phi i64 [ 0, %558 ], [ %605, %559 ]
br i1 %394, label %626, label %610
610: ; preds = %608, %610
%611 = phi i64 [ %623, %610 ], [ %609, %608 ]
%612 = phi i64 [ %624, %610 ], [ 0, %608 ]
%613 = getelementptr inbounds i32, i32* %549, i64 %611
%614 = bitcast i32* %613 to <4 x i32>*
%615 = load <4 x i32>, <4 x i32>* %614
%616 = getelementptr inbounds i32, i32* %613, i64 4
%617 = bitcast i32* %616 to <4 x i32>*
%618 = load <4 x i32>, <4 x i32>* %617
%619 = getelementptr inbounds i32, i32* %551, i64 %611
%620 = bitcast i32* %619 to <4 x i32>*
store <4 x i32> %615, <4 x i32>* %620
%621 = getelementptr inbounds i32, i32* %619, i64 4
%622 = bitcast i32* %621 to <4 x i32>*
store <4 x i32> %618, <4 x i32>* %622
%623 = add nuw i64 %611, 8
%624 = add i64 %612, 1
%625 = icmp eq i64 %624, %391
br i1 %625, label %626, label %610
626: ; preds = %610, %608
br i1 %395, label %674, label %627
627: ; preds = %552, %547, %626
%628 = phi i64 [ 0, %552 ], [ 0, %547 ], [ %390, %626 ]
%629 = xor i64 %628, -1
%630 = add nsw i64 %629, %369
br i1 %397, label %640, label %631
631: ; preds = %627, %631
%632 = phi i64 [ %637, %631 ], [ %628, %627 ]
%633 = phi i64 [ %638, %631 ], [ 0, %627 ]
%634 = getelementptr inbounds i32, i32* %549, i64 %632
%635 = load i32, i32* %634
%636 = getelementptr inbounds i32, i32* %551, i64 %632
store i32 %635, i32* %636
%637 = add nuw nsw i64 %632, 1
%638 = add i64 %633, 1
%639 = icmp eq i64 %638, %396
br i1 %639, label %640, label %631
640: ; preds = %631, %627
%641 = phi i64 [ %628, %627 ], [ %637, %631 ]
%642 = icmp ult i64 %630, 3
br i1 %642, label %674, label %655
643: ; preds = %674, %383
br i1 %14, label %644, label %946
644: ; preds = %643
%645 = zext i32 %0 to i64
%646 = icmp ult i32 %0, 8
%647 = and i64 %293, 4294967288
%648 = and i64 %373, 3
%649 = icmp ult i64 %371, 24
%650 = and i64 %373, 4611686018427387900
%651 = icmp eq i64 %648, 0
%652 = icmp eq i64 %647, %293
%653 = and i64 %645, 3
%654 = icmp eq i64 %653, 0
br label %692
655: ; preds = %640, %655
%656 = phi i64 [ %672, %655 ], [ %641, %640 ]
%657 = getelementptr inbounds i32, i32* %549, i64 %656
%658 = load i32, i32* %657
%659 = getelementptr inbounds i32, i32* %551, i64 %656
store i32 %658, i32* %659
%660 = add nuw nsw i64 %656, 1
%661 = getelementptr inbounds i32, i32* %549, i64 %660
%662 = load i32, i32* %661
%663 = getelementptr inbounds i32, i32* %551, i64 %660
store i32 %662, i32* %663
%664 = add nuw nsw i64 %656, 2
%665 = getelementptr inbounds i32, i32* %549, i64 %664
%666 = load i32, i32* %665
%667 = getelementptr inbounds i32, i32* %551, i64 %664
store i32 %666, i32* %667
%668 = add nuw nsw i64 %656, 3
%669 = getelementptr inbounds i32, i32* %549, i64 %668
%670 = load i32, i32* %669
%671 = getelementptr inbounds i32, i32* %551, i64 %668
store i32 %670, i32* %671
%672 = add nuw nsw i64 %656, 4
%673 = icmp eq i64 %672, %388
br i1 %673, label %674, label %655
674: ; preds = %640, %655, %626, %545
%675 = add nuw nsw i64 %546, 1
%676 = icmp eq i64 %675, %387
br i1 %676, label %643, label %545
677: ; preds = %842
%678 = icmp slt i32 %843, 0
br i1 %678, label %946, label %679
679: ; preds = %677
%680 = add nuw i32 %843, 1
%681 = zext i32 %680 to i64
%682 = zext i32 %0 to i64
%683 = icmp ult i32 %0, 8
%684 = and i64 %293, 4294967288
%685 = and i64 %373, 3
%686 = icmp ult i64 %371, 24
%687 = and i64 %373, 4611686018427387900
%688 = icmp eq i64 %685, 0
%689 = icmp eq i64 %684, %293
%690 = and i64 %645, 3
%691 = icmp eq i64 %690, 0
br label %848
692: ; preds = %644, %842
%693 = phi i64 [ 0, %644 ], [ %845, %842 ]
%694 = phi i32 [ -1, %644 ], [ %843, %842 ]
%695 = getelementptr inbounds i32, i32* %267, i64 %693
%696 = load i32, i32* %695
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds i32, i32* %7, i64 %697
%699 = load i32, i32* %698
%700 = add nsw i32 %696, 1
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds i32, i32* %7, i64 %701
%703 = load i32, i32* %702
%704 = icmp slt i32 %699, %703
br i1 %704, label %705, label %842
705: ; preds = %692
%706 = getelementptr inbounds i32, i32* %5, i64 %697
%707 = getelementptr inbounds i32, i32* %271, i64 %693
%708 = load i32, i32* %707
%709 = sext i32 %699 to i64
%710 = sext i32 %694 to i64
br label %711
711: ; preds = %829, %705
%712 = phi i64 [ %710, %705 ], [ %714, %829 ]
%713 = phi i64 [ %709, %705 ], [ %837, %829 ]
%714 = add nsw i64 %712, 1
%715 = getelementptr inbounds i32*, i32** %6, i64 %713
%716 = load i32*, i32** %715
%717 = getelementptr inbounds i32*, i32** %278, i64 %714
%718 = load i32*, i32** %717
br i1 %646, label %794, label %719
719: ; preds = %711
%720 = getelementptr i32, i32* %718, i64 %293
%721 = getelementptr i32, i32* %716, i64 %293
%722 = icmp ult i32* %718, %721
%723 = icmp ult i32* %716, %720
%724 = and i1 %722, %723
br i1 %724, label %794, label %725
725: ; preds = %719
br i1 %649, label %775, label %726
726: ; preds = %725, %726
%727 = phi i64 [ %772, %726 ], [ 0, %725 ]
%728 = phi i64 [ %773, %726 ], [ 0, %725 ]
%729 = getelementptr inbounds i32, i32* %716, i64 %727
%730 = bitcast i32* %729 to <4 x i32>*
%731 = load <4 x i32>, <4 x i32>* %730
%732 = getelementptr inbounds i32, i32* %729, i64 4
%733 = bitcast i32* %732 to <4 x i32>*
%734 = load <4 x i32>, <4 x i32>* %733
%735 = getelementptr inbounds i32, i32* %718, i64 %727
%736 = bitcast i32* %735 to <4 x i32>*
store <4 x i32> %731, <4 x i32>* %736
%737 = getelementptr inbounds i32, i32* %735, i64 4
%738 = bitcast i32* %737 to <4 x i32>*
store <4 x i32> %734, <4 x i32>* %738
%739 = or i64 %727, 8
%740 = getelementptr inbounds i32, i32* %716, i64 %739
%741 = bitcast i32* %740 to <4 x i32>*
%742 = load <4 x i32>, <4 x i32>* %741
%743 = getelementptr inbounds i32, i32* %740, i64 4
%744 = bitcast i32* %743 to <4 x i32>*
%745 = load <4 x i32>, <4 x i32>* %744
%746 = getelementptr inbounds i32, i32* %718, i64 %739
%747 = bitcast i32* %746 to <4 x i32>*
store <4 x i32> %742, <4 x i32>* %747
%748 = getelementptr inbounds i32, i32* %746, i64 4
%749 = bitcast i32* %748 to <4 x i32>*
store <4 x i32> %745, <4 x i32>* %749
%750 = or i64 %727, 16
%751 = getelementptr inbounds i32, i32* %716, i64 %750
%752 = bitcast i32* %751 to <4 x i32>*
%753 = load <4 x i32>, <4 x i32>* %752
%754 = getelementptr inbounds i32, i32* %751, i64 4
%755 = bitcast i32* %754 to <4 x i32>*
%756 = load <4 x i32>, <4 x i32>* %755
%757 = getelementptr inbounds i32, i32* %718, i64 %750
%758 = bitcast i32* %757 to <4 x i32>*
store <4 x i32> %753, <4 x i32>* %758
%759 = getelementptr inbounds i32, i32* %757, i64 4
%760 = bitcast i32* %759 to <4 x i32>*
store <4 x i32> %756, <4 x i32>* %760
%761 = or i64 %727, 24
%762 = getelementptr inbounds i32, i32* %716, i64 %761
%763 = bitcast i32* %762 to <4 x i32>*
%764 = load <4 x i32>, <4 x i32>* %763
%765 = getelementptr inbounds i32, i32* %762, i64 4
%766 = bitcast i32* %765 to <4 x i32>*
%767 = load <4 x i32>, <4 x i32>* %766
%768 = getelementptr inbounds i32, i32* %718, i64 %761
%769 = bitcast i32* %768 to <4 x i32>*
store <4 x i32> %764, <4 x i32>* %769
%770 = getelementptr inbounds i32, i32* %768, i64 4
%771 = bitcast i32* %770 to <4 x i32>*
store <4 x i32> %767, <4 x i32>* %771
%772 = add nuw i64 %727, 32
%773 = add i64 %728, 4
%774 = icmp eq i64 %773, %650
br i1 %774, label %775, label %726
775: ; preds = %726, %725
%776 = phi i64 [ 0, %725 ], [ %772, %726 ]
br i1 %651, label %793, label %777
777: ; preds = %775, %777
%778 = phi i64 [ %790, %777 ], [ %776, %775 ]
%779 = phi i64 [ %791, %777 ], [ 0, %775 ]
%780 = getelementptr inbounds i32, i32* %716, i64 %778
%781 = bitcast i32* %780 to <4 x i32>*
%782 = load <4 x i32>, <4 x i32>* %781
%783 = getelementptr inbounds i32, i32* %780, i64 4
%784 = bitcast i32* %783 to <4 x i32>*
%785 = load <4 x i32>, <4 x i32>* %784
%786 = getelementptr inbounds i32, i32* %718, i64 %778
%787 = bitcast i32* %786 to <4 x i32>*
store <4 x i32> %782, <4 x i32>* %787
%788 = getelementptr inbounds i32, i32* %786, i64 4
%789 = bitcast i32* %788 to <4 x i32>*
store <4 x i32> %785, <4 x i32>* %789
%790 = add nuw i64 %778, 8
%791 = add i64 %779, 1
%792 = icmp eq i64 %791, %648
br i1 %792, label %793, label %777
793: ; preds = %777, %775
br i1 %652, label %829, label %794
794: ; preds = %719, %711, %793
%795 = phi i64 [ 0, %719 ], [ 0, %711 ], [ %647, %793 ]
%796 = xor i64 %795, -1
%797 = add nsw i64 %796, %645
br i1 %654, label %807, label %798
798: ; preds = %794, %798
%799 = phi i64 [ %804, %798 ], [ %795, %794 ]
%800 = phi i64 [ %805, %798 ], [ 0, %794 ]
%801 = getelementptr inbounds i32, i32* %716, i64 %799
%802 = load i32, i32* %801
%803 = getelementptr inbounds i32, i32* %718, i64 %799
store i32 %802, i32* %803
%804 = add nuw nsw i64 %799, 1
%805 = add i64 %800, 1
%806 = icmp eq i64 %805, %653
br i1 %806, label %807, label %798
807: ; preds = %798, %794
%808 = phi i64 [ %795, %794 ], [ %804, %798 ]
%809 = icmp ult i64 %797, 3
br i1 %809, label %829, label %810
810: ; preds = %807, %810
%811 = phi i64 [ %827, %810 ], [ %808, %807 ]
%812 = getelementptr inbounds i32, i32* %716, i64 %811
%813 = load i32, i32* %812
%814 = getelementptr inbounds i32, i32* %718, i64 %811
store i32 %813, i32* %814
%815 = add nuw nsw i64 %811, 1
%816 = getelementptr inbounds i32, i32* %716, i64 %815
%817 = load i32, i32* %816
%818 = getelementptr inbounds i32, i32* %718, i64 %815
store i32 %817, i32* %818
%819 = add nuw nsw i64 %811, 2
%820 = getelementptr inbounds i32, i32* %716, i64 %819
%821 = load i32, i32* %820
%822 = getelementptr inbounds i32, i32* %718, i64 %819
store i32 %821, i32* %822
%823 = add nuw nsw i64 %811, 3
%824 = getelementptr inbounds i32, i32* %716, i64 %823
%825 = load i32, i32* %824
%826 = getelementptr inbounds i32, i32* %718, i64 %823
store i32 %825, i32* %826
%827 = add nuw nsw i64 %811, 4
%828 = icmp eq i64 %827, %645
br i1 %828, label %829, label %810
829: ; preds = %807, %810, %793
%830 = load i32, i32* %702
%831 = getelementptr inbounds i32, i32* %8, i64 %713
%832 = load i32, i32* %831
%833 = load i32, i32* %706
%834 = sub i32 %832, %833
%835 = add i32 %834, %708
%836 = getelementptr inbounds i32, i32* %291, i64 %714
store i32 %835, i32* %836
%837 = add nsw i64 %713, 1
%838 = sext i32 %830 to i64
%839 = icmp slt i64 %837, %838
br i1 %839, label %711, label %840
840: ; preds = %829
%841 = trunc i64 %714 to i32
br label %842
842: ; preds = %840, %692
%843 = phi i32 [ %694, %692 ], [ %841, %840 ]
%844 = add nsw i32 %843, 1
%845 = add nuw nsw i64 %693, 1
%846 = getelementptr inbounds i32, i32* %273, i64 %845
store i32 %844, i32* %846
%847 = icmp eq i64 %845, %645
br i1 %847, label %677, label %692
848: ; preds = %679, %967
%849 = phi i64 [ 0, %679 ], [ %971, %967 ]
br i1 %14, label %850, label %967
850: ; preds = %848
%851 = getelementptr inbounds i32*, i32** %278, i64 %849
%852 = load i32*, i32** %851
%853 = getelementptr inbounds i32*, i32** %6, i64 %849
%854 = load i32*, i32** %853
br i1 %683, label %930, label %855
855: ; preds = %850
%856 = getelementptr i32, i32* %854, i64 %293
%857 = getelementptr i32, i32* %852, i64 %293
%858 = icmp ult i32* %854, %857
%859 = icmp ult i32* %852, %856
%860 = and i1 %858, %859
br i1 %860, label %930, label %861
861: ; preds = %855
br i1 %686, label %911, label %862
862: ; preds = %861, %862
%863 = phi i64 [ %908, %862 ], [ 0, %861 ]
%864 = phi i64 [ %909, %862 ], [ 0, %861 ]
%865 = getelementptr inbounds i32, i32* %852, i64 %863
%866 = bitcast i32* %865 to <4 x i32>*
%867 = load <4 x i32>, <4 x i32>* %866
%868 = getelementptr inbounds i32, i32* %865, i64 4
%869 = bitcast i32* %868 to <4 x i32>*
%870 = load <4 x i32>, <4 x i32>* %869
%871 = getelementptr inbounds i32, i32* %854, i64 %863
%872 = bitcast i32* %871 to <4 x i32>*
store <4 x i32> %867, <4 x i32>* %872
%873 = getelementptr inbounds i32, i32* %871, i64 4
%874 = bitcast i32* %873 to <4 x i32>*
store <4 x i32> %870, <4 x i32>* %874
%875 = or i64 %863, 8
%876 = getelementptr inbounds i32, i32* %852, i64 %875
%877 = bitcast i32* %876 to <4 x i32>*
%878 = load <4 x i32>, <4 x i32>* %877
%879 = getelementptr inbounds i32, i32* %876, i64 4
%880 = bitcast i32* %879 to <4 x i32>*
%881 = load <4 x i32>, <4 x i32>* %880
%882 = getelementptr inbounds i32, i32* %854, i64 %875
%883 = bitcast i32* %882 to <4 x i32>*
store <4 x i32> %878, <4 x i32>* %883
%884 = getelementptr inbounds i32, i32* %882, i64 4
%885 = bitcast i32* %884 to <4 x i32>*
store <4 x i32> %881, <4 x i32>* %885
%886 = or i64 %863, 16
%887 = getelementptr inbounds i32, i32* %852, i64 %886
%888 = bitcast i32* %887 to <4 x i32>*
%889 = load <4 x i32>, <4 x i32>* %888
%890 = getelementptr inbounds i32, i32* %887, i64 4
%891 = bitcast i32* %890 to <4 x i32>*
%892 = load <4 x i32>, <4 x i32>* %891
%893 = getelementptr inbounds i32, i32* %854, i64 %886
%894 = bitcast i32* %893 to <4 x i32>*
store <4 x i32> %889, <4 x i32>* %894
%895 = getelementptr inbounds i32, i32* %893, i64 4
%896 = bitcast i32* %895 to <4 x i32>*
store <4 x i32> %892, <4 x i32>* %896
%897 = or i64 %863, 24
%898 = getelementptr inbounds i32, i32* %852, i64 %897
%899 = bitcast i32* %898 to <4 x i32>*
%900 = load <4 x i32>, <4 x i32>* %899
%901 = getelementptr inbounds i32, i32* %898, i64 4
%902 = bitcast i32* %901 to <4 x i32>*
%903 = load <4 x i32>, <4 x i32>* %902
%904 = getelementptr inbounds i32, i32* %854, i64 %897
%905 = bitcast i32* %904 to <4 x i32>*
store <4 x i32> %900, <4 x i32>* %905
%906 = getelementptr inbounds i32, i32* %904, i64 4
%907 = bitcast i32* %906 to <4 x i32>*
store <4 x i32> %903, <4 x i32>* %907
%908 = add nuw i64 %863, 32
%909 = add i64 %864, 4
%910 = icmp eq i64 %909, %687
br i1 %910, label %911, label %862
911: ; preds = %862, %861
%912 = phi i64 [ 0, %861 ], [ %908, %862 ]
br i1 %688, label %929, label %913
913: ; preds = %911, %913
%914 = phi i64 [ %926, %913 ], [ %912, %911 ]
%915 = phi i64 [ %927, %913 ], [ 0, %911 ]
%916 = getelementptr inbounds i32, i32* %852, i64 %914
%917 = bitcast i32* %916 to <4 x i32>*
%918 = load <4 x i32>, <4 x i32>* %917
%919 = getelementptr inbounds i32, i32* %916, i64 4
%920 = bitcast i32* %919 to <4 x i32>*
%921 = load <4 x i32>, <4 x i32>* %920
%922 = getelementptr inbounds i32, i32* %854, i64 %914
%923 = bitcast i32* %922 to <4 x i32>*
store <4 x i32> %918, <4 x i32>* %923
%924 = getelementptr inbounds i32, i32* %922, i64 4
%925 = bitcast i32* %924 to <4 x i32>*
store <4 x i32> %921, <4 x i32>* %925
%926 = add nuw i64 %914, 8
%927 = add i64 %915, 1
%928 = icmp eq i64 %927, %685
br i1 %928, label %929, label %913
929: ; preds = %913, %911
br i1 %689, label %967, label %930
930: ; preds = %855, %850, %929
%931 = phi i64 [ 0, %855 ], [ 0, %850 ], [ %684, %929 ]
%932 = xor i64 %931, -1
%933 = add nsw i64 %932, %645
br i1 %691, label %943, label %934
934: ; preds = %930, %934
%935 = phi i64 [ %940, %934 ], [ %931, %930 ]
%936 = phi i64 [ %941, %934 ], [ 0, %930 ]
%937 = getelementptr inbounds i32, i32* %852, i64 %935
%938 = load i32, i32* %937
%939 = getelementptr inbounds i32, i32* %854, i64 %935
store i32 %938, i32* %939
%940 = add nuw nsw i64 %935, 1
%941 = add i64 %936, 1
%942 = icmp eq i64 %941, %690
br i1 %942, label %943, label %934
943: ; preds = %934, %930
%944 = phi i64 [ %931, %930 ], [ %940, %934 ]
%945 = icmp ult i64 %933, 3
br i1 %945, label %967, label %948
946: ; preds = %967, %367, %643, %677
%947 = icmp slt i32 %0, 0
br i1 %947, label %980, label %973
948: ; preds = %943, %948
%949 = phi i64 [ %965, %948 ], [ %944, %943 ]
%950 = getelementptr inbounds i32, i32* %852, i64 %949
%951 = load i32, i32* %950
%952 = getelementptr inbounds i32, i32* %854, i64 %949
store i32 %951, i32* %952
%953 = add nuw nsw i64 %949, 1
%954 = getelementptr inbounds i32, i32* %852, i64 %953
%955 = load i32, i32* %954
%956 = getelementptr inbounds i32, i32* %854, i64 %953
store i32 %955, i32* %956
%957 = add nuw nsw i64 %949, 2
%958 = getelementptr inbounds i32, i32* %852, i64 %957
%959 = load i32, i32* %958
%960 = getelementptr inbounds i32, i32* %854, i64 %957
store i32 %959, i32* %960
%961 = add nuw nsw i64 %949, 3
%962 = getelementptr inbounds i32, i32* %852, i64 %961
%963 = load i32, i32* %962
%964 = getelementptr inbounds i32, i32* %854, i64 %961
store i32 %963, i32* %964
%965 = add nuw nsw i64 %949, 4
%966 = icmp eq i64 %965, %682
br i1 %966, label %967, label %948
967: ; preds = %943, %948, %929, %848
%968 = getelementptr inbounds i32, i32* %291, i64 %849
%969 = load i32, i32* %968
%970 = getelementptr inbounds i32, i32* %8, i64 %849
store i32 %969, i32* %970
%971 = add nuw nsw i64 %849, 1
%972 = icmp eq i64 %971, %681
br i1 %972, label %946, label %848
973: ; preds = %946
%974 = zext i32 %0 to i64
%975 = shl nuw nsw i64 %974, 2
%976 = add nuw nsw i64 %975, 4
%977 = zext i32 %0 to i64
%978 = shl nuw nsw i64 %977, 2
%979 = add nuw nsw i64 %978, 4
br label %980
980: ; preds = %946, %973, %365
br i1 %14, label %981, label %1074
981: ; preds = %980
%982 = zext i32 %0 to i64
%983 = shl nuw nsw i64 %982, 2
%984 = add nsw i32 %0, -1
%985 = icmp eq i32 %0, 1
%986 = zext i32 %984 to i64
br i1 %985, label %1069, label %987
987: ; preds = %981
%988 = zext i32 %0 to i64
br label %989
989: ; preds = %987, %1057
%990 = phi i64 [ 0, %987 ], [ %1058, %1057 ]
%991 = phi i64 [ 1, %987 ], [ %1060, %1057 ]
%992 = phi i32 [ 0, %987 ], [ %1059, %1057 ]
%993 = getelementptr inbounds i32, i32* %3, i64 %990
%994 = load i32, i32* %993
%995 = icmp slt i32 %994, 0
br i1 %995, label %998, label %996
996: ; preds = %989
%997 = add nuw nsw i64 %990, 1
br label %1057
998: ; preds = %989
%999 = add nsw i32 %992, 1
%1000 = add nuw nsw i64 %990, 1
%1001 = icmp slt i64 %1000, %265
br i1 %1001, label %1002, label %1057
1002: ; preds = %998
%1003 = getelementptr inbounds i32, i32* %7, i64 %1000
%1004 = getelementptr inbounds i32, i32* %7, i64 %990
%1005 = trunc i64 %990 to i32
br label %1006
1006: ; preds = %1002, %1055
%1007 = phi i64 [ %991, %1002 ], [ %1011, %1055 ]
%1008 = getelementptr inbounds i32, i32* %3, i64 %1007
%1009 = load i32, i32* %1008
%1010 = icmp slt i32 %1009, 0
%1011 = add nuw nsw i64 %1007, 1
br i1 %1010, label %1012, label %1055
1012: ; preds = %1006
%1013 = getelementptr inbounds i32, i32* %7, i64 %1011
%1014 = load i32, i32* %1013
%1015 = getelementptr inbounds i32, i32* %7, i64 %1007
%1016 = load i32, i32* %1015
%1017 = sub nsw i32 %1014, %1016
%1018 = load i32, i32* %1003
%1019 = load i32, i32* %1004
%1020 = sub nsw i32 %1018, %1019
%1021 = icmp eq i32 %1017, %1020
br i1 %1021, label %1022, label %1055
1022: ; preds = %1012
%1023 = icmp sgt i32 %1018, %1019
br i1 %1023, label %1024, label %1054
1024: ; preds = %1022
%1025 = sub i32 %1016, %1019
%1026 = sext i32 %1019 to i64
%1027 = sext i32 %1018 to i64
br label %1028
1028: ; preds = %1048, %1024
%1029 = phi i64 [ %1026, %1024 ], [ %1049, %1048 ]
%1030 = phi i1 [ true, %1024 ], [ %1050, %1048 ]
%1031 = getelementptr inbounds i32*, i32** %6, i64 %1029
%1032 = load i32*, i32** %1031
%1033 = trunc i64 %1029 to i32
%1034 = add i32 %1025, %1033
%1035 = sext i32 %1034 to i64
%1036 = getelementptr inbounds i32*, i32** %6, i64 %1035
%1037 = load i32*, i32** %1036
br label %1040
1038: ; preds = %1040
%1039 = icmp eq i64 %1047, %988
br i1 %1039, label %1048, label %1040
1040: ; preds = %1028, %1038
%1041 = phi i64 [ 0, %1028 ], [ %1047, %1038 ]
%1042 = getelementptr inbounds i32, i32* %1032, i64 %1041
%1043 = load i32, i32* %1042
%1044 = getelementptr inbounds i32, i32* %1037, i64 %1041
%1045 = load i32, i32* %1044
%1046 = icmp eq i32 %1043, %1045
%1047 = add nuw nsw i64 %1041, 1
br i1 %1046, label %1038, label %1053
1048: ; preds = %1038
%1049 = add nsw i64 %1029, 1
%1050 = icmp slt i64 %1049, %1027
%1051 = trunc i64 %1049 to i32
%1052 = icmp eq i32 %1018, %1051
br i1 %1052, label %1054, label %1028
1053: ; preds = %1040
br i1 %1030, label %1055, label %1054
1054: ; preds = %1048, %1022, %1053
store i32 %1005, i32* %1008
br label %1055
1055: ; preds = %1006, %1054, %1053, %1012
%1056 = icmp eq i64 %1011, %988
br i1 %1056, label %1057, label %1006
1057: ; preds = %1055, %996, %998
%1058 = phi i64 [ %997, %996 ], [ %1000, %998 ], [ %1000, %1055 ]
%1059 = phi i32 [ %992, %996 ], [ %999, %998 ], [ %999, %1055 ]
%1060 = add nuw nsw i64 %991, 1
%1061 = icmp eq i64 %1058, %986
br i1 %1061, label %1062, label %989
1062: ; preds = %1057
%1063 = sext i32 %984 to i64
%1064 = getelementptr inbounds i32, i32* %3, i64 %1063
%1065 = load i32, i32* %1064
%1066 = lshr i32 %1065, 31
%1067 = add nsw i32 %1066, %1059
%1068 = icmp slt i32 %1067, %0
br i1 %1068, label %1156, label %1081
1069: ; preds = %981
%1070 = getelementptr inbounds i32, i32* %3, i64 %986
%1071 = load i32, i32* %1070
%1072 = lshr i32 %1071, 31
%1073 = icmp ult i32 %1072, %0
br i1 %1073, label %1156, label %1082
1074: ; preds = %289, %980
%1075 = add i32 %0, -1
%1076 = sext i32 %1075 to i64
%1077 = getelementptr inbounds i32, i32* %3, i64 %1076
%1078 = load i32, i32* %1077
%1079 = lshr i32 %1078, 31
%1080 = icmp slt i32 %1079, %0
br i1 %1080, label %1156, label %1164
1081: ; preds = %1062
br i1 %14, label %1082, label %1164
1082: ; preds = %1069, %1081
%1083 = zext i32 %0 to i64
%1084 = icmp ult i32 %0, 8
br i1 %1084, label %1154, label %1085
1085: ; preds = %1082
%1086 = and i64 %293, 4294967288
%1087 = add nsw i64 %1086, -8
%1088 = lshr exact i64 %1087, 3
%1089 = add nuw nsw i64 %1088, 1
%1090 = and i64 %1089, 7
%1091 = icmp ult i64 %1087, 56
br i1 %1091, label %1139, label %1092
1092: ; preds = %1085
%1093 = and i64 %1089, 4611686018427387896
br label %1094
1094: ; preds = %1094, %1092
%1095 = phi i64 [ 0, %1092 ], [ %1136, %1094 ]
%1096 = phi i64 [ 0, %1092 ], [ %1137, %1094 ]
%1097 = getelementptr inbounds i32, i32* %3, i64 %1095
%1098 = bitcast i32* %1097 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1098
%1099 = getelementptr inbounds i32, i32* %1097, i64 4
%1100 = bitcast i32* %1099 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1100
%1101 = or i64 %1095, 8
%1102 = getelementptr inbounds i32, i32* %3, i64 %1101
%1103 = bitcast i32* %1102 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1103
%1104 = getelementptr inbounds i32, i32* %1102, i64 4
%1105 = bitcast i32* %1104 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1105
%1106 = or i64 %1095, 16
%1107 = getelementptr inbounds i32, i32* %3, i64 %1106
%1108 = bitcast i32* %1107 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1108
%1109 = getelementptr inbounds i32, i32* %1107, i64 4
%1110 = bitcast i32* %1109 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1110
%1111 = or i64 %1095, 24
%1112 = getelementptr inbounds i32, i32* %3, i64 %1111
%1113 = bitcast i32* %1112 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1113
%1114 = getelementptr inbounds i32, i32* %1112, i64 4
%1115 = bitcast i32* %1114 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1115
%1116 = or i64 %1095, 32
%1117 = getelementptr inbounds i32, i32* %3, i64 %1116
%1118 = bitcast i32* %1117 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1118
%1119 = getelementptr inbounds i32, i32* %1117, i64 4
%1120 = bitcast i32* %1119 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1120
%1121 = or i64 %1095, 40
%1122 = getelementptr inbounds i32, i32* %3, i64 %1121
%1123 = bitcast i32* %1122 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1123
%1124 = getelementptr inbounds i32, i32* %1122, i64 4
%1125 = bitcast i32* %1124 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1125
%1126 = or i64 %1095, 48
%1127 = getelementptr inbounds i32, i32* %3, i64 %1126
%1128 = bitcast i32* %1127 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1128
%1129 = getelementptr inbounds i32, i32* %1127, i64 4
%1130 = bitcast i32* %1129 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1130
%1131 = or i64 %1095, 56
%1132 = getelementptr inbounds i32, i32* %3, i64 %1131
%1133 = bitcast i32* %1132 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1133
%1134 = getelementptr inbounds i32, i32* %1132, i64 4
%1135 = bitcast i32* %1134 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1135
%1136 = add nuw i64 %1095, 64
%1137 = add nuw i64 %1096, 8
%1138 = icmp eq i64 %1137, %1093
br i1 %1138, label %1139, label %1094
1139: ; preds = %1094, %1085
%1140 = phi i64 [ 0, %1085 ], [ %1136, %1094 ]
%1141 = icmp eq i64 %1090, 0
br i1 %1141, label %1152, label %1142
1142: ; preds = %1139, %1142
%1143 = phi i64 [ %1149, %1142 ], [ %1140, %1139 ]
%1144 = phi i64 [ %1150, %1142 ], [ 0, %1139 ]
%1145 = getelementptr inbounds i32, i32* %3, i64 %1143
%1146 = bitcast i32* %1145 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1146
%1147 = getelementptr inbounds i32, i32* %1145, i64 4
%1148 = bitcast i32* %1147 to <4 x i32>*
store <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32>* %1148
%1149 = add nuw i64 %1143, 8
%1150 = add i64 %1144, 1
%1151 = icmp eq i64 %1150, %1090
br i1 %1151, label %1152, label %1142
1152: ; preds = %1142, %1139
%1153 = icmp eq i64 %1086, %293
br i1 %1153, label %1164, label %1154
1154: ; preds = %1082, %1152
%1155 = phi i64 [ 0, %1082 ], [ %1086, %1152 ]
br label %1159
1156: ; preds = %1069, %1074, %1062
%1157 = phi i32 [ %1079, %1074 ], [ %1067, %1062 ], [ %1072, %1069 ]
%1158 = tail call i32 (i32, i32**, i32*, i32**, i32*, i32*, i32*, ...) bitcast (i32 (...)* @ReArrangeSpt to i32 (i32, i32**, i32*, i32**, i32*, i32*, i32*, ...)*)(i32 %0, i32** %4, i32* %5, i32** %6, i32* %7, i32* %3, i32* %8)
br label %1164
1159: ; preds = %1154, %1159
%1160 = phi i64 [ %1162, %1159 ], [ %1155, %1154 ]
%1161 = getelementptr inbounds i32, i32* %3, i64 %1160
store i32 1, i32* %1161
%1162 = add nuw nsw i64 %1160, 1
%1163 = icmp eq i64 %1162, %1083
br i1 %1163, label %1164, label %1159
1164: ; preds = %1159, %1152, %1074, %1081, %1156
%1165 = phi i32 [ %1157, %1156 ], [ %0, %1081 ], [ %0, %1074 ], [ %0, %1152 ], [ %0, %1159 ]
store i32 %1165, i32* %2
tail call void @free(i8* %266)
tail call void @free(i8* %270)
tail call void @free(i8* %272)
%1166 = load i32, i32* %274
%1167 = icmp sgt i32 %1166, 0
br i1 %1167, label %1168, label %1177
1168: ; preds = %1164, %1168
%1169 = phi i64 [ %1173, %1168 ], [ 0, %1164 ]
%1170 = getelementptr inbounds i32*, i32** %278, i64 %1169
%1171 = bitcast i32** %1170 to i8**
%1172 = load i8*, i8** %1171
tail call void @free(i8* %1172)
%1173 = add nuw nsw i64 %1169, 1
%1174 = load i32, i32* %274
%1175 = sext i32 %1174 to i64
%1176 = icmp slt i64 %1173, %1175
br i1 %1176, label %1168, label %1177
1177: ; preds = %1168, %1164
tail call void @free(i8* %277)
tail call void @free(i8* %290)
ret void
}