int biglag_(long int *n, long int *npt, double *xopt, double *xpt, double *bmat,
            double *zmat, long int *idz, long int *ndim, long int *knew,
            double *delta, double *d__, double *alpha, double *hcol, double *gc,
            double *gd, double *s, double *w) {
  long int xpt_dim1, xpt_offset, bmat_dim1, bmat_offset, zmat_dim1, zmat_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, gg;
  static long int iu;
  static double sp, ss, cf1, cf2, cf3, cf4, cf5, dhd, cth, one, tau, sth, sum,
      half, temp, step;
  static long int nptm;
  static double zero, angle, scale, denom;
  static long int iterc, isave;
  static double delsq, tempa, tempb, twopi, taubeg, tauold, taumax;
  zmat_dim1 = *npt;
  zmat_offset = 1 + zmat_dim1;
  zmat -= zmat_offset;
  xpt_dim1 = *npt;
  xpt_offset = 1 + xpt_dim1;
  xpt -= xpt_offset;
  --xopt;
  bmat_dim1 = *ndim;
  bmat_offset = 1 + bmat_dim1;
  bmat -= bmat_offset;
  --d__;
  --hcol;
  --gc;
  --gd;
  --s;
  --w;
  half = .5;
  one = 1.;
  zero = 0.;
  twopi = atan(one) * 8.;
  delsq = *delta * *delta;
  nptm = *npt - *n - 1;
  iterc = 0;
  i__1 = *npt;
  for (k = 1; k <= i__1; ++k) {
    hcol[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) {
      hcol[k] += temp * zmat[k + j * zmat_dim1];
    }
  }
  *alpha = hcol[*knew];
  dd = zero;
  i__2 = *n;
  for (i__ = 1; i__ <= i__2; ++i__) {
    d__[i__] = xpt[*knew + i__ * xpt_dim1] - xopt[i__];
    gc[i__] = bmat[*knew + i__ * bmat_dim1];
    gd[i__] = zero;
    d__1 = d__[i__];
    dd += d__1 * d__1;
  }
  i__2 = *npt;
  for (k = 1; k <= i__2; ++k) {
    temp = zero;
    sum = zero;
    i__1 = *n;
    for (j = 1; j <= i__1; ++j) {
      temp += xpt[k + j * xpt_dim1] * xopt[j];
      sum += xpt[k + j * xpt_dim1] * d__[j];
    }
    temp = hcol[k] * temp;
    sum = hcol[k] * sum;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      gc[i__] += temp * xpt[k + i__ * xpt_dim1];
      gd[i__] += sum * xpt[k + i__ * xpt_dim1];
    }
  }
  gg = zero;
  sp = zero;
  dhd = zero;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    d__1 = gc[i__];
    gg += d__1 * d__1;
    sp += d__[i__] * gc[i__];
    dhd += d__[i__] * gd[i__];
  }
  scale = *delta / sqrt(dd);
  if (sp * dhd < zero) {
    scale = -scale;
  }
  temp = zero;
  if (sp * sp > dd * .99 * gg) {
    temp = one;
  }
  tau = scale * (abs(sp) + half * scale * abs(dhd));
  if (gg * delsq < tau * .01 * tau) {
    temp = one;
  }
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    d__[i__] = scale * d__[i__];
    gd[i__] = scale * gd[i__];
    s[i__] = gc[i__] + temp * gd[i__];
  }
L80:
  ++iterc;
  dd = zero;
  sp = zero;
  ss = zero;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    d__1 = d__[i__];
    dd += d__1 * d__1;
    sp += d__[i__] * s[i__];
    d__1 = s[i__];
    ss += d__1 * d__1;
  }
  temp = dd * ss - sp * sp;
  if (temp <= dd * 1e-8 * ss) {
    goto L160;
  }
  denom = sqrt(temp);
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    s[i__] = (dd * s[i__] - sp * d__[i__]) / denom;
    w[i__] = zero;
  }
  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] * s[j];
    }
    sum = hcol[k] * sum;
    i__2 = *n;
    for (i__ = 1; i__ <= i__2; ++i__) {
      w[i__] += sum * xpt[k + i__ * xpt_dim1];
    }
  }
  cf1 = zero;
  cf2 = zero;
  cf3 = zero;
  cf4 = zero;
  cf5 = zero;
  i__2 = *n;
  for (i__ = 1; i__ <= i__2; ++i__) {
    cf1 += s[i__] * w[i__];
    cf2 += d__[i__] * gc[i__];
    cf3 += s[i__] * gc[i__];
    cf4 += d__[i__] * gd[i__];
    cf5 += s[i__] * gd[i__];
  }
  cf1 = half * cf1;
  cf4 = half * cf4 - cf1;
  taubeg = cf1 + cf2 + cf4;
  taumax = taubeg;
  tauold = taubeg;
  isave = 0;
  iu = 49;
  temp = twopi / (double)(iu + 1);
  i__2 = iu;
  for (i__ = 1; i__ <= i__2; ++i__) {
    angle = (double)i__ * temp;
    cth = cos(angle);
    sth = sin(angle);
    tau = cf1 + (cf2 + cf4 * cth) * cth + (cf3 + cf5 * cth) * sth;
    if (abs(tau) > abs(taumax)) {
      taumax = tau;
      isave = i__;
      tempa = tauold;
    } else if (i__ == isave + 1) {
      tempb = tau;
    }
    tauold = tau;
  }
  if (isave == 0) {
    tempa = tau;
  }
  if (isave == iu) {
    tempb = taubeg;
  }
  step = zero;
  if (tempa != tempb) {
    tempa -= taumax;
    tempb -= taumax;
    step = half * (tempa - tempb) / (tempa + tempb);
  }
  angle = temp * ((double)isave + step);
  cth = cos(angle);
  sth = sin(angle);
  tau = cf1 + (cf2 + cf4 * cth) * cth + (cf3 + cf5 * cth) * sth;
  i__2 = *n;
  for (i__ = 1; i__ <= i__2; ++i__) {
    d__[i__] = cth * d__[i__] + sth * s[i__];
    gd[i__] = cth * gd[i__] + sth * w[i__];
    s[i__] = gc[i__] + gd[i__];
  }
  if (abs(tau) <= abs(taubeg) * 1.1) {
    goto L160;
  }
  if (iterc < *n) {
    goto L80;
  }
L160:
  return 0;
}


