void trsbox_(int n, int npt, double *xpt, double *xopt, double *gopt,
             double *hq, double *pq, double *sl, double *su, double delta,
             double *xnew, double *d, double *gnew, double *xbdi, double *s,
             double *hs, double *hred, double *dsq, double *crvmin) {
  int xpt_offset;
  int i, j, k, ih;
  double ds;
  int iu;
  double dhd, dhs, cth, shs, sth, ssq, beta, sdec, blen;
  int iact, nact;
  double angt, qred;
  int isav;
  double temp, xsav, xsum, angbd, dredg, sredg;
  int iterc;
  double resid, delsq, ggsav, tempa, tempb, ratio, sqstp, redmax, dredsq,
      redsav, gredsq, rednew;
  int itcsav;
  double rdprev, rdnext, stplen, stepsq;
  int itermax;
  const double half = .5;
  const double one = 1.;
  const double onemin = -1.;
  const double zero = 0.;
  iterc = 0;
  nact = 0;
  sqstp = 0;
  for (i = 0; i < n; ++i) {
    xbdi[i] = 0;
    if (xopt[i] <= sl[i]) {
      if (gopt[i] >= 0) {
        xbdi[i] = onemin;
      }
    } else if (xopt[i] >= su[i]) {
      if (gopt[i] <= 0) {
        xbdi[i] = one;
      }
    }
    if (xbdi[i] != 0) {
      ++nact;
    }
    d[i] = 0;
    gnew[i] = gopt[i];
  }
  delsq = delta * delta;
  qred = zero;
  *crvmin = onemin;
  xpt_offset = 1 + npt;
  xpt -= xpt_offset;
  --xopt;
  --gopt;
  --hq;
  --pq;
  --sl;
  --su;
  --xnew;
  --d;
  --gnew;
  --xbdi;
  --s;
  --hs;
  --hred;
L20:
  beta = zero;
L30:
  stepsq = zero;
  for (i = 1; i <= n; ++i) {
    if (xbdi[i] != zero) {
      s[i] = zero;
    } else if (beta == zero) {
      s[i] = -gnew[i];
    } else {
      s[i] = beta * s[i] - gnew[i];
    }
    stepsq += s[i] * s[i];
  }
  if (stepsq == zero) {
    goto L190;
  }
  if (beta == zero) {
    gredsq = stepsq;
    itermax = iterc + n - nact;
  }
  if (gredsq * delsq <= qred * 1e-4 * qred) {
    goto L190;
  }
  goto L210;
L50:
  resid = delsq;
  ds = zero;
  shs = zero;
  for (i = 1; i <= n; ++i) {
    if (xbdi[i] == zero) {
      resid -= d[i] * d[i];
      ds += s[i] * d[i];
      shs += s[i] * hs[i];
    }
  }
  if (resid <= zero) {
    goto L90;
  }
  temp = sqrt(stepsq * resid + ds * ds);
  if (ds < zero) {
    blen = (temp - ds) / stepsq;
  } else {
    blen = resid / (temp + ds);
  }
  stplen = blen;
  if (shs > zero) {
    stplen = gredsq / shs;
    if (blen < stplen) {
      stplen = blen;
    }
  }
  iact = 0;
  for (i = 1; i <= n; ++i) {
    if (s[i] != 0) {
      xsum = xopt[i] + d[i];
      if (s[i] > zero) {
        temp = (su[i] - xsum) / s[i];
      } else {
        temp = (sl[i] - xsum) / s[i];
      }
      if (temp < stplen) {
        stplen = temp;
        iact = i;
      }
    }
  }
  sdec = zero;
  if (stplen > zero) {
    ++iterc;
    temp = shs / stepsq;
    if (iact == 0 && temp > zero) {
      if (temp < *crvmin) {
        *crvmin = temp;
      }
      if (*crvmin == onemin) {
        *crvmin = temp;
      }
    }
    ggsav = gredsq;
    gredsq = zero;
    for (i = 1; i <= n; ++i) {
      gnew[i] += stplen * hs[i];
      if (xbdi[i] == zero) {
        gredsq += gnew[i] * gnew[i];
      }
      d[i] += stplen * s[i];
    }
    sdec = stplen * (ggsav - half * stplen * shs);
    if (sdec < 0) {
      sdec = 0;
    }
    qred += sdec;
  }
  if (iact > 0) {
    ++nact;
    xbdi[iact] = one;
    if (s[iact] < zero) {
      xbdi[iact] = onemin;
    }
    delsq -= d[iact] * d[iact];
    if (delsq <= zero) {
      goto L90;
    }
    goto L20;
  }
  if (stplen < blen) {
    if (iterc == itermax) {
      goto L190;
    }
    if (sdec <= qred * .01) {
      goto L190;
    }
    beta = gredsq / ggsav;
    goto L30;
  }
L90:
  *crvmin = zero;
L100:
  if (nact >= n - 1) {
    goto L190;
  }
  dredsq = 0;
  dredg = 0;
  gredsq = 0;
  for (i = 1; i <= n; ++i) {
    if (xbdi[i] == 0) {
      dredsq += d[i] * d[i];
      dredg += d[i] * gnew[i];
      gredsq += gnew[i] * gnew[i];
      s[i] = d[i];
    } else {
      s[i] = zero;
    }
  }
  itcsav = iterc;
  goto L210;
L120:
  ++iterc;
  temp = gredsq * dredsq - dredg * dredg;
  if (temp <= qred * 1e-4 * qred) {
    goto L190;
  }
  temp = sqrt(temp);
  for (i = 1; i <= n; ++i) {
    if (xbdi[i] == zero) {
      s[i] = (dredg * d[i] - dredsq * gnew[i]) / temp;
    } else {
      s[i] = zero;
    }
  }
  sredg = -temp;
  angbd = one;
  iact = 0;
  for (i = 1; i <= n; ++i) {
    if (xbdi[i] == zero) {
      tempa = xopt[i] + d[i] - sl[i];
      tempb = su[i] - xopt[i] - d[i];
      if (tempa <= zero) {
        ++nact;
        xbdi[i] = onemin;
        goto L100;
      } else if (tempb <= zero) {
        ++nact;
        xbdi[i] = one;
        goto L100;
      }
      ratio = one;
      ssq = d[i] * d[i] + s[i] * s[i];
      temp = ssq - (xopt[i] - sl[i]) * (xopt[i] - sl[i]);
      if (temp > zero) {
        temp = sqrt(temp) - s[i];
        if (angbd * temp > tempa) {
          angbd = tempa / temp;
          iact = i;
          xsav = onemin;
        }
      }
      temp = ssq - (su[i] - xopt[i]) * (su[i] - xopt[i]);
      if (temp > zero) {
        temp = sqrt(temp) + s[i];
        if (angbd * temp > tempb) {
          angbd = tempb / temp;
          iact = i;
          xsav = one;
        }
      }
    }
  }
  goto L210;
L150:
  shs = zero;
  dhs = zero;
  dhd = zero;
  for (i = 1; i <= n; ++i) {
    if (xbdi[i] == zero) {
      shs += s[i] * hs[i];
      dhs += d[i] * hs[i];
      dhd += d[i] * hred[i];
    }
  }
  redmax = zero;
  isav = 0;
  redsav = zero;
  iu = (int)(angbd * 17. + 3.1);
  for (i = 1; i <= iu; ++i) {
    angt = angbd * (double)i / (double)iu;
    sth = (angt + angt) / (one + angt * angt);
    temp = shs + angt * (angt * dhd - dhs - dhs);
    rednew = sth * (angt * dredg - sredg - half * sth * temp);
    if (rednew > redmax) {
      redmax = rednew;
      isav = i;
      rdprev = redsav;
    } else if (i == isav + 1) {
      rdnext = rednew;
    }
    redsav = rednew;
  }
  if (isav == 0) {
    goto L190;
  }
  if (isav < iu) {
    temp = (rdnext - rdprev) / (redmax + redmax - rdprev - rdnext);
    angt = angbd * ((double)isav + half * temp) / (double)iu;
  }
  cth = (one - angt * angt) / (one + angt * angt);
  sth = (angt + angt) / (one + angt * angt);
  temp = shs + angt * (angt * dhd - dhs - dhs);
  sdec = sth * (angt * dredg - sredg - half * sth * temp);
  if (sdec <= zero) {
    goto L190;
  }
  dredg = zero;
  gredsq = zero;
  for (i = 1; i <= n; ++i) {
    gnew[i] = gnew[i] + (cth - one) * hred[i] + sth * hs[i];
    if (xbdi[i] == zero) {
      d[i] = cth * d[i] + sth * s[i];
      dredg += d[i] * gnew[i];
      gredsq += gnew[i] * gnew[i];
    }
    hred[i] = cth * hred[i] + sth * hs[i];
  }
  qred += sdec;
  if (iact > 0 && isav == iu) {
    ++nact;
    xbdi[iact] = xsav;
    goto L100;
  }
  if (sdec > qred * .01) {
    goto L120;
  }
L190:
  *dsq = zero;
  for (i = 1; i <= n; ++i) {
    xnew[i] = xopt[i] + d[i];
    if (su[i] < xnew[i]) {
      xnew[i] = su[i];
    }
    if (sl[i] > xnew[i]) {
      xnew[i] = sl[i];
    }
    if (xbdi[i] == onemin) {
      xnew[i] = sl[i];
    }
    if (xbdi[i] == one) {
      xnew[i] = su[i];
    }
    d[i] = xnew[i] - xopt[i];
    *dsq += d[i] * d[i];
  }
  return;
L210:
  ih = 0;
  for (j = 1; j <= n; ++j) {
    hs[j] = zero;
    for (i = 1; i <= j; ++i) {
      ++ih;
      if (i < j) {
        hs[j] += hq[ih] * s[i];
      }
      hs[i] += hq[ih] * s[j];
    }
  }
  for (k = 1; k <= npt; ++k) {
    if (pq[k] != zero) {
      temp = zero;
      for (j = 1; j <= n; ++j) {
        temp += xpt[k + j * npt] * s[j];
      }
      temp *= pq[k];
      for (i = 1; i <= n; ++i) {
        hs[i] += temp * xpt[k + i * npt];
      }
    }
  }
  if (*crvmin != zero) {
    goto L50;
  }
  if (iterc > itcsav) {
    goto L150;
  }
  for (i = 1; i <= n; ++i) {
    hred[i] = hs[i];
  }
  goto L120;
}


