int bigden_(long int *n, long int *npt, double *xopt, double *xpt, double *bmat,
            double *zmat, long int *idz, long int *ndim, long int *kopt,
            long int *knew, double *d__, double *w, double *vlag, double *beta,
            double *s, double *wvec, double *prod) {
  long int xpt_dim1, xpt_offset, bmat_dim1, bmat_offset, zmat_dim1, zmat_offset,
      wvec_dim1, wvec_offset, prod_dim1, prod_offset, i__1, i__2;
  double d__1;
  double atan(double), sqrt(double), cos(double), sin(double);
  static long int i__, j, k;
  static double dd;
  static long int jc;
  static double ds;
  static long int ip, iu, nw;
  static double ss, den[9], one, par[9], tau, sum, two, diff, half, temp;
  static long int ksav;
  static double step;
  static long int nptm;
  static double zero, alpha, angle, denex[9];
  static long int iterc;
  static double tempa, tempb, tempc;
  static long int isave;
  static double ssden, dtest, quart, xoptd, twopi, xopts, denold, denmax,
      densav, dstemp, sumold, sstemp, xoptsq;
  zmat_dim1 = *npt;
  zmat_offset = 1 + zmat_dim1;
  zmat -= zmat_offset;
  xpt_dim1 = *npt;
  xpt_offset = 1 + xpt_dim1;
  xpt -= xpt_offset;
  --xopt;
  prod_dim1 = *ndim;
  prod_offset = 1 + prod_dim1;
  prod -= prod_offset;
  wvec_dim1 = *ndim;
  wvec_offset = 1 + wvec_dim1;
  wvec -= wvec_offset;
  bmat_dim1 = *ndim;
  bmat_offset = 1 + bmat_dim1;
  bmat -= bmat_offset;
  --d__;
  --w;
  --vlag;
  --s;
  half = .5;
  one = 1.;
  quart = .25;
  two = 2.;
  zero = 0.;
  twopi = atan(one) * 8.;
  nptm = *npt - *n - 1;
  i__1 = *npt;
  for (k = 1; k <= i__1; ++k) {
    w[*n + k] = zero;
  }
  i__1 = nptm;
  for (j = 1; j <= i__1; ++j) {
    temp = zmat[*knew + j * zmat_dim1];
    if (j < *idz) {
      temp = -temp;
    }
    i__2 = *npt;
    for (k = 1; k <= i__2; ++k) {
      w[*n + k] += temp * zmat[k + j * zmat_dim1];
    }
  }
  alpha = w[*n + *knew];
  dd = zero;
  ds = zero;
  ss = zero;
  xoptsq = zero;
  i__2 = *n;
  for (i__ = 1; i__ <= i__2; ++i__) {
    d__1 = d__[i__];
    dd += d__1 * d__1;
    s[i__] = xpt[*knew + i__ * xpt_dim1] - xopt[i__];
    ds += d__[i__] * s[i__];
    d__1 = s[i__];
    ss += d__1 * d__1;
    d__1 = xopt[i__];
    xoptsq += d__1 * d__1;
  }
  if (ds * ds > dd * .99 * ss) {
    ksav = *knew;
    dtest = ds * ds / ss;
    i__2 = *npt;
    for (k = 1; k <= i__2; ++k) {
      if (k != *kopt) {
        dstemp = zero;
        sstemp = zero;
        i__1 = *n;
        for (i__ = 1; i__ <= i__1; ++i__) {
          diff = xpt[k + i__ * xpt_dim1] - xopt[i__];
          dstemp += d__[i__] * diff;
          sstemp += diff * diff;
        }
        if (dstemp * dstemp / sstemp < dtest) {
          ksav = k;
          dtest = dstemp * dstemp / sstemp;
          ds = dstemp;
          ss = sstemp;
        }
      }
    }
    i__2 = *n;
    for (i__ = 1; i__ <= i__2; ++i__) {
      s[i__] = xpt[ksav + i__ * xpt_dim1] - xopt[i__];
    }
  }
  ssden = dd * ss - ds * ds;
  iterc = 0;
  densav = zero;
L70:
  ++iterc;
  temp = one / sqrt(ssden);
  xoptd = zero;
  xopts = zero;
  i__2 = *n;
  for (i__ = 1; i__ <= i__2; ++i__) {
    s[i__] = temp * (dd * s[i__] - ds * d__[i__]);
    xoptd += xopt[i__] * d__[i__];
    xopts += xopt[i__] * s[i__];
  }
  tempa = half * xoptd * xoptd;
  tempb = half * xopts * xopts;
  den[0] = dd * (xoptsq + half * dd) + tempa + tempb;
  den[1] = two * xoptd * dd;
  den[2] = two * xopts * dd;
  den[3] = tempa - tempb;
  den[4] = xoptd * xopts;
  for (i__ = 6; i__ <= 9; ++i__) {
    den[i__ - 1] = zero;
  }
  i__2 = *npt;
  for (k = 1; k <= i__2; ++k) {
    tempa = zero;
    tempb = zero;
    tempc = zero;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      tempa += xpt[k + i__ * xpt_dim1] * d__[i__];
      tempb += xpt[k + i__ * xpt_dim1] * s[i__];
      tempc += xpt[k + i__ * xpt_dim1] * xopt[i__];
    }
    wvec[k + wvec_dim1] = quart * (tempa * tempa + tempb * tempb);
    wvec[k + (wvec_dim1 << 1)] = tempa * tempc;
    wvec[k + wvec_dim1 * 3] = tempb * tempc;
    wvec[k + (wvec_dim1 << 2)] = quart * (tempa * tempa - tempb * tempb);
    wvec[k + wvec_dim1 * 5] = half * tempa * tempb;
  }
  i__2 = *n;
  for (i__ = 1; i__ <= i__2; ++i__) {
    ip = i__ + *npt;
    wvec[ip + wvec_dim1] = zero;
    wvec[ip + (wvec_dim1 << 1)] = d__[i__];
    wvec[ip + wvec_dim1 * 3] = s[i__];
    wvec[ip + (wvec_dim1 << 2)] = zero;
    wvec[ip + wvec_dim1 * 5] = zero;
  }
  for (jc = 1; jc <= 5; ++jc) {
    nw = *npt;
    if (jc == 2 || jc == 3) {
      nw = *ndim;
    }
    i__2 = *npt;
    for (k = 1; k <= i__2; ++k) {
      prod[k + jc * prod_dim1] = zero;
    }
    i__2 = nptm;
    for (j = 1; j <= i__2; ++j) {
      sum = zero;
      i__1 = *npt;
      for (k = 1; k <= i__1; ++k) {
        sum += zmat[k + j * zmat_dim1] * wvec[k + jc * wvec_dim1];
      }
      if (j < *idz) {
        sum = -sum;
      }
      i__1 = *npt;
      for (k = 1; k <= i__1; ++k) {
        prod[k + jc * prod_dim1] += sum * zmat[k + j * zmat_dim1];
      }
    }
    if (nw == *ndim) {
      i__1 = *npt;
      for (k = 1; k <= i__1; ++k) {
        sum = zero;
        i__2 = *n;
        for (j = 1; j <= i__2; ++j) {
          sum += bmat[k + j * bmat_dim1] * wvec[*npt + j + jc * wvec_dim1];
        }
        prod[k + jc * prod_dim1] += sum;
      }
    }
    i__1 = *n;
    for (j = 1; j <= i__1; ++j) {
      sum = zero;
      i__2 = nw;
      for (i__ = 1; i__ <= i__2; ++i__) {
        sum += bmat[i__ + j * bmat_dim1] * wvec[i__ + jc * wvec_dim1];
      }
      prod[*npt + j + jc * prod_dim1] = sum;
    }
  }
  i__1 = *ndim;
  for (k = 1; k <= i__1; ++k) {
    sum = zero;
    for (i__ = 1; i__ <= 5; ++i__) {
      par[i__ - 1] =
          half * prod[k + i__ * prod_dim1] * wvec[k + i__ * wvec_dim1];
      sum += par[i__ - 1];
    }
    den[0] = den[0] - par[0] - sum;
    tempa = prod[k + prod_dim1] * wvec[k + (wvec_dim1 << 1)] +
            prod[k + (prod_dim1 << 1)] * wvec[k + wvec_dim1];
    tempb = prod[k + (prod_dim1 << 1)] * wvec[k + (wvec_dim1 << 2)] +
            prod[k + (prod_dim1 << 2)] * wvec[k + (wvec_dim1 << 1)];
    tempc = prod[k + prod_dim1 * 3] * wvec[k + wvec_dim1 * 5] +
            prod[k + prod_dim1 * 5] * wvec[k + wvec_dim1 * 3];
    den[1] = den[1] - tempa - half * (tempb + tempc);
    den[5] -= half * (tempb - tempc);
    tempa = prod[k + prod_dim1] * wvec[k + wvec_dim1 * 3] +
            prod[k + prod_dim1 * 3] * wvec[k + wvec_dim1];
    tempb = prod[k + (prod_dim1 << 1)] * wvec[k + wvec_dim1 * 5] +
            prod[k + prod_dim1 * 5] * wvec[k + (wvec_dim1 << 1)];
    tempc = prod[k + prod_dim1 * 3] * wvec[k + (wvec_dim1 << 2)] +
            prod[k + (prod_dim1 << 2)] * wvec[k + wvec_dim1 * 3];
    den[2] = den[2] - tempa - half * (tempb - tempc);
    den[6] -= half * (tempb + tempc);
    tempa = prod[k + prod_dim1] * wvec[k + (wvec_dim1 << 2)] +
            prod[k + (prod_dim1 << 2)] * wvec[k + wvec_dim1];
    den[3] = den[3] - tempa - par[1] + par[2];
    tempa = prod[k + prod_dim1] * wvec[k + wvec_dim1 * 5] +
            prod[k + prod_dim1 * 5] * wvec[k + wvec_dim1];
    tempb = prod[k + (prod_dim1 << 1)] * wvec[k + wvec_dim1 * 3] +
            prod[k + prod_dim1 * 3] * wvec[k + (wvec_dim1 << 1)];
    den[4] = den[4] - tempa - half * tempb;
    den[7] = den[7] - par[3] + par[4];
    tempa = prod[k + (prod_dim1 << 2)] * wvec[k + wvec_dim1 * 5] +
            prod[k + prod_dim1 * 5] * wvec[k + (wvec_dim1 << 2)];
    den[8] -= half * tempa;
  }
  sum = zero;
  for (i__ = 1; i__ <= 5; ++i__) {
    d__1 = prod[*knew + i__ * prod_dim1];
    par[i__ - 1] = half * (d__1 * d__1);
    sum += par[i__ - 1];
  }
  denex[0] = alpha * den[0] + par[0] + sum;
  tempa = two * prod[*knew + prod_dim1] * prod[*knew + (prod_dim1 << 1)];
  tempb = prod[*knew + (prod_dim1 << 1)] * prod[*knew + (prod_dim1 << 2)];
  tempc = prod[*knew + prod_dim1 * 3] * prod[*knew + prod_dim1 * 5];
  denex[1] = alpha * den[1] + tempa + tempb + tempc;
  denex[5] = alpha * den[5] + tempb - tempc;
  tempa = two * prod[*knew + prod_dim1] * prod[*knew + prod_dim1 * 3];
  tempb = prod[*knew + (prod_dim1 << 1)] * prod[*knew + prod_dim1 * 5];
  tempc = prod[*knew + prod_dim1 * 3] * prod[*knew + (prod_dim1 << 2)];
  denex[2] = alpha * den[2] + tempa + tempb - tempc;
  denex[6] = alpha * den[6] + tempb + tempc;
  tempa = two * prod[*knew + prod_dim1] * prod[*knew + (prod_dim1 << 2)];
  denex[3] = alpha * den[3] + tempa + par[1] - par[2];
  tempa = two * prod[*knew + prod_dim1] * prod[*knew + prod_dim1 * 5];
  denex[4] = alpha * den[4] + tempa +
             prod[*knew + (prod_dim1 << 1)] * prod[*knew + prod_dim1 * 3];
  denex[7] = alpha * den[7] + par[3] - par[4];
  denex[8] = alpha * den[8] +
             prod[*knew + (prod_dim1 << 2)] * prod[*knew + prod_dim1 * 5];
  sum = denex[0] + denex[1] + denex[3] + denex[5] + denex[7];
  denold = sum;
  denmax = sum;
  isave = 0;
  iu = 49;
  temp = twopi / (double)(iu + 1);
  par[0] = one;
  i__1 = iu;
  for (i__ = 1; i__ <= i__1; ++i__) {
    angle = (double)i__ * temp;
    par[1] = cos(angle);
    par[2] = sin(angle);
    for (j = 4; j <= 8; j += 2) {
      par[j - 1] = par[1] * par[j - 3] - par[2] * par[j - 2];
      par[j] = par[1] * par[j - 2] + par[2] * par[j - 3];
    }
    sumold = sum;
    sum = zero;
    for (j = 1; j <= 9; ++j) {
      sum += denex[j - 1] * par[j - 1];
    }
    if (abs(sum) > abs(denmax)) {
      denmax = sum;
      isave = i__;
      tempa = sumold;
    } else if (i__ == isave + 1) {
      tempb = sum;
    }
  }
  if (isave == 0) {
    tempa = sum;
  }
  if (isave == iu) {
    tempb = denold;
  }
  step = zero;
  if (tempa != tempb) {
    tempa -= denmax;
    tempb -= denmax;
    step = half * (tempa - tempb) / (tempa + tempb);
  }
  angle = temp * ((double)isave + step);
  par[1] = cos(angle);
  par[2] = sin(angle);
  for (j = 4; j <= 8; j += 2) {
    par[j - 1] = par[1] * par[j - 3] - par[2] * par[j - 2];
    par[j] = par[1] * par[j - 2] + par[2] * par[j - 3];
  }
  *beta = zero;
  denmax = zero;
  for (j = 1; j <= 9; ++j) {
    *beta += den[j - 1] * par[j - 1];
    denmax += denex[j - 1] * par[j - 1];
  }
  i__1 = *ndim;
  for (k = 1; k <= i__1; ++k) {
    vlag[k] = zero;
    for (j = 1; j <= 5; ++j) {
      vlag[k] += prod[k + j * prod_dim1] * par[j - 1];
    }
  }
  tau = vlag[*knew];
  dd = zero;
  tempa = zero;
  tempb = zero;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    d__[i__] = par[1] * d__[i__] + par[2] * s[i__];
    w[i__] = xopt[i__] + d__[i__];
    d__1 = d__[i__];
    dd += d__1 * d__1;
    tempa += d__[i__] * w[i__];
    tempb += w[i__] * w[i__];
  }
  if (iterc >= *n) {
    goto L340;
  }
  if (iterc > 1) {
    densav = ((densav) >= (denold) ? (densav) : (denold));
  }
  if (abs(denmax) <= abs(densav) * 1.1) {
    goto L340;
  }
  densav = denmax;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    temp = tempa * xopt[i__] + tempb * d__[i__] - vlag[*npt + i__];
    s[i__] = tau * bmat[*knew + i__ * bmat_dim1] + alpha * temp;
  }
  i__1 = *npt;
  for (k = 1; k <= i__1; ++k) {
    sum = zero;
    i__2 = *n;
    for (j = 1; j <= i__2; ++j) {
      sum += xpt[k + j * xpt_dim1] * w[j];
    }
    temp = (tau * w[*n + k] - alpha * vlag[k]) * sum;
    i__2 = *n;
    for (i__ = 1; i__ <= i__2; ++i__) {
      s[i__] += temp * xpt[k + i__ * xpt_dim1];
    }
  }
  ss = zero;
  ds = zero;
  i__2 = *n;
  for (i__ = 1; i__ <= i__2; ++i__) {
    d__1 = s[i__];
    ss += d__1 * d__1;
    ds += d__[i__] * s[i__];
  }
  ssden = dd * ss - ds * ds;
  if (ssden >= dd * 1e-8 * ss) {
    goto L70;
  }
L340:
  i__2 = *ndim;
  for (k = 1; k <= i__2; ++k) {
    w[k] = zero;
    for (j = 1; j <= 5; ++j) {
      w[k] += wvec[k + j * wvec_dim1] * par[j - 1];
    }
  }
  vlag[*kopt] += one;
  return 0;
}


