int trsapp_(long int *n, long int *npt, double *xopt, double *xpt, double *gq,
            double *hq, double *pq, double *delta, double *step, double *d__,
            double *g, double *hd, double *hs, double *crvmin) {
  long int xpt_dim1, xpt_offset, i__1, i__2;
  double d__1, d__2;
  double atan(double), sqrt(double), cos(double), sin(double);
  static long int i__, j, k;
  static double dd, cf, dg, gg;
  static long int ih;
  static double ds, sg;
  static long int iu;
  static double ss, dhd, dhs, cth, sgk, shs, sth, qadd, half, qbeg, qred, qmin,
      temp, qsav, qnew, zero, ggbeg, alpha, angle, reduc;
  static long int iterc;
  static double ggsav, delsq, tempa, tempb;
  static long int isave;
  static double bstep, ratio, twopi;
  static long int itersw;
  static double angtest;
  static long int itermax;
  xpt_dim1 = *npt;
  xpt_offset = 1 + xpt_dim1;
  xpt -= xpt_offset;
  --xopt;
  --gq;
  --hq;
  --pq;
  --step;
  --d__;
  --g;
  --hd;
  --hs;
  half = .5;
  zero = 0.;
  twopi = atan(1.) * 8.;
  delsq = *delta * *delta;
  iterc = 0;
  itermax = *n;
  itersw = itermax;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    d__[i__] = xopt[i__];
  }
  goto L170;
L20:
  qred = zero;
  dd = zero;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    step[i__] = zero;
    hs[i__] = zero;
    g[i__] = gq[i__] + hd[i__];
    d__[i__] = -g[i__];
    d__1 = d__[i__];
    dd += d__1 * d__1;
  }
  *crvmin = zero;
  if (dd == zero) {
    goto L160;
  }
  ds = zero;
  ss = zero;
  gg = dd;
  ggbeg = gg;
L40:
  ++iterc;
  temp = delsq - ss;
  bstep = temp / (ds + sqrt(ds * ds + dd * temp));
  goto L170;
L50:
  dhd = zero;
  i__1 = *n;
  for (j = 1; j <= i__1; ++j) {
    dhd += d__[j] * hd[j];
  }
  alpha = bstep;
  if (dhd > zero) {
    temp = dhd / dd;
    if (iterc == 1) {
      *crvmin = temp;
    }
    *crvmin = ((*crvmin) <= (temp) ? (*crvmin) : (temp));
    d__1 = alpha, d__2 = gg / dhd;
    alpha = ((d__1) <= (d__2) ? (d__1) : (d__2));
  }
  qadd = alpha * (gg - half * alpha * dhd);
  qred += qadd;
  ggsav = gg;
  gg = zero;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    step[i__] += alpha * d__[i__];
    hs[i__] += alpha * hd[i__];
    d__1 = g[i__] + hs[i__];
    gg += d__1 * d__1;
  }
  if (alpha < bstep) {
    if (qadd <= qred * .01) {
      goto L160;
    }
    if (gg <= ggbeg * 1e-4) {
      goto L160;
    }
    if (iterc == itermax) {
      goto L160;
    }
    temp = gg / ggsav;
    dd = zero;
    ds = zero;
    ss = zero;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      d__[i__] = temp * d__[i__] - g[i__] - hs[i__];
      d__1 = d__[i__];
      dd += d__1 * d__1;
      ds += d__[i__] * step[i__];
      d__1 = step[i__];
      ss += d__1 * d__1;
    }
    if (ds <= zero) {
      goto L160;
    }
    if (ss < delsq) {
      goto L40;
    }
  }
  *crvmin = zero;
  itersw = iterc;
L90:
  if (gg <= ggbeg * 1e-4) {
    goto L160;
  }
  sg = zero;
  shs = zero;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    sg += step[i__] * g[i__];
    shs += step[i__] * hs[i__];
  }
  sgk = sg + shs;
  angtest = sgk / sqrt(gg * delsq);
  if (angtest <= -.99) {
    goto L160;
  }
  ++iterc;
  temp = sqrt(delsq * gg - sgk * sgk);
  tempa = delsq / temp;
  tempb = sgk / temp;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    d__[i__] = tempa * (g[i__] + hs[i__]) - tempb * step[i__];
  }
  goto L170;
L120:
  dg = zero;
  dhd = zero;
  dhs = zero;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    dg += d__[i__] * g[i__];
    dhd += hd[i__] * d__[i__];
    dhs += hd[i__] * step[i__];
  }
  cf = half * (shs - dhd);
  qbeg = sg + cf;
  qsav = qbeg;
  qmin = qbeg;
  isave = 0;
  iu = 49;
  temp = twopi / (double)(iu + 1);
  i__1 = iu;
  for (i__ = 1; i__ <= i__1; ++i__) {
    angle = (double)i__ * temp;
    cth = cos(angle);
    sth = sin(angle);
    qnew = (sg + cf * cth) * cth + (dg + dhs * cth) * sth;
    if (qnew < qmin) {
      qmin = qnew;
      isave = i__;
      tempa = qsav;
    } else if (i__ == isave + 1) {
      tempb = qnew;
    }
    qsav = qnew;
  }
  if ((double)isave == zero) {
    tempa = qnew;
  }
  if (isave == iu) {
    tempb = qbeg;
  }
  angle = zero;
  if (tempa != tempb) {
    tempa -= qmin;
    tempb -= qmin;
    angle = half * (tempa - tempb) / (tempa + tempb);
  }
  angle = temp * ((double)isave + angle);
  cth = cos(angle);
  sth = sin(angle);
  reduc = qbeg - (sg + cf * cth) * cth - (dg + dhs * cth) * sth;
  gg = zero;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    step[i__] = cth * step[i__] + sth * d__[i__];
    hs[i__] = cth * hs[i__] + sth * hd[i__];
    d__1 = g[i__] + hs[i__];
    gg += d__1 * d__1;
  }
  qred += reduc;
  ratio = reduc / qred;
  if (iterc < itermax && ratio > .01) {
    goto L90;
  }
L160:
  return 0;
L170:
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    hd[i__] = zero;
  }
  i__1 = *npt;
  for (k = 1; k <= i__1; ++k) {
    temp = zero;
    i__2 = *n;
    for (j = 1; j <= i__2; ++j) {
      temp += xpt[k + j * xpt_dim1] * d__[j];
    }
    temp *= pq[k];
    i__2 = *n;
    for (i__ = 1; i__ <= i__2; ++i__) {
      hd[i__] += temp * xpt[k + i__ * xpt_dim1];
    }
  }
  ih = 0;
  i__2 = *n;
  for (j = 1; j <= i__2; ++j) {
    i__1 = j;
    for (i__ = 1; i__ <= i__1; ++i__) {
      ++ih;
      if (i__ < j) {
        hd[j] += hq[ih] * d__[i__];
      }
      hd[i__] += hq[ih] * d__[j];
    }
  }
  if (iterc == 0) {
    goto L20;
  }
  if (iterc <= itersw) {
    goto L50;
  }
  goto L120;
}


