#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double DBL_EPSILON;
double cos(double);
int /*<<< orphan*/ cov(int, double *, double *, double *);
int /*<<< orphan*/ cumtrapz(int *, double *, double *, double *);
double fabs(double);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ gradient(int *, int *, double *, double *, double *);
int /*<<< orphan*/ innerprod_q(int *, double *, double *, double *, double *);
double *malloc(int);
int /*<<< orphan*/ printf(char *, int, double);
int /*<<< orphan*/ pvecnorm2(int *, double *, double *, double *);
double sin(double);
int /*<<< orphan*/ spline(int, double *, double *, int, double *, double *);
double sqrt(double);
int /*<<< orphan*/ trapz(int *, int *, double *, double *, double *);
void fpls_warp_grad(int *m1, int *n1, double *ti, double *gami, double *qf,
                    double *qg, double *wf, double *wg, int *max_itri,
                    double *toli, double *deltai, int *displayi,
                    double *gamout) {
  int TT = *m1;
  int N = *n1, max_itr = *max_itri;
  double t = *ti, gam = *gami;
  double tol = *toli, delta = *deltai, display = *displayi;
  int k, j;
  int n2 = 1;
  int itr = 1;
  double tmp2 = 0;
  double N1 = N;
  double psi1[TT * N], gam2[TT * N], rfi_diff[TT], rgi_diff[TT], grad[TT],
      vec[TT], gamI[TT];
  double eps = DBL_EPSILON;
  double tmp[TT], psi2[TT * N], xout[TT], qf_tmp[TT * N], qg_tmp[TT * N];
  double binsize, rfi[N], rgi[N], qf_tmp_diff[TT * N], qg_tmp_diff[TT * N];
  double max_val[max_itr], tmpi, tmpj, gam1[TT * N];
  double res_cos, res_sin, max_val_change;
  double *tmp1 = malloc(sizeof(double) * (TT));
  double *qf_ptr, *qg_ptr, *gam_ptr, *psi_ptr, *gam2_ptr, *psi2_ptr;
  double *qf_tmp_ptr, *qg_tmp_ptr, *qf_tmp_diff_ptr, *qg_tmp_diff_ptr;
  double *xout_ptr, *tmp_ptr, *tmp1_ptr, *tmpi_ptr, *tmpj_ptr;
  double *grad_ptr, *rfi_ptr, *rgi_ptr, *gamI_ptr;
  binsize = 0;
  for (k = 0; k < TT - 1; k++)
    binsize += ti[k + 1] - ti[k];
  binsize = binsize / (TT - 1);
  for (k = 0; k < TT * N; k++) {
    gam1[k] = gami[k];
  }
  psi_ptr = psi1;
  gam_ptr = gam1;
  gradient(m1, n1, gam_ptr, &binsize, psi_ptr);
  for (k = 0; k < TT * N; k++)
    psi1[k] = sqrt(fabs(psi1[k]) + eps);
  do {
    qf_ptr = qf;
    qf_tmp_ptr = qf_tmp;
    qg_ptr = qg;
    qg_tmp_ptr = qg_tmp;
    qf_tmp_diff_ptr = qf_tmp_diff;
    qg_tmp_diff_ptr = qg_tmp_diff;
    for (k = 0; k < N; k++) {
      for (j = 0; j < TT; j++)
        xout[j] = (ti[TT - 1] - ti[0]) * gam_ptr[j] + ti[0];
      xout_ptr = xout;
      spline(TT, ti, qf_ptr, TT, xout_ptr, qf_tmp_ptr);
      spline(TT, ti, qg_ptr, TT, xout_ptr, qg_tmp_ptr);
      for (j = 0; j < TT; j++)
        tmp[j] = qf_tmp_ptr[j] * psi_ptr[j];
      tmp_ptr = tmp;
      innerprod_q(m1, ti, tmp_ptr, wf, &tmpi);
      rfi[k] = tmpi;
      for (j = 0; j < TT; j++)
        tmp[j] = qg_tmp_ptr[j] * psi_ptr[j];
      tmp_ptr = tmp;
      innerprod_q(m1, ti, tmp_ptr, wg, &tmpi);
      rgi[k] = tmpi;
      tmp_ptr = tmp;
      gradient(m1, &n2, qf_ptr, &binsize, tmp_ptr);
      spline(TT, ti, tmp_ptr, TT, xout_ptr, qf_tmp_diff_ptr);
      tmp_ptr = tmp;
      gradient(m1, &n2, qg_ptr, &binsize, tmp_ptr);
      spline(TT, ti, tmp_ptr, TT, xout_ptr, qg_tmp_diff_ptr);
      qf_ptr += TT;
      qf_tmp_ptr += TT;
      qg_ptr += TT;
      qg_tmp_ptr += TT;
      gam_ptr += TT;
      psi_ptr += TT;
      qf_tmp_diff_ptr += TT;
      qg_tmp_diff_ptr += TT;
    }
    psi_ptr = psi_ptr - TT * N;
    qf_tmp_diff_ptr = qf_tmp_diff;
    qg_tmp_diff_ptr = qg_tmp_diff;
    qg_tmp_ptr = qg_tmp;
    qf_tmp_ptr = qf_tmp;
    psi2_ptr = psi2;
    gam2_ptr = gam2;
    for (k = 0; k < N; k++) {
      tmp_ptr = tmp;
      for (j = 0; j < TT; j++)
        tmp_ptr[j] = qf_tmp_diff_ptr[j] * psi_ptr[j] * wf[j];
      tmp1_ptr = tmp1;
      tmpi_ptr = &tmpi;
      trapz(&TT, &n2, ti, tmp_ptr, tmpi_ptr);
      cumtrapz(&TT, ti, tmp_ptr, tmp1_ptr);
      for (j = 0; j < TT; j++)
        tmp1[j] = tmpi - tmp1[j];
      for (j = 0; j < TT; j++)
        rfi_diff[j] = 2 * psi_ptr[j] * tmp1[j] + qf_tmp_ptr[j] * wf[j];
      tmp_ptr = tmp;
      for (j = 0; j < TT; j++)
        tmp_ptr[j] = qg_tmp_diff_ptr[j] * psi_ptr[j] * wg[j];
      tmp1_ptr = tmp1;
      tmpi_ptr = &tmpi;
      trapz(&TT, &n2, ti, tmp_ptr, tmpi_ptr);
      cumtrapz(&TT, ti, tmp_ptr, tmp1_ptr);
      for (j = 0; j < TT; j++)
        tmp1[j] = tmpi - tmp1[j];
      for (j = 0; j < TT; j++)
        rgi_diff[j] = 2 * psi_ptr[j] * tmp1[j] + qg_tmp_ptr[j] * wg[j];
      tmpi = 0;
      tmpj = 0;
      for (j = 0; j < N; j++) {
        if (j == k)
          continue;
        tmpi += rfi[j];
        tmpj += rgi[j];
      }
      for (j = 0; j < TT; j++)
        grad[j] = 1 / N1 * rfi_diff[j] * rgi[k] +
                  1 / N1 * rfi[k] * rgi_diff[j] -
                  1 / (N1 * N1) * rfi_diff[j] * rgi[k] -
                  1 / (N1 * N1) * rfi[k] * rgi_diff[j] -
                  1 / (N1 * N1) * rfi_diff[j] * tmpj -
                  1 / (N1 * N1) * rgi_diff[j] * tmpi;
      grad_ptr = grad;
      tmpi_ptr = &tmpi;
      innerprod_q(m1, ti, grad_ptr, psi_ptr, tmpi_ptr);
      for (j = 0; j < TT; j++)
        vec[j] = grad[j] - tmpi * psi_ptr[j];
      pvecnorm2(&TT, vec, &binsize, &tmpi);
      res_cos = cos(delta * tmpi);
      res_sin = sin(delta * tmpi);
      for (j = 0; j < TT; j++)
        psi2_ptr[j] = res_cos * psi_ptr[j] + res_sin * (vec[j] / tmpi);
      innerprod_q(m1, ti, psi2_ptr, psi2_ptr, &tmpi);
      for (j = 0; j < TT; j++)
        psi2_ptr[j] = psi2_ptr[j] / tmpi;
      for (j = 0; j < TT; j++)
        tmp1[j] = psi2_ptr[j] * psi2_ptr[j];
      tmp1_ptr = tmp1;
      cumtrapz(&TT, ti, tmp1_ptr, gam2_ptr);
      for (j = 0; j < TT; j++)
        gam2_ptr[j] =
            (gam2_ptr[j] - gam2_ptr[0]) / (gam2_ptr[TT - 1] - gam2_ptr[0]);
      qf_tmp_diff_ptr += TT;
      qg_tmp_diff_ptr += TT;
      psi_ptr += TT;
      qf_tmp_ptr += TT;
      qg_tmp_ptr += TT;
      psi2_ptr += TT;
      gam2_ptr += TT;
    }
    rfi_ptr = rfi;
    rgi_ptr = rgi;
    tmpi_ptr = &tmpi;
    cov(N, rfi_ptr, rgi_ptr, tmpi_ptr);
    max_val[itr] = tmpi;
    if (display == 1)
      printf("Iteration %d : Cost %f\n", itr, max_val[itr]);
    gam_ptr = gam2;
    psi_ptr = psi2;
    if (itr >= 2) {
      max_val_change = max_val[itr] - max_val[itr - 1];
      if (fabs(max_val_change) < tol)
        break;
      if (max_val_change < 0)
        break;
    }
    itr++;
  } while (max_itr > itr);
  for (k = 0; k < TT * N; k++) {
    gamout[k] = gam_ptr[k];
  }
  free(tmp1);
}


