int _glp_okalg(int nv, int na, const int tail[], const int head[],
               const int low[], const int cap[], const int cost[], int x[],
               int pi[]) {
  int a, aok, delta, i, j, k, lambda, pos1, pos2, s, t, temp, ret, *ptr, *arc,
      *link, *list;
  ((void)((nv >= 0) ||
          (glp_assert_(
               "nv >= 0",
               "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
               "outputs/2022-01-22/02-19-57/repos/MarhesLab/NeeleyThesisCode/"
               "refs/heads/master/lib/glpk-4.52/src/misc/okalg.c",
               105),
           1)));
  ((void)((na >= 0) ||
          (glp_assert_(
               "na >= 0",
               "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
               "outputs/2022-01-22/02-19-57/repos/MarhesLab/NeeleyThesisCode/"
               "refs/heads/master/lib/glpk-4.52/src/misc/okalg.c",
               106),
           1)));
  for (a = 1; a <= na; a++) {
    i = tail[a], j = head[a];
    ((void)((1 <= i && i <= nv) ||
            (glp_assert_(
                 "1 <= i && i <= nv",
                 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                 "outputs/2022-01-22/02-19-57/repos/MarhesLab/NeeleyThesisCode/"
                 "refs/heads/master/lib/glpk-4.52/src/misc/okalg.c",
                 109),
             1)));
    ((void)((1 <= j && j <= nv) ||
            (glp_assert_(
                 "1 <= j && j <= nv",
                 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                 "outputs/2022-01-22/02-19-57/repos/MarhesLab/NeeleyThesisCode/"
                 "refs/heads/master/lib/glpk-4.52/src/misc/okalg.c",
                 110),
             1)));
    ((void)((i != j) ||
            (glp_assert_(
                 "i != j",
                 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                 "outputs/2022-01-22/02-19-57/repos/MarhesLab/NeeleyThesisCode/"
                 "refs/heads/master/lib/glpk-4.52/src/misc/okalg.c",
                 111),
             1)));
    ((void)((0 <= low[a] && low[a] <= cap[a]) ||
            (glp_assert_(
                 "0 <= low[a] && low[a] <= cap[a]",
                 "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                 "outputs/2022-01-22/02-19-57/repos/MarhesLab/NeeleyThesisCode/"
                 "refs/heads/master/lib/glpk-4.52/src/misc/okalg.c",
                 112),
             1)));
  }
  ptr = glp_alloc(1 + nv + 1, sizeof(int));
  arc = glp_alloc(1 + na + na, sizeof(int));
  link = glp_alloc(1 + nv, sizeof(int));
  list = glp_alloc(1 + nv, sizeof(int));
  for (i = 1; i <= nv; i++)
    ptr[i] = 0;
  for (a = 1; a <= na; a++) {
    ptr[tail[a]]++;
    ptr[head[a]]++;
  }
  ptr[1]++;
  for (i = 1; i < nv; i++)
    ptr[i + 1] += ptr[i];
  ptr[nv + 1] = ptr[nv];
  for (a = 1; a <= na; a++) {
    arc[--ptr[tail[a]]] = a;
    arc[--ptr[head[a]]] = a;
  }
  ((void)((ptr[1] == 1) ||
          (glp_assert_(
               "ptr[1] == 1",
               "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
               "outputs/2022-01-22/02-19-57/repos/MarhesLab/NeeleyThesisCode/"
               "refs/heads/master/lib/glpk-4.52/src/misc/okalg.c",
               136),
           1)));
  ((void)((ptr[nv + 1] == na + na + 1) ||
          (glp_assert_(
               "ptr[nv+1] == na+na+1",
               "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
               "outputs/2022-01-22/02-19-57/repos/MarhesLab/NeeleyThesisCode/"
               "refs/heads/master/lib/glpk-4.52/src/misc/okalg.c",
               137),
           1)));
  for (a = 1; a <= na; a++)
    x[a] = 0;
  for (i = 1; i <= nv; i++)
    pi[i] = 0;
loop:
  aok = 0;
  for (a = 1; a <= na; a++) {
    i = tail[a], j = head[a];
    if (overflow(cost[a], pi[i] - pi[j])) {
      ret = 2;
      goto done;
    }
    lambda = cost[a] + (pi[i] - pi[j]);
    if (x[a] < low[a] || (lambda < 0 && x[a] < cap[a])) {
      aok = a, s = j, t = i;
      break;
    }
    if (x[a] > cap[a] || (lambda > 0 && x[a] > low[a])) {
      aok = a, s = i, t = j;
      break;
    }
  }
  if (aok == 0) {
    for (a = 1; a <= na; a++) {
      if (!(low[a] <= x[a] && x[a] <= cap[a])) {
        ret = 3;
        goto done;
      }
    }
    for (i = 1; i <= nv; i++) {
      temp = 0;
      for (k = ptr[i]; k < ptr[i + 1]; k++) {
        a = arc[k];
        if (tail[a] == i) {
          temp += x[a];
        } else if (head[a] == i) {
          temp -= x[a];
        } else
          ((void)((a != a) ||
                  (glp_assert_("a != a",
                               "/scratch/repos/new/home/jordi_armengol_estape/"
                               "c-scraper/outputs/2022-01-22/02-19-57/repos/"
                               "MarhesLab/NeeleyThesisCode/refs/heads/master/"
                               "lib/glpk-4.52/src/misc/okalg.c",
                               190),
                   1)));
      }
      if (temp != 0) {
        ret = 3;
        goto done;
      }
    }
    for (a = 1; a <= na; a++) {
      i = tail[a], j = head[a];
      lambda = cost[a] + (pi[i] - pi[j]);
      if ((lambda > 0 && x[a] != low[a]) || (lambda < 0 && x[a] != cap[a])) {
        ret = 3;
        goto done;
      }
    }
    ret = 0;
    goto done;
  }
  for (i = 1; i <= nv; i++)
    link[i] = 0;
  link[s] = aok, list[1] = s, pos1 = pos2 = 1;
  while (pos1 <= pos2) {
    i = list[pos1++];
    for (k = ptr[i]; k < ptr[i + 1]; k++) {
      a = arc[k];
      if (tail[a] == i) {
        j = head[a];
        if (link[j] != 0)
          continue;
        if (x[a] >= cap[a])
          continue;
        if (overflow(cost[a], pi[i] - pi[j])) {
          ret = 2;
          goto done;
        }
        lambda = cost[a] + (pi[i] - pi[j]);
        if (lambda > 0 && x[a] >= low[a])
          continue;
      } else if (head[a] == i) {
        j = tail[a];
        if (link[j] != 0)
          continue;
        if (x[a] <= low[a])
          continue;
        if (overflow(cost[a], pi[j] - pi[i])) {
          ret = 2;
          goto done;
        }
        lambda = cost[a] + (pi[j] - pi[i]);
        if (lambda < 0 && x[a] <= cap[a])
          continue;
      } else
        ((void)((a != a) ||
                (glp_assert_("a != a",
                             "/scratch/repos/new/home/jordi_armengol_estape/"
                             "c-scraper/outputs/2022-01-22/02-19-57/repos/"
                             "MarhesLab/NeeleyThesisCode/refs/heads/master/lib/"
                             "glpk-4.52/src/misc/okalg.c",
                             258),
                 1)));
      link[j] = a, list[++pos2] = j;
      if (j == t)
        goto brkt;
    }
  }
  delta = 0;
  for (a = 1; a <= na; a++) {
    i = tail[a], j = head[a];
    if (link[i] != 0 && link[j] == 0) {
      if (overflow(cost[a], pi[i] - pi[j])) {
        ret = 2;
        goto done;
      }
      lambda = cost[a] + (pi[i] - pi[j]);
      if (x[a] <= cap[a] && lambda > 0)
        if (delta == 0 || delta > +lambda)
          delta = +lambda;
    } else if (link[i] == 0 && link[j] != 0) {
      if (overflow(cost[a], pi[i] - pi[j])) {
        ret = 2;
        goto done;
      }
      lambda = cost[a] + (pi[i] - pi[j]);
      if (x[a] >= low[a] && lambda < 0)
        if (delta == 0 || delta > -lambda)
          delta = -lambda;
    }
  }
  if (delta == 0) {
    ret = 1;
    goto done;
  }
  for (i = 1; i <= nv; i++) {
    if (link[i] == 0) {
      if (overflow(pi[i], delta)) {
        ret = 2;
        goto done;
      }
      pi[i] += delta;
    }
  }
  goto loop;
brkt:
  delta = 0;
  for (j = t;; j = i) {
    a = link[j];
    if (head[a] == j) {
      i = tail[a];
      lambda = cost[a] + (pi[i] - pi[j]);
      if (lambda > 0 && x[a] < low[a]) {
        temp = low[a] - x[a];
      } else if (lambda <= 0 && x[a] < cap[a]) {
        temp = cap[a] - x[a];
      } else
        ((void)((a != a) ||
                (glp_assert_("a != a",
                             "/scratch/repos/new/home/jordi_armengol_estape/"
                             "c-scraper/outputs/2022-01-22/02-19-57/repos/"
                             "MarhesLab/NeeleyThesisCode/refs/heads/master/lib/"
                             "glpk-4.52/src/misc/okalg.c",
                             328),
                 1)));
    } else if (tail[a] == j) {
      i = head[a];
      lambda = cost[a] + (pi[j] - pi[i]);
      if (lambda < 0 && x[a] > cap[a]) {
        temp = x[a] - cap[a];
      } else if (lambda >= 0 && x[a] > low[a]) {
        temp = x[a] - low[a];
      } else
        ((void)((a != a) ||
                (glp_assert_("a != a",
                             "/scratch/repos/new/home/jordi_armengol_estape/"
                             "c-scraper/outputs/2022-01-22/02-19-57/repos/"
                             "MarhesLab/NeeleyThesisCode/refs/heads/master/lib/"
                             "glpk-4.52/src/misc/okalg.c",
                             343),
                 1)));
    } else
      ((void)((a != a) ||
              (glp_assert_("a != a",
                           "/scratch/repos/new/home/jordi_armengol_estape/"
                           "c-scraper/outputs/2022-01-22/02-19-57/repos/"
                           "MarhesLab/NeeleyThesisCode/refs/heads/master/lib/"
                           "glpk-4.52/src/misc/okalg.c",
                           346),
               1)));
    if (delta == 0 || delta > temp)
      delta = temp;
    if (i == t)
      break;
  }
  ((void)((delta > 0) ||
          (glp_assert_(
               "delta > 0",
               "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
               "outputs/2022-01-22/02-19-57/repos/MarhesLab/NeeleyThesisCode/"
               "refs/heads/master/lib/glpk-4.52/src/misc/okalg.c",
               351),
           1)));
  for (j = t;; j = i) {
    a = link[j];
    if (head[a] == j) {
      i = tail[a];
      x[a] += delta;
    } else if (tail[a] == j) {
      i = head[a];
      x[a] -= delta;
    } else
      ((void)((a != a) ||
              (glp_assert_("a != a",
                           "/scratch/repos/new/home/jordi_armengol_estape/"
                           "c-scraper/outputs/2022-01-22/02-19-57/repos/"
                           "MarhesLab/NeeleyThesisCode/refs/heads/master/lib/"
                           "glpk-4.52/src/misc/okalg.c",
                           369),
               1)));
    if (i == t)
      break;
  }
  goto loop;
done:
  glp_free(ptr);
  glp_free(arc);
  glp_free(link);
  glp_free(list);
  return ret;
}