x86 assembly (clang, -O0):
<trsapp_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rdx
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x10(%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)
movsd  0x1dea(%rip),%xmm0
movsd  %xmm0,0x3eb2(%rip)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x3edf(%rip)
movsd  0x1dc7(%rip),%xmm0
call   1040 <atan@plt>
movsd  0x1db2(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x3f26(%rip)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x18(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,0x3ede(%rip)
movq   $0x0,0x3ec3(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,0x3f0d(%rip)
mov    0x3f06(%rip),%rax
mov    %rax,0x3eef(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x3d99(%rip)
mov    0x3d92(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     12f7 <trsapp_+0x1b7>
mov    -0x18(%rbp),%rax
mov    0x3d7d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x3d6d(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3d61(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3d56(%rip)
jmp    12af <trsapp_+0x16f>
jmp    23d4 <trsapp_+0x1294>
movsd  0x3e14(%rip),%xmm0
movsd  %xmm0,0x3de4(%rip)
movsd  0x3e04(%rip),%xmm0
movsd  %xmm0,0x3d44(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x3d16(%rip)
mov    0x3d0f(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     1428 <trsapp_+0x2e8>
movsd  0x3dcd(%rip),%xmm0
mov    0x20(%rbp),%rax
mov    0x3cf2(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3db5(%rip),%xmm0
mov    0x40(%rbp),%rax
mov    0x3cda(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    0x3cca(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    0x3cba(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x3caa(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x3c9a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x28(%rbp),%rax
mov    0x3c73(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    0x3c63(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  0x3c5f(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3c4f(%rip)
mov    0x3c30(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3c25(%rip)
jmp    1332 <trsapp_+0x1f2>
movsd  0x3ce8(%rip),%xmm0
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  0x3c20(%rip),%xmm0
ucomisd 0x3cd0(%rip),%xmm0
jne    1459 <trsapp_+0x319>
jp     1459 <trsapp_+0x319>
jmp    23c9 <trsapp_+0x1289>
movsd  0x3cb7(%rip),%xmm0
movsd  %xmm0,0x3c1f(%rip)
movsd  0x3ca7(%rip),%xmm0
movsd  %xmm0,0x3c27(%rip)
movsd  0x3bdf(%rip),%xmm0
movsd  %xmm0,0x3bef(%rip)
movsd  0x3be7(%rip),%xmm0
movsd  %xmm0,0x3c87(%rip)
mov    0x3ca0(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3c95(%rip)
movsd  0x3c9d(%rip),%xmm0
subsd  0x3be5(%rip),%xmm0
movsd  %xmm0,0x3c3d(%rip)
movsd  0x3c35(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x3bb0(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x3ba3(%rip),%xmm0
movsd  0x3b9b(%rip),%xmm2
movsd  0x3b6b(%rip),%xmm1
mulsd  0x3c03(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  -0x70(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x68(%rbp),%xmm0
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x3c49(%rip)
jmp    23d4 <trsapp_+0x1294>
movsd  0x3be4(%rip),%xmm0
movsd  %xmm0,0x3b6c(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x3afe(%rip)
mov    0x3af7(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     15b2 <trsapp_+0x472>
mov    0x28(%rbp),%rax
mov    0x3ae2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    0x3ad2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3b1d(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3b0d(%rip)
mov    0x3aae(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3aa3(%rip)
jmp    1552 <trsapp_+0x412>
movsd  0x3bb6(%rip),%xmm0
movsd  %xmm0,0x3b66(%rip)
movsd  0x3ade(%rip),%xmm0
ucomisd 0x3b46(%rip),%xmm0
jbe    16b0 <trsapp_+0x570>
movsd  0x3ac8(%rip),%xmm0
divsd  0x3a78(%rip),%xmm0
movsd  %xmm0,0x3b10(%rip)
cmpq   $0x1,0x3b48(%rip)
01
jne    160e <trsapp_+0x4ce>
movsd  0x3afa(%rip),%xmm0
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x3ae2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     163a <trsapp_+0x4fa>
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    1647 <trsapp_+0x507>
movsd  0x3abe(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  0x3acc(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0x3a0f(%rip),%xmm0
divsd  0x3a37(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1699 <trsapp_+0x559>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    16a3 <trsapp_+0x563>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,0x3a78(%rip)
movsd  0x3a70(%rip),%xmm0
movsd  0x39b8(%rip),%xmm2
movsd  0x3a18(%rip),%xmm1
mulsd  0x3a58(%rip),%xmm1
movsd  0x39d0(%rip),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x39d5(%rip)
movsd  0x39cd(%rip),%xmm0
addsd  0x39dd(%rip),%xmm0
movsd  %xmm0,0x39d5(%rip)
movsd  0x3955(%rip),%xmm0
movsd  %xmm0,0x3a1d(%rip)
movsd  0x39e5(%rip),%xmm0
movsd  %xmm0,0x393d(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x38f7(%rip)
mov    0x38f0(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     182a <trsapp_+0x6ea>
movsd  0x39be(%rip),%xmm0
mov    0x28(%rbp),%rax
mov    0x38d3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    0x38c3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3989(%rip),%xmm0
mov    0x38(%rbp),%rax
mov    0x389e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x40(%rbp),%rax
mov    0x388e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x3871(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    0x3861(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  0x3875(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3865(%rip)
mov    0x382e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3823(%rip)
jmp    1751 <trsapp_+0x611>
movsd  0x38f6(%rip),%xmm1
movsd  0x3936(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a81 <trsapp_+0x941>
movsd  0x388c(%rip),%xmm1
movsd  0x17c4(%rip),%xmm0
mulsd  0x3894(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     186b <trsapp_+0x72b>
jmp    23c9 <trsapp_+0x1289>
movsd  0x3805(%rip),%xmm1
movsd  0x17a5(%rip),%xmm0
mulsd  0x389d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1892 <trsapp_+0x752>
jmp    23c9 <trsapp_+0x1289>
mov    0x38a7(%rip),%rax
cmp    0x38f8(%rip),%rax
jne    18ab <trsapp_+0x76b>
jmp    23c9 <trsapp_+0x1289>
movsd  0x37c5(%rip),%xmm0
divsd  0x388d(%rip),%xmm0
movsd  %xmm0,0x383d(%rip)
movsd  0x384d(%rip),%xmm0
movsd  %xmm0,0x378d(%rip)
movsd  0x383d(%rip),%xmm0
movsd  %xmm0,0x37a5(%rip)
movsd  0x382d(%rip),%xmm0
movsd  %xmm0,0x37ad(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x373f(%rip)
mov    0x3738(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     1a3e <trsapp_+0x8fe>
movsd  0x37de(%rip),%xmm0
mov    0x28(%rbp),%rax
mov    0x371b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
mov    0x370b(%rip),%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    0x40(%rbp),%rax
mov    0x36dc(%rip),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x36cc(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    0x36bc(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  0x36b8(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x36a8(%rip)
mov    0x28(%rbp),%rax
mov    0x3685(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    0x3675(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x36a8(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3698(%rip)
mov    0x20(%rbp),%rax
mov    0x364d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  0x3689(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3679(%rip)
mov    0x361a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x360f(%rip)
jmp    1909 <trsapp_+0x7c9>
movsd  0x3642(%rip),%xmm1
movsd  0x36ca(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1a5d <trsapp_+0x91d>
jmp    23c9 <trsapp_+0x1289>
movsd  0x363b(%rip),%xmm1
movsd  0x36e3(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a7c <trsapp_+0x93c>
jmp    1499 <trsapp_+0x359>
jmp    1a81 <trsapp_+0x941>
movsd  0x368f(%rip),%xmm0
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x36a8(%rip),%rax
mov    %rax,0x36e9(%rip)
movsd  0x35d1(%rip),%xmm1
movsd  0x1571(%rip),%xmm0
mulsd  0x3669(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1ac6 <trsapp_+0x986>
jmp    23c9 <trsapp_+0x1289>
movsd  0x364a(%rip),%xmm0
movsd  %xmm0,0x35ba(%rip)
movsd  0x363a(%rip),%xmm0
movsd  %xmm0,0x35e2(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x354c(%rip)
mov    0x3545(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     1b94 <trsapp_+0xa54>
mov    0x20(%rbp),%rax
mov    0x3530(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x3520(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x355b(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x354b(%rip)
mov    0x20(%rbp),%rax
mov    0x34f8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    0x34e8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x355b(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x354b(%rip)
mov    0x34c4(%rip),%rax
add    $0x1,%rax
mov    %rax,0x34b9(%rip)
jmp    1afc <trsapp_+0x9bc>
movsd  0x34f4(%rip),%xmm0
addsd  0x3524(%rip),%xmm0
movsd  %xmm0,0x3514(%rip)
movsd  0x350c(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x34b4(%rip),%xmm0
mulsd  0x3584(%rip),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,0x35a8(%rip)
movsd  0x1438(%rip),%xmm0
ucomisd 0x3598(%rip),%xmm0
jb     1c03 <trsapp_+0xac3>
jmp    23c9 <trsapp_+0x1289>
mov    0x3536(%rip),%rax
add    $0x1,%rax
mov    %rax,0x352b(%rip)
movsd  0x3533(%rip),%xmm0
movsd  0x3453(%rip),%xmm2
movsd  0x3493(%rip),%xmm1
mulsd  0x348b(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1060 <sqrt@plt>
movsd  %xmm0,0x349f(%rip)
movsd  0x34e7(%rip),%xmm0
divsd  0x348f(%rip),%xmm0
movsd  %xmm0,0x34df(%rip)
movsd  0x343f(%rip),%xmm0
divsd  0x3477(%rip),%xmm0
movsd  %xmm0,0x34cf(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x33a1(%rip)
mov    0x339a(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     1d3e <trsapp_+0xbfe>
movsd  0x3498(%rip),%xmm0
mov    0x30(%rbp),%rax
mov    0x337d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x40(%rbp),%rax
mov    0x336d(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  0x3478(%rip),%xmm1
mov    0x20(%rbp),%rax
mov    0x3355(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
mov    0x3326(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x331a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x330f(%rip)
jmp    1ca7 <trsapp_+0xb67>
jmp    23d4 <trsapp_+0x1294>
movsd  0x33cd(%rip),%xmm0
movsd  %xmm0,0x331d(%rip)
movsd  0x33bd(%rip),%xmm0
movsd  %xmm0,0x3345(%rip)
movsd  0x33ad(%rip),%xmm0
movsd  %xmm0,0x333d(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x32bf(%rip)
mov    0x32b8(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     1e59 <trsapp_+0xd19>
mov    0x28(%rbp),%rax
mov    0x32a3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x3293(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x32ae(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x329e(%rip)
mov    0x38(%rbp),%rax
mov    0x326b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x325b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x32ae(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x329e(%rip)
mov    0x38(%rbp),%rax
mov    0x3233(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    0x3223(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x327e(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x326e(%rip)
mov    0x31ff(%rip),%rax
add    $0x1,%rax
mov    %rax,0x31f4(%rip)
jmp    1d89 <trsapp_+0xc49>
movsd  0x327f(%rip),%xmm0
movsd  0x325f(%rip),%xmm1
subsd  0x3237(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x31eb(%rip)
movsd  0x320b(%rip),%xmm0
addsd  0x31db(%rip),%xmm0
movsd  %xmm0,0x3253(%rip)
movsd  0x324b(%rip),%xmm0
movsd  %xmm0,0x3263(%rip)
movsd  0x323b(%rip),%xmm0
movsd  %xmm0,0x3243(%rip)
movq   $0x0,0x32a8(%rip)
movq   $0x31,0x31cd(%rip)
movsd  0x32ad(%rip),%xmm0
mov    0x31be(%rip),%rax
add    $0x1,%rax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x3211(%rip)
mov    0x31a2(%rip),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x3143(%rip)
mov    0x313c(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     205d <trsapp_+0xf1d>
cvtsi2sdq 0x3129(%rip),%xmm0
mulsd  0x31d9(%rip),%xmm0
movsd  %xmm0,0x3201(%rip)
movsd  0x31f9(%rip),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,0x3174(%rip)
movsd  0x31e4(%rip),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x3177(%rip)
movsd  0x312f(%rip),%xmm1
movsd  0x30ff(%rip),%xmm0
movsd  0x3147(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x3137(%rip),%xmm2
movsd  0x30e7(%rip),%xmm3
movsd  0x311f(%rip),%xmm1
movsd  0x311f(%rip),%xmm4
mulsd  %xmm4,%xmm1
addsd  %xmm3,%xmm1
mulsd  0x3127(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3157(%rip)
movsd  0x314f(%rip),%xmm1
movsd  0x312f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    2006 <trsapp_+0xec6>
movsd  0x3135(%rip),%xmm0
movsd  %xmm0,0x3115(%rip)
mov    0x305e(%rip),%rax
mov    %rax,0x3177(%rip)
movsd  0x310f(%rip),%xmm0
movsd  %xmm0,0x3157(%rip)
jmp    2036 <trsapp_+0xef6>
mov    0x303b(%rip),%rax
mov    0x3154(%rip),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2031 <trsapp_+0xef1>
movsd  0x30e7(%rip),%xmm0
movsd  %xmm0,0x312f(%rip)
jmp    2036 <trsapp_+0xef6>
movsd  0x30d2(%rip),%xmm0
movsd  %xmm0,0x30c2(%rip)
mov    0x2ffb(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2ff0(%rip)
jmp    1f05 <trsapp_+0xdc5>
cvtsi2sdq 0x3102(%rip),%xmm0
ucomisd 0x30aa(%rip),%xmm0
jne    208a <trsapp_+0xf4a>
jp     208a <trsapp_+0xf4a>
movsd  0x308e(%rip),%xmm0
movsd  %xmm0,0x30ce(%rip)
mov    0x30d7(%rip),%rax
cmp    0x3000(%rip),%rax
jne    20ae <trsapp_+0xf6e>
movsd  0x3042(%rip),%xmm0
movsd  %xmm0,0x30b2(%rip)
movsd  0x3062(%rip),%xmm0
movsd  %xmm0,0x3072(%rip)
movsd  0x3092(%rip),%xmm0
ucomisd 0x3092(%rip),%xmm0
jne    20df <trsapp_+0xf9f>
jp     20df <trsapp_+0xf9f>
jmp    214f <trsapp_+0x100f>
movsd  0x3011(%rip),%xmm1
movsd  0x3069(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x305d(%rip)
movsd  0x2ff5(%rip),%xmm1
movsd  0x3055(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x3049(%rip)
movsd  0x2fc1(%rip),%xmm0
movsd  0x3031(%rip),%xmm1
subsd  0x3031(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x301d(%rip),%xmm1
addsd  0x301d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2fe1(%rip)
movsd  0x2fa9(%rip),%xmm0
cvtsi2sdq 0x3008(%rip),%xmm1
addsd  0x2fc8(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x2fbc(%rip)
movsd  0x2fb4(%rip),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,0x2f2f(%rip)
movsd  0x2f9f(%rip),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x2f32(%rip)
movsd  0x2f42(%rip),%xmm0
movsd  0x2ee2(%rip),%xmm2
movsd  0x2eb2(%rip),%xmm1
movsd  0x2efa(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x2eea(%rip),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2e7b(%rip),%xmm2
movsd  0x2eb3(%rip),%xmm0
movsd  0x2eb3(%rip),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  0x2ebb(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2efc(%rip)
movsd  0x2ed4(%rip),%xmm0
movsd  %xmm0,0x2e2c(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x2de6(%rip)
mov    0x2ddf(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     2361 <trsapp_+0x1221>
movsd  0x2e3d(%rip),%xmm0
mov    0x20(%rbp),%rax
mov    0x2dc2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2e3d(%rip),%xmm1
mov    0x28(%rbp),%rax
mov    0x2daa(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    0x2d92(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2df5(%rip),%xmm0
mov    0x40(%rbp),%rax
mov    0x2d7a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2df5(%rip),%xmm1
mov    0x38(%rbp),%rax
mov    0x2d62(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
mov    0x2d4a(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x2d3a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    0x2d2a(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  0x2d3e(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2d2e(%rip)
mov    0x2cf7(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2cec(%rip)
jmp    2262 <trsapp_+0x1122>
movsd  0x2dcf(%rip),%xmm0
addsd  0x2d7f(%rip),%xmm0
movsd  %xmm0,0x2d77(%rip)
movsd  0x2db7(%rip),%xmm0
divsd  0x2d67(%rip),%xmm0
movsd  %xmm0,0x2de7(%rip)
mov    0x2da8(%rip),%rax
cmp    0x2df9(%rip),%rax
jge    23c4 <trsapp_+0x1284>
movsd  0x2dcb(%rip),%xmm0
movsd  0xc63(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    23c4 <trsapp_+0x1284>
jmp    1a9f <trsapp_+0x95f>
jmp    23c9 <trsapp_+0x1289>
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbp
ret
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x2c5e(%rip)
mov    0x2c57(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     242a <trsapp_+0x12ea>
movsd  0x2d15(%rip),%xmm0
mov    0x38(%rbp),%rax
mov    0x2c3a(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2c2e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2c23(%rip)
jmp    23ea <trsapp_+0x12aa>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x2c18(%rip)
mov    0x2c11(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     25a4 <trsapp_+0x1464>
movsd  0x2cbf(%rip),%xmm0
movsd  %xmm0,0x2c9f(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
movq   $0x1,0x2bd9(%rip)
mov    0x2bd2(%rip),%rax
cmp    -0x50(%rbp),%rax
jg     24e6 <trsapp_+0x13a6>
mov    -0x20(%rbp),%rax
mov    0x2bc5(%rip),%rcx
mov    0x2bb6(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x2b9e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2c41(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2c31(%rip)
mov    0x2b7a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2b6f(%rip)
jmp    2477 <trsapp_+0x1337>
mov    0x10(%rbp),%rax
mov    0x2b67(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x2c02(%rip),%xmm0
movsd  %xmm0,0x2bfa(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
movq   $0x1,0x2b2c(%rip)
mov    0x2b25(%rip),%rax
cmp    -0x50(%rbp),%rax
jg     2588 <trsapp_+0x1448>
movsd  0x2bcb(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x2b18(%rip),%rcx
mov    0x2b01(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    0x2ae9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2ad0(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2ac5(%rip)
jmp    251c <trsapp_+0x13dc>
jmp    258d <trsapp_+0x144d>
mov    0x2ac4(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2ab9(%rip)
jmp    2440 <trsapp_+0x1300>
movq   $0x0,0x2ad1(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
movq   $0x1,0x2a8b(%rip)
mov    0x2a84(%rip),%rax
cmp    -0x50(%rbp),%rax
jg     26d0 <trsapp_+0x1590>
mov    0x2a73(%rip),%rax
mov    %rax,-0x48(%rbp)
movq   $0x1,0x2a5c(%rip)
mov    0x2a55(%rip),%rax
cmp    -0x48(%rbp),%rax
jg     26b4 <trsapp_+0x1574>
mov    0x2a7c(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2a71(%rip)
mov    0x2a32(%rip),%rax
cmp    0x2a33(%rip),%rax
jge    2660 <trsapp_+0x1520>
mov    -0x30(%rbp),%rax
mov    0x2a52(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x2a0a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    0x2a02(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
mov    0x2a15(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    0x29d5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    0x29bd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x29a4(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2999(%rip)
jmp    25ec <trsapp_+0x14ac>
jmp    26b9 <trsapp_+0x1579>
mov    0x2990(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2985(%rip)
jmp    25c5 <trsapp_+0x1485>
cmpq   $0x0,0x2a68(%rip)
jne    26e3 <trsapp_+0x15a3>
jmp    12fc <trsapp_+0x1bc>
mov    0x2a56(%rip),%rax
cmp    0x2a97(%rip),%rax
jg     26fc <trsapp_+0x15bc>
jmp    152c <trsapp_+0x3ec>
jmp    1d43 <trsapp_+0xc03>

x86 assembly (clang, -O2):
<trsapp_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,%r15
mov    %r8,0x58(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rdx,%rbx
mov    %rdi,%rbp
mov    0x108(%rsp),%r14
mov    0xf8(%rsp),%r13
mov    0xe8(%rsp),%r12
mov    %rsi,0x78(%rsp)
mov    (%rsi),%rax
mov    %rax,0x30(%rsp)
not    %rax
mov    %rax,0x10(%rsp)
movabs $0x3fe0000000000000,%rax
mov    %rax,0x3ef6(%rip)
movsd  0x1e46(%rip),%xmm0
call   1050 <atan@plt>
movabs $0x401921fb54442d18,%rax
21 19 40
mov    %rax,0x3f48(%rip)
movsd  (%r12),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x3f0e(%rip)
movq   $0x0,0x3efb(%rip)
mov    %rbp,%r8
mov    0x0(%rbp),%rax
mov    %rax,0x3f2d(%rip)
mov    %rax,0x3f1e(%rip)
mov    %rax,%r12
test   %rax,%rax
jle    13b7 <trsapp_+0x267>
mov    $0x1,%eax
mov    %r12,%rsi
cmp    $0x4,%r12
jb     1320 <trsapp_+0x1d0>
lea    (%rbx,%rsi,8),%rcx
cmp    %r13,%rcx
jbe    123d <trsapp_+0xed>
lea    0x0(,%rsi,8),%rcx
add    %r13,%rcx
cmp    %rbx,%rcx
ja     1320 <trsapp_+0x1d0>
mov    %rsi,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0xc,%rdx
jae    1262 <trsapp_+0x112>
xor    %edx,%edx
jmp    12d5 <trsapp_+0x185>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rdx,8),%xmm0
movups 0x10(%rbx,%rdx,8),%xmm1
movups %xmm0,0x0(%r13,%rdx,8)
movups %xmm1,0x10(%r13,%rdx,8)
movups 0x20(%rbx,%rdx,8),%xmm0
movups 0x30(%rbx,%rdx,8),%xmm1
movups %xmm0,0x20(%r13,%rdx,8)
movups %xmm1,0x30(%r13,%rdx,8)
movups 0x40(%rbx,%rdx,8),%xmm0
movups 0x50(%rbx,%rdx,8),%xmm1
movups %xmm0,0x40(%r13,%rdx,8)
movups %xmm1,0x50(%r13,%rdx,8)
movupd 0x60(%rbx,%rdx,8),%xmm0
movupd 0x70(%rbx,%rdx,8),%xmm1
movupd %xmm0,0x60(%r13,%rdx,8)
movupd %xmm1,0x70(%r13,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1270 <trsapp_+0x120>
test   %rcx,%rcx
je     1310 <trsapp_+0x1c0>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rdx,8),%rsi
or     $0x8,%rsi
movupd -0x8(%rbx,%rsi,1),%xmm0
movupd 0x8(%rbx,%rsi,1),%xmm1
movupd %xmm0,-0x8(%r13,%rsi,1)
movupd %xmm1,0x8(%r13,%rsi,1)
add    $0x4,%rdx
add    $0xffffffffffffffff,%rcx
jne    12e0 <trsapp_+0x190>
cmp    %rax,%r12
je     13b7 <trsapp_+0x267>
or     $0x1,%rax
mov    %r12,%rsi
mov    %esi,%edx
sub    %eax,%edx
add    $0x1,%edx
mov    %rsi,%rcx
sub    %rax,%rcx
and    $0x3,%rdx
je     1357 <trsapp_+0x207>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1340 <trsapp_+0x1f0>
cmp    $0x3,%rcx
jb     13b7 <trsapp_+0x267>
mov    %r12,%rcx
sub    %rax,%rcx
lea    0x10(,%rax,8),%rdx
add    %r13,%rdx
lea    (%rbx,%rax,8),%rax
add    $0x10,%rax
mov    $0xffffffffffffffff,%rsi
nopl   (%rax)
movsd  -0x10(%rax,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%rdx,%rsi,8)
movsd  -0x8(%rax,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rsi,8)
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
movsd  0x8(%rax,%rsi,8),%xmm0
movsd  %xmm0,0x8(%rdx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1380 <trsapp_+0x230>
mov    0x110(%rsp),%r10
mov    0x100(%rsp),%r11
mov    0xf0(%rsp),%r9
mov    0x38(%rsp),%rax
mov    0x10(%rsp),%rbx
lea    (%rax,%rbx,8),%rcx
mov    %rcx,0x40(%rsp)
mov    0x30(%rsp),%rdx
mov    %rdx,%rsi
shl    $0x4,%rsi
lea    0x10(%rax),%rcx
mov    %rcx,0x68(%rsp)
mov    %rdx,%rcx
shl    $0x5,%rcx
mov    %rcx,0xa0(%rsp)
lea    (%rax,%rbx,8),%rax
add    $0x8,%rax
mov    %rax,0x60(%rsp)
lea    (%rdx,%rdx,1),%rbp
lea    -0x8(%r14),%rax
mov    %rax,0x50(%rsp)
lea    -0x8(%r13),%rax
mov    %rax,0x48(%rsp)
movapd 0x1bfe(%rip),%xmm8
mov    %rsi,0x98(%rsp)
mov    %r8,%rbx
mov    %r15,0x70(%rsp)
mov    %r8,0x8(%rsp)
test   %r12,%r12
jg     1461 <trsapp_+0x311>
jmp    1494 <trsapp_+0x344>
xchg   %ax,%ax
mov    $0x1,%edi
mov    %rdi,0x3bf4(%rip)
test   %r12,%r12
jle    1494 <trsapp_+0x344>
lea    0x0(,%r12,8),%rdx
mov    %r14,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
movapd 0x1bb4(%rip),%xmm8
mov    0xf0(%rsp),%r9
mov    0x100(%rsp),%r11
mov    0x110(%rsp),%r10
mov    0x78(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x28(%rsp)
test   %rax,%rax
xorpd  %xmm6,%xmm6
mov    %r12,0x10(%rsp)
jle    17a1 <trsapp_+0x651>
cmpq   $0x1,0x30(%rsp)
sete   %al
lea    0x1(%r12),%r11
lea    (%r14,%r12,8),%rcx
mov    %rcx,0x88(%rsp)
cmp    $0x4,%r12
setae  %cl
and    %al,%cl
mov    %cl,0x7(%rsp)
mov    %r12,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x90(%rsp)
add    $0x1,%rax
mov    %rax,0x80(%rsp)
mov    %r12,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%r9d
mov    0x60(%rsp),%rdx
mov    0x68(%rsp),%r15
mov    0x38(%rsp),%rax
xor    %r8d,%r8d
jmp    155a <trsapp_+0x40a>
nopl   0x0(%rax)
mov    0xe0(%rsp),%rcx
movsd  -0x8(%rcx,%r9,8),%xmm0
mulsd  %xmm6,%xmm0
mov    $0x1,%ecx
lea    0x1(%r9),%rdi
add    $0x1,%r8
add    $0x8,%rax
add    $0x8,%r15
add    $0x8,%rdx
cmp    0x28(%rsp),%r9
mov    %rdi,%r9
je     1770 <trsapp_+0x620>
test   %r12,%r12
jle    1520 <trsapp_+0x3d0>
mov    %rbp,%rbx
xorpd  %xmm0,%xmm0
mov    $0x1,%r10d
cmp    $0x1,%r12
je     15c4 <trsapp_+0x474>
mov    %rax,%rcx
mov    0x30(%rsp),%rbp
mov    0x98(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx),%xmm1
mulsd  -0x8(%r13,%r10,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rcx,%rbp,8),%xmm0
mulsd  0x0(%r13,%r10,8),%xmm0
addsd  %xmm1,%xmm0
add    %r12,%rcx
lea    (%rsi,%r10,1),%rdi
add    $0x2,%rdi
add    $0x2,%r10
cmp    $0x1,%rdi
jne    1590 <trsapp_+0x440>
mov    0x10(%rsp),%rbp
test   $0x1,%bpl
je     15f0 <trsapp_+0x4a0>
mov    %r10,%rcx
imul   0x30(%rsp),%rcx
add    %r9,%rcx
mov    0x40(%rsp),%rdi
movsd  (%rdi,%rcx,8),%xmm1
mulsd  -0x8(%r13,%r10,8),%xmm1
addsd  %xmm1,%xmm0
mov    0xe0(%rsp),%rcx
mulsd  -0x8(%rcx,%r9,8),%xmm0
test   %rbp,%rbp
mov    %rbx,%rbp
jle    16d0 <trsapp_+0x580>
mov    %rbp,%r10
mov    $0x1,%ecx
cmpb   $0x0,0x7(%rsp)
mov    0xa0(%rsp),%rbp
je     16df <trsapp_+0x58f>
mov    0x10(%rsp),%r12
lea    (%r12,%r8,1),%rdi
mov    0x38(%rsp),%rbx
lea    (%rbx,%rdi,8),%rdi
mov    0x90(%rsp),%rbx
cmp    %r14,%rdi
jbe    165c <trsapp_+0x50c>
mov    0x38(%rsp),%rdi
lea    (%rdi,%r8,8),%rdi
cmp    0x88(%rsp),%rdi
jb     16e4 <trsapp_+0x594>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %r15,%rcx
xor    %edi,%edi
nopl   0x0(%rax)
movupd -0x10(%rcx),%xmm2
movupd (%rcx),%xmm3
movupd (%r14,%rdi,8),%xmm4
movupd 0x10(%r14,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r14,%rdi,8)
movupd %xmm3,0x10(%r14,%rdi,8)
add    $0x4,%rdi
add    %rbp,%rcx
cmp    %rdi,%rbx
jne    1670 <trsapp_+0x520>
mov    0x80(%rsp),%rcx
cmp    %rbx,%r12
jne    16e4 <trsapp_+0x594>
mov    %r11,%rcx
mov    %r10,%rbp
jmp    1538 <trsapp_+0x3e8>
nopw   0x0(%rax,%rax,1)
mov    $0x1,%ecx
mov    0x10(%rsp),%r12
jmp    1538 <trsapp_+0x3e8>
mov    0x10(%rsp),%r12
mov    %rcx,%rdi
test   $0x1,%r12b
je     171e <trsapp_+0x5ce>
mov    %rcx,%rdi
imul   0x30(%rsp),%rdi
add    %r9,%rdi
mov    0x40(%rsp),%rbx
movsd  (%rbx,%rdi,8),%xmm1
mov    0x10(%rsp),%r12
mulsd  %xmm0,%xmm1
addsd  -0x8(%r14,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%r14,%rcx,8)
lea    0x1(%rcx),%rdi
cmp    %rcx,%r12
mov    %r10,%rbp
je     1768 <trsapp_+0x618>
mov    0x30(%rsp),%rcx
imul   %rdi,%rcx
nop
movsd  (%rdx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r14,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%r14,%rdi,8)
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rdi,8),%xmm1
movsd  %xmm1,(%r14,%rdi,8)
add    $0x2,%rdi
add    %rbp,%rcx
cmp    %rdi,%r11
jne    1730 <trsapp_+0x5e0>
mov    %r11,%rcx
jmp    1538 <trsapp_+0x3e8>
movsd  %xmm0,0x3950(%rip)
mov    %rcx,0x38d1(%rip)
mov    0x70(%rsp),%r15
mov    0x8(%rsp),%rbx
mov    0x110(%rsp),%r10
mov    0x100(%rsp),%r11
mov    0xf0(%rsp),%r9
test   %r12,%r12
jle    18a0 <trsapp_+0x750>
lea    0x1(%r12),%r8
mov    $0x1,%eax
mov    $0x2,%edx
xor    %esi,%esi
jmp    17d3 <trsapp_+0x683>
nopl   (%rax)
add    $0x1,%rax
lea    0x1(%rdx),%rdi
add    %rcx,%rsi
cmp    %r8,%rdx
mov    %rdi,%rdx
je     1830 <trsapp_+0x6e0>
lea    (%r15,%rsi,8),%rbx
xor    %edi,%edi
jmp    1800 <trsapp_+0x6b0>
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rdi,8),%xmm0
mulsd  -0x8(%r13,%rax,8),%xmm0
addsd  (%r14,%rdi,8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
mov    %rcx,%rdi
cmp    %rcx,%rax
je     17c0 <trsapp_+0x670>
lea    0x1(%rdi),%rcx
cmp    %rax,%rcx
jae    17e0 <trsapp_+0x690>
movsd  (%rbx,%rdi,8),%xmm0
mulsd  0x0(%r13,%rdi,8),%xmm0
addsd  -0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r14,%rax,8)
jmp    17e0 <trsapp_+0x690>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x38b1(%rip),%rax
test   %rax,%rax
je     18d0 <trsapp_+0x780>
cmp    0x38d9(%rip),%rax
mov    0x10(%rsp),%r12
jle    19b0 <trsapp_+0x860>
movq   $0x0,0x380b(%rip)
movq   $0x0,0x3820(%rip)
test   %r12,%r12
jle    19dd <trsapp_+0x88d>
cmp    $0x1,%r12
mov    0x8(%rsp),%rbx
jne    1c6f <trsapp_+0xb1f>
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
test   $0x1,%r12b
jne    1d0d <trsapp_+0xbbd>
jmp    1d3d <trsapp_+0xbed>
nopl   0x0(%rax)
mov    0x3841(%rip),%rax
test   %rax,%rax
je     265e <trsapp_+0x150e>
cmp    0x3869(%rip),%rax
jle    19f0 <trsapp_+0x8a0>
xorpd  %xmm2,%xmm2
xorpd  %xmm0,%xmm0
jmp    1d3d <trsapp_+0xbed>
nopw   0x0(%rax,%rax,1)
movq   $0x0,0x37dd(%rip)
movq   $0x0,0x3772(%rip)
mov    0x10(%rsp),%rdx
test   %rdx,%rdx
mov    0x58(%rsp),%rcx
jle    2674 <trsapp_+0x1524>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
mov    0x8(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%r9,%rax,8)
movq   $0x0,(%r10,%rax,8)
movsd  (%rcx,%rax,8),%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
movapd %xmm0,%xmm2
xorpd  %xmm8,%xmm2
movlpd %xmm2,0x0(%r13,%rax,8)
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rax
cmp    %rax,%rdx
jne    1910 <trsapp_+0x7c0>
movsd  %xmm1,0x36fe(%rip)
mov    %r8,0x36ef(%rip)
mov    0x118(%rsp),%rax
movq   $0x0,(%rax)
ucomisd %xmm6,%xmm1
jne    197c <trsapp_+0x82c>
jnp    269b <trsapp_+0x154b>
movsd  %xmm1,0x36ec(%rip)
movsd  %xmm1,0x374c(%rip)
xorpd  %xmm2,%xmm2
movsd  0x3758(%rip),%xmm3
xor    %eax,%eax
xorpd  %xmm0,%xmm0
jmp    1bb8 <trsapp_+0xa68>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r12,%r12
jle    19eb <trsapp_+0x89b>
lea    -0x1(%r12),%rdx
mov    %r12d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
mov    0x8(%rsp),%rbx
jae    250c <trsapp_+0x13bc>
xorpd  %xmm0,%xmm0
mov    $0x1,%edx
jmp    2579 <trsapp_+0x1429>
xorpd  %xmm2,%xmm2
mov    0x8(%rsp),%rbx
jmp    1d51 <trsapp_+0xc01>
mov    0x8(%rsp),%rbx
xorpd  %xmm0,%xmm0
movsd  0x3714(%rip),%xmm1
movsd  0x366c(%rip),%xmm2
movapd %xmm1,%xmm3
movsd  0x3698(%rip),%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm4
movapd %xmm2,%xmm0
subsd  %xmm4,%xmm0
mulsd  %xmm3,%xmm0
movsd  0x368c(%rip),%xmm4
addsd  %xmm0,%xmm4
movsd  %xmm4,0x3680(%rip)
movq   $0x0,0x362d(%rip)
test   %r12,%r12
jle    1ab0 <trsapp_+0x960>
lea    0x1(%r12),%rcx
xorpd  %xmm7,%xmm7
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%r13,%rdx,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  (%r9,%rdx,8),%xmm5
movsd  %xmm5,(%r9,%rdx,8)
movsd  (%r14,%rdx,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  (%r10,%rdx,8),%xmm5
movsd  %xmm5,(%r10,%rdx,8)
addsd  (%r11,%rdx,8),%xmm5
mulsd  %xmm5,%xmm5
addsd  %xmm5,%xmm7
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1a60 <trsapp_+0x910>
movsd  %xmm7,0x35c4(%rip)
jmp    1ab9 <trsapp_+0x969>
xchg   %ax,%ax
mov    $0x1,%ecx
xorpd  %xmm7,%xmm7
mov    %rcx,0x3590(%rip)
ucomisd %xmm3,%xmm1
jbe    1bf0 <trsapp_+0xaa0>
mulsd  0x1536(%rip),%xmm4
ucomisd %xmm0,%xmm4
jae    269b <trsapp_+0x154b>
movsd  0x35f4(%rip),%xmm0
mulsd  0x1524(%rip),%xmm0
ucomisd %xmm7,%xmm0
jae    269b <trsapp_+0x154b>
cmp    0x362b(%rip),%rax
je     269b <trsapp_+0x154b>
movapd %xmm7,%xmm3
divsd  %xmm2,%xmm3
movsd  %xmm3,0x35b5(%rip)
movq   $0x0,0x353a(%rip)
test   %r12,%r12
jle    2690 <trsapp_+0x1540>
lea    0x1(%r12),%rcx
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13,%rdx,8),%xmm2
mulsd  %xmm3,%xmm2
subsd  (%r11,%rdx,8),%xmm2
subsd  (%r10,%rdx,8),%xmm2
movsd  %xmm2,0x0(%r13,%rdx,8)
movsd  (%r9,%rdx,8),%xmm4
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
unpcklpd %xmm4,%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm2,%xmm1
mulsd  %xmm4,%xmm4
addsd  %xmm4,%xmm0
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1b40 <trsapp_+0x9f0>
movlpd %xmm1,0x34c7(%rip)
mov    %rcx,0x34b8(%rip)
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
ucomisd %xmm2,%xmm6
jae    269b <trsapp_+0x154b>
movsd  0x353e(%rip),%xmm3
ucomisd %xmm0,%xmm3
jbe    1bf0 <trsapp_+0xaa0>
subsd  %xmm0,%xmm3
add    $0x1,%rax
mov    %rax,0x3521(%rip)
movsd  %xmm3,0x34f9(%rip)
mulsd  %xmm3,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm6,%xmm0
jb     1c10 <trsapp_+0xac0>
sqrtsd %xmm0,%xmm0
jmp    1c4e <trsapp_+0xafe>
nopl   0x0(%rax,%rax,1)
mov    0x118(%rsp),%rcx
movq   $0x0,(%rcx)
mov    %rax,0x351a(%rip)
jmp    20ff <trsapp_+0xfaf>
nopl   0x0(%rax,%rax,1)
movapd %xmm2,0x10(%rsp)
movsd  %xmm3,0x28(%rsp)
call   1070 <sqrt@plt>
movsd  0x28(%rsp),%xmm3
movapd 0x10(%rsp),%xmm2
movapd 0x13fa(%rip),%xmm8
mov    0xf0(%rsp),%r9
mov    0x100(%rsp),%r11
mov    0x110(%rsp),%r10
addsd  %xmm0,%xmm2
divsd  %xmm2,%xmm3
movsd  %xmm3,0x34b2(%rip)
mov    (%rbx),%r12
test   %r12,%r12
jg     1461 <trsapp_+0x311>
jmp    1494 <trsapp_+0x344>
mov    %r12,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%r14,%rax,8),%xmm4
movsd  -0x8(%r13,%rax,8),%xmm3
movsd  -0x8(%r11,%rax,8),%xmm5
unpcklpd %xmm3,%xmm5
unpcklpd %xmm4,%xmm3
mulsd  -0x8(%r9,%rax,8),%xmm4
addsd  %xmm0,%xmm4
movsd  (%r14,%rax,8),%xmm0
movsd  0x0(%r13,%rax,8),%xmm2
movsd  (%r11,%rax,8),%xmm6
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
unpcklpd %xmm2,%xmm6
unpcklpd %xmm0,%xmm2
mulpd  %xmm6,%xmm2
movapd %xmm2,%xmm1
addpd  %xmm3,%xmm1
mulsd  (%r9,%rax,8),%xmm0
addsd  %xmm4,%xmm0
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    1c90 <trsapp_+0xb40>
addpd  %xmm3,%xmm2
test   $0x1,%r12b
je     1d3d <trsapp_+0xbed>
movsd  -0x8(%r14,%rax,8),%xmm3
movsd  -0x8(%r13,%rax,8),%xmm2
movsd  -0x8(%r11,%rax,8),%xmm4
unpcklpd %xmm2,%xmm4
unpcklpd %xmm3,%xmm2
mulpd  %xmm4,%xmm2
addpd  %xmm1,%xmm2
mulsd  -0x8(%r9,%rax,8),%xmm3
addsd  %xmm3,%xmm0
movlpd %xmm2,0x3323(%rip)
movsd  %xmm0,0x333b(%rip)
unpckhpd %xmm2,%xmm2
movsd  0x3347(%rip),%xmm0
subsd  %xmm2,%xmm0
mulsd  0x3343(%rip),%xmm0
movsd  %xmm0,0x32f3(%rip)
addsd  0x3303(%rip),%xmm0
movsd  %xmm0,0x3333(%rip)
movsd  %xmm0,0x334b(%rip)
movsd  %xmm0,0x3333(%rip)
movq   $0x0,0x3370(%rip)
movb   $0x1,0x32e1(%rip)
movsd  0x3371(%rip),%xmm1
divsd  0x1269(%rip),%xmm1
movsd  %xmm1,0x3311(%rip)
movq   $0x1,0x328e(%rip)
mov    $0x1,%edx
nopw   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %rdx,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x32fc(%rip)
call   1060 <cos@plt>
movsd  %xmm0,0x329f(%rip)
movsd  0x32e7(%rip),%xmm0
call   1040 <sin@plt>
movsd  0x328a(%rip),%xmm2
movsd  0x3252(%rip),%xmm1
mulsd  %xmm2,%xmm1
addsd  0x325e(%rip),%xmm1
movsd  0x3266(%rip),%xmm3
mulsd  %xmm2,%xmm3
addsd  0x323a(%rip),%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm2,%xmm1
addsd  %xmm3,%xmm1
movsd  0x327e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1e80 <trsapp_+0xd30>
movsd  %xmm1,0x3270(%rip)
mov    0x31f9(%rip),%rax
mov    %rax,0x32aa(%rip)
movsd  0x326a(%rip),%xmm0
movsd  %xmm0,0x328a(%rip)
movapd %xmm1,%xmm0
mov    %rax,%rcx
jmp    1e9f <trsapp_+0xd4f>
nopw   0x0(%rax,%rax,1)
mov    0x31c9(%rip),%rcx
mov    0x327a(%rip),%rax
lea    0x1(%rax),%rdx
cmp    %rdx,%rcx
jne    1e9f <trsapp_+0xd4f>
movsd  %xmm1,0x3261(%rip)
movsd  %xmm1,0x3229(%rip)
lea    0x1(%rcx),%rdx
mov    %rdx,0x319e(%rip)
cmp    $0x30,%rcx
jg     1ed0 <trsapp_+0xd80>
movsd  0x3208(%rip),%xmm1
jmp    1dd0 <trsapp_+0xc80>
cs nopw 0x0(%rax,%rax,1)
nop
test   %rax,%rax
jne    1edd <trsapp_+0xd8d>
movsd  %xmm1,0x321b(%rip)
cmpb   $0x0,0x319c(%rip)
mov    $0x0,%ecx
mov    $0x31,%edx
cmovne %rdx,%rcx
cmp    %rcx,%rax
jne    1f10 <trsapp_+0xdc0>
movsd  0x31b1(%rip),%xmm1
movsd  %xmm1,0x31f9(%rip)
jmp    1f18 <trsapp_+0xdc8>
nopl   0x0(%rax)
movsd  0x31e8(%rip),%xmm1
movsd  0x31d8(%rip),%xmm2
ucomisd %xmm1,%xmm2
xorpd  %xmm3,%xmm3
jne    1f2c <trsapp_+0xddc>
jnp    1f5c <trsapp_+0xe0c>
subsd  %xmm0,%xmm2
movsd  %xmm2,0x31c0(%rip)
subsd  %xmm0,%xmm1
movsd  %xmm1,0x31bc(%rip)
movapd %xmm2,%xmm3
subsd  %xmm1,%xmm3
mulsd  0x3154(%rip),%xmm3
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm3
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm3,%xmm0
mulsd  0x3158(%rip),%xmm0
movsd  %xmm0,0x3168(%rip)
call   1060 <cos@plt>
movsd  %xmm0,0x310b(%rip)
movsd  0x3153(%rip),%xmm0
call   1040 <sin@plt>
movsd  0x30f6(%rip),%xmm3
movsd  0x30be(%rip),%xmm2
mulsd  %xmm3,%xmm2
addsd  0x30ca(%rip),%xmm2
movsd  0x30d2(%rip),%xmm4
mulsd  %xmm3,%xmm4
addsd  0x30a6(%rip),%xmm4
movsd  0x30e6(%rip),%xmm1
movq   $0x0,0x309b(%rip)
mov    (%rbx),%r12
test   %r12,%r12
jle    2080 <trsapp_+0xf30>
lea    0x1(%r12),%rax
xorpd  %xmm7,%xmm7
xor    %ecx,%ecx
mov    0x110(%rsp),%r10
mov    0x100(%rsp),%r11
mov    0xf0(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%r13,%rcx,8),%xmm5
mulsd  %xmm0,%xmm5
movsd  (%r9,%rcx,8),%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
movsd  %xmm6,(%r9,%rcx,8)
movsd  (%r14,%rcx,8),%xmm5
mulsd  %xmm0,%xmm5
movsd  (%r10,%rcx,8),%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
movsd  %xmm6,(%r10,%rcx,8)
addsd  (%r11,%rcx,8),%xmm6
mulsd  %xmm6,%xmm6
addsd  %xmm6,%xmm7
add    $0x1,%rcx
cmp    %rcx,%r12
jne    2010 <trsapp_+0xec0>
movsd  %xmm7,0x3004(%rip)
xorpd  %xmm6,%xmm6
movapd 0xfb7(%rip),%xmm8
jmp    20ae <trsapp_+0xf5e>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%eax
mov    0x110(%rsp),%r10
mov    0x100(%rsp),%r11
mov    0xf0(%rsp),%r9
xorpd  %xmm6,%xmm6
movapd 0xf86(%rip),%xmm8
xorpd  %xmm7,%xmm7
mulsd  %xmm3,%xmm2
subsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm4
subsd  %xmm4,%xmm1
mov    %rax,0x2f8b(%rip)
movsd  0x2feb(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2fdf(%rip)
mov    0x3008(%rip),%rax
cmp    0x3041(%rip),%rax
jge    269b <trsapp_+0x154b>
divsd  %xmm0,%xmm1
ucomisd 0xf0f(%rip),%xmm1
jbe    269b <trsapp_+0x154b>
movsd  0x2fd1(%rip),%xmm0
mulsd  0xf01(%rip),%xmm0
ucomisd %xmm7,%xmm0
jae    269b <trsapp_+0x154b>
movq   $0x0,0x2f54(%rip)
movq   $0x0,0x2f71(%rip)
test   %r12,%r12
jle    2150 <trsapp_+0x1000>
cmp    $0x1,%r12
jne    2160 <trsapp_+0x1010>
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
jmp    21d5 <trsapp_+0x1085>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
mov    $0x1,%r12d
jmp    221c <trsapp_+0x10cc>
nop
mov    %r12,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
xorpd  %xmm1,%xmm1
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%r9,%rax,8),%xmm2
movsd  (%r9,%rax,8),%xmm3
unpcklpd %xmm2,%xmm2
movsd  -0x8(%r11,%rax,8),%xmm4
movsd  (%r11,%rax,8),%xmm0
movhpd -0x8(%r10,%rax,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm1,%xmm4
unpcklpd %xmm3,%xmm3
movhpd (%r10,%rax,8),%xmm0
mulpd  %xmm3,%xmm0
addpd  %xmm4,%xmm0
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    $0x1,%rdx
jne    2180 <trsapp_+0x1030>
test   $0x1,%r12b
je     21fc <trsapp_+0x10ac>
movsd  -0x8(%r9,%rax,8),%xmm1
unpcklpd %xmm1,%xmm1
movsd  -0x8(%r11,%rax,8),%xmm2
movhpd -0x8(%r10,%rax,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm2,%xmm0
add    $0x1,%r12
movlpd %xmm0,0x2e70(%rip)
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
movhpd %xmm0,0x2e88(%rip)
addsd  %xmm0,%xmm1
mov    %r12,0x2e2d(%rip)
movsd  %xmm1,0x2e6d(%rip)
mulsd  0x2ebd(%rip),%xmm7
ucomisd %xmm6,%xmm7
jb     2250 <trsapp_+0x1100>
xorps  %xmm0,%xmm0
sqrtsd %xmm7,%xmm0
jmp    228a <trsapp_+0x113a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm7,%xmm0
movapd %xmm1,0x10(%rsp)
call   1070 <sqrt@plt>
movapd 0x10(%rsp),%xmm1
movapd 0xdc2(%rip),%xmm8
xorpd  %xmm6,%xmm6
mov    0xf0(%rsp),%r9
mov    0x100(%rsp),%r11
mov    0x110(%rsp),%r10
divsd  %xmm0,%xmm1
movsd  0xd8a(%rip),%xmm0
ucomisd %xmm1,%xmm0
jae    269b <trsapp_+0x154b>
addq   $0x1,0x2e40(%rip)
01
movsd  0x2e40(%rip),%xmm0
movsd  0x2de0(%rip),%xmm1
mulsd  0x2db0(%rip),%xmm0
mulsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
ucomisd %xmm6,%xmm0
jb     22e0 <trsapp_+0x1190>
sqrtsd %xmm0,%xmm0
jmp    2306 <trsapp_+0x11b6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   1070 <sqrt@plt>
movapd 0xd42(%rip),%xmm8
mov    0xf0(%rsp),%r9
mov    0x100(%rsp),%r11
mov    0x110(%rsp),%r10
movsd  %xmm0,0x2dba(%rip)
movsd  0x2dda(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x2dd6(%rip)
movsd  0x2d6e(%rip),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x2dca(%rip)
mov    (%rbx),%r12
test   %r12,%r12
jle    1450 <trsapp_+0x300>
xorpd  %xmm8,%xmm2
lea    0x1(%r12),%rdi
mov    $0x1,%ecx
cmp    $0x4,%r12
jae    2400 <trsapp_+0x12b0>
mov    %rcx,%rdx
test   $0x1,%r12b
je     2390 <trsapp_+0x1240>
movsd  -0x8(%r11,%rcx,8),%xmm0
addsd  -0x8(%r10,%rcx,8),%xmm0
movsd  -0x8(%r9,%rcx,8),%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,-0x8(%r13,%rcx,8)
lea    0x1(%rcx),%rdx
cmp    %rcx,%r12
je     1455 <trsapp_+0x305>
lea    0x1(%r12),%rcx
xchg   %ax,%ax
movsd  -0x8(%r11,%rdx,8),%xmm0
addsd  -0x8(%r10,%rdx,8),%xmm0
movsd  -0x8(%r9,%rdx,8),%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,-0x8(%r13,%rdx,8)
movsd  (%r11,%rdx,8),%xmm0
addsd  (%r10,%rdx,8),%xmm0
movsd  (%r9,%rdx,8),%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    23a0 <trsapp_+0x1250>
jmp    1455 <trsapp_+0x305>
nopl   0x0(%rax,%rax,1)
mov    %rdi,0x28(%rsp)
lea    (%r11,%r12,8),%rax
cmp    %r13,%rax
seta   %dil
lea    0x0(,%r12,8),%rsi
add    %r13,%rsi
cmp    %r11,%rsi
seta   %al
lea    (%r10,%r12,8),%rdx
cmp    %r13,%rdx
seta   %dl
cmp    %r10,%rsi
seta   %r8b
mov    %r12,0x10(%rsp)
lea    (%r9,%r12,8),%rbx
cmp    %r13,%rbx
seta   %bl
cmp    %r9,%rsi
seta   %sil
test   %al,%dil
jne    2642 <trsapp_+0x14f2>
and    %r8b,%dl
jne    2642 <trsapp_+0x14f2>
and    %sil,%bl
mov    0xf0(%rsp),%r9
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%r12
mov    0x28(%rsp),%rdi
jne    235b <trsapp_+0x120b>
mov    %r12,%rdx
and    $0xfffffffffffffffc,%rdx
lea    0x1(%rdx),%rcx
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd (%r11,%rsi,8),%xmm4
movupd 0x10(%r11,%rsi,8),%xmm5
movupd (%r10,%rsi,8),%xmm6
addpd  %xmm4,%xmm6
movupd 0x10(%r10,%rsi,8),%xmm4
addpd  %xmm5,%xmm4
movupd (%r9,%rsi,8),%xmm5
movupd 0x10(%r9,%rsi,8),%xmm7
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm7
mulpd  %xmm3,%xmm6
addpd  %xmm5,%xmm6
mulpd  %xmm3,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm6,0x0(%r13,%rsi,8)
movupd %xmm4,0x10(%r13,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    24a0 <trsapp_+0x1350>
cmp    %rdx,%r12
je     1455 <trsapp_+0x305>
jmp    235b <trsapp_+0x120b>
mov    %r12,%rsi
and    $0xfffffffffffffffc,%rsi
neg    %rsi
xorpd  %xmm0,%xmm0
mov    $0x1,%edx
nop
movsd  -0x8(%r13,%rdx,8),%xmm1
mulsd  -0x8(%r14,%rdx,8),%xmm1
movsd  0x0(%r13,%rdx,8),%xmm2
addsd  %xmm0,%xmm1
mulsd  (%r14,%rdx,8),%xmm2
addsd  %xmm1,%xmm2
movsd  0x8(%r13,%rdx,8),%xmm1
mulsd  0x8(%r14,%rdx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  0x10(%r13,%rdx,8),%xmm0
mulsd  0x10(%r14,%rdx,8),%xmm0
addsd  %xmm1,%xmm0
lea    (%rsi,%rdx,1),%rdi
add    $0x4,%rdi
add    $0x4,%rdx
cmp    $0x1,%rdi
jne    2520 <trsapp_+0x13d0>
test   %rcx,%rcx
je     25b7 <trsapp_+0x1467>
mov    0x50(%rsp),%rsi
lea    (%rsi,%rdx,8),%rsi
mov    0x48(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%rdi,8),%xmm1
mulsd  (%rsi,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    25a0 <trsapp_+0x1450>
movsd  0x2b51(%rip),%xmm1
ucomisd %xmm6,%xmm0
jbe    19fc <trsapp_+0x8ac>
movapd %xmm0,%xmm2
divsd  0x2a83(%rip),%xmm2
movsd  %xmm2,0x2aeb(%rip)
movapd %xmm2,%xmm3
cmp    $0x1,%rax
je     25f3 <trsapp_+0x14a3>
mov    0x118(%rsp),%rcx
movsd  (%rcx),%xmm3
movapd %xmm3,%xmm4
cmplesd %xmm2,%xmm4
andpd  %xmm4,%xmm3
andnpd %xmm2,%xmm4
orpd   %xmm3,%xmm4
mov    0x118(%rsp),%rcx
movlpd %xmm4,(%rcx)
movsd  0x2a54(%rip),%xmm2
movapd %xmm2,%xmm4
divsd  %xmm0,%xmm4
movapd %xmm1,%xmm3
cmplesd %xmm4,%xmm3
movapd %xmm3,%xmm5
andnpd %xmm4,%xmm5
andpd  %xmm1,%xmm3
orpd   %xmm5,%xmm3
jmp    1a08 <trsapp_+0x8b8>
mov    0xf0(%rsp),%r9
mov    0x8(%rsp),%rbx
mov    0x10(%rsp),%r12
mov    0x28(%rsp),%rdi
jmp    235b <trsapp_+0x120b>
movq   $0x0,0x2a4f(%rip)
movq   $0x0,0x29e4(%rip)
movq   $0x1,0x29d1(%rip)
mov    0x118(%rsp),%rax
movq   $0x0,(%rax)
jmp    269b <trsapp_+0x154b>
movq   $0x1,0x29b5(%rip)
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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