#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 */
double acos(double);
int /*<<< orphan*/ circum_(double *, double *, double *, double *, int *);
int lstptr_(int *, int *, int *, int *);
int /*<<< orphan*/ swptst_(int *, int *, int *, int *, double *, double *,
                           double *);
int crlist_(int *n, int *ncol, double *x, double *y, double *z__, int *list,
            int *lend, int *lptr, int *lnew, int *ltri, int *listc, int *nb,
            double *xc, double *yc, double *zc, double *rc, int *ier) {
  int i__1, i__2;
  static double c__[3], t;
  static int i1, i2, i3, i4, n0, n1, n2, n3, n4;
  static double v1[3], v2[3], v3[3];
  static int lp, kt, nn, nt, nm2, kt1, kt2, kt11, kt12, kt21, kt22, lpl, lpn;
  static int swp;
  static int ierr;
  --lend;
  --z__;
  --y;
  --x;
  ltri -= 7;
  --list;
  --lptr;
  --listc;
  --xc;
  --yc;
  --zc;
  --rc;
  nn = *n;
  *nb = 0;
  nt = 0;
  if (nn < 3) {
    goto L21;
  }
  i__1 = nn;
  for (n1 = 1; n1 <= i__1; ++n1) {
    lp = lend[n1];
    if (list[lp] < 0) {
      goto L2;
    }
  }
  goto L9;
L2:
  n2 = -list[lp];
  lp = lptr[lp];
  n3 = list[lp];
L3:
  ++nt;
  if (nt <= *ncol) {
    ltri[nt * 6 + 1] = n1;
    ltri[nt * 6 + 2] = n2;
    ltri[nt * 6 + 3] = n3;
    ltri[nt * 6 + 4] = nt + 1;
    ltri[nt * 6 + 5] = nt - 1;
    ltri[nt * 6 + 6] = 0;
  }
  n1 = n2;
  lp = lend[n1];
  n2 = -list[lp];
  if (n2 != n3) {
    goto L3;
  }
  *nb = nt + 2;
  if (*ncol < nt) {
    goto L22;
  }
  ltri[nt * 6 + 4] = 0;
  if (nt == 1) {
    goto L7;
  }
L4:
  swp = (0);
  i__1 = nt - 1;
  for (kt1 = 1; kt1 <= i__1; ++kt1) {
    for (i3 = 1; i3 <= 3; ++i3) {
      kt2 = ltri[i3 + 3 + kt1 * 6];
      if (kt2 <= kt1) {
        goto L5;
      }
      if (i3 == 1) {
        i1 = 2;
        i2 = 3;
      } else if (i3 == 2) {
        i1 = 3;
        i2 = 1;
      } else {
        i1 = 1;
        i2 = 2;
      }
      n1 = ltri[i1 + kt1 * 6];
      n2 = ltri[i2 + kt1 * 6];
      n3 = ltri[i3 + kt1 * 6];
      if (ltri[kt2 * 6 + 4] == kt1) {
        i4 = 1;
      } else if (ltri[kt2 * 6 + 5] == kt1) {
        i4 = 2;
      } else {
        i4 = 3;
      }
      n4 = ltri[i4 + kt2 * 6];
      if (!swptst_(&n1, &n2, &n3, &n4, &x[1], &y[1], &z__[1])) {
        goto L5;
      }
      swp = (1);
      kt11 = ltri[i1 + 3 + kt1 * 6];
      kt12 = ltri[i2 + 3 + kt1 * 6];
      if (i4 == 1) {
        i2 = 2;
        i1 = 3;
      } else if (i4 == 2) {
        i2 = 3;
        i1 = 1;
      } else {
        i2 = 1;
        i1 = 2;
      }
      kt21 = ltri[i1 + 3 + kt2 * 6];
      kt22 = ltri[i2 + 3 + kt2 * 6];
      ltri[kt1 * 6 + 1] = n4;
      ltri[kt1 * 6 + 2] = n3;
      ltri[kt1 * 6 + 3] = n1;
      ltri[kt1 * 6 + 4] = kt12;
      ltri[kt1 * 6 + 5] = kt22;
      ltri[kt1 * 6 + 6] = kt2;
      ltri[kt2 * 6 + 1] = n3;
      ltri[kt2 * 6 + 2] = n4;
      ltri[kt2 * 6 + 3] = n2;
      ltri[kt2 * 6 + 4] = kt21;
      ltri[kt2 * 6 + 5] = kt11;
      ltri[kt2 * 6 + 6] = kt1;
      if (kt11 != 0) {
        i4 = 4;
        if (ltri[kt11 * 6 + 4] != kt1) {
          i4 = 5;
          if (ltri[kt11 * 6 + 5] != kt1) {
            i4 = 6;
          }
        }
        ltri[i4 + kt11 * 6] = kt2;
      }
      if (kt22 != 0) {
        i4 = 4;
        if (ltri[kt22 * 6 + 4] != kt2) {
          i4 = 5;
          if (ltri[kt22 * 6 + 5] != kt2) {
            i4 = 6;
          }
        }
        ltri[i4 + kt22 * 6] = kt1;
      }
    L5:;
    }
  }
  if (swp) {
    goto L4;
  }
L7:
  i__1 = nt;
  for (kt = 1; kt <= i__1; ++kt) {
    n1 = ltri[kt * 6 + 1];
    n2 = ltri[kt * 6 + 2];
    n3 = ltri[kt * 6 + 3];
    v1[0] = x[n1];
    v1[1] = y[n1];
    v1[2] = z__[n1];
    v2[0] = x[n2];
    v2[1] = y[n2];
    v2[2] = z__[n2];
    v3[0] = x[n3];
    v3[1] = y[n3];
    v3[2] = z__[n3];
    circum_(v1, v2, v3, c__, &ierr);
    if (ierr != 0) {
      goto L23;
    }
    xc[kt] = c__[0];
    yc[kt] = c__[1];
    zc[kt] = c__[2];
    t = v1[0] * c__[0] + v1[1] * c__[1] + v1[2] * c__[2];
    if (t < -1.) {
      t = -1.;
    }
    if (t > 1.) {
      t = 1.;
    }
    rc[kt] = acos(t);
  }
L9:
  kt = nt;
  nm2 = nn - 2;
  i__1 = nm2;
  for (n1 = 1; n1 <= i__1; ++n1) {
    lpl = lend[n1];
    lp = lpl;
    n3 = list[lp];
  L10:
    lp = lptr[lp];
    n2 = n3;
    n3 = (i__2 = list[lp], ((i__2) >= 0 ? (i__2) : -(i__2)));
    if (n2 <= n1 || n3 <= n1) {
      goto L11;
    }
    ++kt;
    v1[0] = x[n1];
    v1[1] = y[n1];
    v1[2] = z__[n1];
    v2[0] = x[n2];
    v2[1] = y[n2];
    v2[2] = z__[n2];
    v3[0] = x[n3];
    v3[1] = y[n3];
    v3[2] = z__[n3];
    circum_(v1, v2, v3, c__, &ierr);
    if (ierr != 0) {
      goto L23;
    }
    xc[kt] = c__[0];
    yc[kt] = c__[1];
    zc[kt] = c__[2];
    t = v1[0] * c__[0] + v1[1] * c__[1] + v1[2] * c__[2];
    if (t < -1.) {
      t = -1.;
    }
    if (t > 1.) {
      t = 1.;
    }
    rc[kt] = acos(t);
    lpn = lstptr_(&lpl, &n2, &list[1], &lptr[1]);
    listc[lpn] = kt;
    lpn = lstptr_(&lend[n2], &n3, &list[1], &lptr[1]);
    listc[lpn] = kt;
    lpn = lstptr_(&lend[n3], &n1, &list[1], &lptr[1]);
    listc[lpn] = kt;
  L11:
    if (lp != lpl) {
      goto L10;
    }
  }
  if (nt == 0) {
    goto L20;
  }
  kt1 = 0;
L13:
  ++kt1;
  if (ltri[kt1 * 6 + 4] == 0) {
    i1 = 2;
    i2 = 3;
    i3 = 1;
    goto L14;
  } else if (ltri[kt1 * 6 + 5] == 0) {
    i1 = 3;
    i2 = 1;
    i3 = 2;
    goto L14;
  } else if (ltri[kt1 * 6 + 6] == 0) {
    i1 = 1;
    i2 = 2;
    i3 = 3;
    goto L14;
  }
  goto L13;
L14:
  n1 = ltri[i1 + kt1 * 6];
  n0 = n1;
L15:
  lp = lend[n1];
  lpn = lptr[lp];
  listc[lp] = kt1;
L16:
  kt2 = ltri[i2 + 3 + kt1 * 6];
  if (kt2 != 0) {
    lptr[lp] = *lnew;
    lp = *lnew;
    listc[lp] = kt2;
    ++(*lnew);
    kt1 = kt2;
    if (ltri[kt1 * 6 + 1] == n1) {
      i1 = 1;
      i2 = 2;
      i3 = 3;
    } else if (ltri[kt1 * 6 + 2] == n1) {
      i1 = 2;
      i2 = 3;
      i3 = 1;
    } else {
      i1 = 3;
      i2 = 1;
      i3 = 2;
    }
    goto L16;
  }
  lptr[lp] = lpn;
  n1 = ltri[i3 + kt1 * 6];
  if (n1 != n0) {
    i4 = i3;
    i3 = i2;
    i2 = i1;
    i1 = i4;
    goto L15;
  }
L20:
  *ier = 0;
  return 0;
L21:
  *ier = 1;
  return 0;
L22:
  *ier = 2;
  return 0;
L23:
  *ier = 3;
  return 0;
}