x86 assembly (clang, -O0):
<trsbox_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1b0,%rsp
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  0x1ea2(%rip),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  0x1e8a(%rip),%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  0x1e72(%rip),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movl   $0x0,-0xf4(%rbp)
movl   $0x0,-0xa8(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12fc <trsbox_+0x1ec>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     123b <trsbox_+0x12b>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1236 <trsbox_+0x126>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  0x1dcf(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1290 <trsbox_+0x180>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     128b <trsbox_+0x17b>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     1286 <trsbox_+0x176>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  0x1d87(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    128b <trsbox_+0x17b>
jmp    1290 <trsbox_+0x180>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12b5 <trsbox_+0x1a5>
jp     12b5 <trsbox_+0x1a5>
jmp    12c4 <trsbox_+0x1b4>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11c7 <trsbox_+0xb7>
movsd  -0x30(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    0x68(%rbp),%rax
movsd  0x1cdb(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x10(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x18(%rbp)
mov    0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x20(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rbp)
mov    0x48(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x48(%rbp)
mov    0x50(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x50(%rbp)
mov    0x58(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     152f <trsbox_+0x41f>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1436 <trsbox_+0x326>
jp     1436 <trsbox_+0x326>
jmp    144b <trsbox_+0x33b>
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    14ef <trsbox_+0x3df>
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    149c <trsbox_+0x38c>
jp     149c <trsbox_+0x38c>
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    14ea <trsbox_+0x3da>
movsd  -0x90(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    14ef <trsbox_+0x3df>
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x180(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1405 <trsbox_+0x2f5>
movsd  -0x180(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    154f <trsbox_+0x43f>
jp     154f <trsbox_+0x43f>
jmp    29d6 <trsbox_+0x18c6>
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    158f <trsbox_+0x47f>
jp     158f <trsbox_+0x47f>
movsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0xf4(%rbp),%eax
add    -0x4(%rbp),%eax
sub    -0xa8(%rbp),%eax
mov    %eax,-0x184(%rbp)
movsd  -0x150(%rbp),%xmm1
ff
mulsd  -0x108(%rbp),%xmm1
ff
movsd  0x1a71(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     15c6 <trsbox_+0x4b6>
jmp    29d6 <trsbox_+0x18c6>
jmp    2b7d <trsbox_+0x1a6d>
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     16d2 <trsbox_+0x5c2>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16bf <trsbox_+0x5af>
jp     16bf <trsbox_+0x5af>
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x100(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    16c4 <trsbox_+0x5b4>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15f2 <trsbox_+0x4e2>
xorps  %xmm0,%xmm0
ucomisd -0x100(%rbp),%xmm0
ff
jb     16e8 <trsbox_+0x5d8>
jmp    1c6e <trsbox_+0xb5e>
movsd  -0x180(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    1747 <trsbox_+0x637>
movsd  -0xc8(%rbp),%xmm0
ff
subsd  -0x50(%rbp),%xmm0
divsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1768 <trsbox_+0x658>
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm1
ff
addsd  -0x50(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    17ce <trsbox_+0x6be>
movsd  -0x150(%rbp),%xmm0
ff
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x178(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    17c9 <trsbox_+0x6b9>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
jmp    17ce <trsbox_+0x6be>
movl   $0x0,-0xa4(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     18f0 <trsbox_+0x7e0>
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1810 <trsbox_+0x700>
jp     1810 <trsbox_+0x700>
jmp    18dd <trsbox_+0x7cd>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    187b <trsbox_+0x76b>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xd8(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    18a5 <trsbox_+0x795>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xd8(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x178(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    18d8 <trsbox_+0x7c8>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    18dd <trsbox_+0x7cd>
jmp    18e2 <trsbox_+0x7d2>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17df <trsbox_+0x6cf>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b25 <trsbox_+0xa15>
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
movsd  -0x78(%rbp),%xmm0
divsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
cmpl   $0x0,-0xa4(%rbp)
jne    19b5 <trsbox_+0x8a5>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    19b5 <trsbox_+0x8a5>
movsd  -0xc8(%rbp),%xmm1
ff
mov    0x68(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1980 <trsbox_+0x870>
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x68(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0x1670(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    19b0 <trsbox_+0x8a0>
jp     19b0 <trsbox_+0x8a0>
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    19b5 <trsbox_+0x8a5>
movsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1aa1 <trsbox_+0x991>
movsd  -0x178(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1a64 <trsbox_+0x954>
jp     1a64 <trsbox_+0x954>
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x150(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19d7 <trsbox_+0x8c7>
movsd  -0x178(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  0x1557(%rip),%xmm1
mulsd  -0x178(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jbe    1b0d <trsbox_+0x9fd>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
cmpl   $0x0,-0xa4(%rbp)
jle    1bf4 <trsbox_+0xae4>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    0x40(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  0x14b4(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
movslq -0xa4(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1b8a <trsbox_+0xa7a>
mov    0x40(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  0x147b(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x108(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x108(%rbp),%xmm0
ff
jb     1bef <trsbox_+0xadf>
jmp    1c6e <trsbox_+0xb5e>
jmp    13e8 <trsbox_+0x2d8>
movsd  -0x178(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1c69 <trsbox_+0xb59>
mov    -0xf4(%rbp),%eax
cmp    -0x184(%rbp),%eax
jne    1c25 <trsbox_+0xb15>
jmp    29d6 <trsbox_+0x18c6>
movsd  -0x98(%rbp),%xmm1
ff
movsd  0x13fb(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1c4c <trsbox_+0xb3c>
jmp    29d6 <trsbox_+0x18c6>
movsd  -0x150(%rbp),%xmm0
ff
divsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    13f3 <trsbox_+0x2e3>
jmp    1c6e <trsbox_+0xb5e>
mov    0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0xa8(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     1c92 <trsbox_+0xb82>
jmp    29d6 <trsbox_+0x18c6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1dbe <trsbox_+0xcae>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1d9b <trsbox_+0xc8b>
jp     1d9b <trsbox_+0xc8b>
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x140(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xe8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x150(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1dab <trsbox_+0xc9b>
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1db0 <trsbox_+0xca0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1cba <trsbox_+0xbaa>
mov    -0xf4(%rbp),%eax
mov    %eax,-0x15c(%rbp)
jmp    2b7d <trsbox_+0x1a6d>
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
movsd  -0x150(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm1
ff
mulsd  -0xe8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm1
ff
movsd  0x11e3(%rip),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1e54 <trsbox_+0xd44>
jmp    29d6 <trsbox_+0x18c6>
movsd  -0xc8(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1f22 <trsbox_+0xe12>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1eff <trsbox_+0xdef>
jp     1eff <trsbox_+0xdef>
movsd  -0xe8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x140(%rbp),%xmm1
ff
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0xc8(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f0f <trsbox_+0xdff>
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f14 <trsbox_+0xe04>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1e70 <trsbox_+0xd60>
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  0x10b7(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movl   $0x0,-0xa4(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     22b5 <trsbox_+0x11a5>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    22a2 <trsbox_+0x1192>
jp     22a2 <trsbox_+0x1192>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x118(%rbp),%xmm0
ff
jb     202e <trsbox_+0xf1e>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  0xfdc(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c79 <trsbox_+0xb69>
xorps  %xmm0,%xmm0
ucomisd -0x120(%rbp),%xmm0
ff
jb     2068 <trsbox_+0xf58>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  0xfaa(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c79 <trsbox_+0xb69>
jmp    206d <trsbox_+0xf5d>
movsd  0xf93(%rip),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    21af <trsbox_+0x109f>
movsd  -0xc8(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
ucomisd -0x118(%rbp),%xmm0
ff
jbe    21aa <trsbox_+0x109a>
movsd  -0x118(%rbp),%xmm0
ff
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0xa4(%rbp)
movsd  0xe5e(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    21af <trsbox_+0x109f>
movsd  -0x88(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    229d <trsbox_+0x118d>
movsd  -0xc8(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
ucomisd -0x120(%rbp),%xmm0
ff
jbe    2298 <trsbox_+0x1188>
movsd  -0x120(%rbp),%xmm0
ff
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0xa4(%rbp)
movsd  0xd78(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    229d <trsbox_+0x118d>
jmp    22a2 <trsbox_+0x1192>
jmp    22a7 <trsbox_+0x1197>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1f6a <trsbox_+0xe5a>
jmp    2b7d <trsbox_+0x1a6d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     239c <trsbox_+0x128c>
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2389 <trsbox_+0x1279>
jp     2389 <trsbox_+0x1279>
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    238e <trsbox_+0x127e>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    22d9 <trsbox_+0x11c9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0xbc(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  0xc54(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc50(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x54(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     25ab <trsbox_+0x149b>
movsd  -0xe0(%rbp),%xmm0
ff
cvtsi2sdl -0x38(%rbp),%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x54(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
movsd  0xbc4(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm4
movsd  -0x68(%rbp),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
subsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0xb28(%rip),%xmm1
mulsd  -0x80(%rbp),%xmm1
movsd  -0xc8(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
ucomisd -0x138(%rbp),%xmm0
ff
jbe    2564 <trsbox_+0x1454>
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0xbc(%rbp)
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
jmp    258d <trsbox_+0x147d>
mov    -0x38(%rbp),%eax
mov    -0xbc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    2588 <trsbox_+0x1478>
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
jmp    258d <trsbox_+0x147d>
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    23ea <trsbox_+0x12da>
cmpl   $0x0,-0xbc(%rbp)
jne    25bd <trsbox_+0x14ad>
jmp    29d6 <trsbox_+0x18c6>
mov    -0xbc(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    2645 <trsbox_+0x1535>
movsd  -0x170(%rbp),%xmm0
ff
subsd  -0x168(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm1
ff
addsd  -0x138(%rbp),%xmm1
ff
subsd  -0x168(%rbp),%xmm1
ff
subsd  -0x170(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
cvtsi2sdl -0xbc(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
movsd  0x9e8(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsi2sdl -0x54(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x990(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
movsd  0x970(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
movsd  0x937(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm4
movsd  -0x68(%rbp),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
subsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm3
ff
movsd  -0xf0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x89b(%rip),%xmm1
mulsd  -0x80(%rbp),%xmm1
movsd  -0xc8(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x98(%rbp),%xmm0
ff
jb     27c3 <trsbox_+0x16b3>
jmp    29d6 <trsbox_+0x18c6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     294a <trsbox_+0x183a>
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x70(%rbp),%xmm1
movsd  0x802(%rip),%xmm2
subsd  %xmm2,%xmm1
mov    0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2903 <trsbox_+0x17f3>
jp     2903 <trsbox_+0x17f3>
movsd  -0x70(%rbp),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xe8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x150(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    27e0 <trsbox_+0x16d0>
movsd  -0x98(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
cmpl   $0x0,-0xa4(%rbp)
jle    29aa <trsbox_+0x189a>
mov    -0xbc(%rbp),%eax
cmp    -0x54(%rbp),%eax
jne    29aa <trsbox_+0x189a>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c79 <trsbox_+0xb69>
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x676(%rip),%xmm1
mulsd  -0xb8(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jbe    29d1 <trsbox_+0x18c1>
jmp    1dcf <trsbox_+0xcbf>
jmp    29d6 <trsbox_+0x18c6>
mov    0x60(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     2b74 <trsbox_+0x1a64>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    2a59 <trsbox_+0x1949>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    2a93 <trsbox_+0x1983>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x558(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2ad2 <trsbox_+0x19c2>
jp     2ad2 <trsbox_+0x19c2>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x521(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2b11 <trsbox_+0x1a01>
jp     2b11 <trsbox_+0x1a01>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    29e8 <trsbox_+0x18d8>
add    $0x1b0,%rsp
pop    %rbp
ret
movl   $0x0,-0x44(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     2c58 <trsbox_+0x1b48>
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     2c45 <trsbox_+0x1b35>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    2c03 <trsbox_+0x1af3>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2bae <trsbox_+0x1a9e>
jmp    2c4a <trsbox_+0x1b3a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2b8b <trsbox_+0x1a7b>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     2d89 <trsbox_+0x1c79>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2c90 <trsbox_+0x1b80>
jp     2c90 <trsbox_+0x1b80>
jmp    2d76 <trsbox_+0x1c66>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     2cf9 <trsbox_+0x1be9>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    2ca2 <trsbox_+0x1b92>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     2d71 <trsbox_+0x1c61>
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2d1d <trsbox_+0x1c0d>
jmp    2d76 <trsbox_+0x1c66>
jmp    2d7b <trsbox_+0x1c6b>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    2c5f <trsbox_+0x1b4f>
mov    0x68(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2da9 <trsbox_+0x1c99>
jp     2da9 <trsbox_+0x1c99>
jmp    2dae <trsbox_+0x1c9e>
jmp    15cb <trsbox_+0x4bb>
mov    -0xf4(%rbp),%eax
cmp    -0x15c(%rbp),%eax
jle    2dc5 <trsbox_+0x1cb5>
jmp    22ba <trsbox_+0x11aa>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     2e00 <trsbox_+0x1cf0>
mov    0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2dcc <trsbox_+0x1cbc>
jmp    1dcf <trsbox_+0xcbf>

x86 assembly (clang, -O2):
<trsbox_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
movsd  %xmm0,0x40(%rsp)
mov    %rcx,0x58(%rsp)
mov    %rdx,0x80(%rsp)
mov    %rsi,0x98(%rsp)
mov    0x210(%rsp),%r11
mov    0x208(%rsp),%rbp
mov    0x200(%rsp),%rsi
mov    0x1f0(%rsp),%r10
mov    0x1e8(%rsp),%r15
test   %edi,%edi
jle    1204 <trsbox_+0xf4>
mov    %rdi,%r14
mov    %edi,%eax
xor    %ecx,%ecx
movsd  0x1e8d(%rip),%xmm0
xorpd  %xmm1,%xmm1
movsd  0x1e79(%rip),%xmm2
xor    %ebx,%ebx
jmp    11ba <trsbox_+0xaa>
nopl   0x0(%rax,%rax,1)
movsd  %xmm3,(%r11,%rcx,8)
mov    $0x1,%edx
add    %edx,%ebx
movq   $0x0,(%rsi,%rcx,8)
movsd  (%r8,%rcx,8),%xmm3
movsd  %xmm3,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
je     1209 <trsbox_+0xf9>
movq   $0x0,(%r11,%rcx,8)
mov    0x58(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm3
movsd  (%r15,%rcx,8),%xmm4
ucomisd %xmm3,%xmm4
jae    11f0 <trsbox_+0xe0>
xor    %edx,%edx
ucomisd (%r10,%rcx,8),%xmm3
jb     119b <trsbox_+0x8b>
ucomisd (%r8,%rcx,8),%xmm1
movapd %xmm0,%xmm3
jae    1190 <trsbox_+0x80>
jmp    119b <trsbox_+0x8b>
movsd  (%r8,%rcx,8),%xmm3
xor    %edx,%edx
ucomisd %xmm1,%xmm3
movapd %xmm2,%xmm3
jae    1190 <trsbox_+0x80>
jmp    119b <trsbox_+0x8b>
mov    %rdi,%r14
xor    %ebx,%ebx
mov    %ebx,0x8(%rsp)
movabs $0xbff0000000000000,%rcx
mov    0x238(%rsp),%rax
mov    %rcx,(%rax)
mov    %r14,%rcx
test   %ecx,%ecx
jle    27d1 <trsbox_+0x16c1>
mov    0x228(%rsp),%rdx
mov    0x220(%rsp),%r12
mov    0x98(%rsp),%rdi
mov    %edi,%eax
not    %eax
cltq
lea    0x1(%rcx),%r8d
movslq %edi,%rdi
movsd  0x40(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x40(%rsp)
lea    -0x1(%r8),%r10
lea    -0x8(%r12,%r8,8),%r14
mov    %rcx,%r13
lea    -0x5(%r8),%rcx
mov    %rcx,0x158(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    $0x4,%r10
setae  %r15b
cmp    $0x1,%edi
sete   %bl
and    %r15b,%bl
mov    %bl,0xf(%rsp)
mov    %r10,%rbx
and    $0xfffffffffffffffc,%rbx
mov    %rbx,0xa0(%rsp)
mov    %r8,%rbx
neg    %rbx
mov    %rbx,0x188(%rsp)
mov    %r14,0x180(%rsp)
cmp    %rdx,%r14
seta   %bl
lea    (%rdx,%r8,8),%rdx
add    $0xfffffffffffffff8,%rdx
cmp    %r12,%rdx
seta   %dl
and    %bl,%dl
mov    %dl,0xe(%rsp)
mov    %ecx,%edx
and    $0x3,%edx
mov    %rdx,0xe8(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x150(%rsp)
lea    0x0(,%rax,8),%rcx
lea    (%rcx,%rdi,8),%rcx
add    $0x8,%rcx
mov    %rcx,0x170(%rsp)
mov    %rdi,%r15
shl    $0x4,%r15
mov    %r10,%r14
and    $0xfffffffffffffffe,%r14
neg    %r14
mov    0x80(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    %rdx,0xa8(%rsp)
lea    (%r15,%rax,8),%rdx
add    $0x8,%rdx
mov    %rdx,0x168(%rsp)
add    %rdi,%rax
lea    (%rcx,%rax,8),%rax
add    $0x18,%rax
mov    %r13,%rcx
mov    %rax,0x160(%rsp)
mov    %rdi,%rdx
shl    $0x5,%rdx
xorpd  %xmm13,%xmm13
mov    0x218(%rsp),%r13
lea    -0x1(%rcx),%eax
mov    %eax,0xbc(%rsp)
mov    0x98(%rsp),%rax
lea    0x1(%rax),%eax
mov    %rax,0x198(%rsp)
mov    0xa0(%rsp),%rax
add    $0x1,%rax
mov    %rax,0xf0(%rsp)
mov    %rdi,0xb0(%rsp)
lea    (%rdi,%rdi,1),%rax
mov    %rax,0x1a0(%rsp)
mov    %r8,%rdi
lea    -0x8(,%r8,8),%r8
ff
xor    %eax,%eax
mov    %rax,0x20(%rsp)
xorpd  %xmm14,%xmm14
xorpd  %xmm0,%xmm0
mov    %rdi,0x48(%rsp)
mov    %rdx,0x178(%rsp)
mov    %ebx,0x70(%rsp)
xor    %eax,%eax
xorpd  %xmm7,%xmm7
jmp    13fe <trsbox_+0x2ee>
nop
movq   $0x0,0x0(%r13,%rax,8)
xorpd  %xmm1,%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm7
add    $0x1,%rax
cmp    %rax,%r10
je     1450 <trsbox_+0x340>
movsd  (%r11,%rax,8),%xmm1
ucomisd %xmm13,%xmm1
jne    13e0 <trsbox_+0x2d0>
jp     13e0 <trsbox_+0x2d0>
ucomisd %xmm13,%xmm0
jne    142d <trsbox_+0x31d>
jp     142d <trsbox_+0x31d>
movsd  0x0(%rbp,%rax,8),%xmm1
xorpd  0x1c1c(%rip),%xmm1
movlpd %xmm1,0x0(%r13,%rax,8)
jmp    13ed <trsbox_+0x2dd>
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
subsd  0x0(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
jmp    13ed <trsbox_+0x2dd>
nopw   0x0(%rax,%rax,1)
ucomisd %xmm13,%xmm7
mov    %rcx,%rdx
jne    1460 <trsbox_+0x350>
jnp    27e5 <trsbox_+0x16d5>
mov    %edx,%eax
sub    0x8(%rsp),%eax
add    0x20(%rsp),%eax
ucomisd %xmm13,%xmm0
jne    1480 <trsbox_+0x370>
mov    0x54(%rsp),%ecx
jp     1484 <trsbox_+0x374>
movapd %xmm7,%xmm8
jmp    1484 <trsbox_+0x374>
xchg   %ax,%ax
mov    0x54(%rsp),%ecx
cmovne %ecx,%eax
cmovnp %eax,%ecx
mov    %ecx,0x54(%rsp)
movapd %xmm8,%xmm0
mulsd  0x40(%rsp),%xmm0
movapd %xmm14,%xmm1
mulsd  0x1b6a(%rip),%xmm1
mulsd  %xmm14,%xmm1
ucomisd %xmm0,%xmm1
movsd  %xmm7,0x60(%rsp)
mov    %r9,0x18(%rsp)
mov    %rdx,(%rsp)
mov    %r8,0x30(%rsp)
mov    %r10,0x10(%rsp)
jae    27e5 <trsbox_+0x16d5>
movapd 0x120(%rsp),%xmm0
xorpd  0x1b61(%rip),%xmm0
movapd %xmm0,0x110(%rsp)
mov    0x48(%rsp),%rbx
jmp    1517 <trsbox_+0x407>
nop
movl   $0x0,0x70(%rsp)
xorpd  0x1b3f(%rip),%xmm12
movsd  0x1aff(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
test   %edx,%edx
jg     1fb4 <trsbox_+0xea4>
test   %edx,%edx
jle    15a0 <trsbox_+0x490>
mov    $0x1,%eax
xor    %ecx,%ecx
jmp    153c <trsbox_+0x42c>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
add    %rsi,%rcx
cmp    %rbx,%rax
je     15a0 <trsbox_+0x490>
movq   $0x0,-0x8(%r12,%rax,8)
movslq %ecx,%rcx
lea    (%r9,%rcx,8),%rdx
xor    %edi,%edi
jmp    1570 <trsbox_+0x460>
movsd  (%rdx,%rdi,8),%xmm0
mulsd  -0x8(%r13,%rax,8),%xmm0
addsd  (%r12,%rdi,8),%xmm0
movsd  %xmm0,(%r12,%rdi,8)
mov    %rsi,%rdi
cmp    %rsi,%rax
je     1530 <trsbox_+0x420>
lea    0x1(%rdi),%rsi
cmp    %rax,%rsi
jae    1550 <trsbox_+0x440>
movsd  (%rdx,%rdi,8),%xmm0
mulsd  0x0(%r13,%rdi,8),%xmm0
addsd  -0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rax,8)
jmp    1550 <trsbox_+0x440>
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x0,0x98(%rsp)
mov    0x1e0(%rsp),%r10
jle    1850 <trsbox_+0x740>
mov    $0x1,%edi
mov    0x160(%rsp),%r8
mov    0x168(%rsp),%rdx
mov    0x170(%rsp),%rsi
xor    %r9d,%r9d
jmp    1602 <trsbox_+0x4f2>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x1,%r9
add    $0x8,%rsi
add    $0x8,%rdx
add    $0x8,%r8
cmp    0x198(%rsp),%rdi
je     1850 <trsbox_+0x740>
movsd  -0x8(%r10,%rdi,8),%xmm0
ucomisd %xmm13,%xmm0
jne    1612 <trsbox_+0x502>
jnp    15e0 <trsbox_+0x4d0>
cmpl   $0x0,(%rsp)
jle    15e0 <trsbox_+0x4d0>
cmpl   $0x2,0x48(%rsp)
jne    1630 <trsbox_+0x520>
xorpd  %xmm1,%xmm1
mov    $0x1,%ebx
jmp    1687 <trsbox_+0x577>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
mov    $0x1,%ebx
mov    0x80(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,1),%xmm2
mulsd  -0x8(%r13,%rbx,8),%xmm2
addsd  %xmm1,%xmm2
movsd  0x0(%rbp,%rdx,1),%xmm1
mulsd  0x0(%r13,%rbx,8),%xmm1
addsd  %xmm2,%xmm1
add    %r15,%rbp
lea    (%r14,%rbx,1),%rax
add    $0x2,%rax
add    $0x2,%rbx
cmp    $0x1,%rax
jne    1650 <trsbox_+0x540>
testb  $0x1,0x10(%rsp)
je     16b5 <trsbox_+0x5a5>
mov    %rbx,%rax
imul   0xb0(%rsp),%rax
add    %rdi,%rax
mov    0xa8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm2
mulsd  -0x8(%r13,%rbx,8),%xmm2
addsd  %xmm2,%xmm1
cmpl   $0x0,(%rsp)
jle    15e0 <trsbox_+0x4d0>
mulsd  %xmm1,%xmm0
mov    $0x1,%ebp
cmpb   $0x0,0xf(%rsp)
je     1780 <trsbox_+0x670>
mov    0x10(%rsp),%rax
add    %r9,%rax
mov    0x80(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
cmp    %r12,%rax
jbe    1702 <trsbox_+0x5f2>
mov    0x80(%rsp),%rax
lea    (%rax,%r9,8),%rax
cmp    0x180(%rsp),%rax
jb     1780 <trsbox_+0x670>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %r8,%rcx
xor    %ebp,%ebp
mov    0xa0(%rsp),%rax
mov    0x178(%rsp),%rbx
nop
movupd -0x10(%rcx),%xmm2
movupd (%rcx),%xmm3
movupd (%r12,%rbp,8),%xmm4
movupd 0x10(%r12,%rbp,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r12,%rbp,8)
movupd %xmm3,0x10(%r12,%rbp,8)
add    $0x4,%rbp
add    %rbx,%rcx
cmp    %rbp,%rax
jne    1720 <trsbox_+0x610>
mov    0xf0(%rsp),%rbp
cmp    %rax,0x10(%rsp)
je     15e0 <trsbox_+0x4d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbp,%rbx
testb  $0x1,0x48(%rsp)
jne    17bc <trsbox_+0x6ac>
mov    %rbp,%rax
imul   0xb0(%rsp),%rax
add    %rdi,%rax
mov    0xa8(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r12,%rbp,8),%xmm1
movsd  %xmm1,-0x8(%r12,%rbp,8)
lea    0x1(%rbp),%rbx
not    %rbp
cmp    0x188(%rsp),%rbp
je     15e0 <trsbox_+0x4d0>
mov    0xb0(%rsp),%rcx
mov    %rcx,%rax
imul   %rbx,%rax
mov    0xa8(%rsp),%r10
lea    (%r10,%rax,8),%rbp
lea    0x1(%rbx),%rax
imul   %rcx,%rax
lea    (%r10,%rax,8),%rcx
mov    0x1e0(%rsp),%r10
mov    %rdi,%rax
nop
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r12,%rbx,8),%xmm1
movsd  %xmm1,-0x8(%r12,%rbx,8)
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r12,%rbx,8),%xmm1
movsd  %xmm1,(%r12,%rbx,8)
add    $0x2,%rbx
add    0x1a0(%rsp),%rax
cmp    %rbx,0x48(%rsp)
jne    1800 <trsbox_+0x6f0>
jmp    15e0 <trsbox_+0x4d0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x238(%rsp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm13,%xmm0
jne    2290 <trsbox_+0x1180>
jp     2290 <trsbox_+0x1180>
mov    0x6c(%rsp),%eax
cmp    %eax,0x20(%rsp)
jle    1910 <trsbox_+0x800>
mov    (%rsp),%rdx
test   %edx,%edx
mov    0x200(%rsp),%rsi
mov    0x228(%rsp),%rbx
mov    0x30(%rsp),%r8
xorpd  %xmm11,%xmm11
xorpd  %xmm10,%xmm10
jle    196f <trsbox_+0x85f>
xor    %eax,%eax
mov    0x18(%rsp),%r9
mov    0x208(%rsp),%rbp
mov    0x10(%rsp),%r10
jmp    18cd <trsbox_+0x7bd>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %rax,%r10
je     1981 <trsbox_+0x871>
movsd  (%r11,%rax,8),%xmm2
ucomisd %xmm13,%xmm2
jne    18c0 <trsbox_+0x7b0>
jp     18c0 <trsbox_+0x7b0>
movsd  (%r12,%rax,8),%xmm2
movsd  0x0(%r13,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm10
movsd  (%rsi,%rax,8),%xmm3
unpcklpd %xmm3,%xmm3
movsd  (%rbx,%rax,8),%xmm4
unpcklpd %xmm2,%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm4,%xmm11
jmp    18c0 <trsbox_+0x7b0>
nop
mov    (%rsp),%rdx
test   %edx,%edx
mov    0x228(%rsp),%rsi
mov    0x30(%rsp),%r8
jle    1c74 <trsbox_+0xb64>
mov    0x10(%rsp),%r10
cmp    $0x4,%r10
setb   %al
or     0xe(%rsp),%al
mov    $0x1,%eax
mov    0x18(%rsp),%r9
mov    0x208(%rsp),%rbp
mov    0x48(%rsp),%rdi
jne    1dd0 <trsbox_+0xcc0>
cmpq   $0xc,0x158(%rsp)
jae    1cd7 <trsbox_+0xbc7>
mov    %rdx,%rbx
xor    %eax,%eax
jmp    1d54 <trsbox_+0xc44>
mov    0x18(%rsp),%r9
mov    0x208(%rsp),%rbp
mov    0x10(%rsp),%r10
movsd  0x28(%rsp),%xmm2
mulsd  0x1689(%rip),%xmm2
addsd  0x1689(%rip),%xmm2
cvttsd2si %xmm2,%eax
test   %eax,%eax
jle    27e5 <trsbox_+0x16d5>
movsd  %xmm14,0x38(%rsp)
xorps  %xmm8,%xmm8
cvtsi2sd %eax,%xmm8
movapd %xmm11,%xmm9
unpckhpd %xmm11,%xmm9
movapd %xmm12,%xmm7
movapd %xmm9,%xmm12
movapd 0x1671(%rip),%xmm0
xorpd  %xmm0,%xmm12
movapd %xmm7,%xmm14
xorpd  %xmm0,%xmm7
mov    %eax,%edx
neg    %edx
mov    $0x1,%esi
xor    %ecx,%ecx
xorpd  %xmm1,%xmm1
xorpd  %xmm5,%xmm5
jmp    1a1f <trsbox_+0x90f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm1,0xf8(%rsp)
lea    (%rdx,%rsi,1),%edi
add    $0x1,%edi
add    $0x1,%esi
movapd %xmm3,%xmm1
cmp    $0x1,%edi
je     1ad0 <trsbox_+0x9c0>
xorps  %xmm6,%xmm6
cvtsi2sd %esi,%xmm6
mulsd  0x28(%rsp),%xmm6
divsd  %xmm8,%xmm6
movapd %xmm6,%xmm4
addsd  %xmm6,%xmm4
movapd %xmm6,%xmm3
mulsd  %xmm6,%xmm3
addsd  0x15bf(%rip),%xmm3
divsd  %xmm3,%xmm4
movapd %xmm6,%xmm2
mulsd  %xmm11,%xmm2
addsd  %xmm12,%xmm2
subsd  %xmm9,%xmm2
mulsd  %xmm6,%xmm2
addsd  %xmm10,%xmm2
movapd %xmm6,%xmm0
mulsd  %xmm15,%xmm0
addsd  %xmm7,%xmm0
movapd %xmm4,%xmm3
mulsd  0x15a6(%rip),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm4,%xmm3
ucomisd %xmm5,%xmm3
jbe    1ab0 <trsbox_+0x9a0>
mov    %esi,%ecx
movapd %xmm3,%xmm5
movsd  %xmm1,0x190(%rsp)
jmp    1a09 <trsbox_+0x8f9>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rcx),%edi
movapd %xmm3,%xmm1
cmp    %edi,%esi
je     1a00 <trsbox_+0x8f0>
movsd  0xf8(%rsp),%xmm1
jmp    1a00 <trsbox_+0x8f0>
nopl   (%rax)
test   %ecx,%ecx
movsd  0x38(%rsp),%xmm0
mov    0x200(%rsp),%rsi
movsd  0x60(%rsp),%xmm7
mov    (%rsp),%rdx
je     27e5 <trsbox_+0x16d5>
movapd %xmm14,%xmm12
movapd %xmm0,%xmm14
cmp    %eax,%ecx
jge    1b46 <trsbox_+0xa36>
movsd  0xf8(%rsp),%xmm1
movapd %xmm1,%xmm6
movsd  0x190(%rsp),%xmm0
subsd  %xmm0,%xmm6
addsd  %xmm5,%xmm5
subsd  %xmm0,%xmm5
subsd  %xmm1,%xmm5
divsd  %xmm5,%xmm6
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
mulsd  0x14f9(%rip),%xmm6
addsd  %xmm0,%xmm6
mulsd  0x28(%rsp),%xmm6
divsd  %xmm8,%xmm6
movapd %xmm6,%xmm4
mulsd  %xmm6,%xmm4
movapd %xmm4,%xmm5
addsd  0x14ae(%rip),%xmm5
movapd %xmm6,%xmm3
addsd  %xmm6,%xmm3
divsd  %xmm5,%xmm3
mulsd  %xmm6,%xmm11
subsd  %xmm9,%xmm11
subsd  %xmm9,%xmm11
mulsd  %xmm6,%xmm11
addsd  %xmm10,%xmm11
mulsd  %xmm6,%xmm15
subsd  %xmm12,%xmm15
movapd %xmm3,%xmm1
mulsd  0x1493(%rip),%xmm1
mulsd  %xmm11,%xmm1
addsd  %xmm15,%xmm1
mulsd  %xmm3,%xmm1
ucomisd %xmm1,%xmm13
jae    27e5 <trsbox_+0x16d5>
test   %edx,%edx
jle    1c93 <trsbox_+0xb83>
movsd  0x144a(%rip),%xmm0
subsd  %xmm4,%xmm0
divsd  %xmm5,%xmm0
movapd %xmm0,%xmm2
addsd  0x142e(%rip),%xmm2
xorpd  %xmm15,%xmm15
xor    %edx,%edx
jmp    1c09 <trsbox_+0xaf9>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rdx,1),%xmm4
mulsd  %xmm3,%xmm4
movsd  (%rbx,%rdx,1),%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%rbx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r8
je     1c98 <trsbox_+0xb88>
movsd  (%rbx,%rdx,1),%xmm4
mulsd  %xmm2,%xmm4
addsd  0x0(%rbp,%rdx,1),%xmm4
movsd  (%r12,%rdx,1),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,0x0(%rbp,%rdx,1)
movsd  (%r11,%rdx,1),%xmm4
ucomisd %xmm13,%xmm4
jne    1be0 <trsbox_+0xad0>
jp     1be0 <trsbox_+0xad0>
movsd  0x0(%r13,%rdx,1),%xmm4
mulsd  %xmm3,%xmm4
movsd  (%rsi,%rdx,1),%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%rsi,%rdx,1)
movsd  0x0(%rbp,%rdx,1),%xmm4
unpcklpd %xmm4,%xmm5
unpcklpd %xmm4,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm4,%xmm15
jmp    1be0 <trsbox_+0xad0>
mov    0x18(%rsp),%r9
mov    0x208(%rsp),%rbp
mov    0x10(%rsp),%r10
mov    0x200(%rsp),%rsi
jmp    1e56 <trsbox_+0xd46>
xorpd  %xmm15,%xmm15
addsd  %xmm1,%xmm14
mov    0x70(%rsp),%edx
test   %edx,%edx
jle    1cad <trsbox_+0xb9d>
cmp    %eax,%ecx
je     2314 <trsbox_+0x1204>
movapd %xmm14,%xmm0
mulsd  0x137e(%rip),%xmm0
ucomisd %xmm0,%xmm1
mov    (%rsp),%rdx
jbe    27e5 <trsbox_+0x16d5>
movapd %xmm15,%xmm8
unpckhpd %xmm15,%xmm8
jmp    1e56 <trsbox_+0xd46>
mov    %rdx,%rbx
mov    0x150(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%r12,%rax,8),%xmm0
movups 0x10(%r12,%rax,8),%xmm1
movups %xmm0,(%rsi,%rax,8)
movups %xmm1,0x10(%rsi,%rax,8)
movups 0x20(%r12,%rax,8),%xmm0
movups 0x30(%r12,%rax,8),%xmm1
movups %xmm0,0x20(%rsi,%rax,8)
movups %xmm1,0x30(%rsi,%rax,8)
movups 0x40(%r12,%rax,8),%xmm0
movups 0x50(%r12,%rax,8),%xmm1
movups %xmm0,0x40(%rsi,%rax,8)
movups %xmm1,0x50(%rsi,%rax,8)
movupd 0x60(%r12,%rax,8),%xmm0
movupd 0x70(%r12,%rax,8),%xmm1
movupd %xmm0,0x60(%rsi,%rax,8)
movupd %xmm1,0x70(%rsi,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rcx
jne    1cf0 <trsbox_+0xbe0>
cmpq   $0x0,0xe8(%rsp)
je     1da0 <trsbox_+0xc90>
mov    0xe8(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rax,8),%rdx
or     $0x8,%rdx
movupd -0x8(%r12,%rdx,1),%xmm0
movupd 0x8(%r12,%rdx,1),%xmm1
movupd %xmm0,-0x8(%rsi,%rdx,1)
movupd %xmm1,0x8(%rsi,%rdx,1)
add    $0x4,%rax
add    $0xffffffffffffffff,%rcx
jne    1d70 <trsbox_+0xc60>
mov    0xf0(%rsp),%rax
cmp    0xa0(%rsp),%r10
mov    %rbx,%rdx
jne    1dd0 <trsbox_+0xcc0>
mov    0x200(%rsp),%rsi
jmp    1e56 <trsbox_+0xd46>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rdx,%rbx
mov    %edi,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
and    $0x3,%rdx
je     1e07 <trsbox_+0xcf7>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1df0 <trsbox_+0xce0>
cmp    $0x3,%rcx
jb     1e4b <trsbox_+0xd3b>
nopl   (%rax)
movsd  -0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rax,8)
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rax,8)
movsd  0x10(%r12,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsi,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1e10 <trsbox_+0xd00>
mov    0x200(%rsp),%rsi
mov    %rbx,%rdx
movapd %xmm15,%xmm1
mulsd  %xmm15,%xmm1
movapd %xmm8,%xmm0
mulsd  0x120(%rsp),%xmm0
subsd  %xmm1,%xmm0
movapd %xmm14,%xmm1
mulsd  0x1191(%rip),%xmm1
mulsd  %xmm14,%xmm1
ucomisd %xmm0,%xmm1
jae    27e5 <trsbox_+0x16d5>
ucomisd %xmm13,%xmm0
jb     1ea0 <trsbox_+0xd90>
xorps  %xmm12,%xmm12
sqrtsd %xmm0,%xmm12
jmp    1f14 <trsbox_+0xe04>
movsd  %xmm14,0x38(%rsp)
mov    %rsi,%rbx
movapd %xmm15,0xd0(%rsp)
movapd %xmm8,0xc0(%rsp)
call   1030 <sqrt@plt>
movapd 0xc0(%rsp),%xmm8
movapd 0xd0(%rsp),%xmm15
movsd  0x60(%rsp),%xmm7
mov    %rbx,%rsi
movsd  0x38(%rsp),%xmm14
xorpd  %xmm13,%xmm13
mov    0x10(%rsp),%r10
mov    0x30(%rsp),%r8
mov    0x208(%rsp),%rbp
mov    0x210(%rsp),%r11
mov    (%rsp),%rdx
mov    0x18(%rsp),%r9
movapd %xmm0,%xmm12
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
test   %edx,%edx
mov    0x48(%rsp),%rbx
movapd 0x110(%rsp),%xmm2
jle    1f90 <trsbox_+0xe80>
xor    %eax,%eax
jmp    1f54 <trsbox_+0xe44>
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
je     14f0 <trsbox_+0x3e0>
movsd  (%r11,%rax,8),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jne    1f40 <trsbox_+0xe30>
jp     1f40 <trsbox_+0xe30>
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  (%rsi,%rax,8),%xmm0
mulsd  %xmm15,%xmm0
addsd  %xmm1,%xmm0
divsd  %xmm12,%xmm0
jmp    1f40 <trsbox_+0xe30>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  0x10a7(%rip),%xmm12
movl   $0x0,0x70(%rsp)
movsd  0x105f(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
jmp    1517 <trsbox_+0x407>
xor    %edi,%edi
movsd  0x104a(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
movl   $0x0,0x70(%rsp)
movapd %xmm12,0x100(%rsp)
movsd  %xmm14,0x38(%rsp)
movapd %xmm15,0xd0(%rsp)
movapd %xmm8,0xc0(%rsp)
jmp    200d <trsbox_+0xefd>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdi
cmp    %rdi,%r10
je     1517 <trsbox_+0x407>
movsd  (%r11,%rdi,8),%xmm0
ucomisd %xmm13,%xmm0
jne    2000 <trsbox_+0xef0>
jp     2000 <trsbox_+0xef0>
mov    0x58(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm1
movsd  (%rsi,%rdi,8),%xmm4
movapd %xmm1,%xmm5
addsd  %xmm4,%xmm5
mov    0x1e8(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm0
subsd  %xmm0,%xmm5
ucomisd %xmm5,%xmm13
jae    25ba <trsbox_+0x14aa>
mov    0x1f0(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm3
subsd  %xmm1,%xmm3
subsd  %xmm4,%xmm3
ucomisd %xmm3,%xmm13
jae    25d4 <trsbox_+0x14c4>
movsd  0x0(%r13,%rdi,8),%xmm2
mulsd  %xmm2,%xmm2
mulsd  %xmm4,%xmm4
addsd  %xmm2,%xmm4
subsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm1,%xmm0
ucomisd %xmm13,%xmm0
jbe    2185 <trsbox_+0x1075>
jb     20a8 <trsbox_+0xf98>
sqrtsd %xmm0,%xmm0
jmp    214c <trsbox_+0x103c>
mov    %rsi,%rbp
mov    %rdi,0x90(%rsp)
movsd  %xmm3,0x88(%rsp)
movsd  %xmm4,0x148(%rsp)
movsd  %xmm5,0x140(%rsp)
call   1030 <sqrt@plt>
movsd  0x140(%rsp),%xmm5
movsd  0x148(%rsp),%xmm4
movsd  0x88(%rsp),%xmm3
mov    0x90(%rsp),%rdi
movapd 0xc0(%rsp),%xmm8
movapd 0x100(%rsp),%xmm12
movapd 0xd0(%rsp),%xmm15
movsd  0x60(%rsp),%xmm7
mov    %rbp,%rsi
movsd  0x38(%rsp),%xmm14
xorpd  %xmm13,%xmm13
mov    0x10(%rsp),%r10
mov    0x30(%rsp),%r8
mov    0x208(%rsp),%rbp
mov    0x210(%rsp),%r11
mov    (%rsp),%rdx
mov    0x18(%rsp),%r9
subsd  0x0(%r13,%rdi,8),%xmm0
movsd  0x28(%rsp),%xmm1
mulsd  %xmm0,%xmm1
ucomisd %xmm5,%xmm1
jbe    2185 <trsbox_+0x1075>
divsd  %xmm0,%xmm5
lea    0x1(%rdi),%eax
mov    %eax,0x70(%rsp)
movsd  0xe8a(%rip),%xmm0
movsd  %xmm0,0xe0(%rsp)
movsd  %xmm5,0x28(%rsp)
mov    0x1f0(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm0
mov    0x58(%rsp),%rax
subsd  (%rax,%rdi,8),%xmm0
mulsd  %xmm0,%xmm0
subsd  %xmm0,%xmm4
ucomisd %xmm13,%xmm4
jbe    2000 <trsbox_+0xef0>
jb     21bd <trsbox_+0x10ad>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
jmp    2241 <trsbox_+0x1131>
movapd %xmm4,%xmm0
mov    %rsi,%rbp
mov    %rdi,0x90(%rsp)
movsd  %xmm3,0x88(%rsp)
call   1030 <sqrt@plt>
movsd  0x88(%rsp),%xmm3
mov    0x90(%rsp),%rdi
movapd 0xc0(%rsp),%xmm8
movapd 0x100(%rsp),%xmm12
movapd 0xd0(%rsp),%xmm15
movsd  0x60(%rsp),%xmm7
mov    %rbp,%rsi
movsd  0x38(%rsp),%xmm14
xorpd  %xmm13,%xmm13
mov    0x10(%rsp),%r10
mov    0x30(%rsp),%r8
mov    0x208(%rsp),%rbp
mov    0x210(%rsp),%r11
mov    (%rsp),%rdx
mov    0x18(%rsp),%r9
addsd  0x0(%r13,%rdi,8),%xmm0
movsd  0x28(%rsp),%xmm1
mulsd  %xmm0,%xmm1
ucomisd %xmm3,%xmm1
jbe    2000 <trsbox_+0xef0>
divsd  %xmm0,%xmm3
lea    0x1(%rdi),%eax
mov    %eax,0x70(%rsp)
movsd  0xd99(%rip),%xmm0
movsd  %xmm0,0xe0(%rsp)
movsd  %xmm3,0x28(%rsp)
jmp    2000 <trsbox_+0xef0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsp),%rdx
xorpd  %xmm5,%xmm5
test   %edx,%edx
jle    2336 <trsbox_+0x1226>
xor    %eax,%eax
movsd  0x40(%rsp),%xmm2
mov    0x200(%rsp),%rsi
mov    0x208(%rsp),%rbp
mov    0x30(%rsp),%r8
mov    0x10(%rsp),%r10
jmp    22d9 <trsbox_+0x11c9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    %rax,%r10
je     2356 <trsbox_+0x1246>
movsd  (%r11,%rax,8),%xmm0
ucomisd %xmm13,%xmm0
jne    22d0 <trsbox_+0x11c0>
jp     22d0 <trsbox_+0x11c0>
movsd  (%rsi,%rax,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm1,%xmm2
movsd  0x0(%r13,%rax,8),%xmm1
unpcklpd %xmm1,%xmm1
movhpd (%r12,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
addpd  %xmm0,%xmm5
jmp    22d0 <trsbox_+0x11c0>
mov    0x8(%rsp),%ecx
add    $0x1,%ecx
mov    %edx,%eax
movsd  0xe0(%rsp),%xmm0
movsd  %xmm0,-0x8(%r11,%rax,8)
mov    (%rsp),%rdx
jmp    26b1 <trsbox_+0x15a1>
movsd  0x40(%rsp),%xmm2
mov    0x200(%rsp),%rsi
mov    0x208(%rsp),%rbp
mov    0x30(%rsp),%r8
mov    0x10(%rsp),%r10
ucomisd %xmm2,%xmm13
jae    2381 <trsbox_+0x1271>
movapd %xmm5,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm7,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm13,%xmm0
jb     238b <trsbox_+0x127b>
sqrtsd %xmm0,%xmm0
jmp    2421 <trsbox_+0x1311>
mov    0x18(%rsp),%r9
jmp    269e <trsbox_+0x158e>
movsd  %xmm14,0x38(%rsp)
mov    %rsi,%rbx
movaps %xmm15,0xd0(%rsp)
movaps %xmm12,0x100(%rsp)
movapd %xmm8,0xc0(%rsp)
movapd %xmm5,0x70(%rsp)
movsd  %xmm2,0x110(%rsp)
call   1030 <sqrt@plt>
movsd  0x110(%rsp),%xmm2
movapd 0x70(%rsp),%xmm5
movapd 0xc0(%rsp),%xmm8
movapd 0x100(%rsp),%xmm12
movapd 0xd0(%rsp),%xmm15
movsd  0x60(%rsp),%xmm7
mov    %rbx,%rsi
movsd  0x38(%rsp),%xmm14
xorpd  %xmm13,%xmm13
mov    0x10(%rsp),%r10
mov    0x30(%rsp),%r8
mov    0x208(%rsp),%rbp
mov    0x210(%rsp),%r11
ucomisd %xmm5,%xmm13
mov    0x48(%rsp),%rdi
jbe    2437 <trsbox_+0x1327>
subsd  %xmm5,%xmm0
divsd  %xmm7,%xmm0
jmp    2443 <trsbox_+0x1333>
addsd  %xmm5,%xmm0
divsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
mov    0x18(%rsp),%r9
unpckhpd %xmm5,%xmm5
ucomisd %xmm13,%xmm5
movapd %xmm0,%xmm1
jbe    246a <trsbox_+0x135a>
movapd %xmm8,%xmm1
divsd  %xmm5,%xmm1
ucomisd %xmm0,%xmm1
jbe    246a <trsbox_+0x135a>
movapd %xmm0,%xmm1
cmpl   $0x0,(%rsp)
jle    24dc <trsbox_+0x13cc>
xor    %ebx,%ebx
mov    $0x1,%eax
jmp    2489 <trsbox_+0x1379>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %rax,%rdi
je     24de <trsbox_+0x13ce>
movsd  -0x8(%r13,%rax,8),%xmm2
ucomisd %xmm13,%xmm2
jne    2499 <trsbox_+0x1389>
jnp    2480 <trsbox_+0x1370>
mov    0x58(%rsp),%rcx
movsd  -0x8(%rcx,%rax,8),%xmm4
addsd  -0x8(%rsi,%rax,8),%xmm4
ucomisd %xmm13,%xmm2
mov    0x1e8(%rsp),%rcx
cmova  0x1f0(%rsp),%rcx
movsd  -0x8(%rcx,%rax,8),%xmm3
subsd  %xmm4,%xmm3
divsd  %xmm2,%xmm3
ucomisd %xmm3,%xmm1
jbe    2480 <trsbox_+0x1370>
mov    %eax,%ebx
movapd %xmm3,%xmm1
jmp    2480 <trsbox_+0x1370>
xor    %ebx,%ebx
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm1
jbe    2634 <trsbox_+0x1524>
test   %ebx,%ebx
jne    254a <trsbox_+0x143a>
movapd %xmm5,%xmm2
divsd  %xmm7,%xmm2
ucomisd %xmm13,%xmm2
jbe    254a <trsbox_+0x143a>
mov    0x238(%rsp),%rax
movsd  (%rax),%xmm4
ucomisd %xmm2,%xmm4
movapd %xmm2,%xmm3
minsd  %xmm4,%xmm3
ja     2525 <trsbox_+0x1415>
ucomisd 0xadf(%rip),%xmm3
jne    254a <trsbox_+0x143a>
jp     254a <trsbox_+0x143a>
movapd %xmm3,%xmm4
cmpeqsd 0xace(%rip),%xmm4
andpd  %xmm4,%xmm2
andnpd %xmm3,%xmm4
orpd   %xmm2,%xmm4
mov    0x238(%rsp),%rax
movlpd %xmm4,(%rax)
cmpl   $0x0,(%rsp)
jle    25ee <trsbox_+0x14de>
xorpd  %xmm3,%xmm3
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  0x0(%rbp,%rax,8),%xmm4
movsd  %xmm4,0x0(%rbp,%rax,8)
mulsd  %xmm4,%xmm4
addsd  %xmm3,%xmm4
movsd  (%r11,%rax,8),%xmm2
cmpeqsd %xmm13,%xmm2
andpd  %xmm2,%xmm4
andnpd %xmm3,%xmm2
movsd  0x0(%r13,%rax,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  (%rsi,%rax,8),%xmm3
orpd   %xmm4,%xmm2
movsd  %xmm3,(%rsi,%rax,8)
add    $0x1,%rax
movapd %xmm2,%xmm3
cmp    %rax,%r10
jne    2560 <trsbox_+0x1450>
jmp    25f2 <trsbox_+0x14e2>
mov    0x8(%rsp),%ecx
add    $0x1,%ecx
movabs $0xbff0000000000000,%rax
mov    %rax,(%r11,%rdi,8)
jmp    26b1 <trsbox_+0x15a1>
mov    0x8(%rsp),%ecx
add    $0x1,%ecx
movabs $0x3ff0000000000000,%rax
mov    %rax,(%r11,%rdi,8)
jmp    26b1 <trsbox_+0x15a1>
xorpd  %xmm2,%xmm2
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
movapd %xmm1,%xmm4
mulsd  0xa1d(%rip),%xmm4
mulsd  %xmm5,%xmm4
addsd  %xmm8,%xmm4
mulsd  %xmm1,%xmm4
xorpd  %xmm3,%xmm3
maxsd  %xmm4,%xmm3
addsd  %xmm3,%xmm14
movsd  %xmm8,0x138(%rsp)
movapd %xmm2,%xmm8
test   %ebx,%ebx
mov    %ebx,0x70(%rsp)
jle    2690 <trsbox_+0x1580>
mov    %ebx,%eax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,-0x8(%r11,%rax,8)
ucomisd -0x8(%r13,%rax,8),%xmm13
jbe    2665 <trsbox_+0x1555>
movabs $0xbff0000000000000,%rcx
mov    %rcx,-0x8(%r11,%rax,8)
addl   $0x1,0x8(%rsp)
movsd  -0x8(%rsi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x40(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rsp)
ucomisd %xmm1,%xmm13
jae    269a <trsbox_+0x158a>
jmp    2781 <trsbox_+0x1671>
ucomisd %xmm1,%xmm0
ja     2793 <trsbox_+0x1683>
mov    (%rsp),%rdx
mov    0x238(%rsp),%rax
movq   $0x0,(%rax)
mov    0x8(%rsp),%ecx
mov    %ecx,0x8(%rsp)
cmp    0xbc(%rsp),%ecx
jge    27e5 <trsbox_+0x16d5>
xorpd  %xmm15,%xmm15
xorpd  %xmm0,%xmm0
movapd %xmm0,0x120(%rsp)
xorpd  %xmm8,%xmm8
mov    0x20(%rsp),%rax
mov    %eax,0x6c(%rsp)
test   %edx,%edx
jle    14ce <trsbox_+0x3be>
xorpd  %xmm15,%xmm15
xorpd  %xmm0,%xmm0
xor    %eax,%eax
xorpd  %xmm8,%xmm8
jmp    273d <trsbox_+0x162d>
nopl   0x0(%rax)
movsd  (%rsi,%rax,8),%xmm1
movsd  0x0(%rbp,%rax,8),%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm2,%xmm4
unpcklpd %xmm1,%xmm4
mulpd  %xmm3,%xmm4
addpd  %xmm4,%xmm15
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm8
movsd  %xmm1,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
je     2760 <trsbox_+0x1650>
movsd  (%r11,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
jne    274b <trsbox_+0x163b>
jnp    2700 <trsbox_+0x15f0>
xorpd  %xmm1,%xmm1
jmp    272d <trsbox_+0x161d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm15,%xmm0
unpckhpd %xmm15,%xmm0
movapd %xmm0,0x120(%rsp)
mov    0x20(%rsp),%rax
mov    %eax,0x6c(%rsp)
jmp    14ce <trsbox_+0x3be>
xorpd  %xmm0,%xmm0
mov    (%rsp),%rcx
test   %ecx,%ecx
jg     13d3 <trsbox_+0x2c3>
jmp    27d1 <trsbox_+0x16c1>
movapd %xmm14,%xmm0
mulsd  0x898(%rip),%xmm0
mov    0x54(%rsp),%eax
cmp    %eax,0x20(%rsp)
mov    (%rsp),%rdx
je     27e5 <trsbox_+0x16d5>
ucomisd %xmm3,%xmm0
jae    27e5 <trsbox_+0x16d5>
movapd %xmm8,%xmm0
divsd  0x138(%rsp),%xmm0
test   %edx,%edx
mov    %rdx,%rcx
mov    0x70(%rsp),%ebx
jg     13d3 <trsbox_+0x2c3>
mov    0x230(%rsp),%rax
movq   $0x0,(%rax)
jmp    28de <trsbox_+0x17ce>
mov    0x230(%rsp),%rdi
movq   $0x0,(%rdi)
test   %edx,%edx
mov    0x1f0(%rsp),%r9
mov    %rsi,%rbx
mov    0x1e8(%rsp),%rsi
mov    0x1f8(%rsp),%rbp
jle    28de <trsbox_+0x17ce>
xor    %eax,%eax
movsd  0x7df(%rip),%xmm0
movsd  0x7df(%rip),%xmm1
jmp    285b <trsbox_+0x174b>
nopl   0x0(%rax,%rax,1)
mov    0x58(%rsp),%rcx
subsd  (%rcx,%rax,1),%xmm2
mov    %rdx,%rbx
movsd  %xmm2,(%rdx,%rax,1)
mulsd  %xmm2,%xmm2
addsd  (%rdi),%xmm2
movsd  %xmm2,(%rdi)
add    $0x8,%rax
cmp    %rax,%r8
je     28de <trsbox_+0x17ce>
mov    0x58(%rsp),%rcx
movsd  (%rcx,%rax,1),%xmm2
mov    %rbx,%rdx
addsd  (%rbx,%rax,1),%xmm2
movsd  %xmm2,0x0(%rbp,%rax,1)
movsd  (%r9,%rax,1),%xmm3
ucomisd %xmm3,%xmm2
jbe    2889 <trsbox_+0x1779>
movsd  %xmm3,0x0(%rbp,%rax,1)
movapd %xmm3,%xmm2
movsd  (%rsi,%rax,1),%xmm3
ucomisd %xmm2,%xmm3
jbe    289e <trsbox_+0x178e>
movsd  %xmm3,0x0(%rbp,%rax,1)
movapd %xmm3,%xmm2
movsd  (%r11,%rax,1),%xmm3
ucomisd %xmm0,%xmm3
jne    28bd <trsbox_+0x17ad>
jp     28bd <trsbox_+0x17ad>
movsd  (%rsi,%rax,1),%xmm2
movsd  %xmm2,0x0(%rbp,%rax,1)
movsd  (%r11,%rax,1),%xmm3
ucomisd %xmm1,%xmm3
jne    2830 <trsbox_+0x1720>
jp     2830 <trsbox_+0x1720>
movsd  (%r9,%rax,1),%xmm2
movsd  %xmm2,0x0(%rbp,%rax,1)
jmp    2830 <trsbox_+0x1720>
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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