#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 */
scalar_t__ left_(double *, double *, double *, double *, double *, double *,
                 double *, double *, double *);
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 edge_(int *in1, int *in2, double *x, double *y, double *z__, int *lwk,
          int *iwk, int *list, int *lptr, int *lend, int *ier) {
  int i__1;
  static int i__, n0, n1, n2;
  static double x0, x1, x2, y00, y11, y2, z0, z1, z2;
  static int nl, lp, nr;
  static double dp12;
  static int lp21, iwc, iwf, lft, lpl, iwl, nit;
  static double dp1l, dp2l, dp1r, dp2r;
  static int ierr;
  static int next, iwcp1, n1lst, iwend;
  static int n1frst;
  --lend;
  --lptr;
  --list;
  iwk -= 3;
  --z__;
  --y;
  --x;
  n1 = *in1;
  n2 = *in2;
  iwend = *lwk;
  if (n1 < 1 || n2 < 1 || n1 == n2 || iwend < 0) {
    goto L31;
  }
  lpl = lend[n1];
  n0 = (i__1 = list[lpl], ((i__1) >= 0 ? (i__1) : -(i__1)));
  lp = lpl;
L1:
  if (n0 == n2) {
    goto L30;
  }
  lp = lptr[lp];
  n0 = list[lp];
  if (lp != lpl) {
    goto L1;
  }
  iwl = 0;
  nit = 0;
L2:
  x1 = x[n1];
  y11 = y[n1];
  z1 = z__[n1];
  x2 = x[n2];
  y2 = y[n2];
  z2 = z__[n2];
  lpl = lend[n1];
  n1lst = list[lpl];
  lp = lptr[lpl];
  n1frst = list[lp];
  nl = n1frst;
  if (n1lst < 0) {
    goto L4;
  }
L3:
  if (left_(&x2, &y2, &z2, &x1, &y11, &z1, &x[nl], &y[nl], &z__[nl])) {
    goto L4;
  }
  lp = lptr[lp];
  nl = list[lp];
  if (nl != n1frst) {
    goto L3;
  }
  goto L5;
L4:
  nr = nl;
  lp = lptr[lp];
  nl = (i__1 = list[lp], ((i__1) >= 0 ? (i__1) : -(i__1)));
  if (left_(&x1, &y11, &z1, &x2, &y2, &z2, &x[nl], &y[nl], &z__[nl])) {
    dp12 = x1 * x2 + y11 * y2 + z1 * z2;
    dp1l = x1 * x[nl] + y11 * y[nl] + z1 * z__[nl];
    dp2l = x2 * x[nl] + y2 * y[nl] + z2 * z__[nl];
    dp1r = x1 * x[nr] + y11 * y[nr] + z1 * z__[nr];
    dp2r = x2 * x[nr] + y2 * y[nr] + z2 * z__[nr];
    if ((dp2l - dp12 * dp1l >= 0. || dp2r - dp12 * dp1r >= 0.) &&
        (dp1l - dp12 * dp2l >= 0. || dp1r - dp12 * dp2r >= 0.)) {
      goto L6;
    }
    if (!left_(&x2, &y2, &z2, &x1, &y11, &z1, &x[nl], &y[nl], &z__[nl])) {
      goto L5;
    }
  }
  if (nl != n1frst) {
    goto L4;
  }
L5:
  if (nit > 0) {
    goto L33;
  }
  nit = 1;
  n1 = n2;
  n2 = *in1;
  goto L2;
L6:
  ++iwl;
  if (iwl > iwend) {
    goto L32;
  }
  iwk[(iwl << 1) + 1] = nl;
  iwk[(iwl << 1) + 2] = nr;
  lpl = lend[nl];
  lp = lptr[lpl];
L7:
  if (list[lp] == nr) {
    goto L8;
  }
  lp = lptr[lp];
  if (lp != lpl) {
    goto L7;
  }
  if (list[lp] != nr) {
    goto L33;
  }
L8:
  lp = lptr[lp];
  next = (i__1 = list[lp], ((i__1) >= 0 ? (i__1) : -(i__1)));
  if (next == n2) {
    goto L9;
  }
  if (left_(&x1, &y11, &z1, &x2, &y2, &z2, &x[next], &y[next], &z__[next])) {
    nl = next;
  } else {
    nr = next;
  }
  goto L6;
L9:
  *lwk = iwl;
  iwend = iwl;
  iwf = 1;
L10:
  lft = 0;
  n0 = n1;
  x0 = x1;
  y00 = y11;
  z0 = z1;
  nl = iwk[(iwf << 1) + 1];
  nr = iwk[(iwf << 1) + 2];
  iwc = iwf;
L11:
  if (iwc == iwl) {
    goto L21;
  }
  iwcp1 = iwc + 1;
  next = iwk[(iwcp1 << 1) + 1];
  if (next != nl) {
    goto L16;
  }
  next = iwk[(iwcp1 << 1) + 2];
  if (!left_(&x0, &y00, &z0, &x[nr], &y[nr], &z__[nr], &x[next], &y[next],
             &z__[next])) {
    goto L14;
  }
  if (lft >= 0) {
    goto L12;
  }
  if (!left_(&x[nl], &y[nl], &z__[nl], &x0, &y00, &z0, &x[next], &y[next],
             &z__[next])) {
    goto L14;
  }
  swap_(&next, &n0, &nl, &nr, &list[1], &lptr[1], &lend[1], &lp21);
  iwk[(iwc << 1) + 1] = n0;
  iwk[(iwc << 1) + 2] = next;
  goto L15;
L12:
  swap_(&next, &n0, &nl, &nr, &list[1], &lptr[1], &lend[1], &lp21);
  i__1 = iwl;
  for (i__ = iwcp1; i__ <= i__1; ++i__) {
    iwk[((i__ - 1) << 1) + 1] = iwk[(i__ << 1) + 1];
    iwk[((i__ - 1) << 1) + 2] = iwk[(i__ << 1) + 2];
  }
  iwk[(iwl << 1) + 1] = n0;
  iwk[(iwl << 1) + 2] = next;
  --iwl;
  nr = next;
  goto L11;
L14:
  n0 = nr;
  x0 = x[n0];
  y00 = y[n0];
  z0 = z__[n0];
  lft = 1;
L15:
  nr = next;
  ++iwc;
  goto L11;
L16:
  if (!left_(&x[nl], &y[nl], &z__[nl], &x0, &y00, &z0, &x[next], &y[next],
             &z__[next])) {
    goto L19;
  }
  if (lft <= 0) {
    goto L17;
  }
  if (!left_(&x0, &y00, &z0, &x[nr], &y[nr], &z__[nr], &x[next], &y[next],
             &z__[next])) {
    goto L19;
  }
  swap_(&next, &n0, &nl, &nr, &list[1], &lptr[1], &lend[1], &lp21);
  iwk[(iwc << 1) + 1] = next;
  iwk[(iwc << 1) + 2] = n0;
  goto L20;
L17:
  swap_(&next, &n0, &nl, &nr, &list[1], &lptr[1], &lend[1], &lp21);
  i__1 = iwf;
  for (i__ = iwc - 1; i__ >= i__1; --i__) {
    iwk[((i__ + 1) << 1) + 1] = iwk[(i__ << 1) + 1];
    iwk[((i__ + 1) << 1) + 2] = iwk[(i__ << 1) + 2];
  }
  iwk[(iwf << 1) + 1] = n0;
  iwk[(iwf << 1) + 2] = next;
  ++iwf;
  goto L20;
L19:
  n0 = nl;
  x0 = x[n0];
  y00 = y[n0];
  z0 = z__[n0];
  lft = -1;
L20:
  nl = next;
  ++iwc;
  goto L11;
L21:
  if (n0 == n1) {
    goto L24;
  }
  if (lft < 0) {
    goto L22;
  }
  if (!left_(&x0, &y00, &z0, &x[nr], &y[nr], &z__[nr], &x2, &y2, &z2)) {
    goto L10;
  }
  swap_(&n2, &n0, &nl, &nr, &list[1], &lptr[1], &lend[1], &lp21);
  iwk[(iwl << 1) + 1] = n0;
  iwk[(iwl << 1) + 2] = n2;
  --iwl;
  goto L10;
L22:
  if (!left_(&x[nl], &y[nl], &z__[nl], &x0, &y00, &z0, &x2, &y2, &z2)) {
    goto L10;
  }
  swap_(&n2, &n0, &nl, &nr, &list[1], &lptr[1], &lend[1], &lp21);
  i__ = iwl;
L23:
  iwk[(i__ << 1) + 1] = iwk[((i__ - 1) << 1) + 1];
  iwk[(i__ << 1) + 2] = iwk[((i__ - 1) << 1) + 2];
  --i__;
  if (i__ > iwf) {
    goto L23;
  }
  iwk[(iwf << 1) + 1] = n0;
  iwk[(iwf << 1) + 2] = n2;
  ++iwf;
  goto L10;
L24:
  swap_(&n2, &n1, &nl, &nr, &list[1], &lptr[1], &lend[1], &lp21);
  iwk[(iwc << 1) + 1] = 0;
  iwk[(iwc << 1) + 2] = 0;
  *ier = 0;
  if (iwc > 1) {
    nit = (iwc - 1) << 2;
    i__1 = iwc - 1;
    optim_(&x[1], &y[1], &z__[1], &i__1, &list[1], &lptr[1], &lend[1], &nit,
           &iwk[3], &ierr);
    if (ierr != 0 && ierr != 1) {
      goto L34;
    }
    if (ierr == 1) {
      *ier = 5;
    }
  }
  if (iwc < iwend) {
    nit = (iwend - iwc) << 2;
    i__1 = iwend - iwc;
    optim_(&x[1], &y[1], &z__[1], &i__1, &list[1], &lptr[1], &lend[1], &nit,
           &iwk[((iwc + 1) << 1) + 1], &ierr);
    if (ierr != 0 && ierr != 1) {
      goto L34;
    }
    if (ierr == 1) {
      goto L35;
    }
  }
  if (*ier == 5) {
    goto L35;
  }
  return 0;
L30:
  *ier = 0;
  return 0;
L31:
  *ier = 1;
  return 0;
L32:
  *ier = 2;
  return 0;
L33:
  *ier = 3;
  return 0;
L34:
  *ier = 4;
  return 0;
L35:
  *ier = 5;
  return 0;
}


