#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ delnb_(int *, int *, int *, int *, int *, int *, int *,
                          int *);
int left_(double *, double *, double *, double *, double *, double *, double *,
          double *, double *);
int lstptr_(int *, int *, int *, int *);
int nbcnt_(int *, int *);
int /*<<< orphan*/ optim_(double *, double *, double *, int *, int *, int *,
                          int *, int *, int *, int *);
int /*<<< orphan*/ swap_(int *, int *, int *, int *, int *, int *, int *,
                         int *);
int delnod_(int *k, int *n, double *x, double *y, double *z__, int *list,
            int *lptr, int *lend, int *lnew, int *lwk, int *iwk, int *ier) {
  int i__1;
  static int i__, j, n1, n2;
  static double x1, x2, y11, y2, z1, z2;
  static int nl, lp, nn, nr;
  static double xl, yl, zl, xr, yr, zr;
  static int nnb, lp21, lpf, lph, lpl, lpn, iwl, nit, lnw, lpl2;
  static int bdry;
  static int ierr, lwkl;
  static int nfrst;
  iwk -= 3;
  --lend;
  --lptr;
  --list;
  --z__;
  --y;
  --x;
  n1 = *k;
  nn = *n;
  if (n1 < 1 || n1 > nn || nn < 4 || *lwk < 0) {
    goto L21;
  }
  lpl = lend[n1];
  lpf = lptr[lpl];
  nnb = nbcnt_(&lpl, &lptr[1]);
  bdry = list[lpl] < 0;
  if (bdry) {
    ++nnb;
  }
  if (nnb < 3) {
    goto L23;
  }
  lwkl = *lwk;
  *lwk = nnb - 3;
  if (lwkl < *lwk) {
    goto L22;
  }
  iwl = 0;
  if (nnb == 3) {
    goto L3;
  }
  x1 = x[n1];
  y11 = y[n1];
  z1 = z__[n1];
  nfrst = list[lpf];
  nr = nfrst;
  xr = x[nr];
  yr = y[nr];
  zr = z__[nr];
  lp = lptr[lpf];
  n2 = list[lp];
  x2 = x[n2];
  y2 = y[n2];
  z2 = z__[n2];
  lp = lptr[lp];
L1:
  nl = (i__1 = list[lp], ((i__1) >= 0 ? (i__1) : -(i__1)));
  if (nl == nfrst && bdry) {
    goto L3;
  }
  xl = x[nl];
  yl = y[nl];
  zl = z__[nl];
  lpl2 = lend[n2];
  if (!((bdry || left_(&xr, &yr, &zr, &xl, &yl, &zl, &x1, &y11, &z1)) &&
        (list[lpl2] < 0 ||
         left_(&xl, &yl, &zl, &xr, &yr, &zr, &x2, &y2, &z2)))) {
    nr = n2;
    xr = x2;
    yr = y2;
    zr = z2;
    goto L2;
  }
  swap_(&nl, &nr, &n1, &n2, &list[1], &lptr[1], &lend[1], &lp21);
  if (lp21 == 0) {
    nr = n2;
    xr = x2;
    yr = y2;
    zr = z2;
    goto L2;
  }
  ++iwl;
  if (nl <= n1) {
    iwk[(iwl << 1) + 1] = nl;
  } else {
    iwk[(iwl << 1) + 1] = nl - 1;
  }
  if (nr <= n1) {
    iwk[(iwl << 1) + 2] = nr;
  } else {
    iwk[(iwl << 1) + 2] = nr - 1;
  }
  lpl = lend[n1];
  --nnb;
  if (nnb == 3) {
    goto L3;
  }
  lpf = lptr[lpl];
  nfrst = list[lpf];
  lp = lstptr_(&lpl, &nl, &list[1], &lptr[1]);
  if (nr == nfrst) {
    goto L2;
  }
  n2 = nr;
  x2 = xr;
  y2 = yr;
  z2 = zr;
  lp21 = lptr[lp21];
  lp21 = lptr[lp21];
  nr = (i__1 = list[lp21], ((i__1) >= 0 ? (i__1) : -(i__1)));
  xr = x[nr];
  yr = y[nr];
  zr = z__[nr];
  goto L1;
L2:
  if (n2 == nfrst) {
    goto L3;
  }
  n2 = nl;
  x2 = xl;
  y2 = yl;
  z2 = zl;
  lp = lptr[lp];
  goto L1;
L3:
  if (!bdry) {
    if (nnb > 3) {
      bdry = (1);
    } else {
      lpf = lptr[lpl];
      nr = list[lpf];
      lp = lptr[lpf];
      n2 = list[lp];
      nl = list[lpl];
      bdry = left_(&x[nr], &y[nr], &z__[nr], &x[nl], &y[nl], &z__[nl], &x[n2],
                   &y[n2], &z__[n2]);
    }
    if (bdry) {
      i__1 = nn;
      for (i__ = 1; i__ <= i__1; ++i__) {
        if (list[lend[i__]] < 0) {
          bdry = (0);
          goto L5;
        }
      }
      list[lpl] = -list[lpl];
      ++nnb;
    }
  }
L5:
  if (!bdry && nnb > 3) {
    goto L24;
  }
  lp = lpl;
  lnw = *lnew;
L6:
  lp = lptr[lp];
  n2 = (i__1 = list[lp], ((i__1) >= 0 ? (i__1) : -(i__1)));
  delnb_(&n2, &n1, n, &list[1], &lptr[1], &lend[1], &lnw, &lph);
  if (lph < 0) {
    goto L23;
  }
  if (lpl == lnw) {
    lpl = lph;
  }
  if (lp == lnw) {
    lp = lph;
  }
  if (lp != lpl) {
    goto L6;
  }
  --nn;
  if (n1 > nn) {
    goto L9;
  }
  i__1 = nn;
  for (i__ = n1; i__ <= i__1; ++i__) {
    x[i__] = x[i__ + 1];
    y[i__] = y[i__ + 1];
    z__[i__] = z__[i__ + 1];
    lend[i__] = lend[i__ + 1];
  }
  i__1 = lnw - 1;
  for (i__ = 1; i__ <= i__1; ++i__) {
    if (list[i__] > n1) {
      --list[i__];
    }
    if (list[i__] < -n1) {
      ++list[i__];
    }
  }
L9:
  if (bdry) {
    --nnb;
  }
  lpn = lpl;
  i__1 = nnb;
  for (j = 1; j <= i__1; ++j) {
    --lnw;
    lp = lpn;
    lpn = lptr[lp];
    list[lp] = list[lnw];
    lptr[lp] = lptr[lnw];
    if (lptr[lpn] == lnw) {
      lptr[lpn] = lp;
    }
    if (lpn == lnw) {
      lpn = lp;
    }
    for (i__ = nn; i__ >= 1; --i__) {
      if (lend[i__] == lnw) {
        lend[i__] = lp;
        goto L11;
      }
    }
  L11:
    for (i__ = lnw - 1; i__ >= 1; --i__) {
      if (lptr[i__] == lnw) {
        lptr[i__] = lp;
      }
    }
  }
  *n = nn;
  *lnew = lnw;
  if (iwl > 0) {
    nit = iwl << 2;
    optim_(&x[1], &y[1], &z__[1], &iwl, &list[1], &lptr[1], &lend[1], &nit,
           &iwk[3], &ierr);
    if (ierr != 0 && ierr != 1) {
      goto L25;
    }
    if (ierr == 1) {
      goto L26;
    }
  }
  *ier = 0;
  return 0;
L21:
  *ier = 1;
  return 0;
L22:
  *ier = 2;
  return 0;
L23:
  *ier = 3;
  return 0;
L24:
  *ier = 4;
  return 0;
L25:
  *ier = 5;
  return 0;
L26:
  *ier = 6;
  return 0;
}


