int _glp_triang(int m, int n,
                int (*mat)(void *info, int k, int ind[], double val[]),
                void *info, double tol, int rn[], int cn[]) {
  int head, i, j, jj, k, kk, ks, len, len2, next_j, ns, size;
  int *cind, *rind, *cnt, *ptr, *list, *prev, *next;
  double *cval, *rval, *big;
  char *flag;
  cind = ((int *)glp_alloc(1 + m, sizeof(int)));
  cval = ((double *)glp_alloc(1 + m, sizeof(double)));
  rind = ((int *)glp_alloc(1 + n, sizeof(int)));
  rval = ((double *)glp_alloc(1 + n, sizeof(double)));
  cnt = ptr = ((int *)glp_alloc(1 + m, sizeof(int)));
  list = ((int *)glp_alloc(1 + n, sizeof(int)));
  prev = ((int *)glp_alloc(1 + n, sizeof(int)));
  next = ((int *)glp_alloc(1 + n, sizeof(int)));
  big = ((double *)glp_alloc(1 + n, sizeof(double)));
  flag = ((char *)glp_alloc(1 + n, sizeof(char)));
  for (len = 0; len <= m; len++)
    ptr[len] = 0;
  for (j = 1; j <= n; j++) {
    len = mat(info, -j, cind, cval);
    ((void)((0 <= len && len <= m) ||
            (glp_assert_(
                 "0 <= len && len <= m",
                 "/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/triang.c",
                 136),
             1)));
    next[j] = ptr[len];
    ptr[len] = j;
    big[j] = 0.0;
    for (k = 1; k <= len; k++) {
      if (big[j] < fabs(cval[k]))
        big[j] = fabs(cval[k]);
    }
  }
  head = 0;
  for (len = 0; len <= m; len++) {
    for (j = ptr[len]; j != 0; j = next_j) {
      next_j = next[j];
      prev[j] = 0;
      next[j] = head;
      if (head != 0)
        prev[head] = j;
      head = j;
    }
  }
  for (j = 1; j <= n; j++)
    flag[j] = 1;
  ns = 0;
  for (i = 1; i <= m; i++) {
    len = cnt[i] = mat(info, +i, rind, rval);
    ((void)((0 <= len && len <= n) ||
            (glp_assert_(
                 "0 <= len && len <= n",
                 "/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/triang.c",
                 194),
             1)));
    if (len == 1) {
      j = rind[1];
      ((void)((1 <= j && j <= n) ||
              (glp_assert_("1 <= j && j <= n",
                           "/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/triang.c",
                           198),
               1)));
      if (flag[j] != 2) {
        flag[j] = 2;
        list[++ns] = j;
      }
    }
  }
  size = 0;
  while (head != 0) {
    if (ns == 0) {
      j = head;
      len = mat(info, -j, cind, cval);
      ((void)((0 <= len && len <= m) ||
              (glp_assert_("0 <= len && len <= m",
                           "/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/triang.c",
                           219),
               1)));
      goto drop;
    }
    j = list[ns--];
    ((void)((flag[j] == 2) ||
            (glp_assert_(
                 "flag[j] == 2",
                 "/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/triang.c",
                 224),
             1)));
    len = mat(info, -j, cind, cval);
    ((void)((0 <= len && len <= m) ||
            (glp_assert_(
                 "0 <= len && len <= m",
                 "/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/triang.c",
                 228),
             1)));
    kk = 0;
    for (k = 1; k <= len; k++) {
      i = cind[k];
      ((void)((1 <= i && i <= m) ||
              (glp_assert_("1 <= i && i <= m",
                           "/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/triang.c",
                           232),
               1)));
      if (cnt[i] == 1) {
        if (kk == 0 || fabs(cval[kk]) < fabs(cval[k]))
          kk = k;
      }
    }
    ((void)((kk > 0) ||
            (glp_assert_(
                 "kk > 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/triang.c",
                 239),
             1)));
    if (fabs(cval[kk]) < tol * big[j]) {
      goto drop;
    }
    size++;
    rn[size] = cind[kk];
    cn[size] = j;
  drop:
    ((void)((flag[j]) ||
            (glp_assert_(
                 "flag[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/triang.c",
                 252),
             1)));
    flag[j] = 0;
    if (prev[j] == 0)
      head = next[j];
    else
      next[prev[j]] = next[j];
    if (next[j] == 0)
      ;
    else
      prev[next[j]] = prev[j];
    for (k = 1; k <= len; k++) {
      i = cind[k];
      ((void)((1 <= i && i <= m) ||
              (glp_assert_("1 <= i && i <= m",
                           "/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/triang.c",
                           265),
               1)));
      ((void)((cnt[i] > 0) ||
              (glp_assert_("cnt[i] > 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/triang.c",
                           266),
               1)));
      cnt[i]--;
      if (cnt[i] == 1) {
        len2 = mat(info, +i, rind, rval);
        ((void)((0 <= len2 && len2 <= n) ||
                (glp_assert_("0 <= len2 && len2 <= n",
                             "/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/triang.c",
                             273),
                 1)));
        ks = 0;
        for (kk = 1; kk <= len2; kk++) {
          jj = rind[kk];
          ((void)((1 <= jj && jj <= n) ||
                  (glp_assert_("1 <= jj && jj <= n",
                               "/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/triang.c",
                               277),
                   1)));
          if (flag[jj]) {
            ((void)((ks == 0) ||
                    (glp_assert_(
                         "ks == 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/triang.c",
                         279),
                     1)));
            ks = kk;
          }
        }
        ((void)((ks > 0) ||
                (glp_assert_("ks > 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/triang.c",
                             283),
                 1)));
        jj = rind[ks];
        if (flag[jj] != 2) {
          flag[jj] = 2;
          list[++ns] = jj;
        }
      }
    }
  }
  for (i = 1; i <= m; i++)
    ((void)((cnt[i] == 0) ||
            (glp_assert_(
                 "cnt[i] == 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/triang.c",
                 296),
             1)));
  glp_free(cind);
  glp_free(cval);
  glp_free(rind);
  glp_free(rval);
  glp_free(ptr);
  glp_free(list);
  glp_free(prev);
  glp_free(next);
  glp_free(big);
  glp_free(flag);
  return size;
}


