int solver(int w, int h, int n, int *grid, int *output) {
  int wh = w * h, dc = (((n) + 1) * (((n) + 1) + 1) / 2);
  int *placements, *heads;
  int i, j, x, y, ret;
  placements = ((int *)smalloc((2 * wh) * sizeof(int)));
  for (i = 0; i < 2 * wh; i++)
    placements[i] = -3;
  heads = ((int *)smalloc((dc) * sizeof(int)));
  for (i = 0; i < dc; i++)
    heads[i] = -1;
  for (y = 0; y < h - 1; y++)
    for (x = 0; x < w; x++) {
      int di = (((((grid[y * w + x]) > (grid[(y + 1) * w + x])
                       ? (grid[y * w + x])
                       : (grid[(y + 1) * w + x]))) *
                 ((((grid[y * w + x]) > (grid[(y + 1) * w + x])
                        ? (grid[y * w + x])
                        : (grid[(y + 1) * w + x]))) +
                  1) /
                 2) +
                ((grid[y * w + x]) < (grid[(y + 1) * w + x])
                     ? (grid[y * w + x])
                     : (grid[(y + 1) * w + x])));
      placements[(y * w + x) * 2] = heads[di];
      heads[di] = (y * w + x) * 2;
    }
  for (y = 0; y < h; y++)
    for (x = 0; x < w - 1; x++) {
      int di = (((((grid[y * w + x]) > (grid[y * w + (x + 1)])
                       ? (grid[y * w + x])
                       : (grid[y * w + (x + 1)]))) *
                 ((((grid[y * w + x]) > (grid[y * w + (x + 1)])
                        ? (grid[y * w + x])
                        : (grid[y * w + (x + 1)]))) +
                  1) /
                 2) +
                ((grid[y * w + x]) < (grid[y * w + (x + 1)])
                     ? (grid[y * w + x])
                     : (grid[y * w + (x + 1)])));
      placements[(y * w + x) * 2 + 1] = heads[di];
      heads[di] = (y * w + x) * 2 + 1;
    }
  while (1) {
    int done_something = 0;
    for (i = 0; i < dc; i++) {
      int permset[6], permlen = 0, p;
      if (heads[i] == -1) {
        ret = 0;
        goto done;
      }
      for (j = heads[i]; j >= 0; j = placements[j]) {
        assert(placements[j] != -2);
        if (j == heads[i]) {
          permlen = find_overlaps(w, h, j, permset);
        } else {
          int tempset[6], templen, m, n, k;
          templen = find_overlaps(w, h, j, tempset);
          for (m = n = 0; m < permlen; m++) {
            for (k = 0; k < templen; k++)
              if (tempset[k] == permset[m])
                break;
            if (k < templen)
              permset[n++] = permset[m];
          }
          permlen = n;
        }
      }
      for (p = 0; p < permlen; p++) {
        j = permset[p];
        if (placements[j] != -2) {
          int p1, p2, di;
          done_something = 1;
          p1 = j / 2;
          p2 = (j & 1) ? p1 + 1 : p1 + w;
          di = (((((grid[p1]) > (grid[p2]) ? (grid[p1]) : (grid[p2]))) *
                 ((((grid[p1]) > (grid[p2]) ? (grid[p1]) : (grid[p2]))) + 1) /
                 2) +
                ((grid[p1]) < (grid[p2]) ? (grid[p1]) : (grid[p2])));
          if (heads[di] == j)
            heads[di] = placements[j];
          else {
            int k = heads[di];
            while (placements[k] != -1 && placements[k] != j)
              k = placements[k];
            assert(placements[k] == j);
            placements[k] = placements[j];
          }
          placements[j] = -2;
        }
      }
    }
    for (i = 0; i < wh; i++) {
      int list[4], k, n, adi;
      x = i % w;
      y = i / w;
      j = 0;
      if (x > 0)
        list[j++] = 2 * (i - 1) + 1;
      if (x + 1 < w)
        list[j++] = 2 * i + 1;
      if (y > 0)
        list[j++] = 2 * (i - w);
      if (y + 1 < h)
        list[j++] = 2 * i;
      for (n = k = 0; k < j; k++)
        if (placements[list[k]] >= -1)
          list[n++] = list[k];
      adi = -1;
      for (j = 0; j < n; j++) {
        int p1, p2, di;
        k = list[j];
        p1 = k / 2;
        p2 = (k & 1) ? p1 + 1 : p1 + w;
        di =
            (((((grid[p1]) > (grid[p2]) ? (grid[p1]) : (grid[p2]))) *
              ((((grid[p1]) > (grid[p2]) ? (grid[p1]) : (grid[p2]))) + 1) / 2) +
             ((grid[p1]) < (grid[p2]) ? (grid[p1]) : (grid[p2])));
        if (adi == -1)
          adi = di;
        if (adi != di)
          break;
      }
      if (j == n) {
        int nn;
        assert(adi >= 0);
        nn = 0;
        for (k = heads[adi]; k >= 0; k = placements[k])
          nn++;
        if (nn > n) {
          done_something = 1;
          k = heads[adi];
          while (k >= 0) {
            int tmp = placements[k];
            placements[k] = -2;
            k = tmp;
          }
          heads[adi] = list[0];
          for (k = 0; k < n; k++)
            placements[list[k]] = (k + 1 == n ? -1 : list[k + 1]);
        }
      }
    }
    if (!done_something)
      break;
  }
  ret = 1;
  for (i = 0; i < wh * 2; i++) {
    if (placements[i] == -2) {
      if (output)
        output[i] = -1;
    } else if (placements[i] != -3) {
      int p1, p2, di;
      p1 = i / 2;
      p2 = (i & 1) ? p1 + 1 : p1 + w;
      di = (((((grid[p1]) > (grid[p2]) ? (grid[p1]) : (grid[p2]))) *
             ((((grid[p1]) > (grid[p2]) ? (grid[p1]) : (grid[p2]))) + 1) / 2) +
            ((grid[p1]) < (grid[p2]) ? (grid[p1]) : (grid[p2])));
      if (i == heads[di] && placements[i] == -1) {
        if (output)
          output[i] = 1;
      } else {
        if (output)
          output[i] = 0;
        ret = 2;
      }
    }
  }
done:
  sfree(placements);
  sfree(heads);
  return ret;
}