x86 assembly (clang, -O0):
<delnod_>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x68,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffff4,%rax
mov    %rax,0x30(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rbp)
mov    -0x40(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x3e67(%rip)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x3e9b(%rip)
cmpl   $0x1,0x3e54(%rip)
jl     123e <delnod_+0xde>
mov    0x3e48(%rip),%eax
cmp    0x3e82(%rip),%eax
jg     123e <delnod_+0xde>
cmpl   $0x4,0x3e75(%rip)
jl     123e <delnod_+0xde>
mov    0x28(%rbp),%rax
cmpl   $0x0,(%rax)
jge    1243 <delnod_+0xe3>
jmp    20d6 <delnod_+0xf76>
mov    0x18(%rbp),%rax
movslq 0x3e12(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3e91(%rip)
mov    0x10(%rbp),%rax
movslq 0x3e86(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3e75(%rip)
mov    0x10(%rbp),%rsi
add    $0x4,%rsi
lea    0x3e6e(%rip),%rdi
call   1080 <nbcnt_@plt>
mov    %eax,0x3e53(%rip)
mov    -0x40(%rbp),%rax
movslq 0x3e58(%rip),%rcx
cmpl   $0x0,(%rax,%rcx,4)
setl   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,0x3e5e(%rip)
cmpl   $0x0,0x3e57(%rip)
je     12be <delnod_+0x15e>
mov    0x3e23(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3e1a(%rip)
cmpl   $0x3,0x3e13(%rip)
jge    12d0 <delnod_+0x170>
jmp    2102 <delnod_+0xfa2>
mov    0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x3e2c(%rip)
mov    0x3df6(%rip),%ecx
sub    $0x3,%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    0x3e17(%rip),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    1302 <delnod_+0x1a2>
jmp    20ec <delnod_+0xf8c>
movl   $0x0,0x3de4(%rip)
cmpl   $0x3,0x3dc5(%rip)
jne    131e <delnod_+0x1be>
jmp    195d <delnod_+0x7fd>
mov    -0x28(%rbp),%rax
movslq 0x3d37(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d32(%rip)
mov    -0x30(%rbp),%rax
movslq 0x3d1f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d2a(%rip)
mov    -0x38(%rbp),%rax
movslq 0x3d07(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d22(%rip)
mov    -0x40(%rbp),%rax
movslq 0x3d6f(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3d92(%rip)
mov    0x3d8c(%rip),%eax
mov    %eax,0x3d1e(%rip)
mov    -0x28(%rbp),%rax
movslq 0x3d13(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d22(%rip)
mov    -0x30(%rbp),%rax
movslq 0x3cfb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d12(%rip)
mov    -0x38(%rbp),%rax
movslq 0x3ce3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d02(%rip)
mov    0x10(%rbp),%rax
movslq 0x3d07(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3cba(%rip)
mov    -0x40(%rbp),%rax
movslq 0x3caf(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3c6e(%rip)
mov    -0x28(%rbp),%rax
movslq 0x3c63(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3c62(%rip)
mov    -0x30(%rbp),%rax
movslq 0x3c4b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3c5a(%rip)
mov    -0x38(%rbp),%rax
movslq 0x3c33(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3c52(%rip)
mov    0x10(%rbp),%rax
movslq 0x3c53(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3c4a(%rip)
mov    -0x40(%rbp),%rax
movslq 0x3c3f(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     1478 <delnod_+0x318>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1480 <delnod_+0x320>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,0x3c0f(%rip)
mov    0x3c09(%rip),%eax
cmp    0x3c77(%rip),%eax
jne    14ad <delnod_+0x34d>
cmpl   $0x0,0x3c5e(%rip)
je     14ad <delnod_+0x34d>
jmp    195d <delnod_+0x7fd>
mov    -0x28(%rbp),%rax
movslq 0x3be0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3be3(%rip)
mov    -0x30(%rbp),%rax
movslq 0x3bc8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3bd3(%rip)
mov    -0x38(%rbp),%rax
movslq 0x3bb0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3bc3(%rip)
mov    0x18(%rbp),%rax
movslq 0x3b64(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3bf3(%rip)
cmpl   $0x0,0x3bf0(%rip)
jne    1571 <delnod_+0x411>
lea    0x3ba3(%rip),%rdi
lea    0x3ba4(%rip),%rsi
lea    0x3ba5(%rip),%rdx
lea    0x3b76(%rip),%rcx
lea    0x3b77(%rip),%r8
lea    0x3b78(%rip),%r9
lea    0x3b21(%rip),%r11
lea    0x3b2a(%rip),%r10
lea    0x3b33(%rip),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%eax
je     15e1 <delnod_+0x481>
mov    -0x40(%rbp),%rax
movslq 0x3b80(%rip),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     1622 <delnod_+0x4c2>
lea    0x3b1b(%rip),%rdi
lea    0x3b1c(%rip),%rsi
lea    0x3b1d(%rip),%rdx
lea    0x3b1e(%rip),%rcx
lea    0x3b1f(%rip),%r8
lea    0x3b20(%rip),%r9
lea    0x3ab9(%rip),%r11
lea    0x3ac2(%rip),%r10
lea    0x3acb(%rip),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%eax
jne    1622 <delnod_+0x4c2>
mov    0x3a7d(%rip),%eax
mov    %eax,0x3ab7(%rip)
movsd  0x3a7b(%rip),%xmm0
movsd  %xmm0,0x3ac3(%rip)
movsd  0x3a7b(%rip),%xmm0
movsd  %xmm0,0x3abb(%rip)
movsd  0x3a7b(%rip),%xmm0
movsd  %xmm0,0x3ab3(%rip)
jmp    18f1 <delnod_+0x791>
mov    -0x40(%rbp),%r8
add    $0x4,%r8
mov    0x10(%rbp),%r9
add    $0x4,%r9
mov    0x18(%rbp),%r10
add    $0x4,%r10
lea    0x3a57(%rip),%rdi
lea    0x3a5c(%rip),%rsi
lea    0x3a11(%rip),%rdx
lea    0x3a0e(%rip),%rcx
lea    0x3a7f(%rip),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1050 <swap_@plt>
cmpl   $0x0,0x3a6a(%rip)
jne    16b9 <delnod_+0x559>
mov    0x39e6(%rip),%eax
mov    %eax,0x3a20(%rip)
movsd  0x39e4(%rip),%xmm0
movsd  %xmm0,0x3a2c(%rip)
movsd  0x39e4(%rip),%xmm0
movsd  %xmm0,0x3a24(%rip)
movsd  0x39e4(%rip),%xmm0
movsd  %xmm0,0x3a1c(%rip)
jmp    18f1 <delnod_+0x791>
mov    0x3a31(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3a28(%rip)
mov    0x39ca(%rip),%eax
cmp    0x398c(%rip),%eax
jg     16fb <delnod_+0x59b>
mov    0x39b8(%rip),%edx
mov    0x30(%rbp),%rax
mov    0x3a06(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    171a <delnod_+0x5ba>
mov    0x3997(%rip),%edx
sub    $0x1,%edx
mov    0x30(%rbp),%rax
mov    0x39e2(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3984(%rip),%eax
cmp    0x393a(%rip),%eax
jg     174d <delnod_+0x5ed>
mov    0x3972(%rip),%edx
mov    0x30(%rbp),%rax
mov    0x39b4(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    176c <delnod_+0x60c>
mov    0x3951(%rip),%edx
sub    $0x1,%edx
mov    0x30(%rbp),%rax
mov    0x3990(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq 0x38e9(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3968(%rip)
mov    0x3952(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x3949(%rip)
cmpl   $0x3,0x3942(%rip)
jne    17a1 <delnod_+0x641>
jmp    195d <delnod_+0x7fd>
mov    0x10(%rbp),%rax
movslq 0x393c(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x392b(%rip)
mov    -0x40(%rbp),%rax
movslq 0x3920(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3943(%rip)
mov    -0x40(%rbp),%rdx
add    $0x4,%rdx
mov    0x10(%rbp),%rcx
add    $0x4,%rcx
lea    0x3908(%rip),%rdi
lea    0x38b1(%rip),%rsi
call   1040 <lstptr_@plt>
mov    %eax,0x38aa(%rip)
mov    0x38ac(%rip),%eax
cmp    0x390e(%rip),%eax
jne    1809 <delnod_+0x6a9>
jmp    18f1 <delnod_+0x791>
mov    0x3895(%rip),%eax
mov    %eax,0x384f(%rip)
movsd  0x38a3(%rip),%xmm0
movsd  %xmm0,0x384b(%rip)
movsd  0x389b(%rip),%xmm0
movsd  %xmm0,0x384b(%rip)
movsd  0x3893(%rip),%xmm0
movsd  %xmm0,0x384b(%rip)
mov    0x10(%rbp),%rax
movslq 0x388c(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3883(%rip)
mov    0x10(%rbp),%rax
movslq 0x3878(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x386f(%rip)
mov    -0x40(%rbp),%rax
movslq 0x3864(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     1893 <delnod_+0x733>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    189b <delnod_+0x73b>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,0x3800(%rip)
mov    -0x28(%rbp),%rax
movslq 0x37f5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3804(%rip)
mov    -0x30(%rbp),%rax
movslq 0x37dd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x37f4(%rip)
mov    -0x38(%rbp),%rax
movslq 0x37c5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x37e4(%rip)
jmp    1452 <delnod_+0x2f2>
mov    0x376d(%rip),%eax
cmp    0x380f(%rip),%eax
jne    1908 <delnod_+0x7a8>
jmp    195d <delnod_+0x7fd>
mov    0x378a(%rip),%eax
mov    %eax,0x3750(%rip)
movsd  0x378c(%rip),%xmm0
movsd  %xmm0,0x374c(%rip)
movsd  0x3784(%rip),%xmm0
movsd  %xmm0,0x374c(%rip)
movsd  0x377c(%rip),%xmm0
movsd  %xmm0,0x374c(%rip)
mov    0x10(%rbp),%rax
movslq 0x374d(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3744(%rip)
jmp    1452 <delnod_+0x2f2>
cmpl   $0x0,0x379c(%rip)
jne    1b4b <delnod_+0x9eb>
cmpl   $0x3,0x3767(%rip)
jle    1986 <delnod_+0x826>
movl   $0x1,0x377f(%rip)
jmp    1aa5 <delnod_+0x945>
mov    0x10(%rbp),%rax
movslq 0x3757(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3746(%rip)
mov    -0x40(%rbp),%rax
movslq 0x373b(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x36f6(%rip)
mov    0x10(%rbp),%rax
movslq 0x3727(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x36da(%rip)
mov    -0x40(%rbp),%rax
movslq 0x36cf(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x368e(%rip)
mov    -0x40(%rbp),%rax
movslq 0x3707(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x36ae(%rip)
mov    -0x28(%rbp),%rdi
movslq 0x36af(%rip),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
movslq 0x369d(%rip),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x38(%rbp),%rdx
movslq 0x368b(%rip),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x28(%rbp),%rcx
movslq 0x366d(%rip),%rax
shl    $0x3,%rax
add    %rax,%rcx
mov    -0x30(%rbp),%r8
movslq 0x365b(%rip),%rax
shl    $0x3,%rax
add    %rax,%r8
mov    -0x38(%rbp),%r9
movslq 0x3649(%rip),%rax
shl    $0x3,%rax
add    %rax,%r9
mov    -0x28(%rbp),%r11
movslq 0x3603(%rip),%rax
shl    $0x3,%rax
add    %rax,%r11
mov    -0x30(%rbp),%r10
movslq 0x35f1(%rip),%rax
shl    $0x3,%rax
add    %rax,%r10
mov    -0x38(%rbp),%rax
movslq 0x35df(%rip),%rbx
shl    $0x3,%rbx
add    %rbx,%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
mov    %eax,0x365b(%rip)
cmpl   $0x0,0x3654(%rip)
je     1b46 <delnod_+0x9e6>
mov    0x35e8(%rip),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,0x3593(%rip)
mov    0x358d(%rip),%eax
cmp    -0x44(%rbp),%eax
jg     1b19 <delnod_+0x9b9>
mov    -0x40(%rbp),%rax
mov    0x18(%rbp),%rcx
movslq 0x3575(%rip),%rdx
movslq (%rcx,%rdx,4),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1b00 <delnod_+0x9a0>
movl   $0x0,0x3605(%rip)
jmp    1b50 <delnod_+0x9f0>
jmp    1b05 <delnod_+0x9a5>
mov    0x354d(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3544(%rip)
jmp    1ac5 <delnod_+0x965>
mov    -0x40(%rbp),%rax
movslq 0x35c4(%rip),%rcx
xor    %edx,%edx
sub    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq 0x35b4(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x359b(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3592(%rip)
jmp    1b4b <delnod_+0x9eb>
jmp    1b50 <delnod_+0x9f0>
cmpl   $0x0,0x35a9(%rip)
jne    1b6f <delnod_+0xa0f>
cmpl   $0x3,0x3574(%rip)
jle    1b6f <delnod_+0xa0f>
jmp    2118 <delnod_+0xfb8>
mov    0x3573(%rip),%eax
mov    %eax,0x3521(%rip)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x3571(%rip)
mov    0x10(%rbp),%rax
movslq 0x350a(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3501(%rip)
mov    -0x40(%rbp),%rax
movslq 0x34f6(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     1bc1 <delnod_+0xa61>
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    1bc9 <delnod_+0xa69>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,0x3492(%rip)
mov    -0x20(%rbp),%rdx
mov    -0x40(%rbp),%rcx
add    $0x4,%rcx
mov    0x10(%rbp),%r8
add    $0x4,%r8
mov    0x18(%rbp),%r9
add    $0x4,%r9
lea    0x346f(%rip),%rdi
lea    0x3464(%rip),%rsi
lea    0x34f5(%rip),%r10
lea    0x34da(%rip),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1070 <delnb_@plt>
cmpl   $0x0,0x34c5(%rip)
jge    1c2a <delnod_+0xaca>
jmp    2102 <delnod_+0xfa2>
mov    0x34b8(%rip),%eax
cmp    0x34c2(%rip),%eax
jne    1c48 <delnod_+0xae8>
mov    0x34a2(%rip),%eax
mov    %eax,0x34a0(%rip)
mov    0x344e(%rip),%eax
cmp    0x34a4(%rip),%eax
jne    1c66 <delnod_+0xb06>
mov    0x3484(%rip),%eax
mov    %eax,0x3436(%rip)
mov    0x3430(%rip),%eax
cmp    0x3476(%rip),%eax
je     1c7d <delnod_+0xb1d>
jmp    1b87 <delnod_+0xa27>
mov    0x341d(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x3414(%rip)
mov    0x33ce(%rip),%eax
cmp    0x3408(%rip),%eax
jle    1ca3 <delnod_+0xb43>
jmp    1e0e <delnod_+0xcae>
mov    0x33f7(%rip),%eax
mov    %eax,-0x44(%rbp)
mov    0x33ae(%rip),%eax
mov    %eax,0x33a0(%rip)
mov    0x339a(%rip),%eax
cmp    -0x44(%rbp),%eax
jg     1d6b <delnod_+0xc0b>
mov    -0x28(%rbp),%rax
mov    0x3387(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x3371(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    0x3362(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x334c(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
mov    0x333d(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x3327(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    0x3318(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x18(%rbp),%rax
movslq 0x3304(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x32fb(%rip),%eax
add    $0x1,%eax
mov    %eax,0x32f2(%rip)
jmp    1cb8 <delnod_+0xb58>
mov    0x3387(%rip),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,0x32d7(%rip)
mov    0x32d1(%rip),%eax
cmp    -0x44(%rbp),%eax
jg     1e09 <delnod_+0xca9>
mov    -0x40(%rbp),%rax
movslq 0x32bd(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x32bc(%rip),%eax
jle    1dbe <delnod_+0xc5e>
mov    -0x40(%rbp),%rax
movslq 0x32a3(%rip),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
movslq 0x328f(%rip),%rcx
mov    (%rax,%rcx,4),%eax
xor    %ecx,%ecx
sub    0x328c(%rip),%ecx
cmp    %ecx,%eax
jge    1df0 <delnod_+0xc90>
mov    -0x40(%rbp),%rax
movslq 0x3271(%rip),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1df5 <delnod_+0xc95>
mov    0x325d(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3254(%rip)
jmp    1d81 <delnod_+0xc21>
jmp    1e0e <delnod_+0xcae>
cmpl   $0x0,0x32eb(%rip)
je     1e2a <delnod_+0xcca>
mov    0x32b7(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x32ae(%rip)
mov    0x32b8(%rip),%eax
mov    %eax,0x32b6(%rip)
mov    0x329c(%rip),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,0x3213(%rip)
mov    0x320d(%rip),%eax
cmp    -0x44(%rbp),%eax
jg     1ff1 <delnod_+0xe91>
mov    0x329a(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x3291(%rip)
mov    0x327f(%rip),%eax
mov    %eax,0x3229(%rip)
mov    0x10(%rbp),%rax
movslq 0x321e(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3265(%rip)
mov    -0x40(%rbp),%rax
movslq 0x3266(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
movslq 0x31fc(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq 0x324a(%rip),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
movslq 0x31e0(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq 0x3222(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x3225(%rip),%eax
jne    1eed <delnod_+0xd8d>
mov    0x31bd(%rip),%edx
mov    0x10(%rbp),%rax
movslq 0x3202(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x31f9(%rip),%eax
cmp    0x31ff(%rip),%eax
jne    1f0b <delnod_+0xdab>
mov    0x3197(%rip),%eax
mov    %eax,0x31e1(%rip)
mov    0x318f(%rip),%eax
mov    %eax,0x3141(%rip)
cmpl   $0x1,0x313a(%rip)
jl     1f70 <delnod_+0xe10>
mov    0x18(%rbp),%rax
movslq 0x3129(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x31c0(%rip),%eax
jne    1f57 <delnod_+0xdf7>
mov    0x3158(%rip),%edx
mov    0x18(%rbp),%rax
movslq 0x3109(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1f75 <delnod_+0xe15>
jmp    1f5c <delnod_+0xdfc>
mov    0x30f6(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x30ed(%rip)
jmp    1f17 <delnod_+0xdb7>
jmp    1f75 <delnod_+0xe15>
mov    0x317d(%rip),%eax
sub    $0x1,%eax
mov    %eax,0x30d4(%rip)
cmpl   $0x1,0x30cd(%rip)
jl     1fd8 <delnod_+0xe78>
mov    0x10(%rbp),%rax
movslq 0x30bc(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x3153(%rip),%eax
jne    1fbf <delnod_+0xe5f>
mov    0x30eb(%rip),%edx
mov    0x10(%rbp),%rax
movslq 0x309c(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1fc4 <delnod_+0xe64>
mov    0x308e(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x3085(%rip)
jmp    1f84 <delnod_+0xe24>
jmp    1fdd <delnod_+0xe7d>
mov    0x3079(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3070(%rip)
jmp    1e49 <delnod_+0xce9>
mov    0x30a9(%rip),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    0x30f5(%rip),%ecx
mov    0x20(%rbp),%rax
mov    %ecx,(%rax)
cmpl   $0x0,0x30e0(%rip)
jle    20c0 <delnod_+0xf60>
mov    0x30d4(%rip),%eax
shl    $0x2,%eax
mov    %eax,0x30cf(%rip)
mov    -0x28(%rbp),%rdi
add    $0x8,%rdi
mov    -0x30(%rbp),%rsi
add    $0x8,%rsi
mov    -0x38(%rbp),%rdx
add    $0x8,%rdx
mov    -0x40(%rbp),%r8
add    $0x4,%r8
mov    0x10(%rbp),%r9
add    $0x4,%r9
mov    0x18(%rbp),%rbx
add    $0x4,%rbx
mov    0x30(%rbp),%r10
add    $0xc,%r10
lea    0x308c(%rip),%rcx
lea    0x3089(%rip),%r11
lea    0x3092(%rip),%rax
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
call   1060 <optim_@plt>
cmpl   $0x0,0x3073(%rip)
je     20a9 <delnod_+0xf49>
cmpl   $0x1,0x3066(%rip)
je     20a9 <delnod_+0xf49>
jmp    212e <delnod_+0xfce>
cmpl   $0x1,0x3054(%rip)
jne    20bb <delnod_+0xf5b>
jmp    2144 <delnod_+0xfe4>
jmp    20c0 <delnod_+0xf60>
mov    0x38(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    2155 <delnod_+0xff5>
mov    0x38(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    2155 <delnod_+0xff5>
mov    0x38(%rbp),%rax
movl   $0x2,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    2155 <delnod_+0xff5>
mov    0x38(%rbp),%rax
movl   $0x3,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    2155 <delnod_+0xff5>
mov    0x38(%rbp),%rax
movl   $0x4,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    2155 <delnod_+0xff5>
mov    0x38(%rbp),%rax
movl   $0x5,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    2155 <delnod_+0xff5>
mov    0x38(%rbp),%rax
movl   $0x6,(%rax)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0x68,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<delnod_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    0x98(%rsp),%r13
mov    (%rdi),%eax
mov    %eax,0x2ede(%rip)
mov    (%rsi),%edi
mov    %edi,0x2f1a(%rip)
mov    $0x1,%ebp
test   %eax,%eax
jle    1bb0 <delnod_+0xa50>
cmp    %edi,%eax
jg     1bb0 <delnod_+0xa50>
cmp    $0x4,%edi
jl     1bb0 <delnod_+0xa50>
mov    %rsi,0x30(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rcx,0x20(%rsp)
mov    %r8,0x28(%rsp)
mov    0x88(%rsp),%r12
cmpl   $0x0,(%r12)
js     1bb0 <delnod_+0xa50>
mov    %r9,%r15
mov    0x78(%rsp),%rcx
mov    0x70(%rsp),%r14
movslq -0x4(%rcx,%rax,4),%rax
mov    %eax,0x2f05(%rip)
lea    0x2efe(%rip),%rdi
mov    -0x4(%r14,%rax,4),%eax
mov    %eax,0x2eeb(%rip)
mov    %r14,%rsi
call   1080 <nbcnt_@plt>
mov    %eax,%ecx
mov    %eax,0x2ed3(%rip)
movslq 0x2edc(%rip),%rax
mov    -0x4(%r15,%rax,4),%edx
mov    %edx,%eax
shr    $0x1f,%eax
mov    %eax,0x2ee0(%rip)
test   %edx,%edx
js     122f <delnod_+0xcf>
cmp    $0x3,%ecx
jge    123d <delnod_+0xdd>
mov    $0x3,%ebp
jmp    1bb0 <delnod_+0xa50>
add    $0x1,%ecx
mov    %ecx,0x2ea0(%rip)
cmp    $0x3,%ecx
jl     1225 <delnod_+0xc5>
mov    (%r12),%edi
lea    -0x3(%rcx),%ebx
mov    %ebx,(%r12)
mov    $0x2,%ebp
cmp    %ebx,%edi
jl     1bb0 <delnod_+0xa50>
mov    0x28(%rsp),%rsi
lea    -0x8(%rsi),%rbx
mov    0x20(%rsp),%rsi
lea    -0x8(%rsi),%rbp
mov    0x18(%rsp),%rsi
add    $0xfffffffffffffff8,%rsi
movl   $0x0,0x2e72(%rip)
cmp    $0x3,%ecx
mov    %rbx,0x10(%rsp)
mov    %rbp,0x8(%rsp)
mov    %rsi,(%rsp)
je     16f5 <delnod_+0x595>
movslq 0x2dc4(%rip),%rcx
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x2dc3(%rip)
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x2dc5(%rip)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x2dc8(%rip)
movslq 0x2e19(%rip),%rcx
movslq -0x4(%r15,%rcx,4),%rdi
mov    %edi,0x2e32(%rip)
mov    %edi,0x2dcc(%rip)
movsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x2ddb(%rip)
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,0x2dd5(%rip)
movsd  (%rbx,%rdi,8),%xmm0
movsd  %xmm0,0x2dd0(%rip)
movslq -0x4(%r14,%rcx,4),%r8
movslq -0x4(%r15,%r8,4),%rcx
mov    %ecx,0x2d50(%rip)
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x2d53(%rip)
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x2d55(%rip)
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x2d58(%rip)
movslq -0x4(%r14,%r8,4),%rsi
mov    %esi,0x2d59(%rip)
mov    -0x4(%r15,%rsi,4),%ebp
mov    %ebp,%esi
neg    %esi
cmovs  %ebp,%esi
mov    %esi,0x2d43(%rip)
cmp    %edi,%esi
jne    1361 <delnod_+0x201>
test   %edx,%edx
js     180f <delnod_+0x6af>
lea    0x2d74(%rip),%r12
lea    0x2d01(%rip),%rbx
mov    %esi,%edx
mov    (%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,0x2d26(%rip)
mov    0x8(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,0x2d1c(%rip)
mov    0x10(%rsp),%rsi
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,0x2d12(%rip)
movslq %ecx,%rcx
mov    0x78(%rsp),%rdx
mov    -0x4(%rdx,%rcx,4),%ecx
mov    %ecx,0x2d40(%rip)
test   %eax,%eax
jne    1419 <delnod_+0x2b9>
sub    $0x8,%rsp
lea    0x2cf9(%rip),%rdi
lea    0x2cfa(%rip),%rsi
lea    0x2cfb(%rip),%rdx
lea    0x2ccc(%rip),%rcx
lea    0x2ccd(%rip),%r8
lea    0x2cce(%rip),%r9
lea    0x2c97(%rip),%rax
push   %rax
lea    0x2c7f(%rip),%rax
push   %rax
lea    0x2c67(%rip),%rax
push   %rax
call   1030 <left_@plt>
add    $0x20,%rsp
test   %eax,%eax
je     1589 <delnod_+0x429>
mov    0x2cdf(%rip),%ecx
movslq %ecx,%rax
cmpl   $0x0,-0x4(%r15,%rax,4)
js     1474 <delnod_+0x314>
sub    $0x8,%rsp
lea    0x2c79(%rip),%rdi
lea    0x2c7a(%rip),%rsi
lea    0x2c7b(%rip),%rdx
lea    0x2c7c(%rip),%rcx
lea    0x2c7d(%rip),%r8
lea    0x2c7e(%rip),%r9
lea    0x2c37(%rip),%rax
push   %rax
lea    0x2c1f(%rip),%rax
push   %rax
push   %rbx
call   1030 <left_@plt>
add    $0x20,%rsp
test   %eax,%eax
je     1589 <delnod_+0x429>
lea    0x2c1d(%rip),%rdi
lea    0x2c22(%rip),%rsi
lea    0x2bd3(%rip),%rdx
lea    0x2bd0(%rip),%rcx
mov    %r15,%r8
mov    %r14,%r9
push   %r12
mov    0x80(%rsp),%rbp
push   %rbp
call   1050 <swap_@plt>
add    $0x10,%rsp
cmpl   $0x0,0x2c2b(%rip)
je     1589 <delnod_+0x429>
mov    0x2c2f(%rip),%eax
lea    0x1(%rax),%ecx
mov    %ecx,0x2c26(%rip)
mov    0x2bcc(%rip),%ecx
xor    %edx,%edx
cmp    0x2b88(%rip),%ecx
setg   %dl
sub    %edx,%ecx
add    %eax,%eax
add    $0x3,%eax
cltq
mov    0x90(%rsp),%rdx
mov    %ecx,-0xc(%rdx,%rax,4)
mov    0x2bb2(%rip),%eax
xor    %ecx,%ecx
cmp    0x2b62(%rip),%eax
setg   %cl
sub    %ecx,%eax
mov    0x2be7(%rip),%ecx
add    %ecx,%ecx
movslq %ecx,%rcx
mov    %eax,-0x4(%rdx,%rcx,4)
movslq 0x2b47(%rip),%rax
movslq -0x4(%rbp,%rax,4),%rax
mov    %eax,0x2bc8(%rip)
mov    0x2bb2(%rip),%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x2ba9(%rip)
cmp    $0x3,%ecx
je     16ef <delnod_+0x58f>
movslq -0x4(%r14,%rax,4),%rax
mov    %eax,0x2b9d(%rip)
mov    -0x4(%r15,%rax,4),%eax
mov    %eax,0x2bb6(%rip)
lea    0x2b93(%rip),%rdi
lea    0x2b3c(%rip),%rsi
mov    %r15,%rdx
mov    %r14,%rcx
call   1040 <lstptr_@plt>
mov    %eax,0x2b2f(%rip)
mov    0x2b31(%rip),%ecx
mov    0x2b8b(%rip),%edx
cmp    %edx,%ecx
jne    1626 <delnod_+0x4c6>
mov    0x2ad9(%rip),%eax
jmp    15c5 <delnod_+0x465>
mov    0x2ad1(%rip),%eax
mov    %eax,0x2b0f(%rip)
movsd  0x2ad3(%rip),%xmm0
movsd  %xmm0,0x2b1b(%rip)
movsd  0x2ad3(%rip),%xmm0
movsd  %xmm0,0x2b13(%rip)
movsd  0x2ad3(%rip),%xmm0
movsd  %xmm0,0x2b0b(%rip)
mov    0x2b39(%rip),%edx
cmp    %edx,%eax
je     16ef <delnod_+0x58f>
mov    0x2abf(%rip),%ecx
mov    %ecx,0x2a81(%rip)
movsd  0x2ac1(%rip),%xmm0
movsd  %xmm0,0x2a81(%rip)
movsd  0x2ab9(%rip),%xmm0
movsd  %xmm0,0x2a81(%rip)
movsd  0x2ab1(%rip),%xmm0
movsd  %xmm0,0x2a81(%rip)
movslq 0x2a86(%rip),%rax
mov    -0x4(%r14,%rax,4),%eax
mov    %eax,0x2a7b(%rip)
jmp    16c0 <delnod_+0x560>
mov    %ecx,0x2a34(%rip)
movsd  0x2a8c(%rip),%xmm0
movsd  %xmm0,0x2a34(%rip)
movsd  0x2a84(%rip),%xmm0
movsd  %xmm0,0x2a34(%rip)
movsd  0x2a7c(%rip),%xmm0
movsd  %xmm0,0x2a34(%rip)
movslq 0x2a79(%rip),%rsi
movslq -0x4(%r14,%rsi,4),%rsi
mov    %esi,0x2a6e(%rip)
movslq -0x4(%r14,%rsi,4),%rsi
mov    %esi,0x2a63(%rip)
mov    -0x4(%r15,%rsi,4),%esi
mov    %esi,%edi
neg    %edi
cmovs  %esi,%edi
mov    %edi,0x2a19(%rip)
mov    (%rsp),%rsi
movsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x2a24(%rip)
mov    0x8(%rsp),%rsi
movsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x2a1a(%rip)
mov    0x10(%rsp),%rsi
movsd  (%rsi,%rdi,8),%xmm0
movsd  %xmm0,0x2a10(%rip)
cltq
mov    -0x4(%r15,%rax,4),%eax
mov    %eax,%esi
neg    %esi
cmovs  %eax,%esi
mov    %esi,0x29c4(%rip)
mov    0x2a22(%rip),%eax
cmp    %edx,%esi
jne    136f <delnod_+0x20f>
test   %eax,%eax
je     136f <delnod_+0x20f>
jmp    1825 <delnod_+0x6c5>
mov    0x2a07(%rip),%eax
test   %eax,%eax
jne    1825 <delnod_+0x6c5>
cmpl   $0x4,0x29d4(%rip)
jl     171f <delnod_+0x5bf>
movl   $0x1,0x29ec(%rip)
mov    $0x1,%eax
mov    0x78(%rsp),%rdi
jmp    17ba <delnod_+0x65a>
movslq 0x29c2(%rip),%rax
movslq -0x4(%r14,%rax,4),%rcx
mov    %ecx,0x29af(%rip)
movslq -0x4(%r15,%rcx,4),%rdx
mov    %edx,0x2968(%rip)
movslq -0x4(%r14,%rcx,4),%rcx
mov    %ecx,0x2955(%rip)
movslq -0x4(%r15,%rcx,4),%r11
mov    %r11d,0x290d(%rip)
movslq -0x4(%r15,%rax,4),%r9
mov    %r9d,0x2939(%rip)
mov    (%rsp),%rax
lea    (%rax,%rdx,8),%rdi
mov    0x8(%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%rsi
mov    0x10(%rsp),%rbx
lea    (%rbx,%rdx,8),%rdx
lea    (%rax,%r9,8),%rcx
lea    0x0(%rbp,%r9,8),%r8
lea    (%rbx,%r9,8),%r9
lea    (%rax,%r11,8),%r10
lea    0x0(,%r11,8),%rax
add    %rbp,%rax
lea    (%rbx,%r11,8),%rbp
sub    $0x8,%rsp
push   %rbp
push   %rax
push   %r10
call   1030 <left_@plt>
add    $0x20,%rsp
mov    %eax,0x294b(%rip)
test   %eax,%eax
mov    0x78(%rsp),%rdi
je     180d <delnod_+0x6ad>
mov    0x28e0(%rip),%ecx
movl   $0x1,0x288e(%rip)
test   %ecx,%ecx
jle    17ee <delnod_+0x68e>
xor    %edx,%edx
movslq (%rdi,%rdx,4),%rsi
cmpl   $0x0,-0x4(%r15,%rsi,4)
js     1803 <delnod_+0x6a3>
lea    0x2(%rdx),%esi
mov    %esi,0x2873(%rip)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    17d0 <delnod_+0x670>
movslq 0x28f3(%rip),%rcx
negl   -0x4(%r15,%rcx,4)
addl   $0x1,0x28d7(%rip)
jmp    180f <delnod_+0x6af>
movl   $0x0,0x28ef(%rip)
xor    %eax,%eax
test   %eax,%eax
jne    1825 <delnod_+0x6c5>
mov    $0x4,%ebp
cmpl   $0x3,0x28b9(%rip)
jg     1bb0 <delnod_+0xa50>
mov    0x80(%rsp),%rax
mov    0x28b5(%rip),%ecx
mov    (%rax),%eax
mov    %eax,0x28b9(%rip)
lea    0x281e(%rip),%rbx
lea    0x289b(%rip),%rbp
lea    0x28a4(%rip),%r13
lea    0x2805(%rip),%r12
jmp    1868 <delnod_+0x708>
nopl   0x0(%rax)
cmp    %edx,%ecx
je     18f2 <delnod_+0x792>
movslq %ecx,%rax
movslq -0x4(%r14,%rax,4),%rax
mov    %eax,0x2826(%rip)
mov    -0x4(%r15,%rax,4),%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
mov    %ecx,0x27d8(%rip)
mov    %rbx,%rdi
mov    %r12,%rsi
mov    0x30(%rsp),%rdx
mov    %r15,%rcx
mov    %r14,%r8
mov    0x78(%rsp),%r9
push   %rbp
push   %r13
call   1070 <delnb_@plt>
add    $0x10,%rsp
mov    0x2834(%rip),%eax
test   %eax,%eax
js     18e0 <delnod_+0x780>
mov    0x282e(%rip),%edx
mov    0x2834(%rip),%esi
cmp    %esi,%edx
jne    18cc <delnod_+0x76c>
mov    %eax,0x281e(%rip)
mov    %eax,%edx
mov    0x27ca(%rip),%ecx
cmp    %esi,%ecx
jne    1860 <delnod_+0x700>
mov    %eax,0x27c0(%rip)
mov    %eax,%ecx
jmp    1860 <delnod_+0x700>
mov    $0x3,%ebp
mov    0x98(%rsp),%r13
jmp    1bb0 <delnod_+0xa50>
mov    0x27a7(%rip),%r11d
lea    -0x1(%r11),%r9d
mov    %r9d,0x279c(%rip)
mov    0x2752(%rip),%eax
cmp    %r11d,%eax
mov    0x98(%rsp),%r13
mov    0x78(%rsp),%r12
jge    19f5 <delnod_+0x895>
mov    %eax,0x2732(%rip)
mov    0x10(%rsp),%rdx
mov    0x8(%rsp),%rsi
mov    (%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cltq
movsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
mov    (%r12,%rax,4),%ecx
mov    %ecx,-0x4(%r12,%rax,4)
mov    0x26e6(%rip),%eax
add    $0x1,%eax
mov    %eax,0x26dd(%rip)
cmp    %r11d,%eax
jl     1940 <delnod_+0x7e0>
mov    0x276e(%rip),%eax
movl   $0x1,0x26c8(%rip)
cmp    $0x2,%eax
jl     19f5 <delnod_+0x895>
mov    $0x1,%edx
mov    0x26bc(%rip),%esi
jmp    19af <delnod_+0x84f>
add    $0x1,%edx
mov    %edx,0x26ad(%rip)
cmp    %eax,%edx
jge    19f5 <delnod_+0x895>
movslq %edx,%rdi
mov    -0x4(%r15,%rdi,4),%ebp
cmp    %esi,%ebp
jle    19d7 <delnod_+0x877>
add    $0xffffffff,%ebp
mov    %ebp,-0x4(%r15,%rdi,4)
mov    0x268f(%rip),%edx
movslq %edx,%rdi
mov    -0x4(%r15,%rdi,4),%ebp
mov    0x2685(%rip),%esi
mov    %esi,%ecx
neg    %ecx
cmp    %ecx,%ebp
jge    19a2 <delnod_+0x842>
add    $0x1,%ebp
mov    %ebp,-0x4(%r15,%rdi,4)
mov    0x266f(%rip),%esi
mov    0x2665(%rip),%edx
jmp    19a2 <delnod_+0x842>
cmpl   $0x0,0x2700(%rip)
mov    0x26d5(%rip),%r10d
je     1a10 <delnod_+0x8b0>
add    $0xffffffff,%r10d
mov    %r10d,0x26c8(%rip)
test   %r10d,%r10d
jle    1b26 <delnod_+0x9c6>
mov    0x26c9(%rip),%edi
mov    0x26cf(%rip),%edx
mov    %r9d,%eax
lea    (%r12,%rax,4),%r8
add    $0xfffffffffffffffc,%r8
mov    $0x1,%esi
jmp    1a4e <delnod_+0x8ee>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rsi),%ecx
cmp    %r10d,%esi
mov    %ecx,%esi
je     1b20 <delnod_+0x9c0>
mov    %edi,%eax
lea    -0x1(%rdx),%ecx
mov    %ecx,0x269b(%rip)
movslq %edi,%rcx
movslq -0x4(%r14,%rcx,4),%rdi
movslq %edx,%rdx
mov    -0x8(%r15,%rdx,4),%edx
mov    %edx,-0x4(%r15,%rcx,4)
movslq 0x267f(%rip),%rdx
mov    -0x4(%r14,%rdx,4),%edx
mov    %edx,-0x4(%r14,%rcx,4)
mov    0x266f(%rip),%edx
cmp    %edx,-0x4(%r14,%rdi,4)
jne    1a97 <delnod_+0x937>
mov    %eax,-0x4(%r14,%rdi,4)
mov    0x265d(%rip),%edx
cmp    %edx,%edi
cmove  %eax,%edi
mov    %r9d,0x25b5(%rip)
cmp    $0x2,%r11d
jl     1ad9 <delnod_+0x979>
mov    %r11d,%ecx
mov    %r8,%rbp
nop
lea    -0x1(%rcx),%ebx
cmp    %edx,-0x4(%r12,%rbx,4)
je     1ad0 <delnod_+0x970>
add    $0xfffffffe,%ecx
mov    %ecx,0x2595(%rip)
add    $0xfffffffffffffffc,%rbp
mov    %ebx,%ecx
cmp    $0x1,%ebx
jg     1ab0 <delnod_+0x950>
jmp    1ad9 <delnod_+0x979>
mov    %eax,0x0(%rbp)
mov    0x261b(%rip),%edx
lea    -0x1(%rdx),%ebp
mov    %ebp,0x2576(%rip)
cmp    $0x2,%edx
jge    1b04 <delnod_+0x9a4>
jmp    1a40 <delnod_+0x8e0>
nopl   0x0(%rax)
lea    -0x1(%rbp),%ecx
mov    %ecx,0x255f(%rip)
cmp    $0x1,%ebp
mov    %ecx,%ebp
jle    1a40 <delnod_+0x8e0>
mov    %ebp,%ecx
cmp    %edx,-0x4(%r14,%rcx,4)
jne    1af0 <delnod_+0x990>
mov    %eax,-0x4(%r14,%rcx,4)
mov    0x25dc(%rip),%edx
mov    0x253a(%rip),%ebp
jmp    1af0 <delnod_+0x990>
mov    %eax,0x2576(%rip)
mov    0x30(%rsp),%rax
mov    %r9d,(%rax)
mov    0x25c0(%rip),%eax
mov    0x80(%rsp),%rcx
mov    %eax,(%rcx)
mov    0x25a8(%rip),%eax
test   %eax,%eax
jle    1bae <delnod_+0xa4e>
shl    $0x2,%eax
mov    %eax,0x259f(%rip)
lea    0x2598(%rip),%rax
lea    0x25a1(%rip),%rbp
lea    0x2586(%rip),%rcx
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdx
mov    %r15,%r8
mov    %r14,%r9
push   %rbp
push   0x98(%rsp)
push   %rax
push   %r12
call   1060 <optim_@plt>
add    $0x20,%rsp
mov    0x256b(%rip),%eax
mov    $0x5,%ebp
cmp    $0x1,%eax
ja     1bb0 <delnod_+0xa50>
xor    %ecx,%ecx
cmp    $0x1,%eax
mov    $0x6,%ebp
cmovne %ecx,%ebp
jmp    1bb0 <delnod_+0xa50>
xor    %ebp,%ebp
mov    %ebp,0x0(%r13)
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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