x86 assembly (clang, -O0):
<biglag_>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%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,-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    0x40(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rbp)
mov    0x48(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x48(%rbp)
mov    0x50(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x50(%rbp)
mov    0x58(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x58(%rbp)
mov    0x60(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x60(%rbp)
movsd  0x1d88(%rip),%xmm0
movsd  %xmm0,0x3e58(%rip)
movsd  0x1d70(%rip),%xmm0
movsd  %xmm0,0x3e28(%rip)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x3e5d(%rip)
movsd  0x3e15(%rip),%xmm0
call   1050 <atan@plt>
movsd  0x1d40(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x3e84(%rip)
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x28(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,0x3e54(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
sub    (%rcx),%rax
sub    $0x1,%rax
mov    %rax,0x3e03(%rip)
movq   $0x0,0x3e20(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
movq   $0x1,0x3d42(%rip)
mov    0x3d3b(%rip),%rax
cmp    -0x68(%rbp),%rax
jg     135e <biglag_+0x20e>
movsd  0x3dd1(%rip),%xmm0
mov    0x40(%rbp),%rax
mov    0x3d1e(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3d12(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3d07(%rip)
jmp    131e <biglag_+0x1ce>
mov    0x3d9b(%rip),%rax
mov    %rax,-0x68(%rbp)
movq   $0x1,0x3ce4(%rip)
mov    0x3cdd(%rip),%rax
cmp    -0x68(%rbp),%rax
jg     1485 <biglag_+0x335>
mov    -0x30(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x3cc1(%rip),%rdx
imul   -0x58(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x3d44(%rip)
mov    0x3ca5(%rip),%rax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%rax
jge    13e7 <biglag_+0x297>
movsd  0x3d28(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,0x3d09(%rip)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
movq   $0x1,0x3c63(%rip)
mov    0x3c5c(%rip),%rax
cmp    -0x70(%rbp),%rax
jg     1469 <biglag_+0x319>
movsd  0x3cda(%rip),%xmm0
mov    -0x30(%rbp),%rax
mov    0x3c3f(%rip),%rcx
mov    0x3c30(%rip),%rdx
imul   -0x58(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x40(%rbp),%rax
mov    0x3c20(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3c07(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3bfc(%rip)
jmp    13fd <biglag_+0x2ad>
jmp    146e <biglag_+0x31e>
mov    0x3be3(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3bd8(%rip)
jmp    1374 <biglag_+0x224>
mov    0x40(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  0x3c63(%rip),%xmm0
movsd  %xmm0,0x3bbb(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
movq   $0x1,0x3b8d(%rip)
mov    0x3b86(%rip),%rax
cmp    -0x70(%rbp),%rax
jg     15a8 <biglag_+0x458>
mov    -0x20(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x3b6a(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    0x3b52(%rip),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x3b42(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    (%rcx),%rcx
mov    0x3b2b(%rip),%rdx
imul   -0x48(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    0x3b13(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3bbe(%rip),%xmm0
mov    0x50(%rbp),%rax
mov    0x3afb(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x3aeb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  0x3ae7(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3ad7(%rip)
mov    0x3ab8(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3aad(%rip)
jmp    14c3 <biglag_+0x373>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
movq   $0x1,0x3aa2(%rip)
mov    0x3a9b(%rip),%rax
cmp    -0x70(%rbp),%rax
jg     17dd <biglag_+0x68d>
movsd  0x3b31(%rip),%xmm0
movsd  %xmm0,0x3b11(%rip)
movsd  0x3b21(%rip),%xmm0
movsd  %xmm0,0x3af1(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
movq   $0x1,0x3a53(%rip)
mov    0x3a4c(%rip),%rax
cmp    -0x68(%rbp),%rax
jg     16bb <biglag_+0x56b>
mov    -0x20(%rbp),%rax
mov    0x3a3f(%rip),%rcx
mov    0x3a30(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    0x3a18(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3aa3(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3a93(%rip)
mov    -0x20(%rbp),%rax
mov    0x39f8(%rip),%rcx
mov    0x39e9(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x39d1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x3a4c(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3a3c(%rip)
mov    0x39ad(%rip),%rax
add    $0x1,%rax
mov    %rax,0x39a2(%rip)
jmp    1605 <biglag_+0x4b5>
mov    0x40(%rbp),%rax
mov    0x399a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x3a1d(%rip),%xmm0
movsd  %xmm0,0x3a15(%rip)
mov    0x40(%rbp),%rax
mov    0x397a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x39ed(%rip),%xmm0
movsd  %xmm0,0x39e5(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
movq   $0x1,0x393f(%rip)
mov    0x3938(%rip),%rax
cmp    -0x68(%rbp),%rax
jg     17c1 <biglag_+0x671>
movsd  0x39c6(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x392b(%rip),%rcx
mov    0x3914(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
mov    0x38fc(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3972(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x38e7(%rip),%rcx
mov    0x38d0(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x50(%rbp),%rax
mov    0x38b8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x389f(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3894(%rip)
jmp    1711 <biglag_+0x5c1>
jmp    17c6 <biglag_+0x676>
mov    0x3893(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3888(%rip)
jmp    15be <biglag_+0x46e>
movsd  0x3923(%rip),%xmm0
movsd  %xmm0,0x3883(%rip)
movsd  0x3913(%rip),%xmm0
movsd  %xmm0,0x3883(%rip)
movsd  0x3903(%rip),%xmm0
movsd  %xmm0,0x38ab(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
movq   $0x1,0x382d(%rip)
mov    0x3826(%rip),%rax
cmp    -0x68(%rbp),%rax
jg     18f2 <biglag_+0x7a2>
mov    0x48(%rbp),%rax
mov    0x3811(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  0x3815(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3805(%rip)
mov    0x30(%rbp),%rax
mov    0x37da(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    0x37ca(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x37ed(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x37dd(%rip)
mov    0x30(%rbp),%rax
mov    0x37a2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x3792(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x37ed(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x37dd(%rip)
mov    0x376e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3763(%rip)
jmp    1823 <biglag_+0x6d3>
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x3761(%rip),%xmm0
call   1070 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x37f8(%rip)
movsd  0x3758(%rip),%xmm1
mulsd  0x3788(%rip),%xmm1
movsd  0x37d0(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1969 <biglag_+0x819>
movsd  0x37ce(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,0x37af(%rip)
movsd  0x3797(%rip),%xmm0
movsd  %xmm0,0x3777(%rip)
movsd  0x36ff(%rip),%xmm0
mulsd  0x36f7(%rip),%xmm0
movsd  0x1687(%rip),%xmm1
mulsd  0x36cf(%rip),%xmm1
mulsd  0x36cf(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    19bb <biglag_+0x86b>
movsd  0x3715(%rip),%xmm0
movsd  %xmm0,0x3735(%rip)
movsd  0x3755(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
cvttsd2si 0x36ad(%rip),%edi
call   1030 <abs@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x36fc(%rip),%xmm0
mulsd  0x3724(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
cvttsd2si 0x36b4(%rip),%edi
call   1030 <abs@plt>
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x3697(%rip)
movsd  0x362f(%rip),%xmm1
mulsd  0x36ef(%rip),%xmm1
movsd  0x15cf(%rip),%xmm0
mulsd  0x3677(%rip),%xmm0
mulsd  0x366f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a7b <biglag_+0x92b>
movsd  0x3655(%rip),%xmm0
movsd  %xmm0,0x3675(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
movq   $0x1,0x35bf(%rip)
mov    0x35b8(%rip),%rax
cmp    -0x68(%rbp),%rax
jg     1b49 <biglag_+0x9f9>
movsd  0x366e(%rip),%xmm0
mov    0x30(%rbp),%rax
mov    0x359b(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x358b(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3646(%rip),%xmm0
mov    0x50(%rbp),%rax
mov    0x3573(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x3563(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
mov    0x3553(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x35e6(%rip),%xmm0
mov    0x50(%rbp),%rax
mov    0x353b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x58(%rbp),%rax
mov    0x3523(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3517(%rip),%rax
add    $0x1,%rax
mov    %rax,0x350c(%rip)
jmp    1a91 <biglag_+0x941>
jmp    1b4e <biglag_+0x9fe>
mov    0x35d3(%rip),%rax
add    $0x1,%rax
mov    %rax,0x35c8(%rip)
movsd  0x35a0(%rip),%xmm0
movsd  %xmm0,0x34f8(%rip)
movsd  0x3590(%rip),%xmm0
movsd  %xmm0,0x3500(%rip)
movsd  0x3580(%rip),%xmm0
movsd  %xmm0,0x34f8(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
movq   $0x1,0x34aa(%rip)
mov    0x34a3(%rip),%rax
cmp    -0x68(%rbp),%rax
jg     1c74 <biglag_+0xb24>
mov    0x30(%rbp),%rax
mov    0x348e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  0x348a(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x347a(%rip)
mov    0x30(%rbp),%rax
mov    0x3457(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x3447(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x346a(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x345a(%rip)
mov    0x58(%rbp),%rax
mov    0x341f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  0x343b(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x342b(%rip)
mov    0x33ec(%rip),%rax
add    $0x1,%rax
mov    %rax,0x33e1(%rip)
jmp    1ba6 <biglag_+0xa56>
movsd  0x33ec(%rip),%xmm0
movsd  0x3404(%rip),%xmm2
movsd  0x33f4(%rip),%xmm1
mulsd  0x33ec(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x3435(%rip)
movsd  0x342d(%rip),%xmm1
movsd  0x135d(%rip),%xmm0
mulsd  0x3395(%rip),%xmm0
mulsd  0x33ad(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     1cea <biglag_+0xb9a>
jmp    264c <biglag_+0x14fc>
movsd  0x33fe(%rip),%xmm0
call   1070 <sqrt@plt>
movsd  %xmm0,0x3421(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
movq   $0x1,0x333b(%rip)
mov    0x3334(%rip),%rax
cmp    -0x68(%rbp),%rax
jg     1dbc <biglag_+0xc6c>
movsd  0x333a(%rip),%xmm0
mov    0x58(%rbp),%rax
mov    0x3317(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x333a(%rip),%xmm1
mov    0x30(%rbp),%rax
mov    0x32ff(%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
divsd  0x33a3(%rip),%xmm0
mov    0x58(%rbp),%rax
mov    0x32c8(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3373(%rip),%xmm0
mov    0x60(%rbp),%rax
mov    0x32b0(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x32a4(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3299(%rip)
jmp    1d15 <biglag_+0xbc5>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
movq   $0x1,0x328e(%rip)
mov    0x3287(%rip),%rax
cmp    -0x68(%rbp),%rax
jg     1f36 <biglag_+0xde6>
movsd  0x331d(%rip),%xmm0
movsd  %xmm0,0x32ed(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
movq   $0x1,0x324f(%rip)
mov    0x3248(%rip),%rax
cmp    -0x70(%rbp),%rax
jg     1e78 <biglag_+0xd28>
mov    -0x20(%rbp),%rax
mov    0x323b(%rip),%rcx
mov    0x322c(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x3214(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x328f(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x327f(%rip)
mov    0x31f0(%rip),%rax
add    $0x1,%rax
mov    %rax,0x31e5(%rip)
jmp    1e09 <biglag_+0xcb9>
mov    0x40(%rbp),%rax
mov    0x31dd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  0x3250(%rip),%xmm0
movsd  %xmm0,0x3248(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
movq   $0x1,0x31a2(%rip)
mov    0x319b(%rip),%rax
cmp    -0x70(%rbp),%rax
jg     1f1a <biglag_+0xdca>
movsd  0x3219(%rip),%xmm0
mov    -0x20(%rbp),%rax
mov    0x318e(%rip),%rcx
mov    0x3177(%rip),%rdx
imul   -0x38(%rbp),%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
mov    0x315f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3146(%rip),%rax
add    $0x1,%rax
mov    %rax,0x313b(%rip)
jmp    1eae <biglag_+0xd5e>
jmp    1f1f <biglag_+0xdcf>
mov    0x313a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x312f(%rip)
jmp    1dd2 <biglag_+0xc82>
movsd  0x31ca(%rip),%xmm0
movsd  %xmm0,0x314a(%rip)
movsd  0x31ba(%rip),%xmm0
movsd  %xmm0,0x3142(%rip)
movsd  0x31aa(%rip),%xmm0
movsd  %xmm0,0x313a(%rip)
movsd  0x319a(%rip),%xmm0
movsd  %xmm0,0x3132(%rip)
movsd  0x318a(%rip),%xmm0
movsd  %xmm0,0x312a(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
movq   $0x1,0x30b4(%rip)
mov    0x30ad(%rip),%rax
cmp    -0x70(%rbp),%rax
jg     20dc <biglag_+0xf8c>
mov    0x58(%rbp),%rax
mov    0x3098(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x3088(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x30bb(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x30ab(%rip)
mov    0x30(%rbp),%rax
mov    0x3060(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    0x3050(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x308b(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x307b(%rip)
mov    0x58(%rbp),%rax
mov    0x3028(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    0x3018(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x305b(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x304b(%rip)
mov    0x30(%rbp),%rax
mov    0x2ff0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x2fe0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x302b(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x301b(%rip)
mov    0x58(%rbp),%rax
mov    0x2fb8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x2fa8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2ffb(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2feb(%rip)
mov    0x2f84(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2f79(%rip)
jmp    1f9c <biglag_+0xe4c>
movsd  0x3004(%rip),%xmm0
mulsd  0x2fa4(%rip),%xmm0
movsd  %xmm0,0x2f9c(%rip)
movsd  0x2fec(%rip),%xmm0
movsd  0x2fa4(%rip),%xmm2
movsd  0x2f84(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2f75(%rip)
movsd  0x2f55(%rip),%xmm0
addsd  0x2f55(%rip),%xmm0
addsd  0x2f5d(%rip),%xmm0
movsd  %xmm0,0x3005(%rip)
movsd  0x2ffd(%rip),%xmm0
movsd  %xmm0,0x3005(%rip)
movsd  0x2fed(%rip),%xmm0
movsd  %xmm0,0x2fed(%rip)
movq   $0x0,0x2fb2(%rip)
movq   $0x31,0x2eef(%rip)
movsd  0x2fbf(%rip),%xmm0
mov    0x2ee0(%rip),%rax
add    $0x1,%rax
cvtsi2sd %rax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2f43(%rip)
mov    0x2ec4(%rip),%rax
mov    %rax,-0x70(%rbp)
movq   $0x1,0x2e8d(%rip)
mov    0x2e86(%rip),%rax
cmp    -0x70(%rbp),%rax
jg     2341 <biglag_+0x11f1>
cvtsi2sdq 0x2e73(%rip),%xmm0
mulsd  0x2f0b(%rip),%xmm0
movsd  %xmm0,0x2f23(%rip)
movsd  0x2f1b(%rip),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x2ebe(%rip)
movsd  0x2f06(%rip),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x2ec1(%rip)
movsd  0x2e71(%rip),%xmm0
movsd  0x2e71(%rip),%xmm2
movsd  0x2e79(%rip),%xmm1
movsd  0x2e89(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x2e79(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2e49(%rip),%xmm2
movsd  0x2e51(%rip),%xmm0
movsd  0x2e59(%rip),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  0x2e61(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2e49(%rip)
cvttsd2si 0x2e41(%rip),%edi
call   1030 <abs@plt>
mov    %eax,-0x9c(%rbp)
cvttsd2si 0x2ec6(%rip),%edi
call   1030 <abs@plt>
mov    %eax,%ecx
mov    -0x9c(%rbp),%eax
cmp    %ecx,%eax
jle    22ea <biglag_+0x119a>
movsd  0x2e11(%rip),%xmm0
movsd  %xmm0,0x2ea1(%rip)
mov    0x2d82(%rip),%rax
mov    %rax,0x2e5b(%rip)
movsd  0x2e83(%rip),%xmm0
movsd  %xmm0,0x2e5b(%rip)
jmp    231a <biglag_+0x11ca>
mov    0x2d5f(%rip),%rax
mov    0x2e38(%rip),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2315 <biglag_+0x11c5>
movsd  0x2dc3(%rip),%xmm0
movsd  %xmm0,0x2e33(%rip)
jmp    231a <biglag_+0x11ca>
movsd  0x2dae(%rip),%xmm0
movsd  %xmm0,0x2e36(%rip)
mov    0x2d1f(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2d14(%rip)
jmp    21c3 <biglag_+0x1073>
cmpq   $0x0,0x2de7(%rip)
jne    235f <biglag_+0x120f>
movsd  0x2d79(%rip),%xmm0
movsd  %xmm0,0x2de1(%rip)
mov    0x2dca(%rip),%rax
cmp    0x2d0b(%rip),%rax
jne    2383 <biglag_+0x1233>
movsd  0x2ddd(%rip),%xmm0
movsd  %xmm0,0x2dc5(%rip)
movsd  0x2d7d(%rip),%xmm0
movsd  %xmm0,0x2d65(%rip)
movsd  0x2da5(%rip),%xmm0
ucomisd 0x2da5(%rip),%xmm0
jne    23b4 <biglag_+0x1264>
jp     23b4 <biglag_+0x1264>
jmp    2424 <biglag_+0x12d4>
movsd  0x2dac(%rip),%xmm1
movsd  0x2d7c(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x2d70(%rip)
movsd  0x2d90(%rip),%xmm1
movsd  0x2d68(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x2d5c(%rip)
movsd  0x2cf4(%rip),%xmm0
movsd  0x2d44(%rip),%xmm1
subsd  0x2d44(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x2d30(%rip),%xmm1
addsd  0x2d30(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2cd4(%rip)
movsd  0x2cc4(%rip),%xmm0
cvtsi2sdq 0x2cfb(%rip),%xmm1
addsd  0x2cbb(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x2cc7(%rip)
movsd  0x2cbf(%rip),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x2c62(%rip)
movsd  0x2caa(%rip),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x2c65(%rip)
movsd  0x2c15(%rip),%xmm0
movsd  0x2c15(%rip),%xmm2
movsd  0x2c1d(%rip),%xmm1
movsd  0x2c2d(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x2c1d(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2bed(%rip),%xmm2
movsd  0x2bf5(%rip),%xmm0
movsd  0x2bfd(%rip),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
movsd  0x2c05(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2bed(%rip)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
movq   $0x1,0x2b57(%rip)
mov    0x2b50(%rip),%rax
cmp    -0x70(%rbp),%rax
jg     25e1 <biglag_+0x1491>
movsd  0x2bae(%rip),%xmm0
mov    0x30(%rbp),%rax
mov    0x2b33(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2bae(%rip),%xmm1
mov    0x58(%rbp),%rax
mov    0x2b1b(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
mov    0x2b03(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2b66(%rip),%xmm0
mov    0x50(%rbp),%rax
mov    0x2aeb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2b66(%rip),%xmm1
mov    0x60(%rbp),%rax
mov    0x2ad3(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    0x2abb(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
mov    0x2aab(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    0x2a9b(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x2a8b(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2a7f(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2a74(%rip)
jmp    24f9 <biglag_+0x13a9>
cvttsd2si 0x2ae7(%rip),%edi
call   1030 <abs@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
cvttsd2si 0x2b56(%rip),%edi
call   1030 <abs@plt>
movsd  -0xa8(%rbp),%xmm1
ff
cvtsi2sd %eax,%xmm0
movsd  0xa15(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     262e <biglag_+0x14de>
jmp    264c <biglag_+0x14fc>
mov    0x2af3(%rip),%rax
mov    -0x8(%rbp),%rcx
cmp    (%rcx),%rax
jge    2647 <biglag_+0x14f7>
jmp    1b4e <biglag_+0x9fe>
jmp    264c <biglag_+0x14fc>
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<biglag_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,0x28(%rsp)
mov    %r8,0x80(%rsp)
mov    %rcx,0x20(%rsp)
mov    %rdx,%r13
mov    %rsi,%rbp
mov    %rdi,%r15
mov    0x100(%rsp),%rbx
mov    0xe8(%rsp),%r12
mov    0xe0(%rsp),%r14
mov    0xd8(%rsp),%rax
mov    (%rsi),%rcx
mov    %rcx,0x8(%rsp)
mov    (%rax),%rax
mov    %rax,0x88(%rsp)
movabs $0x3fe0000000000000,%rax
mov    %rax,0x3ef8(%rip)
movabs $0x3ff0000000000000,%rax
mov    %rax,0x3edf(%rip)
movsd  0x1e27(%rip),%xmm0
call   1050 <atan@plt>
movabs $0x401921fb54442d18,%rax
21 19 40
mov    %rax,0x3f09(%rip)
movsd  (%r12),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x3edf(%rip)
mov    %rbp,0x90(%rsp)
mov    0x0(%rbp),%rax
mov    %r15,0x70(%rsp)
mov    (%r15),%r11
mov    %rax,%r15
mov    %r11,%rbp
not    %rbp
add    %rax,%rbp
movq   $0x0,0x3ea4(%rip)
test   %rax,%rax
mov    %r11,0x30(%rsp)
jle    124d <biglag_+0xfd>
lea    0x0(,%r15,8),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x30(%rsp),%r11
mov    0x8(%rsp),%r8
mov    %r8,%r12
not    %r12
mov    0xf8(%rsp),%rcx
mov    (%r14),%rax
test   %rbp,%rbp
mov    %r12,0x18(%rsp)
jle    1518 <biglag_+0x3c8>
mov    0xd0(%rsp),%rcx
mov    0x28(%rsp),%rsi
lea    (%rsi,%r12,8),%rdx
mov    (%rcx),%rcx
mov    %rcx,0x50(%rsp)
mov    %rax,0x10(%rsp)
mov    %r8,%rax
mov    %r15,%rdi
sub    %r11,%rdi
lea    (%rbx,%r15,8),%rcx
mov    %rcx,0x38(%rsp)
lea    -0x4(%r15),%rcx
mov    %rcx,0x48(%rsp)
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    %r15,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x78(%rsp)
add    $0x1,%rcx
mov    %rcx,0x68(%rsp)
mov    %rbp,%rcx
mov    %rbp,0x40(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x60(%rsp)
lea    0x30(%rsi),%r8
lea    0x0(,%rax,8),%r9
mov    0x10(%rsp),%rax
lea    0x1(%r15),%r10
mov    $0x1,%r11d
xor    %ecx,%ecx
movapd 0x1d40(%rip),%xmm0
mov    %rsi,%r12
jmp    1327 <biglag_+0x1d7>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r11
add    $0x1,%rcx
add    %r9,%r8
add    %r9,%r12
cmp    %rdi,%r11
je     14f9 <biglag_+0x3a9>
mov    %r11,%r14
imul   0x8(%rsp),%r14
lea    (%rax,%r14,1),%rsi
movsd  (%rdx,%rsi,8),%xmm1
cmp    0x50(%rsp),%r11
jge    1344 <biglag_+0x1f4>
xorpd  %xmm0,%xmm1
test   %r15,%r15
jle    1310 <biglag_+0x1c0>
mov    $0x1,%ebp
cmp    $0x4,%r15
jb     1490 <biglag_+0x340>
mov    0x8(%rsp),%rsi
imul   %rcx,%rsi
mov    %r15,%rbx
add    %rsi,%r15
mov    0x28(%rsp),%rax
lea    (%rax,%r15,8),%rax
mov    %rbx,%r15
mov    0x100(%rsp),%rbx
cmp    %rbx,%rax
mov    0x10(%rsp),%rax
jbe    139e <biglag_+0x24e>
mov    0x28(%rsp),%rax
lea    (%rax,%rsi,8),%rax
cmp    0x38(%rsp),%rax
mov    0x10(%rsp),%rax
jb     1490 <biglag_+0x340>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
cmpq   $0x4,0x48(%rsp)
jae    13b5 <biglag_+0x265>
xor    %ebp,%ebp
jmp    1433 <biglag_+0x2e3>
mov    0x60(%rsp),%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd -0x30(%r8,%rbp,8),%xmm3
movupd -0x20(%r8,%rbp,8),%xmm4
mulpd  %xmm2,%xmm3
movupd (%rbx,%rbp,8),%xmm5
addpd  %xmm3,%xmm5
movupd 0x10(%rbx,%rbp,8),%xmm3
movupd 0x20(%rbx,%rbp,8),%xmm6
movupd 0x30(%rbx,%rbp,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,(%rbx,%rbp,8)
movupd %xmm4,0x10(%rbx,%rbp,8)
movupd -0x10(%r8,%rbp,8),%xmm3
movupd (%r8,%rbp,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,0x20(%rbx,%rbp,8)
movupd %xmm4,0x30(%rbx,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rsi
jne    13c0 <biglag_+0x270>
testb  $0x1,0x40(%rsp)
je     147a <biglag_+0x32a>
or     $0x1,%rbp
lea    (%r14,%rbp,1),%rax
movupd (%rdx,%rax,8),%xmm3
movupd 0x10(%rdx,%rax,8),%xmm4
mov    0x10(%rsp),%rax
movupd -0x8(%rbx,%rbp,8),%xmm5
movupd 0x8(%rbx,%rbp,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,-0x8(%rbx,%rbp,8)
movupd %xmm4,0x8(%rbx,%rbp,8)
mov    0x68(%rsp),%rbp
cmp    0x78(%rsp),%r15
je     1310 <biglag_+0x1c0>
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rsi
test   $0x1,%r15b
je     14b6 <biglag_+0x366>
add    %rbp,%r14
movsd  (%rdx,%r14,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  -0x8(%rbx,%rbp,8),%xmm2
movsd  %xmm2,-0x8(%rbx,%rbp,8)
lea    0x1(%rbp),%rsi
cmp    %rbp,%r15
je     1310 <biglag_+0x1c0>
nop
movsd  -0x8(%r12,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  -0x8(%rbx,%rsi,8),%xmm2
movsd  %xmm2,-0x8(%rbx,%rsi,8)
movsd  (%r12,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rbx,%rsi,8),%xmm2
movsd  %xmm2,(%rbx,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r10
jne    14c0 <biglag_+0x370>
jmp    1310 <biglag_+0x1c0>
movsd  %xmm1,0x3bbf(%rip)
mov    0x8(%rsp),%r8
mov    0x18(%rsp),%r12
mov    0x30(%rsp),%r11
mov    0xf8(%rsp),%rcx
mov    0x108(%rsp),%rbp
mov    0xf0(%rsp),%r9
movsd  -0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rcx)
movq   $0x0,0x3b1b(%rip)
test   %r11,%r11
jle    15da <biglag_+0x48a>
mov    %rax,%rsi
mov    0x20(%rsp),%rax
lea    (%rax,%rsi,8),%rcx
add    $0xfffffffffffffff8,%rcx
lea    0x0(,%r8,8),%rdx
mov    0x80(%rsp),%rax
lea    (%rax,%rsi,8),%rax
add    $0xfffffffffffffff8,%rax
mov    0x88(%rsp),%rdi
shl    $0x3,%rdi
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x110(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm1
subsd  0x0(%r13,%rsi,8),%xmm1
movsd  %xmm1,(%r9,%rsi,8)
movsd  (%rax),%xmm1
movsd  %xmm1,0x0(%rbp,%rsi,8)
movq   $0x0,(%rbx,%rsi,8)
movsd  (%r9,%rsi,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
add    %rdx,%rcx
add    %rdi,%rax
cmp    %rsi,%r11
jne    1590 <biglag_+0x440>
movsd  %xmm0,0x3a80(%rip)
jmp    15e6 <biglag_+0x496>
xorpd  %xmm0,%xmm0
mov    0x110(%rsp),%rbx
mov    0x20(%rsp),%rax
lea    (%rax,%r12,8),%rax
mov    %rax,0x38(%rsp)
test   %r15,%r15
jle    1910 <biglag_+0x7c0>
mov    %r15,%r14
lea    0x0(,%r11,8),%rcx
add    %rbp,%rcx
lea    (%rbx,%r11,8),%rdx
cmp    $0x1,%r11
setne  %sil
cmp    $0x1,%r8
sete   %al
and    %sil,%al
mov    %al,0x50(%rsp)
mov    %rdx,0x28(%rsp)
cmp    %rbp,%rdx
seta   %al
mov    %rcx,0x10(%rsp)
cmp    %rbx,%rcx
seta   %cl
and    %al,%cl
mov    %cl,0x48(%rsp)
mov    %r11,%r12
and    $0xfffffffffffffffe,%r12
mov    %r11,%rax
or     $0x1,%rax
mov    %rax,0x40(%rsp)
mov    %r8,%rsi
shl    $0x4,%rsi
lea    0x0(,%r8,8),%rcx
mov    %r12,%rdi
neg    %rdi
mov    $0x1,%r10d
xor    %r15d,%r15d
xorpd  %xmm1,%xmm1
mov    0x20(%rsp),%r8
jmp    16ab <biglag_+0x55b>
nopl   (%rax)
mov    0x100(%rsp),%rax
movsd  -0x8(%rax,%r10,8),%xmm2
mulsd  %xmm1,%xmm2
lea    0x1(%r10),%rax
add    $0x1,%r15
add    $0x8,%r8
cmp    %r14,%r10
mov    %rax,%r10
je     1903 <biglag_+0x7b3>
test   %r11,%r11
jle    1680 <biglag_+0x530>
cmp    $0x1,%r11
jne    16d0 <biglag_+0x580>
xorpd  %xmm4,%xmm4
mov    $0x1,%ebp
jmp    1735 <biglag_+0x5e5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
mov    $0x1,%ebp
mov    %r8,%rdx
nopl   0x0(%rax)
movsd  (%rdx),%xmm3
unpcklpd %xmm3,%xmm3
movsd  -0x8(%r13,%rbp,8),%xmm5
movsd  0x0(%r13,%rbp,8),%xmm4
movhpd -0x8(%r9,%rbp,8),%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm2,%xmm5
movsd  (%rdx,%rcx,1),%xmm2
unpcklpd %xmm2,%xmm2
movhpd (%r9,%rbp,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
add    %rsi,%rdx
lea    (%rdi,%rbp,1),%rax
add    $0x2,%rax
add    $0x2,%rbp
movapd %xmm4,%xmm2
cmp    $0x1,%rax
jne    16e0 <biglag_+0x590>
test   $0x1,%r11b
je     176b <biglag_+0x61b>
mov    %rbp,%rax
imul   0x8(%rsp),%rax
add    %r10,%rax
mov    0x38(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm2
unpcklpd %xmm2,%xmm2
movsd  -0x8(%r13,%rbp,8),%xmm3
movhpd -0x8(%r9,%rbp,8),%xmm3
mulpd  %xmm2,%xmm3
addpd  %xmm3,%xmm4
mov    0x100(%rsp),%rax
movsd  -0x8(%rax,%r10,8),%xmm3
movapd %xmm3,%xmm2
mulsd  %xmm4,%xmm2
test   %r11,%r11
jle    1870 <biglag_+0x720>
unpckhpd %xmm4,%xmm4
mulsd  %xmm4,%xmm3
mov    $0x1,%r9d
cmpb   $0x0,0x50(%rsp)
je     1890 <biglag_+0x740>
lea    (%r11,%r15,1),%rax
mov    0x20(%rsp),%rbp
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
cmp    0x108(%rsp),%rax
seta   %dl
lea    0x0(%rbp,%r15,8),%rbp
cmp    0x10(%rsp),%rbp
setb   %r11b
and    %dl,%r11b
or     0x48(%rsp),%r11b
cmp    %rbx,%rax
seta   %dl
cmp    0x28(%rsp),%rbp
setb   %bpl
test   %r11b,%r11b
jne    187d <biglag_+0x72d>
and    %bpl,%dl
mov    0x30(%rsp),%r11
jne    1890 <biglag_+0x740>
movapd %xmm2,%xmm4
unpcklpd %xmm2,%xmm4
movapd %xmm3,%xmm5
unpcklpd %xmm3,%xmm5
mov    %r8,%rdx
xor    %ebp,%ebp
mov    0x108(%rsp),%rax
nopl   0x0(%rax)
movupd (%rdx),%xmm6
mulpd  %xmm4,%xmm6
movupd (%rax,%rbp,8),%xmm7
addpd  %xmm6,%xmm7
movupd %xmm7,(%rax,%rbp,8)
movupd (%rdx),%xmm6
mulpd  %xmm5,%xmm6
movupd (%rbx,%rbp,8),%xmm7
addpd  %xmm6,%xmm7
movupd %xmm7,(%rbx,%rbp,8)
add    $0x2,%rbp
add    %rsi,%rdx
cmp    %rbp,%r12
jne    1820 <biglag_+0x6d0>
mov    0x40(%rsp),%r9
cmp    %r12,%r11
jne    1890 <biglag_+0x740>
mov    0x108(%rsp),%rbp
jmp    18f6 <biglag_+0x7a6>
nop
mov    0x108(%rsp),%rbp
jmp    1693 <biglag_+0x543>
mov    0x30(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%rax
imul   %r9,%rax
add    $0xffffffffffffffff,%r9
add    %r10,%rax
mov    0x38(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    0x108(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx),%xmm4
mulsd  %xmm2,%xmm4
addsd  0x0(%rbp,%r9,8),%xmm4
movsd  %xmm4,0x0(%rbp,%r9,8)
movsd  (%rdx),%xmm4
mulsd  %xmm3,%xmm4
addsd  (%rbx,%r9,8),%xmm4
movsd  %xmm4,(%rbx,%r9,8)
add    $0x1,%r9
add    %rcx,%rdx
cmp    %r9,%r11
jne    18c0 <biglag_+0x770>
mov    0xf0(%rsp),%r9
jmp    1693 <biglag_+0x543>
movsd  %xmm2,0x37b5(%rip)
mov    0x18(%rsp),%r12
movq   $0x0,0x3745(%rip)
movq   $0x0,0x374a(%rip)
movq   $0x0,0x376f(%rip)
test   %r11,%r11
jle    194e <biglag_+0x7fe>
cmp    $0x1,%r11
jne    1959 <biglag_+0x809>
xorpd  %xmm2,%xmm2
xorpd  %xmm1,%xmm1
mov    $0x1,%eax
jmp    19de <biglag_+0x88e>
mov    $0x1,%r11d
jmp    1a2b <biglag_+0x8db>
mov    %r11,%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
xorpd  %xmm4,%xmm4
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
movsd  -0x8(%r9,%rax,8),%xmm5
movsd  (%r9,%rax,8),%xmm1
movsd  -0x8(%rbp,%rax,8),%xmm6
movsd  0x0(%rbp,%rax,8),%xmm2
movapd %xmm6,%xmm7
unpcklpd %xmm5,%xmm7
unpcklpd %xmm6,%xmm6
mulpd  %xmm7,%xmm6
mulsd  -0x8(%rbx,%rax,8),%xmm5
addpd  %xmm4,%xmm6
addsd  %xmm3,%xmm5
movapd %xmm2,%xmm3
unpcklpd %xmm1,%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm6,%xmm2
mulsd  (%rbx,%rax,8),%xmm1
addsd  %xmm5,%xmm1
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
movapd %xmm1,%xmm3
movapd %xmm2,%xmm4
cmp    $0x1,%rdx
jne    1970 <biglag_+0x820>
test   $0x1,%r11b
je     1a0f <biglag_+0x8bf>
movsd  -0x8(%r9,%rax,8),%xmm3
movsd  -0x8(%rbp,%rax,8),%xmm4
movapd %xmm4,%xmm5
unpcklpd %xmm3,%xmm5
unpcklpd %xmm4,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm4,%xmm2
mulsd  -0x8(%rbx,%rax,8),%xmm3
addsd  %xmm3,%xmm1
add    $0x1,%r11
movlpd %xmm2,0x3645(%rip)
movhpd %xmm2,0x364d(%rip)
movsd  %xmm1,0x3675(%rip)
mov    %r11,0x361e(%rip)
mov    0xe8(%rsp),%rax
movsd  (%rax),%xmm4
xorpd  %xmm5,%xmm5
ucomisd %xmm5,%xmm0
jb     1a4e <biglag_+0x8fe>
sqrtsd %xmm0,%xmm0
jmp    1a6b <biglag_+0x91b>
movapd %xmm4,0x50(%rsp)
call   1070 <sqrt@plt>
xorpd  %xmm5,%xmm5
movapd 0x50(%rsp),%xmm4
mov    0xf0(%rsp),%r9
divsd  %xmm0,%xmm4
movsd  0x35f9(%rip),%xmm1
movsd  0x3621(%rip),%xmm3
movapd %xmm1,%xmm0
mulsd  %xmm3,%xmm0
movapd 0x15b1(%rip),%xmm2
xorpd  %xmm4,%xmm2
cmpltsd %xmm5,%xmm0
andpd  %xmm0,%xmm2
andnpd %xmm4,%xmm0
orpd   %xmm2,%xmm0
cvttsd2si %xmm1,%eax
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
xorps  %xmm4,%xmm4
cvtsi2sd %ecx,%xmm4
movsd  0x35a2(%rip),%xmm2
movsd  0x35f2(%rip),%xmm5
cvttsd2si %xmm3,%eax
mulsd  %xmm0,%xmm5
mov    %eax,%ecx
neg    %ecx
cmovs  %eax,%ecx
xorps  %xmm3,%xmm3
cvtsi2sd %ecx,%xmm3
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm0,%xmm3
movsd  0x35f0(%rip),%xmm4
mulsd  %xmm2,%xmm4
movsd  0x1514(%rip),%xmm5
mulsd  %xmm3,%xmm5
mulsd  %xmm3,%xmm5
ucomisd %xmm4,%xmm5
jbe    1b1c <biglag_+0x9cc>
movsd  0x359e(%rip),%xmm1
movsd  %xmm1,0x35a6(%rip)
jmp    1b45 <biglag_+0x9f5>
mulsd  %xmm1,%xmm1
movsd  0x3530(%rip),%xmm3
mulsd  0x14d8(%rip),%xmm3
mulsd  %xmm2,%xmm3
cmpltsd %xmm1,%xmm3
movsd  0x356f(%rip),%xmm1
andpd  %xmm3,%xmm1
mov    0x70(%rsp),%rax
mov    (%rax),%rax
test   %rax,%rax
jle    1be4 <biglag_+0xa94>
mov    $0x1,%ecx
cmp    $0x1,%rax
jne    2723 <biglag_+0x15d3>
mov    0x110(%rsp),%rbx
mov    0x108(%rsp),%rbp
mov    %rax,%rdx
sub    %rcx,%rdx
add    $0x1,%rdx
lea    (%r9,%rcx,8),%rsi
add    $0xfffffffffffffff8,%rsi
lea    -0x8(%rbp,%rcx,8),%rdi
mov    0x118(%rsp),%rbp
lea    -0x8(%rbp,%rcx,8),%rbp
lea    (%rbx,%rcx,8),%rcx
add    $0xfffffffffffffff8,%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rsi,%rbx,8)
movsd  (%rcx,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rcx,%rbx,8)
mulsd  %xmm1,%xmm2
addsd  (%rdi,%rbx,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1bb0 <biglag_+0xa60>
mov    0x120(%rsp),%r13
mov    0x34dd(%rip),%rcx
mov    0x8(%rsp),%rsi
mov    %rsi,%rdx
shl    $0x4,%rdx
mov    %rdx,0x48(%rsp)
mov    0x20(%rsp),%rdx
lea    0x10(%rdx),%rdi
mov    %rdi,0x60(%rsp)
mov    %rsi,%rdi
shl    $0x5,%rdi
mov    %rdi,0x68(%rsp)
lea    (%rdx,%r12,8),%rdx
add    $0x8,%rdx
mov    %rdx,0x18(%rsp)
lea    (%rsi,%rsi,1),%rdx
mov    %rdx,0x28(%rsp)
xorps  %xmm8,%xmm8
mov    0x118(%rsp),%rbp
add    $0x1,%rcx
mov    %rcx,0x3485(%rip)
movq   $0x0,0x3402(%rip)
movq   $0x0,0x340f(%rip)
test   %rax,%rax
jle    1c90 <biglag_+0xb40>
cmp    $0x1,%rax
jne    1cb0 <biglag_+0xb60>
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
mov    $0x1,%ecx
test   $0x1,%al
jne    1d3f <biglag_+0xbef>
jmp    1d68 <biglag_+0xc18>
cs nopw 0x0(%rax,%rax,1)
mov    $0x1,%eax
xorpd  %xmm1,%xmm1
xorpd  %xmm2,%xmm2
jmp    1d7c <biglag_+0xc2c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r9,%rcx,8),%xmm4
movsd  (%r9,%rcx,8),%xmm5
movapd %xmm4,%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm1,%xmm6
movsd  -0x8(%rbp,%rcx,8),%xmm3
movsd  0x0(%rbp,%rcx,8),%xmm2
unpcklpd %xmm3,%xmm4
unpcklpd %xmm3,%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm0,%xmm3
movapd %xmm5,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm6,%xmm1
unpcklpd %xmm2,%xmm5
unpcklpd %xmm2,%xmm2
mulpd  %xmm5,%xmm2
movapd %xmm2,%xmm0
addpd  %xmm3,%xmm0
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    1cd0 <biglag_+0xb80>
addpd  %xmm3,%xmm2
test   $0x1,%al
je     1d68 <biglag_+0xc18>
movsd  -0x8(%r9,%rcx,8),%xmm3
movapd %xmm3,%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
movsd  -0x8(%rbp,%rcx,8),%xmm2
unpcklpd %xmm2,%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
add    $0x1,%rax
movsd  %xmm1,0x32e4(%rip)
movlpd %xmm2,0x32f4(%rip)
mov    %rax,0x32cd(%rip)
movapd %xmm2,%xmm3
mulsd  %xmm2,%xmm3
unpckhpd %xmm2,%xmm2
movapd %xmm1,%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,0x331d(%rip)
mulsd  0x126d(%rip),%xmm1
mulsd  %xmm2,%xmm1
ucomisd %xmm0,%xmm1
jae    270f <biglag_+0x15bf>
ucomisd 0x126f(%rip),%xmm0
jb     1dd0 <biglag_+0xc80>
sqrtsd %xmm0,%xmm0
jmp    1de1 <biglag_+0xc91>
nopl   0x0(%rax)
call   1070 <sqrt@plt>
xorps  %xmm8,%xmm8
mov    0xf0(%rsp),%r9
mov    0x70(%rsp),%rax
mov    (%rax),%r14
test   %r14,%r14
jle    1e54 <biglag_+0xd04>
movsd  0x3262(%rip),%xmm1
movsd  0x3272(%rip),%xmm2
xorpd  0x123a(%rip),%xmm2
mov    $0x1,%eax
cmp    $0x1,%r14
jne    25c0 <biglag_+0x1470>
add    $0xffffffffffffffff,%rax
nopl   0x0(%rax)
movsd  (%r9,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  0x0(%rbp,%rax,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
divsd  %xmm0,%xmm4
movsd  %xmm4,0x0(%rbp,%rax,8)
movq   $0x0,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%r14
jne    1e20 <biglag_+0xcd0>
mov    0x90(%rsp),%rax
mov    (%rax),%rax
mov    %rax,0x50(%rsp)
test   %rax,%rax
jle    2100 <biglag_+0xfb0>
cmpq   $0x1,0x8(%rsp)
sete   %al
lea    0x0(,%r14,8),%rcx
add    %r13,%rcx
mov    %rcx,0x40(%rsp)
cmp    $0x4,%r14
setae  %cl
and    %al,%cl
mov    %cl,0x30(%rsp)
mov    %r14,%r11
and    $0xfffffffffffffffc,%r11
lea    0x1(%r11),%rax
mov    %rax,0x78(%rsp)
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
neg    %rax
lea    0x1(%r14),%r12
mov    $0x1,%r10d
mov    0x18(%rsp),%rbp
mov    0x60(%rsp),%rcx
mov    0x20(%rsp),%r8
xor    %r9d,%r9d
mov    %r11,0x10(%rsp)
jmp    1ef2 <biglag_+0xda2>
lea    0x1(%r10),%rsi
add    $0x1,%r9
add    $0x8,%r8
add    $0x8,%rcx
add    $0x8,%rbp
cmp    0x50(%rsp),%r10
mov    %rsi,%r10
je     2100 <biglag_+0xfb0>
test   %r14,%r14
jle    1ed0 <biglag_+0xd80>
mov    %r14,%rdx
xorpd  %xmm0,%xmm0
mov    $0x1,%r11d
cmp    $0x1,%r14
jne    1f20 <biglag_+0xdd0>
mov    0x8(%rsp),%rdi
jmp    1f73 <biglag_+0xe23>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r8,%rsi
mov    0x8(%rsp),%rdi
mov    0x48(%rsp),%r15
mov    0x118(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rsi),%xmm1
mulsd  -0x8(%r14,%r11,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rsi,%rdi,8),%xmm0
mulsd  (%r14,%r11,8),%xmm0
addsd  %xmm1,%xmm0
add    %r15,%rsi
lea    (%rax,%r11,1),%rbx
add    $0x2,%rbx
add    $0x2,%r11
cmp    $0x1,%rbx
jne    1f40 <biglag_+0xdf0>
mov    %rdx,%r14
test   $0x1,%r14b
mov    0x28(%rsp),%rdx
je     1fa8 <biglag_+0xe58>
mov    %r11,%rsi
imul   %rdi,%rsi
add    %r10,%rsi
mov    0x38(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm1
mov    0x118(%rsp),%rsi
mulsd  -0x8(%rsi,%r11,8),%xmm1
addsd  %xmm1,%xmm0
test   %r14,%r14
mov    0x10(%rsp),%r11
jle    1ed0 <biglag_+0xd80>
mov    0x100(%rsp),%rsi
mulsd  -0x8(%rsi,%r10,8),%xmm0
mov    $0x1,%edi
cmpb   $0x0,0x30(%rsp)
je     2060 <biglag_+0xf10>
lea    (%r14,%r9,1),%rbx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rbx,8),%rbx
cmp    %r13,%rbx
jbe    1ff7 <biglag_+0xea7>
mov    0x20(%rsp),%rsi
lea    (%rsi,%r9,8),%rbx
cmp    0x40(%rsp),%rbx
jb     2060 <biglag_+0xf10>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %rcx,%rsi
xor    %ebx,%ebx
mov    0x68(%rsp),%rdi
nopl   0x0(%rax)
movupd -0x10(%rsi),%xmm2
movupd (%rsi),%xmm3
movupd 0x0(%r13,%rbx,8),%xmm4
movupd 0x10(%r13,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,0x0(%r13,%rbx,8)
movupd %xmm3,0x10(%r13,%rbx,8)
add    $0x4,%rbx
add    %rdi,%rsi
cmp    %rbx,%r11
jne    2010 <biglag_+0xec0>
mov    0x78(%rsp),%rdi
cmp    %r11,%r14
je     1ed0 <biglag_+0xd80>
nop
mov    %rdi,%rbx
test   $0x1,%r14b
je     2095 <biglag_+0xf45>
mov    %rdi,%rsi
imul   0x8(%rsp),%rsi
add    %r10,%rsi
mov    0x38(%rsp),%rbx
movsd  (%rbx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r13,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%r13,%rdi,8)
lea    0x1(%rdi),%rbx
cmp    %rdi,%r14
je     1ed0 <biglag_+0xd80>
mov    0x8(%rsp),%rsi
imul   %rbx,%rsi
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r13,%rbx,8),%xmm1
movsd  %xmm1,-0x8(%r13,%rbx,8)
movsd  (%r8,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x0(%r13,%rbx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rbx,8)
add    $0x2,%rbx
add    %rdx,%rsi
cmp    %rbx,%r12
jne    20b0 <biglag_+0xf60>
jmp    1ed0 <biglag_+0xd80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,0x2f75(%rip)
movq   $0x0,0x2f72(%rip)
movq   $0x0,0x2f77(%rip)
test   %r14,%r14
jle    21e0 <biglag_+0x1090>
xorpd  %xmm4,%xmm4
xorpd  %xmm2,%xmm2
xor    %eax,%eax
xorpd  %xmm0,%xmm0
mov    0x110(%rsp),%rbx
mov    0x108(%rsp),%r15
mov    0xf0(%rsp),%rcx
mov    0x118(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movapd %xmm4,%xmm3
movsd  0x0(%rbp,%rax,8),%xmm5
movapd %xmm5,%xmm4
unpcklpd %xmm5,%xmm4
movsd  (%r15,%rax,8),%xmm1
movsd  0x0(%r13,%rax,8),%xmm6
unpcklpd %xmm1,%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm6,%xmm0
movsd  (%rbx,%rax,8),%xmm6
movsd  (%rcx,%rax,8),%xmm4
unpcklpd %xmm4,%xmm4
unpcklpd %xmm6,%xmm1
mulpd  %xmm4,%xmm1
movapd %xmm1,%xmm4
addpd  %xmm3,%xmm4
mulsd  %xmm6,%xmm5
addsd  %xmm5,%xmm2
add    $0x1,%rax
cmp    %rax,%r14
jne    2160 <biglag_+0x1010>
addpd  %xmm3,%xmm1
movlpd %xmm1,0x2eba(%rip)
movhpd %xmm0,0x2eba(%rip)
movsd  %xmm2,0x2ec2(%rip)
jmp    2200 <biglag_+0x10b0>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
mov    0x110(%rsp),%rbx
mov    0x108(%rsp),%r15
mov    0x118(%rsp),%rbp
movsd  0x2eb0(%rip),%xmm2
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x2e64(%rip)
movapd %xmm1,%xmm3
unpckhpd %xmm1,%xmm3
mulsd  %xmm2,%xmm3
subsd  %xmm0,%xmm3
movsd  %xmm3,0x2e64(%rip)
addsd  %xmm1,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,0x2ec4(%rip)
movsd  %xmm0,0x2ecc(%rip)
movsd  %xmm0,0x2ebc(%rip)
movq   $0x0,0x2e81(%rip)
movb   $0x1,0x2e0a(%rip)
movsd  0x2e92(%rip),%xmm1
divsd  0xdb2(%rip),%xmm1
movsd  %xmm1,0x2e4a(%rip)
movq   $0x1,0x2dcf(%rip)
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %rdx,%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x2e24(%rip)
call   1060 <cos@plt>
movsd  %xmm0,0x2df7(%rip)
movsd  0x2e0f(%rip),%xmm0
call   1040 <sin@plt>
movsd  0x2de2(%rip),%xmm1
movsd  0x2dc2(%rip),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x2da6(%rip),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x2d92(%rip),%xmm2
mulsd  0x2daa(%rip),%xmm1
addsd  0x2d92(%rip),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  0x2e0a(%rip),%xmm0
movapd %xmm1,%xmm2
unpcklpd %xmm0,%xmm2
cvttpd2dq %xmm2,%xmm2
movapd %xmm2,%xmm3
psrad  $0x1f,%xmm3
paddd  %xmm3,%xmm2
pxor   %xmm3,%xmm2
movd   %xmm2,%eax
pshufd $0x55,%xmm2,%xmm2
movd   %xmm2,%ecx
cmp    %ecx,%eax
jbe    2370 <biglag_+0x1220>
movsd  %xmm1,0x2dd4(%rip)
mov    0x2d0d(%rip),%rax
mov    %rax,0x2d8e(%rip)
movsd  0x2db6(%rip),%xmm0
movsd  %xmm0,0x2d8e(%rip)
movapd %xmm1,%xmm0
mov    %rax,%rcx
jmp    238f <biglag_+0x123f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x2cd9(%rip),%rcx
mov    0x2d5a(%rip),%rax
lea    0x1(%rax),%rdx
cmp    %rdx,%rcx
jne    238f <biglag_+0x123f>
movsd  %xmm1,0x2d61(%rip)
movsd  %xmm1,0x2d71(%rip)
lea    0x1(%rcx),%rdx
mov    %rdx,0x2cae(%rip)
cmp    $0x30,%rcx
jg     23c0 <biglag_+0x1270>
movsd  0x2d10(%rip),%xmm1
jmp    2290 <biglag_+0x1140>
cs nopw 0x0(%rax,%rax,1)
nop
test   %rax,%rax
jne    23cd <biglag_+0x127d>
movsd  %xmm1,0x2d1b(%rip)
cmpb   $0x0,0x2c94(%rip)
mov    $0x0,%ecx
mov    $0x31,%edx
cmovne %rdx,%rcx
cmp    %rcx,%rax
jne    2400 <biglag_+0x12b0>
movsd  0x2d11(%rip),%xmm1
movsd  %xmm1,0x2cf9(%rip)
jmp    2408 <biglag_+0x12b8>
nopl   0x0(%rax)
movsd  0x2ce8(%rip),%xmm1
movsd  0x2cd8(%rip),%xmm2
ucomisd %xmm1,%xmm2
jne    2418 <biglag_+0x12c8>
jnp    2450 <biglag_+0x1300>
subsd  %xmm0,%xmm2
movsd  %xmm2,0x2cc4(%rip)
subsd  %xmm0,%xmm1
movsd  %xmm1,0x2cc0(%rip)
movapd %xmm2,%xmm3
subsd  %xmm1,%xmm3
mulsd  0x2c78(%rip),%xmm3
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm3
jmp    2454 <biglag_+0x1304>
nopw   0x0(%rax,%rax,1)
pxor   %xmm3,%xmm3
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
addsd  %xmm3,%xmm0
mulsd  0x2c58(%rip),%xmm0
movsd  %xmm0,0x2c58(%rip)
call   1060 <cos@plt>
movsd  %xmm0,0x2c2b(%rip)
movsd  0x2c43(%rip),%xmm0
call   1040 <sin@plt>
movsd  0x2c16(%rip),%xmm3
movsd  0x2bf6(%rip),%xmm1
mulsd  %xmm3,%xmm1
addsd  0x2bda(%rip),%xmm1
mulsd  %xmm3,%xmm1
addsd  0x2bc6(%rip),%xmm1
movsd  0x2bde(%rip),%xmm2
mulsd  %xmm3,%xmm2
addsd  0x2bc2(%rip),%xmm2
mov    0x70(%rsp),%rax
mov    (%rax),%rax
test   %rax,%rax
jle    2550 <biglag_+0x1400>
lea    0x1(%rax),%rcx
xor    %edx,%edx
mov    0xf0(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm4
mulsd  %xmm0,%xmm4
movsd  (%r9,%rdx,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%r9,%rdx,8)
movsd  0x0(%r13,%rdx,8),%xmm4
mulsd  %xmm0,%xmm4
movsd  (%rbx,%rdx,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%rbx,%rdx,8)
addsd  (%r15,%rdx,8),%xmm5
movsd  %xmm5,0x0(%rbp,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    24f0 <biglag_+0x13a0>
jmp    255d <biglag_+0x140d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x1,%ecx
mov    0xf0(%rsp),%r9
xorps  %xmm8,%xmm8
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
cvttsd2si %xmm2,%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
cvttsd2si 0x2b7d(%rip),%edx
mov    %edx,%esi
neg    %esi
cmovs  %edx,%esi
xorps  %xmm1,%xmm1
cvtsi2sd %esi,%xmm1
mov    %rcx,0x2ab8(%rip)
mulsd  0xa88(%rip),%xmm1
ucomisd %xmm0,%xmm1
jae    270f <biglag_+0x15bf>
mov    0x2b1f(%rip),%rcx
cmp    %rax,%rcx
jl     1c40 <biglag_+0xaf0>
jmp    270f <biglag_+0x15bf>
nop
lea    0x0(,%r14,8),%rsi
add    %r13,%rsi
cmp    %rbp,%rsi
seta   %r8b
lea    0x0(,%r14,8),%rdx
add    %rbp,%rdx
cmp    %r13,%rdx
seta   %bl
lea    (%r9,%r14,8),%rdi
cmp    %rbp,%rdi
seta   %cl
cmp    %r9,%rdx
seta   %r10b
cmp    %r13,%rdi
seta   %dl
cmp    %r9,%rsi
seta   %sil
test   %bl,%r8b
jne    1e15 <biglag_+0xcc5>
and    %r10b,%cl
jne    1e15 <biglag_+0xcc5>
and    %sil,%dl
jne    1e15 <biglag_+0xcc5>
mov    %r14,%rax
and    $0xfffffffffffffffe,%rax
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
lea    -0x2(%rax),%rcx
mov    %rcx,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2706 <biglag_+0x15b6>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rcx,8),%xmm6
movupd (%r9,%rcx,8),%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm3,%xmm6
addpd  %xmm7,%xmm6
divpd  %xmm4,%xmm6
movupd %xmm6,0x0(%rbp,%rcx,8)
movups %xmm8,0x0(%r13,%rcx,8)
movupd 0x10(%rbp,%rcx,8),%xmm6
movupd 0x10(%r9,%rcx,8),%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm3,%xmm6
addpd  %xmm7,%xmm6
divpd  %xmm4,%xmm6
movupd %xmm6,0x10(%rbp,%rcx,8)
movups %xmm8,0x10(%r13,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rdi
jne    2660 <biglag_+0x1510>
test   $0x1,%dl
je     26f1 <biglag_+0x15a1>
shl    $0x3,%rcx
or     $0x8,%rcx
movupd -0x8(%rbp,%rcx,1),%xmm6
movupd -0x8(%r9,%rcx,1),%xmm7
mulpd  %xmm5,%xmm7
mulpd  %xmm6,%xmm3
addpd  %xmm7,%xmm3
divpd  %xmm4,%xmm3
movupd %xmm3,-0x8(%rbp,%rcx,1)
movups %xmm8,-0x8(%r13,%rcx,1)
cmp    %rax,%r14
je     1e54 <biglag_+0xd04>
mov    %r14,%rax
or     $0x1,%rax
jmp    1e15 <biglag_+0xcc5>
xor    %ecx,%ecx
test   $0x1,%dl
jne    26c0 <biglag_+0x1570>
jmp    26f1 <biglag_+0x15a1>
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x110(%rsp),%r8
lea    (%r8,%rax,8),%rbp
cmp    %r9,%rbp
seta   0x50(%rsp)
lea    (%r9,%rax,8),%rsi
cmp    %r8,%rsi
seta   %r13b
mov    0x118(%rsp),%r15
lea    (%r15,%rax,8),%rdi
cmp    %r9,%rdi
seta   %r10b
cmp    %r15,%rsi
mov    %r9,%rdx
seta   %r9b
mov    0x108(%rsp),%r11
lea    (%r11,%rax,8),%rbx
cmp    %rdx,%rbx
seta   %r12b
cmp    %r11,%rsi
seta   %dl
cmp    %r8,%rdi
seta   %sil
cmp    %r15,%rbp
seta   0x10(%rsp)
cmp    %r8,%rbx
seta   %r14b
cmp    %r11,%rbp
seta   %bpl
cmp    %r15,%rbx
seta   %r8b
cmp    %r11,%rdi
seta   %dil
test   %r13b,0x50(%rsp)
jne    292e <biglag_+0x17de>
and    %r9b,%r10b
mov    0x110(%rsp),%rbx
jne    2936 <biglag_+0x17e6>
and    %dl,%r12b
mov    0xf0(%rsp),%r9
jne    291c <biglag_+0x17cc>
and    0x10(%rsp),%sil
mov    0x18(%rsp),%r12
jne    1b6d <biglag_+0xa1d>
and    %bpl,%r14b
jne    1b6d <biglag_+0xa1d>
and    %dil,%r8b
mov    0x108(%rsp),%rbp
jne    1b75 <biglag_+0xa25>
mov    %rax,%r8
and    $0xfffffffffffffffe,%r8
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
lea    -0x2(%r8),%rdx
mov    %rdx,%rsi
shr    %rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     290f <biglag_+0x17bf>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x1,%edx
mov    0x118(%rsp),%rcx
nopl   0x0(%rax)
movupd -0x8(%r9,%rdx,8),%xmm4
mulpd  %xmm3,%xmm4
movupd %xmm4,-0x8(%r9,%rdx,8)
movupd -0x8(%rbx,%rdx,8),%xmm4
mulpd  %xmm3,%xmm4
movupd %xmm4,-0x8(%rbx,%rdx,8)
movupd -0x8(%rbp,%rdx,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,-0x8(%rcx,%rdx,8)
movupd 0x8(%r9,%rdx,8),%xmm4
mulpd  %xmm3,%xmm4
movupd %xmm4,0x8(%r9,%rdx,8)
movupd 0x8(%rbx,%rdx,8),%xmm4
mulpd  %xmm3,%xmm4
movupd %xmm4,0x8(%rbx,%rdx,8)
movupd 0x8(%rbp,%rdx,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,0x8(%rcx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rdi
jne    2840 <biglag_+0x16f0>
test   $0x1,%sil
je     28fa <biglag_+0x17aa>
movupd -0x8(%r9,%rdx,8),%xmm4
mulpd  %xmm3,%xmm4
movupd %xmm4,-0x8(%r9,%rdx,8)
movupd -0x8(%rbx,%rdx,8),%xmm4
mulpd  %xmm3,%xmm4
movupd %xmm4,-0x8(%rbx,%rdx,8)
movupd -0x8(%rbp,%rdx,8),%xmm3
mulpd  %xmm4,%xmm2
addpd  %xmm3,%xmm2
mov    0x118(%rsp),%rcx
movupd %xmm2,-0x8(%rcx,%rdx,8)
cmp    %r8,%rax
je     1be4 <biglag_+0xa94>
mov    %rax,%rcx
or     $0x1,%rcx
jmp    1b65 <biglag_+0xa15>
mov    $0x1,%edx
test   $0x1,%sil
jne    28bc <biglag_+0x176c>
jmp    28fa <biglag_+0x17aa>
mov    0x108(%rsp),%rbp
mov    0x18(%rsp),%r12
jmp    1b75 <biglag_+0xa25>
mov    0x110(%rsp),%rbx
mov    0x108(%rsp),%rbp
mov    0xf0(%rsp),%r9
mov    0x18(%rsp),%r12
jmp    1b75 <biglag_+0xa25>

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

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