x86 assembly (clang, -O0):
<crlist_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x20(%rbp)
mov    0x28(%rbp),%rax
add    $0xffffffffffffffe4,%rax
mov    %rax,0x28(%rbp)
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x30(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rbp)
mov    0x48(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x48(%rbp)
mov    0x50(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x50(%rbp)
mov    0x58(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x3ed8(%rip)
mov    0x38(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,0x3ec8(%rip)
cmpl   $0x3,0x3ebd(%rip)
jge    124e <crlist_+0x10e>
jmp    23cc <crlist_+0x128c>
mov    0x3eac(%rip),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x3e23(%rip)
mov    0x3e1d(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     12b7 <crlist_+0x177>
mov    0x10(%rbp),%rax
movslq 0x3e09(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3e74(%rip)
mov    -0x38(%rbp),%rax
movslq 0x3e69(%rip),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    129e <crlist_+0x15e>
jmp    12bc <crlist_+0x17c>
jmp    12a3 <crlist_+0x163>
mov    0x3ddb(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3dd2(%rip)
jmp    1261 <crlist_+0x121>
jmp    1ca8 <crlist_+0xb68>
mov    -0x38(%rbp),%rcx
movslq 0x3e31(%rip),%rdx
xor    %eax,%eax
sub    (%rcx,%rdx,4),%eax
mov    %eax,0x3db6(%rip)
mov    0x18(%rbp),%rax
movslq 0x3e1b(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3e12(%rip)
mov    -0x38(%rbp),%rax
movslq 0x3e07(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3d92(%rip)
mov    0x3e04(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3dfb(%rip)
mov    0x3df5(%rip),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jg     13bb <crlist_+0x27b>
mov    0x3d63(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x3dd8(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3d4d(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x3dbe(%rip),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3d37(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x3da4(%rip),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3d95(%rip),%edx
add    $0x1,%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x3d87(%rip),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3d78(%rip),%edx
sub    $0x1,%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x3d6a(%rip),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
imul   $0x6,0x3d56(%rip),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x3cc7(%rip),%eax
mov    %eax,0x3cbd(%rip)
mov    0x10(%rbp),%rax
movslq 0x3cb2(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3d1d(%rip)
mov    -0x38(%rbp),%rcx
movslq 0x3d12(%rip),%rdx
xor    %eax,%eax
sub    (%rcx,%rdx,4),%eax
mov    %eax,0x3c97(%rip)
mov    0x3c91(%rip),%eax
cmp    0x3c8f(%rip),%eax
je     1408 <crlist_+0x2c8>
jmp    12fa <crlist_+0x1ba>
mov    0x3cf6(%rip),%ecx
add    $0x2,%ecx
mov    0x38(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
cmp    0x3ce1(%rip),%eax
jge    142e <crlist_+0x2ee>
jmp    23e2 <crlist_+0x12a2>
mov    0x28(%rbp),%rax
imul   $0x6,0x3ccb(%rip),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
cmpl   $0x1,0x3cb7(%rip)
jne    1458 <crlist_+0x318>
jmp    1a10 <crlist_+0x8d0>
jmp    145d <crlist_+0x31d>
movl   $0x0,0x3cc5(%rip)
mov    0x3c97(%rip),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x3c8f(%rip)
mov    0x3c89(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     19f9 <crlist_+0x8b9>
movl   $0x1,0x3be2(%rip)
cmpl   $0x3,0x3bdb(%rip)
jg     19e0 <crlist_+0x8a0>
mov    0x28(%rbp),%rax
mov    0x3bcb(%rip),%ecx
add    $0x3,%ecx
imul   $0x6,0x3c55(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3c4b(%rip)
mov    0x3c45(%rip),%eax
cmp    0x3c3b(%rip),%eax
jg     14dc <crlist_+0x39c>
jmp    19c7 <crlist_+0x887>
cmpl   $0x1,0x3b95(%rip)
jne    1502 <crlist_+0x3c2>
movl   $0x2,0x3b7d(%rip)
movl   $0x3,0x3b77(%rip)
jmp    1541 <crlist_+0x401>
cmpl   $0x2,0x3b6f(%rip)
jne    1528 <crlist_+0x3e8>
movl   $0x3,0x3b57(%rip)
movl   $0x1,0x3b51(%rip)
jmp    153c <crlist_+0x3fc>
movl   $0x1,0x3b3e(%rip)
movl   $0x2,0x3b38(%rip)
jmp    1541 <crlist_+0x401>
mov    0x28(%rbp),%rax
mov    0x3b25(%rip),%ecx
imul   $0x6,0x3bba(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3b24(%rip)
mov    0x28(%rbp),%rax
mov    0x3b0a(%rip),%ecx
imul   $0x6,0x3b9b(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3b09(%rip)
mov    0x28(%rbp),%rax
mov    0x3aef(%rip),%ecx
imul   $0x6,0x3b7c(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3aee(%rip)
mov    0x28(%rbp),%rax
imul   $0x6,0x3b67(%rip),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x3b54(%rip),%eax
jne    15cd <crlist_+0x48d>
movl   $0x1,0x3ab4(%rip)
jmp    160b <crlist_+0x4cb>
mov    0x28(%rbp),%rax
imul   $0x6,0x3b38(%rip),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x3b25(%rip),%eax
jne    15fc <crlist_+0x4bc>
movl   $0x2,0x3a85(%rip)
jmp    1606 <crlist_+0x4c6>
movl   $0x3,0x3a76(%rip)
jmp    160b <crlist_+0x4cb>
mov    0x28(%rbp),%rax
mov    0x3a67(%rip),%ecx
imul   $0x6,0x3af4(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3a66(%rip)
mov    -0x20(%rbp),%r8
add    $0x8,%r8
mov    -0x28(%rbp),%r9
add    $0x8,%r9
mov    -0x30(%rbp),%rax
add    $0x8,%rax
lea    0x3a3b(%rip),%rdi
lea    0x3a38(%rip),%rsi
lea    0x3a35(%rip),%rdx
lea    0x3a32(%rip),%rcx
mov    %rax,(%rsp)
call   1030 <swptst_@plt>
cmp    $0x0,%eax
jne    1675 <crlist_+0x535>
jmp    19c7 <crlist_+0x887>
movl   $0x1,0x3aad(%rip)
mov    0x28(%rbp),%rax
mov    0x39e7(%rip),%ecx
add    $0x3,%ecx
imul   $0x6,0x3a79(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3a73(%rip)
mov    0x28(%rbp),%rax
mov    0x39c9(%rip),%ecx
add    $0x3,%ecx
imul   $0x6,0x3a57(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3a55(%rip)
cmpl   $0x1,0x39b2(%rip)
jne    16e9 <crlist_+0x5a9>
movl   $0x2,0x399a(%rip)
movl   $0x3,0x398c(%rip)
jmp    1728 <crlist_+0x5e8>
cmpl   $0x2,0x398c(%rip)
jne    170f <crlist_+0x5cf>
movl   $0x3,0x3974(%rip)
movl   $0x1,0x3966(%rip)
jmp    1723 <crlist_+0x5e3>
movl   $0x1,0x395b(%rip)
movl   $0x2,0x394d(%rip)
jmp    1728 <crlist_+0x5e8>
mov    0x28(%rbp),%rax
mov    0x393e(%rip),%ecx
add    $0x3,%ecx
imul   $0x6,0x39d4(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x39d2(%rip)
mov    0x28(%rbp),%rax
mov    0x3920(%rip),%ecx
add    $0x3,%ecx
imul   $0x6,0x39b2(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x39b4(%rip)
mov    0x391e(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x398f(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3900(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x3975(%rip),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x38de(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x395b(%rip),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3958(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x3941(%rip),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3946(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x3927(%rip),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x391c(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x390d(%rip),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x387e(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x38f7(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3868(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x38dd(%rip),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x3846(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x38c3(%rip),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x38c0(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x38a9(%rip),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x389e(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x388f(%rip),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x387c(%rip),%edx
mov    0x28(%rbp),%rax
imul   $0x6,0x3875(%rip),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,0x3869(%rip)
je     1933 <crlist_+0x7f3>
movl   $0x4,0x37c1(%rip)
mov    0x28(%rbp),%rax
imul   $0x6,0x384e(%rip),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x3837(%rip),%eax
je     1914 <crlist_+0x7d4>
movl   $0x5,0x3797(%rip)
mov    0x28(%rbp),%rax
imul   $0x6,0x3824(%rip),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x380d(%rip),%eax
je     190f <crlist_+0x7cf>
movl   $0x6,0x376d(%rip)
jmp    1914 <crlist_+0x7d4>
mov    0x37f6(%rip),%edx
mov    0x28(%rbp),%rax
mov    0x3758(%rip),%ecx
imul   $0x6,0x37e9(%rip),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,0x37e6(%rip)
je     19c2 <crlist_+0x882>
movl   $0x4,0x3732(%rip)
mov    0x28(%rbp),%rax
imul   $0x6,0x37cb(%rip),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x37ac(%rip),%eax
je     19a3 <crlist_+0x863>
movl   $0x5,0x3708(%rip)
mov    0x28(%rbp),%rax
imul   $0x6,0x37a1(%rip),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x3782(%rip),%eax
je     199e <crlist_+0x85e>
movl   $0x6,0x36de(%rip)
jmp    19a3 <crlist_+0x863>
mov    0x3763(%rip),%edx
mov    0x28(%rbp),%rax
mov    0x36c9(%rip),%ecx
imul   $0x6,0x3766(%rip),%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    19c7 <crlist_+0x887>
jmp    19cc <crlist_+0x88c>
mov    0x36a6(%rip),%eax
add    $0x1,%eax
mov    %eax,0x369d(%rip)
jmp    1496 <crlist_+0x356>
jmp    19e5 <crlist_+0x8a5>
mov    0x3721(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3718(%rip)
jmp    147d <crlist_+0x33d>
cmpl   $0x0,0x372c(%rip)
je     1a0b <crlist_+0x8cb>
jmp    145d <crlist_+0x31d>
jmp    1a10 <crlist_+0x8d0>
mov    0x36ee(%rip),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x36d9(%rip)
mov    0x36d3(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     1ca3 <crlist_+0xb63>
mov    0x28(%rbp),%rax
imul   $0x6,0x36bf(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3638(%rip)
mov    0x28(%rbp),%rax
imul   $0x6,0x36a5(%rip),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3622(%rip)
mov    0x28(%rbp),%rax
imul   $0x6,0x368b(%rip),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x360c(%rip)
mov    -0x20(%rbp),%rax
movslq 0x35f9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3608(%rip)
mov    -0x28(%rbp),%rax
movslq 0x35e1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x35f8(%rip)
mov    -0x30(%rbp),%rax
movslq 0x35c9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x35e8(%rip)
mov    -0x20(%rbp),%rax
movslq 0x35b5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x35e0(%rip)
mov    -0x28(%rbp),%rax
movslq 0x359d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x35d0(%rip)
mov    -0x30(%rbp),%rax
movslq 0x3585(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x35c0(%rip)
mov    -0x20(%rbp),%rax
movslq 0x3571(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x35b8(%rip)
mov    -0x28(%rbp),%rax
movslq 0x3559(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x35a8(%rip)
mov    -0x30(%rbp),%rax
movslq 0x3541(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3598(%rip)
lea    0x3541(%rip),%rdi
lea    0x355a(%rip),%rsi
lea    0x3573(%rip),%rdx
lea    0x34dc(%rip),%rcx
lea    0x35b5(%rip),%r8
call   1060 <circum_@plt>
cmpl   $0x0,0x35a9(%rip)
je     1b92 <crlist_+0xa52>
jmp    23f8 <crlist_+0x12b8>
movsd  0x34b6(%rip),%xmm0
mov    0x40(%rbp),%rax
movslq 0x3557(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x34a6(%rip),%xmm0
mov    0x48(%rbp),%rax
movslq 0x353f(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3496(%rip),%xmm0
mov    0x50(%rbp),%rax
movslq 0x3527(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x34be(%rip),%xmm1
movsd  0x3466(%rip),%xmm2
movsd  0x34b6(%rip),%xmm0
mulsd  0x345e(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x34a6(%rip),%xmm0
movsd  0x344e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3446(%rip)
movsd  0x13d6(%rip),%xmm0
ucomisd 0x3436(%rip),%xmm0
jbe    1c48 <crlist_+0xb08>
movsd  0x13c0(%rip),%xmm0
movsd  %xmm0,0x3420(%rip)
movsd  0x3418(%rip),%xmm0
movsd  0x13b0(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1c72 <crlist_+0xb32>
movsd  0x139e(%rip),%xmm0
movsd  %xmm0,0x33f6(%rip)
movsd  0x33ee(%rip),%xmm0
call   1050 <acos@plt>
mov    0x58(%rbp),%rax
movslq 0x3472(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3467(%rip),%eax
add    $0x1,%eax
mov    %eax,0x345e(%rip)
jmp    1a23 <crlist_+0x8e3>
jmp    1ca8 <crlist_+0xb68>
mov    0x3456(%rip),%eax
mov    %eax,0x3448(%rip)
mov    0x3446(%rip),%eax
sub    $0x2,%eax
mov    %eax,0x3445(%rip)
mov    0x343f(%rip),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x33ae(%rip)
mov    0x33a8(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     20b4 <crlist_+0xf74>
mov    0x10(%rbp),%rax
movslq 0x3394(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x342b(%rip)
mov    0x3425(%rip),%eax
mov    %eax,0x33f3(%rip)
mov    -0x38(%rbp),%rax
movslq 0x33e8(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3373(%rip)
mov    0x18(%rbp),%rax
movslq 0x33d4(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x33cb(%rip)
mov    0x3359(%rip),%eax
mov    %eax,0x334f(%rip)
mov    -0x38(%rbp),%rax
movslq 0x33b4(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
jl     1d5f <crlist_+0xc1f>
mov    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1d67 <crlist_+0xc27>
xor    %eax,%eax
sub    -0x40(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,0x331c(%rip)
mov    0x3312(%rip),%eax
cmp    0x3308(%rip),%eax
jle    1d94 <crlist_+0xc54>
mov    0x3304(%rip),%eax
cmp    0x32f6(%rip),%eax
jg     1d99 <crlist_+0xc59>
jmp    2084 <crlist_+0xf44>
mov    0x335d(%rip),%eax
add    $0x1,%eax
mov    %eax,0x3354(%rip)
mov    -0x20(%rbp),%rax
movslq 0x32d1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x32e0(%rip)
mov    -0x28(%rbp),%rax
movslq 0x32b9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x32d0(%rip)
mov    -0x30(%rbp),%rax
movslq 0x32a1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x32c0(%rip)
mov    -0x20(%rbp),%rax
movslq 0x328d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x32b8(%rip)
mov    -0x28(%rbp),%rax
movslq 0x3275(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x32a8(%rip)
mov    -0x30(%rbp),%rax
movslq 0x325d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3298(%rip)
mov    -0x20(%rbp),%rax
movslq 0x3249(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3290(%rip)
mov    -0x28(%rbp),%rax
movslq 0x3231(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3280(%rip)
mov    -0x30(%rbp),%rax
movslq 0x3219(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3270(%rip)
lea    0x3219(%rip),%rdi
lea    0x3232(%rip),%rsi
lea    0x324b(%rip),%rdx
lea    0x31b4(%rip),%rcx
lea    0x328d(%rip),%r8
call   1060 <circum_@plt>
cmpl   $0x0,0x3281(%rip)
je     1eba <crlist_+0xd7a>
jmp    23f8 <crlist_+0x12b8>
movsd  0x318e(%rip),%xmm0
mov    0x40(%rbp),%rax
movslq 0x322f(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x317e(%rip),%xmm0
mov    0x48(%rbp),%rax
movslq 0x3217(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x316e(%rip),%xmm0
mov    0x50(%rbp),%rax
movslq 0x31ff(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3196(%rip),%xmm1
movsd  0x313e(%rip),%xmm2
movsd  0x318e(%rip),%xmm0
mulsd  0x3136(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x317e(%rip),%xmm0
movsd  0x3126(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x311e(%rip)
movsd  0x10ae(%rip),%xmm0
ucomisd 0x310e(%rip),%xmm0
jbe    1f70 <crlist_+0xe30>
movsd  0x1098(%rip),%xmm0
movsd  %xmm0,0x30f8(%rip)
movsd  0x30f0(%rip),%xmm0
movsd  0x1088(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1f9a <crlist_+0xe5a>
movsd  0x1076(%rip),%xmm0
movsd  %xmm0,0x30ce(%rip)
movsd  0x30c6(%rip),%xmm0
call   1050 <acos@plt>
mov    0x58(%rbp),%rax
movslq 0x314a(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rdx
add    $0x4,%rdx
mov    0x18(%rbp),%rcx
add    $0x4,%rcx
lea    0x3156(%rip),%rdi
lea    0x30b3(%rip),%rsi
call   1040 <lstptr_@plt>
mov    %eax,0x3148(%rip)
mov    0x3116(%rip),%edx
mov    0x30(%rbp),%rax
movslq 0x3137(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rdi
movslq 0x3089(%rip),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rdx
add    $0x4,%rdx
mov    0x18(%rbp),%rcx
add    $0x4,%rcx
lea    0x306f(%rip),%rsi
call   1040 <lstptr_@plt>
mov    %eax,0x3100(%rip)
mov    0x30ce(%rip),%edx
mov    0x30(%rbp),%rax
movslq 0x30ef(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rdi
movslq 0x3045(%rip),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%rdx
add    $0x4,%rdx
mov    0x18(%rbp),%rcx
add    $0x4,%rcx
lea    0x301f(%rip),%rsi
call   1040 <lstptr_@plt>
mov    %eax,0x30b8(%rip)
mov    0x3086(%rip),%edx
mov    0x30(%rbp),%rax
movslq 0x30a7(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x306e(%rip),%eax
cmp    0x3094(%rip),%eax
je     209b <crlist_+0xf5b>
jmp    1d19 <crlist_+0xbd9>
jmp    20a0 <crlist_+0xf60>
mov    0x2fde(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2fd5(%rip)
jmp    1cd6 <crlist_+0xb96>
cmpl   $0x0,0x3049(%rip)
jne    20c6 <crlist_+0xf86>
jmp    23b6 <crlist_+0x1276>
movl   $0x0,0x303c(%rip)
mov    0x3036(%rip),%eax
add    $0x1,%eax
mov    %eax,0x302d(%rip)
mov    0x28(%rbp),%rax
imul   $0x6,0x3022(%rip),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    211d <crlist_+0xfdd>
movl   $0x2,0x2f6c(%rip)
movl   $0x3,0x2f66(%rip)
movl   $0x1,0x2f60(%rip)
jmp    21a8 <crlist_+0x1068>
mov    0x28(%rbp),%rax
imul   $0x6,0x2fe4(%rip),%ecx
add    $0x5,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    215b <crlist_+0x101b>
movl   $0x3,0x2f2e(%rip)
movl   $0x1,0x2f28(%rip)
movl   $0x2,0x2f22(%rip)
jmp    21a8 <crlist_+0x1068>
mov    0x28(%rbp),%rax
imul   $0x6,0x2fa6(%rip),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    2199 <crlist_+0x1059>
movl   $0x1,0x2ef0(%rip)
movl   $0x2,0x2eea(%rip)
movl   $0x3,0x2ee4(%rip)
jmp    21a8 <crlist_+0x1068>
jmp    219e <crlist_+0x105e>
jmp    21a3 <crlist_+0x1063>
jmp    20d0 <crlist_+0xf90>
mov    0x28(%rbp),%rax
mov    0x2ebe(%rip),%ecx
imul   $0x6,0x2f53(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2ebd(%rip)
mov    0x2eb7(%rip),%eax
mov    %eax,0x2ead(%rip)
mov    0x10(%rbp),%rax
movslq 0x2ea6(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2f11(%rip)
mov    0x18(%rbp),%rax
movslq 0x2f06(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2f2d(%rip)
mov    0x2f0b(%rip),%edx
mov    0x30(%rbp),%rax
movslq 0x2eec(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    0x2e5b(%rip),%ecx
add    $0x3,%ecx
imul   $0x6,0x2ee9(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2edf(%rip)
cmpl   $0x0,0x2ed8(%rip)
je     2337 <crlist_+0x11f7>
mov    0x20(%rbp),%rax
mov    (%rax),%edx
mov    0x18(%rbp),%rax
movslq 0x2ea9(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x2e9a(%rip)
mov    0x2eac(%rip),%edx
mov    0x30(%rbp),%rax
movslq 0x2e89(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    0x2e8d(%rip),%eax
mov    %eax,0x2e83(%rip)
mov    0x28(%rbp),%rax
imul   $0x6,0x2e78(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x2de1(%rip),%eax
jne    22cc <crlist_+0x118c>
movl   $0x1,0x2dbd(%rip)
movl   $0x2,0x2db7(%rip)
movl   $0x3,0x2db1(%rip)
jmp    2332 <crlist_+0x11f2>
mov    0x28(%rbp),%rax
imul   $0x6,0x2e35(%rip),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    0x2d9e(%rip),%eax
jne    230f <crlist_+0x11cf>
movl   $0x2,0x2d7a(%rip)
movl   $0x3,0x2d74(%rip)
movl   $0x1,0x2d6e(%rip)
jmp    232d <crlist_+0x11ed>
movl   $0x3,0x2d57(%rip)
movl   $0x1,0x2d51(%rip)
movl   $0x2,0x2d4b(%rip)
jmp    2332 <crlist_+0x11f2>
jmp    220f <crlist_+0x10cf>
mov    0x2deb(%rip),%edx
mov    0x18(%rbp),%rax
movslq 0x2db0(%rip),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x28(%rbp),%rax
mov    0x2d23(%rip),%ecx
imul   $0x6,0x2db0(%rip),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2d1a(%rip)
mov    0x2d14(%rip),%eax
cmp    0x2d0a(%rip),%eax
je     23b1 <crlist_+0x1271>
mov    0x2cf6(%rip),%eax
mov    %eax,0x2cf4(%rip)
mov    0x2ce6(%rip),%eax
mov    %eax,0x2ce4(%rip)
mov    0x2cd6(%rip),%eax
mov    %eax,0x2cd4(%rip)
mov    0x2cd6(%rip),%eax
mov    %eax,0x2cc4(%rip)
jmp    21d3 <crlist_+0x1093>
jmp    23b6 <crlist_+0x1276>
mov    0x60(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    2409 <crlist_+0x12c9>
mov    0x60(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    2409 <crlist_+0x12c9>
mov    0x60(%rbp),%rax
movl   $0x2,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    2409 <crlist_+0x12c9>
mov    0x60(%rbp),%rax
movl   $0x3,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<crlist_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r8,0x8(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdx,0x28(%rsp)
mov    0xc0(%rsp),%r11
mov    0x98(%rsp),%r15
mov    (%rdi),%ecx
mov    %ecx,0x2f7b(%rip)
movl   $0x0,(%r15)
movl   $0x0,0x2f6e(%rip)
mov    $0x1,%edi
cmp    $0x3,%ecx
jl     1d86 <crlist_+0xc46>
mov    0x88(%rsp),%rax
mov    0x70(%rsp),%rbp
lea    -0x4(%rbp),%r14
lea    -0x1c(%rax),%r13
movl   $0x1,0x2ec5(%rip)
movslq 0x0(%rbp),%rdx
mov    -0x4(%r9,%rdx,4),%edi
test   %edi,%edi
js     11f6 <crlist_+0xb6>
add    $0x1,%rcx
mov    $0x2,%ebx
mov    $0x1,%eax
xchg   %ax,%ax
mov    %ebx,0x2ea2(%rip)
cmp    %rbx,%rcx
je     186d <crlist_+0x72d>
movslq -0x4(%rbp,%rbx,4),%rdx
mov    -0x4(%r9,%rdx,4),%edi
add    $0x1,%rbx
add    $0x1,%eax
test   %edi,%edi
jns    11d0 <crlist_+0x90>
jmp    11fb <crlist_+0xbb>
mov    $0x1,%eax
movabs $0x600000000,%r8
movslq %edx,%rcx
neg    %edi
mov    %edi,0x2e6c(%rip)
mov    0x78(%rsp),%rdx
movslq -0x4(%rdx,%rcx,4),%rcx
mov    -0x4(%r9,%rcx,4),%r10d
mov    %r10d,0x2e5a(%rip)
mov    0x88(%rsp),%rcx
add    $0x14,%rcx
movabs $0x400000000,%rdx
xor    %r12d,%r12d
mov    %r8,%rbp
jmp    127f <crlist_+0x13f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %edi,%eax
mov    %edi,0x2e20(%rip)
movslq %edi,%rdi
movslq (%r14,%rdi,4),%rbx
xor    %edi,%edi
sub    -0x4(%r9,%rbx,4),%edi
mov    %edi,0x2e10(%rip)
add    %r8,%rdx
add    %r8,%rbp
add    $0x18,%rcx
add    $0x1,%r12
cmp    %edi,%r10d
je     12ca <crlist_+0x18a>
movslq (%rsi),%rbx
cmp    %rbx,%r12
jge    1250 <crlist_+0x110>
mov    %rbp,%rdi
sar    $0x1e,%rdi
or     $0x4,%rdi
mov    %eax,0x0(%r13,%rdi,1)
mov    0x2ddf(%rip),%eax
mov    %eax,-0x10(%rcx)
mov    0x2dda(%rip),%eax
mov    %eax,-0xc(%rcx)
lea    0x2(%r12),%eax
mov    %eax,-0x8(%rcx)
mov    %r12d,-0x4(%rcx)
movl   $0x0,(%rcx)
mov    0x2dbb(%rip),%edi
mov    0x2db8(%rip),%r10d
jmp    1250 <crlist_+0x110>
lea    -0x1(%r12),%eax
mov    %r12d,0x2e1e(%rip)
mov    %ebx,0x2e0c(%rip)
lea    0x2(%r12),%ecx
mov    %ecx,(%r15)
mov    $0x2,%edi
cmp    %eax,(%rsi)
jle    1d86 <crlist_+0xc46>
sar    $0x1e,%rdx
movl   $0x0,0x0(%r13,%rdx,1)
cmp    $0x1,%r12d
mov    %r14,0x10(%rsp)
mov    %r9,0x18(%rsp)
je     1685 <crlist_+0x545>
movb   $0x0,0x2deb(%rip)
movl   $0x1,0x2dd5(%rip)
mov    %r12,0x20(%rsp)
cmp    $0x2,%r12d
jl     167e <crlist_+0x53e>
lea    0x2d43(%rip),%r15
lea    0x2d40(%rip),%r12
mov    $0x1,%ecx
jmp    1363 <crlist_+0x223>
nopw   0x0(%rax,%rax,1)
add    $0x1,%ecx
mov    %ecx,0x2d9f(%rip)
cmp    0x20(%rsp),%ecx
jge    1650 <crlist_+0x510>
movl   $0x1,0x2d03(%rip)
mov    $0x1,%edi
jmp    13b4 <crlist_+0x274>
movslq %edx,%rdx
xor    %esi,%esi
cmp    %eax,0x14(%r13,%rdx,4)
sete   %sil
mov    $0x6,%eax
sub    %esi,%eax
mov    %eax,0x2ce5(%rip)
add    %eax,%edx
movslq %edx,%rax
mov    %ecx,0x0(%r13,%rax,4)
nopl   0x0(%rax)
mov    0x2cca(%rip),%eax
lea    0x1(%rax),%edi
mov    %edi,0x2cc1(%rip)
cmp    $0x3,%eax
jge    1350 <crlist_+0x210>
lea    (%rcx,%rcx,1),%eax
lea    (%rax,%rax,2),%edx
lea    (%rdi,%rdx,1),%eax
add    $0x3,%eax
cltq
movslq 0x0(%r13,%rax,4),%rax
mov    %eax,0x2d2f(%rip)
cmp    %ecx,%eax
jle    13a0 <crlist_+0x260>
lea    (%rdx,%rdi,1),%esi
cmp    $0x1,%edi
je     13ea <crlist_+0x2aa>
cmp    $0x2,%edi
jne    13f6 <crlist_+0x2b6>
mov    $0x1,%edi
mov    $0x3,%ebp
jmp    1400 <crlist_+0x2c0>
mov    $0x3,%edi
mov    $0x2,%ebp
jmp    1400 <crlist_+0x2c0>
mov    $0x2,%edi
mov    $0x1,%ebp
mov    %ebp,0x2c62(%rip)
mov    %edi,0x2c60(%rip)
add    %edx,%ebp
movslq %ebp,%rbp
mov    0x0(%r13,%rbp,4),%ebp
mov    %ebp,0x2c5c(%rip)
add    %edx,%edi
movslq %edi,%rdx
mov    0x0(%r13,%rdx,4),%edx
mov    %edx,0x2c50(%rip)
movslq %esi,%rdx
mov    0x0(%r13,%rdx,4),%edx
mov    %edx,0x2c46(%rip)
add    %rax,%rax
lea    (%rax,%rax,2),%rax
mov    $0x1,%edx
cmp    %ecx,0x10(%r13,%rax,4)
je     145d <crlist_+0x31d>
movslq %eax,%rsi
xor    %edx,%edx
cmp    %ecx,0x14(%r13,%rsi,4)
sete   %dl
xor    $0x3,%edx
mov    %edx,0x2c11(%rip)
add    %edx,%eax
cltq
mov    0x0(%r13,%rax,4),%eax
mov    %eax,0x2c12(%rip)
mov    0x8(%rsp),%rax
mov    %rax,(%rsp)
lea    0x2bf6(%rip),%rdi
mov    %r15,%rsi
mov    %r12,%rdx
lea    0x2bf5(%rip),%rcx
mov    0x28(%rsp),%r8
mov    0x30(%rsp),%r9
call   1030 <swptst_@plt>
mov    0x2c54(%rip),%ecx
test   %eax,%eax
je     13a0 <crlist_+0x260>
movslq %ecx,%rax
movb   $0x1,0x2c4e(%rip)
add    %rax,%rax
lea    (%rax,%rax,2),%r14
lea    0x3(%r14),%edi
mov    0x2ba1(%rip),%eax
add    %edi,%eax
cltq
mov    0x0(%r13,%rax,4),%r9d
mov    0x2b96(%rip),%eax
add    %edi,%eax
cltq
mov    0x0(%r13,%rax,4),%r8d
mov    0x2b8f(%rip),%eax
cmp    $0x1,%eax
je     14fb <crlist_+0x3bb>
cmp    $0x2,%eax
jne    1507 <crlist_+0x3c7>
mov    $0x1,%ebp
mov    $0x3,%esi
jmp    1511 <crlist_+0x3d1>
mov    $0x3,%ebp
mov    $0x2,%esi
jmp    1511 <crlist_+0x3d1>
mov    $0x2,%ebp
mov    $0x1,%esi
mov    %esi,0x2b55(%rip)
mov    %ebp,0x2b4b(%rip)
movslq 0x2bd8(%rip),%rax
mov    %rax,%rdx
add    %rax,%rdx
lea    (%rdx,%rdx,2),%rdx
lea    0x3(%rdx),%r10d
add    %edx,%ebp
add    $0x3,%ebp
movslq %ebp,%rbp
mov    0x0(%r13,%rbp,4),%r11d
lea    0x3(%rdx,%rsi,1),%esi
movslq %esi,%rsi
movslq 0x0(%r13,%rsi,4),%rsi
mov    0x2b33(%rip),%ebp
mov    %r14,%rbx
shl    $0x2,%rbx
or     $0x4,%rbx
mov    %ebp,0x0(%r13,%rbx,1)
mov    0x2b19(%rip),%ebx
movslq %r14d,%rbp
mov    %ebx,0x8(%r13,%rbp,4)
mov    0x2b03(%rip),%ebx
movslq %edi,%rdi
mov    %ebx,0x0(%r13,%rdi,4)
mov    %r8d,0x10(%r13,%rbp,4)
mov    %esi,0x14(%r13,%rbp,4)
mov    %eax,0x18(%r13,%rbp,4)
mov    0x2aee(%rip),%edi
mov    %edi,0x4(%r13,%rdx,4)
mov    0x2ae7(%rip),%edi
movslq %edx,%rdx
mov    %edi,0x8(%r13,%rdx,4)
mov    0x2ad1(%rip),%edi
movslq %r10d,%rbp
mov    %edi,0x0(%r13,%rbp,4)
mov    %r11d,0x10(%r13,%rdx,4)
mov    %r9d,0x14(%r13,%rdx,4)
mov    %ecx,0x18(%r13,%rdx,4)
test   %r9d,%r9d
je     1611 <crlist_+0x4d1>
movslq %r9d,%rdx
movl   $0x4,0x2aa0(%rip)
add    %rdx,%rdx
lea    (%rdx,%rdx,2),%rdi
cmp    %ecx,0x10(%r13,%rdi,4)
jne    15ec <crlist_+0x4ac>
lea    (%rdx,%rdx,2),%rdx
add    $0x4,%rdx
jmp    160c <crlist_+0x4cc>
movslq %edi,%rdx
xor    %edi,%edi
cmp    %ecx,0x14(%r13,%rdx,4)
sete   %dil
mov    $0x6,%ebp
sub    %edi,%ebp
mov    %ebp,0x2a6d(%rip)
add    %ebp,%edx
movslq %edx,%rdx
mov    %eax,0x0(%r13,%rdx,4)
test   %esi,%esi
je     13a0 <crlist_+0x260>
movl   $0x4,0x2a51(%rip)
add    %rsi,%rsi
lea    (%rsi,%rsi,2),%rdx
cmp    %eax,0x10(%r13,%rdx,4)
jne    1374 <crlist_+0x234>
lea    (%rsi,%rsi,2),%rax
add    $0x4,%rax
jmp    1394 <crlist_+0x254>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpb   $0x1,0x2aad(%rip)
jne    167e <crlist_+0x53e>
mov    0x2a95(%rip),%eax
movb   $0x0,0x2a9e(%rip)
movl   $0x1,0x2a88(%rip)
mov    %rax,0x20(%rsp)
cmp    $0x1,%eax
jg     1340 <crlist_+0x200>
mov    0x2a6f(%rip),%r12d
mov    0x88(%rsp),%rdx
movl   $0x1,0x2a55(%rip)
test   %r12d,%r12d
jle    1888 <crlist_+0x748>
mov    $0x1,%eax
lea    0x2a24(%rip),%r15
lea    0x299d(%rip),%rbp
lea    0x2a4e(%rip),%r14
mov    0x28(%rsp),%rbx
nop
add    %eax,%eax
lea    (%rax,%rax,2),%eax
movslq %eax,%rcx
or     $0x1,%eax
cltq
movslq 0x0(%r13,%rax,4),%rax
mov    %eax,0x29a0(%rip)
movslq 0x8(%r13,%rcx,4),%rdx
mov    %edx,0x2999(%rip)
movslq 0xc(%r13,%rcx,4),%rcx
mov    %ecx,0x2992(%rip)
movsd  -0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x2994(%rip)
mov    0x30(%rsp),%rdi
movsd  -0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x2989(%rip)
mov    0x8(%rsp),%rsi
movsd  -0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x297e(%rip)
movsd  -0x8(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x2980(%rip)
movsd  -0x8(%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x297a(%rip)
movsd  -0x8(%rsi,%rdx,8),%xmm0
movsd  %xmm0,0x2974(%rip)
movsd  -0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x2976(%rip)
movsd  -0x8(%rdi,%rcx,8),%xmm0
movsd  %xmm0,0x2970(%rip)
movsd  -0x8(%rsi,%rcx,8),%xmm0
movsd  %xmm0,0x296a(%rip)
lea    0x2913(%rip),%rdi
lea    0x292c(%rip),%rsi
mov    %r15,%rdx
mov    %rbp,%rcx
mov    %r14,%r8
call   1060 <circum_@plt>
cmpl   $0x0,0x296f(%rip)
jne    1bd4 <crlist_+0xa94>
movsd  0x28a9(%rip),%xmm0
movslq 0x293e(%rip),%rax
mov    0xa0(%rsp),%rcx
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  0x2894(%rip),%xmm0
mov    0xa8(%rsp),%rcx
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  0x2886(%rip),%xmm0
mov    0xb0(%rsp),%rcx
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  0x28a0(%rip),%xmm0
movsd  0x28a0(%rip),%xmm1
mulsd  0x2858(%rip),%xmm1
mulsd  0x2848(%rip),%xmm0
movsd  0x2890(%rip),%xmm2
mulsd  0x2848(%rip),%xmm2
addsd  %xmm1,%xmm0
addsd  %xmm0,%xmm2
movsd  0x7d8(%rip),%xmm1
maxsd  %xmm2,%xmm1
movsd  0x7d4(%rip),%xmm0
minsd  %xmm1,%xmm0
call   1050 <acos@plt>
movslq 0x28a8(%rip),%rcx
mov    0xb8(%rsp),%rax
movsd  %xmm0,-0x8(%rax,%rcx,8)
lea    0x1(%rcx),%eax
mov    %eax,0x2891(%rip)
cmp    %r12d,%ecx
jl     16c0 <crlist_+0x580>
mov    0x2889(%rip),%r12d
jmp    1880 <crlist_+0x740>
mov    %r9,0x18(%rsp)
mov    %r14,0x10(%rsp)
mov    %edx,0x286b(%rip)
xor    %r12d,%r12d
mov    0x88(%rsp),%rdx
mov    0x90(%rsp),%r15
mov    %r12d,0x2855(%rip)
mov    0x2853(%rip),%esi
movl   $0x1,0x27d1(%rip)
cmp    $0x3,%esi
jge    1916 <crlist_+0x7d6>
xor    %edi,%edi
test   %r12d,%r12d
je     1bd9 <crlist_+0xa99>
mov    0x80(%rsp),%r12
mov    $0x1,%r14d
mov    $0x5,%ecx
mov    $0x1,%esi
nop
mov    %esi,%r9d
mov    %rcx,%rax
mov    $0x2,%r11d
cmpl   $0x0,-0x8(%rdx,%rcx,4)
je     1be6 <crlist_+0xaa6>
cmpl   $0x0,-0x4(%rdx,%rax,4)
je     1bed <crlist_+0xaad>
lea    0x1(%r9),%esi
lea    0x6(%rax),%rcx
cmpl   $0x0,(%rdx,%rax,4)
jne    18d0 <crlist_+0x790>
mov    $0x3,%r14d
mov    $0x2,%esi
mov    $0x1,%r11d
jmp    1bfe <crlist_+0xabe>
add    $0xfffffffe,%esi
mov    $0x1,%eax
lea    0x27e3(%rip),%r14
mov    %esi,0x20(%rsp)
mov    0x10(%rsp),%rbp
jmp    1947 <crlist_+0x807>
lea    0x1(%rax),%ecx
mov    %ecx,0x273f(%rip)
mov    0x20(%rsp),%esi
cmp    %esi,%eax
mov    %ecx,%eax
jge    1d9a <crlist_+0xc5a>
movslq %eax,%rcx
mov    0x10(%rsp),%rdx
movslq (%rdx,%rcx,4),%rcx
mov    %ecx,0x27a7(%rip)
mov    0x18(%rsp),%rdx
mov    -0x4(%rdx,%rcx,4),%ebx
mov    %ebx,0x2718(%rip)
mov    %ecx,%esi
jmp    1976 <crlist_+0x836>
nopl   0x0(%rax)
mov    %edi,%ebx
cmp    %ecx,%esi
je     1930 <crlist_+0x7f0>
movslq %esi,%rdx
mov    0x78(%rsp),%rsi
movslq -0x4(%rsi,%rdx,4),%rsi
mov    %esi,0x275f(%rip)
mov    %ebx,0x26ed(%rip)
mov    0x18(%rsp),%rdx
mov    -0x4(%rdx,%rsi,4),%edx
mov    %edx,%edi
neg    %edi
cmovs  %edx,%edi
mov    %edi,0x26db(%rip)
cmp    %eax,%ebx
jle    1970 <crlist_+0x830>
cmp    %eax,%edi
jle    1970 <crlist_+0x830>
add    $0x1,%r12d
mov    %r12d,0x2734(%rip)
cltq
mov    0x28(%rsp),%rsi
movsd  -0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x26c3(%rip)
mov    0x30(%rsp),%rdx
movsd  -0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x26b8(%rip)
mov    0x8(%rsp),%rcx
movsd  -0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x26ad(%rip)
movslq %ebx,%rax
movsd  -0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x26ac(%rip)
movsd  -0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x26a6(%rip)
movsd  -0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x26a0(%rip)
mov    %edi,%eax
movsd  -0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x26a0(%rip)
movsd  -0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x269a(%rip)
movsd  -0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x2694(%rip)
lea    0x263d(%rip),%rdi
lea    0x2656(%rip),%rsi
lea    0x266f(%rip),%rdx
lea    0x25e8(%rip),%rcx
mov    %r14,%r8
call   1060 <circum_@plt>
cmpl   $0x0,0x2691(%rip)
jne    1bd4 <crlist_+0xa94>
movsd  0x25cb(%rip),%xmm0
movslq 0x2660(%rip),%rax
mov    0xa0(%rsp),%rcx
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  0x25b6(%rip),%xmm0
mov    0xa8(%rsp),%rcx
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  0x25a8(%rip),%xmm0
mov    0xb0(%rsp),%rcx
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  0x25c2(%rip),%xmm0
movsd  0x25c2(%rip),%xmm1
mulsd  0x257a(%rip),%xmm1
mulsd  0x256a(%rip),%xmm0
movsd  0x25b2(%rip),%xmm2
mulsd  0x256a(%rip),%xmm2
addsd  %xmm1,%xmm0
addsd  %xmm0,%xmm2
movsd  0x4fa(%rip),%xmm1
maxsd  %xmm2,%xmm1
movsd  0x4f6(%rip),%xmm0
minsd  %xmm1,%xmm0
call   1050 <acos@plt>
movslq 0x25ca(%rip),%rax
mov    0xb8(%rsp),%rcx
movsd  %xmm0,-0x8(%rcx,%rax,8)
lea    0x25c9(%rip),%rdi
lea    0x253e(%rip),%rsi
mov    0x18(%rsp),%r12
mov    %r12,%rdx
mov    0x78(%rsp),%rbx
mov    %rbx,%rcx
call   1040 <lstptr_@plt>
mov    0x2593(%rip),%ecx
cltq
mov    %ecx,-0x4(%r15,%rax,4)
movslq 0x2515(%rip),%rax
lea    0x0(%rbp,%rax,4),%rdi
lea    0x250d(%rip),%rsi
mov    %r12,%rdx
mov    %rbx,%rcx
call   1040 <lstptr_@plt>
mov    0x2568(%rip),%ecx
cltq
mov    %ecx,-0x4(%r15,%rax,4)
movslq 0x24ee(%rip),%rax
lea    0x0(%rbp,%rax,4),%rdi
lea    0x24da(%rip),%rsi
mov    %r12,%rdx
mov    %rbx,%rcx
call   1040 <lstptr_@plt>
mov    0x253c(%rip),%r12d
cltq
mov    %r12d,-0x4(%r15,%rax,4)
mov    0x24c3(%rip),%edi
mov    0x24b5(%rip),%eax
mov    0x251f(%rip),%esi
mov    0x2531(%rip),%ecx
jmp    1970 <crlist_+0x830>
mov    $0x3,%edi
mov    0xc0(%rsp),%r11
jmp    1d86 <crlist_+0xc46>
mov    $0x3,%esi
jmp    1bfe <crlist_+0xabe>
mov    $0x2,%r14d
mov    $0x1,%esi
mov    $0x3,%r11d
mov    %r9d,0x24f3(%rip)
mov    %r11d,0x245c(%rip)
mov    %esi,0x245a(%rip)
mov    %r14d,0x2457(%rip)
add    %r11d,%eax
add    $0x1,%eax
cltq
mov    0x0(%r13,%rax,4),%eax
mov    %eax,0x244c(%rip)
mov    %eax,0x8(%rsp)
cltq
mov    0x10(%rsp),%rcx
mov    (%rcx,%rax,4),%ebp
movslq %ebp,%rax
mov    0x78(%rsp),%rcx
mov    -0x4(%rcx,%rax,4),%r10d
mov    %r9d,-0x4(%r15,%rax,4)
lea    (%r9,%r9,1),%ecx
lea    (%rcx,%rcx,2),%edi
lea    (%rsi,%rdi,1),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    0x0(%r13,%rcx,4),%r8d
test   %r8d,%r8d
je     1d20 <crlist_+0xbe0>
mov    (%r12),%esi
jmp    1ca5 <crlist_+0xb65>
movslq %edi,%rbx
xor    %edx,%edx
cmp    %ecx,0x8(%r13,%rbx,4)
sete   %dl
lea    (%rdx,%rdx,1),%r14d
add    $0x1,%r14d
mov    $0x2,%ebx
sub    %edx,%ebx
mov    %edx,%ecx
xor    $0x3,%ecx
lea    (%r14,%rdi,1),%edx
add    $0x3,%edx
movslq %edx,%rdx
mov    0x0(%r13,%rdx,4),%r8d
test   %r8d,%r8d
je     1d00 <crlist_+0xbc0>
mov    %r8d,%r9d
movslq %ebp,%rax
mov    0x78(%rsp),%rcx
mov    %esi,-0x4(%rcx,%rax,4)
mov    (%r12),%ebp
movslq %ebp,%rax
mov    %r8d,-0x4(%r15,%rax,4)
mov    (%r12),%esi
add    $0x1,%esi
mov    %esi,(%r12)
lea    (%r9,%r9,1),%ecx
lea    (%rcx,%rcx,2),%edi
mov    %edi,%ecx
or     $0x1,%ecx
movslq %ecx,%rbx
mov    0x2398(%rip),%ecx
cmp    %ecx,0x0(%r13,%rbx,4)
jne    1c70 <crlist_+0xb30>
mov    $0x3,%ebx
mov    $0x2,%r14d
mov    $0x1,%ecx
jmp    1c91 <crlist_+0xb51>
nopl   0x0(%rax)
mov    %ecx,0x2362(%rip)
mov    %r14d,0x235f(%rip)
mov    %ebx,0x235d(%rip)
mov    %r9d,0x23de(%rip)
jmp    1d29 <crlist_+0xbe9>
nopl   0x0(%rax)
mov    %r14d,%ebx
mov    %r11d,%ecx
mov    %esi,%r14d
mov    0x78(%rsp),%rdx
mov    %r10d,-0x4(%rdx,%rax,4)
add    %ebx,%edi
movslq %edi,%rax
mov    0x0(%r13,%rax,4),%eax
mov    %eax,0x2335(%rip)
cmp    0x8(%rsp),%eax
je     1d6c <crlist_+0xc2c>
mov    %ebx,0x2325(%rip)
mov    %r14d,0x231a(%rip)
mov    %ecx,0x2310(%rip)
mov    %ebx,0x2306(%rip)
mov    %ebx,%r11d
mov    %ecx,%esi
jmp    1c30 <crlist_+0xaf0>
mov    %ebp,0x2376(%rip)
movl   $0x0,0x2380(%rip)
mov    0xc0(%rsp),%r11
xor    %edi,%edi
mov    %edi,(%r11)
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2353(%rip),%r12d
mov    0x88(%rsp),%rdx
jmp    18ac <crlist_+0x76c>

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

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