int qrnzcnt(int neqns, int adjlen, int *xadj, int *adjncy, int *zfdperm,
            int *perm, int *invp, int *etpar, int *colcnt_h, int *nlnz,
            int *part_super_ata, int *part_super_h) {
  int temp, last1, last2, i, j, k, lflag, pleaf, hinbr, jstop, jstrt, ifdesc,
      oldnbr, parent, lownbr, lca;
  int xsup;
  int *set, *prvlf, *level, *weight, *fdesc, *nchild, *prvnbr;
  int *fnz;
  int *marker;
  int *fnz_hadj;
  int *hadj_begin;
  int *hadj_end;
  int *first;
  int *firstset;
  int *weight_h;
  int *rowcnt;
  int *colcnt;
  int *rowcnt_h;
  int nsuper;
  int nhnz;
  set = intMalloc(neqns);
  prvlf = intMalloc(neqns);
  level = intMalloc(neqns + 1);
  weight = intMalloc(neqns + 1);
  fdesc = intMalloc(neqns + 1);
  nchild = intMalloc(neqns + 1);
  prvnbr = intMalloc(neqns);
  fnz_hadj = intMalloc(adjlen + 2 * neqns + 1);
  hadj_begin = fnz_hadj + adjlen;
  hadj_end = hadj_begin + neqns + 1;
  fnz = set;
  marker = prvlf;
  first = intMalloc(neqns);
  firstset = intMalloc(neqns);
  weight_h = intCalloc(neqns + 1);
  rowcnt_h = intMalloc(neqns);
  rowcnt = intMalloc(neqns);
  colcnt = intMalloc(neqns);
  for (k = 0; k < neqns; ++k) {
    fnz[k] = first[k] = marker[k] = (-1);
    rowcnt[k] = part_super_ata[k] = 0;
    part_super_h[k] = 0;
    nchild[k] = 0;
  }
  nchild[(neqns)] = 0;
  xsup = 0;
  for (k = 0; k < neqns; ++k) {
    parent = etpar[k];
    ++nchild[parent];
    if (k != 0 && nchild[k] >= 2) {
      part_super_h[xsup] = k - xsup;
      xsup = k;
    }
    oldnbr = perm[k];
    for (j = xadj[oldnbr]; j < xadj[oldnbr + 1]; ++j) {
      i = zfdperm[adjncy[j]];
      ++rowcnt[i];
      if (fnz[i] == (-1)) {
        fnz[i] = k;
        firstset[i] = first[k];
        first[k] = i;
        if (k != 0 && xsup != k) {
          part_super_h[xsup] = k - xsup;
          xsup = k;
        }
      }
    }
  }
  part_super_h[xsup] = neqns - xsup;
  hadj_begin[0] = 0;
  for (k = 0; k < neqns; ++k) {
    temp = 0;
    oldnbr = perm[k];
    hadj_end[k] = hadj_begin[k];
    for (j = xadj[oldnbr]; j < xadj[oldnbr + 1]; ++j) {
      hinbr = zfdperm[adjncy[j]];
      jstrt = fnz[hinbr];
      if (jstrt != k && marker[jstrt] < k) {
        fnz_hadj[hadj_end[jstrt]] = k;
        ++hadj_end[jstrt];
        marker[jstrt] = k;
      }
      if (jstrt == k)
        temp += rowcnt[hinbr];
    }
    hadj_begin[k + 1] = hadj_begin[k] + temp;
  }
  level[(neqns)] = 0;
  for (k = neqns - 1; k >= 0; --k) {
    rowcnt[k] = 1;
    colcnt[k] = 0;
    set[k] = k;
    prvlf[k] = (-1);
    level[k] = level[etpar[k]] + 1;
    weight[k] = 1;
    fdesc[k] = k;
    prvnbr[k] = (-1);
  }
  fdesc[(neqns)] = (-1);
  for (k = 0; k < neqns; ++k) {
    parent = etpar[k];
    weight[parent] = 0;
    colcnt_h[k] = 0;
    ifdesc = fdesc[k];
    if (ifdesc < fdesc[parent]) {
      fdesc[parent] = ifdesc;
    }
  }
  xsup = 0;
  nsuper = 0;
  for (lownbr = 0; lownbr < neqns; ++lownbr) {
    for (i = first[lownbr]; i != (-1); i = firstset[i]) {
      rowcnt_h[i] = 1 + (level[lownbr] - level[i]);
      ++weight_h[lownbr];
      parent = etpar[i];
      --weight_h[parent];
    }
    lflag = 0;
    ifdesc = fdesc[lownbr];
    jstrt = hadj_begin[lownbr];
    jstop = hadj_end[lownbr];
    for (j = jstrt; j < jstop; ++j) {
      hinbr = fnz_hadj[j];
      if (hinbr > lownbr) {
        if (ifdesc > prvnbr[hinbr]) {
          ++weight[lownbr];
          pleaf = prvlf[hinbr];
          if (pleaf == (-1)) {
            rowcnt[hinbr] = rowcnt[hinbr] + level[lownbr] - level[hinbr];
          } else {
            last1 = pleaf;
            last2 = set[last1];
            lca = set[last2];
            while (lca != last2) {
              set[last1] = lca;
              last1 = lca;
              last2 = set[last1];
              lca = set[last2];
            }
            rowcnt[hinbr] = rowcnt[hinbr] + level[lownbr] - level[lca];
            --weight[lca];
          }
          prvlf[hinbr] = lownbr;
          lflag = 1;
        }
        prvnbr[hinbr] = lownbr;
      }
    }
    parent = etpar[lownbr];
    --weight[parent];
    if (lflag == 1 || nchild[lownbr] >= 2) {
      if (lownbr != 0)
        part_super_ata[xsup] = lownbr - xsup;
      ++nsuper;
      xsup = lownbr;
    } else {
      if (parent == (neqns) && ifdesc == lownbr) {
        part_super_ata[lownbr] = 1;
        ++nsuper;
        xsup = lownbr;
      }
    }
    set[xsup] = parent;
  }
  *nlnz = nhnz = 0;
  for (k = 0; k < neqns; ++k) {
    temp = colcnt[k] + weight[k];
    colcnt[k] = temp;
    *nlnz += temp;
    parent = etpar[k];
    if (parent != (neqns)) {
      colcnt[parent] += temp;
    }
    temp = colcnt_h[k] + weight_h[k];
    colcnt_h[k] = temp;
    nhnz += temp;
    if (parent != (neqns)) {
      colcnt_h[parent] += temp;
    }
  }
  part_super_ata[xsup] = neqns - xsup;
  free(set);
  free(prvlf);
  free(level);
  free(weight);
  free(fdesc);
  free(nchild);
  free(prvnbr);
  free(fnz_hadj);
  free(first);
  free(firstset);
  free(weight_h);
  free(rowcnt_h);
  free(rowcnt);
  free(colcnt);
  return 0;
}