x86 assembly (clang, -O0):
<bigden_>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-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,-0x58(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rdx
mov    -0x30(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-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    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rdx
mov    0x60(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x60(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rdx
mov    0x58(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x58(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdx
mov    -0x28(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rbp)
mov    0x50(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x50(%rbp)
movsd  0x3d52(%rip),%xmm0
movsd  %xmm0,0x5e92(%rip)
movsd  0x3d3a(%rip),%xmm0
movsd  %xmm0,0x5e12(%rip)
movsd  0x3d22(%rip),%xmm0
movsd  %xmm0,0x5f3a(%rip)
movsd  0x3d0a(%rip),%xmm0
movsd  %xmm0,0x5e52(%rip)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x5e7f(%rip)
movsd  0x5ddf(%rip),%xmm0
call   1050 <atan@plt>
movsd  0x3cda(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x5f0e(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
sub    (%rcx),%rax
sub    $0x1,%rax
mov    %rax,0x5e3d(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x5d0c(%rip)
mov    0x5d05(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     13ae <bigden_+0x25e>
movsd  0x5e10(%rip),%xmm0
mov    0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
add    0x5cde(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x5cd2(%rip),%rax
add    $0x1,%rax
mov    %rax,0x5cc7(%rip)
jmp    1364 <bigden_+0x214>
mov    0x5dd3(%rip),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x5ca1(%rip)
mov    0x5c9a(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     14e8 <bigden_+0x398>
mov    -0x30(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x5c7b(%rip),%rdx
imul   -0x58(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x5d6e(%rip)
mov    0x5c5f(%rip),%rax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%rax
jge    143d <bigden_+0x2ed>
movsd  0x5d52(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,0x5d33(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x5c1a(%rip)
mov    0x5c13(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     14cc <bigden_+0x37c>
movsd  0x5cfe(%rip),%xmm0
mov    -0x30(%rbp),%rax
mov    0x5bf3(%rip),%rcx
mov    0x5be4(%rip),%rdx
imul   -0x58(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
add    0x5bcd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x5bb4(%rip),%rax
add    $0x1,%rax
mov    %rax,0x5ba9(%rip)
jmp    1456 <bigden_+0x306>
jmp    14d1 <bigden_+0x381>
mov    0x5b90(%rip),%rax
add    $0x1,%rax
mov    %rax,0x5b85(%rip)
jmp    13c7 <bigden_+0x277>
mov    0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x28(%rbp),%rdx
add    (%rdx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x5c91(%rip)
movsd  0x5c81(%rip),%xmm0
movsd  %xmm0,0x5b61(%rip)
movsd  0x5c71(%rip),%xmm0
movsd  %xmm0,0x5b61(%rip)
movsd  0x5c61(%rip),%xmm0
movsd  %xmm0,0x5b71(%rip)
movsd  0x5c51(%rip),%xmm0
movsd  %xmm0,0x5d39(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x5b00(%rip)
mov    0x5af9(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     16c2 <bigden_+0x572>
mov    0x30(%rbp),%rax
mov    0x5ae1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  0x5ad4(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5ac4(%rip)
mov    -0x20(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x5a9a(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    0x5a82(%rip),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x5a72(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x5a62(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x5a52(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x5a6d(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5a5d(%rip)
mov    0x50(%rbp),%rax
mov    0x5a2a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  0x5a4d(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5a3d(%rip)
mov    -0x18(%rbp),%rax
mov    0x59ea(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  0x5be5(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5bd5(%rip)
mov    0x59ae(%rip),%rax
add    $0x1,%rax
mov    %rax,0x59a3(%rip)
jmp    1560 <bigden_+0x410>
movsd  0x59be(%rip),%xmm0
mulsd  0x59b6(%rip),%xmm0
movsd  0x394e(%rip),%xmm1
mulsd  0x5996(%rip),%xmm1
mulsd  0x59be(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1977 <bigden_+0x827>
mov    0x28(%rbp),%rax
mov    (%rax),%rax
mov    %rax,0x5a76(%rip)
movsd  0x597e(%rip),%xmm0
mulsd  0x5976(%rip),%xmm0
divsd  0x598e(%rip),%xmm0
movsd  %xmm0,0x5b06(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x5935(%rip)
mov    0x592e(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     18ef <bigden_+0x79f>
mov    0x591a(%rip),%rax
mov    0x20(%rbp),%rcx
cmp    (%rcx),%rax
je     18d3 <bigden_+0x783>
movsd  0x5a25(%rip),%xmm0
movsd  %xmm0,0x5af5(%rip)
movsd  0x5a15(%rip),%xmm0
movsd  %xmm0,0x5af5(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x58c4(%rip)
mov    0x58bd(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     1856 <bigden_+0x706>
mov    -0x20(%rbp),%rax
mov    0x58b5(%rip),%rcx
mov    0x589e(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    0x5886(%rip),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x5979(%rip)
mov    0x30(%rbp),%rax
mov    0x586e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x5961(%rip),%xmm2
movsd  0x5a61(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5a51(%rip)
movsd  0x5941(%rip),%xmm0
movsd  0x5939(%rip),%xmm2
movsd  0x5a49(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5a39(%rip)
mov    0x581a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x580f(%rip)
jmp    179c <bigden_+0x64c>
movsd  0x5a0a(%rip),%xmm1
mulsd  0x5a02(%rip),%xmm1
divsd  0x5a0a(%rip),%xmm1
movsd  0x59b2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    18ce <bigden_+0x77e>
mov    0x57e9(%rip),%rax
mov    %rax,0x58ea(%rip)
movsd  0x59d2(%rip),%xmm0
mulsd  0x59ca(%rip),%xmm0
divsd  0x59d2(%rip),%xmm0
movsd  %xmm0,0x597a(%rip)
movsd  0x59b2(%rip),%xmm0
movsd  %xmm0,0x57ca(%rip)
movsd  0x59b2(%rip),%xmm0
movsd  %xmm0,0x57da(%rip)
jmp    18d3 <bigden_+0x783>
jmp    18d8 <bigden_+0x788>
mov    0x5791(%rip),%rax
add    $0x1,%rax
mov    %rax,0x5786(%rip)
jmp    173b <bigden_+0x5eb>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x5758(%rip)
mov    0x5751(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     1972 <bigden_+0x822>
mov    -0x20(%rbp),%rax
mov    0x5851(%rip),%rcx
mov    0x5732(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    0x571a(%rip),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x570a(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x56fe(%rip),%rax
add    $0x1,%rax
mov    %rax,0x56f3(%rip)
jmp    1908 <bigden_+0x7b8>
jmp    1977 <bigden_+0x827>
movsd  0x56f9(%rip),%xmm0
movsd  0x5721(%rip),%xmm2
movsd  0x56f9(%rip),%xmm1
mulsd  0x56f1(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5862(%rip)
movq   $0x0,0x582f(%rip)
movsd  0x57bf(%rip),%xmm0
movsd  %xmm0,0x5887(%rip)
mov    0x5818(%rip),%rax
add    $0x1,%rax
mov    %rax,0x580d(%rip)
movsd  0x5705(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x581d(%rip),%xmm0
call   1070 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5751(%rip)
movsd  0x5769(%rip),%xmm0
movsd  %xmm0,0x5809(%rip)
movsd  0x5759(%rip),%xmm0
movsd  %xmm0,0x5809(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x5608(%rip)
mov    0x5601(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     1b5e <bigden_+0xa0e>
movsd  0x56fc(%rip),%xmm0
movsd  0x55fc(%rip),%xmm1
mov    0x50(%rbp),%rax
mov    0x55d9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  0x55f4(%rip),%xmm2
mov    0x30(%rbp),%rax
mov    0x55c1(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    0x558e(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    0x557e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x556e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x5739(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5729(%rip)
mov    -0x18(%rbp),%rax
mov    0x5546(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x5536(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x5711(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5701(%rip)
mov    0x5512(%rip),%rax
add    $0x1,%rax
mov    %rax,0x5507(%rip)
jmp    1a58 <bigden_+0x908>
movsd  0x5602(%rip),%xmm0
mulsd  0x56ca(%rip),%xmm0
mulsd  0x56c2(%rip),%xmm0
movsd  %xmm0,0x5682(%rip)
movsd  0x55e2(%rip),%xmm0
mulsd  0x56ba(%rip),%xmm0
mulsd  0x56b2(%rip),%xmm0
movsd  %xmm0,0x566a(%rip)
movsd  0x54d2(%rip),%xmm0
movsd  0x56d2(%rip),%xmm1
movsd  0x55b2(%rip),%xmm2
movsd  0x54ba(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x5632(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  0x562a(%rip),%xmm0
movsd  %xmm0,0x54ca(%rip)
movsd  0x556a(%rip),%xmm0
mulsd  0x5642(%rip),%xmm0
mulsd  0x547a(%rip),%xmm0
movsd  %xmm0,0x54b2(%rip)
movsd  0x554a(%rip),%xmm0
mulsd  0x5632(%rip),%xmm0
mulsd  0x545a(%rip),%xmm0
movsd  %xmm0,0x549a(%rip)
movsd  0x55d2(%rip),%xmm0
subsd  0x55d2(%rip),%xmm0
movsd  %xmm0,0x548a(%rip)
movsd  0x55f2(%rip),%xmm0
mulsd  0x55fa(%rip),%xmm0
movsd  %xmm0,0x547a(%rip)
movq   $0x6,0x53ff(%rip)
cmpq   $0x9,0x53f7(%rip)
09
jg     1ca5 <bigden_+0xb55>
movsd  0x5519(%rip),%xmm0
mov    0x53e2(%rip),%rcx
sub    $0x1,%rcx
lea    0x5427(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    0x53cb(%rip),%rax
add    $0x1,%rax
mov    %rax,0x53c0(%rip)
jmp    1c61 <bigden_+0xb11>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x53b2(%rip)
mov    0x53ab(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     1f63 <bigden_+0xe13>
movsd  0x54b6(%rip),%xmm0
movsd  %xmm0,0x551e(%rip)
movsd  0x54a6(%rip),%xmm0
movsd  %xmm0,0x5516(%rip)
movsd  0x5496(%rip),%xmm0
movsd  %xmm0,0x550e(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x5345(%rip)
mov    0x533e(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     1e1b <bigden_+0xccb>
mov    -0x20(%rbp),%rax
mov    0x5336(%rip),%rcx
mov    0x531f(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x5307(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x549a(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x548a(%rip)
mov    -0x20(%rbp),%rax
mov    0x52ef(%rip),%rcx
mov    0x52d8(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x52c0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x545b(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x544b(%rip)
mov    -0x20(%rbp),%rax
mov    0x52a8(%rip),%rcx
mov    0x5291(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    0x5279(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x541c(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x540c(%rip)
mov    0x5255(%rip),%rax
add    $0x1,%rax
mov    %rax,0x524a(%rip)
jmp    1d1b <bigden_+0xbcb>
movsd  0x540d(%rip),%xmm0
movsd  0x53d5(%rip),%xmm1
movsd  0x53cd(%rip),%xmm3
movsd  0x53cd(%rip),%xmm2
mulsd  0x53c5(%rip),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x58(%rbp),%rax
mov    0x5216(%rip),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5395(%rip),%xmm0
mulsd  0x539d(%rip),%xmm0
mov    0x58(%rbp),%rax
mov    0x51f2(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5372(%rip),%xmm0
mulsd  0x5372(%rip),%xmm0
mov    0x58(%rbp),%rax
mov    0x51c7(%rip),%rcx
imul   $0x3,-0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5372(%rip),%xmm0
movsd  0x533a(%rip),%xmm1
movsd  0x5332(%rip),%xmm3
movsd  0x5332(%rip),%xmm2
mulsd  0x532a(%rip),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    0x58(%rbp),%rax
mov    0x5164(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5244(%rip),%xmm0
mulsd  0x52d4(%rip),%xmm0
mulsd  0x52d4(%rip),%xmm0
mov    0x58(%rbp),%rax
mov    0x5131(%rip),%rcx
imul   $0x5,-0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x511d(%rip),%rax
add    $0x1,%rax
mov    %rax,0x5112(%rip)
jmp    1cbe <bigden_+0xb6e>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x50e4(%rip)
mov    0x50dd(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     206e <bigden_+0xf1e>
mov    0x50c9(%rip),%rax
mov    -0x10(%rbp),%rcx
add    (%rcx),%rax
mov    %rax,0x50eb(%rip)
movsd  0x51e3(%rip),%xmm0
mov    0x58(%rbp),%rax
mov    0x50d8(%rip),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x5094(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x50b4(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    0x5069(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x5089(%rip),%rcx
imul   $0x3,-0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5174(%rip),%xmm0
mov    0x58(%rbp),%rax
mov    0x5069(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5151(%rip),%xmm0
mov    0x58(%rbp),%rax
mov    0x5046(%rip),%rcx
imul   $0x5,-0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x5002(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4ff7(%rip)
jmp    1f7c <bigden_+0xe2c>
movq   $0x1,0x5007(%rip)
cmpq   $0x5,0x4fff(%rip)
05
jg     2561 <bigden_+0x1411>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,0x500b(%rip)
cmpq   $0x2,0x4fe3(%rip)
02
je     20b1 <bigden_+0xf61>
cmpq   $0x3,0x4fd5(%rip)
03
jne    20bf <bigden_+0xf6f>
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,0x4fe1(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x4f98(%rip)
mov    0x4f91(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     212a <bigden_+0xfda>
movsd  0x509c(%rip),%xmm0
mov    0x60(%rbp),%rax
mov    0x4f71(%rip),%rcx
mov    0x4f7a(%rip),%rdx
imul   -0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x4f56(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4f4b(%rip)
jmp    20d8 <bigden_+0xf88>
mov    0x5057(%rip),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x4f25(%rip)
mov    0x4f1e(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     22ef <bigden_+0x119f>
movsd  0x5031(%rip),%xmm0
movsd  %xmm0,0x4fe9(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x4ef0(%rip)
mov    0x4ee9(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     2201 <bigden_+0x10b1>
mov    -0x30(%rbp),%rax
mov    0x4ed1(%rip),%rcx
mov    0x4ec2(%rip),%rdx
imul   -0x58(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x4eb2(%rip),%rcx
mov    0x4ebb(%rip),%rdx
imul   -0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x4f76(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4f66(%rip)
mov    0x4e7f(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4e74(%rip)
jmp    2180 <bigden_+0x1030>
mov    0x4e60(%rip),%rax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%rax
jge    223c <bigden_+0x10ec>
movsd  0x4f33(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,0x4f14(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x4e1b(%rip)
mov    0x4e14(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     22d3 <bigden_+0x1183>
movsd  0x4edf(%rip),%xmm0
mov    -0x30(%rbp),%rax
mov    0x4df4(%rip),%rcx
mov    0x4de5(%rip),%rdx
imul   -0x58(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x4dd5(%rip),%rcx
mov    0x4dde(%rip),%rdx
imul   -0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x4dad(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4da2(%rip)
jmp    2255 <bigden_+0x1105>
jmp    22d8 <bigden_+0x1188>
mov    0x4d89(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4d7e(%rip)
jmp    2143 <bigden_+0xff3>
mov    0x4daa(%rip),%rax
mov    0x18(%rbp),%rcx
cmp    (%rcx),%rax
jne    2429 <bigden_+0x12d9>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x4d54(%rip)
mov    0x4d4d(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     2424 <bigden_+0x12d4>
movsd  0x4e58(%rip),%xmm0
movsd  %xmm0,0x4e10(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x4d0f(%rip)
mov    0x4d08(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     23e1 <bigden_+0x1291>
mov    -0x28(%rbp),%rax
mov    0x4cf8(%rip),%rcx
mov    0x4ce9(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
add    0x4cca(%rip),%rcx
mov    0x4cdb(%rip),%rdx
imul   -0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x4d96(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4d86(%rip)
mov    0x4c97(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4c8c(%rip)
jmp    2359 <bigden_+0x1209>
movsd  0x4d67(%rip),%xmm0
mov    0x60(%rbp),%rax
mov    0x4c7c(%rip),%rcx
mov    0x4c85(%rip),%rdx
imul   -0x78(%rbp),%rdx
add    %rdx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x4c5c(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4c51(%rip)
jmp    231c <bigden_+0x11cc>
jmp    2429 <bigden_+0x12d9>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x4c26(%rip)
mov    0x4c1f(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     2545 <bigden_+0x13f5>
movsd  0x4d32(%rip),%xmm0
movsd  %xmm0,0x4cea(%rip)
mov    0x4c33(%rip),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x4be1(%rip)
mov    0x4bda(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     2500 <bigden_+0x13b0>
mov    -0x28(%rbp),%rax
mov    0x4bc2(%rip),%rcx
mov    0x4bc3(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x4ba3(%rip),%rcx
mov    0x4bbc(%rip),%rdx
imul   -0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x4c77(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4c67(%rip)
mov    0x4b70(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4b65(%rip)
jmp    247f <bigden_+0x132f>
movsd  0x4c48(%rip),%xmm0
mov    0x60(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
add    0x4b4e(%rip),%rcx
mov    0x4b5f(%rip),%rdx
imul   -0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x4b33(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4b28(%rip)
jmp    2442 <bigden_+0x12f2>
jmp    254a <bigden_+0x13fa>
mov    0x4b2f(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4b24(%rip)
jmp    2079 <bigden_+0xf29>
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x4af6(%rip)
mov    0x4aef(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     2cf3 <bigden_+0x1ba3>
movsd  0x4bfa(%rip),%xmm0
movsd  %xmm0,0x4bb2(%rip)
movq   $0x1,0x4ab7(%rip)
cmpq   $0x5,0x4aaf(%rip)
05
jg     2652 <bigden_+0x1502>
movsd  0x4ba9(%rip),%xmm0
mov    0x60(%rbp),%rax
mov    0x4aa6(%rip),%rcx
mov    0x4a8f(%rip),%rdx
imul   -0x78(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x4a87(%rip),%rcx
mov    0x4a70(%rip),%rdx
imul   -0x68(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x4a5c(%rip),%rcx
sub    $0x1,%rcx
lea    0x4af1(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    0x4a45(%rip),%rcx
sub    $0x1,%rcx
lea    0x4ada(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
addsd  0x4b1d(%rip),%xmm0
movsd  %xmm0,0x4b15(%rip)
mov    0x4a1e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4a13(%rip)
jmp    25a9 <bigden_+0x1459>
movsd  0x4a56(%rip),%xmm0
subsd  0x4a9e(%rip),%xmm0
subsd  0x4ae6(%rip),%xmm0
movsd  %xmm0,0x4a3e(%rip)
mov    0x60(%rbp),%rax
mov    0x49f3(%rip),%rcx
add    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x49df(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x49c4(%rip),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    0x49a9(%rip),%rcx
add    -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4b20(%rip)
mov    0x60(%rbp),%rax
mov    0x4985(%rip),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x496a(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x494f(%rip),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    0x4934(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4aac(%rip)
mov    0x60(%rbp),%rax
mov    0x4909(%rip),%rcx
imul   $0x3,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x48f1(%rip),%rcx
imul   $0x5,-0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x48d9(%rip),%rcx
imul   $0x5,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    0x48c1(%rip),%rcx
imul   $0x3,-0x68(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4a44(%rip)
movsd  0x48e4(%rip),%xmm1
subsd  0x4a24(%rip),%xmm1
movsd  0x4984(%rip),%xmm0
movsd  0x4a1c(%rip),%xmm2
addsd  0x4a1c(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x489d(%rip)
movsd  0x4945(%rip),%xmm0
movsd  0x49dd(%rip),%xmm2
subsd  0x49dd(%rip),%xmm2
movsd  0x489d(%rip),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4876(%rip)
mov    0x60(%rbp),%rax
mov    0x4803(%rip),%rcx
add    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x47ef(%rip),%rcx
imul   $0x3,-0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x47d7(%rip),%rcx
imul   $0x3,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    0x47bf(%rip),%rcx
add    -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4936(%rip)
mov    0x60(%rbp),%rax
mov    0x479b(%rip),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x4780(%rip),%rcx
imul   $0x5,-0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x4768(%rip),%rcx
imul   $0x5,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    0x4750(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x48c8(%rip)
mov    0x60(%rbp),%rax
mov    0x4725(%rip),%rcx
imul   $0x3,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x470d(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x46f2(%rip),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    0x46d7(%rip),%rcx
imul   $0x3,-0x68(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x485a(%rip)
movsd  0x4702(%rip),%xmm1
subsd  0x483a(%rip),%xmm1
movsd  0x479a(%rip),%xmm0
movsd  0x4832(%rip),%xmm2
subsd  0x4832(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x46bb(%rip)
movsd  0x475b(%rip),%xmm0
movsd  0x47f3(%rip),%xmm2
addsd  0x47f3(%rip),%xmm2
movsd  0x46bb(%rip),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4694(%rip)
mov    0x60(%rbp),%rax
mov    0x4619(%rip),%rcx
add    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x4605(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x45ea(%rip),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    0x45cf(%rip),%rcx
add    -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4746(%rip)
movsd  0x4606(%rip),%xmm0
subsd  0x4736(%rip),%xmm0
subsd  0x4636(%rip),%xmm0
addsd  0x4636(%rip),%xmm0
movsd  %xmm0,0x45e6(%rip)
mov    0x60(%rbp),%rax
mov    0x4583(%rip),%rcx
add    -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x456f(%rip),%rcx
imul   $0x5,-0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x4557(%rip),%rcx
imul   $0x5,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    0x453f(%rip),%rcx
add    -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x46b6(%rip)
mov    0x60(%rbp),%rax
mov    0x451b(%rip),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x4500(%rip),%rcx
imul   $0x3,-0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x44e8(%rip),%rcx
imul   $0x3,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    0x44d0(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4648(%rip)
movsd  0x4508(%rip),%xmm1
subsd  0x4630(%rip),%xmm1
movsd  0x4590(%rip),%xmm0
movsd  0x4628(%rip),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x44c9(%rip)
movsd  0x44d9(%rip),%xmm0
subsd  0x4501(%rip),%xmm0
addsd  0x4501(%rip),%xmm0
movsd  %xmm0,0x44c1(%rip)
mov    0x60(%rbp),%rax
mov    0x443e(%rip),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x4423(%rip),%rcx
imul   $0x5,-0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x440b(%rip),%rcx
imul   $0x5,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
mov    0x43f3(%rip),%rcx
mov    -0x68(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4563(%rip)
movsd  0x44c3(%rip),%xmm0
movsd  0x4553(%rip),%xmm2
movsd  0x443b(%rip),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4414(%rip)
mov    0x438d(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4382(%rip)
jmp    257a <bigden_+0x142a>
movsd  0x4495(%rip),%xmm0
movsd  %xmm0,0x444d(%rip)
movq   $0x1,0x4352(%rip)
cmpq   $0x5,0x434a(%rip)
05
jg     2db4 <bigden_+0x1c64>
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x4332(%rip),%rdx
imul   -0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x441d(%rip),%xmm0
movsd  -0x98(%rbp),%xmm1
ff
mulsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    0x42fa(%rip),%rcx
sub    $0x1,%rcx
lea    0x438f(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    0x42e3(%rip),%rcx
sub    $0x1,%rcx
lea    0x4378(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
addsd  0x43bb(%rip),%xmm0
movsd  %xmm0,0x43b3(%rip)
mov    0x42bc(%rip),%rax
add    $0x1,%rax
mov    %rax,0x42b1(%rip)
jmp    2d0e <bigden_+0x1bbe>
movsd  0x43dc(%rip),%xmm0
movsd  0x42ec(%rip),%xmm2
movsd  0x4334(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  0x4374(%rip),%xmm0
movsd  %xmm0,0x43cc(%rip)
movsd  0x436c(%rip),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
add    -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x43dd(%rip)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x43a7(%rip)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x3,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x5,-0x78(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x4377(%rip)
movsd  0x42f7(%rip),%xmm0
movsd  0x420f(%rip),%xmm2
movsd  0x434f(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  0x4347(%rip),%xmm0
addsd  0x4347(%rip),%xmm0
movsd  %xmm0,0x42e7(%rip)
movsd  0x42bf(%rip),%xmm0
movsd  0x41f7(%rip),%xmm2
movsd  0x431f(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  0x4317(%rip),%xmm0
movsd  %xmm0,0x42d7(%rip)
movsd  0x424f(%rip),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
add    -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x3,-0x78(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x42c3(%rip)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x5,-0x78(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x4290(%rip)
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x3,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x425d(%rip)
movsd  0x41dd(%rip),%xmm0
movsd  0x40fd(%rip),%xmm2
movsd  0x4235(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  0x422d(%rip),%xmm0
subsd  0x422d(%rip),%xmm0
movsd  %xmm0,0x41d5(%rip)
movsd  0x41a5(%rip),%xmm0
movsd  0x40e5(%rip),%xmm2
movsd  0x4205(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  0x41fd(%rip),%xmm0
movsd  %xmm0,0x41c5(%rip)
movsd  0x4135(%rip),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
add    -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x41a6(%rip)
movsd  0x4136(%rip),%xmm0
movsd  0x405e(%rip),%xmm2
movsd  0x418e(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  0x4086(%rip),%xmm0
subsd  0x4086(%rip),%xmm0
movsd  %xmm0,0x4136(%rip)
movsd  0x40be(%rip),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
add    -0x78(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x5,-0x78(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x4132(%rip)
movsd  0x40c2(%rip),%xmm1
movsd  0x3ff2(%rip),%xmm2
movsd  0x411a(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x3,-0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x409f(%rip)
movsd  0x405f(%rip),%xmm0
movsd  0x3fa7(%rip),%xmm2
movsd  0x3fcf(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  0x3fc7(%rip),%xmm0
movsd  %xmm0,0x4087(%rip)
movsd  0x402f(%rip),%xmm0
movsd  0x3f7f(%rip),%xmm2
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    -0x78(%rbp),%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x60(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
imul   $0x5,-0x78(%rbp),%rdx
add    %rdx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x403c(%rip)
movsd  0x3ff4(%rip),%xmm0
addsd  0x3ff4(%rip),%xmm0
addsd  0x3ffc(%rip),%xmm0
addsd  0x4004(%rip),%xmm0
addsd  0x400c(%rip),%xmm0
movsd  %xmm0,0x3f6c(%rip)
movsd  0x3f64(%rip),%xmm0
movsd  %xmm0,0x405c(%rip)
movsd  0x3f54(%rip),%xmm0
movsd  %xmm0,0x4054(%rip)
movq   $0x0,0x4009(%rip)
movq   $0x31,0x3e7e(%rip)
movsd  0x401e(%rip),%xmm0
mov    0x3e6f(%rip),%rax
add    $0x1,%rax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x3f32(%rip)
movsd  0x3eb2(%rip),%xmm0
movsd  %xmm0,0x3eb2(%rip)
mov    0x3e43(%rip),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x3df9(%rip)
mov    0x3df2(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     3500 <bigden_+0x23b0>
cvtsi2sdq 0x3ddc(%rip),%xmm0
mulsd  0x3ee4(%rip),%xmm0
movsd  %xmm0,0x3f0c(%rip)
movsd  0x3f04(%rip),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x3e5f(%rip)
movsd  0x3eef(%rip),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x3e52(%rip)
movq   $0x4,0x3d9f(%rip)
cmpq   $0x8,0x3d97(%rip)
08
jg     33bb <bigden_+0x226b>
movsd  0x3e29(%rip),%xmm0
mov    0x3d82(%rip),%rcx
sub    $0x3,%rcx
lea    0x3e0f(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3e12(%rip),%xmm1
mov    0x3d63(%rip),%rcx
sub    $0x2,%rcx
lea    0x3df0(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x3d2d(%rip),%rcx
sub    $0x1,%rcx
lea    0x3dba(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3db5(%rip),%xmm0
mov    0x3d0e(%rip),%rcx
sub    $0x2,%rcx
lea    0x3d9b(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3d9e(%rip),%xmm1
mov    0x3cef(%rip),%rcx
sub    $0x3,%rcx
lea    0x3d7c(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x3cd0(%rip),%rcx
lea    0x3d61(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3cbd(%rip),%rax
add    $0x2,%rax
mov    %rax,0x3cb2(%rip)
jmp    32c9 <bigden_+0x2179>
movsd  0x3d8d(%rip),%xmm0
movsd  %xmm0,0x3ea5(%rip)
movsd  0x3dbd(%rip),%xmm0
movsd  %xmm0,0x3d75(%rip)
movq   $0x1,0x3c82(%rip)
cmpq   $0x9,0x3c7a(%rip)
09
jg     3451 <bigden_+0x2301>
mov    0x3c6d(%rip),%rcx
sub    $0x1,%rcx
lea    0x3daa(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x3c56(%rip),%rcx
sub    $0x1,%rcx
lea    0x3ce3(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3d26(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3d16(%rip)
mov    0x3c27(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3c1c(%rip)
jmp    33e6 <bigden_+0x2296>
cvttsd2si 0x3cf7(%rip),%edi
call   1030 <abs@plt>
mov    %eax,-0xa4(%rbp)
cvttsd2si 0x3dec(%rip),%edi
call   1030 <abs@plt>
mov    %eax,%ecx
mov    -0xa4(%rbp),%eax
cmp    %ecx,%eax
jle    34b4 <bigden_+0x2364>
movsd  0x3cc7(%rip),%xmm0
movsd  %xmm0,0x3dc7(%rip)
mov    0x3bc8(%rip),%rax
mov    %rax,0x3d79(%rip)
movsd  0x3dc9(%rip),%xmm0
movsd  %xmm0,0x3d51(%rip)
jmp    34e4 <bigden_+0x2394>
mov    0x3ba5(%rip),%rax
mov    0x3d56(%rip),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    34df <bigden_+0x238f>
movsd  0x3c79(%rip),%xmm0
movsd  %xmm0,0x3d29(%rip)
jmp    34e4 <bigden_+0x2394>
jmp    34e9 <bigden_+0x2399>
mov    0x3b70(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3b65(%rip)
jmp    3267 <bigden_+0x2117>
cmpq   $0x0,0x3d10(%rip)
jne    351e <bigden_+0x23ce>
movsd  0x3c3a(%rip),%xmm0
movsd  %xmm0,0x3ce2(%rip)
mov    0x3cf3(%rip),%rax
cmp    0x3b6c(%rip),%rax
jne    3542 <bigden_+0x23f2>
movsd  0x3d16(%rip),%xmm0
movsd  %xmm0,0x3cc6(%rip)
movsd  0x3c46(%rip),%xmm0
movsd  %xmm0,0x3c2e(%rip)
movsd  0x3ca6(%rip),%xmm0
ucomisd 0x3ca6(%rip),%xmm0
jne    3573 <bigden_+0x2423>
jp     3573 <bigden_+0x2423>
jmp    35e3 <bigden_+0x2493>
movsd  0x3cdd(%rip),%xmm1
movsd  0x3c7d(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x3c71(%rip)
movsd  0x3cc1(%rip),%xmm1
movsd  0x3c69(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x3c5d(%rip)
movsd  0x3bb5(%rip),%xmm0
movsd  0x3c45(%rip),%xmm1
subsd  0x3c45(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x3c31(%rip),%xmm1
addsd  0x3c31(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x3b9d(%rip)
movsd  0x3b85(%rip),%xmm0
cvtsi2sdq 0x3c24(%rip),%xmm1
addsd  0x3b84(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x3b98(%rip)
movsd  0x3b90(%rip),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x3aeb(%rip)
movsd  0x3b7b(%rip),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x3ade(%rip)
movq   $0x4,0x3a2b(%rip)
cmpq   $0x8,0x3a23(%rip)
08
jg     372f <bigden_+0x25df>
movsd  0x3ab5(%rip),%xmm0
mov    0x3a0e(%rip),%rcx
sub    $0x3,%rcx
lea    0x3a9b(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3a9e(%rip),%xmm1
mov    0x39ef(%rip),%rcx
sub    $0x2,%rcx
lea    0x3a7c(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x39b9(%rip),%rcx
sub    $0x1,%rcx
lea    0x3a46(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3a41(%rip),%xmm0
mov    0x399a(%rip),%rcx
sub    $0x2,%rcx
lea    0x3a27(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3a2a(%rip),%xmm1
mov    0x397b(%rip),%rcx
sub    $0x3,%rcx
lea    0x3a08(%rip),%rax
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x395c(%rip),%rcx
lea    0x39ed(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3949(%rip),%rax
add    $0x2,%rax
mov    %rax,0x393e(%rip)
jmp    363d <bigden_+0x24ed>
movsd  0x3a59(%rip),%xmm0
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  0x3a49(%rip),%xmm0
movsd  %xmm0,0x3b09(%rip)
movq   $0x1,0x390e(%rip)
cmpq   $0x9,0x3906(%rip)
09
jg     3807 <bigden_+0x26b7>
mov    0x38f9(%rip),%rcx
sub    $0x1,%rcx
lea    0x3936(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x38e2(%rip),%rcx
sub    $0x1,%rcx
lea    0x396f(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    0x38b7(%rip),%rcx
sub    $0x1,%rcx
lea    0x39f4(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x38a0(%rip),%rcx
sub    $0x1,%rcx
lea    0x392d(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3a78(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3a68(%rip)
mov    0x3871(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3866(%rip)
jmp    375a <bigden_+0x260a>
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x3850(%rip)
mov    0x3849(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     38eb <bigden_+0x279b>
movsd  0x3954(%rip),%xmm0
mov    0x40(%rbp),%rax
mov    0x3829(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x1,0x3811(%rip)
cmpq   $0x5,0x3809(%rip)
05
jg     38cf <bigden_+0x277f>
mov    0x60(%rbp),%rax
mov    0x3800(%rip),%rcx
mov    0x37f1(%rip),%rdx
imul   -0x78(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x37dd(%rip),%rcx
sub    $0x1,%rcx
lea    0x386a(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
mov    0x40(%rbp),%rax
mov    0x37ca(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x37a9(%rip),%rax
add    $0x1,%rax
mov    %rax,0x379e(%rip)
jmp    3857 <bigden_+0x2707>
jmp    38d4 <bigden_+0x2784>
mov    0x3795(%rip),%rax
add    $0x1,%rax
mov    %rax,0x378a(%rip)
jmp    3820 <bigden_+0x26d0>
mov    0x40(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3845(%rip)
movsd  0x3885(%rip),%xmm0
movsd  %xmm0,0x3765(%rip)
movsd  0x3875(%rip),%xmm0
movsd  %xmm0,0x38dd(%rip)
movsd  0x3865(%rip),%xmm0
movsd  %xmm0,0x38d5(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x3714(%rip)
mov    0x370d(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     3a9f <bigden_+0x294f>
movsd  0x37a0(%rip),%xmm0
mov    0x30(%rbp),%rax
mov    0x36ed(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3790(%rip),%xmm1
mov    0x50(%rbp),%rax
mov    0x36d5(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
mov    0x36bd(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    0x36ad(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x369d(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    0x368d(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x367d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  0x3670(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3660(%rip)
mov    0x30(%rbp),%rax
mov    0x363d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    0x362d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x37c0(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x37b0(%rip)
mov    0x38(%rbp),%rax
mov    0x3605(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    0x35f5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3790(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3780(%rip)
mov    0x35d1(%rip),%rax
add    $0x1,%rax
mov    %rax,0x35c6(%rip)
jmp    394c <bigden_+0x27fc>
mov    0x3752(%rip),%rax
mov    -0x8(%rbp),%rcx
cmp    (%rcx),%rax
jl     3ab8 <bigden_+0x2968>
jmp    3f81 <bigden_+0x2e31>
cmpq   $0x1,0x3738(%rip)
01
jle    3b11 <bigden_+0x29c1>
movsd  0x3792(%rip),%xmm0
ucomisd 0x377a(%rip),%xmm0
jb     3af1 <bigden_+0x29a1>
movsd  0x377c(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    3b01 <bigden_+0x29b1>
movsd  0x3757(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,0x374f(%rip)
cvttsd2si 0x373f(%rip),%edi
call   1030 <abs@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
cvttsd2si 0x372e(%rip),%edi
call   1030 <abs@plt>
movsd  -0xb8(%rbp),%xmm1
ff
cvtsi2sd %eax,%xmm0
movsd  0x14e5(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     3b5e <bigden_+0x2a0e>
jmp    3f81 <bigden_+0x2e31>
movsd  0x36f2(%rip),%xmm0
movsd  %xmm0,0x36f2(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x34d9(%rip)
mov    0x34d2(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     3c58 <bigden_+0x2b08>
movsd  0x365d(%rip),%xmm0
mov    -0x18(%rbp),%rax
mov    0x34b2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x364d(%rip),%xmm1
mov    0x30(%rbp),%rax
mov    0x349a(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
add    0x347b(%rip),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x357e(%rip)
movsd  0x354e(%rip),%xmm0
mov    -0x28(%rbp),%rax
mov    0x28(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x3454(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3577(%rip),%xmm1
mulsd  0x3547(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    0x3424(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3418(%rip),%rax
add    $0x1,%rax
mov    %rax,0x340d(%rip)
jmp    3b87 <bigden_+0x2a37>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
movq   $0x1,0x33ff(%rip)
mov    0x33f8(%rip),%rax
cmp    -0x88(%rbp),%rax
jg     3e2a <bigden_+0x2cda>
movsd  0x3503(%rip),%xmm0
movsd  %xmm0,0x34bb(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x33ba(%rip)
mov    0x33b3(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     3d20 <bigden_+0x2bd0>
mov    -0x20(%rbp),%rax
mov    0x33a3(%rip),%rcx
mov    0x3394(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    0x337c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3457(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3447(%rip)
mov    0x3358(%rip),%rax
add    $0x1,%rax
mov    %rax,0x334d(%rip)
jmp    3cae <bigden_+0x2b5e>
movsd  0x3420(%rip),%xmm0
mov    0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
add    0x3336(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3451(%rip),%xmm1
mov    0x40(%rbp),%rax
mov    0x331e(%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
mulsd  0x33d2(%rip),%xmm0
movsd  %xmm0,0x33ea(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x32c1(%rip)
mov    0x32ba(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     3e0e <bigden_+0x2cbe>
movsd  0x33b5(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x32aa(%rip),%rcx
mov    0x3293(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x50(%rbp),%rax
mov    0x327b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3262(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3257(%rip)
jmp    3d9f <bigden_+0x2c4f>
jmp    3e13 <bigden_+0x2cc3>
mov    0x3256(%rip),%rax
add    $0x1,%rax
mov    %rax,0x324b(%rip)
jmp    3c71 <bigden_+0x2b21>
movsd  0x335e(%rip),%xmm0
movsd  %xmm0,0x326e(%rip)
movsd  0x334e(%rip),%xmm0
movsd  %xmm0,0x323e(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x31fd(%rip)
mov    0x31f6(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     3f06 <bigden_+0x2db6>
mov    0x50(%rbp),%rax
mov    0x31de(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  0x3201(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x31f1(%rip)
mov    0x30(%rbp),%rax
mov    0x319e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x318e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x31a9(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3199(%rip)
mov    0x316a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x315f(%rip)
jmp    3e63 <bigden_+0x2d13>
movsd  0x316a(%rip),%xmm0
movsd  0x3192(%rip),%xmm2
movsd  0x316a(%rip),%xmm1
mulsd  0x3162(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x32d3(%rip)
movsd  0x32cb(%rip),%xmm0
movsd  0x10db(%rip),%xmm1
mulsd  0x3113(%rip),%xmm1
mulsd  0x313b(%rip),%xmm1
ucomisd %xmm1,%xmm0
jb     3f7c <bigden_+0x2e2c>
jmp    19d9 <bigden_+0x889>
jmp    3f81 <bigden_+0x2e31>
mov    0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
movq   $0x1,0x30d6(%rip)
mov    0x30cf(%rip),%rax
cmp    -0x90(%rbp),%rax
jg     4065 <bigden_+0x2f15>
movsd  0x31da(%rip),%xmm0
mov    0x38(%rbp),%rax
mov    0x30af(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x1,0x3097(%rip)
cmpq   $0x5,0x308f(%rip)
05
jg     4049 <bigden_+0x2ef9>
mov    0x58(%rbp),%rax
mov    0x3086(%rip),%rcx
mov    0x3077(%rip),%rdx
imul   -0x68(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3063(%rip),%rcx
sub    $0x1,%rcx
lea    0x30f0(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
mov    0x3050(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x302f(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3024(%rip)
jmp    3fd1 <bigden_+0x2e81>
jmp    404e <bigden_+0x2efe>
mov    0x301b(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3010(%rip)
jmp    3f9a <bigden_+0x2e4a>
movsd  0x308b(%rip),%xmm0
mov    0x40(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
xor    %eax,%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bigden_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2a8,%rsp
mov    %r9,0x70(%rsp)
mov    %r8,0xc0(%rsp)
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    0x2e8(%rsp),%rax
mov    (%rsi),%r12
mov    %r12,0x8(%rsp)
not    %r12
mov    (%rax),%rax
mov    %rax,0x20(%rsp)
movabs $0x3fe0000000000000,%rax
mov    %rax,0x5f52(%rip)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x5f11(%rip)
movabs $0x3fd0000000000000,%rax
mov    %rax,0x6000(%rip)
movabs $0x4000000000000000,%rax
mov    %rax,0x5f17(%rip)
movsd  0x3e1f(%rip),%xmm0
call   1050 <atan@plt>
movabs $0x401921fb54442d18,%rax
21 19 40
mov    %rax,0x5fd9(%rip)
mov    %rbx,0x160(%rsp)
mov    (%rbx),%r13
mov    %rbp,0x168(%rsp)
mov    0x0(%rbp),%r11
mov    %r11,%rbx
not    %rbx
add    %r13,%rbx
mov    %rbx,0x5eea(%rip)
test   %r13,%r13
jle    1244 <bigden_+0xf4>
mov    0x308(%rsp),%rax
lea    (%rax,%r11,8),%rdi
lea    0x0(,%r13,8),%rdx
xor    %esi,%esi
mov    %r11,%rbp
call   1030 <memset@plt>
mov    %rbp,%r11
mov    0x70(%rsp),%rax
lea    (%rax,%r12,8),%rax
mov    %rax,0xc8(%rsp)
mov    0x2f8(%rsp),%rax
mov    (%rax),%rbp
test   %rbx,%rbx
mov    %r14,0x48(%rsp)
mov    %r15,0x30(%rsp)
mov    %r12,0x90(%rsp)
jle    149f <bigden_+0x34f>
mov    0x2e0(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x10(%rsp)
mov    %r13,%rax
sub    %r11,%rax
mov    %rax,0x18(%rsp)
mov    0x308(%rsp),%rcx
lea    (%rcx,%r11,8),%rsi
mov    %r11,0x88(%rsp)
lea    0x0(%r13,%r11,1),%rax
lea    (%rcx,%rax,8),%rax
mov    %rax,0x78(%rsp)
mov    %r13,%r12
and    $0xfffffffffffffffc,%r12
lea    0x1(%r12),%rax
mov    %rax,0xd0(%rsp)
mov    0x70(%rsp),%r15
lea    0x10(%r15),%rbx
mov    0x8(%rsp),%rax
lea    0x0(,%rax,8),%r14
lea    0x1(%r13),%rdi
mov    $0x1,%ecx
xor    %r11d,%r11d
movapd 0x3d3a(%rip),%xmm0
mov    %rbp,0x38(%rsp)
jmp    1319 <bigden_+0x1c9>
nopl   (%rax)
add    $0x1,%rcx
add    $0x1,%r11
add    %r14,%rbx
add    %r14,%r15
cmp    0x18(%rsp),%rcx
je     147d <bigden_+0x32d>
mov    %rcx,%r8
imul   0x8(%rsp),%r8
lea    (%r8,%rbp,1),%rax
mov    0xc8(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm1
cmp    0x10(%rsp),%rcx
jge    133e <bigden_+0x1ee>
xorpd  %xmm0,%xmm1
test   %r13,%r13
jle    1300 <bigden_+0x1b0>
mov    $0x1,%r9d
cmp    $0x4,%r13
jb     13f0 <bigden_+0x2a0>
mov    0x8(%rsp),%rax
imul   %r11,%rax
lea    (%rax,%r13,1),%rbp
mov    0x70(%rsp),%rdx
lea    (%rdx,%rbp,8),%rbp
cmp    %rbp,%rsi
mov    0x38(%rsp),%rbp
jae    138f <bigden_+0x23f>
mov    0x70(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
mov    0x38(%rsp),%rbp
cmp    0x78(%rsp),%rax
jb     13f0 <bigden_+0x2a0>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
xor    %eax,%eax
nopl   0x0(%rax)
movupd -0x10(%rbx,%rax,8),%xmm3
movupd (%rbx,%rax,8),%xmm4
movupd (%rsi,%rax,8),%xmm5
movupd 0x10(%rsi,%rax,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%rsi,%rax,8)
movupd %xmm4,0x10(%rsi,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    13a0 <bigden_+0x250>
mov    0xd0(%rsp),%r9
cmp    %r12,%r13
je     1300 <bigden_+0x1b0>
nopl   0x0(%rax,%rax,1)
mov    %r9,%r10
test   $0x1,%r13b
je     1436 <bigden_+0x2e6>
add    %r9,%r8
mov    0x88(%rsp),%rax
add    %r9,%rax
mov    0xc8(%rsp),%rdx
movsd  (%rdx,%r8,8),%xmm2
mulsd  %xmm1,%xmm2
mov    0x308(%rsp),%rbp
addsd  -0x8(%rbp,%rax,8),%xmm2
movsd  %xmm2,-0x8(%rbp,%rax,8)
mov    0x38(%rsp),%rbp
lea    0x1(%r9),%r10
cmp    %r9,%r13
je     1300 <bigden_+0x1b0>
nop
movsd  -0x8(%r15,%r10,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  -0x8(%rsi,%r10,8),%xmm2
movsd  %xmm2,-0x8(%rsi,%r10,8)
movsd  (%r15,%r10,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rsi,%r10,8),%xmm2
movsd  %xmm2,(%rsi,%r10,8)
add    $0x2,%r10
cmp    %r10,%rdi
jne    1440 <bigden_+0x2f0>
jmp    1300 <bigden_+0x1b0>
movsd  %xmm1,0x5c7b(%rip)
mov    0x48(%rsp),%r14
mov    0x30(%rsp),%r15
mov    0x90(%rsp),%r12
mov    0x88(%rsp),%r11
mov    0x320(%rsp),%r9
mov    0x300(%rsp),%rdi
lea    (%r11,%rbp,1),%rax
mov    0x308(%rsp),%rcx
movsd  -0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x5c47(%rip)
movq   $0x0,0x5b94(%rip)
movq   $0x0,0x5b91(%rip)
movq   $0x0,0x5d06(%rip)
test   %r11,%r11
mov    0x8(%rsp),%rcx
jle    158a <bigden_+0x43a>
lea    (%r14,%rbp,8),%rax
add    $0xfffffffffffffff8,%rax
lea    0x0(,%rcx,8),%rcx
xorpd  %xmm3,%xmm3
xor    %edx,%edx
xorpd  %xmm1,%xmm1
mov    0x20(%rsp),%r8
nopw   0x0(%rax,%rax,1)
movapd %xmm3,%xmm2
movsd  (%rax),%xmm0
subsd  (%r15,%rdx,8),%xmm0
movsd  (%rdi,%rdx,8),%xmm4
movsd  %xmm0,(%r9,%rdx,8)
movsd  (%rdi,%rdx,8),%xmm3
unpcklpd %xmm0,%xmm3
unpcklpd %xmm0,%xmm0
mulpd  %xmm3,%xmm0
movapd %xmm0,%xmm3
addpd  %xmm2,%xmm3
movhpd (%r15,%rdx,8),%xmm4
mulpd  %xmm4,%xmm4
addpd  %xmm4,%xmm1
add    $0x1,%rdx
add    %rcx,%rax
cmp    %rdx,%r11
jne    1520 <bigden_+0x3d0>
addpd  %xmm2,%xmm0
movlpd %xmm1,0x5af0(%rip)
movlpd %xmm0,0x5af0(%rip)
movhpd %xmm1,0x5c68(%rip)
jmp    1597 <bigden_+0x447>
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
mov    0x20(%rsp),%r8
mov    %r8,%rbx
not    %rbx
mov    0x2f0(%rsp),%rax
lea    (%r14,%r12,8),%rcx
mov    %rcx,0xa0(%rsp)
movsd  0x3a4f(%rip),%xmm3
mulsd  %xmm1,%xmm3
movapd %xmm0,%xmm2
unpcklpd %xmm3,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
ucomisd %xmm3,%xmm2
jbe    19c5 <bigden_+0x875>
test   %r13,%r13
mov    %rbx,0x10(%rsp)
jle    1751 <bigden_+0x601>
movapd %xmm0,%xmm3
unpckhpd %xmm0,%xmm3
divsd  %xmm3,%xmm2
mov    (%rax),%r9
lea    0x1(%r11),%r10
mov    0x8(%rsp),%r12
shl    $0x4,%r12
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
neg    %rbx
mov    $0x1,%eax
mov    0x48(%rsp),%rsi
mov    0x8(%rsp),%r8
jmp    1634 <bigden_+0x4e4>
lea    0x1(%rax),%rcx
add    $0x8,%rsi
cmp    %r13,%rax
mov    %rcx,%rax
je     1751 <bigden_+0x601>
cmp    %r9,%rax
je     1620 <bigden_+0x4d0>
mov    %rbp,%r14
test   %r11,%r11
jle    1652 <bigden_+0x502>
xorpd  %xmm4,%xmm4
mov    $0x1,%ebp
cmp    $0x1,%r11
jne    1660 <bigden_+0x510>
jmp    16cf <bigden_+0x57f>
xorpd  %xmm3,%xmm3
mov    $0x1,%ecx
jmp    1711 <bigden_+0x5c1>
mov    %rsi,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx),%xmm5
subsd  -0x8(%r15,%rbp,8),%xmm5
movsd  -0x8(%rdi,%rbp,8),%xmm3
movsd  (%rdi,%rbp,8),%xmm6
unpcklpd %xmm5,%xmm3
unpcklpd %xmm5,%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movsd  (%rcx,%r8,8),%xmm3
subsd  (%r15,%rbp,8),%xmm3
unpcklpd %xmm3,%xmm6
unpcklpd %xmm3,%xmm3
mulpd  %xmm6,%xmm3
movapd %xmm3,%xmm4
addpd  %xmm5,%xmm4
add    %r12,%rcx
lea    (%rbx,%rbp,1),%rdx
add    $0x2,%rdx
add    $0x2,%rbp
cmp    $0x1,%rdx
jne    1670 <bigden_+0x520>
addpd  %xmm5,%xmm3
mov    %r10,%rcx
test   $0x1,%r11b
je     1711 <bigden_+0x5c1>
mov    %rbp,%rcx
imul   0x8(%rsp),%rcx
add    %rax,%rcx
mov    0xa0(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm3
subsd  -0x8(%r15,%rbp,8),%xmm3
movsd  -0x8(%rdi,%rbp,8),%xmm5
unpcklpd %xmm3,%xmm5
unpcklpd %xmm3,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm4,%xmm3
mov    %r10,%rcx
mov    %rcx,0x5948(%rip)
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm3,%xmm5
unpckhpd %xmm3,%xmm5
divsd  %xmm5,%xmm4
ucomisd %xmm4,%xmm2
mov    %r14,%rbp
jbe    1620 <bigden_+0x4d0>
movlpd %xmm3,0x592f(%rip)
mov    %rax,%rbp
movapd %xmm4,%xmm2
movapd %xmm3,%xmm0
jmp    1620 <bigden_+0x4d0>
test   %r11,%r11
mov    0x10(%rsp),%rbx
jle    1902 <bigden_+0x7b2>
mov    $0x1,%eax
cmp    $0x4,%r11
mov    0x320(%rsp),%r9
jb     190f <bigden_+0x7bf>
cmpq   $0x1,0x8(%rsp)
mov    0x48(%rsp),%r8
jne    191e <bigden_+0x7ce>
lea    (%r9,%r11,8),%rdx
lea    (%r8,%rbp,8),%rcx
add    $0xfffffffffffffff8,%rcx
lea    (%r11,%rbp,1),%rsi
lea    (%r8,%rsi,8),%rsi
add    $0xfffffffffffffff8,%rsi
lea    (%r15,%r11,8),%rdi
cmp    %r9,%rsi
seta   %sil
cmp    %rdx,%rcx
setb   %r10b
cmp    %r9,%rdi
seta   %cl
cmp    %r15,%rdx
seta   %dl
test   %r10b,%sil
jne    1916 <bigden_+0x7c6>
and    %dl,%cl
mov    0x300(%rsp),%rdi
jne    191e <bigden_+0x7ce>
mov    %r11,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     4130 <bigden_+0x2fe0>
mov    %rbx,%r14
mov    %rdx,%rsi
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rsi
mov    0x8(%rsp),%rbx
mov    %rbx,%rdi
shl    $0x5,%rdi
mov    %rbp,%r10
lea    (%r8,%rbp,8),%rbp
add    $0x8,%rbp
shl    $0x6,%rbx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rbp),%xmm2
movupd 0x0(%rbp),%xmm3
movupd (%r15,%rcx,8),%xmm4
subpd  %xmm4,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm4
subpd  %xmm4,%xmm3
movupd %xmm2,(%r9,%rcx,8)
movupd %xmm3,0x10(%r9,%rcx,8)
movupd -0x10(%rbp,%rdi,1),%xmm2
movupd 0x0(%rbp,%rdi,1),%xmm3
movupd 0x20(%r15,%rcx,8),%xmm4
subpd  %xmm4,%xmm2
movupd 0x30(%r15,%rcx,8),%xmm4
subpd  %xmm4,%xmm3
movupd %xmm2,0x20(%r9,%rcx,8)
movupd %xmm3,0x30(%r9,%rcx,8)
add    $0x8,%rcx
add    %rbx,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1830 <bigden_+0x6e0>
add    $0x1,%rcx
mov    0x300(%rsp),%rdi
mov    %r10,%rbp
mov    %r14,%rbx
test   $0x1,%dl
je     18f3 <bigden_+0x7a3>
mov    %rcx,%rdx
imul   0x8(%rsp),%rdx
add    %rbp,%rdx
mov    0xa0(%rsp),%rsi
movupd (%rsi,%rdx,8),%xmm2
movupd 0x10(%rsi,%rdx,8),%xmm3
movupd -0x8(%r15,%rcx,8),%xmm4
subpd  %xmm4,%xmm2
movupd 0x8(%r15,%rcx,8),%xmm4
subpd  %xmm4,%xmm3
movupd %xmm2,-0x8(%r9,%rcx,8)
movupd %xmm3,0x8(%r9,%rcx,8)
cmp    %rax,%r11
je     19c5 <bigden_+0x875>
or     $0x1,%rax
jmp    191e <bigden_+0x7ce>
mov    0x320(%rsp),%r9
jmp    19c5 <bigden_+0x875>
mov    0x48(%rsp),%r8
jmp    191e <bigden_+0x7ce>
mov    0x300(%rsp),%rdi
mov    %rax,%rsi
test   $0x1,%r11b
je     1952 <bigden_+0x802>
mov    %rax,%rcx
imul   0x8(%rsp),%rcx
add    %rbp,%rcx
mov    0xa0(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm2
subsd  -0x8(%r15,%rax,8),%xmm2
movsd  %xmm2,-0x8(%r9,%rax,8)
lea    0x1(%rax),%rsi
cmp    %rax,%r11
je     19c5 <bigden_+0x875>
lea    (%r9,%rsi,8),%rax
lea    (%r15,%rsi,8),%rcx
mov    0x90(%rsp),%rdx
lea    (%r8,%rdx,8),%rdx
add    $0x8,%rdx
sub    %rsi,%r11
mov    0x8(%rsp),%rdi
imul   %rdi,%rsi
add    %rbp,%rsi
add    $0xffffffffffffffff,%rsi
add    %rdi,%rdi
add    $0x1,%r11
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm2
subsd  -0x8(%rcx,%rbp,8),%xmm2
movsd  %xmm2,-0x8(%rax,%rbp,8)
movsd  (%r8,%rsi,8),%xmm2
subsd  (%rcx,%rbp,8),%xmm2
movsd  %xmm2,(%rax,%rbp,8)
add    $0x2,%rbp
add    %rdi,%rsi
cmp    %rbp,%r11
jne    1990 <bigden_+0x840>
mov    0x300(%rsp),%rdi
mov    0x330(%rsp),%r12
lea    (%r12,%rbx,8),%rax
mov    %rax,0x80(%rsp)
mov    0x328(%rsp),%rcx
lea    (%rcx,%rbx,8),%rax
mov    %rax,0x78(%rsp)
mov    0xc0(%rsp),%rax
lea    (%rax,%rbx,8),%rsi
mov    %rsi,0xf8(%rsp)
movapd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
unpckhpd %xmm0,%xmm0
mulsd  %xmm0,%xmm1
subsd  %xmm2,%xmm1
movq   $0x0,0x57cb(%rip)
mov    0x20(%rsp),%rbx
lea    (%rbx,%rbx,1),%r13
lea    0x0(,%rbx,4),%rsi
mov    %rsi,0x40(%rsp)
lea    (%rbx,%rbx,2),%r11
mov    %rbx,%rsi
shl    $0x5,%rsi
lea    0x0(,%rbx,8),%rbp
mov    %r12,%rdx
sub    %rbp,%rdx
mov    %rbx,%rcx
shl    $0x4,%rcx
mov    %rbp,0xa8(%rsp)
neg    %rbp
mov    %rbp,0x1d0(%rsp)
mov    0x8(%rsp),%r8
mov    %r8,%rbp
shl    $0x4,%rbp
mov    %rbp,0xe8(%rsp)
mov    %r8,%rbp
shl    $0x5,%rbp
mov    0x48(%rsp),%r10
mov    0x90(%rsp),%rax
lea    (%r10,%rax,8),%r14
add    $0x8,%r14
mov    %r14,0x228(%rsp)
xorpd  %xmm14,%xmm14
lea    (%rbx,%rbx,4),%rax
mov    %rax,0xb0(%rsp)
mov    0xc0(%rsp),%rax
lea    -0x8(%rax),%rax
mov    %rax,0x1d8(%rsp)
lea    (%r12,%rsi,1),%rax
mov    %rax,0x150(%rsp)
lea    (%r12,%rcx,1),%rax
mov    %rax,0x148(%rsp)
lea    0x0(,%r8,8),%rax
mov    %rax,0x88(%rsp)
lea    0x10(%r12),%rax
mov    %rax,0x260(%rsp)
mov    0x328(%rsp),%r14
lea    (%r14,%rsi,1),%rax
mov    %rax,0x250(%rsp)
lea    (%r14,%r11,8),%rax
mov    %rax,0x248(%rsp)
mov    %r11,0xe0(%rsp)
lea    (%r12,%r11,8),%rax
mov    %rax,0x258(%rsp)
lea    (%r14,%rcx,1),%rax
mov    %rax,0x240(%rsp)
lea    (%r14,%rbx,8),%rax
mov    %rax,0x238(%rsp)
lea    (%r12,%rbx,8),%rax
mov    %rax,0x230(%rsp)
mov    %rsi,0x140(%rsp)
lea    -0x8(%r12,%rsi,1),%rax
mov    %rax,0x218(%rsp)
mov    %rcx,0xb8(%rsp)
lea    -0x8(%r12,%rcx,1),%rax
mov    %rax,0x210(%rsp)
mov    0x310(%rsp),%rax
lea    -0x8(%rax),%rax
mov    %rax,0x158(%rsp)
lea    -0x8(%r12),%rax
mov    %rax,0x208(%rsp)
lea    -0x8(%r15),%rax
mov    %rax,0x200(%rsp)
lea    -0x8(%rdi),%rax
mov    %rax,0x1f8(%rsp)
lea    -0x8(%r9),%rax
mov    %rax,0x1f0(%rsp)
lea    0x10(%r10),%rax
mov    %rax,0x220(%rsp)
lea    (%r8,%r8,1),%rax
mov    %rax,0x68(%rsp)
xor    %eax,%eax
mov    %rax,0x90(%rsp)
mov    %rdx,0x1e8(%rsp)
lea    (%rdx,%r13,8),%rax
mov    %rax,0x1e0(%rsp)
mov    %r13,0x28(%rsp)
mov    %rbp,0x270(%rsp)
jmp    1c5b <bigden_+0xb0b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm3,%xmm3
mov    $0x1,%r12d
mov    0x308(%rsp),%rbx
mov    %r12,0x5437(%rip)
movapd %xmm3,%xmm2
mulsd  %xmm3,%xmm2
unpckhpd %xmm3,%xmm3
movapd %xmm8,%xmm1
mulsd  %xmm3,%xmm1
subsd  %xmm2,%xmm1
mulsd  0x33d5(%rip),%xmm8
mulsd  %xmm3,%xmm8
ucomisd %xmm8,%xmm1
jb     3e2c <bigden_+0x2cdc>
mov    0x90(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x553a(%rip)
movsd  0x5452(%rip),%xmm5
ucomisd %xmm14,%xmm1
jb     1c90 <bigden_+0xb40>
sqrtsd %xmm1,%xmm0
jmp    1cba <bigden_+0xb6a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm1,%xmm0
movsd  %xmm5,0x10(%rsp)
call   1070 <sqrt@plt>
movsd  0x10(%rsp),%xmm5
mov    0x300(%rsp),%rdi
mov    0x320(%rsp),%r9
mov    0x8(%rsp),%r8
mov    0xa8(%rsp),%rbp
mov    0xe0(%rsp),%r10
mov    0xb0(%rsp),%r12
divsd  %xmm0,%xmm5
movsd  %xmm5,0x5422(%rip)
mov    0x168(%rsp),%rax
mov    (%rax),%rsi
movsd  0x5377(%rip),%xmm0
test   %rsi,%rsi
mov    0x48(%rsp),%rdx
mov    0x40(%rsp),%r14
xorpd  %xmm4,%xmm4
movapd 0x3326(%rip),%xmm7
mov    %rsi,0x10(%rsp)
jle    1d90 <bigden_+0xc40>
movsd  0x5357(%rip),%xmm1
xorpd  %xmm7,%xmm1
lea    0x1(%rsi),%rax
xorpd  %xmm3,%xmm3
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movapd %xmm3,%xmm2
movsd  (%rdi,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
movsd  (%r9,%rcx,8),%xmm9
mulsd  %xmm0,%xmm9
addsd  %xmm3,%xmm9
mulsd  %xmm5,%xmm9
movsd  %xmm9,(%r9,%rcx,8)
movsd  (%r15,%rcx,8),%xmm3
unpcklpd %xmm3,%xmm3
movhpd (%rdi,%rcx,8),%xmm9
mulpd  %xmm3,%xmm9
movapd %xmm9,%xmm3
addpd  %xmm2,%xmm3
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1d30 <bigden_+0xbe0>
addpd  %xmm2,%xmm9
jmp    1d9a <bigden_+0xc4a>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm9,%xmm9
mov    $0x1,%eax
mov    %rax,0x52bf(%rip)
movsd  0x534f(%rip),%xmm2
movapd %xmm9,%xmm5
unpckhpd %xmm9,%xmm5
movapd %xmm2,%xmm8
mulsd  %xmm5,%xmm8
mulsd  %xmm5,%xmm8
movapd %xmm2,%xmm1
mulsd  %xmm9,%xmm1
mulsd  %xmm9,%xmm1
movapd %xmm2,0x110(%rsp)
mulsd  %xmm0,%xmm2
addsd  0x540b(%rip),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm8,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm2,0x100(%rsp)
movsd  %xmm2,0x527d(%rip)
movsd  0x52e5(%rip),%xmm3
mulsd  %xmm3,%xmm5
mulsd  %xmm0,%xmm5
movapd %xmm5,0x290(%rsp)
movsd  %xmm5,0x5264(%rip)
movapd %xmm9,%xmm2
movsd  %xmm3,0x268(%rsp)
mulsd  %xmm3,%xmm2
movapd %xmm9,%xmm3
shufpd $0x1,%xmm0,%xmm3
unpcklpd %xmm2,%xmm9
mulpd  %xmm3,%xmm9
movhpd %xmm9,0x523d(%rip)
subsd  %xmm1,%xmm8
movsd  %xmm8,0x5237(%rip)
movlpd %xmm9,0x5236(%rip)
movupd %xmm4,0x5236(%rip)
movupd %xmm4,0x523e(%rip)
mov    0x160(%rsp),%rax
mov    (%rax),%rcx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
test   %rcx,%rcx
jle    1fe0 <bigden_+0xe90>
mov    $0x1,%ecx
movsd  0x5325(%rip),%xmm0
mov    %rdx,%rax
jmp    1f4d <bigden_+0xdfd>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
xorpd  %xmm1,%xmm1
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm1,%xmm5
movapd %xmm5,%xmm6
addsd  %xmm4,%xmm6
mulsd  %xmm0,%xmm6
mov    0x20(%rsp),%rdx
add    %rcx,%rdx
mov    0x78(%rsp),%rsi
movsd  %xmm6,(%rsi,%rdx,8)
movapd %xmm1,%xmm6
mulsd  %xmm2,%xmm6
lea    (%rcx,%r13,1),%rdx
movsd  %xmm6,(%rsi,%rdx,8)
mulsd  %xmm3,%xmm2
lea    (%rcx,%r10,1),%rdx
movsd  %xmm2,(%rsi,%rdx,8)
subsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm5
lea    (%rcx,%r14,1),%rdx
movsd  %xmm5,(%rsi,%rdx,8)
movapd 0x110(%rsp),%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm3,%xmm2
lea    (%rcx,%r12,1),%rdx
movsd  %xmm2,(%rsi,%rdx,8)
lea    0x1(%rcx),%rdx
add    $0x8,%rax
cmp    0x18(%rsp),%rcx
mov    %rdx,%rcx
je     1fd0 <bigden_+0xe80>
cmpq   $0x0,0x10(%rsp)
jle    1eb0 <bigden_+0xd60>
mov    %r13,%r11
xorpd  %xmm4,%xmm4
xorpd  %xmm1,%xmm1
mov    %rax,%rdx
xor    %esi,%esi
mov    0x88(%rsp),%rbx
mov    0x10(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
movapd %xmm4,%xmm3
movsd  (%rdx),%xmm4
movsd  (%rdi,%rsi,8),%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm2,%xmm1
unpcklpd %xmm4,%xmm4
movsd  (%r15,%rsi,8),%xmm2
movhpd (%r9,%rsi,8),%xmm2
mulpd  %xmm4,%xmm2
movapd %xmm2,%xmm4
addpd  %xmm3,%xmm4
add    $0x1,%rsi
add    %rbx,%rdx
cmp    %rsi,%r13
jne    1f80 <bigden_+0xe30>
addpd  %xmm3,%xmm2
mov    %r11,%r13
jmp    1eb8 <bigden_+0xd68>
nopl   0x0(%rax)
movsd  %xmm1,0x51d8(%rip)
movsd  %xmm3,0x51d8(%rip)
mov    $0x1,%ecx
mov    $0x1,%r11d
mov    0x10(%rsp),%rdx
test   %rdx,%rdx
jle    205f <bigden_+0xf0f>
lea    0x1(%rdx),%r11
mov    0x328(%rsp),%rcx
mov    0x18(%rsp),%rax
lea    (%rcx,%rax,8),%rcx
mov    %rdx,%rax
xor    %edx,%edx
nop
lea    (%rcx,%rdx,8),%rsi
movq   $0x0,(%rcx,%rdx,8)
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,1)
add    %rbp,%rsi
movsd  (%r9,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,1)
add    %rbp,%rsi
movq   $0x0,0x0(%rbp,%rsi,1)
add    %rbp,%rsi
movq   $0x0,0x0(%rbp,%rsi,1)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    2010 <bigden_+0xec0>
mov    %rax,%rdx
mov    $0x1,%ecx
movapd %xmm8,0x170(%rsp)
mov    %r11,0x4ff0(%rip)
mov    0x5091(%rip),%rax
mov    %rax,0x38(%rsp)
mov    0x2e8(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0xf0(%rsp)
mov    0x18(%rsp),%rbp
lea    0x0(,%rbp,8),%rax
mov    %rax,0x278(%rsp)
mov    %rbp,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x288(%rsp)
add    $0x1,%rax
mov    %rax,0x280(%rsp)
mov    %rbp,%rax
and    $0xfffffffffffffffe,%rax
neg    %rax
mov    %rax,0x1c0(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0x90(%rsp)
mov    0x328(%rsp),%r14
lea    (%r14,%rbp,8),%r15
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
mov    0x330(%rsp),%rdx
mov    %rdx,%r13
mov    0x260(%rsp),%r12
xor    %eax,%eax
movapd %xmm9,0x180(%rsp)
mov    %rdi,0xd0(%rsp)
jmp    2163 <bigden_+0x1013>
nopl   0x0(%rax)
movsd  %xmm0,0x4fc0(%rip)
mov    0x8(%rsp),%r8
mov    0x120(%rsp),%rcx
add    $0x1,%rcx
mov    0x190(%rsp),%rax
add    $0x1,%rax
add    %rbx,%r14
add    %rbx,%r12
add    %rbx,%r13
add    %rbx,%r15
cmp    $0x5,%rax
mov    0x330(%rsp),%rdx
je     26e0 <bigden_+0x1590>
mov    0x20(%rsp),%rsi
mov    %rax,0x190(%rsp)
imul   %rax,%rsi
mov    %rcx,0x120(%rsp)
mov    %rcx,%rax
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rax
cmp    $0x2,%rax
mov    %rbp,%rax
cmove  0xf0(%rsp),%rax
mov    %rax,0x50(%rsp)
lea    (%rdx,%rsi,8),%rbx
test   %rbp,%rbp
jle    21e3 <bigden_+0x1093>
mov    %rbx,%rdi
mov    %rsi,0x130(%rsp)
xor    %esi,%esi
mov    0x278(%rsp),%rdx
call   1030 <memset@plt>
mov    0x130(%rsp),%rsi
movapd 0x180(%rsp),%xmm9
movapd 0x2e52(%rip),%xmm7
mov    0x8(%rsp),%r8
mov    %rbx,0x1b0(%rsp)
cmpq   $0x0,0x38(%rsp)
jle    2470 <bigden_+0x1320>
add    %rbp,%rsi
mov    0x330(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,0x1a0(%rsp)
mov    0x120(%rsp),%rax
imul   0x20(%rsp),%rax
mov    %rax,0x130(%rsp)
mov    0x2e0(%rsp),%rax
mov    (%rax),%r10
mov    $0x1,%eax
mov    0x70(%rsp),%rsi
xor    %edi,%edi
jmp    225e <bigden_+0x110e>
nopl   (%rax)
lea    0x1(%rax),%rcx
add    $0x1,%rdi
add    0x88(%rsp),%rsi
cmp    0x38(%rsp),%rax
mov    %rcx,%rax
je     2470 <bigden_+0x1320>
test   %rbp,%rbp
jle    2240 <bigden_+0x10f0>
cmp    $0x1,%rbp
jne    2280 <bigden_+0x1130>
xorpd  %xmm0,%xmm0
mov    $0x1,%edx
jmp    22d6 <bigden_+0x1186>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorpd  %xmm1,%xmm1
mov    $0x1,%edx
mov    0x1c0(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdx,8),%xmm2
mulsd  -0x8(%r14,%rdx,8),%xmm2
movsd  (%rsi,%rdx,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  (%r14,%rdx,8),%xmm0
addsd  %xmm2,%xmm0
lea    (%rbx,%rdx,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdx
movapd %xmm0,%xmm1
cmp    $0x1,%rcx
jne    22a0 <bigden_+0x1150>
mov    %rax,%r11
imul   %r8,%r11
test   $0x1,%bpl
je     2310 <bigden_+0x11c0>
lea    (%rdx,%r11,1),%rcx
mov    0xc8(%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm1
mov    0x18(%rsp),%rbp
add    0x130(%rsp),%rdx
mov    0x78(%rsp),%rcx
mulsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
cmp    %r10,%rax
mov    0x90(%rsp),%rbx
jge    2321 <bigden_+0x11d1>
xorpd  %xmm7,%xmm0
test   %rbp,%rbp
jle    2240 <bigden_+0x10f0>
mov    $0x1,%r9d
cmp    $0x4,%rbp
jb     23e0 <bigden_+0x1290>
mov    %r8,%rdx
imul   %rdi,%rdx
lea    (%rdx,%rbp,1),%r8
mov    0x70(%rsp),%rcx
lea    (%rcx,%r8,8),%rcx
mov    0x8(%rsp),%r8
cmp    %rcx,0x1b0(%rsp)
jae    2370 <bigden_+0x1220>
mov    0x70(%rsp),%rcx
lea    (%rcx,%rdx,8),%rcx
cmp    0x1a0(%rsp),%rcx
jb     23e0 <bigden_+0x1290>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %ecx,%ecx
mov    0x288(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rsi,%rcx,8),%xmm2
movupd 0x10(%rsi,%rcx,8),%xmm3
movupd -0x10(%r12,%rcx,8),%xmm4
movupd (%r12,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%r12,%rcx,8)
movupd %xmm3,(%r12,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    2390 <bigden_+0x1240>
mov    0x280(%rsp),%r9
cmp    %rdx,%rbp
je     2240 <bigden_+0x10f0>
nop
mov    %r9,%rdx
test   $0x1,%bpl
je     241f <bigden_+0x12cf>
add    %r9,%r11
mov    0x130(%rsp),%rcx
add    %r9,%rcx
mov    0xc8(%rsp),%rdx
movsd  (%rdx,%r11,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x80(%rsp),%rdx
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
lea    0x1(%r9),%rdx
cmp    %r9,%rbp
je     2240 <bigden_+0x10f0>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r13,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%r13,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%r13,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rbx
jne    2430 <bigden_+0x12e0>
jmp    2240 <bigden_+0x10f0>
nopl   (%rax)
mov    0x50(%rsp),%r10
cmp    0xf0(%rsp),%r10
mov    0xb8(%rsp),%rbp
mov    0xa8(%rsp),%rbx
mov    0x80(%rsp),%r11
mov    0x10(%rsp),%rdx
mov    0xd0(%rsp),%rdi
jne    25cd <bigden_+0x147d>
cmpq   $0x0,0x18(%rsp)
jle    25cd <bigden_+0x147d>
mov    0x120(%rsp),%r9
imul   0x20(%rsp),%r9
mov    0x18(%rsp),%rax
lea    (%r9,%rax,1),%r8
mov    $0x1,%esi
mov    0xc0(%rsp),%rcx
jmp    2512 <bigden_+0x13c2>
nopw   0x0(%rax,%rax,1)
lea    (%rsi,%r9,1),%rax
movsd  (%r11,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r11,%rax,8)
lea    0x1(%rsi),%rax
add    $0x8,%rcx
cmp    0x18(%rsp),%rsi
mov    %rax,%rsi
mov    0xd0(%rsp),%rdi
je     25c0 <bigden_+0x1470>
xorpd  %xmm0,%xmm0
test   %rdx,%rdx
jle    24e0 <bigden_+0x1390>
cmp    $0x1,%rdx
jne    2530 <bigden_+0x13e0>
mov    $0x1,%edi
jmp    2573 <bigden_+0x1423>
nopl   0x0(%rax,%rax,1)
mov    %rdi,%r10
mov    $0x1,%edi
mov    %rcx,%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rdx),%xmm1
mulsd  -0x8(%r15,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rdx,%rbx,1),%xmm0
mulsd  (%r15,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
add    %rbp,%rdx
lea    (%r10,%rdi,1),%rax
add    $0x2,%rax
add    $0x2,%rdi
cmp    $0x1,%rax
jne    2540 <bigden_+0x13f0>
mov    0x10(%rsp),%rdx
test   $0x1,%dl
mov    0x50(%rsp),%r10
je     24e0 <bigden_+0x1390>
lea    (%r8,%rdi,1),%rax
imul   0x20(%rsp),%rdi
add    %rsi,%rdi
mov    0xf8(%rsp),%rdx
movsd  (%rdx,%rdi,8),%xmm1
mov    0x78(%rsp),%rdx
mulsd  (%rdx,%rax,8),%xmm1
mov    0x10(%rsp),%rdx
addsd  %xmm1,%xmm0
jmp    24e0 <bigden_+0x1390>
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,0x4b20(%rip)
mov    0x8(%rsp),%r8
test   %rdx,%rdx
mov    0x18(%rsp),%rbp
mov    0x120(%rsp),%rcx
jle    2135 <bigden_+0xfe5>
mov    %rcx,%r8
imul   0x20(%rsp),%r8
lea    (%r8,%rbp,1),%r9
mov    %r10,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%edi
mov    0xc0(%rsp),%rsi
jmp    2633 <bigden_+0x14e3>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
lea    (%r9,%rdi,1),%rax
movsd  %xmm0,(%r11,%rax,8)
lea    0x1(%rdi),%rax
add    %rbx,%rsi
cmp    0x10(%rsp),%rdi
mov    %rax,%rdi
je     2120 <bigden_+0xfd0>
test   %r10,%r10
jle    2610 <bigden_+0x14c0>
cmp    $0x1,%r10
jne    2650 <bigden_+0x1500>
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
jmp    2696 <bigden_+0x1546>
nopl   0x0(%rax)
xorpd  %xmm1,%xmm1
mov    $0x1,%eax
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rax,8),%xmm2
mulsd  -0x8(%r14,%rax,8),%xmm2
movsd  (%rsi,%rax,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  (%r14,%rax,8),%xmm0
addsd  %xmm2,%xmm0
lea    (%rdx,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    $0x1,%rcx
jne    2660 <bigden_+0x1510>
test   $0x1,%r10b
je     2614 <bigden_+0x14c4>
mov    %rdi,%rcx
imul   0x20(%rsp),%rcx
add    %rax,%rcx
mov    0xf8(%rsp),%rbp
movsd  0x0(%rbp,%rcx,8),%xmm1
mov    0x18(%rsp),%rbp
add    %r8,%rax
mov    0x78(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm1,%xmm0
jmp    2614 <bigden_+0x14c4>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0xf0(%rsp),%r13
test   %r13,%r13
mov    0x258(%rsp),%r9
jle    2b30 <bigden_+0x19e0>
movapd 0x110(%rsp),%xmm0
xorpd  %xmm7,%xmm0
movapd %xmm0,0x1a0(%rsp)
pshufd $0x44,%xmm0,%xmm0
movdqa %xmm0,0x190(%rsp)
xorpd  %xmm3,%xmm3
xorpd  %xmm6,%xmm6
xor    %eax,%eax
xorps  %xmm11,%xmm11
mov    0x30(%rsp),%r15
mov    0x328(%rsp),%r14
mov    0xb0(%rsp),%r10
mov    0x150(%rsp),%r12
mov    0x148(%rsp),%rbp
mov    0x250(%rsp),%rbx
mov    0x248(%rsp),%rsi
mov    0x240(%rsp),%rcx
mov    0x238(%rsp),%rdi
mov    0x230(%rsp),%r8
movaps 0x100(%rsp),%xmm2
movapd 0x290(%rsp),%xmm12
nopw   0x0(%rax,%rax,1)
movapd %xmm3,0xd0(%rsp)
movapd %xmm9,0x180(%rsp)
movaps %xmm2,0x100(%rsp)
movsd  %xmm11,0x18(%rsp)
movsd  %xmm6,0x10(%rsp)
movsd  (%rdx,%rax,8),%xmm1
movapd %xmm1,0x130(%rsp)
movsd  (%r14,%rax,8),%xmm11
movsd  (%r8,%rax,8),%xmm10
movsd  (%rdi,%rax,8),%xmm3
movsd  (%r9,%rax,8),%xmm9
movsd  (%rsi,%rax,8),%xmm13
movsd  (%r12,%rax,8),%xmm14
movapd 0x110(%rsp),%xmm5
movapd %xmm5,%xmm0
mulsd  %xmm14,%xmm0
movapd %xmm0,%xmm6
movsd  (%rbx,%rax,8),%xmm8
movapd %xmm10,%xmm0
mulsd  %xmm11,%xmm0
movapd %xmm11,0x1c0(%rsp)
movapd %xmm3,0x90(%rsp)
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
subsd  %xmm1,%xmm12
movsd  %xmm12,0x38(%rsp)
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
movapd %xmm9,%xmm7
unpcklpd %xmm14,%xmm7
movapd %xmm14,%xmm4
unpcklpd %xmm9,%xmm4
mulpd  %xmm0,%xmm4
movapd %xmm10,%xmm0
unpcklpd %xmm10,%xmm0
movapd %xmm8,%xmm1
movapd %xmm13,%xmm3
unpcklpd %xmm13,%xmm1
mulpd  %xmm0,%xmm1
movapd %xmm5,%xmm13
mulsd  %xmm10,%xmm13
addpd  %xmm4,%xmm1
movsd  0x0(%rbp,%rax,8),%xmm15
movapd %xmm5,%xmm2
mulsd  %xmm15,%xmm2
movsd  (%rcx,%rax,8),%xmm12
mulsd  %xmm12,%xmm2
movapd 0x110(%rsp),%xmm0
mulsd  %xmm9,%xmm0
movapd %xmm0,%xmm4
mulsd  %xmm8,%xmm6
movapd %xmm6,0x50(%rsp)
movapd %xmm3,%xmm0
unpcklpd %xmm8,%xmm0
mulsd  %xmm9,%xmm11
mulsd  %xmm8,%xmm9
unpcklpd %xmm12,%xmm8
mulsd  %xmm12,%xmm10
unpcklpd %xmm12,%xmm12
mulpd  %xmm7,%xmm12
mulsd  %xmm3,%xmm4
movapd %xmm4,0x1b0(%rsp)
movapd 0x130(%rsp),%xmm7
movapd %xmm7,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm14,%xmm3
movapd %xmm3,0x120(%rsp)
movapd %xmm14,%xmm6
movapd 0x90(%rsp),%xmm3
mulsd  %xmm3,%xmm13
unpcklpd %xmm15,%xmm6
mulsd  %xmm15,%xmm3
unpcklpd %xmm15,%xmm15
mulpd  %xmm15,%xmm0
addpd  %xmm12,%xmm0
movapd %xmm1,%xmm14
addpd  %xmm0,%xmm14
movapd %xmm14,%xmm12
unpckhpd %xmm14,%xmm12
movapd 0x1a0(%rsp),%xmm15
mulsd  %xmm15,%xmm12
addsd  0x38(%rsp),%xmm12
subpd  %xmm0,%xmm1
addsd  %xmm11,%xmm4
movapd 0x170(%rsp),%xmm5
subsd  %xmm4,%xmm5
movapd 0x110(%rsp),%xmm0
movapd %xmm7,%xmm4
mulsd  %xmm7,%xmm0
movapd 0x1c0(%rsp),%xmm11
mulsd  %xmm11,%xmm0
movapd %xmm0,%xmm7
addsd  0x2684(%rip),%xmm7
addsd  %xmm13,%xmm7
addsd  %xmm2,%xmm7
subsd  %xmm13,%xmm5
addsd  %xmm2,%xmm5
movapd %xmm5,0x170(%rsp)
unpcklpd %xmm11,%xmm11
mulpd  %xmm11,%xmm6
unpcklpd %xmm4,%xmm4
mulpd  %xmm4,%xmm8
addpd  %xmm6,%xmm8
movapd 0x180(%rsp),%xmm4
subpd  %xmm8,%xmm4
movapd 0x100(%rsp),%xmm2
movsd  0x10(%rsp),%xmm6
addsd  %xmm3,%xmm10
shufpd $0x2,%xmm1,%xmm14
unpcklpd %xmm1,%xmm10
movapd 0x1b0(%rsp),%xmm1
addsd  %xmm1,%xmm7
subsd  %xmm1,%xmm6
movsd  0x18(%rsp),%xmm11
movapd 0x50(%rsp),%xmm1
addsd  %xmm1,%xmm7
addsd  %xmm1,%xmm6
movapd 0xd0(%rsp),%xmm8
subsd  %xmm0,%xmm2
subsd  %xmm7,%xmm2
movapd 0x190(%rsp),%xmm1
mulpd  %xmm1,%xmm14
addsd  0x120(%rsp),%xmm9
movapd %xmm14,%xmm3
addpd  %xmm8,%xmm3
mulpd  %xmm1,%xmm10
mulsd  %xmm15,%xmm9
addsd  %xmm9,%xmm11
movapd %xmm10,%xmm9
addpd  %xmm4,%xmm9
add    $0x1,%rax
cmp    %rax,%r13
jne    2790 <bigden_+0x1640>
addpd  %xmm8,%xmm14
addpd  %xmm4,%xmm10
movsd  %xmm0,0x463a(%rip)
movsd  %xmm13,0x4641(%rip)
movsd  %xmm7,0x4641(%rip)
movq   $0x6,0x45ae(%rip)
movsd  %xmm2,0x45c6(%rip)
movsd  %xmm12,0x45c5(%rip)
movhpd %xmm10,0x45c4(%rip)
movlpd %xmm14,0x45db(%rip)
movaps 0x170(%rsp),%xmm0
movsd  %xmm0,0x45b3(%rip)
movapd %xmm14,%xmm0
movsd  %xmm10,%xmm0
movapd %xmm0,0x45a9(%rip)
movsd  %xmm6,0x10(%rsp)
movsd  %xmm6,0x45b3(%rip)
movsd  %xmm11,0x45b2(%rip)
movapd %xmm10,%xmm9
movapd %xmm2,%xmm13
movapd %xmm12,%xmm8
mov    0x40(%rsp),%rbx
mov    0x28(%rsp),%r13
jmp    2b6a <bigden_+0x1a1a>
nopl   0x0(%rax)
xorpd  %xmm14,%xmm14
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x30(%rsp),%r15
mov    0x28(%rsp),%r13
mov    0x40(%rsp),%rbx
mov    0xb0(%rsp),%r10
movapd 0x100(%rsp),%xmm13
movapd 0x290(%rsp),%xmm8
mov    0x2f8(%rsp),%rax
mov    (%rax),%rax
mov    0x20(%rsp),%rcx
add    %rax,%rcx
movsd  (%r11,%rcx,8),%xmm0
movsd  0x268(%rsp),%xmm7
mulsd  %xmm0,%xmm7
movapd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
movapd 0x110(%rsp),%xmm4
mulsd  %xmm4,%xmm2
movsd  0x4563(%rip),%xmm0
mulsd  %xmm0,%xmm13
addsd  %xmm2,%xmm13
movapd %xmm13,%xmm1
movapd %xmm2,%xmm3
addsd  0x2460(%rip),%xmm3
lea    (%rax,%r13,1),%rcx
movsd  (%r11,%rcx,8),%xmm2
mulsd  %xmm2,%xmm2
mulsd  %xmm4,%xmm2
movsd  %xmm2,0x44fe(%rip)
addsd  %xmm2,%xmm3
mov    0xe0(%rsp),%rdx
lea    (%rax,%rdx,1),%rdx
movsd  (%r11,%rdx,8),%xmm6
movapd %xmm6,%xmm12
mulsd  %xmm6,%xmm12
mulsd  %xmm4,%xmm12
addsd  %xmm12,%xmm3
lea    (%rax,%rbx,1),%rdx
movsd  (%r11,%rdx,8),%xmm13
mulsd  %xmm13,%xmm13
mulsd  %xmm4,%xmm13
addsd  %xmm13,%xmm3
add    %r10,%rax
movsd  (%r11,%rax,8),%xmm5
movapd %xmm5,%xmm11
mulsd  %xmm5,%xmm11
mulsd  %xmm4,%xmm11
addsd  %xmm11,%xmm3
addsd  %xmm3,%xmm1
movapd %xmm1,0x100(%rsp)
movsd  %xmm1,0x44c9(%rip)
movsd  (%r11,%rcx,8),%xmm10
movapd %xmm7,%xmm3
mulsd  %xmm10,%xmm3
mulsd  %xmm0,%xmm8
addsd  %xmm3,%xmm8
movsd  (%r11,%rdx,8),%xmm15
movapd %xmm10,%xmm3
mulsd  %xmm15,%xmm3
addsd  %xmm3,%xmm8
movapd %xmm14,%xmm4
unpckhpd %xmm14,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm6,%xmm3
mulsd  %xmm5,%xmm3
movapd %xmm5,%xmm1
movsd  %xmm5,0x18(%rsp)
addsd  %xmm3,%xmm8
subsd  %xmm3,%xmm4
movapd %xmm7,%xmm3
mulsd  %xmm6,%xmm3
movapd %xmm9,%xmm5
unpckhpd %xmm9,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm3,%xmm5
movapd %xmm15,%xmm3
mulsd  %xmm6,%xmm3
mulsd  %xmm10,%xmm6
mulsd  %xmm1,%xmm10
addsd  %xmm10,%xmm5
subsd  %xmm3,%xmm5
movsd  %xmm5,0x4450(%rip)
movsd  %xmm10,0x44bf(%rip)
mulsd  %xmm0,%xmm14
addsd  %xmm10,%xmm14
addsd  %xmm3,%xmm14
movsd  %xmm14,0x446f(%rip)
movapd %xmm7,%xmm1
mulsd  %xmm15,%xmm1
movapd 0x170(%rsp),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
subsd  %xmm12,%xmm3
movsd  0x18(%rsp),%xmm2
mulsd  %xmm2,%xmm7
movsd  %xmm7,0x446a(%rip)
mulsd  %xmm0,%xmm9
addsd  %xmm7,%xmm9
addsd  %xmm9,%xmm6
movsd  %xmm6,0x4403(%rip)
movsd  0x10(%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm13,%xmm1
subsd  %xmm11,%xmm1
mulsd  %xmm2,%xmm15
mulsd  0x4342(%rip),%xmm0
addsd  %xmm15,%xmm0
movsd  %xmm0,0x4415(%rip)
movsd  %xmm8,0x439c(%rip)
addsd  0x100(%rsp),%xmm8
movsd  %xmm3,0x43aa(%rip)
addsd  %xmm3,%xmm8
movsd  %xmm4,0x43bd(%rip)
addsd  %xmm4,%xmm8
movsd  %xmm1,0x43d0(%rip)
addsd  %xmm1,%xmm8
movsd  %xmm8,0x431a(%rip)
movsd  %xmm8,0x4401(%rip)
movsd  %xmm8,0x4400(%rip)
movq   $0x0,0x43d5(%rip)
movb   $0x1,0x4286(%rip)
movsd  0x42ce(%rip),%xmm0
movsd  %xmm0,0x42ce(%rip)
movsd  0x43c6(%rip),%xmm1
divsd  0x21fe(%rip),%xmm1
movsd  %xmm1,0x42e6(%rip)
movq   $0x1,0x423b(%rip)
mov    $0x1,%edx
mov    0x68(%rsp),%r14
nop
xorps  %xmm0,%xmm0
cvtsi2sd %rdx,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x42d4(%rip)
call   1060 <cos@plt>
movsd  %xmm0,0x428f(%rip)
movsd  0x42bf(%rip),%xmm0
call   1040 <sin@plt>
movsd  0x427a(%rip),%xmm7
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm7,%xmm4
mulsd  %xmm7,%xmm4
subsd  %xmm1,%xmm4
movapd %xmm0,%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm3,%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm7,%xmm5
mulsd  %xmm4,%xmm5
subsd  %xmm1,%xmm5
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm7,%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm6,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm7,%xmm10
mulsd  %xmm5,%xmm10
subsd  %xmm1,%xmm10
movapd %xmm0,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm7,%xmm9
mulsd  %xmm6,%xmm9
addsd  %xmm1,%xmm9
movsd  0x4203(%rip),%xmm8
movsd  0x4233(%rip),%xmm1
mulsd  0x41db(%rip),%xmm1
xorpd  %xmm2,%xmm2
addsd  %xmm2,%xmm1
mulsd  0x422b(%rip),%xmm7
mulsd  0x4233(%rip),%xmm0
addsd  %xmm1,%xmm7
addsd  %xmm7,%xmm0
mulsd  0x4233(%rip),%xmm4
addsd  %xmm0,%xmm4
mulsd  0x4237(%rip),%xmm3
addsd  %xmm4,%xmm3
mulsd  0x423b(%rip),%xmm5
mulsd  0x4243(%rip),%xmm6
addsd  %xmm3,%xmm5
addsd  %xmm5,%xmm6
mulsd  0x4242(%rip),%xmm10
addsd  %xmm6,%xmm10
mulsd  0x4244(%rip),%xmm9
addsd  %xmm10,%xmm9
movsd  0x4277(%rip),%xmm0
movapd %xmm9,%xmm1
unpcklpd %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm1
movsd  %xmm9,0x4169(%rip)
movapd %xmm1,%xmm2
psrad  $0x1f,%xmm2
paddd  %xmm2,%xmm1
pxor   %xmm2,%xmm1
movd   %xmm1,%eax
pshufd $0x55,%xmm1,%xmm1
movd   %xmm1,%ecx
cmp    %ecx,%eax
jbe    2fd0 <bigden_+0x1e80>
movsd  %xmm9,0x4236(%rip)
mov    0x40af(%rip),%rax
mov    %rax,0x4208(%rip)
movsd  %xmm8,0x41ef(%rip)
movapd %xmm9,%xmm0
mov    %rax,%rcx
jmp    2ff0 <bigden_+0x1ea0>
nopl   0x0(%rax,%rax,1)
mov    0x4089(%rip),%rcx
mov    0x41e2(%rip),%rax
lea    0x1(%rax),%rdx
cmp    %rdx,%rcx
jne    2ff0 <bigden_+0x1ea0>
movsd  %xmm9,0x41c8(%rip)
lea    0x1(%rcx),%rdx
mov    %rdx,0x4065(%rip)
cmp    $0x30,%rcx
jg     3010 <bigden_+0x1ec0>
movsd  0x40f7(%rip),%xmm1
jmp    2e30 <bigden_+0x1ce0>
xchg   %ax,%ax
test   %rax,%rax
jne    301e <bigden_+0x1ece>
movsd  %xmm9,0x4192(%rip)
cmpb   $0x0,0x4053(%rip)
mov    $0x0,%ecx
mov    $0x31,%edx
cmovne %rdx,%rcx
cmp    %rcx,%rax
lea    0x417b(%rip),%rcx
lea    0x4194(%rip),%rdx
cmove  %rdx,%rcx
movsd  (%rcx),%xmm1
movsd  0x415c(%rip),%xmm2
ucomisd %xmm1,%xmm2
jne    305c <bigden_+0x1f0c>
jnp    3090 <bigden_+0x1f40>
subsd  %xmm0,%xmm2
movsd  %xmm2,0x4148(%rip)
subsd  %xmm0,%xmm1
movsd  %xmm1,0x4144(%rip)
movapd %xmm2,%xmm3
subsd  %xmm1,%xmm3
mulsd  0x4074(%rip),%xmm3
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm3
jmp    3094 <bigden_+0x1f44>
xchg   %ax,%ax
xorpd  %xmm3,%xmm3
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm3,%xmm0
mulsd  0x4058(%rip),%xmm0
movsd  %xmm0,0x4068(%rip)
call   1060 <cos@plt>
movsd  %xmm0,0x4023(%rip)
movsd  0x4053(%rip),%xmm0
call   1040 <sin@plt>
movsd  0x400d(%rip),%xmm11
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm11,%xmm9
mulsd  %xmm11,%xmm9
subsd  %xmm1,%xmm9
movapd %xmm0,%xmm10
mulsd  %xmm11,%xmm10
addsd  %xmm10,%xmm10
movapd %xmm10,%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm11,%xmm5
mulsd  %xmm9,%xmm5
subsd  %xmm1,%xmm5
movapd %xmm0,%xmm1
mulsd  %xmm9,%xmm1
movapd %xmm11,%xmm3
mulsd  %xmm10,%xmm3
addsd  %xmm1,%xmm3
movapd %xmm3,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm11,%xmm1
mulsd  %xmm5,%xmm1
subsd  %xmm2,%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm5,%xmm2
movapd %xmm11,%xmm13
mulsd  %xmm3,%xmm13
addsd  %xmm2,%xmm13
movsd  0x3f74(%rip),%xmm15
movsd  0x3f1c(%rip),%xmm2
mulsd  %xmm15,%xmm2
xorpd  %xmm14,%xmm14
addsd  %xmm14,%xmm2
movsd  0x3fa5(%rip),%xmm4
mulsd  %xmm15,%xmm4
addsd  %xmm14,%xmm4
movsd  0x3efb(%rip),%xmm6
mulsd  %xmm11,%xmm6
addsd  %xmm2,%xmm6
movsd  0x3f92(%rip),%xmm2
mulsd  %xmm11,%xmm2
addsd  %xmm4,%xmm2
movsd  0x3ee1(%rip),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm6,%xmm4
movapd %xmm0,%xmm6
mulsd  0x3f7d(%rip),%xmm6
addsd  %xmm2,%xmm6
movsd  0x3ec9(%rip),%xmm2
mulsd  %xmm9,%xmm2
addsd  %xmm4,%xmm2
movsd  0x3f70(%rip),%xmm4
mulsd  %xmm9,%xmm4
addsd  %xmm6,%xmm4
movsd  0x3eaf(%rip),%xmm6
mulsd  %xmm10,%xmm6
addsd  %xmm2,%xmm6
movsd  0x3f5e(%rip),%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm4,%xmm2
movsd  0x3e95(%rip),%xmm4
mulsd  %xmm5,%xmm4
mulsd  0x3f51(%rip),%xmm5
addsd  %xmm6,%xmm4
addsd  %xmm2,%xmm5
movsd  0x3e81(%rip),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm4,%xmm2
mulsd  0x3f41(%rip),%xmm3
addsd  %xmm5,%xmm3
movsd  0x3e6d(%rip),%xmm4
mulsd  %xmm1,%xmm4
mulsd  0x3f39(%rip),%xmm1
addsd  %xmm2,%xmm4
addsd  %xmm3,%xmm1
movsd  0x3e59(%rip),%xmm2
mulsd  %xmm13,%xmm2
addsd  %xmm4,%xmm2
mulsd  0x3f27(%rip),%xmm13
addsd  %xmm1,%xmm13
mov    0x318(%rsp),%rax
movsd  %xmm2,(%rax)
movsd  %xmm13,0x3f4d(%rip)
mov    0x2e8(%rsp),%rax
mov    (%rax),%r10
test   %r10,%r10
mov    0x320(%rsp),%r9
mov    0x80(%rsp),%r11
mov    %r10,0x50(%rsp)
jle    3592 <bigden_+0x2442>
mov    $0x1,%r12d
cmp    $0x1,%r10
je     34d0 <bigden_+0x2380>
mov    0x310(%rsp),%rcx
mov    %rbx,%rsi
mov    %rcx,%rbx
lea    (%rcx,%r10,8),%rbp
mov    0x150(%rsp),%rdx
lea    (%rdx,%r10,8),%r11
mov    0x1e8(%rsp),%rax
lea    (%rax,%rsi,8),%r8
add    %r10,%rsi
lea    (%rax,%rsi,8),%rsi
mov    %r10,%rcx
mov    0x148(%rsp),%r10
lea    (%r10,%rcx,8),%r9
lea    (%rcx,%r13,1),%rdi
lea    (%rax,%rdi,8),%rdi
cmp    %rbx,%r11
seta   %r14b
cmp    %rbp,%rdx
setb   %r15b
cmp    %rbx,%rsi
seta   %al
cmp    %rbp,%r8
mov    0x330(%rsp),%rdx
lea    (%rdx,%rcx,8),%rsi
mov    %rdx,%rcx
setb   %r11b
cmp    %rbx,%r9
seta   %dl
cmp    %rbp,%r10
setb   %r8b
cmp    %rbx,%rdi
seta   %dil
cmp    %rbp,0x1e0(%rsp)
setb   %r9b
cmp    %rbx,%rsi
seta   %sil
cmp    %rcx,%rbp
seta   %r10b
test   %r15b,%r14b
jne    3dee <bigden_+0x2c9e>
and    %r11b,%al
mov    0x30(%rsp),%r15
mov    0x68(%rsp),%r14
mov    0x40(%rsp),%rbx
jne    3e17 <bigden_+0x2cc7>
and    %r8b,%dl
mov    0x80(%rsp),%r11
jne    34bb <bigden_+0x236b>
and    %r9b,%dil
jne    34bb <bigden_+0x236b>
and    %r10b,%sil
mov    0x320(%rsp),%r9
mov    0x50(%rsp),%r10
jne    34d0 <bigden_+0x2380>
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
mov    %r10,%r12
or     $0x1,%r12
movapd %xmm15,%xmm8
unpcklpd %xmm15,%xmm8
movapd %xmm11,%xmm3
unpcklpd %xmm11,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
movapd %xmm9,%xmm5
unpcklpd %xmm9,%xmm5
movapd %xmm10,%xmm6
unpcklpd %xmm10,%xmm6
mov    0x1d0(%rsp),%rax
lea    (%rax,%r13,8),%rdx
lea    (%rax,%rbx,8),%rsi
mov    %r8,%rdi
mov    0x330(%rsp),%rbp
mov    0x310(%rsp),%rbx
mov    0x140(%rsp),%rcx
mov    0xb8(%rsp),%rax
xorpd  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd %xmm1,(%rbx)
movupd 0x0(%rbp),%xmm2
mulpd  %xmm8,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%rbx)
movupd 0x0(%rbp,%rdx,1),%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm2,%xmm7
movupd %xmm7,(%rbx)
movupd 0x0(%rbp,%rax,1),%xmm2
mulpd  %xmm4,%xmm2
addpd  %xmm7,%xmm2
movupd %xmm2,(%rbx)
movupd 0x0(%rbp,%rsi,1),%xmm7
mulpd  %xmm5,%xmm7
addpd  %xmm2,%xmm7
movupd %xmm7,(%rbx)
movupd 0x0(%rbp,%rcx,1),%xmm2
mulpd  %xmm6,%xmm2
addpd  %xmm7,%xmm2
movupd %xmm2,(%rbx)
add    $0x10,%rbx
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    3440 <bigden_+0x22f0>
cmp    %r8,%r10
mov    0x40(%rsp),%rbx
jne    34d0 <bigden_+0x2380>
jmp    3592 <bigden_+0x2442>
mov    0x320(%rsp),%r9
mov    0x50(%rsp),%r10
nopl   0x0(%rax,%rax,1)
mov    %r10,%rcx
sub    %r12,%rcx
add    $0x1,%rcx
mov    0x218(%rsp),%rax
lea    (%rax,%r12,8),%r8
lea    (%r12,%rbx,1),%rdx
lea    (%r11,%rdx,8),%rsi
mov    0x210(%rsp),%rax
lea    (%rax,%r12,8),%rdi
lea    (%r12,%r13,1),%rdx
lea    (%r11,%rdx,8),%rbp
mov    0x158(%rsp),%rax
lea    (%rax,%r12,8),%rbx
mov    0x208(%rsp),%rax
lea    (%rax,%r12,8),%rax
xor    %edx,%edx
nopl   0x0(%rax)
movq   $0x0,(%rbx,%rdx,8)
movsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm15,%xmm1
addsd  %xmm14,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm2
mulsd  %xmm11,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rdx,8)
movsd  (%rdi,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movsd  (%rsi,%rdx,8),%xmm2
mulsd  %xmm9,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx,%rdx,8)
movsd  (%r8,%rdx,8),%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    3520 <bigden_+0x23d0>
mov    0x2f8(%rsp),%rax
mov    (%rax),%r11
mov    0x310(%rsp),%rax
movsd  -0x8(%rax,%r11,8),%xmm12
movq   $0x0,0x3ab1(%rip)
movq   $0x0,0x3bee(%rip)
movq   $0x0,0x3beb(%rip)
mov    0x168(%rsp),%rax
mov    (%rax),%r12
test   %r12,%r12
jle    3690 <bigden_+0x2540>
lea    0x1(%r12),%rax
xorpd  %xmm2,%xmm2
xorpd  %xmm5,%xmm5
xor    %ecx,%ecx
mov    0x308(%rsp),%rbx
mov    0x8(%rsp),%r8
mov    0x300(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm2,%xmm1
movsd  (%r9,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  (%rdi,%rcx,8),%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rdi,%rcx,8)
addsd  (%r15,%rcx,8),%xmm3
movsd  %xmm3,(%rbx,%rcx,8)
movsd  (%rdi,%rcx,8),%xmm8
movapd %xmm8,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm2,%xmm5
unpcklpd %xmm3,%xmm8
mulpd  %xmm8,%xmm8
movapd %xmm8,%xmm2
addpd  %xmm1,%xmm2
add    $0x1,%rcx
cmp    %rcx,%r12
jne    3610 <bigden_+0x24c0>
addpd  %xmm1,%xmm8
movlpd %xmm8,0x39ef(%rip)
movsd  %xmm5,0x3b2f(%rip)
movhpd %xmm8,0x3b2e(%rip)
jmp    36b3 <bigden_+0x2563>
nopl   0x0(%rax)
xorpd  %xmm8,%xmm8
mov    $0x1,%eax
xorpd  %xmm5,%xmm5
mov    0x308(%rsp),%rbx
mov    0x8(%rsp),%r8
mov    0x300(%rsp),%rdi
mov    %rax,0x39a6(%rip)
mov    0x3ae7(%rip),%rcx
mov    %rcx,%rax
mov    %rcx,0x90(%rsp)
cmp    %r12,%rcx
jge    3e2c <bigden_+0x2cdc>
movsd  0x3b0b(%rip),%xmm1
cmpq   $0x2,0x90(%rsp)
jl     370d <bigden_+0x25bd>
movsd  0x3ae8(%rip),%xmm2
movapd %xmm2,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm3
orpd   %xmm3,%xmm1
movlpd %xmm1,0x3adb(%rip)
cvttsd2si %xmm13,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
xorps  %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
cvttsd2si %xmm1,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
mulsd  0x18de(%rip),%xmm1
ucomisd %xmm2,%xmm1
mov    0xe8(%rsp),%rcx
jae    3e2c <bigden_+0x2cdc>
movsd  %xmm13,0x3a93(%rip)
mov    0x160(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x10(%rsp)
test   %r12,%r12
jle    39f0 <bigden_+0x28a0>
movsd  0x399a(%rip),%xmm7
mov    $0x1,%eax
movapd %xmm8,%xmm3
unpckhpd %xmm8,%xmm3
cmp    $0x1,%r12
je     3920 <bigden_+0x27d0>
cmpq   $0x1,0x20(%rsp)
jne    3920 <bigden_+0x27d0>
lea    (%r9,%r12,8),%rbp
lea    (%r15,%r12,8),%rdx
lea    (%rdi,%r12,8),%r10
mov    0x310(%rsp),%r8
mov    0x10(%rsp),%rsi
lea    (%r8,%rsi,8),%rcx
lea    (%rsi,%r12,1),%rbx
cmp    %r9,%rdx
mov    %rdi,%rdx
mov    %r15,%rdi
seta   %r15b
lea    (%r8,%rbx,8),%r8
cmp    %rdi,%rbp
seta   %r13b
lea    (%r11,%r12,1),%rdi
cmp    %r9,%r10
seta   %bl
mov    0x1d8(%rsp),%rsi
lea    (%rsi,%rdi,8),%rdi
cmp    %rdx,%rbp
mov    %r9,%rdx
seta   %r9b
cmp    %rdx,%r8
seta   %r14b
cmp    %rbp,%rcx
setb   %r10b
cmp    %rdx,%rdi
seta   %r8b
lea    (%rsi,%r11,8),%rdx
cmp    %rbp,%rdx
setb   %dil
test   %r13b,%r15b
jne    3901 <bigden_+0x27b1>
and    %r9b,%bl
jne    3901 <bigden_+0x27b1>
and    %r10b,%r14b
jne    3901 <bigden_+0x27b1>
and    %dil,%r8b
mov    0x30(%rsp),%r15
mov    0x8(%rsp),%r8
mov    0x320(%rsp),%r9
mov    0x28(%rsp),%r13
mov    0x68(%rsp),%r14
jne    3920 <bigden_+0x27d0>
movapd %xmm15,%xmm6
mov    %r12,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %r12,%rax
or     $0x1,%rax
movapd %xmm5,%xmm13
unpcklpd %xmm5,%xmm13
movapd %xmm7,%xmm14
unpcklpd %xmm7,%xmm14
movapd %xmm12,%xmm15
unpcklpd %xmm12,%xmm15
xor    %ebp,%ebp
mov    0x300(%rsp),%rdi
mov    0xb8(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movupd (%r15,%rbp,8),%xmm1
mulpd  %xmm13,%xmm1
movupd (%rdi,%rbp,8),%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm1,%xmm2
movupd (%rcx,%rbp,8),%xmm1
subpd  %xmm1,%xmm2
movupd (%rdx),%xmm1
mulpd  %xmm15,%xmm1
movapd %xmm2,%xmm4
mulpd  %xmm14,%xmm4
addpd  %xmm1,%xmm4
movupd %xmm4,(%r9,%rbp,8)
add    $0x2,%rbp
add    %rbx,%rdx
cmp    %rbp,%rsi
jne    38a0 <bigden_+0x2750>
cmp    %rsi,%r12
xorpd  %xmm14,%xmm14
movapd %xmm6,%xmm15
jne    3920 <bigden_+0x27d0>
unpckhpd %xmm2,%xmm2
jmp    39d3 <bigden_+0x2883>
mov    0x30(%rsp),%r15
mov    0x8(%rsp),%r8
mov    0x320(%rsp),%r9
mov    0x28(%rsp),%r13
mov    0x68(%rsp),%r14
nopl   (%rax)
mov    %r12,%rcx
sub    %rax,%rcx
add    $0x1,%rcx
mov    0x200(%rsp),%rdx
lea    (%rdx,%rax,8),%r10
mov    0x1f8(%rsp),%rdx
lea    (%rdx,%rax,8),%rsi
mov    0x10(%rsp),%rdx
lea    (%rax,%rdx,1),%rdi
mov    0x158(%rsp),%rdx
lea    (%rdx,%rdi,8),%rbp
mov    0x1f0(%rsp),%rdx
lea    (%rdx,%rax,8),%rbx
imul   0x20(%rsp),%rax
add    %rax,%r11
mov    0xf8(%rsp),%rax
lea    (%rax,%r11,8),%rax
xor    %edi,%edi
mov    0xa8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rdi,8),%xmm1
mulsd  %xmm3,%xmm1
movsd  (%r10,%rdi,8),%xmm2
mulsd  %xmm5,%xmm2
addsd  %xmm1,%xmm2
subsd  0x0(%rbp,%rdi,8),%xmm2
movapd %xmm2,%xmm1
mulsd  %xmm7,%xmm1
movsd  (%rax),%xmm4
mulsd  %xmm12,%xmm4
addsd  %xmm1,%xmm4
movsd  %xmm4,(%rbx,%rdi,8)
add    $0x1,%rdi
add    %rdx,%rax
cmp    %rdi,%rcx
jne    3990 <bigden_+0x2840>
movsd  %xmm2,0x3725(%rip)
mov    0x300(%rsp),%rdi
mov    0xe8(%rsp),%rcx
mov    0x50(%rsp),%r10
cmpq   $0x0,0x10(%rsp)
jle    3d0f <bigden_+0x2bbf>
cmp    $0x1,%r8
sete   %al
movsd  0x3704(%rip),%xmm13
xorpd  0x161b(%rip),%xmm13
lea    (%r9,%r12,8),%rdx
mov    %rdx,0x38(%rsp)
cmp    $0x4,%r12
setae  %dl
and    %al,%dl
mov    %dl,0x18(%rsp)
mov    %r12,%r13
and    $0xfffffffffffffffc,%r13
lea    0x1(%r13),%rax
mov    %rax,0xd0(%rsp)
mov    %r12,%rbp
and    $0xfffffffffffffffe,%rbp
neg    %rbp
lea    0x1(%r12),%r15
mov    $0x1,%r11d
mov    0x228(%rsp),%rdi
mov    0x220(%rsp),%r9
mov    0x48(%rsp),%rbx
xor    %r10d,%r10d
jmp    3a9a <bigden_+0x294a>
nopl   (%rax)
lea    0x1(%r11),%rdx
add    $0x1,%r10
add    $0x8,%rbx
add    $0x8,%r9
add    $0x8,%rdi
cmp    0x10(%rsp),%r11
mov    %rdx,%r11
mov    0xe8(%rsp),%rcx
je     3ce0 <bigden_+0x2b90>
xorpd  %xmm7,%xmm7
test   %r12,%r12
jle    3ac0 <bigden_+0x2970>
mov    $0x1,%r8d
cmp    $0x1,%r12
jne    3ad0 <bigden_+0x2980>
mov    0x308(%rsp),%rsi
jmp    3b2b <bigden_+0x29db>
nopl   0x0(%rax)
mov    0x308(%rsp),%rsi
jmp    3b55 <bigden_+0x2a05>
nopl   (%rax)
mov    %rbx,%rdx
mov    0x308(%rsp),%rsi
mov    0x88(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx),%xmm1
mulsd  -0x8(%rsi,%r8,8),%xmm1
addsd  %xmm7,%xmm1
movsd  (%rdx,%rax,1),%xmm7
mulsd  (%rsi,%r8,8),%xmm7
addsd  %xmm1,%xmm7
add    %rcx,%rdx
lea    (%r8,%rbp,1),%rsi
add    $0x2,%rsi
add    $0x2,%r8
cmp    $0x1,%rsi
mov    0x308(%rsp),%rsi
jne    3af0 <bigden_+0x29a0>
test   $0x1,%r12b
je     3b55 <bigden_+0x2a05>
mov    %r8,%rdx
imul   0x8(%rsp),%rdx
add    %r11,%rdx
mov    0xa0(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  -0x8(%rsi,%r8,8),%xmm1
addsd  %xmm1,%xmm7
lea    (%r11,%r12,1),%rdx
mov    0x310(%rsp),%rcx
movsd  -0x8(%rcx,%r11,8),%xmm1
mulsd  %xmm13,%xmm1
movsd  -0x8(%rsi,%rdx,8),%xmm3
mulsd  %xmm12,%xmm3
addsd  %xmm1,%xmm3
mulsd  %xmm7,%xmm3
test   %r12,%r12
mov    0x8(%rsp),%r8
jle    3a70 <bigden_+0x2920>
mov    $0x1,%edx
cmpb   $0x0,0x18(%rsp)
je     3c40 <bigden_+0x2af0>
lea    (%r12,%r10,1),%rsi
mov    0x48(%rsp),%rcx
lea    (%rcx,%rsi,8),%rsi
mov    0x320(%rsp),%rcx
cmp    %rcx,%rsi
jbe    3bc8 <bigden_+0x2a78>
mov    0x48(%rsp),%rsi
lea    (%rsi,%r10,8),%rsi
cmp    0x38(%rsp),%rsi
jb     3c40 <bigden_+0x2af0>
movapd %xmm3,%xmm1
unpcklpd %xmm3,%xmm1
mov    %r9,%rdx
xor    %esi,%esi
mov    0x270(%rsp),%r14
nopl   (%rax)
movupd -0x10(%rdx),%xmm2
movupd (%rdx),%xmm4
movupd (%rcx,%rsi,8),%xmm5
movupd 0x10(%rcx,%rsi,8),%xmm6
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm2,(%rcx,%rsi,8)
movupd %xmm4,0x10(%rcx,%rsi,8)
add    $0x4,%rsi
add    %r14,%rdx
cmp    %rsi,%r13
jne    3be0 <bigden_+0x2a90>
mov    0xd0(%rsp),%rdx
cmp    %r13,%r12
mov    0x68(%rsp),%r14
je     3a70 <bigden_+0x2920>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rsi
test   $0x1,%r12b
je     3c7c <bigden_+0x2b2c>
mov    %rdx,%rsi
imul   %r8,%rsi
add    %r11,%rsi
mov    0xa0(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm1
mulsd  %xmm3,%xmm1
mov    0x320(%rsp),%rcx
addsd  -0x8(%rcx,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rdx,8)
lea    0x1(%rdx),%rsi
cmp    %rdx,%r12
mov    0x320(%rsp),%rcx
je     3a70 <bigden_+0x2920>
mov    %r8,%rdx
imul   %rsi,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rdx,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  -0x8(%rcx,%rsi,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rsi,8)
movsd  (%rbx,%rdx,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  (%rcx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
add    $0x2,%rsi
add    %r14,%rdx
cmp    %rsi,%r15
jne    3ca0 <bigden_+0x2b50>
jmp    3a70 <bigden_+0x2920>
nopl   0x0(%rax)
movsd  %xmm7,0x3400(%rip)
movsd  %xmm3,0x3410(%rip)
mov    0x30(%rsp),%r15
mov    0x320(%rsp),%r9
mov    0x300(%rsp),%rdi
mov    0x28(%rsp),%r13
mov    0x50(%rsp),%r10
movq   $0x0,0x3356(%rip)
test   %r12,%r12
jle    1c10 <bigden_+0xac0>
cmp    $0x1,%r12
jne    3d40 <bigden_+0x2bf0>
xorpd  %xmm1,%xmm1
mov    $0x1,%eax
jmp    3db2 <bigden_+0x2c62>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
xorpd  %xmm1,%xmm1
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x8(%rdi,%rax,8),%xmm4
movsd  (%rdi,%rax,8),%xmm5
movsd  -0x8(%r9,%rax,8),%xmm2
movsd  (%r9,%rax,8),%xmm3
unpcklpd %xmm2,%xmm4
unpcklpd %xmm2,%xmm2
mulpd  %xmm4,%xmm2
addpd  %xmm1,%xmm2
unpcklpd %xmm3,%xmm5
unpcklpd %xmm3,%xmm3
mulpd  %xmm5,%xmm3
movapd %xmm3,%xmm1
addpd  %xmm2,%xmm1
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    3d60 <bigden_+0x2c10>
addpd  %xmm2,%xmm3
mov    0x308(%rsp),%rbx
test   $0x1,%r12b
je     3ddd <bigden_+0x2c8d>
movsd  -0x8(%r9,%rax,8),%xmm3
movsd  -0x8(%rdi,%rax,8),%xmm2
unpcklpd %xmm3,%xmm2
unpcklpd %xmm3,%xmm3
mulpd  %xmm2,%xmm3
addpd  %xmm1,%xmm3
add    $0x1,%r12
movlpd %xmm3,0x3287(%rip)
jmp    1c22 <bigden_+0xad2>
mov    0x30(%rsp),%r15
mov    0x320(%rsp),%r9
mov    0x80(%rsp),%r11
mov    0x68(%rsp),%r14
mov    0x50(%rsp),%r10
mov    0x40(%rsp),%rbx
jmp    34d0 <bigden_+0x2380>
mov    0x320(%rsp),%r9
mov    0x80(%rsp),%r11
jmp    34c3 <bigden_+0x2373>
test   %r10,%r10
mov    0x328(%rsp),%r8
mov    0x40(%rsp),%r11
jle    40f5 <bigden_+0x2fa5>
mov    $0x1,%r13d
cmp    $0x1,%r10
je     403b <bigden_+0x2eeb>
lea    (%rbx,%r10,8),%rcx
lea    (%r8,%r11,8),%r15
mov    %rbx,%rdi
lea    (%r10,%r11,1),%rsi
lea    (%r8,%rsi,8),%r14
mov    %r11,%rbp
mov    0x20(%rsp),%rax
sub    %rax,%rbp
lea    (%r8,%rbp,8),%rdx
mov    %rdx,0x10(%rsp)
sub    %rax,%rsi
lea    (%r8,%rsi,8),%rbp
mov    0x28(%rsp),%rdx
lea    (%r8,%rdx,8),%r9
lea    (%r10,%rdx,1),%rbx
lea    (%r8,%rbx,8),%r12
sub    %rax,%rdx
lea    (%r8,%rdx,8),%r11
sub    %rax,%rbx
lea    (%r8,%rbx,8),%rsi
cmp    %rdi,%r14
seta   %r14b
cmp    %rcx,%r15
setb   %r15b
cmp    %rdi,%rbp
seta   %dl
lea    (%r8,%r10,8),%rbp
cmp    %rcx,0x10(%rsp)
setb   %al
cmp    %rdi,%r12
seta   %bl
cmp    %rcx,%r9
setb   %r9b
cmp    %rdi,%rsi
seta   %sil
cmp    %rcx,%r11
setb   %r10b
cmp    %rdi,%rbp
seta   %dil
cmp    %r8,%rcx
seta   %cl
test   %r15b,%r14b
jne    4143 <bigden_+0x2ff3>
and    %al,%dl
mov    0x40(%rsp),%r11
jne    415d <bigden_+0x300d>
and    %r9b,%bl
mov    0x328(%rsp),%r8
jne    402e <bigden_+0x2ede>
and    %r10b,%sil
jne    402e <bigden_+0x2ede>
and    %cl,%dil
mov    0x308(%rsp),%rbx
mov    0x50(%rsp),%r10
jne    403b <bigden_+0x2eeb>
mov    %r10,%r9
and    $0xfffffffffffffffe,%r9
mov    %r10,%r13
or     $0x1,%r13
movapd %xmm15,%xmm8
unpcklpd %xmm15,%xmm8
movapd %xmm11,%xmm3
unpcklpd %xmm11,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
movapd %xmm9,%xmm5
unpcklpd %xmm9,%xmm5
movapd %xmm10,%xmm6
unpcklpd %xmm10,%xmm6
mov    0x28(%rsp),%rax
lea    0x0(,%rax,8),%rdx
mov    0xa8(%rsp),%rax
sub    %rax,%rdx
lea    0x0(,%r11,8),%rsi
sub    %rax,%rsi
xorpd  %xmm7,%xmm7
mov    %r9,%rdi
mov    %r8,%rbp
mov    0x140(%rsp),%rax
mov    0xb8(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movupd %xmm7,(%rbx)
movupd 0x0(%rbp),%xmm2
mulpd  %xmm8,%xmm2
addpd  %xmm7,%xmm2
movupd %xmm2,(%rbx)
movupd 0x0(%rbp,%rdx,1),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,(%rbx)
movupd 0x0(%rbp,%rcx,1),%xmm2
mulpd  %xmm4,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%rbx)
movupd 0x0(%rbp,%rsi,1),%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,(%rbx)
movupd 0x0(%rbp,%rax,1),%xmm2
mulpd  %xmm6,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,(%rbx)
add    $0x10,%rbx
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    3fb0 <bigden_+0x2e60>
cmp    %r9,%r10
mov    0x308(%rsp),%rbx
jne    403b <bigden_+0x2eeb>
jmp    40f5 <bigden_+0x2fa5>
mov    0x308(%rsp),%rbx
mov    0x50(%rsp),%r10
sub    %r13,%r10
add    $0x1,%r10
add    %r13,%r11
lea    (%r8,%r11,8),%rcx
add    $0xfffffffffffffff8,%rcx
mov    0x78(%rsp),%rdi
lea    (%rdi,%r11,8),%rdx
mov    0x28(%rsp),%rax
add    %r13,%rax
lea    (%r8,%rax,8),%rsi
add    $0xfffffffffffffff8,%rsi
lea    (%rdi,%rax,8),%rdi
lea    (%rbx,%r13,8),%rbp
add    $0xfffffffffffffff8,%rbp
lea    (%r8,%r13,8),%rax
add    $0xfffffffffffffff8,%rax
xor    %ebx,%ebx
xorpd  %xmm1,%xmm1
movq   $0x0,0x0(%rbp,%rbx,8)
movsd  (%rax,%rbx,8),%xmm2
mulsd  %xmm15,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x0(%rbp,%rbx,8)
movsd  (%rdi,%rbx,8),%xmm3
mulsd  %xmm11,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%rbp,%rbx,8)
movsd  (%rsi,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rbx,8)
movsd  (%rdx,%rbx,8),%xmm3
mulsd  %xmm9,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%rbp,%rbx,8)
movsd  (%rcx,%rbx,8),%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r10
jne    4080 <bigden_+0x2f30>
movsd  0x2fcb(%rip),%xmm0
mov    0x2f0(%rsp),%rax
mov    (%rax),%rax
mov    0x310(%rsp),%rcx
addsd  -0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rax,8)
xor    %eax,%eax
add    $0x2a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%ecx
test   $0x1,%dl
jne    18b0 <bigden_+0x760>
jmp    18f3 <bigden_+0x7a3>
mov    0x308(%rsp),%rbx
mov    0x328(%rsp),%r8
mov    0x40(%rsp),%r11
jmp    4036 <bigden_+0x2ee6>
mov    0x308(%rsp),%rbx
mov    0x328(%rsp),%r8
jmp    4036 <bigden_+0x2ee6>

LLVM IR (-O0):
@bigden_.i__ = internal global i64 0
@bigden_.j = internal global i64 0
@bigden_.k = internal global i64 0
@bigden_.dd = internal global double 0.000000e+00
@bigden_.jc = internal global i64 0
@bigden_.ds = internal global double 0.000000e+00
@bigden_.ip = internal global i64 0
@bigden_.iu = internal global i64 0
@bigden_.nw = internal global i64 0
@bigden_.ss = internal global double 0.000000e+00
@bigden_.den = internal global [9 x double] zeroinitializer
@bigden_.one = internal global double 0.000000e+00
@bigden_.par = internal global [9 x double] zeroinitializer
@bigden_.tau = internal global double 0.000000e+00
@bigden_.sum = internal global double 0.000000e+00
@bigden_.two = internal global double 0.000000e+00
@bigden_.diff = internal global double 0.000000e+00
@bigden_.half = internal global double 0.000000e+00
@bigden_.temp = internal global double 0.000000e+00
@bigden_.ksav = internal global i64 0
@bigden_.step = internal global double 0.000000e+00
@bigden_.nptm = internal global i64 0
@bigden_.zero = internal global double 0.000000e+00
@bigden_.alpha = internal global double 0.000000e+00
@bigden_.angle = internal global double 0.000000e+00
@bigden_.denex = internal global [9 x double] zeroinitializer
@bigden_.iterc = internal global i64 0
@bigden_.tempa = internal global double 0.000000e+00
@bigden_.tempb = internal global double 0.000000e+00
@bigden_.tempc = internal global double 0.000000e+00
@bigden_.isave = internal global i64 0
@bigden_.ssden = internal global double 0.000000e+00
@bigden_.dtest = internal global double 0.000000e+00
@bigden_.quart = internal global double 0.000000e+00
@bigden_.xoptd = internal global double 0.000000e+00
@bigden_.twopi = internal global double 0.000000e+00
@bigden_.xopts = internal global double 0.000000e+00
@bigden_.denold = internal global double 0.000000e+00
@bigden_.denmax = internal global double 0.000000e+00
@bigden_.densav = internal global double 0.000000e+00
@bigden_.dstemp = internal global double 0.000000e+00
@bigden_.sumold = internal global double 0.000000e+00
@bigden_.sstemp = internal global double 0.000000e+00
@bigden_.xoptsq = internal global double 0.000000e+00
define i32 @bigden_(i64* %0, i64* %1, double* %2, double* %3, double* %4, double* %5, i64* %6, i64* %7, i64* %8, i64* %9, double* %10, double* %11, double* %12, double* %13, double* %14, double* %15, double* %16) {
%18 = alloca i64*
%19 = alloca i64*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca i64*
%25 = alloca i64*
%26 = alloca i64*
%27 = alloca i64*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca double*
%35 = alloca i64
%36 = alloca i64
%37 = alloca i64
%38 = alloca i64
%39 = alloca i64
%40 = alloca i64
%41 = alloca i64
%42 = alloca i64
%43 = alloca i64
%44 = alloca i64
%45 = alloca i64
%46 = alloca i64
%47 = alloca double
store i64* %0, i64** %18
store i64* %1, i64** %19
store double* %2, double** %20
store double* %3, double** %21
store double* %4, double** %22
store double* %5, double** %23
store i64* %6, i64** %24
store i64* %7, i64** %25
store i64* %8, i64** %26
store i64* %9, i64** %27
store double* %10, double** %28
store double* %11, double** %29
store double* %12, double** %30
store double* %13, double** %31
store double* %14, double** %32
store double* %15, double** %33
store double* %16, double** %34
%48 = load i64*, i64** %19
%49 = load i64, i64* %48
store i64 %49, i64* %39
%50 = load i64, i64* %39
%51 = add nsw i64 1, %50
store i64 %51, i64* %40
%52 = load i64, i64* %40
%53 = load double*, double** %23
%54 = sub i64 0, %52
%55 = getelementptr inbounds double, double* %53, i64 %54
store double* %55, double** %23
%56 = load i64*, i64** %19
%57 = load i64, i64* %56
store i64 %57, i64* %35
%58 = load i64, i64* %35
%59 = add nsw i64 1, %58
store i64 %59, i64* %36
%60 = load i64, i64* %36
%61 = load double*, double** %21
%62 = sub i64 0, %60
%63 = getelementptr inbounds double, double* %61, i64 %62
store double* %63, double** %21
%64 = load double*, double** %20
%65 = getelementptr inbounds double, double* %64, i32 -1
store double* %65, double** %20
%66 = load i64*, i64** %25
%67 = load i64, i64* %66
store i64 %67, i64* %43
%68 = load i64, i64* %43
%69 = add nsw i64 1, %68
store i64 %69, i64* %44
%70 = load i64, i64* %44
%71 = load double*, double** %34
%72 = sub i64 0, %70
%73 = getelementptr inbounds double, double* %71, i64 %72
store double* %73, double** %34
%74 = load i64*, i64** %25
%75 = load i64, i64* %74
store i64 %75, i64* %41
%76 = load i64, i64* %41
%77 = add nsw i64 1, %76
store i64 %77, i64* %42
%78 = load i64, i64* %42
%79 = load double*, double** %33
%80 = sub i64 0, %78
%81 = getelementptr inbounds double, double* %79, i64 %80
store double* %81, double** %33
%82 = load i64*, i64** %25
%83 = load i64, i64* %82
store i64 %83, i64* %37
%84 = load i64, i64* %37
%85 = add nsw i64 1, %84
store i64 %85, i64* %38
%86 = load i64, i64* %38
%87 = load double*, double** %22
%88 = sub i64 0, %86
%89 = getelementptr inbounds double, double* %87, i64 %88
store double* %89, double** %22
%90 = load double*, double** %28
%91 = getelementptr inbounds double, double* %90, i32 -1
store double* %91, double** %28
%92 = load double*, double** %29
%93 = getelementptr inbounds double, double* %92, i32 -1
store double* %93, double** %29
%94 = load double*, double** %30
%95 = getelementptr inbounds double, double* %94, i32 -1
store double* %95, double** %30
%96 = load double*, double** %32
%97 = getelementptr inbounds double, double* %96, i32 -1
store double* %97, double** %32
store double 5.000000e-01, double* @bigden_.half
store double 1.000000e+00, double* @bigden_.one
store double 2.500000e-01, double* @bigden_.quart
store double 2.000000e+00, double* @bigden_.two
store double 0.000000e+00, double* @bigden_.zero
%98 = load double, double* @bigden_.one
%99 = call double @atan(double %98)
%100 = fmul double %99, 8.000000e+00
store double %100, double* @bigden_.twopi
%101 = load i64*, i64** %19
%102 = load i64, i64* %101
%103 = load i64*, i64** %18
%104 = load i64, i64* %103
%105 = sub nsw i64 %102, %104
%106 = sub nsw i64 %105, 1
store i64 %106, i64* @bigden_.nptm
%107 = load i64*, i64** %19
%108 = load i64, i64* %107
store i64 %108, i64* %45
store i64 1, i64* @bigden_.k
br label %109
109: ; preds = %121, %17
%110 = load i64, i64* @bigden_.k
%111 = load i64, i64* %45
%112 = icmp sle i64 %110, %111
br i1 %112, label %113, label %124
113: ; preds = %109
%114 = load double, double* @bigden_.zero
%115 = load double*, double** %29
%116 = load i64*, i64** %18
%117 = load i64, i64* %116
%118 = load i64, i64* @bigden_.k
%119 = add nsw i64 %117, %118
%120 = getelementptr inbounds double, double* %115, i64 %119
store double %114, double* %120
br label %121
121: ; preds = %113
%122 = load i64, i64* @bigden_.k
%123 = add nsw i64 %122, 1
store i64 %123, i64* @bigden_.k
br label %109
124: ; preds = %109
%125 = load i64, i64* @bigden_.nptm
store i64 %125, i64* %45
store i64 1, i64* @bigden_.j
br label %126
126: ; preds = %176, %124
%127 = load i64, i64* @bigden_.j
%128 = load i64, i64* %45
%129 = icmp sle i64 %127, %128
br i1 %129, label %130, label %179
130: ; preds = %126
%131 = load double*, double** %23
%132 = load i64*, i64** %27
%133 = load i64, i64* %132
%134 = load i64, i64* @bigden_.j
%135 = load i64, i64* %39
%136 = mul nsw i64 %134, %135
%137 = add nsw i64 %133, %136
%138 = getelementptr inbounds double, double* %131, i64 %137
%139 = load double, double* %138
store double %139, double* @bigden_.temp
%140 = load i64, i64* @bigden_.j
%141 = load i64*, i64** %24
%142 = load i64, i64* %141
%143 = icmp slt i64 %140, %142
br i1 %143, label %144, label %147
144: ; preds = %130
%145 = load double, double* @bigden_.temp
%146 = fneg double %145
store double %146, double* @bigden_.temp
br label %147
147: ; preds = %144, %130
%148 = load i64*, i64** %19
%149 = load i64, i64* %148
store i64 %149, i64* %46
store i64 1, i64* @bigden_.k
br label %150
150: ; preds = %172, %147
%151 = load i64, i64* @bigden_.k
%152 = load i64, i64* %46
%153 = icmp sle i64 %151, %152
br i1 %153, label %154, label %175
154: ; preds = %150
%155 = load double, double* @bigden_.temp
%156 = load double*, double** %23
%157 = load i64, i64* @bigden_.k
%158 = load i64, i64* @bigden_.j
%159 = load i64, i64* %39
%160 = mul nsw i64 %158, %159
%161 = add nsw i64 %157, %160
%162 = getelementptr inbounds double, double* %156, i64 %161
%163 = load double, double* %162
%164 = load double*, double** %29
%165 = load i64*, i64** %18
%166 = load i64, i64* %165
%167 = load i64, i64* @bigden_.k
%168 = add nsw i64 %166, %167
%169 = getelementptr inbounds double, double* %164, i64 %168
%170 = load double, double* %169
%171 = call double @llvm.fmuladd.f64(double %155, double %163, double %170)
store double %171, double* %169
br label %172
172: ; preds = %154
%173 = load i64, i64* @bigden_.k
%174 = add nsw i64 %173, 1
store i64 %174, i64* @bigden_.k
br label %150
175: ; preds = %150
br label %176
176: ; preds = %175
%177 = load i64, i64* @bigden_.j
%178 = add nsw i64 %177, 1
store i64 %178, i64* @bigden_.j
br label %126
179: ; preds = %126
%180 = load double*, double** %29
%181 = load i64*, i64** %18
%182 = load i64, i64* %181
%183 = load i64*, i64** %27
%184 = load i64, i64* %183
%185 = add nsw i64 %182, %184
%186 = getelementptr inbounds double, double* %180, i64 %185
%187 = load double, double* %186
store double %187, double* @bigden_.alpha
%188 = load double, double* @bigden_.zero
store double %188, double* @bigden_.dd
%189 = load double, double* @bigden_.zero
store double %189, double* @bigden_.ds
%190 = load double, double* @bigden_.zero
store double %190, double* @bigden_.ss
%191 = load double, double* @bigden_.zero
store double %191, double* @bigden_.xoptsq
%192 = load i64*, i64** %18
%193 = load i64, i64* %192
store i64 %193, i64* %46
store i64 1, i64* @bigden_.i__
br label %194
194: ; preds = %250, %179
%195 = load i64, i64* @bigden_.i__
%196 = load i64, i64* %46
%197 = icmp sle i64 %195, %196
br i1 %197, label %198, label %253
198: ; preds = %194
%199 = load double*, double** %28
%200 = load i64, i64* @bigden_.i__
%201 = getelementptr inbounds double, double* %199, i64 %200
%202 = load double, double* %201
store double %202, double* %47
%203 = load double, double* %47
%204 = load double, double* %47
%205 = load double, double* @bigden_.dd
%206 = call double @llvm.fmuladd.f64(double %203, double %204, double %205)
store double %206, double* @bigden_.dd
%207 = load double*, double** %21
%208 = load i64*, i64** %27
%209 = load i64, i64* %208
%210 = load i64, i64* @bigden_.i__
%211 = load i64, i64* %35
%212 = mul nsw i64 %210, %211
%213 = add nsw i64 %209, %212
%214 = getelementptr inbounds double, double* %207, i64 %213
%215 = load double, double* %214
%216 = load double*, double** %20
%217 = load i64, i64* @bigden_.i__
%218 = getelementptr inbounds double, double* %216, i64 %217
%219 = load double, double* %218
%220 = fsub double %215, %219
%221 = load double*, double** %32
%222 = load i64, i64* @bigden_.i__
%223 = getelementptr inbounds double, double* %221, i64 %222
store double %220, double* %223
%224 = load double*, double** %28
%225 = load i64, i64* @bigden_.i__
%226 = getelementptr inbounds double, double* %224, i64 %225
%227 = load double, double* %226
%228 = load double*, double** %32
%229 = load i64, i64* @bigden_.i__
%230 = getelementptr inbounds double, double* %228, i64 %229
%231 = load double, double* %230
%232 = load double, double* @bigden_.ds
%233 = call double @llvm.fmuladd.f64(double %227, double %231, double %232)
store double %233, double* @bigden_.ds
%234 = load double*, double** %32
%235 = load i64, i64* @bigden_.i__
%236 = getelementptr inbounds double, double* %234, i64 %235
%237 = load double, double* %236
store double %237, double* %47
%238 = load double, double* %47
%239 = load double, double* %47
%240 = load double, double* @bigden_.ss
%241 = call double @llvm.fmuladd.f64(double %238, double %239, double %240)
store double %241, double* @bigden_.ss
%242 = load double*, double** %20
%243 = load i64, i64* @bigden_.i__
%244 = getelementptr inbounds double, double* %242, i64 %243
%245 = load double, double* %244
store double %245, double* %47
%246 = load double, double* %47
%247 = load double, double* %47
%248 = load double, double* @bigden_.xoptsq
%249 = call double @llvm.fmuladd.f64(double %246, double %247, double %248)
store double %249, double* @bigden_.xoptsq
br label %250
250: ; preds = %198
%251 = load i64, i64* @bigden_.i__
%252 = add nsw i64 %251, 1
store i64 %252, i64* @bigden_.i__
br label %194
253: ; preds = %194
%254 = load double, double* @bigden_.ds
%255 = load double, double* @bigden_.ds
%256 = fmul double %254, %255
%257 = load double, double* @bigden_.dd
%258 = fmul double %257, 0x3FEFAE147AE147AE
%259 = load double, double* @bigden_.ss
%260 = fmul double %258, %259
%261 = fcmp ogt double %256, %260
br i1 %261, label %262, label %368
262: ; preds = %253
%263 = load i64*, i64** %27
%264 = load i64, i64* %263
store i64 %264, i64* @bigden_.ksav
%265 = load double, double* @bigden_.ds
%266 = load double, double* @bigden_.ds
%267 = fmul double %265, %266
%268 = load double, double* @bigden_.ss
%269 = fdiv double %267, %268
store double %269, double* @bigden_.dtest
%270 = load i64*, i64** %19
%271 = load i64, i64* %270
store i64 %271, i64* %46
store i64 1, i64* @bigden_.k
br label %272
272: ; preds = %337, %262
%273 = load i64, i64* @bigden_.k
%274 = load i64, i64* %46
%275 = icmp sle i64 %273, %274
br i1 %275, label %276, label %340
276: ; preds = %272
%277 = load i64, i64* @bigden_.k
%278 = load i64*, i64** %26
%279 = load i64, i64* %278
%280 = icmp ne i64 %277, %279
br i1 %280, label %281, label %336
281: ; preds = %276
%282 = load double, double* @bigden_.zero
store double %282, double* @bigden_.dstemp
%283 = load double, double* @bigden_.zero
store double %283, double* @bigden_.sstemp
%284 = load i64*, i64** %18
%285 = load i64, i64* %284
store i64 %285, i64* %45
store i64 1, i64* @bigden_.i__
br label %286
286: ; preds = %315, %281
%287 = load i64, i64* @bigden_.i__
%288 = load i64, i64* %45
%289 = icmp sle i64 %287, %288
br i1 %289, label %290, label %318
290: ; preds = %286
%291 = load double*, double** %21
%292 = load i64, i64* @bigden_.k
%293 = load i64, i64* @bigden_.i__
%294 = load i64, i64* %35
%295 = mul nsw i64 %293, %294
%296 = add nsw i64 %292, %295
%297 = getelementptr inbounds double, double* %291, i64 %296
%298 = load double, double* %297
%299 = load double*, double** %20
%300 = load i64, i64* @bigden_.i__
%301 = getelementptr inbounds double, double* %299, i64 %300
%302 = load double, double* %301
%303 = fsub double %298, %302
store double %303, double* @bigden_.diff
%304 = load double*, double** %28
%305 = load i64, i64* @bigden_.i__
%306 = getelementptr inbounds double, double* %304, i64 %305
%307 = load double, double* %306
%308 = load double, double* @bigden_.diff
%309 = load double, double* @bigden_.dstemp
%310 = call double @llvm.fmuladd.f64(double %307, double %308, double %309)
store double %310, double* @bigden_.dstemp
%311 = load double, double* @bigden_.diff
%312 = load double, double* @bigden_.diff
%313 = load double, double* @bigden_.sstemp
%314 = call double @llvm.fmuladd.f64(double %311, double %312, double %313)
store double %314, double* @bigden_.sstemp
br label %315
315: ; preds = %290
%316 = load i64, i64* @bigden_.i__
%317 = add nsw i64 %316, 1
store i64 %317, i64* @bigden_.i__
br label %286
318: ; preds = %286
%319 = load double, double* @bigden_.dstemp
%320 = load double, double* @bigden_.dstemp
%321 = fmul double %319, %320
%322 = load double, double* @bigden_.sstemp
%323 = fdiv double %321, %322
%324 = load double, double* @bigden_.dtest
%325 = fcmp olt double %323, %324
br i1 %325, label %326, label %335
326: ; preds = %318
%327 = load i64, i64* @bigden_.k
store i64 %327, i64* @bigden_.ksav
%328 = load double, double* @bigden_.dstemp
%329 = load double, double* @bigden_.dstemp
%330 = fmul double %328, %329
%331 = load double, double* @bigden_.sstemp
%332 = fdiv double %330, %331
store double %332, double* @bigden_.dtest
%333 = load double, double* @bigden_.dstemp
store double %333, double* @bigden_.ds
%334 = load double, double* @bigden_.sstemp
store double %334, double* @bigden_.ss
br label %335
335: ; preds = %326, %318
br label %336
336: ; preds = %335, %276
br label %337
337: ; preds = %336
%338 = load i64, i64* @bigden_.k
%339 = add nsw i64 %338, 1
store i64 %339, i64* @bigden_.k
br label %272
340: ; preds = %272
%341 = load i64*, i64** %18
%342 = load i64, i64* %341
store i64 %342, i64* %46
store i64 1, i64* @bigden_.i__
br label %343
343: ; preds = %364, %340
%344 = load i64, i64* @bigden_.i__
%345 = load i64, i64* %46
%346 = icmp sle i64 %344, %345
br i1 %346, label %347, label %367
347: ; preds = %343
%348 = load double*, double** %21
%349 = load i64, i64* @bigden_.ksav
%350 = load i64, i64* @bigden_.i__
%351 = load i64, i64* %35
%352 = mul nsw i64 %350, %351
%353 = add nsw i64 %349, %352
%354 = getelementptr inbounds double, double* %348, i64 %353
%355 = load double, double* %354
%356 = load double*, double** %20
%357 = load i64, i64* @bigden_.i__
%358 = getelementptr inbounds double, double* %356, i64 %357
%359 = load double, double* %358
%360 = fsub double %355, %359
%361 = load double*, double** %32
%362 = load i64, i64* @bigden_.i__
%363 = getelementptr inbounds double, double* %361, i64 %362
store double %360, double* %363
br label %364
364: ; preds = %347
%365 = load i64, i64* @bigden_.i__
%366 = add nsw i64 %365, 1
store i64 %366, i64* @bigden_.i__
br label %343
367: ; preds = %343
br label %368
368: ; preds = %367, %253
%369 = load double, double* @bigden_.dd
%370 = load double, double* @bigden_.ss
%371 = load double, double* @bigden_.ds
%372 = load double, double* @bigden_.ds
%373 = fmul double %371, %372
%374 = fneg double %373
%375 = call double @llvm.fmuladd.f64(double %369, double %370, double %374)
store double %375, double* @bigden_.ssden
store i64 0, i64* @bigden_.iterc
%376 = load double, double* @bigden_.zero
store double %376, double* @bigden_.densav
br label %377
377: ; preds = %2092, %368
%378 = load i64, i64* @bigden_.iterc
%379 = add nsw i64 %378, 1
store i64 %379, i64* @bigden_.iterc
%380 = load double, double* @bigden_.one
%381 = load double, double* @bigden_.ssden
%382 = call double @sqrt(double %381)
%383 = fdiv double %380, %382
store double %383, double* @bigden_.temp
%384 = load double, double* @bigden_.zero
store double %384, double* @bigden_.xoptd
%385 = load double, double* @bigden_.zero
store double %385, double* @bigden_.xopts
%386 = load i64*, i64** %18
%387 = load i64, i64* %386
store i64 %387, i64* %46
store i64 1, i64* @bigden_.i__
br label %388
388: ; preds = %431, %377
%389 = load i64, i64* @bigden_.i__
%390 = load i64, i64* %46
%391 = icmp sle i64 %389, %390
br i1 %391, label %392, label %434
392: ; preds = %388
%393 = load double, double* @bigden_.temp
%394 = load double, double* @bigden_.dd
%395 = load double*, double** %32
%396 = load i64, i64* @bigden_.i__
%397 = getelementptr inbounds double, double* %395, i64 %396
%398 = load double, double* %397
%399 = load double, double* @bigden_.ds
%400 = load double*, double** %28
%401 = load i64, i64* @bigden_.i__
%402 = getelementptr inbounds double, double* %400, i64 %401
%403 = load double, double* %402
%404 = fmul double %399, %403
%405 = fneg double %404
%406 = call double @llvm.fmuladd.f64(double %394, double %398, double %405)
%407 = fmul double %393, %406
%408 = load double*, double** %32
%409 = load i64, i64* @bigden_.i__
%410 = getelementptr inbounds double, double* %408, i64 %409
store double %407, double* %410
%411 = load double*, double** %20
%412 = load i64, i64* @bigden_.i__
%413 = getelementptr inbounds double, double* %411, i64 %412
%414 = load double, double* %413
%415 = load double*, double** %28
%416 = load i64, i64* @bigden_.i__
%417 = getelementptr inbounds double, double* %415, i64 %416
%418 = load double, double* %417
%419 = load double, double* @bigden_.xoptd
%420 = call double @llvm.fmuladd.f64(double %414, double %418, double %419)
store double %420, double* @bigden_.xoptd
%421 = load double*, double** %20
%422 = load i64, i64* @bigden_.i__
%423 = getelementptr inbounds double, double* %421, i64 %422
%424 = load double, double* %423
%425 = load double*, double** %32
%426 = load i64, i64* @bigden_.i__
%427 = getelementptr inbounds double, double* %425, i64 %426
%428 = load double, double* %427
%429 = load double, double* @bigden_.xopts
%430 = call double @llvm.fmuladd.f64(double %424, double %428, double %429)
store double %430, double* @bigden_.xopts
br label %431
431: ; preds = %392
%432 = load i64, i64* @bigden_.i__
%433 = add nsw i64 %432, 1
store i64 %433, i64* @bigden_.i__
br label %388
434: ; preds = %388
%435 = load double, double* @bigden_.half
%436 = load double, double* @bigden_.xoptd
%437 = fmul double %435, %436
%438 = load double, double* @bigden_.xoptd
%439 = fmul double %437, %438
store double %439, double* @bigden_.tempa
%440 = load double, double* @bigden_.half
%441 = load double, double* @bigden_.xopts
%442 = fmul double %440, %441
%443 = load double, double* @bigden_.xopts
%444 = fmul double %442, %443
store double %444, double* @bigden_.tempb
%445 = load double, double* @bigden_.dd
%446 = load double, double* @bigden_.xoptsq
%447 = load double, double* @bigden_.half
%448 = load double, double* @bigden_.dd
%449 = call double @llvm.fmuladd.f64(double %447, double %448, double %446)
%450 = load double, double* @bigden_.tempa
%451 = call double @llvm.fmuladd.f64(double %445, double %449, double %450)
%452 = load double, double* @bigden_.tempb
%453 = fadd double %451, %452
store double %453, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 0)
%454 = load double, double* @bigden_.two
%455 = load double, double* @bigden_.xoptd
%456 = fmul double %454, %455
%457 = load double, double* @bigden_.dd
%458 = fmul double %456, %457
store double %458, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 1)
%459 = load double, double* @bigden_.two
%460 = load double, double* @bigden_.xopts
%461 = fmul double %459, %460
%462 = load double, double* @bigden_.dd
%463 = fmul double %461, %462
store double %463, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 2)
%464 = load double, double* @bigden_.tempa
%465 = load double, double* @bigden_.tempb
%466 = fsub double %464, %465
store double %466, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 3)
%467 = load double, double* @bigden_.xoptd
%468 = load double, double* @bigden_.xopts
%469 = fmul double %467, %468
store double %469, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 4)
store i64 6, i64* @bigden_.i__
br label %470
470: ; preds = %478, %434
%471 = load i64, i64* @bigden_.i__
%472 = icmp sle i64 %471, 9
br i1 %472, label %473, label %481
473: ; preds = %470
%474 = load double, double* @bigden_.zero
%475 = load i64, i64* @bigden_.i__
%476 = sub nsw i64 %475, 1
%477 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.den, i64 0, i64 %476
store double %474, double* %477
br label %478
478: ; preds = %473
%479 = load i64, i64* @bigden_.i__
%480 = add nsw i64 %479, 1
store i64 %480, i64* @bigden_.i__
br label %470
481: ; preds = %470
%482 = load i64*, i64** %19
%483 = load i64, i64* %482
store i64 %483, i64* %46
store i64 1, i64* @bigden_.k
br label %484
484: ; preds = %602, %481
%485 = load i64, i64* @bigden_.k
%486 = load i64, i64* %46
%487 = icmp sle i64 %485, %486
br i1 %487, label %488, label %605
488: ; preds = %484
%489 = load double, double* @bigden_.zero
store double %489, double* @bigden_.tempa
%490 = load double, double* @bigden_.zero
store double %490, double* @bigden_.tempb
%491 = load double, double* @bigden_.zero
store double %491, double* @bigden_.tempc
%492 = load i64*, i64** %18
%493 = load i64, i64* %492
store i64 %493, i64* %45
store i64 1, i64* @bigden_.i__
br label %494
494: ; preds = %541, %488
%495 = load i64, i64* @bigden_.i__
%496 = load i64, i64* %45
%497 = icmp sle i64 %495, %496
br i1 %497, label %498, label %544
498: ; preds = %494
%499 = load double*, double** %21
%500 = load i64, i64* @bigden_.k
%501 = load i64, i64* @bigden_.i__
%502 = load i64, i64* %35
%503 = mul nsw i64 %501, %502
%504 = add nsw i64 %500, %503
%505 = getelementptr inbounds double, double* %499, i64 %504
%506 = load double, double* %505
%507 = load double*, double** %28
%508 = load i64, i64* @bigden_.i__
%509 = getelementptr inbounds double, double* %507, i64 %508
%510 = load double, double* %509
%511 = load double, double* @bigden_.tempa
%512 = call double @llvm.fmuladd.f64(double %506, double %510, double %511)
store double %512, double* @bigden_.tempa
%513 = load double*, double** %21
%514 = load i64, i64* @bigden_.k
%515 = load i64, i64* @bigden_.i__
%516 = load i64, i64* %35
%517 = mul nsw i64 %515, %516
%518 = add nsw i64 %514, %517
%519 = getelementptr inbounds double, double* %513, i64 %518
%520 = load double, double* %519
%521 = load double*, double** %32
%522 = load i64, i64* @bigden_.i__
%523 = getelementptr inbounds double, double* %521, i64 %522
%524 = load double, double* %523
%525 = load double, double* @bigden_.tempb
%526 = call double @llvm.fmuladd.f64(double %520, double %524, double %525)
store double %526, double* @bigden_.tempb
%527 = load double*, double** %21
%528 = load i64, i64* @bigden_.k
%529 = load i64, i64* @bigden_.i__
%530 = load i64, i64* %35
%531 = mul nsw i64 %529, %530
%532 = add nsw i64 %528, %531
%533 = getelementptr inbounds double, double* %527, i64 %532
%534 = load double, double* %533
%535 = load double*, double** %20
%536 = load i64, i64* @bigden_.i__
%537 = getelementptr inbounds double, double* %535, i64 %536
%538 = load double, double* %537
%539 = load double, double* @bigden_.tempc
%540 = call double @llvm.fmuladd.f64(double %534, double %538, double %539)
store double %540, double* @bigden_.tempc
br label %541
541: ; preds = %498
%542 = load i64, i64* @bigden_.i__
%543 = add nsw i64 %542, 1
store i64 %543, i64* @bigden_.i__
br label %494
544: ; preds = %494
%545 = load double, double* @bigden_.quart
%546 = load double, double* @bigden_.tempa
%547 = load double, double* @bigden_.tempa
%548 = load double, double* @bigden_.tempb
%549 = load double, double* @bigden_.tempb
%550 = fmul double %548, %549
%551 = call double @llvm.fmuladd.f64(double %546, double %547, double %550)
%552 = fmul double %545, %551
%553 = load double*, double** %33
%554 = load i64, i64* @bigden_.k
%555 = load i64, i64* %41
%556 = add nsw i64 %554, %555
%557 = getelementptr inbounds double, double* %553, i64 %556
store double %552, double* %557
%558 = load double, double* @bigden_.tempa
%559 = load double, double* @bigden_.tempc
%560 = fmul double %558, %559
%561 = load double*, double** %33
%562 = load i64, i64* @bigden_.k
%563 = load i64, i64* %41
%564 = shl i64 %563, 1
%565 = add nsw i64 %562, %564
%566 = getelementptr inbounds double, double* %561, i64 %565
store double %560, double* %566
%567 = load double, double* @bigden_.tempb
%568 = load double, double* @bigden_.tempc
%569 = fmul double %567, %568
%570 = load double*, double** %33
%571 = load i64, i64* @bigden_.k
%572 = load i64, i64* %41
%573 = mul nsw i64 %572, 3
%574 = add nsw i64 %571, %573
%575 = getelementptr inbounds double, double* %570, i64 %574
store double %569, double* %575
%576 = load double, double* @bigden_.quart
%577 = load double, double* @bigden_.tempa
%578 = load double, double* @bigden_.tempa
%579 = load double, double* @bigden_.tempb
%580 = load double, double* @bigden_.tempb
%581 = fmul double %579, %580
%582 = fneg double %581
%583 = call double @llvm.fmuladd.f64(double %577, double %578, double %582)
%584 = fmul double %576, %583
%585 = load double*, double** %33
%586 = load i64, i64* @bigden_.k
%587 = load i64, i64* %41
%588 = shl i64 %587, 2
%589 = add nsw i64 %586, %588
%590 = getelementptr inbounds double, double* %585, i64 %589
store double %584, double* %590
%591 = load double, double* @bigden_.half
%592 = load double, double* @bigden_.tempa
%593 = fmul double %591, %592
%594 = load double, double* @bigden_.tempb
%595 = fmul double %593, %594
%596 = load double*, double** %33
%597 = load i64, i64* @bigden_.k
%598 = load i64, i64* %41
%599 = mul nsw i64 %598, 5
%600 = add nsw i64 %597, %599
%601 = getelementptr inbounds double, double* %596, i64 %600
store double %595, double* %601
br label %602
602: ; preds = %544
%603 = load i64, i64* @bigden_.k
%604 = add nsw i64 %603, 1
store i64 %604, i64* @bigden_.k
br label %484
605: ; preds = %484
%606 = load i64*, i64** %18
%607 = load i64, i64* %606
store i64 %607, i64* %46
store i64 1, i64* @bigden_.i__
br label %608
608: ; preds = %657, %605
%609 = load i64, i64* @bigden_.i__
%610 = load i64, i64* %46
%611 = icmp sle i64 %609, %610
br i1 %611, label %612, label %660
612: ; preds = %608
%613 = load i64, i64* @bigden_.i__
%614 = load i64*, i64** %19
%615 = load i64, i64* %614
%616 = add nsw i64 %613, %615
store i64 %616, i64* @bigden_.ip
%617 = load double, double* @bigden_.zero
%618 = load double*, double** %33
%619 = load i64, i64* @bigden_.ip
%620 = load i64, i64* %41
%621 = add nsw i64 %619, %620
%622 = getelementptr inbounds double, double* %618, i64 %621
store double %617, double* %622
%623 = load double*, double** %28
%624 = load i64, i64* @bigden_.i__
%625 = getelementptr inbounds double, double* %623, i64 %624
%626 = load double, double* %625
%627 = load double*, double** %33
%628 = load i64, i64* @bigden_.ip
%629 = load i64, i64* %41
%630 = shl i64 %629, 1
%631 = add nsw i64 %628, %630
%632 = getelementptr inbounds double, double* %627, i64 %631
store double %626, double* %632
%633 = load double*, double** %32
%634 = load i64, i64* @bigden_.i__
%635 = getelementptr inbounds double, double* %633, i64 %634
%636 = load double, double* %635
%637 = load double*, double** %33
%638 = load i64, i64* @bigden_.ip
%639 = load i64, i64* %41
%640 = mul nsw i64 %639, 3
%641 = add nsw i64 %638, %640
%642 = getelementptr inbounds double, double* %637, i64 %641
store double %636, double* %642
%643 = load double, double* @bigden_.zero
%644 = load double*, double** %33
%645 = load i64, i64* @bigden_.ip
%646 = load i64, i64* %41
%647 = shl i64 %646, 2
%648 = add nsw i64 %645, %647
%649 = getelementptr inbounds double, double* %644, i64 %648
store double %643, double* %649
%650 = load double, double* @bigden_.zero
%651 = load double*, double** %33
%652 = load i64, i64* @bigden_.ip
%653 = load i64, i64* %41
%654 = mul nsw i64 %653, 5
%655 = add nsw i64 %652, %654
%656 = getelementptr inbounds double, double* %651, i64 %655
store double %650, double* %656
br label %657
657: ; preds = %612
%658 = load i64, i64* @bigden_.i__
%659 = add nsw i64 %658, 1
store i64 %659, i64* @bigden_.i__
br label %608
660: ; preds = %608
store i64 1, i64* @bigden_.jc
br label %661
661: ; preds = %883, %660
%662 = load i64, i64* @bigden_.jc
%663 = icmp sle i64 %662, 5
br i1 %663, label %664, label %886
664: ; preds = %661
%665 = load i64*, i64** %19
%666 = load i64, i64* %665
store i64 %666, i64* @bigden_.nw
%667 = load i64, i64* @bigden_.jc
%668 = icmp eq i64 %667, 2
br i1 %668, label %672, label %669
669: ; preds = %664
%670 = load i64, i64* @bigden_.jc
%671 = icmp eq i64 %670, 3
br i1 %671, label %672, label %675
672: ; preds = %669, %664
%673 = load i64*, i64** %25
%674 = load i64, i64* %673
store i64 %674, i64* @bigden_.nw
br label %675
675: ; preds = %672, %669
%676 = load i64*, i64** %19
%677 = load i64, i64* %676
store i64 %677, i64* %46
store i64 1, i64* @bigden_.k
br label %678
678: ; preds = %691, %675
%679 = load i64, i64* @bigden_.k
%680 = load i64, i64* %46
%681 = icmp sle i64 %679, %680
br i1 %681, label %682, label %694
682: ; preds = %678
%683 = load double, double* @bigden_.zero
%684 = load double*, double** %34
%685 = load i64, i64* @bigden_.k
%686 = load i64, i64* @bigden_.jc
%687 = load i64, i64* %43
%688 = mul nsw i64 %686, %687
%689 = add nsw i64 %685, %688
%690 = getelementptr inbounds double, double* %684, i64 %689
store double %683, double* %690
br label %691
691: ; preds = %682
%692 = load i64, i64* @bigden_.k
%693 = add nsw i64 %692, 1
store i64 %693, i64* @bigden_.k
br label %678
694: ; preds = %678
%695 = load i64, i64* @bigden_.nptm
store i64 %695, i64* %46
store i64 1, i64* @bigden_.j
br label %696
696: ; preds = %768, %694
%697 = load i64, i64* @bigden_.j
%698 = load i64, i64* %46
%699 = icmp sle i64 %697, %698
br i1 %699, label %700, label %771
700: ; preds = %696
%701 = load double, double* @bigden_.zero
store double %701, double* @bigden_.sum
%702 = load i64*, i64** %19
%703 = load i64, i64* %702
store i64 %703, i64* %45
store i64 1, i64* @bigden_.k
br label %704
704: ; preds = %727, %700
%705 = load i64, i64* @bigden_.k
%706 = load i64, i64* %45
%707 = icmp sle i64 %705, %706
br i1 %707, label %708, label %730
708: ; preds = %704
%709 = load double*, double** %23
%710 = load i64, i64* @bigden_.k
%711 = load i64, i64* @bigden_.j
%712 = load i64, i64* %39
%713 = mul nsw i64 %711, %712
%714 = add nsw i64 %710, %713
%715 = getelementptr inbounds double, double* %709, i64 %714
%716 = load double, double* %715
%717 = load double*, double** %33
%718 = load i64, i64* @bigden_.k
%719 = load i64, i64* @bigden_.jc
%720 = load i64, i64* %41
%721 = mul nsw i64 %719, %720
%722 = add nsw i64 %718, %721
%723 = getelementptr inbounds double, double* %717, i64 %722
%724 = load double, double* %723
%725 = load double, double* @bigden_.sum
%726 = call double @llvm.fmuladd.f64(double %716, double %724, double %725)
store double %726, double* @bigden_.sum
br label %727
727: ; preds = %708
%728 = load i64, i64* @bigden_.k
%729 = add nsw i64 %728, 1
store i64 %729, i64* @bigden_.k
br label %704
730: ; preds = %704
%731 = load i64, i64* @bigden_.j
%732 = load i64*, i64** %24
%733 = load i64, i64* %732
%734 = icmp slt i64 %731, %733
br i1 %734, label %735, label %738
735: ; preds = %730
%736 = load double, double* @bigden_.sum
%737 = fneg double %736
store double %737, double* @bigden_.sum
br label %738
738: ; preds = %735, %730
%739 = load i64*, i64** %19
%740 = load i64, i64* %739
store i64 %740, i64* %45
store i64 1, i64* @bigden_.k
br label %741
741: ; preds = %764, %738
%742 = load i64, i64* @bigden_.k
%743 = load i64, i64* %45
%744 = icmp sle i64 %742, %743
br i1 %744, label %745, label %767
745: ; preds = %741
%746 = load double, double* @bigden_.sum
%747 = load double*, double** %23
%748 = load i64, i64* @bigden_.k
%749 = load i64, i64* @bigden_.j
%750 = load i64, i64* %39
%751 = mul nsw i64 %749, %750
%752 = add nsw i64 %748, %751
%753 = getelementptr inbounds double, double* %747, i64 %752
%754 = load double, double* %753
%755 = load double*, double** %34
%756 = load i64, i64* @bigden_.k
%757 = load i64, i64* @bigden_.jc
%758 = load i64, i64* %43
%759 = mul nsw i64 %757, %758
%760 = add nsw i64 %756, %759
%761 = getelementptr inbounds double, double* %755, i64 %760
%762 = load double, double* %761
%763 = call double @llvm.fmuladd.f64(double %746, double %754, double %762)
store double %763, double* %761
br label %764
764: ; preds = %745
%765 = load i64, i64* @bigden_.k
%766 = add nsw i64 %765, 1
store i64 %766, i64* @bigden_.k
br label %741
767: ; preds = %741
br label %768
768: ; preds = %767
%769 = load i64, i64* @bigden_.j
%770 = add nsw i64 %769, 1
store i64 %770, i64* @bigden_.j
br label %696
771: ; preds = %696
%772 = load i64, i64* @bigden_.nw
%773 = load i64*, i64** %25
%774 = load i64, i64* %773
%775 = icmp eq i64 %772, %774
br i1 %775, label %776, label %831
776: ; preds = %771
%777 = load i64*, i64** %19
%778 = load i64, i64* %777
store i64 %778, i64* %45
store i64 1, i64* @bigden_.k
br label %779
779: ; preds = %827, %776
%780 = load i64, i64* @bigden_.k
%781 = load i64, i64* %45
%782 = icmp sle i64 %780, %781
br i1 %782, label %783, label %830
783: ; preds = %779
%784 = load double, double* @bigden_.zero
store double %784, double* @bigden_.sum
%785 = load i64*, i64** %18
%786 = load i64, i64* %785
store i64 %786, i64* %46
store i64 1, i64* @bigden_.j
br label %787
787: ; preds = %813, %783
%788 = load i64, i64* @bigden_.j
%789 = load i64, i64* %46
%790 = icmp sle i64 %788, %789
br i1 %790, label %791, label %816
791: ; preds = %787
%792 = load double*, double** %22
%793 = load i64, i64* @bigden_.k
%794 = load i64, i64* @bigden_.j
%795 = load i64, i64* %37
%796 = mul nsw i64 %794, %795
%797 = add nsw i64 %793, %796
%798 = getelementptr inbounds double, double* %792, i64 %797
%799 = load double, double* %798
%800 = load double*, double** %33
%801 = load i64*, i64** %19
%802 = load i64, i64* %801
%803 = load i64, i64* @bigden_.j
%804 = add nsw i64 %802, %803
%805 = load i64, i64* @bigden_.jc
%806 = load i64, i64* %41
%807 = mul nsw i64 %805, %806
%808 = add nsw i64 %804, %807
%809 = getelementptr inbounds double, double* %800, i64 %808
%810 = load double, double* %809
%811 = load double, double* @bigden_.sum
%812 = call double @llvm.fmuladd.f64(double %799, double %810, double %811)
store double %812, double* @bigden_.sum
br label %813
813: ; preds = %791
%814 = load i64, i64* @bigden_.j
%815 = add nsw i64 %814, 1
store i64 %815, i64* @bigden_.j
br label %787
816: ; preds = %787
%817 = load double, double* @bigden_.sum
%818 = load double*, double** %34
%819 = load i64, i64* @bigden_.k
%820 = load i64, i64* @bigden_.jc
%821 = load i64, i64* %43
%822 = mul nsw i64 %820, %821
%823 = add nsw i64 %819, %822
%824 = getelementptr inbounds double, double* %818, i64 %823
%825 = load double, double* %824
%826 = fadd double %825, %817
store double %826, double* %824
br label %827
827: ; preds = %816
%828 = load i64, i64* @bigden_.k
%829 = add nsw i64 %828, 1
store i64 %829, i64* @bigden_.k
br label %779
830: ; preds = %779
br label %831
831: ; preds = %830, %771
%832 = load i64*, i64** %18
%833 = load i64, i64* %832
store i64 %833, i64* %45
store i64 1, i64* @bigden_.j
br label %834
834: ; preds = %879, %831
%835 = load i64, i64* @bigden_.j
%836 = load i64, i64* %45
%837 = icmp sle i64 %835, %836
br i1 %837, label %838, label %882
838: ; preds = %834
%839 = load double, double* @bigden_.zero
store double %839, double* @bigden_.sum
%840 = load i64, i64* @bigden_.nw
store i64 %840, i64* %46
store i64 1, i64* @bigden_.i__
br label %841
841: ; preds = %864, %838
%842 = load i64, i64* @bigden_.i__
%843 = load i64, i64* %46
%844 = icmp sle i64 %842, %843
br i1 %844, label %845, label %867
845: ; preds = %841
%846 = load double*, double** %22
%847 = load i64, i64* @bigden_.i__
%848 = load i64, i64* @bigden_.j
%849 = load i64, i64* %37
%850 = mul nsw i64 %848, %849
%851 = add nsw i64 %847, %850
%852 = getelementptr inbounds double, double* %846, i64 %851
%853 = load double, double* %852
%854 = load double*, double** %33
%855 = load i64, i64* @bigden_.i__
%856 = load i64, i64* @bigden_.jc
%857 = load i64, i64* %41
%858 = mul nsw i64 %856, %857
%859 = add nsw i64 %855, %858
%860 = getelementptr inbounds double, double* %854, i64 %859
%861 = load double, double* %860
%862 = load double, double* @bigden_.sum
%863 = call double @llvm.fmuladd.f64(double %853, double %861, double %862)
store double %863, double* @bigden_.sum
br label %864
864: ; preds = %845
%865 = load i64, i64* @bigden_.i__
%866 = add nsw i64 %865, 1
store i64 %866, i64* @bigden_.i__
br label %841
867: ; preds = %841
%868 = load double, double* @bigden_.sum
%869 = load double*, double** %34
%870 = load i64*, i64** %19
%871 = load i64, i64* %870
%872 = load i64, i64* @bigden_.j
%873 = add nsw i64 %871, %872
%874 = load i64, i64* @bigden_.jc
%875 = load i64, i64* %43
%876 = mul nsw i64 %874, %875
%877 = add nsw i64 %873, %876
%878 = getelementptr inbounds double, double* %869, i64 %877
store double %868, double* %878
br label %879
879: ; preds = %867
%880 = load i64, i64* @bigden_.j
%881 = add nsw i64 %880, 1
store i64 %881, i64* @bigden_.j
br label %834
882: ; preds = %834
br label %883
883: ; preds = %882
%884 = load i64, i64* @bigden_.jc
%885 = add nsw i64 %884, 1
store i64 %885, i64* @bigden_.jc
br label %661
886: ; preds = %661
%887 = load i64*, i64** %25
%888 = load i64, i64* %887
store i64 %888, i64* %45
store i64 1, i64* @bigden_.k
br label %889
889: ; preds = %1284, %886
%890 = load i64, i64* @bigden_.k
%891 = load i64, i64* %45
%892 = icmp sle i64 %890, %891
br i1 %892, label %893, label %1287
893: ; preds = %889
%894 = load double, double* @bigden_.zero
store double %894, double* @bigden_.sum
store i64 1, i64* @bigden_.i__
br label %895
895: ; preds = %927, %893
%896 = load i64, i64* @bigden_.i__
%897 = icmp sle i64 %896, 5
br i1 %897, label %898, label %930
898: ; preds = %895
%899 = load double, double* @bigden_.half
%900 = load double*, double** %34
%901 = load i64, i64* @bigden_.k
%902 = load i64, i64* @bigden_.i__
%903 = load i64, i64* %43
%904 = mul nsw i64 %902, %903
%905 = add nsw i64 %901, %904
%906 = getelementptr inbounds double, double* %900, i64 %905
%907 = load double, double* %906
%908 = fmul double %899, %907
%909 = load double*, double** %33
%910 = load i64, i64* @bigden_.k
%911 = load i64, i64* @bigden_.i__
%912 = load i64, i64* %41
%913 = mul nsw i64 %911, %912
%914 = add nsw i64 %910, %913
%915 = getelementptr inbounds double, double* %909, i64 %914
%916 = load double, double* %915
%917 = fmul double %908, %916
%918 = load i64, i64* @bigden_.i__
%919 = sub nsw i64 %918, 1
%920 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %919
store double %917, double* %920
%921 = load i64, i64* @bigden_.i__
%922 = sub nsw i64 %921, 1
%923 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %922
%924 = load double, double* %923
%925 = load double, double* @bigden_.sum
%926 = fadd double %925, %924
store double %926, double* @bigden_.sum
br label %927
927: ; preds = %898
%928 = load i64, i64* @bigden_.i__
%929 = add nsw i64 %928, 1
store i64 %929, i64* @bigden_.i__
br label %895
930: ; preds = %895
%931 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 0)
%932 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 0)
%933 = fsub double %931, %932
%934 = load double, double* @bigden_.sum
%935 = fsub double %933, %934
store double %935, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 0)
%936 = load double*, double** %34
%937 = load i64, i64* @bigden_.k
%938 = load i64, i64* %43
%939 = add nsw i64 %937, %938
%940 = getelementptr inbounds double, double* %936, i64 %939
%941 = load double, double* %940
%942 = load double*, double** %33
%943 = load i64, i64* @bigden_.k
%944 = load i64, i64* %41
%945 = shl i64 %944, 1
%946 = add nsw i64 %943, %945
%947 = getelementptr inbounds double, double* %942, i64 %946
%948 = load double, double* %947
%949 = load double*, double** %34
%950 = load i64, i64* @bigden_.k
%951 = load i64, i64* %43
%952 = shl i64 %951, 1
%953 = add nsw i64 %950, %952
%954 = getelementptr inbounds double, double* %949, i64 %953
%955 = load double, double* %954
%956 = load double*, double** %33
%957 = load i64, i64* @bigden_.k
%958 = load i64, i64* %41
%959 = add nsw i64 %957, %958
%960 = getelementptr inbounds double, double* %956, i64 %959
%961 = load double, double* %960
%962 = fmul double %955, %961
%963 = call double @llvm.fmuladd.f64(double %941, double %948, double %962)
store double %963, double* @bigden_.tempa
%964 = load double*, double** %34
%965 = load i64, i64* @bigden_.k
%966 = load i64, i64* %43
%967 = shl i64 %966, 1
%968 = add nsw i64 %965, %967
%969 = getelementptr inbounds double, double* %964, i64 %968
%970 = load double, double* %969
%971 = load double*, double** %33
%972 = load i64, i64* @bigden_.k
%973 = load i64, i64* %41
%974 = shl i64 %973, 2
%975 = add nsw i64 %972, %974
%976 = getelementptr inbounds double, double* %971, i64 %975
%977 = load double, double* %976
%978 = load double*, double** %34
%979 = load i64, i64* @bigden_.k
%980 = load i64, i64* %43
%981 = shl i64 %980, 2
%982 = add nsw i64 %979, %981
%983 = getelementptr inbounds double, double* %978, i64 %982
%984 = load double, double* %983
%985 = load double*, double** %33
%986 = load i64, i64* @bigden_.k
%987 = load i64, i64* %41
%988 = shl i64 %987, 1
%989 = add nsw i64 %986, %988
%990 = getelementptr inbounds double, double* %985, i64 %989
%991 = load double, double* %990
%992 = fmul double %984, %991
%993 = call double @llvm.fmuladd.f64(double %970, double %977, double %992)
store double %993, double* @bigden_.tempb
%994 = load double*, double** %34
%995 = load i64, i64* @bigden_.k
%996 = load i64, i64* %43
%997 = mul nsw i64 %996, 3
%998 = add nsw i64 %995, %997
%999 = getelementptr inbounds double, double* %994, i64 %998
%1000 = load double, double* %999
%1001 = load double*, double** %33
%1002 = load i64, i64* @bigden_.k
%1003 = load i64, i64* %41
%1004 = mul nsw i64 %1003, 5
%1005 = add nsw i64 %1002, %1004
%1006 = getelementptr inbounds double, double* %1001, i64 %1005
%1007 = load double, double* %1006
%1008 = load double*, double** %34
%1009 = load i64, i64* @bigden_.k
%1010 = load i64, i64* %43
%1011 = mul nsw i64 %1010, 5
%1012 = add nsw i64 %1009, %1011
%1013 = getelementptr inbounds double, double* %1008, i64 %1012
%1014 = load double, double* %1013
%1015 = load double*, double** %33
%1016 = load i64, i64* @bigden_.k
%1017 = load i64, i64* %41
%1018 = mul nsw i64 %1017, 3
%1019 = add nsw i64 %1016, %1018
%1020 = getelementptr inbounds double, double* %1015, i64 %1019
%1021 = load double, double* %1020
%1022 = fmul double %1014, %1021
%1023 = call double @llvm.fmuladd.f64(double %1000, double %1007, double %1022)
store double %1023, double* @bigden_.tempc
%1024 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 1)
%1025 = load double, double* @bigden_.tempa
%1026 = fsub double %1024, %1025
%1027 = load double, double* @bigden_.half
%1028 = load double, double* @bigden_.tempb
%1029 = load double, double* @bigden_.tempc
%1030 = fadd double %1028, %1029
%1031 = fneg double %1027
%1032 = call double @llvm.fmuladd.f64(double %1031, double %1030, double %1026)
store double %1032, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 1)
%1033 = load double, double* @bigden_.half
%1034 = load double, double* @bigden_.tempb
%1035 = load double, double* @bigden_.tempc
%1036 = fsub double %1034, %1035
%1037 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 5)
%1038 = fneg double %1033
%1039 = call double @llvm.fmuladd.f64(double %1038, double %1036, double %1037)
store double %1039, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 5)
%1040 = load double*, double** %34
%1041 = load i64, i64* @bigden_.k
%1042 = load i64, i64* %43
%1043 = add nsw i64 %1041, %1042
%1044 = getelementptr inbounds double, double* %1040, i64 %1043
%1045 = load double, double* %1044
%1046 = load double*, double** %33
%1047 = load i64, i64* @bigden_.k
%1048 = load i64, i64* %41
%1049 = mul nsw i64 %1048, 3
%1050 = add nsw i64 %1047, %1049
%1051 = getelementptr inbounds double, double* %1046, i64 %1050
%1052 = load double, double* %1051
%1053 = load double*, double** %34
%1054 = load i64, i64* @bigden_.k
%1055 = load i64, i64* %43
%1056 = mul nsw i64 %1055, 3
%1057 = add nsw i64 %1054, %1056
%1058 = getelementptr inbounds double, double* %1053, i64 %1057
%1059 = load double, double* %1058
%1060 = load double*, double** %33
%1061 = load i64, i64* @bigden_.k
%1062 = load i64, i64* %41
%1063 = add nsw i64 %1061, %1062
%1064 = getelementptr inbounds double, double* %1060, i64 %1063
%1065 = load double, double* %1064
%1066 = fmul double %1059, %1065
%1067 = call double @llvm.fmuladd.f64(double %1045, double %1052, double %1066)
store double %1067, double* @bigden_.tempa
%1068 = load double*, double** %34
%1069 = load i64, i64* @bigden_.k
%1070 = load i64, i64* %43
%1071 = shl i64 %1070, 1
%1072 = add nsw i64 %1069, %1071
%1073 = getelementptr inbounds double, double* %1068, i64 %1072
%1074 = load double, double* %1073
%1075 = load double*, double** %33
%1076 = load i64, i64* @bigden_.k
%1077 = load i64, i64* %41
%1078 = mul nsw i64 %1077, 5
%1079 = add nsw i64 %1076, %1078
%1080 = getelementptr inbounds double, double* %1075, i64 %1079
%1081 = load double, double* %1080
%1082 = load double*, double** %34
%1083 = load i64, i64* @bigden_.k
%1084 = load i64, i64* %43
%1085 = mul nsw i64 %1084, 5
%1086 = add nsw i64 %1083, %1085
%1087 = getelementptr inbounds double, double* %1082, i64 %1086
%1088 = load double, double* %1087
%1089 = load double*, double** %33
%1090 = load i64, i64* @bigden_.k
%1091 = load i64, i64* %41
%1092 = shl i64 %1091, 1
%1093 = add nsw i64 %1090, %1092
%1094 = getelementptr inbounds double, double* %1089, i64 %1093
%1095 = load double, double* %1094
%1096 = fmul double %1088, %1095
%1097 = call double @llvm.fmuladd.f64(double %1074, double %1081, double %1096)
store double %1097, double* @bigden_.tempb
%1098 = load double*, double** %34
%1099 = load i64, i64* @bigden_.k
%1100 = load i64, i64* %43
%1101 = mul nsw i64 %1100, 3
%1102 = add nsw i64 %1099, %1101
%1103 = getelementptr inbounds double, double* %1098, i64 %1102
%1104 = load double, double* %1103
%1105 = load double*, double** %33
%1106 = load i64, i64* @bigden_.k
%1107 = load i64, i64* %41
%1108 = shl i64 %1107, 2
%1109 = add nsw i64 %1106, %1108
%1110 = getelementptr inbounds double, double* %1105, i64 %1109
%1111 = load double, double* %1110
%1112 = load double*, double** %34
%1113 = load i64, i64* @bigden_.k
%1114 = load i64, i64* %43
%1115 = shl i64 %1114, 2
%1116 = add nsw i64 %1113, %1115
%1117 = getelementptr inbounds double, double* %1112, i64 %1116
%1118 = load double, double* %1117
%1119 = load double*, double** %33
%1120 = load i64, i64* @bigden_.k
%1121 = load i64, i64* %41
%1122 = mul nsw i64 %1121, 3
%1123 = add nsw i64 %1120, %1122
%1124 = getelementptr inbounds double, double* %1119, i64 %1123
%1125 = load double, double* %1124
%1126 = fmul double %1118, %1125
%1127 = call double @llvm.fmuladd.f64(double %1104, double %1111, double %1126)
store double %1127, double* @bigden_.tempc
%1128 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 2)
%1129 = load double, double* @bigden_.tempa
%1130 = fsub double %1128, %1129
%1131 = load double, double* @bigden_.half
%1132 = load double, double* @bigden_.tempb
%1133 = load double, double* @bigden_.tempc
%1134 = fsub double %1132, %1133
%1135 = fneg double %1131
%1136 = call double @llvm.fmuladd.f64(double %1135, double %1134, double %1130)
store double %1136, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 2)
%1137 = load double, double* @bigden_.half
%1138 = load double, double* @bigden_.tempb
%1139 = load double, double* @bigden_.tempc
%1140 = fadd double %1138, %1139
%1141 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 6)
%1142 = fneg double %1137
%1143 = call double @llvm.fmuladd.f64(double %1142, double %1140, double %1141)
store double %1143, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 6)
%1144 = load double*, double** %34
%1145 = load i64, i64* @bigden_.k
%1146 = load i64, i64* %43
%1147 = add nsw i64 %1145, %1146
%1148 = getelementptr inbounds double, double* %1144, i64 %1147
%1149 = load double, double* %1148
%1150 = load double*, double** %33
%1151 = load i64, i64* @bigden_.k
%1152 = load i64, i64* %41
%1153 = shl i64 %1152, 2
%1154 = add nsw i64 %1151, %1153
%1155 = getelementptr inbounds double, double* %1150, i64 %1154
%1156 = load double, double* %1155
%1157 = load double*, double** %34
%1158 = load i64, i64* @bigden_.k
%1159 = load i64, i64* %43
%1160 = shl i64 %1159, 2
%1161 = add nsw i64 %1158, %1160
%1162 = getelementptr inbounds double, double* %1157, i64 %1161
%1163 = load double, double* %1162
%1164 = load double*, double** %33
%1165 = load i64, i64* @bigden_.k
%1166 = load i64, i64* %41
%1167 = add nsw i64 %1165, %1166
%1168 = getelementptr inbounds double, double* %1164, i64 %1167
%1169 = load double, double* %1168
%1170 = fmul double %1163, %1169
%1171 = call double @llvm.fmuladd.f64(double %1149, double %1156, double %1170)
store double %1171, double* @bigden_.tempa
%1172 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 3)
%1173 = load double, double* @bigden_.tempa
%1174 = fsub double %1172, %1173
%1175 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 1)
%1176 = fsub double %1174, %1175
%1177 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 2)
%1178 = fadd double %1176, %1177
store double %1178, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 3)
%1179 = load double*, double** %34
%1180 = load i64, i64* @bigden_.k
%1181 = load i64, i64* %43
%1182 = add nsw i64 %1180, %1181
%1183 = getelementptr inbounds double, double* %1179, i64 %1182
%1184 = load double, double* %1183
%1185 = load double*, double** %33
%1186 = load i64, i64* @bigden_.k
%1187 = load i64, i64* %41
%1188 = mul nsw i64 %1187, 5
%1189 = add nsw i64 %1186, %1188
%1190 = getelementptr inbounds double, double* %1185, i64 %1189
%1191 = load double, double* %1190
%1192 = load double*, double** %34
%1193 = load i64, i64* @bigden_.k
%1194 = load i64, i64* %43
%1195 = mul nsw i64 %1194, 5
%1196 = add nsw i64 %1193, %1195
%1197 = getelementptr inbounds double, double* %1192, i64 %1196
%1198 = load double, double* %1197
%1199 = load double*, double** %33
%1200 = load i64, i64* @bigden_.k
%1201 = load i64, i64* %41
%1202 = add nsw i64 %1200, %1201
%1203 = getelementptr inbounds double, double* %1199, i64 %1202
%1204 = load double, double* %1203
%1205 = fmul double %1198, %1204
%1206 = call double @llvm.fmuladd.f64(double %1184, double %1191, double %1205)
store double %1206, double* @bigden_.tempa
%1207 = load double*, double** %34
%1208 = load i64, i64* @bigden_.k
%1209 = load i64, i64* %43
%1210 = shl i64 %1209, 1
%1211 = add nsw i64 %1208, %1210
%1212 = getelementptr inbounds double, double* %1207, i64 %1211
%1213 = load double, double* %1212
%1214 = load double*, double** %33
%1215 = load i64, i64* @bigden_.k
%1216 = load i64, i64* %41
%1217 = mul nsw i64 %1216, 3
%1218 = add nsw i64 %1215, %1217
%1219 = getelementptr inbounds double, double* %1214, i64 %1218
%1220 = load double, double* %1219
%1221 = load double*, double** %34
%1222 = load i64, i64* @bigden_.k
%1223 = load i64, i64* %43
%1224 = mul nsw i64 %1223, 3
%1225 = add nsw i64 %1222, %1224
%1226 = getelementptr inbounds double, double* %1221, i64 %1225
%1227 = load double, double* %1226
%1228 = load double*, double** %33
%1229 = load i64, i64* @bigden_.k
%1230 = load i64, i64* %41
%1231 = shl i64 %1230, 1
%1232 = add nsw i64 %1229, %1231
%1233 = getelementptr inbounds double, double* %1228, i64 %1232
%1234 = load double, double* %1233
%1235 = fmul double %1227, %1234
%1236 = call double @llvm.fmuladd.f64(double %1213, double %1220, double %1235)
store double %1236, double* @bigden_.tempb
%1237 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 4)
%1238 = load double, double* @bigden_.tempa
%1239 = fsub double %1237, %1238
%1240 = load double, double* @bigden_.half
%1241 = load double, double* @bigden_.tempb
%1242 = fneg double %1240
%1243 = call double @llvm.fmuladd.f64(double %1242, double %1241, double %1239)
store double %1243, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 4)
%1244 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 7)
%1245 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 3)
%1246 = fsub double %1244, %1245
%1247 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 4)
%1248 = fadd double %1246, %1247
store double %1248, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 7)
%1249 = load double*, double** %34
%1250 = load i64, i64* @bigden_.k
%1251 = load i64, i64* %43
%1252 = shl i64 %1251, 2
%1253 = add nsw i64 %1250, %1252
%1254 = getelementptr inbounds double, double* %1249, i64 %1253
%1255 = load double, double* %1254
%1256 = load double*, double** %33
%1257 = load i64, i64* @bigden_.k
%1258 = load i64, i64* %41
%1259 = mul nsw i64 %1258, 5
%1260 = add nsw i64 %1257, %1259
%1261 = getelementptr inbounds double, double* %1256, i64 %1260
%1262 = load double, double* %1261
%1263 = load double*, double** %34
%1264 = load i64, i64* @bigden_.k
%1265 = load i64, i64* %43
%1266 = mul nsw i64 %1265, 5
%1267 = add nsw i64 %1264, %1266
%1268 = getelementptr inbounds double, double* %1263, i64 %1267
%1269 = load double, double* %1268
%1270 = load double*, double** %33
%1271 = load i64, i64* @bigden_.k
%1272 = load i64, i64* %41
%1273 = shl i64 %1272, 2
%1274 = add nsw i64 %1271, %1273
%1275 = getelementptr inbounds double, double* %1270, i64 %1274
%1276 = load double, double* %1275
%1277 = fmul double %1269, %1276
%1278 = call double @llvm.fmuladd.f64(double %1255, double %1262, double %1277)
store double %1278, double* @bigden_.tempa
%1279 = load double, double* @bigden_.half
%1280 = load double, double* @bigden_.tempa
%1281 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 8)
%1282 = fneg double %1279
%1283 = call double @llvm.fmuladd.f64(double %1282, double %1280, double %1281)
store double %1283, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 8)
br label %1284
1284: ; preds = %930
%1285 = load i64, i64* @bigden_.k
%1286 = add nsw i64 %1285, 1
store i64 %1286, i64* @bigden_.k
br label %889
1287: ; preds = %889
%1288 = load double, double* @bigden_.zero
store double %1288, double* @bigden_.sum
store i64 1, i64* @bigden_.i__
br label %1289
1289: ; preds = %1316, %1287
%1290 = load i64, i64* @bigden_.i__
%1291 = icmp sle i64 %1290, 5
br i1 %1291, label %1292, label %1319
1292: ; preds = %1289
%1293 = load double*, double** %34
%1294 = load i64*, i64** %27
%1295 = load i64, i64* %1294
%1296 = load i64, i64* @bigden_.i__
%1297 = load i64, i64* %43
%1298 = mul nsw i64 %1296, %1297
%1299 = add nsw i64 %1295, %1298
%1300 = getelementptr inbounds double, double* %1293, i64 %1299
%1301 = load double, double* %1300
store double %1301, double* %47
%1302 = load double, double* @bigden_.half
%1303 = load double, double* %47
%1304 = load double, double* %47
%1305 = fmul double %1303, %1304
%1306 = fmul double %1302, %1305
%1307 = load i64, i64* @bigden_.i__
%1308 = sub nsw i64 %1307, 1
%1309 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1308
store double %1306, double* %1309
%1310 = load i64, i64* @bigden_.i__
%1311 = sub nsw i64 %1310, 1
%1312 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1311
%1313 = load double, double* %1312
%1314 = load double, double* @bigden_.sum
%1315 = fadd double %1314, %1313
store double %1315, double* @bigden_.sum
br label %1316
1316: ; preds = %1292
%1317 = load i64, i64* @bigden_.i__
%1318 = add nsw i64 %1317, 1
store i64 %1318, i64* @bigden_.i__
br label %1289
1319: ; preds = %1289
%1320 = load double, double* @bigden_.alpha
%1321 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 0)
%1322 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 0)
%1323 = call double @llvm.fmuladd.f64(double %1320, double %1321, double %1322)
%1324 = load double, double* @bigden_.sum
%1325 = fadd double %1323, %1324
store double %1325, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 0)
%1326 = load double, double* @bigden_.two
%1327 = load double*, double** %34
%1328 = load i64*, i64** %27
%1329 = load i64, i64* %1328
%1330 = load i64, i64* %43
%1331 = add nsw i64 %1329, %1330
%1332 = getelementptr inbounds double, double* %1327, i64 %1331
%1333 = load double, double* %1332
%1334 = fmul double %1326, %1333
%1335 = load double*, double** %34
%1336 = load i64*, i64** %27
%1337 = load i64, i64* %1336
%1338 = load i64, i64* %43
%1339 = shl i64 %1338, 1
%1340 = add nsw i64 %1337, %1339
%1341 = getelementptr inbounds double, double* %1335, i64 %1340
%1342 = load double, double* %1341
%1343 = fmul double %1334, %1342
store double %1343, double* @bigden_.tempa
%1344 = load double*, double** %34
%1345 = load i64*, i64** %27
%1346 = load i64, i64* %1345
%1347 = load i64, i64* %43
%1348 = shl i64 %1347, 1
%1349 = add nsw i64 %1346, %1348
%1350 = getelementptr inbounds double, double* %1344, i64 %1349
%1351 = load double, double* %1350
%1352 = load double*, double** %34
%1353 = load i64*, i64** %27
%1354 = load i64, i64* %1353
%1355 = load i64, i64* %43
%1356 = shl i64 %1355, 2
%1357 = add nsw i64 %1354, %1356
%1358 = getelementptr inbounds double, double* %1352, i64 %1357
%1359 = load double, double* %1358
%1360 = fmul double %1351, %1359
store double %1360, double* @bigden_.tempb
%1361 = load double*, double** %34
%1362 = load i64*, i64** %27
%1363 = load i64, i64* %1362
%1364 = load i64, i64* %43
%1365 = mul nsw i64 %1364, 3
%1366 = add nsw i64 %1363, %1365
%1367 = getelementptr inbounds double, double* %1361, i64 %1366
%1368 = load double, double* %1367
%1369 = load double*, double** %34
%1370 = load i64*, i64** %27
%1371 = load i64, i64* %1370
%1372 = load i64, i64* %43
%1373 = mul nsw i64 %1372, 5
%1374 = add nsw i64 %1371, %1373
%1375 = getelementptr inbounds double, double* %1369, i64 %1374
%1376 = load double, double* %1375
%1377 = fmul double %1368, %1376
store double %1377, double* @bigden_.tempc
%1378 = load double, double* @bigden_.alpha
%1379 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 1)
%1380 = load double, double* @bigden_.tempa
%1381 = call double @llvm.fmuladd.f64(double %1378, double %1379, double %1380)
%1382 = load double, double* @bigden_.tempb
%1383 = fadd double %1381, %1382
%1384 = load double, double* @bigden_.tempc
%1385 = fadd double %1383, %1384
store double %1385, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 1)
%1386 = load double, double* @bigden_.alpha
%1387 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 5)
%1388 = load double, double* @bigden_.tempb
%1389 = call double @llvm.fmuladd.f64(double %1386, double %1387, double %1388)
%1390 = load double, double* @bigden_.tempc
%1391 = fsub double %1389, %1390
store double %1391, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 5)
%1392 = load double, double* @bigden_.two
%1393 = load double*, double** %34
%1394 = load i64*, i64** %27
%1395 = load i64, i64* %1394
%1396 = load i64, i64* %43
%1397 = add nsw i64 %1395, %1396
%1398 = getelementptr inbounds double, double* %1393, i64 %1397
%1399 = load double, double* %1398
%1400 = fmul double %1392, %1399
%1401 = load double*, double** %34
%1402 = load i64*, i64** %27
%1403 = load i64, i64* %1402
%1404 = load i64, i64* %43
%1405 = mul nsw i64 %1404, 3
%1406 = add nsw i64 %1403, %1405
%1407 = getelementptr inbounds double, double* %1401, i64 %1406
%1408 = load double, double* %1407
%1409 = fmul double %1400, %1408
store double %1409, double* @bigden_.tempa
%1410 = load double*, double** %34
%1411 = load i64*, i64** %27
%1412 = load i64, i64* %1411
%1413 = load i64, i64* %43
%1414 = shl i64 %1413, 1
%1415 = add nsw i64 %1412, %1414
%1416 = getelementptr inbounds double, double* %1410, i64 %1415
%1417 = load double, double* %1416
%1418 = load double*, double** %34
%1419 = load i64*, i64** %27
%1420 = load i64, i64* %1419
%1421 = load i64, i64* %43
%1422 = mul nsw i64 %1421, 5
%1423 = add nsw i64 %1420, %1422
%1424 = getelementptr inbounds double, double* %1418, i64 %1423
%1425 = load double, double* %1424
%1426 = fmul double %1417, %1425
store double %1426, double* @bigden_.tempb
%1427 = load double*, double** %34
%1428 = load i64*, i64** %27
%1429 = load i64, i64* %1428
%1430 = load i64, i64* %43
%1431 = mul nsw i64 %1430, 3
%1432 = add nsw i64 %1429, %1431
%1433 = getelementptr inbounds double, double* %1427, i64 %1432
%1434 = load double, double* %1433
%1435 = load double*, double** %34
%1436 = load i64*, i64** %27
%1437 = load i64, i64* %1436
%1438 = load i64, i64* %43
%1439 = shl i64 %1438, 2
%1440 = add nsw i64 %1437, %1439
%1441 = getelementptr inbounds double, double* %1435, i64 %1440
%1442 = load double, double* %1441
%1443 = fmul double %1434, %1442
store double %1443, double* @bigden_.tempc
%1444 = load double, double* @bigden_.alpha
%1445 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 2)
%1446 = load double, double* @bigden_.tempa
%1447 = call double @llvm.fmuladd.f64(double %1444, double %1445, double %1446)
%1448 = load double, double* @bigden_.tempb
%1449 = fadd double %1447, %1448
%1450 = load double, double* @bigden_.tempc
%1451 = fsub double %1449, %1450
store double %1451, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 2)
%1452 = load double, double* @bigden_.alpha
%1453 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 6)
%1454 = load double, double* @bigden_.tempb
%1455 = call double @llvm.fmuladd.f64(double %1452, double %1453, double %1454)
%1456 = load double, double* @bigden_.tempc
%1457 = fadd double %1455, %1456
store double %1457, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 6)
%1458 = load double, double* @bigden_.two
%1459 = load double*, double** %34
%1460 = load i64*, i64** %27
%1461 = load i64, i64* %1460
%1462 = load i64, i64* %43
%1463 = add nsw i64 %1461, %1462
%1464 = getelementptr inbounds double, double* %1459, i64 %1463
%1465 = load double, double* %1464
%1466 = fmul double %1458, %1465
%1467 = load double*, double** %34
%1468 = load i64*, i64** %27
%1469 = load i64, i64* %1468
%1470 = load i64, i64* %43
%1471 = shl i64 %1470, 2
%1472 = add nsw i64 %1469, %1471
%1473 = getelementptr inbounds double, double* %1467, i64 %1472
%1474 = load double, double* %1473
%1475 = fmul double %1466, %1474
store double %1475, double* @bigden_.tempa
%1476 = load double, double* @bigden_.alpha
%1477 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 3)
%1478 = load double, double* @bigden_.tempa
%1479 = call double @llvm.fmuladd.f64(double %1476, double %1477, double %1478)
%1480 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 1)
%1481 = fadd double %1479, %1480
%1482 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 2)
%1483 = fsub double %1481, %1482
store double %1483, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 3)
%1484 = load double, double* @bigden_.two
%1485 = load double*, double** %34
%1486 = load i64*, i64** %27
%1487 = load i64, i64* %1486
%1488 = load i64, i64* %43
%1489 = add nsw i64 %1487, %1488
%1490 = getelementptr inbounds double, double* %1485, i64 %1489
%1491 = load double, double* %1490
%1492 = fmul double %1484, %1491
%1493 = load double*, double** %34
%1494 = load i64*, i64** %27
%1495 = load i64, i64* %1494
%1496 = load i64, i64* %43
%1497 = mul nsw i64 %1496, 5
%1498 = add nsw i64 %1495, %1497
%1499 = getelementptr inbounds double, double* %1493, i64 %1498
%1500 = load double, double* %1499
%1501 = fmul double %1492, %1500
store double %1501, double* @bigden_.tempa
%1502 = load double, double* @bigden_.alpha
%1503 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 4)
%1504 = load double, double* @bigden_.tempa
%1505 = call double @llvm.fmuladd.f64(double %1502, double %1503, double %1504)
%1506 = load double*, double** %34
%1507 = load i64*, i64** %27
%1508 = load i64, i64* %1507
%1509 = load i64, i64* %43
%1510 = shl i64 %1509, 1
%1511 = add nsw i64 %1508, %1510
%1512 = getelementptr inbounds double, double* %1506, i64 %1511
%1513 = load double, double* %1512
%1514 = load double*, double** %34
%1515 = load i64*, i64** %27
%1516 = load i64, i64* %1515
%1517 = load i64, i64* %43
%1518 = mul nsw i64 %1517, 3
%1519 = add nsw i64 %1516, %1518
%1520 = getelementptr inbounds double, double* %1514, i64 %1519
%1521 = load double, double* %1520
%1522 = call double @llvm.fmuladd.f64(double %1513, double %1521, double %1505)
store double %1522, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 4)
%1523 = load double, double* @bigden_.alpha
%1524 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 7)
%1525 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 3)
%1526 = call double @llvm.fmuladd.f64(double %1523, double %1524, double %1525)
%1527 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 4)
%1528 = fsub double %1526, %1527
store double %1528, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 7)
%1529 = load double, double* @bigden_.alpha
%1530 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.den, i64 0, i64 8)
%1531 = load double*, double** %34
%1532 = load i64*, i64** %27
%1533 = load i64, i64* %1532
%1534 = load i64, i64* %43
%1535 = shl i64 %1534, 2
%1536 = add nsw i64 %1533, %1535
%1537 = getelementptr inbounds double, double* %1531, i64 %1536
%1538 = load double, double* %1537
%1539 = load double*, double** %34
%1540 = load i64*, i64** %27
%1541 = load i64, i64* %1540
%1542 = load i64, i64* %43
%1543 = mul nsw i64 %1542, 5
%1544 = add nsw i64 %1541, %1543
%1545 = getelementptr inbounds double, double* %1539, i64 %1544
%1546 = load double, double* %1545
%1547 = fmul double %1538, %1546
%1548 = call double @llvm.fmuladd.f64(double %1529, double %1530, double %1547)
store double %1548, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 8)
%1549 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 0)
%1550 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 1)
%1551 = fadd double %1549, %1550
%1552 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 3)
%1553 = fadd double %1551, %1552
%1554 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 5)
%1555 = fadd double %1553, %1554
%1556 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.denex, i64 0, i64 7)
%1557 = fadd double %1555, %1556
store double %1557, double* @bigden_.sum
%1558 = load double, double* @bigden_.sum
store double %1558, double* @bigden_.denold
%1559 = load double, double* @bigden_.sum
store double %1559, double* @bigden_.denmax
store i64 0, i64* @bigden_.isave
store i64 49, i64* @bigden_.iu
%1560 = load double, double* @bigden_.twopi
%1561 = load i64, i64* @bigden_.iu
%1562 = add nsw i64 %1561, 1
%1563 = sitofp i64 %1562 to double
%1564 = fdiv double %1560, %1563
store double %1564, double* @bigden_.temp
%1565 = load double, double* @bigden_.one
store double %1565, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 0)
%1566 = load i64, i64* @bigden_.iu
store i64 %1566, i64* %45
store i64 1, i64* @bigden_.i__
br label %1567
1567: ; preds = %1658, %1319
%1568 = load i64, i64* @bigden_.i__
%1569 = load i64, i64* %45
%1570 = icmp sle i64 %1568, %1569
br i1 %1570, label %1571, label %1661
1571: ; preds = %1567
%1572 = load i64, i64* @bigden_.i__
%1573 = sitofp i64 %1572 to double
%1574 = load double, double* @bigden_.temp
%1575 = fmul double %1573, %1574
store double %1575, double* @bigden_.angle
%1576 = load double, double* @bigden_.angle
%1577 = call double @cos(double %1576)
store double %1577, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 1)
%1578 = load double, double* @bigden_.angle
%1579 = call double @sin(double %1578)
store double %1579, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 2)
store i64 4, i64* @bigden_.j
br label %1580
1580: ; preds = %1614, %1571
%1581 = load i64, i64* @bigden_.j
%1582 = icmp sle i64 %1581, 8
br i1 %1582, label %1583, label %1617
1583: ; preds = %1580
%1584 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 1)
%1585 = load i64, i64* @bigden_.j
%1586 = sub nsw i64 %1585, 3
%1587 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1586
%1588 = load double, double* %1587
%1589 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 2)
%1590 = load i64, i64* @bigden_.j
%1591 = sub nsw i64 %1590, 2
%1592 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1591
%1593 = load double, double* %1592
%1594 = fmul double %1589, %1593
%1595 = fneg double %1594
%1596 = call double @llvm.fmuladd.f64(double %1584, double %1588, double %1595)
%1597 = load i64, i64* @bigden_.j
%1598 = sub nsw i64 %1597, 1
%1599 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1598
store double %1596, double* %1599
%1600 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 1)
%1601 = load i64, i64* @bigden_.j
%1602 = sub nsw i64 %1601, 2
%1603 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1602
%1604 = load double, double* %1603
%1605 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 2)
%1606 = load i64, i64* @bigden_.j
%1607 = sub nsw i64 %1606, 3
%1608 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1607
%1609 = load double, double* %1608
%1610 = fmul double %1605, %1609
%1611 = call double @llvm.fmuladd.f64(double %1600, double %1604, double %1610)
%1612 = load i64, i64* @bigden_.j
%1613 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1612
store double %1611, double* %1613
br label %1614
1614: ; preds = %1583
%1615 = load i64, i64* @bigden_.j
%1616 = add nsw i64 %1615, 2
store i64 %1616, i64* @bigden_.j
br label %1580
1617: ; preds = %1580
%1618 = load double, double* @bigden_.sum
store double %1618, double* @bigden_.sumold
%1619 = load double, double* @bigden_.zero
store double %1619, double* @bigden_.sum
store i64 1, i64* @bigden_.j
br label %1620
1620: ; preds = %1634, %1617
%1621 = load i64, i64* @bigden_.j
%1622 = icmp sle i64 %1621, 9
br i1 %1622, label %1623, label %1637
1623: ; preds = %1620
%1624 = load i64, i64* @bigden_.j
%1625 = sub nsw i64 %1624, 1
%1626 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.denex, i64 0, i64 %1625
%1627 = load double, double* %1626
%1628 = load i64, i64* @bigden_.j
%1629 = sub nsw i64 %1628, 1
%1630 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1629
%1631 = load double, double* %1630
%1632 = load double, double* @bigden_.sum
%1633 = call double @llvm.fmuladd.f64(double %1627, double %1631, double %1632)
store double %1633, double* @bigden_.sum
br label %1634
1634: ; preds = %1623
%1635 = load i64, i64* @bigden_.j
%1636 = add nsw i64 %1635, 1
store i64 %1636, i64* @bigden_.j
br label %1620
1637: ; preds = %1620
%1638 = load double, double* @bigden_.sum
%1639 = fptosi double %1638 to i32
%1640 = call i32 @abs(i32 %1639)
%1641 = load double, double* @bigden_.denmax
%1642 = fptosi double %1641 to i32
%1643 = call i32 @abs(i32 %1642)
%1644 = icmp sgt i32 %1640, %1643
br i1 %1644, label %1645, label %1649
1645: ; preds = %1637
%1646 = load double, double* @bigden_.sum
store double %1646, double* @bigden_.denmax
%1647 = load i64, i64* @bigden_.i__
store i64 %1647, i64* @bigden_.isave
%1648 = load double, double* @bigden_.sumold
store double %1648, double* @bigden_.tempa
br label %1657
1649: ; preds = %1637
%1650 = load i64, i64* @bigden_.i__
%1651 = load i64, i64* @bigden_.isave
%1652 = add nsw i64 %1651, 1
%1653 = icmp eq i64 %1650, %1652
br i1 %1653, label %1654, label %1656
1654: ; preds = %1649
%1655 = load double, double* @bigden_.sum
store double %1655, double* @bigden_.tempb
br label %1656
1656: ; preds = %1654, %1649
br label %1657
1657: ; preds = %1656, %1645
br label %1658
1658: ; preds = %1657
%1659 = load i64, i64* @bigden_.i__
%1660 = add nsw i64 %1659, 1
store i64 %1660, i64* @bigden_.i__
br label %1567
1661: ; preds = %1567
%1662 = load i64, i64* @bigden_.isave
%1663 = icmp eq i64 %1662, 0
br i1 %1663, label %1664, label %1666
1664: ; preds = %1661
%1665 = load double, double* @bigden_.sum
store double %1665, double* @bigden_.tempa
br label %1666
1666: ; preds = %1664, %1661
%1667 = load i64, i64* @bigden_.isave
%1668 = load i64, i64* @bigden_.iu
%1669 = icmp eq i64 %1667, %1668
br i1 %1669, label %1670, label %1672
1670: ; preds = %1666
%1671 = load double, double* @bigden_.denold
store double %1671, double* @bigden_.tempb
br label %1672
1672: ; preds = %1670, %1666
%1673 = load double, double* @bigden_.zero
store double %1673, double* @bigden_.step
%1674 = load double, double* @bigden_.tempa
%1675 = load double, double* @bigden_.tempb
%1676 = fcmp une double %1674, %1675
br i1 %1676, label %1677, label %1693
1677: ; preds = %1672
%1678 = load double, double* @bigden_.denmax
%1679 = load double, double* @bigden_.tempa
%1680 = fsub double %1679, %1678
store double %1680, double* @bigden_.tempa
%1681 = load double, double* @bigden_.denmax
%1682 = load double, double* @bigden_.tempb
%1683 = fsub double %1682, %1681
store double %1683, double* @bigden_.tempb
%1684 = load double, double* @bigden_.half
%1685 = load double, double* @bigden_.tempa
%1686 = load double, double* @bigden_.tempb
%1687 = fsub double %1685, %1686
%1688 = fmul double %1684, %1687
%1689 = load double, double* @bigden_.tempa
%1690 = load double, double* @bigden_.tempb
%1691 = fadd double %1689, %1690
%1692 = fdiv double %1688, %1691
store double %1692, double* @bigden_.step
br label %1693
1693: ; preds = %1677, %1672
%1694 = load double, double* @bigden_.temp
%1695 = load i64, i64* @bigden_.isave
%1696 = sitofp i64 %1695 to double
%1697 = load double, double* @bigden_.step
%1698 = fadd double %1696, %1697
%1699 = fmul double %1694, %1698
store double %1699, double* @bigden_.angle
%1700 = load double, double* @bigden_.angle
%1701 = call double @cos(double %1700)
store double %1701, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 1)
%1702 = load double, double* @bigden_.angle
%1703 = call double @sin(double %1702)
store double %1703, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 2)
store i64 4, i64* @bigden_.j
br label %1704
1704: ; preds = %1738, %1693
%1705 = load i64, i64* @bigden_.j
%1706 = icmp sle i64 %1705, 8
br i1 %1706, label %1707, label %1741
1707: ; preds = %1704
%1708 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 1)
%1709 = load i64, i64* @bigden_.j
%1710 = sub nsw i64 %1709, 3
%1711 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1710
%1712 = load double, double* %1711
%1713 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 2)
%1714 = load i64, i64* @bigden_.j
%1715 = sub nsw i64 %1714, 2
%1716 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1715
%1717 = load double, double* %1716
%1718 = fmul double %1713, %1717
%1719 = fneg double %1718
%1720 = call double @llvm.fmuladd.f64(double %1708, double %1712, double %1719)
%1721 = load i64, i64* @bigden_.j
%1722 = sub nsw i64 %1721, 1
%1723 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1722
store double %1720, double* %1723
%1724 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 1)
%1725 = load i64, i64* @bigden_.j
%1726 = sub nsw i64 %1725, 2
%1727 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1726
%1728 = load double, double* %1727
%1729 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 2)
%1730 = load i64, i64* @bigden_.j
%1731 = sub nsw i64 %1730, 3
%1732 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1731
%1733 = load double, double* %1732
%1734 = fmul double %1729, %1733
%1735 = call double @llvm.fmuladd.f64(double %1724, double %1728, double %1734)
%1736 = load i64, i64* @bigden_.j
%1737 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1736
store double %1735, double* %1737
br label %1738
1738: ; preds = %1707
%1739 = load i64, i64* @bigden_.j
%1740 = add nsw i64 %1739, 2
store i64 %1740, i64* @bigden_.j
br label %1704
1741: ; preds = %1704
%1742 = load double, double* @bigden_.zero
%1743 = load double*, double** %31
store double %1742, double* %1743
%1744 = load double, double* @bigden_.zero
store double %1744, double* @bigden_.denmax
store i64 1, i64* @bigden_.j
br label %1745
1745: ; preds = %1770, %1741
%1746 = load i64, i64* @bigden_.j
%1747 = icmp sle i64 %1746, 9
br i1 %1747, label %1748, label %1773
1748: ; preds = %1745
%1749 = load i64, i64* @bigden_.j
%1750 = sub nsw i64 %1749, 1
%1751 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.den, i64 0, i64 %1750
%1752 = load double, double* %1751
%1753 = load i64, i64* @bigden_.j
%1754 = sub nsw i64 %1753, 1
%1755 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1754
%1756 = load double, double* %1755
%1757 = load double*, double** %31
%1758 = load double, double* %1757
%1759 = call double @llvm.fmuladd.f64(double %1752, double %1756, double %1758)
store double %1759, double* %1757
%1760 = load i64, i64* @bigden_.j
%1761 = sub nsw i64 %1760, 1
%1762 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.denex, i64 0, i64 %1761
%1763 = load double, double* %1762
%1764 = load i64, i64* @bigden_.j
%1765 = sub nsw i64 %1764, 1
%1766 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1765
%1767 = load double, double* %1766
%1768 = load double, double* @bigden_.denmax
%1769 = call double @llvm.fmuladd.f64(double %1763, double %1767, double %1768)
store double %1769, double* @bigden_.denmax
br label %1770
1770: ; preds = %1748
%1771 = load i64, i64* @bigden_.j
%1772 = add nsw i64 %1771, 1
store i64 %1772, i64* @bigden_.j
br label %1745
1773: ; preds = %1745
%1774 = load i64*, i64** %25
%1775 = load i64, i64* %1774
store i64 %1775, i64* %45
store i64 1, i64* @bigden_.k
br label %1776
1776: ; preds = %1810, %1773
%1777 = load i64, i64* @bigden_.k
%1778 = load i64, i64* %45
%1779 = icmp sle i64 %1777, %1778
br i1 %1779, label %1780, label %1813
1780: ; preds = %1776
%1781 = load double, double* @bigden_.zero
%1782 = load double*, double** %30
%1783 = load i64, i64* @bigden_.k
%1784 = getelementptr inbounds double, double* %1782, i64 %1783
store double %1781, double* %1784
store i64 1, i64* @bigden_.j
br label %1785
1785: ; preds = %1806, %1780
%1786 = load i64, i64* @bigden_.j
%1787 = icmp sle i64 %1786, 5
br i1 %1787, label %1788, label %1809
1788: ; preds = %1785
%1789 = load double*, double** %34
%1790 = load i64, i64* @bigden_.k
%1791 = load i64, i64* @bigden_.j
%1792 = load i64, i64* %43
%1793 = mul nsw i64 %1791, %1792
%1794 = add nsw i64 %1790, %1793
%1795 = getelementptr inbounds double, double* %1789, i64 %1794
%1796 = load double, double* %1795
%1797 = load i64, i64* @bigden_.j
%1798 = sub nsw i64 %1797, 1
%1799 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %1798
%1800 = load double, double* %1799
%1801 = load double*, double** %30
%1802 = load i64, i64* @bigden_.k
%1803 = getelementptr inbounds double, double* %1801, i64 %1802
%1804 = load double, double* %1803
%1805 = call double @llvm.fmuladd.f64(double %1796, double %1800, double %1804)
store double %1805, double* %1803
br label %1806
1806: ; preds = %1788
%1807 = load i64, i64* @bigden_.j
%1808 = add nsw i64 %1807, 1
store i64 %1808, i64* @bigden_.j
br label %1785
1809: ; preds = %1785
br label %1810
1810: ; preds = %1809
%1811 = load i64, i64* @bigden_.k
%1812 = add nsw i64 %1811, 1
store i64 %1812, i64* @bigden_.k
br label %1776
1813: ; preds = %1776
%1814 = load double*, double** %30
%1815 = load i64*, i64** %27
%1816 = load i64, i64* %1815
%1817 = getelementptr inbounds double, double* %1814, i64 %1816
%1818 = load double, double* %1817
store double %1818, double* @bigden_.tau
%1819 = load double, double* @bigden_.zero
store double %1819, double* @bigden_.dd
%1820 = load double, double* @bigden_.zero
store double %1820, double* @bigden_.tempa
%1821 = load double, double* @bigden_.zero
store double %1821, double* @bigden_.tempb
%1822 = load i64*, i64** %18
%1823 = load i64, i64* %1822
store i64 %1823, i64* %45
store i64 1, i64* @bigden_.i__
br label %1824
1824: ; preds = %1884, %1813
%1825 = load i64, i64* @bigden_.i__
%1826 = load i64, i64* %45
%1827 = icmp sle i64 %1825, %1826
br i1 %1827, label %1828, label %1887
1828: ; preds = %1824
%1829 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 1)
%1830 = load double*, double** %28
%1831 = load i64, i64* @bigden_.i__
%1832 = getelementptr inbounds double, double* %1830, i64 %1831
%1833 = load double, double* %1832
%1834 = load double, double* getelementptr inbounds ([9 x double], [9 x double]* @bigden_.par, i64 0, i64 2)
%1835 = load double*, double** %32
%1836 = load i64, i64* @bigden_.i__
%1837 = getelementptr inbounds double, double* %1835, i64 %1836
%1838 = load double, double* %1837
%1839 = fmul double %1834, %1838
%1840 = call double @llvm.fmuladd.f64(double %1829, double %1833, double %1839)
%1841 = load double*, double** %28
%1842 = load i64, i64* @bigden_.i__
%1843 = getelementptr inbounds double, double* %1841, i64 %1842
store double %1840, double* %1843
%1844 = load double*, double** %20
%1845 = load i64, i64* @bigden_.i__
%1846 = getelementptr inbounds double, double* %1844, i64 %1845
%1847 = load double, double* %1846
%1848 = load double*, double** %28
%1849 = load i64, i64* @bigden_.i__
%1850 = getelementptr inbounds double, double* %1848, i64 %1849
%1851 = load double, double* %1850
%1852 = fadd double %1847, %1851
%1853 = load double*, double** %29
%1854 = load i64, i64* @bigden_.i__
%1855 = getelementptr inbounds double, double* %1853, i64 %1854
store double %1852, double* %1855
%1856 = load double*, double** %28
%1857 = load i64, i64* @bigden_.i__
%1858 = getelementptr inbounds double, double* %1856, i64 %1857
%1859 = load double, double* %1858
store double %1859, double* %47
%1860 = load double, double* %47
%1861 = load double, double* %47
%1862 = load double, double* @bigden_.dd
%1863 = call double @llvm.fmuladd.f64(double %1860, double %1861, double %1862)
store double %1863, double* @bigden_.dd
%1864 = load double*, double** %28
%1865 = load i64, i64* @bigden_.i__
%1866 = getelementptr inbounds double, double* %1864, i64 %1865
%1867 = load double, double* %1866
%1868 = load double*, double** %29
%1869 = load i64, i64* @bigden_.i__
%1870 = getelementptr inbounds double, double* %1868, i64 %1869
%1871 = load double, double* %1870
%1872 = load double, double* @bigden_.tempa
%1873 = call double @llvm.fmuladd.f64(double %1867, double %1871, double %1872)
store double %1873, double* @bigden_.tempa
%1874 = load double*, double** %29
%1875 = load i64, i64* @bigden_.i__
%1876 = getelementptr inbounds double, double* %1874, i64 %1875
%1877 = load double, double* %1876
%1878 = load double*, double** %29
%1879 = load i64, i64* @bigden_.i__
%1880 = getelementptr inbounds double, double* %1878, i64 %1879
%1881 = load double, double* %1880
%1882 = load double, double* @bigden_.tempb
%1883 = call double @llvm.fmuladd.f64(double %1877, double %1881, double %1882)
store double %1883, double* @bigden_.tempb
br label %1884
1884: ; preds = %1828
%1885 = load i64, i64* @bigden_.i__
%1886 = add nsw i64 %1885, 1
store i64 %1886, i64* @bigden_.i__
br label %1824
1887: ; preds = %1824
%1888 = load i64, i64* @bigden_.iterc
%1889 = load i64*, i64** %18
%1890 = load i64, i64* %1889
%1891 = icmp sge i64 %1888, %1890
br i1 %1891, label %1892, label %1893
1892: ; preds = %1887
br label %2094
1893: ; preds = %1887
%1894 = load i64, i64* @bigden_.iterc
%1895 = icmp sgt i64 %1894, 1
br i1 %1895, label %1896, label %1906
1896: ; preds = %1893
%1897 = load double, double* @bigden_.densav
%1898 = load double, double* @bigden_.denold
%1899 = fcmp oge double %1897, %1898
br i1 %1899, label %1900, label %1902
1900: ; preds = %1896
%1901 = load double, double* @bigden_.densav
br label %1904
1902: ; preds = %1896
%1903 = load double, double* @bigden_.denold
br label %1904
1904: ; preds = %1902, %1900
%1905 = phi double [ %1901, %1900 ], [ %1903, %1902 ]
store double %1905, double* @bigden_.densav
br label %1906
1906: ; preds = %1904, %1893
%1907 = load double, double* @bigden_.denmax
%1908 = fptosi double %1907 to i32
%1909 = call i32 @abs(i32 %1908)
%1910 = sitofp i32 %1909 to double
%1911 = load double, double* @bigden_.densav
%1912 = fptosi double %1911 to i32
%1913 = call i32 @abs(i32 %1912)
%1914 = sitofp i32 %1913 to double
%1915 = fmul double %1914, 1.100000e+00
%1916 = fcmp ole double %1910, %1915
br i1 %1916, label %1917, label %1918
1917: ; preds = %1906
br label %2094
1918: ; preds = %1906
%1919 = load double, double* @bigden_.denmax
store double %1919, double* @bigden_.densav
%1920 = load i64*, i64** %18
%1921 = load i64, i64* %1920
store i64 %1921, i64* %45
store i64 1, i64* @bigden_.i__
br label %1922
1922: ; preds = %1964, %1918
%1923 = load i64, i64* @bigden_.i__
%1924 = load i64, i64* %45
%1925 = icmp sle i64 %1923, %1924
br i1 %1925, label %1926, label %1967
1926: ; preds = %1922
%1927 = load double, double* @bigden_.tempa
%1928 = load double*, double** %20
%1929 = load i64, i64* @bigden_.i__
%1930 = getelementptr inbounds double, double* %1928, i64 %1929
%1931 = load double, double* %1930
%1932 = load double, double* @bigden_.tempb
%1933 = load double*, double** %28
%1934 = load i64, i64* @bigden_.i__
%1935 = getelementptr inbounds double, double* %1933, i64 %1934
%1936 = load double, double* %1935
%1937 = fmul double %1932, %1936
%1938 = call double @llvm.fmuladd.f64(double %1927, double %1931, double %1937)
%1939 = load double*, double** %30
%1940 = load i64*, i64** %19
%1941 = load i64, i64* %1940
%1942 = load i64, i64* @bigden_.i__
%1943 = add nsw i64 %1941, %1942
%1944 = getelementptr inbounds double, double* %1939, i64 %1943
%1945 = load double, double* %1944
%1946 = fsub double %1938, %1945
store double %1946, double* @bigden_.temp
%1947 = load double, double* @bigden_.tau
%1948 = load double*, double** %22
%1949 = load i64*, i64** %27
%1950 = load i64, i64* %1949
%1951 = load i64, i64* @bigden_.i__
%1952 = load i64, i64* %37
%1953 = mul nsw i64 %1951, %1952
%1954 = add nsw i64 %1950, %1953
%1955 = getelementptr inbounds double, double* %1948, i64 %1954
%1956 = load double, double* %1955
%1957 = load double, double* @bigden_.alpha
%1958 = load double, double* @bigden_.temp
%1959 = fmul double %1957, %1958
%1960 = call double @llvm.fmuladd.f64(double %1947, double %1956, double %1959)
%1961 = load double*, double** %32
%1962 = load i64, i64* @bigden_.i__
%1963 = getelementptr inbounds double, double* %1961, i64 %1962
store double %1960, double* %1963
br label %1964
1964: ; preds = %1926
%1965 = load i64, i64* @bigden_.i__
%1966 = add nsw i64 %1965, 1
store i64 %1966, i64* @bigden_.i__
br label %1922
1967: ; preds = %1922
%1968 = load i64*, i64** %19
%1969 = load i64, i64* %1968
store i64 %1969, i64* %45
store i64 1, i64* @bigden_.k
br label %1970
1970: ; preds = %2044, %1967
%1971 = load i64, i64* @bigden_.k
%1972 = load i64, i64* %45
%1973 = icmp sle i64 %1971, %1972
br i1 %1973, label %1974, label %2047
1974: ; preds = %1970
%1975 = load double, double* @bigden_.zero
store double %1975, double* @bigden_.sum
%1976 = load i64*, i64** %18
%1977 = load i64, i64* %1976
store i64 %1977, i64* %46
store i64 1, i64* @bigden_.j
br label %1978
1978: ; preds = %1997, %1974
%1979 = load i64, i64* @bigden_.j
%1980 = load i64, i64* %46
%1981 = icmp sle i64 %1979, %1980
br i1 %1981, label %1982, label %2000
1982: ; preds = %1978
%1983 = load double*, double** %21
%1984 = load i64, i64* @bigden_.k
%1985 = load i64, i64* @bigden_.j
%1986 = load i64, i64* %35
%1987 = mul nsw i64 %1985, %1986
%1988 = add nsw i64 %1984, %1987
%1989 = getelementptr inbounds double, double* %1983, i64 %1988
%1990 = load double, double* %1989
%1991 = load double*, double** %29
%1992 = load i64, i64* @bigden_.j
%1993 = getelementptr inbounds double, double* %1991, i64 %1992
%1994 = load double, double* %1993
%1995 = load double, double* @bigden_.sum
%1996 = call double @llvm.fmuladd.f64(double %1990, double %1994, double %1995)
store double %1996, double* @bigden_.sum
br label %1997
1997: ; preds = %1982
%1998 = load i64, i64* @bigden_.j
%1999 = add nsw i64 %1998, 1
store i64 %1999, i64* @bigden_.j
br label %1978
2000: ; preds = %1978
%2001 = load double, double* @bigden_.tau
%2002 = load double*, double** %29
%2003 = load i64*, i64** %18
%2004 = load i64, i64* %2003
%2005 = load i64, i64* @bigden_.k
%2006 = add nsw i64 %2004, %2005
%2007 = getelementptr inbounds double, double* %2002, i64 %2006
%2008 = load double, double* %2007
%2009 = load double, double* @bigden_.alpha
%2010 = load double*, double** %30
%2011 = load i64, i64* @bigden_.k
%2012 = getelementptr inbounds double, double* %2010, i64 %2011
%2013 = load double, double* %2012
%2014 = fmul double %2009, %2013
%2015 = fneg double %2014
%2016 = call double @llvm.fmuladd.f64(double %2001, double %2008, double %2015)
%2017 = load double, double* @bigden_.sum
%2018 = fmul double %2016, %2017
store double %2018, double* @bigden_.temp
%2019 = load i64*, i64** %18
%2020 = load i64, i64* %2019
store i64 %2020, i64* %46
store i64 1, i64* @bigden_.i__
br label %2021
2021: ; preds = %2040, %2000
%2022 = load i64, i64* @bigden_.i__
%2023 = load i64, i64* %46
%2024 = icmp sle i64 %2022, %2023
br i1 %2024, label %2025, label %2043
2025: ; preds = %2021
%2026 = load double, double* @bigden_.temp
%2027 = load double*, double** %21
%2028 = load i64, i64* @bigden_.k
%2029 = load i64, i64* @bigden_.i__
%2030 = load i64, i64* %35
%2031 = mul nsw i64 %2029, %2030
%2032 = add nsw i64 %2028, %2031
%2033 = getelementptr inbounds double, double* %2027, i64 %2032
%2034 = load double, double* %2033
%2035 = load double*, double** %32
%2036 = load i64, i64* @bigden_.i__
%2037 = getelementptr inbounds double, double* %2035, i64 %2036
%2038 = load double, double* %2037
%2039 = call double @llvm.fmuladd.f64(double %2026, double %2034, double %2038)
store double %2039, double* %2037
br label %2040
2040: ; preds = %2025
%2041 = load i64, i64* @bigden_.i__
%2042 = add nsw i64 %2041, 1
store i64 %2042, i64* @bigden_.i__
br label %2021
2043: ; preds = %2021
br label %2044
2044: ; preds = %2043
%2045 = load i64, i64* @bigden_.k
%2046 = add nsw i64 %2045, 1
store i64 %2046, i64* @bigden_.k
br label %1970
2047: ; preds = %1970
%2048 = load double, double* @bigden_.zero
store double %2048, double* @bigden_.ss
%2049 = load double, double* @bigden_.zero
store double %2049, double* @bigden_.ds
%2050 = load i64*, i64** %18
%2051 = load i64, i64* %2050
store i64 %2051, i64* %46
store i64 1, i64* @bigden_.i__
br label %2052
2052: ; preds = %2075, %2047
%2053 = load i64, i64* @bigden_.i__
%2054 = load i64, i64* %46
%2055 = icmp sle i64 %2053, %2054
br i1 %2055, label %2056, label %2078
2056: ; preds = %2052
%2057 = load double*, double** %32
%2058 = load i64, i64* @bigden_.i__
%2059 = getelementptr inbounds double, double* %2057, i64 %2058
%2060 = load double, double* %2059
store double %2060, double* %47
%2061 = load double, double* %47
%2062 = load double, double* %47
%2063 = load double, double* @bigden_.ss
%2064 = call double @llvm.fmuladd.f64(double %2061, double %2062, double %2063)
store double %2064, double* @bigden_.ss
%2065 = load double*, double** %28
%2066 = load i64, i64* @bigden_.i__
%2067 = getelementptr inbounds double, double* %2065, i64 %2066
%2068 = load double, double* %2067
%2069 = load double*, double** %32
%2070 = load i64, i64* @bigden_.i__
%2071 = getelementptr inbounds double, double* %2069, i64 %2070
%2072 = load double, double* %2071
%2073 = load double, double* @bigden_.ds
%2074 = call double @llvm.fmuladd.f64(double %2068, double %2072, double %2073)
store double %2074, double* @bigden_.ds
br label %2075
2075: ; preds = %2056
%2076 = load i64, i64* @bigden_.i__
%2077 = add nsw i64 %2076, 1
store i64 %2077, i64* @bigden_.i__
br label %2052
2078: ; preds = %2052
%2079 = load double, double* @bigden_.dd
%2080 = load double, double* @bigden_.ss
%2081 = load double, double* @bigden_.ds
%2082 = load double, double* @bigden_.ds
%2083 = fmul double %2081, %2082
%2084 = fneg double %2083
%2085 = call double @llvm.fmuladd.f64(double %2079, double %2080, double %2084)
store double %2085, double* @bigden_.ssden
%2086 = load double, double* @bigden_.ssden
%2087 = load double, double* @bigden_.dd
%2088 = fmul double %2087, 1.000000e-08
%2089 = load double, double* @bigden_.ss
%2090 = fmul double %2088, %2089
%2091 = fcmp oge double %2086, %2090
br i1 %2091, label %2092, label %2093
2092: ; preds = %2078
br label %377
2093: ; preds = %2078
br label %2094
2094: ; preds = %2093, %1917, %1892
%2095 = load i64*, i64** %25
%2096 = load i64, i64* %2095
store i64 %2096, i64* %46
store i64 1, i64* @bigden_.k
br label %2097
2097: ; preds = %2131, %2094
%2098 = load i64, i64* @bigden_.k
%2099 = load i64, i64* %46
%2100 = icmp sle i64 %2098, %2099
br i1 %2100, label %2101, label %2134
2101: ; preds = %2097
%2102 = load double, double* @bigden_.zero
%2103 = load double*, double** %29
%2104 = load i64, i64* @bigden_.k
%2105 = getelementptr inbounds double, double* %2103, i64 %2104
store double %2102, double* %2105
store i64 1, i64* @bigden_.j
br label %2106
2106: ; preds = %2127, %2101
%2107 = load i64, i64* @bigden_.j
%2108 = icmp sle i64 %2107, 5
br i1 %2108, label %2109, label %2130
2109: ; preds = %2106
%2110 = load double*, double** %33
%2111 = load i64, i64* @bigden_.k
%2112 = load i64, i64* @bigden_.j
%2113 = load i64, i64* %41
%2114 = mul nsw i64 %2112, %2113
%2115 = add nsw i64 %2111, %2114
%2116 = getelementptr inbounds double, double* %2110, i64 %2115
%2117 = load double, double* %2116
%2118 = load i64, i64* @bigden_.j
%2119 = sub nsw i64 %2118, 1
%2120 = getelementptr inbounds [9 x double], [9 x double]* @bigden_.par, i64 0, i64 %2119
%2121 = load double, double* %2120
%2122 = load double*, double** %29
%2123 = load i64, i64* @bigden_.k
%2124 = getelementptr inbounds double, double* %2122, i64 %2123
%2125 = load double, double* %2124
%2126 = call double @llvm.fmuladd.f64(double %2117, double %2121, double %2125)
store double %2126, double* %2124
br label %2127
2127: ; preds = %2109
%2128 = load i64, i64* @bigden_.j
%2129 = add nsw i64 %2128, 1
store i64 %2129, i64* @bigden_.j
br label %2106
2130: ; preds = %2106
br label %2131
2131: ; preds = %2130
%2132 = load i64, i64* @bigden_.k
%2133 = add nsw i64 %2132, 1
store i64 %2133, i64* @bigden_.k
br label %2097
2134: ; preds = %2097
%2135 = load double, double* @bigden_.one
%2136 = load double*, double** %30
%2137 = load i64*, i64** %26
%2138 = load i64, i64* %2137
%2139 = getelementptr inbounds double, double* %2136, i64 %2138
%2140 = load double, double* %2139
%2141 = fadd double %2140, %2135
store double %2141, double* %2139
ret i32 0
}

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