x86 assembly (clang, -O0):
<_glp_triang>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1050 <glp_alloc@plt>
cltq
mov    %rax,-0x68(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1050 <glp_alloc@plt>
cltq
mov    %rax,-0xa0(%rbp)
mov    -0x8(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1050 <glp_alloc@plt>
cltq
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1050 <glp_alloc@plt>
cltq
mov    %rax,-0xa8(%rbp)
mov    -0x4(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1050 <glp_alloc@plt>
cltq
mov    %rax,-0x80(%rbp)
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1050 <glp_alloc@plt>
cltq
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1050 <glp_alloc@plt>
cltq
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1050 <glp_alloc@plt>
cltq
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%edi
add    $0x1,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1050 <glp_alloc@plt>
cltq
mov    %rax,-0xb0(%rbp)
mov    -0x8(%rbp),%edi
add    $0x1,%edi
mov    $0x1,%esi
mov    $0x0,%al
call   1050 <glp_alloc@plt>
cltq
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     128f <_glp_triang+0x15f>
mov    -0x80(%rbp),%rax
movslq -0x50(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1266 <_glp_triang+0x136>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     13d9 <_glp_triang+0x2a9>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rdi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0xa0(%rbp),%rcx
call   *%rax
mov    %eax,-0x50(%rbp)
xor    %eax,%eax
cmp    -0x50(%rbp),%eax
jg     12de <_glp_triang+0x1ae>
mov    -0x50(%rbp),%ecx
mov    $0x1,%al
cmp    -0x4(%rbp),%ecx
mov    %al,-0xb9(%rbp)
jle    1300 <_glp_triang+0x1d0>
lea    0xd2b(%rip),%rdi
lea    0xd39(%rip),%rsi
mov    $0x88,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xb9(%rbp)
mov    -0xb9(%rbp),%al
mov    -0x80(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x80(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xb0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     13c6 <_glp_triang+0x296>
mov    -0xb0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xa0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc86(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    13b3 <_glp_triang+0x283>
mov    -0xa0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xc61(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13b8 <_glp_triang+0x288>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1347 <_glp_triang+0x217>
jmp    13cb <_glp_triang+0x29b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1296 <_glp_triang+0x166>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     147e <_glp_triang+0x34e>
mov    -0x80(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
je     146b <_glp_triang+0x33b>
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x34(%rbp)
je     145a <_glp_triang+0x32a>
mov    -0x3c(%rbp),%edx
mov    -0x90(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1401 <_glp_triang+0x2d1>
jmp    1470 <_glp_triang+0x340>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13e7 <_glp_triang+0x2b7>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     14ae <_glp_triang+0x37e>
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1485 <_glp_triang+0x355>
movl   $0x0,-0x5c(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     15eb <_glp_triang+0x4bb>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0xa8(%rbp),%rcx
call   *%rax
mov    -0x78(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    %eax,(%rcx,%rdx,4)
mov    %eax,-0x50(%rbp)
xor    %eax,%eax
cmp    -0x50(%rbp),%eax
jg     150d <_glp_triang+0x3dd>
mov    -0x50(%rbp),%ecx
mov    $0x1,%al
cmp    -0x8(%rbp),%ecx
mov    %al,-0xba(%rbp)
jle    152f <_glp_triang+0x3ff>
lea    0xbb8(%rip),%rdi
lea    0xb0a(%rip),%rsi
mov    $0xc2,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xba(%rbp)
mov    -0xba(%rbp),%al
cmpl   $0x1,-0x50(%rbp)
jne    15d8 <_glp_triang+0x4a8>
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    $0x1,%eax
cmp    -0x3c(%rbp),%eax
jg     156b <_glp_triang+0x43b>
mov    -0x3c(%rbp),%ecx
mov    $0x1,%al
cmp    -0x8(%rbp),%ecx
mov    %al,-0xbb(%rbp)
jle    158d <_glp_triang+0x45d>
lea    0xb6f(%rip),%rdi
lea    0xaac(%rip),%rsi
mov    $0xc6,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xbb(%rbp)
mov    -0xbb(%rbp),%al
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2,%eax
je     15d3 <_glp_triang+0x4a3>
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movb   $0x2,(%rax,%rcx,1)
mov    -0x3c(%rbp),%edx
mov    -0x88(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    15d8 <_glp_triang+0x4a8>
jmp    15dd <_glp_triang+0x4ad>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14bc <_glp_triang+0x38c>
movl   $0x0,-0x60(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     1c69 <_glp_triang+0xb39>
cmpl   $0x0,-0x5c(%rbp)
jne    1675 <_glp_triang+0x545>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rdi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0xa0(%rbp),%rcx
call   *%rax
mov    %eax,-0x50(%rbp)
xor    %eax,%eax
cmp    -0x50(%rbp),%eax
jg     1648 <_glp_triang+0x518>
mov    -0x50(%rbp),%ecx
mov    $0x1,%al
cmp    -0x4(%rbp),%ecx
mov    %al,-0xbc(%rbp)
jle    166a <_glp_triang+0x53a>
lea    0x9c1(%rip),%rdi
lea    0x9cf(%rip),%rsi
mov    $0xdb,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xbc(%rbp)
mov    -0xbc(%rbp),%al
jmp    18ce <_glp_triang+0x79e>
mov    -0x88(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x2,%ecx
mov    %al,-0xbd(%rbp)
je     16d2 <_glp_triang+0x5a2>
lea    0xa3b(%rip),%rdi
lea    0x967(%rip),%rsi
mov    $0xe0,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xbd(%rbp)
mov    -0xbd(%rbp),%al
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rdi
xor    %esi,%esi
sub    -0x3c(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0xa0(%rbp),%rcx
call   *%rax
mov    %eax,-0x50(%rbp)
xor    %eax,%eax
cmp    -0x50(%rbp),%eax
jg     1714 <_glp_triang+0x5e4>
mov    -0x50(%rbp),%ecx
mov    $0x1,%al
cmp    -0x4(%rbp),%ecx
mov    %al,-0xbe(%rbp)
jle    1736 <_glp_triang+0x606>
lea    0x8f5(%rip),%rdi
lea    0x903(%rip),%rsi
mov    $0xe4,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xbe(%rbp)
mov    -0xbe(%rbp),%al
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1828 <_glp_triang+0x6f8>
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    $0x1,%eax
cmp    -0x38(%rbp),%eax
jg     1786 <_glp_triang+0x656>
mov    -0x38(%rbp),%ecx
mov    $0x1,%al
cmp    -0x4(%rbp),%ecx
mov    %al,-0xbf(%rbp)
jle    17a8 <_glp_triang+0x678>
lea    0x972(%rip),%rdi
lea    0x891(%rip),%rsi
mov    $0xe8,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xbf(%rbp)
mov    -0xbf(%rbp),%al
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    1815 <_glp_triang+0x6e5>
cmpl   $0x0,-0x48(%rbp)
je     180a <_glp_triang+0x6da>
mov    -0xa0(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x81f(%rip),%xmm0
pand   %xmm0,%xmm1
mov    -0xa0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x804(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1810 <_glp_triang+0x6e0>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1815 <_glp_triang+0x6e5>
jmp    181a <_glp_triang+0x6ea>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    174a <_glp_triang+0x61a>
mov    $0x1,%al
cmpl   $0x0,-0x48(%rbp)
mov    %al,-0xc0(%rbp)
jg     185c <_glp_triang+0x72c>
lea    0x8cf(%rip),%rdi
lea    0x7dd(%rip),%rsi
mov    $0xef,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xc0(%rbp)
mov    -0xc0(%rbp),%al
mov    -0xa0(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x787(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    18a1 <_glp_triang+0x771>
jmp    18ce <_glp_triang+0x79e>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x1,%al
cmp    $0x0,%ecx
mov    %al,-0xc1(%rbp)
jne    1910 <_glp_triang+0x7e0>
lea    0x822(%rip),%rdi
lea    0x729(%rip),%rsi
mov    $0xfc,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xc1(%rbp)
mov    -0xc1(%rbp),%al
mov    -0xb8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1950 <_glp_triang+0x820>
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
jmp    1977 <_glp_triang+0x847>
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x98(%rbp),%rax
mov    -0x90(%rbp),%rcx
movslq -0x3c(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x98(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1991 <_glp_triang+0x861>
jmp    19b8 <_glp_triang+0x888>
mov    -0x90(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rcx
movslq -0x3c(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1c64 <_glp_triang+0xb34>
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    $0x1,%eax
cmp    -0x38(%rbp),%eax
jg     19fb <_glp_triang+0x8cb>
mov    -0x38(%rbp),%ecx
mov    $0x1,%al
cmp    -0x4(%rbp),%ecx
mov    %al,-0xc2(%rbp)
jle    1a1d <_glp_triang+0x8ed>
lea    0x6fd(%rip),%rdi
lea    0x61c(%rip),%rsi
mov    $0x109,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xc2(%rbp)
mov    -0xc2(%rbp),%al
mov    -0x78(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    $0x1,%al
cmpl   $0x0,(%rcx,%rdx,4)
mov    %al,-0xc3(%rbp)
jg     1a5f <_glp_triang+0x92f>
lea    0x6db(%rip),%rdi
lea    0x5da(%rip),%rsi
mov    $0x10a,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xc3(%rbp)
mov    -0xc3(%rbp),%al
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    1c51 <_glp_triang+0xb21>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x70(%rbp),%rdx
mov    -0xa8(%rbp),%rcx
call   *%rax
mov    %eax,-0x54(%rbp)
xor    %eax,%eax
cmp    -0x54(%rbp),%eax
jg     1ac2 <_glp_triang+0x992>
mov    -0x54(%rbp),%ecx
mov    $0x1,%al
cmp    -0x8(%rbp),%ecx
mov    %al,-0xc4(%rbp)
jle    1ae4 <_glp_triang+0x9b4>
lea    0x661(%rip),%rdi
lea    0x555(%rip),%rsi
mov    $0x111,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xc4(%rbp)
mov    -0xc4(%rbp),%al
movl   $0x0,-0x4c(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     1bc4 <_glp_triang+0xa94>
mov    -0x70(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    $0x1,%eax
cmp    -0x40(%rbp),%eax
jg     1b34 <_glp_triang+0xa04>
mov    -0x40(%rbp),%ecx
mov    $0x1,%al
cmp    -0x8(%rbp),%ecx
mov    %al,-0xc5(%rbp)
jle    1b56 <_glp_triang+0xa26>
lea    0x606(%rip),%rdi
lea    0x4e3(%rip),%rsi
mov    $0x115,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xc5(%rbp)
mov    -0xc5(%rbp),%al
mov    -0xb8(%rbp),%rax
movslq -0x40(%rbp),%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     1bb1 <_glp_triang+0xa81>
mov    $0x1,%al
cmpl   $0x0,-0x4c(%rbp)
mov    %al,-0xc6(%rbp)
je     1ba5 <_glp_triang+0xa75>
lea    0x5ca(%rip),%rdi
lea    0x494(%rip),%rsi
mov    $0x117,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xc6(%rbp)
mov    -0xc6(%rbp),%al
mov    -0x48(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    1bb6 <_glp_triang+0xa86>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1af8 <_glp_triang+0x9c8>
mov    $0x1,%al
cmpl   $0x0,-0x4c(%rbp)
mov    %al,-0xc7(%rbp)
jg     1bf8 <_glp_triang+0xac8>
lea    0x57f(%rip),%rdi
lea    0x441(%rip),%rsi
mov    $0x11b,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xc7(%rbp)
mov    -0xc7(%rbp),%al
mov    -0x70(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2,%eax
je     1c4c <_glp_triang+0xb1c>
mov    -0xb8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movb   $0x2,(%rax,%rcx,1)
mov    -0x40(%rbp),%edx
mov    -0x88(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1c51 <_glp_triang+0xb21>
jmp    1c56 <_glp_triang+0xb26>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    19bf <_glp_triang+0x88f>
jmp    15f2 <_glp_triang+0x4c2>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1ccc <_glp_triang+0xb9c>
mov    -0x78(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    $0x1,%al
cmpl   $0x0,(%rcx,%rdx,4)
mov    %al,-0xc8(%rbp)
je     1cb8 <_glp_triang+0xb88>
lea    0x4c6(%rip),%rdi
lea    0x381(%rip),%rsi
mov    $0x128,%edx
mov    $0x0,%al
call   1040 <glp_assert_@plt>
mov    $0x1,%al
mov    %al,-0xc8(%rbp)
mov    -0xc8(%rbp),%al
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c70 <_glp_triang+0xb40>
mov    -0x68(%rbp),%rdi
mov    $0x0,%al
call   1030 <glp_free@plt>
mov    -0xa0(%rbp),%rdi
mov    $0x0,%al
call   1030 <glp_free@plt>
mov    -0x70(%rbp),%rdi
mov    $0x0,%al
call   1030 <glp_free@plt>
mov    -0xa8(%rbp),%rdi
mov    $0x0,%al
call   1030 <glp_free@plt>
mov    -0x80(%rbp),%rdi
mov    $0x0,%al
call   1030 <glp_free@plt>
mov    -0x88(%rbp),%rdi
mov    $0x0,%al
call   1030 <glp_free@plt>
mov    -0x90(%rbp),%rdi
mov    $0x0,%al
call   1030 <glp_free@plt>
mov    -0x98(%rbp),%rdi
mov    $0x0,%al
call   1030 <glp_free@plt>
mov    -0xb0(%rbp),%rdi
mov    $0x0,%al
call   1030 <glp_free@plt>
mov    -0xb8(%rbp),%rdi
mov    $0x0,%al
call   1030 <glp_free@plt>
mov    -0x60(%rbp),%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_glp_triang>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0xa0(%rsp)
mov    %r8,0x98(%rsp)
movsd  %xmm0,0xa8(%rsp)
mov    %rcx,0x78(%rsp)
mov    %rdx,0x70(%rsp)
mov    %esi,%ebx
mov    %edi,%r13d
lea    0x1(%r13),%ebp
mov    $0x4,%esi
mov    %ebp,%edi
xor    %eax,%eax
call   1060 <glp_alloc@plt>
mov    %eax,0x20(%rsp)
mov    $0x8,%esi
mov    %ebp,%edi
xor    %eax,%eax
call   1060 <glp_alloc@plt>
mov    %eax,0x18(%rsp)
mov    %rbx,0x48(%rsp)
add    $0x1,%ebx
mov    $0x4,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1060 <glp_alloc@plt>
mov    %eax,0xc(%rsp)
mov    $0x8,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1060 <glp_alloc@plt>
mov    %eax,0x30(%rsp)
mov    $0x4,%esi
mov    %ebp,0x10(%rsp)
mov    %ebp,%edi
xor    %eax,%eax
call   1060 <glp_alloc@plt>
movslq %eax,%r14
mov    $0x4,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1060 <glp_alloc@plt>
mov    %eax,0x50(%rsp)
mov    $0x4,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1060 <glp_alloc@plt>
mov    %eax,0x60(%rsp)
mov    $0x4,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1060 <glp_alloc@plt>
mov    %eax,%r12d
mov    $0x8,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1060 <glp_alloc@plt>
mov    %eax,%r15d
mov    $0x1,%esi
mov    %ebx,%edi
xor    %eax,%eax
call   1060 <glp_alloc@plt>
mov    %eax,0x68(%rsp)
test   %r13d,%r13d
js     1254 <_glp_triang+0x114>
mov    %r13d,%eax
lea    0x4(,%rax,4),%rdx
mov    %r14,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    %r13,0x40(%rsp)
mov    %r14,0x88(%rsp)
movslq 0x20(%rsp),%rax
mov    %rax,0x20(%rsp)
movslq 0x18(%rsp),%rax
mov    %rax,0x18(%rsp)
movslq %r12d,%rax
mov    %rax,0x38(%rsp)
movslq %r15d,%rbp
cmpl   $0x0,0x48(%rsp)
jle    13d3 <_glp_triang+0x293>
mov    %ebx,%r14d
mov    $0x1,%r12d
lea    0xd75(%rip),%r15
lea    0xd83(%rip),%r13
jmp    12bd <_glp_triang+0x17d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
cmp    %r14,%r12
je     13d3 <_glp_triang+0x293>
mov    %r12d,%esi
neg    %esi
mov    0x78(%rsp),%rdi
mov    0x20(%rsp),%rdx
mov    0x18(%rsp),%rcx
call   *0x70(%rsp)
mov    %eax,%ebx
test   %eax,%eax
js     12e1 <_glp_triang+0x1a1>
cmp    0x40(%rsp),%ebx
jle    12f3 <_glp_triang+0x1b3>
mov    %r15,%rdi
mov    %r13,%rsi
mov    $0x88,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
movslq %ebx,%rax
mov    0x88(%rsp),%rdx
mov    (%rdx,%rax,4),%ecx
mov    0x38(%rsp),%rsi
mov    %ecx,(%rsi,%r12,4)
mov    %r12d,(%rdx,%rax,4)
movq   $0x0,0x0(%rbp,%r12,8)
test   %ebx,%ebx
movapd 0xcdf(%rip),%xmm2
jle    12b0 <_glp_triang+0x170>
mov    %ebx,%eax
cmp    $0x1,%ebx
jne    1360 <_glp_triang+0x220>
mov    $0x1,%ecx
xorpd  %xmm0,%xmm0
test   $0x1,%al
je     12b0 <_glp_triang+0x170>
mov    0x18(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm1
andpd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jbe    12b0 <_glp_triang+0x170>
movsd  %xmm1,0x0(%rbp,%r12,8)
jmp    12b0 <_glp_triang+0x170>
nop
mov    %eax,%edx
and    $0xfffffffe,%edx
neg    %rdx
mov    $0x1,%ecx
xorpd  %xmm0,%xmm0
jmp    1392 <_glp_triang+0x252>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
je     1333 <_glp_triang+0x1f3>
mov    0x18(%rsp),%rsi
movsd  (%rsi,%rcx,8),%xmm1
andpd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jbe    13b1 <_glp_triang+0x271>
movsd  %xmm1,0x0(%rbp,%r12,8)
movapd %xmm1,%xmm0
mov    0x18(%rsp),%rsi
movsd  0x8(%rsi,%rcx,8),%xmm1
andpd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jbe    1380 <_glp_triang+0x240>
movsd  %xmm1,0x0(%rbp,%r12,8)
movapd %xmm1,%xmm0
jmp    1380 <_glp_triang+0x240>
movslq 0x60(%rsp),%rbx
mov    0x10(%rsp),%eax
mov    %rax,0x60(%rsp)
mov    0x40(%rsp),%r13
test   %r13d,%r13d
js     1457 <_glp_triang+0x317>
xor    %eax,%eax
xor    %ecx,%ecx
mov    0x88(%rsp),%r12
mov    0x48(%rsp),%r8
mov    0x38(%rsp),%rdi
jmp    141e <_glp_triang+0x2de>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
mov    %r15d,%ecx
cmp    0x60(%rsp),%rax
je     1467 <_glp_triang+0x327>
mov    (%r12,%rax,4),%edx
test   %edx,%edx
jne    1437 <_glp_triang+0x2f7>
mov    %ecx,%r15d
jmp    1410 <_glp_triang+0x2d0>
nopl   0x0(%rax,%rax,1)
mov    %r15d,%ecx
test   %edx,%edx
je     1410 <_glp_triang+0x2d0>
mov    %edx,%r15d
movslq %edx,%rsi
mov    (%rdi,%rsi,4),%edx
movl   $0x0,(%rbx,%rsi,4)
mov    %ecx,(%rdi,%rsi,4)
test   %ecx,%ecx
je     1430 <_glp_triang+0x2f0>
movslq %ecx,%rcx
mov    %r15d,(%rbx,%rcx,4)
jmp    1430 <_glp_triang+0x2f0>
xor    %r15d,%r15d
mov    0x88(%rsp),%r12
mov    0x48(%rsp),%r8
movslq 0x68(%rsp),%r14
test   %r8d,%r8d
jle    1482 <_glp_triang+0x342>
lea    0x1(%r14),%rdi
mov    %r8d,%edx
mov    $0x1,%esi
call   1030 <memset@plt>
mov    %r14,0x10(%rsp)
mov    %rbx,0x58(%rsp)
mov    %rbp,0x90(%rsp)
movslq 0xc(%rsp),%rbp
movslq 0x30(%rsp),%rax
mov    %rax,0x68(%rsp)
movslq 0x50(%rsp),%rax
mov    %rax,0x50(%rsp)
movl   $0x0,0x2c(%rsp)
mov    $0x0,%r14d
test   %r13d,%r13d
jle    15a7 <_glp_triang+0x467>
mov    $0x1,%ebx
xor    %r14d,%r14d
jmp    14e4 <_glp_triang+0x3a4>
xchg   %ax,%ax
mov    0x40(%rsp),%r13
add    $0x1,%rbx
cmp    %rbx,0x60(%rsp)
je     15a7 <_glp_triang+0x467>
mov    0x78(%rsp),%rdi
mov    %ebx,%esi
mov    %rbp,%rdx
mov    0x68(%rsp),%rcx
call   *0x70(%rsp)
mov    %eax,%r13d
mov    %eax,(%r12,%rbx,4)
test   %eax,%eax
js     1509 <_glp_triang+0x3c9>
cmp    0x48(%rsp),%r13d
jle    1523 <_glp_triang+0x3e3>
lea    0xbbc(%rip),%rdi
lea    0xb0e(%rip),%rsi
mov    $0xc2,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
cmp    $0x1,%r13d
jne    14d0 <_glp_triang+0x390>
mov    %r14d,0xc(%rsp)
movslq 0x4(%rbp),%r14
test   %r14,%r14
mov    0x40(%rsp),%r13
mov    0x10(%rsp),%rax
jle    1560 <_glp_triang+0x420>
cmp    0x48(%rsp),%r14d
jg     1560 <_glp_triang+0x420>
cmpb   $0x2,(%rax,%r14,1)
jne    1586 <_glp_triang+0x446>
mov    0xc(%rsp),%r14d
jmp    14d5 <_glp_triang+0x395>
nopl   0x0(%rax)
lea    0xb7a(%rip),%rdi
lea    0xab7(%rip),%rsi
mov    $0xc6,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
mov    0x10(%rsp),%rax
cmpb   $0x2,(%rax,%r14,1)
je     154f <_glp_triang+0x40f>
movb   $0x2,(%rax,%r14,1)
mov    0xc(%rsp),%edx
movslq %edx,%rax
add    $0x1,%edx
mov    0x50(%rsp),%rcx
mov    %r14d,0x4(%rcx,%rax,4)
mov    %edx,%r14d
jmp    14d5 <_glp_triang+0x395>
test   %r15d,%r15d
je     1a9e <_glp_triang+0x95e>
movl   $0x0,0x2c(%rsp)
jmp    15d1 <_glp_triang+0x491>
nopw   0x0(%rax,%rax,1)
mov    0x84(%rsp),%r15d
test   %r15d,%r15d
je     1a9e <_glp_triang+0x95e>
test   %r14d,%r14d
mov    %r15d,0x84(%rsp)
je     1730 <_glp_triang+0x5f0>
movslq %r14d,%rax
mov    0x50(%rsp),%rcx
mov    (%rcx,%rax,4),%ebx
movslq %ebx,%rcx
mov    0x10(%rsp),%rax
mov    %rcx,0xb0(%rsp)
cmpb   $0x2,(%rax,%rcx,1)
je     161d <_glp_triang+0x4dd>
lea    0xae8(%rip),%rdi
lea    0xa14(%rip),%rsi
mov    $0xe0,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
mov    %ebx,0x80(%rsp)
mov    %ebx,%esi
neg    %esi
mov    0x78(%rsp),%rdi
mov    0x20(%rsp),%rdx
mov    0x18(%rsp),%rcx
call   *0x70(%rsp)
mov    %eax,%ebx
test   %eax,%eax
js     1646 <_glp_triang+0x506>
cmp    %r13d,%ebx
jle    1660 <_glp_triang+0x520>
lea    0x9c3(%rip),%rdi
lea    0x9d1(%rip),%rsi
mov    $0xe4,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
test   %ebx,%ebx
mov    %rbx,0x30(%rsp)
jle    1770 <_glp_triang+0x630>
mov    %r14d,0xc(%rsp)
lea    0x1(%rbx),%r13d
xor    %r15d,%r15d
mov    $0x1,%r14d
jmp    169c <_glp_triang+0x55c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r14d,%r15d
add    $0x1,%r14
cmp    %r14,%r13
je     1710 <_glp_triang+0x5d0>
mov    0x20(%rsp),%rax
movslq (%rax,%r14,4),%rbx
test   %rbx,%rbx
jle    16b0 <_glp_triang+0x570>
cmp    0x40(%rsp),%ebx
jle    16ca <_glp_triang+0x58a>
lea    0xa48(%rip),%rdi
lea    0x967(%rip),%rsi
mov    $0xe8,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
cmpl   $0x1,(%r12,%rbx,4)
jne    1693 <_glp_triang+0x553>
test   %r15d,%r15d
je     1690 <_glp_triang+0x550>
movslq %r15d,%rax
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movapd 0x915(%rip),%xmm2
andpd  %xmm2,%xmm0
movsd  (%rcx,%r14,8),%xmm1
andpd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
ja     1690 <_glp_triang+0x550>
jmp    1693 <_glp_triang+0x553>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r15d,%r15d
mov    0x40(%rsp),%r13
mov    0x90(%rsp),%rbx
mov    0xc(%rsp),%r14d
jg     1795 <_glp_triang+0x655>
jmp    177b <_glp_triang+0x63b>
nopl   0x0(%rax)
mov    %r15d,%esi
neg    %esi
mov    0x78(%rsp),%rdi
mov    0x20(%rsp),%rdx
mov    0x18(%rsp),%rcx
call   *0x70(%rsp)
test   %eax,%eax
mov    %rax,0x30(%rsp)
js     1827 <_glp_triang+0x6e7>
cmp    %r13d,%eax
jg     1827 <_glp_triang+0x6e7>
movl   $0x0,0xc(%rsp)
jmp    1849 <_glp_triang+0x709>
nopl   0x0(%rax,%rax,1)
xor    %r15d,%r15d
mov    0x90(%rsp),%rbx
lea    0x98e(%rip),%rdi
lea    0x89c(%rip),%rsi
mov    $0xef,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
add    $0xffffffff,%r14d
mov    %r14d,0xc(%rsp)
movslq %r15d,%rax
mov    0x18(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
andpd  0x84d(%rip),%xmm0
mov    0xb0(%rsp),%rcx
movsd  (%rbx,%rcx,8),%xmm1
mulsd  0xa8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    17f0 <_glp_triang+0x6b0>
mov    0x38(%rsp),%r14
mov    0x58(%rsp),%r15
mov    0x10(%rsp),%rax
mov    0x80(%rsp),%edx
jmp    185b <_glp_triang+0x71b>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
mov    0x2c(%rsp),%edx
movslq %edx,%rcx
add    $0x1,%edx
mov    %edx,0x2c(%rsp)
mov    0x98(%rsp),%rdx
mov    %eax,0x4(%rdx,%rcx,4)
mov    0xa0(%rsp),%rax
mov    0x80(%rsp),%edx
mov    %edx,0x4(%rax,%rcx,4)
jmp    184c <_glp_triang+0x70c>
movl   $0x0,0xc(%rsp)
lea    0x7da(%rip),%rdi
lea    0x7e8(%rip),%rsi
mov    $0xdb,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
mov    %r15d,%edx
mov    0x38(%rsp),%r14
mov    0x58(%rsp),%r15
mov    0x10(%rsp),%rax
movslq %edx,%rbx
cmpb   $0x0,(%rax,%rbx,1)
jne    1883 <_glp_triang+0x743>
lea    0x8ac(%rip),%rdi
lea    0x7b3(%rip),%rsi
mov    $0xfc,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
mov    0x10(%rsp),%rax
movb   $0x0,(%rax,%rbx,1)
movslq (%r15,%rbx,4),%rcx
mov    (%r14,%rbx,4),%eax
test   %rcx,%rcx
je     18a0 <_glp_triang+0x760>
mov    %eax,(%r14,%rcx,4)
mov    (%r14,%rbx,4),%eax
jmp    18a7 <_glp_triang+0x767>
xchg   %ax,%ax
mov    %eax,0x84(%rsp)
mov    0xc(%rsp),%r14d
test   %eax,%eax
je     18ba <_glp_triang+0x77a>
mov    (%r15,%rbx,4),%ecx
cltq
mov    %ecx,(%r15,%rax,4)
mov    0x30(%rsp),%rbx
test   %ebx,%ebx
jle    15c0 <_glp_triang+0x480>
add    $0x1,%ebx
mov    $0x1,%r15d
mov    %rbx,0x30(%rsp)
jmp    18f2 <_glp_triang+0x7b2>
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rbx
add    $0x1,%r15
cmp    %rbx,%r15
je     15c0 <_glp_triang+0x480>
mov    0x20(%rsp),%rax
movslq (%rax,%r15,4),%rbx
test   %rbx,%rbx
jle    1905 <_glp_triang+0x7c5>
cmp    %r13d,%ebx
jle    191f <_glp_triang+0x7df>
lea    0x7f3(%rip),%rdi
lea    0x712(%rip),%rsi
mov    $0x109,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
mov    (%r12,%rbx,4),%eax
test   %eax,%eax
jg     1945 <_glp_triang+0x805>
lea    0x7f1(%rip),%rdi
lea    0x6f0(%rip),%rsi
mov    $0x10a,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
mov    (%r12,%rbx,4),%eax
add    $0xffffffff,%eax
mov    %eax,(%r12,%rbx,4)
cmp    $0x1,%eax
jne    18e0 <_glp_triang+0x7a0>
mov    0x78(%rsp),%rdi
mov    %ebx,%esi
mov    %rbp,%rdx
mov    0x68(%rsp),%rcx
call   *0x70(%rsp)
mov    %eax,%ebx
test   %eax,%eax
js     1970 <_glp_triang+0x830>
cmp    0x48(%rsp),%ebx
jle    198a <_glp_triang+0x84a>
lea    0x7b3(%rip),%rdi
lea    0x6a7(%rip),%rsi
mov    $0x111,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
test   %ebx,%ebx
mov    %r14d,0xc(%rsp)
jle    1a39 <_glp_triang+0x8f9>
add    $0x1,%ebx
xor    %r14d,%r14d
mov    $0x1,%r13d
mov    0x10(%rsp),%rax
jmp    19bc <_glp_triang+0x87c>
nopw   0x0(%rax,%rax,1)
mov    %r13d,%r14d
add    $0x1,%r13
cmp    %r13,%rbx
je     1a20 <_glp_triang+0x8e0>
movslq 0x0(%rbp,%r13,4),%r12
test   %r12,%r12
jle    19cd <_glp_triang+0x88d>
cmp    0x48(%rsp),%r12d
jle    19ec <_glp_triang+0x8ac>
lea    0x76d(%rip),%rdi
lea    0x64a(%rip),%rsi
mov    $0x115,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
mov    0x10(%rsp),%rax
cmpb   $0x0,(%rax,%r12,1)
je     19b3 <_glp_triang+0x873>
test   %r14d,%r14d
je     19b0 <_glp_triang+0x870>
lea    0x755(%rip),%rdi
lea    0x61f(%rip),%rsi
mov    $0x117,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
mov    0x10(%rsp),%rax
jmp    19b0 <_glp_triang+0x870>
nopl   0x0(%rax)
test   %r14d,%r14d
mov    0x88(%rsp),%r12
mov    0x40(%rsp),%r13
mov    0x30(%rsp),%rbx
jg     1a5b <_glp_triang+0x91b>
jmp    1a41 <_glp_triang+0x901>
xor    %r14d,%r14d
mov    0x30(%rsp),%rbx
lea    0x714(%rip),%rdi
lea    0x5d6(%rip),%rsi
mov    $0x11b,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
movslq %r14d,%rax
mov    0x0(%rbp,%rax,4),%eax
cltq
mov    0x10(%rsp),%rcx
cmpb   $0x2,(%rcx,%rax,1)
jne    1a80 <_glp_triang+0x940>
mov    0xc(%rsp),%r14d
jmp    18e5 <_glp_triang+0x7a5>
nopl   0x0(%rax)
movb   $0x2,(%rcx,%rax,1)
mov    0xc(%rsp),%r14d
movslq %r14d,%rcx
add    $0x1,%r14d
mov    0x50(%rsp),%rdx
mov    %eax,0x4(%rdx,%rcx,4)
jmp    18e5 <_glp_triang+0x7a5>
test   %r13d,%r13d
jle    1ae6 <_glp_triang+0x9a6>
mov    $0x1,%ebx
lea    0x6b4(%rip),%r14
lea    0x56f(%rip),%r15
jmp    1acb <_glp_triang+0x98b>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,0x60(%rsp)
je     1ae6 <_glp_triang+0x9a6>
cmpl   $0x0,(%r12,%rbx,4)
je     1ac0 <_glp_triang+0x980>
mov    %r14,%rdi
mov    %r15,%rsi
mov    $0x128,%edx
xor    %eax,%eax
call   1050 <glp_assert_@plt>
jmp    1ac0 <_glp_triang+0x980>
mov    0x20(%rsp),%rdi
xor    %eax,%eax
call   1040 <glp_free@plt>
mov    0x18(%rsp),%rdi
xor    %eax,%eax
call   1040 <glp_free@plt>
mov    %rbp,%rdi
xor    %eax,%eax
call   1040 <glp_free@plt>
mov    0x68(%rsp),%rdi
xor    %eax,%eax
call   1040 <glp_free@plt>
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <glp_free@plt>
mov    0x50(%rsp),%rdi
xor    %eax,%eax
call   1040 <glp_free@plt>
mov    0x58(%rsp),%rdi
xor    %eax,%eax
call   1040 <glp_free@plt>
mov    0x38(%rsp),%rdi
xor    %eax,%eax
call   1040 <glp_free@plt>
mov    0x90(%rsp),%rdi
xor    %eax,%eax
call   1040 <glp_free@plt>
mov    0x10(%rsp),%rdi
xor    %eax,%eax
call   1040 <glp_free@plt>
mov    0x2c(%rsp),%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [21 x i8] c"0 <= len && len <= m\00"
@.str.1 = [167 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/triang.c\00"
@.str.2 = [21 x i8] c"0 <= len && len <= n\00"
@.str.3 = [17 x i8] c"1 <= j && j <= n\00"
@.str.4 = [13 x i8] c"flag[j] == 2\00"
@.str.5 = [17 x i8] c"1 <= i && i <= m\00"
@.str.6 = [7 x i8] c"kk > 0\00"
@.str.7 = [8 x i8] c"flag[j]\00"
@.str.8 = [11 x i8] c"cnt[i] > 0\00"
@.str.9 = [23 x i8] c"0 <= len2 && len2 <= n\00"
@.str.10 = [19 x i8] c"1 <= jj && jj <= n\00"
@.str.11 = [8 x i8] c"ks == 0\00"
@.str.12 = [7 x i8] c"ks > 0\00"
@.str.13 = [12 x i8] c"cnt[i] == 0\00"
define i32 @_glp_triang(i32 %0, i32 %1, i32 (i8*, i32, i32*, double*)* nocapture %2, i8* %3, double %4, i32* nocapture writeonly %5, i32* nocapture writeonly %6) {
%8 = add i32 %0, 1
%9 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @glp_alloc to i32 (i32, i64, ...)*)(i32 %8, i64 4)
%10 = sext i32 %9 to i64
%11 = inttoptr i64 %10 to i32*
%12 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @glp_alloc to i32 (i32, i64, ...)*)(i32 %8, i64 8)
%13 = sext i32 %12 to i64
%14 = inttoptr i64 %13 to double*
%15 = add i32 %1, 1
%16 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @glp_alloc to i32 (i32, i64, ...)*)(i32 %15, i64 4)
%17 = sext i32 %16 to i64
%18 = inttoptr i64 %17 to i32*
%19 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @glp_alloc to i32 (i32, i64, ...)*)(i32 %15, i64 8)
%20 = sext i32 %19 to i64
%21 = inttoptr i64 %20 to double*
%22 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @glp_alloc to i32 (i32, i64, ...)*)(i32 %8, i64 4)
%23 = sext i32 %22 to i64
%24 = inttoptr i64 %23 to i32*
%25 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @glp_alloc to i32 (i32, i64, ...)*)(i32 %15, i64 4)
%26 = sext i32 %25 to i64
%27 = inttoptr i64 %26 to i32*
%28 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @glp_alloc to i32 (i32, i64, ...)*)(i32 %15, i64 4)
%29 = sext i32 %28 to i64
%30 = inttoptr i64 %29 to i32*
%31 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @glp_alloc to i32 (i32, i64, ...)*)(i32 %15, i64 4)
%32 = sext i32 %31 to i64
%33 = inttoptr i64 %32 to i32*
%34 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @glp_alloc to i32 (i32, i64, ...)*)(i32 %15, i64 8)
%35 = sext i32 %34 to i64
%36 = inttoptr i64 %35 to double*
%37 = tail call i32 (i32, i64, ...) bitcast (i32 (...)* @glp_alloc to i32 (i32, i64, ...)*)(i32 %15, i64 1)
%38 = sext i32 %37 to i64
%39 = inttoptr i64 %38 to i8*
%40 = icmp slt i32 %0, 0
br i1 %40, label %46, label %41
41: ; preds = %7
%42 = inttoptr i64 %23 to i8*
%43 = zext i32 %0 to i64
%44 = shl nuw nsw i64 %43, 2
%45 = add nuw nsw i64 %44, 4
br label %46
46: ; preds = %41, %7
%47 = icmp slt i32 %1, 1
br i1 %47, label %50, label %48
48: ; preds = %46
%49 = zext i32 %15 to i64
br label %53
50: ; preds = %109, %46
br i1 %40, label %112, label %51
51: ; preds = %50
%52 = zext i32 %8 to i64
br label %117
53: ; preds = %48, %109
%54 = phi i64 [ 1, %48 ], [ %110, %109 ]
%55 = trunc i64 %54 to i32
%56 = sub i32 0, %55
%57 = tail call i32 %2(i8* %3, i32 %56, i32* %11, double* %14)
%58 = icmp slt i32 %57, 0
%59 = icmp sgt i32 %57, %0
%60 = or i1 %58, %59
br i1 %60, label %61, label %63
61: ; preds = %53
%62 = 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, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 136)
br label %63
63: ; preds = %53, %61
%64 = sext i32 %57 to i64
%65 = getelementptr inbounds i32, i32* %24, i64 %64
%66 = load i32, i32* %65
%67 = getelementptr inbounds i32, i32* %33, i64 %54
store i32 %66, i32* %67
%68 = trunc i64 %54 to i32
store i32 %68, i32* %65
%69 = getelementptr inbounds double, double* %36, i64 %54
store double 0.000000e+00, double* %69
%70 = icmp slt i32 %57, 1
br i1 %70, label %109, label %71
71: ; preds = %63
%72 = zext i32 %57 to i64
%73 = and i64 %72, 1
%74 = icmp eq i32 %57, 1
br i1 %74, label %99, label %75
75: ; preds = %71
%76 = and i64 %72, 4294967294
br label %77
77: ; preds = %94, %75
%78 = phi double [ 0.000000e+00, %75 ], [ %95, %94 ]
%79 = phi i64 [ 1, %75 ], [ %96, %94 ]
%80 = phi i64 [ 0, %75 ], [ %97, %94 ]
%81 = getelementptr inbounds double, double* %14, i64 %79
%82 = load double, double* %81
%83 = tail call double @llvm.fabs.f64(double %82)
%84 = fcmp olt double %78, %83
br i1 %84, label %85, label %86
85: ; preds = %77
store double %83, double* %69
br label %86
86: ; preds = %77, %85
%87 = phi double [ %78, %77 ], [ %83, %85 ]
%88 = add nuw nsw i64 %79, 1
%89 = getelementptr inbounds double, double* %14, i64 %88
%90 = load double, double* %89
%91 = tail call double @llvm.fabs.f64(double %90)
%92 = fcmp olt double %87, %91
br i1 %92, label %93, label %94
93: ; preds = %86
store double %91, double* %69
br label %94
94: ; preds = %93, %86
%95 = phi double [ %87, %86 ], [ %91, %93 ]
%96 = add nuw nsw i64 %79, 2
%97 = add i64 %80, 2
%98 = icmp eq i64 %97, %76
br i1 %98, label %99, label %77
99: ; preds = %94, %71
%100 = phi double [ 0.000000e+00, %71 ], [ %95, %94 ]
%101 = phi i64 [ 1, %71 ], [ %96, %94 ]
%102 = icmp eq i64 %73, 0
br i1 %102, label %109, label %103
103: ; preds = %99
%104 = getelementptr inbounds double, double* %14, i64 %101
%105 = load double, double* %104
%106 = tail call double @llvm.fabs.f64(double %105)
%107 = fcmp olt double %100, %106
br i1 %107, label %108, label %109
108: ; preds = %103
store double %106, double* %69
br label %109
109: ; preds = %99, %108, %103, %63
%110 = add nuw nsw i64 %54, 1
%111 = icmp eq i64 %110, %49
br i1 %111, label %50, label %53
112: ; preds = %136, %50
%113 = phi i32 [ 0, %50 ], [ %137, %136 ]
br i1 %47, label %140, label %114
114: ; preds = %112
%115 = getelementptr i8, i8* %39, i64 1
%116 = zext i32 %1 to i64
br label %140
117: ; preds = %51, %136
%118 = phi i64 [ 0, %51 ], [ %138, %136 ]
%119 = phi i32 [ 0, %51 ], [ %137, %136 ]
%120 = getelementptr inbounds i32, i32* %24, i64 %118
%121 = load i32, i32* %120
%122 = icmp eq i32 %121, 0
br i1 %122, label %136, label %123
123: ; preds = %117, %134
%124 = phi i32 [ %125, %134 ], [ %119, %117 ]
%125 = phi i32 [ %128, %134 ], [ %121, %117 ]
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32, i32* %33, i64 %126
%128 = load i32, i32* %127
%129 = getelementptr inbounds i32, i32* %30, i64 %126
store i32 0, i32* %129
store i32 %124, i32* %127
%130 = icmp eq i32 %124, 0
br i1 %130, label %134, label %131
131: ; preds = %123
%132 = sext i32 %124 to i64
%133 = getelementptr inbounds i32, i32* %30, i64 %132
store i32 %125, i32* %133
br label %134
134: ; preds = %131, %123
%135 = icmp eq i32 %128, 0
br i1 %135, label %136, label %123
136: ; preds = %134, %117
%137 = phi i32 [ %119, %117 ], [ %125, %134 ]
%138 = add nuw nsw i64 %118, 1
%139 = icmp eq i64 %138, %52
br i1 %139, label %112, label %117
140: ; preds = %114, %112
%141 = icmp slt i32 %0, 1
br i1 %141, label %145, label %142
142: ; preds = %140
%143 = getelementptr inbounds i32, i32* %18, i64 1
%144 = zext i32 %8 to i64
br label %148
145: ; preds = %177, %140
%146 = phi i32 [ 0, %140 ], [ %178, %177 ]
%147 = icmp eq i32 %113, 0
br i1 %147, label %184, label %188
148: ; preds = %142, %177
%149 = phi i64 [ 1, %142 ], [ %179, %177 ]
%150 = phi i32 [ 0, %142 ], [ %178, %177 ]
%151 = trunc i64 %149 to i32
%152 = tail call i32 %2(i8* %3, i32 %151, i32* %18, double* %21)
%153 = getelementptr inbounds i32, i32* %24, i64 %149
store i32 %152, i32* %153
%154 = icmp slt i32 %152, 0
%155 = icmp sgt i32 %152, %1
%156 = or i1 %154, %155
br i1 %156, label %157, label %159
157: ; preds = %148
%158 = 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.2, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 194)
br label %159
159: ; preds = %148, %157
%160 = icmp eq i32 %152, 1
br i1 %160, label %161, label %177
161: ; preds = %159
%162 = load i32, i32* %143
%163 = icmp slt i32 %162, 1
%164 = icmp sgt i32 %162, %1
%165 = or i1 %163, %164
br i1 %165, label %166, label %168
166: ; preds = %161
%167 = tail call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @glp_assert_ to i32 (i8*, i8*, i32, ...)*)(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 198)
br label %168
168: ; preds = %161, %166
%169 = sext i32 %162 to i64
%170 = getelementptr inbounds i8, i8* %39, i64 %169
%171 = load i8, i8* %170
%172 = icmp eq i8 %171, 2
br i1 %172, label %177, label %173
173: ; preds = %168
store i8 2, i8* %170
%174 = add nsw i32 %150, 1
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i32, i32* %27, i64 %175
store i32 %162, i32* %176
br label %177
177: ; preds = %159, %173, %168
%178 = phi i32 [ %174, %173 ], [ %150, %168 ], [ %150, %159 ]
%179 = add nuw nsw i64 %149, 1
%180 = icmp eq i64 %179, %144
br i1 %180, label %145, label %148
181: ; preds = %389, %308
%182 = phi i32 [ %281, %308 ], [ %390, %389 ]
%183 = icmp eq i32 %302, 0
br i1 %183, label %184, label %188
184: ; preds = %181, %145
%185 = phi i32 [ 0, %145 ], [ %280, %181 ]
br i1 %141, label %403, label %186
186: ; preds = %184
%187 = zext i32 %8 to i64
br label %393
188: ; preds = %145, %181
%189 = phi i32 [ %302, %181 ], [ %113, %145 ]
%190 = phi i32 [ %182, %181 ], [ %146, %145 ]
%191 = phi i32 [ %280, %181 ], [ 0, %145 ]
%192 = icmp eq i32 %190, 0
br i1 %192, label %193, label %201
193: ; preds = %188
%194 = sub nsw i32 0, %189
%195 = tail call i32 %2(i8* %3, i32 %194, i32* %11, double* %14)
%196 = icmp slt i32 %195, 0
%197 = icmp sgt i32 %195, %0
%198 = or i1 %196, %197
br i1 %198, label %199, label %279
199: ; preds = %193
%200 = 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, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 219)
br label %279
201: ; preds = %188
%202 = add nsw i32 %190, -1
%203 = sext i32 %190 to i64
%204 = getelementptr inbounds i32, i32* %27, i64 %203
%205 = load i32, i32* %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i8, i8* %39, i64 %206
%208 = load i8, i8* %207
%209 = icmp eq i8 %208, 2
br i1 %209, label %212, label %210
210: ; preds = %201
%211 = tail call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @glp_assert_ to i32 (i8*, i8*, i32, ...)*)(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 224)
br label %212
212: ; preds = %210, %201
%213 = sub nsw i32 0, %205
%214 = tail call i32 %2(i8* %3, i32 %213, i32* %11, double* %14)
%215 = icmp slt i32 %214, 0
%216 = icmp sgt i32 %214, %0
%217 = or i1 %215, %216
br i1 %217, label %218, label %220
218: ; preds = %212
%219 = 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, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 228)
br label %220
220: ; preds = %212, %218
%221 = icmp slt i32 %214, 1
br i1 %221, label %259, label %222
222: ; preds = %220
%223 = add nuw i32 %214, 1
%224 = zext i32 %223 to i64
br label %225
225: ; preds = %222, %253
%226 = phi i64 [ 1, %222 ], [ %255, %253 ]
%227 = phi i32 [ 0, %222 ], [ %254, %253 ]
%228 = getelementptr inbounds i32, i32* %11, i64 %226
%229 = load i32, i32* %228
%230 = icmp slt i32 %229, 1
%231 = icmp sgt i32 %229, %0
%232 = or i1 %230, %231
br i1 %232, label %233, label %235
233: ; preds = %225
%234 = tail call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @glp_assert_ to i32 (i8*, i8*, i32, ...)*)(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 232)
br label %235
235: ; preds = %225, %233
%236 = sext i32 %229 to i64
%237 = getelementptr inbounds i32, i32* %24, i64 %236
%238 = load i32, i32* %237
%239 = icmp eq i32 %238, 1
br i1 %239, label %240, label %253
240: ; preds = %235
%241 = icmp eq i32 %227, 0
br i1 %241, label %251, label %242
242: ; preds = %240
%243 = sext i32 %227 to i64
%244 = getelementptr inbounds double, double* %14, i64 %243
%245 = load double, double* %244
%246 = tail call double @llvm.fabs.f64(double %245)
%247 = getelementptr inbounds double, double* %14, i64 %226
%248 = load double, double* %247
%249 = tail call double @llvm.fabs.f64(double %248)
%250 = fcmp olt double %246, %249
br i1 %250, label %251, label %253
251: ; preds = %242, %240
%252 = trunc i64 %226 to i32
br label %253
253: ; preds = %235, %251, %242
%254 = phi i32 [ %252, %251 ], [ %227, %242 ], [ %227, %235 ]
%255 = add nuw nsw i64 %226, 1
%256 = icmp eq i64 %255, %224
br i1 %256, label %257, label %225
257: ; preds = %253
%258 = icmp sgt i32 %254, 0
br i1 %258, label %262, label %259
259: ; preds = %220, %257
%260 = phi i32 [ %254, %257 ], [ 0, %220 ]
%261 = 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.6, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 239)
br label %262
262: ; preds = %259, %257
%263 = phi i32 [ %260, %259 ], [ %254, %257 ]
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds double, double* %14, i64 %264
%266 = load double, double* %265
%267 = tail call double @llvm.fabs.f64(double %266)
%268 = getelementptr inbounds double, double* %36, i64 %206
%269 = load double, double* %268
%270 = fmul double %269, %4
%271 = fcmp olt double %267, %270
br i1 %271, label %279, label %272
272: ; preds = %262
%273 = add nsw i32 %191, 1
%274 = getelementptr inbounds i32, i32* %11, i64 %264
%275 = load i32, i32* %274
%276 = sext i32 %273 to i64
%277 = getelementptr inbounds i32, i32* %5, i64 %276
store i32 %275, i32* %277
%278 = getelementptr inbounds i32, i32* %6, i64 %276
store i32 %205, i32* %278
br label %279
279: ; preds = %199, %193, %262, %272
%280 = phi i32 [ %191, %262 ], [ %273, %272 ], [ %191, %193 ], [ %191, %199 ]
%281 = phi i32 [ %202, %262 ], [ %202, %272 ], [ 0, %193 ], [ 0, %199 ]
%282 = phi i32 [ %214, %262 ], [ %214, %272 ], [ %195, %193 ], [ %195, %199 ]
%283 = phi i32 [ %205, %262 ], [ %205, %272 ], [ %189, %193 ], [ %189, %199 ]
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i8, i8* %39, i64 %284
%286 = load i8, i8* %285
%287 = icmp eq i8 %286, 0
br i1 %287, label %288, label %290
288: ; preds = %279
%289 = 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.7, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 252)
br label %290
290: ; preds = %288, %279
store i8 0, i8* %285
%291 = getelementptr inbounds i32, i32* %30, i64 %284
%292 = load i32, i32* %291
%293 = icmp eq i32 %292, 0
%294 = getelementptr inbounds i32, i32* %33, i64 %284
%295 = load i32, i32* %294
br i1 %293, label %300, label %296
296: ; preds = %290
%297 = sext i32 %292 to i64
%298 = getelementptr inbounds i32, i32* %33, i64 %297
store i32 %295, i32* %298
%299 = load i32, i32* %294
br label %300
300: ; preds = %290, %296
%301 = phi i32 [ %299, %296 ], [ %295, %290 ]
%302 = phi i32 [ %189, %296 ], [ %295, %290 ]
%303 = icmp eq i32 %301, 0
br i1 %303, label %308, label %304
304: ; preds = %300
%305 = load i32, i32* %291
%306 = sext i32 %301 to i64
%307 = getelementptr inbounds i32, i32* %30, i64 %306
store i32 %305, i32* %307
br label %308
308: ; preds = %300, %304
%309 = icmp slt i32 %282, 1
br i1 %309, label %181, label %310
310: ; preds = %308
%311 = add nuw i32 %282, 1
%312 = zext i32 %311 to i64
br label %313
313: ; preds = %310, %389
%314 = phi i64 [ 1, %310 ], [ %391, %389 ]
%315 = phi i32 [ %281, %310 ], [ %390, %389 ]
%316 = getelementptr inbounds i32, i32* %11, i64 %314
%317 = load i32, i32* %316
%318 = icmp slt i32 %317, 1
%319 = icmp sgt i32 %317, %0
%320 = or i1 %318, %319
br i1 %320, label %321, label %323
321: ; preds = %313
%322 = tail call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @glp_assert_ to i32 (i8*, i8*, i32, ...)*)(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 265)
br label %323
323: ; preds = %313, %321
%324 = sext i32 %317 to i64
%325 = getelementptr inbounds i32, i32* %24, i64 %324
%326 = load i32, i32* %325
%327 = icmp sgt i32 %326, 0
br i1 %327, label %331, label %328
328: ; preds = %323
%329 = tail call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @glp_assert_ to i32 (i8*, i8*, i32, ...)*)(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 266)
%330 = load i32, i32* %325
br label %331
331: ; preds = %328, %323
%332 = phi i32 [ %330, %328 ], [ %326, %323 ]
%333 = add nsw i32 %332, -1
store i32 %333, i32* %325
%334 = icmp eq i32 %333, 1
br i1 %334, label %335, label %389
335: ; preds = %331
%336 = tail call i32 %2(i8* %3, i32 %317, i32* %18, double* %21)
%337 = icmp slt i32 %336, 0
%338 = icmp sgt i32 %336, %1
%339 = or i1 %337, %338
br i1 %339, label %340, label %342
340: ; preds = %335
%341 = tail call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @glp_assert_ to i32 (i8*, i8*, i32, ...)*)(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 273)
br label %342
342: ; preds = %335, %340
%343 = icmp slt i32 %336, 1
br i1 %343, label %373, label %344
344: ; preds = %342
%345 = add nuw i32 %336, 1
%346 = zext i32 %345 to i64
br label %347
347: ; preds = %344, %367
%348 = phi i64 [ 1, %344 ], [ %369, %367 ]
%349 = phi i32 [ 0, %344 ], [ %368, %367 ]
%350 = getelementptr inbounds i32, i32* %18, i64 %348
%351 = load i32, i32* %350
%352 = icmp slt i32 %351, 1
%353 = icmp sgt i32 %351, %1
%354 = or i1 %352, %353
br i1 %354, label %355, label %357
355: ; preds = %347
%356 = tail call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @glp_assert_ to i32 (i8*, i8*, i32, ...)*)(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 277)
br label %357
357: ; preds = %347, %355
%358 = sext i32 %351 to i64
%359 = getelementptr inbounds i8, i8* %39, i64 %358
%360 = load i8, i8* %359
%361 = icmp eq i8 %360, 0
br i1 %361, label %367, label %362
362: ; preds = %357
%363 = icmp eq i32 %349, 0
%364 = trunc i64 %348 to i32
br i1 %363, label %367, label %365
365: ; preds = %362
%366 = 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.11, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 279)
br label %367
367: ; preds = %362, %365, %357
%368 = phi i32 [ %349, %357 ], [ %364, %365 ], [ %364, %362 ]
%369 = add nuw nsw i64 %348, 1
%370 = icmp eq i64 %369, %346
br i1 %370, label %371, label %347
371: ; preds = %367
%372 = icmp sgt i32 %368, 0
br i1 %372, label %376, label %373
373: ; preds = %342, %371
%374 = phi i32 [ %368, %371 ], [ 0, %342 ]
%375 = 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.12, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 283)
br label %376
376: ; preds = %373, %371
%377 = phi i32 [ %374, %373 ], [ %368, %371 ]
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds i32, i32* %18, i64 %378
%380 = load i32, i32* %379
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds i8, i8* %39, i64 %381
%383 = load i8, i8* %382
%384 = icmp eq i8 %383, 2
br i1 %384, label %389, label %385
385: ; preds = %376
store i8 2, i8* %382
%386 = add nsw i32 %315, 1
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds i32, i32* %27, i64 %387
store i32 %380, i32* %388
br label %389
389: ; preds = %331, %385, %376
%390 = phi i32 [ %386, %385 ], [ %315, %376 ], [ %315, %331 ]
%391 = add nuw nsw i64 %314, 1
%392 = icmp eq i64 %391, %312
br i1 %392, label %181, label %313
393: ; preds = %186, %400
%394 = phi i64 [ 1, %186 ], [ %401, %400 ]
%395 = getelementptr inbounds i32, i32* %24, i64 %394
%396 = load i32, i32* %395
%397 = icmp eq i32 %396, 0
br i1 %397, label %400, label %398
398: ; preds = %393
%399 = 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.13, i64 0, i64 0), i8* getelementptr inbounds ([167 x i8], [167 x i8]* @.str.1, i64 0, i64 0), i32 296)
br label %400
400: ; preds = %398, %393
%401 = add nuw nsw i64 %394, 1
%402 = icmp eq i64 %401, %187
br i1 %402, label %403, label %393
403: ; preds = %400, %184
%404 = tail call i32 (i32*, ...) bitcast (i32 (...)* @glp_free to i32 (i32*, ...)*)(i32* %11)
%405 = tail call i32 (double*, ...) bitcast (i32 (...)* @glp_free to i32 (double*, ...)*)(double* %14)
%406 = tail call i32 (i32*, ...) bitcast (i32 (...)* @glp_free to i32 (i32*, ...)*)(i32* %18)
%407 = tail call i32 (double*, ...) bitcast (i32 (...)* @glp_free to i32 (double*, ...)*)(double* %21)
%408 = tail call i32 (i32*, ...) bitcast (i32 (...)* @glp_free to i32 (i32*, ...)*)(i32* %24)
%409 = tail call i32 (i32*, ...) bitcast (i32 (...)* @glp_free to i32 (i32*, ...)*)(i32* %27)
%410 = tail call i32 (i32*, ...) bitcast (i32 (...)* @glp_free to i32 (i32*, ...)*)(i32* %30)
%411 = tail call i32 (i32*, ...) bitcast (i32 (...)* @glp_free to i32 (i32*, ...)*)(i32* %33)
%412 = tail call i32 (double*, ...) bitcast (i32 (...)* @glp_free to i32 (double*, ...)*)(double* %36)
%413 = tail call i32 (i8*, ...) bitcast (i32 (...)* @glp_free to i32 (i8*, ...)*)(i8* %39)
ret i32 %185
}