x86 assembly (clang, -O0):
<qrnzcnt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
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    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0x78(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0x80(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0x88(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0x90(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0x98(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0xa0(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0xa8(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x4(%rbp),%eax
shl    $0x1,%eax
add    %eax,%edi
add    $0x1,%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
movslq -0x8(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0x4,%rax
mov    %rax,-0xd0(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0xd8(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0xe0(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x0,%al
call   1030 <intCalloc@plt>
cltq
mov    %rax,-0xe8(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0x100(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0xf0(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x0,%al
call   1050 <intMalloc@plt>
cltq
mov    %rax,-0xf8(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    136c <qrnzcnt+0x23c>
mov    -0xb8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0xd8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0xb0(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0xf0(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0xa0(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12da <qrnzcnt+0x1aa>
mov    -0xa0(%rbp),%rax
movslq -0x4(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14fa <qrnzcnt+0x3ca>
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0xa0(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x40(%rbp)
je     13f0 <qrnzcnt+0x2c0>
mov    -0xa0(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0x2,(%rax,%rcx,4)
jl     13f0 <qrnzcnt+0x2c0>
mov    -0x40(%rbp),%edx
sub    -0x6c(%rbp),%edx
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x5c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    14e7 <qrnzcnt+0x3b7>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0xf0(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xb0(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    14d4 <qrnzcnt+0x3a4>
mov    -0x40(%rbp),%edx
mov    -0xb0(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xd8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%edx
mov    -0xd8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x40(%rbp)
je     14cf <qrnzcnt+0x39f>
mov    -0x6c(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     14cf <qrnzcnt+0x39f>
mov    -0x40(%rbp),%edx
sub    -0x6c(%rbp),%edx
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    14d4 <qrnzcnt+0x3a4>
jmp    14d9 <qrnzcnt+0x3a9>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    140c <qrnzcnt+0x2dc>
jmp    14ec <qrnzcnt+0x3bc>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    138c <qrnzcnt+0x25c>
mov    -0x4(%rbp),%edx
sub    -0x6c(%rbp),%edx
mov    0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc8(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1673 <qrnzcnt+0x543>
movl   $0x0,-0x2c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    -0xc8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0xd0(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x10(%rbp),%rcx
mov    -0x5c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1641 <qrnzcnt+0x511>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0xb0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x40(%rbp),%eax
je     160e <qrnzcnt+0x4de>
mov    -0xb8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x40(%rbp),%eax
jge    160e <qrnzcnt+0x4de>
mov    -0x40(%rbp),%edx
mov    -0xc0(%rbp),%rax
mov    -0xd0(%rbp),%rcx
movslq -0x54(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xd0(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%edx
mov    -0xb8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
cmp    -0x40(%rbp),%eax
jne    162e <qrnzcnt+0x4fe>
mov    -0xf0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1633 <qrnzcnt+0x503>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    156a <qrnzcnt+0x43a>
mov    -0xc8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    -0x2c(%rbp),%edx
mov    -0xc8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    151f <qrnzcnt+0x3ef>
mov    -0x88(%rbp),%rax
movslq -0x4(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     1743 <qrnzcnt+0x613>
mov    -0xf0(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0xf8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x40(%rbp),%edx
mov    -0x78(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x88(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq -0x40(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x88(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x40(%rbp),%edx
mov    -0x98(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    168e <qrnzcnt+0x55e>
mov    -0x98(%rbp),%rax
movslq -0x4(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17e3 <qrnzcnt+0x6b3>
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x60(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x98(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x98(%rbp),%rcx
movslq -0x60(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    17d0 <qrnzcnt+0x6a0>
mov    -0x58(%rbp),%edx
mov    -0x98(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    17d5 <qrnzcnt+0x6a5>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    175c <qrnzcnt+0x62c>
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x104(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1b3f <qrnzcnt+0xa0f>
mov    -0xd8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0xffffffff,-0x38(%rbp)
je     189b <qrnzcnt+0x76b>
mov    -0x88(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x88(%rbp),%rax
movslq -0x38(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x100(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xe8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0xe8(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0xe0(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
jmp    1818 <qrnzcnt+0x6e8>
movl   $0x0,-0x44(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0xc8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0xd0(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1a6c <qrnzcnt+0x93c>
mov    -0xc0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x64(%rbp),%eax
jle    1a59 <qrnzcnt+0x929>
mov    -0x58(%rbp),%eax
mov    -0xa8(%rbp),%rcx
movslq -0x4c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1a48 <qrnzcnt+0x918>
mov    -0x90(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0xffffffff,-0x48(%rbp)
jne    1984 <qrnzcnt+0x854>
mov    -0xf0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x88(%rbp),%rax
movslq -0x64(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
mov    -0xf0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1a33 <qrnzcnt+0x903>
mov    -0x48(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     19e7 <qrnzcnt+0x8b7>
mov    -0x68(%rbp),%edx
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
jmp    19a6 <qrnzcnt+0x876>
mov    -0xf0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x88(%rbp),%rax
movslq -0x64(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    -0x88(%rbp),%rax
movslq -0x68(%rbp),%rcx
sub    (%rax,%rcx,4),%edx
mov    -0xf0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x90(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%edx
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x44(%rbp)
mov    -0x64(%rbp),%edx
mov    -0xa8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1a5e <qrnzcnt+0x92e>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    18db <qrnzcnt+0x7ab>
mov    0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x1,-0x44(%rbp)
je     1aad <qrnzcnt+0x97d>
mov    -0xa0(%rbp),%rax
movslq -0x64(%rbp),%rcx
cmpl   $0x2,(%rax,%rcx,4)
jl     1ae2 <qrnzcnt+0x9b2>
cmpl   $0x0,-0x64(%rbp)
je     1ac8 <qrnzcnt+0x998>
mov    -0x64(%rbp),%edx
sub    -0x6c(%rbp),%edx
mov    0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1b23 <qrnzcnt+0x9f3>
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    1b1e <qrnzcnt+0x9ee>
mov    -0x58(%rbp),%eax
cmp    -0x64(%rbp),%eax
jne    1b1e <qrnzcnt+0x9ee>
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    1b23 <qrnzcnt+0x9f3>
mov    -0x60(%rbp),%edx
mov    -0x78(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    17fb <qrnzcnt+0x6cb>
movl   $0x0,-0x108(%rbp)
mov    0x28(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1c38 <qrnzcnt+0xb08>
mov    -0xf8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x90(%rbp),%rcx
movslq -0x40(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%edx
mov    -0xf8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%ecx
mov    0x28(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
je     1bcf <qrnzcnt+0xa9f>
mov    -0x2c(%rbp),%edx
mov    -0xf8(%rbp),%rax
movslq -0x60(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0xe8(%rbp),%rcx
movslq -0x40(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    -0x108(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
je     1c25 <qrnzcnt+0xaf5>
mov    -0x2c(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1c2a <qrnzcnt+0xafa>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1b5a <qrnzcnt+0xa2a>
mov    -0x4(%rbp),%edx
sub    -0x6c(%rbp),%edx
mov    0x30(%rbp),%rax
movslq -0x6c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x78(%rbp),%rdi
call   1040 <free@plt>
mov    -0x80(%rbp),%rdi
call   1040 <free@plt>
mov    -0x88(%rbp),%rdi
call   1040 <free@plt>
mov    -0x90(%rbp),%rdi
call   1040 <free@plt>
mov    -0x98(%rbp),%rdi
call   1040 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1040 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1040 <free@plt>
mov    -0xc0(%rbp),%rdi
call   1040 <free@plt>
mov    -0xd8(%rbp),%rdi
call   1040 <free@plt>
mov    -0xe0(%rbp),%rdi
call   1040 <free@plt>
mov    -0xe8(%rbp),%rdi
call   1040 <free@plt>
mov    -0x100(%rbp),%rdi
call   1040 <free@plt>
mov    -0xf0(%rbp),%rdi
call   1040 <free@plt>
mov    -0xf8(%rbp),%rdi
call   1040 <free@plt>
xor    %eax,%eax
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qrnzcnt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9,0x80(%rsp)
mov    %r8,%r12
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,0x28(%rsp)
mov    %edi,%r13d
xor    %eax,%eax
call   1050 <intMalloc@plt>
movslq %eax,%rbx
mov    %r13d,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
cltq
mov    %rax,0x18(%rsp)
lea    0x1(%r13),%ebp
mov    %ebp,(%rsp)
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
cltq
mov    %rax,0x8(%rsp)
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
cltq
mov    %rax,0x20(%rsp)
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
cltq
mov    %rax,0x48(%rsp)
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
cltq
mov    %rax,0x38(%rsp)
mov    %r13,%rbp
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
cltq
mov    %rax,0x58(%rsp)
mov    0x28(%rsp),%r13
lea    0x1(%r13,%rbp,2),%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
movslq %eax,%rcx
movslq %r13d,%rax
mov    %rcx,0x68(%rsp)
lea    (%rcx,%rax,4),%rax
mov    %rax,0x30(%rsp)
mov    %rbp,0x10(%rsp)
movslq %ebp,%rbp
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
cltq
mov    %rax,0x28(%rsp)
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
cltq
mov    %rax,0x70(%rsp)
mov    (%rsp),%edi
xor    %eax,%eax
call   1030 <intCalloc@plt>
cltq
mov    %rax,0x50(%rsp)
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
cltq
mov    %rax,0x78(%rsp)
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
movslq %eax,%r13
mov    %ebp,%edi
xor    %eax,%eax
call   1050 <intMalloc@plt>
mov    0x38(%rsp),%rdx
cltq
mov    %rax,0x60(%rsp)
mov    0x30(%rsp),%rax
test   %ebp,%ebp
jle    14a3 <qrnzcnt+0x373>
lea    (%rax,%rbp,4),%r8
add    $0x4,%r8
mov    %rbp,0x40(%rsp)
mov    %ebp,%ebp
xor    %eax,%eax
mov    0xe0(%rsp),%r9
mov    0x18(%rsp),%rcx
mov    0x28(%rsp),%rsi
mov    0xe8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
movl   $0xffffffff,(%rcx,%rax,4)
movl   $0xffffffff,(%rsi,%rax,4)
movl   $0xffffffff,(%rbx,%rax,4)
movl   $0x0,(%r9,%rax,4)
movl   $0x0,0x0(%r13,%rax,4)
movl   $0x0,(%rdi,%rax,4)
movl   $0x0,(%rdx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    12a0 <qrnzcnt+0x170>
mov    %rbp,(%rsp)
mov    0x40(%rsp),%rbp
movl   $0x0,(%rdx,%rbp,4)
test   %ebp,%ebp
mov    0x58(%rsp),%r10
jle    14ba <qrnzcnt+0x38a>
xor    %eax,%eax
xor    %edi,%edi
mov    0x28(%rsp),%r9
mov    0x70(%rsp),%r11
jmp    131e <qrnzcnt+0x1ee>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    (%rsp),%rax
je     13c7 <qrnzcnt+0x297>
mov    0xc8(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
mov    0x38(%rsp),%rdx
addl   $0x1,(%rdx,%rcx,4)
test   %rax,%rax
je     1352 <qrnzcnt+0x222>
cmpl   $0x2,(%rdx,%rax,4)
jl     1352 <qrnzcnt+0x222>
mov    %eax,%ecx
sub    %edi,%ecx
movslq %edi,%rdx
mov    0xe8(%rsp),%rsi
mov    %ecx,(%rsi,%rdx,4)
mov    %eax,%edi
mov    0x80(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
movslq (%r15,%rcx,4),%rdx
cmp    0x4(%r15,%rcx,4),%edx
jl     137e <qrnzcnt+0x24e>
jmp    1310 <qrnzcnt+0x1e0>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
movslq 0x4(%r15,%rcx,4),%rsi
cmp    %rsi,%rdx
jge    1310 <qrnzcnt+0x1e0>
movslq (%r14,%rdx,4),%rsi
mov    (%r12,%rsi,4),%esi
movslq %esi,%rsi
addl   $0x1,0x0(%r13,%rsi,4)
cmpl   $0xffffffff,(%rbx,%rsi,4)
jne    1370 <qrnzcnt+0x240>
mov    %eax,(%rbx,%rsi,4)
mov    (%r9,%rax,4),%ebp
mov    %ebp,(%r11,%rsi,4)
mov    %esi,(%r9,%rax,4)
test   %rax,%rax
je     1370 <qrnzcnt+0x240>
mov    %edi,%esi
cmp    %rsi,%rax
je     1370 <qrnzcnt+0x240>
mov    %eax,%esi
sub    %edi,%esi
movslq %edi,%rdi
mov    0xe8(%rsp),%rbp
mov    %esi,0x0(%rbp,%rdi,4)
mov    %eax,%edi
jmp    1370 <qrnzcnt+0x240>
mov    0x10(%rsp),%rdx
mov    %edx,%eax
sub    %edi,%eax
movslq %edi,%rcx
mov    0xe8(%rsp),%rsi
mov    %eax,(%rsi,%rcx,4)
mov    0x30(%rsp),%rax
movl   $0x0,(%rax)
test   %edx,%edx
mov    0xe0(%rsp),%r9
mov    0x40(%rsp),%rbp
jle    14cc <qrnzcnt+0x39c>
xor    %ecx,%ecx
xor    %eax,%eax
jmp    142a <qrnzcnt+0x2fa>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x30(%rsp),%rdx
add    (%rdx,%rax,4),%ecx
mov    %ecx,0x4(%rdx,%rax,4)
add    $0x1,%rax
cmp    (%rsp),%rax
je     15a2 <qrnzcnt+0x472>
mov    0x80(%rsp),%rdx
movslq (%rdx,%rax,4),%r9
mov    %ecx,(%r8,%rax,4)
movslq (%r15,%r9,4),%rdi
mov    0x4(%r15,%r9,4),%esi
mov    $0x0,%ecx
cmp    %esi,%edi
jge    1410 <qrnzcnt+0x2e0>
xor    %ecx,%ecx
jmp    1461 <qrnzcnt+0x331>
add    0x0(%r13,%rbp,4),%ecx
add    $0x1,%rdi
movslq %esi,%rdx
cmp    %rdx,%rdi
jge    1410 <qrnzcnt+0x2e0>
movslq (%r14,%rdi,4),%rdx
movslq (%r12,%rdx,4),%rbp
mov    (%rbx,%rbp,4),%edx
cmp    %rdx,%rax
je     1450 <qrnzcnt+0x320>
movslq %edx,%rbp
mov    0x18(%rsp),%r10
movslq (%r10,%rbp,4),%rdx
cmp    %rdx,%rax
jle    149c <qrnzcnt+0x36c>
movslq (%r8,%rbp,4),%rdx
mov    0x68(%rsp),%rsi
mov    %eax,(%rsi,%rdx,4)
addl   $0x1,(%r8,%rbp,4)
mov    %eax,(%r10,%rbp,4)
mov    0x4(%r15,%r9,4),%esi
mov    0x58(%rsp),%r10
jmp    1455 <qrnzcnt+0x325>
movl   $0x0,(%rdx,%rbp,4)
mov    0xe0(%rsp),%r9
mov    0xe8(%rsp),%rdi
mov    0x10(%rsp),%rax
mov    %eax,(%rdi)
mov    0x30(%rsp),%rax
movl   $0x0,(%rax)
mov    0x8(%rsp),%r14
movl   $0x0,(%r14,%rbp,4)
mov    0x10(%rsp),%r11
mov    0x48(%rsp),%rdi
movl   $0xffffffff,(%rdi,%rbp,4)
mov    0x20(%rsp),%r15
mov    0xd8(%rsp),%rax
movl   $0x0,(%rax)
xor    %r12d,%r12d
sub    %r12d,%r11d
movslq %r12d,%rax
mov    %r11d,(%r9,%rax,4)
mov    %rbx,%rdi
call   1040 <free@plt>
mov    0x18(%rsp),%rdi
call   1040 <free@plt>
mov    %r14,%rdi
call   1040 <free@plt>
mov    %r15,%rdi
call   1040 <free@plt>
mov    0x48(%rsp),%rdi
call   1040 <free@plt>
mov    0x38(%rsp),%rdi
call   1040 <free@plt>
mov    0x58(%rsp),%rdi
call   1040 <free@plt>
mov    0x68(%rsp),%rdi
call   1040 <free@plt>
mov    0x28(%rsp),%rdi
call   1040 <free@plt>
mov    0x70(%rsp),%rdi
call   1040 <free@plt>
mov    0x50(%rsp),%rdi
call   1040 <free@plt>
mov    0x78(%rsp),%rdi
call   1040 <free@plt>
mov    %r13,%rdi
call   1040 <free@plt>
mov    0x60(%rsp),%rdi
call   1040 <free@plt>
xor    %eax,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x8(%rsp),%r14
mov    0x40(%rsp),%rbp
movl   $0x0,(%r14,%rbp,4)
mov    0x10(%rsp),%r11
test   %r11d,%r11d
mov    0xe0(%rsp),%r9
mov    0x48(%rsp),%rdi
jle    14e3 <qrnzcnt+0x3b3>
mov    (%rsp),%rax
mov    0x18(%rsp),%r12
mov    0x20(%rsp),%r15
mov    0x60(%rsp),%rbp
mov    0xc8(%rsp),%r11
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rax),%rcx
mov    %ecx,%edx
movl   $0x1,0x0(%r13,%rdx,4)
movl   $0x0,0x0(%rbp,%rdx,4)
mov    %ecx,(%rbx,%rdx,4)
movl   $0xffffffff,(%r12,%rdx,4)
ff
movslq (%r11,%rdx,4),%rsi
mov    (%r14,%rsi,4),%esi
add    $0x1,%esi
mov    %esi,(%r14,%rdx,4)
movl   $0x1,(%r15,%rdx,4)
mov    %ecx,(%rdi,%rdx,4)
movl   $0xffffffff,(%r10,%rdx,4)
ff
cmp    $0x1,%rax
mov    %rcx,%rax
ja     15f0 <qrnzcnt+0x4c0>
mov    0x40(%rsp),%rax
movl   $0xffffffff,(%rdi,%rax,4)
mov    0x10(%rsp),%r11
test   %r11d,%r11d
mov    0xd0(%rsp),%rbp
jle    14ef <qrnzcnt+0x3bf>
cmp    $0x1,%r11d
jne    193b <qrnzcnt+0x80b>
xor    %eax,%eax
testb  $0x1,(%rsp)
je     1698 <qrnzcnt+0x568>
mov    0xc8(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
movl   $0x0,(%r15,%rcx,4)
movl   $0x0,0x0(%rbp,%rax,4)
mov    (%rdi,%rax,4),%eax
cmp    (%rdi,%rcx,4),%eax
jge    1698 <qrnzcnt+0x568>
mov    %eax,(%rdi,%rcx,4)
test   %r11d,%r11d
jle    14ef <qrnzcnt+0x3bf>
xor    %eax,%eax
xor    %r12d,%r12d
mov    0x78(%rsp),%r11
jmp    16e1 <qrnzcnt+0x5b1>
nopl   (%rax)
test   %rax,%rax
je     1890 <qrnzcnt+0x760>
mov    %eax,%edx
sub    %r12d,%edx
movslq %r12d,%rsi
mov    0x8(%rsp),%r14
mov    %edx,(%r9,%rsi,4)
mov    %eax,%r12d
movslq %r12d,%rdx
mov    %ecx,(%rbx,%rdx,4)
add    $0x1,%rax
cmp    (%rsp),%rax
je     189d <qrnzcnt+0x76d>
mov    0x28(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
cmp    $0xffffffff,%ecx
mov    0x70(%rsp),%rsi
mov    0x50(%rsp),%rbp
mov    0xc8(%rsp),%rdi
je     1728 <qrnzcnt+0x5f8>
mov    (%r14,%rax,4),%edx
movslq %ecx,%rcx
sub    (%r14,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%r11,%rcx,4)
addl   $0x1,0x0(%rbp,%rax,4)
movslq (%rdi,%rcx,4),%rdx
addl   $0xffffffff,0x0(%rbp,%rdx,4)
mov    (%rsi,%rcx,4),%ecx
cmp    $0xffffffff,%ecx
jne    1700 <qrnzcnt+0x5d0>
mov    0x48(%rsp),%rcx
mov    (%rcx,%rax,4),%r14d
mov    0x30(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
movslq (%r8,%rax,4),%r15
cmp    %r15d,%ecx
jge    1810 <qrnzcnt+0x6e0>
xor    %esi,%esi
mov    0x18(%rsp),%rdx
jmp    178e <qrnzcnt+0x65e>
mov    0x8(%rsp),%rbp
mov    0x0(%rbp,%rax,4),%edx
add    0x0(%r13,%rdi,4),%edx
sub    0x0(%rbp,%rsi,4),%edx
mov    %edx,0x0(%r13,%rdi,4)
mov    0x20(%rsp),%rdx
addl   $0xffffffff,(%rdx,%rsi,4)
mov    0x18(%rsp),%rdx
mov    %eax,(%rdx,%rdi,4)
mov    $0x1,%esi
mov    %eax,(%r10,%rdi,4)
add    $0x1,%rcx
cmp    %r15,%rcx
je     1830 <qrnzcnt+0x700>
mov    0x68(%rsp),%rdi
movslq (%rdi,%rcx,4),%rdi
cmp    %rdi,%rax
jge    1781 <qrnzcnt+0x651>
cmp    (%r10,%rdi,4),%r14d
jle    177d <qrnzcnt+0x64d>
mov    0x20(%rsp),%rsi
addl   $0x1,(%rsi,%rax,4)
movslq (%rdx,%rdi,4),%rdx
cmp    $0xffffffffffffffff,%rdx
je     17e9 <qrnzcnt+0x6b9>
movslq (%rbx,%rdx,4),%rsi
mov    (%rbx,%rsi,4),%ebp
cmp    %esi,%ebp
je     1750 <qrnzcnt+0x620>
lea    (%rbx,%rdx,4),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebp,(%rdx)
movslq %ebp,%rsi
lea    (%rbx,%rsi,4),%rdx
movslq (%rbx,%rsi,4),%rsi
mov    (%rbx,%rsi,4),%ebp
cmp    %esi,%ebp
jne    17d0 <qrnzcnt+0x6a0>
jmp    1750 <qrnzcnt+0x620>
mov    0x8(%rsp),%rsi
mov    (%rsi,%rax,4),%edx
add    0x0(%r13,%rdi,4),%edx
sub    (%rsi,%rdi,4),%edx
mov    %edx,0x0(%r13,%rdi,4)
jmp    1770 <qrnzcnt+0x640>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc8(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
mov    0x20(%rsp),%r15
addl   $0xffffffff,(%r15,%rcx,4)
mov    0x38(%rsp),%rdx
jmp    185c <qrnzcnt+0x72c>
nopl   (%rax)
mov    0xc8(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
mov    0x20(%rsp),%r15
addl   $0xffffffff,(%r15,%rcx,4)
cmp    $0x1,%esi
mov    0xe0(%rsp),%r9
mov    0x38(%rsp),%rdx
je     16b0 <qrnzcnt+0x580>
cmpl   $0x2,(%rdx,%rax,4)
jge    16b0 <qrnzcnt+0x580>
cmp    0x10(%rsp),%ecx
jne    1893 <qrnzcnt+0x763>
mov    $0x1,%edx
mov    %rax,%rsi
cmp    %r14,%rax
mov    0x8(%rsp),%r14
je     16c6 <qrnzcnt+0x596>
jmp    16cd <qrnzcnt+0x59d>
nopw   0x0(%rax,%rax,1)
mov    %eax,%r12d
mov    0x8(%rsp),%r14
jmp    16cd <qrnzcnt+0x59d>
mov    0xd8(%rsp),%r8
movl   $0x0,(%r8)
mov    0x10(%rsp),%r11
test   %r11d,%r11d
jle    1500 <qrnzcnt+0x3d0>
mov    (%rsp),%rdi
shl    $0x2,%rdi
xor    %eax,%eax
mov    0x60(%rsp),%rbp
jmp    1902 <qrnzcnt+0x7d2>
nopl   0x0(%rax,%rax,1)
add    %ecx,0x0(%rbp,%rdx,4)
mov    0x50(%rsp),%rcx
mov    (%rcx,%rax,1),%ecx
mov    0xd0(%rsp),%rsi
add    (%rsi,%rax,1),%ecx
mov    %ecx,(%rsi,%rax,1)
lea    (%rsi,%rdx,4),%rdx
mov    %rdx,%rsi
add    (%rdx),%ecx
mov    %ecx,(%rsi)
add    $0x4,%rax
cmp    %rax,%rdi
je     1500 <qrnzcnt+0x3d0>
mov    (%r15,%rax,1),%ecx
add    0x0(%rbp,%rax,1),%ecx
mov    %ecx,0x0(%rbp,%rax,1)
add    %ecx,(%r8)
mov    0xc8(%rsp),%rdx
movslq (%rdx,%rax,1),%rdx
cmp    %r11d,%edx
jne    18d0 <qrnzcnt+0x7a0>
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rax,1),%rsi
mov    (%rcx,%rax,1),%ecx
mov    0x50(%rsp),%rdx
add    %rax,%rdx
jmp    18f1 <qrnzcnt+0x7c1>
mov    (%rsp),%rcx
and    $0xfffffffe,%ecx
xor    %eax,%eax
jmp    195d <qrnzcnt+0x82d>
cs nopw 0x0(%rax,%rax,1)
add    $0x2,%rax
cmp    %rax,%rcx
je     166b <qrnzcnt+0x53b>
mov    0xc8(%rsp),%rdx
movslq (%rdx,%rax,4),%rdx
movl   $0x0,(%r15,%rdx,4)
movl   $0x0,0x0(%rbp,%rax,4)
mov    (%rdi,%rax,4),%esi
cmp    (%rdi,%rdx,4),%esi
jge    1984 <qrnzcnt+0x854>
mov    %esi,(%rdi,%rdx,4)
mov    0xc8(%rsp),%rdx
movslq 0x4(%rdx,%rax,4),%rdx
movl   $0x0,(%r15,%rdx,4)
movl   $0x0,0x4(%rbp,%rax,4)
mov    0x4(%rdi,%rax,4),%esi
cmp    (%rdi,%rdx,4),%esi
jge    1950 <qrnzcnt+0x820>
mov    %esi,(%rdi,%rdx,4)
jmp    1950 <qrnzcnt+0x820>

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

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