x86 assembly (clang, -O0):
<solver>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x4(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
mov    $0x0,%al
call   1060 <smalloc@plt>
cltq
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    11d2 <solver+0x92>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0xfffffffd,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11a4 <solver+0x64>
movslq -0x28(%rbp),%rdi
shl    $0x2,%rdi
mov    $0x0,%al
call   1060 <smalloc@plt>
cltq
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1217 <solver+0xd7>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11ee <solver+0xae>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1421 <solver+0x2e1>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    140e <solver+0x2ce>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    -0x44(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1292 <solver+0x152>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf0(%rbp)
jmp    12af <solver+0x16f>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf0(%rbp)
mov    -0xf0(%rbp),%eax
mov    %eax,-0xf4(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    -0x44(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    130b <solver+0x1cb>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf8(%rbp)
jmp    1328 <solver+0x1e8>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xf4(%rbp),%eax
mov    -0xf8(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xfc(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%edx
add    $0x1,%edx
imul   -0x4(%rbp),%edx
add    -0x44(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1398 <solver+0x258>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x100(%rbp)
jmp    13b5 <solver+0x275>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x100(%rbp)
mov    -0xfc(%rbp),%eax
mov    -0x100(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%edx
imul   -0x4(%rbp),%edx
add    -0x44(%rbp),%edx
shl    $0x1,%edx
mov    -0x38(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1236 <solver+0xf6>
jmp    1413 <solver+0x2d3>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    121e <solver+0xde>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    163d <solver+0x4fd>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    162a <solver+0x4ea>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%edx
imul   -0x4(%rbp),%edx
mov    -0x44(%rbp),%esi
add    $0x1,%esi
add    %esi,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    149e <solver+0x35e>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x104(%rbp)
jmp    14bd <solver+0x37d>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0x44(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x104(%rbp)
mov    -0x104(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%edx
imul   -0x4(%rbp),%edx
mov    -0x44(%rbp),%esi
add    $0x1,%esi
add    %esi,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    151b <solver+0x3db>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x10c(%rbp)
jmp    153a <solver+0x3fa>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0x44(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x108(%rbp),%eax
mov    -0x10c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x110(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x48(%rbp),%edx
imul   -0x4(%rbp),%edx
mov    -0x44(%rbp),%esi
add    $0x1,%esi
add    %esi,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    15ac <solver+0x46c>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x114(%rbp)
jmp    15cb <solver+0x48b>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
mov    -0x44(%rbp),%edx
add    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x114(%rbp)
mov    -0x110(%rbp),%eax
mov    -0x114(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x44(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%edx
imul   -0x4(%rbp),%edx
add    -0x44(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
mov    -0x38(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    143b <solver+0x2fb>
jmp    162f <solver+0x4ef>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1428 <solver+0x2e8>
jmp    1642 <solver+0x502>
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ab8 <solver+0x978>
movl   $0x0,-0x74(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    1681 <solver+0x541>
movl   $0x0,-0x4c(%rbp)
jmp    2223 <solver+0x10e3>
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     17eb <solver+0x6ab>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0xfffffffe,(%rax,%rcx,4)
setne  %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
mov    -0x40(%rbp),%eax
mov    -0x38(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    16e4 <solver+0x5a4>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x40(%rbp),%edx
lea    -0x70(%rbp),%rcx
mov    $0x0,%al
call   1050 <find_overlaps@plt>
mov    %eax,-0x74(%rbp)
jmp    17d3 <solver+0x693>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x40(%rbp),%edx
lea    -0x90(%rbp),%rcx
mov    $0x0,%al
call   1050 <find_overlaps@plt>
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x9c(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    17ca <solver+0x68a>
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x94(%rbp),%eax
jge    177d <solver+0x63d>
movslq -0xa0(%rbp),%rax
mov    -0x90(%rbp,%rax,4),%eax
movslq -0x98(%rbp),%rcx
cmp    -0x70(%rbp,%rcx,4),%eax
jne    1764 <solver+0x624>
jmp    177d <solver+0x63d>
jmp    1769 <solver+0x629>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    172e <solver+0x5ee>
mov    -0xa0(%rbp),%eax
cmp    -0x94(%rbp),%eax
jge    17b1 <solver+0x671>
movslq -0x98(%rbp),%rax
mov    -0x70(%rbp,%rax,4),%ecx
mov    -0x9c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x9c(%rbp)
cltq
mov    %ecx,-0x70(%rbp,%rax,4)
jmp    17b6 <solver+0x676>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1715 <solver+0x5d5>
mov    -0x9c(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    17d8 <solver+0x698>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
jmp    168f <solver+0x54f>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1aa5 <solver+0x965>
movslq -0x78(%rbp),%rax
mov    -0x70(%rbp,%rax,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpl   $0xfffffffe,(%rax,%rcx,4)
je     1a92 <solver+0x952>
movl   $0x1,-0x58(%rbp)
mov    -0x40(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xa4(%rbp)
mov    -0x40(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1856 <solver+0x716>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    1865 <solver+0x725>
mov    -0xa4(%rbp),%eax
add    -0x4(%rbp),%eax
mov    %eax,-0x118(%rbp)
mov    -0x118(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0xa8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    18ac <solver+0x76c>
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x11c(%rbp)
jmp    18c0 <solver+0x780>
mov    -0x18(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x11c(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0xa8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1907 <solver+0x7c7>
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x124(%rbp)
jmp    191b <solver+0x7db>
mov    -0x18(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x124(%rbp)
mov    -0x120(%rbp),%eax
mov    -0x124(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x128(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0xa8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1976 <solver+0x836>
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x12c(%rbp)
jmp    198a <solver+0x84a>
mov    -0x18(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x128(%rbp),%eax
mov    -0x12c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0x38(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x40(%rbp),%eax
jne    19d3 <solver+0x893>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1a83 <solver+0x943>
mov    -0x38(%rbp),%rax
movslq -0xac(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x30(%rbp),%rcx
movslq -0xb0(%rbp),%rdx
xor    %eax,%eax
cmpl   $0xffffffff,(%rcx,%rdx,4)
mov    %al,-0x12d(%rbp)
je     1a1e <solver+0x8de>
mov    -0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x40(%rbp),%eax
setne  %al
mov    %al,-0x12d(%rbp)
mov    -0x12d(%rbp),%al
test   $0x1,%al
jne    1a31 <solver+0x8f1>
jmp    1a4a <solver+0x90a>
mov    -0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
jmp    19e7 <solver+0x8a7>
mov    -0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x40(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0xb0(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
movl   $0xfffffffe,(%rax,%rcx,4)
jmp    1a97 <solver+0x957>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    17f2 <solver+0x6b2>
jmp    1aaa <solver+0x96a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1650 <solver+0x510>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1fa6 <solver+0xe66>
mov    -0x3c(%rbp),%eax
cltd
idivl  -0x4(%rbp)
mov    %edx,-0x44(%rbp)
mov    -0x3c(%rbp),%eax
cltd
idivl  -0x4(%rbp)
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x0,-0x44(%rbp)
jle    1b10 <solver+0x9d0>
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
cltq
mov    %ecx,-0xc0(%rbp,%rax,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
cmp    -0x4(%rbp),%eax
jge    1b3c <solver+0x9fc>
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
cltq
mov    %ecx,-0xc0(%rbp,%rax,4)
cmpl   $0x0,-0x48(%rbp)
jle    1b63 <solver+0xa23>
mov    -0x3c(%rbp),%ecx
sub    -0x4(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x40(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
cltq
mov    %ecx,-0xc0(%rbp,%rax,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
cmp    -0x8(%rbp),%eax
jge    1b8c <solver+0xa4c>
mov    -0x3c(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x40(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
cltq
mov    %ecx,-0xc0(%rbp,%rax,4)
movl   $0x0,-0xc4(%rbp)
movl   $0x0,-0xc8(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1c0d <solver+0xacd>
mov    -0x30(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movslq -0xc0(%rbp,%rcx,4),%rcx
ff
cmpl   $0xffffffff,(%rax,%rcx,4)
jl     1bf4 <solver+0xab4>
movslq -0xc4(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%ecx
mov    -0xc8(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0xc8(%rbp)
cltq
mov    %ecx,-0xc0(%rbp,%rax,4)
jmp    1bf9 <solver+0xab9>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1ba0 <solver+0xa60>
movl   $0xffffffff,-0xcc(%rbp)
ff ff ff
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0xc8(%rbp),%eax
jge    1e03 <solver+0xcc3>
movslq -0x40(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xd0(%rbp)
mov    -0xc4(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1c78 <solver+0xb38>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1c87 <solver+0xb47>
mov    -0xd0(%rbp),%eax
add    -0x4(%rbp),%eax
mov    %eax,-0x134(%rbp)
mov    -0x134(%rbp),%eax
mov    %eax,-0xd4(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0xd4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1cce <solver+0xb8e>
mov    -0x18(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x138(%rbp)
jmp    1ce2 <solver+0xba2>
mov    -0x18(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x138(%rbp)
mov    -0x138(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0xd4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1d29 <solver+0xbe9>
mov    -0x18(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x140(%rbp)
jmp    1d3d <solver+0xbfd>
mov    -0x18(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x140(%rbp)
mov    -0x13c(%rbp),%eax
mov    -0x140(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x144(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0xd4(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1d98 <solver+0xc58>
mov    -0x18(%rbp),%rax
movslq -0xd0(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x148(%rbp)
jmp    1dac <solver+0xc6c>
mov    -0x18(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x148(%rbp)
mov    -0x144(%rbp),%eax
mov    -0x148(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xd8(%rbp)
cmpl   $0xffffffff,-0xcc(%rbp)
jne    1dd9 <solver+0xc99>
mov    -0xd8(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0xd8(%rbp),%eax
je     1df0 <solver+0xcb0>
jmp    1e03 <solver+0xcc3>
jmp    1df5 <solver+0xcb5>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1c1e <solver+0xade>
mov    -0x40(%rbp),%eax
cmp    -0xc8(%rbp),%eax
jne    1f93 <solver+0xe53>
cmpl   $0x0,-0xcc(%rbp)
setge  %al
and    $0x1,%al
movzbl %al,%edi
mov    $0x0,%al
call   1040 <assert@plt>
movl   $0x0,-0xdc(%rbp)
mov    -0x38(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc4(%rbp)
cmpl   $0x0,-0xc4(%rbp)
jl     1e7b <solver+0xd3b>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
mov    -0x30(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc4(%rbp)
jmp    1e46 <solver+0xd06>
mov    -0xdc(%rbp),%eax
cmp    -0xc8(%rbp),%eax
jle    1f8e <solver+0xe4e>
movl   $0x1,-0x58(%rbp)
mov    -0x38(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc4(%rbp)
cmpl   $0x0,-0xc4(%rbp)
jl     1eec <solver+0xdac>
mov    -0x30(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xe0(%rbp)
mov    -0x30(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movl   $0xfffffffe,(%rax,%rcx,4)
mov    -0xe0(%rbp),%eax
mov    %eax,-0xc4(%rbp)
jmp    1ea8 <solver+0xd68>
mov    -0xc0(%rbp),%edx
mov    -0x38(%rbp),%rax
movslq -0xcc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xc8(%rbp),%eax
jge    1f89 <solver+0xe49>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
cmp    -0xc8(%rbp),%eax
jne    1f41 <solver+0xe01>
mov    $0xffffffff,%eax
mov    %eax,-0x14c(%rbp)
jmp    1f59 <solver+0xe19>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0xc0(%rbp,%rax,4),%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movslq -0xc0(%rbp,%rcx,4),%rcx
ff
mov    %edx,(%rax,%rcx,4)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1f0a <solver+0xdca>
jmp    1f8e <solver+0xe4e>
jmp    1f93 <solver+0xe53>
jmp    1f98 <solver+0xe58>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1abf <solver+0x97f>
cmpl   $0x0,-0x58(%rbp)
jne    1fb5 <solver+0xe75>
jmp    1fba <solver+0xe7a>
jmp    1642 <solver+0x502>
movl   $0x1,-0x4c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    221e <solver+0x10de>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0xfffffffe,(%rax,%rcx,4)
jne    200a <solver+0xeca>
cmpq   $0x0,-0x20(%rbp)
je     2005 <solver+0xec5>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
jmp    220b <solver+0x10cb>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0xfffffffd,(%rax,%rcx,4)
je     2206 <solver+0x10c6>
mov    -0x3c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xe4(%rbp)
mov    -0x3c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     2050 <solver+0xf10>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x150(%rbp)
jmp    205f <solver+0xf1f>
mov    -0xe4(%rbp),%eax
add    -0x4(%rbp),%eax
mov    %eax,-0x150(%rbp)
mov    -0x150(%rbp),%eax
mov    %eax,-0xe8(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0xe8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    20a6 <solver+0xf66>
mov    -0x18(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x154(%rbp)
jmp    20ba <solver+0xf7a>
mov    -0x18(%rbp),%rax
movslq -0xe8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x154(%rbp)
mov    -0x154(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0xe8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    2101 <solver+0xfc1>
mov    -0x18(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x15c(%rbp)
jmp    2115 <solver+0xfd5>
mov    -0x18(%rbp),%rax
movslq -0xe8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x158(%rbp),%eax
mov    -0x15c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x160(%rbp)
mov    -0x18(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0xe8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    2170 <solver+0x1030>
mov    -0x18(%rbp),%rax
movslq -0xe4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x164(%rbp)
jmp    2184 <solver+0x1044>
mov    -0x18(%rbp),%rax
movslq -0xe8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x164(%rbp)
mov    -0x160(%rbp),%eax
mov    -0x164(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x38(%rbp),%rcx
movslq -0xec(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    21e0 <solver+0x10a0>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    21e0 <solver+0x10a0>
cmpq   $0x0,-0x20(%rbp)
je     21db <solver+0x109b>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    2201 <solver+0x10c1>
cmpq   $0x0,-0x20(%rbp)
je     21fa <solver+0x10ba>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x2,-0x4c(%rbp)
jmp    2206 <solver+0x10c6>
jmp    220b <solver+0x10cb>
jmp    2210 <solver+0x10d0>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1fc8 <solver+0xe88>
jmp    2223 <solver+0x10e3>
mov    -0x30(%rbp),%rdi
mov    $0x0,%al
call   1030 <sfree@plt>
mov    -0x38(%rbp),%rdi
mov    $0x0,%al
call   1030 <sfree@plt>
mov    -0x4c(%rbp),%eax
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solver>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r8,0x60(%rsp)
mov    %rcx,%rbx
mov    %rsi,0x28(%rsp)
mov    %esi,%ebp
mov    %rdi,0x10(%rsp)
imul   %edi,%ebp
lea    0x1(%rdx),%eax
add    $0x2,%edx
imul   %eax,%edx
mov    %edx,%r12d
shr    $0x1f,%r12d
mov    %rdx,0x58(%rsp)
add    %edx,%r12d
sar    %r12d
lea    0x0(%rbp,%rbp,1),%eax
mov    %rax,0x50(%rsp)
movslq %eax,%rdi
shl    $0x2,%rdi
xor    %eax,%eax
call   1070 <smalloc@plt>
movslq %eax,%r15
mov    %rbp,0x48(%rsp)
test   %ebp,%ebp
jle    12e1 <solver+0x191>
mov    0x50(%rsp),%rcx
cmp    $0x2,%ecx
mov    $0x1,%eax
cmovge %ecx,%eax
cmp    $0x8,%eax
jae    11d6 <solver+0x86>
xor    %ecx,%ecx
jmp    12d0 <solver+0x180>
mov    %eax,%ecx
and    $0x7ffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x7,%edx
cmp    $0x38,%rdi
jae    11ff <solver+0xaf>
xor    %edi,%edi
jmp    1295 <solver+0x145>
and    $0xfffffffffffffff8,%rsi
xor    %edi,%edi
movaps 0xdf4(%rip),%xmm0
nopl   0x0(%rax)
movups %xmm0,(%r15,%rdi,4)
movups %xmm0,0x10(%r15,%rdi,4)
movups %xmm0,0x20(%r15,%rdi,4)
movups %xmm0,0x30(%r15,%rdi,4)
movups %xmm0,0x40(%r15,%rdi,4)
movups %xmm0,0x50(%r15,%rdi,4)
movups %xmm0,0x60(%r15,%rdi,4)
movups %xmm0,0x70(%r15,%rdi,4)
movups %xmm0,0x80(%r15,%rdi,4)
movups %xmm0,0x90(%r15,%rdi,4)
movups %xmm0,0xa0(%r15,%rdi,4)
movups %xmm0,0xb0(%r15,%rdi,4)
movups %xmm0,0xc0(%r15,%rdi,4)
movups %xmm0,0xd0(%r15,%rdi,4)
movups %xmm0,0xe0(%r15,%rdi,4)
movups %xmm0,0xf0(%r15,%rdi,4)
add    $0x40,%rdi
add    $0xfffffffffffffff8,%rsi
jne    1210 <solver+0xc0>
test   %rdx,%rdx
je     12c2 <solver+0x172>
lea    (%r15,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movaps 0xd51(%rip),%xmm0
nop
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    12b0 <solver+0x160>
cmp    %rax,%rcx
je     12e1 <solver+0x191>
nopw   0x0(%rax,%rax,1)
movl   $0xfffffffd,(%r15,%rcx,4)
ff
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12d0 <solver+0x180>
mov    %rbx,0x20(%rsp)
movslq %r12d,%rdi
shl    $0x2,%rdi
xor    %eax,%eax
call   1070 <smalloc@plt>
cltq
mov    %rax,0x18(%rsp)
cmpl   $0x2,0x58(%rsp)
jl     131e <solver+0x1ce>
lea    -0x1(%r12),%eax
lea    0x4(,%rax,4),%rdx
mov    0x18(%rsp),%rdi
mov    $0xff,%esi
call   1040 <memset@plt>
movslq 0x10(%rsp),%r10
cmpl   $0x2,0x28(%rsp)
jl     13d3 <solver+0x283>
mov    0x28(%rsp),%rax
lea    -0x1(%rax),%r9d
mov    0x10(%rsp),%rax
mov    %eax,%r14d
lea    (%rax,%rax,1),%r8d
add    %r14,%r14
xor    %r13d,%r13d
mov    0x18(%rsp),%rdi
jmp    135c <solver+0x20c>
add    $0x1,%r13
mov    %r13,%r11
cmp    %r9,%r11
je     13d3 <solver+0x283>
cmpl   $0x0,0x10(%rsp)
jle    1350 <solver+0x200>
mov    %r13,%rcx
imul   %r10,%rcx
lea    0x1(%r13),%r11
mov    %r11,%rsi
imul   %r10,%rsi
imul   %r8d,%r13d
mov    0x20(%rsp),%rax
lea    (%rax,%rsi,4),%rbx
lea    (%rax,%rcx,4),%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rcx,2),%eax
mov    (%rbx,%rcx,2),%ebp
cmp    %ebp,%eax
mov    %ebp,%edx
cmovg  %eax,%edx
cmovl  %eax,%ebp
lea    0x1(%rdx),%eax
imul   %edx,%eax
mov    %eax,%edx
shr    $0x1f,%edx
add    %eax,%edx
sar    %edx
add    %ebp,%edx
movslq %edx,%rax
mov    (%rdi,%rax,4),%edx
lea    (%rcx,%r13,1),%rbp
movslq %ebp,%rbp
mov    %edx,(%r15,%rbp,4)
mov    %ebp,(%rdi,%rax,4)
add    $0x2,%rcx
cmp    %rcx,%r14
jne    1390 <solver+0x240>
mov    %r11,%r13
jmp    1357 <solver+0x207>
cmpl   $0x0,0x28(%rsp)
jle    1475 <solver+0x325>
mov    0x10(%rsp),%rax
lea    -0x1(%rax),%ecx
mov    0x28(%rsp),%r8d
lea    (%rax,%rax,1),%r9d
mov    0x20(%rsp),%rax
lea    0x4(%rax),%rdi
shl    $0x2,%r10
add    %rcx,%rcx
xor    %r11d,%r11d
xor    %r14d,%r14d
mov    0x18(%rsp),%r13
jmp    141f <solver+0x2cf>
nopl   0x0(%rax)
add    $0x1,%r14
add    %r9d,%r11d
add    %r10,%rdi
cmp    %r8,%r14
je     1475 <solver+0x325>
cmpl   $0x2,0x10(%rsp)
jl     1410 <solver+0x2c0>
mov    %r11d,%edx
add    $0x1,%rdx
xor    %esi,%esi
nop
mov    -0x4(%rdi,%rsi,2),%eax
mov    (%rdi,%rsi,2),%ebp
cmp    %ebp,%eax
mov    %ebp,%ebx
cmovg  %eax,%ebx
cmovl  %eax,%ebp
lea    0x1(%rbx),%eax
imul   %ebx,%eax
mov    %eax,%ebx
shr    $0x1f,%ebx
add    %eax,%ebx
sar    %ebx
add    %ebp,%ebx
movslq %ebx,%rax
mov    0x0(%r13,%rax,4),%ebx
lea    (%rdx,%rsi,1),%rbp
movslq %ebp,%rbp
mov    %ebx,(%r15,%rbp,4)
mov    %ebp,0x0(%r13,%rax,4)
add    $0x2,%rsi
cmp    %rsi,%rcx
jne    1430 <solver+0x2e0>
jmp    1410 <solver+0x2c0>
mov    %r12d,%eax
mov    %rax,0x68(%rsp)
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r10
jmp    1498 <solver+0x348>
nopl   0x0(%rax)
test   %edx,%edx
je     19ab <solver+0x85b>
mov    $0x0,%edx
cmpl   $0x2,0x58(%rsp)
jl     16a0 <solver+0x550>
xor    %r13d,%r13d
xor    %edx,%edx
jmp    14cd <solver+0x37d>
nop
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r10
mov    0xc(%rsp),%edx
add    $0x1,%r13
cmp    0x68(%rsp),%r13
je     16a0 <solver+0x550>
mov    (%r10,%r13,4),%ebx
cmp    $0xffffffff,%ebx
je     197c <solver+0x82c>
test   %ebx,%ebx
js     14be <solver+0x36e>
mov    %edx,0xc(%rsp)
xor    %r12d,%r12d
jmp    1518 <solver+0x3c8>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    %r14d,%edx
lea    0x30(%rsp),%rcx
xor    %eax,%eax
call   1060 <find_overlaps@plt>
mov    %eax,%r12d
mov    (%r15,%r14,4),%ebx
test   %ebx,%ebx
js     15b0 <solver+0x460>
mov    %ebx,%r14d
xor    %edi,%edi
cmpl   $0xfffffffe,(%r15,%r14,4)
setne  %dil
xor    %eax,%eax
call   1050 <assert@plt>
mov    0x18(%rsp),%rax
cmp    (%rax,%r13,4),%ebx
je     14f0 <solver+0x3a0>
xor    %ebx,%ebx
mov    0x10(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    %r14d,%edx
lea    0x70(%rsp),%rcx
xor    %eax,%eax
call   1060 <find_overlaps@plt>
test   %r12d,%r12d
jg     155d <solver+0x40d>
mov    %ebx,%r12d
jmp    150c <solver+0x3bc>
mov    %r12d,%ecx
mov    %eax,%edx
xor    %esi,%esi
xor    %ebx,%ebx
jmp    1583 <solver+0x433>
nopl   0x0(%rax,%rax,1)
movslq %ebx,%rbp
add    $0x1,%ebx
mov    %edi,0x30(%rsp,%rbp,4)
add    $0x1,%rsi
cmp    %rcx,%rsi
je     1558 <solver+0x408>
test   %eax,%eax
jle    157a <solver+0x42a>
mov    0x30(%rsp,%rsi,4),%edi
xor    %ebp,%ebp
nopl   (%rax)
cmp    %edi,0x70(%rsp,%rbp,4)
je     1570 <solver+0x420>
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1590 <solver+0x440>
jmp    157a <solver+0x42a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r12d,%r12d
jle    14b0 <solver+0x360>
mov    %r12d,%ebx
xor    %ebp,%ebp
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%r10
mov    0xc(%rsp),%edx
jmp    15f3 <solver+0x4a3>
xchg   %ax,%ax
mov    %eax,(%r10,%rdx,4)
mov    0x20(%rsp),%r14
movl   $0xfffffffe,(%r15,%r12,4)
ff
mov    $0x1,%edx
add    $0x1,%rbp
cmp    %rbx,%rbp
je     14be <solver+0x36e>
movslq 0x30(%rsp,%rbp,4),%r12
mov    (%r15,%r12,4),%eax
cmp    $0xfffffffe,%eax
je     15e6 <solver+0x496>
mov    %r12d,%ecx
shr    $0x1f,%ecx
add    %r12d,%ecx
sar    %ecx
test   $0x1,%r12b
mov    $0x1,%edx
cmove  0x10(%rsp),%edx
add    %ecx,%edx
movslq %ecx,%rcx
mov    (%r14,%rcx,4),%ecx
movslq %edx,%rdx
mov    (%r14,%rdx,4),%edx
cmp    %edx,%ecx
mov    %edx,%esi
cmovg  %ecx,%esi
cmovl  %ecx,%edx
lea    0x1(%rsi),%ecx
imul   %esi,%ecx
mov    %ecx,%esi
shr    $0x1f,%esi
add    %ecx,%esi
sar    %esi
add    %edx,%esi
movslq %esi,%rdx
mov    (%r10,%rdx,4),%ecx
cmp    %r12d,%ecx
je     15d0 <solver+0x480>
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ecx,%r14
mov    (%r15,%r14,4),%ecx
cmp    $0xffffffff,%ecx
je     1671 <solver+0x521>
cmp    %r12d,%ecx
jne    1660 <solver+0x510>
xor    %edi,%edi
cmp    %r12d,%ecx
sete   %dil
xor    %eax,%eax
call   1050 <assert@plt>
mov    0x18(%rsp),%r10
mov    (%r15,%r12,4),%eax
mov    %eax,(%r15,%r14,4)
jmp    15d4 <solver+0x484>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpl   $0x0,0x48(%rsp)
jle    1490 <solver+0x340>
xor    %r13d,%r13d
jmp    16cf <solver+0x57f>
movslq 0x30(%rsp,%rbp,4),%rax
mov    %ecx,(%r15,%rax,4)
nopl   0x0(%rax)
add    $0x1,%r13d
cmp    0x48(%rsp),%r13d
je     1490 <solver+0x340>
mov    %edx,0xc(%rsp)
mov    %r13d,%eax
cltd
idivl  0x10(%rsp)
mov    $0x0,%esi
test   %edx,%edx
je     16f2 <solver+0x5a2>
lea    -0x1(%r13,%r13,1),%ecx
mov    %ecx,0x30(%rsp)
mov    $0x1,%esi
add    $0x1,%edx
cmp    0x10(%rsp),%edx
jge    1709 <solver+0x5b9>
lea    0x1(%r13,%r13,1),%ecx
mov    %esi,%edx
add    $0x1,%esi
mov    %ecx,0x30(%rsp,%rdx,4)
test   %eax,%eax
jle    171f <solver+0x5cf>
mov    %r13d,%ecx
sub    0x10(%rsp),%ecx
add    %ecx,%ecx
mov    %esi,%edx
add    $0x1,%esi
mov    %ecx,0x30(%rsp,%rdx,4)
add    $0x1,%eax
cmp    0x28(%rsp),%eax
jge    1740 <solver+0x5f0>
lea    0x0(%r13,%r13,1),%eax
mov    %esi,%ecx
add    $0x1,%esi
mov    %eax,0x30(%rsp,%rcx,4)
jmp    1748 <solver+0x5f8>
nopl   0x0(%rax,%rax,1)
test   %esi,%esi
je     1858 <solver+0x708>
mov    %esi,%ecx
cmp    $0x1,%esi
jne    17f0 <solver+0x6a0>
xor    %edx,%edx
xor    %eax,%eax
test   $0x1,%cl
je     1772 <solver+0x622>
movslq 0x30(%rsp,%rdx,4),%rcx
cmpl   $0xffffffff,(%r15,%rcx,4)
jl     1772 <solver+0x622>
movslq %eax,%rdx
add    $0x1,%eax
mov    %ecx,0x30(%rsp,%rdx,4)
mov    %eax,%ebx
test   %eax,%eax
setg   %r12b
jle    1840 <solver+0x6f0>
mov    $0xffffffff,%ecx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    %ecx,%ebp
mov    0x30(%rsp,%rax,4),%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
add    %ecx,%edx
sar    %edx
test   $0x1,%cl
mov    $0x1,%ecx
cmove  0x10(%rsp),%ecx
add    %edx,%ecx
movslq %edx,%rdx
mov    (%r14,%rdx,4),%edx
movslq %ecx,%rcx
mov    (%r14,%rcx,4),%esi
cmp    %esi,%edx
mov    %esi,%ecx
cmovg  %edx,%ecx
cmovl  %edx,%esi
lea    0x1(%rcx),%edx
imul   %ecx,%edx
mov    %edx,%ecx
shr    $0x1f,%ecx
add    %edx,%ecx
sar    %ecx
add    %esi,%ecx
cmp    $0xffffffff,%ebp
cmove  %ecx,%ebp
cmp    %ecx,%ebp
jne    184a <solver+0x6fa>
add    $0x1,%rax
cmp    %rax,%rbx
jne    1790 <solver+0x640>
mov    %ecx,%ebp
jmp    1862 <solver+0x712>
xchg   %ax,%ax
mov    %ecx,%esi
and    $0xfffffffe,%esi
xor    %edx,%edx
xor    %eax,%eax
jmp    180d <solver+0x6bd>
nopl   0x0(%rax,%rax,1)
add    $0x2,%rdx
cmp    %rdx,%rsi
je     1757 <solver+0x607>
movslq 0x30(%rsp,%rdx,4),%rdi
cmpl   $0xffffffff,(%r15,%rdi,4)
jl     1823 <solver+0x6d3>
movslq %eax,%rbp
add    $0x1,%eax
mov    %edi,0x30(%rsp,%rbp,4)
movslq 0x34(%rsp,%rdx,4),%rdi
cmpl   $0xffffffff,(%r15,%rdi,4)
jl     1800 <solver+0x6b0>
movslq %eax,%rbp
add    $0x1,%eax
mov    %edi,0x30(%rsp,%rbp,4)
jmp    1800 <solver+0x6b0>
nopl   0x0(%rax,%rax,1)
xor    %r12d,%r12d
mov    $0xffffffff,%ebp
xor    %eax,%eax
mov    0xc(%rsp),%edx
cmp    %ebx,%eax
jne    16c0 <solver+0x570>
jmp    1862 <solver+0x712>
xor    %ebx,%ebx
mov    $0xffffffff,%ebp
xor    %r12d,%r12d
mov    %ebp,%edi
not    %edi
shr    $0x1f,%edi
xor    %eax,%eax
call   1050 <assert@plt>
movslq %ebp,%rax
mov    0x18(%rsp),%r10
mov    (%r10,%rax,4),%ecx
test   %ecx,%ecx
js     18d0 <solver+0x780>
mov    $0xffffffff,%edx
mov    %ecx,%esi
nopw   0x0(%rax,%rax,1)
mov    %esi,%esi
mov    (%r15,%rsi,4),%esi
add    $0x1,%edx
test   %esi,%esi
jns    1890 <solver+0x740>
cmp    %ebx,%edx
mov    0xc(%rsp),%edx
jl     16c0 <solver+0x570>
nopl   0x0(%rax)
test   %ecx,%ecx
js     18dc <solver+0x78c>
mov    %ecx,%edx
mov    (%r15,%rdx,4),%ecx
movl   $0xfffffffe,(%r15,%rdx,4)
ff
test   %ecx,%ecx
jns    18b4 <solver+0x764>
jmp    18dc <solver+0x78c>
nopl   0x0(%rax,%rax,1)
test   %ebx,%ebx
mov    0xc(%rsp),%edx
jns    16c0 <solver+0x570>
mov    0x30(%rsp),%ecx
mov    %ecx,(%r10,%rax,4)
mov    $0x1,%edx
test   %r12b,%r12b
je     16c0 <solver+0x570>
mov    %ebx,%r8d
cmp    $0x1,%ebx
jne    190c <solver+0x7bc>
xor    %ebp,%ebp
test   $0x1,%r8b
jne    195c <solver+0x80c>
mov    $0x1,%edx
jmp    16c0 <solver+0x570>
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
lea    -0x1(%r8),%rsi
lea    -0x2(%r8),%rdi
xor    %edx,%edx
jmp    1931 <solver+0x7e1>
xchg   %ax,%ax
movslq 0x34(%rsp,%rdx,4),%rax
mov    %ebx,(%r15,%rax,4)
mov    %rbp,%rdx
cmp    %rbp,%rcx
je     18fc <solver+0x7ac>
mov    $0xffffffff,%ebx
mov    $0xffffffff,%ebp
cmp    %rdx,%rsi
je     1944 <solver+0x7f4>
mov    0x34(%rsp,%rdx,4),%ebp
movslq 0x30(%rsp,%rdx,4),%rax
mov    %ebp,(%r15,%rax,4)
lea    0x2(%rdx),%rbp
cmp    %rdx,%rdi
je     1920 <solver+0x7d0>
mov    0x38(%rsp,%rdx,4),%ebx
jmp    1920 <solver+0x7d0>
lea    0x1(%rbp),%rax
mov    $0xffffffff,%ecx
cmp    %r8,%rax
mov    $0x1,%edx
je     16b0 <solver+0x560>
mov    0x34(%rsp,%rbp,4),%ecx
jmp    16b0 <solver+0x560>
xor    %r14d,%r14d
mov    %r15,%rdi
xor    %eax,%eax
mov    %r10,%rbx
call   1030 <sfree@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   1030 <sfree@plt>
mov    %r14d,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmpl   $0x0,0x48(%rsp)
jle    1a63 <solver+0x913>
mov    0x50(%rsp),%r9
cmp    $0x2,%r9d
mov    $0x1,%r14d
cmovl  %r14d,%r9d
xor    %eax,%eax
mov    $0x2,%r8d
mov    0x60(%rsp),%rbp
jmp    19f7 <solver+0x8a7>
nopl   0x0(%rax,%rax,1)
mov    $0xffffffff,%edx
test   %rbp,%rbp
je     19ee <solver+0x89e>
mov    %edx,0x0(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r9
je     197f <solver+0x82f>
mov    (%r15,%rax,4),%edx
cmp    $0xfffffffd,%edx
je     19ee <solver+0x89e>
cmp    $0xfffffffe,%edx
je     19e0 <solver+0x890>
mov    %eax,%esi
shr    %esi
test   $0x1,%al
mov    $0x1,%edi
cmove  0x10(%rsp),%edi
add    %esi,%edi
mov    0x20(%rsp),%rcx
mov    (%rcx,%rsi,4),%esi
movslq %edi,%rdi
mov    (%rcx,%rdi,4),%edi
cmp    %edi,%esi
mov    %edi,%ebx
cmovg  %esi,%ebx
cmovl  %esi,%edi
lea    0x1(%rbx),%ecx
imul   %ebx,%ecx
mov    %ecx,%esi
shr    $0x1f,%esi
add    %ecx,%esi
sar    %esi
add    %edi,%esi
movslq %esi,%rcx
mov    (%r10,%rcx,4),%ecx
cmp    %rcx,%rax
sete   %cl
cmp    $0xffffffff,%edx
sete   %dl
and    %cl,%dl
cmove  %r8d,%r14d
test   %rbp,%rbp
je     19ee <solver+0x89e>
movzbl %dl,%edx
jmp    19ea <solver+0x89a>
mov    $0x1,%r14d
jmp    197f <solver+0x82f>

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

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