int trstlp(int *n, int *m, double *a, double *b, double *rho, double *dx,
           int *ifull, int *iact, double *z__, double *zdota, double *vmultc,
           double *sdirn, double *dxnew, double *vmultd) {
  int a_dim1, a_offset, z_dim1, z_offset, i__1, i__2;
  double d__1, d__2;
  double alpha, tempa;
  double beta;
  double optnew, stpful, sum, tot, acca, accb;
  double ratio, vsave, zdotv, zdotw, dd;
  double sd;
  double sp, ss, resold = 0.0, zdvabs, zdwabs, sumabs, resmax, optold;
  double spabs;
  double temp, step;
  int icount;
  int iout, i__, j, k;
  int isave;
  int kk;
  int kl, kp, kw;
  int nact, icon = 0, mcon;
  int nactx = 0;
  z_dim1 = *n;
  z_offset = 1 + z_dim1 * 1;
  z__ -= z_offset;
  a_dim1 = *n;
  a_offset = 1 + a_dim1 * 1;
  a -= a_offset;
  --b;
  --dx;
  --iact;
  --zdota;
  --vmultc;
  --sdirn;
  --dxnew;
  --vmultd;
  *ifull = 1;
  mcon = *m;
  nact = 0;
  resmax = 0.;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    i__2 = *n;
    for (j = 1; j <= i__2; ++j) {
      z__[i__ + j * z_dim1] = 0.;
    }
    z__[i__ + i__ * z_dim1] = 1.;
    dx[i__] = 0.;
  }
  if (*m >= 1) {
    i__1 = *m;
    for (k = 1; k <= i__1; ++k) {
      if (b[k] > resmax) {
        resmax = b[k];
        icon = k;
      }
    }
    i__1 = *m;
    for (k = 1; k <= i__1; ++k) {
      iact[k] = k;
      vmultc[k] = resmax - b[k];
    }
  }
  if (resmax == 0.) {
    goto L480;
  }
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    sdirn[i__] = 0.;
  }
L60:
  optold = 0.;
  icount = 0;
L70:
  if (mcon == *m) {
    optnew = resmax;
  } else {
    optnew = 0.;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      optnew -= dx[i__] * a[i__ + mcon * a_dim1];
    }
  }
  if (icount == 0 || optnew < optold) {
    optold = optnew;
    nactx = nact;
    icount = 3;
  } else if (nact > nactx) {
    nactx = nact;
    icount = 3;
  } else {
    --icount;
    if (icount == 0) {
      goto L490;
    }
  }
  if (icon <= nact) {
    goto L260;
  }
  kk = iact[icon];
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    dxnew[i__] = a[i__ + kk * a_dim1];
  }
  tot = 0.;
  k = *n;
L100:
  if (k > nact) {
    sp = 0.;
    spabs = 0.;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      temp = z__[i__ + k * z_dim1] * dxnew[i__];
      sp += temp;
      spabs += ((temp) >= 0 ? (temp) : -(temp));
    }
    acca = spabs + ((sp) >= 0 ? (sp) : -(sp)) * .1;
    accb = spabs + ((sp) >= 0 ? (sp) : -(sp)) * .2;
    if (spabs >= acca || acca >= accb) {
      sp = 0.;
    }
    if (tot == 0.) {
      tot = sp;
    } else {
      kp = k + 1;
      temp = sqrt(sp * sp + tot * tot);
      alpha = sp / temp;
      beta = tot / temp;
      tot = temp;
      i__1 = *n;
      for (i__ = 1; i__ <= i__1; ++i__) {
        temp = alpha * z__[i__ + k * z_dim1] + beta * z__[i__ + kp * z_dim1];
        z__[i__ + kp * z_dim1] =
            alpha * z__[i__ + kp * z_dim1] - beta * z__[i__ + k * z_dim1];
        z__[i__ + k * z_dim1] = temp;
      }
    }
    --k;
    goto L100;
  }
  if (tot != 0.) {
    ++nact;
    zdota[nact] = tot;
    vmultc[icon] = vmultc[nact];
    vmultc[nact] = 0.;
    goto L210;
  }
  ratio = -1.;
  k = nact;
L130:
  zdotv = 0.;
  zdvabs = 0.;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    temp = z__[i__ + k * z_dim1] * dxnew[i__];
    zdotv += temp;
    zdvabs += ((temp) >= 0 ? (temp) : -(temp));
  }
  acca = zdvabs + ((zdotv) >= 0 ? (zdotv) : -(zdotv)) * .1;
  accb = zdvabs + ((zdotv) >= 0 ? (zdotv) : -(zdotv)) * .2;
  if (zdvabs < acca && acca < accb) {
    temp = zdotv / zdota[k];
    if (temp > 0. && iact[k] <= *m) {
      tempa = vmultc[k] / temp;
      if (ratio < 0. || tempa < ratio) {
        ratio = tempa;
        iout = k;
      }
    }
    if (k >= 2) {
      kw = iact[k];
      i__1 = *n;
      for (i__ = 1; i__ <= i__1; ++i__) {
        dxnew[i__] -= temp * a[i__ + kw * a_dim1];
      }
    }
    vmultd[k] = temp;
  } else {
    vmultd[k] = 0.;
  }
  --k;
  if (k > 0) {
    goto L130;
  }
  if (ratio < 0.) {
    goto L490;
  }
  i__1 = nact;
  for (k = 1; k <= i__1; ++k) {
    d__1 = 0., d__2 = vmultc[k] - ratio * vmultd[k];
    vmultc[k] = ((d__1) >= (d__2) ? (d__1) : (d__2));
  }
  if (icon < nact) {
    isave = iact[icon];
    vsave = vmultc[icon];
    k = icon;
  L170:
    kp = k + 1;
    kw = iact[kp];
    sp = 0.;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      sp += z__[i__ + k * z_dim1] * a[i__ + kw * a_dim1];
    }
    d__1 = zdota[kp];
    temp = sqrt(sp * sp + d__1 * d__1);
    alpha = zdota[kp] / temp;
    beta = sp / temp;
    zdota[kp] = alpha * zdota[k];
    zdota[k] = temp;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      temp = alpha * z__[i__ + kp * z_dim1] + beta * z__[i__ + k * z_dim1];
      z__[i__ + kp * z_dim1] =
          alpha * z__[i__ + k * z_dim1] - beta * z__[i__ + kp * z_dim1];
      z__[i__ + k * z_dim1] = temp;
    }
    iact[k] = kw;
    vmultc[k] = vmultc[kp];
    k = kp;
    if (k < nact) {
      goto L170;
    }
    iact[k] = isave;
    vmultc[k] = vsave;
  }
  temp = 0.;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    temp += z__[i__ + nact * z_dim1] * a[i__ + kk * a_dim1];
  }
  if (temp == 0.) {
    goto L490;
  }
  zdota[nact] = temp;
  vmultc[icon] = 0.;
  vmultc[nact] = ratio;
L210:
  iact[icon] = iact[nact];
  iact[nact] = kk;
  if (mcon > *m && kk != mcon) {
    k = nact - 1;
    sp = 0.;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      sp += z__[i__ + k * z_dim1] * a[i__ + kk * a_dim1];
    }
    d__1 = zdota[nact];
    temp = sqrt(sp * sp + d__1 * d__1);
    alpha = zdota[nact] / temp;
    beta = sp / temp;
    zdota[nact] = alpha * zdota[k];
    zdota[k] = temp;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      temp = alpha * z__[i__ + nact * z_dim1] + beta * z__[i__ + k * z_dim1];
      z__[i__ + nact * z_dim1] =
          alpha * z__[i__ + k * z_dim1] - beta * z__[i__ + nact * z_dim1];
      z__[i__ + k * z_dim1] = temp;
    }
    iact[nact] = iact[k];
    iact[k] = kk;
    temp = vmultc[k];
    vmultc[k] = vmultc[nact];
    vmultc[nact] = temp;
  }
  if (mcon > *m) {
    goto L320;
  }
  kk = iact[nact];
  temp = 0.;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    temp += sdirn[i__] * a[i__ + kk * a_dim1];
  }
  temp += -1.;
  temp /= zdota[nact];
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    sdirn[i__] -= temp * z__[i__ + nact * z_dim1];
  }
  goto L340;
L260:
  if (icon < nact) {
    isave = iact[icon];
    vsave = vmultc[icon];
    k = icon;
  L270:
    kp = k + 1;
    kk = iact[kp];
    sp = 0.;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      sp += z__[i__ + k * z_dim1] * a[i__ + kk * a_dim1];
    }
    d__1 = zdota[kp];
    temp = sqrt(sp * sp + d__1 * d__1);
    alpha = zdota[kp] / temp;
    beta = sp / temp;
    zdota[kp] = alpha * zdota[k];
    zdota[k] = temp;
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      temp = alpha * z__[i__ + kp * z_dim1] + beta * z__[i__ + k * z_dim1];
      z__[i__ + kp * z_dim1] =
          alpha * z__[i__ + k * z_dim1] - beta * z__[i__ + kp * z_dim1];
      z__[i__ + k * z_dim1] = temp;
    }
    iact[k] = kk;
    vmultc[k] = vmultc[kp];
    k = kp;
    if (k < nact) {
      goto L270;
    }
    iact[k] = isave;
    vmultc[k] = vsave;
  }
  --nact;
  if (mcon > *m) {
    goto L320;
  }
  temp = 0.;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    temp += sdirn[i__] * z__[i__ + (nact + 1) * z_dim1];
  }
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    sdirn[i__] -= temp * z__[i__ + (nact + 1) * z_dim1];
  }
  goto L340;
L320:
  temp = 1. / zdota[nact];
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    sdirn[i__] = temp * z__[i__ + nact * z_dim1];
  }
L340:
  dd = *rho * *rho;
  sd = 0.;
  ss = 0.;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    if ((d__1 = dx[i__], ((d__1) >= 0 ? (d__1) : -(d__1))) >= *rho * 1e-6f) {
      d__2 = dx[i__];
      dd -= d__2 * d__2;
    }
    sd += dx[i__] * sdirn[i__];
    d__1 = sdirn[i__];
    ss += d__1 * d__1;
  }
  if (dd <= 0.) {
    goto L490;
  }
  temp = sqrt(ss * dd);
  if (((sd) >= 0 ? (sd) : -(sd)) >= temp * 1e-6f) {
    temp = sqrt(ss * dd + sd * sd);
  }
  stpful = dd / (temp + sd);
  step = stpful;
  if (mcon == *m) {
    acca = step + resmax * .1;
    accb = step + resmax * .2;
    if (step >= acca || acca >= accb) {
      goto L480;
    }
    step = ((step) <= (resmax) ? (step) : (resmax));
  }
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    dxnew[i__] = dx[i__] + step * sdirn[i__];
  }
  if (mcon == *m) {
    resold = resmax;
    resmax = 0.;
    i__1 = nact;
    for (k = 1; k <= i__1; ++k) {
      kk = iact[k];
      temp = b[kk];
      i__2 = *n;
      for (i__ = 1; i__ <= i__2; ++i__) {
        temp -= a[i__ + kk * a_dim1] * dxnew[i__];
      }
      resmax = ((resmax) >= (temp) ? (resmax) : (temp));
    }
  }
  k = nact;
L390:
  zdotw = 0.;
  zdwabs = 0.;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    temp = z__[i__ + k * z_dim1] * dxnew[i__];
    zdotw += temp;
    zdwabs += ((temp) >= 0 ? (temp) : -(temp));
  }
  acca = zdwabs + ((zdotw) >= 0 ? (zdotw) : -(zdotw)) * .1;
  accb = zdwabs + ((zdotw) >= 0 ? (zdotw) : -(zdotw)) * .2;
  if (zdwabs >= acca || acca >= accb) {
    zdotw = 0.;
  }
  vmultd[k] = zdotw / zdota[k];
  if (k >= 2) {
    kk = iact[k];
    i__1 = *n;
    for (i__ = 1; i__ <= i__1; ++i__) {
      dxnew[i__] -= vmultd[k] * a[i__ + kk * a_dim1];
    }
    --k;
    goto L390;
  }
  if (mcon > *m) {
    d__1 = 0., d__2 = vmultd[nact];
    vmultd[nact] = ((d__1) >= (d__2) ? (d__1) : (d__2));
  }
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    dxnew[i__] = dx[i__] + step * sdirn[i__];
  }
  if (mcon > nact) {
    kl = nact + 1;
    i__1 = mcon;
    for (k = kl; k <= i__1; ++k) {
      kk = iact[k];
      sum = resmax - b[kk];
      sumabs = resmax + (d__1 = b[kk], ((d__1) >= 0 ? (d__1) : -(d__1)));
      i__2 = *n;
      for (i__ = 1; i__ <= i__2; ++i__) {
        temp = a[i__ + kk * a_dim1] * dxnew[i__];
        sum += temp;
        sumabs += ((temp) >= 0 ? (temp) : -(temp));
      }
      acca = sumabs + ((sum) >= 0 ? (sum) : -(sum)) * .1f;
      accb = sumabs + ((sum) >= 0 ? (sum) : -(sum)) * .2f;
      if (sumabs >= acca || acca >= accb) {
        sum = 0.f;
      }
      vmultd[k] = sum;
    }
  }
  ratio = 1.;
  icon = 0;
  i__1 = mcon;
  for (k = 1; k <= i__1; ++k) {
    if (vmultd[k] < 0.) {
      temp = vmultc[k] / (vmultc[k] - vmultd[k]);
      if (temp < ratio) {
        ratio = temp;
        icon = k;
      }
    }
  }
  temp = 1. - ratio;
  i__1 = *n;
  for (i__ = 1; i__ <= i__1; ++i__) {
    dx[i__] = temp * dx[i__] + ratio * dxnew[i__];
  }
  i__1 = mcon;
  for (k = 1; k <= i__1; ++k) {
    d__1 = 0., d__2 = temp * vmultc[k] + ratio * vmultd[k];
    vmultc[k] = ((d__1) >= (d__2) ? (d__1) : (d__2));
  }
  if (mcon == *m) {
    resmax = resold + ratio * (resmax - resold);
  }
  if (icon > 0) {
    goto L70;
  }
  if (step == stpful) {
    goto L500;
  }
L480:
  mcon = *m + 1;
  icon = mcon;
  iact[mcon] = mcon;
  vmultc[mcon] = 0.;
  goto L60;
L490:
  if (mcon == *m) {
    goto L480;
  }
  *ifull = 0;
L500:
  return 0;
}


x86 assembly (clang, -O0):
<trstlp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x250,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x158(%rbp)
movl   $0x0,-0x160(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x0,%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%ecx
mov    0x20(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
shl    $0x0,%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rbp)
mov    0x48(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x48(%rbp)
mov    0x10(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x15c(%rbp)
movl   $0x0,-0x154(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1321 <trstlp+0x211>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x48(%rbp)
movl   $0x1,-0x138(%rbp)
mov    -0x138(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     12d4 <trstlp+0x1c4>
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x138(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    1290 <trstlp+0x180>
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x134(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0x2d23(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x134(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    126e <trstlp+0x15e>
mov    -0x10(%rbp),%rax
cmpl   $0x1,(%rax)
jl     1422 <trstlp+0x312>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     13ab <trstlp+0x29b>
mov    -0x20(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x108(%rbp),%xmm0
ff
jbe    1392 <trstlp+0x282>
mov    -0x20(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x13c(%rbp),%eax
mov    %eax,-0x158(%rbp)
jmp    1397 <trstlp+0x287>
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    1341 <trstlp+0x231>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     141d <trstlp+0x30d>
mov    -0x13c(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x13c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    13be <trstlp+0x2ae>
jmp    1422 <trstlp+0x312>
movsd  -0x108(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1442 <trstlp+0x332>
jp     1442 <trstlp+0x332>
jmp    3ee2 <trstlp+0x2dd2>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     148b <trstlp+0x37b>
mov    0x38(%rbp),%rax
movslq -0x134(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1455 <trstlp+0x345>
jmp    1490 <trstlp+0x380>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movl   $0x0,-0x12c(%rbp)
mov    -0x15c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jne    14c9 <trstlp+0x3b9>
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
jmp    1563 <trstlp+0x453>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     155e <trstlp+0x44e>
mov    -0x30(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x15c(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    14e4 <trstlp+0x3d4>
jmp    1563 <trstlp+0x453>
cmpl   $0x0,-0x12c(%rbp)
je     1587 <trstlp+0x477>
movsd  -0x78(%rbp),%xmm1
movsd  -0x110(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    15af <trstlp+0x49f>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x154(%rbp),%eax
mov    %eax,-0x160(%rbp)
movl   $0x3,-0x12c(%rbp)
jmp    1607 <trstlp+0x4f7>
mov    -0x154(%rbp),%eax
cmp    -0x160(%rbp),%eax
jle    15dc <trstlp+0x4cc>
mov    -0x154(%rbp),%eax
mov    %eax,-0x160(%rbp)
movl   $0x3,-0x12c(%rbp)
jmp    1602 <trstlp+0x4f2>
mov    -0x12c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x12c(%rbp)
cmpl   $0x0,-0x12c(%rbp)
jne    15fd <trstlp+0x4ed>
jmp    3f29 <trstlp+0x2e19>
jmp    1602 <trstlp+0x4f2>
jmp    1607 <trstlp+0x4f7>
mov    -0x158(%rbp),%eax
cmp    -0x154(%rbp),%eax
jg     161e <trstlp+0x50e>
jmp    29d3 <trstlp+0x18c3>
mov    0x18(%rbp),%rax
movslq -0x158(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x144(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1696 <trstlp+0x586>
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1645 <trstlp+0x535>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x154(%rbp),%eax
jle    1b07 <trstlp+0x9f7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     17c2 <trstlp+0x6b2>
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
addsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     176f <trstlp+0x65f>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
jmp    1796 <trstlp+0x686>
movsd  -0x120(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
addsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    16e8 <trstlp+0x5d8>
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     17fc <trstlp+0x6ec>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
jmp    1823 <trstlp+0x713>
movsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x170(%rbp),%xmm1
ff
movsd  -0x178(%rbp),%xmm0
ff
movsd  0x27cd(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1885 <trstlp+0x775>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x188(%rbp)
ff
jmp    18ac <trstlp+0x79c>
movsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x180(%rbp),%xmm1
ff
movsd  -0x188(%rbp),%xmm0
ff
movsd  0x274c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jae    1900 <trstlp+0x7f0>
movsd  -0x98(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jb     190b <trstlp+0x7fb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    193b <trstlp+0x82b>
jp     193b <trstlp+0x82b>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1af3 <trstlp+0x9e3>
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14c(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
divsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1aee <trstlp+0x9de>
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x14c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x14c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x14c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    19cc <trstlp+0x8bc>
jmp    1af3 <trstlp+0x9e3>
mov    -0x13c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x13c(%rbp)
jmp    16ad <trstlp+0x59d>
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1b27 <trstlp+0xa17>
jp     1b27 <trstlp+0xa17>
jmp    1b86 <trstlp+0xa76>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x158(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x154(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    24f0 <trstlp+0x13e0>
movsd  0x2472(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x154(%rbp),%eax
mov    %eax,-0x13c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1ca5 <trstlp+0xb95>
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1c52 <trstlp+0xb42>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
jmp    1c79 <trstlp+0xb69>
movsd  -0x120(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
addsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1bcb <trstlp+0xabb>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1cdf <trstlp+0xbcf>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
jmp    1d06 <trstlp+0xbf6>
movsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x198(%rbp),%xmm1
ff
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  0x22ea(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1d68 <trstlp+0xc58>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b0(%rbp)
ff
jmp    1d8f <trstlp+0xc7f>
movsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1a8(%rbp),%xmm1
ff
movsd  -0x1b0(%rbp),%xmm0
ff
movsd  0x2269(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1f70 <trstlp+0xe60>
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1f70 <trstlp+0xe60>
movsd  -0xb8(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x13c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1e9d <trstlp+0xd8d>
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jg     1e9d <trstlp+0xd8d>
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0xa8(%rbp),%xmm0
ff
ja     1e7f <trstlp+0xd6f>
movsd  -0x68(%rbp),%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1e98 <trstlp+0xd88>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x13c(%rbp),%eax
mov    %eax,-0x130(%rbp)
jmp    1e9d <trstlp+0xd8d>
cmpl   $0x2,-0x13c(%rbp)
jl     1f53 <trstlp+0xe43>
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x150(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1f4e <trstlp+0xe3e>
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x150(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1ed1 <trstlp+0xdc1>
jmp    1f53 <trstlp+0xe43>
movsd  -0x120(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f83 <trstlp+0xe73>
mov    0x48(%rbp),%rax
movslq -0x13c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x13c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x13c(%rbp)
cmpl   $0x0,-0x13c(%rbp)
jle    1fa4 <trstlp+0xe94>
jmp    1ba2 <trstlp+0xa92>
xorps  %xmm0,%xmm0
ucomisd -0xa8(%rbp),%xmm0
ff
jbe    1fba <trstlp+0xeaa>
jmp    3f29 <trstlp+0x2e19>
mov    -0x154(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     208b <trstlp+0xf7b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jb     2052 <trstlp+0xf42>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
jmp    205f <trstlp+0xf4f>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    1fcd <trstlp+0xebd>
mov    -0x158(%rbp),%eax
cmp    -0x154(%rbp),%eax
jge    23f8 <trstlp+0x12e8>
mov    0x18(%rbp),%rax
movslq -0x158(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x140(%rbp)
mov    0x30(%rbp),%rax
movslq -0x158(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x158(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14c(%rbp)
mov    0x18(%rbp),%rax
movslq -0x14c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x150(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     218d <trstlp+0x107d>
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x150(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2116 <trstlp+0x1006>
mov    0x28(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x120(%rbp)
ff
mov    0x28(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
divsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2375 <trstlp+0x1265>
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x14c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x14c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x14c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2253 <trstlp+0x1143>
mov    -0x150(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14c(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x154(%rbp),%eax
jge    23cc <trstlp+0x12bc>
jmp    20d5 <trstlp+0xfc5>
mov    -0x140(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     248d <trstlp+0x137d>
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x154(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2416 <trstlp+0x1306>
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    24ad <trstlp+0x139d>
jp     24ad <trstlp+0x139d>
jmp    3f29 <trstlp+0x2e19>
movsd  -0x120(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x158(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x18(%rbp),%rax
movslq -0x158(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x144(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x15c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jle    2850 <trstlp+0x1740>
mov    -0x144(%rbp),%eax
cmp    -0x15c(%rbp),%eax
je     2850 <trstlp+0x1740>
mov    -0x154(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x13c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     25e8 <trstlp+0x14d8>
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2571 <trstlp+0x1461>
mov    0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x120(%rbp)
ff
mov    0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
divsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     27d0 <trstlp+0x16c0>
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x154(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x154(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x154(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    26ae <trstlp+0x159e>
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x18(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x144(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    0x30(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x15c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jle    2867 <trstlp+0x1757>
jmp    2e88 <trstlp+0x1d78>
mov    0x18(%rbp),%rax
movslq -0x154(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x144(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2902 <trstlp+0x17f2>
mov    0x38(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2899 <trstlp+0x1789>
movsd  0x16f6(%rip),%xmm0
addsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
mov    0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x120(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     29ce <trstlp+0x18be>
movsd  -0x120(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x154(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2951 <trstlp+0x1841>
jmp    2f19 <trstlp+0x1e09>
mov    -0x158(%rbp),%eax
cmp    -0x154(%rbp),%eax
jge    2d40 <trstlp+0x1c30>
mov    0x18(%rbp),%rax
movslq -0x158(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x140(%rbp)
mov    0x30(%rbp),%rax
movslq -0x158(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x158(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14c(%rbp)
mov    0x18(%rbp),%rax
movslq -0x14c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x144(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2ad5 <trstlp+0x19c5>
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2a5e <trstlp+0x194e>
mov    0x28(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x120(%rbp)
ff
mov    0x28(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
divsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2cbd <trstlp+0x1bad>
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x14c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x14c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x14c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2b9b <trstlp+0x1a8b>
mov    -0x144(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14c(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x154(%rbp),%eax
jge    2d14 <trstlp+0x1c04>
jmp    2a1d <trstlp+0x190d>
mov    -0x140(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x154(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x154(%rbp)
mov    -0x15c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jle    2d66 <trstlp+0x1c56>
jmp    2e88 <trstlp+0x1d78>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2df0 <trstlp+0x1ce0>
mov    0x38(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x154(%rbp),%edx
add    $0x1,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2d84 <trstlp+0x1c74>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2e83 <trstlp+0x1d73>
movsd  -0x120(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x154(%rbp),%edx
add    $0x1,%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2e03 <trstlp+0x1cf3>
jmp    2f19 <trstlp+0x1e09>
mov    0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  0x117d(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     2f14 <trstlp+0x1e04>
movsd  -0x120(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x154(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2ebb <trstlp+0x1dab>
jmp    2f19 <trstlp+0x1e09>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     30b9 <trstlp+0x1fa9>
mov    -0x30(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2fa2 <trstlp+0x1e92>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
jmp    2fc6 <trstlp+0x1eb6>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x1c0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
movsd  0x1046(%rip),%xmm1
mulsd  (%rax),%xmm1
ucomisd %xmm1,%xmm0
jb     3036 <trstlp+0x1f26>
mov    -0x30(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  -0xc8(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x30(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    0x38(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    2f5a <trstlp+0x1e4a>
xorps  %xmm0,%xmm0
ucomisd -0xc8(%rbp),%xmm0
ff
jb     30cf <trstlp+0x1fbf>
jmp    3f29 <trstlp+0x2e19>
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     3116 <trstlp+0x2006>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
jmp    313d <trstlp+0x202d>
movsd  -0xd0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  0xed3(%rip),%xmm1
mulsd  -0x120(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jb     3194 <trstlp+0x2084>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm1
ff
addsd  -0xd0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x15c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jne    32a4 <trstlp+0x2194>
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  0xe1c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  0xdfc(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jae    3250 <trstlp+0x2140>
movsd  -0x98(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jb     3255 <trstlp+0x2145>
jmp    3ee2 <trstlp+0x2dd2>
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     3284 <trstlp+0x2174>
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d0(%rbp)
ff
jmp    3294 <trstlp+0x2184>
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x1d0(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     331a <trstlp+0x220a>
mov    -0x30(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x128(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    32b7 <trstlp+0x21a7>
mov    -0x15c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jne    348c <trstlp+0x237c>
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x154(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     3487 <trstlp+0x2377>
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x144(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x144(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x48(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     3428 <trstlp+0x2318>
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    33a8 <trstlp+0x2298>
movsd  -0x108(%rbp),%xmm0
ff
ucomisd -0x120(%rbp),%xmm0
ff
jb     3453 <trstlp+0x2343>
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
jmp    3463 <trstlp+0x2353>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    335a <trstlp+0x224a>
jmp    348c <trstlp+0x237c>
mov    -0x154(%rbp),%eax
mov    %eax,-0x13c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     359b <trstlp+0x248b>
mov    0x20(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x13c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     3548 <trstlp+0x2438>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e0(%rbp)
ff
jmp    356f <trstlp+0x245f>
movsd  -0x120(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x1e0(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    34c1 <trstlp+0x23b1>
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     35d5 <trstlp+0x24c5>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
jmp    35fc <trstlp+0x24ec>
movsd  -0xc0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm1
ff
movsd  -0x1f0(%rbp),%xmm0
ff
movsd  0x9f4(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     365e <trstlp+0x254e>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x200(%rbp)
ff
jmp    3685 <trstlp+0x2575>
movsd  -0xc0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x1f8(%rbp),%xmm1
ff
movsd  -0x200(%rbp),%xmm0
ff
movsd  0x973(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jae    36d9 <trstlp+0x25c9>
movsd  -0x98(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jb     36e4 <trstlp+0x25d4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x28(%rbp),%rax
movslq -0x13c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x2,-0x13c(%rbp)
jl     37d9 <trstlp+0x26c9>
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x144(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     37c5 <trstlp+0x26b5>
mov    0x48(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    3740 <trstlp+0x2630>
mov    -0x13c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x13c(%rbp)
jmp    3498 <trstlp+0x2388>
mov    -0x15c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jle    384f <trstlp+0x273f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x48(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jb     382a <trstlp+0x271a>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
jmp    3837 <trstlp+0x2727>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x208(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x154(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     38c5 <trstlp+0x27b5>
mov    -0x30(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x128(%rbp),%xmm0
ff
mov    0x38(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    3862 <trstlp+0x2752>
mov    -0x15c(%rbp),%eax
cmp    -0x154(%rbp),%eax
jle    3c2e <trstlp+0x2b1e>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x148(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x148(%rbp),%eax
mov    %eax,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     3c29 <trstlp+0x2b19>
mov    0x18(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x144(%rbp)
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x144(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x144(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     3987 <trstlp+0x2877>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
jmp    39ab <trstlp+0x289b>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x210(%rbp),%xmm0
ff
movsd  -0x218(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x48(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     3ab4 <trstlp+0x29a4>
mov    -0x18(%rbp),%rax
mov    -0x134(%rbp),%ecx
mov    -0x144(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     3a61 <trstlp+0x2951>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x220(%rbp)
ff
jmp    3a88 <trstlp+0x2978>
movsd  -0x120(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x220(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    39da <trstlp+0x28ca>
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x228(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     3aee <trstlp+0x29de>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x230(%rbp)
ff
jmp    3b15 <trstlp+0x2a05>
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x228(%rbp),%xmm1
ff
movsd  -0x230(%rbp),%xmm0
ff
movsd  0x4fb(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x238(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     3b77 <trstlp+0x2a67>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x240(%rbp)
ff
jmp    3b9e <trstlp+0x2a8e>
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0x238(%rbp),%xmm1
ff
movsd  -0x240(%rbp),%xmm0
ff
movsd  0x47a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jae    3bf2 <trstlp+0x2ae2>
movsd  -0x98(%rbp),%xmm0
ff
ucomisd -0xa0(%rbp),%xmm0
ff
jb     3bfd <trstlp+0x2aed>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    38fb <trstlp+0x27eb>
jmp    3c2e <trstlp+0x2b1e>
movsd  0x3e2(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x158(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     3d13 <trstlp+0x2c03>
mov    0x48(%rbp),%rax
movslq -0x13c(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    3cfa <trstlp+0x2bea>
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x48(%rbp),%rax
movslq -0x13c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    3cf5 <trstlp+0x2be5>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x13c(%rbp),%eax
mov    %eax,-0x158(%rbp)
jmp    3cfa <trstlp+0x2bea>
jmp    3cff <trstlp+0x2bef>
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    3c5b <trstlp+0x2b4b>
movsd  0x2fd(%rip),%xmm0
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x134(%rbp)
mov    -0x134(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     3da9 <trstlp+0x2c99>
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x30(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mov    0x40(%rbp),%rax
movslq -0x134(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    3d3e <trstlp+0x2c2e>
mov    -0x15c(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x1,-0x13c(%rbp)
mov    -0x13c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     3e6b <trstlp+0x2d5b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
mov    0x48(%rbp),%rax
movslq -0x13c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jb     3e32 <trstlp+0x2d22>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
jmp    3e3f <trstlp+0x2d2f>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
movslq -0x13c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x13c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x13c(%rbp)
jmp    3dbc <trstlp+0x2cac>
mov    -0x15c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jne    3ead <trstlp+0x2d9d>
movsd  -0xe8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
subsd  -0xe8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
cmpl   $0x0,-0x158(%rbp)
jle    3ebf <trstlp+0x2daf>
jmp    14a5 <trstlp+0x395>
movsd  -0x128(%rbp),%xmm0
ff
ucomisd -0x80(%rbp),%xmm0
jne    3edd <trstlp+0x2dcd>
jp     3edd <trstlp+0x2dcd>
jmp    3f4a <trstlp+0x2e3a>
jmp    3ee2 <trstlp+0x2dd2>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
mov    %eax,-0x15c(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x15c(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x15c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x30(%rbp),%rax
movslq -0x15c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1490 <trstlp+0x380>
mov    -0x15c(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jne    3f40 <trstlp+0x2e30>
jmp    3ee2 <trstlp+0x2dd2>
mov    0x10(%rbp),%rax
movl   $0x0,(%rax)
xor    %eax,%eax
add    $0x250,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<trstlp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x208,%rsp
mov    %r9,%r15
mov    %r8,0x1a0(%rsp)
mov    %rcx,0xa8(%rsp)
mov    0x270(%rsp),%r13
mov    0x250(%rsp),%rax
mov    0x240(%rsp),%rcx
movslq (%rdi),%rbx
mov    %rbx,%rbp
mov    %rbx,0x8(%rsp)
not    %rbp
movl   $0x1,(%rcx)
lea    (%rax,%rbp,8),%rax
mov    %rax,0x18(%rsp)
mov    %rdx,0x1b0(%rsp)
lea    (%rdx,%rbp,8),%rax
mov    %rax,0x28(%rsp)
mov    %rsi,0xb0(%rsp)
mov    (%rsi),%eax
mov    %rax,0x30(%rsp)
mov    %rdi,0x40(%rsp)
mov    (%rdi),%eax
test   %eax,%eax
mov    %r9,0x58(%rsp)
mov    %rbp,0xf8(%rsp)
jle    1355 <trstlp+0x235>
lea    0x1(%rax),%rcx
mov    %rcx,0x70(%rsp)
lea    -0x1(%rax),%rcx
mov    %rcx,0xc0(%rsp)
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rcx,0xb8(%rsp)
mov    0x8(%rsp),%rsi
mov    %rsi,%rdi
shl    $0x5,%rdi
mov    0x250(%rsp),%rdx
lea    (%rdi,%rdx,1),%rcx
add    $0x8,%rcx
mov    %rcx,0x80(%rsp)
lea    (%rsi,%rsi,2),%rcx
lea    (%rdx,%rcx,8),%rbx
add    $0x8,%rbx
lea    (%rdx,%rsi,8),%r14
add    $0x8,%r14
mov    %rsi,%rcx
shl    $0x4,%rcx
lea    (%rcx,%rdx,1),%r8
add    $0x8,%r8
mov    %rbx,%rcx
and    $0xfffffffc,%eax
neg    %rax
lea    0x0(,%rsi,8),%rsi
mov    $0x1,%r9d
jmp    1297 <trstlp+0x177>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rdx
imul   %r9d,%edx
movslq %edx,%rdx
add    %r9,%rdx
mov    0x18(%rsp),%rbx
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%rbx,%rdx,8)
mov    0x58(%rsp),%r15
movq   $0x0,-0x8(%r15,%r9,8)
add    $0x1,%r9
addq   $0x8,0x80(%rsp)
mov    %r10,%rcx
add    $0x8,%rcx
add    $0x8,%r14
add    $0x8,%r8
cmp    0x70(%rsp),%r9
je     1355 <trstlp+0x235>
mov    $0x1,%ebx
cmpq   $0x3,0xc0(%rsp)
jb     1306 <trstlp+0x1e6>
mov    $0x1,%ebx
mov    %r8,%rdx
mov    %r14,%r12
mov    %rcx,%r15
mov    0x80(%rsp),%r11
nopl   (%rax)
movq   $0x0,(%r12,%rbp,8)
movq   $0x0,(%rdx,%rbp,8)
movq   $0x0,(%r15,%rbp,8)
movq   $0x0,(%r11,%rbp,8)
add    %rdi,%r11
add    %rdi,%r15
add    %rdi,%r12
add    %rdi,%rdx
lea    (%rax,%rbx,1),%r10
add    $0x4,%r10
add    $0x4,%rbx
cmp    $0x1,%r10
mov    0xf8(%rsp),%rbp
jne    12c0 <trstlp+0x1a0>
mov    %rcx,%r10
cmpq   $0x0,0xb8(%rsp)
je     1240 <trstlp+0x120>
imul   0x8(%rsp),%rbx
add    %r9,%rbx
mov    0x18(%rsp),%rdx
lea    (%rdx,%rbx,8),%rdx
mov    0xb8(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   $0x0,(%rdx)
add    %rsi,%rdx
add    $0xffffffffffffffff,%rbx
jne    1340 <trstlp+0x220>
jmp    1240 <trstlp+0x120>
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xf0(%rsp)
xorpd  %xmm14,%xmm14
mov    0x30(%rsp),%r12
test   %r12d,%r12d
mov    0x260(%rsp),%r8
mov    0x258(%rsp),%r10
mov    0x248(%rsp),%r14
jle    1714 <trstlp+0x5f4>
lea    0x1(%r12),%rax
mov    %rax,0xb8(%rsp)
lea    -0x1(%r12),%rsi
mov    %r12d,%ecx
and    $0x3,%ecx
xorpd  %xmm0,%xmm0
xor    %edi,%edi
mov    $0x1,%edx
cmp    $0x3,%rsi
jb     143f <trstlp+0x31f>
mov    %r12d,%r11d
and    $0xfffffffc,%r11d
xorpd  %xmm0,%xmm0
xor    %edi,%edi
mov    $0x1,%edx
mov    $0x2,%r9d
xor    %ebp,%ebp
mov    0xa8(%rsp),%rsi
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rdx,8),%xmm1
ucomisd %xmm0,%xmm1
lea    -0x1(%r9),%ebx
cmovbe %edi,%ebx
movsd  (%rsi,%rdx,8),%xmm2
maxsd  %xmm0,%xmm1
ucomisd %xmm1,%xmm2
maxsd  %xmm1,%xmm2
cmova  %r9d,%ebx
lea    0x2(%rdx),%eax
movsd  0x8(%rsi,%rdx,8),%xmm1
ucomisd %xmm2,%xmm1
maxsd  %xmm2,%xmm1
cmovbe %ebx,%eax
lea    0x3(%rdx),%edi
movsd  0x10(%rsi,%rdx,8),%xmm0
ucomisd %xmm1,%xmm0
maxsd  %xmm1,%xmm0
cmovbe %eax,%edi
add    $0x4,%rdx
add    $0x4,%rbp
add    $0x4,%r9d
cmp    %r11,%rbp
jne    13e0 <trstlp+0x2c0>
movapd %xmm0,%xmm14
test   %rcx,%rcx
je     1483 <trstlp+0x363>
mov    0xa8(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rdx,8),%xmm14
ucomisd %xmm0,%xmm14
cmova  %edx,%edi
maxsd  %xmm0,%xmm14
add    $0x1,%rdx
movapd %xmm14,%xmm0
add    $0xffffffffffffffff,%rcx
jne    1460 <trstlp+0x340>
test   %r12d,%r12d
mov    0x278(%rsp),%rbx
mov    0xb8(%rsp),%rsi
jle    1707 <trstlp+0x5e7>
lea    -0x1(%rsi),%rdx
mov    $0x1,%ecx
cmp    $0x4,%rdx
jb     1689 <trstlp+0x569>
lea    (%r8,%rsi,8),%rbp
add    $0xfffffffffffffff8,%rbp
mov    %rdi,0x90(%rsp)
mov    0xa8(%rsp),%rax
lea    (%rax,%rsi,8),%rdi
add    $0xfffffffffffffff8,%rdi
cmp    %r8,%rdi
mov    0x90(%rsp),%rdi
jbe    14ea <trstlp+0x3ca>
cmp    0xa8(%rsp),%rbp
ja     1689 <trstlp+0x569>
mov    %rdx,%r8
and    $0xfffffffffffffffc,%r8
lea    0x1(%r8),%rcx
movapd %xmm14,%xmm2
unpcklpd %xmm14,%xmm2
lea    -0x4(%r8),%rbx
mov    %rbx,%r9
shr    $0x2,%r9
add    $0x1,%r9
movdqa 0x4aea(%rip),%xmm1
mov    $0x1,%edi
test   %rbx,%rbx
je     1617 <trstlp+0x4f7>
mov    %r9,%rbp
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rbp
movdqa 0x4ac4(%rip),%xmm1
mov    $0x6,%edi
movdqa 0x4ac6(%rip),%xmm8
movdqa 0x4ace(%rip),%xmm3
movdqa 0x4ad6(%rip),%xmm4
movdqa 0x4ade(%rip),%xmm5
mov    0x260(%rsp),%rax
mov    0xa8(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm1,%xmm6
paddd  %xmm8,%xmm6
movdqa %xmm1,%xmm7
punpcklqdq %xmm6,%xmm7
movdqu %xmm7,-0x18(%r14,%rdi,4)
movupd -0x30(%rbx,%rdi,8),%xmm6
movupd -0x20(%rbx,%rdi,8),%xmm7
movapd %xmm2,%xmm0
subpd  %xmm6,%xmm0
movapd %xmm2,%xmm6
subpd  %xmm7,%xmm6
movupd %xmm0,-0x30(%rax,%rdi,8)
movupd %xmm6,-0x20(%rax,%rdi,8)
movdqa %xmm1,%xmm0
paddd  %xmm3,%xmm0
movdqa %xmm1,%xmm6
paddd  %xmm4,%xmm6
punpcklqdq %xmm6,%xmm0
movdqu %xmm0,-0x8(%r14,%rdi,4)
movupd -0x10(%rbx,%rdi,8),%xmm0
movupd (%rbx,%rdi,8),%xmm6
movapd %xmm2,%xmm7
subpd  %xmm0,%xmm7
movapd %xmm2,%xmm0
subpd  %xmm6,%xmm0
movupd %xmm7,-0x10(%rax,%rdi,8)
movupd %xmm0,(%rax,%rdi,8)
paddd  %xmm5,%xmm1
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1580 <trstlp+0x460>
add    $0xfffffffffffffffb,%rdi
test   $0x1,%r9b
je     1668 <trstlp+0x548>
movdqa 0x49eb(%rip),%xmm0
paddd  %xmm1,%xmm0
punpcklqdq %xmm0,%xmm1
movdqu %xmm1,-0x4(%r14,%rdi,4)
mov    0xa8(%rsp),%rax
movupd -0x8(%rax,%rdi,8),%xmm0
movupd 0x8(%rax,%rdi,8),%xmm1
movapd %xmm2,%xmm3
subpd  %xmm0,%xmm3
subpd  %xmm1,%xmm2
mov    0x260(%rsp),%rax
movupd %xmm3,-0x8(%rax,%rdi,8)
movupd %xmm2,0x8(%rax,%rdi,8)
cmp    %r8,%rdx
mov    0x278(%rsp),%rbx
mov    0x260(%rsp),%r8
mov    0x90(%rsp),%rdi
je     1707 <trstlp+0x5e7>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%sil
jne    16b8 <trstlp+0x598>
mov    %ecx,-0x4(%r14,%rcx,4)
movapd %xmm14,%xmm0
mov    0xa8(%rsp),%rax
subsd  -0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%r8,%rcx,8)
add    $0x1,%rcx
add    %rsi,%rdx
je     1707 <trstlp+0x5e7>
mov    0xa8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ecx,-0x4(%r14,%rcx,4)
movapd %xmm14,%xmm0
subsd  -0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,-0x8(%r8,%rcx,8)
lea    0x1(%rcx),%eax
mov    %eax,(%r14,%rcx,4)
movapd %xmm14,%xmm0
subsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rsi
jne    16d0 <trstlp+0x5b0>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm14
jne    1743 <trstlp+0x623>
jp     1743 <trstlp+0x623>
mov    0xb0(%rsp),%rax
mov    (%rax),%r12d
xor    %eax,%eax
mov    %rax,0x10(%rsp)
movl   $0x0,0x6c(%rsp)
mov    0x278(%rsp),%rbx
mov    0x268(%rsp),%r9
jmp    5189 <trstlp+0x4069>
mov    0x40(%rsp),%rax
mov    (%rax),%edx
test   %edx,%edx
mov    %rdi,0x90(%rsp)
jle    17a8 <trstlp+0x688>
shl    $0x3,%rdx
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    0x268(%rsp),%rbp
mov    %rbp,%rdi
xor    %esi,%esi
movapd %xmm14,0x110(%rsp)
call   1030 <memset@plt>
xorpd  %xmm0,%xmm0
movapd 0x110(%rsp),%xmm14
mov    0x258(%rsp),%r10
mov    0x260(%rsp),%r8
mov    %rbp,%r9
movl   $0x0,0x6c(%rsp)
jmp    17bf <trstlp+0x69f>
xor    %eax,%eax
mov    %rax,0x10(%rsp)
movl   $0x0,0x6c(%rsp)
mov    0x268(%rsp),%r9
mov    0x8(%rsp),%rax
imul   %r12d,%eax
movslq %eax,%rdi
lea    0x1(%r12),%esi
mov    0xb0(%rsp),%rax
mov    (%rax),%eax
mov    %eax,0x50(%rsp)
movslq %r12d,%rax
mov    %rax,0x200(%rsp)
lea    -0x1(%rsi),%rbp
lea    -0x8(%r8,%rsi,8),%rax
mov    %rbx,%r11
lea    (%rbx,%rsi,8),%rcx
add    $0xfffffffffffffff8,%rcx
lea    -0x8(%r15),%rdx
mov    %rdx,0x148(%rsp)
cmp    %r8,%rcx
seta   %cl
lea    -0x8(%r13),%rdx
mov    %rdx,0x128(%rsp)
cmp    %rbx,%rax
seta   %al
lea    -0x8(%r9),%rdx
mov    %rdx,0xd0(%rsp)
and    %cl,%al
mov    %al,0x4f(%rsp)
mov    %rbp,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rsi,0x168(%rsp)
neg    %rsi
mov    %rsi,0x1e0(%rsp)
mov    0xf8(%rsp),%rsi
mov    %rdi,0x1c8(%rsp)
lea    (%rdi,%rsi,1),%rax
mov    0x1b0(%rsp),%rcx
lea    0x8(%rcx,%rax,8),%rdi
mov    0x8(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0x1a8(%rsp)
neg    %rax
mov    %rax,0xb8(%rsp)
mov    %rbp,%rax
mov    %rbp,0x160(%rsp)
mov    %rdi,%rbp
and    $0xfffffffffffffffe,%rax
neg    %rax
mov    %rax,0x1f8(%rsp)
xorpd  %xmm9,%xmm9
movapd 0x4797(%rip),%xmm10
movapd 0x479e(%rip),%xmm11
movapd 0x4785(%rip),%xmm12
movsd  %xmm0,0xf0(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x158(%rsp)
lea    0x8(%r13),%rax
mov    %rax,0x1f0(%rsp)
lea    0x10(%rcx,%rsi,8),%rax
mov    %rax,0x60(%rsp)
lea    0x1(%rsi),%rax
mov    %rax,0x140(%rsp)
mov    0x250(%rsp),%rax
lea    0x8(%rax,%rsi,8),%rax
mov    %rax,0x38(%rsp)
mov    %rdx,0x1e8(%rsp)
lea    -0x8(%r8),%rax
mov    %rax,0x1c0(%rsp)
lea    -0x8(%rbx),%rax
mov    %rax,0x1b8(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0x1d8(%rsp)
xor    %eax,%eax
mov    %rax,0x100(%rsp)
mov    %r12,0x30(%rsp)
mov    %rdi,0x170(%rsp)
mov    0x90(%rsp),%rdi
jmp    1978 <trstlp+0x858>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %edi,%edi
jle    513b <trstlp+0x401b>
movapd %xmm14,%xmm0
cmp    0x50(%rsp),%r12d
je     1a20 <trstlp+0x900>
mov    0x40(%rsp),%rax
mov    (%rax),%eax
xorpd  %xmm0,%xmm0
test   %eax,%eax
jle    1a20 <trstlp+0x900>
xorpd  %xmm0,%xmm0
mov    $0x1,%ecx
cmp    $0x1,%eax
je     19f3 <trstlp+0x8d3>
mov    %eax,%edx
and    $0xfffffffe,%edx
neg    %rdx
xorpd  %xmm0,%xmm0
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r15,%rcx,8),%xmm1
mulsd  -0x8(%rbp,%rcx,8),%xmm1
movsd  (%r15,%rcx,8),%xmm2
subsd  %xmm1,%xmm0
mulsd  0x0(%rbp,%rcx,8),%xmm2
subsd  %xmm2,%xmm0
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    19c0 <trstlp+0x8a0>
test   $0x1,%al
je     1a20 <trstlp+0x900>
movsd  -0x8(%r15,%rcx,8),%xmm1
add    0x1c8(%rsp),%rcx
mov    0x28(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x100(%rsp),%rax
test   %eax,%eax
je     1a60 <trstlp+0x940>
movsd  0x158(%rsp),%xmm1
ucomisd %xmm0,%xmm1
ja     1a60 <trstlp+0x940>
mov    0x10(%rsp),%rcx
cmp    0x6c(%rsp),%ecx
jle    1a90 <trstlp+0x970>
mov    $0x3,%eax
mov    %rax,0x100(%rsp)
jmp    1a7b <trstlp+0x95b>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  %xmm0,0x158(%rsp)
mov    $0x3,%eax
mov    %rax,0x100(%rsp)
mov    0x10(%rsp),%rcx
mov    %ecx,%eax
mov    %ecx,0x6c(%rsp)
jmp    1aa1 <trstlp+0x981>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xffffffff,%eax
mov    %rax,0x100(%rsp)
je     517c <trstlp+0x405c>
cmp    %ecx,%edi
mov    %rcx,%r15
movapd %xmm14,0x110(%rsp)
jle    2120 <trstlp+0x1000>
mov    %rdi,0x90(%rsp)
movslq %edi,%rax
mov    %rax,0x150(%rsp)
mov    -0x4(%r14,%rax,4),%eax
mov    %eax,0xd8(%rsp)
mov    0x40(%rsp),%rax
movslq (%rax),%r9
mov    %r9d,%edi
test   %r9,%r9
jle    1c9c <trstlp+0xb7c>
mov    0xd8(%rsp),%ecx
imul   0x8(%rsp),%ecx
movslq %ecx,%r14
lea    0x1(%rdi),%rsi
mov    $0x1,%edx
cmp    $0x4,%rdi
jb     1c10 <trstlp+0xaf0>
mov    0x128(%rsp),%rax
lea    (%rax,%rsi,8),%rcx
mov    0x60(%rsp),%rax
lea    (%rax,%r14,8),%rbp
add    $0xfffffffffffffff8,%rbp
lea    (%r14,%rsi,1),%rbx
mov    0x28(%rsp),%rax
lea    (%rax,%rbx,8),%rbx
cmp    %r13,%rbx
jbe    1b3f <trstlp+0xa1f>
cmp    %rcx,%rbp
jb     1c10 <trstlp+0xaf0>
mov    %edi,%r8d
and    $0xfffffffc,%r8d
lea    0x1(%r8),%rdx
lea    -0x4(%r8),%rcx
mov    %rcx,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    $0x0,%ebp
test   %rcx,%rcx
je     1bc9 <trstlp+0xaa9>
mov    %r10,%rcx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
mov    0x60(%rsp),%rax
lea    (%rax,%r14,8),%rbx
add    $0x28,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%rbx,%rbp,8),%xmm0
movups -0x20(%rbx,%rbp,8),%xmm1
movups %xmm0,0x0(%r13,%rbp,8)
movups %xmm1,0x10(%r13,%rbp,8)
movupd -0x10(%rbx,%rbp,8),%xmm0
movupd (%rbx,%rbp,8),%xmm1
movupd %xmm0,0x20(%r13,%rbp,8)
movupd %xmm1,0x30(%r13,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rcx
jne    1b90 <trstlp+0xa70>
test   $0x1,%r10b
je     1bf5 <trstlp+0xad5>
or     $0x1,%rbp
lea    (%r14,%rbp,1),%rcx
mov    0x28(%rsp),%rax
movupd (%rax,%rcx,8),%xmm0
movupd 0x10(%rax,%rcx,8),%xmm1
movupd %xmm0,-0x8(%r13,%rbp,8)
movupd %xmm1,0x8(%r13,%rbp,8)
cmp    %r8,%rdi
mov    0x260(%rsp),%r8
mov    0x258(%rsp),%r10
je     1c9c <trstlp+0xb7c>
xchg   %ax,%ax
mov    %esi,%ecx
sub    %edx,%ecx
mov    %rdx,%rdi
not    %rdi
add    %rsi,%rdi
and    $0x3,%rcx
je     1c47 <trstlp+0xb27>
mov    0x28(%rsp),%rax
lea    (%rax,%r14,8),%rbp
nopl   0x0(%rax)
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%r13,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1c30 <trstlp+0xb10>
cmp    $0x3,%rdi
jb     1c9c <trstlp+0xb7c>
mov    0x28(%rsp),%rax
lea    (%rax,%r14,8),%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%r13,%rdx,8)
movsd  0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
movsd  0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r13,%rdx,8)
movsd  0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%r13,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rsi
jne    1c60 <trstlp+0xb40>
cmp    %r15d,%r9d
jle    2590 <trstlp+0x1470>
movslq %r15d,%rax
mov    %rax,0xa0(%rsp)
lea    0x1(%r9),%rcx
mov    0x8(%rsp),%rdx
imul   %rdx,%rcx
mov    0x140(%rsp),%rsi
lea    (%rsi,%rcx,1),%rax
mov    %rax,0x98(%rsp)
mov    0xf8(%rsp),%rax
lea    (%rcx,%rax,1),%rdi
mov    %rdi,0x50(%rsp)
imul   %r9,%rdx
add    %rdx,%rsi
mov    %rsi,0xe8(%rsp)
add    %rdx,%rax
mov    %rax,0xe0(%rsp)
mov    0x38(%rsp),%rax
lea    (%rax,%rdx,8),%r15
lea    (%rax,%rcx,8),%r12
mov    0x18(%rsp),%rax
lea    (%rax,%rcx,8),%rbp
lea    (%rax,%rdx,8),%rbx
xorpd  %xmm0,%xmm0
xor    %r11d,%r11d
mov    %r9,%r14
jmp    1dc0 <trstlp+0xca0>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm1,%xmm2
xorpd  %xmm10,%xmm2
xorpd  %xmm6,%xmm6
cmplesd %xmm1,%xmm6
movapd %xmm6,%xmm3
andpd  %xmm1,%xmm3
andnpd %xmm2,%xmm6
orpd   %xmm3,%xmm6
unpcklpd %xmm6,%xmm6
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
mulpd  %xmm11,%xmm6
addpd  %xmm2,%xmm6
movapd %xmm6,%xmm2
unpckhpd %xmm6,%xmm2
cmpnlesd %xmm6,%xmm2
andpd  %xmm1,%xmm2
cmpnlesd %xmm0,%xmm6
andpd  %xmm2,%xmm6
ucomisd %xmm9,%xmm15
movapd %xmm6,%xmm0
jne    1f50 <trstlp+0xe30>
jp     1f50 <trstlp+0xe30>
add    $0xffffffffffffffff,%r14
add    $0x1,%r11
mov    0xb8(%rsp),%rax
add    %rax,%r15
add    %rax,%r12
add    %rax,%rbp
add    %rax,%rbx
cmp    0xa0(%rsp),%r14
jle    2520 <trstlp+0x1400>
movapd %xmm0,%xmm15
mov    %r11,%rcx
imul   0x8(%rsp),%rcx
mov    0x98(%rsp),%rdx
sub    %rcx,%rdx
mov    0x250(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
mov    %rdx,0x80(%rsp)
mov    0x50(%rsp),%rdx
sub    %rcx,%rdx
lea    (%rax,%rdx,8),%rdx
mov    %rdx,0x70(%rsp)
mov    0xe8(%rsp),%rdx
sub    %rcx,%rdx
lea    (%rax,%rdx,8),%rdx
mov    %rdx,0x20(%rsp)
mov    0xe0(%rsp),%rdx
sub    %rcx,%rdx
lea    (%rax,%rdx,8),%rax
mov    %rax,0xc0(%rsp)
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
test   %r9d,%r9d
jle    1d30 <trstlp+0xc10>
mov    %r14,%rcx
imul   0x8(%rsp),%rcx
mov    %r9d,%edx
xorpd  %xmm0,%xmm0
mov    $0x1,%esi
xorpd  %xmm1,%xmm1
cmp    $0x1,%r9d
je     1ef9 <trstlp+0xdd9>
mov    %edx,%edi
and    $0xfffffffe,%edi
neg    %rdi
xorpd  %xmm0,%xmm0
mov    $0x1,%esi
xorpd  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%r15,%rsi,8),%xmm2
movsd  (%r15,%rsi,8),%xmm3
mulsd  -0x8(%r13,%rsi,8),%xmm2
addsd  %xmm2,%xmm1
movapd %xmm2,%xmm4
xorpd  %xmm12,%xmm4
pxor   %xmm5,%xmm5
cmplesd %xmm2,%xmm5
andpd  %xmm5,%xmm2
andnpd %xmm4,%xmm5
orpd   %xmm2,%xmm5
mulsd  0x0(%r13,%rsi,8),%xmm3
addsd  %xmm0,%xmm5
addsd  %xmm3,%xmm1
movapd %xmm3,%xmm2
xorpd  %xmm12,%xmm2
xorpd  %xmm0,%xmm0
cmplesd %xmm3,%xmm0
andpd  %xmm0,%xmm3
andnpd %xmm2,%xmm0
orpd   %xmm3,%xmm0
addsd  %xmm5,%xmm0
lea    (%rdi,%rsi,1),%rax
add    $0x2,%rax
add    $0x2,%rsi
cmp    $0x1,%rax
jne    1e80 <trstlp+0xd60>
test   $0x1,%dl
je     1d30 <trstlp+0xc10>
add    %rsi,%rcx
mov    0x18(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm2
mulsd  -0x8(%r13,%rsi,8),%xmm2
addsd  %xmm2,%xmm1
movapd %xmm2,%xmm3
xorpd  %xmm10,%xmm3
pxor   %xmm4,%xmm4
cmplesd %xmm2,%xmm4
andpd  %xmm4,%xmm2
andnpd %xmm3,%xmm4
orpd   %xmm2,%xmm4
addsd  %xmm4,%xmm0
jmp    1d30 <trstlp+0xc10>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm15,%xmm0
mulsd  %xmm15,%xmm0
movapd %xmm6,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
ucomisd %xmm9,%xmm1
jae    1fed <trstlp+0xecd>
movapd %xmm1,%xmm0
mov    %r11,0x108(%rsp)
movapd %xmm15,0x190(%rsp)
movapd %xmm6,0x180(%rsp)
call   1040 <sqrt@plt>
movapd 0x180(%rsp),%xmm6
movapd 0x190(%rsp),%xmm15
mov    0x108(%rsp),%r11
movapd 0x110(%rsp),%xmm14
movapd 0x408a(%rip),%xmm12
movapd 0x4091(%rip),%xmm11
movapd 0x4078(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x258(%rsp),%r10
mov    0x260(%rsp),%r8
divsd  %xmm0,%xmm6
divsd  %xmm0,%xmm15
mov    0x40(%rsp),%rax
mov    (%rax),%r9d
test   %r9d,%r9d
jle    1d96 <trstlp+0xc76>
movapd %xmm15,%xmm1
xorpd  %xmm10,%xmm1
lea    0x1(%r9),%rcx
mov    $0x1,%edx
cmp    $0x2,%r9
jb     20d0 <trstlp+0xfb0>
mov    0x70(%rsp),%rax
lea    (%rax,%rcx,8),%rsi
mov    0xc0(%rsp),%rax
lea    (%rax,%rcx,8),%rax
cmp    %rax,0x80(%rsp)
jae    204e <trstlp+0xf2e>
cmp    %rsi,0x20(%rsp)
jb     20d0 <trstlp+0xfb0>
mov    %r9d,%esi
and    $0xfffffffe,%esi
mov    %r9,%rdx
or     $0x1,%rdx
movapd %xmm15,%xmm8
unpcklpd %xmm15,%xmm8
movapd %xmm6,%xmm13
movapd %xmm6,%xmm2
unpcklpd %xmm6,%xmm2
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
xor    %edi,%edi
nopl   0x0(%rax)
movupd (%r15,%rdi,8),%xmm5
movupd (%r12,%rdi,8),%xmm6
movapd %xmm8,%xmm7
mulpd  %xmm6,%xmm7
movapd %xmm2,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm7,%xmm3
mulpd  %xmm4,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%r12,%rdi,8)
movupd %xmm3,(%r15,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rsi
jne    2080 <trstlp+0xf60>
cmp    %rsi,%r9
movapd %xmm13,%xmm6
je     1d96 <trstlp+0xc76>
movsd  (%rbx,%rdx,8),%xmm2
movsd  0x0(%rbp,%rdx,8),%xmm3
movapd %xmm15,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm6,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm1,%xmm2
mulsd  %xmm6,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%rbp,%rdx,8)
movsd  %xmm5,(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    20d0 <trstlp+0xfb0>
jmp    1d96 <trstlp+0xc76>
cs nopw 0x0(%rax,%rax,1)
nop
jge    305f <trstlp+0x1f3f>
movslq %edi,%rbp
mov    -0x4(%r14,%rbp,4),%eax
mov    %eax,0x90(%rsp)
movsd  -0x8(%r8,%rbp,8),%xmm0
movsd  %xmm0,0xd8(%rsp)
movslq %r15d,%r11
lea    0x1(%rbp),%rax
mov    0x8(%rsp),%rcx
imul   %rcx,%rax
mov    0x140(%rsp),%rsi
lea    (%rsi,%rax,1),%rdx
mov    %rdx,0xe8(%rsp)
mov    0xf8(%rsp),%rdx
lea    (%rax,%rdx,1),%rdi
mov    %rdi,0xe0(%rsp)
imul   %rbp,%rcx
add    %rcx,%rsi
mov    %rsi,0x108(%rsp)
add    %rcx,%rdx
mov    %rdx,0x190(%rsp)
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,8),%r15
lea    (%rdx,%rax,8),%r12
mov    0x18(%rsp),%rdx
lea    (%rdx,%rcx,8),%rbx
mov    %r14,%rsi
lea    (%rdx,%rax,8),%r14
xor    %ecx,%ecx
mov    %r11,0x130(%rsp)
jmp    220e <trstlp+0x10ee>
mov    0x248(%rsp),%rsi
mov    0x80(%rsp),%eax
mov    %eax,-0x4(%rsi,%rbp,4)
movsd  (%r8,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%r8,%rbp,8)
mov    0xc0(%rsp),%rcx
add    $0x1,%rcx
mov    0x1a8(%rsp),%rax
add    %rax,%r15
add    %rax,%r12
add    %rax,%rbx
add    %rax,%r14
mov    0x70(%rsp),%rbp
cmp    %r11,%rbp
je     3020 <trstlp+0x1f00>
mov    %rcx,0xc0(%rsp)
mov    %rcx,%rax
imul   0x8(%rsp),%rax
mov    0xe8(%rsp),%rcx
add    %rax,%rcx
mov    0x250(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x20(%rsp)
mov    0xe0(%rsp),%rcx
add    %rax,%rcx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0xa0(%rsp)
mov    0x108(%rsp),%rcx
add    %rax,%rcx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x50(%rsp)
add    0x190(%rsp),%rax
lea    (%rdx,%rax,8),%rax
mov    %rax,0x98(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0x70(%rsp)
mov    (%rsi,%rbp,4),%eax
mov    %eax,0x80(%rsp)
mov    0x40(%rsp),%rax
mov    (%rax),%edx
xorpd  %xmm7,%xmm7
test   %edx,%edx
jle    234b <trstlp+0x122b>
mov    %rbp,%r9
mov    0x8(%rsp),%rcx
imul   %rcx,%r9
mov    0x80(%rsp),%eax
imul   %ecx,%eax
movslq %eax,%r8
xorpd  %xmm7,%xmm7
mov    $0x1,%esi
cmp    $0x1,%edx
je     2326 <trstlp+0x1206>
mov    0x60(%rsp),%rax
lea    (%rax,%r8,8),%rdi
add    $0xfffffffffffffff8,%rdi
mov    %edx,%eax
and    $0xfffffffe,%eax
neg    %rax
xorpd  %xmm0,%xmm0
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%r15,%rsi,8),%xmm1
mulsd  -0x8(%rdi,%rsi,8),%xmm1
movsd  (%r15,%rsi,8),%xmm7
addsd  %xmm0,%xmm1
mulsd  (%rdi,%rsi,8),%xmm7
addsd  %xmm1,%xmm7
lea    (%rax,%rsi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rsi
movapd %xmm7,%xmm0
cmp    $0x1,%rcx
jne    22f0 <trstlp+0x11d0>
test   $0x1,%dl
je     234b <trstlp+0x122b>
add    %rsi,%r9
mov    0x18(%rsp),%rax
movsd  (%rax,%r9,8),%xmm0
add    %rsi,%r8
mov    0x28(%rsp),%rax
mulsd  (%rax,%r8,8),%xmm0
addsd  %xmm0,%xmm7
movsd  (%r10,%rbp,8),%xmm0
mulsd  %xmm0,%xmm0
movapd %xmm7,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
ucomisd %xmm9,%xmm1
jae    23c4 <trstlp+0x12a4>
movapd %xmm1,%xmm0
movapd %xmm7,0x180(%rsp)
call   1040 <sqrt@plt>
movapd 0x180(%rsp),%xmm7
mov    0x130(%rsp),%r11
movapd 0x110(%rsp),%xmm14
movapd 0x3cab(%rip),%xmm12
movapd 0x3cb2(%rip),%xmm11
movapd 0x3c99(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x258(%rsp),%r10
movsd  (%r10,%rbp,8),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm7
movsd  -0x8(%r10,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r10,%rbp,8)
movsd  %xmm0,-0x8(%r10,%rbp,8)
mov    0x40(%rsp),%rax
mov    (%rax),%edx
test   %edx,%edx
mov    0x268(%rsp),%r9
mov    0x260(%rsp),%r8
jle    21c0 <trstlp+0x10a0>
movapd %xmm7,%xmm0
xorpd  %xmm10,%xmm0
lea    0x1(%rdx),%rax
mov    $0x1,%ecx
cmp    $0x2,%rdx
jb     24d0 <trstlp+0x13b0>
mov    0xa0(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
mov    0x98(%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
cmp    %rdi,0x20(%rsp)
jae    244f <trstlp+0x132f>
cmp    %rsi,0x50(%rsp)
jb     24d0 <trstlp+0x13b0>
mov    %edx,%esi
and    $0xfffffffe,%esi
mov    %rdx,%rcx
or     $0x1,%rcx
movapd %xmm7,%xmm8
unpcklpd %xmm7,%xmm8
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
movapd %xmm0,%xmm15
unpcklpd %xmm0,%xmm15
xor    %edi,%edi
nopl   0x0(%rax)
movupd (%r12,%rdi,8),%xmm5
movupd (%r15,%rdi,8),%xmm6
movapd %xmm8,%xmm4
mulpd  %xmm6,%xmm4
movapd %xmm2,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm4,%xmm3
mulpd  %xmm15,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%r12,%rdi,8)
movupd %xmm3,(%r15,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rsi
jne    2480 <trstlp+0x1360>
cmp    %rsi,%rdx
je     21c0 <trstlp+0x10a0>
nopl   0x0(%rax)
movsd  (%r14,%rcx,8),%xmm2
movsd  (%rbx,%rcx,8),%xmm3
movapd %xmm7,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r14,%rcx,8)
movsd  %xmm5,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    24d0 <trstlp+0x13b0>
jmp    21c0 <trstlp+0x10a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
ucomisd %xmm9,%xmm0
mov    0x278(%rsp),%rbx
mov    0x248(%rsp),%r14
mov    0x10(%rsp),%r15
jne    253e <trstlp+0x141e>
jnp    2590 <trstlp+0x1470>
add    $0x1,%r15d
mov    %r15,0x10(%rsp)
mov    0xa0(%rsp),%rdx
lea    0x1(%rdx),%rax
movsd  %xmm0,(%r10,%rdx,8)
movsd  (%r8,%rdx,8),%xmm0
mov    0x150(%rsp),%rcx
movsd  %xmm0,-0x8(%r8,%rcx,8)
movq   $0x0,(%r8,%rdx,8)
mov    0x58(%rsp),%r15
mov    0x268(%rsp),%r9
mov    0x30(%rsp),%r12
jmp    348b <trstlp+0x236b>
nopl   (%rax)
lea    0x1(%r9),%ecx
movslq %r15d,%r11
mov    0x128(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x70(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,0x80(%rsp)
lea    -0x1(%rcx),%r12
lea    -0x5(%rcx),%r15
mov    %r15,0xc0(%rsp)
shr    $0x2,%r15
add    $0x1,%r15
mov    %r12,%rax
and    $0xfffffffffffffffc,%rax
lea    0x1(%rax),%rdx
mov    %rdx,0xa0(%rsp)
mov    %r15,%rsi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rsi
mov    %rsi,0x98(%rsp)
mov    %rcx,%r10
neg    %r10
mov    0x8(%rsp),%rdx
imul   %r11,%rdx
mov    0x38(%rsp),%rsi
lea    (%rsi,%rdx,8),%r8
mov    %r12,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
mov    %r11,0x20(%rsp)
movsd  0x3a55(%rip),%xmm0
movapd %xmm0,0x130(%rsp)
jmp    266c <trstlp+0x154c>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
mov    0x278(%rsp),%rbx
movsd  %xmm1,-0x8(%rbx,%r11,8)
lea    -0x1(%r11),%rdx
add    0xb8(%rsp),%r8
cmp    $0x1,%r11
mov    %rdx,%r11
jle    2a60 <trstlp+0x1940>
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
xorpd  %xmm2,%xmm2
test   %r9d,%r9d
jle    2769 <trstlp+0x1649>
mov    %r11,%rbx
imul   0x8(%rsp),%rbx
xorpd  %xmm2,%xmm2
mov    $0x1,%esi
xorpd  %xmm0,%xmm0
cmp    $0x2,%ecx
je     2729 <trstlp+0x1609>
xorpd  %xmm2,%xmm2
mov    $0x1,%esi
xorpd  %xmm0,%xmm0
nopl   (%rax)
movsd  -0x8(%r8,%rsi,8),%xmm3
movsd  (%r8,%rsi,8),%xmm4
mulsd  -0x8(%r13,%rsi,8),%xmm3
addsd  %xmm3,%xmm0
movapd %xmm3,%xmm5
xorpd  %xmm12,%xmm5
xorpd  %xmm6,%xmm6
cmplesd %xmm3,%xmm6
andpd  %xmm6,%xmm3
andnpd %xmm5,%xmm6
orpd   %xmm3,%xmm6
mulsd  0x0(%r13,%rsi,8),%xmm4
addsd  %xmm2,%xmm6
addsd  %xmm4,%xmm0
movapd %xmm4,%xmm3
xorpd  %xmm12,%xmm3
xorpd  %xmm2,%xmm2
cmplesd %xmm4,%xmm2
andpd  %xmm2,%xmm4
andnpd %xmm3,%xmm2
orpd   %xmm4,%xmm2
addsd  %xmm6,%xmm2
lea    (%rdi,%rsi,1),%rdx
add    $0x2,%rdx
add    $0x2,%rsi
cmp    $0x1,%rdx
jne    26b0 <trstlp+0x1590>
test   $0x1,%r12b
je     2769 <trstlp+0x1649>
add    %rsi,%rbx
mov    0x18(%rsp),%rdx
movsd  (%rdx,%rbx,8),%xmm3
mulsd  -0x8(%r13,%rsi,8),%xmm3
addsd  %xmm3,%xmm0
movapd %xmm3,%xmm4
xorpd  %xmm10,%xmm4
pxor   %xmm5,%xmm5
cmplesd %xmm3,%xmm5
andpd  %xmm5,%xmm3
andnpd %xmm4,%xmm5
orpd   %xmm3,%xmm5
addsd  %xmm5,%xmm2
movapd %xmm0,%xmm4
xorpd  %xmm10,%xmm4
xorpd  %xmm3,%xmm3
cmplesd %xmm0,%xmm3
movapd %xmm3,%xmm5
andpd  %xmm0,%xmm5
andnpd %xmm4,%xmm3
orpd   %xmm5,%xmm3
unpcklpd %xmm3,%xmm3
movapd %xmm2,%xmm4
unpcklpd %xmm2,%xmm4
mulpd  %xmm11,%xmm3
addpd  %xmm4,%xmm3
ucomisd %xmm2,%xmm3
movapd %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
jbe    2644 <trstlp+0x1524>
ucomisd %xmm3,%xmm2
jbe    2644 <trstlp+0x1524>
mov    0x258(%rsp),%rdx
divsd  -0x8(%rdx,%r11,8),%xmm0
ucomisd %xmm9,%xmm0
mov    0x278(%rsp),%rbx
jbe    2836 <trstlp+0x1716>
mov    0x248(%rsp),%rdx
mov    -0x4(%rdx,%r11,4),%edx
mov    0xb0(%rsp),%rsi
cmp    (%rsi),%edx
jg     2836 <trstlp+0x1716>
mov    0x260(%rsp),%rdx
movsd  -0x8(%rdx,%r11,8),%xmm1
divsd  %xmm0,%xmm1
movapd 0x130(%rsp),%xmm4
movapd %xmm4,%xmm2
cmpltsd %xmm9,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm1,%xmm3
minsd  %xmm4,%xmm1
andnpd %xmm1,%xmm2
orpd   %xmm3,%xmm2
movapd %xmm2,0x130(%rsp)
cmp    $0x2,%r11
jl     2a50 <trstlp+0x1930>
test   %r9d,%r9d
jle    2a50 <trstlp+0x1930>
mov    0x248(%rsp),%rdx
movslq -0x4(%rdx,%r11,4),%rbx
imul   0x8(%rsp),%rbx
movapd %xmm0,%xmm1
xorpd  %xmm10,%xmm1
mov    $0x1,%esi
cmp    $0x4,%r12
jb     29c0 <trstlp+0x18a0>
mov    0x60(%rsp),%rdx
lea    (%rdx,%rbx,8),%rdx
add    $0xfffffffffffffff8,%rdx
mov    0x80(%rsp),%rbp
lea    0x0(%rbp,%rbx,8),%rbp
cmp    %r13,%rbp
jbe    289e <trstlp+0x177e>
cmp    0x70(%rsp),%rdx
jb     29c0 <trstlp+0x18a0>
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
mov    $0x0,%esi
cmpq   $0x4,0xc0(%rsp)
jb     295a <trstlp+0x183a>
mov    0x60(%rsp),%rdx
lea    (%rdx,%rbx,8),%rbp
add    $0x28,%rbp
mov    0x98(%rsp),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rbp,%rsi,8),%xmm3
movupd -0x20(%rbp,%rsi,8),%xmm4
mulpd  %xmm2,%xmm3
movupd 0x0(%r13,%rsi,8),%xmm5
addpd  %xmm3,%xmm5
movupd 0x10(%r13,%rsi,8),%xmm3
movupd 0x20(%r13,%rsi,8),%xmm6
movupd 0x30(%r13,%rsi,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,0x0(%r13,%rsi,8)
movupd %xmm4,0x10(%r13,%rsi,8)
movupd -0x10(%rbp,%rsi,8),%xmm3
movupd 0x0(%rbp,%rsi,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,0x20(%r13,%rsi,8)
movupd %xmm4,0x30(%r13,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdx
jne    28e0 <trstlp+0x17c0>
test   $0x1,%r15b
je     29a5 <trstlp+0x1885>
or     $0x1,%rsi
lea    (%rsi,%rbx,1),%rdx
mov    0x28(%rsp),%rbp
movupd 0x0(%rbp,%rdx,8),%xmm3
movupd 0x10(%rbp,%rdx,8),%xmm4
movupd -0x8(%r13,%rsi,8),%xmm5
movupd 0x8(%r13,%rsi,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,-0x8(%r13,%rsi,8)
movupd %xmm4,0x8(%r13,%rsi,8)
mov    0xa0(%rsp),%rsi
cmp    %rax,%r12
je     2640 <trstlp+0x1520>
cs nopw 0x0(%rax,%rax,1)
mov    %rsi,%rdx
not    %rdx
test   $0x1,%cl
jne    29f0 <trstlp+0x18d0>
lea    (%rsi,%rbx,1),%rbp
mov    0x28(%rsp),%r14
movsd  (%r14,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  -0x8(%r13,%rsi,8),%xmm2
movsd  %xmm2,-0x8(%r13,%rsi,8)
add    $0x1,%rsi
cmp    %r10,%rdx
je     2640 <trstlp+0x1520>
mov    0x28(%rsp),%rdx
lea    (%rdx,%rbx,8),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  -0x8(%r13,%rsi,8),%xmm2
movsd  %xmm2,-0x8(%r13,%rsi,8)
movsd  0x8(%rdx,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x0(%r13,%rsi,8),%xmm2
movsd  %xmm2,0x0(%r13,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rcx
jne    2a10 <trstlp+0x18f0>
jmp    2640 <trstlp+0x1520>
nopl   (%rax)
movapd %xmm0,%xmm1
jmp    264c <trstlp+0x152c>
nopl   0x0(%rax)
ucomisd 0x130(%rsp),%xmm9
mov    0x30(%rsp),%r12
ja     514d <trstlp+0x402d>
cmpl   $0x0,0x10(%rsp)
mov    0x58(%rsp),%r15
mov    0x260(%rsp),%r8
mov    0xf8(%rsp),%r10
mov    0x248(%rsp),%r14
jle    2c02 <trstlp+0x1ae2>
movapd 0x130(%rsp),%xmm0
xorpd  %xmm10,%xmm0
mov    0x10(%rsp),%rax
mov    %eax,%esi
lea    0x1(%rsi),%rcx
mov    $0x1,%edx
cmp    $0x4,%eax
jb     2b65 <trstlp+0x1a45>
mov    0x1c0(%rsp),%rax
lea    (%rax,%rcx,8),%rdi
mov    0x1b8(%rsp),%rax
lea    (%rax,%rcx,8),%rax
cmp    %r8,%rax
mov    %rbx,%rax
jbe    2ae9 <trstlp+0x19c9>
cmp    %rax,%rdi
ja     2b65 <trstlp+0x1a45>
mov    %esi,%edi
and    $0xfffffffc,%edi
lea    0x1(%rdi),%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %ebp,%ebp
nopl   0x0(%rax)
movupd (%r8,%rbp,8),%xmm2
movupd 0x10(%r8,%rbp,8),%xmm3
movupd (%rax,%rbp,8),%xmm4
movupd 0x10(%rax,%rbp,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm4,%xmm2
xorpd  %xmm6,%xmm6
cmpnlepd %xmm6,%xmm2
andpd  %xmm4,%xmm2
movapd %xmm5,%xmm3
cmpnlepd %xmm6,%xmm3
andpd  %xmm5,%xmm3
movupd %xmm2,(%r8,%rbp,8)
movupd %xmm3,0x10(%r8,%rbp,8)
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    2b00 <trstlp+0x19e0>
cmp    %rdi,%rsi
je     2c02 <trstlp+0x1ae2>
mov    %rdx,%rsi
not    %rsi
test   $0x1,%cl
jne    2b9a <trstlp+0x1a7a>
movsd  -0x8(%rbx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r8,%rdx,8),%xmm1
movapd %xmm1,%xmm2
cmplesd %xmm9,%xmm2
andnpd %xmm1,%xmm2
movlpd %xmm2,-0x8(%r8,%rdx,8)
add    $0x1,%rdx
add    %rcx,%rsi
je     2c02 <trstlp+0x1ae2>
mov    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rax,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r8,%rdx,8),%xmm1
movapd %xmm1,%xmm2
cmplesd %xmm9,%xmm2
andnpd %xmm1,%xmm2
movlpd %xmm2,-0x8(%r8,%rdx,8)
movsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r8,%rdx,8),%xmm1
movapd %xmm1,%xmm2
cmplesd %xmm9,%xmm2
andnpd %xmm1,%xmm2
movlpd %xmm2,(%r8,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rcx
jne    2bb0 <trstlp+0x1a90>
mov    0x90(%rsp),%rax
cmp    0x10(%rsp),%eax
jge    3324 <trstlp+0x2204>
mov    0x150(%rsp),%rbx
mov    -0x4(%r14,%rbx,4),%eax
mov    %eax,0x17c(%rsp)
movsd  -0x8(%r8,%rbx,8),%xmm0
movsd  %xmm0,0x1d0(%rsp)
lea    0x1(%rbx),%rax
mov    0x8(%rsp),%rcx
imul   %rcx,%rax
mov    0x140(%rsp),%rdx
lea    (%rdx,%rax,1),%r11
lea    (%rax,%r10,1),%rsi
mov    %rsi,0xe0(%rsp)
imul   %rbx,%rcx
add    %rcx,%rdx
mov    %rdx,0x108(%rsp)
lea    (%rcx,%r10,1),%rdx
mov    %rdx,0x190(%rsp)
mov    0x38(%rsp),%rdx
lea    (%rdx,%rcx,8),%r14
lea    (%rdx,%rax,8),%r15
mov    0x18(%rsp),%rdx
lea    (%rdx,%rcx,8),%r12
lea    (%rdx,%rax,8),%rbp
xor    %ecx,%ecx
mov    %r11,0x90(%rsp)
nopl   0x0(%rax)
mov    %rcx,0xc0(%rsp)
mov    %rcx,%rax
imul   0x8(%rsp),%rax
lea    (%r11,%rax,1),%rcx
mov    0x250(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0xa0(%rsp)
mov    0xe0(%rsp),%rcx
add    %rax,%rcx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0x98(%rsp)
mov    0x108(%rsp),%rcx
add    %rax,%rcx
lea    (%rdx,%rcx,8),%rcx
mov    %rcx,0xe8(%rsp)
add    0x190(%rsp),%rax
lea    (%rdx,%rax,8),%rax
mov    %rax,0x50(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x70(%rsp)
mov    0x248(%rsp),%rax
mov    (%rax,%rbx,4),%eax
mov    %eax,0x80(%rsp)
xorpd  %xmm7,%xmm7
test   %r9d,%r9d
jle    2de3 <trstlp+0x1cc3>
mov    %rbx,%rcx
mov    0x8(%rsp),%rdx
imul   %rdx,%rcx
mov    0x80(%rsp),%eax
imul   %edx,%eax
movslq %eax,%r10
mov    %r9d,%r8d
xorpd  %xmm7,%xmm7
mov    $0x1,%edi
cmp    $0x1,%r9d
je     2db6 <trstlp+0x1c96>
mov    0x60(%rsp),%rax
lea    (%rax,%r10,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %r8d,%esi
and    $0xfffffffe,%esi
neg    %rsi
xorpd  %xmm0,%xmm0
mov    $0x1,%edi
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r14,%rdi,8),%xmm1
mulsd  -0x8(%rax,%rdi,8),%xmm1
movsd  (%r14,%rdi,8),%xmm7
addsd  %xmm0,%xmm1
mulsd  (%rax,%rdi,8),%xmm7
addsd  %xmm1,%xmm7
lea    (%rsi,%rdi,1),%rdx
add    $0x2,%rdx
add    $0x2,%rdi
movapd %xmm7,%xmm0
cmp    $0x1,%rdx
jne    2d80 <trstlp+0x1c60>
test   $0x1,%r8b
mov    0x260(%rsp),%r8
je     2de3 <trstlp+0x1cc3>
add    %rdi,%rcx
mov    0x18(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
add    %rdi,%r10
mov    0x28(%rsp),%rax
mulsd  (%rax,%r10,8),%xmm0
addsd  %xmm0,%xmm7
mov    0x258(%rsp),%r10
movsd  (%r10,%rbx,8),%xmm0
mulsd  %xmm0,%xmm0
movapd %xmm7,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
ucomisd %xmm9,%xmm1
jae    2e6c <trstlp+0x1d4c>
movapd %xmm1,%xmm0
movapd %xmm7,0x180(%rsp)
call   1040 <sqrt@plt>
movapd 0x180(%rsp),%xmm7
mov    0x90(%rsp),%r11
movapd 0x110(%rsp),%xmm14
movapd 0x320b(%rip),%xmm12
movapd 0x3212(%rip),%xmm11
movapd 0x31f9(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x258(%rsp),%r10
mov    0x260(%rsp),%r8
movsd  (%r10,%rbx,8),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm7
movsd  -0x8(%r10,%rbx,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,(%r10,%rbx,8)
movsd  %xmm0,-0x8(%r10,%rbx,8)
mov    0x40(%rsp),%rax
mov    (%rax),%edx
test   %edx,%edx
jle    2fb1 <trstlp+0x1e91>
movapd %xmm7,%xmm0
xorpd  %xmm10,%xmm0
lea    0x1(%rdx),%rax
mov    $0x1,%ecx
cmp    $0x2,%rdx
jb     2f70 <trstlp+0x1e50>
mov    0x98(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
mov    0x50(%rsp),%rdi
lea    (%rdi,%rax,8),%rdi
cmp    %rdi,0xa0(%rsp)
jae    2eea <trstlp+0x1dca>
cmp    %rsi,0xe8(%rsp)
jb     2f70 <trstlp+0x1e50>
mov    %edx,%esi
and    $0xfffffffe,%esi
mov    %rdx,%rcx
or     $0x1,%rcx
movapd %xmm7,%xmm8
unpcklpd %xmm7,%xmm8
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
movapd %xmm0,%xmm15
unpcklpd %xmm0,%xmm15
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%r15,%rdi,8),%xmm5
movupd (%r14,%rdi,8),%xmm6
movapd %xmm8,%xmm4
mulpd  %xmm6,%xmm4
movapd %xmm2,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm4,%xmm3
mulpd  %xmm15,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%r15,%rdi,8)
movupd %xmm3,(%r14,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rsi
jne    2f20 <trstlp+0x1e00>
cmp    %rsi,%rdx
je     2fb1 <trstlp+0x1e91>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm2
movsd  (%r12,%rcx,8),%xmm3
movapd %xmm7,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%rbp,%rcx,8)
movsd  %xmm5,(%r12,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2f70 <trstlp+0x1e50>
mov    0x248(%rsp),%rax
mov    0x80(%rsp),%ecx
mov    %ecx,-0x4(%rax,%rbx,4)
movsd  (%r8,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%r8,%rbx,8)
mov    0x20(%rsp),%rax
mov    0x70(%rsp),%rbx
cmp    %rax,%rbx
je     3336 <trstlp+0x2216>
mov    0x40(%rsp),%rax
mov    (%rax),%r9d
mov    0xc0(%rsp),%rcx
add    $0x1,%rcx
mov    0x1a8(%rsp),%rax
add    %rax,%r14
add    %rax,%r15
add    %rax,%r12
add    %rax,%rbp
jmp    2ca0 <trstlp+0x1b80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x90(%rsp),%eax
mov    %eax,-0x4(%rsi,%r11,4)
movsd  0xd8(%rsp),%xmm0
movsd  %xmm0,-0x8(%r8,%r11,8)
mov    0xb0(%rsp),%rax
mov    (%rax),%eax
mov    %eax,0x50(%rsp)
mov    0x278(%rsp),%rbx
mov    %rsi,%r14
mov    0x30(%rsp),%r12
mov    0x10(%rsp),%r15
lea    -0x1(%r15),%r11d
cmp    0x50(%rsp),%r12d
jg     37ef <trstlp+0x26cf>
mov    0x40(%rsp),%rax
mov    (%rax),%r12d
test   %r12d,%r12d
jle    3d80 <trstlp+0x2c60>
mov    %r15d,%eax
imul   0x8(%rsp),%eax
movslq %eax,%r9
lea    0x1(%r12),%rdx
lea    -0x1(%r12),%rax
mov    %r12d,%edi
and    $0x3,%edi
xorpd  %xmm0,%xmm0
mov    $0x1,%esi
cmp    $0x3,%rax
jb     311c <trstlp+0x1ffc>
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    0x38(%rsp),%rcx
lea    (%rcx,%r9,8),%rcx
add    $0x18,%rcx
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x268(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rsi,8),%xmm1
movsd  0x8(%rbp,%rsi,8),%xmm2
mulsd  -0x18(%rcx,%rsi,8),%xmm1
mulsd  -0x10(%rcx,%rsi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%rbp,%rsi,8),%xmm3
mulsd  -0x8(%rcx,%rsi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rbp,%rsi,8),%xmm0
mulsd  (%rcx,%rsi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rsi
cmp    %rsi,%rax
jne    30d0 <trstlp+0x1fb0>
add    $0x1,%rsi
test   %rdi,%rdi
je     3157 <trstlp+0x2037>
lea    (%rsi,%r9,1),%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  (%rcx,%rsi,8),%xmm1
mulsd  (%rax,%rsi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    3140 <trstlp+0x2020>
test   %r12d,%r12d
jle    3d62 <trstlp+0x2c42>
imul   0x8(%rsp),%r15d
xorpd  %xmm10,%xmm0
movslq %r15d,%r14
lea    -0x1(%rdx),%r10
mov    $0x1,%edi
cmp    $0x4,%r10
jb     3ca8 <trstlp+0x2b88>
mov    0xd0(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%r14,8),%rcx
lea    (%r14,%rdx,1),%rsi
mov    0x18(%rsp),%rbp
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
cmp    0x268(%rsp),%rsi
jbe    31bd <trstlp+0x209d>
cmp    %rax,%rcx
jb     3ca8 <trstlp+0x2b88>
mov    %r11d,%r15d
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    0x1(%r8),%rdi
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r8),%rax
mov    %rax,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    $0x0,%esi
test   %rax,%rax
mov    0x268(%rsp),%rax
je     3290 <trstlp+0x2170>
mov    %r11,%rbx
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rbx
mov    0x38(%rsp),%rcx
lea    (%rcx,%r9,8),%rbp
add    $0x30,%rbp
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rbp,%rsi,8),%xmm2
movupd -0x20(%rbp,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rax,%rsi,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rax,%rsi,8),%xmm2
movupd 0x20(%rax,%rsi,8),%xmm5
movupd 0x30(%rax,%rsi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rax,%rsi,8)
movupd %xmm3,0x10(%rax,%rsi,8)
movupd -0x10(%rbp,%rsi,8),%xmm2
movupd 0x0(%rbp,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rax,%rsi,8)
movupd %xmm3,0x30(%rax,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rbx
jne    3220 <trstlp+0x2100>
test   $0x1,%r11b
je     32de <trstlp+0x21be>
or     $0x1,%rsi
lea    (%rsi,%r14,1),%rax
mov    0x18(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm2
movupd 0x10(%rcx,%rax,8),%xmm3
mov    0x268(%rsp),%rax
movupd -0x8(%rax,%rsi,8),%xmm4
movupd 0x8(%rax,%rsi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x8(%rax,%rsi,8)
movupd %xmm3,0x8(%rax,%rsi,8)
cmp    %r8,%r10
mov    0x278(%rsp),%rbx
mov    0x260(%rsp),%r8
mov    %r15d,%r11d
jne    3ca8 <trstlp+0x2b88>
mov    %r11d,%eax
mov    %rax,0x10(%rsp)
mov    0x58(%rsp),%r15
mov    0x268(%rsp),%r9
mov    0x258(%rsp),%r10
mov    0x248(%rsp),%r14
jmp    3e1d <trstlp+0x2cfd>
mov    0x258(%rsp),%r10
test   %r9d,%r9d
jg     337d <trstlp+0x225d>
jmp    5174 <trstlp+0x4054>
mov    0x248(%rsp),%r14
mov    0x17c(%rsp),%ecx
mov    %ecx,-0x4(%r14,%rax,4)
movsd  0x1d0(%rsp),%xmm0
movsd  %xmm0,-0x8(%r8,%rax,8)
mov    0x40(%rsp),%rax
mov    (%rax),%r9d
mov    0x58(%rsp),%r15
mov    0x278(%rsp),%rbx
mov    0x30(%rsp),%r12
test   %r9d,%r9d
jle    5174 <trstlp+0x4054>
mov    0x10(%rsp),%rax
mov    0x8(%rsp),%rdx
imul   %edx,%eax
mov    0xd8(%rsp),%ecx
imul   %edx,%ecx
movslq %eax,%rdx
movslq %ecx,%rcx
mov    %r9d,%r8d
xorpd  %xmm0,%xmm0
mov    $0x1,%edi
cmp    $0x1,%r9d
je     3415 <trstlp+0x22f5>
mov    0x60(%rsp),%rax
lea    (%rax,%rcx,8),%rax
add    $0xfffffffffffffff8,%rax
mov    0x38(%rsp),%rsi
lea    (%rsi,%rdx,8),%rbp
mov    %r8d,%esi
and    $0xfffffffe,%esi
neg    %rsi
xorpd  %xmm1,%xmm1
mov    $0x1,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rbp,%rdi,8),%xmm2
mulsd  -0x8(%rax,%rdi,8),%xmm2
movsd  0x0(%rbp,%rdi,8),%xmm0
addsd  %xmm1,%xmm2
mulsd  (%rax,%rdi,8),%xmm0
addsd  %xmm2,%xmm0
lea    (%rsi,%rdi,1),%rbx
add    $0x2,%rbx
add    $0x2,%rdi
movapd %xmm0,%xmm1
cmp    $0x1,%rbx
jne    33e0 <trstlp+0x22c0>
test   $0x1,%r8b
je     3439 <trstlp+0x2319>
add    %rdi,%rdx
mov    0x18(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm1
add    %rdi,%rcx
mov    0x28(%rsp),%rax
mulsd  (%rax,%rcx,8),%xmm1
addsd  %xmm1,%xmm0
ucomisd %xmm9,%xmm0
mov    0x278(%rsp),%rbx
mov    0x268(%rsp),%r9
mov    0x260(%rsp),%r8
mov    0x150(%rsp),%rcx
jne    3466 <trstlp+0x2346>
jnp    517c <trstlp+0x405c>
mov    0x20(%rsp),%rax
movsd  %xmm0,-0x8(%r10,%rax,8)
movq   $0x0,-0x8(%r8,%rcx,8)
movapd 0x130(%rsp),%xmm0
movsd  %xmm0,-0x8(%r8,%rax,8)
mov    %rax,%rdx
mov    -0x4(%r14,%rax,4),%eax
mov    %eax,-0x4(%r14,%rcx,4)
mov    0xd8(%rsp),%ecx
mov    %rdx,0x20(%rsp)
mov    %ecx,-0x4(%r14,%rdx,4)
mov    0xb0(%rsp),%rax
mov    (%rax),%eax
cmp    %eax,%r12d
jle    37de <trstlp+0x26be>
cmp    %r12d,%ecx
je     37de <trstlp+0x26be>
mov    0x10(%rsp),%rax
lea    -0x1(%rax),%ebx
mov    0x40(%rsp),%rax
mov    (%rax),%ecx
xorpd  %xmm7,%xmm7
test   %ecx,%ecx
jle    358a <trstlp+0x246a>
mov    %ebx,%eax
mov    0x8(%rsp),%rdx
imul   %edx,%eax
mov    0xd8(%rsp),%esi
imul   %edx,%esi
movslq %eax,%r9
movslq %esi,%r8
xorpd  %xmm7,%xmm7
mov    $0x1,%esi
cmp    $0x1,%ecx
je     3565 <trstlp+0x2445>
mov    0x60(%rsp),%rax
lea    (%rax,%r8,8),%rdi
add    $0xfffffffffffffff8,%rdi
mov    0x38(%rsp),%rax
lea    (%rax,%r9,8),%rbp
mov    %ecx,%eax
and    $0xfffffffe,%eax
neg    %rax
xorpd  %xmm0,%xmm0
mov    $0x1,%esi
nop
movsd  -0x8(%rbp,%rsi,8),%xmm1
mulsd  -0x8(%rdi,%rsi,8),%xmm1
movsd  0x0(%rbp,%rsi,8),%xmm7
addsd  %xmm0,%xmm1
mulsd  (%rdi,%rsi,8),%xmm7
addsd  %xmm1,%xmm7
lea    (%rax,%rsi,1),%rdx
add    $0x2,%rdx
add    $0x2,%rsi
movapd %xmm7,%xmm0
cmp    $0x1,%rdx
jne    3530 <trstlp+0x2410>
test   $0x1,%cl
je     358a <trstlp+0x246a>
add    %rsi,%r9
mov    0x18(%rsp),%rax
movsd  (%rax,%r9,8),%xmm0
add    %rsi,%r8
mov    0x28(%rsp),%rax
mulsd  (%rax,%r8,8),%xmm0
addsd  %xmm0,%xmm7
mov    0x20(%rsp),%rax
movsd  -0x8(%r10,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movapd %xmm7,%xmm1
mulsd  %xmm7,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
ucomisd %xmm9,%xmm1
jae    3606 <trstlp+0x24e6>
movapd %xmm1,%xmm0
movapd %xmm7,0x80(%rsp)
call   1040 <sqrt@plt>
movapd 0x80(%rsp),%xmm7
mov    0x20(%rsp),%rax
movapd 0x110(%rsp),%xmm14
movapd 0x2a69(%rip),%xmm12
movapd 0x2a70(%rip),%xmm11
movapd 0x2a57(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x258(%rsp),%r10
movsd  -0x8(%r10,%rax,8),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm7
mov    %rax,%rcx
movslq %ebx,%rax
movsd  -0x8(%r10,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,-0x8(%r10,%rcx,8)
movsd  %xmm0,-0x8(%r10,%rax,8)
mov    0x40(%rsp),%rcx
mov    (%rcx),%r10d
test   %r10d,%r10d
jle    377d <trstlp+0x265d>
mov    0x10(%rsp),%rcx
mov    0x8(%rsp),%rdx
imul   %edx,%ecx
imul   %edx,%ebx
movapd %xmm7,%xmm0
xorpd  %xmm10,%xmm0
movslq %ecx,%r8
movslq %ebx,%r9
lea    0x1(%r10),%rcx
mov    $0x1,%edx
cmp    $0x2,%r10
jb     3724 <trstlp+0x2604>
mov    0x38(%rsp),%rdi
lea    (%rdi,%r8,8),%rbx
lea    (%r8,%rcx,1),%rsi
mov    0x18(%rsp),%r12
lea    (%r12,%rsi,8),%rsi
lea    (%rdi,%r9,8),%rdi
lea    (%r9,%rcx,1),%rbp
lea    (%r12,%rbp,8),%rbp
mov    0x30(%rsp),%r12
cmp    %rbp,%rbx
jae    36a8 <trstlp+0x2588>
cmp    %rsi,%rdi
jb     3724 <trstlp+0x2604>
mov    %r10d,%esi
and    $0xfffffffe,%esi
mov    %r10,%rdx
or     $0x1,%rdx
movapd %xmm7,%xmm8
unpcklpd %xmm7,%xmm8
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
movapd %xmm0,%xmm15
unpcklpd %xmm0,%xmm15
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rbx,%rbp,8),%xmm5
movupd (%rdi,%rbp,8),%xmm6
movapd %xmm8,%xmm4
mulpd  %xmm6,%xmm4
movapd %xmm2,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm4,%xmm3
mulpd  %xmm15,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%rbx,%rbp,8)
movupd %xmm3,(%rdi,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%rsi
jne    36e0 <trstlp+0x25c0>
cmp    %rsi,%r10
je     377d <trstlp+0x265d>
mov    0x18(%rsp),%rdi
lea    (%rdi,%r9,8),%rsi
lea    (%rdi,%r8,8),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,8),%xmm2
movsd  (%rsi,%rdx,8),%xmm3
movapd %xmm7,%xmm4
mulsd  %xmm3,%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rdi,%rdx,8)
movsd  %xmm5,(%rsi,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    3740 <trstlp+0x2620>
mov    -0x4(%r14,%rax,4),%ecx
mov    0x20(%rsp),%rdx
mov    %ecx,-0x4(%r14,%rdx,4)
mov    0xd8(%rsp),%ecx
mov    %ecx,-0x4(%r14,%rax,4)
mov    0x260(%rsp),%r8
movsd  -0x8(%r8,%rax,8),%xmm0
movsd  -0x8(%r8,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%r8,%rax,8)
movsd  %xmm0,-0x8(%r8,%rdx,8)
mov    0xb0(%rsp),%rax
mov    (%rax),%eax
mov    0x278(%rsp),%rbx
mov    0x268(%rsp),%r9
mov    0x258(%rsp),%r10
cmp    %eax,%r12d
jle    39f0 <trstlp+0x28d0>
mov    0x10(%rsp),%rax
mov    %eax,%r11d
movslq %r11d,%rax
movsd  0x288e(%rip),%xmm0
divsd  -0x8(%r10,%rax,8),%xmm0
mov    0x40(%rsp),%rax
mov    (%rax),%r12d
test   %r12d,%r12d
jle    3d80 <trstlp+0x2c60>
mov    %r11d,%eax
imul   0x8(%rsp),%eax
movslq %eax,%rdi
lea    0x1(%r12),%rdx
mov    $0x1,%esi
cmp    $0x4,%r12
jb     3950 <trstlp+0x2830>
mov    0xd0(%rsp),%rax
lea    (%rax,%rdx,8),%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
lea    (%rdi,%rdx,1),%rbp
mov    0x18(%rsp),%r15
lea    (%r15,%rbp,8),%rbp
cmp    %r9,%rbp
jbe    3861 <trstlp+0x2741>
cmp    %rax,%rcx
jb     3950 <trstlp+0x2830>
mov    %r12d,%r8d
and    $0xfffffffc,%r8d
lea    0x1(%r8),%rsi
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r8),%rax
mov    %rax,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    $0x0,%ebx
test   %rax,%rax
je     38fc <trstlp+0x27dc>
mov    %rbp,%rax
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rdi,8),%rcx
add    $0x30,%rcx
xor    %ebx,%ebx
nopl   0x0(%rax)
movupd -0x30(%rcx,%rbx,8),%xmm2
movupd -0x20(%rcx,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r9,%rbx,8)
movupd %xmm3,0x10(%r9,%rbx,8)
movupd -0x10(%rcx,%rbx,8),%xmm2
movupd (%rcx,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r9,%rbx,8)
movupd %xmm3,0x30(%r9,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    38b0 <trstlp+0x2790>
test   $0x1,%bpl
je     3930 <trstlp+0x2810>
or     $0x1,%rbx
lea    (%rbx,%rdi,1),%rax
mov    0x18(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm2
movupd 0x10(%rcx,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x8(%r9,%rbx,8)
movupd %xmm3,0x8(%r9,%rbx,8)
cmp    %r8,%r12
mov    0x278(%rsp),%rbx
mov    0x260(%rsp),%r8
je     3e10 <trstlp+0x2cf0>
nopl   0x0(%rax)
mov    %edx,%ecx
sub    %esi,%ecx
mov    %rsi,%rax
not    %rax
add    %rdx,%rax
and    $0x3,%rcx
je     398b <trstlp+0x286b>
mov    0x18(%rsp),%rbp
lea    0x0(%rbp,%rdi,8),%rbp
nopl   (%rax)
movsd  0x0(%rbp,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r9,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    3970 <trstlp+0x2850>
cmp    $0x3,%rax
jb     3e10 <trstlp+0x2cf0>
mov    0x18(%rsp),%rax
lea    (%rax,%rdi,8),%rax
xchg   %ax,%ax
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r9,%rsi,8)
movsd  0x8(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rsi,8)
movsd  0x10(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r9,%rsi,8)
movsd  0x18(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r9,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    39a0 <trstlp+0x2880>
jmp    3e10 <trstlp+0x2cf0>
mov    0x40(%rsp),%rax
mov    (%rax),%r12d
test   %r12d,%r12d
jle    3c9b <trstlp+0x2b7b>
mov    0x20(%rsp),%rax
movslq -0x4(%r14,%rax,4),%rsi
imul   0x8(%rsp),%rsi
lea    0x1(%r12),%rax
lea    -0x1(%r12),%rcx
mov    %r12d,%edx
and    $0x3,%edx
xorpd  %xmm0,%xmm0
mov    $0x1,%edi
cmp    $0x3,%rcx
jb     3aa0 <trstlp+0x2980>
mov    %r12d,%ecx
and    $0xfffffffc,%ecx
mov    0x60(%rsp),%rdi
lea    (%rdi,%rsi,8),%rbp
add    $0x10,%rbp
xorpd  %xmm0,%xmm0
xor    %edi,%edi
nopl   0x0(%rax)
movsd  (%r9,%rdi,8),%xmm1
movsd  0x8(%r9,%rdi,8),%xmm2
mulsd  -0x18(%rbp,%rdi,8),%xmm1
mulsd  -0x10(%rbp,%rdi,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%r9,%rdi,8),%xmm3
mulsd  -0x8(%rbp,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%r9,%rdi,8),%xmm0
mulsd  0x0(%rbp,%rdi,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    3a50 <trstlp+0x2930>
add    $0x1,%rdi
test   %rdx,%rdx
je     3ad7 <trstlp+0x29b7>
add    %rdi,%rsi
mov    0x28(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    0xd0(%rsp),%rsi
lea    (%rsi,%rdi,8),%rsi
xor    %edi,%edi
nop
movsd  (%rsi,%rdi,8),%xmm1
mulsd  (%rcx,%rdi,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    3ac0 <trstlp+0x29a0>
test   %r12d,%r12d
jle    3c9b <trstlp+0x2b7b>
addsd  0x2598(%rip),%xmm0
mov    0x10(%rsp),%rcx
imul   0x8(%rsp),%ecx
xorpd  %xmm10,%xmm0
mov    0x20(%rsp),%rdx
divsd  -0x8(%r10,%rdx,8),%xmm0
movslq %ecx,%r9
lea    -0x1(%rax),%r10
mov    $0x1,%edx
cmp    $0x4,%r10
jb     3d10 <trstlp+0x2bf0>
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x38(%rsp),%rsi
lea    (%rsi,%r9,8),%rsi
lea    (%r9,%rax,1),%rdi
mov    0x18(%rsp),%rbp
lea    0x0(,%rdi,8),%rdi
add    %rbp,%rdi
cmp    0x268(%rsp),%rdi
jbe    3b55 <trstlp+0x2a35>
cmp    %rcx,%rsi
jb     3d10 <trstlp+0x2bf0>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    0x1(%r8),%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r8),%rcx
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    $0x0,%ebx
test   %rcx,%rcx
mov    0x268(%rsp),%rcx
je     3c1f <trstlp+0x2aff>
mov    %rsi,%rbp
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
and    %rdi,%rbp
mov    0x38(%rsp),%rdi
lea    (%rdi,%r9,8),%rdi
add    $0x30,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax)
movupd -0x30(%rdi,%rbx,8),%xmm2
movupd -0x20(%rdi,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rcx,%rbx,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rcx,%rbx,8),%xmm2
movupd 0x20(%rcx,%rbx,8),%xmm5
movupd 0x30(%rcx,%rbx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rcx,%rbx,8)
movupd %xmm3,0x10(%rcx,%rbx,8)
movupd -0x10(%rdi,%rbx,8),%xmm2
movupd (%rdi,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rcx,%rbx,8)
movupd %xmm3,0x30(%rcx,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    3bb0 <trstlp+0x2a90>
test   $0x1,%sil
je     3c6d <trstlp+0x2b4d>
or     $0x1,%rbx
lea    (%rbx,%r9,1),%rcx
mov    0x18(%rsp),%rsi
movupd (%rsi,%rcx,8),%xmm2
movupd 0x10(%rsi,%rcx,8),%xmm3
mov    0x268(%rsp),%rcx
movupd -0x8(%rcx,%rbx,8),%xmm4
movupd 0x8(%rcx,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x8(%rcx,%rbx,8)
movupd %xmm3,0x8(%rcx,%rbx,8)
cmp    %r8,%r10
mov    0x278(%rsp),%rbx
mov    0x260(%rsp),%r8
jne    3d10 <trstlp+0x2bf0>
mov    0x268(%rsp),%r9
mov    0x258(%rsp),%r10
jmp    3e1d <trstlp+0x2cfd>
mov    0x10(%rsp),%rax
mov    %eax,%r11d
jmp    3d80 <trstlp+0x2c60>
mov    %rdi,%rax
not    %rax
test   $0x1,%dl
jne    3cdd <trstlp+0x2bbd>
add    %rdi,%r14
mov    0x18(%rsp),%rcx
movsd  (%rcx,%r14,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x268(%rsp),%rcx
addsd  -0x8(%rcx,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rdi,8)
add    $0x1,%rdi
mov    0x258(%rsp),%r10
mov    0x248(%rsp),%r14
add    %rdx,%rax
jne    3db8 <trstlp+0x2c98>
mov    %r11d,%eax
mov    %rax,0x10(%rsp)
mov    0x58(%rsp),%r15
mov    0x268(%rsp),%r9
jmp    3e1d <trstlp+0x2cfd>
mov    %rdx,%rcx
not    %rcx
test   $0x1,%al
jne    3d44 <trstlp+0x2c24>
lea    (%rdx,%r9,1),%rsi
mov    0x18(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x268(%rsp),%rsi
addsd  -0x8(%rsi,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rsi,%rdx,8)
add    $0x1,%rdx
mov    0x258(%rsp),%r10
add    %rax,%rcx
jne    50ef <trstlp+0x3fcf>
mov    0x268(%rsp),%r9
jmp    3e1d <trstlp+0x2cfd>
mov    0x268(%rsp),%r9
mov    0x258(%rsp),%r10
mov    0x248(%rsp),%r14
nopw   0x0(%rax,%rax,1)
mov    0x30(%rsp),%r12
mov    0x1a0(%rsp),%rax
movsd  (%rax),%xmm15
mulsd  %xmm15,%xmm15
pxor   %xmm4,%xmm4
mov    %r11d,%eax
mov    %rax,0x10(%rsp)
mov    0x58(%rsp),%r15
ucomisd %xmm15,%xmm9
jb     3ef0 <trstlp+0x2dd0>
jmp    517c <trstlp+0x405c>
mov    0x18(%rsp),%rax
lea    (%rax,%r9,8),%rax
mov    0x268(%rsp),%r9
nopl   0x0(%rax)
movsd  (%rax,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r9,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%r9,%rdi,8)
movsd  0x8(%rax,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r9,%rdi,8),%xmm1
movsd  %xmm1,(%r9,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    3dd0 <trstlp+0x2cb0>
cs nopw 0x0(%rax,%rax,1)
mov    %r11d,%eax
mov    %rax,0x10(%rsp)
mov    0x58(%rsp),%r15
mov    0x1a0(%rsp),%rax
movsd  (%rax),%xmm0
movapd %xmm0,%xmm15
mulsd  %xmm0,%xmm15
pxor   %xmm4,%xmm4
test   %r12d,%r12d
jle    3ee0 <trstlp+0x2dc0>
mulsd  0x2248(%rip),%xmm0
mov    %r12d,%eax
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm2,%xmm1
movsd  (%r15,%rcx,8),%xmm2
movapd %xmm2,%xmm3
xorpd  %xmm10,%xmm3
pxor   %xmm4,%xmm4
cmplesd %xmm2,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm2,%xmm5
andnpd %xmm3,%xmm4
orpd   %xmm5,%xmm4
movapd %xmm2,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm0,%xmm5
cmpnlesd %xmm4,%xmm5
movapd %xmm5,%xmm4
andpd  %xmm15,%xmm4
subsd  %xmm3,%xmm15
andnpd %xmm15,%xmm5
orpd   %xmm4,%xmm5
movapd %xmm5,%xmm15
movsd  (%r9,%rcx,8),%xmm4
unpcklpd %xmm4,%xmm2
unpcklpd %xmm4,%xmm4
mulpd  %xmm2,%xmm4
movapd %xmm4,%xmm2
addpd  %xmm1,%xmm2
add    $0x1,%rcx
cmp    %rcx,%rax
jne    3e60 <trstlp+0x2d40>
addpd  %xmm1,%xmm4
mov    0x30(%rsp),%r12
ucomisd %xmm15,%xmm9
jae    517c <trstlp+0x405c>
movapd %xmm4,%xmm5
unpckhpd %xmm4,%xmm5
movapd %xmm5,%xmm1
mulsd  %xmm15,%xmm1
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
ucomisd %xmm9,%xmm1
jae    3f8c <trstlp+0x2e6c>
movapd %xmm1,%xmm0
movapd %xmm15,0x80(%rsp)
movapd %xmm4,0x70(%rsp)
movapd %xmm5,0xc0(%rsp)
call   1040 <sqrt@plt>
movapd 0xc0(%rsp),%xmm5
movapd 0x70(%rsp),%xmm4
movapd 0x80(%rsp),%xmm15
movapd 0x110(%rsp),%xmm14
movapd 0x20f3(%rip),%xmm12
movapd 0x20fa(%rip),%xmm11
movapd 0x20e1(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x258(%rsp),%r10
mov    0x260(%rsp),%r8
mov    0x268(%rsp),%r9
movapd %xmm4,%xmm1
xorpd  %xmm10,%xmm1
xorpd  %xmm2,%xmm2
cmplesd %xmm4,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm4,%xmm3
andnpd %xmm1,%xmm2
orpd   %xmm3,%xmm2
movapd %xmm0,%xmm1
mulsd  0x20d6(%rip),%xmm1
ucomisd %xmm1,%xmm2
jb     404e <trstlp+0x2f2e>
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
mulsd  %xmm15,%xmm5
addsd  %xmm0,%xmm5
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
ucomisd %xmm9,%xmm5
jae    404e <trstlp+0x2f2e>
movapd %xmm5,%xmm0
movapd %xmm15,0x80(%rsp)
movapd %xmm4,0x70(%rsp)
call   1040 <sqrt@plt>
movapd 0x70(%rsp),%xmm4
movapd 0x80(%rsp),%xmm15
movapd 0x110(%rsp),%xmm14
movapd 0x2031(%rip),%xmm12
movapd 0x2038(%rip),%xmm11
movapd 0x201f(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x258(%rsp),%r10
mov    0x260(%rsp),%r8
mov    0x268(%rsp),%r9
addsd  %xmm4,%xmm0
divsd  %xmm0,%xmm15
mov    0xb0(%rsp),%rax
mov    (%rax),%eax
movapd %xmm15,%xmm8
mov    %eax,0x50(%rsp)
cmp    %eax,%r12d
jne    40c8 <trstlp+0x2fa8>
movapd %xmm14,%xmm0
unpcklpd %xmm14,%xmm0
movapd %xmm15,%xmm1
unpcklpd %xmm15,%xmm1
mulpd  %xmm11,%xmm0
addpd  %xmm1,%xmm0
ucomisd %xmm0,%xmm15
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
jae    5189 <trstlp+0x4069>
ucomisd %xmm1,%xmm0
jae    5189 <trstlp+0x4069>
movapd %xmm15,%xmm8
cmplesd %xmm14,%xmm8
movapd %xmm8,%xmm1
andpd  %xmm15,%xmm1
andnpd %xmm14,%xmm8
orpd   %xmm1,%xmm8
mov    0x40(%rsp),%rax
mov    (%rax),%eax
mov    %rax,0x70(%rsp)
test   %eax,%eax
movapd 0x1f92(%rip),%xmm0
jle    42e0 <trstlp+0x31c0>
mov    0x70(%rsp),%rcx
lea    0x1(%rcx),%rax
mov    $0x1,%edx
cmp    $0x4,%rcx
jae    4170 <trstlp+0x3050>
mov    %rdx,%rcx
not    %rcx
test   $0x1,%al
jne    4120 <trstlp+0x3000>
movsd  -0x8(%r9,%rdx,8),%xmm1
mulsd  %xmm8,%xmm1
addsd  -0x8(%r15,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%r13,%rdx,8)
add    $0x1,%rdx
add    %rax,%rcx
je     42e0 <trstlp+0x31c0>
nopl   0x0(%rax)
movsd  -0x8(%r9,%rdx,8),%xmm1
mulsd  %xmm8,%xmm1
addsd  -0x8(%r15,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%r13,%rdx,8)
movsd  (%r9,%rdx,8),%xmm1
mulsd  %xmm8,%xmm1
addsd  (%r15,%rdx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    4130 <trstlp+0x3010>
jmp    42e0 <trstlp+0x31c0>
mov    0x128(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    0x148(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
cmp    %r13,%rsi
seta   %dil
mov    0xd0(%rsp),%rsi
lea    (%rsi,%rax,8),%rsi
cmp    %r15,%rcx
seta   %r8b
cmp    %r13,%rsi
seta   %bl
cmp    %r9,%rcx
seta   %cl
and    %bl,%cl
test   %r8b,%dil
jne    50cd <trstlp+0x3fad>
test   %cl,%cl
mov    0x278(%rsp),%rbx
jne    40f8 <trstlp+0x2fd8>
mov    0x70(%rsp),%rsi
and    $0xfffffffc,%esi
lea    0x1(%rsi),%rdx
movapd %xmm8,%xmm1
unpcklpd %xmm8,%xmm1
lea    -0x4(%rsi),%rdi
mov    %rdi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    $0x0,%ecx
test   %rdi,%rdi
je     428c <trstlp+0x316c>
mov    %rbp,%rdi
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rdi
xor    %ecx,%ecx
xchg   %ax,%ax
movupd (%r15,%rcx,8),%xmm2
movupd 0x10(%r15,%rcx,8),%xmm3
movupd (%r9,%rcx,8),%xmm4
movupd 0x10(%r9,%rcx,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,0x0(%r13,%rcx,8)
movupd %xmm5,0x10(%r13,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm2
movupd 0x30(%r15,%rcx,8),%xmm3
movupd 0x20(%r9,%rcx,8),%xmm4
movupd 0x30(%r9,%rcx,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,0x20(%r13,%rcx,8)
movupd %xmm5,0x30(%r13,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    4210 <trstlp+0x30f0>
test   $0x1,%bpl
je     42d4 <trstlp+0x31b4>
shl    $0x3,%rcx
or     $0x8,%rcx
movupd -0x8(%r15,%rcx,1),%xmm2
movupd 0x8(%r15,%rcx,1),%xmm3
movupd -0x8(%r9,%rcx,1),%xmm4
movupd 0x8(%r9,%rcx,1),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,-0x8(%r13,%rcx,1)
movupd %xmm5,0x8(%r13,%rcx,1)
cmp    %rsi,0x70(%rsp)
jne    40f8 <trstlp+0x2fd8>
nop
cmp    0x50(%rsp),%r12d
jne    43f0 <trstlp+0x32d0>
xorpd  %xmm1,%xmm1
mov    0x10(%rsp),%r15
test   %r15d,%r15d
jle    4414 <trstlp+0x32f4>
mov    0x70(%rsp),%rax
lea    0x1(%rax),%r8d
lea    0x1(%r15),%edx
lea    -0x1(%r8),%r9
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
xorpd  %xmm1,%xmm1
mov    $0x1,%ebp
jmp    4352 <trstlp+0x3232>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm2,%xmm3
cmplesd %xmm1,%xmm3
andpd  %xmm3,%xmm1
andnpd %xmm2,%xmm3
orpd   %xmm3,%xmm1
add    $0x1,%rbp
cmp    %rdx,%rbp
je     4400 <trstlp+0x32e0>
movslq -0x4(%r14,%rbp,4),%rcx
mov    0xa8(%rsp),%rax
movsd  -0x8(%rax,%rcx,8),%xmm2
cmpl   $0x0,0x70(%rsp)
jle    4330 <trstlp+0x3210>
imul   0x8(%rsp),%rcx
mov    $0x1,%ebx
cmp    $0x2,%r8d
je     43c3 <trstlp+0x32a3>
mov    0x60(%rsp),%rax
lea    (%rax,%rcx,8),%rax
add    $0xfffffffffffffff8,%rax
mov    $0x1,%ebx
nop
movsd  -0x8(%rax,%rbx,8),%xmm3
mulsd  -0x8(%r13,%rbx,8),%xmm3
movsd  (%rax,%rbx,8),%xmm4
subsd  %xmm3,%xmm2
mulsd  0x0(%r13,%rbx,8),%xmm4
subsd  %xmm4,%xmm2
lea    (%rdi,%rbx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rbx
cmp    $0x1,%rsi
jne    4390 <trstlp+0x3270>
test   $0x1,%r9b
je     4330 <trstlp+0x3210>
add    %rbx,%rcx
mov    0x28(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm3
mulsd  -0x8(%r13,%rbx,8),%xmm3
subsd  %xmm3,%xmm2
jmp    4330 <trstlp+0x3210>
nopw   0x0(%rax,%rax,1)
movapd %xmm14,%xmm1
mov    0x10(%rsp),%r15
jmp    4420 <trstlp+0x3300>
nopl   0x0(%rax)
movsd  %xmm14,0xf0(%rsp)
mov    0x278(%rsp),%rbx
jmp    4420 <trstlp+0x3300>
movsd  %xmm14,0xf0(%rsp)
xchg   %ax,%ax
mov    0x70(%rsp),%r11
lea    0x1(%r11),%r12d
movslq %r15d,%rdx
mov    0x128(%rsp),%rax
lea    (%rax,%r12,8),%rax
mov    %rax,0x98(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%r12,8),%rax
mov    %rax,0x110(%rsp)
lea    -0x2(%r12),%r15
lea    -0x1(%r12),%rsi
mov    %r15,0x80(%rsp)
and    $0xfffffffffffffffc,%r15
mov    %r15,0xe0(%rsp)
lea    0x2(%r15),%rax
mov    %rax,0xe8(%rsp)
mov    %r12,%rax
neg    %rax
mov    %rax,0xa0(%rsp)
mov    0x8(%rsp),%rax
imul   %rdx,%rax
mov    0x38(%rsp),%rcx
lea    (%rcx,%rax,8),%rbp
mov    %rsi,%rax
mov    %rsi,0x20(%rsp)
and    $0xfffffffffffffffe,%rsi
neg    %rsi
xor    %r8d,%r8d
mov    %rdx,0xc0(%rsp)
mov    %rdx,%rax
jmp    44d8 <trstlp+0x33b8>
nopw   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rax
add    $0x1,%r8
add    0xb8(%rsp),%rbp
mov    0x258(%rsp),%r10
mov    %r8,%rcx
not    %rcx
add    0xc0(%rsp),%rcx
lea    (%rbx,%rcx,8),%r14
lea    (%rbx,%rax,8),%r9
xorpd  %xmm3,%xmm3
xorpd  %xmm2,%xmm2
test   %r11d,%r11d
jle    45f9 <trstlp+0x34d9>
mov    %rax,%rcx
imul   0x8(%rsp),%rcx
xorpd  %xmm2,%xmm2
mov    $0x1,%edx
xorpd  %xmm3,%xmm3
cmpq   $0x0,0x80(%rsp)
je     45b8 <trstlp+0x3498>
xorpd  %xmm2,%xmm2
mov    $0x1,%edx
xorpd  %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%rdx,8),%xmm4
movsd  0x0(%rbp,%rdx,8),%xmm5
mulsd  -0x8(%r13,%rdx,8),%xmm4
addsd  %xmm4,%xmm3
movapd %xmm4,%xmm6
xorpd  %xmm12,%xmm6
xorpd  %xmm7,%xmm7
cmplesd %xmm4,%xmm7
andpd  %xmm7,%xmm4
andnpd %xmm6,%xmm7
orpd   %xmm4,%xmm7
mulsd  0x0(%r13,%rdx,8),%xmm5
addsd  %xmm2,%xmm7
addsd  %xmm5,%xmm3
movapd %xmm5,%xmm4
xorpd  %xmm12,%xmm4
xorpd  %xmm2,%xmm2
cmplesd %xmm5,%xmm2
andpd  %xmm2,%xmm5
andnpd %xmm4,%xmm2
orpd   %xmm5,%xmm2
addsd  %xmm7,%xmm2
lea    (%rsi,%rdx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rdx
cmp    $0x1,%rdi
jne    4540 <trstlp+0x3420>
testb  $0x1,0x20(%rsp)
je     45f9 <trstlp+0x34d9>
add    %rdx,%rcx
mov    0x18(%rsp),%rdi
movsd  (%rdi,%rcx,8),%xmm4
mulsd  -0x8(%r13,%rdx,8),%xmm4
addsd  %xmm4,%xmm3
movapd %xmm4,%xmm5
xorpd  %xmm10,%xmm5
xorpd  %xmm6,%xmm6
cmplesd %xmm4,%xmm6
andpd  %xmm6,%xmm4
andnpd %xmm5,%xmm6
orpd   %xmm4,%xmm6
addsd  %xmm6,%xmm2
movapd %xmm3,%xmm5
xorpd  %xmm10,%xmm5
xorpd  %xmm4,%xmm4
cmplesd %xmm3,%xmm4
movapd %xmm4,%xmm6
andpd  %xmm3,%xmm6
andnpd %xmm5,%xmm4
orpd   %xmm6,%xmm4
unpcklpd %xmm4,%xmm4
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
mulpd  %xmm11,%xmm4
addpd  %xmm5,%xmm4
movapd %xmm4,%xmm5
unpckhpd %xmm4,%xmm5
cmpnlesd %xmm4,%xmm5
andpd  %xmm3,%xmm5
cmpnlesd %xmm2,%xmm4
andpd  %xmm5,%xmm4
divsd  -0x8(%r10,%rax,8),%xmm4
movsd  %xmm4,-0x8(%rbx,%rax,8)
cmp    $0x2,%rax
jl     4860 <trstlp+0x3740>
test   %r11d,%r11d
jle    44c0 <trstlp+0x33a0>
mov    0x248(%rsp),%rcx
movslq -0x4(%rcx,%rax,4),%r10
imul   0x8(%rsp),%r10
mov    0x28(%rsp),%rcx
mulsd  0x8(%rcx,%r10,8),%xmm4
movsd  0x0(%r13),%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,0x0(%r13)
cmp    $0x2,%r12d
je     44c0 <trstlp+0x33a0>
mov    %r12,%r15
mov    %r14,%r12
mov    $0x2,%r14d
cmpq   $0x4,0x80(%rsp)
jb     47b5 <trstlp+0x3695>
mov    0x60(%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
mov    0x110(%rsp),%rdx
lea    (%rdx,%r10,8),%rdx
mov    0x1f0(%rsp),%r11
cmp    %r9,%r11
setb   %r9b
mov    0x98(%rsp),%rdi
cmp    %rdi,%r12
setb   %bl
cmp    %rdx,%r11
setb   %dl
cmp    %rdi,%rcx
setb   %cl
and    %dl,%cl
test   %bl,%r9b
jne    47a8 <trstlp+0x3688>
test   %cl,%cl
mov    0x278(%rsp),%rbx
mov    0x70(%rsp),%r11
mov    %r15,%r12
jne    47b8 <trstlp+0x3698>
movsd  -0x8(%rbx,%rax,8),%xmm2
unpcklpd %xmm2,%xmm2
xorpd  %xmm10,%xmm2
mov    0x60(%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
add    $0x10,%rcx
xor    %edx,%edx
mov    0xe0(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rcx,%rdx,8),%xmm3
movupd (%rcx,%rdx,8),%xmm4
movupd 0x8(%r13,%rdx,8),%xmm5
movupd 0x18(%r13,%rdx,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,0x8(%r13,%rdx,8)
movupd %xmm4,0x18(%r13,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rdi
jne    4750 <trstlp+0x3630>
mov    0xe8(%rsp),%r14
cmp    %rdi,0x80(%rsp)
je     44c0 <trstlp+0x33a0>
jmp    47b8 <trstlp+0x3698>
mov    0x278(%rsp),%rbx
mov    0x70(%rsp),%r11
mov    %r15,%r12
mov    %r12d,%edx
sub    %r14d,%edx
mov    %r14,%rcx
not    %rcx
test   $0x1,%dl
je     47f3 <trstlp+0x36d3>
movsd  -0x8(%rbx,%rax,8),%xmm2
lea    (%r14,%r10,1),%rdx
mov    0x28(%rsp),%rdi
mulsd  (%rdi,%rdx,8),%xmm2
movsd  -0x8(%r13,%r14,8),%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,-0x8(%r13,%r14,8)
add    $0x1,%r14
cmp    0xa0(%rsp),%rcx
je     44c0 <trstlp+0x33a0>
mov    0x28(%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%rax,8),%xmm2
mulsd  (%rcx,%r14,8),%xmm2
movsd  -0x8(%r13,%r14,8),%xmm3
subsd  %xmm2,%xmm3
movsd  0x0(%r13,%r14,8),%xmm2
movsd  %xmm3,-0x8(%r13,%r14,8)
movsd  -0x8(%rbx,%rax,8),%xmm3
mulsd  0x8(%rcx,%r14,8),%xmm3
subsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%r13,%r14,8)
add    $0x2,%r14
cmp    %r14,%r12
jne    4810 <trstlp+0x36f0>
jmp    44c0 <trstlp+0x33a0>
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%eax
cmp    %eax,0x30(%rsp)
jle    488c <trstlp+0x376c>
mov    0xc0(%rsp),%rax
movsd  -0x8(%rbx,%rax,8),%xmm2
movapd %xmm2,%xmm3
cmplesd %xmm9,%xmm3
andnpd %xmm2,%xmm3
movlpd %xmm3,-0x8(%rbx,%rax,8)
test   %r11d,%r11d
mov    0x58(%rsp),%r15
mov    0x268(%rsp),%r9
mov    0x260(%rsp),%r8
mov    0x248(%rsp),%r14
mov    0x170(%rsp),%rbp
jle    4ad0 <trstlp+0x39b0>
mov    $0x1,%eax
cmpq   $0x4,0x20(%rsp)
jae    4940 <trstlp+0x3820>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r12b
jne    48f1 <trstlp+0x37d1>
movsd  -0x8(%r9,%rax,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  -0x8(%r15,%rax,8),%xmm2
movsd  %xmm2,-0x8(%r13,%rax,8)
add    $0x1,%rax
add    %r12,%rcx
je     4ad0 <trstlp+0x39b0>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r9,%rax,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  -0x8(%r15,%rax,8),%xmm2
movsd  %xmm2,-0x8(%r13,%rax,8)
movsd  (%r9,%rax,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  (%r15,%rax,8),%xmm2
movsd  %xmm2,0x0(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%r12
jne    4900 <trstlp+0x37e0>
jmp    4ad0 <trstlp+0x39b0>
mov    0x148(%rsp),%rcx
lea    (%rcx,%r12,8),%rcx
cmp    %r13,%rcx
seta   %dil
mov    0xd0(%rsp),%rcx
lea    (%rcx,%r12,8),%rcx
mov    0x98(%rsp),%r11
cmp    %r15,%r11
seta   %bl
cmp    %r13,%rcx
seta   %dl
cmp    %r9,%r11
seta   %cl
and    %dl,%cl
test   %bl,%dil
jne    50da <trstlp+0x3fba>
test   %cl,%cl
mov    0x278(%rsp),%rbx
mov    0x248(%rsp),%r14
jne    48c7 <trstlp+0x37a7>
mov    0x20(%rsp),%rdi
and    $0xfffffffffffffffc,%rdi
lea    0x1(%rdi),%rax
movapd %xmm8,%xmm2
unpcklpd %xmm8,%xmm2
lea    -0x4(%rdi),%rdx
mov    %rdx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
mov    $0x0,%ecx
test   %rdx,%rdx
je     4a6c <trstlp+0x394c>
mov    %rbp,%rdx
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    %rcx,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%r15,%rcx,8),%xmm3
movupd 0x10(%r15,%rcx,8),%xmm4
movupd (%r9,%rcx,8),%xmm5
movupd 0x10(%r9,%rcx,8),%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm5,0x0(%r13,%rcx,8)
movupd %xmm6,0x10(%r13,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm3
movupd 0x30(%r15,%rcx,8),%xmm4
movupd 0x20(%r9,%rcx,8),%xmm5
movupd 0x30(%r9,%rcx,8),%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm5,0x20(%r13,%rcx,8)
movupd %xmm6,0x30(%r13,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    49f0 <trstlp+0x38d0>
test   $0x1,%bpl
je     4ab4 <trstlp+0x3994>
shl    $0x3,%rcx
or     $0x8,%rcx
movupd -0x8(%r15,%rcx,1),%xmm3
movupd 0x8(%r15,%rcx,1),%xmm4
movupd -0x8(%r9,%rcx,1),%xmm5
movupd 0x8(%r9,%rcx,1),%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm5,-0x8(%r13,%rcx,1)
movupd %xmm6,0x8(%r13,%rcx,1)
cmp    %rdi,0x20(%rsp)
mov    0x170(%rsp),%rbp
jne    48c7 <trstlp+0x37a7>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
cmp    %eax,0x30(%rsp)
mov    0xc0(%rsp),%r11
jg     4ee3 <trstlp+0x3dc3>
xor    %edi,%edi
movsd  0x1596(%rip),%xmm14
cmpl   $0x0,0x30(%rsp)
mov    0x1e8(%rsp),%rsi
jle    4b60 <trstlp+0x3a40>
xor    %edi,%edi
mov    $0x1,%eax
movsd  0x1577(%rip),%xmm14
cmpl   $0x2,0x168(%rsp)
02
jne    5030 <trstlp+0x3f10>
testb  $0x1,0x160(%rsp)
01
je     4b60 <trstlp+0x3a40>
movsd  -0x8(%rbx,%rax,8),%xmm3
ucomisd %xmm3,%xmm9
jbe    4b60 <trstlp+0x3a40>
movsd  -0x8(%r8,%rax,8),%xmm2
movapd %xmm2,%xmm4
subsd  %xmm3,%xmm4
divsd  %xmm4,%xmm2
ucomisd %xmm2,%xmm14
jbe    4b60 <trstlp+0x3a40>
movapd %xmm2,%xmm14
mov    %eax,%edi
nopw   0x0(%rax,%rax,1)
movsd  0x1520(%rip),%xmm2
subsd  %xmm14,%xmm2
cmpl   $0x0,0x70(%rsp)
jle    4cbb <trstlp+0x3b9b>
mov    $0x1,%eax
cmpq   $0x4,0x20(%rsp)
jb     4c30 <trstlp+0x3b10>
mov    0x148(%rsp),%rcx
lea    (%rcx,%r12,8),%rcx
cmp    %r15,0x98(%rsp)
jbe    4ba8 <trstlp+0x3a88>
cmp    %r13,%rcx
ja     4c30 <trstlp+0x3b10>
mov    0x20(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
lea    0x1(%rcx),%rax
movapd %xmm14,%xmm3
unpcklpd %xmm14,%xmm3
movapd %xmm2,%xmm4
unpcklpd %xmm2,%xmm4
xor    %edx,%edx
nopl   0x0(%rax)
movupd (%r15,%rdx,8),%xmm5
movupd 0x10(%r15,%rdx,8),%xmm6
movupd 0x0(%r13,%rdx,8),%xmm7
movupd 0x10(%r13,%rdx,8),%xmm0
mulpd  %xmm3,%xmm7
mulpd  %xmm3,%xmm0
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm0,%xmm6
movupd %xmm5,(%r15,%rdx,8)
movupd %xmm6,0x10(%r15,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    4bd0 <trstlp+0x3ab0>
cmp    %rcx,0x20(%rsp)
je     4cbb <trstlp+0x3b9b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r12b
jne    4c62 <trstlp+0x3b42>
movsd  -0x8(%r13,%rax,8),%xmm0
mulsd  %xmm14,%xmm0
movsd  -0x8(%r15,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,-0x8(%r15,%rax,8)
add    $0x1,%rax
add    %r12,%rcx
je     4cbb <trstlp+0x3b9b>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%r13,%rax,8),%xmm0
mulsd  %xmm14,%xmm0
movsd  -0x8(%r15,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,-0x8(%r15,%rax,8)
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  %xmm14,%xmm0
movsd  (%r15,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%r12
jne    4c70 <trstlp+0x3b50>
mov    0x30(%rsp),%r12
test   %r12d,%r12d
mov    0x168(%rsp),%rcx
jle    4e44 <trstlp+0x3d24>
cmpq   $0x4,0x160(%rsp)
setb   %al
or     0x4f(%rsp),%al
mov    $0x1,%eax
jne    4d8a <trstlp+0x3c6a>
mov    %rbx,%rdx
movapd %xmm14,%xmm3
unpcklpd %xmm14,%xmm3
movapd %xmm2,%xmm4
unpcklpd %xmm2,%xmm4
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%r8,%rax,8),%xmm0
movupd 0x10(%r8,%rax,8),%xmm5
movupd (%rdx,%rax,8),%xmm6
movupd 0x10(%rdx,%rax,8),%xmm7
mulpd  %xmm3,%xmm6
mulpd  %xmm3,%xmm7
mulpd  %xmm4,%xmm0
addpd  %xmm6,%xmm0
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
movapd %xmm0,%xmm6
xorpd  %xmm7,%xmm7
cmpnlepd %xmm7,%xmm6
andpd  %xmm0,%xmm6
movapd %xmm5,%xmm0
cmpnlepd %xmm7,%xmm0
andpd  %xmm5,%xmm0
movupd %xmm6,(%r8,%rax,8)
movupd %xmm0,0x10(%r8,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    4d10 <trstlp+0x3bf0>
mov    0x1d8(%rsp),%rax
cmp    %rsi,0x160(%rsp)
je     4e44 <trstlp+0x3d24>
mov    %rcx,%rdx
mov    %rax,%rcx
not    %rcx
test   $0x1,%dl
jne    4dcb <trstlp+0x3cab>
movsd  -0x8(%rbx,%rax,8),%xmm0
mulsd  %xmm14,%xmm0
movsd  -0x8(%r8,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movapd %xmm3,%xmm0
cmplesd %xmm9,%xmm0
andnpd %xmm3,%xmm0
movlpd %xmm0,-0x8(%r8,%rax,8)
add    $0x1,%rax
cmp    0x1e0(%rsp),%rcx
mov    0x168(%rsp),%rcx
mov    %rbx,%rdx
je     4e44 <trstlp+0x3d24>
movsd  -0x8(%rdx,%rax,8),%xmm0
mulsd  %xmm14,%xmm0
movsd  -0x8(%r8,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movapd %xmm3,%xmm0
cmplesd %xmm9,%xmm0
andnpd %xmm3,%xmm0
movlpd %xmm0,-0x8(%r8,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
mulsd  %xmm14,%xmm0
movsd  (%r8,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm0,%xmm3
movapd %xmm3,%xmm0
cmplesd %xmm9,%xmm0
andnpd %xmm3,%xmm0
movlpd %xmm0,(%r8,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    4de0 <trstlp+0x3cc0>
movapd %xmm1,%xmm0
movsd  0xf0(%rsp),%xmm2
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm14
addsd  %xmm2,%xmm14
cmp    0x50(%rsp),%r12d
je     1970 <trstlp+0x850>
movapd %xmm1,%xmm14
jmp    1970 <trstlp+0x850>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm2,%xmm4
xorpd  %xmm10,%xmm4
xorpd  %xmm5,%xmm5
cmplesd %xmm2,%xmm5
movapd %xmm5,%xmm6
andpd  %xmm2,%xmm6
andnpd %xmm4,%xmm5
orpd   %xmm6,%xmm5
unpcklpd %xmm5,%xmm5
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
mulpd  %xmm0,%xmm5
addpd  %xmm4,%xmm5
movapd %xmm5,%xmm4
unpckhpd %xmm5,%xmm4
cmpnlesd %xmm5,%xmm4
andpd  %xmm2,%xmm4
cmpnlesd %xmm3,%xmm5
andpd  %xmm4,%xmm5
movlpd %xmm5,(%rbx,%rax,8)
cmp    0x200(%rsp),%r11
je     4ae7 <trstlp+0x39c7>
mov    %r11,%rax
add    $0x1,%r11
movslq (%r14,%rax,4),%rdi
mov    0xa8(%rsp),%rcx
movsd  -0x8(%rcx,%rdi,8),%xmm4
movapd %xmm1,%xmm2
subsd  %xmm4,%xmm2
movapd %xmm4,%xmm5
xorpd  %xmm10,%xmm5
xorpd  %xmm3,%xmm3
cmplesd %xmm4,%xmm3
andpd  %xmm3,%xmm4
andnpd %xmm5,%xmm3
orpd   %xmm4,%xmm3
addsd  %xmm1,%xmm3
cmpl   $0x0,0x70(%rsp)
jle    4e80 <trstlp+0x3d60>
imul   0x8(%rsp),%rdi
mov    $0x1,%ecx
cmpq   $0x0,0x80(%rsp)
je     4fd7 <trstlp+0x3eb7>
mov    0x60(%rsp),%rcx
lea    (%rcx,%rdi,8),%rdx
add    $0xfffffffffffffff8,%rdx
mov    $0x1,%ecx
nopl   (%rax)
movsd  -0x8(%rdx,%rcx,8),%xmm4
movsd  (%rdx,%rcx,8),%xmm5
mulsd  -0x8(%r13,%rcx,8),%xmm4
addsd  %xmm4,%xmm2
movapd %xmm4,%xmm6
xorpd  %xmm12,%xmm6
xorpd  %xmm7,%xmm7
cmplesd %xmm4,%xmm7
andpd  %xmm7,%xmm4
andnpd %xmm6,%xmm7
orpd   %xmm4,%xmm7
mulsd  0x0(%r13,%rcx,8),%xmm5
addsd  %xmm3,%xmm7
addsd  %xmm5,%xmm2
movapd %xmm5,%xmm4
xorpd  %xmm12,%xmm4
xorpd  %xmm3,%xmm3
cmplesd %xmm5,%xmm3
andpd  %xmm3,%xmm5
andnpd %xmm4,%xmm3
orpd   %xmm5,%xmm3
addsd  %xmm7,%xmm3
lea    (%rsi,%rcx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rcx
cmp    $0x1,%rbp
jne    4f60 <trstlp+0x3e40>
testb  $0x1,0x20(%rsp)
mov    0x170(%rsp),%rbp
je     4e80 <trstlp+0x3d60>
add    %rcx,%rdi
mov    0x28(%rsp),%rdx
movsd  (%rdx,%rdi,8),%xmm4
mulsd  -0x8(%r13,%rcx,8),%xmm4
addsd  %xmm4,%xmm2
movapd %xmm4,%xmm5
xorpd  %xmm10,%xmm5
xorpd  %xmm6,%xmm6
cmplesd %xmm4,%xmm6
andpd  %xmm6,%xmm4
andnpd %xmm5,%xmm6
orpd   %xmm4,%xmm6
addsd  %xmm6,%xmm3
jmp    4e80 <trstlp+0x3d60>
nopl   0x0(%rax)
xor    %edi,%edi
mov    $0x1,%eax
mov    $0x2,%ecx
movsd  0x1043(%rip),%xmm14
jmp    5070 <trstlp+0x3f50>
nopw   0x0(%rax,%rax,1)
add    $0x2,%ecx
mov    0x1f8(%rsp),%rdx
add    %rax,%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
je     4b1f <trstlp+0x39ff>
movsd  -0x8(%rbx,%rax,8),%xmm3
ucomisd %xmm3,%xmm9
jbe    509f <trstlp+0x3f7f>
movsd  -0x8(%r8,%rax,8),%xmm2
movapd %xmm2,%xmm4
subsd  %xmm3,%xmm4
divsd  %xmm4,%xmm2
ucomisd %xmm2,%xmm14
jbe    509f <trstlp+0x3f7f>
lea    -0x1(%rcx),%edi
movapd %xmm2,%xmm14
movsd  (%rbx,%rax,8),%xmm3
ucomisd %xmm3,%xmm9
jbe    5050 <trstlp+0x3f30>
movsd  (%r8,%rax,8),%xmm2
movapd %xmm2,%xmm4
subsd  %xmm3,%xmm4
divsd  %xmm4,%xmm2
ucomisd %xmm2,%xmm14
jbe    5050 <trstlp+0x3f30>
movapd %xmm2,%xmm14
mov    %ecx,%edi
jmp    5050 <trstlp+0x3f30>
mov    0x278(%rsp),%rbx
jmp    40f8 <trstlp+0x2fd8>
mov    0x278(%rsp),%rbx
mov    0x248(%rsp),%r14
jmp    48c7 <trstlp+0x37a7>
mov    0x18(%rsp),%rcx
lea    (%rcx,%r9,8),%rcx
mov    0x268(%rsp),%r9
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r9,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%r9,%rdx,8)
movsd  0x8(%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r9,%rdx,8),%xmm1
movsd  %xmm1,(%r9,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    5100 <trstlp+0x3fe0>
jmp    3e1d <trstlp+0x2cfd>
ucomisd %xmm15,%xmm8
mov    0x50(%rsp),%eax
mov    %eax,%r12d
jne    5189 <trstlp+0x4069>
jp     5189 <trstlp+0x4069>
jmp    51c3 <trstlp+0x40a3>
mov    0x58(%rsp),%r15
mov    0x268(%rsp),%r9
mov    0x260(%rsp),%r8
mov    0x258(%rsp),%r10
mov    0x248(%rsp),%r14
jmp    517c <trstlp+0x405c>
mov    0x268(%rsp),%r9
mov    0xb0(%rsp),%rax
cmp    (%rax),%r12d
jne    51b5 <trstlp+0x4095>
movslq %r12d,%rax
add    $0x1,%r12d
mov    %r12d,(%r14,%rax,4)
movq   $0x0,(%r8,%rax,8)
movsd  0xf0(%rsp),%xmm0
mov    %r12d,%eax
mov    %rax,0x90(%rsp)
jmp    17bf <trstlp+0x69f>
mov    0x240(%rsp),%rax
movl   $0x0,(%rax)
xor    %eax,%eax
add    $0x208,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @trstlp(i32* %0, i32* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture %4, double* nocapture %5, i32* nocapture writeonly %6, i32* nocapture %7, double* %8, double* nocapture %9, double* nocapture %10, double* nocapture %11, double* nocapture %12, double* nocapture %13) {
%15 = bitcast double* %11 to i8*
%16 = load i32, i32* %0
%17 = xor i32 %16, -1
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds double, double* %8, i64 %18
%20 = getelementptr inbounds double, double* %2, i64 %18
%21 = getelementptr inbounds double, double* %3, i64 -1
%22 = getelementptr inbounds double, double* %5, i64 -1
%23 = getelementptr inbounds i32, i32* %7, i64 -1
%24 = getelementptr inbounds double, double* %9, i64 -1
%25 = getelementptr inbounds double, double* %10, i64 -1
%26 = getelementptr inbounds double, double* %11, i64 -1
%27 = getelementptr inbounds double, double* %12, i64 -1
%28 = getelementptr inbounds double, double* %13, i64 -1
store i32 1, i32* %6
%29 = load i32, i32* %1
%30 = load i32, i32* %0
%31 = icmp slt i32 %30, 1
br i1 %31, label %85, label %32
32: ; preds = %14
%33 = sext i32 %16 to i64
%34 = add nuw i32 %30, 1
%35 = zext i32 %34 to i64
%36 = add nsw i64 %35, -1
%37 = add nsw i64 %35, -2
%38 = and i64 %36, 3
%39 = icmp ult i64 %37, 3
%40 = and i64 %36, -4
%41 = icmp eq i64 %38, 0
br label %42
42: ; preds = %77, %32
%43 = phi i64 [ 1, %32 ], [ %83, %77 ]
%44 = trunc i64 %43 to i32
br i1 %39, label %66, label %45
45: ; preds = %42, %45
%46 = phi i64 [ %63, %45 ], [ 1, %42 ]
%47 = phi i64 [ %64, %45 ], [ 0, %42 ]
%48 = mul nsw i64 %46, %33
%49 = add nsw i64 %48, %43
%50 = getelementptr inbounds double, double* %19, i64 %49
store double 0.000000e+00, double* %50
%51 = add nuw nsw i64 %46, 1
%52 = mul nsw i64 %51, %33
%53 = add nsw i64 %52, %43
%54 = getelementptr inbounds double, double* %19, i64 %53
store double 0.000000e+00, double* %54
%55 = add nuw nsw i64 %46, 2
%56 = mul nsw i64 %55, %33
%57 = add nsw i64 %56, %43
%58 = getelementptr inbounds double, double* %19, i64 %57
store double 0.000000e+00, double* %58
%59 = add nuw nsw i64 %46, 3
%60 = mul nsw i64 %59, %33
%61 = add nsw i64 %60, %43
%62 = getelementptr inbounds double, double* %19, i64 %61
store double 0.000000e+00, double* %62
%63 = add nuw nsw i64 %46, 4
%64 = add nuw i64 %47, 4
%65 = icmp eq i64 %64, %40
br i1 %65, label %66, label %45
66: ; preds = %45, %42
%67 = phi i64 [ 1, %42 ], [ %63, %45 ]
br i1 %41, label %77, label %68
68: ; preds = %66, %68
%69 = phi i64 [ %74, %68 ], [ %67, %66 ]
%70 = phi i64 [ %75, %68 ], [ 0, %66 ]
%71 = mul nsw i64 %69, %33
%72 = add nsw i64 %71, %43
%73 = getelementptr inbounds double, double* %19, i64 %72
store double 0.000000e+00, double* %73
%74 = add nuw nsw i64 %69, 1
%75 = add i64 %70, 1
%76 = icmp eq i64 %75, %38
br i1 %76, label %77, label %68
77: ; preds = %68, %66
%78 = mul nsw i32 %16, %44
%79 = sext i32 %78 to i64
%80 = add nsw i64 %43, %79
%81 = getelementptr inbounds double, double* %19, i64 %80
store double 1.000000e+00, double* %81
%82 = getelementptr inbounds double, double* %22, i64 %43
store double 0.000000e+00, double* %82
%83 = add nuw nsw i64 %43, 1
%84 = icmp eq i64 %83, %35
br i1 %84, label %85, label %42
85: ; preds = %77, %14
%86 = icmp sgt i32 %29, 0
br i1 %86, label %87, label %289
87: ; preds = %85
%88 = add nuw i32 %29, 1
%89 = zext i32 %88 to i64
%90 = add nsw i64 %89, -1
%91 = add nsw i64 %89, -2
%92 = and i64 %90, 3
%93 = icmp ult i64 %91, 3
br i1 %93, label %96, label %94
94: ; preds = %87
%95 = and i64 %90, -4
br label %235
96: ; preds = %235, %87
%97 = phi double [ undef, %87 ], [ %264, %235 ]
%98 = phi i32 [ undef, %87 ], [ %266, %235 ]
%99 = phi i64 [ 1, %87 ], [ %267, %235 ]
%100 = phi i32 [ 0, %87 ], [ %266, %235 ]
%101 = phi double [ 0.000000e+00, %87 ], [ %264, %235 ]
%102 = icmp eq i64 %92, 0
br i1 %102, label %117, label %103
103: ; preds = %96, %103
%104 = phi i64 [ %114, %103 ], [ %99, %96 ]
%105 = phi i32 [ %113, %103 ], [ %100, %96 ]
%106 = phi double [ %111, %103 ], [ %101, %96 ]
%107 = phi i64 [ %115, %103 ], [ 0, %96 ]
%108 = getelementptr inbounds double, double* %21, i64 %104
%109 = load double, double* %108
%110 = fcmp ogt double %109, %106
%111 = select i1 %110, double %109, double %106
%112 = trunc i64 %104 to i32
%113 = select i1 %110, i32 %112, i32 %105
%114 = add nuw nsw i64 %104, 1
%115 = add i64 %107, 1
%116 = icmp eq i64 %115, %92
br i1 %116, label %117, label %103
117: ; preds = %103, %96
%118 = phi double [ %97, %96 ], [ %111, %103 ]
%119 = phi i32 [ %98, %96 ], [ %113, %103 ]
%120 = icmp slt i32 %29, 1
br i1 %120, label %287, label %121
121: ; preds = %117
%122 = add nuw i32 %29, 1
%123 = zext i32 %122 to i64
%124 = add nsw i64 %89, -1
%125 = icmp ult i64 %124, 4
br i1 %125, label %218, label %126
126: ; preds = %121
%127 = add nsw i64 %89, -1
%128 = getelementptr double, double* %10, i64 %127
%129 = getelementptr double, double* %3, i64 %127
%130 = icmp ugt double* %129, %10
%131 = icmp ugt double* %128, %3
%132 = and i1 %130, %131
br i1 %132, label %218, label %133
133: ; preds = %126
%134 = and i64 %124, -4
%135 = or i64 %134, 1
%136 = insertelement <2 x double> poison, double %118, i64 0
%137 = shufflevector <2 x double> %136, <2 x double> poison, <2 x i32> zeroinitializer
%138 = insertelement <2 x double> poison, double %118, i64 0
%139 = shufflevector <2 x double> %138, <2 x double> poison, <2 x i32> zeroinitializer
%140 = add nsw i64 %134, -4
%141 = lshr exact i64 %140, 2
%142 = add nuw nsw i64 %141, 1
%143 = and i64 %142, 1
%144 = icmp eq i64 %140, 0
br i1 %144, label %194, label %145
145: ; preds = %133
%146 = and i64 %142, 9223372036854775806
br label %147
147: ; preds = %147, %145
%148 = phi i64 [ 0, %145 ], [ %188, %147 ]
%149 = phi <2 x i32> [ <i32 1, i32 2>, %145 ], [ %189, %147 ]
%150 = phi i64 [ 0, %145 ], [ %190, %147 ]
%151 = or i64 %148, 1
%152 = add <2 x i32> %149, <i32 2, i32 2>
%153 = getelementptr inbounds i32, i32* %23, i64 %151
%154 = bitcast i32* %153 to <2 x i32>*
store <2 x i32> %149, <2 x i32>* %154
%155 = getelementptr inbounds i32, i32* %153, i64 2
%156 = bitcast i32* %155 to <2 x i32>*
store <2 x i32> %152, <2 x i32>* %156
%157 = getelementptr inbounds double, double* %21, i64 %151
%158 = bitcast double* %157 to <2 x double>*
%159 = load <2 x double>, <2 x double>* %158
%160 = getelementptr inbounds double, double* %157, i64 2
%161 = bitcast double* %160 to <2 x double>*
%162 = load <2 x double>, <2 x double>* %161
%163 = fsub <2 x double> %137, %159
%164 = fsub <2 x double> %139, %162
%165 = getelementptr inbounds double, double* %25, i64 %151
%166 = bitcast double* %165 to <2 x double>*
store <2 x double> %163, <2 x double>* %166
%167 = getelementptr inbounds double, double* %165, i64 2
%168 = bitcast double* %167 to <2 x double>*
store <2 x double> %164, <2 x double>* %168
%169 = add <2 x i32> %149, <i32 4, i32 4>
%170 = or i64 %148, 5
%171 = add <2 x i32> %149, <i32 6, i32 6>
%172 = getelementptr inbounds i32, i32* %23, i64 %170
%173 = bitcast i32* %172 to <2 x i32>*
store <2 x i32> %169, <2 x i32>* %173
%174 = getelementptr inbounds i32, i32* %172, i64 2
%175 = bitcast i32* %174 to <2 x i32>*
store <2 x i32> %171, <2 x i32>* %175
%176 = getelementptr inbounds double, double* %21, i64 %170
%177 = bitcast double* %176 to <2 x double>*
%178 = load <2 x double>, <2 x double>* %177
%179 = getelementptr inbounds double, double* %176, i64 2
%180 = bitcast double* %179 to <2 x double>*
%181 = load <2 x double>, <2 x double>* %180
%182 = fsub <2 x double> %137, %178
%183 = fsub <2 x double> %139, %181
%184 = getelementptr inbounds double, double* %25, i64 %170
%185 = bitcast double* %184 to <2 x double>*
store <2 x double> %182, <2 x double>* %185
%186 = getelementptr inbounds double, double* %184, i64 2
%187 = bitcast double* %186 to <2 x double>*
store <2 x double> %183, <2 x double>* %187
%188 = add nuw i64 %148, 8
%189 = add <2 x i32> %149, <i32 8, i32 8>
%190 = add i64 %150, 2
%191 = icmp eq i64 %190, %146
br i1 %191, label %192, label %147
192: ; preds = %147
%193 = or i64 %188, 1
br label %194
194: ; preds = %192, %133
%195 = phi i64 [ 1, %133 ], [ %193, %192 ]
%196 = phi <2 x i32> [ <i32 1, i32 2>, %133 ], [ %189, %192 ]
%197 = icmp eq i64 %143, 0
br i1 %197, label %216, label %198
198: ; preds = %194
%199 = add <2 x i32> %196, <i32 2, i32 2>
%200 = getelementptr inbounds i32, i32* %23, i64 %195
%201 = bitcast i32* %200 to <2 x i32>*
store <2 x i32> %196, <2 x i32>* %201
%202 = getelementptr inbounds i32, i32* %200, i64 2
%203 = bitcast i32* %202 to <2 x i32>*
store <2 x i32> %199, <2 x i32>* %203
%204 = getelementptr inbounds double, double* %21, i64 %195
%205 = bitcast double* %204 to <2 x double>*
%206 = load <2 x double>, <2 x double>* %205
%207 = getelementptr inbounds double, double* %204, i64 2
%208 = bitcast double* %207 to <2 x double>*
%209 = load <2 x double>, <2 x double>* %208
%210 = fsub <2 x double> %137, %206
%211 = fsub <2 x double> %139, %209
%212 = getelementptr inbounds double, double* %25, i64 %195
%213 = bitcast double* %212 to <2 x double>*
store <2 x double> %210, <2 x double>* %213
%214 = getelementptr inbounds double, double* %212, i64 2
%215 = bitcast double* %214 to <2 x double>*
store <2 x double> %211, <2 x double>* %215
br label %216
216: ; preds = %194, %198
%217 = icmp eq i64 %124, %134
br i1 %217, label %287, label %218
218: ; preds = %126, %121, %216
%219 = phi i64 [ 1, %126 ], [ 1, %121 ], [ %135, %216 ]
%220 = xor i64 %219, -1
%221 = and i64 %89, 1
%222 = icmp eq i64 %221, 0
br i1 %222, label %223, label %231
223: ; preds = %218
%224 = getelementptr inbounds i32, i32* %23, i64 %219
%225 = trunc i64 %219 to i32
store i32 %225, i32* %224
%226 = getelementptr inbounds double, double* %21, i64 %219
%227 = load double, double* %226
%228 = fsub double %118, %227
%229 = getelementptr inbounds double, double* %25, i64 %219
store double %228, double* %229
%230 = add nuw nsw i64 %219, 1
br label %231
231: ; preds = %223, %218
%232 = phi i64 [ %219, %218 ], [ %230, %223 ]
%233 = sub nsw i64 0, %89
%234 = icmp eq i64 %220, %233
br i1 %234, label %287, label %270
235: ; preds = %235, %94
%236 = phi i64 [ 1, %94 ], [ %267, %235 ]
%237 = phi i32 [ 0, %94 ], [ %266, %235 ]
%238 = phi double [ 0.000000e+00, %94 ], [ %264, %235 ]
%239 = phi i64 [ 0, %94 ], [ %268, %235 ]
%240 = getelementptr inbounds double, double* %21, i64 %236
%241 = load double, double* %240
%242 = fcmp ogt double %241, %238
%243 = select i1 %242, double %241, double %238
%244 = trunc i64 %236 to i32
%245 = select i1 %242, i32 %244, i32 %237
%246 = getelementptr inbounds double, double* %3, i64 %236
%247 = load double, double* %246
%248 = fcmp ogt double %247, %243
%249 = select i1 %248, double %247, double %243
%250 = trunc i64 %236 to i32
%251 = add i32 %250, 1
%252 = select i1 %248, i32 %251, i32 %245
%253 = add nuw nsw i64 %236, 2
%254 = getelementptr inbounds double, double* %21, i64 %253
%255 = load double, double* %254
%256 = fcmp ogt double %255, %249
%257 = select i1 %256, double %255, double %249
%258 = trunc i64 %253 to i32
%259 = select i1 %256, i32 %258, i32 %252
%260 = add nuw nsw i64 %236, 3
%261 = getelementptr inbounds double, double* %21, i64 %260
%262 = load double, double* %261
%263 = fcmp ogt double %262, %257
%264 = select i1 %263, double %262, double %257
%265 = trunc i64 %260 to i32
%266 = select i1 %263, i32 %265, i32 %259
%267 = add nuw nsw i64 %236, 4
%268 = add i64 %239, 4
%269 = icmp eq i64 %268, %95
br i1 %269, label %96, label %235
270: ; preds = %231, %270
%271 = phi i64 [ %285, %270 ], [ %232, %231 ]
%272 = getelementptr inbounds i32, i32* %23, i64 %271
%273 = trunc i64 %271 to i32
store i32 %273, i32* %272
%274 = getelementptr inbounds double, double* %21, i64 %271
%275 = load double, double* %274
%276 = fsub double %118, %275
%277 = getelementptr inbounds double, double* %25, i64 %271
store double %276, double* %277
%278 = getelementptr inbounds i32, i32* %7, i64 %271
%279 = trunc i64 %271 to i32
%280 = add i32 %279, 1
store i32 %280, i32* %278
%281 = getelementptr inbounds double, double* %3, i64 %271
%282 = load double, double* %281
%283 = fsub double %118, %282
%284 = getelementptr inbounds double, double* %10, i64 %271
store double %283, double* %284
%285 = add nuw nsw i64 %271, 2
%286 = icmp eq i64 %285, %123
br i1 %286, label %287, label %270
287: ; preds = %231, %270, %216, %117
%288 = fcmp oeq double %118, 0.000000e+00
br i1 %288, label %289, label %292
289: ; preds = %85, %287
%290 = phi double [ %118, %287 ], [ 0.000000e+00, %85 ]
%291 = load i32, i32* %1
br label %3085
292: ; preds = %287
%293 = load i32, i32* %0
%294 = icmp slt i32 %293, 1
br i1 %294, label %298, label %295
295: ; preds = %292
%296 = zext i32 %293 to i64
%297 = shl nuw nsw i64 %296, 3
br label %298
298: ; preds = %295, %292, %3085
%299 = phi double [ %3087, %3085 ], [ 0.000000e+00, %292 ], [ 0.000000e+00, %295 ]
%300 = phi double [ %3088, %3085 ], [ %118, %292 ], [ %118, %295 ]
%301 = phi i32 [ %3089, %3085 ], [ 0, %292 ], [ 0, %295 ]
%302 = phi i32 [ %3091, %3085 ], [ %119, %292 ], [ %119, %295 ]
%303 = phi i32 [ %3091, %3085 ], [ %29, %292 ], [ %29, %295 ]
%304 = phi i32 [ %3090, %3085 ], [ 0, %292 ], [ 0, %295 ]
%305 = mul nsw i32 %303, %16
%306 = icmp slt i32 %303, 1
%307 = sext i32 %305 to i64
%308 = sext i32 %16 to i64
%309 = add i32 %303, 1
%310 = load i32, i32* %1
%311 = sext i32 %303 to i64
%312 = zext i32 %309 to i64
%313 = zext i32 %309 to i64
%314 = add nsw i64 %312, -1
%315 = getelementptr double, double* %10, i64 %314
%316 = getelementptr double, double* %13, i64 %314
%317 = add nsw i64 %312, -1
%318 = getelementptr double, double* %5, i64 -1
%319 = getelementptr double, double* %12, i64 -1
%320 = getelementptr double, double* %12, i64 -1
%321 = getelementptr double, double* %5, i64 -1
%322 = getelementptr double, double* %11, i64 -1
%323 = getelementptr double, double* %12, i64 1
%324 = getelementptr double, double* %12, i64 -1
%325 = add nsw i64 %18, 2
%326 = getelementptr double, double* %2, i64 %325
%327 = getelementptr double, double* %2, i64 %18
%328 = getelementptr double, double* %12, i64 -1
%329 = getelementptr double, double* %5, i64 -1
%330 = getelementptr double, double* %11, i64 -1
%331 = getelementptr double, double* %11, i64 -1
%332 = add nsw i64 %18, 1
%333 = getelementptr double, double* %8, i64 %332
%334 = getelementptr double, double* %8, i64 %18
%335 = getelementptr double, double* %11, i64 -1
%336 = add nsw i64 %18, 1
%337 = getelementptr double, double* %8, i64 %336
%338 = getelementptr double, double* %8, i64 %18
%339 = add nsw i64 %18, 1
%340 = getelementptr double, double* %8, i64 %339
%341 = getelementptr double, double* %8, i64 %18
%342 = getelementptr double, double* %8, i64 %339
%343 = getelementptr double, double* %8, i64 %18
%344 = add nsw i64 %18, 1
%345 = add nsw i64 %18, 1
%346 = getelementptr double, double* %10, i64 -1
%347 = getelementptr double, double* %13, i64 -1
%348 = getelementptr double, double* %12, i64 -1
%349 = add nsw i64 %18, 1
%350 = getelementptr double, double* %2, i64 %349
%351 = getelementptr double, double* %2, i64 %18
%352 = add nsw i64 %18, 1
%353 = add nsw i64 %18, 1
%354 = getelementptr double, double* %12, i64 -1
%355 = add nsw i64 %18, 1
%356 = getelementptr double, double* %2, i64 %355
%357 = getelementptr double, double* %2, i64 %18
%358 = getelementptr double, double* %11, i64 -1
%359 = add nsw i64 %18, 1
%360 = getelementptr double, double* %8, i64 %359
%361 = getelementptr double, double* %8, i64 %18
%362 = add nsw i64 %18, 1
%363 = add nsw i64 %18, 1
%364 = add nsw i64 %312, -1
%365 = and i64 %364, 1
%366 = icmp eq i32 %309, 2
%367 = and i64 %364, -2
%368 = icmp eq i64 %365, 0
%369 = icmp ult i64 %317, 4
%370 = icmp ugt double* %316, %10
%371 = icmp ugt double* %315, %13
%372 = and i1 %370, %371
%373 = and i64 %317, -4
%374 = or i64 %373, 1
%375 = icmp eq i64 %317, %373
%376 = and i64 %312, 1
%377 = icmp eq i64 %376, 0
%378 = sub nsw i64 0, %312
br label %379
379: ; preds = %3078, %298
%380 = phi i32 [ %310, %298 ], [ %2217, %3078 ]
%381 = phi double [ %299, %298 ], [ %2434, %3078 ]
%382 = phi double [ %300, %298 ], [ %3081, %3078 ]
%383 = phi double [ 0.000000e+00, %298 ], [ %444, %3078 ]
%384 = phi i32 [ 0, %298 ], [ %445, %3078 ]
%385 = phi i32 [ %301, %298 ], [ %2194, %3078 ]
%386 = phi i32 [ %302, %298 ], [ %2921, %3078 ]
%387 = phi i32 [ %304, %298 ], [ %446, %3078 ]
%388 = icmp eq i32 %303, %380
br i1 %388, label %433, label %389
389: ; preds = %379
%390 = load i32, i32* %0
%391 = icmp slt i32 %390, 1
br i1 %391, label %433, label %392
392: ; preds = %389
%393 = zext i32 %390 to i64
%394 = and i64 %393, 1
%395 = icmp eq i32 %390, 1
br i1 %395, label %420, label %396
396: ; preds = %392
%397 = and i64 %393, 4294967294
br label %398
398: ; preds = %398, %396
%399 = phi i64 [ 1, %396 ], [ %417, %398 ]
%400 = phi double [ 0.000000e+00, %396 ], [ %416, %398 ]
%401 = phi i64 [ 0, %396 ], [ %418, %398 ]
%402 = getelementptr inbounds double, double* %22, i64 %399
%403 = load double, double* %402
%404 = add nsw i64 %399, %307
%405 = getelementptr inbounds double, double* %20, i64 %404
%406 = load double, double* %405
%407 = fneg double %403
%408 = tail call double @llvm.fmuladd.f64(double %407, double %406, double %400)
%409 = add nuw nsw i64 %399, 1
%410 = getelementptr inbounds double, double* %5, i64 %399
%411 = load double, double* %410
%412 = add nsw i64 %409, %307
%413 = getelementptr inbounds double, double* %20, i64 %412
%414 = load double, double* %413
%415 = fneg double %411
%416 = tail call double @llvm.fmuladd.f64(double %415, double %414, double %408)
%417 = add nuw nsw i64 %399, 2
%418 = add i64 %401, 2
%419 = icmp eq i64 %418, %397
br i1 %419, label %420, label %398
420: ; preds = %398, %392
%421 = phi double [ undef, %392 ], [ %416, %398 ]
%422 = phi i64 [ 1, %392 ], [ %417, %398 ]
%423 = phi double [ 0.000000e+00, %392 ], [ %416, %398 ]
%424 = icmp eq i64 %394, 0
br i1 %424, label %433, label %425
425: ; preds = %420
%426 = getelementptr inbounds double, double* %22, i64 %422
%427 = load double, double* %426
%428 = add nsw i64 %422, %307
%429 = getelementptr inbounds double, double* %20, i64 %428
%430 = load double, double* %429
%431 = fneg double %427
%432 = tail call double @llvm.fmuladd.f64(double %431, double %430, double %423)
br label %433
433: ; preds = %425, %420, %389, %379
%434 = phi double [ %382, %379 ], [ 0.000000e+00, %389 ], [ %421, %420 ], [ %432, %425 ]
%435 = icmp eq i32 %384, 0
%436 = fcmp olt double %434, %383
%437 = select i1 %435, i1 true, i1 %436
br i1 %437, label %443, label %438
438: ; preds = %433
%439 = icmp sgt i32 %385, %387
br i1 %439, label %443, label %440
440: ; preds = %438
%441 = add nsw i32 %384, -1
%442 = icmp eq i32 %441, 0
br i1 %442, label %3095, label %443
443: ; preds = %438, %433, %440
%444 = phi double [ %383, %440 ], [ %434, %433 ], [ %383, %438 ]
%445 = phi i32 [ %441, %440 ], [ 3, %433 ], [ 3, %438 ]
%446 = phi i32 [ %387, %440 ], [ %385, %433 ], [ %385, %438 ]
%447 = icmp sgt i32 %386, %385
br i1 %447, label %448, label %1652
448: ; preds = %443
%449 = sext i32 %386 to i64
%450 = getelementptr inbounds i32, i32* %23, i64 %449
%451 = load i32, i32* %450
%452 = load i32, i32* %0
%453 = icmp slt i32 %452, 1
br i1 %453, label %547, label %454
454: ; preds = %448
%455 = mul nsw i32 %451, %16
%456 = sext i32 %455 to i64
%457 = add nuw i32 %452, 1
%458 = zext i32 %457 to i64
%459 = add nsw i64 %458, -1
%460 = icmp ult i64 %459, 4
br i1 %460, label %527, label %461
461: ; preds = %454
%462 = getelementptr double, double* %354, i64 %458
%463 = getelementptr double, double* %356, i64 %456
%464 = add nsw i64 %456, %458
%465 = getelementptr double, double* %357, i64 %464
%466 = icmp ugt double* %465, %12
%467 = icmp ult double* %463, %462
%468 = and i1 %466, %467
br i1 %468, label %527, label %469
469: ; preds = %461
%470 = and i64 %459, -4
%471 = or i64 %470, 1
%472 = add nsw i64 %470, -4
%473 = lshr exact i64 %472, 2
%474 = add nuw nsw i64 %473, 1
%475 = and i64 %474, 1
%476 = icmp eq i64 %472, 0
br i1 %476, label %509, label %477
477: ; preds = %469
%478 = and i64 %474, 9223372036854775806
br label %479
479: ; preds = %479, %477
%480 = phi i64 [ 0, %477 ], [ %506, %479 ]
%481 = phi i64 [ 0, %477 ], [ %507, %479 ]
%482 = or i64 %480, 1
%483 = add nsw i64 %482, %456
%484 = getelementptr inbounds double, double* %20, i64 %483
%485 = bitcast double* %484 to <2 x double>*
%486 = load <2 x double>, <2 x double>* %485
%487 = getelementptr inbounds double, double* %484, i64 2
%488 = bitcast double* %487 to <2 x double>*
%489 = load <2 x double>, <2 x double>* %488
%490 = getelementptr inbounds double, double* %27, i64 %482
%491 = bitcast double* %490 to <2 x double>*
store <2 x double> %486, <2 x double>* %491
%492 = getelementptr inbounds double, double* %490, i64 2
%493 = bitcast double* %492 to <2 x double>*
store <2 x double> %489, <2 x double>* %493
%494 = or i64 %480, 5
%495 = add nsw i64 %494, %456
%496 = getelementptr inbounds double, double* %20, i64 %495
%497 = bitcast double* %496 to <2 x double>*
%498 = load <2 x double>, <2 x double>* %497
%499 = getelementptr inbounds double, double* %496, i64 2
%500 = bitcast double* %499 to <2 x double>*
%501 = load <2 x double>, <2 x double>* %500
%502 = getelementptr inbounds double, double* %27, i64 %494
%503 = bitcast double* %502 to <2 x double>*
store <2 x double> %498, <2 x double>* %503
%504 = getelementptr inbounds double, double* %502, i64 2
%505 = bitcast double* %504 to <2 x double>*
store <2 x double> %501, <2 x double>* %505
%506 = add nuw i64 %480, 8
%507 = add i64 %481, 2
%508 = icmp eq i64 %507, %478
br i1 %508, label %509, label %479
509: ; preds = %479, %469
%510 = phi i64 [ 0, %469 ], [ %506, %479 ]
%511 = icmp eq i64 %475, 0
br i1 %511, label %525, label %512
512: ; preds = %509
%513 = or i64 %510, 1
%514 = add nsw i64 %513, %456
%515 = getelementptr inbounds double, double* %20, i64 %514
%516 = bitcast double* %515 to <2 x double>*
%517 = load <2 x double>, <2 x double>* %516
%518 = getelementptr inbounds double, double* %515, i64 2
%519 = bitcast double* %518 to <2 x double>*
%520 = load <2 x double>, <2 x double>* %519
%521 = getelementptr inbounds double, double* %27, i64 %513
%522 = bitcast double* %521 to <2 x double>*
store <2 x double> %517, <2 x double>* %522
%523 = getelementptr inbounds double, double* %521, i64 2
%524 = bitcast double* %523 to <2 x double>*
store <2 x double> %520, <2 x double>* %524
br label %525
525: ; preds = %509, %512
%526 = icmp eq i64 %459, %470
br i1 %526, label %547, label %527
527: ; preds = %461, %454, %525
%528 = phi i64 [ 1, %461 ], [ 1, %454 ], [ %471, %525 ]
%529 = sub nsw i64 %458, %528
%530 = xor i64 %528, -1
%531 = add nsw i64 %530, %458
%532 = and i64 %529, 3
%533 = icmp eq i64 %532, 0
br i1 %533, label %544, label %534
534: ; preds = %527, %534
%535 = phi i64 [ %541, %534 ], [ %528, %527 ]
%536 = phi i64 [ %542, %534 ], [ 0, %527 ]
%537 = add nsw i64 %535, %456
%538 = getelementptr inbounds double, double* %20, i64 %537
%539 = load double, double* %538
%540 = getelementptr inbounds double, double* %27, i64 %535
store double %539, double* %540
%541 = add nuw nsw i64 %535, 1
%542 = add i64 %536, 1
%543 = icmp eq i64 %542, %532
br i1 %543, label %544, label %534
544: ; preds = %534, %527
%545 = phi i64 [ %528, %527 ], [ %541, %534 ]
%546 = icmp ult i64 %531, 3
br i1 %546, label %547, label %559
547: ; preds = %544, %559, %525, %448
%548 = icmp sgt i32 %452, %385
br i1 %548, label %549, label %749
549: ; preds = %547
%550 = sext i32 %452 to i64
%551 = sext i32 %385 to i64
%552 = add nsw i64 %550, 1
%553 = mul i64 %552, %308
%554 = add i64 %352, %553
%555 = add i64 %553, %18
%556 = mul nsw i64 %308, %550
%557 = add i64 %353, %556
%558 = add i64 %556, %18
br label %582
559: ; preds = %544, %559
%560 = phi i64 [ %580, %559 ], [ %545, %544 ]
%561 = add nsw i64 %560, %456
%562 = getelementptr inbounds double, double* %20, i64 %561
%563 = load double, double* %562
%564 = getelementptr inbounds double, double* %27, i64 %560
store double %563, double* %564
%565 = add nuw nsw i64 %560, 1
%566 = add nsw i64 %565, %456
%567 = getelementptr inbounds double, double* %20, i64 %566
%568 = load double, double* %567
%569 = getelementptr inbounds double, double* %12, i64 %560
store double %568, double* %569
%570 = add nuw nsw i64 %560, 2
%571 = add nsw i64 %570, %456
%572 = getelementptr inbounds double, double* %20, i64 %571
%573 = load double, double* %572
%574 = getelementptr inbounds double, double* %27, i64 %570
store double %573, double* %574
%575 = add nuw nsw i64 %560, 3
%576 = add nsw i64 %575, %456
%577 = getelementptr inbounds double, double* %20, i64 %576
%578 = load double, double* %577
%579 = getelementptr inbounds double, double* %27, i64 %575
store double %578, double* %579
%580 = add nuw nsw i64 %560, 4
%581 = icmp eq i64 %580, %458
br i1 %581, label %547, label %559
582: ; preds = %549, %741
%583 = phi i64 [ 0, %549 ], [ %746, %741 ]
%584 = phi i32 [ %452, %549 ], [ %742, %741 ]
%585 = phi i64 [ %550, %549 ], [ %744, %741 ]
%586 = phi double [ 0.000000e+00, %549 ], [ %743, %741 ]
%587 = mul i64 %583, %308
%588 = sub i64 %554, %587
%589 = getelementptr double, double* %8, i64 %588
%590 = sub i64 %555, %587
%591 = getelementptr double, double* %8, i64 %590
%592 = sub i64 %557, %587
%593 = getelementptr double, double* %8, i64 %592
%594 = sub i64 %558, %587
%595 = getelementptr double, double* %8, i64 %594
%596 = icmp slt i32 %584, 1
br i1 %596, label %654, label %597
597: ; preds = %582
%598 = mul nsw i64 %585, %308
%599 = zext i32 %584 to i64
%600 = and i64 %599, 1
%601 = icmp eq i32 %584, 1
br i1 %601, label %635, label %602
602: ; preds = %597
%603 = and i64 %599, 4294967294
br label %604
604: ; preds = %604, %602
%605 = phi i64 [ 1, %602 ], [ %632, %604 ]
%606 = phi double [ 0.000000e+00, %602 ], [ %631, %604 ]
%607 = phi double [ 0.000000e+00, %602 ], [ %627, %604 ]
%608 = phi i64 [ 0, %602 ], [ %633, %604 ]
%609 = add nsw i64 %605, %598
%610 = getelementptr inbounds double, double* %19, i64 %609
%611 = load double, double* %610
%612 = getelementptr inbounds double, double* %27, i64 %605
%613 = load double, double* %612
%614 = fmul double %611, %613
%615 = fadd double %607, %614
%616 = fcmp oge double %614, 0.000000e+00
%617 = fneg double %614
%618 = select i1 %616, double %614, double %617
%619 = fadd double %606, %618
%620 = add nuw nsw i64 %605, 1
%621 = add nsw i64 %620, %598
%622 = getelementptr inbounds double, double* %19, i64 %621
%623 = load double, double* %622
%624 = getelementptr inbounds double, double* %12, i64 %605
%625 = load double, double* %624
%626 = fmul double %623, %625
%627 = fadd double %615, %626
%628 = fcmp oge double %626, 0.000000e+00
%629 = fneg double %626
%630 = select i1 %628, double %626, double %629
%631 = fadd double %619, %630
%632 = add nuw nsw i64 %605, 2
%633 = add i64 %608, 2
%634 = icmp eq i64 %633, %603
br i1 %634, label %635, label %604
635: ; preds = %604, %597
%636 = phi double [ undef, %597 ], [ %627, %604 ]
%637 = phi double [ undef, %597 ], [ %631, %604 ]
%638 = phi i64 [ 1, %597 ], [ %632, %604 ]
%639 = phi double [ 0.000000e+00, %597 ], [ %631, %604 ]
%640 = phi double [ 0.000000e+00, %597 ], [ %627, %604 ]
%641 = icmp eq i64 %600, 0
br i1 %641, label %654, label %642
642: ; preds = %635
%643 = add nsw i64 %638, %598
%644 = getelementptr inbounds double, double* %19, i64 %643
%645 = load double, double* %644
%646 = getelementptr inbounds double, double* %27, i64 %638
%647 = load double, double* %646
%648 = fmul double %645, %647
%649 = fadd double %640, %648
%650 = fcmp oge double %648, 0.000000e+00
%651 = fneg double %648
%652 = select i1 %650, double %648, double %651
%653 = fadd double %639, %652
br label %654
654: ; preds = %642, %635, %582
%655 = phi double [ 0.000000e+00, %582 ], [ %636, %635 ], [ %649, %642 ]
%656 = phi double [ 0.000000e+00, %582 ], [ %637, %635 ], [ %653, %642 ]
%657 = fcmp oge double %655, 0.000000e+00
%658 = fneg double %655
%659 = select i1 %657, double %655, double %658
%660 = insertelement <2 x double> poison, double %659, i64 0
%661 = shufflevector <2 x double> %660, <2 x double> poison, <2 x i32> zeroinitializer
%662 = insertelement <2 x double> poison, double %656, i64 0
%663 = shufflevector <2 x double> %662, <2 x double> poison, <2 x i32> zeroinitializer
%664 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %661, <2 x double> <double 1.000000e-01, double 2.000000e-01>, <2 x double> %663)
%665 = extractelement <2 x double> %664, i64 0
%666 = fcmp ult double %656, %665
%667 = extractelement <2 x double> %664, i64 1
%668 = fcmp ult double %665, %667
%669 = select i1 %666, i1 %668, i1 false
%670 = select i1 %669, double %655, double 0.000000e+00
%671 = fcmp oeq double %586, 0.000000e+00
br i1 %671, label %741, label %672
672: ; preds = %654
%673 = fmul double %586, %586
%674 = tail call double @llvm.fmuladd.f64(double %670, double %670, double %673)
%675 = tail call double @sqrt(double %674)
%676 = fdiv double %670, %675
%677 = fdiv double %586, %675
%678 = load i32, i32* %0
%679 = icmp slt i32 %678, 1
br i1 %679, label %741, label %680
680: ; preds = %672
%681 = add nsw i64 %585, 1
%682 = mul nsw i64 %585, %308
%683 = mul nsw i64 %681, %308
%684 = fneg double %677
%685 = add nuw i32 %678, 1
%686 = zext i32 %685 to i64
%687 = add nsw i64 %686, -1
%688 = icmp ult i64 %687, 2
br i1 %688, label %725, label %689
689: ; preds = %680
%690 = getelementptr double, double* %591, i64 %686
%691 = getelementptr double, double* %595, i64 %686
%692 = icmp ult double* %589, %691
%693 = icmp ult double* %593, %690
%694 = and i1 %692, %693
br i1 %694, label %725, label %695
695: ; preds = %689
%696 = and i64 %687, -2
%697 = or i64 %687, 1
%698 = insertelement <2 x double> poison, double %677, i64 0
%699 = shufflevector <2 x double> %698, <2 x double> poison, <2 x i32> zeroinitializer
%700 = insertelement <2 x double> poison, double %676, i64 0
%701 = shufflevector <2 x double> %700, <2 x double> poison, <2 x i32> zeroinitializer
%702 = insertelement <2 x double> poison, double %684, i64 0
%703 = shufflevector <2 x double> %702, <2 x double> poison, <2 x i32> zeroinitializer
br label %704
704: ; preds = %704, %695
%705 = phi i64 [ 0, %695 ], [ %721, %704 ]
%706 = or i64 %705, 1
%707 = add nsw i64 %706, %682
%708 = getelementptr inbounds double, double* %19, i64 %707
%709 = bitcast double* %708 to <2 x double>*
%710 = load <2 x double>, <2 x double>* %709
%711 = add nsw i64 %706, %683
%712 = getelementptr inbounds double, double* %19, i64 %711
%713 = bitcast double* %712 to <2 x double>*
%714 = load <2 x double>, <2 x double>* %713
%715 = fmul <2 x double> %699, %714
%716 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %701, <2 x double> %710, <2 x double> %715)
%717 = fmul <2 x double> %710, %703
%718 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %701, <2 x double> %714, <2 x double> %717)
%719 = bitcast double* %712 to <2 x double>*
store <2 x double> %718, <2 x double>* %719
%720 = bitcast double* %708 to <2 x double>*
store <2 x double> %716, <2 x double>* %720
%721 = add nuw i64 %705, 2
%722 = icmp eq i64 %721, %696
br i1 %722, label %723, label %704
723: ; preds = %704
%724 = icmp eq i64 %687, %696
br i1 %724, label %741, label %725
725: ; preds = %689, %680, %723
%726 = phi i64 [ 1, %689 ], [ 1, %680 ], [ %697, %723 ]
br label %727
727: ; preds = %725, %727
%728 = phi i64 [ %739, %727 ], [ %726, %725 ]
%729 = add nsw i64 %728, %682
%730 = getelementptr inbounds double, double* %19, i64 %729
%731 = load double, double* %730
%732 = add nsw i64 %728, %683
%733 = getelementptr inbounds double, double* %19, i64 %732
%734 = load double, double* %733
%735 = fmul double %677, %734
%736 = tail call double @llvm.fmuladd.f64(double %676, double %731, double %735)
%737 = fmul double %731, %684
%738 = tail call double @llvm.fmuladd.f64(double %676, double %734, double %737)
store double %738, double* %733
store double %736, double* %730
%739 = add nuw nsw i64 %728, 1
%740 = icmp eq i64 %739, %686
br i1 %740, label %741, label %727
741: ; preds = %727, %723, %672, %654
%742 = phi i32 [ %584, %654 ], [ %678, %672 ], [ %678, %723 ], [ %678, %727 ]
%743 = phi double [ %670, %654 ], [ %675, %672 ], [ %675, %723 ], [ %675, %727 ]
%744 = add nsw i64 %585, -1
%745 = icmp sgt i64 %744, %551
%746 = add i64 %583, 1
br i1 %745, label %582, label %747
747: ; preds = %741
%748 = fcmp une double %743, 0.000000e+00
br i1 %748, label %778, label %749
749: ; preds = %547, %747
%750 = phi i32 [ %742, %747 ], [ %452, %547 ]
%751 = icmp slt i32 %750, 1
%752 = add i32 %750, 1
%753 = sext i32 %385 to i64
%754 = zext i32 %752 to i64
%755 = zext i32 %752 to i64
%756 = getelementptr double, double* %348, i64 %755
%757 = getelementptr double, double* %351, i64 %755
%758 = add nsw i64 %755, -1
%759 = add nsw i64 %754, -1
%760 = add nsw i64 %754, -5
%761 = lshr i64 %760, 2
%762 = add nuw nsw i64 %761, 1
%763 = and i64 %759, 1
%764 = icmp eq i32 %752, 2
%765 = and i64 %759, -2
%766 = icmp eq i64 %763, 0
%767 = icmp ult i64 %758, 4
%768 = and i64 %758, -4
%769 = or i64 %768, 1
%770 = and i64 %762, 1
%771 = icmp ult i64 %760, 4
%772 = and i64 %762, 9223372036854775806
%773 = icmp eq i64 %770, 0
%774 = icmp eq i64 %758, %768
%775 = and i64 %754, 1
%776 = icmp eq i64 %775, 0
%777 = sub nsw i64 0, %754
br label %785
778: ; preds = %747
%779 = add nsw i32 %385, 1
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds double, double* %24, i64 %780
store double %743, double* %781
%782 = getelementptr inbounds double, double* %25, i64 %780
%783 = load double, double* %782
%784 = getelementptr inbounds double, double* %25, i64 %449
store double %783, double* %784
store double 0.000000e+00, double* %782
br label %1298
785: ; preds = %749, %989
%786 = phi i64 [ %753, %749 ], [ %993, %989 ]
%787 = phi double [ -1.000000e+00, %749 ], [ %991, %989 ]
br i1 %751, label %839, label %788
788: ; preds = %785
%789 = mul nsw i64 %786, %308
br i1 %764, label %821, label %790
790: ; preds = %788, %790
%791 = phi i64 [ %818, %790 ], [ 1, %788 ]
%792 = phi double [ %817, %790 ], [ 0.000000e+00, %788 ]
%793 = phi double [ %813, %790 ], [ 0.000000e+00, %788 ]
%794 = phi i64 [ %819, %790 ], [ 0, %788 ]
%795 = add nsw i64 %791, %789
%796 = getelementptr inbounds double, double* %19, i64 %795
%797 = load double, double* %796
%798 = getelementptr inbounds double, double* %27, i64 %791
%799 = load double, double* %798
%800 = fmul double %797, %799
%801 = fadd double %793, %800
%802 = fcmp oge double %800, 0.000000e+00
%803 = fneg double %800
%804 = select i1 %802, double %800, double %803
%805 = fadd double %792, %804
%806 = add nuw nsw i64 %791, 1
%807 = add nsw i64 %806, %789
%808 = getelementptr inbounds double, double* %19, i64 %807
%809 = load double, double* %808
%810 = getelementptr inbounds double, double* %12, i64 %791
%811 = load double, double* %810
%812 = fmul double %809, %811
%813 = fadd double %801, %812
%814 = fcmp oge double %812, 0.000000e+00
%815 = fneg double %812
%816 = select i1 %814, double %812, double %815
%817 = fadd double %805, %816
%818 = add nuw nsw i64 %791, 2
%819 = add i64 %794, 2
%820 = icmp eq i64 %819, %765
br i1 %820, label %821, label %790
821: ; preds = %790, %788
%822 = phi double [ undef, %788 ], [ %813, %790 ]
%823 = phi double [ undef, %788 ], [ %817, %790 ]
%824 = phi i64 [ 1, %788 ], [ %818, %790 ]
%825 = phi double [ 0.000000e+00, %788 ], [ %817, %790 ]
%826 = phi double [ 0.000000e+00, %788 ], [ %813, %790 ]
br i1 %766, label %839, label %827
827: ; preds = %821
%828 = add nsw i64 %824, %789
%829 = getelementptr inbounds double, double* %19, i64 %828
%830 = load double, double* %829
%831 = getelementptr inbounds double, double* %27, i64 %824
%832 = load double, double* %831
%833 = fmul double %830, %832
%834 = fadd double %826, %833
%835 = fcmp oge double %833, 0.000000e+00
%836 = fneg double %833
%837 = select i1 %835, double %833, double %836
%838 = fadd double %825, %837
br label %839
839: ; preds = %827, %821, %785
%840 = phi double [ 0.000000e+00, %785 ], [ %822, %821 ], [ %834, %827 ]
%841 = phi double [ 0.000000e+00, %785 ], [ %823, %821 ], [ %838, %827 ]
%842 = fcmp oge double %840, 0.000000e+00
%843 = fneg double %840
%844 = select i1 %842, double %840, double %843
%845 = insertelement <2 x double> poison, double %844, i64 0
%846 = shufflevector <2 x double> %845, <2 x double> poison, <2 x i32> zeroinitializer
%847 = insertelement <2 x double> poison, double %841, i64 0
%848 = shufflevector <2 x double> %847, <2 x double> poison, <2 x i32> zeroinitializer
%849 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %846, <2 x double> <double 1.000000e-01, double 2.000000e-01>, <2 x double> %848)
%850 = extractelement <2 x double> %849, i64 0
%851 = fcmp olt double %841, %850
%852 = extractelement <2 x double> %849, i64 1
%853 = fcmp olt double %850, %852
%854 = select i1 %851, i1 %853, i1 false
br i1 %854, label %855, label %989
855: ; preds = %839
%856 = getelementptr inbounds double, double* %24, i64 %786
%857 = load double, double* %856
%858 = fdiv double %840, %857
%859 = fcmp ogt double %858, 0.000000e+00
br i1 %859, label %860, label %873
860: ; preds = %855
%861 = getelementptr inbounds i32, i32* %23, i64 %786
%862 = load i32, i32* %861
%863 = load i32, i32* %1
%864 = icmp sgt i32 %862, %863
br i1 %864, label %873, label %865
865: ; preds = %860
%866 = getelementptr inbounds double, double* %25, i64 %786
%867 = load double, double* %866
%868 = fdiv double %867, %858
%869 = fcmp olt double %787, 0.000000e+00
%870 = fcmp olt double %868, %787
%871 = select i1 %869, i1 true, i1 %870
%872 = select i1 %871, double %868, double %787
br label %873
873: ; preds = %865, %860, %855
%874 = phi double [ %787, %860 ], [ %787, %855 ], [ %872, %865 ]
%875 = icmp slt i64 %786, 2
%876 = select i1 %875, i1 true, i1 %751
br i1 %876, label %989, label %877
877: ; preds = %873
%878 = getelementptr inbounds i32, i32* %23, i64 %786
%879 = load i32, i32* %878
%880 = mul nsw i32 %879, %16
%881 = fneg double %858
%882 = sext i32 %880 to i64
br i1 %767, label %958, label %883
883: ; preds = %877
%884 = getelementptr double, double* %350, i64 %882
%885 = getelementptr double, double* %757, i64 %882
%886 = icmp ugt double* %885, %12
%887 = icmp ult double* %884, %756
%888 = and i1 %886, %887
br i1 %888, label %958, label %889
889: ; preds = %883
%890 = insertelement <2 x double> poison, double %881, i64 0
%891 = shufflevector <2 x double> %890, <2 x double> poison, <2 x i32> zeroinitializer
%892 = insertelement <2 x double> poison, double %881, i64 0
%893 = shufflevector <2 x double> %892, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %771, label %936, label %894
894: ; preds = %889, %894
%895 = phi i64 [ %933, %894 ], [ 0, %889 ]
%896 = phi i64 [ %934, %894 ], [ 0, %889 ]
%897 = or i64 %895, 1
%898 = add nsw i64 %897, %882
%899 = getelementptr inbounds double, double* %20, i64 %898
%900 = bitcast double* %899 to <2 x double>*
%901 = load <2 x double>, <2 x double>* %900
%902 = getelementptr inbounds double, double* %899, i64 2
%903 = bitcast double* %902 to <2 x double>*
%904 = load <2 x double>, <2 x double>* %903
%905 = getelementptr inbounds double, double* %27, i64 %897
%906 = bitcast double* %905 to <2 x double>*
%907 = load <2 x double>, <2 x double>* %906
%908 = getelementptr inbounds double, double* %905, i64 2
%909 = bitcast double* %908 to <2 x double>*
%910 = load <2 x double>, <2 x double>* %909
%911 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %891, <2 x double> %901, <2 x double> %907)
%912 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %893, <2 x double> %904, <2 x double> %910)
%913 = bitcast double* %905 to <2 x double>*
store <2 x double> %911, <2 x double>* %913
%914 = bitcast double* %908 to <2 x double>*
store <2 x double> %912, <2 x double>* %914
%915 = or i64 %895, 5
%916 = add nsw i64 %915, %882
%917 = getelementptr inbounds double, double* %20, i64 %916
%918 = bitcast double* %917 to <2 x double>*
%919 = load <2 x double>, <2 x double>* %918
%920 = getelementptr inbounds double, double* %917, i64 2
%921 = bitcast double* %920 to <2 x double>*
%922 = load <2 x double>, <2 x double>* %921
%923 = getelementptr inbounds double, double* %27, i64 %915
%924 = bitcast double* %923 to <2 x double>*
%925 = load <2 x double>, <2 x double>* %924
%926 = getelementptr inbounds double, double* %923, i64 2
%927 = bitcast double* %926 to <2 x double>*
%928 = load <2 x double>, <2 x double>* %927
%929 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %891, <2 x double> %919, <2 x double> %925)
%930 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %893, <2 x double> %922, <2 x double> %928)
%931 = bitcast double* %923 to <2 x double>*
store <2 x double> %929, <2 x double>* %931
%932 = bitcast double* %926 to <2 x double>*
store <2 x double> %930, <2 x double>* %932
%933 = add nuw i64 %895, 8
%934 = add i64 %896, 2
%935 = icmp eq i64 %934, %772
br i1 %935, label %936, label %894
936: ; preds = %894, %889
%937 = phi i64 [ 0, %889 ], [ %933, %894 ]
br i1 %773, label %957, label %938
938: ; preds = %936
%939 = or i64 %937, 1
%940 = add nsw i64 %939, %882
%941 = getelementptr inbounds double, double* %20, i64 %940
%942 = bitcast double* %941 to <2 x double>*
%943 = load <2 x double>, <2 x double>* %942
%944 = getelementptr inbounds double, double* %941, i64 2
%945 = bitcast double* %944 to <2 x double>*
%946 = load <2 x double>, <2 x double>* %945
%947 = getelementptr inbounds double, double* %27, i64 %939
%948 = bitcast double* %947 to <2 x double>*
%949 = load <2 x double>, <2 x double>* %948
%950 = getelementptr inbounds double, double* %947, i64 2
%951 = bitcast double* %950 to <2 x double>*
%952 = load <2 x double>, <2 x double>* %951
%953 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %891, <2 x double> %943, <2 x double> %949)
%954 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %893, <2 x double> %946, <2 x double> %952)
%955 = bitcast double* %947 to <2 x double>*
store <2 x double> %953, <2 x double>* %955
%956 = bitcast double* %950 to <2 x double>*
store <2 x double> %954, <2 x double>* %956
br label %957
957: ; preds = %936, %938
br i1 %774, label %989, label %958
958: ; preds = %883, %877, %957
%959 = phi i64 [ 1, %883 ], [ 1, %877 ], [ %769, %957 ]
%960 = xor i64 %959, -1
br i1 %776, label %961, label %969
961: ; preds = %958
%962 = add nsw i64 %959, %882
%963 = getelementptr inbounds double, double* %20, i64 %962
%964 = load double, double* %963
%965 = getelementptr inbounds double, double* %27, i64 %959
%966 = load double, double* %965
%967 = tail call double @llvm.fmuladd.f64(double %881, double %964, double %966)
store double %967, double* %965
%968 = add nuw nsw i64 %959, 1
br label %969
969: ; preds = %961, %958
%970 = phi i64 [ %959, %958 ], [ %968, %961 ]
%971 = icmp eq i64 %960, %777
br i1 %971, label %989, label %972
972: ; preds = %969, %972
%973 = phi i64 [ %987, %972 ], [ %970, %969 ]
%974 = add nsw i64 %973, %882
%975 = getelementptr inbounds double, double* %20, i64 %974
%976 = load double, double* %975
%977 = getelementptr inbounds double, double* %27, i64 %973
%978 = load double, double* %977
%979 = tail call double @llvm.fmuladd.f64(double %881, double %976, double %978)
store double %979, double* %977
%980 = add nuw nsw i64 %973, 1
%981 = add nsw i64 %980, %882
%982 = getelementptr inbounds double, double* %20, i64 %981
%983 = load double, double* %982
%984 = getelementptr inbounds double, double* %12, i64 %973
%985 = load double, double* %984
%986 = tail call double @llvm.fmuladd.f64(double %881, double %983, double %985)
store double %986, double* %984
%987 = add nuw nsw i64 %973, 2
%988 = icmp eq i64 %987, %755
br i1 %988, label %989, label %972
989: ; preds = %969, %972, %957, %839, %873
%990 = phi double [ %858, %873 ], [ 0.000000e+00, %839 ], [ %858, %957 ], [ %858, %972 ], [ %858, %969 ]
%991 = phi double [ %874, %873 ], [ %787, %839 ], [ %874, %957 ], [ %874, %972 ], [ %874, %969 ]
%992 = getelementptr inbounds double, double* %28, i64 %786
store double %990, double* %992
%993 = add nsw i64 %786, -1
%994 = icmp sgt i64 %786, 1
br i1 %994, label %785, label %995
995: ; preds = %989
%996 = fcmp olt double %991, 0.000000e+00
br i1 %996, label %3095, label %997
997: ; preds = %995
%998 = icmp slt i32 %385, 1
br i1 %998, label %1081, label %999
999: ; preds = %997
%1000 = fneg double %991
%1001 = add nuw i32 %385, 1
%1002 = zext i32 %1001 to i64
%1003 = add nsw i64 %1002, -1
%1004 = icmp ult i64 %1003, 4
br i1 %1004, label %1045, label %1005
1005: ; preds = %999
%1006 = getelementptr double, double* %346, i64 %1002
%1007 = getelementptr double, double* %347, i64 %1002
%1008 = icmp ugt double* %1007, %10
%1009 = icmp ugt double* %1006, %13
%1010 = and i1 %1008, %1009
br i1 %1010, label %1045, label %1011
1011: ; preds = %1005
%1012 = and i64 %1003, -4
%1013 = or i64 %1012, 1
%1014 = insertelement <2 x double> poison, double %1000, i64 0
%1015 = shufflevector <2 x double> %1014, <2 x double> poison, <2 x i32> zeroinitializer
%1016 = insertelement <2 x double> poison, double %1000, i64 0
%1017 = shufflevector <2 x double> %1016, <2 x double> poison, <2 x i32> zeroinitializer
br label %1018
1018: ; preds = %1018, %1011
%1019 = phi i64 [ 0, %1011 ], [ %1041, %1018 ]
%1020 = or i64 %1019, 1
%1021 = getelementptr inbounds double, double* %25, i64 %1020
%1022 = bitcast double* %1021 to <2 x double>*
%1023 = load <2 x double>, <2 x double>* %1022
%1024 = getelementptr inbounds double, double* %1021, i64 2
%1025 = bitcast double* %1024 to <2 x double>*
%1026 = load <2 x double>, <2 x double>* %1025
%1027 = getelementptr inbounds double, double* %28, i64 %1020
%1028 = bitcast double* %1027 to <2 x double>*
%1029 = load <2 x double>, <2 x double>* %1028
%1030 = getelementptr inbounds double, double* %1027, i64 2
%1031 = bitcast double* %1030 to <2 x double>*
%1032 = load <2 x double>, <2 x double>* %1031
%1033 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1015, <2 x double> %1029, <2 x double> %1023)
%1034 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1017, <2 x double> %1032, <2 x double> %1026)
%1035 = fcmp ole <2 x double> %1033, zeroinitializer
%1036 = fcmp ole <2 x double> %1034, zeroinitializer
%1037 = select <2 x i1> %1035, <2 x double> zeroinitializer, <2 x double> %1033
%1038 = select <2 x i1> %1036, <2 x double> zeroinitializer, <2 x double> %1034
%1039 = bitcast double* %1021 to <2 x double>*
store <2 x double> %1037, <2 x double>* %1039
%1040 = bitcast double* %1024 to <2 x double>*
store <2 x double> %1038, <2 x double>* %1040
%1041 = add nuw i64 %1019, 4
%1042 = icmp eq i64 %1041, %1012
br i1 %1042, label %1043, label %1018
1043: ; preds = %1018
%1044 = icmp eq i64 %1003, %1012
br i1 %1044, label %1081, label %1045
1045: ; preds = %1005, %999, %1043
%1046 = phi i64 [ 1, %1005 ], [ 1, %999 ], [ %1013, %1043 ]
%1047 = xor i64 %1046, -1
%1048 = and i64 %1002, 1
%1049 = icmp eq i64 %1048, 0
br i1 %1049, label %1050, label %1059
1050: ; preds = %1045
%1051 = getelementptr inbounds double, double* %25, i64 %1046
%1052 = load double, double* %1051
%1053 = getelementptr inbounds double, double* %28, i64 %1046
%1054 = load double, double* %1053
%1055 = tail call double @llvm.fmuladd.f64(double %1000, double %1054, double %1052)
%1056 = fcmp ole double %1055, 0.000000e+00
%1057 = select i1 %1056, double 0.000000e+00, double %1055
store double %1057, double* %1051
%1058 = add nuw nsw i64 %1046, 1
br label %1059
1059: ; preds = %1050, %1045
%1060 = phi i64 [ %1046, %1045 ], [ %1058, %1050 ]
%1061 = sub nsw i64 0, %1002
%1062 = icmp eq i64 %1047, %1061
br i1 %1062, label %1081, label %1063
1063: ; preds = %1059, %1063
%1064 = phi i64 [ %1079, %1063 ], [ %1060, %1059 ]
%1065 = getelementptr inbounds double, double* %25, i64 %1064
%1066 = load double, double* %1065
%1067 = getelementptr inbounds double, double* %28, i64 %1064
%1068 = load double, double* %1067
%1069 = tail call double @llvm.fmuladd.f64(double %1000, double %1068, double %1066)
%1070 = fcmp ole double %1069, 0.000000e+00
%1071 = select i1 %1070, double 0.000000e+00, double %1069
store double %1071, double* %1065
%1072 = getelementptr inbounds double, double* %10, i64 %1064
%1073 = load double, double* %1072
%1074 = getelementptr inbounds double, double* %13, i64 %1064
%1075 = load double, double* %1074
%1076 = tail call double @llvm.fmuladd.f64(double %1000, double %1075, double %1073)
%1077 = fcmp ole double %1076, 0.000000e+00
%1078 = select i1 %1077, double 0.000000e+00, double %1076
store double %1078, double* %1072
%1079 = add nuw nsw i64 %1064, 2
%1080 = icmp eq i64 %1079, %1002
br i1 %1080, label %1081, label %1063
1081: ; preds = %1059, %1063, %1043, %997
%1082 = icmp slt i32 %386, %385
br i1 %1082, label %1083, label %1243
1083: ; preds = %1081
%1084 = load i32, i32* %450
%1085 = getelementptr inbounds double, double* %25, i64 %449
%1086 = load double, double* %1085
%1087 = add nsw i64 %449, 1
%1088 = mul i64 %1087, %308
%1089 = add i64 %344, %1088
%1090 = add i64 %1088, %18
%1091 = mul nsw i64 %308, %449
%1092 = add i64 %345, %1091
%1093 = add i64 %1091, %18
br label %1094
1094: ; preds = %1236, %1083
%1095 = phi i64 [ %1238, %1236 ], [ 0, %1083 ]
%1096 = phi i32 [ %1237, %1236 ], [ %750, %1083 ]
%1097 = phi i64 [ %1107, %1236 ], [ %449, %1083 ]
%1098 = mul i64 %1095, %308
%1099 = add i64 %1089, %1098
%1100 = getelementptr double, double* %8, i64 %1099
%1101 = add i64 %1090, %1098
%1102 = getelementptr double, double* %8, i64 %1101
%1103 = add i64 %1092, %1098
%1104 = getelementptr double, double* %8, i64 %1103
%1105 = add i64 %1093, %1098
%1106 = getelementptr double, double* %8, i64 %1105
%1107 = add nsw i64 %1097, 1
%1108 = getelementptr inbounds i32, i32* %7, i64 %1097
%1109 = load i32, i32* %1108
%1110 = icmp slt i32 %1096, 1
br i1 %1110, label %1155, label %1111
1111: ; preds = %1094
%1112 = mul nsw i64 %1097, %308
%1113 = mul nsw i32 %1109, %16
%1114 = sext i32 %1113 to i64
%1115 = zext i32 %1096 to i64
%1116 = and i64 %1115, 1
%1117 = icmp eq i32 %1096, 1
br i1 %1117, label %1142, label %1118
1118: ; preds = %1111
%1119 = and i64 %1115, 4294967294
br label %1120
1120: ; preds = %1120, %1118
%1121 = phi i64 [ 1, %1118 ], [ %1139, %1120 ]
%1122 = phi double [ 0.000000e+00, %1118 ], [ %1138, %1120 ]
%1123 = phi i64 [ 0, %1118 ], [ %1140, %1120 ]
%1124 = add nsw i64 %1121, %1112
%1125 = getelementptr inbounds double, double* %19, i64 %1124
%1126 = load double, double* %1125
%1127 = add nsw i64 %1121, %1114
%1128 = getelementptr inbounds double, double* %20, i64 %1127
%1129 = load double, double* %1128
%1130 = tail call double @llvm.fmuladd.f64(double %1126, double %1129, double %1122)
%1131 = add nuw nsw i64 %1121, 1
%1132 = add nsw i64 %1131, %1112
%1133 = getelementptr inbounds double, double* %19, i64 %1132
%1134 = load double, double* %1133
%1135 = add nsw i64 %1131, %1114
%1136 = getelementptr inbounds double, double* %20, i64 %1135
%1137 = load double, double* %1136
%1138 = tail call double @llvm.fmuladd.f64(double %1134, double %1137, double %1130)
%1139 = add nuw nsw i64 %1121, 2
%1140 = add i64 %1123, 2
%1141 = icmp eq i64 %1140, %1119
br i1 %1141, label %1142, label %1120
1142: ; preds = %1120, %1111
%1143 = phi double [ undef, %1111 ], [ %1138, %1120 ]
%1144 = phi i64 [ 1, %1111 ], [ %1139, %1120 ]
%1145 = phi double [ 0.000000e+00, %1111 ], [ %1138, %1120 ]
%1146 = icmp eq i64 %1116, 0
br i1 %1146, label %1155, label %1147
1147: ; preds = %1142
%1148 = add nsw i64 %1144, %1112
%1149 = getelementptr inbounds double, double* %19, i64 %1148
%1150 = load double, double* %1149
%1151 = add nsw i64 %1144, %1114
%1152 = getelementptr inbounds double, double* %20, i64 %1151
%1153 = load double, double* %1152
%1154 = tail call double @llvm.fmuladd.f64(double %1150, double %1153, double %1145)
br label %1155
1155: ; preds = %1147, %1142, %1094
%1156 = phi double [ 0.000000e+00, %1094 ], [ %1143, %1142 ], [ %1154, %1147 ]
%1157 = getelementptr inbounds double, double* %9, i64 %1097
%1158 = load double, double* %1157
%1159 = fmul double %1158, %1158
%1160 = tail call double @llvm.fmuladd.f64(double %1156, double %1156, double %1159)
%1161 = tail call double @sqrt(double %1160)
%1162 = load double, double* %1157
%1163 = fdiv double %1162, %1161
%1164 = fdiv double %1156, %1161
%1165 = getelementptr inbounds double, double* %24, i64 %1097
%1166 = load double, double* %1165
%1167 = fmul double %1163, %1166
store double %1167, double* %1157
store double %1161, double* %1165
%1168 = load i32, i32* %0
%1169 = icmp slt i32 %1168, 1
br i1 %1169, label %1230, label %1170
1170: ; preds = %1155
%1171 = mul nsw i64 %1107, %308
%1172 = mul nsw i64 %1097, %308
%1173 = fneg double %1164
%1174 = add nuw i32 %1168, 1
%1175 = zext i32 %1174 to i64
%1176 = add nsw i64 %1175, -1
%1177 = icmp ult i64 %1176, 2
br i1 %1177, label %1214, label %1178
1178: ; preds = %1170
%1179 = getelementptr double, double* %1102, i64 %1175
%1180 = getelementptr double, double* %1106, i64 %1175
%1181 = icmp ult double* %1100, %1180
%1182 = icmp ult double* %1104, %1179
%1183 = and i1 %1181, %1182
br i1 %1183, label %1214, label %1184
1184: ; preds = %1178
%1185 = and i64 %1176, -2
%1186 = or i64 %1176, 1
%1187 = insertelement <2 x double> poison, double %1164, i64 0
%1188 = shufflevector <2 x double> %1187, <2 x double> poison, <2 x i32> zeroinitializer
%1189 = insertelement <2 x double> poison, double %1163, i64 0
%1190 = shufflevector <2 x double> %1189, <2 x double> poison, <2 x i32> zeroinitializer
%1191 = insertelement <2 x double> poison, double %1173, i64 0
%1192 = shufflevector <2 x double> %1191, <2 x double> poison, <2 x i32> zeroinitializer
br label %1193
1193: ; preds = %1193, %1184
%1194 = phi i64 [ 0, %1184 ], [ %1210, %1193 ]
%1195 = or i64 %1194, 1
%1196 = add nsw i64 %1195, %1171
%1197 = getelementptr inbounds double, double* %19, i64 %1196
%1198 = bitcast double* %1197 to <2 x double>*
%1199 = load <2 x double>, <2 x double>* %1198
%1200 = add nsw i64 %1195, %1172
%1201 = getelementptr inbounds double, double* %19, i64 %1200
%1202 = bitcast double* %1201 to <2 x double>*
%1203 = load <2 x double>, <2 x double>* %1202
%1204 = fmul <2 x double> %1188, %1203
%1205 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1190, <2 x double> %1199, <2 x double> %1204)
%1206 = fmul <2 x double> %1199, %1192
%1207 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1190, <2 x double> %1203, <2 x double> %1206)
%1208 = bitcast double* %1197 to <2 x double>*
store <2 x double> %1207, <2 x double>* %1208
%1209 = bitcast double* %1201 to <2 x double>*
store <2 x double> %1205, <2 x double>* %1209
%1210 = add nuw i64 %1194, 2
%1211 = icmp eq i64 %1210, %1185
br i1 %1211, label %1212, label %1193
1212: ; preds = %1193
%1213 = icmp eq i64 %1176, %1185
br i1 %1213, label %1230, label %1214
1214: ; preds = %1178, %1170, %1212
%1215 = phi i64 [ 1, %1178 ], [ 1, %1170 ], [ %1186, %1212 ]
br label %1216
1216: ; preds = %1214, %1216
%1217 = phi i64 [ %1228, %1216 ], [ %1215, %1214 ]
%1218 = add nsw i64 %1217, %1171
%1219 = getelementptr inbounds double, double* %19, i64 %1218
%1220 = load double, double* %1219
%1221 = add nsw i64 %1217, %1172
%1222 = getelementptr inbounds double, double* %19, i64 %1221
%1223 = load double, double* %1222
%1224 = fmul double %1164, %1223
%1225 = tail call double @llvm.fmuladd.f64(double %1163, double %1220, double %1224)
%1226 = fmul double %1220, %1173
%1227 = tail call double @llvm.fmuladd.f64(double %1163, double %1223, double %1226)
store double %1227, double* %1219
store double %1225, double* %1222
%1228 = add nuw nsw i64 %1217, 1
%1229 = icmp eq i64 %1228, %1175
br i1 %1229, label %1230, label %1216
1230: ; preds = %1216, %1212, %1155
%1231 = getelementptr inbounds i32, i32* %23, i64 %1097
store i32 %1109, i32* %1231
%1232 = getelementptr inbounds double, double* %10, i64 %1097
%1233 = load double, double* %1232
%1234 = getelementptr inbounds double, double* %25, i64 %1097
store double %1233, double* %1234
%1235 = icmp eq i64 %1107, %753
br i1 %1235, label %1239, label %1236
1236: ; preds = %1230
%1237 = load i32, i32* %0
%1238 = add i64 %1095, 1
br label %1094
1239: ; preds = %1230
%1240 = getelementptr inbounds i32, i32* %23, i64 %753
%1241 = getelementptr inbounds double, double* %25, i64 %753
store i32 %1084, i32* %1240
store double %1086, double* %1241
%1242 = load i32, i32* %0
br label %1243
1243: ; preds = %1239, %1081
%1244 = phi i32 [ %1242, %1239 ], [ %750, %1081 ]
%1245 = icmp slt i32 %1244, 1
br i1 %1245, label %3095, label %1246
1246: ; preds = %1243
%1247 = mul nsw i32 %385, %16
%1248 = mul nsw i32 %451, %16
%1249 = sext i32 %1247 to i64
%1250 = sext i32 %1248 to i64
%1251 = zext i32 %1244 to i64
%1252 = and i64 %1251, 1
%1253 = icmp eq i32 %1244, 1
br i1 %1253, label %1278, label %1254
1254: ; preds = %1246
%1255 = and i64 %1251, 4294967294
br label %1256
1256: ; preds = %1256, %1254
%1257 = phi i64 [ 1, %1254 ], [ %1275, %1256 ]
%1258 = phi double [ 0.000000e+00, %1254 ], [ %1274, %1256 ]
%1259 = phi i64 [ 0, %1254 ], [ %1276, %1256 ]
%1260 = add nsw i64 %1257, %1249
%1261 = getelementptr inbounds double, double* %19, i64 %1260
%1262 = load double, double* %1261
%1263 = add nsw i64 %1257, %1250
%1264 = getelementptr inbounds double, double* %20, i64 %1263
%1265 = load double, double* %1264
%1266 = tail call double @llvm.fmuladd.f64(double %1262, double %1265, double %1258)
%1267 = add nuw nsw i64 %1257, 1
%1268 = add nsw i64 %1267, %1249
%1269 = getelementptr inbounds double, double* %19, i64 %1268
%1270 = load double, double* %1269
%1271 = add nsw i64 %1267, %1250
%1272 = getelementptr inbounds double, double* %20, i64 %1271
%1273 = load double, double* %1272
%1274 = tail call double @llvm.fmuladd.f64(double %1270, double %1273, double %1266)
%1275 = add nuw nsw i64 %1257, 2
%1276 = add i64 %1259, 2
%1277 = icmp eq i64 %1276, %1255
br i1 %1277, label %1278, label %1256
1278: ; preds = %1256, %1246
%1279 = phi double [ undef, %1246 ], [ %1274, %1256 ]
%1280 = phi i64 [ 1, %1246 ], [ %1275, %1256 ]
%1281 = phi double [ 0.000000e+00, %1246 ], [ %1274, %1256 ]
%1282 = icmp eq i64 %1252, 0
br i1 %1282, label %1291, label %1283
1283: ; preds = %1278
%1284 = add nsw i64 %1280, %1249
%1285 = getelementptr inbounds double, double* %19, i64 %1284
%1286 = load double, double* %1285
%1287 = add nsw i64 %1280, %1250
%1288 = getelementptr inbounds double, double* %20, i64 %1287
%1289 = load double, double* %1288
%1290 = tail call double @llvm.fmuladd.f64(double %1286, double %1289, double %1281)
br label %1291
1291: ; preds = %1278, %1283
%1292 = phi double [ %1279, %1278 ], [ %1290, %1283 ]
%1293 = fcmp oeq double %1292, 0.000000e+00
br i1 %1293, label %3095, label %1294
1294: ; preds = %1291
%1295 = getelementptr inbounds double, double* %24, i64 %753
store double %1292, double* %1295
%1296 = getelementptr inbounds double, double* %25, i64 %449
store double 0.000000e+00, double* %1296
%1297 = getelementptr inbounds double, double* %25, i64 %753
store double %991, double* %1297
br label %1298
1298: ; preds = %1294, %778
%1299 = phi i64 [ %753, %1294 ], [ %780, %778 ]
%1300 = phi i32 [ %385, %1294 ], [ %779, %778 ]
%1301 = getelementptr inbounds i32, i32* %23, i64 %1299
%1302 = load i32, i32* %1301
store i32 %1302, i32* %450
store i32 %451, i32* %1301
%1303 = load i32, i32* %1
%1304 = icmp sle i32 %303, %1303
%1305 = icmp eq i32 %451, %303
%1306 = select i1 %1304, i1 true, i1 %1305
br i1 %1306, label %1446, label %1307
1307: ; preds = %1298
%1308 = add nsw i32 %1300, -1
%1309 = load i32, i32* %0
%1310 = icmp slt i32 %1309, 1
br i1 %1310, label %1356, label %1311
1311: ; preds = %1307
%1312 = mul nsw i32 %1308, %16
%1313 = mul nsw i32 %451, %16
%1314 = sext i32 %1312 to i64
%1315 = sext i32 %1313 to i64
%1316 = zext i32 %1309 to i64
%1317 = and i64 %1316, 1
%1318 = icmp eq i32 %1309, 1
br i1 %1318, label %1343, label %1319
1319: ; preds = %1311
%1320 = and i64 %1316, 4294967294
br label %1321
1321: ; preds = %1321, %1319
%1322 = phi i64 [ 1, %1319 ], [ %1340, %1321 ]
%1323 = phi double [ 0.000000e+00, %1319 ], [ %1339, %1321 ]
%1324 = phi i64 [ 0, %1319 ], [ %1341, %1321 ]
%1325 = add nsw i64 %1322, %1314
%1326 = getelementptr inbounds double, double* %19, i64 %1325
%1327 = load double, double* %1326
%1328 = add nsw i64 %1322, %1315
%1329 = getelementptr inbounds double, double* %20, i64 %1328
%1330 = load double, double* %1329
%1331 = tail call double @llvm.fmuladd.f64(double %1327, double %1330, double %1323)
%1332 = add nuw nsw i64 %1322, 1
%1333 = add nsw i64 %1332, %1314
%1334 = getelementptr inbounds double, double* %19, i64 %1333
%1335 = load double, double* %1334
%1336 = add nsw i64 %1332, %1315
%1337 = getelementptr inbounds double, double* %20, i64 %1336
%1338 = load double, double* %1337
%1339 = tail call double @llvm.fmuladd.f64(double %1335, double %1338, double %1331)
%1340 = add nuw nsw i64 %1322, 2
%1341 = add i64 %1324, 2
%1342 = icmp eq i64 %1341, %1320
br i1 %1342, label %1343, label %1321
1343: ; preds = %1321, %1311
%1344 = phi double [ undef, %1311 ], [ %1339, %1321 ]
%1345 = phi i64 [ 1, %1311 ], [ %1340, %1321 ]
%1346 = phi double [ 0.000000e+00, %1311 ], [ %1339, %1321 ]
%1347 = icmp eq i64 %1317, 0
br i1 %1347, label %1356, label %1348
1348: ; preds = %1343
%1349 = add nsw i64 %1345, %1314
%1350 = getelementptr inbounds double, double* %19, i64 %1349
%1351 = load double, double* %1350
%1352 = add nsw i64 %1345, %1315
%1353 = getelementptr inbounds double, double* %20, i64 %1352
%1354 = load double, double* %1353
%1355 = tail call double @llvm.fmuladd.f64(double %1351, double %1354, double %1346)
br label %1356
1356: ; preds = %1348, %1343, %1307
%1357 = phi double [ 0.000000e+00, %1307 ], [ %1344, %1343 ], [ %1355, %1348 ]
%1358 = getelementptr inbounds double, double* %24, i64 %1299
%1359 = load double, double* %1358
%1360 = fmul double %1359, %1359
%1361 = tail call double @llvm.fmuladd.f64(double %1357, double %1357, double %1360)
%1362 = tail call double @sqrt(double %1361)
%1363 = load double, double* %1358
%1364 = fdiv double %1363, %1362
%1365 = fdiv double %1357, %1362
%1366 = sext i32 %1308 to i64
%1367 = getelementptr inbounds double, double* %24, i64 %1366
%1368 = load double, double* %1367
%1369 = fmul double %1364, %1368
store double %1369, double* %1358
store double %1362, double* %1367
%1370 = load i32, i32* %0
%1371 = icmp slt i32 %1370, 1
br i1 %1371, label %1438, label %1372
1372: ; preds = %1356
%1373 = mul nsw i32 %1300, %16
%1374 = mul nsw i32 %1308, %16
%1375 = fneg double %1365
%1376 = sext i32 %1373 to i64
%1377 = sext i32 %1374 to i64
%1378 = add nuw i32 %1370, 1
%1379 = zext i32 %1378 to i64
%1380 = add nsw i64 %1379, -1
%1381 = icmp ult i64 %1380, 2
br i1 %1381, label %1422, label %1382
1382: ; preds = %1372
%1383 = getelementptr double, double* %340, i64 %1376
%1384 = add nsw i64 %1376, %1379
%1385 = getelementptr double, double* %341, i64 %1384
%1386 = getelementptr double, double* %342, i64 %1377
%1387 = add nsw i64 %1377, %1379
%1388 = getelementptr double, double* %343, i64 %1387
%1389 = icmp ult double* %1383, %1388
%1390 = icmp ult double* %1386, %1385
%1391 = and i1 %1389, %1390
br i1 %1391, label %1422, label %1392
1392: ; preds = %1382
%1393 = and i64 %1380, -2
%1394 = or i64 %1380, 1
%1395 = insertelement <2 x double> poison, double %1365, i64 0
%1396 = shufflevector <2 x double> %1395, <2 x double> poison, <2 x i32> zeroinitializer
%1397 = insertelement <2 x double> poison, double %1364, i64 0
%1398 = shufflevector <2 x double> %1397, <2 x double> poison, <2 x i32> zeroinitializer
%1399 = insertelement <2 x double> poison, double %1375, i64 0
%1400 = shufflevector <2 x double> %1399, <2 x double> poison, <2 x i32> zeroinitializer
br label %1401
1401: ; preds = %1401, %1392
%1402 = phi i64 [ 0, %1392 ], [ %1418, %1401 ]
%1403 = or i64 %1402, 1
%1404 = add nsw i64 %1403, %1376
%1405 = getelementptr inbounds double, double* %19, i64 %1404
%1406 = bitcast double* %1405 to <2 x double>*
%1407 = load <2 x double>, <2 x double>* %1406
%1408 = add nsw i64 %1403, %1377
%1409 = getelementptr inbounds double, double* %19, i64 %1408
%1410 = bitcast double* %1409 to <2 x double>*
%1411 = load <2 x double>, <2 x double>* %1410
%1412 = fmul <2 x double> %1396, %1411
%1413 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1398, <2 x double> %1407, <2 x double> %1412)
%1414 = fmul <2 x double> %1407, %1400
%1415 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1398, <2 x double> %1411, <2 x double> %1414)
%1416 = bitcast double* %1405 to <2 x double>*
store <2 x double> %1415, <2 x double>* %1416
%1417 = bitcast double* %1409 to <2 x double>*
store <2 x double> %1413, <2 x double>* %1417
%1418 = add nuw i64 %1402, 2
%1419 = icmp eq i64 %1418, %1393
br i1 %1419, label %1420, label %1401
1420: ; preds = %1401
%1421 = icmp eq i64 %1380, %1393
br i1 %1421, label %1438, label %1422
1422: ; preds = %1382, %1372, %1420
%1423 = phi i64 [ 1, %1382 ], [ 1, %1372 ], [ %1394, %1420 ]
br label %1424
1424: ; preds = %1422, %1424
%1425 = phi i64 [ %1436, %1424 ], [ %1423, %1422 ]
%1426 = add nsw i64 %1425, %1376
%1427 = getelementptr inbounds double, double* %19, i64 %1426
%1428 = load double, double* %1427
%1429 = add nsw i64 %1425, %1377
%1430 = getelementptr inbounds double, double* %19, i64 %1429
%1431 = load double, double* %1430
%1432 = fmul double %1365, %1431
%1433 = tail call double @llvm.fmuladd.f64(double %1364, double %1428, double %1432)
%1434 = fmul double %1428, %1375
%1435 = tail call double @llvm.fmuladd.f64(double %1364, double %1431, double %1434)
store double %1435, double* %1427
store double %1433, double* %1430
%1436 = add nuw nsw i64 %1425, 1
%1437 = icmp eq i64 %1436, %1379
br i1 %1437, label %1438, label %1424
1438: ; preds = %1424, %1420, %1356
%1439 = getelementptr inbounds i32, i32* %23, i64 %1366
%1440 = load i32, i32* %1439
store i32 %1440, i32* %1301
store i32 %451, i32* %1439
%1441 = getelementptr inbounds double, double* %25, i64 %1366
%1442 = load double, double* %1441
%1443 = getelementptr inbounds double, double* %25, i64 %1299
%1444 = load double, double* %1443
store double %1444, double* %1441
store double %1442, double* %1443
%1445 = load i32, i32* %1
br label %1446
1446: ; preds = %1438, %1298
%1447 = phi i32 [ %1445, %1438 ], [ %1303, %1298 ]
%1448 = icmp sgt i32 %303, %1447
br i1 %1448, label %2017, label %1449
1449: ; preds = %1446
%1450 = load i32, i32* %0
%1451 = icmp slt i32 %1450, 1
br i1 %1451, label %2156, label %1452
1452: ; preds = %1449
%1453 = load i32, i32* %1301
%1454 = mul nsw i32 %1453, %16
%1455 = sext i32 %1454 to i64
%1456 = add nuw i32 %1450, 1
%1457 = zext i32 %1456 to i64
%1458 = add nsw i64 %1457, -1
%1459 = add nsw i64 %1457, -2
%1460 = and i64 %1458, 3
%1461 = icmp ult i64 %1459, 3
br i1 %1461, label %1498, label %1462
1462: ; preds = %1452
%1463 = and i64 %1458, -4
br label %1464
1464: ; preds = %1464, %1462
%1465 = phi i64 [ 1, %1462 ], [ %1495, %1464 ]
%1466 = phi double [ 0.000000e+00, %1462 ], [ %1494, %1464 ]
%1467 = phi i64 [ 0, %1462 ], [ %1496, %1464 ]
%1468 = getelementptr inbounds double, double* %26, i64 %1465
%1469 = load double, double* %1468
%1470 = add nsw i64 %1465, %1455
%1471 = getelementptr inbounds double, double* %20, i64 %1470
%1472 = load double, double* %1471
%1473 = tail call double @llvm.fmuladd.f64(double %1469, double %1472, double %1466)
%1474 = add nuw nsw i64 %1465, 1
%1475 = getelementptr inbounds double, double* %11, i64 %1465
%1476 = load double, double* %1475
%1477 = add nsw i64 %1474, %1455
%1478 = getelementptr inbounds double, double* %20, i64 %1477
%1479 = load double, double* %1478
%1480 = tail call double @llvm.fmuladd.f64(double %1476, double %1479, double %1473)
%1481 = add nuw nsw i64 %1465, 2
%1482 = getelementptr inbounds double, double* %26, i64 %1481
%1483 = load double, double* %1482
%1484 = add nsw i64 %1481, %1455
%1485 = getelementptr inbounds double, double* %20, i64 %1484
%1486 = load double, double* %1485
%1487 = tail call double @llvm.fmuladd.f64(double %1483, double %1486, double %1480)
%1488 = add nuw nsw i64 %1465, 3
%1489 = getelementptr inbounds double, double* %26, i64 %1488
%1490 = load double, double* %1489
%1491 = add nsw i64 %1488, %1455
%1492 = getelementptr inbounds double, double* %20, i64 %1491
%1493 = load double, double* %1492
%1494 = tail call double @llvm.fmuladd.f64(double %1490, double %1493, double %1487)
%1495 = add nuw nsw i64 %1465, 4
%1496 = add nuw i64 %1467, 4
%1497 = icmp eq i64 %1496, %1463
br i1 %1497, label %1498, label %1464
1498: ; preds = %1464, %1452
%1499 = phi double [ undef, %1452 ], [ %1494, %1464 ]
%1500 = phi i64 [ 1, %1452 ], [ %1495, %1464 ]
%1501 = phi double [ 0.000000e+00, %1452 ], [ %1494, %1464 ]
%1502 = icmp eq i64 %1460, 0
br i1 %1502, label %1516, label %1503
1503: ; preds = %1498, %1503
%1504 = phi i64 [ %1513, %1503 ], [ %1500, %1498 ]
%1505 = phi double [ %1512, %1503 ], [ %1501, %1498 ]
%1506 = phi i64 [ %1514, %1503 ], [ 0, %1498 ]
%1507 = getelementptr inbounds double, double* %26, i64 %1504
%1508 = load double, double* %1507
%1509 = add nsw i64 %1504, %1455
%1510 = getelementptr inbounds double, double* %20, i64 %1509
%1511 = load double, double* %1510
%1512 = tail call double @llvm.fmuladd.f64(double %1508, double %1511, double %1505)
%1513 = add nuw nsw i64 %1504, 1
%1514 = add i64 %1506, 1
%1515 = icmp eq i64 %1514, %1460
br i1 %1515, label %1516, label %1503
1516: ; preds = %1503, %1498
%1517 = phi double [ %1499, %1498 ], [ %1512, %1503 ]
br i1 %1451, label %2156, label %1518
1518: ; preds = %1516
%1519 = getelementptr inbounds double, double* %24, i64 %1299
%1520 = load double, double* %1519
%1521 = fadd double %1517, -1.000000e+00
%1522 = mul nsw i32 %1300, %16
%1523 = fneg double %1521
%1524 = fdiv double %1523, %1520
%1525 = sext i32 %1522 to i64
%1526 = add nuw i32 %1450, 1
%1527 = zext i32 %1526 to i64
%1528 = add nsw i64 %1457, -1
%1529 = icmp ult i64 %1528, 4
br i1 %1529, label %1618, label %1530
1530: ; preds = %1518
%1531 = getelementptr double, double* %335, i64 %1457
%1532 = getelementptr double, double* %337, i64 %1525
%1533 = add nsw i64 %1525, %1457
%1534 = getelementptr double, double* %338, i64 %1533
%1535 = icmp ugt double* %1534, %11
%1536 = icmp ult double* %1532, %1531
%1537 = and i1 %1535, %1536
br i1 %1537, label %1618, label %1538
1538: ; preds = %1530
%1539 = and i64 %1528, -4
%1540 = or i64 %1539, 1
%1541 = insertelement <2 x double> poison, double %1524, i64 0
%1542 = shufflevector <2 x double> %1541, <2 x double> poison, <2 x i32> zeroinitializer
%1543 = insertelement <2 x double> poison, double %1524, i64 0
%1544 = shufflevector <2 x double> %1543, <2 x double> poison, <2 x i32> zeroinitializer
%1545 = add nsw i64 %1539, -4
%1546 = lshr exact i64 %1545, 2
%1547 = add nuw nsw i64 %1546, 1
%1548 = and i64 %1547, 1
%1549 = icmp eq i64 %1545, 0
br i1 %1549, label %1594, label %1550
1550: ; preds = %1538
%1551 = and i64 %1547, 9223372036854775806
br label %1552
1552: ; preds = %1552, %1550
%1553 = phi i64 [ 0, %1550 ], [ %1591, %1552 ]
%1554 = phi i64 [ 0, %1550 ], [ %1592, %1552 ]
%1555 = or i64 %1553, 1
%1556 = add nsw i64 %1555, %1525
%1557 = getelementptr inbounds double, double* %19, i64 %1556
%1558 = bitcast double* %1557 to <2 x double>*
%1559 = load <2 x double>, <2 x double>* %1558
%1560 = getelementptr inbounds double, double* %1557, i64 2
%1561 = bitcast double* %1560 to <2 x double>*
%1562 = load <2 x double>, <2 x double>* %1561
%1563 = getelementptr inbounds double, double* %26, i64 %1555
%1564 = bitcast double* %1563 to <2 x double>*
%1565 = load <2 x double>, <2 x double>* %1564
%1566 = getelementptr inbounds double, double* %1563, i64 2
%1567 = bitcast double* %1566 to <2 x double>*
%1568 = load <2 x double>, <2 x double>* %1567
%1569 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1542, <2 x double> %1559, <2 x double> %1565)
%1570 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1544, <2 x double> %1562, <2 x double> %1568)
%1571 = bitcast double* %1563 to <2 x double>*
store <2 x double> %1569, <2 x double>* %1571
%1572 = bitcast double* %1566 to <2 x double>*
store <2 x double> %1570, <2 x double>* %1572
%1573 = or i64 %1553, 5
%1574 = add nsw i64 %1573, %1525
%1575 = getelementptr inbounds double, double* %19, i64 %1574
%1576 = bitcast double* %1575 to <2 x double>*
%1577 = load <2 x double>, <2 x double>* %1576
%1578 = getelementptr inbounds double, double* %1575, i64 2
%1579 = bitcast double* %1578 to <2 x double>*
%1580 = load <2 x double>, <2 x double>* %1579
%1581 = getelementptr inbounds double, double* %26, i64 %1573
%1582 = bitcast double* %1581 to <2 x double>*
%1583 = load <2 x double>, <2 x double>* %1582
%1584 = getelementptr inbounds double, double* %1581, i64 2
%1585 = bitcast double* %1584 to <2 x double>*
%1586 = load <2 x double>, <2 x double>* %1585
%1587 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1542, <2 x double> %1577, <2 x double> %1583)
%1588 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1544, <2 x double> %1580, <2 x double> %1586)
%1589 = bitcast double* %1581 to <2 x double>*
store <2 x double> %1587, <2 x double>* %1589
%1590 = bitcast double* %1584 to <2 x double>*
store <2 x double> %1588, <2 x double>* %1590
%1591 = add nuw i64 %1553, 8
%1592 = add i64 %1554, 2
%1593 = icmp eq i64 %1592, %1551
br i1 %1593, label %1594, label %1552
1594: ; preds = %1552, %1538
%1595 = phi i64 [ 0, %1538 ], [ %1591, %1552 ]
%1596 = icmp eq i64 %1548, 0
br i1 %1596, label %1616, label %1597
1597: ; preds = %1594
%1598 = or i64 %1595, 1
%1599 = add nsw i64 %1598, %1525
%1600 = getelementptr inbounds double, double* %19, i64 %1599
%1601 = bitcast double* %1600 to <2 x double>*
%1602 = load <2 x double>, <2 x double>* %1601
%1603 = getelementptr inbounds double, double* %1600, i64 2
%1604 = bitcast double* %1603 to <2 x double>*
%1605 = load <2 x double>, <2 x double>* %1604
%1606 = getelementptr inbounds double, double* %26, i64 %1598
%1607 = bitcast double* %1606 to <2 x double>*
%1608 = load <2 x double>, <2 x double>* %1607
%1609 = getelementptr inbounds double, double* %1606, i64 2
%1610 = bitcast double* %1609 to <2 x double>*
%1611 = load <2 x double>, <2 x double>* %1610
%1612 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1542, <2 x double> %1602, <2 x double> %1608)
%1613 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1544, <2 x double> %1605, <2 x double> %1611)
%1614 = bitcast double* %1606 to <2 x double>*
store <2 x double> %1612, <2 x double>* %1614
%1615 = bitcast double* %1609 to <2 x double>*
store <2 x double> %1613, <2 x double>* %1615
br label %1616
1616: ; preds = %1594, %1597
%1617 = icmp eq i64 %1528, %1539
br i1 %1617, label %2160, label %1618
1618: ; preds = %1530, %1518, %1616
%1619 = phi i64 [ 1, %1530 ], [ 1, %1518 ], [ %1540, %1616 ]
%1620 = xor i64 %1619, -1
%1621 = and i64 %1457, 1
%1622 = icmp eq i64 %1621, 0
br i1 %1622, label %1623, label %1631
1623: ; preds = %1618
%1624 = add nsw i64 %1619, %1525
%1625 = getelementptr inbounds double, double* %19, i64 %1624
%1626 = load double, double* %1625
%1627 = getelementptr inbounds double, double* %26, i64 %1619
%1628 = load double, double* %1627
%1629 = tail call double @llvm.fmuladd.f64(double %1524, double %1626, double %1628)
store double %1629, double* %1627
%1630 = add nuw nsw i64 %1619, 1
br label %1631
1631: ; preds = %1623, %1618
%1632 = phi i64 [ %1619, %1618 ], [ %1630, %1623 ]
%1633 = sub nsw i64 0, %1457
%1634 = icmp eq i64 %1620, %1633
br i1 %1634, label %2160, label %1635
1635: ; preds = %1631, %1635
%1636 = phi i64 [ %1650, %1635 ], [ %1632, %1631 ]
%1637 = add nsw i64 %1636, %1525
%1638 = getelementptr inbounds double, double* %19, i64 %1637
%1639 = load double, double* %1638
%1640 = getelementptr inbounds double, double* %26, i64 %1636
%1641 = load double, double* %1640
%1642 = tail call double @llvm.fmuladd.f64(double %1524, double %1639, double %1641)
store double %1642, double* %1640
%1643 = add nuw nsw i64 %1636, 1
%1644 = add nsw i64 %1643, %1525
%1645 = getelementptr inbounds double, double* %19, i64 %1644
%1646 = load double, double* %1645
%1647 = getelementptr inbounds double, double* %11, i64 %1636
%1648 = load double, double* %1647
%1649 = tail call double @llvm.fmuladd.f64(double %1524, double %1646, double %1648)
store double %1649, double* %1647
%1650 = add nuw nsw i64 %1636, 2
%1651 = icmp eq i64 %1650, %1527
br i1 %1651, label %2160, label %1635
1652: ; preds = %443
%1653 = icmp slt i32 %386, %385
br i1 %1653, label %1654, label %1815
1654: ; preds = %1652
%1655 = sext i32 %386 to i64
%1656 = getelementptr inbounds i32, i32* %23, i64 %1655
%1657 = load i32, i32* %1656
%1658 = getelementptr inbounds double, double* %25, i64 %1655
%1659 = load double, double* %1658
%1660 = sext i32 %385 to i64
%1661 = add nsw i64 %1655, 1
%1662 = mul i64 %1661, %308
%1663 = add i64 %362, %1662
%1664 = add i64 %1662, %18
%1665 = mul nsw i64 %308, %1655
%1666 = add i64 %363, %1665
%1667 = add i64 %1665, %18
br label %1668
1668: ; preds = %1804, %1654
%1669 = phi i64 [ %1810, %1804 ], [ 0, %1654 ]
%1670 = phi i64 [ %1680, %1804 ], [ %1655, %1654 ]
%1671 = mul i64 %1669, %308
%1672 = add i64 %1663, %1671
%1673 = getelementptr double, double* %8, i64 %1672
%1674 = add i64 %1664, %1671
%1675 = getelementptr double, double* %8, i64 %1674
%1676 = add i64 %1666, %1671
%1677 = getelementptr double, double* %8, i64 %1676
%1678 = add i64 %1667, %1671
%1679 = getelementptr double, double* %8, i64 %1678
%1680 = add nsw i64 %1670, 1
%1681 = getelementptr inbounds i32, i32* %7, i64 %1670
%1682 = load i32, i32* %1681
%1683 = load i32, i32* %0
%1684 = icmp slt i32 %1683, 1
br i1 %1684, label %1729, label %1685
1685: ; preds = %1668
%1686 = mul nsw i64 %1670, %308
%1687 = mul nsw i32 %1682, %16
%1688 = sext i32 %1687 to i64
%1689 = zext i32 %1683 to i64
%1690 = and i64 %1689, 1
%1691 = icmp eq i32 %1683, 1
br i1 %1691, label %1716, label %1692
1692: ; preds = %1685
%1693 = and i64 %1689, 4294967294
br label %1694
1694: ; preds = %1694, %1692
%1695 = phi i64 [ 1, %1692 ], [ %1713, %1694 ]
%1696 = phi double [ 0.000000e+00, %1692 ], [ %1712, %1694 ]
%1697 = phi i64 [ 0, %1692 ], [ %1714, %1694 ]
%1698 = add nsw i64 %1695, %1686
%1699 = getelementptr inbounds double, double* %19, i64 %1698
%1700 = load double, double* %1699
%1701 = add nsw i64 %1695, %1688
%1702 = getelementptr inbounds double, double* %20, i64 %1701
%1703 = load double, double* %1702
%1704 = tail call double @llvm.fmuladd.f64(double %1700, double %1703, double %1696)
%1705 = add nuw nsw i64 %1695, 1
%1706 = add nsw i64 %1705, %1686
%1707 = getelementptr inbounds double, double* %19, i64 %1706
%1708 = load double, double* %1707
%1709 = add nsw i64 %1705, %1688
%1710 = getelementptr inbounds double, double* %20, i64 %1709
%1711 = load double, double* %1710
%1712 = tail call double @llvm.fmuladd.f64(double %1708, double %1711, double %1704)
%1713 = add nuw nsw i64 %1695, 2
%1714 = add i64 %1697, 2
%1715 = icmp eq i64 %1714, %1693
br i1 %1715, label %1716, label %1694
1716: ; preds = %1694, %1685
%1717 = phi double [ undef, %1685 ], [ %1712, %1694 ]
%1718 = phi i64 [ 1, %1685 ], [ %1713, %1694 ]
%1719 = phi double [ 0.000000e+00, %1685 ], [ %1712, %1694 ]
%1720 = icmp eq i64 %1690, 0
br i1 %1720, label %1729, label %1721
1721: ; preds = %1716
%1722 = add nsw i64 %1718, %1686
%1723 = getelementptr inbounds double, double* %19, i64 %1722
%1724 = load double, double* %1723
%1725 = add nsw i64 %1718, %1688
%1726 = getelementptr inbounds double, double* %20, i64 %1725
%1727 = load double, double* %1726
%1728 = tail call double @llvm.fmuladd.f64(double %1724, double %1727, double %1719)
br label %1729
1729: ; preds = %1721, %1716, %1668
%1730 = phi double [ 0.000000e+00, %1668 ], [ %1717, %1716 ], [ %1728, %1721 ]
%1731 = getelementptr inbounds double, double* %9, i64 %1670
%1732 = load double, double* %1731
%1733 = fmul double %1732, %1732
%1734 = tail call double @llvm.fmuladd.f64(double %1730, double %1730, double %1733)
%1735 = tail call double @sqrt(double %1734)
%1736 = load double, double* %1731
%1737 = fdiv double %1736, %1735
%1738 = fdiv double %1730, %1735
%1739 = getelementptr inbounds double, double* %24, i64 %1670
%1740 = load double, double* %1739
%1741 = fmul double %1737, %1740
store double %1741, double* %1731
store double %1735, double* %1739
%1742 = load i32, i32* %0
%1743 = icmp slt i32 %1742, 1
br i1 %1743, label %1804, label %1744
1744: ; preds = %1729
%1745 = mul nsw i64 %1680, %308
%1746 = mul nsw i64 %1670, %308
%1747 = fneg double %1738
%1748 = add nuw i32 %1742, 1
%1749 = zext i32 %1748 to i64
%1750 = add nsw i64 %1749, -1
%1751 = icmp ult i64 %1750, 2
br i1 %1751, label %1788, label %1752
1752: ; preds = %1744
%1753 = getelementptr double, double* %1675, i64 %1749
%1754 = getelementptr double, double* %1679, i64 %1749
%1755 = icmp ult double* %1673, %1754
%1756 = icmp ult double* %1677, %1753
%1757 = and i1 %1755, %1756
br i1 %1757, label %1788, label %1758
1758: ; preds = %1752
%1759 = and i64 %1750, -2
%1760 = or i64 %1750, 1
%1761 = insertelement <2 x double> poison, double %1738, i64 0
%1762 = shufflevector <2 x double> %1761, <2 x double> poison, <2 x i32> zeroinitializer
%1763 = insertelement <2 x double> poison, double %1737, i64 0
%1764 = shufflevector <2 x double> %1763, <2 x double> poison, <2 x i32> zeroinitializer
%1765 = insertelement <2 x double> poison, double %1747, i64 0
%1766 = shufflevector <2 x double> %1765, <2 x double> poison, <2 x i32> zeroinitializer
br label %1767
1767: ; preds = %1767, %1758
%1768 = phi i64 [ 0, %1758 ], [ %1784, %1767 ]
%1769 = or i64 %1768, 1
%1770 = add nsw i64 %1769, %1745
%1771 = getelementptr inbounds double, double* %19, i64 %1770
%1772 = bitcast double* %1771 to <2 x double>*
%1773 = load <2 x double>, <2 x double>* %1772
%1774 = add nsw i64 %1769, %1746
%1775 = getelementptr inbounds double, double* %19, i64 %1774
%1776 = bitcast double* %1775 to <2 x double>*
%1777 = load <2 x double>, <2 x double>* %1776
%1778 = fmul <2 x double> %1762, %1777
%1779 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1764, <2 x double> %1773, <2 x double> %1778)
%1780 = fmul <2 x double> %1773, %1766
%1781 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1764, <2 x double> %1777, <2 x double> %1780)
%1782 = bitcast double* %1771 to <2 x double>*
store <2 x double> %1781, <2 x double>* %1782
%1783 = bitcast double* %1775 to <2 x double>*
store <2 x double> %1779, <2 x double>* %1783
%1784 = add nuw i64 %1768, 2
%1785 = icmp eq i64 %1784, %1759
br i1 %1785, label %1786, label %1767
1786: ; preds = %1767
%1787 = icmp eq i64 %1750, %1759
br i1 %1787, label %1804, label %1788
1788: ; preds = %1752, %1744, %1786
%1789 = phi i64 [ 1, %1752 ], [ 1, %1744 ], [ %1760, %1786 ]
br label %1790
1790: ; preds = %1788, %1790
%1791 = phi i64 [ %1802, %1790 ], [ %1789, %1788 ]
%1792 = add nsw i64 %1791, %1745
%1793 = getelementptr inbounds double, double* %19, i64 %1792
%1794 = load double, double* %1793
%1795 = add nsw i64 %1791, %1746
%1796 = getelementptr inbounds double, double* %19, i64 %1795
%1797 = load double, double* %1796
%1798 = fmul double %1738, %1797
%1799 = tail call double @llvm.fmuladd.f64(double %1737, double %1794, double %1798)
%1800 = fmul double %1794, %1747
%1801 = tail call double @llvm.fmuladd.f64(double %1737, double %1797, double %1800)
store double %1801, double* %1793
store double %1799, double* %1796
%1802 = add nuw nsw i64 %1791, 1
%1803 = icmp eq i64 %1802, %1749
br i1 %1803, label %1804, label %1790
1804: ; preds = %1790, %1786, %1729
%1805 = getelementptr inbounds i32, i32* %23, i64 %1670
store i32 %1682, i32* %1805
%1806 = getelementptr inbounds double, double* %10, i64 %1670
%1807 = load double, double* %1806
%1808 = getelementptr inbounds double, double* %25, i64 %1670
store double %1807, double* %1808
%1809 = icmp eq i64 %1680, %1660
%1810 = add i64 %1669, 1
br i1 %1809, label %1811, label %1668
1811: ; preds = %1804
%1812 = getelementptr inbounds i32, i32* %23, i64 %1660
%1813 = getelementptr inbounds double, double* %25, i64 %1660
store i32 %1657, i32* %1812
store double %1659, double* %1813
%1814 = load i32, i32* %1
br label %1815
1815: ; preds = %1811, %1652
%1816 = phi i32 [ %1814, %1811 ], [ %380, %1652 ]
%1817 = add nsw i32 %385, -1
%1818 = icmp sgt i32 %303, %1816
br i1 %1818, label %2017, label %1819
1819: ; preds = %1815
%1820 = load i32, i32* %0
%1821 = icmp slt i32 %1820, 1
br i1 %1821, label %2156, label %1822
1822: ; preds = %1819
%1823 = mul nsw i32 %385, %16
%1824 = sext i32 %1823 to i64
%1825 = add nuw i32 %1820, 1
%1826 = zext i32 %1825 to i64
%1827 = add nsw i64 %1826, -1
%1828 = add nsw i64 %1826, -2
%1829 = and i64 %1827, 3
%1830 = icmp ult i64 %1828, 3
br i1 %1830, label %1833, label %1831
1831: ; preds = %1822
%1832 = and i64 %1827, -4
br label %1966
1833: ; preds = %1966, %1822
%1834 = phi double [ undef, %1822 ], [ %1996, %1966 ]
%1835 = phi i64 [ 1, %1822 ], [ %1997, %1966 ]
%1836 = phi double [ 0.000000e+00, %1822 ], [ %1996, %1966 ]
%1837 = icmp eq i64 %1829, 0
br i1 %1837, label %1851, label %1838
1838: ; preds = %1833, %1838
%1839 = phi i64 [ %1848, %1838 ], [ %1835, %1833 ]
%1840 = phi double [ %1847, %1838 ], [ %1836, %1833 ]
%1841 = phi i64 [ %1849, %1838 ], [ 0, %1833 ]
%1842 = getelementptr inbounds double, double* %26, i64 %1839
%1843 = load double, double* %1842
%1844 = add nsw i64 %1839, %1824
%1845 = getelementptr inbounds double, double* %19, i64 %1844
%1846 = load double, double* %1845
%1847 = tail call double @llvm.fmuladd.f64(double %1843, double %1846, double %1840)
%1848 = add nuw nsw i64 %1839, 1
%1849 = add i64 %1841, 1
%1850 = icmp eq i64 %1849, %1829
br i1 %1850, label %1851, label %1838
1851: ; preds = %1838, %1833
%1852 = phi double [ %1834, %1833 ], [ %1847, %1838 ]
br i1 %1821, label %2156, label %1853
1853: ; preds = %1851
%1854 = mul nsw i32 %385, %16
%1855 = fneg double %1852
%1856 = sext i32 %1854 to i64
%1857 = add nuw i32 %1820, 1
%1858 = zext i32 %1857 to i64
%1859 = add nsw i64 %1826, -1
%1860 = icmp ult i64 %1859, 4
br i1 %1860, label %1949, label %1861
1861: ; preds = %1853
%1862 = getelementptr double, double* %358, i64 %1826
%1863 = getelementptr double, double* %360, i64 %1856
%1864 = add nsw i64 %1856, %1826
%1865 = getelementptr double, double* %361, i64 %1864
%1866 = icmp ugt double* %1865, %11
%1867 = icmp ult double* %1863, %1862
%1868 = and i1 %1866, %1867
br i1 %1868, label %1949, label %1869
1869: ; preds = %1861
%1870 = and i64 %1859, -4
%1871 = or i64 %1870, 1
%1872 = insertelement <2 x double> poison, double %1855, i64 0
%1873 = shufflevector <2 x double> %1872, <2 x double> poison, <2 x i32> zeroinitializer
%1874 = insertelement <2 x double> poison, double %1855, i64 0
%1875 = shufflevector <2 x double> %1874, <2 x double> poison, <2 x i32> zeroinitializer
%1876 = add nsw i64 %1870, -4
%1877 = lshr exact i64 %1876, 2
%1878 = add nuw nsw i64 %1877, 1
%1879 = and i64 %1878, 1
%1880 = icmp eq i64 %1876, 0
br i1 %1880, label %1925, label %1881
1881: ; preds = %1869
%1882 = and i64 %1878, 9223372036854775806
br label %1883
1883: ; preds = %1883, %1881
%1884 = phi i64 [ 0, %1881 ], [ %1922, %1883 ]
%1885 = phi i64 [ 0, %1881 ], [ %1923, %1883 ]
%1886 = or i64 %1884, 1
%1887 = add nsw i64 %1886, %1856
%1888 = getelementptr inbounds double, double* %19, i64 %1887
%1889 = bitcast double* %1888 to <2 x double>*
%1890 = load <2 x double>, <2 x double>* %1889
%1891 = getelementptr inbounds double, double* %1888, i64 2
%1892 = bitcast double* %1891 to <2 x double>*
%1893 = load <2 x double>, <2 x double>* %1892
%1894 = getelementptr inbounds double, double* %26, i64 %1886
%1895 = bitcast double* %1894 to <2 x double>*
%1896 = load <2 x double>, <2 x double>* %1895
%1897 = getelementptr inbounds double, double* %1894, i64 2
%1898 = bitcast double* %1897 to <2 x double>*
%1899 = load <2 x double>, <2 x double>* %1898
%1900 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1873, <2 x double> %1890, <2 x double> %1896)
%1901 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1875, <2 x double> %1893, <2 x double> %1899)
%1902 = bitcast double* %1894 to <2 x double>*
store <2 x double> %1900, <2 x double>* %1902
%1903 = bitcast double* %1897 to <2 x double>*
store <2 x double> %1901, <2 x double>* %1903
%1904 = or i64 %1884, 5
%1905 = add nsw i64 %1904, %1856
%1906 = getelementptr inbounds double, double* %19, i64 %1905
%1907 = bitcast double* %1906 to <2 x double>*
%1908 = load <2 x double>, <2 x double>* %1907
%1909 = getelementptr inbounds double, double* %1906, i64 2
%1910 = bitcast double* %1909 to <2 x double>*
%1911 = load <2 x double>, <2 x double>* %1910
%1912 = getelementptr inbounds double, double* %26, i64 %1904
%1913 = bitcast double* %1912 to <2 x double>*
%1914 = load <2 x double>, <2 x double>* %1913
%1915 = getelementptr inbounds double, double* %1912, i64 2
%1916 = bitcast double* %1915 to <2 x double>*
%1917 = load <2 x double>, <2 x double>* %1916
%1918 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1873, <2 x double> %1908, <2 x double> %1914)
%1919 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1875, <2 x double> %1911, <2 x double> %1917)
%1920 = bitcast double* %1912 to <2 x double>*
store <2 x double> %1918, <2 x double>* %1920
%1921 = bitcast double* %1915 to <2 x double>*
store <2 x double> %1919, <2 x double>* %1921
%1922 = add nuw i64 %1884, 8
%1923 = add i64 %1885, 2
%1924 = icmp eq i64 %1923, %1882
br i1 %1924, label %1925, label %1883
1925: ; preds = %1883, %1869
%1926 = phi i64 [ 0, %1869 ], [ %1922, %1883 ]
%1927 = icmp eq i64 %1879, 0
br i1 %1927, label %1947, label %1928
1928: ; preds = %1925
%1929 = or i64 %1926, 1
%1930 = add nsw i64 %1929, %1856
%1931 = getelementptr inbounds double, double* %19, i64 %1930
%1932 = bitcast double* %1931 to <2 x double>*
%1933 = load <2 x double>, <2 x double>* %1932
%1934 = getelementptr inbounds double, double* %1931, i64 2
%1935 = bitcast double* %1934 to <2 x double>*
%1936 = load <2 x double>, <2 x double>* %1935
%1937 = getelementptr inbounds double, double* %26, i64 %1929
%1938 = bitcast double* %1937 to <2 x double>*
%1939 = load <2 x double>, <2 x double>* %1938
%1940 = getelementptr inbounds double, double* %1937, i64 2
%1941 = bitcast double* %1940 to <2 x double>*
%1942 = load <2 x double>, <2 x double>* %1941
%1943 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1873, <2 x double> %1933, <2 x double> %1939)
%1944 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1875, <2 x double> %1936, <2 x double> %1942)
%1945 = bitcast double* %1937 to <2 x double>*
store <2 x double> %1943, <2 x double>* %1945
%1946 = bitcast double* %1940 to <2 x double>*
store <2 x double> %1944, <2 x double>* %1946
br label %1947
1947: ; preds = %1925, %1928
%1948 = icmp eq i64 %1859, %1870
br i1 %1948, label %2160, label %1949
1949: ; preds = %1861, %1853, %1947
%1950 = phi i64 [ 1, %1861 ], [ 1, %1853 ], [ %1871, %1947 ]
%1951 = xor i64 %1950, -1
%1952 = and i64 %1826, 1
%1953 = icmp eq i64 %1952, 0
br i1 %1953, label %1954, label %1962
1954: ; preds = %1949
%1955 = add nsw i64 %1950, %1856
%1956 = getelementptr inbounds double, double* %19, i64 %1955
%1957 = load double, double* %1956
%1958 = getelementptr inbounds double, double* %26, i64 %1950
%1959 = load double, double* %1958
%1960 = tail call double @llvm.fmuladd.f64(double %1855, double %1957, double %1959)
store double %1960, double* %1958
%1961 = add nuw nsw i64 %1950, 1
br label %1962
1962: ; preds = %1954, %1949
%1963 = phi i64 [ %1950, %1949 ], [ %1961, %1954 ]
%1964 = sub nsw i64 0, %1826
%1965 = icmp eq i64 %1951, %1964
br i1 %1965, label %2160, label %2000
1966: ; preds = %1966, %1831
%1967 = phi i64 [ 1, %1831 ], [ %1997, %1966 ]
%1968 = phi double [ 0.000000e+00, %1831 ], [ %1996, %1966 ]
%1969 = phi i64 [ 0, %1831 ], [ %1998, %1966 ]
%1970 = getelementptr inbounds double, double* %26, i64 %1967
%1971 = load double, double* %1970
%1972 = add nsw i64 %1967, %1824
%1973 = getelementptr inbounds double, double* %19, i64 %1972
%1974 = load double, double* %1973
%1975 = tail call double @llvm.fmuladd.f64(double %1971, double %1974, double %1968)
%1976 = add nuw nsw i64 %1967, 1
%1977 = getelementptr inbounds double, double* %11, i64 %1967
%1978 = load double, double* %1977
%1979 = add nsw i64 %1976, %1824
%1980 = getelementptr inbounds double, double* %19, i64 %1979
%1981 = load double, double* %1980
%1982 = tail call double @llvm.fmuladd.f64(double %1978, double %1981, double %1975)
%1983 = add nuw nsw i64 %1967, 2
%1984 = getelementptr inbounds double, double* %26, i64 %1983
%1985 = load double, double* %1984
%1986 = add nsw i64 %1983, %1824
%1987 = getelementptr inbounds double, double* %19, i64 %1986
%1988 = load double, double* %1987
%1989 = tail call double @llvm.fmuladd.f64(double %1985, double %1988, double %1982)
%1990 = add nuw nsw i64 %1967, 3
%1991 = getelementptr inbounds double, double* %26, i64 %1990
%1992 = load double, double* %1991
%1993 = add nsw i64 %1990, %1824
%1994 = getelementptr inbounds double, double* %19, i64 %1993
%1995 = load double, double* %1994
%1996 = tail call double @llvm.fmuladd.f64(double %1992, double %1995, double %1989)
%1997 = add nuw nsw i64 %1967, 4
%1998 = add nuw i64 %1969, 4
%1999 = icmp eq i64 %1998, %1832
br i1 %1999, label %1833, label %1966
2000: ; preds = %1962, %2000
%2001 = phi i64 [ %2015, %2000 ], [ %1963, %1962 ]
%2002 = add nsw i64 %2001, %1856
%2003 = getelementptr inbounds double, double* %19, i64 %2002
%2004 = load double, double* %2003
%2005 = getelementptr inbounds double, double* %26, i64 %2001
%2006 = load double, double* %2005
%2007 = tail call double @llvm.fmuladd.f64(double %1855, double %2004, double %2006)
store double %2007, double* %2005
%2008 = add nuw nsw i64 %2001, 1
%2009 = add nsw i64 %2008, %1856
%2010 = getelementptr inbounds double, double* %19, i64 %2009
%2011 = load double, double* %2010
%2012 = getelementptr inbounds double, double* %11, i64 %2001
%2013 = load double, double* %2012
%2014 = tail call double @llvm.fmuladd.f64(double %1855, double %2011, double %2013)
store double %2014, double* %2012
%2015 = add nuw nsw i64 %2001, 2
%2016 = icmp eq i64 %2015, %1858
br i1 %2016, label %2160, label %2000
2017: ; preds = %1815, %1446
%2018 = phi i32 [ %1300, %1446 ], [ %1817, %1815 ]
%2019 = sext i32 %2018 to i64
%2020 = getelementptr inbounds double, double* %24, i64 %2019
%2021 = load double, double* %2020
%2022 = fdiv double 1.000000e+00, %2021
%2023 = load i32, i32* %0
%2024 = icmp slt i32 %2023, 1
br i1 %2024, label %2156, label %2025
2025: ; preds = %2017
%2026 = mul nsw i32 %2018, %16
%2027 = sext i32 %2026 to i64
%2028 = add nuw i32 %2023, 1
%2029 = zext i32 %2028 to i64
%2030 = add nsw i64 %2029, -1
%2031 = icmp ult i64 %2030, 4
br i1 %2031, label %2108, label %2032
2032: ; preds = %2025
%2033 = getelementptr double, double* %331, i64 %2029
%2034 = getelementptr double, double* %333, i64 %2027
%2035 = add nsw i64 %2027, %2029
%2036 = getelementptr double, double* %334, i64 %2035
%2037 = icmp ugt double* %2036, %11
%2038 = icmp ult double* %2034, %2033
%2039 = and i1 %2037, %2038
br i1 %2039, label %2108, label %2040
2040: ; preds = %2032
%2041 = and i64 %2030, -4
%2042 = or i64 %2041, 1
%2043 = insertelement <2 x double> poison, double %2022, i64 0
%2044 = shufflevector <2 x double> %2043, <2 x double> poison, <2 x i32> zeroinitializer
%2045 = insertelement <2 x double> poison, double %2022, i64 0
%2046 = shufflevector <2 x double> %2045, <2 x double> poison, <2 x i32> zeroinitializer
%2047 = add nsw i64 %2041, -4
%2048 = lshr exact i64 %2047, 2
%2049 = add nuw nsw i64 %2048, 1
%2050 = and i64 %2049, 1
%2051 = icmp eq i64 %2047, 0
br i1 %2051, label %2088, label %2052
2052: ; preds = %2040
%2053 = and i64 %2049, 9223372036854775806
br label %2054
2054: ; preds = %2054, %2052
%2055 = phi i64 [ 0, %2052 ], [ %2085, %2054 ]
%2056 = phi i64 [ 0, %2052 ], [ %2086, %2054 ]
%2057 = or i64 %2055, 1
%2058 = add nsw i64 %2057, %2027
%2059 = getelementptr inbounds double, double* %19, i64 %2058
%2060 = bitcast double* %2059 to <2 x double>*
%2061 = load <2 x double>, <2 x double>* %2060
%2062 = getelementptr inbounds double, double* %2059, i64 2
%2063 = bitcast double* %2062 to <2 x double>*
%2064 = load <2 x double>, <2 x double>* %2063
%2065 = fmul <2 x double> %2044, %2061
%2066 = fmul <2 x double> %2046, %2064
%2067 = getelementptr inbounds double, double* %26, i64 %2057
%2068 = bitcast double* %2067 to <2 x double>*
store <2 x double> %2065, <2 x double>* %2068
%2069 = getelementptr inbounds double, double* %2067, i64 2
%2070 = bitcast double* %2069 to <2 x double>*
store <2 x double> %2066, <2 x double>* %2070
%2071 = or i64 %2055, 5
%2072 = add nsw i64 %2071, %2027
%2073 = getelementptr inbounds double, double* %19, i64 %2072
%2074 = bitcast double* %2073 to <2 x double>*
%2075 = load <2 x double>, <2 x double>* %2074
%2076 = getelementptr inbounds double, double* %2073, i64 2
%2077 = bitcast double* %2076 to <2 x double>*
%2078 = load <2 x double>, <2 x double>* %2077
%2079 = fmul <2 x double> %2044, %2075
%2080 = fmul <2 x double> %2046, %2078
%2081 = getelementptr inbounds double, double* %26, i64 %2071
%2082 = bitcast double* %2081 to <2 x double>*
store <2 x double> %2079, <2 x double>* %2082
%2083 = getelementptr inbounds double, double* %2081, i64 2
%2084 = bitcast double* %2083 to <2 x double>*
store <2 x double> %2080, <2 x double>* %2084
%2085 = add nuw i64 %2055, 8
%2086 = add i64 %2056, 2
%2087 = icmp eq i64 %2086, %2053
br i1 %2087, label %2088, label %2054
2088: ; preds = %2054, %2040
%2089 = phi i64 [ 0, %2040 ], [ %2085, %2054 ]
%2090 = icmp eq i64 %2050, 0
br i1 %2090, label %2106, label %2091
2091: ; preds = %2088
%2092 = or i64 %2089, 1
%2093 = add nsw i64 %2092, %2027
%2094 = getelementptr inbounds double, double* %19, i64 %2093
%2095 = bitcast double* %2094 to <2 x double>*
%2096 = load <2 x double>, <2 x double>* %2095
%2097 = getelementptr inbounds double, double* %2094, i64 2
%2098 = bitcast double* %2097 to <2 x double>*
%2099 = load <2 x double>, <2 x double>* %2098
%2100 = fmul <2 x double> %2044, %2096
%2101 = fmul <2 x double> %2046, %2099
%2102 = getelementptr inbounds double, double* %26, i64 %2092
%2103 = bitcast double* %2102 to <2 x double>*
store <2 x double> %2100, <2 x double>* %2103
%2104 = getelementptr inbounds double, double* %2102, i64 2
%2105 = bitcast double* %2104 to <2 x double>*
store <2 x double> %2101, <2 x double>* %2105
br label %2106
2106: ; preds = %2088, %2091
%2107 = icmp eq i64 %2030, %2041
br i1 %2107, label %2160, label %2108
2108: ; preds = %2032, %2025, %2106
%2109 = phi i64 [ 1, %2032 ], [ 1, %2025 ], [ %2042, %2106 ]
%2110 = sub nsw i64 %2029, %2109
%2111 = xor i64 %2109, -1
%2112 = add nsw i64 %2111, %2029
%2113 = and i64 %2110, 3
%2114 = icmp eq i64 %2113, 0
br i1 %2114, label %2126, label %2115
2115: ; preds = %2108, %2115
%2116 = phi i64 [ %2123, %2115 ], [ %2109, %2108 ]
%2117 = phi i64 [ %2124, %2115 ], [ 0, %2108 ]
%2118 = add nsw i64 %2116, %2027
%2119 = getelementptr inbounds double, double* %19, i64 %2118
%2120 = load double, double* %2119
%2121 = fmul double %2022, %2120
%2122 = getelementptr inbounds double, double* %26, i64 %2116
store double %2121, double* %2122
%2123 = add nuw nsw i64 %2116, 1
%2124 = add i64 %2117, 1
%2125 = icmp eq i64 %2124, %2113
br i1 %2125, label %2126, label %2115
2126: ; preds = %2115, %2108
%2127 = phi i64 [ %2109, %2108 ], [ %2123, %2115 ]
%2128 = icmp ult i64 %2112, 3
br i1 %2128, label %2160, label %2129
2129: ; preds = %2126, %2129
%2130 = phi i64 [ %2154, %2129 ], [ %2127, %2126 ]
%2131 = add nsw i64 %2130, %2027
%2132 = getelementptr inbounds double, double* %19, i64 %2131
%2133 = load double, double* %2132
%2134 = fmul double %2022, %2133
%2135 = getelementptr inbounds double, double* %26, i64 %2130
store double %2134, double* %2135
%2136 = add nuw nsw i64 %2130, 1
%2137 = add nsw i64 %2136, %2027
%2138 = getelementptr inbounds double, double* %19, i64 %2137
%2139 = load double, double* %2138
%2140 = fmul double %2022, %2139
%2141 = getelementptr inbounds double, double* %11, i64 %2130
store double %2140, double* %2141
%2142 = add nuw nsw i64 %2130, 2
%2143 = add nsw i64 %2142, %2027
%2144 = getelementptr inbounds double, double* %19, i64 %2143
%2145 = load double, double* %2144
%2146 = fmul double %2022, %2145
%2147 = getelementptr inbounds double, double* %26, i64 %2142
store double %2146, double* %2147
%2148 = add nuw nsw i64 %2130, 3
%2149 = add nsw i64 %2148, %2027
%2150 = getelementptr inbounds double, double* %19, i64 %2149
%2151 = load double, double* %2150
%2152 = fmul double %2022, %2151
%2153 = getelementptr inbounds double, double* %26, i64 %2148
store double %2152, double* %2153
%2154 = add nuw nsw i64 %2130, 4
%2155 = icmp eq i64 %2154, %2029
br i1 %2155, label %2160, label %2129
2156: ; preds = %2017, %1516, %1851, %1449, %1819
%2157 = phi i32 [ %1817, %1851 ], [ %1300, %1516 ], [ %2018, %2017 ], [ %1300, %1449 ], [ %1817, %1819 ]
%2158 = load double, double* %4
%2159 = fmul double %2158, %2158
br label %2193
2160: ; preds = %1962, %2000, %1631, %1635, %2126, %2129, %1947, %1616, %2106
%2161 = phi i32 [ %2023, %2106 ], [ %1450, %1616 ], [ %1820, %1947 ], [ %2023, %2129 ], [ %2023, %2126 ], [ %1450, %1635 ], [ %1450, %1631 ], [ %1820, %2000 ], [ %1820, %1962 ]
%2162 = phi i32 [ %2018, %2106 ], [ %1300, %1616 ], [ %1817, %1947 ], [ %2018, %2129 ], [ %2018, %2126 ], [ %1300, %1635 ], [ %1300, %1631 ], [ %1817, %2000 ], [ %1817, %1962 ]
%2163 = load double, double* %4
%2164 = fmul double %2163, %2163
%2165 = icmp slt i32 %2161, 1
br i1 %2165, label %2193, label %2166
2166: ; preds = %2160
%2167 = fmul double %2163, 0x3EB0C6F7A0000000
%2168 = add nuw i32 %2161, 1
%2169 = zext i32 %2168 to i64
br label %2170
2170: ; preds = %2166, %2170
%2171 = phi i64 [ 1, %2166 ], [ %2189, %2170 ]
%2172 = phi double [ %2164, %2166 ], [ %2181, %2170 ]
%2173 = phi <2 x double> [ zeroinitializer, %2166 ], [ %2188, %2170 ]
%2174 = getelementptr inbounds double, double* %22, i64 %2171
%2175 = load double, double* %2174
%2176 = fcmp oge double %2175, 0.000000e+00
%2177 = fneg double %2175
%2178 = select i1 %2176, double %2175, double %2177
%2179 = fcmp ult double %2178, %2167
%2180 = tail call double @llvm.fmuladd.f64(double %2177, double %2175, double %2172)
%2181 = select i1 %2179, double %2172, double %2180
%2182 = getelementptr inbounds double, double* %26, i64 %2171
%2183 = load double, double* %2182
%2184 = insertelement <2 x double> poison, double %2175, i64 0
%2185 = insertelement <2 x double> %2184, double %2183, i64 1
%2186 = insertelement <2 x double> poison, double %2183, i64 0
%2187 = shufflevector <2 x double> %2186, <2 x double> poison, <2 x i32> zeroinitializer
%2188 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2185, <2 x double> %2187, <2 x double> %2173)
%2189 = add nuw nsw i64 %2171, 1
%2190 = icmp eq i64 %2189, %2169
br i1 %2190, label %2191, label %2170
2191: ; preds = %2170
%2192 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2185, <2 x double> %2187, <2 x double> %2173)
br label %2193
2193: ; preds = %2191, %2156, %2160
%2194 = phi i32 [ %2162, %2160 ], [ %2157, %2156 ], [ %2162, %2191 ]
%2195 = phi double [ %2164, %2160 ], [ %2159, %2156 ], [ %2181, %2191 ]
%2196 = phi <2 x double> [ zeroinitializer, %2160 ], [ zeroinitializer, %2156 ], [ %2192, %2191 ]
%2197 = fcmp ugt double %2195, 0.000000e+00
br i1 %2197, label %2198, label %3095
2198: ; preds = %2193
%2199 = extractelement <2 x double> %2196, i64 1
%2200 = fmul double %2195, %2199
%2201 = tail call double @sqrt(double %2200)
%2202 = extractelement <2 x double> %2196, i64 0
%2203 = fcmp oge double %2202, 0.000000e+00
%2204 = fneg double %2202
%2205 = select i1 %2203, double %2202, double %2204
%2206 = fmul double %2201, 0x3EB0C6F7A0000000
%2207 = fcmp ult double %2205, %2206
br i1 %2207, label %2213, label %2208
2208: ; preds = %2198
%2209 = fmul <2 x double> %2196, %2196
%2210 = extractelement <2 x double> %2209, i64 0
%2211 = tail call double @llvm.fmuladd.f64(double %2199, double %2195, double %2210)
%2212 = tail call double @sqrt(double %2211)
br label %2213
2213: ; preds = %2208, %2198
%2214 = phi double [ %2212, %2208 ], [ %2201, %2198 ]
%2215 = fadd double %2202, %2214
%2216 = fdiv double %2195, %2215
%2217 = load i32, i32* %1
%2218 = icmp eq i32 %303, %2217
br i1 %2218, label %2219, label %2233
2219: ; preds = %2213
%2220 = insertelement <2 x double> poison, double %382, i64 0
%2221 = shufflevector <2 x double> %2220, <2 x double> poison, <2 x i32> zeroinitializer
%2222 = insertelement <2 x double> poison, double %2216, i64 0
%2223 = shufflevector <2 x double> %2222, <2 x double> poison, <2 x i32> zeroinitializer
%2224 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2221, <2 x double> <double 1.000000e-01, double 2.000000e-01>, <2 x double> %2223)
%2225 = extractelement <2 x double> %2224, i64 0
%2226 = fcmp ult double %2216, %2225
%2227 = extractelement <2 x double> %2224, i64 1
%2228 = fcmp ult double %2225, %2227
%2229 = select i1 %2226, i1 %2228, i1 false
br i1 %2229, label %2230, label %3085
2230: ; preds = %2219
%2231 = fcmp ole double %2216, %382
%2232 = select i1 %2231, double %2216, double %382
br label %2233
2233: ; preds = %2230, %2213
%2234 = phi double [ %2232, %2230 ], [ %2216, %2213 ]
%2235 = load i32, i32* %0
%2236 = icmp slt i32 %2235, 1
br i1 %2236, label %2369, label %2237
2237: ; preds = %2233
%2238 = add nuw i32 %2235, 1
%2239 = zext i32 %2238 to i64
%2240 = add nsw i64 %2239, -1
%2241 = icmp ult i64 %2240, 4
br i1 %2241, label %2336, label %2242
2242: ; preds = %2237
%2243 = getelementptr double, double* %328, i64 %2239
%2244 = getelementptr double, double* %329, i64 %2239
%2245 = getelementptr double, double* %330, i64 %2239
%2246 = icmp ugt double* %2244, %12
%2247 = icmp ugt double* %2243, %5
%2248 = and i1 %2246, %2247
%2249 = icmp ugt double* %2245, %12
%2250 = icmp ugt double* %2243, %11
%2251 = and i1 %2249, %2250
%2252 = or i1 %2248, %2251
br i1 %2252, label %2336, label %2253
2253: ; preds = %2242
%2254 = and i64 %2240, -4
%2255 = or i64 %2254, 1
%2256 = insertelement <2 x double> poison, double %2234, i64 0
%2257 = shufflevector <2 x double> %2256, <2 x double> poison, <2 x i32> zeroinitializer
%2258 = insertelement <2 x double> poison, double %2234, i64 0
%2259 = shufflevector <2 x double> %2258, <2 x double> poison, <2 x i32> zeroinitializer
%2260 = add nsw i64 %2254, -4
%2261 = lshr exact i64 %2260, 2
%2262 = add nuw nsw i64 %2261, 1
%2263 = and i64 %2262, 1
%2264 = icmp eq i64 %2260, 0
br i1 %2264, label %2311, label %2265
2265: ; preds = %2253
%2266 = and i64 %2262, 9223372036854775806
br label %2267
2267: ; preds = %2267, %2265
%2268 = phi i64 [ 0, %2265 ], [ %2308, %2267 ]
%2269 = phi i64 [ 0, %2265 ], [ %2309, %2267 ]
%2270 = or i64 %2268, 1
%2271 = getelementptr inbounds double, double* %22, i64 %2270
%2272 = bitcast double* %2271 to <2 x double>*
%2273 = load <2 x double>, <2 x double>* %2272
%2274 = getelementptr inbounds double, double* %2271, i64 2
%2275 = bitcast double* %2274 to <2 x double>*
%2276 = load <2 x double>, <2 x double>* %2275
%2277 = getelementptr inbounds double, double* %26, i64 %2270
%2278 = bitcast double* %2277 to <2 x double>*
%2279 = load <2 x double>, <2 x double>* %2278
%2280 = getelementptr inbounds double, double* %2277, i64 2
%2281 = bitcast double* %2280 to <2 x double>*
%2282 = load <2 x double>, <2 x double>* %2281
%2283 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2257, <2 x double> %2279, <2 x double> %2273)
%2284 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2259, <2 x double> %2282, <2 x double> %2276)
%2285 = getelementptr inbounds double, double* %27, i64 %2270
%2286 = bitcast double* %2285 to <2 x double>*
store <2 x double> %2283, <2 x double>* %2286
%2287 = getelementptr inbounds double, double* %2285, i64 2
%2288 = bitcast double* %2287 to <2 x double>*
store <2 x double> %2284, <2 x double>* %2288
%2289 = or i64 %2268, 5
%2290 = getelementptr inbounds double, double* %22, i64 %2289
%2291 = bitcast double* %2290 to <2 x double>*
%2292 = load <2 x double>, <2 x double>* %2291
%2293 = getelementptr inbounds double, double* %2290, i64 2
%2294 = bitcast double* %2293 to <2 x double>*
%2295 = load <2 x double>, <2 x double>* %2294
%2296 = getelementptr inbounds double, double* %26, i64 %2289
%2297 = bitcast double* %2296 to <2 x double>*
%2298 = load <2 x double>, <2 x double>* %2297
%2299 = getelementptr inbounds double, double* %2296, i64 2
%2300 = bitcast double* %2299 to <2 x double>*
%2301 = load <2 x double>, <2 x double>* %2300
%2302 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2257, <2 x double> %2298, <2 x double> %2292)
%2303 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2259, <2 x double> %2301, <2 x double> %2295)
%2304 = getelementptr inbounds double, double* %27, i64 %2289
%2305 = bitcast double* %2304 to <2 x double>*
store <2 x double> %2302, <2 x double>* %2305
%2306 = getelementptr inbounds double, double* %2304, i64 2
%2307 = bitcast double* %2306 to <2 x double>*
store <2 x double> %2303, <2 x double>* %2307
%2308 = add nuw i64 %2268, 8
%2309 = add i64 %2269, 2
%2310 = icmp eq i64 %2309, %2266
br i1 %2310, label %2311, label %2267
2311: ; preds = %2267, %2253
%2312 = phi i64 [ 0, %2253 ], [ %2308, %2267 ]
%2313 = icmp eq i64 %2263, 0
br i1 %2313, label %2334, label %2314
2314: ; preds = %2311
%2315 = or i64 %2312, 1
%2316 = getelementptr inbounds double, double* %22, i64 %2315
%2317 = bitcast double* %2316 to <2 x double>*
%2318 = load <2 x double>, <2 x double>* %2317
%2319 = getelementptr inbounds double, double* %2316, i64 2
%2320 = bitcast double* %2319 to <2 x double>*
%2321 = load <2 x double>, <2 x double>* %2320
%2322 = getelementptr inbounds double, double* %26, i64 %2315
%2323 = bitcast double* %2322 to <2 x double>*
%2324 = load <2 x double>, <2 x double>* %2323
%2325 = getelementptr inbounds double, double* %2322, i64 2
%2326 = bitcast double* %2325 to <2 x double>*
%2327 = load <2 x double>, <2 x double>* %2326
%2328 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2257, <2 x double> %2324, <2 x double> %2318)
%2329 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2259, <2 x double> %2327, <2 x double> %2321)
%2330 = getelementptr inbounds double, double* %27, i64 %2315
%2331 = bitcast double* %2330 to <2 x double>*
store <2 x double> %2328, <2 x double>* %2331
%2332 = getelementptr inbounds double, double* %2330, i64 2
%2333 = bitcast double* %2332 to <2 x double>*
store <2 x double> %2329, <2 x double>* %2333
br label %2334
2334: ; preds = %2311, %2314
%2335 = icmp eq i64 %2240, %2254
br i1 %2335, label %2369, label %2336
2336: ; preds = %2242, %2237, %2334
%2337 = phi i64 [ 1, %2242 ], [ 1, %2237 ], [ %2255, %2334 ]
%2338 = xor i64 %2337, -1
%2339 = and i64 %2239, 1
%2340 = icmp eq i64 %2339, 0
br i1 %2340, label %2341, label %2349
2341: ; preds = %2336
%2342 = getelementptr inbounds double, double* %22, i64 %2337
%2343 = load double, double* %2342
%2344 = getelementptr inbounds double, double* %26, i64 %2337
%2345 = load double, double* %2344
%2346 = tail call double @llvm.fmuladd.f64(double %2234, double %2345, double %2343)
%2347 = getelementptr inbounds double, double* %27, i64 %2337
store double %2346, double* %2347
%2348 = add nuw nsw i64 %2337, 1
br label %2349
2349: ; preds = %2341, %2336
%2350 = phi i64 [ %2337, %2336 ], [ %2348, %2341 ]
%2351 = sub nsw i64 0, %2239
%2352 = icmp eq i64 %2338, %2351
br i1 %2352, label %2369, label %2353
2353: ; preds = %2349, %2353
%2354 = phi i64 [ %2367, %2353 ], [ %2350, %2349 ]
%2355 = getelementptr inbounds double, double* %22, i64 %2354
%2356 = load double, double* %2355
%2357 = getelementptr inbounds double, double* %26, i64 %2354
%2358 = load double, double* %2357
%2359 = tail call double @llvm.fmuladd.f64(double %2234, double %2358, double %2356)
%2360 = getelementptr inbounds double, double* %27, i64 %2354
store double %2359, double* %2360
%2361 = getelementptr inbounds double, double* %5, i64 %2354
%2362 = load double, double* %2361
%2363 = getelementptr inbounds double, double* %11, i64 %2354
%2364 = load double, double* %2363
%2365 = tail call double @llvm.fmuladd.f64(double %2234, double %2364, double %2362)
%2366 = getelementptr inbounds double, double* %12, i64 %2354
store double %2365, double* %2366
%2367 = add nuw nsw i64 %2354, 2
%2368 = icmp eq i64 %2367, %2239
br i1 %2368, label %2369, label %2353
2369: ; preds = %2349, %2353, %2334, %2233
br i1 %2218, label %2370, label %2433
2370: ; preds = %2369
%2371 = icmp slt i32 %2194, 1
br i1 %2371, label %2433, label %2372
2372: ; preds = %2370
%2373 = add i32 %2235, 1
%2374 = add nuw i32 %2194, 1
%2375 = zext i32 %2374 to i64
%2376 = zext i32 %2373 to i64
%2377 = add nsw i64 %2376, -1
%2378 = and i64 %2377, 1
%2379 = icmp eq i32 %2373, 2
%2380 = and i64 %2377, -2
%2381 = icmp eq i64 %2378, 0
br label %2382
2382: ; preds = %2372, %2427
%2383 = phi i64 [ 1, %2372 ], [ %2431, %2427 ]
%2384 = phi double [ 0.000000e+00, %2372 ], [ %2430, %2427 ]
%2385 = getelementptr inbounds i32, i32* %23, i64 %2383
%2386 = load i32, i32* %2385
%2387 = sext i32 %2386 to i64
%2388 = getelementptr inbounds double, double* %21, i64 %2387
%2389 = load double, double* %2388
br i1 %2236, label %2427, label %2390
2390: ; preds = %2382
%2391 = mul nsw i32 %2386, %16
%2392 = sext i32 %2391 to i64
br i1 %2379, label %2415, label %2393
2393: ; preds = %2390, %2393
%2394 = phi i64 [ %2412, %2393 ], [ 1, %2390 ]
%2395 = phi double [ %2411, %2393 ], [ %2389, %2390 ]
%2396 = phi i64 [ %2413, %2393 ], [ 0, %2390 ]
%2397 = add nsw i64 %2394, %2392
%2398 = getelementptr inbounds double, double* %20, i64 %2397
%2399 = load double, double* %2398
%2400 = getelementptr inbounds double, double* %27, i64 %2394
%2401 = load double, double* %2400
%2402 = fneg double %2399
%2403 = tail call double @llvm.fmuladd.f64(double %2402, double %2401, double %2395)
%2404 = add nuw nsw i64 %2394, 1
%2405 = add nsw i64 %2404, %2392
%2406 = getelementptr inbounds double, double* %20, i64 %2405
%2407 = load double, double* %2406
%2408 = getelementptr inbounds double, double* %12, i64 %2394
%2409 = load double, double* %2408
%2410 = fneg double %2407
%2411 = tail call double @llvm.fmuladd.f64(double %2410, double %2409, double %2403)
%2412 = add nuw nsw i64 %2394, 2
%2413 = add i64 %2396, 2
%2414 = icmp eq i64 %2413, %2380
br i1 %2414, label %2415, label %2393
2415: ; preds = %2393, %2390
%2416 = phi double [ undef, %2390 ], [ %2411, %2393 ]
%2417 = phi i64 [ 1, %2390 ], [ %2412, %2393 ]
%2418 = phi double [ %2389, %2390 ], [ %2411, %2393 ]
br i1 %2381, label %2427, label %2419
2419: ; preds = %2415
%2420 = add nsw i64 %2417, %2392
%2421 = getelementptr inbounds double, double* %20, i64 %2420
%2422 = load double, double* %2421
%2423 = getelementptr inbounds double, double* %27, i64 %2417
%2424 = load double, double* %2423
%2425 = fneg double %2422
%2426 = tail call double @llvm.fmuladd.f64(double %2425, double %2424, double %2418)
br label %2427
2427: ; preds = %2419, %2415, %2382
%2428 = phi double [ %2389, %2382 ], [ %2416, %2415 ], [ %2426, %2419 ]
%2429 = fcmp oge double %2384, %2428
%2430 = select i1 %2429, double %2384, double %2428
%2431 = add nuw nsw i64 %2383, 1
%2432 = icmp eq i64 %2431, %2375
br i1 %2432, label %2433, label %2382
2433: ; preds = %2427, %2370, %2369
%2434 = phi double [ %381, %2369 ], [ %382, %2370 ], [ %382, %2427 ]
%2435 = phi double [ %382, %2369 ], [ 0.000000e+00, %2370 ], [ %2430, %2427 ]
%2436 = add i32 %2235, 1
%2437 = sext i32 %2194 to i64
%2438 = zext i32 %2436 to i64
%2439 = zext i32 %2436 to i64
%2440 = getelementptr double, double* %324, i64 %2438
%2441 = getelementptr double, double* %327, i64 %2438
%2442 = add nsw i64 %2438, -2
%2443 = add nsw i64 %2438, -1
%2444 = add nsw i64 %2438, -2
%2445 = and i64 %2443, 1
%2446 = icmp eq i64 %2444, 0
%2447 = and i64 %2443, -2
%2448 = icmp eq i64 %2445, 0
%2449 = icmp eq i32 %2436, 2
%2450 = icmp ult i64 %2442, 4
%2451 = and i64 %2442, -4
%2452 = or i64 %2451, 2
%2453 = icmp eq i64 %2442, %2451
%2454 = sub nsw i64 0, %2438
br label %2455
2455: ; preds = %2629, %2433
%2456 = phi i64 [ %2631, %2629 ], [ 0, %2433 ]
%2457 = phi i64 [ %2630, %2629 ], [ %2437, %2433 ]
%2458 = xor i64 %2456, -1
%2459 = add i64 %2458, %2437
%2460 = getelementptr double, double* %13, i64 %2459
%2461 = getelementptr double, double* %13, i64 %2457
br i1 %2236, label %2513, label %2462
2462: ; preds = %2455
%2463 = mul nsw i64 %2457, %308
br i1 %2446, label %2495, label %2464
2464: ; preds = %2462, %2464
%2465 = phi i64 [ %2492, %2464 ], [ 1, %2462 ]
%2466 = phi double [ %2491, %2464 ], [ 0.000000e+00, %2462 ]
%2467 = phi double [ %2487, %2464 ], [ 0.000000e+00, %2462 ]
%2468 = phi i64 [ %2493, %2464 ], [ 0, %2462 ]
%2469 = add nsw i64 %2465, %2463
%2470 = getelementptr inbounds double, double* %19, i64 %2469
%2471 = load double, double* %2470
%2472 = getelementptr inbounds double, double* %27, i64 %2465
%2473 = load double, double* %2472
%2474 = fmul double %2471, %2473
%2475 = fadd double %2467, %2474
%2476 = fcmp oge double %2474, 0.000000e+00
%2477 = fneg double %2474
%2478 = select i1 %2476, double %2474, double %2477
%2479 = fadd double %2466, %2478
%2480 = add nuw nsw i64 %2465, 1
%2481 = add nsw i64 %2480, %2463
%2482 = getelementptr inbounds double, double* %19, i64 %2481
%2483 = load double, double* %2482
%2484 = getelementptr inbounds double, double* %12, i64 %2465
%2485 = load double, double* %2484
%2486 = fmul double %2483, %2485
%2487 = fadd double %2475, %2486
%2488 = fcmp oge double %2486, 0.000000e+00
%2489 = fneg double %2486
%2490 = select i1 %2488, double %2486, double %2489
%2491 = fadd double %2479, %2490
%2492 = add nuw nsw i64 %2465, 2
%2493 = add i64 %2468, 2
%2494 = icmp eq i64 %2493, %2447
br i1 %2494, label %2495, label %2464
2495: ; preds = %2464, %2462
%2496 = phi double [ undef, %2462 ], [ %2487, %2464 ]
%2497 = phi double [ undef, %2462 ], [ %2491, %2464 ]
%2498 = phi i64 [ 1, %2462 ], [ %2492, %2464 ]
%2499 = phi double [ 0.000000e+00, %2462 ], [ %2491, %2464 ]
%2500 = phi double [ 0.000000e+00, %2462 ], [ %2487, %2464 ]
br i1 %2448, label %2513, label %2501
2501: ; preds = %2495
%2502 = add nsw i64 %2498, %2463
%2503 = getelementptr inbounds double, double* %19, i64 %2502
%2504 = load double, double* %2503
%2505 = getelementptr inbounds double, double* %27, i64 %2498
%2506 = load double, double* %2505
%2507 = fmul double %2504, %2506
%2508 = fadd double %2500, %2507
%2509 = fcmp oge double %2507, 0.000000e+00
%2510 = fneg double %2507
%2511 = select i1 %2509, double %2507, double %2510
%2512 = fadd double %2499, %2511
br label %2513
2513: ; preds = %2501, %2495, %2455
%2514 = phi double [ 0.000000e+00, %2455 ], [ %2496, %2495 ], [ %2508, %2501 ]
%2515 = phi double [ 0.000000e+00, %2455 ], [ %2497, %2495 ], [ %2512, %2501 ]
%2516 = fcmp oge double %2514, 0.000000e+00
%2517 = fneg double %2514
%2518 = select i1 %2516, double %2514, double %2517
%2519 = insertelement <2 x double> poison, double %2518, i64 0
%2520 = shufflevector <2 x double> %2519, <2 x double> poison, <2 x i32> zeroinitializer
%2521 = insertelement <2 x double> poison, double %2515, i64 0
%2522 = shufflevector <2 x double> %2521, <2 x double> poison, <2 x i32> zeroinitializer
%2523 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2520, <2 x double> <double 1.000000e-01, double 2.000000e-01>, <2 x double> %2522)
%2524 = extractelement <2 x double> %2523, i64 0
%2525 = fcmp ult double %2515, %2524
%2526 = extractelement <2 x double> %2523, i64 1
%2527 = fcmp ult double %2524, %2526
%2528 = select i1 %2525, i1 %2527, i1 false
%2529 = select i1 %2528, double %2514, double 0.000000e+00
%2530 = getelementptr inbounds double, double* %24, i64 %2457
%2531 = load double, double* %2530
%2532 = fdiv double %2529, %2531
%2533 = getelementptr inbounds double, double* %28, i64 %2457
store double %2532, double* %2533
%2534 = icmp sgt i64 %2457, 1
br i1 %2534, label %2535, label %2632
2535: ; preds = %2513
br i1 %2236, label %2629, label %2536
2536: ; preds = %2535
%2537 = getelementptr inbounds i32, i32* %23, i64 %2457
%2538 = load i32, i32* %2537
%2539 = mul nsw i32 %2538, %16
%2540 = sext i32 %2539 to i64
%2541 = add nsw i64 %2540, 1
%2542 = getelementptr inbounds double, double* %20, i64 %2541
%2543 = load double, double* %2542
%2544 = load double, double* %12
%2545 = fneg double %2532
%2546 = tail call double @llvm.fmuladd.f64(double %2545, double %2543, double %2544)
store double %2546, double* %12
br i1 %2449, label %2629, label %2547
2547: ; preds = %2536
br i1 %2450, label %2589, label %2548
2548: ; preds = %2547
%2549 = getelementptr double, double* %326, i64 %2540
%2550 = getelementptr double, double* %2441, i64 %2540
%2551 = icmp ult double* %323, %2461
%2552 = icmp ult double* %2460, %2440
%2553 = and i1 %2551, %2552
%2554 = icmp ult double* %323, %2550
%2555 = icmp ult double* %2549, %2440
%2556 = and i1 %2554, %2555
%2557 = or i1 %2553, %2556
br i1 %2557, label %2589, label %2558
2558: ; preds = %2548
%2559 = load double, double* %2533
%2560 = insertelement <2 x double> poison, double %2559, i64 0
%2561 = shufflevector <2 x double> %2560, <2 x double> poison, <2 x i32> zeroinitializer
%2562 = insertelement <2 x double> poison, double %2559, i64 0
%2563 = shufflevector <2 x double> %2562, <2 x double> poison, <2 x i32> zeroinitializer
%2564 = fneg <2 x double> %2561
%2565 = fneg <2 x double> %2563
br label %2566
2566: ; preds = %2566, %2558
%2567 = phi i64 [ 0, %2558 ], [ %2586, %2566 ]
%2568 = or i64 %2567, 2
%2569 = add nsw i64 %2568, %2540
%2570 = getelementptr inbounds double, double* %20, i64 %2569
%2571 = bitcast double* %2570 to <2 x double>*
%2572 = load <2 x double>, <2 x double>* %2571
%2573 = getelementptr inbounds double, double* %2570, i64 2
%2574 = bitcast double* %2573 to <2 x double>*
%2575 = load <2 x double>, <2 x double>* %2574
%2576 = getelementptr inbounds double, double* %27, i64 %2568
%2577 = bitcast double* %2576 to <2 x double>*
%2578 = load <2 x double>, <2 x double>* %2577
%2579 = getelementptr inbounds double, double* %2576, i64 2
%2580 = bitcast double* %2579 to <2 x double>*
%2581 = load <2 x double>, <2 x double>* %2580
%2582 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2564, <2 x double> %2572, <2 x double> %2578)
%2583 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2565, <2 x double> %2575, <2 x double> %2581)
%2584 = bitcast double* %2576 to <2 x double>*
store <2 x double> %2582, <2 x double>* %2584
%2585 = bitcast double* %2579 to <2 x double>*
store <2 x double> %2583, <2 x double>* %2585
%2586 = add nuw i64 %2567, 4
%2587 = icmp eq i64 %2586, %2451
br i1 %2587, label %2588, label %2566
2588: ; preds = %2566
br i1 %2453, label %2629, label %2589
2589: ; preds = %2548, %2547, %2588
%2590 = phi i64 [ 2, %2548 ], [ 2, %2547 ], [ %2452, %2588 ]
%2591 = sub nsw i64 %2438, %2590
%2592 = xor i64 %2590, -1
%2593 = and i64 %2591, 1
%2594 = icmp eq i64 %2593, 0
br i1 %2594, label %2605, label %2595
2595: ; preds = %2589
%2596 = load double, double* %2533
%2597 = add nsw i64 %2590, %2540
%2598 = getelementptr inbounds double, double* %20, i64 %2597
%2599 = load double, double* %2598
%2600 = getelementptr inbounds double, double* %27, i64 %2590
%2601 = load double, double* %2600
%2602 = fneg double %2596
%2603 = tail call double @llvm.fmuladd.f64(double %2602, double %2599, double %2601)
store double %2603, double* %2600
%2604 = add nuw nsw i64 %2590, 1
br label %2605
2605: ; preds = %2595, %2589
%2606 = phi i64 [ %2590, %2589 ], [ %2604, %2595 ]
%2607 = icmp eq i64 %2592, %2454
br i1 %2607, label %2629, label %2608
2608: ; preds = %2605, %2608
%2609 = phi i64 [ %2627, %2608 ], [ %2606, %2605 ]
%2610 = load double, double* %2533
%2611 = add nsw i64 %2609, %2540
%2612 = getelementptr inbounds double, double* %20, i64 %2611
%2613 = load double, double* %2612
%2614 = getelementptr inbounds double, double* %27, i64 %2609
%2615 = load double, double* %2614
%2616 = fneg double %2610
%2617 = tail call double @llvm.fmuladd.f64(double %2616, double %2613, double %2615)
store double %2617, double* %2614
%2618 = add nuw nsw i64 %2609, 1
%2619 = load double, double* %2533
%2620 = add nsw i64 %2618, %2540
%2621 = getelementptr inbounds double, double* %20, i64 %2620
%2622 = load double, double* %2621
%2623 = getelementptr inbounds double, double* %12, i64 %2609
%2624 = load double, double* %2623
%2625 = fneg double %2619
%2626 = tail call double @llvm.fmuladd.f64(double %2625, double %2622, double %2624)
store double %2626, double* %2623
%2627 = add nuw nsw i64 %2609, 2
%2628 = icmp eq i64 %2627, %2439
br i1 %2628, label %2629, label %2608
2629: ; preds = %2605, %2608, %2536, %2588, %2535
%2630 = add nsw i64 %2457, -1
%2631 = add i64 %2456, 1
br label %2455
2632: ; preds = %2513
%2633 = icmp sgt i32 %303, %2217
br i1 %2633, label %2634, label %2639
2634: ; preds = %2632
%2635 = getelementptr inbounds double, double* %28, i64 %2437
%2636 = load double, double* %2635
%2637 = fcmp ole double %2636, 0.000000e+00
%2638 = select i1 %2637, double 0.000000e+00, double %2636
store double %2638, double* %2635
br label %2639
2639: ; preds = %2634, %2632
br i1 %2236, label %2771, label %2640
2640: ; preds = %2639
%2641 = zext i32 %2436 to i64
%2642 = add nsw i64 %2438, -1
%2643 = icmp ult i64 %2642, 4
br i1 %2643, label %2738, label %2644
2644: ; preds = %2640
%2645 = getelementptr double, double* %320, i64 %2438
%2646 = getelementptr double, double* %321, i64 %2438
%2647 = getelementptr double, double* %322, i64 %2438
%2648 = icmp ugt double* %2646, %12
%2649 = icmp ugt double* %2645, %5
%2650 = and i1 %2648, %2649
%2651 = icmp ugt double* %2647, %12
%2652 = icmp ugt double* %2645, %11
%2653 = and i1 %2651, %2652
%2654 = or i1 %2650, %2653
br i1 %2654, label %2738, label %2655
2655: ; preds = %2644
%2656 = and i64 %2642, -4
%2657 = or i64 %2656, 1
%2658 = insertelement <2 x double> poison, double %2234, i64 0
%2659 = shufflevector <2 x double> %2658, <2 x double> poison, <2 x i32> zeroinitializer
%2660 = insertelement <2 x double> poison, double %2234, i64 0
%2661 = shufflevector <2 x double> %2660, <2 x double> poison, <2 x i32> zeroinitializer
%2662 = add nsw i64 %2656, -4
%2663 = lshr exact i64 %2662, 2
%2664 = add nuw nsw i64 %2663, 1
%2665 = and i64 %2664, 1
%2666 = icmp eq i64 %2662, 0
br i1 %2666, label %2713, label %2667
2667: ; preds = %2655
%2668 = and i64 %2664, 9223372036854775806
br label %2669
2669: ; preds = %2669, %2667
%2670 = phi i64 [ 0, %2667 ], [ %2710, %2669 ]
%2671 = phi i64 [ 0, %2667 ], [ %2711, %2669 ]
%2672 = or i64 %2670, 1
%2673 = getelementptr inbounds double, double* %22, i64 %2672
%2674 = bitcast double* %2673 to <2 x double>*
%2675 = load <2 x double>, <2 x double>* %2674
%2676 = getelementptr inbounds double, double* %2673, i64 2
%2677 = bitcast double* %2676 to <2 x double>*
%2678 = load <2 x double>, <2 x double>* %2677
%2679 = getelementptr inbounds double, double* %26, i64 %2672
%2680 = bitcast double* %2679 to <2 x double>*
%2681 = load <2 x double>, <2 x double>* %2680
%2682 = getelementptr inbounds double, double* %2679, i64 2
%2683 = bitcast double* %2682 to <2 x double>*
%2684 = load <2 x double>, <2 x double>* %2683
%2685 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2659, <2 x double> %2681, <2 x double> %2675)
%2686 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2661, <2 x double> %2684, <2 x double> %2678)
%2687 = getelementptr inbounds double, double* %27, i64 %2672
%2688 = bitcast double* %2687 to <2 x double>*
store <2 x double> %2685, <2 x double>* %2688
%2689 = getelementptr inbounds double, double* %2687, i64 2
%2690 = bitcast double* %2689 to <2 x double>*
store <2 x double> %2686, <2 x double>* %2690
%2691 = or i64 %2670, 5
%2692 = getelementptr inbounds double, double* %22, i64 %2691
%2693 = bitcast double* %2692 to <2 x double>*
%2694 = load <2 x double>, <2 x double>* %2693
%2695 = getelementptr inbounds double, double* %2692, i64 2
%2696 = bitcast double* %2695 to <2 x double>*
%2697 = load <2 x double>, <2 x double>* %2696
%2698 = getelementptr inbounds double, double* %26, i64 %2691
%2699 = bitcast double* %2698 to <2 x double>*
%2700 = load <2 x double>, <2 x double>* %2699
%2701 = getelementptr inbounds double, double* %2698, i64 2
%2702 = bitcast double* %2701 to <2 x double>*
%2703 = load <2 x double>, <2 x double>* %2702
%2704 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2659, <2 x double> %2700, <2 x double> %2694)
%2705 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2661, <2 x double> %2703, <2 x double> %2697)
%2706 = getelementptr inbounds double, double* %27, i64 %2691
%2707 = bitcast double* %2706 to <2 x double>*
store <2 x double> %2704, <2 x double>* %2707
%2708 = getelementptr inbounds double, double* %2706, i64 2
%2709 = bitcast double* %2708 to <2 x double>*
store <2 x double> %2705, <2 x double>* %2709
%2710 = add nuw i64 %2670, 8
%2711 = add i64 %2671, 2
%2712 = icmp eq i64 %2711, %2668
br i1 %2712, label %2713, label %2669
2713: ; preds = %2669, %2655
%2714 = phi i64 [ 0, %2655 ], [ %2710, %2669 ]
%2715 = icmp eq i64 %2665, 0
br i1 %2715, label %2736, label %2716
2716: ; preds = %2713
%2717 = or i64 %2714, 1
%2718 = getelementptr inbounds double, double* %22, i64 %2717
%2719 = bitcast double* %2718 to <2 x double>*
%2720 = load <2 x double>, <2 x double>* %2719
%2721 = getelementptr inbounds double, double* %2718, i64 2
%2722 = bitcast double* %2721 to <2 x double>*
%2723 = load <2 x double>, <2 x double>* %2722
%2724 = getelementptr inbounds double, double* %26, i64 %2717
%2725 = bitcast double* %2724 to <2 x double>*
%2726 = load <2 x double>, <2 x double>* %2725
%2727 = getelementptr inbounds double, double* %2724, i64 2
%2728 = bitcast double* %2727 to <2 x double>*
%2729 = load <2 x double>, <2 x double>* %2728
%2730 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2659, <2 x double> %2726, <2 x double> %2720)
%2731 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2661, <2 x double> %2729, <2 x double> %2723)
%2732 = getelementptr inbounds double, double* %27, i64 %2717
%2733 = bitcast double* %2732 to <2 x double>*
store <2 x double> %2730, <2 x double>* %2733
%2734 = getelementptr inbounds double, double* %2732, i64 2
%2735 = bitcast double* %2734 to <2 x double>*
store <2 x double> %2731, <2 x double>* %2735
br label %2736
2736: ; preds = %2713, %2716
%2737 = icmp eq i64 %2642, %2656
br i1 %2737, label %2771, label %2738
2738: ; preds = %2644, %2640, %2736
%2739 = phi i64 [ 1, %2644 ], [ 1, %2640 ], [ %2657, %2736 ]
%2740 = xor i64 %2739, -1
%2741 = and i64 %2438, 1
%2742 = icmp eq i64 %2741, 0
br i1 %2742, label %2743, label %2751
2743: ; preds = %2738
%2744 = getelementptr inbounds double, double* %22, i64 %2739
%2745 = load double, double* %2744
%2746 = getelementptr inbounds double, double* %26, i64 %2739
%2747 = load double, double* %2746
%2748 = tail call double @llvm.fmuladd.f64(double %2234, double %2747, double %2745)
%2749 = getelementptr inbounds double, double* %27, i64 %2739
store double %2748, double* %2749
%2750 = add nuw nsw i64 %2739, 1
br label %2751
2751: ; preds = %2743, %2738
%2752 = phi i64 [ %2739, %2738 ], [ %2750, %2743 ]
%2753 = sub nsw i64 0, %2438
%2754 = icmp eq i64 %2740, %2753
br i1 %2754, label %2771, label %2755
2755: ; preds = %2751, %2755
%2756 = phi i64 [ %2769, %2755 ], [ %2752, %2751 ]
%2757 = getelementptr inbounds double, double* %22, i64 %2756
%2758 = load double, double* %2757
%2759 = getelementptr inbounds double, double* %26, i64 %2756
%2760 = load double, double* %2759
%2761 = tail call double @llvm.fmuladd.f64(double %2234, double %2760, double %2758)
%2762 = getelementptr inbounds double, double* %27, i64 %2756
store double %2761, double* %2762
%2763 = getelementptr inbounds double, double* %5, i64 %2756
%2764 = load double, double* %2763
%2765 = getelementptr inbounds double, double* %11, i64 %2756
%2766 = load double, double* %2765
%2767 = tail call double @llvm.fmuladd.f64(double %2234, double %2766, double %2764)
%2768 = getelementptr inbounds double, double* %12, i64 %2756
store double %2767, double* %2768
%2769 = add nuw nsw i64 %2756, 2
%2770 = icmp eq i64 %2769, %2641
br i1 %2770, label %2771, label %2755
2771: ; preds = %2751, %2755, %2736, %2639
%2772 = icmp sgt i32 %303, %2194
br i1 %2772, label %2773, label %2862
2773: ; preds = %2771
%2774 = and i64 %2443, 1
%2775 = icmp eq i64 %2444, 0
%2776 = and i64 %2443, -2
%2777 = icmp eq i64 %2774, 0
br label %2778
2778: ; preds = %2773, %2843
%2779 = phi i64 [ %2437, %2773 ], [ %2780, %2843 ]
%2780 = add nsw i64 %2779, 1
%2781 = getelementptr inbounds i32, i32* %7, i64 %2779
%2782 = load i32, i32* %2781
%2783 = sext i32 %2782 to i64
%2784 = getelementptr inbounds double, double* %21, i64 %2783
%2785 = load double, double* %2784
%2786 = fsub double %2435, %2785
%2787 = fcmp oge double %2785, 0.000000e+00
%2788 = fneg double %2785
%2789 = select i1 %2787, double %2785, double %2788
%2790 = fadd double %2435, %2789
br i1 %2236, label %2843, label %2791
2791: ; preds = %2778
%2792 = mul nsw i32 %2782, %16
%2793 = sext i32 %2792 to i64
br i1 %2775, label %2825, label %2794
2794: ; preds = %2791, %2794
%2795 = phi i64 [ %2822, %2794 ], [ 1, %2791 ]
%2796 = phi double [ %2821, %2794 ], [ %2790, %2791 ]
%2797 = phi double [ %2817, %2794 ], [ %2786, %2791 ]
%2798 = phi i64 [ %2823, %2794 ], [ 0, %2791 ]
%2799 = add nsw i64 %2795, %2793
%2800 = getelementptr inbounds double, double* %20, i64 %2799
%2801 = load double, double* %2800
%2802 = getelementptr inbounds double, double* %27, i64 %2795
%2803 = load double, double* %2802
%2804 = fmul double %2801, %2803
%2805 = fadd double %2797, %2804
%2806 = fcmp oge double %2804, 0.000000e+00
%2807 = fneg double %2804
%2808 = select i1 %2806, double %2804, double %2807
%2809 = fadd double %2796, %2808
%2810 = add nuw nsw i64 %2795, 1
%2811 = add nsw i64 %2810, %2793
%2812 = getelementptr inbounds double, double* %20, i64 %2811
%2813 = load double, double* %2812
%2814 = getelementptr inbounds double, double* %12, i64 %2795
%2815 = load double, double* %2814
%2816 = fmul double %2813, %2815
%2817 = fadd double %2805, %2816
%2818 = fcmp oge double %2816, 0.000000e+00
%2819 = fneg double %2816
%2820 = select i1 %2818, double %2816, double %2819
%2821 = fadd double %2809, %2820
%2822 = add nuw nsw i64 %2795, 2
%2823 = add i64 %2798, 2
%2824 = icmp eq i64 %2823, %2776
br i1 %2824, label %2825, label %2794
2825: ; preds = %2794, %2791
%2826 = phi double [ undef, %2791 ], [ %2817, %2794 ]
%2827 = phi double [ undef, %2791 ], [ %2821, %2794 ]
%2828 = phi i64 [ 1, %2791 ], [ %2822, %2794 ]
%2829 = phi double [ %2790, %2791 ], [ %2821, %2794 ]
%2830 = phi double [ %2786, %2791 ], [ %2817, %2794 ]
br i1 %2777, label %2843, label %2831
2831: ; preds = %2825
%2832 = add nsw i64 %2828, %2793
%2833 = getelementptr inbounds double, double* %20, i64 %2832
%2834 = load double, double* %2833
%2835 = getelementptr inbounds double, double* %27, i64 %2828
%2836 = load double, double* %2835
%2837 = fmul double %2834, %2836
%2838 = fadd double %2830, %2837
%2839 = fcmp oge double %2837, 0.000000e+00
%2840 = fneg double %2837
%2841 = select i1 %2839, double %2837, double %2840
%2842 = fadd double %2829, %2841
br label %2843
2843: ; preds = %2831, %2825, %2778
%2844 = phi double [ %2786, %2778 ], [ %2826, %2825 ], [ %2838, %2831 ]
%2845 = phi double [ %2790, %2778 ], [ %2827, %2825 ], [ %2842, %2831 ]
%2846 = fcmp oge double %2844, 0.000000e+00
%2847 = fneg double %2844
%2848 = select i1 %2846, double %2844, double %2847
%2849 = insertelement <2 x double> poison, double %2848, i64 0
%2850 = shufflevector <2 x double> %2849, <2 x double> poison, <2 x i32> zeroinitializer
%2851 = insertelement <2 x double> poison, double %2845, i64 0
%2852 = shufflevector <2 x double> %2851, <2 x double> poison, <2 x i32> zeroinitializer
%2853 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2850, <2 x double> <double 0x3FB99999A0000000, double 0x3FC99999A0000000>, <2 x double> %2852)
%2854 = extractelement <2 x double> %2853, i64 0
%2855 = fcmp ult double %2845, %2854
%2856 = extractelement <2 x double> %2853, i64 1
%2857 = fcmp ult double %2854, %2856
%2858 = select i1 %2855, i1 %2857, i1 false
%2859 = select i1 %2858, double %2844, double 0.000000e+00
%2860 = getelementptr inbounds double, double* %13, i64 %2779
store double %2859, double* %2860
%2861 = icmp eq i64 %2780, %311
br i1 %2861, label %2862, label %2778
2862: ; preds = %2843, %2771
br i1 %306, label %2919, label %2863
2863: ; preds = %2862
br i1 %366, label %2901, label %2864
2864: ; preds = %2863, %2895
%2865 = phi i64 [ %2898, %2895 ], [ 1, %2863 ]
%2866 = phi i32 [ %2897, %2895 ], [ 0, %2863 ]
%2867 = phi double [ %2896, %2895 ], [ 1.000000e+00, %2863 ]
%2868 = phi i64 [ %2899, %2895 ], [ 0, %2863 ]
%2869 = getelementptr inbounds double, double* %28, i64 %2865
%2870 = load double, double* %2869
%2871 = fcmp olt double %2870, 0.000000e+00
br i1 %2871, label %2872, label %2880
2872: ; preds = %2864
%2873 = getelementptr inbounds double, double* %25, i64 %2865
%2874 = load double, double* %2873
%2875 = fsub double %2874, %2870
%2876 = fdiv double %2874, %2875
%2877 = fcmp olt double %2876, %2867
br i1 %2877, label %2878, label %2880
2878: ; preds = %2872
%2879 = trunc i64 %2865 to i32
br label %2880
2880: ; preds = %2864, %2878, %2872
%2881 = phi double [ %2876, %2878 ], [ %2867, %2872 ], [ %2867, %2864 ]
%2882 = phi i32 [ %2879, %2878 ], [ %2866, %2872 ], [ %2866, %2864 ]
%2883 = getelementptr inbounds double, double* %13, i64 %2865
%2884 = load double, double* %2883
%2885 = fcmp olt double %2884, 0.000000e+00
br i1 %2885, label %2886, label %2895
2886: ; preds = %2880
%2887 = getelementptr inbounds double, double* %10, i64 %2865
%2888 = load double, double* %2887
%2889 = fsub double %2888, %2884
%2890 = fdiv double %2888, %2889
%2891 = fcmp olt double %2890, %2881
br i1 %2891, label %2892, label %2895
2892: ; preds = %2886
%2893 = trunc i64 %2865 to i32
%2894 = add i32 %2893, 1
br label %2895
2895: ; preds = %2892, %2886, %2880
%2896 = phi double [ %2890, %2892 ], [ %2881, %2886 ], [ %2881, %2880 ]
%2897 = phi i32 [ %2894, %2892 ], [ %2882, %2886 ], [ %2882, %2880 ]
%2898 = add nuw nsw i64 %2865, 2
%2899 = add i64 %2868, 2
%2900 = icmp eq i64 %2899, %367
br i1 %2900, label %2901, label %2864
2901: ; preds = %2895, %2863
%2902 = phi double [ undef, %2863 ], [ %2896, %2895 ]
%2903 = phi i32 [ undef, %2863 ], [ %2897, %2895 ]
%2904 = phi i64 [ 1, %2863 ], [ %2898, %2895 ]
%2905 = phi i32 [ 0, %2863 ], [ %2897, %2895 ]
%2906 = phi double [ 1.000000e+00, %2863 ], [ %2896, %2895 ]
br i1 %368, label %2919, label %2907
2907: ; preds = %2901
%2908 = getelementptr inbounds double, double* %28, i64 %2904
%2909 = load double, double* %2908
%2910 = fcmp olt double %2909, 0.000000e+00
br i1 %2910, label %2911, label %2919
2911: ; preds = %2907
%2912 = getelementptr inbounds double, double* %25, i64 %2904
%2913 = load double, double* %2912
%2914 = fsub double %2913, %2909
%2915 = fdiv double %2913, %2914
%2916 = fcmp olt double %2915, %2906
br i1 %2916, label %2917, label %2919
2917: ; preds = %2911
%2918 = trunc i64 %2904 to i32
br label %2919
2919: ; preds = %2901, %2917, %2911, %2907, %2862
%2920 = phi double [ 1.000000e+00, %2862 ], [ %2902, %2901 ], [ %2915, %2917 ], [ %2906, %2911 ], [ %2906, %2907 ]
%2921 = phi i32 [ 0, %2862 ], [ %2903, %2901 ], [ %2918, %2917 ], [ %2905, %2911 ], [ %2905, %2907 ]
%2922 = fsub double 1.000000e+00, %2920
br i1 %2236, label %2986, label %2923
2923: ; preds = %2919
%2924 = zext i32 %2436 to i64
%2925 = add nsw i64 %2438, -1
%2926 = icmp ult i64 %2925, 4
br i1 %2926, label %2969, label %2927
2927: ; preds = %2923
%2928 = getelementptr double, double* %318, i64 %2438
%2929 = getelementptr double, double* %319, i64 %2438
%2930 = icmp ugt double* %2929, %5
%2931 = icmp ugt double* %2928, %12
%2932 = and i1 %2930, %2931
br i1 %2932, label %2969, label %2933
2933: ; preds = %2927
%2934 = and i64 %2925, -4
%2935 = or i64 %2934, 1
%2936 = insertelement <2 x double> poison, double %2920, i64 0
%2937 = shufflevector <2 x double> %2936, <2 x double> poison, <2 x i32> zeroinitializer
%2938 = insertelement <2 x double> poison, double %2920, i64 0
%2939 = shufflevector <2 x double> %2938, <2 x double> poison, <2 x i32> zeroinitializer
%2940 = insertelement <2 x double> poison, double %2922, i64 0
%2941 = shufflevector <2 x double> %2940, <2 x double> poison, <2 x i32> zeroinitializer
%2942 = insertelement <2 x double> poison, double %2922, i64 0
%2943 = shufflevector <2 x double> %2942, <2 x double> poison, <2 x i32> zeroinitializer
br label %2944
2944: ; preds = %2944, %2933
%2945 = phi i64 [ 0, %2933 ], [ %2965, %2944 ]
%2946 = or i64 %2945, 1
%2947 = getelementptr inbounds double, double* %22, i64 %2946
%2948 = bitcast double* %2947 to <2 x double>*
%2949 = load <2 x double>, <2 x double>* %2948
%2950 = getelementptr inbounds double, double* %2947, i64 2
%2951 = bitcast double* %2950 to <2 x double>*
%2952 = load <2 x double>, <2 x double>* %2951
%2953 = getelementptr inbounds double, double* %27, i64 %2946
%2954 = bitcast double* %2953 to <2 x double>*
%2955 = load <2 x double>, <2 x double>* %2954
%2956 = getelementptr inbounds double, double* %2953, i64 2
%2957 = bitcast double* %2956 to <2 x double>*
%2958 = load <2 x double>, <2 x double>* %2957
%2959 = fmul <2 x double> %2937, %2955
%2960 = fmul <2 x double> %2939, %2958
%2961 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2941, <2 x double> %2949, <2 x double> %2959)
%2962 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2943, <2 x double> %2952, <2 x double> %2960)
%2963 = bitcast double* %2947 to <2 x double>*
store <2 x double> %2961, <2 x double>* %2963
%2964 = bitcast double* %2950 to <2 x double>*
store <2 x double> %2962, <2 x double>* %2964
%2965 = add nuw i64 %2945, 4
%2966 = icmp eq i64 %2965, %2934
br i1 %2966, label %2967, label %2944
2967: ; preds = %2944
%2968 = icmp eq i64 %2925, %2934
br i1 %2968, label %2986, label %2969
2969: ; preds = %2927, %2923, %2967
%2970 = phi i64 [ 1, %2927 ], [ 1, %2923 ], [ %2935, %2967 ]
%2971 = xor i64 %2970, -1
%2972 = and i64 %2438, 1
%2973 = icmp eq i64 %2972, 0
br i1 %2973, label %2974, label %2982
2974: ; preds = %2969
%2975 = getelementptr inbounds double, double* %22, i64 %2970
%2976 = load double, double* %2975
%2977 = getelementptr inbounds double, double* %27, i64 %2970
%2978 = load double, double* %2977
%2979 = fmul double %2920, %2978
%2980 = tail call double @llvm.fmuladd.f64(double %2922, double %2976, double %2979)
store double %2980, double* %2975
%2981 = add nuw nsw i64 %2970, 1
br label %2982
2982: ; preds = %2974, %2969
%2983 = phi i64 [ %2970, %2969 ], [ %2981, %2974 ]
%2984 = sub nsw i64 0, %2438
%2985 = icmp eq i64 %2971, %2984
br i1 %2985, label %2986, label %3042
2986: ; preds = %2982, %3042, %2967, %2919
br i1 %306, label %3078, label %2987
2987: ; preds = %2986
%2988 = select i1 %369, i1 true, i1 %372
br i1 %2988, label %3026, label %2989
2989: ; preds = %2987
%2990 = insertelement <2 x double> poison, double %2920, i64 0
%2991 = shufflevector <2 x double> %2990, <2 x double> poison, <2 x i32> zeroinitializer
%2992 = insertelement <2 x double> poison, double %2920, i64 0
%2993 = shufflevector <2 x double> %2992, <2 x double> poison, <2 x i32> zeroinitializer
%2994 = insertelement <2 x double> poison, double %2922, i64 0
%2995 = shufflevector <2 x double> %2994, <2 x double> poison, <2 x i32> zeroinitializer
%2996 = insertelement <2 x double> poison, double %2922, i64 0
%2997 = shufflevector <2 x double> %2996, <2 x double> poison, <2 x i32> zeroinitializer
br label %2998
2998: ; preds = %2998, %2989
%2999 = phi i64 [ 0, %2989 ], [ %3023, %2998 ]
%3000 = or i64 %2999, 1
%3001 = getelementptr inbounds double, double* %25, i64 %3000
%3002 = bitcast double* %3001 to <2 x double>*
%3003 = load <2 x double>, <2 x double>* %3002
%3004 = getelementptr inbounds double, double* %3001, i64 2
%3005 = bitcast double* %3004 to <2 x double>*
%3006 = load <2 x double>, <2 x double>* %3005
%3007 = getelementptr inbounds double, double* %28, i64 %3000
%3008 = bitcast double* %3007 to <2 x double>*
%3009 = load <2 x double>, <2 x double>* %3008
%3010 = getelementptr inbounds double, double* %3007, i64 2
%3011 = bitcast double* %3010 to <2 x double>*
%3012 = load <2 x double>, <2 x double>* %3011
%3013 = fmul <2 x double> %2991, %3009
%3014 = fmul <2 x double> %2993, %3012
%3015 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2995, <2 x double> %3003, <2 x double> %3013)
%3016 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %2997, <2 x double> %3006, <2 x double> %3014)
%3017 = fcmp ole <2 x double> %3015, zeroinitializer
%3018 = fcmp ole <2 x double> %3016, zeroinitializer
%3019 = select <2 x i1> %3017, <2 x double> zeroinitializer, <2 x double> %3015
%3020 = select <2 x i1> %3018, <2 x double> zeroinitializer, <2 x double> %3016
%3021 = bitcast double* %3001 to <2 x double>*
store <2 x double> %3019, <2 x double>* %3021
%3022 = bitcast double* %3004 to <2 x double>*
store <2 x double> %3020, <2 x double>* %3022
%3023 = add nuw i64 %2999, 4
%3024 = icmp eq i64 %3023, %373
br i1 %3024, label %3025, label %2998
3025: ; preds = %2998
br i1 %375, label %3078, label %3026
3026: ; preds = %2987, %3025
%3027 = phi i64 [ 1, %2987 ], [ %374, %3025 ]
%3028 = xor i64 %3027, -1
br i1 %377, label %3029, label %3039
3029: ; preds = %3026
%3030 = getelementptr inbounds double, double* %25, i64 %3027
%3031 = load double, double* %3030
%3032 = getelementptr inbounds double, double* %28, i64 %3027
%3033 = load double, double* %3032
%3034 = fmul double %2920, %3033
%3035 = tail call double @llvm.fmuladd.f64(double %2922, double %3031, double %3034)
%3036 = fcmp ole double %3035, 0.000000e+00
%3037 = select i1 %3036, double 0.000000e+00, double %3035
store double %3037, double* %3030
%3038 = add nuw nsw i64 %3027, 1
br label %3039
3039: ; preds = %3029, %3026
%3040 = phi i64 [ %3027, %3026 ], [ %3038, %3029 ]
%3041 = icmp eq i64 %3028, %378
br i1 %3041, label %3078, label %3058
3042: ; preds = %2982, %3042
%3043 = phi i64 [ %3056, %3042 ], [ %2983, %2982 ]
%3044 = getelementptr inbounds double, double* %22, i64 %3043
%3045 = load double, double* %3044
%3046 = getelementptr inbounds double, double* %27, i64 %3043
%3047 = load double, double* %3046
%3048 = fmul double %2920, %3047
%3049 = tail call double @llvm.fmuladd.f64(double %2922, double %3045, double %3048)
store double %3049, double* %3044
%3050 = getelementptr inbounds double, double* %5, i64 %3043
%3051 = load double, double* %3050
%3052 = getelementptr inbounds double, double* %12, i64 %3043
%3053 = load double, double* %3052
%3054 = fmul double %2920, %3053
%3055 = tail call double @llvm.fmuladd.f64(double %2922, double %3051, double %3054)
store double %3055, double* %3050
%3056 = add nuw nsw i64 %3043, 2
%3057 = icmp eq i64 %3056, %2924
br i1 %3057, label %2986, label %3042
3058: ; preds = %3039, %3058
%3059 = phi i64 [ %3076, %3058 ], [ %3040, %3039 ]
%3060 = getelementptr inbounds double, double* %25, i64 %3059
%3061 = load double, double* %3060
%3062 = getelementptr inbounds double, double* %28, i64 %3059
%3063 = load double, double* %3062
%3064 = fmul double %2920, %3063
%3065 = tail call double @llvm.fmuladd.f64(double %2922, double %3061, double %3064)
%3066 = fcmp ole double %3065, 0.000000e+00
%3067 = select i1 %3066, double 0.000000e+00, double %3065
store double %3067, double* %3060
%3068 = getelementptr inbounds double, double* %10, i64 %3059
%3069 = load double, double* %3068
%3070 = getelementptr inbounds double, double* %13, i64 %3059
%3071 = load double, double* %3070
%3072 = fmul double %2920, %3071
%3073 = tail call double @llvm.fmuladd.f64(double %2922, double %3069, double %3072)
%3074 = fcmp ole double %3073, 0.000000e+00
%3075 = select i1 %3074, double 0.000000e+00, double %3073
store double %3075, double* %3068
%3076 = add nuw nsw i64 %3059, 2
%3077 = icmp eq i64 %3076, %313
br i1 %3077, label %3078, label %3058
3078: ; preds = %3039, %3058, %3025, %2986
%3079 = fsub double %2435, %2434
%3080 = tail call double @llvm.fmuladd.f64(double %2920, double %3079, double %2434)
%3081 = select i1 %2218, double %3080, double %2435
%3082 = icmp sgt i32 %2921, 0
br i1 %3082, label %379, label %3083
3083: ; preds = %3078
%3084 = fcmp oeq double %2234, %2216
br i1 %3084, label %3101, label %3085
3085: ; preds = %2219, %289, %3095, %3083
%3086 = phi i32 [ %291, %289 ], [ %303, %3095 ], [ %2217, %3083 ], [ %303, %2219 ]
%3087 = phi double [ 0.000000e+00, %289 ], [ %381, %3095 ], [ %2434, %3083 ], [ %381, %2219 ]
%3088 = phi double [ %290, %289 ], [ %382, %3095 ], [ %3081, %3083 ], [ %382, %2219 ]
%3089 = phi i32 [ 0, %289 ], [ %3096, %3095 ], [ %2194, %3083 ], [ %2194, %2219 ]
%3090 = phi i32 [ 0, %289 ], [ %3097, %3095 ], [ %446, %3083 ], [ %446, %2219 ]
%3091 = add nsw i32 %3086, 1
%3092 = sext i32 %3091 to i64
%3093 = getelementptr inbounds i32, i32* %23, i64 %3092
store i32 %3091, i32* %3093
%3094 = getelementptr inbounds double, double* %25, i64 %3092
store double 0.000000e+00, double* %3094
br label %298
3095: ; preds = %1243, %2193, %1291, %995, %440
%3096 = phi i32 [ %2194, %2193 ], [ %385, %995 ], [ %385, %1291 ], [ %385, %440 ], [ %385, %1243 ]
%3097 = phi i32 [ %446, %2193 ], [ %446, %995 ], [ %446, %1291 ], [ %387, %440 ], [ %446, %1243 ]
%3098 = load i32, i32* %1
%3099 = icmp eq i32 %303, %3098
br i1 %3099, label %3085, label %3100
3100: ; preds = %3095
store i32 0, i32* %6
br label %3101
3101: ; preds = %3083, %3100
ret i32 0
}