x86 assembly (clang, -O0):
<edge_>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x68,%rsp
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    0x28(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x28(%rbp)
mov    0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x20(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffff4,%rax
mov    %rax,0x10(%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,0x3e83(%rip)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x3e7b(%rip)
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x3f23(%rip)
cmpl   $0x1,0x3e64(%rip)
jl     1216 <edge_+0xe6>
cmpl   $0x1,0x3e5b(%rip)
jl     1216 <edge_+0xe6>
mov    0x3e4b(%rip),%eax
cmp    0x3e49(%rip),%eax
je     1216 <edge_+0xe6>
cmpl   $0x0,0x3ef0(%rip)
jge    121b <edge_+0xeb>
jmp    28b1 <edge_+0x1781>
mov    0x28(%rbp),%rax
movslq 0x3e22(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3e91(%rip)
mov    0x18(%rbp),%rax
movslq 0x3e86(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     1255 <edge_+0x125>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    125d <edge_+0x12d>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,0x3dde(%rip)
mov    0x3e54(%rip),%eax
mov    %eax,0x3e2a(%rip)
mov    0x3dcc(%rip),%eax
cmp    0x3dce(%rip),%eax
jne    1289 <edge_+0x159>
jmp    289b <edge_+0x176b>
mov    0x20(%rbp),%rax
movslq 0x3e08(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3dff(%rip)
mov    0x18(%rbp),%rax
movslq 0x3df4(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3d93(%rip)
mov    0x3de5(%rip),%eax
cmp    0x3e03(%rip),%eax
je     12c8 <edge_+0x198>
jmp    1272 <edge_+0x142>
movl   $0x0,0x3df2(%rip)
movl   $0x0,0x3dec(%rip)
mov    -0x28(%rbp),%rax
movslq 0x3d61(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d64(%rip)
mov    -0x30(%rbp),%rax
movslq 0x3d49(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d64(%rip)
mov    -0x38(%rbp),%rax
movslq 0x3d31(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d64(%rip)
mov    -0x28(%rbp),%rax
movslq 0x3d1d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d24(%rip)
mov    -0x30(%rbp),%rax
movslq 0x3d05(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d24(%rip)
mov    -0x38(%rbp),%rax
movslq 0x3ced(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d24(%rip)
mov    0x28(%rbp),%rax
movslq 0x3cd1(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3d40(%rip)
mov    0x18(%rbp),%rax
movslq 0x3d35(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3d68(%rip)
mov    0x20(%rbp),%rax
movslq 0x3d21(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3cf4(%rip)
mov    0x18(%rbp),%rax
movslq 0x3ce9(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3d48(%rip)
mov    0x3d42(%rip),%eax
mov    %eax,0x3cd0(%rip)
cmpl   $0x0,0x3d2d(%rip)
jge    13da <edge_+0x2aa>
jmp    14a5 <edge_+0x375>
jmp    13df <edge_+0x2af>
mov    -0x28(%rbp),%r11
movslq 0x3cae(%rip),%rax
shl    $0x3,%rax
add    %rax,%r11
mov    -0x30(%rbp),%r10
movslq 0x3c9c(%rip),%rax
shl    $0x3,%rax
add    %rax,%r10
mov    -0x38(%rbp),%rax
movslq 0x3c8a(%rip),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
lea    0x3c44(%rip),%rdi
lea    0x3c55(%rip),%rsi
lea    0x3c66(%rip),%rdx
lea    0x3c27(%rip),%rcx
lea    0x3c38(%rip),%r8
lea    0x3c49(%rip),%r9
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%rax
je     1461 <edge_+0x331>
jmp    14a5 <edge_+0x375>
mov    0x20(%rbp),%rax
movslq 0x3c30(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3c27(%rip)
mov    0x18(%rbp),%rax
movslq 0x3c1c(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3c0f(%rip)
mov    0x3c09(%rip),%eax
cmp    0x3c6f(%rip),%eax
je     14a0 <edge_+0x370>
jmp    13df <edge_+0x2af>
jmp    18f9 <edge_+0x7c9>
mov    0x3bed(%rip),%eax
mov    %eax,0x3bef(%rip)
mov    0x20(%rbp),%rax
movslq 0x3be0(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3bd7(%rip)
mov    0x18(%rbp),%rax
movslq 0x3bcc(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     14eb <edge_+0x3bb>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    14f3 <edge_+0x3c3>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,0x3b9c(%rip)
mov    -0x28(%rbp),%r11
movslq 0x3b91(%rip),%rax
shl    $0x3,%rax
add    %rax,%r11
mov    -0x30(%rbp),%r10
movslq 0x3b7f(%rip),%rax
shl    $0x3,%rax
add    %rax,%r10
mov    -0x38(%rbp),%rax
movslq 0x3b6d(%rip),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
lea    0x3b1f(%rip),%rdi
lea    0x3b30(%rip),%rsi
lea    0x3b41(%rip),%rdx
lea    0x3b12(%rip),%rcx
lea    0x3b23(%rip),%r8
lea    0x3b34(%rip),%r9
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%rax
je     18dd <edge_+0x7ad>
movsd  0x3ad7(%rip),%xmm1
movsd  0x3ad7(%rip),%xmm2
movsd  0x3adf(%rip),%xmm0
mulsd  0x3adf(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3adf(%rip),%xmm0
movsd  0x3adf(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3ae7(%rip)
movsd  0x3a8f(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x3ac4(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3a8f(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x3aac(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3a87(%rip),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x3a8c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3aaf(%rip)
movsd  0x3a37(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x3a64(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3a37(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x3a4c(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3a2f(%rip),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x3a2c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3a57(%rip)
movsd  0x39cf(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x3a0c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x39cf(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x39f4(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x39c7(%rip),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x39d4(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x39ff(%rip)
movsd  0x3977(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x39ac(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3977(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x3994(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x396f(%rip),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x3974(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x39a7(%rip)
movsd  0x398f(%rip),%xmm1
movsd  0x3957(%rip),%xmm0
movsd  0x3977(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jae    17c9 <edge_+0x699>
movsd  0x395b(%rip),%xmm1
movsd  0x3913(%rip),%xmm0
movsd  0x3943(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1856 <edge_+0x726>
movsd  0x38ff(%rip),%xmm1
movsd  0x38cf(%rip),%xmm0
movsd  0x38f7(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jae    1851 <edge_+0x721>
movsd  0x38cb(%rip),%xmm1
movsd  0x388b(%rip),%xmm0
movsd  0x38c3(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1856 <edge_+0x726>
jmp    1932 <edge_+0x802>
mov    -0x28(%rbp),%r11
movslq 0x3837(%rip),%rax
shl    $0x3,%rax
add    %rax,%r11
mov    -0x30(%rbp),%r10
movslq 0x3825(%rip),%rax
shl    $0x3,%rax
add    %rax,%r10
mov    -0x38(%rbp),%rax
movslq 0x3813(%rip),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
lea    0x37cd(%rip),%rdi
lea    0x37de(%rip),%rsi
lea    0x37ef(%rip),%rdx
lea    0x37b0(%rip),%rcx
lea    0x37c1(%rip),%r8
lea    0x37d2(%rip),%r9
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%rax
jne    18d8 <edge_+0x7a8>
jmp    18f9 <edge_+0x7c9>
jmp    18dd <edge_+0x7ad>
mov    0x37b5(%rip),%eax
cmp    0x381b(%rip),%eax
je     18f4 <edge_+0x7c4>
jmp    14a5 <edge_+0x375>
jmp    18f9 <edge_+0x7c9>
cmpl   $0x0,0x37c8(%rip)
jle    190b <edge_+0x7db>
jmp    28dd <edge_+0x17ad>
movl   $0x1,0x37b3(%rip)
mov    0x3731(%rip),%eax
mov    %eax,0x3727(%rip)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x371f(%rip)
jmp    12dc <edge_+0x1ac>
mov    0x378c(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3783(%rip)
mov    0x377d(%rip),%eax
cmp    0x37b3(%rip),%eax
jle    1958 <edge_+0x828>
jmp    28c7 <edge_+0x1797>
mov    0x373a(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x375c(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3726(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x3740(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
movslq 0x36fd(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x371c(%rip)
mov    0x20(%rbp),%rax
movslq 0x3711(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x36e4(%rip)
mov    0x18(%rbp),%rax
movslq 0x36d9(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x36d4(%rip),%eax
jne    19d7 <edge_+0x8a7>
jmp    1a26 <edge_+0x8f6>
mov    0x20(%rbp),%rax
movslq 0x36ba(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x36b1(%rip)
mov    0x36ab(%rip),%eax
cmp    0x36c9(%rip),%eax
je     1a02 <edge_+0x8d2>
jmp    19b8 <edge_+0x888>
mov    0x18(%rbp),%rax
movslq 0x368f(%rip),%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x368a(%rip),%eax
je     1a21 <edge_+0x8f1>
jmp    28dd <edge_+0x17ad>
jmp    1a26 <edge_+0x8f6>
mov    0x20(%rbp),%rax
movslq 0x366b(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3662(%rip)
mov    0x18(%rbp),%rax
movslq 0x3657(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     1a60 <edge_+0x930>
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    1a68 <edge_+0x938>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,0x3683(%rip)
mov    0x367d(%rip),%eax
cmp    0x35cf(%rip),%eax
jne    1a88 <edge_+0x958>
jmp    1b27 <edge_+0x9f7>
mov    -0x28(%rbp),%r11
movslq 0x3661(%rip),%rax
shl    $0x3,%rax
add    %rax,%r11
mov    -0x30(%rbp),%r10
movslq 0x364f(%rip),%rax
shl    $0x3,%rax
add    %rax,%r10
mov    -0x38(%rbp),%rax
movslq 0x363d(%rip),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
lea    0x3593(%rip),%rdi
lea    0x35a4(%rip),%rsi
lea    0x35b5(%rip),%rdx
lea    0x3586(%rip),%rcx
lea    0x3597(%rip),%r8
lea    0x35a8(%rip),%r9
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%rax
je     1b16 <edge_+0x9e6>
mov    0x35e9(%rip),%eax
mov    %eax,0x3587(%rip)
jmp    1b22 <edge_+0x9f2>
mov    0x35d8(%rip),%eax
mov    %eax,0x357e(%rip)
jmp    1932 <edge_+0x802>
mov    0x3597(%rip),%ecx
mov    -0x40(%rbp),%rax
mov    %ecx,(%rax)
mov    0x358b(%rip),%eax
mov    %eax,0x35c1(%rip)
movl   $0x1,0x356f(%rip)
movl   $0x0,0x3569(%rip)
mov    0x34ef(%rip),%eax
mov    %eax,0x34e5(%rip)
movsd  0x34f1(%rip),%xmm0
movsd  %xmm0,0x34e1(%rip)
movsd  0x34f9(%rip),%xmm0
movsd  %xmm0,0x34e9(%rip)
movsd  0x3501(%rip),%xmm0
movsd  %xmm0,0x34f1(%rip)
mov    0x10(%rbp),%rax
mov    0x351f(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x34ed(%rip)
mov    0x10(%rbp),%rax
mov    0x3503(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x34d9(%rip)
mov    0x34eb(%rip),%eax
mov    %eax,0x34e1(%rip)
mov    0x34db(%rip),%eax
cmp    0x34e5(%rip),%eax
jne    1bea <edge_+0xaba>
jmp    2365 <edge_+0x1235>
mov    0x34c4(%rip),%eax
add    $0x1,%eax
mov    %eax,0x34ff(%rip)
mov    0x10(%rbp),%rax
mov    0x34f5(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x34df(%rip)
mov    0x34d9(%rip),%eax
cmp    0x3477(%rip),%eax
je     1c2c <edge_+0xafc>
jmp    1fdb <edge_+0xeab>
mov    0x10(%rbp),%rax
mov    0x34c2(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x34ac(%rip)
mov    -0x28(%rbp),%rcx
movslq 0x344d(%rip),%rax
shl    $0x3,%rax
add    %rax,%rcx
mov    -0x30(%rbp),%r8
movslq 0x343b(%rip),%rax
shl    $0x3,%rax
add    %rax,%r8
mov    -0x38(%rbp),%r9
movslq 0x3429(%rip),%rax
shl    $0x3,%rax
add    %rax,%r9
mov    -0x28(%rbp),%r11
movslq 0x346b(%rip),%rax
shl    $0x3,%rax
add    %rax,%r11
mov    -0x30(%rbp),%r10
movslq 0x3459(%rip),%rax
shl    $0x3,%rax
add    %rax,%r10
mov    -0x38(%rbp),%rax
movslq 0x3447(%rip),%rdx
shl    $0x3,%rdx
add    %rdx,%rax
lea    0x3395(%rip),%rdi
lea    0x33a6(%rip),%rsi
lea    0x33b7(%rip),%rdx
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%rax
jne    1ceb <edge_+0xbbb>
jmp    1f5d <edge_+0xe2d>
cmpl   $0x0,0x33ca(%rip)
jl     1cfd <edge_+0xbcd>
jmp    1e26 <edge_+0xcf6>
mov    -0x28(%rbp),%rdi
movslq 0x3390(%rip),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
movslq 0x337e(%rip),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x38(%rbp),%rdx
movslq 0x336c(%rip),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x28(%rbp),%r11
movslq 0x33b6(%rip),%rax
shl    $0x3,%rax
add    %rax,%r11
mov    -0x30(%rbp),%r10
movslq 0x33a4(%rip),%rax
shl    $0x3,%rax
add    %rax,%r10
mov    -0x38(%rbp),%rax
movslq 0x3392(%rip),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
lea    0x32e0(%rip),%rcx
lea    0x32f1(%rip),%r8
lea    0x3302(%rip),%r9
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%rax
jne    1da0 <edge_+0xc70>
jmp    1f5d <edge_+0xe2d>
mov    0x18(%rbp),%r8
add    $0x4,%r8
mov    0x20(%rbp),%r9
add    $0x4,%r9
mov    0x28(%rbp),%r10
add    $0x4,%r10
lea    0x3335(%rip),%rdi
lea    0x327e(%rip),%rsi
lea    0x32cb(%rip),%rdx
lea    0x32cc(%rip),%rcx
lea    0x32d5(%rip),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <swap_@plt>
mov    0x3255(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x32bb(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x32e9(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x329f(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1fbb <edge_+0xe8b>
mov    0x18(%rbp),%r8
add    $0x4,%r8
mov    0x20(%rbp),%r9
add    $0x4,%r9
mov    0x28(%rbp),%r10
add    $0x4,%r10
lea    0x32af(%rip),%rdi
lea    0x31f8(%rip),%rsi
lea    0x3245(%rip),%rdx
lea    0x3246(%rip),%rcx
lea    0x324f(%rip),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <swap_@plt>
mov    0x324f(%rip),%eax
mov    %eax,-0x44(%rbp)
mov    0x327a(%rip),%eax
mov    %eax,0x31bc(%rip)
mov    0x31b6(%rip),%eax
cmp    -0x44(%rbp),%eax
jg     1f05 <edge_+0xdd5>
mov    0x10(%rbp),%rax
mov    0x31a3(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
mov    0x318d(%rip),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x3174(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
mov    0x315e(%rip),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3149(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3140(%rip)
jmp    1e84 <edge_+0xd54>
mov    0x3139(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x31af(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x31cd(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x3193(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3181(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x3178(%rip)
mov    0x31a2(%rip),%eax
mov    %eax,0x3148(%rip)
jmp    1bd3 <edge_+0xaa3>
mov    0x313d(%rip),%eax
mov    %eax,0x30db(%rip)
mov    -0x28(%rbp),%rax
movslq 0x30d0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x30cf(%rip)
mov    -0x30(%rbp),%rax
movslq 0x30b8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x30cf(%rip)
mov    -0x38(%rbp),%rax
movslq 0x30a0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x30cf(%rip)
movl   $0x1,0x3101(%rip)
mov    0x3133(%rip),%eax
mov    %eax,0x30d9(%rip)
mov    0x30e7(%rip),%eax
add    $0x1,%eax
mov    %eax,0x30de(%rip)
jmp    1bd3 <edge_+0xaa3>
mov    -0x28(%rbp),%rdi
movslq 0x30b2(%rip),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
movslq 0x30a0(%rip),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x38(%rbp),%rdx
movslq 0x308e(%rip),%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x28(%rbp),%r11
movslq 0x30d8(%rip),%rax
shl    $0x3,%rax
add    %rax,%r11
mov    -0x30(%rbp),%r10
movslq 0x30c6(%rip),%rax
shl    $0x3,%rax
add    %rax,%r10
mov    -0x38(%rbp),%rax
movslq 0x30b4(%rip),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
lea    0x3002(%rip),%rcx
lea    0x3013(%rip),%r8
lea    0x3024(%rip),%r9
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%rax
jne    207e <edge_+0xf4e>
jmp    22e7 <edge_+0x11b7>
cmpl   $0x0,0x3037(%rip)
jg     2090 <edge_+0xf60>
jmp    21b9 <edge_+0x1089>
mov    -0x28(%rbp),%rcx
movslq 0x3005(%rip),%rax
shl    $0x3,%rax
add    %rax,%rcx
mov    -0x30(%rbp),%r8
movslq 0x2ff3(%rip),%rax
shl    $0x3,%rax
add    %rax,%r8
mov    -0x38(%rbp),%r9
movslq 0x2fe1(%rip),%rax
shl    $0x3,%rax
add    %rax,%r9
mov    -0x28(%rbp),%r11
movslq 0x3023(%rip),%rax
shl    $0x3,%rax
add    %rax,%r11
mov    -0x30(%rbp),%r10
movslq 0x3011(%rip),%rax
shl    $0x3,%rax
add    %rax,%r10
mov    -0x38(%rbp),%rax
movslq 0x2fff(%rip),%rdx
shl    $0x3,%rdx
add    %rdx,%rax
lea    0x2f4d(%rip),%rdi
lea    0x2f5e(%rip),%rsi
lea    0x2f6f(%rip),%rdx
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%rax
jne    2133 <edge_+0x1003>
jmp    22e7 <edge_+0x11b7>
mov    0x18(%rbp),%r8
add    $0x4,%r8
mov    0x20(%rbp),%r9
add    $0x4,%r9
mov    0x28(%rbp),%r10
add    $0x4,%r10
lea    0x2fa2(%rip),%rdi
lea    0x2eeb(%rip),%rsi
lea    0x2f38(%rip),%rdx
lea    0x2f39(%rip),%rcx
lea    0x2f42(%rip),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <swap_@plt>
mov    0x2f72(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x2f28(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2ea6(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x2f0c(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    2345 <edge_+0x1215>
mov    0x18(%rbp),%r8
add    $0x4,%r8
mov    0x20(%rbp),%r9
add    $0x4,%r9
mov    0x28(%rbp),%r10
add    $0x4,%r10
lea    0x2f1c(%rip),%rdi
lea    0x2e65(%rip),%rsi
lea    0x2eb2(%rip),%rdx
lea    0x2eb3(%rip),%rcx
lea    0x2ebc(%rip),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <swap_@plt>
mov    0x2eb0(%rip),%eax
mov    %eax,-0x44(%rbp)
mov    0x2ea3(%rip),%eax
sub    $0x1,%eax
mov    %eax,0x2e26(%rip)
mov    0x2e20(%rip),%eax
cmp    -0x44(%rbp),%eax
jl     229b <edge_+0x116b>
mov    0x10(%rbp),%rax
mov    0x2e0d(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
mov    0x2df7(%rip),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x2dde(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
mov    0x2dc8(%rip),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2db3(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x2daa(%rip)
jmp    221a <edge_+0x10ea>
mov    0x2da3(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x2e0d(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2e37(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x2df1(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2ddf(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2dd6(%rip)
jmp    2345 <edge_+0x1215>
mov    0x2dab(%rip),%eax
mov    %eax,0x2d51(%rip)
mov    -0x28(%rbp),%rax
movslq 0x2d46(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2d45(%rip)
mov    -0x30(%rbp),%rax
movslq 0x2d2e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2d45(%rip)
mov    -0x38(%rbp),%rax
movslq 0x2d16(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2d45(%rip)
movl   $0xffffffff,0x2d77(%rip)
ff ff ff
mov    0x2da9(%rip),%eax
mov    %eax,0x2d47(%rip)
mov    0x2d5d(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2d54(%rip)
jmp    1bd3 <edge_+0xaa3>
mov    0x2cd9(%rip),%eax
cmp    0x2cd7(%rip),%eax
jne    237c <edge_+0x124c>
jmp    264c <edge_+0x151c>
cmpl   $0x0,0x2d39(%rip)
jge    238e <edge_+0x125e>
jmp    24a5 <edge_+0x1375>
mov    -0x28(%rbp),%rcx
movslq 0x2d07(%rip),%rax
shl    $0x3,%rax
add    %rax,%rcx
mov    -0x30(%rbp),%r8
movslq 0x2cf5(%rip),%rax
shl    $0x3,%rax
add    %rax,%r8
mov    -0x38(%rbp),%r9
movslq 0x2ce3(%rip),%rax
shl    $0x3,%rax
add    %rax,%r9
lea    0x2c85(%rip),%rdi
lea    0x2c96(%rip),%rsi
lea    0x2ca7(%rip),%rdx
lea    0x2c80(%rip),%r11
lea    0x2c91(%rip),%r10
lea    0x2ca2(%rip),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%rax
jne    2410 <edge_+0x12e0>
jmp    1b49 <edge_+0xa19>
mov    0x18(%rbp),%r8
add    $0x4,%r8
mov    0x20(%rbp),%r9
add    $0x4,%r9
mov    0x28(%rbp),%r10
add    $0x4,%r10
lea    0x2c1d(%rip),%rdi
lea    0x2c0e(%rip),%rsi
lea    0x2c5b(%rip),%rdx
lea    0x2c5c(%rip),%rcx
lea    0x2c65(%rip),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <swap_@plt>
mov    0x2be5(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x2c5b(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2bd1(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x2c3f(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2c2d(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x2c24(%rip)
jmp    1b49 <edge_+0xa19>
mov    -0x28(%rbp),%rdi
movslq 0x2be8(%rip),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
movslq 0x2bd6(%rip),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x38(%rbp),%rdx
movslq 0x2bc4(%rip),%rax
shl    $0x3,%rax
add    %rax,%rdx
lea    0x2b6e(%rip),%rcx
lea    0x2b7f(%rip),%r8
lea    0x2b90(%rip),%r9
lea    0x2b69(%rip),%r11
lea    0x2b7a(%rip),%r10
lea    0x2b8b(%rip),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1030 <left_@plt>
cmp    $0x0,%rax
jne    2527 <edge_+0x13f7>
jmp    1b49 <edge_+0xa19>
mov    0x18(%rbp),%r8
add    $0x4,%r8
mov    0x20(%rbp),%r9
add    $0x4,%r9
mov    0x28(%rbp),%r10
add    $0x4,%r10
lea    0x2b06(%rip),%rdi
lea    0x2af7(%rip),%rsi
lea    0x2b44(%rip),%rdx
lea    0x2b45(%rip),%rcx
lea    0x2b4e(%rip),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <swap_@plt>
mov    0x2b4e(%rip),%eax
mov    %eax,0x2ac4(%rip)
mov    0x10(%rbp),%rax
mov    0x2aba(%rip),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
mov    0x2aa1(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x2a8b(%rip),%ecx
sub    $0x1,%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x10(%rbp),%rax
mov    0x2a72(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2a60(%rip),%eax
add    $0xffffffff,%eax
mov    %eax,0x2a57(%rip)
mov    0x2a51(%rip),%eax
cmp    0x2ac3(%rip),%eax
jle    2600 <edge_+0x14d0>
jmp    257c <edge_+0x144c>
mov    0x2a3e(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x2aa8(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2a2a(%rip),%edx
mov    0x10(%rbp),%rax
mov    0x2a8c(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x2a7a(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2a71(%rip)
jmp    1b49 <edge_+0xa19>
mov    0x18(%rbp),%r8
add    $0x4,%r8
mov    0x20(%rbp),%r9
add    $0x4,%r9
mov    0x28(%rbp),%r10
add    $0x4,%r10
lea    0x29e1(%rip),%rdi
lea    0x29d6(%rip),%rsi
lea    0x2a1f(%rip),%rdx
lea    0x2a20(%rip),%rcx
lea    0x2a29(%rip),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
call   1040 <swap_@plt>
mov    0x10(%rbp),%rax
mov    0x2a15(%rip),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
mov    0x29fb(%rip),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movl   $0x0,(%rax)
cmpl   $0x1,0x29da(%rip)
jle    279b <edge_+0x166b>
mov    0x29ce(%rip),%eax
sub    $0x1,%eax
shl    $0x2,%eax
mov    %eax,0x29d6(%rip)
mov    0x29bc(%rip),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rdi
add    $0x8,%rdi
mov    -0x30(%rbp),%rsi
add    $0x8,%rsi
mov    -0x38(%rbp),%rdx
add    $0x8,%rdx
mov    0x18(%rbp),%r8
add    $0x4,%r8
mov    0x20(%rbp),%r9
add    $0x4,%r9
mov    0x28(%rbp),%rbx
add    $0x4,%rbx
mov    0x10(%rbp),%r10
add    $0xc,%r10
lea    -0x44(%rbp),%rcx
lea    0x2987(%rip),%r11
lea    0x29a8(%rip),%rax
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
call   1050 <optim_@plt>
cmpl   $0x0,0x2989(%rip)
je     277f <edge_+0x164f>
cmpl   $0x1,0x297c(%rip)
je     277f <edge_+0x164f>
jmp    28f3 <edge_+0x17c3>
cmpl   $0x1,0x296a(%rip)
jne    2796 <edge_+0x1666>
mov    0x30(%rbp),%rax
movl   $0x5,(%rax)
jmp    279b <edge_+0x166b>
mov    0x2913(%rip),%eax
cmp    0x2959(%rip),%eax
jge    287d <edge_+0x174d>
mov    0x294d(%rip),%eax
sub    0x28fb(%rip),%eax
shl    $0x2,%eax
mov    %eax,0x2906(%rip)
mov    0x2938(%rip),%eax
sub    0x28e6(%rip),%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rdi
add    $0x8,%rdi
mov    -0x30(%rbp),%rsi
add    $0x8,%rsi
mov    -0x38(%rbp),%rdx
add    $0x8,%rdx
mov    0x18(%rbp),%r8
add    $0x4,%r8
mov    0x20(%rbp),%r9
add    $0x4,%r9
mov    0x28(%rbp),%rbx
add    $0x4,%rbx
mov    0x10(%rbp),%r10
mov    0x28a9(%rip),%eax
add    $0x1,%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
add    %rax,%r10
lea    -0x44(%rbp),%rcx
lea    0x28a0(%rip),%r11
lea    0x28c1(%rip),%rax
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
call   1050 <optim_@plt>
cmpl   $0x0,0x28a2(%rip)
je     2866 <edge_+0x1736>
cmpl   $0x1,0x2895(%rip)
je     2866 <edge_+0x1736>
jmp    28f3 <edge_+0x17c3>
cmpl   $0x1,0x2883(%rip)
jne    2878 <edge_+0x1748>
jmp    2909 <edge_+0x17d9>
jmp    287d <edge_+0x174d>
mov    0x30(%rbp),%rax
cmpl   $0x5,(%rax)
jne    288f <edge_+0x175f>
jmp    2909 <edge_+0x17d9>
movl   $0x0,-0xc(%rbp)
jmp    291a <edge_+0x17ea>
mov    0x30(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    291a <edge_+0x17ea>
mov    0x30(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    291a <edge_+0x17ea>
mov    0x30(%rbp),%rax
movl   $0x2,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    291a <edge_+0x17ea>
mov    0x30(%rbp),%rax
movl   $0x3,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    291a <edge_+0x17ea>
mov    0x30(%rbp),%rax
movl   $0x4,(%rax)
movl   $0x0,-0xc(%rbp)
jmp    291a <edge_+0x17ea>
mov    0x30(%rbp),%rax
movl   $0x5,(%rax)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0x68,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<edge_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    0x90(%rsp),%rbx
mov    (%rdi),%ebp
mov    %ebp,0x3efa(%rip)
mov    (%rsi),%eax
mov    %eax,0x3ef6(%rip)
mov    (%r9),%esi
mov    %esi,0x3f69(%rip)
mov    $0x1,%r11d
test   %ebp,%ebp
jle    1759 <edge_+0x629>
test   %eax,%eax
jle    1759 <edge_+0x629>
cmp    %eax,%ebp
je     1759 <edge_+0x629>
test   %esi,%esi
js     1759 <edge_+0x629>
mov    %rdi,%r10
mov    %r9,0x28(%rsp)
mov    0x88(%rsp),%rsi
mov    0x78(%rsp),%rdi
mov    0x70(%rsp),%rbx
lea    -0xc(%rbx),%r12
lea    -0x8(%r8),%r13
lea    -0x8(%rcx),%r14
lea    -0x8(%rdx),%r15
movslq -0x4(%rsi,%rbp,4),%rbx
mov    -0x4(%rdi,%rbx,4),%edi
mov    %edi,0xc(%rsp)
mov    %edi,%esi
neg    %esi
cmovs  %edi,%esi
mov    %esi,0x3e7b(%rip)
mov    %ebx,0x3ecd(%rip)
mov    %ebx,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %eax,%esi
je     1736 <edge_+0x606>
movslq %edi,%rsi
mov    0x80(%rsp),%rdi
movslq -0x4(%rdi,%rsi,4),%rdi
mov    %edi,0x3e9e(%rip)
mov    0x78(%rsp),%rsi
mov    -0x4(%rsi,%rdi,4),%esi
mov    %esi,0x3e37(%rip)
cmp    %ebx,%edi
jne    11e0 <edge_+0xb0>
mov    %r10,0x30(%rsp)
mov    %rdx,0x10(%rsp)
mov    %rcx,0x18(%rsp)
mov    %r8,0x20(%rsp)
movl   $0x0,0x3e85(%rip)
movl   $0x0,0x3e7f(%rip)
mov    0x78(%rsp),%rbx
xchg   %ax,%ax
movslq %ebp,%rcx
movsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,0x3e07(%rip)
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,0x3e11(%rip)
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x3e1a(%rip)
cltq
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x3de2(%rip)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x3dec(%rip)
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x3df5(%rip)
mov    0x88(%rsp),%rax
movslq -0x4(%rax,%rcx,4),%rax
mov    0x80(%rsp),%rcx
movslq -0x4(%rcx,%rax,4),%rcx
cmpl   $0x0,-0x4(%rbx,%rax,4)
mov    %ecx,0x3ddc(%rip)
mov    -0x4(%rbx,%rcx,4),%eax
mov    %eax,0x3e02(%rip)
mov    %eax,0x3dc8(%rip)
js     1420 <edge_+0x2f0>
cs nopw 0x0(%rax,%rax,1)
cltq
lea    (%r15,%rax,8),%rbx
lea    (%r14,%rax,8),%rbp
lea    0x0(,%rax,8),%rax
add    %r13,%rax
sub    $0x8,%rsp
lea    0x3d60(%rip),%rdi
lea    0x3d71(%rip),%rsi
lea    0x3d82(%rip),%rdx
lea    0x3d43(%rip),%rcx
lea    0x3d54(%rip),%r8
lea    0x3d65(%rip),%r9
push   %rax
push   %rbp
push   %rbx
call   1030 <left_@plt>
add    $0x20,%rsp
test   %rax,%rax
jne    13a0 <edge_+0x270>
movslq 0x3d61(%rip),%rax
mov    0x80(%rsp),%rcx
movslq -0x4(%rcx,%rax,4),%rax
mov    %eax,0x3d4e(%rip)
mov    0x78(%rsp),%rbx
mov    -0x4(%rbx,%rax,4),%eax
mov    %eax,0x3d3b(%rip)
cmp    0x3d69(%rip),%eax
jne    12e0 <edge_+0x1b0>
cmpl   $0x0,0x3d48(%rip)
jg     174b <edge_+0x61b>
movl   $0x1,0x3d38(%rip)
mov    0x3cc6(%rip),%ebp
mov    %ebp,0x3cbc(%rip)
mov    0x30(%rsp),%rax
mov    (%rax),%eax
mov    %eax,0x3cb3(%rip)
jmp    1240 <edge_+0x110>
xchg   %ax,%ax
mov    0x3cf2(%rip),%eax
mov    0x78(%rsp),%rbx
jmp    1420 <edge_+0x2f0>
nopl   (%rax)
lea    (%r15,%rcx,8),%rax
lea    (%r14,%rcx,8),%rbp
lea    0x0(,%rcx,8),%rbx
add    %r13,%rbx
sub    $0x8,%rsp
lea    0x3c92(%rip),%rdi
lea    0x3ca3(%rip),%rsi
lea    0x3cb4(%rip),%rdx
lea    0x3c75(%rip),%rcx
lea    0x3c86(%rip),%r8
lea    0x3c97(%rip),%r9
push   %rbx
mov    0x88(%rsp),%rbx
push   %rbp
push   %rax
call   1030 <left_@plt>
add    $0x20,%rsp
test   %rax,%rax
je     1369 <edge_+0x239>
mov    0x3c84(%rip),%eax
cmp    0x3cb2(%rip),%eax
je     1369 <edge_+0x239>
mov    %eax,0x3c7a(%rip)
movslq 0x3c6f(%rip),%rax
mov    0x80(%rsp),%rcx
movslq -0x4(%rcx,%rax,4),%rax
mov    %eax,0x3c5c(%rip)
mov    -0x4(%rbx,%rax,4),%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
mov    %ecx,0x3c47(%rip)
lea    (%r15,%rcx,8),%rax
lea    (%r14,%rcx,8),%rbp
lea    0x0(,%rcx,8),%rbx
add    %r13,%rbx
sub    $0x8,%rsp
lea    0x3be9(%rip),%rdi
lea    0x3bfa(%rip),%rsi
lea    0x3c0b(%rip),%rdx
lea    0x3bdc(%rip),%rcx
lea    0x3bed(%rip),%r8
lea    0x3bfe(%rip),%r9
push   %rbx
mov    0x88(%rsp),%rbx
push   %rbp
push   %rax
call   1030 <left_@plt>
add    $0x20,%rsp
test   %rax,%rax
je     140e <edge_+0x2de>
movsd  0x3ba1(%rip),%xmm5
movsd  0x3ba1(%rip),%xmm3
movsd  0x3ba9(%rip),%xmm6
movsd  0x3ba9(%rip),%xmm4
movapd %xmm6,%xmm0
mulsd  %xmm4,%xmm0
movapd %xmm5,%xmm7
mulsd  %xmm3,%xmm7
addsd  %xmm0,%xmm7
movsd  0x3b9d(%rip),%xmm0
movsd  0x3b9d(%rip),%xmm1
movapd %xmm0,%xmm8
mulsd  %xmm1,%xmm8
addsd  %xmm7,%xmm8
movslq 0x3b8f(%rip),%rcx
movslq 0x3b90(%rip),%rax
unpcklpd %xmm6,%xmm6
movsd  (%r14,%rax,8),%xmm7
movhpd (%r14,%rcx,8),%xmm7
mulpd  %xmm7,%xmm6
movsd  (%r15,%rax,8),%xmm2
movhpd (%r15,%rcx,8),%xmm2
unpcklpd %xmm5,%xmm5
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
unpcklpd %xmm0,%xmm0
movsd  0x0(%r13,%rax,8),%xmm6
movhpd 0x0(%r13,%rcx,8),%xmm6
mulpd  %xmm6,%xmm0
addpd  %xmm5,%xmm0
unpcklpd %xmm4,%xmm4
mulpd  %xmm7,%xmm4
unpcklpd %xmm3,%xmm3
mulpd  %xmm2,%xmm3
addpd  %xmm4,%xmm3
unpcklpd %xmm1,%xmm1
mulpd  %xmm6,%xmm1
addpd  %xmm3,%xmm1
movapd %xmm8,%xmm2
unpcklpd %xmm8,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
subpd  %xmm2,%xmm3
xorpd  %xmm2,%xmm2
cmpnlepd %xmm3,%xmm2
movmskpd %xmm2,%eax
cmp    $0x3,%al
je     13b0 <edge_+0x280>
xorpd  0x1a56(%rip),%xmm8
pshufd $0x44,%xmm8,%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
xorpd  %xmm0,%xmm0
cmpnlepd %xmm2,%xmm0
movmskpd %xmm0,%eax
cmp    $0x3,%al
je     13b0 <edge_+0x280>
mov    0x3ae1(%rip),%edx
lea    0x1(%rdx),%eax
mov    %eax,0x3ad8(%rip)
cmp    0x3ae6(%rip),%edx
jge    173b <edge_+0x60b>
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rax,1),%edx
lea    (%rax,%rax,1),%esi
add    $0x1,%esi
movslq %esi,%rsi
mov    %ecx,(%r12,%rsi,4)
mov    0x3a9a(%rip),%ecx
movslq %edx,%rdx
mov    %ecx,0x8(%r12,%rdx,4)
movslq 0x3a83(%rip),%rcx
mov    0x88(%rsp),%rdx
movslq -0x4(%rdx,%rcx,4),%rcx
mov    0x80(%rsp),%rdx
mov    -0x4(%rdx,%rcx,4),%esi
mov    %esi,0x3a68(%rip)
mov    0x3a66(%rip),%edx
nopw   0x0(%rax,%rax,1)
movslq %esi,%rsi
cmp    %edx,-0x4(%rbx,%rsi,4)
je     1670 <edge_+0x540>
mov    0x80(%rsp),%rdi
mov    -0x4(%rdi,%rsi,4),%esi
mov    %esi,0x3a41(%rip)
cmp    %ecx,%esi
jne    1640 <edge_+0x510>
cmp    %edx,-0x4(%rbx,%rcx,4)
je     1673 <edge_+0x543>
jmp    174b <edge_+0x61b>
nopw   0x0(%rax,%rax,1)
mov    %rsi,%rcx
mov    0x80(%rsp),%rdx
movslq -0x4(%rdx,%rcx,4),%rcx
mov    %ecx,0x3a16(%rip)
mov    -0x4(%rbx,%rcx,4),%ecx
mov    %ecx,%edx
neg    %edx
cmovs  %ecx,%edx
mov    %edx,0x3a29(%rip)
cmp    0x39af(%rip),%edx
je     176d <edge_+0x63d>
mov    %edx,%eax
lea    (%r15,%rax,8),%rbp
lea    (%r14,%rax,8),%rbx
lea    0x0(,%rax,8),%rax
add    %r13,%rax
sub    $0x8,%rsp
lea    0x3995(%rip),%rdi
lea    0x39a6(%rip),%rsi
lea    0x39b7(%rip),%rdx
lea    0x3988(%rip),%rcx
lea    0x3999(%rip),%r8
lea    0x39aa(%rip),%r9
push   %rax
push   %rbx
push   %rbp
call   1030 <left_@plt>
add    $0x20,%rsp
test   %rax,%rax
mov    0x39c5(%rip),%eax
lea    0x3996(%rip),%rcx
lea    0x3997(%rip),%rdx
cmove  %rdx,%rcx
mov    %eax,(%rcx)
mov    0x399f(%rip),%ecx
lea    0x1(%rcx),%eax
mov    %eax,0x3996(%rip)
cmp    0x39a4(%rip),%ecx
jge    173b <edge_+0x60b>
mov    0x396c(%rip),%ecx
mov    0x78(%rsp),%rbx
jmp    15f0 <edge_+0x4c0>
xor    %r11d,%r11d
jmp    1751 <edge_+0x621>
mov    0x90(%rsp),%rbx
mov    $0x2,%r11d
jmp    1759 <edge_+0x629>
mov    $0x3,%r11d
mov    0x90(%rsp),%rbx
mov    %r11d,(%rbx)
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ecx,0xc(%rsp)
mov    0x28(%rsp),%rcx
mov    %eax,(%rcx)
mov    %eax,0x394a(%rip)
movl   $0x1,0x3924(%rip)
mov    $0x1,%ecx
jmp    179c <edge_+0x66c>
nop
mov    0x3916(%rip),%ecx
mov    0x3918(%rip),%eax
movl   $0x0,0x390a(%rip)
mov    0x389c(%rip),%edx
mov    %edx,0x3892(%rip)
movsd  0x389e(%rip),%xmm0
movsd  %xmm0,0x388e(%rip)
movsd  0x38a6(%rip),%xmm0
movsd  %xmm0,0x3896(%rip)
movsd  0x38ae(%rip),%xmm0
movsd  %xmm0,0x389e(%rip)
lea    (%rcx,%rcx,1),%esi
lea    0x1(%rcx,%rcx,1),%edx
movslq %edx,%rdx
mov    (%r12,%rdx,4),%edx
mov    %edx,0x38a2(%rip)
movslq %esi,%rsi
mov    0x8(%r12,%rsi,4),%esi
mov    %esi,0x389c(%rip)
mov    %ecx,0x389e(%rip)
cmp    %eax,%ecx
jne    1894 <edge_+0x764>
jmp    1f71 <edge_+0xe41>
nopw   0x0(%rax,%rax,1)
movslq 0x3871(%rip),%rax
mov    %eax,0x3817(%rip)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x3815(%rip)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x381f(%rip)
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x3828(%rip)
movl   $0xffffffff,0x384e(%rip)
ff ff ff
mov    0x78(%rsp),%rbx
mov    0x3853(%rip),%eax
mov    %eax,0x3825(%rip)
mov    0x382f(%rip),%ecx
add    $0x1,%ecx
mov    %ecx,0x3826(%rip)
cmp    0x382c(%rip),%ecx
je     1d60 <edge_+0xc30>
mov    0x3804(%rip),%edx
lea    0x1(%rcx),%eax
mov    %eax,0x3827(%rip)
lea    (%rcx,%rcx,1),%eax
add    $0x3,%eax
cltq
movslq (%r12,%rax,4),%rax
mov    %eax,0x3811(%rip)
cmp    %edx,%eax
jne    1a20 <edge_+0x8f0>
lea    (%rcx,%rcx,1),%eax
add    $0x2,%eax
cltq
movslq 0x8(%r12,%rax,4),%rax
mov    %eax,0x37f6(%rip)
movslq 0x37cf(%rip),%rdx
lea    (%r15,%rdx,8),%rcx
lea    (%r14,%rdx,8),%r8
lea    0x0(%r13,%rdx,8),%r9
lea    (%r15,%rax,8),%rbp
lea    (%r14,%rax,8),%rbx
lea    0x0(,%rax,8),%rax
add    %r13,%rax
sub    $0x8,%rsp
lea    0x3754(%rip),%rdi
lea    0x3765(%rip),%rsi
lea    0x3776(%rip),%rdx
push   %rax
push   %rbx
push   %rbp
call   1030 <left_@plt>
add    $0x20,%rsp
test   %rax,%rax
je     1c30 <edge_+0xb00>
cmpl   $0x0,0x378a(%rip)
js     1b5d <edge_+0xa2d>
lea    0x378d(%rip),%rdi
lea    0x370a(%rip),%rsi
lea    0x3757(%rip),%rdx
lea    0x3758(%rip),%rcx
mov    0x78(%rsp),%rbx
mov    %rbx,%r8
mov    0x80(%rsp),%r9
lea    0x3745(%rip),%rax
push   %rax
push   0x90(%rsp)
call   1040 <swap_@plt>
add    $0x10,%rsp
mov    0x373e(%rip),%eax
mov    0x3748(%rip),%ecx
mov    %ecx,0x36be(%rip)
cmp    %eax,%ecx
jg     19cf <edge_+0x89f>
cs nopw 0x0(%rax,%rax,1)
lea    (%rcx,%rcx,1),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%r12,%rdx,4),%edx
lea    -0x1(%rcx,%rcx,1),%ecx
movslq %ecx,%rcx
mov    %edx,(%r12,%rcx,4)
mov    0x3692(%rip),%ecx
add    %ecx,%ecx
movslq %ecx,%rcx
mov    0x8(%r12,%rcx,4),%edx
mov    %edx,(%r12,%rcx,4)
mov    0x367e(%rip),%edx
lea    0x1(%rdx),%ecx
mov    %ecx,0x3675(%rip)
cmp    %eax,%edx
jl     1990 <edge_+0x860>
mov    0x366f(%rip),%ecx
lea    (%rax,%rax,1),%edx
lea    (%rax,%rax,1),%esi
add    $0x1,%esi
movslq %esi,%rsi
mov    %ecx,(%r12,%rsi,4)
mov    0x36d5(%rip),%ecx
movslq %edx,%rdx
mov    %ecx,0x8(%r12,%rdx,4)
add    $0xffffffff,%eax
mov    %eax,0x36b8(%rip)
mov    0x36be(%rip),%eax
mov    %eax,0x3698(%rip)
mov    0x369a(%rip),%ecx
cmp    0x36a0(%rip),%ecx
jne    188e <edge_+0x75e>
jmp    1d60 <edge_+0xc30>
nop
movslq %edx,%rcx
lea    (%r15,%rcx,8),%rdi
lea    (%r14,%rcx,8),%rsi
lea    0x0(,%rcx,8),%rdx
add    %r13,%rdx
lea    (%r15,%rax,8),%rbp
lea    (%r14,%rax,8),%rbx
lea    0x0(,%rax,8),%rax
add    %r13,%rax
sub    $0x8,%rsp
lea    0x35fc(%rip),%rcx
lea    0x360d(%rip),%r8
lea    0x361e(%rip),%r9
push   %rax
push   %rbx
push   %rbp
call   1030 <left_@plt>
add    $0x20,%rsp
test   %rax,%rax
je     1820 <edge_+0x6f0>
cmpl   $0x0,0x3632(%rip)
jle    1c88 <edge_+0xb58>
movslq 0x3615(%rip),%rax
lea    (%r15,%rax,8),%rcx
lea    (%r14,%rax,8),%r8
lea    0x0(,%rax,8),%r9
add    %r13,%r9
movslq 0x361b(%rip),%rax
lea    (%r15,%rax,8),%rbp
lea    (%r14,%rax,8),%rbx
lea    0x0(,%rax,8),%rax
add    %r13,%rax
sub    $0x8,%rsp
lea    0x358d(%rip),%rdi
lea    0x359e(%rip),%rsi
lea    0x35af(%rip),%rdx
push   %rax
push   %rbx
push   %rbp
call   1030 <left_@plt>
add    $0x20,%rsp
test   %rax,%rax
je     1820 <edge_+0x6f0>
lea    0x35d3(%rip),%rdi
lea    0x3550(%rip),%rsi
lea    0x359d(%rip),%rdx
lea    0x359e(%rip),%rcx
mov    0x78(%rsp),%rbx
mov    %rbx,%r8
mov    0x80(%rsp),%r9
lea    0x358b(%rip),%rax
push   %rax
push   0x90(%rsp)
call   1040 <swap_@plt>
add    $0x10,%rsp
mov    0x3590(%rip),%eax
mov    0x3572(%rip),%ecx
add    %ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %eax,(%r12,%rcx,4)
mov    0x34fc(%rip),%eax
mov    0x355a(%rip),%ecx
add    %ecx,%ecx
movslq %ecx,%rcx
mov    %eax,0x8(%r12,%rcx,4)
jmp    1867 <edge_+0x737>
movslq 0x3534(%rip),%rax
lea    (%r15,%rax,8),%rdi
lea    (%r14,%rax,8),%rsi
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
movslq 0x3542(%rip),%rax
lea    (%r15,%rax,8),%rbp
lea    (%r14,%rax,8),%rbx
lea    0x0(,%rax,8),%rax
add    %r13,%rax
sub    $0x8,%rsp
lea    0x34b4(%rip),%rcx
lea    0x34c5(%rip),%r8
lea    0x34d6(%rip),%r9
push   %rax
push   %rbx
push   %rbp
call   1030 <left_@plt>
add    $0x20,%rsp
test   %rax,%rax
je     1c30 <edge_+0xb00>
lea    0x34fe(%rip),%rdi
lea    0x347b(%rip),%rsi
lea    0x34c8(%rip),%rdx
lea    0x34c9(%rip),%rcx
mov    0x78(%rsp),%rbx
mov    %rbx,%r8
mov    0x80(%rsp),%r9
lea    0x34b6(%rip),%rax
push   %rax
push   0x90(%rsp)
call   1040 <swap_@plt>
add    $0x10,%rsp
mov    0x343f(%rip),%eax
mov    0x349d(%rip),%ecx
add    %ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %eax,(%r12,%rcx,4)
mov    0x34a3(%rip),%eax
mov    0x3485(%rip),%ecx
add    %ecx,%ecx
movslq %ecx,%rcx
mov    %eax,0x8(%r12,%rcx,4)
jmp    1c77 <edge_+0xb47>
nop
movslq 0x3469(%rip),%rax
mov    %eax,0x3407(%rip)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x3405(%rip)
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x340f(%rip)
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x3418(%rip)
movl   $0x1,0x343e(%rip)
mov    0x78(%rsp),%rbx
mov    0x3443(%rip),%eax
mov    %eax,0x341d(%rip)
jmp    1873 <edge_+0x743>
lea    0x3431(%rip),%rdi
lea    0x33ae(%rip),%rsi
lea    0x33fb(%rip),%rdx
lea    0x33fc(%rip),%rcx
mov    0x78(%rsp),%rbx
mov    %rbx,%r8
mov    0x80(%rsp),%r9
lea    0x33e9(%rip),%rax
push   %rax
push   0x90(%rsp)
call   1040 <swap_@plt>
add    $0x10,%rsp
mov    0x33da(%rip),%eax
mov    0x33d0(%rip),%ecx
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rcx),%edx
mov    %edx,0x3357(%rip)
cmp    %eax,%ecx
jle    1d28 <edge_+0xbf8>
add    %edx,%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%r12,%rdx,4),%edx
lea    0x1(%rcx,%rcx,1),%ecx
movslq %ecx,%rcx
mov    %edx,(%r12,%rcx,4)
mov    0x3336(%rip),%ecx
lea    (%rcx,%rcx,1),%edx
movslq %edx,%rdx
mov    0x8(%r12,%rdx,4),%edx
lea    0x4(%rcx,%rcx,1),%ecx
movslq %ecx,%rcx
mov    %edx,(%r12,%rcx,4)
mov    0x331a(%rip),%ecx
jmp    1ce0 <edge_+0xbb0>
mov    0x3316(%rip),%ecx
lea    (%rax,%rax,1),%edx
lea    (%rax,%rax,1),%esi
add    $0x1,%esi
movslq %esi,%rsi
mov    %ecx,(%r12,%rsi,4)
mov    0x337c(%rip),%ecx
movslq %edx,%rdx
mov    %ecx,0x8(%r12,%rdx,4)
add    $0x1,%eax
mov    %eax,0x3357(%rip)
jmp    1867 <edge_+0x737>
nopw   0x0(%rax,%rax,1)
mov    0x32de(%rip),%eax
cmp    0x32dc(%rip),%eax
je     1f71 <edge_+0xe41>
cmpl   $0x0,0x3337(%rip)
js     1e51 <edge_+0xd21>
movslq 0x331a(%rip),%rax
lea    (%r15,%rax,8),%rcx
lea    (%r14,%rax,8),%r8
lea    0x0(,%rax,8),%r9
add    %r13,%r9
sub    $0x8,%rsp
lea    0x32ac(%rip),%rdi
lea    0x32bd(%rip),%rsi
lea    0x32ce(%rip),%rdx
lea    0x32d7(%rip),%rax
push   %rax
lea    0x32b7(%rip),%rax
push   %rax
lea    0x3297(%rip),%rax
push   %rax
call   1030 <left_@plt>
add    $0x20,%rsp
test   %rax,%rax
je     1790 <edge_+0x660>
lea    0x3269(%rip),%rdi
lea    0x325a(%rip),%rsi
lea    0x32a7(%rip),%rdx
lea    0x32a8(%rip),%rcx
mov    %rbx,%r8
mov    0x80(%rsp),%r9
lea    0x329a(%rip),%rax
push   %rax
push   0x90(%rsp)
call   1040 <swap_@plt>
add    $0x10,%rsp
mov    0x3223(%rip),%eax
mov    0x328d(%rip),%ecx
lea    (%rcx,%rcx,1),%edx
lea    0x1(%rcx,%rcx,1),%esi
movslq %esi,%rsi
mov    %eax,(%r12,%rsi,4)
mov    0x3211(%rip),%eax
movslq %edx,%rdx
mov    %eax,0x8(%r12,%rdx,4)
add    $0xffffffff,%ecx
mov    %ecx,0x3268(%rip)
jmp    1790 <edge_+0x660>
movslq 0x3240(%rip),%rax
lea    (%r15,%rax,8),%rdi
lea    (%r14,%rax,8),%rsi
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
sub    $0x8,%rsp
lea    0x31da(%rip),%rcx
lea    0x31eb(%rip),%r8
lea    0x31fc(%rip),%r9
lea    0x3205(%rip),%rax
push   %rax
lea    0x31e5(%rip),%rax
push   %rax
lea    0x31c5(%rip),%rax
push   %rax
call   1030 <left_@plt>
add    $0x20,%rsp
test   %rax,%rax
je     1790 <edge_+0x660>
lea    0x3197(%rip),%rdi
lea    0x3188(%rip),%rsi
lea    0x31d5(%rip),%rdx
lea    0x31d6(%rip),%rcx
mov    %rbx,%r8
mov    0x80(%rsp),%r9
lea    0x31c8(%rip),%rax
push   %rax
push   0x90(%rsp)
call   1040 <swap_@plt>
add    $0x10,%rsp
mov    0x31c1(%rip),%ecx
mov    %ecx,0x3147(%rip)
mov    0x31ad(%rip),%eax
nop
lea    (%rcx,%rcx,1),%edx
add    $0xffffffff,%edx
movslq %edx,%rdx
mov    (%r12,%rdx,4),%edx
lea    0x1(%rcx,%rcx,1),%ecx
movslq %ecx,%rcx
mov    %edx,(%r12,%rcx,4)
mov    0x3122(%rip),%ecx
add    %ecx,%ecx
movslq %ecx,%rcx
mov    (%r12,%rcx,4),%edx
mov    %edx,0x8(%r12,%rcx,4)
mov    0x310e(%rip),%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x3105(%rip)
cmp    %eax,%ecx
jg     1f00 <edge_+0xdd0>
mov    0x30ff(%rip),%ecx
lea    (%rax,%rax,1),%edx
lea    (%rax,%rax,1),%esi
add    $0x1,%esi
movslq %esi,%rsi
mov    %ecx,(%r12,%rsi,4)
mov    0x30f1(%rip),%ecx
movslq %edx,%rdx
mov    %ecx,0x8(%r12,%rdx,4)
add    $0x1,%eax
mov    %eax,0x3140(%rip)
jmp    1790 <edge_+0x660>
lea    0x30d4(%rip),%rdi
lea    0x30c9(%rip),%rsi
lea    0x3112(%rip),%rdx
lea    0x3113(%rip),%rcx
mov    %rbx,%r8
mov    0x80(%rsp),%r9
lea    0x3105(%rip),%rax
push   %rax
push   0x90(%rsp)
call   1040 <swap_@plt>
add    $0x10,%rsp
mov    0x30f2(%rip),%eax
add    %eax,%eax
add    $0x1,%eax
cltq
movl   $0x0,(%r12,%rax,4)
mov    0x30dd(%rip),%eax
add    %eax,%eax
cltq
movl   $0x0,0x8(%r12,%rax,4)
mov    0x90(%rsp),%rbx
movl   $0x0,(%rbx)
mov    0x30bc(%rip),%eax
cmp    $0x2,%eax
mov    0x20(%rsp),%rdx
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rdi
jl     2074 <edge_+0xf44>
lea    -0x4(,%rax,4),%ecx
mov    %ecx,0x30ab(%rip)
lea    0x30a4(%rip),%rbp
add    $0xffffffff,%eax
mov    %eax,0xc(%rsp)
lea    0x309a(%rip),%rax
lea    0xc(%rsp),%rcx
mov    0x78(%rsp),%r8
mov    0x80(%rsp),%r9
push   %rax
push   0x78(%rsp)
push   %rbp
push   0xa0(%rsp)
call   1050 <optim_@plt>
mov    0x30(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    0x40(%rsp),%rdx
add    $0x20,%rsp
mov    $0x4,%r11d
cmpl   $0x1,0x3056(%rip)
ja     1759 <edge_+0x629>
jne    2074 <edge_+0xf44>
movl   $0x5,(%rbx)
mov    0x302e(%rip),%eax
mov    0x3048(%rip),%ecx
sub    %eax,%ecx
jle    20f3 <edge_+0xfc3>
lea    0x0(,%rcx,4),%ebp
mov    %ebp,0x3027(%rip)
lea    0x3020(%rip),%r10
mov    %ecx,0xc(%rsp)
add    %eax,%eax
add    $0x3,%eax
cltq
lea    (%r12,%rax,4),%rax
lea    0x300e(%rip),%rbp
lea    0xc(%rsp),%rcx
mov    0x78(%rsp),%r8
mov    0x80(%rsp),%r9
push   %rbp
push   %rax
push   %r10
push   0xa0(%rsp)
call   1050 <optim_@plt>
add    $0x20,%rsp
mov    $0x4,%r11d
cmpl   $0x1,0x2fdb(%rip)
ja     1759 <edge_+0x629>
mov    $0x5,%r11d
je     1759 <edge_+0x629>
mov    $0x5,%r11d
cmpl   $0x5,(%rbx)
je     1759 <edge_+0x629>
jmp    175c <edge_+0x62c>

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

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