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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int jrand_(int *, int *, int *, int *);
int lstptr_(int *, int *, int *, int *);
int store_(double *);
int trfind_(int *nst, double *p, int *n, double *x, double *y, double *z__,
            int *list, int *lptr, int *lend, double *b1, double *b2, double *b3,
            int *i1, int *i2, int *i3) {
  static int ix = 1;
  static int iy = 2;
  static int iz = 3;
  int i__1;
  double d__1, d__2;
  static double q[3];
  static int n0, n1, n2, n3, n4, nf;
  static double s12;
  static int nl, lp;
  static double xp, yp, zp;
  static int n1s, n2s;
  static double eps, tol, ptn1, ptn2;
  static int next;
  --p;
  --lend;
  --z__;
  --y;
  --x;
  --list;
  --lptr;
  xp = p[1];
  yp = p[2];
  zp = p[3];
  n0 = *nst;
  if (n0 < 1 || n0 > *n) {
    n0 = jrand_(n, &ix, &iy, &iz);
  }
  eps = 1.;
L1:
  eps /= 2.;
  d__1 = eps + 1.;
  if (store_(&d__1) > 1.) {
    goto L1;
  }
  eps *= 2.;
  tol = eps * 100.;
L2:
  lp = lend[n0];
  nl = list[lp];
  lp = lptr[lp];
  nf = list[lp];
  n1 = nf;
  if (nl > 0) {
  L3:
    if (xp * (y[n0] * z__[n1] - y[n1] * z__[n0]) -
            yp * (x[n0] * z__[n1] - x[n1] * z__[n0]) +
            zp * (x[n0] * y[n1] - x[n1] * y[n0]) <
        0.) {
      lp = lptr[lp];
      n1 = list[lp];
      if (n1 == nl) {
        goto L6;
      }
      goto L3;
    }
  } else {
    nl = -nl;
    if (xp * (y[n0] * z__[nf] - y[nf] * z__[n0]) -
            yp * (x[n0] * z__[nf] - x[nf] * z__[n0]) +
            zp * (x[n0] * y[nf] - x[nf] * y[n0]) <
        0.) {
      n1 = n0;
      n2 = nf;
      goto L9;
    }
    if (xp * (y[nl] * z__[n0] - y[n0] * z__[nl]) -
            yp * (x[nl] * z__[n0] - x[n0] * z__[nl]) +
            zp * (x[nl] * y[n0] - x[n0] * y[nl]) <
        0.) {
      n1 = nl;
      n2 = n0;
      goto L9;
    }
  }
L4:
  lp = lptr[lp];
  n2 = (i__1 = list[lp], ((i__1) >= 0 ? (i__1) : -(i__1)));
  if (xp * (y[n0] * z__[n2] - y[n2] * z__[n0]) -
          yp * (x[n0] * z__[n2] - x[n2] * z__[n0]) +
          zp * (x[n0] * y[n2] - x[n2] * y[n0]) <
      0.) {
    goto L7;
  }
  n1 = n2;
  if (n1 != nl) {
    goto L4;
  }
  if (xp * (y[n0] * z__[nf] - y[nf] * z__[n0]) -
          yp * (x[n0] * z__[nf] - x[nf] * z__[n0]) +
          zp * (x[n0] * y[nf] - x[nf] * y[n0]) <
      0.) {
    goto L6;
  }
  d__2 = (d__1 = x[n0] * xp + y[n0] * yp + z__[n0] * zp,
          ((d__1) >= 0 ? (d__1) : -(d__1)));
  if (store_(&d__2) < 1. - eps * 4.) {
  L5:
    if (xp * (y[n1] * z__[n0] - y[n0] * z__[n1]) -
            yp * (x[n1] * z__[n0] - x[n0] * z__[n1]) +
            zp * (x[n1] * y[n0] - x[n0] * y[n1]) >=
        0.) {
      lp = lptr[lp];
      n1 = (i__1 = list[lp], ((i__1) >= 0 ? (i__1) : -(i__1)));
      if (n1 == nl) {
        goto L14;
      }
      goto L5;
    }
  }
  n0 = n1;
  goto L2;
L6:
  n2 = nf;
L7:
  n3 = n0;
  n1s = n1;
  n2s = n2;
L8:
  *b3 = xp * (y[n1] * z__[n2] - y[n2] * z__[n1]) -
        yp * (x[n1] * z__[n2] - x[n2] * z__[n1]) +
        zp * (x[n1] * y[n2] - x[n2] * y[n1]);
  if (*b3 < 0.) {
    lp = lstptr_(&lend[n2], &n1, &list[1], &lptr[1]);
    if (list[lp] < 0) {
      goto L9;
    }
    lp = lptr[lp];
    n4 = (i__1 = list[lp], ((i__1) >= 0 ? (i__1) : -(i__1)));
    if (xp * (y[n0] * z__[n4] - y[n4] * z__[n0]) -
            yp * (x[n0] * z__[n4] - x[n4] * z__[n0]) +
            zp * (x[n0] * y[n4] - x[n4] * y[n0]) <
        0.) {
      n3 = n2;
      n2 = n4;
      n1s = n1;
      if (n2 != n2s && n2 != n0) {
        goto L8;
      }
    } else {
      n3 = n1;
      n1 = n4;
      n2s = n2;
      if (n1 != n1s && n1 != n0) {
        goto L8;
      }
    }
    n0 = jrand_(n, &ix, &iy, &iz);
    goto L2;
  }
  if (*b3 >= eps) {
    *b1 = xp * (y[n2] * z__[n3] - y[n3] * z__[n2]) -
          yp * (x[n2] * z__[n3] - x[n3] * z__[n2]) +
          zp * (x[n2] * y[n3] - x[n3] * y[n2]);
    *b2 = xp * (y[n3] * z__[n1] - y[n1] * z__[n3]) -
          yp * (x[n3] * z__[n1] - x[n1] * z__[n3]) +
          zp * (x[n3] * y[n1] - x[n1] * y[n3]);
    if (*b1 < -tol || *b2 < -tol) {
      n0 = jrand_(n, &ix, &iy, &iz);
      goto L2;
    }
  } else {
    *b3 = 0.;
    s12 = x[n1] * x[n2] + y[n1] * y[n2] + z__[n1] * z__[n2];
    ptn1 = xp * x[n1] + yp * y[n1] + zp * z__[n1];
    ptn2 = xp * x[n2] + yp * y[n2] + zp * z__[n2];
    *b1 = ptn1 - s12 * ptn2;
    *b2 = ptn2 - s12 * ptn1;
    if (*b1 < -tol || *b2 < -tol) {
      n0 = jrand_(n, &ix, &iy, &iz);
      goto L2;
    }
  }
  *i1 = n1;
  *i2 = n2;
  *i3 = n3;
  if (*b1 < 0.) {
    *b1 = 0.;
  }
  if (*b2 < 0.) {
    *b2 = 0.;
  }
  return 0;
L9:
  n1s = n1;
  n2s = n2;
  nl = 0;
L10:
  lp = lend[n2];
  lp = lptr[lp];
  next = list[lp];
  if (xp * (y[n2] * z__[next] - y[next] * z__[n2]) -
          yp * (x[n2] * z__[next] - x[next] * z__[n2]) +
          zp * (x[n2] * y[next] - x[next] * y[n2]) >=
      0.) {
    s12 = x[n1] * x[n2] + y[n1] * y[n2] + z__[n1] * z__[n2];
    q[0] = x[n1] - s12 * x[n2];
    q[1] = y[n1] - s12 * y[n2];
    q[2] = z__[n1] - s12 * z__[n2];
    if (xp * q[0] + yp * q[1] + zp * q[2] >= 0.) {
      goto L11;
    }
    if (x[next] * q[0] + y[next] * q[1] + z__[next] * q[2] >= 0.) {
      goto L11;
    }
    nl = n2;
  }
  n1 = n2;
  n2 = next;
  if (n2 != n1s) {
    goto L10;
  }
  *i1 = n1s;
  *i2 = n1s;
  *i3 = 0;
  return 0;
L11:
  nf = n2;
  if (nl == 0) {
    n2 = n2s;
    n1 = n1s;
  L12:
    lp = lend[n1];
    next = -list[lp];
    if (xp * (y[next] * z__[n1] - y[n1] * z__[next]) -
            yp * (x[next] * z__[n1] - x[n1] * z__[next]) +
            zp * (x[next] * y[n1] - x[n1] * y[next]) >=
        0.) {
      s12 = x[n1] * x[n2] + y[n1] * y[n2] + z__[n1] * z__[n2];
      q[0] = x[n2] - s12 * x[n1];
      q[1] = y[n2] - s12 * y[n1];
      q[2] = z__[n2] - s12 * z__[n1];
      if (xp * q[0] + yp * q[1] + zp * q[2] >= 0.) {
        goto L13;
      }
      if (x[next] * q[0] + y[next] * q[1] + z__[next] * q[2] >= 0.) {
        goto L13;
      }
      nf = n1;
    }
    n2 = n1;
    n1 = next;
    if (n1 != n1s) {
      goto L12;
    }
    *i1 = n1;
    *i2 = n1;
    *i3 = 0;
    return 0;
  L13:
    nl = n1;
  }
  *i1 = nf;
  *i2 = nl;
  *i3 = 0;
  return 0;
L14:
  *i1 = 0;
  *i2 = 0;
  *i3 = 0;
  return 0;
}