x86 assembly (clang, -O0):
<_glp_okalg>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    $0x1,%al
cmpl   $0x0,-0x4(%rbp)
mov    %al,-0x81(%rbp)
jge    11a1 <_glp_okalg+0x61>
lea    0x1e7a(%rip),%rdi
lea    0x1e7b(%rip),%rsi
mov    $0x69,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
mov    $0x1,%al
cmpl   $0x0,-0x8(%rbp)
mov    %al,-0x82(%rbp)
jge    11db <_glp_okalg+0x9b>
lea    0x1eee(%rip),%rdi
lea    0x1e41(%rip),%rsi
mov    $0x6a,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x82(%rbp)
mov    -0x82(%rbp),%al
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     134d <_glp_okalg+0x20d>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    $0x1,%eax
cmp    -0x38(%rbp),%eax
jg     1232 <_glp_okalg+0xf2>
mov    -0x38(%rbp),%ecx
mov    $0x1,%al
cmp    -0x4(%rbp),%ecx
mov    %al,-0x83(%rbp)
jle    1254 <_glp_okalg+0x114>
lea    0x1e7d(%rip),%rdi
lea    0x1dc8(%rip),%rsi
mov    $0x6d,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x83(%rbp)
mov    -0x83(%rbp),%al
mov    $0x1,%eax
cmp    -0x3c(%rbp),%eax
jg     127c <_glp_okalg+0x13c>
mov    -0x3c(%rbp),%ecx
mov    $0x1,%al
cmp    -0x4(%rbp),%ecx
mov    %al,-0x84(%rbp)
jle    129e <_glp_okalg+0x15e>
lea    0x1e45(%rip),%rdi
lea    0x1d7e(%rip),%rsi
mov    $0x6e,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x84(%rbp)
mov    -0x84(%rbp),%al
mov    -0x38(%rbp),%ecx
mov    $0x1,%al
cmp    -0x3c(%rbp),%ecx
mov    %al,-0x85(%rbp)
jne    12da <_glp_okalg+0x19a>
lea    0x1e1b(%rip),%rdi
lea    0x1d42(%rip),%rsi
mov    $0x6f,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x85(%rbp)
mov    -0x85(%rbp),%al
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
jg     1317 <_glp_okalg+0x1d7>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x28(%rbp),%rdx
movslq -0x2c(%rbp),%rsi
mov    $0x1,%al
cmp    (%rdx,%rsi,4),%ecx
mov    %al,-0x86(%rbp)
jle    1339 <_glp_okalg+0x1f9>
lea    0x1dc3(%rip),%rdi
lea    0x1ce3(%rip),%rsi
mov    $0x70,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x86(%rbp)
mov    -0x86(%rbp),%al
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11e8 <_glp_okalg+0xa8>
mov    -0x4(%rbp),%edi
add    $0x1,%edi
add    $0x1,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1060 <glp_alloc@plt>
cltq
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%edi
add    $0x1,%edi
add    -0x8(%rbp),%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1060 <glp_alloc@plt>
cltq
mov    %rax,-0x70(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1060 <glp_alloc@plt>
cltq
mov    %rax,-0x78(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1060 <glp_alloc@plt>
cltq
mov    %rax,-0x80(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     13e3 <_glp_okalg+0x2a3>
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13ba <_glp_okalg+0x27a>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1436 <_glp_okalg+0x2f6>
mov    -0x68(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13ea <_glp_okalg+0x2aa>
mov    -0x68(%rbp),%rax
mov    0x4(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x4(%rax)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1482 <_glp_okalg+0x342>
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    144a <_glp_okalg+0x30a>
mov    -0x68(%rbp),%rax
movslq -0x4(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x68(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     150a <_glp_okalg+0x3ca>
mov    -0x2c(%rbp),%edx
mov    -0x70(%rbp),%rax
mov    -0x68(%rbp),%rsi
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdi
movslq (%rcx,%rdi,4),%rdi
mov    (%rsi,%rdi,4),%ecx
add    $0xffffffff,%ecx
mov    %ecx,(%rsi,%rdi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x70(%rbp),%rax
mov    -0x68(%rbp),%rsi
mov    -0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdi
movslq (%rcx,%rdi,4),%rdi
mov    (%rsi,%rdi,4),%ecx
add    $0xffffffff,%ecx
mov    %ecx,(%rsi,%rdi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14a4 <_glp_okalg+0x364>
mov    -0x68(%rbp),%rcx
mov    $0x1,%al
cmpl   $0x1,0x4(%rcx)
mov    %al,-0x87(%rbp)
je     1542 <_glp_okalg+0x402>
lea    0x1bda(%rip),%rdi
lea    0x1ada(%rip),%rsi
mov    $0x88,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x87(%rbp)
mov    -0x87(%rbp),%al
mov    -0x68(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%edx
add    -0x8(%rbp),%edx
add    $0x1,%edx
mov    $0x1,%al
cmp    %edx,%ecx
mov    %al,-0x88(%rbp)
je     1593 <_glp_okalg+0x453>
lea    0x1b95(%rip),%rdi
lea    0x1a89(%rip),%rsi
mov    $0x89,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x88(%rbp)
mov    -0x88(%rbp),%al
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     15c9 <_glp_okalg+0x489>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15a0 <_glp_okalg+0x460>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     15f9 <_glp_okalg+0x4b9>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15d0 <_glp_okalg+0x490>
jmp    15fe <_glp_okalg+0x4be>
movl   $0x0,-0x30(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     175c <_glp_okalg+0x61c>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
sub    (%rax,%rcx,4),%esi
mov    $0x0,%al
call   1030 <overflow@plt>
cmp    $0x0,%eax
je     1671 <_glp_okalg+0x531>
movl   $0x2,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    0x20(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     16d9 <_glp_okalg+0x599>
cmpl   $0x0,-0x44(%rbp)
jge    16f0 <_glp_okalg+0x5b0>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    16f0 <_glp_okalg+0x5b0>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    175c <_glp_okalg+0x61c>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1732 <_glp_okalg+0x5f2>
cmpl   $0x0,-0x44(%rbp)
jle    1749 <_glp_okalg+0x609>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1749 <_glp_okalg+0x609>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    175c <_glp_okalg+0x61c>
jmp    174e <_glp_okalg+0x60e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    160c <_glp_okalg+0x4cc>
cmpl   $0x0,-0x30(%rbp)
jne    19be <_glp_okalg+0x87e>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     17d0 <_glp_okalg+0x690>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     17b1 <_glp_okalg+0x671>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    17bd <_glp_okalg+0x67d>
movl   $0x3,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
jmp    17c2 <_glp_okalg+0x682>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    176d <_glp_okalg+0x62d>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     18f2 <_glp_okalg+0x7b2>
movl   $0x0,-0x58(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    18c9 <_glp_okalg+0x789>
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x38(%rbp),%eax
jne    1849 <_glp_okalg+0x709>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    18b6 <_glp_okalg+0x776>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x38(%rbp),%eax
jne    1875 <_glp_okalg+0x735>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x58(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x58(%rbp)
jmp    18b1 <_glp_okalg+0x771>
mov    -0x2c(%rbp),%ecx
mov    $0x1,%al
cmp    -0x2c(%rbp),%ecx
mov    %al,-0x89(%rbp)
jne    18ab <_glp_okalg+0x76b>
lea    0x1892(%rip),%rdi
lea    0x1771(%rip),%rsi
mov    $0xbe,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x89(%rbp)
mov    -0x89(%rbp),%al
jmp    18b6 <_glp_okalg+0x776>
jmp    18bb <_glp_okalg+0x77b>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    17f8 <_glp_okalg+0x6b8>
cmpl   $0x0,-0x58(%rbp)
je     18df <_glp_okalg+0x79f>
movl   $0x3,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
jmp    18e4 <_glp_okalg+0x7a4>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17d7 <_glp_okalg+0x697>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     19b2 <_glp_okalg+0x872>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    0x20(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jle    196d <_glp_okalg+0x82d>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1993 <_glp_okalg+0x853>
cmpl   $0x0,-0x44(%rbp)
jge    199f <_glp_okalg+0x85f>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     199f <_glp_okalg+0x85f>
movl   $0x3,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
jmp    19a4 <_glp_okalg+0x864>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18f9 <_glp_okalg+0x7b9>
movl   $0x0,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     19ee <_glp_okalg+0x8ae>
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19c5 <_glp_okalg+0x885>
mov    -0x30(%rbp),%edx
mov    -0x78(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%ecx
mov    -0x80(%rbp),%rax
mov    %ecx,0x4(%rax)
movl   $0x1,-0x4c(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     1cd5 <_glp_okalg+0xb95>
mov    -0x80(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x48(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x68(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1cd0 <_glp_okalg+0xb90>
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x38(%rbp),%eax
jne    1b5a <_glp_okalg+0xa1a>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1aa6 <_glp_okalg+0x966>
jmp    1cc2 <_glp_okalg+0xb82>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     1ac7 <_glp_okalg+0x987>
jmp    1cc2 <_glp_okalg+0xb82>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
sub    (%rax,%rcx,4),%esi
mov    $0x0,%al
call   1030 <overflow@plt>
cmp    $0x0,%eax
je     1b04 <_glp_okalg+0x9c4>
movl   $0x2,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    0x20(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jle    1b55 <_glp_okalg+0xa15>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     1b55 <_glp_okalg+0xa15>
jmp    1cc2 <_glp_okalg+0xb82>
jmp    1c88 <_glp_okalg+0xb48>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x38(%rbp),%eax
jne    1c47 <_glp_okalg+0xb07>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1b93 <_glp_okalg+0xa53>
jmp    1cc2 <_glp_okalg+0xb82>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1bb4 <_glp_okalg+0xa74>
jmp    1cc2 <_glp_okalg+0xb82>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
sub    (%rax,%rcx,4),%esi
mov    $0x0,%al
call   1030 <overflow@plt>
cmp    $0x0,%eax
je     1bf1 <_glp_okalg+0xab1>
movl   $0x2,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    0x20(%rbp),%rdx
movslq -0x38(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jge    1c42 <_glp_okalg+0xb02>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1c42 <_glp_okalg+0xb02>
jmp    1cc2 <_glp_okalg+0xb82>
jmp    1c83 <_glp_okalg+0xb43>
mov    -0x2c(%rbp),%ecx
mov    $0x1,%al
cmp    -0x2c(%rbp),%ecx
mov    %al,-0x8a(%rbp)
jne    1c7d <_glp_okalg+0xb3d>
lea    0x14c0(%rip),%rdi
lea    0x139f(%rip),%rsi
mov    $0x102,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x8a(%rbp)
mov    -0x8a(%rbp),%al
jmp    1c88 <_glp_okalg+0xb48>
mov    -0x2c(%rbp),%edx
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x80(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jne    1cbd <_glp_okalg+0xb7d>
jmp    1f5d <_glp_okalg+0xe1d>
jmp    1cc2 <_glp_okalg+0xb82>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1a46 <_glp_okalg+0x906>
jmp    1a14 <_glp_okalg+0x8d4>
movl   $0x0,-0x34(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1ecf <_glp_okalg+0xd8f>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1dde <_glp_okalg+0xc9e>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1dde <_glp_okalg+0xc9e>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
sub    (%rax,%rcx,4),%esi
mov    $0x0,%al
call   1030 <overflow@plt>
cmp    $0x0,%eax
je     1d6c <_glp_okalg+0xc2c>
movl   $0x2,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    0x20(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1dd9 <_glp_okalg+0xc99>
cmpl   $0x0,-0x44(%rbp)
jle    1dd9 <_glp_okalg+0xc99>
cmpl   $0x0,-0x34(%rbp)
je     1dce <_glp_okalg+0xc8e>
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jle    1dd4 <_glp_okalg+0xc94>
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1dd9 <_glp_okalg+0xc99>
jmp    1ebc <_glp_okalg+0xd7c>
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1eb7 <_glp_okalg+0xd77>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1eb7 <_glp_okalg+0xd77>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
sub    (%rax,%rcx,4),%esi
mov    $0x0,%al
call   1030 <overflow@plt>
cmp    $0x0,%eax
je     1e3f <_glp_okalg+0xcff>
movl   $0x2,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    0x20(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     1eb2 <_glp_okalg+0xd72>
cmpl   $0x0,-0x44(%rbp)
jge    1eb2 <_glp_okalg+0xd72>
cmpl   $0x0,-0x34(%rbp)
je     1ea5 <_glp_okalg+0xd65>
mov    -0x34(%rbp),%eax
xor    %ecx,%ecx
sub    -0x44(%rbp),%ecx
cmp    %ecx,%eax
jle    1ead <_glp_okalg+0xd6d>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1eb2 <_glp_okalg+0xd72>
jmp    1eb7 <_glp_okalg+0xd77>
jmp    1ebc <_glp_okalg+0xd7c>
jmp    1ec1 <_glp_okalg+0xd81>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1ce3 <_glp_okalg+0xba3>
cmpl   $0x0,-0x34(%rbp)
jne    1ee5 <_glp_okalg+0xda5>
movl   $0x1,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1f58 <_glp_okalg+0xe18>
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1f45 <_glp_okalg+0xe05>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x34(%rbp),%esi
mov    $0x0,%al
call   1030 <overflow@plt>
cmp    $0x0,%eax
je     1f34 <_glp_okalg+0xdf4>
movl   $0x2,-0x5c(%rbp)
jmp    2349 <_glp_okalg+0x1209>
mov    -0x34(%rbp),%edx
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1f4a <_glp_okalg+0xe0a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1eec <_glp_okalg+0xdac>
jmp    15fe <_glp_okalg+0x4be>
movl   $0x0,-0x34(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jne    208e <_glp_okalg+0xf4e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    0x20(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jle    2004 <_glp_okalg+0xec4>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    2004 <_glp_okalg+0xec4>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x58(%rbp)
jmp    2089 <_glp_okalg+0xf49>
cmpl   $0x0,-0x44(%rbp)
jg     2048 <_glp_okalg+0xf08>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    2048 <_glp_okalg+0xf08>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x58(%rbp)
jmp    2084 <_glp_okalg+0xf44>
mov    -0x2c(%rbp),%ecx
mov    $0x1,%al
cmp    -0x2c(%rbp),%ecx
mov    %al,-0x8b(%rbp)
jne    207e <_glp_okalg+0xf3e>
lea    0x10bf(%rip),%rdi
lea    0xf9e(%rip),%rsi
mov    $0x148,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x8b(%rbp)
mov    -0x8b(%rbp),%al
jmp    2089 <_glp_okalg+0xf49>
jmp    21e5 <_glp_okalg+0x10a5>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jne    21a4 <_glp_okalg+0x1064>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x20(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    0x20(%rbp),%rdx
movslq -0x38(%rbp),%rsi
sub    (%rdx,%rsi,4),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jge    211a <_glp_okalg+0xfda>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    211a <_glp_okalg+0xfda>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x58(%rbp)
jmp    219f <_glp_okalg+0x105f>
cmpl   $0x0,-0x44(%rbp)
jl     215e <_glp_okalg+0x101e>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    215e <_glp_okalg+0x101e>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x58(%rbp)
jmp    219a <_glp_okalg+0x105a>
mov    -0x2c(%rbp),%ecx
mov    $0x1,%al
cmp    -0x2c(%rbp),%ecx
mov    %al,-0x8c(%rbp)
jne    2194 <_glp_okalg+0x1054>
lea    0xfa9(%rip),%rdi
lea    0xe88(%rip),%rsi
mov    $0x157,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x8c(%rbp)
mov    -0x8c(%rbp),%al
jmp    219f <_glp_okalg+0x105f>
jmp    21e0 <_glp_okalg+0x10a0>
mov    -0x2c(%rbp),%ecx
mov    $0x1,%al
cmp    -0x2c(%rbp),%ecx
mov    %al,-0x8d(%rbp)
jne    21da <_glp_okalg+0x109a>
lea    0xf63(%rip),%rdi
lea    0xe42(%rip),%rsi
mov    $0x15a,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x8d(%rbp)
mov    -0x8d(%rbp),%al
jmp    21e5 <_glp_okalg+0x10a5>
cmpl   $0x0,-0x34(%rbp)
je     21fb <_glp_okalg+0x10bb>
mov    -0x34(%rbp),%eax
cmp    -0x58(%rbp),%eax
jle    2201 <_glp_okalg+0x10c1>
mov    -0x58(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x54(%rbp),%eax
jne    2212 <_glp_okalg+0x10d2>
jmp    2222 <_glp_okalg+0x10e2>
jmp    2217 <_glp_okalg+0x10d7>
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1f6a <_glp_okalg+0xe2a>
mov    $0x1,%al
cmpl   $0x0,-0x34(%rbp)
mov    %al,-0x8e(%rbp)
jg     2256 <_glp_okalg+0x1116>
lea    0xeee(%rip),%rdi
lea    0xdc6(%rip),%rsi
mov    $0x15f,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x8e(%rbp)
mov    -0x8e(%rbp),%al
mov    -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jne    22a8 <_glp_okalg+0x1168>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    2323 <_glp_okalg+0x11e3>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jne    22e2 <_glp_okalg+0x11a2>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%esi
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
jmp    231e <_glp_okalg+0x11de>
mov    -0x2c(%rbp),%ecx
mov    $0x1,%al
cmp    -0x2c(%rbp),%ecx
mov    %al,-0x8f(%rbp)
jne    2318 <_glp_okalg+0x11d8>
lea    0xe25(%rip),%rdi
lea    0xd04(%rip),%rsi
mov    $0x171,%edx
mov    $0x0,%al
call   1050 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0x8f(%rbp)
mov    -0x8f(%rbp),%al
jmp    2323 <_glp_okalg+0x11e3>
mov    -0x38(%rbp),%eax
cmp    -0x54(%rbp),%eax
jne    2334 <_glp_okalg+0x11f4>
jmp    2344 <_glp_okalg+0x1204>
jmp    2339 <_glp_okalg+0x11f9>
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    2262 <_glp_okalg+0x1122>
jmp    15fe <_glp_okalg+0x4be>
mov    -0x68(%rbp),%rdi
mov    $0x0,%al
call   1040 <glp_free@plt>
mov    -0x70(%rbp),%rdi
mov    $0x0,%al
call   1040 <glp_free@plt>
mov    -0x78(%rbp),%rdi
mov    $0x0,%al
call   1040 <glp_free@plt>
mov    -0x80(%rbp),%rdi
mov    $0x0,%al
call   1040 <glp_free@plt>
mov    -0x5c(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_glp_okalg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,0x48(%rsp)
mov    %r8,0x50(%rsp)
mov    %rcx,0x18(%rsp)
mov    %rdx,0x10(%rsp)
mov    %esi,%r14d
mov    %rdi,0x40(%rsp)
test   %edi,%edi
jns    119b <_glp_okalg+0x4b>
lea    0xe78(%rip),%rdi
lea    0xe79(%rip),%rsi
mov    $0x69,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
test   %r14d,%r14d
mov    %r14,0x38(%rsp)
js     128a <_glp_okalg+0x13a>
sete   0x7(%rsp)
je     12a4 <_glp_okalg+0x154>
lea    0x1(%r14),%r12d
mov    $0x1,%ebx
lea    0xe44(%rip),%rbp
lea    0xf16(%rip),%r14
jmp    11ef <_glp_okalg+0x9f>
nopl   (%rax)
mov    %r14,%rdi
mov    %rbp,%rsi
mov    $0x70,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
add    $0x1,%rbx
cmp    %rbx,%r12
je     1283 <_glp_okalg+0x133>
mov    0x10(%rsp),%rax
mov    (%rax,%rbx,4),%r15d
mov    0x18(%rsp),%rax
mov    (%rax,%rbx,4),%r13d
test   %r15d,%r15d
jle    120d <_glp_okalg+0xbd>
cmp    0x40(%rsp),%r15d
jle    1223 <_glp_okalg+0xd3>
lea    0xea2(%rip),%rdi
mov    %rbp,%rsi
mov    $0x6d,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
test   %r13d,%r13d
jle    122f <_glp_okalg+0xdf>
cmp    0x40(%rsp),%r13d
jle    1245 <_glp_okalg+0xf5>
lea    0xe92(%rip),%rdi
mov    %rbp,%rsi
mov    $0x6e,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
cmp    %r13d,%r15d
jne    1260 <_glp_okalg+0x110>
lea    0xe89(%rip),%rdi
mov    %rbp,%rsi
mov    $0x6f,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
mov    0x50(%rsp),%rax
mov    (%rax,%rbx,4),%eax
test   %eax,%eax
js     11d0 <_glp_okalg+0x80>
mov    0x48(%rsp),%rcx
cmp    (%rcx,%rbx,4),%eax
jg     11d0 <_glp_okalg+0x80>
jmp    11e2 <_glp_okalg+0x92>
mov    0x38(%rsp),%r14
jmp    12a9 <_glp_okalg+0x159>
lea    0xe1d(%rip),%rdi
lea    0xd70(%rip),%rsi
mov    $0x6a,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
movb   $0x1,0x7(%rsp)
mov    0x40(%rsp),%rbp
lea    0x1(%rbp),%ebx
lea    0x2(%rbp),%edi
mov    $0x4,%esi
xor    %eax,%eax
call   1070 <glp_alloc@plt>
movslq %eax,%r12
add    %r14d,%r14d
add    $0x1,%r14d
mov    $0x4,%esi
mov    %r14d,%edi
xor    %eax,%eax
call   1070 <glp_alloc@plt>
mov    %eax,%r15d
mov    $0x4,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1070 <glp_alloc@plt>
mov    %eax,0x30(%rsp)
mov    $0x4,%esi
mov    %ebx,0x24(%rsp)
mov    %ebx,%edi
xor    %eax,%eax
call   1070 <glp_alloc@plt>
mov    %eax,0x70(%rsp)
mov    %ebp,%r13d
test   %ebp,%ebp
jle    131f <_glp_okalg+0x1cf>
lea    0x4(%r12),%rdi
lea    0x0(,%r13,4),%rdx
xor    %esi,%esi
call   1030 <memset@plt>
cmpb   $0x0,0x7(%rsp)
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
mov    %r12,%rdi
jne    13a8 <_glp_okalg+0x258>
mov    0x38(%rsp),%rax
lea    0x1(%rax),%edx
lea    -0x1(%rdx),%rax
mov    $0x1,%ecx
cmp    $0x2,%edx
je     1394 <_glp_okalg+0x244>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%ecx
nopl   0x0(%rax,%rax,1)
movslq (%r9,%rcx,4),%rsi
addl   $0x1,(%rdi,%rsi,4)
movslq (%r8,%rcx,4),%rsi
addl   $0x1,(%rdi,%rsi,4)
movslq 0x4(%r9,%rcx,4),%rsi
addl   $0x1,(%rdi,%rsi,4)
movslq 0x4(%r8,%rcx,4),%rsi
addl   $0x1,(%rdi,%rsi,4)
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    1360 <_glp_okalg+0x210>
test   $0x1,%al
je     13a8 <_glp_okalg+0x258>
movslq (%r9,%rcx,4),%rax
addl   $0x1,(%rdi,%rax,4)
movslq (%r8,%rcx,4),%rax
addl   $0x1,(%rdi,%rax,4)
mov    0x4(%rdi),%eax
add    $0x1,%eax
mov    %eax,0x4(%rdi)
cmpl   $0x2,0x40(%rsp)
jl     142f <_glp_okalg+0x2df>
mov    %r13,%rcx
lea    -0x1(%r13),%rsi
lea    -0x2(%r13),%rbp
mov    %esi,%ecx
and    $0x3,%ecx
mov    $0x1,%edx
cmp    $0x3,%rbp
jb     140d <_glp_okalg+0x2bd>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
nopl   0x0(%rax)
add    0x8(%rdi,%rdx,4),%eax
mov    %eax,0x8(%rdi,%rdx,4)
add    0xc(%rdi,%rdx,4),%eax
mov    %eax,0xc(%rdi,%rdx,4)
add    0x10(%rdi,%rdx,4),%eax
mov    %eax,0x10(%rdi,%rdx,4)
add    0x14(%rdi,%rdx,4),%eax
mov    %eax,0x14(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    13e0 <_glp_okalg+0x290>
add    $0x1,%rdx
test   %rcx,%rcx
je     142f <_glp_okalg+0x2df>
lea    (%rdi,%rdx,4),%rdx
add    $0x4,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
add    (%rdx,%rsi,4),%eax
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1420 <_glp_okalg+0x2d0>
movslq %r15d,%rbx
movslq 0x40(%rsp),%rax
mov    (%rdi,%rax,4),%eax
movslq 0x24(%rsp),%r12
mov    %eax,(%rdi,%r12,4)
cmpb   $0x0,0x7(%rsp)
jne    148f <_glp_okalg+0x33f>
mov    0x38(%rsp),%rax
add    $0x1,%eax
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
movslq (%r9,%rcx,4),%rdx
movslq (%rdi,%rdx,4),%rsi
lea    -0x1(%rsi),%rbp
mov    %ebp,(%rdi,%rdx,4)
mov    %ecx,-0x4(%rbx,%rsi,4)
movslq (%r8,%rcx,4),%rdx
movslq (%rdi,%rdx,4),%rsi
lea    -0x1(%rsi),%rbp
mov    %ebp,(%rdi,%rdx,4)
mov    %ecx,-0x4(%rbx,%rsi,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1460 <_glp_okalg+0x310>
mov    %rbx,0x28(%rsp)
cmpl   $0x1,0x4(%rdi)
mov    %rdi,0x8(%rsp)
je     14c8 <_glp_okalg+0x378>
lea    0xc5b(%rip),%rdi
lea    0xb5b(%rip),%rsi
mov    $0x88,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
cmp    %r14d,(%rdi,%r12,4)
je     14f7 <_glp_okalg+0x3a7>
lea    0xc38(%rip),%rdi
lea    0xb2c(%rip),%rsi
mov    $0x89,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
cmpb   $0x0,0x7(%rsp)
mov    0x38(%rsp),%rbx
jne    152b <_glp_okalg+0x3db>
mov    0xe8(%rsp),%rax
lea    0x4(%rax),%rdi
mov    %ebx,%edx
shl    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
mov    0xf0(%rsp),%rax
cmpl   $0x0,0x40(%rsp)
jle    1565 <_glp_okalg+0x415>
lea    0x4(%rax),%rdi
shl    $0x2,%r13
xor    %esi,%esi
mov    %r13,0x80(%rsp)
mov    %r13,%rdx
call   1030 <memset@plt>
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
jmp    1571 <_glp_okalg+0x421>
shl    $0x2,%r13
mov    %r13,0x80(%rsp)
mov    0x28(%rsp),%r10
mov    0x30(%rsp),%eax
mov    0x70(%rsp),%ecx
cltq
mov    %rax,0x30(%rsp)
movslq %ecx,%rax
mov    %rax,0x68(%rsp)
add    $0x1,%ebx
mov    %rbx,0x38(%rsp)
cmpb   $0x0,0x7(%rsp)
mov    0xf0(%rsp),%r15
je     167c <_glp_okalg+0x52c>
xor    %eax,%eax
mov    0x40(%rsp),%rcx
test   %ecx,%ecx
cmovle %eax,%ecx
add    $0x1,%ecx
mov    %rcx,0x40(%rsp)
mov    $0x1,%ebx
lea    0xb5a(%rip),%r15
lea    0xa39(%rip),%r14
jmp    15ec <_glp_okalg+0x49c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r12,%rbx
test   %r13d,%r13d
jne    1f5a <_glp_okalg+0xe0a>
cmp    0x40(%rsp),%rbx
je     1ee1 <_glp_okalg+0xd91>
movslq (%rdi,%rbx,4),%rbp
lea    0x1(%rbx),%r12
mov    0x4(%rdi,%rbx,4),%eax
xor    %r13d,%r13d
cmp    %eax,%ebp
jge    15e0 <_glp_okalg+0x490>
xor    %r13d,%r13d
jmp    1628 <_glp_okalg+0x4d8>
nop
mov    0xe8(%rsp),%rdx
add    (%rdx,%rcx,4),%r13d
add    $0x1,%rbp
movslq %eax,%rcx
cmp    %rcx,%rbp
jge    15e0 <_glp_okalg+0x490>
movslq (%r10,%rbp,4),%rcx
mov    (%r9,%rcx,4),%edx
cmp    %rdx,%rbx
je     1610 <_glp_okalg+0x4c0>
mov    (%r8,%rcx,4),%edx
cmp    %rdx,%rbx
jne    1650 <_glp_okalg+0x500>
mov    0xe8(%rsp),%rdx
sub    (%rdx,%rcx,4),%r13d
jmp    161c <_glp_okalg+0x4cc>
nopl   0x0(%rax)
mov    %r15,%rdi
mov    %r14,%rsi
mov    $0xbe,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
mov    0x28(%rsp),%r10
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
mov    (%rdi,%r12,4),%eax
jmp    161c <_glp_okalg+0x4cc>
mov    0x30(%rsp),%rax
add    $0x4,%rax
mov    %rax,0x98(%rsp)
mov    0x24(%rsp),%eax
mov    %rax,0xa0(%rsp)
jmp    16ab <_glp_okalg+0x55b>
nopl   0x0(%rax,%rax,1)
cmpb   $0x0,0x7(%rsp)
jne    15a8 <_glp_okalg+0x458>
mov    $0x1,%r14d
mov    (%r9,%r14,4),%eax
mov    (%r8,%r14,4),%edx
mov    0xe0(%rsp),%rcx
mov    (%rcx,%r14,4),%edi
mov    %eax,0x24(%rsp)
movslq %eax,%rbp
mov    (%r15,%rbp,4),%esi
mov    %edx,%r12d
movslq %edx,%rbx
sub    (%r15,%rbx,4),%esi
xor    %eax,%eax
call   1040 <overflow@plt>
test   %eax,%eax
jne    1ed2 <_glp_okalg+0xd82>
mov    0xe8(%rsp),%rax
mov    (%rax,%r14,4),%eax
mov    0x50(%rsp),%rcx
mov    (%rcx,%r14,4),%ecx
cmp    %ecx,%eax
mov    0x8(%rsp),%rdi
jge    1730 <_glp_okalg+0x5e0>
mov    %r12d,%edx
mov    %r12d,%r11d
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
mov    0x38(%rsp),%rsi
mov    0x28(%rsp),%r10
jmp    178a <_glp_okalg+0x63a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15,%rbp,4),%edx
sub    (%r15,%rbx,4),%edx
mov    0xe0(%rsp),%rsi
add    (%rsi,%r14,4),%edx
mov    0x48(%rsp),%rsi
mov    (%rsi,%r14,4),%esi
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
mov    0x28(%rsp),%r10
jns    1770 <_glp_okalg+0x620>
cmp    %esi,%eax
jge    1770 <_glp_okalg+0x620>
mov    %r12d,%edx
mov    %r12d,%r11d
jmp    1785 <_glp_okalg+0x635>
nopw   0x0(%rax,%rax,1)
cmp    %esi,%eax
jle    1a8a <_glp_okalg+0x93a>
mov    0x24(%rsp),%r11d
mov    %r12d,%edx
mov    %r12d,0x24(%rsp)
mov    0x38(%rsp),%rsi
test   %r14d,%r14d
je     1f9e <_glp_okalg+0xe4e>
cmpl   $0x0,0x40(%rsp)
jle    17ce <_glp_okalg+0x67e>
mov    0x98(%rsp),%rdi
xor    %esi,%esi
mov    0x80(%rsp),%rdx
mov    %r11d,%ebx
call   1030 <memset@plt>
mov    %r12d,%edx
mov    %ebx,%r11d
mov    0x28(%rsp),%r10
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
movslq %r11d,%rax
mov    0x30(%rsp),%rcx
mov    %r14d,(%rcx,%rax,4)
mov    0x68(%rsp),%rcx
mov    %eax,0x4(%rcx)
mov    $0x1,%esi
mov    $0x1,%eax
mov    %rax,0x88(%rsp)
mov    %r13d,0x64(%rsp)
nopl   0x0(%rax)
movslq %r11d,%rax
movslq (%rdi,%rax,4),%rbx
cmp    0x4(%rdi,%rax,4),%ebx
jge    1a60 <_glp_okalg+0x910>
mov    %rax,0x90(%rsp)
add    $0x1,%rax
mov    %rax,0x70(%rsp)
mov    %edx,%r15d
mov    %r11d,0x5c(%rsp)
jmp    185e <_glp_okalg+0x70e>
nopl   0x0(%rax)
movslq %ebp,%r12
mov    0x30(%rsp),%rax
cmpl   $0x0,(%rax,%r12,4)
je     199d <_glp_okalg+0x84d>
mov    %ebp,%edx
add    $0x1,%rbx
mov    0x70(%rsp),%rax
movslq (%rdi,%rax,4),%rax
mov    %edx,%r15d
cmp    %rax,%rbx
jge    1a60 <_glp_okalg+0x910>
mov    (%r10,%rbx,4),%r13d
movslq %r13d,%r14
mov    (%r9,%r14,4),%ebp
mov    (%r8,%r14,4),%edx
cmp    %r11d,%ebp
jne    1930 <_glp_okalg+0x7e0>
movslq %edx,%r12
mov    0x30(%rsp),%rax
cmpl   $0x0,(%rax,%r12,4)
jne    1845 <_glp_okalg+0x6f5>
mov    0xe8(%rsp),%rax
mov    (%rax,%r14,4),%eax
mov    0x48(%rsp),%rcx
cmp    (%rcx,%r14,4),%eax
jge    1845 <_glp_okalg+0x6f5>
mov    %esi,0x60(%rsp)
mov    %edx,0x7c(%rsp)
mov    0xe0(%rsp),%r15
mov    (%r15,%r14,4),%edi
mov    0xf0(%rsp),%rbp
mov    0x90(%rsp),%r15
mov    0x0(%rbp,%r15,4),%esi
sub    0x0(%rbp,%r12,4),%esi
xor    %eax,%eax
call   1040 <overflow@plt>
test   %eax,%eax
jne    1ed2 <_glp_okalg+0xd82>
mov    0x0(%rbp,%r15,4),%eax
mov    0xe0(%rsp),%rcx
add    (%rcx,%r14,4),%eax
sub    0x0(%rbp,%r12,4),%eax
test   %eax,%eax
mov    0x7c(%rsp),%edx
mov    0x60(%rsp),%esi
jle    1a13 <_glp_okalg+0x8c3>
mov    0xe8(%rsp),%rax
mov    (%rax,%r14,4),%eax
mov    0x50(%rsp),%rcx
cmp    (%rcx,%r14,4),%eax
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdi
jl     196c <_glp_okalg+0x81c>
jmp    198e <_glp_okalg+0x83e>
nopw   0x0(%rax,%rax,1)
cmp    %r11d,%edx
je     1830 <_glp_okalg+0x6e0>
lea    0x7e2(%rip),%rdi
mov    %esi,%ebp
lea    0x6bf(%rip),%rsi
mov    $0x102,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
mov    %ebp,%esi
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
movslq %r15d,%r12
mov    %r15d,%edx
mov    0x30(%rsp),%rax
mov    %r13d,(%rax,%r12,4)
movslq %esi,%rax
mov    0x68(%rsp),%rcx
mov    %edx,0x4(%rcx,%rax,4)
cmp    0x24(%rsp),%edx
je     1c90 <_glp_okalg+0xb40>
add    $0x1,%esi
mov    0x28(%rsp),%r10
mov    0x5c(%rsp),%r11d
jmp    1845 <_glp_okalg+0x6f5>
mov    0xe8(%rsp),%rax
mov    (%rax,%r14,4),%eax
mov    0x50(%rsp),%rcx
cmp    (%rcx,%r14,4),%eax
jle    1843 <_glp_okalg+0x6f3>
mov    %esi,0x60(%rsp)
mov    0xe0(%rsp),%rax
mov    (%rax,%r14,4),%edi
mov    0xf0(%rsp),%rax
mov    (%rax,%r12,4),%esi
mov    0x90(%rsp),%r15
sub    (%rax,%r15,4),%esi
xor    %eax,%eax
call   1040 <overflow@plt>
test   %eax,%eax
jne    1ed2 <_glp_okalg+0xd82>
mov    0xf0(%rsp),%rdx
mov    (%rdx,%r12,4),%eax
mov    0xe0(%rsp),%rcx
add    (%rcx,%r14,4),%eax
cmp    (%rdx,%r15,4),%eax
mov    0x60(%rsp),%esi
js     1a27 <_glp_okalg+0x8d7>
mov    %ebp,%edx
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdi
jmp    196c <_glp_okalg+0x81c>
mov    0xe8(%rsp),%rax
mov    (%rax,%r14,4),%eax
mov    %ebp,%edx
mov    0x48(%rsp),%rcx
cmp    (%rcx,%r14,4),%eax
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdi
jg     196c <_glp_okalg+0x81c>
mov    %ebp,%edx
jmp    198e <_glp_okalg+0x83e>
nopw   0x0(%rax,%rax,1)
movslq %esi,%rax
mov    0x88(%rsp),%rcx
cmp    %rax,%rcx
jge    1aba <_glp_okalg+0x96a>
add    $0x1,%rcx
mov    0x68(%rsp),%rax
mov    %rcx,0x88(%rsp)
mov    (%rax,%rcx,4),%r11d
jmp    1800 <_glp_okalg+0x6b0>
test   %edx,%edx
mov    0x38(%rsp),%rsi
jle    1aa8 <_glp_okalg+0x958>
mov    %r12d,%edx
mov    0x24(%rsp),%r11d
mov    %r12d,0x24(%rsp)
cmp    %ecx,%eax
jg     178a <_glp_okalg+0x63a>
add    $0x1,%r14
cmp    %rsi,%r14
jne    16b1 <_glp_okalg+0x561>
jmp    1f9e <_glp_okalg+0xe4e>
mov    $0x1,%ebx
cmpb   $0x0,0x7(%rsp)
mov    0xf0(%rsp),%r15
mov    0x64(%rsp),%r13d
jne    1f5f <_glp_okalg+0xe0f>
xor    %r12d,%r12d
mov    $0x1,%ebx
mov    0xe0(%rsp),%rdx
jmp    1b1b <_glp_okalg+0x9cb>
neg    %eax
cmp    %eax,%r12d
mov    %r12d,%ecx
cmovg  %eax,%ecx
test   %r12d,%r12d
cmove  %eax,%ecx
mov    %ecx,%r12d
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdi
add    $0x1,%rbx
cmp    %rbx,0x38(%rsp)
je     1c01 <_glp_okalg+0xab1>
movslq (%r9,%rbx,4),%rbp
movslq (%r8,%rbx,4),%r14
mov    0x30(%rsp),%rax
cmpl   $0x0,(%rax,%rbp,4)
mov    (%rax,%r14,4),%eax
je     1b90 <_glp_okalg+0xa40>
test   %eax,%eax
jne    1b0c <_glp_okalg+0x9bc>
mov    (%rdx,%rbx,4),%edi
mov    (%r15,%rbp,4),%esi
sub    (%r15,%r14,4),%esi
xor    %eax,%eax
call   1040 <overflow@plt>
test   %eax,%eax
jne    1ed2 <_glp_okalg+0xd82>
mov    0xe8(%rsp),%rax
mov    (%rax,%rbx,4),%eax
mov    0x48(%rsp),%rcx
cmp    (%rcx,%rbx,4),%eax
jg     1be5 <_glp_okalg+0xa95>
mov    (%r15,%rbp,4),%eax
sub    (%r15,%r14,4),%eax
mov    0xe0(%rsp),%rdx
add    (%rdx,%rbx,4),%eax
test   %eax,%eax
jg     1aeb <_glp_okalg+0x99b>
jmp    1afd <_glp_okalg+0x9ad>
nopl   0x0(%rax)
test   %eax,%eax
je     1b0c <_glp_okalg+0x9bc>
mov    (%rdx,%rbx,4),%edi
mov    (%r15,%rbp,4),%esi
sub    (%r15,%r14,4),%esi
xor    %eax,%eax
call   1040 <overflow@plt>
test   %eax,%eax
jne    1ed2 <_glp_okalg+0xd82>
mov    0xe8(%rsp),%rax
mov    (%rax,%rbx,4),%eax
mov    0x50(%rsp),%rcx
cmp    (%rcx,%rbx,4),%eax
jl     1be5 <_glp_okalg+0xa95>
mov    (%r15,%rbp,4),%eax
sub    (%r15,%r14,4),%eax
mov    0xe0(%rsp),%rdx
add    (%rdx,%rbx,4),%eax
js     1ae9 <_glp_okalg+0x999>
jmp    1afd <_glp_okalg+0x9ad>
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdi
mov    0xe0(%rsp),%rdx
jmp    1b0c <_glp_okalg+0x9bc>
test   %r12d,%r12d
mov    $0x1,%ebx
je     1f5f <_glp_okalg+0xe0f>
cmpl   $0x0,0x40(%rsp)
mov    0x28(%rsp),%r10
jle    1c79 <_glp_okalg+0xb29>
mov    $0x1,%ebx
jmp    1c3e <_glp_okalg+0xaee>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbx
cmp    %rbx,0xa0(%rsp)
je     1c79 <_glp_okalg+0xb29>
mov    0x30(%rsp),%rax
cmpl   $0x0,(%rax,%rbx,4)
jne    1c30 <_glp_okalg+0xae0>
mov    (%r15,%rbx,4),%edi
mov    %r12d,%esi
xor    %eax,%eax
call   1040 <overflow@plt>
test   %eax,%eax
jne    1ed2 <_glp_okalg+0xd82>
add    %r12d,(%r15,%rbx,4)
mov    0x18(%rsp),%r8
mov    0x10(%rsp),%r9
mov    0x8(%rsp),%rdi
mov    0x28(%rsp),%r10
jmp    1c30 <_glp_okalg+0xae0>
mov    $0x1,%r14d
cmpb   $0x0,0x7(%rsp)
je     16b1 <_glp_okalg+0x561>
jmp    15a8 <_glp_okalg+0x458>
nop
xor    %ebx,%ebx
mov    0x24(%rsp),%ecx
mov    0xf0(%rsp),%r15
mov    0xe0(%rsp),%r10
mov    0x64(%rsp),%r13d
mov    0x5c(%rsp),%ebp
jmp    1d16 <_glp_okalg+0xbc6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x45b(%rip),%rdi
lea    0x33a(%rip),%rsi
mov    $0x15a,%edx
xor    %eax,%eax
mov    %ebp,%r14d
call   1060 <glp_assert_@plt>
mov    0xe0(%rsp),%r10
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
cmp    %r13d,%ebx
mov    %ebx,%eax
cmovg  %r13d,%eax
test   %ebx,%ebx
mov    %eax,%ebx
cmove  %r13d,%ebx
mov    %r14d,%ecx
mov    %r14d,%ebp
cmp    0x24(%rsp),%r14d
je     1e10 <_glp_okalg+0xcc0>
movslq %ecx,%rdx
mov    0x30(%rsp),%rax
movslq (%rax,%rdx,4),%rax
mov    (%r8,%rax,4),%r12d
mov    (%r9,%rax,4),%r14d
cmp    %edx,%r12d
jne    1d60 <_glp_okalg+0xc10>
movslq %r14d,%rcx
mov    (%r15,%rcx,4),%esi
add    (%r10,%rax,4),%esi
sub    (%r15,%rdx,4),%esi
mov    0xe8(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
test   %esi,%esi
jle    1d9a <_glp_okalg+0xc4a>
mov    0x50(%rsp),%rdx
jmp    1d9f <_glp_okalg+0xc4f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %ecx,%r14d
jne    1cc0 <_glp_okalg+0xb70>
mov    (%r15,%rdx,4),%ecx
add    (%r10,%rax,4),%ecx
movslq %r12d,%rdx
cmp    (%r15,%rdx,4),%ecx
mov    0xe8(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
js     1dca <_glp_okalg+0xc7a>
mov    0x50(%rsp),%rdx
sub    (%rdx,%rax,4),%ecx
jle    1dd4 <_glp_okalg+0xc84>
mov    %ecx,%r13d
mov    %r12d,%r14d
jmp    1cf4 <_glp_okalg+0xba4>
mov    0x48(%rsp),%rdx
mov    (%rdx,%rax,4),%eax
sub    %ecx,%eax
jle    1db0 <_glp_okalg+0xc60>
mov    %eax,%r13d
jmp    1cf4 <_glp_okalg+0xba4>
xchg   %ax,%ax
lea    0x36b(%rip),%rdi
lea    0x24a(%rip),%rsi
mov    $0x148,%edx
xor    %eax,%eax
jmp    1cd8 <_glp_okalg+0xb88>
mov    0x48(%rsp),%rdx
sub    (%rdx,%rax,4),%ecx
jg     1d8f <_glp_okalg+0xc3f>
lea    0x347(%rip),%rdi
lea    0x226(%rip),%rsi
mov    $0x157,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
mov    0xe0(%rsp),%r10
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
mov    %r12d,%r14d
jmp    1cf4 <_glp_okalg+0xba4>
nopl   (%rax)
test   %ebx,%ebx
jg     1e3d <_glp_okalg+0xced>
lea    0x30e(%rip),%rdi
lea    0x1e6(%rip),%rsi
mov    $0x15f,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
mov    0x24(%rsp),%ebp
mov    0x28(%rsp),%r10
jmp    1e67 <_glp_okalg+0xd17>
nopl   0x0(%rax,%rax,1)
mov    0xe8(%rsp),%rdx
add    %ebx,(%rdx,%rcx,4)
mov    %eax,%ebp
cmp    0x24(%rsp),%eax
je     16a0 <_glp_okalg+0x550>
movslq %ebp,%rsi
mov    0x30(%rsp),%rax
movslq (%rax,%rsi,4),%rcx
mov    (%r8,%rcx,4),%edx
mov    (%r9,%rcx,4),%eax
cmp    %esi,%edx
je     1e50 <_glp_okalg+0xd00>
cmp    %ebp,%eax
jne    1ea0 <_glp_okalg+0xd50>
mov    0xe8(%rsp),%rax
sub    %ebx,(%rax,%rcx,4)
mov    %edx,%eax
jmp    1e5b <_glp_okalg+0xd0b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x27b(%rip),%rdi
lea    0x15a(%rip),%rsi
mov    $0x171,%edx
xor    %eax,%eax
call   1060 <glp_assert_@plt>
mov    0x28(%rsp),%r10
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r9
mov    0x18(%rsp),%r8
mov    %ebp,%eax
jmp    1e5b <_glp_okalg+0xd0b>
mov    $0x2,%ebx
mov    0x8(%rsp),%rdi
jmp    1f5f <_glp_okalg+0xe0f>
cmpb   $0x0,0x7(%rsp)
mov    0xe0(%rsp),%rbx
je     1ef4 <_glp_okalg+0xda4>
xor    %ebx,%ebx
jmp    1f5f <_glp_okalg+0xe0f>
mov    $0x1,%eax
mov    0x38(%rsp),%rsi
mov    0xf0(%rsp),%rbp
jmp    1f2e <_glp_okalg+0xdde>
nopl   0x0(%rax,%rax,1)
mov    0xe8(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
mov    0x50(%rsp),%rdx
cmp    (%rdx,%rax,4),%ecx
jne    1f5a <_glp_okalg+0xe0a>
add    $0x1,%rax
cmp    %rax,%rsi
je     1ef0 <_glp_okalg+0xda0>
movslq (%r9,%rax,4),%rcx
movslq (%r8,%rax,4),%rdx
mov    0x0(%rbp,%rcx,4),%ecx
sub    0x0(%rbp,%rdx,4),%ecx
add    (%rbx,%rax,4),%ecx
jg     1f10 <_glp_okalg+0xdc0>
jns    1f25 <_glp_okalg+0xdd5>
mov    0xe8(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
mov    0x48(%rsp),%rdx
cmp    (%rdx,%rax,4),%ecx
je     1f25 <_glp_okalg+0xdd5>
mov    $0x3,%ebx
xor    %eax,%eax
call   1050 <glp_free@plt>
mov    0x28(%rsp),%rdi
xor    %eax,%eax
call   1050 <glp_free@plt>
mov    0x30(%rsp),%rdi
xor    %eax,%eax
call   1050 <glp_free@plt>
mov    0x68(%rsp),%rdi
xor    %eax,%eax
call   1050 <glp_free@plt>
mov    %ebx,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmpb   $0x0,0x7(%rsp)
jne    15a8 <_glp_okalg+0x458>
mov    $0x1,%eax
mov    $0x3,%ebx
mov    0x28(%rsp),%r10
nopl   0x0(%rax,%rax,1)
mov    0xe8(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
mov    0x50(%rsp),%rdx
cmp    %ecx,(%rdx,%rax,4)
jg     1f5f <_glp_okalg+0xe0f>
mov    0x48(%rsp),%rdx
cmp    (%rdx,%rax,4),%ecx
jg     1f5f <_glp_okalg+0xe0f>
add    $0x1,%rax
cmp    %rax,%rsi
jne    1fc0 <_glp_okalg+0xe70>
jmp    15a8 <_glp_okalg+0x458>

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

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