x86 assembly (clang, -O0):
<fpls_warp_grad>:
push   %rbp
mov    %rsp,%rbp
sub    $0x280,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    0x38(%rbp),%rax
cvtsi2sdl (%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x1,-0x74(%rbp)
movl   $0x1,-0x78(%rbp)
movq   $0x0,-0x80(%rbp)
cvtsi2sdl -0x38(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   %ecx,%eax
mov    %rsp,%rcx
mov    %rcx,-0x90(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x280(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x98(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   %ecx,%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x278(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa0(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x270(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa8(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x268(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xb0(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x260(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xb8(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x258(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xc0(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,%rsp
mov    %rax,-0xc8(%rbp)
mov    0x3c3a(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x250(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xd8(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   %ecx,%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x248(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xe0(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x240(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xe8(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   %ecx,%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x238(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf0(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   %ecx,%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x230(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf8(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x228(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x108(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x220(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x110(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   %ecx,%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x218(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x118(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   %ecx,%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x210(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x120(%rbp)
mov    -0x3c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x208(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x128(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x38(%rbp),%ecx
imul   %ecx,%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x200(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x140(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x160(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    15f6 <fpls_warp_grad+0x426>
mov    -0x18(%rbp),%rax
mov    -0x6c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    15a8 <fpls_warp_grad+0x3d8>
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    1658 <fpls_warp_grad+0x488>
mov    -0x200(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x6c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    161b <fpls_warp_grad+0x44b>
mov    -0x200(%rbp),%rax
mov    -0x280(%rbp),%rcx
mov    %rcx,-0x180(%rbp)
mov    %rax,-0x178(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x178(%rbp),%rdx
mov    -0x180(%rbp),%r8
lea    -0x100(%rbp),%rcx
call   10a0 <gradient@plt>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    16f5 <fpls_warp_grad+0x525>
mov    -0x280(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x194a(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xd0(%rbp),%xmm0
ff
call   10e0 <sqrt@plt>
mov    -0x280(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    169d <fpls_warp_grad+0x4cd>
jmp    16fa <fpls_warp_grad+0x52a>
mov    -0x210(%rbp),%rax
mov    -0x218(%rbp),%rcx
mov    -0x230(%rbp),%rdx
mov    -0x238(%rbp),%rsi
mov    -0x28(%rbp),%rdi
mov    %rdi,-0x168(%rbp)
mov    %rsi,-0x198(%rbp)
mov    -0x30(%rbp),%rsi
mov    %rsi,-0x170(%rbp)
mov    %rdx,-0x1a0(%rbp)
mov    %rcx,-0x1a8(%rbp)
mov    %rax,-0x1b0(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1ad6 <fpls_warp_grad+0x906>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    17c6 <fpls_warp_grad+0x5f6>
mov    -0x240(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x18(%rbp),%rcx
subsd  (%rcx),%xmm0
mov    -0x178(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mov    -0x18(%rbp),%rcx
movsd  (%rcx),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1762 <fpls_warp_grad+0x592>
mov    -0x240(%rbp),%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x34(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x168(%rbp),%rdx
mov    -0x34(%rbp),%ecx
mov    -0x1b8(%rbp),%r8
mov    -0x198(%rbp),%r9
call   10f0 <spline@plt>
mov    -0x34(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x170(%rbp),%rdx
mov    -0x34(%rbp),%ecx
mov    -0x1b8(%rbp),%r8
mov    -0x1a0(%rbp),%r9
call   10f0 <spline@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    186d <fpls_warp_grad+0x69d>
mov    -0x250(%rbp),%rax
mov    -0x198(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x180(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1823 <fpls_warp_grad+0x653>
mov    -0x250(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c0(%rbp),%rdx
mov    0x10(%rbp),%rcx
lea    -0x130(%rbp),%r8
call   10c0 <innerprod_q@plt>
mov    -0x228(%rbp),%rax
movsd  -0x130(%rbp),%xmm0
ff
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1903 <fpls_warp_grad+0x733>
mov    -0x250(%rbp),%rax
mov    -0x1a0(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x180(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    18b9 <fpls_warp_grad+0x6e9>
mov    -0x250(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c0(%rbp),%rdx
mov    0x18(%rbp),%rcx
lea    -0x130(%rbp),%r8
call   10c0 <innerprod_q@plt>
mov    -0x220(%rbp),%rcx
mov    -0x250(%rbp),%rax
movsd  -0x130(%rbp),%xmm0
ff
movslq -0x6c(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
mov    %rax,-0x1c0(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x168(%rbp),%rdx
mov    -0x1c0(%rbp),%r8
lea    -0x74(%rbp),%rsi
lea    -0x100(%rbp),%rcx
call   10a0 <gradient@plt>
mov    -0x34(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x1c0(%rbp),%rdx
mov    -0x34(%rbp),%ecx
mov    -0x1b8(%rbp),%r8
mov    -0x1a8(%rbp),%r9
call   10f0 <spline@plt>
mov    -0x250(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x170(%rbp),%rdx
mov    -0x1c0(%rbp),%r8
lea    -0x74(%rbp),%rsi
lea    -0x100(%rbp),%rcx
call   10a0 <gradient@plt>
mov    -0x34(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x1c0(%rbp),%rdx
mov    -0x34(%rbp),%ecx
mov    -0x1b8(%rbp),%r8
mov    -0x1b0(%rbp),%r9
call   10f0 <spline@plt>
mov    -0x34(%rbp),%ecx
mov    -0x168(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x168(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x198(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x198(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x170(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x170(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x1a0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x178(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x178(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x180(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x180(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x1a8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x1b0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    174f <fpls_warp_grad+0x57f>
mov    -0x278(%rbp),%rax
mov    -0x248(%rbp),%rcx
mov    -0x238(%rbp),%rdx
mov    -0x230(%rbp),%rsi
mov    -0x210(%rbp),%rdi
mov    -0x218(%rbp),%r8
mov    -0x180(%rbp),%r9
mov    -0x34(%rbp),%r10d
imul   -0x38(%rbp),%r10d
movslq %r10d,%r11
xor    %r10d,%r10d
sub    %r11,%r10
shl    $0x3,%r10
add    %r10,%r9
mov    %r9,-0x180(%rbp)
mov    %r8,-0x1a8(%rbp)
mov    %rdi,-0x1b0(%rbp)
mov    %rsi,-0x1a0(%rbp)
mov    %rdx,-0x198(%rbp)
mov    %rcx,-0x190(%rbp)
mov    %rax,-0x188(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    246c <fpls_warp_grad+0x129c>
mov    -0x250(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1bd0 <fpls_warp_grad+0xa00>
mov    -0x1a8(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x180(%rbp),%rax
movslq -0x70(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x1c0(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1b79 <fpls_warp_grad+0x9a9>
mov    -0x160(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
lea    -0x130(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x1c0(%rbp),%rcx
mov    -0x1d0(%rbp),%r8
lea    -0x34(%rbp),%rdi
lea    -0x74(%rbp),%rsi
call   1070 <trapz@plt>
mov    -0x18(%rbp),%rsi
mov    -0x1c0(%rbp),%rdx
mov    -0x1c8(%rbp),%rcx
lea    -0x34(%rbp),%rdi
call   1060 <cumtrapz@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1c6f <fpls_warp_grad+0xa9f>
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x160(%rbp),%rax
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x160(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1c2d <fpls_warp_grad+0xa5d>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1ced <fpls_warp_grad+0xb1d>
mov    -0x270(%rbp),%rax
mov    -0x180(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  0x136c(%rip),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
mov    -0x160(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mov    -0x198(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm1
mov    0x10(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1c76 <fpls_warp_grad+0xaa6>
mov    -0x250(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1d59 <fpls_warp_grad+0xb89>
mov    -0x1b0(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x180(%rbp),%rax
movslq -0x70(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x1c0(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1d02 <fpls_warp_grad+0xb32>
mov    -0x160(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
lea    -0x130(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x18(%rbp),%rdx
mov    -0x1c0(%rbp),%rcx
mov    -0x1d0(%rbp),%r8
lea    -0x34(%rbp),%rdi
lea    -0x74(%rbp),%rsi
call   1070 <trapz@plt>
mov    -0x18(%rbp),%rsi
mov    -0x1c0(%rbp),%rdx
mov    -0x1c8(%rbp),%rcx
lea    -0x34(%rbp),%rdi
call   1060 <cumtrapz@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1df8 <fpls_warp_grad+0xc28>
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x160(%rbp),%rax
movslq -0x70(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x160(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1db6 <fpls_warp_grad+0xbe6>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1e76 <fpls_warp_grad+0xca6>
mov    -0x268(%rbp),%rax
mov    -0x180(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  0x11e3(%rip),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
mov    -0x160(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mov    -0x1a0(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm1
mov    0x18(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1dff <fpls_warp_grad+0xc2f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1efe <fpls_warp_grad+0xd2e>
mov    -0x70(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jne    1eb0 <fpls_warp_grad+0xce0>
jmp    1ef0 <fpls_warp_grad+0xd20>
mov    -0x220(%rbp),%rax
mov    -0x228(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
addsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1e93 <fpls_warp_grad+0xcc3>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    20cf <fpls_warp_grad+0xeff>
mov    -0x260(%rbp),%rax
mov    -0x268(%rbp),%rcx
mov    -0x270(%rbp),%rdx
mov    -0x228(%rbp),%rsi
mov    -0x220(%rbp),%rdi
movsd  0x10c4(%rip),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movslq -0x70(%rbp),%r8
mulsd  (%rdx,%r8,8),%xmm0
movslq -0x6c(%rbp),%r8
movsd  (%rdi,%r8,8),%xmm2
movsd  0x10a0(%rip),%xmm1
divsd  -0x88(%rbp),%xmm1
ff
movslq -0x6c(%rbp),%r8
mulsd  (%rsi,%r8,8),%xmm1
movslq -0x70(%rbp),%r8
mulsd  (%rcx,%r8,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mulsd  -0x88(%rbp),%xmm2
ff
movsd  0x1064(%rip),%xmm1
divsd  %xmm2,%xmm1
movslq -0x70(%rbp),%r8
mulsd  (%rdx,%r8,8),%xmm1
movslq -0x6c(%rbp),%r8
movsd  (%rdi,%r8,8),%xmm2
movq   %xmm1,%rdi
movabs $0x8000000000000000,%r8
xor    %r8,%rdi
movq   %rdi,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm2
ff
mulsd  -0x88(%rbp),%xmm2
ff
movsd  0x1015(%rip),%xmm0
divsd  %xmm2,%xmm0
movslq -0x6c(%rbp),%rdi
mulsd  (%rsi,%rdi,8),%xmm0
movslq -0x70(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm2
movq   %xmm0,%rsi
movabs $0x8000000000000000,%rdi
xor    %rdi,%rsi
movq   %rsi,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x88(%rbp),%xmm2
ff
mulsd  -0x88(%rbp),%xmm2
ff
movsd  0xfc8(%rip),%xmm1
divsd  %xmm2,%xmm1
movslq -0x70(%rbp),%rsi
mulsd  (%rdx,%rsi,8),%xmm1
movsd  -0x138(%rbp),%xmm2
ff
movq   %xmm1,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm2
ff
mulsd  -0x88(%rbp),%xmm2
ff
movsd  0xf7c(%rip),%xmm0
divsd  %xmm2,%xmm0
movslq -0x70(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movsd  -0x130(%rbp),%xmm2
ff
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1f05 <fpls_warp_grad+0xd35>
mov    -0x260(%rbp),%rax
mov    %rax,-0x1e0(%rbp)
lea    -0x130(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1e0(%rbp),%rdx
mov    -0x180(%rbp),%rcx
mov    -0x1d0(%rbp),%r8
call   10c0 <innerprod_q@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2185 <fpls_warp_grad+0xfb5>
mov    -0x258(%rbp),%rax
mov    -0x260(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm1
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x180(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    2114 <fpls_warp_grad+0xf44>
mov    -0x258(%rbp),%rsi
lea    -0x34(%rbp),%rdi
lea    -0x100(%rbp),%rdx
lea    -0x130(%rbp),%rcx
call   1090 <pvecnorm2@plt>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x130(%rbp),%xmm0
ff
call   10d0 <cos@plt>
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mulsd  -0x130(%rbp),%xmm0
ff
call   1080 <sin@plt>
movsd  %xmm0,-0x150(%rbp)
ff
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    224c <fpls_warp_grad+0x107c>
mov    -0x258(%rbp),%rax
movsd  -0x148(%rbp),%xmm0
ff
mov    -0x180(%rbp),%rcx
movslq -0x70(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
movsd  -0x150(%rbp),%xmm1
ff
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
divsd  -0x130(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x190(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    21de <fpls_warp_grad+0x100e>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x190(%rbp),%rdx
mov    -0x190(%rbp),%rcx
lea    -0x130(%rbp),%r8
call   10c0 <innerprod_q@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    22b7 <fpls_warp_grad+0x10e7>
mov    -0x190(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x130(%rbp),%xmm0
ff
mov    -0x190(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    2275 <fpls_warp_grad+0x10a5>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2308 <fpls_warp_grad+0x1138>
mov    -0x190(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x190(%rbp),%rax
movslq -0x70(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x160(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    22be <fpls_warp_grad+0x10ee>
mov    -0x160(%rbp),%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x18(%rbp),%rsi
mov    -0x1c8(%rbp),%rdx
mov    -0x188(%rbp),%rcx
lea    -0x34(%rbp),%rdi
call   1060 <cumtrapz@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    23a1 <fpls_warp_grad+0x11d1>
mov    -0x188(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x188(%rbp),%rax
subsd  (%rax),%xmm0
mov    -0x188(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x188(%rbp),%rax
subsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x188(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    2338 <fpls_warp_grad+0x1168>
mov    -0x34(%rbp),%ecx
mov    -0x1a8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x1b0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x180(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x180(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x198(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x198(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x1a0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x190(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x190(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x188(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x188(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1b58 <fpls_warp_grad+0x988>
mov    -0x220(%rbp),%rax
mov    -0x228(%rbp),%rcx
mov    %rcx,-0x1e8(%rbp)
mov    %rax,-0x1f0(%rbp)
lea    -0x130(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x38(%rbp),%edi
mov    -0x1e8(%rbp),%rsi
mov    -0x1f0(%rbp),%rdx
mov    -0x1d0(%rbp),%rcx
call   1040 <cov@plt>
mov    -0x208(%rbp),%rax
movsd  -0x130(%rbp),%xmm0
ff
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  0xb28(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2507 <fpls_warp_grad+0x1337>
jp     2507 <fpls_warp_grad+0x1337>
mov    -0x208(%rbp),%rax
mov    -0x78(%rbp),%esi
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xb1e(%rip),%rdi
call   1050 <printf@plt>
mov    -0x248(%rbp),%rax
mov    -0x278(%rbp),%rcx
mov    %rcx,-0x178(%rbp)
mov    %rax,-0x180(%rbp)
cmpl   $0x2,-0x78(%rbp)
jl     2595 <fpls_warp_grad+0x13c5>
mov    -0x208(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x158(%rbp),%xmm1
ff
movaps 0xaae(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    257a <fpls_warp_grad+0x13aa>
jmp    25aa <fpls_warp_grad+0x13da>
xorps  %xmm0,%xmm0
ucomisd -0x158(%rbp),%xmm0
ff
jbe    2590 <fpls_warp_grad+0x13c0>
jmp    25aa <fpls_warp_grad+0x13da>
jmp    2595 <fpls_warp_grad+0x13c5>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     16fa <fpls_warp_grad+0x52a>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    25ee <fpls_warp_grad+0x141e>
mov    -0x178(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    25b1 <fpls_warp_grad+0x13e1>
mov    -0x160(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fpls_warp_grad>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r9,-0x170(%rbp)
mov    %r8,-0x168(%rbp)
mov    %rcx,-0x70(%rbp)
mov    %rdx,-0x58(%rbp)
mov    %rdi,%r15
mov    %rsp,-0x158(%rbp)
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    0x28(%rbp),%rdx
mov    0x20(%rbp),%rbx
mov    (%rdi),%r12d
mov    %r12d,-0x2c(%rbp)
mov    %rsi,-0x50(%rbp)
mov    (%rsi),%edi
mov    (%rbx),%esi
movsd  (%rdx),%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  (%rcx),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    (%rax),%eax
mov    %eax,-0x104(%rbp)
movl   $0x1,-0x84(%rbp)
mov    %edi,%r13d
imul   %r12d,%r13d
lea    0xf(,%r13,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,%r14
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0xd0(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rdx
lea    0xf(,%r12,8),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%rdx
mov    %rdx,-0xc8(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0xb0(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0xc0(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x148(%rbp)
mov    %rdx,%rsp
mov    0x4d09(%rip),%rdx
movsd  (%rdx),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x80(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rax,%rdx
mov    %rdx,-0xf8(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x140(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x130(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x128(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rdx
mov    %rdi,-0x68(%rbp)
lea    0xf(,%rdi,8),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%rdx
mov    %rdx,-0xd8(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x60(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x120(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x118(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rdx
mov    %rsi,-0x110(%rbp)
lea    0xf(,%rsi,8),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%rdx
mov    %rdx,-0x138(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0xb8(%rbp)
mov    %rcx,%rsp
lea    0x0(,%r12,8),%edi
call   10c0 <malloc@plt>
lea    -0x1(%r12),%ebx
xorpd  %xmm0,%xmm0
cmp    $0x2,%r12d
jl     148e <fpls_warp_grad+0x2ae>
mov    %ebx,%esi
mov    -0x58(%rbp),%rdi
movsd  (%rdi),%xmm1
lea    -0x1(%rsi),%rdx
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x3,%rdx
jae    13f9 <fpls_warp_grad+0x219>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
jmp    1459 <fpls_warp_grad+0x279>
and    $0xfffffffc,%esi
xorpd  %xmm0,%xmm0
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x8(%rdi,%rdx,8),%xmm2
movsd  0x10(%rdi,%rdx,8),%xmm3
movsd  0x18(%rdi,%rdx,8),%xmm4
movapd %xmm4,%xmm5
subsd  %xmm3,%xmm5
subsd  %xmm2,%xmm3
subsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm5
movsd  0x20(%rdi,%rdx,8),%xmm1
add    $0x4,%rdx
movapd %xmm1,%xmm0
subsd  %xmm4,%xmm0
addsd  %xmm5,%xmm0
cmp    %rdx,%rsi
jne    1410 <fpls_warp_grad+0x230>
test   %rcx,%rcx
je     148e <fpls_warp_grad+0x2ae>
mov    -0x58(%rbp),%rsi
lea    (%rsi,%rdx,8),%rdx
add    $0x8,%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  (%rdx,%rsi,8),%xmm2
movapd %xmm2,%xmm3
subsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
add    $0x1,%rsi
movapd %xmm2,%xmm1
cmp    %rsi,%rcx
jne    1470 <fpls_warp_grad+0x290>
mov    %rax,-0x40(%rbp)
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
test   %r13d,%r13d
mov    -0xb8(%rbp),%rbx
jle    14c4 <fpls_warp_grad+0x2e4>
shl    $0x3,%r13
mov    %rbx,%rdi
mov    -0x70(%rbp),%rsi
mov    %r13,%rdx
call   1090 <memcpy@plt>
mov    -0x68(%rbp),%r12
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
movsd  %xmm0,-0x70(%rbp)
lea    -0xe0(%rbp),%rcx
mov    %r15,-0x100(%rbp)
mov    %r15,%rdi
mov    -0x50(%rbp),%rsi
mov    %rbx,%rdx
mov    %r14,%r15
mov    %r14,%r8
call   10b0 <gradient@plt>
mov    %r12,%rdi
mov    -0x2c(%rbp),%eax
imul   %edi,%eax
test   %eax,%eax
mov    -0x60(%rbp),%rdx
jle    1571 <fpls_warp_grad+0x391>
movslq %edi,%r12
xor    %r13d,%r13d
movapd 0x2ae9(%rip),%xmm1
xorpd  %xmm2,%xmm2
jmp    1553 <fpls_warp_grad+0x373>
nopl   (%rax)
call   10f0 <sqrt@plt>
xorpd  %xmm2,%xmm2
movapd 0x2acf(%rip),%xmm1
mov    -0x60(%rbp),%rdx
mov    -0x68(%rbp),%rdi
mov    %r14,%r15
movsd  %xmm0,(%r14,%r13,8)
add    $0x1,%r13
movslq -0x2c(%rbp),%rax
imul   %r12,%rax
cmp    %rax,%r13
jge    1571 <fpls_warp_grad+0x391>
movsd  (%r15,%r13,8),%xmm0
andpd  %xmm1,%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm2,%xmm0
jb     1520 <fpls_warp_grad+0x340>
sqrtsd %xmm0,%xmm0
jmp    1539 <fpls_warp_grad+0x359>
movsd  0x2aa7(%rip),%xmm0
movsd  -0x70(%rbp),%xmm2
divsd  %xmm2,%xmm0
movapd %xmm0,-0x1a0(%rbp)
ff
mulsd  %xmm2,%xmm2
movsd  0x2a92(%rip),%xmm1
divsd  %xmm2,%xmm1
movapd %xmm1,-0x190(%rbp)
ff
mov    %edi,%eax
and    $0xfffffffe,%eax
mov    %rax,-0x180(%rbp)
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
unpcklpd %xmm1,%xmm1
movapd %xmm1,-0x1b0(%rbp)
ff
mov    $0x1,%r12d
mov    %r15,%r14
mov    -0xd8(%rbp),%r13
mov    -0xb8(%rbp),%rbx
movapd %xmm2,-0x1c0(%rbp)
ff
jmp    1617 <fpls_warp_grad+0x437>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12d
mov    -0xd0(%rbp),%rbx
mov    -0xf8(%rbp),%r14
cmp    %r12d,-0x110(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x60(%rbp),%rdx
jle    31ad <fpls_warp_grad+0x1fcd>
mov    %r12,-0x178(%rbp)
test   %edi,%edi
jle    30f0 <fpls_warp_grad+0x1f10>
mov    -0x2c(%rbp),%ecx
xor    %eax,%eax
mov    %rax,-0xa0(%rbp)
mov    -0x168(%rbp),%rdx
mov    -0x170(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x118(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x120(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x128(%rbp),%r12
mov    -0x130(%rbp),%r13
mov    -0x140(%rbp),%r15
jmp    1796 <fpls_warp_grad+0x5b6>
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %r14,%rbx
mov    -0x58(%rbp),%r15
mov    %r15,%rsi
lea    -0x38(%rbp),%r8
mov    %rdx,%r14
call   10d0 <innerprod_q@plt>
movsd  -0x38(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    %rbx,%rdi
lea    -0x84(%rbp),%rsi
mov    -0xa8(%rbp),%rdx
lea    -0xe0(%rbp),%rcx
mov    %r14,%r8
call   10b0 <gradient@plt>
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edi
mov    %r15,%rsi
mov    %r14,%rdx
mov    -0x140(%rbp),%r15
mov    %r15,%r8
mov    -0x70(%rbp),%r9
call   1100 <spline@plt>
mov    %rbx,%rdi
lea    -0x84(%rbp),%rsi
mov    -0x50(%rbp),%rbx
mov    %rbx,%rdx
lea    -0xe0(%rbp),%rcx
mov    %r14,%r8
call   10b0 <gradient@plt>
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edi
mov    -0x58(%rbp),%rsi
mov    %r14,%rdx
mov    %r15,%r8
mov    -0xf0(%rbp),%r14
mov    %r14,%r9
call   1100 <spline@plt>
mov    -0xa8(%rbp),%rdx
movslq -0x2c(%rbp),%rcx
lea    (%rdx,%rcx,8),%rdx
lea    0x0(%r13,%rcx,8),%r13
lea    (%rbx,%rcx,8),%rbx
mov    %rbx,-0x50(%rbp)
lea    (%r12,%rcx,8),%r12
mov    -0xb8(%rbp),%rbx
lea    (%rbx,%rcx,8),%rbx
mov    -0x78(%rbp),%rdi
lea    (%rdi,%rcx,8),%rdi
mov    -0x70(%rbp),%rsi
lea    (%rsi,%rcx,8),%rsi
mov    %rsi,-0x70(%rbp)
lea    (%r14,%rcx,8),%r14
mov    %r14,-0xf0(%rbp)
mov    %rdi,%r14
mov    -0xa0(%rbp),%rsi
add    $0x1,%rsi
mov    -0x68(%rbp),%rdi
mov    %rsi,-0xa0(%rbp)
cmp    %rdi,%rsi
je     1b80 <fpls_warp_grad+0x9a0>
mov    %r14,-0x78(%rbp)
test   %ecx,%ecx
jle    18bc <fpls_warp_grad+0x6dc>
lea    -0x1(%rcx),%eax
mov    -0x58(%rbp),%rsi
movsd  (%rsi,%rax,8),%xmm0
movsd  (%rsi),%xmm1
subsd  %xmm1,%xmm0
mov    %ecx,%r9d
cmp    $0x4,%ecx
jae    17d0 <fpls_warp_grad+0x5f0>
xor    %eax,%eax
jmp    18a0 <fpls_warp_grad+0x6c0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9d,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
lea    -0x4(%rax),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1b4e <fpls_warp_grad+0x96e>
mov    %r8,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
movupd (%rbx,%rsi,8),%xmm4
movupd 0x10(%rbx,%rsi,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm4,(%r15,%rsi,8)
movapd %xmm5,0x10(%r15,%rsi,8)
movupd 0x20(%rbx,%rsi,8),%xmm4
movupd 0x30(%rbx,%rsi,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm4,0x20(%r15,%rsi,8)
movapd %xmm5,0x30(%r15,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1810 <fpls_warp_grad+0x630>
test   $0x1,%r8b
je     189a <fpls_warp_grad+0x6ba>
movupd (%rbx,%rsi,8),%xmm4
movupd 0x10(%rbx,%rsi,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm4,(%r15,%rsi,8)
movapd %xmm5,0x10(%r15,%rsi,8)
cmp    %r9,%rax
je     18bc <fpls_warp_grad+0x6dc>
nop
movsd  (%rbx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r15,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    18a0 <fpls_warp_grad+0x6c0>
mov    %rbx,-0xb8(%rbp)
mov    %ecx,%edi
mov    -0x58(%rbp),%r14
mov    %r14,%rsi
mov    %rdx,-0xa8(%rbp)
mov    %r15,%r8
mov    %r13,%r9
call   1100 <spline@plt>
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edi
mov    %r14,%rsi
mov    -0x50(%rbp),%rdx
mov    %r15,%r8
mov    %r12,%r9
call   1100 <spline@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
mov    -0x100(%rbp),%r14
mov    -0x80(%rbp),%rdx
mov    -0x78(%rbp),%rbx
jle    1a0a <fpls_warp_grad+0x82a>
cmp    $0x4,%eax
jae    1920 <fpls_warp_grad+0x740>
xor    %ecx,%ecx
jmp    19f0 <fpls_warp_grad+0x810>
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1b5f <fpls_warp_grad+0x97f>
mov    %r8,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
nop
movupd 0x0(%r13,%rsi,8),%xmm0
movupd 0x10(%r13,%rsi,8),%xmm1
movupd (%rbx,%rsi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,(%rdx,%rsi,8)
movapd %xmm0,0x10(%rdx,%rsi,8)
movupd 0x20(%r13,%rsi,8),%xmm0
movupd 0x30(%r13,%rsi,8),%xmm1
movupd 0x20(%rbx,%rsi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rbx,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,0x20(%rdx,%rsi,8)
movapd %xmm0,0x30(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1950 <fpls_warp_grad+0x770>
test   $0x1,%r8b
je     19e6 <fpls_warp_grad+0x806>
movupd 0x0(%r13,%rsi,8),%xmm0
movupd 0x10(%r13,%rsi,8),%xmm1
movupd (%rbx,%rsi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,(%rdx,%rsi,8)
movapd %xmm0,0x10(%rdx,%rsi,8)
cmp    %rax,%rcx
je     1a0a <fpls_warp_grad+0x82a>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rcx,8),%xmm0
mulsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    19f0 <fpls_warp_grad+0x810>
mov    %r14,%rdi
mov    -0x58(%rbp),%rsi
mov    0x10(%rbp),%rcx
lea    -0x38(%rbp),%r8
call   10d0 <innerprod_q@plt>
mov    -0x80(%rbp),%rdx
movsd  -0x38(%rbp),%xmm0
mov    -0xd8(%rbp),%rax
mov    -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%r9d
test   %r9d,%r9d
mov    0x18(%rbp),%rcx
jle    1680 <fpls_warp_grad+0x4a0>
cmp    $0x4,%r9d
jae    1a60 <fpls_warp_grad+0x880>
xor    %eax,%eax
jmp    1b30 <fpls_warp_grad+0x950>
nopl   0x0(%rax,%rax,1)
mov    %r9d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1b70 <fpls_warp_grad+0x990>
mov    %r8,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
movupd (%r12,%rsi,8),%xmm0
movupd 0x10(%r12,%rsi,8),%xmm1
movupd (%rbx,%rsi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,(%rdx,%rsi,8)
movapd %xmm0,0x10(%rdx,%rsi,8)
movupd 0x20(%r12,%rsi,8),%xmm0
movupd 0x30(%r12,%rsi,8),%xmm1
movupd 0x20(%rbx,%rsi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rbx,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,0x20(%rdx,%rsi,8)
movapd %xmm0,0x30(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1a90 <fpls_warp_grad+0x8b0>
test   $0x1,%r8b
je     1b24 <fpls_warp_grad+0x944>
movupd (%r12,%rsi,8),%xmm0
movupd 0x10(%r12,%rsi,8),%xmm1
movupd (%rbx,%rsi,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,(%rdx,%rsi,8)
movapd %xmm0,0x10(%rdx,%rsi,8)
cmp    %r9,%rax
je     1680 <fpls_warp_grad+0x4a0>
nopl   (%rax)
movsd  (%r12,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    1b30 <fpls_warp_grad+0x950>
jmp    1680 <fpls_warp_grad+0x4a0>
xor    %esi,%esi
test   $0x1,%r8b
jne    1872 <fpls_warp_grad+0x692>
jmp    189a <fpls_warp_grad+0x6ba>
xor    %esi,%esi
test   $0x1,%r8b
jne    19ba <fpls_warp_grad+0x7da>
jmp    19e6 <fpls_warp_grad+0x806>
xor    %esi,%esi
test   $0x1,%r8b
jne    1af9 <fpls_warp_grad+0x919>
jmp    1b24 <fpls_warp_grad+0x944>
nopw   0x0(%rax,%rax,1)
test   %edi,%edi
mov    -0x80(%rbp),%r11
mov    -0xd8(%rbp),%r13
mov    -0x60(%rbp),%rdx
jle    30f0 <fpls_warp_grad+0x1f10>
mov    %ecx,%eax
imul   %edi,%eax
cltq
shl    $0x3,%rax
sub    %rax,%r14
xor    %r9d,%r9d
mov    -0x118(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x120(%rbp),%rsi
mov    -0x128(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x130(%rbp),%r10
mov    -0xf8(%rbp),%r15
mov    -0xd0(%rbp),%r12
jmp    1c26 <fpls_warp_grad+0xa46>
nop
mov    -0xa8(%rbp),%rsi
lea    (%rsi,%rcx,8),%rsi
mov    -0xa0(%rbp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,-0xa0(%rbp)
lea    (%r14,%rcx,8),%r14
lea    (%r10,%rcx,8),%r10
mov    -0x78(%rbp),%rax
lea    (%rax,%rcx,8),%rax
mov    %rax,-0x78(%rbp)
lea    (%r15,%rcx,8),%r15
lea    (%r12,%rcx,8),%r12
add    $0x1,%r9
cmp    %rdi,%r9
je     30f0 <fpls_warp_grad+0x1f10>
mov    %r10,-0x50(%rbp)
mov    %r9,-0x70(%rbp)
test   %ecx,%ecx
mov    0x10(%rbp),%rbx
mov    %rsi,-0xa8(%rbp)
jle    1e40 <fpls_warp_grad+0xc60>
mov    %ecx,%eax
cmp    $0x4,%ecx
jae    1cc0 <fpls_warp_grad+0xae0>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%al
je     1c6e <fpls_warp_grad+0xa8e>
movsd  (%rsi,%rcx,8),%xmm0
mulsd  (%r14,%rcx,8),%xmm0
mulsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r11,%rcx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
add    %rax,%rcx
je     1e40 <fpls_warp_grad+0xc60>
nopw   0x0(%rax,%rax,1)
movsd  (%rsi,%rdx,8),%xmm0
mulsd  (%r14,%rdx,8),%xmm0
mulsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%r11,%rdx,8)
movsd  0x8(%rsi,%rdx,8),%xmm0
mulsd  0x8(%r14,%rdx,8),%xmm0
mulsd  0x8(%rbx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r11,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1c80 <fpls_warp_grad+0xaa0>
jmp    1e40 <fpls_warp_grad+0xc60>
xchg   %ax,%ax
lea    (%r11,%rax,8),%rdi
lea    (%rsi,%rax,8),%rcx
lea    (%r14,%rax,8),%rdx
lea    (%rbx,%rax,8),%r13
cmp    %rcx,%r11
setb   %r9b
cmp    %rdi,%rsi
setb   %r10b
cmp    %rdx,%r11
setb   %cl
cmp    %rdi,%r14
setb   %r8b
cmp    %r13,%r11
setb   %dl
cmp    %rbx,%rdi
seta   %sil
test   %r10b,%r9b
jne    302a <fpls_warp_grad+0x1e4a>
and    %r8b,%cl
jne    302a <fpls_warp_grad+0x1e4a>
mov    $0x0,%ecx
and    %sil,%dl
mov    -0xa8(%rbp),%rsi
jne    1c4a <fpls_warp_grad+0xa6a>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     3048 <fpls_warp_grad+0x1e68>
mov    %r8,%rdi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rdi
xor    %edx,%edx
xchg   %ax,%ax
movupd (%rsi,%rdx,8),%xmm0
movupd 0x10(%rsi,%rdx,8),%xmm1
movupd (%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd (%rbx,%rdx,8),%xmm1
mulpd  %xmm2,%xmm1
movupd 0x10(%rbx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,(%r11,%rdx,8)
movapd %xmm2,0x10(%r11,%rdx,8)
movupd 0x20(%rsi,%rdx,8),%xmm0
movupd 0x30(%rsi,%rdx,8),%xmm1
movupd 0x20(%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x20(%rbx,%rdx,8),%xmm1
mulpd  %xmm2,%xmm1
movupd 0x30(%rbx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,0x20(%r11,%rdx,8)
movapd %xmm2,0x30(%r11,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1d50 <fpls_warp_grad+0xb70>
test   $0x1,%r8b
je     1e28 <fpls_warp_grad+0xc48>
movupd (%rsi,%rdx,8),%xmm0
movupd 0x10(%rsi,%rdx,8),%xmm1
movupd (%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd (%rbx,%rdx,8),%xmm1
mulpd  %xmm2,%xmm1
movupd 0x10(%rbx,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,(%r11,%rdx,8)
movapd %xmm2,0x10(%r11,%rdx,8)
cmp    %rax,%rcx
jne    1c4a <fpls_warp_grad+0xa6a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x2c(%rbp),%rbx
mov    %rbx,%rdi
lea    -0x84(%rbp),%rsi
mov    -0x58(%rbp),%r13
mov    %r13,%rdx
mov    %r11,%rcx
lea    -0x38(%rbp),%r8
call   1070 <trapz@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    -0x80(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   1060 <cumtrapz@plt>
mov    -0x50(%rbp),%rbx
mov    -0x80(%rbp),%rcx
mov    -0x2c(%rbp),%r11d
test   %r11d,%r11d
mov    -0xc8(%rbp),%r10
mov    0x18(%rbp),%r9
mov    -0xa0(%rbp),%r13
jle    23b0 <fpls_warp_grad+0x11d0>
movsd  -0x38(%rbp),%xmm0
cmp    $0x4,%r11d
jae    1ec0 <fpls_warp_grad+0xce0>
xor    %eax,%eax
mov    -0x40(%rbp),%rdx
jmp    1f90 <fpls_warp_grad+0xdb0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r11d,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rax),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
mov    -0x40(%rbp),%rdx
je     2ff6 <fpls_warp_grad+0x1e16>
mov    %r8,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movupd (%rdx,%rsi,8),%xmm2
movupd 0x10(%rdx,%rsi,8),%xmm3
movupd 0x20(%rdx,%rsi,8),%xmm4
movupd 0x30(%rdx,%rsi,8),%xmm5
movapd %xmm1,%xmm6
subpd  %xmm2,%xmm6
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
movupd %xmm6,(%rdx,%rsi,8)
movupd %xmm2,0x10(%rdx,%rsi,8)
movapd %xmm1,%xmm2
subpd  %xmm4,%xmm2
movapd %xmm1,%xmm3
subpd  %xmm5,%xmm3
movupd %xmm2,0x20(%rdx,%rsi,8)
movupd %xmm3,0x30(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1f00 <fpls_warp_grad+0xd20>
test   $0x1,%r8b
je     1f80 <fpls_warp_grad+0xda0>
movupd (%rdx,%rsi,8),%xmm2
movupd 0x10(%rdx,%rsi,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
subpd  %xmm3,%xmm1
movupd %xmm4,(%rdx,%rsi,8)
movupd %xmm1,0x10(%rdx,%rsi,8)
cmp    %r11,%rax
je     1fa7 <fpls_warp_grad+0xdc7>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm0,%xmm1
subsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    1f90 <fpls_warp_grad+0xdb0>
test   %r11d,%r11d
jle    23b0 <fpls_warp_grad+0x11d0>
cmp    $0x4,%r11d
jae    2069 <fpls_warp_grad+0xe89>
xor    %r8d,%r8d
mov    -0x40(%rbp),%rdi
mov    0x10(%rbp),%rax
mov    %r8,%rdx
test   $0x1,%r11b
je     1ffb <fpls_warp_grad+0xe1b>
movsd  (%r14,%r8,8),%xmm0
addsd  %xmm0,%xmm0
movsd  (%rbx,%r8,8),%xmm1
mulsd  (%rax,%r8,8),%xmm1
mulsd  (%rdi,%r8,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%r8,8)
mov    %r8,%rdx
or     $0x1,%rdx
not    %r8
add    %r11,%r8
je     2190 <fpls_warp_grad+0xfb0>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rdx,8),%xmm0
movsd  (%rbx,%rdx,8),%xmm1
mulsd  (%rax,%rdx,8),%xmm1
addsd  %xmm0,%xmm0
mulsd  (%rdi,%rdx,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r10,%rdx,8)
movsd  0x8(%r14,%rdx,8),%xmm0
addsd  %xmm0,%xmm0
movsd  0x8(%rbx,%rdx,8),%xmm1
mulsd  0x8(%rax,%rdx,8),%xmm1
mulsd  0x8(%rdi,%rdx,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r10,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r11
jne    2010 <fpls_warp_grad+0xe30>
jmp    2190 <fpls_warp_grad+0xfb0>
lea    (%r10,%r11,8),%rdi
lea    (%r14,%r11,8),%rcx
mov    -0x40(%rbp),%rax
lea    (%rax,%r11,8),%rdx
lea    (%rbx,%r11,8),%r8
mov    0x10(%rbp),%r9
mov    %rbx,%rsi
lea    (%r9,%r11,8),%r13
cmp    %rcx,%r10
mov    %r10,%rbx
setb   %r10b
cmp    %rdi,%r14
setb   %r9b
cmp    %rdx,%rbx
setb   %cl
cmp    %rdi,%rax
setb   %al
cmp    %r8,%rbx
setb   %dl
cmp    %rdi,%rsi
setb   %r8b
cmp    %r13,%rbx
setb   %sil
cmp    0x10(%rbp),%rdi
seta   %bl
test   %r9b,%r10b
jne    3086 <fpls_warp_grad+0x1ea6>
and    %al,%cl
jne    3086 <fpls_warp_grad+0x1ea6>
and    %r8b,%dl
mov    -0xc8(%rbp),%r10
mov    -0x80(%rbp),%rcx
mov    -0x40(%rbp),%rdi
mov    0x18(%rbp),%r9
mov    0x10(%rbp),%rax
mov    -0xa0(%rbp),%r13
jne    30b0 <fpls_warp_grad+0x1ed0>
mov    $0x0,%r8d
and    %bl,%sil
mov    -0x50(%rbp),%rbx
jne    1fc5 <fpls_warp_grad+0xde5>
mov    %r11d,%r8d
and    $0xfffffffc,%r8d
lea    0x0(,%r11,8),%rdx
and    $0xffffffffffffffe0,%rdx
xor    %esi,%esi
movupd (%r14,%rsi,1),%xmm0
movupd 0x10(%r14,%rsi,1),%xmm1
addpd  %xmm0,%xmm0
addpd  %xmm1,%xmm1
movupd (%rdi,%rsi,1),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rdi,%rsi,1),%xmm0
mulpd  %xmm1,%xmm0
movupd (%rbx,%rsi,1),%xmm1
movupd 0x10(%rbx,%rsi,1),%xmm3
movupd (%rax,%rsi,1),%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rax,%rsi,1),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm4,(%r10,%rsi,1)
movapd %xmm1,0x10(%r10,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    2120 <fpls_warp_grad+0xf40>
cmp    %r11,%r8
jne    1fc5 <fpls_warp_grad+0xde5>
nopl   (%rax)
test   %r11d,%r11d
jle    23b0 <fpls_warp_grad+0x11d0>
cmp    $0x4,%r11d
jae    2221 <fpls_warp_grad+0x1041>
xor    %ebx,%ebx
mov    %rbx,%rdx
test   $0x1,%r11b
je     21cd <fpls_warp_grad+0xfed>
movsd  0x0(%r13,%rbx,8),%xmm0
mulsd  (%r14,%rbx,8),%xmm0
mulsd  (%r9,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
mov    %rbx,%rdx
or     $0x1,%rdx
not    %rbx
add    %r11,%rbx
je     23b0 <fpls_warp_grad+0x11d0>
nopl   0x0(%rax)
movsd  0x0(%r13,%rdx,8),%xmm0
mulsd  (%r14,%rdx,8),%xmm0
mulsd  (%r9,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x8(%r13,%rdx,8),%xmm0
mulsd  0x8(%r14,%rdx,8),%xmm0
mulsd  0x8(%r9,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r11
jne    21e0 <fpls_warp_grad+0x1000>
jmp    23b0 <fpls_warp_grad+0x11d0>
lea    (%rcx,%r11,8),%rsi
lea    0x0(,%r11,8),%rax
add    %r13,%rax
lea    (%r14,%r11,8),%rdx
lea    (%r9,%r11,8),%rdi
cmp    %rax,%rcx
mov    %r9,%rbx
setb   %r9b
cmp    %rsi,%r13
setb   %r10b
cmp    %rdx,%rcx
setb   %al
cmp    %rsi,%r14
setb   %r8b
cmp    %rdi,%rcx
setb   %dl
cmp    %rbx,%rsi
seta   %sil
test   %r10b,%r9b
jne    307b <fpls_warp_grad+0x1e9b>
and    %r8b,%al
jne    307b <fpls_warp_grad+0x1e9b>
mov    $0x0,%ebx
and    %sil,%dl
mov    0x18(%rbp),%r9
jne    21a5 <fpls_warp_grad+0xfc5>
mov    %r11d,%ebx
and    $0xfffffffc,%ebx
lea    -0x4(%rbx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     30de <fpls_warp_grad+0x1efe>
mov    %rsi,%rdi
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rdx,8),%xmm0
movupd 0x10(%r13,%rdx,8),%xmm1
movupd (%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd (%r9,%rdx,8),%xmm1
mulpd  %xmm2,%xmm1
movupd 0x10(%r9,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,(%rcx,%rdx,8)
movapd %xmm2,0x10(%rcx,%rdx,8)
movupd 0x20(%r13,%rdx,8),%xmm0
movupd 0x30(%r13,%rdx,8),%xmm1
movupd 0x20(%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd 0x20(%r9,%rdx,8),%xmm1
mulpd  %xmm2,%xmm1
movupd 0x30(%r9,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,0x20(%rcx,%rdx,8)
movapd %xmm2,0x30(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    22c0 <fpls_warp_grad+0x10e0>
test   $0x1,%sil
je     23a0 <fpls_warp_grad+0x11c0>
movupd 0x0(%r13,%rdx,8),%xmm0
movupd 0x10(%r13,%rdx,8),%xmm1
movupd (%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movupd (%r9,%rdx,8),%xmm1
mulpd  %xmm2,%xmm1
movupd 0x10(%r9,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,(%rcx,%rdx,8)
movapd %xmm2,0x10(%rcx,%rdx,8)
cmp    %r11,%rbx
jne    21a5 <fpls_warp_grad+0xfc5>
nopl   0x0(%rax)
lea    -0x2c(%rbp),%rdi
lea    -0x84(%rbp),%rsi
mov    -0x58(%rbp),%rbx
mov    %rbx,%rdx
lea    -0x38(%rbp),%r8
mov    %rcx,%r13
call   1070 <trapz@plt>
lea    -0x2c(%rbp),%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
mov    -0x40(%rbp),%rbx
mov    %rbx,%rcx
call   1060 <cumtrapz@plt>
mov    0x18(%rbp),%rdi
mov    -0x2c(%rbp),%r9d
test   %r9d,%r9d
mov    -0x68(%rbp),%r8
mov    -0xb0(%rbp),%r11
mov    -0xc0(%rbp),%rdx
mov    -0xd8(%rbp),%r13
mov    -0x60(%rbp),%r10
movapd -0x1a0(%rbp),%xmm10
ff ff
movapd -0x190(%rbp),%xmm7
ff
jle    2730 <fpls_warp_grad+0x1550>
movsd  -0x38(%rbp),%xmm0
cmp    $0x4,%r9d
jae    2440 <fpls_warp_grad+0x1260>
xor    %ecx,%ecx
jmp    2510 <fpls_warp_grad+0x1330>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rcx),%rsi
mov    %rsi,%rax
shr    $0x2,%rax
add    $0x1,%rax
test   %rsi,%rsi
je     3007 <fpls_warp_grad+0x1e27>
mov    %rax,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
mov    -0x40(%rbp),%rbx
nopl   0x0(%rax)
movupd (%rbx,%rsi,8),%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm3
movupd 0x20(%rbx,%rsi,8),%xmm4
movupd 0x30(%rbx,%rsi,8),%xmm5
movapd %xmm1,%xmm6
subpd  %xmm2,%xmm6
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
movupd %xmm6,(%rbx,%rsi,8)
movupd %xmm2,0x10(%rbx,%rsi,8)
movapd %xmm1,%xmm2
subpd  %xmm4,%xmm2
movapd %xmm1,%xmm3
subpd  %xmm5,%xmm3
movupd %xmm2,0x20(%rbx,%rsi,8)
movupd %xmm3,0x30(%rbx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    2480 <fpls_warp_grad+0x12a0>
test   $0x1,%al
je     24fe <fpls_warp_grad+0x131e>
movupd (%rbx,%rsi,8),%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
subpd  %xmm3,%xmm1
movupd %xmm4,(%rbx,%rsi,8)
movupd %xmm1,0x10(%rbx,%rsi,8)
cmp    %r9,%rcx
mov    0x18(%rbp),%rdi
je     2527 <fpls_warp_grad+0x1347>
nopw   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
subsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r9
jne    2510 <fpls_warp_grad+0x1330>
test   %r9d,%r9d
mov    -0x78(%rbp),%rcx
jle    2730 <fpls_warp_grad+0x1550>
cmp    $0x4,%r9d
jae    25d9 <fpls_warp_grad+0x13f9>
xor    %eax,%eax
mov    %rax,%rsi
test   $0x1,%r9b
je     2573 <fpls_warp_grad+0x1393>
movsd  (%r14,%rax,8),%xmm0
addsd  %xmm0,%xmm0
movsd  (%rcx,%rax,8),%xmm1
mulsd  (%rdi,%rax,8),%xmm1
mulsd  (%rbx,%rax,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%rax,8)
mov    %rax,%rsi
or     $0x1,%rsi
not    %rax
add    %r9,%rax
je     2730 <fpls_warp_grad+0x1550>
nop
movsd  (%r14,%rsi,8),%xmm0
movsd  (%rcx,%rsi,8),%xmm1
mulsd  (%rdi,%rsi,8),%xmm1
addsd  %xmm0,%xmm0
mulsd  (%rbx,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%rsi,8)
movsd  0x8(%r14,%rsi,8),%xmm0
addsd  %xmm0,%xmm0
movsd  0x8(%rcx,%rsi,8),%xmm1
mulsd  0x8(%rdi,%rsi,8),%xmm1
mulsd  0x8(%rbx,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%r11,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r9
jne    2580 <fpls_warp_grad+0x13a0>
jmp    2730 <fpls_warp_grad+0x1550>
lea    (%r11,%r9,8),%r8
lea    (%r14,%r9,8),%rax
lea    (%rbx,%r9,8),%rdx
lea    (%rcx,%r9,8),%rsi
lea    (%rdi,%r9,8),%r10
cmp    %rax,-0xb0(%rbp)
setb   -0xf0(%rbp)
cmp    %r8,%r14
setb   -0xb8(%rbp)
cmp    %rdx,-0xb0(%rbp)
setb   %al
cmp    %r8,%rbx
setb   -0x42(%rbp)
cmp    %rsi,-0xb0(%rbp)
setb   %dl
cmp    %r8,%rcx
setb   -0x41(%rbp)
cmp    %r10,-0xb0(%rbp)
mov    -0xb0(%rbp),%r11
setb   %sil
cmp    %rdi,%r8
seta   %cl
mov    -0xb8(%rbp),%bl
test   %bl,-0xf0(%rbp)
jne    30bc <fpls_warp_grad+0x1edc>
and    -0x42(%rbp),%al
jne    30bc <fpls_warp_grad+0x1edc>
mov    %cl,-0xf0(%rbp)
and    -0x41(%rbp),%dl
mov    -0x68(%rbp),%r8
mov    -0xc0(%rbp),%rdx
mov    -0x60(%rbp),%r10
mov    -0x40(%rbp),%rbx
mov    0x18(%rbp),%rdi
mov    -0x78(%rbp),%rcx
jne    253e <fpls_warp_grad+0x135e>
mov    $0x0,%eax
and    -0xf0(%rbp),%sil
jne    2540 <fpls_warp_grad+0x1360>
mov    %r9d,%eax
and    $0xfffffffc,%eax
lea    0x0(,%r9,8),%r8
and    $0xffffffffffffffe0,%r8
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd (%r14,%rsi,1),%xmm0
movupd 0x10(%r14,%rsi,1),%xmm1
addpd  %xmm0,%xmm0
addpd  %xmm1,%xmm1
movupd (%rbx,%rsi,1),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rbx,%rsi,1),%xmm0
mulpd  %xmm1,%xmm0
movupd (%rcx,%rsi,1),%xmm1
movupd 0x10(%rcx,%rsi,1),%xmm3
movupd (%rdi,%rsi,1),%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rdi,%rsi,1),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm4,(%r11,%rsi,1)
movapd %xmm1,0x10(%r11,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r8
jne    26b0 <fpls_warp_grad+0x14d0>
cmp    %r9,%rax
mov    -0x68(%rbp),%r8
jne    2540 <fpls_warp_grad+0x1360>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movq   $0x0,-0x38(%rbp)
cmp    $0x1,%r8d
mov    -0xc8(%rbp),%rsi
xorpd  %xmm0,%xmm0
jne    2770 <fpls_warp_grad+0x1590>
xor    %ecx,%ecx
xorpd  %xmm1,%xmm1
mov    -0x70(%rbp),%rax
test   $0x1,%r8b
jne    27ea <fpls_warp_grad+0x160a>
jmp    2801 <fpls_warp_grad+0x1621>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %edi,%edi
xorpd  %xmm1,%xmm1
mov    -0x180(%rbp),%rbx
mov    -0x70(%rbp),%rax
jmp    2799 <fpls_warp_grad+0x15b9>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdi
cmp    %rbx,%rdi
je     27e0 <fpls_warp_grad+0x1600>
mov    %rdi,%rcx
cmp    %rdi,%rax
je     27b3 <fpls_warp_grad+0x15d3>
addsd  0x0(%r13,%rcx,8),%xmm1
movsd  %xmm1,-0x38(%rbp)
addsd  (%r10,%rcx,8),%xmm0
lea    0x1(%rcx),%rdi
cmp    %rax,%rdi
je     2790 <fpls_warp_grad+0x15b0>
addsd  0x8(%r13,%rcx,8),%xmm1
movsd  %xmm1,-0x38(%rbp)
addsd  0x8(%r10,%rcx,8),%xmm0
jmp    2790 <fpls_warp_grad+0x15b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rcx
test   $0x1,%r8b
je     2801 <fpls_warp_grad+0x1621>
cmp    %rax,%rcx
je     2801 <fpls_warp_grad+0x1621>
addsd  0x0(%r13,%rcx,8),%xmm1
movsd  %xmm1,-0x38(%rbp)
addsd  (%r10,%rcx,8),%xmm0
test   %r9d,%r9d
jle    2974 <fpls_warp_grad+0x1794>
movsd  (%r10,%rax,8),%xmm2
movsd  0x0(%r13,%rax,8),%xmm9
movapd %xmm10,%xmm8
mulsd  %xmm9,%xmm8
mulsd  %xmm7,%xmm9
cmp    $0x1,%r9d
jne    2840 <fpls_warp_grad+0x1660>
xor    %ecx,%ecx
jmp    2910 <fpls_warp_grad+0x1730>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r9d,%ecx
and    $0xfffffffe,%ecx
movapd %xmm8,%xmm10
unpcklpd %xmm8,%xmm10
movapd %xmm2,%xmm6
unpcklpd %xmm2,%xmm6
movapd %xmm9,%xmm11
unpcklpd %xmm9,%xmm11
movapd %xmm0,%xmm12
unpcklpd %xmm0,%xmm12
movapd %xmm1,%xmm13
unpcklpd %xmm1,%xmm13
xor    %edi,%edi
movapd -0x1c0(%rbp),%xmm14
ff ff
movapd -0x1b0(%rbp),%xmm15
ff ff
nopw   0x0(%rax,%rax,1)
movapd (%rsi,%rdi,8),%xmm5
movapd %xmm14,%xmm7
mulpd  %xmm5,%xmm7
movapd (%r11,%rdi,8),%xmm4
movapd %xmm10,%xmm3
mulpd  %xmm4,%xmm3
mulpd  %xmm6,%xmm7
addpd  %xmm3,%xmm7
mulpd  %xmm15,%xmm5
movapd %xmm5,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm7,%xmm3
movapd %xmm11,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm3,%xmm7
mulpd  %xmm12,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm15,%xmm4
mulpd  %xmm13,%xmm4
addpd  %xmm5,%xmm4
movapd %xmm4,(%rdx,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    2890 <fpls_warp_grad+0x16b0>
cmp    %r9,%rcx
movapd -0x1a0(%rbp),%xmm10
ff ff
movapd -0x190(%rbp),%xmm7
ff
je     2974 <fpls_warp_grad+0x1794>
xchg   %ax,%ax
movsd  (%rsi,%rcx,8),%xmm3
movapd %xmm10,%xmm4
mulsd  %xmm3,%xmm4
movsd  (%r11,%rcx,8),%xmm5
movapd %xmm8,%xmm6
mulsd  %xmm5,%xmm6
mulsd  %xmm2,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm7,%xmm3
movapd %xmm3,%xmm6
mulsd  %xmm2,%xmm6
addsd  %xmm4,%xmm6
movapd %xmm9,%xmm4
mulsd  %xmm5,%xmm4
addsd  %xmm6,%xmm4
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm7,%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm5,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r9
jne    2910 <fpls_warp_grad+0x1730>
mov    -0x100(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    %r14,%rcx
lea    -0x38(%rbp),%r8
call   10d0 <innerprod_q@plt>
mov    -0xc0(%rbp),%rbx
mov    -0x2c(%rbp),%eax
test   %eax,%eax
mov    -0x148(%rbp),%rsi
jle    2b50 <fpls_warp_grad+0x1970>
movsd  -0x38(%rbp),%xmm0
xorpd  0x165f(%rip),%xmm0
cmp    $0x4,%eax
jae    2a30 <fpls_warp_grad+0x1850>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%al
je     29da <fpls_warp_grad+0x17fa>
movsd  (%r14,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
add    %rax,%rcx
je     2b50 <fpls_warp_grad+0x1970>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rdx,8),%xmm1
movsd  0x8(%r14,%rdx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  0x8(%rbx,%rdx,8),%xmm2
movsd  %xmm1,(%rsi,%rdx,8)
movsd  %xmm2,0x8(%rsi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    29f0 <fpls_warp_grad+0x1810>
jmp    2b50 <fpls_warp_grad+0x1970>
nopl   0x0(%rax)
lea    (%rsi,%rax,8),%rcx
lea    (%rbx,%rax,8),%rdx
lea    (%r14,%rax,8),%rdi
cmp    %rdx,%rsi
setb   %r10b
cmp    %rcx,%rbx
setb   %r8b
cmp    %rdi,%rsi
setb   %dl
cmp    %rcx,%r14
setb   %r9b
test   %r8b,%r10b
jne    29b6 <fpls_warp_grad+0x17d6>
mov    $0x0,%ecx
and    %r9b,%dl
jne    29b8 <fpls_warp_grad+0x17d8>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rcx),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     3059 <fpls_warp_grad+0x1e79>
mov    %r8,%rdi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movupd (%r14,%rdx,8),%xmm2
movupd 0x10(%r14,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  (%rbx,%rdx,8),%xmm2
mulpd  %xmm1,%xmm3
addpd  0x10(%rbx,%rdx,8),%xmm3
movapd %xmm2,(%rsi,%rdx,8)
movapd %xmm3,0x10(%rsi,%rdx,8)
movupd 0x20(%r14,%rdx,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  0x20(%rbx,%rdx,8),%xmm2
movupd 0x30(%r14,%rdx,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  0x30(%rbx,%rdx,8),%xmm3
movapd %xmm2,0x20(%rsi,%rdx,8)
movapd %xmm3,0x30(%rsi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    2ab0 <fpls_warp_grad+0x18d0>
test   $0x1,%r8b
je     2b44 <fpls_warp_grad+0x1964>
movupd (%r14,%rdx,8),%xmm2
movupd 0x10(%r14,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  (%rbx,%rdx,8),%xmm2
mulpd  %xmm1,%xmm3
addpd  0x10(%rbx,%rdx,8),%xmm3
movapd %xmm2,(%rsi,%rdx,8)
movapd %xmm3,0x10(%rsi,%rdx,8)
cmp    %rax,%rcx
jne    29b8 <fpls_warp_grad+0x17d8>
nopl   (%rax)
lea    -0x2c(%rbp),%rdi
lea    -0xe0(%rbp),%rdx
lea    -0x38(%rbp),%rcx
call   10a0 <pvecnorm2@plt>
movsd  -0x38(%rbp),%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
call   10e0 <cos@plt>
movapd %xmm0,-0xf0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x150(%rbp),%xmm0
ff
call   1080 <sin@plt>
movapd -0xf0(%rbp),%xmm7
ff
mov    -0x148(%rbp),%rbx
mov    -0x2c(%rbp),%eax
test   %eax,%eax
jle    2d60 <fpls_warp_grad+0x1b80>
movsd  -0x38(%rbp),%xmm1
cmp    $0x1,%eax
jne    2c60 <fpls_warp_grad+0x1a80>
xor    %ecx,%ecx
mov    %rcx,%rdx
test   $0x1,%al
je     2be9 <fpls_warp_grad+0x1a09>
movsd  (%rbx,%rcx,8),%xmm2
divsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  (%r14,%rcx,8),%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r15,%rcx,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
add    %rax,%rcx
je     2d60 <fpls_warp_grad+0x1b80>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rdx,8),%xmm2
divsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  (%r14,%rdx,8),%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r15,%rdx,8)
movsd  0x8(%rbx,%rdx,8),%xmm2
divsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  0x8(%r14,%rdx,8),%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x8(%r15,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    2c00 <fpls_warp_grad+0x1a20>
jmp    2d60 <fpls_warp_grad+0x1b80>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r15,%rax,8),%rcx
lea    (%r14,%rax,8),%rdx
lea    (%rbx,%rax,8),%rsi
cmp    %rdx,%r15
setb   %dil
cmp    %rcx,%r14
setb   %r8b
cmp    %rsi,%r15
setb   %dl
cmp    %rcx,%rbx
setb   %sil
test   %r8b,%dil
jne    2bb8 <fpls_warp_grad+0x19d8>
mov    $0x0,%ecx
and    %sil,%dl
jne    2bba <fpls_warp_grad+0x19da>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm7,%xmm3
unpcklpd %xmm7,%xmm3
lea    -0x2(%rcx),%rdx
mov    %rdx,%rsi
shr    %rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     306a <fpls_warp_grad+0x1e8a>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd (%r14,%rdx,8),%xmm5
movapd (%rbx,%rdx,8),%xmm6
divpd  %xmm4,%xmm6
mulpd  %xmm2,%xmm6
mulpd  %xmm3,%xmm5
addpd  %xmm6,%xmm5
movupd %xmm5,(%r15,%rdx,8)
movupd 0x10(%r14,%rdx,8),%xmm5
movapd 0x10(%rbx,%rdx,8),%xmm6
divpd  %xmm4,%xmm6
mulpd  %xmm2,%xmm6
mulpd  %xmm3,%xmm5
addpd  %xmm6,%xmm5
movupd %xmm5,0x10(%r15,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rdi
jne    2ce0 <fpls_warp_grad+0x1b00>
test   $0x1,%sil
je     2d56 <fpls_warp_grad+0x1b76>
movupd (%r14,%rdx,8),%xmm5
movapd (%rbx,%rdx,8),%xmm6
divpd  %xmm4,%xmm6
mulpd  %xmm6,%xmm2
mulpd  %xmm5,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm3,(%r15,%rdx,8)
cmp    %rax,%rcx
jne    2bba <fpls_warp_grad+0x19da>
nop
mov    -0x100(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    %r15,%rdx
mov    %r15,%rcx
lea    -0x38(%rbp),%r8
call   10d0 <innerprod_q@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
mov    -0x40(%rbp),%rdx
jle    2f18 <fpls_warp_grad+0x1d38>
movsd  -0x38(%rbp),%xmm0
cmp    $0x1,%eax
jne    2da0 <fpls_warp_grad+0x1bc0>
xor    %ecx,%ecx
jmp    2e20 <fpls_warp_grad+0x1c40>
nopw   0x0(%rax,%rax,1)
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rcx),%rsi
mov    %rsi,%rbx
shr    %rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     301a <fpls_warp_grad+0x1e3a>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   (%rax)
movupd (%r15,%rsi,8),%xmm2
movupd 0x10(%r15,%rsi,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%r15,%rsi,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%r15,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    2dd0 <fpls_warp_grad+0x1bf0>
test   $0x1,%bl
je     2e11 <fpls_warp_grad+0x1c31>
movupd (%r15,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r15,%rsi,8)
cmp    %rax,%rcx
je     2e39 <fpls_warp_grad+0x1c59>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2e20 <fpls_warp_grad+0x1c40>
test   %eax,%eax
jle    2f18 <fpls_warp_grad+0x1d38>
cmp    $0x4,%eax
jae    2e4d <fpls_warp_grad+0x1c6d>
xor    %ecx,%ecx
jmp    2f00 <fpls_warp_grad+0x1d20>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     3038 <fpls_warp_grad+0x1e58>
mov    %rbx,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movupd (%r15,%rsi,8),%xmm0
movupd 0x10(%r15,%rsi,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,(%rdx,%rsi,8)
movupd %xmm1,0x10(%rdx,%rsi,8)
movupd 0x20(%r15,%rsi,8),%xmm0
movupd 0x30(%r15,%rsi,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,0x20(%rdx,%rsi,8)
movupd %xmm1,0x30(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    2e80 <fpls_warp_grad+0x1ca0>
test   $0x1,%bl
je     2ef1 <fpls_warp_grad+0x1d11>
movupd (%r15,%rsi,8),%xmm0
movupd 0x10(%r15,%rsi,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,(%rdx,%rsi,8)
movupd %xmm1,0x10(%rdx,%rsi,8)
cmp    %rax,%rcx
je     2f18 <fpls_warp_grad+0x1d38>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2f00 <fpls_warp_grad+0x1d20>
lea    -0x2c(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    %r12,%rcx
call   1060 <cumtrapz@plt>
movslq -0x2c(%rbp),%rcx
test   %rcx,%rcx
mov    -0x68(%rbp),%rdi
mov    -0x80(%rbp),%r11
mov    -0x60(%rbp),%rdx
mov    -0x70(%rbp),%r9
mov    -0x50(%rbp),%r10
jle    1be0 <fpls_warp_grad+0xa00>
mov    %ecx,%r8d
lea    -0x1(%rcx),%eax
cmp    $0x1,%ecx
jne    2f60 <fpls_warp_grad+0x1d80>
xor    %esi,%esi
jmp    2fc3 <fpls_warp_grad+0x1de3>
nopl   0x0(%rax,%rax,1)
mov    %r8d,%ebx
and    $0xfffffffe,%ebx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  (%r12),%xmm0
movsd  (%r12,%rsi,8),%xmm1
movsd  0x8(%r12,%rsi,8),%xmm2
subsd  %xmm0,%xmm1
movsd  (%r12,%rax,8),%xmm3
subsd  %xmm0,%xmm3
divsd  %xmm3,%xmm1
movsd  %xmm1,(%r12,%rsi,8)
movsd  (%r12),%xmm0
subsd  %xmm0,%xmm2
movsd  (%r12,%rax,8),%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%r12,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rbx
jne    2f70 <fpls_warp_grad+0x1d90>
test   $0x1,%r8b
je     1be0 <fpls_warp_grad+0xa00>
movsd  (%r12,%rsi,8),%xmm0
movsd  (%r12),%xmm1
subsd  %xmm1,%xmm0
movsd  (%r12,%rax,8),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%r12,%rsi,8)
jmp    1be0 <fpls_warp_grad+0xa00>
xor    %esi,%esi
test   $0x1,%r8b
jne    1f5e <fpls_warp_grad+0xd7e>
jmp    1f80 <fpls_warp_grad+0xda0>
xor    %esi,%esi
mov    -0x40(%rbp),%rbx
test   $0x1,%al
jne    24dc <fpls_warp_grad+0x12fc>
jmp    24fe <fpls_warp_grad+0x131e>
xor    %esi,%esi
test   $0x1,%bl
jne    2e01 <fpls_warp_grad+0x1c21>
jmp    2e11 <fpls_warp_grad+0x1c31>
xor    %ecx,%ecx
mov    -0xa8(%rbp),%rsi
jmp    1c4a <fpls_warp_grad+0xa6a>
xor    %esi,%esi
test   $0x1,%bl
jne    2ed1 <fpls_warp_grad+0x1cf1>
jmp    2ef1 <fpls_warp_grad+0x1d11>
xor    %edx,%edx
test   $0x1,%r8b
jne    1de8 <fpls_warp_grad+0xc08>
jmp    1e28 <fpls_warp_grad+0xc48>
xor    %edx,%edx
test   $0x1,%r8b
jne    2b19 <fpls_warp_grad+0x1939>
jmp    2b44 <fpls_warp_grad+0x1964>
xor    %edx,%edx
test   $0x1,%sil
jne    2d35 <fpls_warp_grad+0x1b55>
jmp    2d56 <fpls_warp_grad+0x1b76>
xor    %ebx,%ebx
mov    0x18(%rbp),%r9
jmp    21a5 <fpls_warp_grad+0xfc5>
xor    %r8d,%r8d
mov    -0xc8(%rbp),%r10
mov    -0x80(%rbp),%rcx
mov    -0x40(%rbp),%rdi
mov    0x18(%rbp),%r9
mov    0x10(%rbp),%rax
mov    -0xa0(%rbp),%r13
mov    -0x50(%rbp),%rbx
jmp    1fc5 <fpls_warp_grad+0xde5>
xor    %r8d,%r8d
mov    -0x50(%rbp),%rbx
jmp    1fc5 <fpls_warp_grad+0xde5>
xor    %eax,%eax
mov    -0x68(%rbp),%r8
mov    -0xc0(%rbp),%rdx
mov    -0x60(%rbp),%r10
mov    -0x40(%rbp),%rbx
mov    0x18(%rbp),%rdi
mov    -0x78(%rbp),%rcx
jmp    2540 <fpls_warp_grad+0x1360>
xor    %edx,%edx
test   $0x1,%sil
jne    235d <fpls_warp_grad+0x117d>
jmp    23a0 <fpls_warp_grad+0x11c0>
nop
mov    %r13,%rsi
lea    -0x38(%rbp),%rcx
call   1040 <cov@plt>
movsd  -0x38(%rbp),%xmm3
mov    -0x178(%rbp),%r12
mov    %r12d,%eax
mov    -0x138(%rbp),%rcx
movsd  %xmm3,(%rcx,%rax,8)
cmpl   $0x1,-0x104(%rbp)
jne    3143 <fpls_warp_grad+0x1f63>
lea    0xf11(%rip),%rdi
mov    %r12d,%esi
movapd %xmm3,%xmm0
movapd %xmm3,-0xa0(%rbp)
ff
call   1050 <printf@plt>
movapd -0xa0(%rbp),%xmm3
ff
cmp    $0x2,%r12d
mov    -0x40(%rbp),%rcx
jb     15f0 <fpls_warp_grad+0x410>
lea    -0x1(%r12),%eax
mov    -0x138(%rbp),%rdx
subsd  (%rdx,%rax,8),%xmm3
movapd %xmm3,%xmm0
andpd  0xe92(%rip),%xmm0
movsd  -0x160(%rbp),%xmm1
ff
ucomisd %xmm0,%xmm1
mov    -0x68(%rbp),%rdi
mov    -0x60(%rbp),%rdx
ja     31ad <fpls_warp_grad+0x1fcd>
xorpd  %xmm0,%xmm0
ucomisd %xmm3,%xmm0
ja     31ad <fpls_warp_grad+0x1fcd>
add    $0x1,%r12d
mov    -0xd0(%rbp),%rbx
mov    -0xf8(%rbp),%r14
cmp    %r12d,-0x110(%rbp)
jg     1617 <fpls_warp_grad+0x437>
imul   -0x2c(%rbp),%edi
test   %edi,%edi
jle    31cf <fpls_warp_grad+0x1fef>
mov    %edi,%edx
shl    $0x3,%rdx
mov    0x40(%rbp),%rdi
mov    -0xd0(%rbp),%rsi
call   1090 <memcpy@plt>
mov    -0x40(%rbp),%rcx
mov    %rcx,%rdi
call   1030 <free@plt>
mov    -0x158(%rbp),%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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