x86 assembly (clang, -O0):
<trfind_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
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    -0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rbp)
mov    0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x20(%rbp)
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x4ec7(%rip)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,0x4ebe(%rip)
mov    -0x18(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,0x4eb5(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x4e71(%rip)
cmpl   $0x1,0x4e6a(%rip)
jl     1226 <trfind_+0xf6>
mov    0x4e5e(%rip),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jle    124a <trfind_+0x11a>
mov    -0x20(%rbp),%rdi
lea    0x4e07(%rip),%rsi
lea    0x4e04(%rip),%rdx
lea    0x4e01(%rip),%rcx
call   1030 <jrand_@plt>
mov    %eax,0x4e2e(%rip)
movsd  0x2dae(%rip),%xmm0
movsd  %xmm0,0x4e66(%rip)
movsd  0x4e5e(%rip),%xmm0
movsd  0x2d9e(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x4e4a(%rip)
movsd  0x2d82(%rip),%xmm0
addsd  0x4e3a(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
lea    -0x48(%rbp),%rdi
call   1050 <store_@plt>
cvtsi2sd %eax,%xmm0
movsd  0x2d60(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12af <trfind_+0x17f>
jmp    125a <trfind_+0x12a>
movsd  0x2d51(%rip),%xmm0
mulsd  0x4e01(%rip),%xmm0
movsd  %xmm0,0x4df9(%rip)
movsd  0x2d41(%rip),%xmm0
mulsd  0x4de9(%rip),%xmm0
movsd  %xmm0,0x4de9(%rip)
mov    0x20(%rbp),%rax
movslq 0x4d8e(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x4da9(%rip)
mov    0x10(%rbp),%rax
movslq 0x4d9e(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x4d91(%rip)
mov    0x18(%rbp),%rax
movslq 0x4d8a(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x4d81(%rip)
mov    0x10(%rbp),%rax
movslq 0x4d76(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x4d5d(%rip)
mov    0x4d57(%rip),%eax
mov    %eax,0x4d41(%rip)
cmpl   $0x0,0x4d56(%rip)
jle    1503 <trfind_+0x3d3>
jmp    134d <trfind_+0x21d>
movsd  0x4d4b(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x4d18(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x4d0c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x4cfc(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq 0x4ce8(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x4cec(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x4cb1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x4ca5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x4c95(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x4c81(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x4c6a(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x4c27(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x4c1b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x4c0b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x4bf7(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    14fe <trfind_+0x3ce>
mov    0x18(%rbp),%rax
movslq 0x4bd7(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x4bce(%rip)
mov    0x10(%rbp),%rax
movslq 0x4bc3(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x4b9a(%rip)
mov    0x4b94(%rip),%eax
cmp    0x4baa(%rip),%eax
jne    14f9 <trfind_+0x3c9>
jmp    1e67 <trfind_+0xd37>
jmp    134d <trfind_+0x21d>
jmp    182a <trfind_+0x6fa>
xor    %eax,%eax
sub    0x4b8d(%rip),%eax
mov    %eax,0x4b87(%rip)
movsd  0x4b87(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x4b54(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x4b58(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x4b48(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq 0x4b24(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x4b28(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x4aed(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x4af1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x4ae1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x4abd(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x4aa6(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x4a63(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x4a67(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x4a57(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x4a33(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    169b <trfind_+0x56b>
mov    0x49f4(%rip),%eax
mov    %eax,0x49f2(%rip)
mov    0x49fc(%rip),%eax
mov    %eax,0x49ea(%rip)
jmp    2912 <trfind_+0x17e2>
movsd  0x49fd(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x49ea(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x49ba(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x49aa(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq 0x49ba(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x499e(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x4983(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x4953(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x4943(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x4953(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x491c(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x48f9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x48c9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x48b9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x48c9(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1825 <trfind_+0x6f5>
mov    0x488a(%rip),%eax
mov    %eax,0x4868(%rip)
mov    0x485e(%rip),%eax
mov    %eax,0x4860(%rip)
jmp    2912 <trfind_+0x17e2>
jmp    182a <trfind_+0x6fa>
jmp    182f <trfind_+0x6ff>
mov    0x18(%rbp),%rax
movslq 0x4862(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x4859(%rip)
mov    0x10(%rbp),%rax
movslq 0x484e(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     1869 <trfind_+0x739>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1871 <trfind_+0x741>
xor    %eax,%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,0x4806(%rip)
movsd  0x481e(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x47eb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x47e3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x47d3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq 0x47bb(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x47bf(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x4784(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x477c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x476c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x4754(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x473d(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x46fa(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x46f2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x46e2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x46ca(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    19ec <trfind_+0x8bc>
jmp    1e73 <trfind_+0xd43>
mov    0x468e(%rip),%eax
mov    %eax,0x4684(%rip)
mov    0x467e(%rip),%eax
cmp    0x4694(%rip),%eax
je     1a0f <trfind_+0x8df>
jmp    182f <trfind_+0x6ff>
movsd  0x4689(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x4656(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x465a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x464a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq 0x4626(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x462a(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x45ef(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x45f3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x45e3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x45bf(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x45a8(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x4565(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x4569(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x4559(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x4535(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1b81 <trfind_+0xa51>
jmp    1e67 <trfind_+0xd37>
mov    -0x28(%rbp),%rax
movslq 0x44ec(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x4507(%rip),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x44d4(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x44f7(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x38(%rbp),%rax
movslq 0x44b4(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x44df(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1bff <trfind_+0xacf>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1c20 <trfind_+0xaf0>
movsd  -0x48(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
lea    -0x50(%rbp),%rdi
call   1050 <store_@plt>
cvtsi2sd %eax,%xmm1
movsd  0x4481(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0x23ba(%rip),%xmm2
mulsd  %xmm2,%xmm0
movsd  0x2396(%rip),%xmm2
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1e56 <trfind_+0xd26>
jmp    1c7d <trfind_+0xb4d>
movsd  0x441b(%rip),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x43ec(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x43d8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x43c8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x43bc(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  0x43bc(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x4385(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x4371(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x4361(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x4355(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x433a(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x42fb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x42e7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x42d7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x42cb(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1e51 <trfind_+0xd21>
mov    0x18(%rbp),%rax
movslq 0x42a7(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x429e(%rip)
mov    0x10(%rbp),%rax
movslq 0x4293(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     1e24 <trfind_+0xcf4>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    1e2c <trfind_+0xcfc>
xor    %eax,%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,0x4247(%rip)
mov    0x4241(%rip),%eax
cmp    0x4257(%rip),%eax
jne    1e4c <trfind_+0xd1c>
jmp    31f3 <trfind_+0x20c3>
jmp    1c7d <trfind_+0xb4d>
jmp    1e56 <trfind_+0xd26>
mov    0x4220(%rip),%eax
mov    %eax,0x4216(%rip)
jmp    12df <trfind_+0x1af>
mov    0x421f(%rip),%eax
mov    %eax,0x420d(%rip)
mov    0x41ff(%rip),%eax
mov    %eax,0x4205(%rip)
mov    0x41f7(%rip),%eax
mov    %eax,0x422d(%rip)
mov    0x41ef(%rip),%eax
mov    %eax,0x4225(%rip)
movsd  0x4201(%rip),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x41d2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x41c6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x41b6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x41a2(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  0x41a2(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x416b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x415f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x414f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x413b(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x4120(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x40e1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x40d5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x40c5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x40b1(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x38(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    22e3 <trfind_+0x11b3>
mov    0x20(%rbp),%rdi
movslq 0x4065(%rip),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    0x10(%rbp),%rdx
add    $0x4,%rdx
mov    0x18(%rbp),%rcx
add    $0x4,%rcx
lea    0x4043(%rip),%rsi
call   1040 <lstptr_@plt>
mov    %eax,0x4058(%rip)
mov    0x10(%rbp),%rax
movslq 0x404d(%rip),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    205e <trfind_+0xf2e>
jmp    2912 <trfind_+0x17e2>
mov    0x18(%rbp),%rax
movslq 0x4033(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x402a(%rip)
mov    0x10(%rbp),%rax
movslq 0x401f(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     2098 <trfind_+0xf68>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x68(%rbp)
jmp    20a0 <trfind_+0xf70>
xor    %eax,%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,0x3fdf(%rip)
movsd  0x3fef(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x3fbc(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x3fbc(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x3fac(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq 0x3f8c(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x3f90(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x3f55(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x3f55(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x3f45(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x3f25(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x3f0e(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x3ecb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x3ecb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x3ebb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x3e9b(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    2268 <trfind_+0x1138>
mov    0x3e64(%rip),%eax
mov    %eax,0x3e62(%rip)
mov    0x3e60(%rip),%eax
mov    %eax,0x3e52(%rip)
mov    0x3e48(%rip),%eax
mov    %eax,0x3e7e(%rip)
mov    0x3e40(%rip),%eax
cmp    0x3e76(%rip),%eax
je     2263 <trfind_+0x1133>
mov    0x3e2e(%rip),%eax
cmp    0x3e20(%rip),%eax
je     2263 <trfind_+0x1133>
jmp    1e97 <trfind_+0xd67>
jmp    22ba <trfind_+0x118a>
mov    0x3e0e(%rip),%eax
mov    %eax,0x3e10(%rip)
mov    0x3e0e(%rip),%eax
mov    %eax,0x3dfc(%rip)
mov    0x3dfa(%rip),%eax
mov    %eax,0x3e30(%rip)
mov    0x3dea(%rip),%eax
cmp    0x3e20(%rip),%eax
je     22b5 <trfind_+0x1185>
mov    0x3dd8(%rip),%eax
cmp    0x3dce(%rip),%eax
je     22b5 <trfind_+0x1185>
jmp    1e97 <trfind_+0xd67>
jmp    22ba <trfind_+0x118a>
mov    -0x20(%rbp),%rdi
lea    0x3d73(%rip),%rsi
lea    0x3d70(%rip),%rdx
lea    0x3d6d(%rip),%rcx
call   1030 <jrand_@plt>
mov    %eax,0x3d9a(%rip)
jmp    12df <trfind_+0x1af>
mov    0x38(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd 0x3dcd(%rip),%xmm0
jb     2659 <trfind_+0x1529>
movsd  0x3d9f(%rip),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x3d74(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x3d68(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x3d58(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x3d44(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  0x3d40(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x3d0d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x3d01(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x3cf1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x3cdd(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3cbe(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x3c83(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x3c77(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x3c67(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x3c53(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  0x3c37(%rip),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x3c10(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x3bf8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x3be8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x3be0(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  0x3bd8(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x3ba9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x3b91(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x3b81(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x3b79(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3b56(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x3b1f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x3b07(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x3af7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x3aef(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x3aef(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
ja     262b <trfind_+0x14fb>
mov    0x30(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x3abe(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    2654 <trfind_+0x1524>
mov    -0x20(%rbp),%rdi
lea    0x3a02(%rip),%rsi
lea    0x39ff(%rip),%rdx
lea    0x39fc(%rip),%rcx
call   1030 <jrand_@plt>
mov    %eax,0x3a29(%rip)
jmp    12df <trfind_+0x1af>
jmp    28aa <trfind_+0x177a>
mov    0x38(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
movslq 0x3a0d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x3a01(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x39ed(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x39e1(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x38(%rbp),%rax
movslq 0x39c5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x39b9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x39b4(%rip)
movsd  0x39bc(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x398d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x39ac(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x3975(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3994(%rip),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x3955(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3994(%rip)
movsd  0x395c(%rip),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x3931(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x394c(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x3919(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3934(%rip),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x38f9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x393c(%rip)
movsd  0x392c(%rip),%xmm1
movsd  0x38e4(%rip),%xmm0
movsd  0x3924(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  0x38f5(%rip),%xmm1
movsd  0x38a5(%rip),%xmm0
movsd  0x38dd(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x389e(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
ja     287c <trfind_+0x174c>
mov    0x30(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x386d(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    28a5 <trfind_+0x1775>
mov    -0x20(%rbp),%rdi
lea    0x37b1(%rip),%rsi
lea    0x37ae(%rip),%rdx
lea    0x37ab(%rip),%rcx
call   1030 <jrand_@plt>
mov    %eax,0x37d8(%rip)
jmp    12df <trfind_+0x1af>
jmp    28aa <trfind_+0x177a>
mov    0x37cc(%rip),%ecx
mov    0x40(%rbp),%rax
mov    %ecx,(%rax)
mov    0x37c4(%rip),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,(%rax)
mov    0x37bc(%rip),%ecx
mov    0x50(%rbp),%rax
mov    %ecx,(%rax)
mov    0x28(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    28ea <trfind_+0x17ba>
mov    0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    0x30(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    2906 <trfind_+0x17d6>
mov    0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    3218 <trfind_+0x20e8>
mov    0x3764(%rip),%eax
mov    %eax,0x379a(%rip)
mov    0x375c(%rip),%eax
mov    %eax,0x3792(%rip)
movl   $0x0,0x3764(%rip)
mov    0x20(%rbp),%rax
movslq 0x3741(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3754(%rip)
mov    0x18(%rbp),%rax
movslq 0x3749(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3740(%rip)
mov    0x10(%rbp),%rax
movslq 0x3735(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x3770(%rip)
movsd  0x3728(%rip),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x36fd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x374d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x373d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x36cd(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  0x36c9(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x3696(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x36e6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x36d6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x3666(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3647(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x360c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x365c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x364c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x35dc(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2d0a <trfind_+0x1bda>
mov    -0x28(%rbp),%rax
movslq 0x3594(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x3588(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x3574(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x3568(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x38(%rbp),%rax
movslq 0x354c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x3540(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x353b(%rip)
mov    -0x28(%rbp),%rax
movslq 0x351c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x3523(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x3508(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x34bc(%rip)
mov    -0x30(%rbp),%rax
movslq 0x34cd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x34d4(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x34b9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3475(%rip)
mov    -0x38(%rbp),%rax
movslq 0x347e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x3485(%rip),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x346a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x342e(%rip)
movsd  0x3456(%rip),%xmm1
movsd  0x340e(%rip),%xmm2
movsd  0x344e(%rip),%xmm0
mulsd  0x3406(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x343e(%rip),%xmm0
movsd  0x33f6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2c94 <trfind_+0x1b64>
jmp    2d67 <trfind_+0x1c37>
mov    -0x28(%rbp),%rax
movslq 0x3441(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x33b4(%rip),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x3429(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x33a4(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x38(%rbp),%rax
movslq 0x3409(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x338c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2cfe <trfind_+0x1bce>
jmp    2d67 <trfind_+0x1c37>
mov    0x337c(%rip),%eax
mov    %eax,0x338e(%rip)
mov    0x3370(%rip),%eax
mov    %eax,0x3366(%rip)
mov    0x33c4(%rip),%eax
mov    %eax,0x335e(%rip)
mov    0x3358(%rip),%eax
cmp    0x338a(%rip),%eax
je     2d39 <trfind_+0x1c09>
jmp    2934 <trfind_+0x1804>
mov    0x3379(%rip),%ecx
mov    0x40(%rbp),%rax
mov    %ecx,(%rax)
mov    0x336d(%rip),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,(%rax)
mov    0x50(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    3218 <trfind_+0x20e8>
mov    0x3313(%rip),%eax
mov    %eax,0x3319(%rip)
cmpl   $0x0,0x331e(%rip)
jne    31c5 <trfind_+0x2095>
mov    0x3336(%rip),%eax
mov    %eax,0x32f4(%rip)
mov    0x3326(%rip),%eax
mov    %eax,0x32e4(%rip)
mov    0x20(%rbp),%rax
movslq 0x32d9(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x32f0(%rip)
mov    0x10(%rbp),%rcx
movslq 0x32e5(%rip),%rdx
xor    %eax,%eax
sub    (%rcx,%rdx,4),%eax
mov    %eax,0x331e(%rip)
movsd  0x32d6(%rip),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x330b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x38(%rbp),%rax
movslq 0x3297(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x3287(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x32db(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  0x3277(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x32a4(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x38(%rbp),%rax
movslq 0x3230(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm5
mov    -0x28(%rbp),%rax
movslq 0x3220(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x38(%rbp),%rax
movslq 0x3274(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm4
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x31f5(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x321a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x31a6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm4
mov    -0x28(%rbp),%rax
movslq 0x3196(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x30(%rbp),%rax
movslq 0x31ea(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     315c <trfind_+0x202c>
mov    -0x28(%rbp),%rax
movslq 0x3142(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x3136(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x3122(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x3116(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x38(%rbp),%rax
movslq 0x30fa(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x30ee(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30e9(%rip)
mov    -0x28(%rbp),%rax
movslq 0x30ce(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x30d1(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x30b2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x306a(%rip)
mov    -0x30(%rbp),%rax
movslq 0x307f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x3082(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x3063(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3023(%rip)
mov    -0x38(%rbp),%rax
movslq 0x3030(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x3033(%rip),%xmm0
mov    -0x38(%rbp),%rax
movslq 0x3014(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2fdc(%rip)
movsd  0x3004(%rip),%xmm1
movsd  0x2fbc(%rip),%xmm2
movsd  0x2ffc(%rip),%xmm0
mulsd  0x2fb4(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2fec(%rip),%xmm0
movsd  0x2fa4(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     30e6 <trfind_+0x1fb6>
jmp    31b9 <trfind_+0x2089>
mov    -0x28(%rbp),%rax
movslq 0x2fef(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x2f62(%rip),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x2fd7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x2f52(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x38(%rbp),%rax
movslq 0x2fb7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x2f3a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     3150 <trfind_+0x2020>
jmp    31b9 <trfind_+0x2089>
mov    0x2f26(%rip),%eax
mov    %eax,0x2f30(%rip)
mov    0x2f1a(%rip),%eax
mov    %eax,0x2f18(%rip)
mov    0x2f72(%rip),%eax
mov    %eax,0x2f08(%rip)
mov    0x2f02(%rip),%eax
cmp    0x2f38(%rip),%eax
je     318b <trfind_+0x205b>
jmp    2d98 <trfind_+0x1c68>
mov    0x2eeb(%rip),%ecx
mov    0x40(%rbp),%rax
mov    %ecx,(%rax)
mov    0x2edf(%rip),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,(%rax)
mov    0x50(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    3218 <trfind_+0x20e8>
mov    0x2ebd(%rip),%eax
mov    %eax,0x2ed3(%rip)
mov    0x2ec1(%rip),%ecx
mov    0x40(%rbp),%rax
mov    %ecx,(%rax)
mov    0x2ec1(%rip),%ecx
mov    0x48(%rbp),%rax
mov    %ecx,(%rax)
mov    0x50(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    3218 <trfind_+0x20e8>
mov    0x40(%rbp),%rax
movl   $0x0,(%rax)
mov    0x48(%rbp),%rax
movl   $0x0,(%rax)
mov    0x50(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<trfind_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,%r14
mov    %r8,%r15
mov    %rcx,%r12
mov    %rdx,%rbx
mov    0x70(%rsp),%rbp
movsd  (%rsi),%xmm0
movsd  %xmm0,0x2f0d(%rip)
movsd  0x8(%rsi),%xmm0
movsd  %xmm0,0x2f08(%rip)
movsd  0x10(%rsi),%xmm0
movsd  %xmm0,0x2f03(%rip)
mov    (%rdi),%eax
mov    %eax,0x2ed3(%rip)
test   %eax,%eax
jle    1185 <trfind_+0x55>
cmp    (%rbx),%eax
jle    11a8 <trfind_+0x78>
lea    0x2eac(%rip),%rsi
lea    0x2ea9(%rip),%rdx
lea    0x2ea6(%rip),%rcx
mov    %rbx,%rdi
call   1030 <jrand_@plt>
mov    %eax,0x2ea8(%rip)
mov    %rbx,0x10(%rsp)
add    $0xfffffffffffffffc,%rbp
mov    %rbp,0x8(%rsp)
add    $0xfffffffffffffff8,%r14
add    $0xfffffffffffffff8,%r15
add    $0xfffffffffffffff8,%r12
movsd  0xe36(%rip),%xmm0
lea    0x18(%rsp),%rbp
nop
mulsd  0xe30(%rip),%xmm0
movsd  %xmm0,0x2ea8(%rip)
addsd  0xe18(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %rbp,%rdi
call   1050 <store_@plt>
movsd  0x2e8a(%rip),%xmm0
cmp    $0x1,%eax
jg     11d0 <trfind_+0xa0>
addsd  %xmm0,%xmm0
movsd  %xmm0,0x2e79(%rip)
mulsd  0xdf9(%rip),%xmm0
movsd  %xmm0,0x2e71(%rip)
mov    0x2e2b(%rip),%eax
xorpd  %xmm15,%xmm15
mov    0x8(%rsp),%r13
mov    0x68(%rsp),%r10
mov    0x60(%rsp),%rdx
jmp    1274 <trfind_+0x144>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdi
lea    0x2dec(%rip),%rsi
lea    0x2de9(%rip),%rdx
lea    0x2de6(%rip),%rcx
call   1030 <jrand_@plt>
mov    0x60(%rsp),%rdx
mov    0x68(%rsp),%r10
xorpd  %xmm15,%xmm15
mov    %eax,0x2ddc(%rip)
movslq %eax,%rbp
movslq 0x0(%r13,%rbp,4),%rcx
mov    -0x4(%rdx,%rcx,4),%esi
mov    %esi,0x2dd6(%rip)
movslq -0x4(%r10,%rcx,4),%rcx
mov    -0x4(%rdx,%rcx,4),%r8d
movslq %r8d,%r9
mov    %r9d,0x2dba(%rip)
test   %esi,%esi
jle    1370 <trfind_+0x240>
movsd  0x2dbd(%rip),%xmm13
movsd  (%r15,%rbp,8),%xmm5
movsd  (%r14,%rbp,8),%xmm4
movsd  0x2db0(%rip),%xmm11
movsd  (%r12,%rbp,8),%xmm6
movapd %xmm11,%xmm12
xorpd  0xd4c(%rip),%xmm12
movsd  0x2d9b(%rip),%xmm14
mov    %r8d,%ebx
movslq %ebx,%rdi
movsd  (%r14,%rdi,8),%xmm0
movsd  (%r15,%rdi,8),%xmm1
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm5,%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm2,%xmm3
movsd  (%r12,%rdi,8),%xmm2
movapd %xmm4,%xmm7
mulsd  %xmm2,%xmm7
mulsd  %xmm6,%xmm0
subsd  %xmm7,%xmm0
mulsd  %xmm12,%xmm0
mulsd  %xmm13,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm5,%xmm2
mulsd  %xmm6,%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm3,%xmm1
ucomisd %xmm1,%xmm15
jbe    1480 <trfind_+0x350>
movslq %ecx,%rcx
movslq -0x4(%r10,%rcx,4),%rcx
mov    %ecx,0x2d0b(%rip)
mov    -0x4(%rdx,%rcx,4),%ebx
mov    %ebx,0x2cf5(%rip)
cmp    %esi,%ebx
jne    12e0 <trfind_+0x1b0>
jmp    157c <trfind_+0x44c>
nopl   0x0(%rax)
neg    %esi
mov    %esi,0x2ce4(%rip)
movsd  0x2ce7(%rip),%xmm13
movsd  (%r15,%rbp,8),%xmm5
movsd  (%r14,%r9,8),%xmm2
movsd  (%r15,%r9,8),%xmm0
movsd  (%r14,%rbp,8),%xmm4
movapd %xmm4,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm5,%xmm1
mulsd  %xmm2,%xmm1
subsd  %xmm3,%xmm1
movsd  0x2cba(%rip),%xmm11
movsd  (%r12,%rbp,8),%xmm6
movsd  (%r12,%r9,8),%xmm3
movapd %xmm4,%xmm7
mulsd  %xmm3,%xmm7
mulsd  %xmm6,%xmm2
subsd  %xmm7,%xmm2
movapd %xmm11,%xmm12
xorpd  0xc40(%rip),%xmm12
mulsd  %xmm11,%xmm2
mulsd  %xmm13,%xmm1
subsd  %xmm2,%xmm1
movsd  0x2c81(%rip),%xmm14
mulsd  %xmm5,%xmm3
mulsd  %xmm6,%xmm0
subsd  %xmm3,%xmm0
mulsd  %xmm14,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm0,%xmm15
ja     1f2a <trfind_+0xdfa>
mov    %esi,%edi
movsd  (%r15,%rdi,8),%xmm0
movsd  (%r14,%rdi,8),%xmm1
movapd %xmm1,%xmm2
mulsd  %xmm5,%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm4,%xmm3
subsd  %xmm2,%xmm3
movsd  (%r12,%rdi,8),%xmm2
mulsd  %xmm6,%xmm1
movapd %xmm2,%xmm7
mulsd  %xmm4,%xmm7
subsd  %xmm1,%xmm7
mulsd  %xmm12,%xmm7
mulsd  %xmm13,%xmm3
addsd  %xmm7,%xmm3
mulsd  %xmm6,%xmm0
mulsd  %xmm5,%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm14,%xmm2
addsd  %xmm3,%xmm2
ucomisd %xmm2,%xmm15
ja     1f3f <trfind_+0xe0f>
mov    %r8d,%ebx
movslq %ecx,%rcx
movslq -0x4(%r10,%rcx,4),%rcx
mov    -0x4(%rdx,%rcx,4),%ebp
mov    %ebp,%edi
neg    %edi
cmovs  %ebp,%edi
movsd  (%r14,%rdi,8),%xmm0
movsd  (%r15,%rdi,8),%xmm1
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm5,%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm2,%xmm3
movsd  (%r12,%rdi,8),%xmm2
movapd %xmm4,%xmm7
mulsd  %xmm2,%xmm7
mulsd  %xmm6,%xmm0
subsd  %xmm7,%xmm0
mulsd  %xmm12,%xmm0
mulsd  %xmm13,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm5,%xmm2
mulsd  %xmm6,%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm3,%xmm1
ucomisd %xmm1,%xmm15
ja     1590 <trfind_+0x460>
mov    %edi,0x2b57(%rip)
mov    %edi,%ebx
cmp    %esi,%edi
jne    1480 <trfind_+0x350>
mov    %ecx,0x2b53(%rip)
mov    %esi,0x2b45(%rip)
movsd  (%r14,%r9,8),%xmm0
movsd  (%r15,%r9,8),%xmm1
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm5,%xmm3
mulsd  %xmm0,%xmm3
subsd  %xmm2,%xmm3
movsd  (%r12,%r9,8),%xmm2
movapd %xmm4,%xmm7
mulsd  %xmm2,%xmm7
mulsd  %xmm6,%xmm0
subsd  %xmm7,%xmm0
mulsd  %xmm12,%xmm0
mulsd  %xmm13,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm5,%xmm2
mulsd  %xmm6,%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm3,%xmm1
ucomisd %xmm1,%xmm15
mov    0x8(%rsp),%r13
jbe    1864 <trfind_+0x734>
mov    %esi,%ebx
mov    %r8d,%edi
jmp    159b <trfind_+0x46b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ecx,0x2aca(%rip)
mov    0x8(%rsp),%r13
mov    %edi,0x2ab7(%rip)
mov    %ebx,0x2ad9(%rip)
mov    %edi,0x2ad7(%rip)
jmp    15b8 <trfind_+0x488>
nop
cmp    %esi,%ecx
je     1240 <trfind_+0x110>
movslq %ebx,%rcx
movsd  (%r15,%rcx,8),%xmm1
movslq %edi,%rsi
movsd  (%r14,%rsi,8),%xmm2
movsd  (%r15,%rsi,8),%xmm3
movsd  (%r14,%rcx,8),%xmm4
movapd %xmm4,%xmm0
mulsd  %xmm3,%xmm0
movapd %xmm1,%xmm5
mulsd  %xmm2,%xmm5
subsd  %xmm0,%xmm5
movsd  (%r12,%rcx,8),%xmm0
movsd  (%r12,%rsi,8),%xmm6
mulsd  %xmm6,%xmm4
mulsd  %xmm0,%xmm2
subsd  %xmm4,%xmm2
mulsd  %xmm11,%xmm2
mulsd  %xmm13,%xmm5
subsd  %xmm2,%xmm5
mulsd  %xmm6,%xmm1
mulsd  %xmm3,%xmm0
subsd  %xmm1,%xmm0
mulsd  %xmm14,%xmm0
addsd  %xmm5,%xmm0
mov    0x88(%rsp),%rbp
movsd  %xmm0,0x0(%rbp)
ucomisd %xmm0,%xmm15
jbe    1780 <trfind_+0x650>
lea    0x0(,%rsi,4),%rdi
add    %r13,%rdi
lea    0x2a05(%rip),%rsi
mov    %r10,%rcx
mov    %r10,%rbx
call   1040 <lstptr_@plt>
mov    0x60(%rsp),%rdx
mov    %eax,0x29fb(%rip)
cltq
cmpl   $0x0,-0x4(%rdx,%rax,4)
js     1b25 <trfind_+0x9f5>
movslq -0x4(%rbx,%rax,4),%rax
mov    %eax,0x29e3(%rip)
mov    -0x4(%rdx,%rax,4),%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
movsd  0x29d7(%rip),%xmm13
movslq 0x29b8(%rip),%rsi
movsd  (%r15,%rsi,8),%xmm0
movsd  (%r14,%rcx,8),%xmm1
movsd  (%r15,%rcx,8),%xmm2
movsd  (%r14,%rsi,8),%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm2,%xmm4
movapd %xmm0,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm4,%xmm5
movsd  0x29a3(%rip),%xmm11
movsd  (%r12,%rsi,8),%xmm4
movsd  (%r12,%rcx,8),%xmm6
mulsd  %xmm6,%xmm3
mulsd  %xmm4,%xmm1
subsd  %xmm3,%xmm1
mulsd  %xmm11,%xmm1
mulsd  %xmm13,%xmm5
subsd  %xmm1,%xmm5
movsd  0x297c(%rip),%xmm14
mulsd  %xmm6,%xmm0
mulsd  %xmm2,%xmm4
subsd  %xmm0,%xmm4
mulsd  %xmm14,%xmm4
addsd  %xmm5,%xmm4
xorpd  %xmm15,%xmm15
ucomisd %xmm4,%xmm15
mov    %rbx,%r10
jbe    1750 <trfind_+0x620>
mov    0x2932(%rip),%eax
mov    %ecx,0x292c(%rip)
mov    0x2922(%rip),%ebx
mov    %ebx,0x2948(%rip)
cmp    0x2946(%rip),%ecx
je     1240 <trfind_+0x110>
mov    %ecx,%edi
jmp    15b0 <trfind_+0x480>
nopl   0x0(%rax,%rax,1)
mov    0x28fe(%rip),%eax
mov    %ecx,0x28f8(%rip)
mov    0x28f6(%rip),%edi
mov    %edi,0x291c(%rip)
cmp    0x2912(%rip),%ecx
je     1240 <trfind_+0x110>
mov    %ecx,%ebx
jmp    15b0 <trfind_+0x480>
nopl   0x0(%rax,%rax,1)
ucomisd 0x2900(%rip),%xmm0
jae    19e4 <trfind_+0x8b4>
mov    0x88(%rsp),%rbp
movq   $0x0,0x0(%rbp)
movsd  (%r12,%rcx,8),%xmm1
movsd  (%r12,%rsi,8),%xmm2
movsd  (%r15,%rcx,8),%xmm3
movsd  (%r15,%rsi,8),%xmm4
movapd %xmm11,%xmm5
mulsd  %xmm3,%xmm5
mulsd  %xmm4,%xmm3
movapd %xmm13,%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm3,%xmm1
movsd  (%r14,%rcx,8),%xmm3
movsd  (%r14,%rsi,8),%xmm6
movapd %xmm14,%xmm7
mulsd  %xmm3,%xmm7
mulsd  %xmm6,%xmm3
addsd  %xmm1,%xmm3
addsd  %xmm5,%xmm0
addsd  %xmm7,%xmm0
mulsd  %xmm4,%xmm11
mulsd  %xmm2,%xmm13
addsd  %xmm11,%xmm13
mulsd  %xmm6,%xmm14
addsd  %xmm13,%xmm14
movapd %xmm3,%xmm1
mulsd  %xmm14,%xmm1
mulsd  %xmm0,%xmm3
subsd  %xmm1,%xmm0
mov    0x78(%rsp),%rsi
movsd  %xmm0,(%rsi)
movapd %xmm14,%xmm1
subsd  %xmm3,%xmm1
mov    0x80(%rsp),%rcx
movsd  %xmm1,(%rcx)
movsd  (%rsi),%xmm0
movsd  0x2843(%rip),%xmm2
xorpd  0x7cb(%rip),%xmm2
ucomisd %xmm0,%xmm2
jbe    1af6 <trfind_+0x9c6>
jmp    1240 <trfind_+0x110>
mulsd  %xmm11,%xmm5
mulsd  %xmm13,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm14,%xmm4
addsd  %xmm6,%xmm4
movsd  %xmm4,0x18(%rsp)
movapd %xmm4,%xmm0
xorpd  0x793(%rip),%xmm0
xorpd  %xmm1,%xmm1
cmplesd %xmm4,%xmm1
andpd  %xmm1,%xmm4
andnpd %xmm0,%xmm1
orpd   %xmm4,%xmm1
movlpd %xmm1,0x20(%rsp)
lea    0x20(%rsp),%rdi
call   1050 <store_@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x27c7(%rip),%xmm1
mulsd  0x74f(%rip),%xmm1
addsd  0x72f(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1b05 <trfind_+0x9d5>
movsd  0x2784(%rip),%xmm8
movslq 0x2765(%rip),%rax
movsd  (%r14,%rax,8),%xmm1
movsd  (%r15,%rax,8),%xmm9
movapd %xmm9,%xmm10
movapd 0x71c(%rip),%xmm0
xorpd  %xmm0,%xmm10
movsd  (%r12,%rax,8),%xmm4
xorpd  %xmm0,%xmm4
movsd  0x2755(%rip),%xmm5
xorpd  %xmm0,%xmm5
movsd  0x2750(%rip),%xmm11
mov    0x2732(%rip),%edi
mov    0x2728(%rip),%ecx
mov    0x271a(%rip),%eax
xorpd  %xmm15,%xmm15
mov    0x68(%rsp),%r10
mov    0x60(%rsp),%rdx
nopl   0x0(%rax)
movslq %eax,%rsi
movsd  (%r15,%rsi,8),%xmm3
movsd  (%r14,%rsi,8),%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm10,%xmm0
movapd %xmm3,%xmm7
mulsd  %xmm1,%xmm7
addsd  %xmm0,%xmm7
mulsd  %xmm8,%xmm7
movsd  (%r12,%rsi,8),%xmm0
mulsd  %xmm4,%xmm2
movapd %xmm0,%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm2,%xmm6
mulsd  %xmm5,%xmm6
addsd  %xmm7,%xmm6
mulsd  %xmm4,%xmm3
mulsd  %xmm9,%xmm0
addsd  %xmm3,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm6,%xmm0
ucomisd %xmm15,%xmm0
jb     1b1a <trfind_+0x9ea>
movslq %edi,%rax
movslq -0x4(%r10,%rax,4),%rdi
mov    %edi,0x269a(%rip)
mov    -0x4(%rdx,%rdi,4),%esi
mov    %esi,%eax
neg    %eax
cmovs  %esi,%eax
mov    %eax,0x267d(%rip)
cmp    %ecx,%eax
jne    1950 <trfind_+0x820>
jmp    1ef3 <trfind_+0xdc3>
movapd 0x634(%rip),%xmm7
xorpd  %xmm7,%xmm11
movsd  (%r15,%rsi,8),%xmm0
movslq %eax,%rbp
movsd  (%r14,%rbp,8),%xmm1
movsd  (%r15,%rbp,8),%xmm2
movsd  (%r14,%rsi,8),%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm2,%xmm4
movapd %xmm0,%xmm5
mulsd  %xmm1,%xmm5
subsd  %xmm4,%xmm5
movsd  (%r12,%rsi,8),%xmm4
movsd  (%r12,%rbp,8),%xmm6
mulsd  %xmm6,%xmm3
mulsd  %xmm4,%xmm1
subsd  %xmm3,%xmm1
mulsd  %xmm11,%xmm1
mulsd  %xmm13,%xmm5
addsd  %xmm1,%xmm5
mulsd  %xmm6,%xmm0
mulsd  %xmm2,%xmm4
subsd  %xmm0,%xmm4
mulsd  %xmm14,%xmm4
addsd  %xmm5,%xmm4
mov    0x78(%rsp),%rsi
movsd  %xmm4,(%rsi)
movsd  (%r15,%rbp,8),%xmm0
movsd  (%r14,%rcx,8),%xmm2
movsd  (%r15,%rcx,8),%xmm3
movsd  (%r14,%rbp,8),%xmm4
movapd %xmm4,%xmm1
mulsd  %xmm3,%xmm1
movapd %xmm0,%xmm5
mulsd  %xmm2,%xmm5
subsd  %xmm1,%xmm5
movsd  (%r12,%rbp,8),%xmm1
mov    0x8(%rsp),%r13
movsd  (%r12,%rcx,8),%xmm6
mulsd  %xmm6,%xmm4
mulsd  %xmm1,%xmm2
subsd  %xmm4,%xmm2
mulsd  %xmm11,%xmm2
mulsd  %xmm13,%xmm5
addsd  %xmm2,%xmm5
mulsd  %xmm6,%xmm0
mulsd  %xmm3,%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm14,%xmm1
addsd  %xmm5,%xmm1
mov    0x80(%rsp),%rcx
movsd  %xmm1,(%rcx)
movsd  (%rsi),%xmm0
movsd  0x25a8(%rip),%xmm2
xorpd  %xmm7,%xmm2
ucomisd %xmm0,%xmm2
ja     1240 <trfind_+0x110>
ucomisd %xmm1,%xmm2
ja     1240 <trfind_+0x110>
jmp    1f55 <trfind_+0xe25>
mov    0x2549(%rip),%eax
xorpd  %xmm15,%xmm15
mov    0x68(%rsp),%r10
mov    0x60(%rsp),%rdx
mov    %eax,0x2530(%rip)
jmp    1274 <trfind_+0x144>
mov    0x2529(%rip),%eax
mov    0x2526(%rip),%r8d
movsd  0x252d(%rip),%xmm13
movsd  0x252c(%rip),%xmm11
movsd  0x252b(%rip),%xmm14
movslq %r8d,%rbp
movapd 0x4c7(%rip),%xmm12
xorpd  %xmm11,%xmm12
mov    %rbx,%r10
mov    %eax,0x2519(%rip)
mov    %r8d,0x2516(%rip)
movl   $0x0,0x24e4(%rip)
movsd  (%r15,%rbp,8),%xmm6
movsd  (%r14,%rbp,8),%xmm5
movsd  (%r12,%rbp,8),%xmm7
xor    %ebx,%ebx
xorpd  %xmm8,%xmm8
mov    %eax,%esi
mov    %r8d,%ebp
jmp    1bcf <trfind_+0xa9f>
nopl   0x0(%rax,%rax,1)
mov    %ebp,0x24b6(%rip)
mov    %ebp,%ebx
mov    %ebp,0x24a6(%rip)
mov    %edi,0x24a4(%rip)
mov    %ebp,%esi
movapd %xmm15,%xmm7
movapd %xmm10,%xmm5
movapd %xmm9,%xmm6
mov    %edi,%ebp
cmp    %eax,%edi
je     1eba <trfind_+0xd8a>
movslq %ebp,%rcx
mov    0x8(%rsp),%rdi
movslq (%rdi,%rcx,4),%rcx
movslq -0x4(%r10,%rcx,4),%rcx
movslq -0x4(%rdx,%rcx,4),%rdi
movsd  (%r14,%rdi,8),%xmm10
movsd  (%r15,%rdi,8),%xmm9
movapd %xmm5,%xmm0
mulsd  %xmm9,%xmm0
movapd %xmm6,%xmm1
mulsd  %xmm10,%xmm1
subsd  %xmm0,%xmm1
movsd  (%r12,%rdi,8),%xmm15
movapd %xmm5,%xmm0
mulsd  %xmm15,%xmm0
movapd %xmm7,%xmm2
mulsd  %xmm10,%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm12,%xmm2
mulsd  %xmm13,%xmm1
addsd  %xmm2,%xmm1
movapd %xmm6,%xmm0
mulsd  %xmm15,%xmm0
movapd %xmm7,%xmm2
mulsd  %xmm9,%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm14,%xmm2
addsd  %xmm1,%xmm2
ucomisd %xmm8,%xmm2
jb     1ba8 <trfind_+0xa78>
movslq %esi,%rsi
movsd  (%r12,%rsi,8),%xmm0
movsd  (%r15,%rsi,8),%xmm2
movapd %xmm6,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm0,%xmm4
mulsd  %xmm7,%xmm4
addsd  %xmm1,%xmm4
movsd  (%r14,%rsi,8),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm1,%xmm7
subsd  %xmm7,%xmm0
mulsd  %xmm1,%xmm6
subsd  %xmm6,%xmm2
mulsd  %xmm5,%xmm1
subsd  %xmm1,%xmm3
movapd %xmm11,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm13,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm14,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
ucomisd %xmm8,%xmm1
jae    1cf4 <trfind_+0xbc4>
mulsd  %xmm9,%xmm2
mulsd  %xmm15,%xmm0
addsd  %xmm2,%xmm0
mulsd  %xmm10,%xmm3
addsd  %xmm0,%xmm3
ucomisd %xmm8,%xmm3
jb     1ba0 <trfind_+0xa70>
mov    %ecx,0x2366(%rip)
test   %ebx,%ebx
jne    1ea4 <trfind_+0xd74>
mov    %r8d,0x234f(%rip)
mov    %eax,0x2345(%rip)
movslq %eax,%rcx
movsd  (%r14,%rcx,8),%xmm4
movsd  (%r15,%rcx,8),%xmm5
movsd  (%r12,%rcx,8),%xmm7
xorpd  %xmm8,%xmm8
mov    %eax,%edi
jmp    1d5c <trfind_+0xc2c>
nopl   (%rax)
mov    %ebp,%esi
neg    %edi
mov    %ebx,0x231e(%rip)
mov    %edi,0x2314(%rip)
mov    %esi,%ebp
movapd %xmm15,%xmm7
movapd %xmm9,%xmm5
movapd %xmm10,%xmm4
mov    %ebx,%r8d
cmp    %edi,%eax
je     1f11 <trfind_+0xde1>
mov    %edi,%ebx
movslq %edi,%rcx
mov    0x8(%rsp),%rsi
movslq (%rsi,%rcx,4),%r9
movslq -0x4(%rdx,%r9,4),%rdi
lea    0x0(,%rdi,8),%rsi
mov    %r15,%rcx
sub    %rsi,%rcx
movsd  (%rcx),%xmm9
mov    %r14,%rcx
sub    %rsi,%rcx
movsd  (%rcx),%xmm10
movapd %xmm10,%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm9,%xmm1
mulsd  %xmm4,%xmm1
subsd  %xmm0,%xmm1
mov    %r12,%rcx
sub    %rsi,%rcx
movsd  (%rcx),%xmm15
movapd %xmm10,%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm15,%xmm2
mulsd  %xmm4,%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm12,%xmm2
mulsd  %xmm13,%xmm1
addsd  %xmm2,%xmm1
movapd %xmm9,%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm15,%xmm2
mulsd  %xmm5,%xmm2
subsd  %xmm0,%xmm2
mulsd  %xmm14,%xmm2
addsd  %xmm1,%xmm2
ucomisd %xmm8,%xmm2
jb     1d30 <trfind_+0xc00>
movslq %r8d,%rcx
movsd  (%r12,%rcx,8),%xmm0
movsd  (%r15,%rcx,8),%xmm1
movapd %xmm5,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm7,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movsd  (%r14,%rcx,8),%xmm2
movapd %xmm4,%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm6,%xmm7
subsd  %xmm7,%xmm0
mulsd  %xmm6,%xmm5
subsd  %xmm5,%xmm1
mulsd  %xmm4,%xmm6
subsd  %xmm6,%xmm2
movapd %xmm11,%xmm3
mulsd  %xmm1,%xmm3
movapd %xmm13,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm14,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
ucomisd %xmm8,%xmm3
jae    1e97 <trfind_+0xd67>
mulsd  %xmm9,%xmm1
mulsd  %xmm15,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm10,%xmm2
addsd  %xmm0,%xmm2
ucomisd %xmm8,%xmm2
mov    %ebx,%esi
jb     1d32 <trfind_+0xc02>
mov    %r9d,0x21c2(%rip)
mov    %ebx,0x21b8(%rip)
mov    0x90(%rsp),%rax
mov    %ebp,(%rax)
mov    0x98(%rsp),%rax
mov    %ebx,(%rax)
jmp    1ed4 <trfind_+0xda4>
mov    %ecx,0x21a0(%rip)
mov    0x90(%rsp),%rcx
mov    %eax,(%rcx)
mov    0x98(%rsp),%rcx
mov    %eax,(%rcx)
mov    0xa0(%rsp),%rax
movl   $0x0,(%rax)
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x90(%rsp),%rax
movl   $0x0,(%rax)
mov    0x98(%rsp),%rax
movl   $0x0,(%rax)
jmp    1ed4 <trfind_+0xda4>
mov    %r9d,0x2148(%rip)
mov    0x90(%rsp),%rcx
mov    %eax,(%rcx)
mov    0x212c(%rip),%eax
jmp    1eca <trfind_+0xd9a>
mov    %eax,0x2124(%rip)
mov    %r9d,0x2121(%rip)
mov    %r9,%rbp
jmp    1b61 <trfind_+0xa31>
mov    %esi,0x210f(%rip)
mov    %eax,0x210d(%rip)
mov    %eax,%r8d
mov    %esi,%eax
jmp    1b61 <trfind_+0xa31>
mov    0x90(%rsp),%rcx
mov    %ebx,(%rcx)
mov    0x98(%rsp),%rcx
mov    %edi,(%rcx)
mov    0xa0(%rsp),%rcx
mov    %eax,(%rcx)
xorpd  %xmm2,%xmm2
ucomisd %xmm0,%xmm2
jbe    1f95 <trfind_+0xe65>
mov    0x78(%rsp),%rax
movq   $0x0,(%rax)
mov    0x80(%rsp),%rax
movsd  (%rax),%xmm1
ucomisd %xmm1,%xmm2
jbe    1ee2 <trfind_+0xdb2>
mov    0x80(%rsp),%rax
movq   $0x0,(%rax)
jmp    1ee2 <trfind_+0xdb2>

LLVM IR (-O0):
@trfind_.ix = internal global i32 1
@trfind_.iy = internal global i32 2
@trfind_.iz = internal global i32 3
@trfind_.q = internal global [3 x double] zeroinitializer
@trfind_.n0 = internal global i32 0
@trfind_.n1 = internal global i32 0
@trfind_.n2 = internal global i32 0
@trfind_.n3 = internal global i32 0
@trfind_.n4 = internal global i32 0
@trfind_.nf = internal global i32 0
@trfind_.s12 = internal global double 0.000000e+00
@trfind_.nl = internal global i32 0
@trfind_.lp = internal global i32 0
@trfind_.xp = internal global double 0.000000e+00
@trfind_.yp = internal global double 0.000000e+00
@trfind_.zp = internal global double 0.000000e+00
@trfind_.n1s = internal global i32 0
@trfind_.n2s = internal global i32 0
@trfind_.eps = internal global double 0.000000e+00
@trfind_.tol = internal global double 0.000000e+00
@trfind_.ptn1 = internal global double 0.000000e+00
@trfind_.ptn2 = internal global double 0.000000e+00
@trfind_.next = internal global i32 0
define i32 @trfind_(i32* %0, double* %1, i32* %2, double* %3, double* %4, double* %5, i32* %6, i32* %7, i32* %8, double* %9, double* %10, double* %11, i32* %12, i32* %13, i32* %14) {
%16 = alloca i32
%17 = alloca i32*
%18 = alloca double*
%19 = alloca i32*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca i32*
%30 = alloca i32*
%31 = alloca i32*
%32 = alloca i32
%33 = alloca double
%34 = alloca double
store i32* %0, i32** %17
store double* %1, double** %18
store i32* %2, i32** %19
store double* %3, double** %20
store double* %4, double** %21
store double* %5, double** %22
store i32* %6, i32** %23
store i32* %7, i32** %24
store i32* %8, i32** %25
store double* %9, double** %26
store double* %10, double** %27
store double* %11, double** %28
store i32* %12, i32** %29
store i32* %13, i32** %30
store i32* %14, i32** %31
%35 = load double*, double** %18
%36 = getelementptr inbounds double, double* %35, i32 -1
store double* %36, double** %18
%37 = load i32*, i32** %25
%38 = getelementptr inbounds i32, i32* %37, i32 -1
store i32* %38, i32** %25
%39 = load double*, double** %22
%40 = getelementptr inbounds double, double* %39, i32 -1
store double* %40, double** %22
%41 = load double*, double** %21
%42 = getelementptr inbounds double, double* %41, i32 -1
store double* %42, double** %21
%43 = load double*, double** %20
%44 = getelementptr inbounds double, double* %43, i32 -1
store double* %44, double** %20
%45 = load i32*, i32** %23
%46 = getelementptr inbounds i32, i32* %45, i32 -1
store i32* %46, i32** %23
%47 = load i32*, i32** %24
%48 = getelementptr inbounds i32, i32* %47, i32 -1
store i32* %48, i32** %24
%49 = load double*, double** %18
%50 = getelementptr inbounds double, double* %49, i64 1
%51 = load double, double* %50
store double %51, double* @trfind_.xp
%52 = load double*, double** %18
%53 = getelementptr inbounds double, double* %52, i64 2
%54 = load double, double* %53
store double %54, double* @trfind_.yp
%55 = load double*, double** %18
%56 = getelementptr inbounds double, double* %55, i64 3
%57 = load double, double* %56
store double %57, double* @trfind_.zp
%58 = load i32*, i32** %17
%59 = load i32, i32* %58
store i32 %59, i32* @trfind_.n0
%60 = load i32, i32* @trfind_.n0
%61 = icmp slt i32 %60, 1
br i1 %61, label %67, label %62
62: ; preds = %15
%63 = load i32, i32* @trfind_.n0
%64 = load i32*, i32** %19
%65 = load i32, i32* %64
%66 = icmp sgt i32 %63, %65
br i1 %66, label %67, label %70
67: ; preds = %62, %15
%68 = load i32*, i32** %19
%69 = call i32 @jrand_(i32* %68, i32* @trfind_.ix, i32* @trfind_.iy, i32* @trfind_.iz)
store i32 %69, i32* @trfind_.n0
br label %70
70: ; preds = %67, %62
store double 1.000000e+00, double* @trfind_.eps
br label %71
71: ; preds = %79, %70
%72 = load double, double* @trfind_.eps
%73 = fdiv double %72, 2.000000e+00
store double %73, double* @trfind_.eps
%74 = load double, double* @trfind_.eps
%75 = fadd double %74, 1.000000e+00
store double %75, double* %33
%76 = call i32 @store_(double* %33)
%77 = sitofp i32 %76 to double
%78 = fcmp ogt double %77, 1.000000e+00
br i1 %78, label %79, label %80
79: ; preds = %71
br label %71
80: ; preds = %71
%81 = load double, double* @trfind_.eps
%82 = fmul double %81, 2.000000e+00
store double %82, double* @trfind_.eps
%83 = load double, double* @trfind_.eps
%84 = fmul double %83, 1.000000e+02
store double %84, double* @trfind_.tol
br label %85
85: ; preds = %1203, %1099, %925, %696, %80
%86 = load i32*, i32** %25
%87 = load i32, i32* @trfind_.n0
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i32, i32* %86, i64 %88
%90 = load i32, i32* %89
store i32 %90, i32* @trfind_.lp
%91 = load i32*, i32** %23
%92 = load i32, i32* @trfind_.lp
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i32, i32* %91, i64 %93
%95 = load i32, i32* %94
store i32 %95, i32* @trfind_.nl
%96 = load i32*, i32** %24
%97 = load i32, i32* @trfind_.lp
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i32, i32* %96, i64 %98
%100 = load i32, i32* %99
store i32 %100, i32* @trfind_.lp
%101 = load i32*, i32** %23
%102 = load i32, i32* @trfind_.lp
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i32, i32* %101, i64 %103
%105 = load i32, i32* %104
store i32 %105, i32* @trfind_.nf
%106 = load i32, i32* @trfind_.nf
store i32 %106, i32* @trfind_.n1
%107 = load i32, i32* @trfind_.nl
%108 = icmp sgt i32 %107, 0
br i1 %108, label %109, label %205
109: ; preds = %85
br label %110
110: ; preds = %203, %109
%111 = load double, double* @trfind_.xp
%112 = load double*, double** %21
%113 = load i32, i32* @trfind_.n0
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %112, i64 %114
%116 = load double, double* %115
%117 = load double*, double** %22
%118 = load i32, i32* @trfind_.n1
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %117, i64 %119
%121 = load double, double* %120
%122 = load double*, double** %21
%123 = load i32, i32* @trfind_.n1
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds double, double* %122, i64 %124
%126 = load double, double* %125
%127 = load double*, double** %22
%128 = load i32, i32* @trfind_.n0
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %127, i64 %129
%131 = load double, double* %130
%132 = fmul double %126, %131
%133 = fneg double %132
%134 = call double @llvm.fmuladd.f64(double %116, double %121, double %133)
%135 = load double, double* @trfind_.yp
%136 = load double*, double** %20
%137 = load i32, i32* @trfind_.n0
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
%140 = load double, double* %139
%141 = load double*, double** %22
%142 = load i32, i32* @trfind_.n1
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %141, i64 %143
%145 = load double, double* %144
%146 = load double*, double** %20
%147 = load i32, i32* @trfind_.n1
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %146, i64 %148
%150 = load double, double* %149
%151 = load double*, double** %22
%152 = load i32, i32* @trfind_.n0
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds double, double* %151, i64 %153
%155 = load double, double* %154
%156 = fmul double %150, %155
%157 = fneg double %156
%158 = call double @llvm.fmuladd.f64(double %140, double %145, double %157)
%159 = fmul double %135, %158
%160 = fneg double %159
%161 = call double @llvm.fmuladd.f64(double %111, double %134, double %160)
%162 = load double, double* @trfind_.zp
%163 = load double*, double** %20
%164 = load i32, i32* @trfind_.n0
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds double, double* %163, i64 %165
%167 = load double, double* %166
%168 = load double*, double** %21
%169 = load i32, i32* @trfind_.n1
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds double, double* %168, i64 %170
%172 = load double, double* %171
%173 = load double*, double** %20
%174 = load i32, i32* @trfind_.n1
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds double, double* %173, i64 %175
%177 = load double, double* %176
%178 = load double*, double** %21
%179 = load i32, i32* @trfind_.n0
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %178, i64 %180
%182 = load double, double* %181
%183 = fmul double %177, %182
%184 = fneg double %183
%185 = call double @llvm.fmuladd.f64(double %167, double %172, double %184)
%186 = call double @llvm.fmuladd.f64(double %162, double %185, double %161)
%187 = fcmp olt double %186, 0.000000e+00
br i1 %187, label %188, label %204
188: ; preds = %110
%189 = load i32*, i32** %24
%190 = load i32, i32* @trfind_.lp
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i32, i32* %189, i64 %191
%193 = load i32, i32* %192
store i32 %193, i32* @trfind_.lp
%194 = load i32*, i32** %23
%195 = load i32, i32* @trfind_.lp
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds i32, i32* %194, i64 %196
%198 = load i32, i32* %197
store i32 %198, i32* @trfind_.n1
%199 = load i32, i32* @trfind_.n1
%200 = load i32, i32* @trfind_.nl
%201 = icmp eq i32 %199, %200
br i1 %201, label %202, label %203
202: ; preds = %188
br label %698
203: ; preds = %188
br label %110
204: ; preds = %110
br label %370
205: ; preds = %85
%206 = load i32, i32* @trfind_.nl
%207 = sub nsw i32 0, %206
store i32 %207, i32* @trfind_.nl
%208 = load double, double* @trfind_.xp
%209 = load double*, double** %21
%210 = load i32, i32* @trfind_.n0
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %209, i64 %211
%213 = load double, double* %212
%214 = load double*, double** %22
%215 = load i32, i32* @trfind_.nf
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds double, double* %214, i64 %216
%218 = load double, double* %217
%219 = load double*, double** %21
%220 = load i32, i32* @trfind_.nf
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %219, i64 %221
%223 = load double, double* %222
%224 = load double*, double** %22
%225 = load i32, i32* @trfind_.n0
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
%228 = load double, double* %227
%229 = fmul double %223, %228
%230 = fneg double %229
%231 = call double @llvm.fmuladd.f64(double %213, double %218, double %230)
%232 = load double, double* @trfind_.yp
%233 = load double*, double** %20
%234 = load i32, i32* @trfind_.n0
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %233, i64 %235
%237 = load double, double* %236
%238 = load double*, double** %22
%239 = load i32, i32* @trfind_.nf
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %238, i64 %240
%242 = load double, double* %241
%243 = load double*, double** %20
%244 = load i32, i32* @trfind_.nf
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %243, i64 %245
%247 = load double, double* %246
%248 = load double*, double** %22
%249 = load i32, i32* @trfind_.n0
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds double, double* %248, i64 %250
%252 = load double, double* %251
%253 = fmul double %247, %252
%254 = fneg double %253
%255 = call double @llvm.fmuladd.f64(double %237, double %242, double %254)
%256 = fmul double %232, %255
%257 = fneg double %256
%258 = call double @llvm.fmuladd.f64(double %208, double %231, double %257)
%259 = load double, double* @trfind_.zp
%260 = load double*, double** %20
%261 = load i32, i32* @trfind_.n0
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %260, i64 %262
%264 = load double, double* %263
%265 = load double*, double** %21
%266 = load i32, i32* @trfind_.nf
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %265, i64 %267
%269 = load double, double* %268
%270 = load double*, double** %20
%271 = load i32, i32* @trfind_.nf
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double, double* %270, i64 %272
%274 = load double, double* %273
%275 = load double*, double** %21
%276 = load i32, i32* @trfind_.n0
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds double, double* %275, i64 %277
%279 = load double, double* %278
%280 = fmul double %274, %279
%281 = fneg double %280
%282 = call double @llvm.fmuladd.f64(double %264, double %269, double %281)
%283 = call double @llvm.fmuladd.f64(double %259, double %282, double %258)
%284 = fcmp olt double %283, 0.000000e+00
br i1 %284, label %285, label %288
285: ; preds = %205
%286 = load i32, i32* @trfind_.n0
store i32 %286, i32* @trfind_.n1
%287 = load i32, i32* @trfind_.nf
store i32 %287, i32* @trfind_.n2
br label %1226
288: ; preds = %205
%289 = load double, double* @trfind_.xp
%290 = load double*, double** %21
%291 = load i32, i32* @trfind_.nl
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds double, double* %290, i64 %292
%294 = load double, double* %293
%295 = load double*, double** %22
%296 = load i32, i32* @trfind_.n0
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds double, double* %295, i64 %297
%299 = load double, double* %298
%300 = load double*, double** %21
%301 = load i32, i32* @trfind_.n0
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds double, double* %300, i64 %302
%304 = load double, double* %303
%305 = load double*, double** %22
%306 = load i32, i32* @trfind_.nl
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds double, double* %305, i64 %307
%309 = load double, double* %308
%310 = fmul double %304, %309
%311 = fneg double %310
%312 = call double @llvm.fmuladd.f64(double %294, double %299, double %311)
%313 = load double, double* @trfind_.yp
%314 = load double*, double** %20
%315 = load i32, i32* @trfind_.nl
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double, double* %314, i64 %316
%318 = load double, double* %317
%319 = load double*, double** %22
%320 = load i32, i32* @trfind_.n0
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double, double* %319, i64 %321
%323 = load double, double* %322
%324 = load double*, double** %20
%325 = load i32, i32* @trfind_.n0
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds double, double* %324, i64 %326
%328 = load double, double* %327
%329 = load double*, double** %22
%330 = load i32, i32* @trfind_.nl
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds double, double* %329, i64 %331
%333 = load double, double* %332
%334 = fmul double %328, %333
%335 = fneg double %334
%336 = call double @llvm.fmuladd.f64(double %318, double %323, double %335)
%337 = fmul double %313, %336
%338 = fneg double %337
%339 = call double @llvm.fmuladd.f64(double %289, double %312, double %338)
%340 = load double, double* @trfind_.zp
%341 = load double*, double** %20
%342 = load i32, i32* @trfind_.nl
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double, double* %341, i64 %343
%345 = load double, double* %344
%346 = load double*, double** %21
%347 = load i32, i32* @trfind_.n0
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds double, double* %346, i64 %348
%350 = load double, double* %349
%351 = load double*, double** %20
%352 = load i32, i32* @trfind_.n0
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds double, double* %351, i64 %353
%355 = load double, double* %354
%356 = load double*, double** %21
%357 = load i32, i32* @trfind_.nl
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %356, i64 %358
%360 = load double, double* %359
%361 = fmul double %355, %360
%362 = fneg double %361
%363 = call double @llvm.fmuladd.f64(double %345, double %350, double %362)
%364 = call double @llvm.fmuladd.f64(double %340, double %363, double %339)
%365 = fcmp olt double %364, 0.000000e+00
br i1 %365, label %366, label %369
366: ; preds = %288
%367 = load i32, i32* @trfind_.nl
store i32 %367, i32* @trfind_.n1
%368 = load i32, i32* @trfind_.n0
store i32 %368, i32* @trfind_.n2
br label %1226
369: ; preds = %288
br label %370
370: ; preds = %369, %204
br label %371
371: ; preds = %474, %370
%372 = load i32*, i32** %24
%373 = load i32, i32* @trfind_.lp
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds i32, i32* %372, i64 %374
%376 = load i32, i32* %375
store i32 %376, i32* @trfind_.lp
%377 = load i32*, i32** %23
%378 = load i32, i32* @trfind_.lp
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i32, i32* %377, i64 %379
%381 = load i32, i32* %380
store i32 %381, i32* %32
%382 = load i32, i32* %32
%383 = icmp sge i32 %382, 0
br i1 %383, label %384, label %386
384: ; preds = %371
%385 = load i32, i32* %32
br label %389
386: ; preds = %371
%387 = load i32, i32* %32
%388 = sub nsw i32 0, %387
br label %389
389: ; preds = %386, %384
%390 = phi i32 [ %385, %384 ], [ %388, %386 ]
store i32 %390, i32* @trfind_.n2
%391 = load double, double* @trfind_.xp
%392 = load double*, double** %21
%393 = load i32, i32* @trfind_.n0
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds double, double* %392, i64 %394
%396 = load double, double* %395
%397 = load double*, double** %22
%398 = load i32, i32* @trfind_.n2
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double, double* %397, i64 %399
%401 = load double, double* %400
%402 = load double*, double** %21
%403 = load i32, i32* @trfind_.n2
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds double, double* %402, i64 %404
%406 = load double, double* %405
%407 = load double*, double** %22
%408 = load i32, i32* @trfind_.n0
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds double, double* %407, i64 %409
%411 = load double, double* %410
%412 = fmul double %406, %411
%413 = fneg double %412
%414 = call double @llvm.fmuladd.f64(double %396, double %401, double %413)
%415 = load double, double* @trfind_.yp
%416 = load double*, double** %20
%417 = load i32, i32* @trfind_.n0
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds double, double* %416, i64 %418
%420 = load double, double* %419
%421 = load double*, double** %22
%422 = load i32, i32* @trfind_.n2
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %421, i64 %423
%425 = load double, double* %424
%426 = load double*, double** %20
%427 = load i32, i32* @trfind_.n2
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double, double* %426, i64 %428
%430 = load double, double* %429
%431 = load double*, double** %22
%432 = load i32, i32* @trfind_.n0
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %431, i64 %433
%435 = load double, double* %434
%436 = fmul double %430, %435
%437 = fneg double %436
%438 = call double @llvm.fmuladd.f64(double %420, double %425, double %437)
%439 = fmul double %415, %438
%440 = fneg double %439
%441 = call double @llvm.fmuladd.f64(double %391, double %414, double %440)
%442 = load double, double* @trfind_.zp
%443 = load double*, double** %20
%444 = load i32, i32* @trfind_.n0
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds double, double* %443, i64 %445
%447 = load double, double* %446
%448 = load double*, double** %21
%449 = load i32, i32* @trfind_.n2
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds double, double* %448, i64 %450
%452 = load double, double* %451
%453 = load double*, double** %20
%454 = load i32, i32* @trfind_.n2
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %453, i64 %455
%457 = load double, double* %456
%458 = load double*, double** %21
%459 = load i32, i32* @trfind_.n0
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds double, double* %458, i64 %460
%462 = load double, double* %461
%463 = fmul double %457, %462
%464 = fneg double %463
%465 = call double @llvm.fmuladd.f64(double %447, double %452, double %464)
%466 = call double @llvm.fmuladd.f64(double %442, double %465, double %441)
%467 = fcmp olt double %466, 0.000000e+00
br i1 %467, label %468, label %469
468: ; preds = %389
br label %700
469: ; preds = %389
%470 = load i32, i32* @trfind_.n2
store i32 %470, i32* @trfind_.n1
%471 = load i32, i32* @trfind_.n1
%472 = load i32, i32* @trfind_.nl
%473 = icmp ne i32 %471, %472
br i1 %473, label %474, label %475
474: ; preds = %469
br label %371
475: ; preds = %469
%476 = load double, double* @trfind_.xp
%477 = load double*, double** %21
%478 = load i32, i32* @trfind_.n0
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds double, double* %477, i64 %479
%481 = load double, double* %480
%482 = load double*, double** %22
%483 = load i32, i32* @trfind_.nf
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds double, double* %482, i64 %484
%486 = load double, double* %485
%487 = load double*, double** %21
%488 = load i32, i32* @trfind_.nf
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds double, double* %487, i64 %489
%491 = load double, double* %490
%492 = load double*, double** %22
%493 = load i32, i32* @trfind_.n0
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds double, double* %492, i64 %494
%496 = load double, double* %495
%497 = fmul double %491, %496
%498 = fneg double %497
%499 = call double @llvm.fmuladd.f64(double %481, double %486, double %498)
%500 = load double, double* @trfind_.yp
%501 = load double*, double** %20
%502 = load i32, i32* @trfind_.n0
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds double, double* %501, i64 %503
%505 = load double, double* %504
%506 = load double*, double** %22
%507 = load i32, i32* @trfind_.nf
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds double, double* %506, i64 %508
%510 = load double, double* %509
%511 = load double*, double** %20
%512 = load i32, i32* @trfind_.nf
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds double, double* %511, i64 %513
%515 = load double, double* %514
%516 = load double*, double** %22
%517 = load i32, i32* @trfind_.n0
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds double, double* %516, i64 %518
%520 = load double, double* %519
%521 = fmul double %515, %520
%522 = fneg double %521
%523 = call double @llvm.fmuladd.f64(double %505, double %510, double %522)
%524 = fmul double %500, %523
%525 = fneg double %524
%526 = call double @llvm.fmuladd.f64(double %476, double %499, double %525)
%527 = load double, double* @trfind_.zp
%528 = load double*, double** %20
%529 = load i32, i32* @trfind_.n0
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds double, double* %528, i64 %530
%532 = load double, double* %531
%533 = load double*, double** %21
%534 = load i32, i32* @trfind_.nf
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds double, double* %533, i64 %535
%537 = load double, double* %536
%538 = load double*, double** %20
%539 = load i32, i32* @trfind_.nf
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds double, double* %538, i64 %540
%542 = load double, double* %541
%543 = load double*, double** %21
%544 = load i32, i32* @trfind_.n0
%545 = sext i32 %544 to i64
%546 = getelementptr inbounds double, double* %543, i64 %545
%547 = load double, double* %546
%548 = fmul double %542, %547
%549 = fneg double %548
%550 = call double @llvm.fmuladd.f64(double %532, double %537, double %549)
%551 = call double @llvm.fmuladd.f64(double %527, double %550, double %526)
%552 = fcmp olt double %551, 0.000000e+00
br i1 %552, label %553, label %554
553: ; preds = %475
br label %698
554: ; preds = %475
%555 = load double*, double** %20
%556 = load i32, i32* @trfind_.n0
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds double, double* %555, i64 %557
%559 = load double, double* %558
%560 = load double, double* @trfind_.xp
%561 = load double*, double** %21
%562 = load i32, i32* @trfind_.n0
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds double, double* %561, i64 %563
%565 = load double, double* %564
%566 = load double, double* @trfind_.yp
%567 = fmul double %565, %566
%568 = call double @llvm.fmuladd.f64(double %559, double %560, double %567)
%569 = load double*, double** %22
%570 = load i32, i32* @trfind_.n0
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds double, double* %569, i64 %571
%573 = load double, double* %572
%574 = load double, double* @trfind_.zp
%575 = call double @llvm.fmuladd.f64(double %573, double %574, double %568)
store double %575, double* %33
%576 = load double, double* %33
%577 = fcmp oge double %576, 0.000000e+00
br i1 %577, label %578, label %580
578: ; preds = %554
%579 = load double, double* %33
br label %583
580: ; preds = %554
%581 = load double, double* %33
%582 = fneg double %581
br label %583
583: ; preds = %580, %578
%584 = phi double [ %579, %578 ], [ %582, %580 ]
store double %584, double* %34
%585 = call i32 @store_(double* %34)
%586 = sitofp i32 %585 to double
%587 = load double, double* @trfind_.eps
%588 = fneg double %587
%589 = call double @llvm.fmuladd.f64(double %588, double 4.000000e+00, double 1.000000e+00)
%590 = fcmp olt double %586, %589
br i1 %590, label %591, label %696
591: ; preds = %583
br label %592
592: ; preds = %694, %591
%593 = load double, double* @trfind_.xp
%594 = load double*, double** %21
%595 = load i32, i32* @trfind_.n1
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds double, double* %594, i64 %596
%598 = load double, double* %597
%599 = load double*, double** %22
%600 = load i32, i32* @trfind_.n0
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds double, double* %599, i64 %601
%603 = load double, double* %602
%604 = load double*, double** %21
%605 = load i32, i32* @trfind_.n0
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds double, double* %604, i64 %606
%608 = load double, double* %607
%609 = load double*, double** %22
%610 = load i32, i32* @trfind_.n1
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds double, double* %609, i64 %611
%613 = load double, double* %612
%614 = fmul double %608, %613
%615 = fneg double %614
%616 = call double @llvm.fmuladd.f64(double %598, double %603, double %615)
%617 = load double, double* @trfind_.yp
%618 = load double*, double** %20
%619 = load i32, i32* @trfind_.n1
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds double, double* %618, i64 %620
%622 = load double, double* %621
%623 = load double*, double** %22
%624 = load i32, i32* @trfind_.n0
%625 = sext i32 %624 to i64
%626 = getelementptr inbounds double, double* %623, i64 %625
%627 = load double, double* %626
%628 = load double*, double** %20
%629 = load i32, i32* @trfind_.n0
%630 = sext i32 %629 to i64
%631 = getelementptr inbounds double, double* %628, i64 %630
%632 = load double, double* %631
%633 = load double*, double** %22
%634 = load i32, i32* @trfind_.n1
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds double, double* %633, i64 %635
%637 = load double, double* %636
%638 = fmul double %632, %637
%639 = fneg double %638
%640 = call double @llvm.fmuladd.f64(double %622, double %627, double %639)
%641 = fmul double %617, %640
%642 = fneg double %641
%643 = call double @llvm.fmuladd.f64(double %593, double %616, double %642)
%644 = load double, double* @trfind_.zp
%645 = load double*, double** %20
%646 = load i32, i32* @trfind_.n1
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds double, double* %645, i64 %647
%649 = load double, double* %648
%650 = load double*, double** %21
%651 = load i32, i32* @trfind_.n0
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double, double* %650, i64 %652
%654 = load double, double* %653
%655 = load double*, double** %20
%656 = load i32, i32* @trfind_.n0
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds double, double* %655, i64 %657
%659 = load double, double* %658
%660 = load double*, double** %21
%661 = load i32, i32* @trfind_.n1
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds double, double* %660, i64 %662
%664 = load double, double* %663
%665 = fmul double %659, %664
%666 = fneg double %665
%667 = call double @llvm.fmuladd.f64(double %649, double %654, double %666)
%668 = call double @llvm.fmuladd.f64(double %644, double %667, double %643)
%669 = fcmp oge double %668, 0.000000e+00
br i1 %669, label %670, label %695
670: ; preds = %592
%671 = load i32*, i32** %24
%672 = load i32, i32* @trfind_.lp
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds i32, i32* %671, i64 %673
%675 = load i32, i32* %674
store i32 %675, i32* @trfind_.lp
%676 = load i32*, i32** %23
%677 = load i32, i32* @trfind_.lp
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds i32, i32* %676, i64 %678
%680 = load i32, i32* %679
store i32 %680, i32* %32
%681 = load i32, i32* %32
%682 = icmp sge i32 %681, 0
br i1 %682, label %683, label %685
683: ; preds = %670
%684 = load i32, i32* %32
br label %688
685: ; preds = %670
%686 = load i32, i32* %32
%687 = sub nsw i32 0, %686
br label %688
688: ; preds = %685, %683
%689 = phi i32 [ %684, %683 ], [ %687, %685 ]
store i32 %689, i32* @trfind_.n1
%690 = load i32, i32* @trfind_.n1
%691 = load i32, i32* @trfind_.nl
%692 = icmp eq i32 %690, %691
br i1 %692, label %693, label %694
693: ; preds = %688
br label %1672
694: ; preds = %688
br label %592
695: ; preds = %592
br label %696
696: ; preds = %695, %583
%697 = load i32, i32* @trfind_.n1
store i32 %697, i32* @trfind_.n0
br label %85
698: ; preds = %553, %202
%699 = load i32, i32* @trfind_.nf
store i32 %699, i32* @trfind_.n2
br label %700
700: ; preds = %698, %468
%701 = load i32, i32* @trfind_.n0
store i32 %701, i32* @trfind_.n3
%702 = load i32, i32* @trfind_.n1
store i32 %702, i32* @trfind_.n1s
%703 = load i32, i32* @trfind_.n2
store i32 %703, i32* @trfind_.n2s
br label %704
704: ; preds = %923, %910, %700
%705 = load double, double* @trfind_.xp
%706 = load double*, double** %21
%707 = load i32, i32* @trfind_.n1
%708 = sext i32 %707 to i64
%709 = getelementptr inbounds double, double* %706, i64 %708
%710 = load double, double* %709
%711 = load double*, double** %22
%712 = load i32, i32* @trfind_.n2
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds double, double* %711, i64 %713
%715 = load double, double* %714
%716 = load double*, double** %21
%717 = load i32, i32* @trfind_.n2
%718 = sext i32 %717 to i64
%719 = getelementptr inbounds double, double* %716, i64 %718
%720 = load double, double* %719
%721 = load double*, double** %22
%722 = load i32, i32* @trfind_.n1
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds double, double* %721, i64 %723
%725 = load double, double* %724
%726 = fmul double %720, %725
%727 = fneg double %726
%728 = call double @llvm.fmuladd.f64(double %710, double %715, double %727)
%729 = load double, double* @trfind_.yp
%730 = load double*, double** %20
%731 = load i32, i32* @trfind_.n1
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds double, double* %730, i64 %732
%734 = load double, double* %733
%735 = load double*, double** %22
%736 = load i32, i32* @trfind_.n2
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds double, double* %735, i64 %737
%739 = load double, double* %738
%740 = load double*, double** %20
%741 = load i32, i32* @trfind_.n2
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds double, double* %740, i64 %742
%744 = load double, double* %743
%745 = load double*, double** %22
%746 = load i32, i32* @trfind_.n1
%747 = sext i32 %746 to i64
%748 = getelementptr inbounds double, double* %745, i64 %747
%749 = load double, double* %748
%750 = fmul double %744, %749
%751 = fneg double %750
%752 = call double @llvm.fmuladd.f64(double %734, double %739, double %751)
%753 = fmul double %729, %752
%754 = fneg double %753
%755 = call double @llvm.fmuladd.f64(double %705, double %728, double %754)
%756 = load double, double* @trfind_.zp
%757 = load double*, double** %20
%758 = load i32, i32* @trfind_.n1
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds double, double* %757, i64 %759
%761 = load double, double* %760
%762 = load double*, double** %21
%763 = load i32, i32* @trfind_.n2
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds double, double* %762, i64 %764
%766 = load double, double* %765
%767 = load double*, double** %20
%768 = load i32, i32* @trfind_.n2
%769 = sext i32 %768 to i64
%770 = getelementptr inbounds double, double* %767, i64 %769
%771 = load double, double* %770
%772 = load double*, double** %21
%773 = load i32, i32* @trfind_.n1
%774 = sext i32 %773 to i64
%775 = getelementptr inbounds double, double* %772, i64 %774
%776 = load double, double* %775
%777 = fmul double %771, %776
%778 = fneg double %777
%779 = call double @llvm.fmuladd.f64(double %761, double %766, double %778)
%780 = call double @llvm.fmuladd.f64(double %756, double %779, double %755)
%781 = load double*, double** %28
store double %780, double* %781
%782 = load double*, double** %28
%783 = load double, double* %782
%784 = fcmp olt double %783, 0.000000e+00
br i1 %784, label %785, label %928
785: ; preds = %704
%786 = load i32*, i32** %25
%787 = load i32, i32* @trfind_.n2
%788 = sext i32 %787 to i64
%789 = getelementptr inbounds i32, i32* %786, i64 %788
%790 = load i32*, i32** %23
%791 = getelementptr inbounds i32, i32* %790, i64 1
%792 = load i32*, i32** %24
%793 = getelementptr inbounds i32, i32* %792, i64 1
%794 = call i32 @lstptr_(i32* %789, i32* @trfind_.n1, i32* %791, i32* %793)
store i32 %794, i32* @trfind_.lp
%795 = load i32*, i32** %23
%796 = load i32, i32* @trfind_.lp
%797 = sext i32 %796 to i64
%798 = getelementptr inbounds i32, i32* %795, i64 %797
%799 = load i32, i32* %798
%800 = icmp slt i32 %799, 0
br i1 %800, label %801, label %802
801: ; preds = %785
br label %1226
802: ; preds = %785
%803 = load i32*, i32** %24
%804 = load i32, i32* @trfind_.lp
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds i32, i32* %803, i64 %805
%807 = load i32, i32* %806
store i32 %807, i32* @trfind_.lp
%808 = load i32*, i32** %23
%809 = load i32, i32* @trfind_.lp
%810 = sext i32 %809 to i64
%811 = getelementptr inbounds i32, i32* %808, i64 %810
%812 = load i32, i32* %811
store i32 %812, i32* %32
%813 = load i32, i32* %32
%814 = icmp sge i32 %813, 0
br i1 %814, label %815, label %817
815: ; preds = %802
%816 = load i32, i32* %32
br label %820
817: ; preds = %802
%818 = load i32, i32* %32
%819 = sub nsw i32 0, %818
br label %820
820: ; preds = %817, %815
%821 = phi i32 [ %816, %815 ], [ %819, %817 ]
store i32 %821, i32* @trfind_.n4
%822 = load double, double* @trfind_.xp
%823 = load double*, double** %21
%824 = load i32, i32* @trfind_.n0
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds double, double* %823, i64 %825
%827 = load double, double* %826
%828 = load double*, double** %22
%829 = load i32, i32* @trfind_.n4
%830 = sext i32 %829 to i64
%831 = getelementptr inbounds double, double* %828, i64 %830
%832 = load double, double* %831
%833 = load double*, double** %21
%834 = load i32, i32* @trfind_.n4
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds double, double* %833, i64 %835
%837 = load double, double* %836
%838 = load double*, double** %22
%839 = load i32, i32* @trfind_.n0
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds double, double* %838, i64 %840
%842 = load double, double* %841
%843 = fmul double %837, %842
%844 = fneg double %843
%845 = call double @llvm.fmuladd.f64(double %827, double %832, double %844)
%846 = load double, double* @trfind_.yp
%847 = load double*, double** %20
%848 = load i32, i32* @trfind_.n0
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds double, double* %847, i64 %849
%851 = load double, double* %850
%852 = load double*, double** %22
%853 = load i32, i32* @trfind_.n4
%854 = sext i32 %853 to i64
%855 = getelementptr inbounds double, double* %852, i64 %854
%856 = load double, double* %855
%857 = load double*, double** %20
%858 = load i32, i32* @trfind_.n4
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds double, double* %857, i64 %859
%861 = load double, double* %860
%862 = load double*, double** %22
%863 = load i32, i32* @trfind_.n0
%864 = sext i32 %863 to i64
%865 = getelementptr inbounds double, double* %862, i64 %864
%866 = load double, double* %865
%867 = fmul double %861, %866
%868 = fneg double %867
%869 = call double @llvm.fmuladd.f64(double %851, double %856, double %868)
%870 = fmul double %846, %869
%871 = fneg double %870
%872 = call double @llvm.fmuladd.f64(double %822, double %845, double %871)
%873 = load double, double* @trfind_.zp
%874 = load double*, double** %20
%875 = load i32, i32* @trfind_.n0
%876 = sext i32 %875 to i64
%877 = getelementptr inbounds double, double* %874, i64 %876
%878 = load double, double* %877
%879 = load double*, double** %21
%880 = load i32, i32* @trfind_.n4
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds double, double* %879, i64 %881
%883 = load double, double* %882
%884 = load double*, double** %20
%885 = load i32, i32* @trfind_.n4
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds double, double* %884, i64 %886
%888 = load double, double* %887
%889 = load double*, double** %21
%890 = load i32, i32* @trfind_.n0
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds double, double* %889, i64 %891
%893 = load double, double* %892
%894 = fmul double %888, %893
%895 = fneg double %894
%896 = call double @llvm.fmuladd.f64(double %878, double %883, double %895)
%897 = call double @llvm.fmuladd.f64(double %873, double %896, double %872)
%898 = fcmp olt double %897, 0.000000e+00
br i1 %898, label %899, label %912
899: ; preds = %820
%900 = load i32, i32* @trfind_.n2
store i32 %900, i32* @trfind_.n3
%901 = load i32, i32* @trfind_.n4
store i32 %901, i32* @trfind_.n2
%902 = load i32, i32* @trfind_.n1
store i32 %902, i32* @trfind_.n1s
%903 = load i32, i32* @trfind_.n2
%904 = load i32, i32* @trfind_.n2s
%905 = icmp ne i32 %903, %904
br i1 %905, label %906, label %911
906: ; preds = %899
%907 = load i32, i32* @trfind_.n2
%908 = load i32, i32* @trfind_.n0
%909 = icmp ne i32 %907, %908
br i1 %909, label %910, label %911
910: ; preds = %906
br label %704
911: ; preds = %906, %899
br label %925
912: ; preds = %820
%913 = load i32, i32* @trfind_.n1
store i32 %913, i32* @trfind_.n3
%914 = load i32, i32* @trfind_.n4
store i32 %914, i32* @trfind_.n1
%915 = load i32, i32* @trfind_.n2
store i32 %915, i32* @trfind_.n2s
%916 = load i32, i32* @trfind_.n1
%917 = load i32, i32* @trfind_.n1s
%918 = icmp ne i32 %916, %917
br i1 %918, label %919, label %924
919: ; preds = %912
%920 = load i32, i32* @trfind_.n1
%921 = load i32, i32* @trfind_.n0
%922 = icmp ne i32 %920, %921
br i1 %922, label %923, label %924
923: ; preds = %919
br label %704
924: ; preds = %919, %912
br label %925
925: ; preds = %924, %911
%926 = load i32*, i32** %19
%927 = call i32 @jrand_(i32* %926, i32* @trfind_.ix, i32* @trfind_.iy, i32* @trfind_.iz)
store i32 %927, i32* @trfind_.n0
br label %85
928: ; preds = %704
%929 = load double*, double** %28
%930 = load double, double* %929
%931 = load double, double* @trfind_.eps
%932 = fcmp oge double %930, %931
br i1 %932, label %933, label %1103
933: ; preds = %928
%934 = load double, double* @trfind_.xp
%935 = load double*, double** %21
%936 = load i32, i32* @trfind_.n2
%937 = sext i32 %936 to i64
%938 = getelementptr inbounds double, double* %935, i64 %937
%939 = load double, double* %938
%940 = load double*, double** %22
%941 = load i32, i32* @trfind_.n3
%942 = sext i32 %941 to i64
%943 = getelementptr inbounds double, double* %940, i64 %942
%944 = load double, double* %943
%945 = load double*, double** %21
%946 = load i32, i32* @trfind_.n3
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds double, double* %945, i64 %947
%949 = load double, double* %948
%950 = load double*, double** %22
%951 = load i32, i32* @trfind_.n2
%952 = sext i32 %951 to i64
%953 = getelementptr inbounds double, double* %950, i64 %952
%954 = load double, double* %953
%955 = fmul double %949, %954
%956 = fneg double %955
%957 = call double @llvm.fmuladd.f64(double %939, double %944, double %956)
%958 = load double, double* @trfind_.yp
%959 = load double*, double** %20
%960 = load i32, i32* @trfind_.n2
%961 = sext i32 %960 to i64
%962 = getelementptr inbounds double, double* %959, i64 %961
%963 = load double, double* %962
%964 = load double*, double** %22
%965 = load i32, i32* @trfind_.n3
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds double, double* %964, i64 %966
%968 = load double, double* %967
%969 = load double*, double** %20
%970 = load i32, i32* @trfind_.n3
%971 = sext i32 %970 to i64
%972 = getelementptr inbounds double, double* %969, i64 %971
%973 = load double, double* %972
%974 = load double*, double** %22
%975 = load i32, i32* @trfind_.n2
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds double, double* %974, i64 %976
%978 = load double, double* %977
%979 = fmul double %973, %978
%980 = fneg double %979
%981 = call double @llvm.fmuladd.f64(double %963, double %968, double %980)
%982 = fmul double %958, %981
%983 = fneg double %982
%984 = call double @llvm.fmuladd.f64(double %934, double %957, double %983)
%985 = load double, double* @trfind_.zp
%986 = load double*, double** %20
%987 = load i32, i32* @trfind_.n2
%988 = sext i32 %987 to i64
%989 = getelementptr inbounds double, double* %986, i64 %988
%990 = load double, double* %989
%991 = load double*, double** %21
%992 = load i32, i32* @trfind_.n3
%993 = sext i32 %992 to i64
%994 = getelementptr inbounds double, double* %991, i64 %993
%995 = load double, double* %994
%996 = load double*, double** %20
%997 = load i32, i32* @trfind_.n3
%998 = sext i32 %997 to i64
%999 = getelementptr inbounds double, double* %996, i64 %998
%1000 = load double, double* %999
%1001 = load double*, double** %21
%1002 = load i32, i32* @trfind_.n2
%1003 = sext i32 %1002 to i64
%1004 = getelementptr inbounds double, double* %1001, i64 %1003
%1005 = load double, double* %1004
%1006 = fmul double %1000, %1005
%1007 = fneg double %1006
%1008 = call double @llvm.fmuladd.f64(double %990, double %995, double %1007)
%1009 = call double @llvm.fmuladd.f64(double %985, double %1008, double %984)
%1010 = load double*, double** %26
store double %1009, double* %1010
%1011 = load double, double* @trfind_.xp
%1012 = load double*, double** %21
%1013 = load i32, i32* @trfind_.n3
%1014 = sext i32 %1013 to i64
%1015 = getelementptr inbounds double, double* %1012, i64 %1014
%1016 = load double, double* %1015
%1017 = load double*, double** %22
%1018 = load i32, i32* @trfind_.n1
%1019 = sext i32 %1018 to i64
%1020 = getelementptr inbounds double, double* %1017, i64 %1019
%1021 = load double, double* %1020
%1022 = load double*, double** %21
%1023 = load i32, i32* @trfind_.n1
%1024 = sext i32 %1023 to i64
%1025 = getelementptr inbounds double, double* %1022, i64 %1024
%1026 = load double, double* %1025
%1027 = load double*, double** %22
%1028 = load i32, i32* @trfind_.n3
%1029 = sext i32 %1028 to i64
%1030 = getelementptr inbounds double, double* %1027, i64 %1029
%1031 = load double, double* %1030
%1032 = fmul double %1026, %1031
%1033 = fneg double %1032
%1034 = call double @llvm.fmuladd.f64(double %1016, double %1021, double %1033)
%1035 = load double, double* @trfind_.yp
%1036 = load double*, double** %20
%1037 = load i32, i32* @trfind_.n3
%1038 = sext i32 %1037 to i64
%1039 = getelementptr inbounds double, double* %1036, i64 %1038
%1040 = load double, double* %1039
%1041 = load double*, double** %22
%1042 = load i32, i32* @trfind_.n1
%1043 = sext i32 %1042 to i64
%1044 = getelementptr inbounds double, double* %1041, i64 %1043
%1045 = load double, double* %1044
%1046 = load double*, double** %20
%1047 = load i32, i32* @trfind_.n1
%1048 = sext i32 %1047 to i64
%1049 = getelementptr inbounds double, double* %1046, i64 %1048
%1050 = load double, double* %1049
%1051 = load double*, double** %22
%1052 = load i32, i32* @trfind_.n3
%1053 = sext i32 %1052 to i64
%1054 = getelementptr inbounds double, double* %1051, i64 %1053
%1055 = load double, double* %1054
%1056 = fmul double %1050, %1055
%1057 = fneg double %1056
%1058 = call double @llvm.fmuladd.f64(double %1040, double %1045, double %1057)
%1059 = fmul double %1035, %1058
%1060 = fneg double %1059
%1061 = call double @llvm.fmuladd.f64(double %1011, double %1034, double %1060)
%1062 = load double, double* @trfind_.zp
%1063 = load double*, double** %20
%1064 = load i32, i32* @trfind_.n3
%1065 = sext i32 %1064 to i64
%1066 = getelementptr inbounds double, double* %1063, i64 %1065
%1067 = load double, double* %1066
%1068 = load double*, double** %21
%1069 = load i32, i32* @trfind_.n1
%1070 = sext i32 %1069 to i64
%1071 = getelementptr inbounds double, double* %1068, i64 %1070
%1072 = load double, double* %1071
%1073 = load double*, double** %20
%1074 = load i32, i32* @trfind_.n1
%1075 = sext i32 %1074 to i64
%1076 = getelementptr inbounds double, double* %1073, i64 %1075
%1077 = load double, double* %1076
%1078 = load double*, double** %21
%1079 = load i32, i32* @trfind_.n3
%1080 = sext i32 %1079 to i64
%1081 = getelementptr inbounds double, double* %1078, i64 %1080
%1082 = load double, double* %1081
%1083 = fmul double %1077, %1082
%1084 = fneg double %1083
%1085 = call double @llvm.fmuladd.f64(double %1067, double %1072, double %1084)
%1086 = call double @llvm.fmuladd.f64(double %1062, double %1085, double %1061)
%1087 = load double*, double** %27
store double %1086, double* %1087
%1088 = load double*, double** %26
%1089 = load double, double* %1088
%1090 = load double, double* @trfind_.tol
%1091 = fneg double %1090
%1092 = fcmp olt double %1089, %1091
br i1 %1092, label %1099, label %1093
1093: ; preds = %933
%1094 = load double*, double** %27
%1095 = load double, double* %1094
%1096 = load double, double* @trfind_.tol
%1097 = fneg double %1096
%1098 = fcmp olt double %1095, %1097
br i1 %1098, label %1099, label %1102
1099: ; preds = %1093, %933
%1100 = load i32*, i32** %19
%1101 = call i32 @jrand_(i32* %1100, i32* @trfind_.ix, i32* @trfind_.iy, i32* @trfind_.iz)
store i32 %1101, i32* @trfind_.n0
br label %85
1102: ; preds = %1093
br label %1207
1103: ; preds = %928
%1104 = load double*, double** %28
store double 0.000000e+00, double* %1104
%1105 = load double*, double** %20
%1106 = load i32, i32* @trfind_.n1
%1107 = sext i32 %1106 to i64
%1108 = getelementptr inbounds double, double* %1105, i64 %1107
%1109 = load double, double* %1108
%1110 = load double*, double** %20
%1111 = load i32, i32* @trfind_.n2
%1112 = sext i32 %1111 to i64
%1113 = getelementptr inbounds double, double* %1110, i64 %1112
%1114 = load double, double* %1113
%1115 = load double*, double** %21
%1116 = load i32, i32* @trfind_.n1
%1117 = sext i32 %1116 to i64
%1118 = getelementptr inbounds double, double* %1115, i64 %1117
%1119 = load double, double* %1118
%1120 = load double*, double** %21
%1121 = load i32, i32* @trfind_.n2
%1122 = sext i32 %1121 to i64
%1123 = getelementptr inbounds double, double* %1120, i64 %1122
%1124 = load double, double* %1123
%1125 = fmul double %1119, %1124
%1126 = call double @llvm.fmuladd.f64(double %1109, double %1114, double %1125)
%1127 = load double*, double** %22
%1128 = load i32, i32* @trfind_.n1
%1129 = sext i32 %1128 to i64
%1130 = getelementptr inbounds double, double* %1127, i64 %1129
%1131 = load double, double* %1130
%1132 = load double*, double** %22
%1133 = load i32, i32* @trfind_.n2
%1134 = sext i32 %1133 to i64
%1135 = getelementptr inbounds double, double* %1132, i64 %1134
%1136 = load double, double* %1135
%1137 = call double @llvm.fmuladd.f64(double %1131, double %1136, double %1126)
store double %1137, double* @trfind_.s12
%1138 = load double, double* @trfind_.xp
%1139 = load double*, double** %20
%1140 = load i32, i32* @trfind_.n1
%1141 = sext i32 %1140 to i64
%1142 = getelementptr inbounds double, double* %1139, i64 %1141
%1143 = load double, double* %1142
%1144 = load double, double* @trfind_.yp
%1145 = load double*, double** %21
%1146 = load i32, i32* @trfind_.n1
%1147 = sext i32 %1146 to i64
%1148 = getelementptr inbounds double, double* %1145, i64 %1147
%1149 = load double, double* %1148
%1150 = fmul double %1144, %1149
%1151 = call double @llvm.fmuladd.f64(double %1138, double %1143, double %1150)
%1152 = load double, double* @trfind_.zp
%1153 = load double*, double** %22
%1154 = load i32, i32* @trfind_.n1
%1155 = sext i32 %1154 to i64
%1156 = getelementptr inbounds double, double* %1153, i64 %1155
%1157 = load double, double* %1156
%1158 = call double @llvm.fmuladd.f64(double %1152, double %1157, double %1151)
store double %1158, double* @trfind_.ptn1
%1159 = load double, double* @trfind_.xp
%1160 = load double*, double** %20
%1161 = load i32, i32* @trfind_.n2
%1162 = sext i32 %1161 to i64
%1163 = getelementptr inbounds double, double* %1160, i64 %1162
%1164 = load double, double* %1163
%1165 = load double, double* @trfind_.yp
%1166 = load double*, double** %21
%1167 = load i32, i32* @trfind_.n2
%1168 = sext i32 %1167 to i64
%1169 = getelementptr inbounds double, double* %1166, i64 %1168
%1170 = load double, double* %1169
%1171 = fmul double %1165, %1170
%1172 = call double @llvm.fmuladd.f64(double %1159, double %1164, double %1171)
%1173 = load double, double* @trfind_.zp
%1174 = load double*, double** %22
%1175 = load i32, i32* @trfind_.n2
%1176 = sext i32 %1175 to i64
%1177 = getelementptr inbounds double, double* %1174, i64 %1176
%1178 = load double, double* %1177
%1179 = call double @llvm.fmuladd.f64(double %1173, double %1178, double %1172)
store double %1179, double* @trfind_.ptn2
%1180 = load double, double* @trfind_.ptn1
%1181 = load double, double* @trfind_.s12
%1182 = load double, double* @trfind_.ptn2
%1183 = fneg double %1181
%1184 = call double @llvm.fmuladd.f64(double %1183, double %1182, double %1180)
%1185 = load double*, double** %26
store double %1184, double* %1185
%1186 = load double, double* @trfind_.ptn2
%1187 = load double, double* @trfind_.s12
%1188 = load double, double* @trfind_.ptn1
%1189 = fneg double %1187
%1190 = call double @llvm.fmuladd.f64(double %1189, double %1188, double %1186)
%1191 = load double*, double** %27
store double %1190, double* %1191
%1192 = load double*, double** %26
%1193 = load double, double* %1192
%1194 = load double, double* @trfind_.tol
%1195 = fneg double %1194
%1196 = fcmp olt double %1193, %1195
br i1 %1196, label %1203, label %1197
1197: ; preds = %1103
%1198 = load double*, double** %27
%1199 = load double, double* %1198
%1200 = load double, double* @trfind_.tol
%1201 = fneg double %1200
%1202 = fcmp olt double %1199, %1201
br i1 %1202, label %1203, label %1206
1203: ; preds = %1197, %1103
%1204 = load i32*, i32** %19
%1205 = call i32 @jrand_(i32* %1204, i32* @trfind_.ix, i32* @trfind_.iy, i32* @trfind_.iz)
store i32 %1205, i32* @trfind_.n0
br label %85
1206: ; preds = %1197
br label %1207
1207: ; preds = %1206, %1102
%1208 = load i32, i32* @trfind_.n1
%1209 = load i32*, i32** %29
store i32 %1208, i32* %1209
%1210 = load i32, i32* @trfind_.n2
%1211 = load i32*, i32** %30
store i32 %1210, i32* %1211
%1212 = load i32, i32* @trfind_.n3
%1213 = load i32*, i32** %31
store i32 %1212, i32* %1213
%1214 = load double*, double** %26
%1215 = load double, double* %1214
%1216 = fcmp olt double %1215, 0.000000e+00
br i1 %1216, label %1217, label %1219
1217: ; preds = %1207
%1218 = load double*, double** %26
store double 0.000000e+00, double* %1218
br label %1219
1219: ; preds = %1217, %1207
%1220 = load double*, double** %27
%1221 = load double, double* %1220
%1222 = fcmp olt double %1221, 0.000000e+00
br i1 %1222, label %1223, label %1225
1223: ; preds = %1219
%1224 = load double*, double** %27
store double 0.000000e+00, double* %1224
br label %1225
1225: ; preds = %1223, %1219
store i32 0, i32* %16
br label %1676
1226: ; preds = %801, %366, %285
%1227 = load i32, i32* @trfind_.n1
store i32 %1227, i32* @trfind_.n1s
%1228 = load i32, i32* @trfind_.n2
store i32 %1228, i32* @trfind_.n2s
store i32 0, i32* @trfind_.nl
br label %1229
1229: ; preds = %1438, %1226
%1230 = load i32*, i32** %25
%1231 = load i32, i32* @trfind_.n2
%1232 = sext i32 %1231 to i64
%1233 = getelementptr inbounds i32, i32* %1230, i64 %1232
%1234 = load i32, i32* %1233
store i32 %1234, i32* @trfind_.lp
%1235 = load i32*, i32** %24
%1236 = load i32, i32* @trfind_.lp
%1237 = sext i32 %1236 to i64
%1238 = getelementptr inbounds i32, i32* %1235, i64 %1237
%1239 = load i32, i32* %1238
store i32 %1239, i32* @trfind_.lp
%1240 = load i32*, i32** %23
%1241 = load i32, i32* @trfind_.lp
%1242 = sext i32 %1241 to i64
%1243 = getelementptr inbounds i32, i32* %1240, i64 %1242
%1244 = load i32, i32* %1243
store i32 %1244, i32* @trfind_.next
%1245 = load double, double* @trfind_.xp
%1246 = load double*, double** %21
%1247 = load i32, i32* @trfind_.n2
%1248 = sext i32 %1247 to i64
%1249 = getelementptr inbounds double, double* %1246, i64 %1248
%1250 = load double, double* %1249
%1251 = load double*, double** %22
%1252 = load i32, i32* @trfind_.next
%1253 = sext i32 %1252 to i64
%1254 = getelementptr inbounds double, double* %1251, i64 %1253
%1255 = load double, double* %1254
%1256 = load double*, double** %21
%1257 = load i32, i32* @trfind_.next
%1258 = sext i32 %1257 to i64
%1259 = getelementptr inbounds double, double* %1256, i64 %1258
%1260 = load double, double* %1259
%1261 = load double*, double** %22
%1262 = load i32, i32* @trfind_.n2
%1263 = sext i32 %1262 to i64
%1264 = getelementptr inbounds double, double* %1261, i64 %1263
%1265 = load double, double* %1264
%1266 = fmul double %1260, %1265
%1267 = fneg double %1266
%1268 = call double @llvm.fmuladd.f64(double %1250, double %1255, double %1267)
%1269 = load double, double* @trfind_.yp
%1270 = load double*, double** %20
%1271 = load i32, i32* @trfind_.n2
%1272 = sext i32 %1271 to i64
%1273 = getelementptr inbounds double, double* %1270, i64 %1272
%1274 = load double, double* %1273
%1275 = load double*, double** %22
%1276 = load i32, i32* @trfind_.next
%1277 = sext i32 %1276 to i64
%1278 = getelementptr inbounds double, double* %1275, i64 %1277
%1279 = load double, double* %1278
%1280 = load double*, double** %20
%1281 = load i32, i32* @trfind_.next
%1282 = sext i32 %1281 to i64
%1283 = getelementptr inbounds double, double* %1280, i64 %1282
%1284 = load double, double* %1283
%1285 = load double*, double** %22
%1286 = load i32, i32* @trfind_.n2
%1287 = sext i32 %1286 to i64
%1288 = getelementptr inbounds double, double* %1285, i64 %1287
%1289 = load double, double* %1288
%1290 = fmul double %1284, %1289
%1291 = fneg double %1290
%1292 = call double @llvm.fmuladd.f64(double %1274, double %1279, double %1291)
%1293 = fmul double %1269, %1292
%1294 = fneg double %1293
%1295 = call double @llvm.fmuladd.f64(double %1245, double %1268, double %1294)
%1296 = load double, double* @trfind_.zp
%1297 = load double*, double** %20
%1298 = load i32, i32* @trfind_.n2
%1299 = sext i32 %1298 to i64
%1300 = getelementptr inbounds double, double* %1297, i64 %1299
%1301 = load double, double* %1300
%1302 = load double*, double** %21
%1303 = load i32, i32* @trfind_.next
%1304 = sext i32 %1303 to i64
%1305 = getelementptr inbounds double, double* %1302, i64 %1304
%1306 = load double, double* %1305
%1307 = load double*, double** %20
%1308 = load i32, i32* @trfind_.next
%1309 = sext i32 %1308 to i64
%1310 = getelementptr inbounds double, double* %1307, i64 %1309
%1311 = load double, double* %1310
%1312 = load double*, double** %21
%1313 = load i32, i32* @trfind_.n2
%1314 = sext i32 %1313 to i64
%1315 = getelementptr inbounds double, double* %1312, i64 %1314
%1316 = load double, double* %1315
%1317 = fmul double %1311, %1316
%1318 = fneg double %1317
%1319 = call double @llvm.fmuladd.f64(double %1301, double %1306, double %1318)
%1320 = call double @llvm.fmuladd.f64(double %1296, double %1319, double %1295)
%1321 = fcmp oge double %1320, 0.000000e+00
br i1 %1321, label %1322, label %1432
1322: ; preds = %1229
%1323 = load double*, double** %20
%1324 = load i32, i32* @trfind_.n1
%1325 = sext i32 %1324 to i64
%1326 = getelementptr inbounds double, double* %1323, i64 %1325
%1327 = load double, double* %1326
%1328 = load double*, double** %20
%1329 = load i32, i32* @trfind_.n2
%1330 = sext i32 %1329 to i64
%1331 = getelementptr inbounds double, double* %1328, i64 %1330
%1332 = load double, double* %1331
%1333 = load double*, double** %21
%1334 = load i32, i32* @trfind_.n1
%1335 = sext i32 %1334 to i64
%1336 = getelementptr inbounds double, double* %1333, i64 %1335
%1337 = load double, double* %1336
%1338 = load double*, double** %21
%1339 = load i32, i32* @trfind_.n2
%1340 = sext i32 %1339 to i64
%1341 = getelementptr inbounds double, double* %1338, i64 %1340
%1342 = load double, double* %1341
%1343 = fmul double %1337, %1342
%1344 = call double @llvm.fmuladd.f64(double %1327, double %1332, double %1343)
%1345 = load double*, double** %22
%1346 = load i32, i32* @trfind_.n1
%1347 = sext i32 %1346 to i64
%1348 = getelementptr inbounds double, double* %1345, i64 %1347
%1349 = load double, double* %1348
%1350 = load double*, double** %22
%1351 = load i32, i32* @trfind_.n2
%1352 = sext i32 %1351 to i64
%1353 = getelementptr inbounds double, double* %1350, i64 %1352
%1354 = load double, double* %1353
%1355 = call double @llvm.fmuladd.f64(double %1349, double %1354, double %1344)
store double %1355, double* @trfind_.s12
%1356 = load double*, double** %20
%1357 = load i32, i32* @trfind_.n1
%1358 = sext i32 %1357 to i64
%1359 = getelementptr inbounds double, double* %1356, i64 %1358
%1360 = load double, double* %1359
%1361 = load double, double* @trfind_.s12
%1362 = load double*, double** %20
%1363 = load i32, i32* @trfind_.n2
%1364 = sext i32 %1363 to i64
%1365 = getelementptr inbounds double, double* %1362, i64 %1364
%1366 = load double, double* %1365
%1367 = fneg double %1361
%1368 = call double @llvm.fmuladd.f64(double %1367, double %1366, double %1360)
store double %1368, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 0)
%1369 = load double*, double** %21
%1370 = load i32, i32* @trfind_.n1
%1371 = sext i32 %1370 to i64
%1372 = getelementptr inbounds double, double* %1369, i64 %1371
%1373 = load double, double* %1372
%1374 = load double, double* @trfind_.s12
%1375 = load double*, double** %21
%1376 = load i32, i32* @trfind_.n2
%1377 = sext i32 %1376 to i64
%1378 = getelementptr inbounds double, double* %1375, i64 %1377
%1379 = load double, double* %1378
%1380 = fneg double %1374
%1381 = call double @llvm.fmuladd.f64(double %1380, double %1379, double %1373)
store double %1381, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 1)
%1382 = load double*, double** %22
%1383 = load i32, i32* @trfind_.n1
%1384 = sext i32 %1383 to i64
%1385 = getelementptr inbounds double, double* %1382, i64 %1384
%1386 = load double, double* %1385
%1387 = load double, double* @trfind_.s12
%1388 = load double*, double** %22
%1389 = load i32, i32* @trfind_.n2
%1390 = sext i32 %1389 to i64
%1391 = getelementptr inbounds double, double* %1388, i64 %1390
%1392 = load double, double* %1391
%1393 = fneg double %1387
%1394 = call double @llvm.fmuladd.f64(double %1393, double %1392, double %1386)
store double %1394, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 2)
%1395 = load double, double* @trfind_.xp
%1396 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 0)
%1397 = load double, double* @trfind_.yp
%1398 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 1)
%1399 = fmul double %1397, %1398
%1400 = call double @llvm.fmuladd.f64(double %1395, double %1396, double %1399)
%1401 = load double, double* @trfind_.zp
%1402 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 2)
%1403 = call double @llvm.fmuladd.f64(double %1401, double %1402, double %1400)
%1404 = fcmp oge double %1403, 0.000000e+00
br i1 %1404, label %1405, label %1406
1405: ; preds = %1322
br label %1445
1406: ; preds = %1322
%1407 = load double*, double** %20
%1408 = load i32, i32* @trfind_.next
%1409 = sext i32 %1408 to i64
%1410 = getelementptr inbounds double, double* %1407, i64 %1409
%1411 = load double, double* %1410
%1412 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 0)
%1413 = load double*, double** %21
%1414 = load i32, i32* @trfind_.next
%1415 = sext i32 %1414 to i64
%1416 = getelementptr inbounds double, double* %1413, i64 %1415
%1417 = load double, double* %1416
%1418 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 1)
%1419 = fmul double %1417, %1418
%1420 = call double @llvm.fmuladd.f64(double %1411, double %1412, double %1419)
%1421 = load double*, double** %22
%1422 = load i32, i32* @trfind_.next
%1423 = sext i32 %1422 to i64
%1424 = getelementptr inbounds double, double* %1421, i64 %1423
%1425 = load double, double* %1424
%1426 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 2)
%1427 = call double @llvm.fmuladd.f64(double %1425, double %1426, double %1420)
%1428 = fcmp oge double %1427, 0.000000e+00
br i1 %1428, label %1429, label %1430
1429: ; preds = %1406
br label %1445
1430: ; preds = %1406
%1431 = load i32, i32* @trfind_.n2
store i32 %1431, i32* @trfind_.nl
br label %1432
1432: ; preds = %1430, %1229
%1433 = load i32, i32* @trfind_.n2
store i32 %1433, i32* @trfind_.n1
%1434 = load i32, i32* @trfind_.next
store i32 %1434, i32* @trfind_.n2
%1435 = load i32, i32* @trfind_.n2
%1436 = load i32, i32* @trfind_.n1s
%1437 = icmp ne i32 %1435, %1436
br i1 %1437, label %1438, label %1439
1438: ; preds = %1432
br label %1229
1439: ; preds = %1432
%1440 = load i32, i32* @trfind_.n1s
%1441 = load i32*, i32** %29
store i32 %1440, i32* %1441
%1442 = load i32, i32* @trfind_.n1s
%1443 = load i32*, i32** %30
store i32 %1442, i32* %1443
%1444 = load i32*, i32** %31
store i32 0, i32* %1444
store i32 0, i32* %16
br label %1676
1445: ; preds = %1429, %1405
%1446 = load i32, i32* @trfind_.n2
store i32 %1446, i32* @trfind_.nf
%1447 = load i32, i32* @trfind_.nl
%1448 = icmp eq i32 %1447, 0
br i1 %1448, label %1449, label %1666
1449: ; preds = %1445
%1450 = load i32, i32* @trfind_.n2s
store i32 %1450, i32* @trfind_.n2
%1451 = load i32, i32* @trfind_.n1s
store i32 %1451, i32* @trfind_.n1
br label %1452
1452: ; preds = %1657, %1449
%1453 = load i32*, i32** %25
%1454 = load i32, i32* @trfind_.n1
%1455 = sext i32 %1454 to i64
%1456 = getelementptr inbounds i32, i32* %1453, i64 %1455
%1457 = load i32, i32* %1456
store i32 %1457, i32* @trfind_.lp
%1458 = load i32*, i32** %23
%1459 = load i32, i32* @trfind_.lp
%1460 = sext i32 %1459 to i64
%1461 = getelementptr inbounds i32, i32* %1458, i64 %1460
%1462 = load i32, i32* %1461
%1463 = sub nsw i32 0, %1462
store i32 %1463, i32* @trfind_.next
%1464 = load double, double* @trfind_.xp
%1465 = load double*, double** %21
%1466 = load i32, i32* @trfind_.next
%1467 = sext i32 %1466 to i64
%1468 = getelementptr inbounds double, double* %1465, i64 %1467
%1469 = load double, double* %1468
%1470 = load double*, double** %22
%1471 = load i32, i32* @trfind_.n1
%1472 = sext i32 %1471 to i64
%1473 = getelementptr inbounds double, double* %1470, i64 %1472
%1474 = load double, double* %1473
%1475 = load double*, double** %21
%1476 = load i32, i32* @trfind_.n1
%1477 = sext i32 %1476 to i64
%1478 = getelementptr inbounds double, double* %1475, i64 %1477
%1479 = load double, double* %1478
%1480 = load double*, double** %22
%1481 = load i32, i32* @trfind_.next
%1482 = sext i32 %1481 to i64
%1483 = getelementptr inbounds double, double* %1480, i64 %1482
%1484 = load double, double* %1483
%1485 = fmul double %1479, %1484
%1486 = fneg double %1485
%1487 = call double @llvm.fmuladd.f64(double %1469, double %1474, double %1486)
%1488 = load double, double* @trfind_.yp
%1489 = load double*, double** %20
%1490 = load i32, i32* @trfind_.next
%1491 = sext i32 %1490 to i64
%1492 = getelementptr inbounds double, double* %1489, i64 %1491
%1493 = load double, double* %1492
%1494 = load double*, double** %22
%1495 = load i32, i32* @trfind_.n1
%1496 = sext i32 %1495 to i64
%1497 = getelementptr inbounds double, double* %1494, i64 %1496
%1498 = load double, double* %1497
%1499 = load double*, double** %20
%1500 = load i32, i32* @trfind_.n1
%1501 = sext i32 %1500 to i64
%1502 = getelementptr inbounds double, double* %1499, i64 %1501
%1503 = load double, double* %1502
%1504 = load double*, double** %22
%1505 = load i32, i32* @trfind_.next
%1506 = sext i32 %1505 to i64
%1507 = getelementptr inbounds double, double* %1504, i64 %1506
%1508 = load double, double* %1507
%1509 = fmul double %1503, %1508
%1510 = fneg double %1509
%1511 = call double @llvm.fmuladd.f64(double %1493, double %1498, double %1510)
%1512 = fmul double %1488, %1511
%1513 = fneg double %1512
%1514 = call double @llvm.fmuladd.f64(double %1464, double %1487, double %1513)
%1515 = load double, double* @trfind_.zp
%1516 = load double*, double** %20
%1517 = load i32, i32* @trfind_.next
%1518 = sext i32 %1517 to i64
%1519 = getelementptr inbounds double, double* %1516, i64 %1518
%1520 = load double, double* %1519
%1521 = load double*, double** %21
%1522 = load i32, i32* @trfind_.n1
%1523 = sext i32 %1522 to i64
%1524 = getelementptr inbounds double, double* %1521, i64 %1523
%1525 = load double, double* %1524
%1526 = load double*, double** %20
%1527 = load i32, i32* @trfind_.n1
%1528 = sext i32 %1527 to i64
%1529 = getelementptr inbounds double, double* %1526, i64 %1528
%1530 = load double, double* %1529
%1531 = load double*, double** %21
%1532 = load i32, i32* @trfind_.next
%1533 = sext i32 %1532 to i64
%1534 = getelementptr inbounds double, double* %1531, i64 %1533
%1535 = load double, double* %1534
%1536 = fmul double %1530, %1535
%1537 = fneg double %1536
%1538 = call double @llvm.fmuladd.f64(double %1520, double %1525, double %1537)
%1539 = call double @llvm.fmuladd.f64(double %1515, double %1538, double %1514)
%1540 = fcmp oge double %1539, 0.000000e+00
br i1 %1540, label %1541, label %1651
1541: ; preds = %1452
%1542 = load double*, double** %20
%1543 = load i32, i32* @trfind_.n1
%1544 = sext i32 %1543 to i64
%1545 = getelementptr inbounds double, double* %1542, i64 %1544
%1546 = load double, double* %1545
%1547 = load double*, double** %20
%1548 = load i32, i32* @trfind_.n2
%1549 = sext i32 %1548 to i64
%1550 = getelementptr inbounds double, double* %1547, i64 %1549
%1551 = load double, double* %1550
%1552 = load double*, double** %21
%1553 = load i32, i32* @trfind_.n1
%1554 = sext i32 %1553 to i64
%1555 = getelementptr inbounds double, double* %1552, i64 %1554
%1556 = load double, double* %1555
%1557 = load double*, double** %21
%1558 = load i32, i32* @trfind_.n2
%1559 = sext i32 %1558 to i64
%1560 = getelementptr inbounds double, double* %1557, i64 %1559
%1561 = load double, double* %1560
%1562 = fmul double %1556, %1561
%1563 = call double @llvm.fmuladd.f64(double %1546, double %1551, double %1562)
%1564 = load double*, double** %22
%1565 = load i32, i32* @trfind_.n1
%1566 = sext i32 %1565 to i64
%1567 = getelementptr inbounds double, double* %1564, i64 %1566
%1568 = load double, double* %1567
%1569 = load double*, double** %22
%1570 = load i32, i32* @trfind_.n2
%1571 = sext i32 %1570 to i64
%1572 = getelementptr inbounds double, double* %1569, i64 %1571
%1573 = load double, double* %1572
%1574 = call double @llvm.fmuladd.f64(double %1568, double %1573, double %1563)
store double %1574, double* @trfind_.s12
%1575 = load double*, double** %20
%1576 = load i32, i32* @trfind_.n2
%1577 = sext i32 %1576 to i64
%1578 = getelementptr inbounds double, double* %1575, i64 %1577
%1579 = load double, double* %1578
%1580 = load double, double* @trfind_.s12
%1581 = load double*, double** %20
%1582 = load i32, i32* @trfind_.n1
%1583 = sext i32 %1582 to i64
%1584 = getelementptr inbounds double, double* %1581, i64 %1583
%1585 = load double, double* %1584
%1586 = fneg double %1580
%1587 = call double @llvm.fmuladd.f64(double %1586, double %1585, double %1579)
store double %1587, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 0)
%1588 = load double*, double** %21
%1589 = load i32, i32* @trfind_.n2
%1590 = sext i32 %1589 to i64
%1591 = getelementptr inbounds double, double* %1588, i64 %1590
%1592 = load double, double* %1591
%1593 = load double, double* @trfind_.s12
%1594 = load double*, double** %21
%1595 = load i32, i32* @trfind_.n1
%1596 = sext i32 %1595 to i64
%1597 = getelementptr inbounds double, double* %1594, i64 %1596
%1598 = load double, double* %1597
%1599 = fneg double %1593
%1600 = call double @llvm.fmuladd.f64(double %1599, double %1598, double %1592)
store double %1600, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 1)
%1601 = load double*, double** %22
%1602 = load i32, i32* @trfind_.n2
%1603 = sext i32 %1602 to i64
%1604 = getelementptr inbounds double, double* %1601, i64 %1603
%1605 = load double, double* %1604
%1606 = load double, double* @trfind_.s12
%1607 = load double*, double** %22
%1608 = load i32, i32* @trfind_.n1
%1609 = sext i32 %1608 to i64
%1610 = getelementptr inbounds double, double* %1607, i64 %1609
%1611 = load double, double* %1610
%1612 = fneg double %1606
%1613 = call double @llvm.fmuladd.f64(double %1612, double %1611, double %1605)
store double %1613, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 2)
%1614 = load double, double* @trfind_.xp
%1615 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 0)
%1616 = load double, double* @trfind_.yp
%1617 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 1)
%1618 = fmul double %1616, %1617
%1619 = call double @llvm.fmuladd.f64(double %1614, double %1615, double %1618)
%1620 = load double, double* @trfind_.zp
%1621 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 2)
%1622 = call double @llvm.fmuladd.f64(double %1620, double %1621, double %1619)
%1623 = fcmp oge double %1622, 0.000000e+00
br i1 %1623, label %1624, label %1625
1624: ; preds = %1541
br label %1664
1625: ; preds = %1541
%1626 = load double*, double** %20
%1627 = load i32, i32* @trfind_.next
%1628 = sext i32 %1627 to i64
%1629 = getelementptr inbounds double, double* %1626, i64 %1628
%1630 = load double, double* %1629
%1631 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 0)
%1632 = load double*, double** %21
%1633 = load i32, i32* @trfind_.next
%1634 = sext i32 %1633 to i64
%1635 = getelementptr inbounds double, double* %1632, i64 %1634
%1636 = load double, double* %1635
%1637 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 1)
%1638 = fmul double %1636, %1637
%1639 = call double @llvm.fmuladd.f64(double %1630, double %1631, double %1638)
%1640 = load double*, double** %22
%1641 = load i32, i32* @trfind_.next
%1642 = sext i32 %1641 to i64
%1643 = getelementptr inbounds double, double* %1640, i64 %1642
%1644 = load double, double* %1643
%1645 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @trfind_.q, i64 0, i64 2)
%1646 = call double @llvm.fmuladd.f64(double %1644, double %1645, double %1639)
%1647 = fcmp oge double %1646, 0.000000e+00
br i1 %1647, label %1648, label %1649
1648: ; preds = %1625
br label %1664
1649: ; preds = %1625
%1650 = load i32, i32* @trfind_.n1
store i32 %1650, i32* @trfind_.nf
br label %1651
1651: ; preds = %1649, %1452
%1652 = load i32, i32* @trfind_.n1
store i32 %1652, i32* @trfind_.n2
%1653 = load i32, i32* @trfind_.next
store i32 %1653, i32* @trfind_.n1
%1654 = load i32, i32* @trfind_.n1
%1655 = load i32, i32* @trfind_.n1s
%1656 = icmp ne i32 %1654, %1655
br i1 %1656, label %1657, label %1658
1657: ; preds = %1651
br label %1452
1658: ; preds = %1651
%1659 = load i32, i32* @trfind_.n1
%1660 = load i32*, i32** %29
store i32 %1659, i32* %1660
%1661 = load i32, i32* @trfind_.n1
%1662 = load i32*, i32** %30
store i32 %1661, i32* %1662
%1663 = load i32*, i32** %31
store i32 0, i32* %1663
store i32 0, i32* %16
br label %1676
1664: ; preds = %1648, %1624
%1665 = load i32, i32* @trfind_.n1
store i32 %1665, i32* @trfind_.nl
br label %1666
1666: ; preds = %1664, %1445
%1667 = load i32, i32* @trfind_.nf
%1668 = load i32*, i32** %29
store i32 %1667, i32* %1668
%1669 = load i32, i32* @trfind_.nl
%1670 = load i32*, i32** %30
store i32 %1669, i32* %1670
%1671 = load i32*, i32** %31
store i32 0, i32* %1671
store i32 0, i32* %16
br label %1676
1672: ; preds = %693
%1673 = load i32*, i32** %29
store i32 0, i32* %1673
%1674 = load i32*, i32** %30
store i32 0, i32* %1674
%1675 = load i32*, i32** %31
store i32 0, i32* %1675
store i32 0, i32* %16
br label %1676
1676: ; preds = %1672, %1666, %1658, %1439, %1225
%1677 = load i32, i32* %16
ret i32 %1677
}

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