#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*/ cumtrapz(int *, double *, double *, double *);
double exp(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 log(double);
double *malloc(int);
int /*<<< orphan*/ printf(char *, int, double);
int /*<<< orphan*/ pvecnorm(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 mlogit_warp_grad(int *m1, int *m2, double *alpha, double *beta, double *ti,
                      double *gami, double *q, int *y, int *max_itri,
                      double *toli, double *deltai, int *displayi,
                      double *gamout) {
  int TT = *m1;
  int m = *m2;
  int max_itr = *max_itri;
  double t = *ti;
  double tol = *toli, delta = *deltai, display = *displayi;
  int k, j;
  int n1 = 1;
  int itr = 1;
  double gam1[TT], psi1[TT], q_tmp[TT], q_tmp_diff[TT];
  double A[m], Adiff[TT * m], xout[TT], tmp[TT], tmp1, tmpi, binsize;
  double eps = DBL_EPSILON;
  double tmp3[TT * m], h[TT], vec[TT];
  double psi2[TT], gam2[TT];
  double res_cos, res_sin, max_val_change, max_val[max_itr];
  double *tmp2 = malloc(sizeof(double) * (TT));
  double *psi_ptr, *gam_ptr, *q_ptr, *q_tmp_ptr, *q_tmp_diff_ptr;
  double *xout_ptr, *tmp_ptr, *A_ptr, *Adiff_ptr, *tmp1_ptr, *tmp2_ptr;
  double *alpha_ptr, *beta_ptr, *tmp3_ptr, *h_ptr;
  int *y_ptr;
  double *psi2_ptr, *gam2_ptr, *tmpi_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; k++) {
    gam1[k] = gami[k];
  }
  psi_ptr = psi1;
  gam_ptr = gam1;
  gradient(m1, &n1, gam_ptr, &binsize, psi_ptr);
  for (k = 0; k < TT; k++)
    psi1[k] = sqrt(fabs(psi1[k]) + eps);
  do {
    q_ptr = q;
    q_tmp_ptr = q_tmp;
    q_tmp_diff_ptr = q_tmp_diff;
    alpha_ptr = alpha;
    beta_ptr = beta;
    for (j = 0; j < TT; j++)
      xout[j] = (ti[TT - 1] - ti[0]) * gam_ptr[j] + ti[0];
    xout_ptr = xout;
    spline(TT, ti, q_ptr, TT, xout_ptr, q_tmp_ptr);
    tmp_ptr = tmp;
    gradient(m1, &n1, q_ptr, &binsize, tmp_ptr);
    spline(TT, ti, tmp_ptr, TT, xout_ptr, q_tmp_diff_ptr);
    A_ptr = A;
    Adiff_ptr = Adiff;
    tmp2_ptr = tmp2;
    tmp1_ptr = &tmp1;
    for (j = 0; j < m; j++) {
      for (k = 0; k < TT; k++)
        tmp[k] = q_tmp_ptr[k] * psi_ptr[k] * beta_ptr[k];
      tmp_ptr = tmp;
      trapz(m1, &n1, ti, tmp_ptr, tmp1_ptr);
      A[j] = tmp1;
      for (k = 0; k < TT; k++)
        tmp[k] = q_tmp_diff_ptr[k] * psi_ptr[k] * beta_ptr[k];
      tmp_ptr = tmp;
      trapz(&TT, &n1, ti, tmp_ptr, tmp1_ptr);
      cumtrapz(&TT, ti, tmp_ptr, tmp2_ptr);
      for (k = 0; k < TT; k++)
        tmp[k] = tmp1_ptr[0] - tmp2_ptr[k];
      tmp_ptr = tmp;
      for (k = 0; k < TT; k++)
        Adiff_ptr[k] = 2 * psi_ptr[k] * tmp_ptr[k] + q_tmp_ptr[k] * beta_ptr[k];
      beta_ptr += TT;
      Adiff_ptr += TT;
    }
    tmp1 = 0;
    for (j = 0; j < m; j++)
      tmp1 += exp(alpha_ptr[j] + A_ptr[j]);
    tmp3_ptr = tmp3;
    Adiff_ptr = Adiff;
    for (j = 0; j < m; j++) {
      for (k = 0; k < TT; k++) {
        tmp3_ptr[k] = exp(alpha_ptr[j] + A_ptr[j]) * Adiff_ptr[k];
      }
      Adiff_ptr += TT;
      tmp3_ptr += TT;
    }
    tmp_ptr = tmp;
    tmp3_ptr = tmp3;
    for (k = 0; k < TT; k++) {
      tmp[k] = tmp3_ptr[k];
      for (j = 1; j < m; j++)
        tmp[k] = tmp[k] + tmp3_ptr[k + j * TT];
    }
    for (k = 0; k < TT; k++)
      tmp[k] = tmp[k] / tmp1;
    tmp3_ptr = tmp3;
    Adiff_ptr = Adiff;
    y_ptr = y;
    for (j = 0; j < m; j++) {
      for (k = 0; k < TT; k++) {
        tmp3_ptr[k] = y_ptr[j] * Adiff_ptr[k];
      }
      Adiff_ptr += TT;
      tmp3_ptr += TT;
    }
    h_ptr = h;
    tmp3_ptr = tmp3;
    for (k = 0; k < TT; k++) {
      h[k] = tmp3_ptr[k];
      for (j = 1; j < m; j++)
        h[k] += tmp3_ptr[k + j * TT];
    }
    tmp_ptr = tmp;
    for (k = 0; k < TT; k++)
      h[k] = h[k] - tmp_ptr[k];
    tmpi_ptr = &tmpi;
    innerprod_q(m1, ti, h_ptr, psi_ptr, tmpi_ptr);
    for (j = 0; j < TT; j++)
      vec[j] = h[j] - tmpi * psi_ptr[j];
    psi2_ptr = psi2;
    gam2_ptr = gam2;
    pvecnorm(&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);
    for (j = 0; j < TT; j++)
      tmp[j] = psi2_ptr[j] * psi2_ptr[j];
    tmp_ptr = tmp;
    cumtrapz(&TT, ti, tmp_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]);
    tmpi = 0;
    alpha_ptr = alpha;
    A_ptr = A;
    for (j = 0; j < m; j++)
      tmpi += y[j] * (alpha_ptr[j] + A_ptr[j]);
    max_val[itr] = tmpi - log(tmp1);
    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 = 1; k < TT; k++) {
    gamout[k] = gam2_ptr[k];
  }
  free(tmp2);
}


x86 assembly (clang, -O0):
<mlogit_warp_grad>:
push   %rbp
mov    %rsp,%rbp
sub    $0x240,%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    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    0x30(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x38(%rbp),%rax
cvtsi2sdl (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x6c(%rbp)
movl   $0x1,-0x70(%rbp)
mov    -0x34(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x78(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x230(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x80(%rbp)
mov    -0x34(%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,-0x88(%rbp)
mov    -0x34(%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,-0x90(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x218(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x98(%rbp)
mov    -0x38(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x210(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa0(%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,-0x208(%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,-0x200(%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,-0x1f8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xb8(%rbp)
mov    0x3c2b(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
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,-0x1f0(%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,-0x1e8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xe8(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1e0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf0(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1d8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xf8(%rbp)
mov    -0x34(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1d0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x100(%rbp)
mov    -0x3c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x1c8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x120(%rbp)
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   10a0 <malloc@plt>
mov    %rax,-0x128(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1529 <mlogit_warp_grad+0x349>
mov    -0x28(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    14db <mlogit_warp_grad+0x2fb>
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1585 <mlogit_warp_grad+0x3a5>
mov    -0x230(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    154e <mlogit_warp_grad+0x36e>
mov    -0x230(%rbp),%rax
mov    -0x228(%rbp),%rcx
mov    %rcx,-0x130(%rbp)
mov    %rax,-0x138(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x138(%rbp),%rdx
mov    -0x130(%rbp),%r8
lea    -0x6c(%rbp),%rsi
lea    -0xd0(%rbp),%rcx
call   1090 <gradient@plt>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    161c <mlogit_warp_grad+0x43c>
mov    -0x228(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1a23(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0xd8(%rbp),%xmm0
ff
call   10f0 <sqrt@plt>
mov    -0x228(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    15ca <mlogit_warp_grad+0x3ea>
jmp    1621 <mlogit_warp_grad+0x441>
mov    -0x218(%rbp),%rax
mov    -0x220(%rbp),%rcx
mov    0x10(%rbp),%rdx
mov    %rdx,-0x140(%rbp)
mov    %rcx,-0x148(%rbp)
mov    %rax,-0x150(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x190(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    16c9 <mlogit_warp_grad+0x4e9>
mov    -0x200(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x28(%rbp),%rcx
subsd  (%rcx),%xmm0
mov    -0x138(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
mov    -0x28(%rbp),%rcx
movsd  (%rcx),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1665 <mlogit_warp_grad+0x485>
mov    -0x200(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x34(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x140(%rbp),%rdx
mov    -0x34(%rbp),%ecx
mov    -0x158(%rbp),%r8
mov    -0x148(%rbp),%r9
call   1100 <spline@plt>
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x140(%rbp),%rdx
mov    -0x160(%rbp),%r8
lea    -0x6c(%rbp),%rsi
lea    -0xd0(%rbp),%rcx
call   1090 <gradient@plt>
mov    -0x34(%rbp),%edi
mov    -0x28(%rbp),%rsi
mov    -0x160(%rbp),%rdx
mov    -0x34(%rbp),%ecx
mov    -0x158(%rbp),%r8
mov    -0x150(%rbp),%r9
call   1100 <spline@plt>
mov    -0x210(%rbp),%rcx
mov    -0x208(%rbp),%rax
mov    %rcx,-0x168(%rbp)
mov    %rax,-0x170(%rbp)
mov    -0x128(%rbp),%rax
mov    %rax,-0x180(%rbp)
lea    -0xc0(%rbp),%rax
mov    %rax,-0x178(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1a08 <mlogit_warp_grad+0x828>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    17fb <mlogit_warp_grad+0x61b>
mov    -0x1f8(%rbp),%rax
mov    -0x148(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x130(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
mov    -0x190(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    17a1 <mlogit_warp_grad+0x5c1>
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rdx
mov    -0x160(%rbp),%rcx
mov    -0x178(%rbp),%r8
lea    -0x6c(%rbp),%rsi
call   1060 <trapz@plt>
mov    -0x210(%rbp),%rax
movsd  -0xc0(%rbp),%xmm0
ff
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    18a1 <mlogit_warp_grad+0x6c1>
mov    -0x1f8(%rbp),%rax
mov    -0x150(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x130(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
mov    -0x190(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1847 <mlogit_warp_grad+0x667>
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x160(%rbp),%rcx
mov    -0x178(%rbp),%r8
lea    -0x34(%rbp),%rdi
lea    -0x6c(%rbp),%rsi
call   1060 <trapz@plt>
mov    -0x28(%rbp),%rsi
mov    -0x160(%rbp),%rdx
mov    -0x180(%rbp),%rcx
lea    -0x34(%rbp),%rdi
call   1050 <cumtrapz@plt>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1935 <mlogit_warp_grad+0x755>
mov    -0x1f8(%rbp),%rax
mov    -0x178(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    -0x180(%rbp),%rcx
movslq -0x64(%rbp),%rdx
subsd  (%rcx,%rdx,8),%xmm0
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    18f0 <mlogit_warp_grad+0x710>
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x160(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    19c4 <mlogit_warp_grad+0x7e4>
mov    -0x130(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  0x169f(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x160(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x148(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x190(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x170(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    194a <mlogit_warp_grad+0x76a>
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    -0x170(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x170(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    178e <mlogit_warp_grad+0x5ae>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1a69 <mlogit_warp_grad+0x889>
mov    -0x188(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x168(%rbp),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
call   10c0 <exp@plt>
addsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1a1a <mlogit_warp_grad+0x83a>
mov    -0x208(%rbp),%rax
mov    -0x1f0(%rbp),%rcx
mov    %rcx,-0x198(%rbp)
mov    %rax,-0x170(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1b42 <mlogit_warp_grad+0x962>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1afe <mlogit_warp_grad+0x91e>
mov    -0x188(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x168(%rbp),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
call   10c0 <exp@plt>
mov    -0x170(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x198(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1a9f <mlogit_warp_grad+0x8bf>
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    -0x198(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x198(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1a8c <mlogit_warp_grad+0x8ac>
mov    -0x1f0(%rbp),%rax
mov    -0x1f8(%rbp),%rcx
mov    %rcx,-0x160(%rbp)
mov    %rax,-0x198(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1bf9 <mlogit_warp_grad+0xa19>
mov    -0x1f8(%rbp),%rax
mov    -0x198(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1be6 <mlogit_warp_grad+0xa06>
mov    -0x1f8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x198(%rbp),%rcx
mov    -0x64(%rbp),%edx
mov    -0x68(%rbp),%esi
imul   -0x34(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
addsd  (%rcx,%rdx,8),%xmm0
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1b98 <mlogit_warp_grad+0x9b8>
jmp    1beb <mlogit_warp_grad+0xa0b>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1b65 <mlogit_warp_grad+0x985>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1c3b <mlogit_warp_grad+0xa5b>
mov    -0x1f8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1c00 <mlogit_warp_grad+0xa20>
mov    -0x208(%rbp),%rax
mov    -0x1f0(%rbp),%rcx
mov    %rcx,-0x198(%rbp)
mov    %rax,-0x170(%rbp)
mov    0x18(%rbp),%rax
mov    %rax,-0x1a8(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1d0a <mlogit_warp_grad+0xb2a>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1cc6 <mlogit_warp_grad+0xae6>
mov    -0x1a8(%rbp),%rax
movslq -0x68(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x170(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x198(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1c7c <mlogit_warp_grad+0xa9c>
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    -0x198(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x198(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1c69 <mlogit_warp_grad+0xa89>
mov    -0x1f0(%rbp),%rax
mov    -0x1e8(%rbp),%rcx
mov    %rcx,-0x1a0(%rbp)
mov    %rax,-0x198(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1dbd <mlogit_warp_grad+0xbdd>
mov    -0x1e8(%rbp),%rax
mov    -0x198(%rbp),%rcx
movslq -0x64(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1daa <mlogit_warp_grad+0xbca>
mov    -0x1e8(%rbp),%rax
mov    -0x198(%rbp),%rcx
mov    -0x64(%rbp),%edx
mov    -0x68(%rbp),%esi
imul   -0x34(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x64(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1d60 <mlogit_warp_grad+0xb80>
jmp    1daf <mlogit_warp_grad+0xbcf>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1d2d <mlogit_warp_grad+0xb4d>
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x160(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1e15 <mlogit_warp_grad+0xc35>
mov    -0x1e8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x160(%rbp),%rcx
movslq -0x64(%rbp),%rdx
subsd  (%rcx,%rdx,8),%xmm0
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1dd2 <mlogit_warp_grad+0xbf2>
lea    -0xc8(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x1a0(%rbp),%rdx
mov    -0x130(%rbp),%rcx
mov    -0x1c0(%rbp),%r8
call   10b0 <innerprod_q@plt>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1ebd <mlogit_warp_grad+0xcdd>
mov    -0x1e0(%rbp),%rax
mov    -0x1e8(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x130(%rbp),%rcx
movslq -0x68(%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 -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1e4c <mlogit_warp_grad+0xc6c>
mov    -0x1e0(%rbp),%rsi
mov    -0x1d0(%rbp),%rax
mov    -0x1d8(%rbp),%rcx
mov    %rcx,-0x1b0(%rbp)
mov    %rax,-0x1b8(%rbp)
lea    -0x34(%rbp),%rdi
lea    -0xd0(%rbp),%rdx
lea    -0xc8(%rbp),%rcx
call   1080 <pvecnorm@plt>
movsd  -0x58(%rbp),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
call   10d0 <cos@plt>
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
call   1070 <sin@plt>
movsd  %xmm0,-0x110(%rbp)
ff
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1fa0 <mlogit_warp_grad+0xdc0>
mov    -0x1e0(%rbp),%rax
movsd  -0x108(%rbp),%xmm0
ff
mov    -0x130(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm2
movsd  -0x110(%rbp),%xmm1
ff
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
divsd  -0xc8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x1b0(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1f32 <mlogit_warp_grad+0xd52>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1ff1 <mlogit_warp_grad+0xe11>
mov    -0x1f8(%rbp),%rax
mov    -0x1b0(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x1b0(%rbp),%rcx
movslq -0x68(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1fa7 <mlogit_warp_grad+0xdc7>
mov    -0x1f8(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x28(%rbp),%rsi
mov    -0x160(%rbp),%rdx
mov    -0x1b8(%rbp),%rcx
lea    -0x34(%rbp),%rdi
call   1050 <cumtrapz@plt>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    208a <mlogit_warp_grad+0xeaa>
mov    -0x1b8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1b8(%rbp),%rax
subsd  (%rax),%xmm0
mov    -0x1b8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x1b8(%rbp),%rax
subsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x1b8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    2021 <mlogit_warp_grad+0xe41>
mov    -0x210(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x18(%rbp),%rcx
mov    %rcx,-0x188(%rbp)
mov    %rax,-0x168(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    2114 <mlogit_warp_grad+0xf34>
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x188(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x168(%rbp),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    20b5 <mlogit_warp_grad+0xed5>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x238(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   10e0 <log@plt>
mov    -0x1c8(%rbp),%rax
movaps %xmm0,%xmm1
movsd  -0x238(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  0xea3(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    218c <mlogit_warp_grad+0xfac>
jp     218c <mlogit_warp_grad+0xfac>
mov    -0x1c8(%rbp),%rax
mov    -0x70(%rbp),%esi
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xe99(%rip),%rdi
call   1040 <printf@plt>
mov    -0x1d8(%rbp),%rax
mov    -0x1d0(%rbp),%rcx
mov    %rcx,-0x138(%rbp)
mov    %rax,-0x130(%rbp)
cmpl   $0x2,-0x70(%rbp)
jl     221a <mlogit_warp_grad+0x103a>
mov    -0x1c8(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm1
ff
movaps 0xe29(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    21ff <mlogit_warp_grad+0x101f>
jmp    222f <mlogit_warp_grad+0x104f>
xorps  %xmm0,%xmm0
ucomisd -0x118(%rbp),%xmm0
ff
jbe    2215 <mlogit_warp_grad+0x1035>
jmp    222f <mlogit_warp_grad+0x104f>
jmp    221a <mlogit_warp_grad+0x103a>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1621 <mlogit_warp_grad+0x441>
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    226d <mlogit_warp_grad+0x108d>
mov    -0x1b8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    2236 <mlogit_warp_grad+0x1056>
mov    -0x128(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mlogit_warp_grad>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %r9,-0xa8(%rbp)
mov    %r8,%r13
mov    %rcx,-0x140(%rbp)
mov    %rdx,%r15
mov    %rsp,-0x128(%rbp)
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rcx
mov    0x28(%rbp),%rdx
mov    %rdi,-0xb8(%rbp)
mov    (%rdi),%ebx
mov    %ebx,-0x2c(%rbp)
movsd  (%rdx),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    0x20(%rbp),%rdx
mov    (%rsi),%esi
mov    (%rdx),%edi
movsd  (%rcx),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    (%rax),%eax
mov    %eax,-0xe4(%rbp)
movl   $0x1,-0x54(%rbp)
mov    %rsp,%rcx
lea    0xf(,%rbx,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,%r14
mov    %rcx,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x120(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rdx
lea    0xf(,%rsi,8),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%rdx
mov    %rdx,-0xc0(%rbp)
mov    %rdx,%rsp
mov    %rsi,-0x38(%rbp)
mov    %esi,%ecx
imul   %ebx,%ecx
lea    0xf(,%rcx,8),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0xc8(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rax,%rdx
mov    %rdx,-0xa0(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rax,%rdx
mov    %rdx,-0x40(%rbp)
mov    %rdx,%rsp
mov    0x3cdf(%rip),%rdx
movsd  (%rdx),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x90(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x100(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x148(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x150(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
mov    %rdi,-0x98(%rbp)
lea    0xf(,%rdi,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rcx
mov    %rcx,-0xf8(%rbp)
mov    %rcx,%rsp
lea    0x0(,%rbx,8),%edi
call   10b0 <malloc@plt>
mov    %rbx,%rdx
lea    -0x1(%rbx),%edi
xorpd  %xmm0,%xmm0
cmp    $0x2,%edx
jl     144e <mlogit_warp_grad+0x25e>
mov    %edi,%esi
movsd  0x0(%r13),%xmm1
lea    -0x1(%rsi),%rbx
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x3,%rbx
jae    13c0 <mlogit_warp_grad+0x1d0>
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
jmp    141d <mlogit_warp_grad+0x22d>
and    $0xfffffffc,%esi
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  0x8(%r13,%rbx,8),%xmm2
movsd  0x10(%r13,%rbx,8),%xmm3
movsd  0x18(%r13,%rbx,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(%r13,%rbx,8),%xmm1
add    $0x4,%rbx
movapd %xmm1,%xmm0
subsd  %xmm4,%xmm0
addsd  %xmm5,%xmm0
cmp    %rbx,%rsi
jne    13d0 <mlogit_warp_grad+0x1e0>
test   %rcx,%rcx
je     144e <mlogit_warp_grad+0x25e>
lea    0x8(,%rbx,8),%rbx
add    %r13,%rbx
xor    %esi,%esi
nop
movsd  (%rbx,%rsi,8),%xmm2
movapd %xmm2,%xmm3
subsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
add    $0x1,%rsi
movapd %xmm2,%xmm1
cmp    %rsi,%rcx
jne    1430 <mlogit_warp_grad+0x240>
mov    %rax,-0xb0(%rbp)
xorps  %xmm1,%xmm1
cvtsi2sd %edi,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
test   %edx,%edx
mov    -0x48(%rbp),%rbx
jle    1483 <mlogit_warp_grad+0x293>
shl    $0x3,%rdx
mov    %rbx,%rdi
mov    -0xa8(%rbp),%rsi
call   1080 <memcpy@plt>
lea    -0x54(%rbp),%rsi
lea    -0xe0(%rbp),%rcx
mov    -0xb8(%rbp),%rdi
mov    %rbx,%rdx
mov    %r14,%rbx
mov    %r14,%r8
call   10a0 <gradient@plt>
mov    %r14,%r10
mov    -0x2c(%rbp),%ecx
test   %ecx,%ecx
mov    %r12,-0x80(%rbp)
mov    -0xa0(%rbp),%r8
jle    151d <mlogit_warp_grad+0x32d>
xor    %ebx,%ebx
movapd 0x1b3e(%rip),%xmm1
xorpd  %xmm2,%xmm2
jmp    14fe <mlogit_warp_grad+0x30e>
nopl   0x0(%rax,%rax,1)
call   1100 <sqrt@plt>
xorpd  %xmm2,%xmm2
movapd 0x1b1f(%rip),%xmm1
mov    %r14,%r10
mov    -0xa0(%rbp),%r8
movsd  %xmm0,(%r10,%rbx,8)
add    $0x1,%rbx
movslq -0x2c(%rbp),%rcx
cmp    %rcx,%rbx
jge    1519 <mlogit_warp_grad+0x329>
movsd  (%r10,%rbx,8),%xmm0
andpd  %xmm1,%xmm0
addsd  -0x70(%rbp),%xmm0
ucomisd %xmm2,%xmm0
jb     14d0 <mlogit_warp_grad+0x2e0>
sqrtsd %xmm0,%xmm0
jmp    14eb <mlogit_warp_grad+0x2fb>
mov    -0x80(%rbp),%r12
movslq -0x98(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x38(%rbp),%rsi
lea    -0x1(%rsi),%rdx
lea    -0x2(%rsi),%rax
mov    %rax,-0xa8(%rbp)
mov    %edx,%eax
and    $0x3,%eax
mov    %rax,-0x98(%rbp)
mov    %esi,%eax
and    $0xfffffffe,%eax
mov    %rax,-0x130(%rbp)
mov    %rdx,%rax
mov    %rdx,-0x110(%rbp)
mov    %rdx,%r9
and    $0xfffffffffffffffc,%r9
neg    %r9
mov    $0x1,%eax
mov    %rax,-0xd0(%rbp)
mov    -0x48(%rbp),%rbx
mov    %r13,-0x88(%rbp)
mov    %r15,-0xd8(%rbp)
mov    %r9,-0x118(%rbp)
jmp    15cc <mlogit_warp_grad+0x3dc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    -0xf0(%rbp),%rsi
mov    -0xa0(%rbp),%r8
mov    -0xb0(%rbp),%rdi
jge    29a1 <mlogit_warp_grad+0x17b1>
add    $0x1,%rsi
mov    %rsi,-0xd0(%rbp)
mov    -0x2c(%rbp),%ecx
mov    %r14,%r10
test   %ecx,%ecx
jle    16ec <mlogit_warp_grad+0x4fc>
lea    -0x1(%rcx),%eax
movsd  0x0(%r13,%rax,8),%xmm0
movsd  0x0(%r13),%xmm1
subsd  %xmm1,%xmm0
mov    %ecx,%eax
cmp    $0x4,%ecx
jae    1600 <mlogit_warp_grad+0x410>
xor    %edx,%edx
jmp    16d0 <mlogit_warp_grad+0x4e0>
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%edx
and    $0xfffffffc,%edx
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
lea    -0x4(%rdx),%rsi
mov    %rsi,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rsi,%rsi
je     2939 <mlogit_warp_grad+0x1749>
mov    %r11,%rdi
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    %rsi,%rdi
xor    %esi,%esi
nop
movapd (%rbx,%rsi,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movapd 0x10(%rbx,%rsi,8),%xmm5
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm4,(%r8,%rsi,8)
movapd %xmm5,0x10(%r8,%rsi,8)
movapd 0x20(%rbx,%rsi,8),%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movapd 0x30(%rbx,%rsi,8),%xmm5
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
movapd %xmm4,0x20(%r8,%rsi,8)
movapd %xmm5,0x30(%r8,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1640 <mlogit_warp_grad+0x450>
test   $0x1,%r11b
je     16c6 <mlogit_warp_grad+0x4d6>
movapd (%rbx,%rsi,8),%xmm4
mulpd  %xmm2,%xmm4
mulpd  0x10(%rbx,%rsi,8),%xmm2
addpd  %xmm3,%xmm4
addpd  %xmm3,%xmm2
movapd %xmm4,(%r8,%rsi,8)
movapd %xmm2,0x10(%r8,%rsi,8)
cmp    %rax,%rdx
mov    -0x80(%rbp),%r12
je     16ec <mlogit_warp_grad+0x4fc>
nop
movsd  (%rbx,%rdx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r8,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    16d0 <mlogit_warp_grad+0x4e0>
mov    %r10,-0x48(%rbp)
mov    %ecx,%edi
mov    %r13,%rsi
mov    0x10(%rbp),%rbx
mov    %rbx,%rdx
mov    %r8,%r15
mov    %r12,%r9
call   1110 <spline@plt>
mov    -0xb8(%rbp),%rdi
lea    -0x54(%rbp),%rsi
mov    %rbx,%rdx
lea    -0xe0(%rbp),%rcx
mov    -0x40(%rbp),%rbx
mov    %rbx,%r8
call   10a0 <gradient@plt>
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edi
mov    %r13,%rsi
mov    %rbx,%rdx
mov    %r15,%r8
mov    -0x120(%rbp),%r9
call   1110 <spline@plt>
cmpl   $0x0,-0x38(%rbp)
jle    1d90 <mlogit_warp_grad+0xba0>
mov    -0x2c(%rbp),%r9d
xor    %eax,%eax
mov    %rax,-0x70(%rbp)
mov    -0x140(%rbp),%r14
mov    -0xc8(%rbp),%r15
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%r10
jmp    1791 <mlogit_warp_grad+0x5a1>
xchg   %ax,%ax
lea    (%r14,%r9,8),%r14
lea    (%r15,%r9,8),%r15
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,%rdx
mov    %rax,-0x70(%rbp)
cmp    -0x38(%rbp),%rax
je     1c90 <mlogit_warp_grad+0xaa0>
test   %r9d,%r9d
jle    18d0 <mlogit_warp_grad+0x6e0>
mov    %r9d,%esi
cmp    $0x4,%r9d
jae    17b0 <mlogit_warp_grad+0x5c0>
xor    %eax,%eax
jmp    18b0 <mlogit_warp_grad+0x6c0>
nopw   0x0(%rax,%rax,1)
mov    %esi,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rdx,%rdx
je     1c53 <mlogit_warp_grad+0xa63>
mov    %rbx,%rdi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rdi
xor    %edx,%edx
nop
movapd (%r12,%rdx,8),%xmm0
movapd 0x10(%r12,%rdx,8),%xmm1
mulpd  (%r10,%rdx,8),%xmm0
mulpd  0x10(%r10,%rdx,8),%xmm1
movupd (%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,(%rcx,%rdx,8)
movapd %xmm0,0x10(%rcx,%rdx,8)
movapd 0x20(%r12,%rdx,8),%xmm0
movapd 0x30(%r12,%rdx,8),%xmm1
mulpd  0x20(%r10,%rdx,8),%xmm0
mulpd  0x30(%r10,%rdx,8),%xmm1
movupd 0x20(%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,0x20(%rcx,%rdx,8)
movapd %xmm0,0x30(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    17e0 <mlogit_warp_grad+0x5f0>
test   $0x1,%bl
je     18a5 <mlogit_warp_grad+0x6b5>
movapd (%r12,%rdx,8),%xmm0
movapd 0x10(%r12,%rdx,8),%xmm1
mulpd  (%r10,%rdx,8),%xmm0
mulpd  0x10(%r10,%rdx,8),%xmm1
movupd (%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,(%rcx,%rdx,8)
movapd %xmm0,0x10(%rcx,%rdx,8)
cmp    %rsi,%rax
je     18d0 <mlogit_warp_grad+0x6e0>
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
mulsd  (%r10,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    18b0 <mlogit_warp_grad+0x6c0>
mov    -0xb8(%rbp),%rdi
lea    -0x54(%rbp),%rsi
mov    -0x88(%rbp),%rdx
lea    -0x50(%rbp),%r8
call   1060 <trapz@plt>
mov    -0x48(%rbp),%rbx
mov    -0x40(%rbp),%rcx
movsd  -0x50(%rbp),%xmm0
mov    -0xc0(%rbp),%rax
mov    -0x70(%rbp),%rdx
movsd  %xmm0,(%rax,%rdx,8)
mov    -0x2c(%rbp),%r9d
test   %r9d,%r9d
mov    -0x120(%rbp),%rsi
jle    1a3e <mlogit_warp_grad+0x84e>
cmp    $0x4,%r9d
jae    1930 <mlogit_warp_grad+0x740>
xor    %eax,%eax
jmp    1a20 <mlogit_warp_grad+0x830>
nopl   0x0(%rax)
mov    %r9d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1c63 <mlogit_warp_grad+0xa73>
mov    %r8,%rdi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rdi
xor    %edx,%edx
movapd (%rsi,%rdx,8),%xmm0
movapd 0x10(%rsi,%rdx,8),%xmm1
mulpd  (%rbx,%rdx,8),%xmm0
mulpd  0x10(%rbx,%rdx,8),%xmm1
movupd (%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,(%rcx,%rdx,8)
movapd %xmm0,0x10(%rcx,%rdx,8)
movapd 0x20(%rsi,%rdx,8),%xmm0
movapd 0x30(%rsi,%rdx,8),%xmm1
mulpd  0x20(%rbx,%rdx,8),%xmm0
mulpd  0x30(%rbx,%rdx,8),%xmm1
movupd 0x20(%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,0x20(%rcx,%rdx,8)
movapd %xmm0,0x30(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1960 <mlogit_warp_grad+0x770>
test   $0x1,%r8b
je     1a16 <mlogit_warp_grad+0x826>
movapd (%rsi,%rdx,8),%xmm0
movapd 0x10(%rsi,%rdx,8),%xmm1
mulpd  (%rbx,%rdx,8),%xmm0
mulpd  0x10(%rbx,%rdx,8),%xmm1
movupd (%r14,%rdx,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%r14,%rdx,8),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm2,(%rcx,%rdx,8)
movapd %xmm0,0x10(%rcx,%rdx,8)
cmp    %r9,%rax
je     1a3e <mlogit_warp_grad+0x84e>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    1a20 <mlogit_warp_grad+0x830>
lea    -0x2c(%rbp),%rbx
mov    %rbx,%rdi
lea    -0x54(%rbp),%rsi
mov    -0x88(%rbp),%r13
mov    %r13,%rdx
lea    -0x50(%rbp),%r8
call   1060 <trapz@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    -0x40(%rbp),%rdx
mov    -0xb0(%rbp),%rbx
mov    %rbx,%rcx
call   1050 <cumtrapz@plt>
mov    -0x48(%rbp),%r10
mov    -0x40(%rbp),%rcx
movslq -0x2c(%rbp),%r9
test   %r9,%r9
jle    1770 <mlogit_warp_grad+0x580>
mov    %r9d,%eax
movsd  -0x50(%rbp),%xmm0
cmp    $0x4,%r9d
jae    1aa0 <mlogit_warp_grad+0x8b0>
xor    %edx,%edx
jmp    1b70 <mlogit_warp_grad+0x980>
nop
mov    %eax,%edx
and    $0xfffffffc,%edx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rdx),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     1c74 <mlogit_warp_grad+0xa84>
mov    %r8,%rsi
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
and    %rdi,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd (%rbx,%rdi,8),%xmm2
movupd 0x10(%rbx,%rdi,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
movapd %xmm4,(%rcx,%rdi,8)
movapd %xmm2,0x10(%rcx,%rdi,8)
movupd 0x20(%rbx,%rdi,8),%xmm2
movupd 0x30(%rbx,%rdi,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
movapd %xmm1,%xmm2
subpd  %xmm3,%xmm2
movapd %xmm4,0x20(%rcx,%rdi,8)
movapd %xmm2,0x30(%rcx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1ae0 <mlogit_warp_grad+0x8f0>
test   $0x1,%r8b
je     1b60 <mlogit_warp_grad+0x970>
movupd (%rbx,%rdi,8),%xmm2
movupd 0x10(%rbx,%rdi,8),%xmm3
movapd %xmm1,%xmm4
subpd  %xmm2,%xmm4
subpd  %xmm3,%xmm1
movapd %xmm4,(%rcx,%rdi,8)
movapd %xmm1,0x10(%rcx,%rdi,8)
cmp    %rax,%rdx
mov    -0x80(%rbp),%r12
je     1b87 <mlogit_warp_grad+0x997>
nopl   0x0(%rax)
movapd %xmm0,%xmm1
subsd  (%rbx,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1b70 <mlogit_warp_grad+0x980>
test   %r9d,%r9d
jle    1770 <mlogit_warp_grad+0x580>
cmp    $0x4,%r9d
jae    1b9d <mlogit_warp_grad+0x9ad>
xor    %edx,%edx
jmp    1c20 <mlogit_warp_grad+0xa30>
mov    %eax,%edx
and    $0xfffffffc,%edx
lea    0x0(,%rax,8),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edi,%edi
movapd (%r10,%rdi,1),%xmm0
movapd 0x10(%r10,%rdi,1),%xmm1
addpd  %xmm0,%xmm0
addpd  %xmm1,%xmm1
movupd (%r14,%rdi,1),%xmm2
movupd 0x10(%r14,%rdi,1),%xmm3
mulpd  (%r12,%rdi,1),%xmm2
mulpd  0x10(%r12,%rdi,1),%xmm3
mulpd  (%rcx,%rdi,1),%xmm0
addpd  %xmm2,%xmm0
mulpd  0x10(%rcx,%rdi,1),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,(%r15,%rdi,1)
movupd %xmm1,0x10(%r15,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1bb0 <mlogit_warp_grad+0x9c0>
cmp    %rax,%rdx
je     1770 <mlogit_warp_grad+0x580>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r10,%rdx,8),%xmm0
addsd  %xmm0,%xmm0
movsd  (%r12,%rdx,8),%xmm1
mulsd  (%r14,%rdx,8),%xmm1
mulsd  (%rcx,%rdx,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1c20 <mlogit_warp_grad+0xa30>
jmp    1770 <mlogit_warp_grad+0x580>
xor    %edx,%edx
test   $0x1,%bl
jne    186b <mlogit_warp_grad+0x67b>
jmp    18a5 <mlogit_warp_grad+0x6b5>
xor    %edx,%edx
test   $0x1,%r8b
jne    19e0 <mlogit_warp_grad+0x7f0>
jmp    1a16 <mlogit_warp_grad+0x826>
xor    %edi,%edi
test   $0x1,%r8b
jne    1b3e <mlogit_warp_grad+0x94e>
jmp    1b60 <mlogit_warp_grad+0x970>
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,-0x50(%rbp)
cmpl   $0x0,-0x38(%rbp)
mov    -0x88(%rbp),%r13
jle    1d98 <mlogit_warp_grad+0xba8>
xor    %ebx,%ebx
mov    -0xd8(%rbp),%r14
mov    -0x38(%rbp),%r15
mov    -0xc0(%rbp),%r12
nopl   (%rax)
movsd  (%r14,%rbx,8),%xmm0
addsd  (%r12,%rbx,8),%xmm0
call   10d0 <exp@plt>
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1cc0 <mlogit_warp_grad+0xad0>
test   %r15d,%r15d
jle    1d98 <mlogit_warp_grad+0xba8>
mov    -0x2c(%rbp),%r11d
xor    %ebx,%ebx
mov    -0x90(%rbp),%r12
mov    %r12,%r14
mov    -0xc8(%rbp),%r15
jmp    1d25 <mlogit_warp_grad+0xb35>
cs nopw 0x0(%rax,%rax,1)
movslq %r11d,%rax
lea    (%r15,%rax,8),%r15
lea    (%r14,%rax,8),%r14
add    $0x1,%rbx
cmp    -0x38(%rbp),%rbx
je     1da3 <mlogit_warp_grad+0xbb3>
test   %r11d,%r11d
jle    1d10 <mlogit_warp_grad+0xb20>
mov    -0xc0(%rbp),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
xor    %r13d,%r13d
mov    -0xd8(%rbp),%r12
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r12,%rbx,8),%xmm0
addsd  -0x70(%rbp),%xmm0
call   10d0 <exp@plt>
mulsd  (%r15,%r13,8),%xmm0
movsd  %xmm0,(%r14,%r13,8)
add    $0x1,%r13
movslq -0x2c(%rbp),%r11
cmp    %r11,%r13
jl     1d50 <mlogit_warp_grad+0xb60>
mov    -0x88(%rbp),%r13
mov    -0x90(%rbp),%r12
jmp    1d10 <mlogit_warp_grad+0xb20>
nopl   0x0(%rax)
movq   $0x0,-0x50(%rbp)
mov    -0x2c(%rbp),%r11d
mov    -0x90(%rbp),%r12
mov    %r11d,%r15d
test   %r11d,%r11d
mov    -0x38(%rbp),%r14
jle    1f57 <mlogit_warp_grad+0xd67>
mov    %r15,%rdx
shl    $0x5,%rdx
lea    0x0(,%r15,8),%r13
lea    0x0(,%r13,2),%r9
add    %r13,%r9
mov    %r15,%r10
shl    $0x4,%r10
mov    %r12,%r8
xor    %ebx,%ebx
jmp    1dfa <mlogit_warp_grad+0xc0a>
nopl   0x0(%rax,%rax,1)
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
add    $0x8,%r8
cmp    %r15,%rbx
je     1ea0 <mlogit_warp_grad+0xcb0>
movsd  (%r12,%rbx,8),%xmm0
mov    -0x40(%rbp),%rax
movsd  %xmm0,(%rax,%rbx,8)
cmp    $0x2,%r14d
jl     1de9 <mlogit_warp_grad+0xbf9>
mov    $0x1,%edi
cmpq   $0x3,-0xa8(%rbp)
03
jb     1e5c <mlogit_warp_grad+0xc6c>
mov    $0x1,%edi
mov    %r8,%rax
mov    -0x118(%rbp),%rsi
nopl   (%rax)
addsd  (%rax,%r15,8),%xmm0
addsd  (%rax,%r10,1),%xmm0
addsd  (%rax,%r9,1),%xmm0
addsd  (%rax,%rdx,1),%xmm0
add    %rdx,%rax
lea    (%rsi,%rdi,1),%rcx
add    $0x4,%rcx
add    $0x4,%rdi
cmp    $0x1,%rcx
jne    1e30 <mlogit_warp_grad+0xc40>
cmpq   $0x0,-0x98(%rbp)
je     1de0 <mlogit_warp_grad+0xbf0>
imul   %r15,%rdi
add    %rbx,%rdi
lea    (%r12,%rdi,8),%rax
mov    -0x98(%rbp),%rdi
nopl   0x0(%rax)
addsd  (%rax),%xmm0
add    %r13,%rax
add    $0xffffffffffffffff,%rdi
jne    1e80 <mlogit_warp_grad+0xc90>
jmp    1de0 <mlogit_warp_grad+0xbf0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %r11d,%r11d
mov    -0x40(%rbp),%rcx
mov    -0x88(%rbp),%r13
jle    1f57 <mlogit_warp_grad+0xd67>
movsd  -0x50(%rbp),%xmm0
cmp    $0x1,%r11d
jne    1ec3 <mlogit_warp_grad+0xcd3>
xor    %eax,%eax
jmp    1f40 <mlogit_warp_grad+0xd50>
mov    %r15d,%eax
and    $0xfffffffe,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rax),%rsi
mov    %rsi,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     295f <mlogit_warp_grad+0x176f>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd (%rcx,%rsi,8),%xmm2
movapd 0x10(%rcx,%rsi,8),%xmm3
divpd  %xmm1,%xmm2
movapd %xmm2,(%rcx,%rsi,8)
divpd  %xmm1,%xmm3
movapd %xmm3,0x10(%rcx,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1f00 <mlogit_warp_grad+0xd10>
test   $0x1,%dl
je     1f3b <mlogit_warp_grad+0xd4b>
movapd (%rcx,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movapd %xmm2,(%rcx,%rsi,8)
cmp    %r15,%rax
je     1f57 <mlogit_warp_grad+0xd67>
movsd  (%rcx,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1f40 <mlogit_warp_grad+0xd50>
test   %r14d,%r14d
mov    -0x80(%rbp),%r12
jle    20c0 <mlogit_warp_grad+0xed0>
movslq %r11d,%r14
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%r8
mov    %r8,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10,%r9
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%r9
shl    $0x3,%r14
mov    -0x90(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
xor    %edx,%edx
jmp    1fc4 <mlogit_warp_grad+0xdd4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %r14,%rsi
add    %r14,%rdi
add    $0x1,%rdx
cmp    -0x38(%rbp),%rdx
je     20c0 <mlogit_warp_grad+0xed0>
test   %r11d,%r11d
jle    1fb0 <mlogit_warp_grad+0xdc0>
mov    0x18(%rbp),%rax
xorps  %xmm0,%xmm0
cvtsi2sdl (%rax,%rdx,4),%xmm0
cmp    $0x4,%r11d
jae    1ff0 <mlogit_warp_grad+0xe00>
xor    %eax,%eax
jmp    2090 <mlogit_warp_grad+0xea0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
test   %r8,%r8
je     20ac <mlogit_warp_grad+0xebc>
mov    %r9,%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd (%rsi,%rax,8),%xmm2
movupd 0x10(%rsi,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rax,8)
movupd %xmm3,0x10(%rdi,%rax,8)
movupd 0x20(%rsi,%rax,8),%xmm2
movupd 0x30(%rsi,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rdi,%rax,8)
movupd %xmm3,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbx
jne    2010 <mlogit_warp_grad+0xe20>
test   $0x1,%r10b
je     207c <mlogit_warp_grad+0xe8c>
movupd (%rsi,%rax,8),%xmm2
movupd 0x10(%rsi,%rax,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rdi,%rax,8)
movupd %xmm3,0x10(%rdi,%rax,8)
mov    %rcx,%rax
cmp    %r15,%rcx
mov    -0x80(%rbp),%r12
je     1fb0 <mlogit_warp_grad+0xdc0>
nopl   0x0(%rax)
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    2090 <mlogit_warp_grad+0xea0>
jmp    1fb0 <mlogit_warp_grad+0xdc0>
xor    %eax,%eax
test   $0x1,%r10b
jne    205e <mlogit_warp_grad+0xe6e>
jmp    207c <mlogit_warp_grad+0xe8c>
cs nopw 0x0(%rax,%rax,1)
test   %r11d,%r11d
mov    -0x60(%rbp),%r14
jle    22ca <mlogit_warp_grad+0x10da>
mov    %r15,%rdx
shl    $0x5,%rdx
lea    0x0(,%r15,8),%r13
lea    0x0(,%r13,2),%r9
add    %r13,%r9
mov    %r15,%r10
shl    $0x4,%r10
mov    -0x90(%rbp),%r12
mov    %r12,%r8
xor    %ebx,%ebx
jmp    211b <mlogit_warp_grad+0xf2b>
nopl   0x0(%rax)
mov    -0x60(%rbp),%r14
movsd  %xmm0,(%r14,%rbx,8)
add    $0x1,%rbx
add    $0x8,%r8
cmp    %r15,%rbx
je     21c0 <mlogit_warp_grad+0xfd0>
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,(%r14,%rbx,8)
cmpl   $0x2,-0x38(%rbp)
jl     210a <mlogit_warp_grad+0xf1a>
mov    $0x1,%edi
cmpq   $0x3,-0xa8(%rbp)
03
mov    -0x118(%rbp),%rsi
jb     217c <mlogit_warp_grad+0xf8c>
mov    $0x1,%edi
mov    %r8,%rax
nopl   0x0(%rax,%rax,1)
addsd  (%rax,%r15,8),%xmm0
addsd  (%rax,%r10,1),%xmm0
addsd  (%rax,%r9,1),%xmm0
addsd  (%rax,%rdx,1),%xmm0
add    %rdx,%rax
lea    (%rsi,%rdi,1),%rcx
add    $0x4,%rcx
add    $0x4,%rdi
cmp    $0x1,%rcx
jne    2150 <mlogit_warp_grad+0xf60>
testb  $0x3,-0x110(%rbp)
je     2100 <mlogit_warp_grad+0xf10>
imul   %r15,%rdi
add    %rbx,%rdi
lea    (%r12,%rdi,8),%rax
mov    -0x98(%rbp),%rdi
nopl   0x0(%rax,%rax,1)
addsd  (%rax),%xmm0
add    %r13,%rax
add    $0xffffffffffffffff,%rdi
jne    21a0 <mlogit_warp_grad+0xfb0>
jmp    2100 <mlogit_warp_grad+0xf10>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %r11d,%r11d
mov    -0x80(%rbp),%r12
mov    -0x40(%rbp),%rdi
mov    -0x88(%rbp),%r13
jle    22ca <mlogit_warp_grad+0x10da>
cmp    $0x4,%r11d
jae    21e9 <mlogit_warp_grad+0xff9>
xor    %eax,%eax
mov    -0x60(%rbp),%r14
jmp    22b0 <mlogit_warp_grad+0x10c0>
mov    %r15d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     296f <mlogit_warp_grad+0x177f>
mov    %rcx,%rsi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rsi
xor    %edx,%edx
mov    -0x60(%rbp),%rbx
nopl   (%rax)
movapd (%rbx,%rdx,8),%xmm0
movapd 0x10(%rbx,%rdx,8),%xmm1
movapd 0x20(%rbx,%rdx,8),%xmm2
movapd 0x30(%rbx,%rdx,8),%xmm3
subpd  (%rdi,%rdx,8),%xmm0
subpd  0x10(%rdi,%rdx,8),%xmm1
movapd %xmm0,(%rbx,%rdx,8)
movapd %xmm1,0x10(%rbx,%rdx,8)
subpd  0x20(%rdi,%rdx,8),%xmm2
subpd  0x30(%rdi,%rdx,8),%xmm3
movapd %xmm2,0x20(%rbx,%rdx,8)
movapd %xmm3,0x30(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    2220 <mlogit_warp_grad+0x1030>
test   $0x1,%cl
je     2299 <mlogit_warp_grad+0x10a9>
mov    -0x60(%rbp),%rcx
movapd (%rcx,%rdx,8),%xmm0
movapd 0x10(%rcx,%rdx,8),%xmm1
subpd  (%rdi,%rdx,8),%xmm0
subpd  0x10(%rdi,%rdx,8),%xmm1
movapd %xmm0,(%rcx,%rdx,8)
movapd %xmm1,0x10(%rcx,%rdx,8)
cmp    %r15,%rax
mov    -0x60(%rbp),%r14
je     22ca <mlogit_warp_grad+0x10da>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r14,%rax,8),%xmm0
subsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    22b0 <mlogit_warp_grad+0x10c0>
mov    -0xb8(%rbp),%rdi
mov    %r13,%rsi
mov    %r14,%rdx
mov    -0x48(%rbp),%rbx
mov    %rbx,%rcx
lea    -0x78(%rbp),%r8
call   10c0 <innerprod_q@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
mov    -0xd8(%rbp),%r15
mov    -0x100(%rbp),%rsi
jle    241d <mlogit_warp_grad+0x122d>
movsd  -0x78(%rbp),%xmm0
xorpd  0xd03(%rip),%xmm0
cmp    $0x4,%eax
jae    2320 <mlogit_warp_grad+0x1130>
xor    %ecx,%ecx
jmp    2400 <mlogit_warp_grad+0x1210>
nopl   0x0(%rax)
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     294a <mlogit_warp_grad+0x175a>
mov    %r8,%rdi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rdi
xor    %edx,%edx
mov    -0x60(%rbp),%r14
nopl   0x0(%rax,%rax,1)
movapd (%rbx,%rdx,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  (%r14,%rdx,8),%xmm2
movapd 0x10(%rbx,%rdx,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  0x10(%r14,%rdx,8),%xmm3
movapd %xmm2,(%rsi,%rdx,8)
movapd %xmm3,0x10(%rsi,%rdx,8)
movapd 0x20(%rbx,%rdx,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  0x20(%r14,%rdx,8),%xmm2
movapd 0x30(%rbx,%rdx,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  0x30(%r14,%rdx,8),%xmm3
movapd %xmm2,0x20(%rsi,%rdx,8)
movapd %xmm3,0x30(%rsi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    2360 <mlogit_warp_grad+0x1170>
test   $0x1,%r8b
je     23f0 <mlogit_warp_grad+0x1200>
movapd (%rbx,%rdx,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  (%r14,%rdx,8),%xmm2
mulpd  0x10(%rbx,%rdx,8),%xmm1
addpd  0x10(%r14,%rdx,8),%xmm1
movapd %xmm2,(%rsi,%rdx,8)
movapd %xmm1,0x10(%rsi,%rdx,8)
cmp    %rax,%rcx
je     241d <mlogit_warp_grad+0x122d>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2400 <mlogit_warp_grad+0x1210>
lea    -0x2c(%rbp),%rdi
lea    -0xe0(%rbp),%rdx
lea    -0x78(%rbp),%rcx
call   1090 <pvecnorm@plt>
movsd  -0x78(%rbp),%xmm0
mulsd  -0x108(%rbp),%xmm0
ff
call   10e0 <cos@plt>
movapd %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x108(%rbp),%xmm0
ff
call   1070 <sin@plt>
mov    -0x100(%rbp),%r10
mov    -0x2c(%rbp),%r9d
test   %r9d,%r9d
mov    -0x40(%rbp),%rdx
mov    -0x150(%rbp),%rbx
mov    -0x148(%rbp),%r14
jle    26f8 <mlogit_warp_grad+0x1508>
movsd  -0x78(%rbp),%xmm1
cmp    $0x1,%r9d
jne    24a0 <mlogit_warp_grad+0x12b0>
xor    %ecx,%ecx
mov    -0x48(%rbp),%rax
movapd -0x70(%rbp),%xmm7
jmp    2580 <mlogit_warp_grad+0x1390>
nopl   0x0(%rax,%rax,1)
mov    -0x48(%rbp),%rax
lea    (%rax,%r9,8),%rcx
cmp    %rcx,%r14
movapd -0x70(%rbp),%xmm7
jae    24c2 <mlogit_warp_grad+0x12d2>
lea    (%r14,%r9,8),%rcx
cmp    %rcx,%rax
jae    24c2 <mlogit_warp_grad+0x12d2>
xor    %ecx,%ecx
jmp    2580 <mlogit_warp_grad+0x1390>
mov    %r9d,%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),%rsi
mov    %rsi,%r8
shr    %r8
add    $0x1,%r8
test   %rsi,%rsi
je     2990 <mlogit_warp_grad+0x17a0>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movapd (%r10,%rsi,8),%xmm5
divpd  %xmm4,%xmm5
mulpd  %xmm2,%xmm5
movapd (%rax,%rsi,8),%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm5,%xmm6
movapd %xmm6,(%r14,%rsi,8)
movapd 0x10(%r10,%rsi,8),%xmm5
divpd  %xmm4,%xmm5
mulpd  %xmm2,%xmm5
movapd 0x10(%rax,%rsi,8),%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm5,%xmm6
movapd %xmm6,0x10(%r14,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    2500 <mlogit_warp_grad+0x1310>
test   $0x1,%r8b
je     2572 <mlogit_warp_grad+0x1382>
movapd (%r10,%rsi,8),%xmm5
divpd  %xmm4,%xmm5
mulpd  %xmm5,%xmm2
mulpd  (%rax,%rsi,8),%xmm3
addpd  %xmm2,%xmm3
movapd %xmm3,(%r14,%rsi,8)
cmp    %r9,%rcx
je     260e <mlogit_warp_grad+0x141e>
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rsi
test   $0x1,%r9b
je     25b1 <mlogit_warp_grad+0x13c1>
movsd  (%r10,%rcx,8),%xmm2
divsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r14,%rcx,8)
mov    %rcx,%rsi
or     $0x1,%rsi
not    %rcx
add    %r9,%rcx
je     260e <mlogit_warp_grad+0x141e>
nopl   0x0(%rax)
movsd  (%r10,%rsi,8),%xmm2
divsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  (%rax,%rsi,8),%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r14,%rsi,8)
movsd  0x8(%r10,%rsi,8),%xmm2
divsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
movsd  0x8(%rax,%rsi,8),%xmm3
mulsd  %xmm7,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x8(%r14,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%r9
jne    25c0 <mlogit_warp_grad+0x13d0>
test   %r9d,%r9d
jle    26f8 <mlogit_warp_grad+0x1508>
cmp    $0x4,%r9d
jae    2624 <mlogit_warp_grad+0x1434>
xor    %ecx,%ecx
jmp    26e0 <mlogit_warp_grad+0x14f0>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     297f <mlogit_warp_grad+0x178f>
mov    %r8,%rdi
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd (%r14,%rsi,8),%xmm0
movapd 0x10(%r14,%rsi,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movapd %xmm0,(%rdx,%rsi,8)
movapd %xmm1,0x10(%rdx,%rsi,8)
movapd 0x20(%r14,%rsi,8),%xmm0
movapd 0x30(%r14,%rsi,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movapd %xmm0,0x20(%rdx,%rsi,8)
movapd %xmm1,0x30(%rdx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    2660 <mlogit_warp_grad+0x1470>
test   $0x1,%r8b
je     26d2 <mlogit_warp_grad+0x14e2>
movapd (%r14,%rsi,8),%xmm0
movapd 0x10(%r14,%rsi,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movapd %xmm0,(%rdx,%rsi,8)
movapd %xmm1,0x10(%rdx,%rsi,8)
cmp    %r9,%rcx
je     26f8 <mlogit_warp_grad+0x1508>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r9
jne    26e0 <mlogit_warp_grad+0x14f0>
lea    -0x2c(%rbp),%rdi
mov    %r13,%rsi
mov    %rbx,%rcx
call   1050 <cumtrapz@plt>
mov    -0x2c(%rbp),%eax
test   %eax,%eax
mov    -0xc0(%rbp),%rdi
jle    27ac <mlogit_warp_grad+0x15bc>
lea    -0x1(%rax),%ecx
cmp    $0x1,%eax
jne    2730 <mlogit_warp_grad+0x1540>
xor    %edx,%edx
jmp    2789 <mlogit_warp_grad+0x1599>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,%esi
and    $0xfffffffe,%esi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rbx),%xmm0
movsd  (%rbx,%rdx,8),%xmm1
movsd  0x8(%rbx,%rdx,8),%xmm2
subsd  %xmm0,%xmm1
movsd  (%rbx,%rcx,8),%xmm3
subsd  %xmm0,%xmm3
divsd  %xmm3,%xmm1
movsd  %xmm1,(%rbx,%rdx,8)
movsd  (%rbx),%xmm0
subsd  %xmm0,%xmm2
movsd  (%rbx,%rcx,8),%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    2740 <mlogit_warp_grad+0x1550>
test   $0x1,%al
je     27ac <mlogit_warp_grad+0x15bc>
movsd  (%rbx,%rdx,8),%xmm0
movsd  (%rbx),%xmm1
subsd  %xmm1,%xmm0
movsd  (%rbx,%rcx,8),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movq   $0x0,-0x78(%rbp)
cmpl   $0x0,-0x38(%rbp)
jle    2860 <mlogit_warp_grad+0x1670>
cmpq   $0x0,-0x110(%rbp)
je     2920 <mlogit_warp_grad+0x1730>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x18(%rbp),%rcx
mov    -0x130(%rbp),%rdx
nopl   (%rax)
xorps  %xmm1,%xmm1
cvtsi2sdl (%rcx,%rax,4),%xmm1
movsd  (%r15,%rax,8),%xmm2
movsd  0x8(%r15,%rax,8),%xmm3
addsd  (%rdi,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsi2sdl 0x4(%rcx,%rax,4),%xmm0
addsd  0x8(%rdi,%rax,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
add    $0x2,%rax
movapd %xmm3,%xmm0
cmp    %rax,%rdx
jne    27e0 <mlogit_warp_grad+0x15f0>
testb  $0x1,-0x38(%rbp)
je     2847 <mlogit_warp_grad+0x1657>
xorps  %xmm0,%xmm0
cvtsi2sdl (%rcx,%rax,4),%xmm0
movsd  (%r15,%rax,8),%xmm1
addsd  (%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  %xmm1,%xmm3
movapd %xmm3,-0x70(%rbp)
movsd  %xmm3,-0x78(%rbp)
jmp    2869 <mlogit_warp_grad+0x1679>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorpd  %xmm0,%xmm0
movapd %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
call   10f0 <log@plt>
movapd -0x70(%rbp),%xmm2
subsd  %xmm0,%xmm2
mov    -0xf8(%rbp),%rax
mov    -0xd0(%rbp),%rsi
movsd  %xmm2,(%rax,%rsi,8)
cmpl   $0x1,-0xe4(%rbp)
jne    28b9 <mlogit_warp_grad+0x16c9>
lea    0x789(%rip),%rdi
movapd %xmm2,%xmm0
movapd %xmm2,-0x70(%rbp)
call   1040 <printf@plt>
movapd -0x70(%rbp),%xmm2
mov    -0xd0(%rbp),%rsi
cmp    $0x2,%rsi
jb     15a0 <mlogit_warp_grad+0x3b0>
mov    -0xf8(%rbp),%rax
subsd  -0x8(%rax,%rsi,8),%xmm2
movapd %xmm2,%xmm0
andpd  0x724(%rip),%xmm0
movsd  -0x138(%rbp),%xmm1
ff
ucomisd %xmm0,%xmm1
mov    -0xa0(%rbp),%r8
mov    -0xb0(%rbp),%rdi
ja     29a1 <mlogit_warp_grad+0x17b1>
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm0
ja     29a1 <mlogit_warp_grad+0x17b1>
cmp    -0xf0(%rbp),%rsi
jl     15bb <mlogit_warp_grad+0x3cb>
jmp    29a1 <mlogit_warp_grad+0x17b1>
nopl   0x0(%rax)
xorpd  %xmm3,%xmm3
xor    %eax,%eax
mov    0x18(%rbp),%rcx
testb  $0x1,-0x38(%rbp)
jne    282c <mlogit_warp_grad+0x163c>
jmp    2847 <mlogit_warp_grad+0x1657>
xor    %esi,%esi
test   $0x1,%r11b
jne    16a2 <mlogit_warp_grad+0x4b2>
jmp    16c6 <mlogit_warp_grad+0x4d6>
xor    %edx,%edx
mov    -0x60(%rbp),%r14
test   $0x1,%r8b
jne    23c9 <mlogit_warp_grad+0x11d9>
jmp    23f0 <mlogit_warp_grad+0x1200>
xor    %esi,%esi
test   $0x1,%dl
jne    1f2d <mlogit_warp_grad+0xd3d>
jmp    1f3b <mlogit_warp_grad+0xd4b>
xor    %edx,%edx
test   $0x1,%cl
jne    2274 <mlogit_warp_grad+0x1084>
jmp    2299 <mlogit_warp_grad+0x10a9>
xor    %esi,%esi
test   $0x1,%r8b
jne    26b2 <mlogit_warp_grad+0x14c2>
jmp    26d2 <mlogit_warp_grad+0x14e2>
xor    %esi,%esi
test   $0x1,%r8b
jne    2555 <mlogit_warp_grad+0x1365>
jmp    2572 <mlogit_warp_grad+0x1382>
mov    -0x2c(%rbp),%edx
cmp    $0x2,%edx
jl     29cb <mlogit_warp_grad+0x17db>
mov    0x40(%rbp),%rdi
add    $0x8,%rdi
add    $0x8,%rbx
add    $0xffffffff,%edx
shl    $0x3,%rdx
mov    %rbx,%rsi
call   1080 <memcpy@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x128(%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 @mlogit_warp_grad(i32* %0, i32* %1, double* %2, double* %3, double* %4, double* %5, double* %6, i32* %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 i32*
%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 i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i8*
%39 = alloca i64
%40 = alloca i64
%41 = alloca i64
%42 = alloca i64
%43 = alloca i64
%44 = alloca i64
%45 = alloca i64
%46 = alloca i64
%47 = alloca double
%48 = alloca double
%49 = alloca double
%50 = alloca double
%51 = alloca i64
%52 = alloca i64
%53 = alloca i64
%54 = alloca i64
%55 = alloca i64
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca i64
%60 = alloca double*
%61 = alloca double*
%62 = alloca double*
%63 = alloca double*
%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 i32*
%77 = alloca double*
%78 = alloca double*
%79 = 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 i32* %7, i32** %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
%80 = load i32*, i32** %14
%81 = load i32, i32* %80
store i32 %81, i32* %27
%82 = load i32*, i32** %15
%83 = load i32, i32* %82
store i32 %83, i32* %28
%84 = load i32*, i32** %22
%85 = load i32, i32* %84
store i32 %85, i32* %29
%86 = load double*, double** %18
%87 = load double, double* %86
store double %87, double* %30
%88 = load double*, double** %23
%89 = load double, double* %88
store double %89, double* %31
%90 = load double*, double** %24
%91 = load double, double* %90
store double %91, double* %32
%92 = load i32*, i32** %25
%93 = load i32, i32* %92
%94 = sitofp i32 %93 to double
store double %94, double* %33
store i32 1, i32* %36
store i32 1, i32* %37
%95 = load i32, i32* %27
%96 = zext i32 %95 to i64
%97 = call i8* @llvm.stacksave()
store i8* %97, i8** %38
%98 = alloca double, i64 %96
store i64 %96, i64* %39
%99 = load i32, i32* %27
%100 = zext i32 %99 to i64
%101 = alloca double, i64 %100
store i64 %100, i64* %40
%102 = load i32, i32* %27
%103 = zext i32 %102 to i64
%104 = alloca double, i64 %103
store i64 %103, i64* %41
%105 = load i32, i32* %27
%106 = zext i32 %105 to i64
%107 = alloca double, i64 %106
store i64 %106, i64* %42
%108 = load i32, i32* %28
%109 = zext i32 %108 to i64
%110 = alloca double, i64 %109
store i64 %109, i64* %43
%111 = load i32, i32* %27
%112 = load i32, i32* %28
%113 = mul nsw i32 %111, %112
%114 = zext i32 %113 to i64
%115 = alloca double, i64 %114
store i64 %114, i64* %44
%116 = load i32, i32* %27
%117 = zext i32 %116 to i64
%118 = alloca double, i64 %117
store i64 %117, i64* %45
%119 = load i32, i32* %27
%120 = zext i32 %119 to i64
%121 = alloca double, i64 %120
store i64 %120, i64* %46
%122 = load double, double* @DBL_EPSILON
store double %122, double* %50
%123 = load i32, i32* %27
%124 = load i32, i32* %28
%125 = mul nsw i32 %123, %124
%126 = zext i32 %125 to i64
%127 = alloca double, i64 %126
store i64 %126, i64* %51
%128 = load i32, i32* %27
%129 = zext i32 %128 to i64
%130 = alloca double, i64 %129
store i64 %129, i64* %52
%131 = load i32, i32* %27
%132 = zext i32 %131 to i64
%133 = alloca double, i64 %132
store i64 %132, i64* %53
%134 = load i32, i32* %27
%135 = zext i32 %134 to i64
%136 = alloca double, i64 %135
store i64 %135, i64* %54
%137 = load i32, i32* %27
%138 = zext i32 %137 to i64
%139 = alloca double, i64 %138
store i64 %138, i64* %55
%140 = load i32, i32* %29
%141 = zext i32 %140 to i64
%142 = alloca double, i64 %141
store i64 %141, i64* %59
%143 = load i32, i32* %27
%144 = sext i32 %143 to i64
%145 = mul i64 8, %144
%146 = trunc i64 %145 to i32
%147 = call double* @malloc(i32 %146)
store double* %147, double** %60
store double 0.000000e+00, double* %49
store i32 0, i32* %34
br label %148
148: ; preds = %168, %13
%149 = load i32, i32* %34
%150 = load i32, i32* %27
%151 = sub nsw i32 %150, 1
%152 = icmp slt i32 %149, %151
br i1 %152, label %153, label %171
153: ; preds = %148
%154 = load double*, double** %18
%155 = load i32, i32* %34
%156 = add nsw i32 %155, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds double, double* %154, i64 %157
%159 = load double, double* %158
%160 = load double*, double** %18
%161 = load i32, i32* %34
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %160, i64 %162
%164 = load double, double* %163
%165 = fsub double %159, %164
%166 = load double, double* %49
%167 = fadd double %166, %165
store double %167, double* %49
br label %168
168: ; preds = %153
%169 = load i32, i32* %34
%170 = add nsw i32 %169, 1
store i32 %170, i32* %34
br label %148
171: ; preds = %148
%172 = load double, double* %49
%173 = load i32, i32* %27
%174 = sub nsw i32 %173, 1
%175 = sitofp i32 %174 to double
%176 = fdiv double %172, %175
store double %176, double* %49
store i32 0, i32* %34
br label %177
177: ; preds = %190, %171
%178 = load i32, i32* %34
%179 = load i32, i32* %27
%180 = icmp slt i32 %178, %179
br i1 %180, label %181, label %193
181: ; preds = %177
%182 = load double*, double** %19
%183 = load i32, i32* %34
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds double, double* %182, i64 %184
%186 = load double, double* %185
%187 = load i32, i32* %34
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double, double* %98, i64 %188
store double %186, double* %189
br label %190
190: ; preds = %181
%191 = load i32, i32* %34
%192 = add nsw i32 %191, 1
store i32 %192, i32* %34
br label %177
193: ; preds = %177
store double* %101, double** %61
store double* %98, double** %62
%194 = load i32*, i32** %14
%195 = load double*, double** %62
%196 = load double*, double** %61
%197 = call i32 @gradient(i32* %194, i32* %36, double* %195, double* %49, double* %196)
store i32 0, i32* %34
br label %198
198: ; preds = %214, %193
%199 = load i32, i32* %34
%200 = load i32, i32* %27
%201 = icmp slt i32 %199, %200
br i1 %201, label %202, label %217
202: ; preds = %198
%203 = load i32, i32* %34
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds double, double* %101, i64 %204
%206 = load double, double* %205
%207 = call double @llvm.fabs.f64(double %206)
%208 = load double, double* %50
%209 = fadd double %207, %208
%210 = call double @sqrt(double %209)
%211 = load i32, i32* %34
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds double, double* %101, i64 %212
store double %210, double* %213
br label %214
214: ; preds = %202
%215 = load i32, i32* %34
%216 = add nsw i32 %215, 1
store i32 %216, i32* %34
br label %198
217: ; preds = %198
br label %218
218: ; preds = %857, %217
%219 = load double*, double** %20
store double* %219, double** %63
store double* %104, double** %64
store double* %107, double** %65
%220 = load double*, double** %16
store double* %220, double** %72
%221 = load double*, double** %17
store double* %221, double** %73
store i32 0, i32* %35
br label %222
222: ; preds = %249, %218
%223 = load i32, i32* %35
%224 = load i32, i32* %27
%225 = icmp slt i32 %223, %224
br i1 %225, label %226, label %252
226: ; preds = %222
%227 = load double*, double** %18
%228 = load i32, i32* %27
%229 = sub nsw i32 %228, 1
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds double, double* %227, i64 %230
%232 = load double, double* %231
%233 = load double*, double** %18
%234 = getelementptr inbounds double, double* %233, i64 0
%235 = load double, double* %234
%236 = fsub double %232, %235
%237 = load double*, double** %62
%238 = load i32, i32* %35
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds double, double* %237, i64 %239
%241 = load double, double* %240
%242 = load double*, double** %18
%243 = getelementptr inbounds double, double* %242, i64 0
%244 = load double, double* %243
%245 = call double @llvm.fmuladd.f64(double %236, double %241, double %244)
%246 = load i32, i32* %35
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %118, i64 %247
store double %245, double* %248
br label %249
249: ; preds = %226
%250 = load i32, i32* %35
%251 = add nsw i32 %250, 1
store i32 %251, i32* %35
br label %222
252: ; preds = %222
store double* %118, double** %66
%253 = load i32, i32* %27
%254 = load double*, double** %18
%255 = load double*, double** %63
%256 = load i32, i32* %27
%257 = load double*, double** %66
%258 = load double*, double** %64
%259 = call i32 @spline(i32 %253, double* %254, double* %255, i32 %256, double* %257, double* %258)
store double* %121, double** %67
%260 = load i32*, i32** %14
%261 = load double*, double** %63
%262 = load double*, double** %67
%263 = call i32 @gradient(i32* %260, i32* %36, double* %261, double* %49, double* %262)
%264 = load i32, i32* %27
%265 = load double*, double** %18
%266 = load double*, double** %67
%267 = load i32, i32* %27
%268 = load double*, double** %66
%269 = load double*, double** %65
%270 = call i32 @spline(i32 %264, double* %265, double* %266, i32 %267, double* %268, double* %269)
store double* %110, double** %68
store double* %115, double** %69
%271 = load double*, double** %60
store double* %271, double** %71
store double* %47, double** %70
store i32 0, i32* %35
br label %272
272: ; preds = %417, %252
%273 = load i32, i32* %35
%274 = load i32, i32* %28
%275 = icmp slt i32 %273, %274
br i1 %275, label %276, label %420
276: ; preds = %272
store i32 0, i32* %34
br label %277
277: ; preds = %302, %276
%278 = load i32, i32* %34
%279 = load i32, i32* %27
%280 = icmp slt i32 %278, %279
br i1 %280, label %281, label %305
281: ; preds = %277
%282 = load double*, double** %64
%283 = load i32, i32* %34
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds double, double* %282, i64 %284
%286 = load double, double* %285
%287 = load double*, double** %61
%288 = load i32, i32* %34
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double, double* %287, i64 %289
%291 = load double, double* %290
%292 = fmul double %286, %291
%293 = load double*, double** %73
%294 = load i32, i32* %34
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds double, double* %293, i64 %295
%297 = load double, double* %296
%298 = fmul double %292, %297
%299 = load i32, i32* %34
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double, double* %121, i64 %300
store double %298, double* %301
br label %302
302: ; preds = %281
%303 = load i32, i32* %34
%304 = add nsw i32 %303, 1
store i32 %304, i32* %34
br label %277
305: ; preds = %277
store double* %121, double** %67
%306 = load i32*, i32** %14
%307 = load double*, double** %18
%308 = load double*, double** %67
%309 = load double*, double** %70
%310 = call i32 @trapz(i32* %306, i32* %36, double* %307, double* %308, double* %309)
%311 = load double, double* %47
%312 = load i32, i32* %35
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds double, double* %110, i64 %313
store double %311, double* %314
store i32 0, i32* %34
br label %315
315: ; preds = %340, %305
%316 = load i32, i32* %34
%317 = load i32, i32* %27
%318 = icmp slt i32 %316, %317
br i1 %318, label %319, label %343
319: ; preds = %315
%320 = load double*, double** %65
%321 = load i32, i32* %34
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds double, double* %320, i64 %322
%324 = load double, double* %323
%325 = load double*, double** %61
%326 = load i32, i32* %34
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds double, double* %325, i64 %327
%329 = load double, double* %328
%330 = fmul double %324, %329
%331 = load double*, double** %73
%332 = load i32, i32* %34
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %331, i64 %333
%335 = load double, double* %334
%336 = fmul double %330, %335
%337 = load i32, i32* %34
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds double, double* %121, i64 %338
store double %336, double* %339
br label %340
340: ; preds = %319
%341 = load i32, i32* %34
%342 = add nsw i32 %341, 1
store i32 %342, i32* %34
br label %315
343: ; preds = %315
store double* %121, double** %67
%344 = load double*, double** %18
%345 = load double*, double** %67
%346 = load double*, double** %70
%347 = call i32 @trapz(i32* %27, i32* %36, double* %344, double* %345, double* %346)
%348 = load double*, double** %18
%349 = load double*, double** %67
%350 = load double*, double** %71
%351 = call i32 @cumtrapz(i32* %27, double* %348, double* %349, double* %350)
store i32 0, i32* %34
br label %352
352: ; preds = %369, %343
%353 = load i32, i32* %34
%354 = load i32, i32* %27
%355 = icmp slt i32 %353, %354
br i1 %355, label %356, label %372
356: ; preds = %352
%357 = load double*, double** %70
%358 = getelementptr inbounds double, double* %357, i64 0
%359 = load double, double* %358
%360 = load double*, double** %71
%361 = load i32, i32* %34
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds double, double* %360, i64 %362
%364 = load double, double* %363
%365 = fsub double %359, %364
%366 = load i32, i32* %34
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double, double* %121, i64 %367
store double %365, double* %368
br label %369
369: ; preds = %356
%370 = load i32, i32* %34
%371 = add nsw i32 %370, 1
store i32 %371, i32* %34
br label %352
372: ; preds = %352
store double* %121, double** %67
store i32 0, i32* %34
br label %373
373: ; preds = %405, %372
%374 = load i32, i32* %34
%375 = load i32, i32* %27
%376 = icmp slt i32 %374, %375
br i1 %376, label %377, label %408
377: ; preds = %373
%378 = load double*, double** %61
%379 = load i32, i32* %34
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds double, double* %378, i64 %380
%382 = load double, double* %381
%383 = fmul double 2.000000e+00, %382
%384 = load double*, double** %67
%385 = load i32, i32* %34
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double, double* %384, i64 %386
%388 = load double, double* %387
%389 = load double*, double** %64
%390 = load i32, i32* %34
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds double, double* %389, i64 %391
%393 = load double, double* %392
%394 = load double*, double** %73
%395 = load i32, i32* %34
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double, double* %394, i64 %396
%398 = load double, double* %397
%399 = fmul double %393, %398
%400 = call double @llvm.fmuladd.f64(double %383, double %388, double %399)
%401 = load double*, double** %69
%402 = load i32, i32* %34
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double, double* %401, i64 %403
store double %400, double* %404
br label %405
405: ; preds = %377
%406 = load i32, i32* %34
%407 = add nsw i32 %406, 1
store i32 %407, i32* %34
br label %373
408: ; preds = %373
%409 = load i32, i32* %27
%410 = load double*, double** %73
%411 = sext i32 %409 to i64
%412 = getelementptr inbounds double, double* %410, i64 %411
store double* %412, double** %73
%413 = load i32, i32* %27
%414 = load double*, double** %69
%415 = sext i32 %413 to i64
%416 = getelementptr inbounds double, double* %414, i64 %415
store double* %416, double** %69
br label %417
417: ; preds = %408
%418 = load i32, i32* %35
%419 = add nsw i32 %418, 1
store i32 %419, i32* %35
br label %272
420: ; preds = %272
store double 0.000000e+00, double* %47
store i32 0, i32* %35
br label %421
421: ; preds = %440, %420
%422 = load i32, i32* %35
%423 = load i32, i32* %28
%424 = icmp slt i32 %422, %423
br i1 %424, label %425, label %443
425: ; preds = %421
%426 = load double*, double** %72
%427 = load i32, i32* %35
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double, double* %426, i64 %428
%430 = load double, double* %429
%431 = load double*, double** %68
%432 = load i32, i32* %35
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %431, i64 %433
%435 = load double, double* %434
%436 = fadd double %430, %435
%437 = call double @exp(double %436)
%438 = load double, double* %47
%439 = fadd double %438, %437
store double %439, double* %47
br label %440
440: ; preds = %425
%441 = load i32, i32* %35
%442 = add nsw i32 %441, 1
store i32 %442, i32* %35
br label %421
443: ; preds = %421
store double* %127, double** %74
store double* %115, double** %69
store i32 0, i32* %35
br label %444
444: ; preds = %488, %443
%445 = load i32, i32* %35
%446 = load i32, i32* %28
%447 = icmp slt i32 %445, %446
br i1 %447, label %448, label %491
448: ; preds = %444
store i32 0, i32* %34
br label %449
449: ; preds = %476, %448
%450 = load i32, i32* %34
%451 = load i32, i32* %27
%452 = icmp slt i32 %450, %451
br i1 %452, label %453, label %479
453: ; preds = %449
%454 = load double*, double** %72
%455 = load i32, i32* %35
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds double, double* %454, i64 %456
%458 = load double, double* %457
%459 = load double*, double** %68
%460 = load i32, i32* %35
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double, double* %459, i64 %461
%463 = load double, double* %462
%464 = fadd double %458, %463
%465 = call double @exp(double %464)
%466 = load double*, double** %69
%467 = load i32, i32* %34
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds double, double* %466, i64 %468
%470 = load double, double* %469
%471 = fmul double %465, %470
%472 = load double*, double** %74
%473 = load i32, i32* %34
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double, double* %472, i64 %474
store double %471, double* %475
br label %476
476: ; preds = %453
%477 = load i32, i32* %34
%478 = add nsw i32 %477, 1
store i32 %478, i32* %34
br label %449
479: ; preds = %449
%480 = load i32, i32* %27
%481 = load double*, double** %69
%482 = sext i32 %480 to i64
%483 = getelementptr inbounds double, double* %481, i64 %482
store double* %483, double** %69
%484 = load i32, i32* %27
%485 = load double*, double** %74
%486 = sext i32 %484 to i64
%487 = getelementptr inbounds double, double* %485, i64 %486
store double* %487, double** %74
br label %488
488: ; preds = %479
%489 = load i32, i32* %35
%490 = add nsw i32 %489, 1
store i32 %490, i32* %35
br label %444
491: ; preds = %444
store double* %121, double** %67
store double* %127, double** %74
store i32 0, i32* %34
br label %492
492: ; preds = %531, %491
%493 = load i32, i32* %34
%494 = load i32, i32* %27
%495 = icmp slt i32 %493, %494
br i1 %495, label %496, label %534
496: ; preds = %492
%497 = load double*, double** %74
%498 = load i32, i32* %34
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds double, double* %497, i64 %499
%501 = load double, double* %500
%502 = load i32, i32* %34
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds double, double* %121, i64 %503
store double %501, double* %504
store i32 1, i32* %35
br label %505
505: ; preds = %527, %496
%506 = load i32, i32* %35
%507 = load i32, i32* %28
%508 = icmp slt i32 %506, %507
br i1 %508, label %509, label %530
509: ; preds = %505
%510 = load i32, i32* %34
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds double, double* %121, i64 %511
%513 = load double, double* %512
%514 = load double*, double** %74
%515 = load i32, i32* %34
%516 = load i32, i32* %35
%517 = load i32, i32* %27
%518 = mul nsw i32 %516, %517
%519 = add nsw i32 %515, %518
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds double, double* %514, i64 %520
%522 = load double, double* %521
%523 = fadd double %513, %522
%524 = load i32, i32* %34
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds double, double* %121, i64 %525
store double %523, double* %526
br label %527
527: ; preds = %509
%528 = load i32, i32* %35
%529 = add nsw i32 %528, 1
store i32 %529, i32* %35
br label %505
530: ; preds = %505
br label %531
531: ; preds = %530
%532 = load i32, i32* %34
%533 = add nsw i32 %532, 1
store i32 %533, i32* %34
br label %492
534: ; preds = %492
store i32 0, i32* %34
br label %535
535: ; preds = %549, %534
%536 = load i32, i32* %34
%537 = load i32, i32* %27
%538 = icmp slt i32 %536, %537
br i1 %538, label %539, label %552
539: ; preds = %535
%540 = load i32, i32* %34
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds double, double* %121, i64 %541
%543 = load double, double* %542
%544 = load double, double* %47
%545 = fdiv double %543, %544
%546 = load i32, i32* %34
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds double, double* %121, i64 %547
store double %545, double* %548
br label %549
549: ; preds = %539
%550 = load i32, i32* %34
%551 = add nsw i32 %550, 1
store i32 %551, i32* %34
br label %535
552: ; preds = %535
store double* %127, double** %74
store double* %115, double** %69
%553 = load i32*, i32** %21
store i32* %553, i32** %76
store i32 0, i32* %35
br label %554
554: ; preds = %592, %552
%555 = load i32, i32* %35
%556 = load i32, i32* %28
%557 = icmp slt i32 %555, %556
br i1 %557, label %558, label %595
558: ; preds = %554
store i32 0, i32* %34
br label %559
559: ; preds = %580, %558
%560 = load i32, i32* %34
%561 = load i32, i32* %27
%562 = icmp slt i32 %560, %561
br i1 %562, label %563, label %583
563: ; preds = %559
%564 = load i32*, i32** %76
%565 = load i32, i32* %35
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds i32, i32* %564, i64 %566
%568 = load i32, i32* %567
%569 = sitofp i32 %568 to double
%570 = load double*, double** %69
%571 = load i32, i32* %34
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds double, double* %570, i64 %572
%574 = load double, double* %573
%575 = fmul double %569, %574
%576 = load double*, double** %74
%577 = load i32, i32* %34
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds double, double* %576, i64 %578
store double %575, double* %579
br label %580
580: ; preds = %563
%581 = load i32, i32* %34
%582 = add nsw i32 %581, 1
store i32 %582, i32* %34
br label %559
583: ; preds = %559
%584 = load i32, i32* %27
%585 = load double*, double** %69
%586 = sext i32 %584 to i64
%587 = getelementptr inbounds double, double* %585, i64 %586
store double* %587, double** %69
%588 = load i32, i32* %27
%589 = load double*, double** %74
%590 = sext i32 %588 to i64
%591 = getelementptr inbounds double, double* %589, i64 %590
store double* %591, double** %74
br label %592
592: ; preds = %583
%593 = load i32, i32* %35
%594 = add nsw i32 %593, 1
store i32 %594, i32* %35
br label %554
595: ; preds = %554
store double* %130, double** %75
store double* %127, double** %74
store i32 0, i32* %34
br label %596
596: ; preds = %632, %595
%597 = load i32, i32* %34
%598 = load i32, i32* %27
%599 = icmp slt i32 %597, %598
br i1 %599, label %600, label %635
600: ; preds = %596
%601 = load double*, double** %74
%602 = load i32, i32* %34
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds double, double* %601, i64 %603
%605 = load double, double* %604
%606 = load i32, i32* %34
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds double, double* %130, i64 %607
store double %605, double* %608
store i32 1, i32* %35
br label %609
609: ; preds = %628, %600
%610 = load i32, i32* %35
%611 = load i32, i32* %28
%612 = icmp slt i32 %610, %611
br i1 %612, label %613, label %631
613: ; preds = %609
%614 = load double*, double** %74
%615 = load i32, i32* %34
%616 = load i32, i32* %35
%617 = load i32, i32* %27
%618 = mul nsw i32 %616, %617
%619 = add nsw i32 %615, %618
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds double, double* %614, i64 %620
%622 = load double, double* %621
%623 = load i32, i32* %34
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds double, double* %130, i64 %624
%626 = load double, double* %625
%627 = fadd double %626, %622
store double %627, double* %625
br label %628
628: ; preds = %613
%629 = load i32, i32* %35
%630 = add nsw i32 %629, 1
store i32 %630, i32* %35
br label %609
631: ; preds = %609
br label %632
632: ; preds = %631
%633 = load i32, i32* %34
%634 = add nsw i32 %633, 1
store i32 %634, i32* %34
br label %596
635: ; preds = %596
store double* %121, double** %67
store i32 0, i32* %34
br label %636
636: ; preds = %654, %635
%637 = load i32, i32* %34
%638 = load i32, i32* %27
%639 = icmp slt i32 %637, %638
br i1 %639, label %640, label %657
640: ; preds = %636
%641 = load i32, i32* %34
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds double, double* %130, i64 %642
%644 = load double, double* %643
%645 = load double*, double** %67
%646 = load i32, i32* %34
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds double, double* %645, i64 %647
%649 = load double, double* %648
%650 = fsub double %644, %649
%651 = load i32, i32* %34
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double, double* %130, i64 %652
store double %650, double* %653
br label %654
654: ; preds = %640
%655 = load i32, i32* %34
%656 = add nsw i32 %655, 1
store i32 %656, i32* %34
br label %636
657: ; preds = %636
store double* %48, double** %79
%658 = load i32*, i32** %14
%659 = load double*, double** %18
%660 = load double*, double** %75
%661 = load double*, double** %61
%662 = load double*, double** %79
%663 = call i32 @innerprod_q(i32* %658, double* %659, double* %660, double* %661, double* %662)
store i32 0, i32* %35
br label %664
664: ; preds = %684, %657
%665 = load i32, i32* %35
%666 = load i32, i32* %27
%667 = icmp slt i32 %665, %666
br i1 %667, label %668, label %687
668: ; preds = %664
%669 = load i32, i32* %35
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds double, double* %130, i64 %670
%672 = load double, double* %671
%673 = load double, double* %48
%674 = load double*, double** %61
%675 = load i32, i32* %35
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds double, double* %674, i64 %676
%678 = load double, double* %677
%679 = fneg double %673
%680 = call double @llvm.fmuladd.f64(double %679, double %678, double %672)
%681 = load i32, i32* %35
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds double, double* %133, i64 %682
store double %680, double* %683
br label %684
684: ; preds = %668
%685 = load i32, i32* %35
%686 = add nsw i32 %685, 1
store i32 %686, i32* %35
br label %664
687: ; preds = %664
store double* %136, double** %77
store double* %139, double** %78
%688 = call i32 @pvecnorm(i32* %27, double* %133, double* %49, double* %48)
%689 = load double, double* %32
%690 = load double, double* %48
%691 = fmul double %689, %690
%692 = call double @cos(double %691)
store double %692, double* %56
%693 = load double, double* %32
%694 = load double, double* %48
%695 = fmul double %693, %694
%696 = call double @sin(double %695)
store double %696, double* %57
store i32 0, i32* %35
br label %697
697: ; preds = %721, %687
%698 = load i32, i32* %35
%699 = load i32, i32* %27
%700 = icmp slt i32 %698, %699
br i1 %700, label %701, label %724
701: ; preds = %697
%702 = load double, double* %56
%703 = load double*, double** %61
%704 = load i32, i32* %35
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds double, double* %703, i64 %705
%707 = load double, double* %706
%708 = load double, double* %57
%709 = load i32, i32* %35
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds double, double* %133, i64 %710
%712 = load double, double* %711
%713 = load double, double* %48
%714 = fdiv double %712, %713
%715 = fmul double %708, %714
%716 = call double @llvm.fmuladd.f64(double %702, double %707, double %715)
%717 = load double*, double** %77
%718 = load i32, i32* %35
%719 = sext i32 %718 to i64
%720 = getelementptr inbounds double, double* %717, i64 %719
store double %716, double* %720
br label %721
721: ; preds = %701
%722 = load i32, i32* %35
%723 = add nsw i32 %722, 1
store i32 %723, i32* %35
br label %697
724: ; preds = %697
store i32 0, i32* %35
br label %725
725: ; preds = %744, %724
%726 = load i32, i32* %35
%727 = load i32, i32* %27
%728 = icmp slt i32 %726, %727
br i1 %728, label %729, label %747
729: ; preds = %725
%730 = load double*, double** %77
%731 = load i32, i32* %35
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds double, double* %730, i64 %732
%734 = load double, double* %733
%735 = load double*, double** %77
%736 = load i32, i32* %35
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds double, double* %735, i64 %737
%739 = load double, double* %738
%740 = fmul double %734, %739
%741 = load i32, i32* %35
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds double, double* %121, i64 %742
store double %740, double* %743
br label %744
744: ; preds = %729
%745 = load i32, i32* %35
%746 = add nsw i32 %745, 1
store i32 %746, i32* %35
br label %725
747: ; preds = %725
store double* %121, double** %67
%748 = load double*, double** %18
%749 = load double*, double** %67
%750 = load double*, double** %78
%751 = call i32 @cumtrapz(i32* %27, double* %748, double* %749, double* %750)
store i32 0, i32* %35
br label %752
752: ; preds = %781, %747
%753 = load i32, i32* %35
%754 = load i32, i32* %27
%755 = icmp slt i32 %753, %754
br i1 %755, label %756, label %784
756: ; preds = %752
%757 = load double*, double** %78
%758 = load i32, i32* %35
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds double, double* %757, i64 %759
%761 = load double, double* %760
%762 = load double*, double** %78
%763 = getelementptr inbounds double, double* %762, i64 0
%764 = load double, double* %763
%765 = fsub double %761, %764
%766 = load double*, double** %78
%767 = load i32, i32* %27
%768 = sub nsw i32 %767, 1
%769 = sext i32 %768 to i64
%770 = getelementptr inbounds double, double* %766, i64 %769
%771 = load double, double* %770
%772 = load double*, double** %78
%773 = getelementptr inbounds double, double* %772, i64 0
%774 = load double, double* %773
%775 = fsub double %771, %774
%776 = fdiv double %765, %775
%777 = load double*, double** %78
%778 = load i32, i32* %35
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds double, double* %777, i64 %779
store double %776, double* %780
br label %781
781: ; preds = %756
%782 = load i32, i32* %35
%783 = add nsw i32 %782, 1
store i32 %783, i32* %35
br label %752
784: ; preds = %752
store double 0.000000e+00, double* %48
%785 = load double*, double** %16
store double* %785, double** %72
store double* %110, double** %68
store i32 0, i32* %35
br label %786
786: ; preds = %810, %784
%787 = load i32, i32* %35
%788 = load i32, i32* %28
%789 = icmp slt i32 %787, %788
br i1 %789, label %790, label %813
790: ; preds = %786
%791 = load i32*, i32** %21
%792 = load i32, i32* %35
%793 = sext i32 %792 to i64
%794 = getelementptr inbounds i32, i32* %791, i64 %793
%795 = load i32, i32* %794
%796 = sitofp i32 %795 to double
%797 = load double*, double** %72
%798 = load i32, i32* %35
%799 = sext i32 %798 to i64
%800 = getelementptr inbounds double, double* %797, i64 %799
%801 = load double, double* %800
%802 = load double*, double** %68
%803 = load i32, i32* %35
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds double, double* %802, i64 %804
%806 = load double, double* %805
%807 = fadd double %801, %806
%808 = load double, double* %48
%809 = call double @llvm.fmuladd.f64(double %796, double %807, double %808)
store double %809, double* %48
br label %810
810: ; preds = %790
%811 = load i32, i32* %35
%812 = add nsw i32 %811, 1
store i32 %812, i32* %35
br label %786
813: ; preds = %786
%814 = load double, double* %48
%815 = load double, double* %47
%816 = call double @log(double %815)
%817 = fsub double %814, %816
%818 = load i32, i32* %37
%819 = sext i32 %818 to i64
%820 = getelementptr inbounds double, double* %142, i64 %819
store double %817, double* %820
%821 = load double, double* %33
%822 = fcmp oeq double %821, 1.000000e+00
br i1 %822, label %823, label %830
823: ; preds = %813
%824 = load i32, i32* %37
%825 = load i32, i32* %37
%826 = sext i32 %825 to i64
%827 = getelementptr inbounds double, double* %142, i64 %826
%828 = load double, double* %827
%829 = call i32 @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str, i64 0, i64 0), i32 %824, double %828)
br label %830
830: ; preds = %823, %813
store double* %139, double** %62
store double* %136, double** %61
%831 = load i32, i32* %37
%832 = icmp sge i32 %831, 2
br i1 %832, label %833, label %854
833: ; preds = %830
%834 = load i32, i32* %37
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds double, double* %142, i64 %835
%837 = load double, double* %836
%838 = load i32, i32* %37
%839 = sub nsw i32 %838, 1
%840 = sext i32 %839 to i64
%841 = getelementptr inbounds double, double* %142, i64 %840
%842 = load double, double* %841
%843 = fsub double %837, %842
store double %843, double* %58
%844 = load double, double* %58
%845 = call double @llvm.fabs.f64(double %844)
%846 = load double, double* %31
%847 = fcmp olt double %845, %846
br i1 %847, label %848, label %849
848: ; preds = %833
br label %861
849: ; preds = %833
%850 = load double, double* %58
%851 = fcmp olt double %850, 0.000000e+00
br i1 %851, label %852, label %853
852: ; preds = %849
br label %861
853: ; preds = %849
br label %854
854: ; preds = %853, %830
%855 = load i32, i32* %37
%856 = add nsw i32 %855, 1
store i32 %856, i32* %37
br label %857
857: ; preds = %854
%858 = load i32, i32* %29
%859 = load i32, i32* %37
%860 = icmp sge i32 %858, %859
br i1 %860, label %218, label %861
861: ; preds = %857, %852, %848
store i32 1, i32* %34
br label %862
862: ; preds = %876, %861
%863 = load i32, i32* %34
%864 = load i32, i32* %27
%865 = icmp slt i32 %863, %864
br i1 %865, label %866, label %879
866: ; preds = %862
%867 = load double*, double** %78
%868 = load i32, i32* %34
%869 = sext i32 %868 to i64
%870 = getelementptr inbounds double, double* %867, i64 %869
%871 = load double, double* %870
%872 = load double*, double** %26
%873 = load i32, i32* %34
%874 = sext i32 %873 to i64
%875 = getelementptr inbounds double, double* %872, i64 %874
store double %871, double* %875
br label %876
876: ; preds = %866
%877 = load i32, i32* %34
%878 = add nsw i32 %877, 1
store i32 %878, i32* %34
br label %862
879: ; preds = %862
%880 = load double*, double** %60
%881 = call i32 @free(double* %880)
%882 = load i8*, i8** %38
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 @mlogit_warp_grad(i32* %0, i32* nocapture %1, double* nocapture %2, double* nocapture %3, double* %4, double* nocapture %5, double* %6, i32* nocapture %7, i32* nocapture %8, double* nocapture %9, double* nocapture %10, i32* nocapture %11, double* nocapture writeonly %12) {
%14 = bitcast double* %5 to i8*
%15 = alloca i32
%16 = alloca i32
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = bitcast i32* %15 to i8*
%21 = load i32, i32* %0
store i32 %21, i32* %15
%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* %16 to i8*
store i32 1, i32* %16
%28 = zext i32 %21 to i64
%29 = tail call i8* @llvm.stacksave()
%30 = alloca double, i64 %28
%31 = bitcast double* %30 to i8*
%32 = alloca double, i64 %28
%33 = alloca double, i64 %28
%34 = alloca double, i64 %28
%35 = zext i32 %22 to i64
%36 = alloca double, i64 %35
%37 = mul nsw i32 %21, %22
%38 = zext i32 %37 to i64
%39 = alloca double, i64 %38
%40 = alloca double, i64 %28
%41 = alloca double, i64 %28
%42 = bitcast double* %17 to i8*
%43 = bitcast double* %18 to i8*
%44 = bitcast double* %19 to i8*
%45 = load double, double* @DBL_EPSILON
%46 = alloca double, i64 %38
%47 = alloca double, i64 %28
%48 = alloca double, i64 %28
%49 = alloca double, i64 %28
%50 = alloca double, i64 %28
%51 = zext i32 %23 to i64
%52 = alloca double, i64 %51
%53 = shl i32 %21, 3
%54 = tail call double* @malloc(i32 %53)
%55 = add i32 %21, -1
%56 = icmp sgt i32 %21, 1
br i1 %56, label %57, label %110
57: ; preds = %13
%58 = zext i32 %55 to i64
%59 = load double, double* %4
%60 = add nsw i64 %58, -1
%61 = and i64 %58, 3
%62 = icmp ult i64 %60, 3
br i1 %62, label %92, label %63
63: ; preds = %57
%64 = and i64 %58, 4294967292
br label %65
65: ; preds = %65, %63
%66 = phi double [ %59, %63 ], [ %87, %65 ]
%67 = phi i64 [ 0, %63 ], [ %85, %65 ]
%68 = phi double [ 0.000000e+00, %63 ], [ %89, %65 ]
%69 = phi i64 [ 0, %63 ], [ %90, %65 ]
%70 = or i64 %67, 1
%71 = getelementptr inbounds double, double* %4, i64 %70
%72 = load double, double* %71
%73 = fsub double %72, %66
%74 = fadd double %68, %73
%75 = or i64 %67, 2
%76 = getelementptr inbounds double, double* %4, i64 %75
%77 = load double, double* %76
%78 = fsub double %77, %72
%79 = fadd double %74, %78
%80 = or i64 %67, 3
%81 = getelementptr inbounds double, double* %4, i64 %80
%82 = load double, double* %81
%83 = fsub double %82, %77
%84 = fadd double %79, %83
%85 = add nuw nsw i64 %67, 4
%86 = getelementptr inbounds double, double* %4, i64 %85
%87 = load double, double* %86
%88 = fsub double %87, %82
%89 = fadd double %84, %88
%90 = add i64 %69, 4
%91 = icmp eq i64 %90, %64
br i1 %91, label %92, label %65
92: ; preds = %65, %57
%93 = phi double [ undef, %57 ], [ %89, %65 ]
%94 = phi double [ %59, %57 ], [ %87, %65 ]
%95 = phi i64 [ 0, %57 ], [ %85, %65 ]
%96 = phi double [ 0.000000e+00, %57 ], [ %89, %65 ]
%97 = icmp eq i64 %61, 0
br i1 %97, label %110, label %98
98: ; preds = %92, %98
%99 = phi double [ %105, %98 ], [ %94, %92 ]
%100 = phi i64 [ %103, %98 ], [ %95, %92 ]
%101 = phi double [ %107, %98 ], [ %96, %92 ]
%102 = phi i64 [ %108, %98 ], [ 0, %92 ]
%103 = add nuw nsw i64 %100, 1
%104 = getelementptr inbounds double, double* %4, i64 %103
%105 = load double, double* %104
%106 = fsub double %105, %99
%107 = fadd double %101, %106
%108 = add i64 %102, 1
%109 = icmp eq i64 %108, %61
br i1 %109, label %110, label %98
110: ; preds = %92, %98, %13
%111 = phi double [ 0.000000e+00, %13 ], [ %93, %92 ], [ %107, %98 ]
%112 = sitofp i32 %55 to double
%113 = fdiv double %111, %112
store double %113, double* %19
%114 = icmp sgt i32 %21, 0
br i1 %114, label %115, label %117
115: ; preds = %110
%116 = shl nuw nsw i64 %28, 3
br label %117
117: ; preds = %115, %110
%118 = call i32 @gradient(i32* %0, i32* %16, double* %30, double* %19, double* %32)
%119 = load i32, i32* %15
%120 = icmp sgt i32 %119, 0
br i1 %120, label %141, label %121
121: ; preds = %141, %117
%122 = phi i32 [ %119, %117 ], [ %149, %141 ]
%123 = icmp sgt i32 %22, 0
%124 = icmp sgt i32 %22, 1
%125 = icmp eq i32 %26, 1
%126 = sext i32 %23 to i64
%127 = add nsw i64 %35, -1
%128 = add nsw i64 %35, -2
%129 = and i64 %127, 3
%130 = icmp ult i64 %128, 3
%131 = and i64 %127, -4
%132 = icmp eq i64 %129, 0
%133 = and i64 %127, 3
%134 = icmp ult i64 %128, 3
%135 = and i64 %127, -4
%136 = icmp eq i64 %133, 0
%137 = and i64 %35, 1
%138 = icmp eq i64 %127, 0
%139 = and i64 %35, 4294967294
%140 = icmp eq i64 %137, 0
br label %152
141: ; preds = %117, %141
%142 = phi i64 [ %148, %141 ], [ 0, %117 ]
%143 = getelementptr inbounds double, double* %32, i64 %142
%144 = load double, double* %143
%145 = call double @llvm.fabs.f64(double %144)
%146 = fadd double %45, %145
%147 = call double @sqrt(double %146)
store double %147, double* %143
%148 = add nuw nsw i64 %142, 1
%149 = load i32, i32* %15
%150 = sext i32 %149 to i64
%151 = icmp slt i64 %148, %150
br i1 %151, label %141, label %121
152: ; preds = %1457, %121
%153 = phi i32 [ %1459, %1457 ], [ %122, %121 ]
%154 = phi i64 [ %1458, %1457 ], [ 1, %121 ]
%155 = phi double* [ %50, %1457 ], [ %30, %121 ]
%156 = phi double* [ %49, %1457 ], [ %32, %121 ]
%157 = icmp sgt i32 %153, 0
br i1 %157, label %158, label %243
158: ; preds = %152
%159 = add nsw i32 %153, -1
%160 = zext i32 %159 to i64
%161 = getelementptr inbounds double, double* %4, i64 %160
%162 = load double, double* %161
%163 = load double, double* %4
%164 = fsub double %162, %163
%165 = zext i32 %153 to i64
%166 = icmp ult i32 %153, 4
br i1 %166, label %233, label %167
167: ; preds = %158
%168 = and i64 %165, 4294967292
%169 = insertelement <2 x double> poison, double %164, i64 0
%170 = shufflevector <2 x double> %169, <2 x double> poison, <2 x i32> zeroinitializer
%171 = insertelement <2 x double> poison, double %163, i64 0
%172 = shufflevector <2 x double> %171, <2 x double> poison, <2 x i32> zeroinitializer
%173 = insertelement <2 x double> poison, double %164, i64 0
%174 = shufflevector <2 x double> %173, <2 x double> poison, <2 x i32> zeroinitializer
%175 = insertelement <2 x double> poison, double %163, i64 0
%176 = shufflevector <2 x double> %175, <2 x double> poison, <2 x i32> zeroinitializer
%177 = add nsw i64 %168, -4
%178 = lshr exact i64 %177, 2
%179 = add nuw nsw i64 %178, 1
%180 = and i64 %179, 1
%181 = icmp eq i64 %177, 0
br i1 %181, label %215, label %182
182: ; preds = %167
%183 = and i64 %179, 9223372036854775806
br label %184
184: ; preds = %184, %182
%185 = phi i64 [ 0, %182 ], [ %212, %184 ]
%186 = phi i64 [ 0, %182 ], [ %213, %184 ]
%187 = getelementptr inbounds double, double* %155, i64 %185
%188 = bitcast double* %187 to <2 x double>*
%189 = load <2 x double>, <2 x double>* %188
%190 = getelementptr inbounds double, double* %187, i64 2
%191 = bitcast double* %190 to <2 x double>*
%192 = load <2 x double>, <2 x double>* %191
%193 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %170, <2 x double> %189, <2 x double> %172)
%194 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %174, <2 x double> %192, <2 x double> %176)
%195 = getelementptr inbounds double, double* %40, i64 %185
%196 = bitcast double* %195 to <2 x double>*
store <2 x double> %193, <2 x double>* %196
%197 = getelementptr inbounds double, double* %195, i64 2
%198 = bitcast double* %197 to <2 x double>*
store <2 x double> %194, <2 x double>* %198
%199 = or i64 %185, 4
%200 = getelementptr inbounds double, double* %155, i64 %199
%201 = bitcast double* %200 to <2 x double>*
%202 = load <2 x double>, <2 x double>* %201
%203 = getelementptr inbounds double, double* %200, i64 2
%204 = bitcast double* %203 to <2 x double>*
%205 = load <2 x double>, <2 x double>* %204
%206 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %170, <2 x double> %202, <2 x double> %172)
%207 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %174, <2 x double> %205, <2 x double> %176)
%208 = getelementptr inbounds double, double* %40, i64 %199
%209 = bitcast double* %208 to <2 x double>*
store <2 x double> %206, <2 x double>* %209
%210 = getelementptr inbounds double, double* %208, i64 2
%211 = bitcast double* %210 to <2 x double>*
store <2 x double> %207, <2 x double>* %211
%212 = add nuw i64 %185, 8
%213 = add i64 %186, 2
%214 = icmp eq i64 %213, %183
br i1 %214, label %215, label %184
215: ; preds = %184, %167
%216 = phi i64 [ 0, %167 ], [ %212, %184 ]
%217 = icmp eq i64 %180, 0
br i1 %217, label %231, label %218
218: ; preds = %215
%219 = getelementptr inbounds double, double* %155, i64 %216
%220 = bitcast double* %219 to <2 x double>*
%221 = load <2 x double>, <2 x double>* %220
%222 = getelementptr inbounds double, double* %219, i64 2
%223 = bitcast double* %222 to <2 x double>*
%224 = load <2 x double>, <2 x double>* %223
%225 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %170, <2 x double> %221, <2 x double> %172)
%226 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %174, <2 x double> %224, <2 x double> %176)
%227 = getelementptr inbounds double, double* %40, i64 %216
%228 = bitcast double* %227 to <2 x double>*
store <2 x double> %225, <2 x double>* %228
%229 = getelementptr inbounds double, double* %227, i64 2
%230 = bitcast double* %229 to <2 x double>*
store <2 x double> %226, <2 x double>* %230
br label %231
231: ; preds = %215, %218
%232 = icmp eq i64 %168, %165
br i1 %232, label %243, label %233
233: ; preds = %158, %231
%234 = phi i64 [ 0, %158 ], [ %168, %231 ]
br label %235
235: ; preds = %233, %235
%236 = phi i64 [ %241, %235 ], [ %234, %233 ]
%237 = getelementptr inbounds double, double* %155, i64 %236
%238 = load double, double* %237
%239 = call double @llvm.fmuladd.f64(double %164, double %238, double %163)
%240 = getelementptr inbounds double, double* %40, i64 %236
store double %239, double* %240
%241 = add nuw nsw i64 %236, 1
%242 = icmp eq i64 %241, %165
br i1 %242, label %243, label %235
243: ; preds = %235, %231, %152
%244 = call i32 @spline(i32 %153, double* %4, double* %6, i32 %153, double* %40, double* %33)
%245 = call i32 @gradient(i32* %0, i32* %16, double* %6, double* %19, double* %41)
%246 = load i32, i32* %15
%247 = call i32 @spline(i32 %246, double* %4, double* %41, i32 %246, double* %40, double* %34)
br i1 %123, label %249, label %248
248: ; preds = %243
store double 0.000000e+00, double* %17
br label %652
249: ; preds = %243
%250 = load i32, i32* %15
br label %251
251: ; preds = %249, %644
%252 = phi i32 [ %250, %249 ], [ %502, %644 ]
%253 = phi i64 [ 0, %249 ], [ %648, %644 ]
%254 = phi double* [ %3, %249 ], [ %646, %644 ]
%255 = phi double* [ %39, %249 ], [ %647, %644 ]
%256 = icmp sgt i32 %252, 0
br i1 %256, label %257, label %375
257: ; preds = %251
%258 = zext i32 %252 to i64
%259 = icmp ult i32 %252, 4
br i1 %259, label %360, label %260
260: ; preds = %257
%261 = and i64 %258, 4294967292
%262 = add nsw i64 %261, -4
%263 = lshr exact i64 %262, 2
%264 = add nuw nsw i64 %263, 1
%265 = and i64 %264, 1
%266 = icmp eq i64 %262, 0
br i1 %266, label %328, label %267
267: ; preds = %260
%268 = and i64 %264, 9223372036854775806
br label %269
269: ; preds = %269, %267
%270 = phi i64 [ 0, %267 ], [ %325, %269 ]
%271 = phi i64 [ 0, %267 ], [ %326, %269 ]
%272 = getelementptr inbounds double, double* %33, i64 %270
%273 = bitcast double* %272 to <2 x double>*
%274 = load <2 x double>, <2 x double>* %273
%275 = getelementptr inbounds double, double* %272, i64 2
%276 = bitcast double* %275 to <2 x double>*
%277 = load <2 x double>, <2 x double>* %276
%278 = getelementptr inbounds double, double* %156, i64 %270
%279 = bitcast double* %278 to <2 x double>*
%280 = load <2 x double>, <2 x double>* %279
%281 = getelementptr inbounds double, double* %278, i64 2
%282 = bitcast double* %281 to <2 x double>*
%283 = load <2 x double>, <2 x double>* %282
%284 = fmul <2 x double> %274, %280
%285 = fmul <2 x double> %277, %283
%286 = getelementptr inbounds double, double* %254, i64 %270
%287 = bitcast double* %286 to <2 x double>*
%288 = load <2 x double>, <2 x double>* %287
%289 = getelementptr inbounds double, double* %286, i64 2
%290 = bitcast double* %289 to <2 x double>*
%291 = load <2 x double>, <2 x double>* %290
%292 = fmul <2 x double> %284, %288
%293 = fmul <2 x double> %285, %291
%294 = getelementptr inbounds double, double* %41, i64 %270
%295 = bitcast double* %294 to <2 x double>*
store <2 x double> %292, <2 x double>* %295
%296 = getelementptr inbounds double, double* %294, i64 2
%297 = bitcast double* %296 to <2 x double>*
store <2 x double> %293, <2 x double>* %297
%298 = or i64 %270, 4
%299 = getelementptr inbounds double, double* %33, i64 %298
%300 = bitcast double* %299 to <2 x double>*
%301 = load <2 x double>, <2 x double>* %300
%302 = getelementptr inbounds double, double* %299, i64 2
%303 = bitcast double* %302 to <2 x double>*
%304 = load <2 x double>, <2 x double>* %303
%305 = getelementptr inbounds double, double* %156, i64 %298
%306 = bitcast double* %305 to <2 x double>*
%307 = load <2 x double>, <2 x double>* %306
%308 = getelementptr inbounds double, double* %305, i64 2
%309 = bitcast double* %308 to <2 x double>*
%310 = load <2 x double>, <2 x double>* %309
%311 = fmul <2 x double> %301, %307
%312 = fmul <2 x double> %304, %310
%313 = getelementptr inbounds double, double* %254, i64 %298
%314 = bitcast double* %313 to <2 x double>*
%315 = load <2 x double>, <2 x double>* %314
%316 = getelementptr inbounds double, double* %313, i64 2
%317 = bitcast double* %316 to <2 x double>*
%318 = load <2 x double>, <2 x double>* %317
%319 = fmul <2 x double> %311, %315
%320 = fmul <2 x double> %312, %318
%321 = getelementptr inbounds double, double* %41, i64 %298
%322 = bitcast double* %321 to <2 x double>*
store <2 x double> %319, <2 x double>* %322
%323 = getelementptr inbounds double, double* %321, i64 2
%324 = bitcast double* %323 to <2 x double>*
store <2 x double> %320, <2 x double>* %324
%325 = add nuw i64 %270, 8
%326 = add i64 %271, 2
%327 = icmp eq i64 %326, %268
br i1 %327, label %328, label %269
328: ; preds = %269, %260
%329 = phi i64 [ 0, %260 ], [ %325, %269 ]
%330 = icmp eq i64 %265, 0
br i1 %330, label %358, label %331
331: ; preds = %328
%332 = getelementptr inbounds double, double* %33, i64 %329
%333 = bitcast double* %332 to <2 x double>*
%334 = load <2 x double>, <2 x double>* %333
%335 = getelementptr inbounds double, double* %332, i64 2
%336 = bitcast double* %335 to <2 x double>*
%337 = load <2 x double>, <2 x double>* %336
%338 = getelementptr inbounds double, double* %156, i64 %329
%339 = bitcast double* %338 to <2 x double>*
%340 = load <2 x double>, <2 x double>* %339
%341 = getelementptr inbounds double, double* %338, i64 2
%342 = bitcast double* %341 to <2 x double>*
%343 = load <2 x double>, <2 x double>* %342
%344 = fmul <2 x double> %334, %340
%345 = fmul <2 x double> %337, %343
%346 = getelementptr inbounds double, double* %254, i64 %329
%347 = bitcast double* %346 to <2 x double>*
%348 = load <2 x double>, <2 x double>* %347
%349 = getelementptr inbounds double, double* %346, i64 2
%350 = bitcast double* %349 to <2 x double>*
%351 = load <2 x double>, <2 x double>* %350
%352 = fmul <2 x double> %344, %348
%353 = fmul <2 x double> %345, %351
%354 = getelementptr inbounds double, double* %41, i64 %329
%355 = bitcast double* %354 to <2 x double>*
store <2 x double> %352, <2 x double>* %355
%356 = getelementptr inbounds double, double* %354, i64 2
%357 = bitcast double* %356 to <2 x double>*
store <2 x double> %353, <2 x double>* %357
br label %358
358: ; preds = %328, %331
%359 = icmp eq i64 %261, %258
br i1 %359, label %375, label %360
360: ; preds = %257, %358
%361 = phi i64 [ 0, %257 ], [ %261, %358 ]
br label %362
362: ; preds = %360, %362
%363 = phi i64 [ %373, %362 ], [ %361, %360 ]
%364 = getelementptr inbounds double, double* %33, i64 %363
%365 = load double, double* %364
%366 = getelementptr inbounds double, double* %156, i64 %363
%367 = load double, double* %366
%368 = fmul double %365, %367
%369 = getelementptr inbounds double, double* %254, i64 %363
%370 = load double, double* %369
%371 = fmul double %368, %370
%372 = getelementptr inbounds double, double* %41, i64 %363
store double %371, double* %372
%373 = add nuw nsw i64 %363, 1
%374 = icmp eq i64 %373, %258
br i1 %374, label %375, label %362
375: ; preds = %362, %358, %251
%376 = call i32 @trapz(i32* %0, i32* %16, double* %4, double* %41, double* %17)
%377 = load double, double* %17
%378 = getelementptr inbounds double, double* %36, i64 %253
store double %377, double* %378
%379 = load i32, i32* %15
%380 = icmp sgt i32 %379, 0
br i1 %380, label %381, label %499
381: ; preds = %375
%382 = zext i32 %379 to i64
%383 = icmp ult i32 %379, 4
br i1 %383, label %484, label %384
384: ; preds = %381
%385 = and i64 %382, 4294967292
%386 = add nsw i64 %385, -4
%387 = lshr exact i64 %386, 2
%388 = add nuw nsw i64 %387, 1
%389 = and i64 %388, 1
%390 = icmp eq i64 %386, 0
br i1 %390, label %452, label %391
391: ; preds = %384
%392 = and i64 %388, 9223372036854775806
br label %393
393: ; preds = %393, %391
%394 = phi i64 [ 0, %391 ], [ %449, %393 ]
%395 = phi i64 [ 0, %391 ], [ %450, %393 ]
%396 = getelementptr inbounds double, double* %34, i64 %394
%397 = bitcast double* %396 to <2 x double>*
%398 = load <2 x double>, <2 x double>* %397
%399 = getelementptr inbounds double, double* %396, i64 2
%400 = bitcast double* %399 to <2 x double>*
%401 = load <2 x double>, <2 x double>* %400
%402 = getelementptr inbounds double, double* %156, i64 %394
%403 = bitcast double* %402 to <2 x double>*
%404 = load <2 x double>, <2 x double>* %403
%405 = getelementptr inbounds double, double* %402, i64 2
%406 = bitcast double* %405 to <2 x double>*
%407 = load <2 x double>, <2 x double>* %406
%408 = fmul <2 x double> %398, %404
%409 = fmul <2 x double> %401, %407
%410 = getelementptr inbounds double, double* %254, i64 %394
%411 = bitcast double* %410 to <2 x double>*
%412 = load <2 x double>, <2 x double>* %411
%413 = getelementptr inbounds double, double* %410, i64 2
%414 = bitcast double* %413 to <2 x double>*
%415 = load <2 x double>, <2 x double>* %414
%416 = fmul <2 x double> %408, %412
%417 = fmul <2 x double> %409, %415
%418 = getelementptr inbounds double, double* %41, i64 %394
%419 = bitcast double* %418 to <2 x double>*
store <2 x double> %416, <2 x double>* %419
%420 = getelementptr inbounds double, double* %418, i64 2
%421 = bitcast double* %420 to <2 x double>*
store <2 x double> %417, <2 x double>* %421
%422 = or i64 %394, 4
%423 = getelementptr inbounds double, double* %34, i64 %422
%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 = getelementptr inbounds double, double* %156, i64 %422
%430 = bitcast double* %429 to <2 x double>*
%431 = load <2 x double>, <2 x double>* %430
%432 = getelementptr inbounds double, double* %429, i64 2
%433 = bitcast double* %432 to <2 x double>*
%434 = load <2 x double>, <2 x double>* %433
%435 = fmul <2 x double> %425, %431
%436 = fmul <2 x double> %428, %434
%437 = getelementptr inbounds double, double* %254, i64 %422
%438 = bitcast double* %437 to <2 x double>*
%439 = load <2 x double>, <2 x double>* %438
%440 = getelementptr inbounds double, double* %437, i64 2
%441 = bitcast double* %440 to <2 x double>*
%442 = load <2 x double>, <2 x double>* %441
%443 = fmul <2 x double> %435, %439
%444 = fmul <2 x double> %436, %442
%445 = getelementptr inbounds double, double* %41, i64 %422
%446 = bitcast double* %445 to <2 x double>*
store <2 x double> %443, <2 x double>* %446
%447 = getelementptr inbounds double, double* %445, i64 2
%448 = bitcast double* %447 to <2 x double>*
store <2 x double> %444, <2 x double>* %448
%449 = add nuw i64 %394, 8
%450 = add i64 %395, 2
%451 = icmp eq i64 %450, %392
br i1 %451, label %452, label %393
452: ; preds = %393, %384
%453 = phi i64 [ 0, %384 ], [ %449, %393 ]
%454 = icmp eq i64 %389, 0
br i1 %454, label %482, label %455
455: ; preds = %452
%456 = getelementptr inbounds double, double* %34, i64 %453
%457 = bitcast double* %456 to <2 x double>*
%458 = load <2 x double>, <2 x double>* %457
%459 = getelementptr inbounds double, double* %456, i64 2
%460 = bitcast double* %459 to <2 x double>*
%461 = load <2 x double>, <2 x double>* %460
%462 = getelementptr inbounds double, double* %156, i64 %453
%463 = bitcast double* %462 to <2 x double>*
%464 = load <2 x double>, <2 x double>* %463
%465 = getelementptr inbounds double, double* %462, i64 2
%466 = bitcast double* %465 to <2 x double>*
%467 = load <2 x double>, <2 x double>* %466
%468 = fmul <2 x double> %458, %464
%469 = fmul <2 x double> %461, %467
%470 = getelementptr inbounds double, double* %254, i64 %453
%471 = bitcast double* %470 to <2 x double>*
%472 = load <2 x double>, <2 x double>* %471
%473 = getelementptr inbounds double, double* %470, i64 2
%474 = bitcast double* %473 to <2 x double>*
%475 = load <2 x double>, <2 x double>* %474
%476 = fmul <2 x double> %468, %472
%477 = fmul <2 x double> %469, %475
%478 = getelementptr inbounds double, double* %41, i64 %453
%479 = bitcast double* %478 to <2 x double>*
store <2 x double> %476, <2 x double>* %479
%480 = getelementptr inbounds double, double* %478, i64 2
%481 = bitcast double* %480 to <2 x double>*
store <2 x double> %477, <2 x double>* %481
br label %482
482: ; preds = %452, %455
%483 = icmp eq i64 %385, %382
br i1 %483, label %499, label %484
484: ; preds = %381, %482
%485 = phi i64 [ 0, %381 ], [ %385, %482 ]
br label %486
486: ; preds = %484, %486
%487 = phi i64 [ %497, %486 ], [ %485, %484 ]
%488 = getelementptr inbounds double, double* %34, i64 %487
%489 = load double, double* %488
%490 = getelementptr inbounds double, double* %156, i64 %487
%491 = load double, double* %490
%492 = fmul double %489, %491
%493 = getelementptr inbounds double, double* %254, i64 %487
%494 = load double, double* %493
%495 = fmul double %492, %494
%496 = getelementptr inbounds double, double* %41, i64 %487
store double %495, double* %496
%497 = add nuw nsw i64 %487, 1
%498 = icmp eq i64 %497, %382
br i1 %498, label %499, label %486
499: ; preds = %486, %482, %375
%500 = call i32 @trapz(i32* %15, i32* %16, double* %4, double* %41, double* %17)
%501 = call i32 @cumtrapz(i32* %15, double* %4, double* %41, double* %54)
%502 = load i32, i32* %15
%503 = icmp sgt i32 %502, 0
br i1 %503, label %504, label %644
504: ; preds = %499
%505 = load double, double* %17
%506 = zext i32 %502 to i64
%507 = icmp ult i32 %502, 4
br i1 %507, label %570, label %508
508: ; preds = %504
%509 = and i64 %506, 4294967292
%510 = insertelement <2 x double> poison, double %505, i64 0
%511 = shufflevector <2 x double> %510, <2 x double> poison, <2 x i32> zeroinitializer
%512 = insertelement <2 x double> poison, double %505, i64 0
%513 = shufflevector <2 x double> %512, <2 x double> poison, <2 x i32> zeroinitializer
%514 = add nsw i64 %509, -4
%515 = lshr exact i64 %514, 2
%516 = add nuw nsw i64 %515, 1
%517 = and i64 %516, 1
%518 = icmp eq i64 %514, 0
br i1 %518, label %552, label %519
519: ; preds = %508
%520 = and i64 %516, 9223372036854775806
br label %521
521: ; preds = %521, %519
%522 = phi i64 [ 0, %519 ], [ %549, %521 ]
%523 = phi i64 [ 0, %519 ], [ %550, %521 ]
%524 = getelementptr inbounds double, double* %54, i64 %522
%525 = bitcast double* %524 to <2 x double>*
%526 = load <2 x double>, <2 x double>* %525
%527 = getelementptr inbounds double, double* %524, i64 2
%528 = bitcast double* %527 to <2 x double>*
%529 = load <2 x double>, <2 x double>* %528
%530 = fsub <2 x double> %511, %526
%531 = fsub <2 x double> %513, %529
%532 = getelementptr inbounds double, double* %41, i64 %522
%533 = bitcast double* %532 to <2 x double>*
store <2 x double> %530, <2 x double>* %533
%534 = getelementptr inbounds double, double* %532, i64 2
%535 = bitcast double* %534 to <2 x double>*
store <2 x double> %531, <2 x double>* %535
%536 = or i64 %522, 4
%537 = getelementptr inbounds double, double* %54, i64 %536
%538 = bitcast double* %537 to <2 x double>*
%539 = load <2 x double>, <2 x double>* %538
%540 = getelementptr inbounds double, double* %537, i64 2
%541 = bitcast double* %540 to <2 x double>*
%542 = load <2 x double>, <2 x double>* %541
%543 = fsub <2 x double> %511, %539
%544 = fsub <2 x double> %513, %542
%545 = getelementptr inbounds double, double* %41, i64 %536
%546 = bitcast double* %545 to <2 x double>*
store <2 x double> %543, <2 x double>* %546
%547 = getelementptr inbounds double, double* %545, i64 2
%548 = bitcast double* %547 to <2 x double>*
store <2 x double> %544, <2 x double>* %548
%549 = add nuw i64 %522, 8
%550 = add i64 %523, 2
%551 = icmp eq i64 %550, %520
br i1 %551, label %552, label %521
552: ; preds = %521, %508
%553 = phi i64 [ 0, %508 ], [ %549, %521 ]
%554 = icmp eq i64 %517, 0
br i1 %554, label %568, label %555
555: ; preds = %552
%556 = getelementptr inbounds double, double* %54, i64 %553
%557 = bitcast double* %556 to <2 x double>*
%558 = load <2 x double>, <2 x double>* %557
%559 = getelementptr inbounds double, double* %556, i64 2
%560 = bitcast double* %559 to <2 x double>*
%561 = load <2 x double>, <2 x double>* %560
%562 = fsub <2 x double> %511, %558
%563 = fsub <2 x double> %513, %561
%564 = getelementptr inbounds double, double* %41, i64 %553
%565 = bitcast double* %564 to <2 x double>*
store <2 x double> %562, <2 x double>* %565
%566 = getelementptr inbounds double, double* %564, i64 2
%567 = bitcast double* %566 to <2 x double>*
store <2 x double> %563, <2 x double>* %567
br label %568
568: ; preds = %552, %555
%569 = icmp eq i64 %509, %506
br i1 %569, label %572, label %570
570: ; preds = %504, %568
%571 = phi i64 [ 0, %504 ], [ %509, %568 ]
br label %620
572: ; preds = %620, %568
br i1 %503, label %573, label %644
573: ; preds = %572
%574 = zext i32 %502 to i64
%575 = icmp ult i32 %502, 4
br i1 %575, label %618, label %576
576: ; preds = %573
%577 = and i64 %506, 4294967292
br label %578
578: ; preds = %578, %576
%579 = phi i64 [ 0, %576 ], [ %614, %578 ]
%580 = getelementptr inbounds double, double* %156, i64 %579
%581 = bitcast double* %580 to <2 x double>*
%582 = load <2 x double>, <2 x double>* %581
%583 = getelementptr inbounds double, double* %580, i64 2
%584 = bitcast double* %583 to <2 x double>*
%585 = load <2 x double>, <2 x double>* %584
%586 = fmul <2 x double> %582, <double 2.000000e+00, double 2.000000e+00>
%587 = fmul <2 x double> %585, <double 2.000000e+00, double 2.000000e+00>
%588 = getelementptr inbounds double, double* %41, i64 %579
%589 = bitcast double* %588 to <2 x double>*
%590 = load <2 x double>, <2 x double>* %589
%591 = getelementptr inbounds double, double* %588, i64 2
%592 = bitcast double* %591 to <2 x double>*
%593 = load <2 x double>, <2 x double>* %592
%594 = getelementptr inbounds double, double* %33, i64 %579
%595 = bitcast double* %594 to <2 x double>*
%596 = load <2 x double>, <2 x double>* %595
%597 = getelementptr inbounds double, double* %594, i64 2
%598 = bitcast double* %597 to <2 x double>*
%599 = load <2 x double>, <2 x double>* %598
%600 = getelementptr inbounds double, double* %254, i64 %579
%601 = bitcast double* %600 to <2 x double>*
%602 = load <2 x double>, <2 x double>* %601
%603 = getelementptr inbounds double, double* %600, i64 2
%604 = bitcast double* %603 to <2 x double>*
%605 = load <2 x double>, <2 x double>* %604
%606 = fmul <2 x double> %596, %602
%607 = fmul <2 x double> %599, %605
%608 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %586, <2 x double> %590, <2 x double> %606)
%609 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %587, <2 x double> %593, <2 x double> %607)
%610 = getelementptr inbounds double, double* %255, i64 %579
%611 = bitcast double* %610 to <2 x double>*
store <2 x double> %608, <2 x double>* %611
%612 = getelementptr inbounds double, double* %610, i64 2
%613 = bitcast double* %612 to <2 x double>*
store <2 x double> %609, <2 x double>* %613
%614 = add nuw i64 %579, 4
%615 = icmp eq i64 %614, %577
br i1 %615, label %616, label %578
616: ; preds = %578
%617 = icmp eq i64 %577, %506
br i1 %617, label %644, label %618
618: ; preds = %573, %616
%619 = phi i64 [ 0, %573 ], [ %577, %616 ]
br label %628
620: ; preds = %570, %620
%621 = phi i64 [ %626, %620 ], [ %571, %570 ]
%622 = getelementptr inbounds double, double* %54, i64 %621
%623 = load double, double* %622
%624 = fsub double %505, %623
%625 = getelementptr inbounds double, double* %41, i64 %621
store double %624, double* %625
%626 = add nuw nsw i64 %621, 1
%627 = icmp eq i64 %626, %506
br i1 %627, label %572, label %620
628: ; preds = %618, %628
%629 = phi i64 [ %642, %628 ], [ %619, %618 ]
%630 = getelementptr inbounds double, double* %156, i64 %629
%631 = load double, double* %630
%632 = fmul double %631, 2.000000e+00
%633 = getelementptr inbounds double, double* %41, i64 %629
%634 = load double, double* %633
%635 = getelementptr inbounds double, double* %33, i64 %629
%636 = load double, double* %635
%637 = getelementptr inbounds double, double* %254, i64 %629
%638 = load double, double* %637
%639 = fmul double %636, %638
%640 = call double @llvm.fmuladd.f64(double %632, double %634, double %639)
%641 = getelementptr inbounds double, double* %255, i64 %629
store double %640, double* %641
%642 = add nuw nsw i64 %629, 1
%643 = icmp eq i64 %642, %574
br i1 %643, label %644, label %628
644: ; preds = %628, %616, %499, %572
%645 = sext i32 %502 to i64
%646 = getelementptr inbounds double, double* %254, i64 %645
%647 = getelementptr inbounds double, double* %255, i64 %645
%648 = add nuw nsw i64 %253, 1
%649 = icmp eq i64 %648, %35
br i1 %649, label %650, label %251
650: ; preds = %644
store double 0.000000e+00, double* %17
br i1 %123, label %656, label %652
651: ; preds = %656
br i1 %123, label %654, label %652
652: ; preds = %650, %248, %651
%653 = load i32, i32* %15
br label %668
654: ; preds = %651
%655 = load i32, i32* %15
br label %674
656: ; preds = %650, %656
%657 = phi i64 [ %666, %656 ], [ 0, %650 ]
%658 = getelementptr inbounds double, double* %2, i64 %657
%659 = load double, double* %658
%660 = getelementptr inbounds double, double* %36, i64 %657
%661 = load double, double* %660
%662 = fadd double %659, %661
%663 = call double @exp(double %662)
%664 = load double, double* %17
%665 = fadd double %663, %664
store double %665, double* %17
%666 = add nuw nsw i64 %657, 1
%667 = icmp eq i64 %666, %35
br i1 %667, label %651, label %656
668: ; preds = %697, %652
%669 = phi i32 [ %653, %652 ], [ %698, %697 ]
%670 = icmp sgt i32 %669, 0
br i1 %670, label %671, label %807
671: ; preds = %668
%672 = zext i32 %669 to i64
%673 = zext i32 %669 to i64
br label %750
674: ; preds = %654, %697
%675 = phi i32 [ %655, %654 ], [ %698, %697 ]
%676 = phi i64 [ 0, %654 ], [ %702, %697 ]
%677 = phi double* [ %46, %654 ], [ %701, %697 ]
%678 = phi double* [ %39, %654 ], [ %700, %697 ]
%679 = icmp sgt i32 %675, 0
br i1 %679, label %680, label %697
680: ; preds = %674
%681 = getelementptr inbounds double, double* %2, i64 %676
%682 = getelementptr inbounds double, double* %36, i64 %676
%683 = load double, double* %682
br label %684
684: ; preds = %680, %684
%685 = phi i64 [ 0, %680 ], [ %693, %684 ]
%686 = load double, double* %681
%687 = fadd double %686, %683
%688 = call double @exp(double %687)
%689 = getelementptr inbounds double, double* %678, i64 %685
%690 = load double, double* %689
%691 = fmul double %688, %690
%692 = getelementptr inbounds double, double* %677, i64 %685
store double %691, double* %692
%693 = add nuw nsw i64 %685, 1
%694 = load i32, i32* %15
%695 = sext i32 %694 to i64
%696 = icmp slt i64 %693, %695
br i1 %696, label %684, label %697
697: ; preds = %684, %674
%698 = phi i32 [ %675, %674 ], [ %694, %684 ]
%699 = sext i32 %698 to i64
%700 = getelementptr inbounds double, double* %678, i64 %699
%701 = getelementptr inbounds double, double* %677, i64 %699
%702 = add nuw nsw i64 %676, 1
%703 = icmp eq i64 %702, %35
br i1 %703, label %668, label %674
704: ; preds = %804
br i1 %670, label %705, label %807
705: ; preds = %704
%706 = load double, double* %17
%707 = zext i32 %669 to i64
%708 = icmp eq i32 %669, 1
br i1 %708, label %748, label %709
709: ; preds = %705
%710 = and i64 %673, 4294967294
%711 = insertelement <2 x double> poison, double %706, i64 0
%712 = shufflevector <2 x double> %711, <2 x double> poison, <2 x i32> zeroinitializer
%713 = add nsw i64 %710, -2
%714 = lshr exact i64 %713, 1
%715 = add nuw i64 %714, 1
%716 = and i64 %715, 1
%717 = icmp eq i64 %713, 0
br i1 %717, label %737, label %718
718: ; preds = %709
%719 = and i64 %715, -2
br label %720
720: ; preds = %720, %718
%721 = phi i64 [ 0, %718 ], [ %734, %720 ]
%722 = phi i64 [ 0, %718 ], [ %735, %720 ]
%723 = getelementptr inbounds double, double* %41, i64 %721
%724 = bitcast double* %723 to <2 x double>*
%725 = load <2 x double>, <2 x double>* %724
%726 = fdiv <2 x double> %725, %712
%727 = bitcast double* %723 to <2 x double>*
store <2 x double> %726, <2 x double>* %727
%728 = or i64 %721, 2
%729 = getelementptr inbounds double, double* %41, i64 %728
%730 = bitcast double* %729 to <2 x double>*
%731 = load <2 x double>, <2 x double>* %730
%732 = fdiv <2 x double> %731, %712
%733 = bitcast double* %729 to <2 x double>*
store <2 x double> %732, <2 x double>* %733
%734 = add nuw i64 %721, 4
%735 = add nuw i64 %722, 2
%736 = icmp eq i64 %735, %719
br i1 %736, label %737, label %720
737: ; preds = %720, %709
%738 = phi i64 [ 0, %709 ], [ %734, %720 ]
%739 = icmp eq i64 %716, 0
br i1 %739, label %746, label %740
740: ; preds = %737
%741 = getelementptr inbounds double, double* %41, i64 %738
%742 = bitcast double* %741 to <2 x double>*
%743 = load <2 x double>, <2 x double>* %742
%744 = fdiv <2 x double> %743, %712
%745 = bitcast double* %741 to <2 x double>*
store <2 x double> %744, <2 x double>* %745
br label %746
746: ; preds = %737, %740
%747 = icmp eq i64 %710, %673
br i1 %747, label %807, label %748
748: ; preds = %705, %746
%749 = phi i64 [ 0, %705 ], [ %710, %746 ]
br label %822
750: ; preds = %671, %804
%751 = phi i64 [ 0, %671 ], [ %805, %804 ]
%752 = getelementptr inbounds double, double* %46, i64 %751
%753 = load double, double* %752
%754 = getelementptr inbounds double, double* %41, i64 %751
store double %753, double* %754
br i1 %124, label %755, label %804
755: ; preds = %750
br i1 %130, label %786, label %756
756: ; preds = %755, %756
%757 = phi i64 [ %783, %756 ], [ 1, %755 ]
%758 = phi double [ %782, %756 ], [ %753, %755 ]
%759 = phi i64 [ %784, %756 ], [ 0, %755 ]
%760 = mul nsw i64 %757, %672
%761 = add nuw nsw i64 %760, %751
%762 = getelementptr inbounds double, double* %46, i64 %761
%763 = load double, double* %762
%764 = fadd double %758, %763
%765 = add nuw nsw i64 %757, 1
%766 = mul nsw i64 %765, %672
%767 = add nuw nsw i64 %766, %751
%768 = getelementptr inbounds double, double* %46, i64 %767
%769 = load double, double* %768
%770 = fadd double %764, %769
%771 = add nuw nsw i64 %757, 2
%772 = mul nsw i64 %771, %672
%773 = add nuw nsw i64 %772, %751
%774 = getelementptr inbounds double, double* %46, i64 %773
%775 = load double, double* %774
%776 = fadd double %770, %775
%777 = add nuw nsw i64 %757, 3
%778 = mul nsw i64 %777, %672
%779 = add nuw nsw i64 %778, %751
%780 = getelementptr inbounds double, double* %46, i64 %779
%781 = load double, double* %780
%782 = fadd double %776, %781
%783 = add nuw nsw i64 %757, 4
%784 = add nuw i64 %759, 4
%785 = icmp eq i64 %784, %131
br i1 %785, label %786, label %756
786: ; preds = %756, %755
%787 = phi double [ undef, %755 ], [ %782, %756 ]
%788 = phi i64 [ 1, %755 ], [ %783, %756 ]
%789 = phi double [ %753, %755 ], [ %782, %756 ]
br i1 %132, label %802, label %790
790: ; preds = %786, %790
%791 = phi i64 [ %799, %790 ], [ %788, %786 ]
%792 = phi double [ %798, %790 ], [ %789, %786 ]
%793 = phi i64 [ %800, %790 ], [ 0, %786 ]
%794 = mul nsw i64 %791, %672
%795 = add nuw nsw i64 %794, %751
%796 = getelementptr inbounds double, double* %46, i64 %795
%797 = load double, double* %796
%798 = fadd double %792, %797
%799 = add nuw nsw i64 %791, 1
%800 = add i64 %793, 1
%801 = icmp eq i64 %800, %129
br i1 %801, label %802, label %790
802: ; preds = %790, %786
%803 = phi double [ %787, %786 ], [ %798, %790 ]
store double %803, double* %754
br label %804
804: ; preds = %802, %750
%805 = add nuw nsw i64 %751, 1
%806 = icmp eq i64 %805, %673
br i1 %806, label %704, label %750
807: ; preds = %822, %746, %668, %704
br i1 %123, label %808, label %829
808: ; preds = %807
%809 = sext i32 %669 to i64
%810 = zext i32 %669 to i64
%811 = and i64 %810, 4294967292
%812 = add nsw i64 %811, -4
%813 = lshr exact i64 %812, 2
%814 = add nuw nsw i64 %813, 1
%815 = icmp ult i32 %669, 4
%816 = and i64 %810, 4294967292
%817 = and i64 %814, 1
%818 = icmp eq i64 %812, 0
%819 = and i64 %814, 9223372036854775806
%820 = icmp eq i64 %817, 0
%821 = icmp eq i64 %816, %810
br label %833
822: ; preds = %748, %822
%823 = phi i64 [ %827, %822 ], [ %749, %748 ]
%824 = getelementptr inbounds double, double* %41, i64 %823
%825 = load double, double* %824
%826 = fdiv double %825, %706
store double %826, double* %824
%827 = add nuw nsw i64 %823, 1
%828 = icmp eq i64 %827, %707
br i1 %828, label %807, label %822
829: ; preds = %903, %807
br i1 %670, label %830, label %1050
830: ; preds = %829
%831 = zext i32 %669 to i64
%832 = zext i32 %669 to i64
br label %984
833: ; preds = %808, %903
%834 = phi i64 [ 0, %808 ], [ %906, %903 ]
%835 = phi double* [ %46, %808 ], [ %905, %903 ]
%836 = phi double* [ %39, %808 ], [ %904, %903 ]
br i1 %670, label %837, label %903
837: ; preds = %833
%838 = getelementptr inbounds i32, i32* %7, i64 %834
%839 = load i32, i32* %838
%840 = sitofp i32 %839 to double
br i1 %815, label %893, label %841
841: ; preds = %837
%842 = insertelement <2 x double> poison, double %840, i64 0
%843 = shufflevector <2 x double> %842, <2 x double> poison, <2 x i32> zeroinitializer
%844 = insertelement <2 x double> poison, double %840, i64 0
%845 = shufflevector <2 x double> %844, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %818, label %877, label %846
846: ; preds = %841, %846
%847 = phi i64 [ %874, %846 ], [ 0, %841 ]
%848 = phi i64 [ %875, %846 ], [ 0, %841 ]
%849 = getelementptr inbounds double, double* %836, i64 %847
%850 = bitcast double* %849 to <2 x double>*
%851 = load <2 x double>, <2 x double>* %850
%852 = getelementptr inbounds double, double* %849, i64 2
%853 = bitcast double* %852 to <2 x double>*
%854 = load <2 x double>, <2 x double>* %853
%855 = fmul <2 x double> %851, %843
%856 = fmul <2 x double> %854, %845
%857 = getelementptr inbounds double, double* %835, i64 %847
%858 = bitcast double* %857 to <2 x double>*
store <2 x double> %855, <2 x double>* %858
%859 = getelementptr inbounds double, double* %857, i64 2
%860 = bitcast double* %859 to <2 x double>*
store <2 x double> %856, <2 x double>* %860
%861 = or i64 %847, 4
%862 = getelementptr inbounds double, double* %836, i64 %861
%863 = bitcast double* %862 to <2 x double>*
%864 = load <2 x double>, <2 x double>* %863
%865 = getelementptr inbounds double, double* %862, i64 2
%866 = bitcast double* %865 to <2 x double>*
%867 = load <2 x double>, <2 x double>* %866
%868 = fmul <2 x double> %864, %843
%869 = fmul <2 x double> %867, %845
%870 = getelementptr inbounds double, double* %835, i64 %861
%871 = bitcast double* %870 to <2 x double>*
store <2 x double> %868, <2 x double>* %871
%872 = getelementptr inbounds double, double* %870, i64 2
%873 = bitcast double* %872 to <2 x double>*
store <2 x double> %869, <2 x double>* %873
%874 = add nuw i64 %847, 8
%875 = add i64 %848, 2
%876 = icmp eq i64 %875, %819
br i1 %876, label %877, label %846
877: ; preds = %846, %841
%878 = phi i64 [ 0, %841 ], [ %874, %846 ]
br i1 %820, label %892, label %879
879: ; preds = %877
%880 = getelementptr inbounds double, double* %836, i64 %878
%881 = bitcast double* %880 to <2 x double>*
%882 = load <2 x double>, <2 x double>* %881
%883 = getelementptr inbounds double, double* %880, i64 2
%884 = bitcast double* %883 to <2 x double>*
%885 = load <2 x double>, <2 x double>* %884
%886 = fmul <2 x double> %882, %843
%887 = fmul <2 x double> %885, %845
%888 = getelementptr inbounds double, double* %835, i64 %878
%889 = bitcast double* %888 to <2 x double>*
store <2 x double> %886, <2 x double>* %889
%890 = getelementptr inbounds double, double* %888, i64 2
%891 = bitcast double* %890 to <2 x double>*
store <2 x double> %887, <2 x double>* %891
br label %892
892: ; preds = %877, %879
br i1 %821, label %903, label %893
893: ; preds = %837, %892
%894 = phi i64 [ 0, %837 ], [ %816, %892 ]
br label %895
895: ; preds = %893, %895
%896 = phi i64 [ %901, %895 ], [ %894, %893 ]
%897 = getelementptr inbounds double, double* %836, i64 %896
%898 = load double, double* %897
%899 = fmul double %898, %840
%900 = getelementptr inbounds double, double* %835, i64 %896
store double %899, double* %900
%901 = add nuw nsw i64 %896, 1
%902 = icmp eq i64 %901, %810
br i1 %902, label %903, label %895
903: ; preds = %895, %892, %833
%904 = getelementptr inbounds double, double* %836, i64 %809
%905 = getelementptr inbounds double, double* %835, i64 %809
%906 = add nuw nsw i64 %834, 1
%907 = icmp eq i64 %906, %35
br i1 %907, label %829, label %833
908: ; preds = %1038
br i1 %670, label %909, label %1050
909: ; preds = %908
%910 = zext i32 %669 to i64
%911 = icmp ult i32 %669, 4
br i1 %911, label %982, label %912
912: ; preds = %909
%913 = and i64 %832, 4294967292
%914 = add nsw i64 %913, -4
%915 = lshr exact i64 %914, 2
%916 = add nuw nsw i64 %915, 1
%917 = and i64 %916, 1
%918 = icmp eq i64 %914, 0
br i1 %918, label %960, label %919
919: ; preds = %912
%920 = and i64 %916, 9223372036854775806
br label %921
921: ; preds = %921, %919
%922 = phi i64 [ 0, %919 ], [ %957, %921 ]
%923 = phi i64 [ 0, %919 ], [ %958, %921 ]
%924 = getelementptr inbounds double, double* %47, i64 %922
%925 = bitcast double* %924 to <2 x double>*
%926 = load <2 x double>, <2 x double>* %925
%927 = getelementptr inbounds double, double* %924, i64 2
%928 = bitcast double* %927 to <2 x double>*
%929 = load <2 x double>, <2 x double>* %928
%930 = getelementptr inbounds double, double* %41, i64 %922
%931 = bitcast double* %930 to <2 x double>*
%932 = load <2 x double>, <2 x double>* %931
%933 = getelementptr inbounds double, double* %930, i64 2
%934 = bitcast double* %933 to <2 x double>*
%935 = load <2 x double>, <2 x double>* %934
%936 = fsub <2 x double> %926, %932
%937 = fsub <2 x double> %929, %935
%938 = bitcast double* %924 to <2 x double>*
store <2 x double> %936, <2 x double>* %938
%939 = bitcast double* %927 to <2 x double>*
store <2 x double> %937, <2 x double>* %939
%940 = or i64 %922, 4
%941 = getelementptr inbounds double, double* %47, i64 %940
%942 = bitcast double* %941 to <2 x double>*
%943 = load <2 x double>, <2 x double>* %942
%944 = getelementptr inbounds double, double* %941, i64 2
%945 = bitcast double* %944 to <2 x double>*
%946 = load <2 x double>, <2 x double>* %945
%947 = getelementptr inbounds double, double* %41, i64 %940
%948 = bitcast double* %947 to <2 x double>*
%949 = load <2 x double>, <2 x double>* %948
%950 = getelementptr inbounds double, double* %947, i64 2
%951 = bitcast double* %950 to <2 x double>*
%952 = load <2 x double>, <2 x double>* %951
%953 = fsub <2 x double> %943, %949
%954 = fsub <2 x double> %946, %952
%955 = bitcast double* %941 to <2 x double>*
store <2 x double> %953, <2 x double>* %955
%956 = bitcast double* %944 to <2 x double>*
store <2 x double> %954, <2 x double>* %956
%957 = add nuw i64 %922, 8
%958 = add i64 %923, 2
%959 = icmp eq i64 %958, %920
br i1 %959, label %960, label %921
960: ; preds = %921, %912
%961 = phi i64 [ 0, %912 ], [ %957, %921 ]
%962 = icmp eq i64 %917, 0
br i1 %962, label %980, label %963
963: ; preds = %960
%964 = getelementptr inbounds double, double* %47, i64 %961
%965 = bitcast double* %964 to <2 x double>*
%966 = load <2 x double>, <2 x double>* %965
%967 = getelementptr inbounds double, double* %964, i64 2
%968 = bitcast double* %967 to <2 x double>*
%969 = load <2 x double>, <2 x double>* %968
%970 = getelementptr inbounds double, double* %41, i64 %961
%971 = bitcast double* %970 to <2 x double>*
%972 = load <2 x double>, <2 x double>* %971
%973 = getelementptr inbounds double, double* %970, i64 2
%974 = bitcast double* %973 to <2 x double>*
%975 = load <2 x double>, <2 x double>* %974
%976 = fsub <2 x double> %966, %972
%977 = fsub <2 x double> %969, %975
%978 = bitcast double* %964 to <2 x double>*
store <2 x double> %976, <2 x double>* %978
%979 = bitcast double* %967 to <2 x double>*
store <2 x double> %977, <2 x double>* %979
br label %980
980: ; preds = %960, %963
%981 = icmp eq i64 %913, %832
br i1 %981, label %1050, label %982
982: ; preds = %909, %980
%983 = phi i64 [ 0, %909 ], [ %913, %980 ]
br label %1041
984: ; preds = %830, %1038
%985 = phi i64 [ 0, %830 ], [ %1039, %1038 ]
%986 = getelementptr inbounds double, double* %46, i64 %985
%987 = load double, double* %986
%988 = getelementptr inbounds double, double* %47, i64 %985
store double %987, double* %988
br i1 %124, label %989, label %1038
989: ; preds = %984
br i1 %134, label %1020, label %990
990: ; preds = %989, %990
%991 = phi i64 [ %1017, %990 ], [ 1, %989 ]
%992 = phi double [ %1016, %990 ], [ %987, %989 ]
%993 = phi i64 [ %1018, %990 ], [ 0, %989 ]
%994 = mul nsw i64 %991, %831
%995 = add nuw nsw i64 %994, %985
%996 = getelementptr inbounds double, double* %46, i64 %995
%997 = load double, double* %996
%998 = fadd double %997, %992
%999 = add nuw nsw i64 %991, 1
%1000 = mul nsw i64 %999, %831
%1001 = add nuw nsw i64 %1000, %985
%1002 = getelementptr inbounds double, double* %46, i64 %1001
%1003 = load double, double* %1002
%1004 = fadd double %1003, %998
%1005 = add nuw nsw i64 %991, 2
%1006 = mul nsw i64 %1005, %831
%1007 = add nuw nsw i64 %1006, %985
%1008 = getelementptr inbounds double, double* %46, i64 %1007
%1009 = load double, double* %1008
%1010 = fadd double %1009, %1004
%1011 = add nuw nsw i64 %991, 3
%1012 = mul nsw i64 %1011, %831
%1013 = add nuw nsw i64 %1012, %985
%1014 = getelementptr inbounds double, double* %46, i64 %1013
%1015 = load double, double* %1014
%1016 = fadd double %1015, %1010
%1017 = add nuw nsw i64 %991, 4
%1018 = add nuw i64 %993, 4
%1019 = icmp eq i64 %1018, %135
br i1 %1019, label %1020, label %990
1020: ; preds = %990, %989
%1021 = phi double [ undef, %989 ], [ %1016, %990 ]
%1022 = phi i64 [ 1, %989 ], [ %1017, %990 ]
%1023 = phi double [ %987, %989 ], [ %1016, %990 ]
br i1 %136, label %1036, label %1024
1024: ; preds = %1020, %1024
%1025 = phi i64 [ %1033, %1024 ], [ %1022, %1020 ]
%1026 = phi double [ %1032, %1024 ], [ %1023, %1020 ]
%1027 = phi i64 [ %1034, %1024 ], [ 0, %1020 ]
%1028 = mul nsw i64 %1025, %831
%1029 = add nuw nsw i64 %1028, %985
%1030 = getelementptr inbounds double, double* %46, i64 %1029
%1031 = load double, double* %1030
%1032 = fadd double %1031, %1026
%1033 = add nuw nsw i64 %1025, 1
%1034 = add i64 %1027, 1
%1035 = icmp eq i64 %1034, %133
br i1 %1035, label %1036, label %1024
1036: ; preds = %1024, %1020
%1037 = phi double [ %1021, %1020 ], [ %1032, %1024 ]
store double %1037, double* %988
br label %1038
1038: ; preds = %1036, %984
%1039 = add nuw nsw i64 %985, 1
%1040 = icmp eq i64 %1039, %832
br i1 %1040, label %908, label %984
1041: ; preds = %982, %1041
%1042 = phi i64 [ %1048, %1041 ], [ %983, %982 ]
%1043 = getelementptr inbounds double, double* %47, i64 %1042
%1044 = load double, double* %1043
%1045 = getelementptr inbounds double, double* %41, i64 %1042
%1046 = load double, double* %1045
%1047 = fsub double %1044, %1046
store double %1047, double* %1043
%1048 = add nuw nsw i64 %1042, 1
%1049 = icmp eq i64 %1048, %910
br i1 %1049, label %1050, label %1041
1050: ; preds = %1041, %980, %829, %908
%1051 = call i32 @innerprod_q(i32* %0, double* %4, double* %47, double* %156, double* %18)
%1052 = load i32, i32* %15
%1053 = icmp sgt i32 %1052, 0
br i1 %1053, label %1054, label %1151
1054: ; preds = %1050
%1055 = load double, double* %18
%1056 = fneg double %1055
%1057 = zext i32 %1052 to i64
%1058 = icmp ult i32 %1052, 4
br i1 %1058, label %1139, label %1059
1059: ; preds = %1054
%1060 = and i64 %1057, 4294967292
%1061 = insertelement <2 x double> poison, double %1056, i64 0
%1062 = shufflevector <2 x double> %1061, <2 x double> poison, <2 x i32> zeroinitializer
%1063 = insertelement <2 x double> poison, double %1056, i64 0
%1064 = shufflevector <2 x double> %1063, <2 x double> poison, <2 x i32> zeroinitializer
%1065 = add nsw i64 %1060, -4
%1066 = lshr exact i64 %1065, 2
%1067 = add nuw nsw i64 %1066, 1
%1068 = and i64 %1067, 1
%1069 = icmp eq i64 %1065, 0
br i1 %1069, label %1115, label %1070
1070: ; preds = %1059
%1071 = and i64 %1067, 9223372036854775806
br label %1072
1072: ; preds = %1072, %1070
%1073 = phi i64 [ 0, %1070 ], [ %1112, %1072 ]
%1074 = phi i64 [ 0, %1070 ], [ %1113, %1072 ]
%1075 = getelementptr inbounds double, double* %47, i64 %1073
%1076 = bitcast double* %1075 to <2 x double>*
%1077 = load <2 x double>, <2 x double>* %1076
%1078 = getelementptr inbounds double, double* %1075, i64 2
%1079 = bitcast double* %1078 to <2 x double>*
%1080 = load <2 x double>, <2 x double>* %1079
%1081 = getelementptr inbounds double, double* %156, i64 %1073
%1082 = bitcast double* %1081 to <2 x double>*
%1083 = load <2 x double>, <2 x double>* %1082
%1084 = getelementptr inbounds double, double* %1081, i64 2
%1085 = bitcast double* %1084 to <2 x double>*
%1086 = load <2 x double>, <2 x double>* %1085
%1087 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1062, <2 x double> %1083, <2 x double> %1077)
%1088 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1064, <2 x double> %1086, <2 x double> %1080)
%1089 = getelementptr inbounds double, double* %48, i64 %1073
%1090 = bitcast double* %1089 to <2 x double>*
store <2 x double> %1087, <2 x double>* %1090
%1091 = getelementptr inbounds double, double* %1089, i64 2
%1092 = bitcast double* %1091 to <2 x double>*
store <2 x double> %1088, <2 x double>* %1092
%1093 = or i64 %1073, 4
%1094 = getelementptr inbounds double, double* %47, i64 %1093
%1095 = bitcast double* %1094 to <2 x double>*
%1096 = load <2 x double>, <2 x double>* %1095
%1097 = getelementptr inbounds double, double* %1094, i64 2
%1098 = bitcast double* %1097 to <2 x double>*
%1099 = load <2 x double>, <2 x double>* %1098
%1100 = getelementptr inbounds double, double* %156, i64 %1093
%1101 = bitcast double* %1100 to <2 x double>*
%1102 = load <2 x double>, <2 x double>* %1101
%1103 = getelementptr inbounds double, double* %1100, i64 2
%1104 = bitcast double* %1103 to <2 x double>*
%1105 = load <2 x double>, <2 x double>* %1104
%1106 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1062, <2 x double> %1102, <2 x double> %1096)
%1107 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1064, <2 x double> %1105, <2 x double> %1099)
%1108 = getelementptr inbounds double, double* %48, i64 %1093
%1109 = bitcast double* %1108 to <2 x double>*
store <2 x double> %1106, <2 x double>* %1109
%1110 = getelementptr inbounds double, double* %1108, i64 2
%1111 = bitcast double* %1110 to <2 x double>*
store <2 x double> %1107, <2 x double>* %1111
%1112 = add nuw i64 %1073, 8
%1113 = add i64 %1074, 2
%1114 = icmp eq i64 %1113, %1071
br i1 %1114, label %1115, label %1072
1115: ; preds = %1072, %1059
%1116 = phi i64 [ 0, %1059 ], [ %1112, %1072 ]
%1117 = icmp eq i64 %1068, 0
br i1 %1117, label %1137, label %1118
1118: ; preds = %1115
%1119 = getelementptr inbounds double, double* %47, i64 %1116
%1120 = bitcast double* %1119 to <2 x double>*
%1121 = load <2 x double>, <2 x double>* %1120
%1122 = getelementptr inbounds double, double* %1119, i64 2
%1123 = bitcast double* %1122 to <2 x double>*
%1124 = load <2 x double>, <2 x double>* %1123
%1125 = getelementptr inbounds double, double* %156, i64 %1116
%1126 = bitcast double* %1125 to <2 x double>*
%1127 = load <2 x double>, <2 x double>* %1126
%1128 = getelementptr inbounds double, double* %1125, i64 2
%1129 = bitcast double* %1128 to <2 x double>*
%1130 = load <2 x double>, <2 x double>* %1129
%1131 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1062, <2 x double> %1127, <2 x double> %1121)
%1132 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1064, <2 x double> %1130, <2 x double> %1124)
%1133 = getelementptr inbounds double, double* %48, i64 %1116
%1134 = bitcast double* %1133 to <2 x double>*
store <2 x double> %1131, <2 x double>* %1134
%1135 = getelementptr inbounds double, double* %1133, i64 2
%1136 = bitcast double* %1135 to <2 x double>*
store <2 x double> %1132, <2 x double>* %1136
br label %1137
1137: ; preds = %1115, %1118
%1138 = icmp eq i64 %1060, %1057
br i1 %1138, label %1151, label %1139
1139: ; preds = %1054, %1137
%1140 = phi i64 [ 0, %1054 ], [ %1060, %1137 ]
br label %1141
1141: ; preds = %1139, %1141
%1142 = phi i64 [ %1149, %1141 ], [ %1140, %1139 ]
%1143 = getelementptr inbounds double, double* %47, i64 %1142
%1144 = load double, double* %1143
%1145 = getelementptr inbounds double, double* %156, i64 %1142
%1146 = load double, double* %1145
%1147 = call double @llvm.fmuladd.f64(double %1056, double %1146, double %1144)
%1148 = getelementptr inbounds double, double* %48, i64 %1142
store double %1147, double* %1148
%1149 = add nuw nsw i64 %1142, 1
%1150 = icmp eq i64 %1149, %1057
br i1 %1150, label %1151, label %1141
1151: ; preds = %1141, %1137, %1050
%1152 = call i32 @pvecnorm(i32* %15, double* %48, double* %19, double* %18)
%1153 = load double, double* %18
%1154 = fmul double %25, %1153
%1155 = call double @cos(double %1154)
%1156 = load double, double* %18
%1157 = fmul double %25, %1156
%1158 = call double @sin(double %1157)
%1159 = load i32, i32* %15
%1160 = icmp sgt i32 %1159, 0
br i1 %1160, label %1161, label %1344
1161: ; preds = %1151
%1162 = load double, double* %18
%1163 = zext i32 %1159 to i64
%1164 = icmp eq i32 %1159, 1
br i1 %1164, label %1232, label %1165
1165: ; preds = %1161
%1166 = getelementptr double, double* %49, i64 %1163
%1167 = getelementptr double, double* %156, i64 %1163
%1168 = icmp ult double* %49, %1167
%1169 = icmp ult double* %156, %1166
%1170 = and i1 %1168, %1169
br i1 %1170, label %1232, label %1171
1171: ; preds = %1165
%1172 = and i64 %1163, 4294967294
%1173 = insertelement <2 x double> poison, double %1162, i64 0
%1174 = shufflevector <2 x double> %1173, <2 x double> poison, <2 x i32> zeroinitializer
%1175 = insertelement <2 x double> poison, double %1158, i64 0
%1176 = shufflevector <2 x double> %1175, <2 x double> poison, <2 x i32> zeroinitializer
%1177 = insertelement <2 x double> poison, double %1155, i64 0
%1178 = shufflevector <2 x double> %1177, <2 x double> poison, <2 x i32> zeroinitializer
%1179 = add nsw i64 %1172, -2
%1180 = lshr exact i64 %1179, 1
%1181 = add nuw i64 %1180, 1
%1182 = and i64 %1181, 1
%1183 = icmp eq i64 %1179, 0
br i1 %1183, label %1215, label %1184
1184: ; preds = %1171
%1185 = and i64 %1181, -2
br label %1186
1186: ; preds = %1186, %1184
%1187 = phi i64 [ 0, %1184 ], [ %1212, %1186 ]
%1188 = phi i64 [ 0, %1184 ], [ %1213, %1186 ]
%1189 = getelementptr inbounds double, double* %156, i64 %1187
%1190 = bitcast double* %1189 to <2 x double>*
%1191 = load <2 x double>, <2 x double>* %1190
%1192 = getelementptr inbounds double, double* %48, i64 %1187
%1193 = bitcast double* %1192 to <2 x double>*
%1194 = load <2 x double>, <2 x double>* %1193
%1195 = fdiv <2 x double> %1194, %1174
%1196 = fmul <2 x double> %1176, %1195
%1197 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1178, <2 x double> %1191, <2 x double> %1196)
%1198 = getelementptr inbounds double, double* %49, i64 %1187
%1199 = bitcast double* %1198 to <2 x double>*
store <2 x double> %1197, <2 x double>* %1199
%1200 = or i64 %1187, 2
%1201 = getelementptr inbounds double, double* %156, i64 %1200
%1202 = bitcast double* %1201 to <2 x double>*
%1203 = load <2 x double>, <2 x double>* %1202
%1204 = getelementptr inbounds double, double* %48, i64 %1200
%1205 = bitcast double* %1204 to <2 x double>*
%1206 = load <2 x double>, <2 x double>* %1205
%1207 = fdiv <2 x double> %1206, %1174
%1208 = fmul <2 x double> %1176, %1207
%1209 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1178, <2 x double> %1203, <2 x double> %1208)
%1210 = getelementptr inbounds double, double* %49, i64 %1200
%1211 = bitcast double* %1210 to <2 x double>*
store <2 x double> %1209, <2 x double>* %1211
%1212 = add nuw i64 %1187, 4
%1213 = add nuw i64 %1188, 2
%1214 = icmp eq i64 %1213, %1185
br i1 %1214, label %1215, label %1186
1215: ; preds = %1186, %1171
%1216 = phi i64 [ 0, %1171 ], [ %1212, %1186 ]
%1217 = icmp eq i64 %1182, 0
br i1 %1217, label %1230, label %1218
1218: ; preds = %1215
%1219 = getelementptr inbounds double, double* %156, i64 %1216
%1220 = bitcast double* %1219 to <2 x double>*
%1221 = load <2 x double>, <2 x double>* %1220
%1222 = getelementptr inbounds double, double* %48, i64 %1216
%1223 = bitcast double* %1222 to <2 x double>*
%1224 = load <2 x double>, <2 x double>* %1223
%1225 = fdiv <2 x double> %1224, %1174
%1226 = fmul <2 x double> %1176, %1225
%1227 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1178, <2 x double> %1221, <2 x double> %1226)
%1228 = getelementptr inbounds double, double* %49, i64 %1216
%1229 = bitcast double* %1228 to <2 x double>*
store <2 x double> %1227, <2 x double>* %1229
br label %1230
1230: ; preds = %1215, %1218
%1231 = icmp eq i64 %1172, %1163
br i1 %1231, label %1251, label %1232
1232: ; preds = %1165, %1161, %1230
%1233 = phi i64 [ 0, %1165 ], [ 0, %1161 ], [ %1172, %1230 ]
%1234 = xor i64 %1233, -1
%1235 = and i64 %1163, 1
%1236 = icmp eq i64 %1235, 0
br i1 %1236, label %1247, label %1237
1237: ; preds = %1232
%1238 = getelementptr inbounds double, double* %156, i64 %1233
%1239 = load double, double* %1238
%1240 = getelementptr inbounds double, double* %48, i64 %1233
%1241 = load double, double* %1240
%1242 = fdiv double %1241, %1162
%1243 = fmul double %1158, %1242
%1244 = call double @llvm.fmuladd.f64(double %1155, double %1239, double %1243)
%1245 = getelementptr inbounds double, double* %49, i64 %1233
store double %1244, double* %1245
%1246 = or i64 %1233, 1
br label %1247
1247: ; preds = %1237, %1232
%1248 = phi i64 [ %1233, %1232 ], [ %1246, %1237 ]
%1249 = sub nsw i64 0, %1163
%1250 = icmp eq i64 %1234, %1249
br i1 %1250, label %1251, label %1315
1251: ; preds = %1247, %1315, %1230
br i1 %1160, label %1252, label %1344
1252: ; preds = %1251
%1253 = zext i32 %1159 to i64
%1254 = icmp ult i32 %1159, 4
br i1 %1254, label %1313, label %1255
1255: ; preds = %1252
%1256 = and i64 %1163, 4294967292
%1257 = add nsw i64 %1256, -4
%1258 = lshr exact i64 %1257, 2
%1259 = add nuw nsw i64 %1258, 1
%1260 = and i64 %1259, 1
%1261 = icmp eq i64 %1257, 0
br i1 %1261, label %1295, label %1262
1262: ; preds = %1255
%1263 = and i64 %1259, 9223372036854775806
br label %1264
1264: ; preds = %1264, %1262
%1265 = phi i64 [ 0, %1262 ], [ %1292, %1264 ]
%1266 = phi i64 [ 0, %1262 ], [ %1293, %1264 ]
%1267 = getelementptr inbounds double, double* %49, i64 %1265
%1268 = bitcast double* %1267 to <2 x double>*
%1269 = load <2 x double>, <2 x double>* %1268
%1270 = getelementptr inbounds double, double* %1267, i64 2
%1271 = bitcast double* %1270 to <2 x double>*
%1272 = load <2 x double>, <2 x double>* %1271
%1273 = fmul <2 x double> %1269, %1269
%1274 = fmul <2 x double> %1272, %1272
%1275 = getelementptr inbounds double, double* %41, i64 %1265
%1276 = bitcast double* %1275 to <2 x double>*
store <2 x double> %1273, <2 x double>* %1276
%1277 = getelementptr inbounds double, double* %1275, i64 2
%1278 = bitcast double* %1277 to <2 x double>*
store <2 x double> %1274, <2 x double>* %1278
%1279 = or i64 %1265, 4
%1280 = getelementptr inbounds double, double* %49, i64 %1279
%1281 = bitcast double* %1280 to <2 x double>*
%1282 = load <2 x double>, <2 x double>* %1281
%1283 = getelementptr inbounds double, double* %1280, i64 2
%1284 = bitcast double* %1283 to <2 x double>*
%1285 = load <2 x double>, <2 x double>* %1284
%1286 = fmul <2 x double> %1282, %1282
%1287 = fmul <2 x double> %1285, %1285
%1288 = getelementptr inbounds double, double* %41, i64 %1279
%1289 = bitcast double* %1288 to <2 x double>*
store <2 x double> %1286, <2 x double>* %1289
%1290 = getelementptr inbounds double, double* %1288, i64 2
%1291 = bitcast double* %1290 to <2 x double>*
store <2 x double> %1287, <2 x double>* %1291
%1292 = add nuw i64 %1265, 8
%1293 = add i64 %1266, 2
%1294 = icmp eq i64 %1293, %1263
br i1 %1294, label %1295, label %1264
1295: ; preds = %1264, %1255
%1296 = phi i64 [ 0, %1255 ], [ %1292, %1264 ]
%1297 = icmp eq i64 %1260, 0
br i1 %1297, label %1311, label %1298
1298: ; preds = %1295
%1299 = getelementptr inbounds double, double* %49, i64 %1296
%1300 = bitcast double* %1299 to <2 x double>*
%1301 = load <2 x double>, <2 x double>* %1300
%1302 = getelementptr inbounds double, double* %1299, i64 2
%1303 = bitcast double* %1302 to <2 x double>*
%1304 = load <2 x double>, <2 x double>* %1303
%1305 = fmul <2 x double> %1301, %1301
%1306 = fmul <2 x double> %1304, %1304
%1307 = getelementptr inbounds double, double* %41, i64 %1296
%1308 = bitcast double* %1307 to <2 x double>*
store <2 x double> %1305, <2 x double>* %1308
%1309 = getelementptr inbounds double, double* %1307, i64 2
%1310 = bitcast double* %1309 to <2 x double>*
store <2 x double> %1306, <2 x double>* %1310
br label %1311
1311: ; preds = %1295, %1298
%1312 = icmp eq i64 %1256, %1163
br i1 %1312, label %1344, label %1313
1313: ; preds = %1252, %1311
%1314 = phi i64 [ 0, %1252 ], [ %1256, %1311 ]
br label %1336
1315: ; preds = %1247, %1315
%1316 = phi i64 [ %1334, %1315 ], [ %1248, %1247 ]
%1317 = getelementptr inbounds double, double* %156, i64 %1316
%1318 = load double, double* %1317
%1319 = getelementptr inbounds double, double* %48, i64 %1316
%1320 = load double, double* %1319
%1321 = fdiv double %1320, %1162
%1322 = fmul double %1158, %1321
%1323 = call double @llvm.fmuladd.f64(double %1155, double %1318, double %1322)
%1324 = getelementptr inbounds double, double* %49, i64 %1316
store double %1323, double* %1324
%1325 = add nuw nsw i64 %1316, 1
%1326 = getelementptr inbounds double, double* %156, i64 %1325
%1327 = load double, double* %1326
%1328 = getelementptr inbounds double, double* %48, i64 %1325
%1329 = load double, double* %1328
%1330 = fdiv double %1329, %1162
%1331 = fmul double %1158, %1330
%1332 = call double @llvm.fmuladd.f64(double %1155, double %1327, double %1331)
%1333 = getelementptr inbounds double, double* %49, i64 %1325
store double %1332, double* %1333
%1334 = add nuw nsw i64 %1316, 2
%1335 = icmp eq i64 %1334, %1163
br i1 %1335, label %1251, label %1315
1336: ; preds = %1313, %1336
%1337 = phi i64 [ %1342, %1336 ], [ %1314, %1313 ]
%1338 = getelementptr inbounds double, double* %49, i64 %1337
%1339 = load double, double* %1338
%1340 = fmul double %1339, %1339
%1341 = getelementptr inbounds double, double* %41, i64 %1337
store double %1340, double* %1341
%1342 = add nuw nsw i64 %1337, 1
%1343 = icmp eq i64 %1342, %1253
br i1 %1343, label %1344, label %1336
1344: ; preds = %1336, %1311, %1151, %1251
%1345 = call i32 @cumtrapz(i32* %15, double* %4, double* %41, double* %50)
%1346 = load i32, i32* %15
%1347 = icmp sgt i32 %1346, 0
br i1 %1347, label %1348, label %1389
1348: ; preds = %1344
%1349 = add nsw i32 %1346, -1
%1350 = zext i32 %1349 to i64
%1351 = getelementptr inbounds double, double* %50, i64 %1350
%1352 = zext i32 %1346 to i64
%1353 = and i64 %1352, 1
%1354 = icmp eq i32 %1346, 1
br i1 %1354, label %1378, label %1355
1355: ; preds = %1348
%1356 = and i64 %1352, 4294967294
br label %1357
1357: ; preds = %1357, %1355
%1358 = phi i64 [ 0, %1355 ], [ %1375, %1357 ]
%1359 = phi i64 [ 0, %1355 ], [ %1376, %1357 ]
%1360 = getelementptr inbounds double, double* %50, i64 %1358
%1361 = load double, double* %1360
%1362 = load double, double* %50
%1363 = fsub double %1361, %1362
%1364 = load double, double* %1351
%1365 = fsub double %1364, %1362
%1366 = fdiv double %1363, %1365
store double %1366, double* %1360
%1367 = or i64 %1358, 1
%1368 = getelementptr inbounds double, double* %50, i64 %1367
%1369 = load double, double* %1368
%1370 = load double, double* %50
%1371 = fsub double %1369, %1370
%1372 = load double, double* %1351
%1373 = fsub double %1372, %1370
%1374 = fdiv double %1371, %1373
store double %1374, double* %1368
%1375 = add nuw nsw i64 %1358, 2
%1376 = add i64 %1359, 2
%1377 = icmp eq i64 %1376, %1356
br i1 %1377, label %1378, label %1357
1378: ; preds = %1357, %1348
%1379 = phi i64 [ 0, %1348 ], [ %1375, %1357 ]
%1380 = icmp eq i64 %1353, 0
br i1 %1380, label %1389, label %1381
1381: ; preds = %1378
%1382 = getelementptr inbounds double, double* %50, i64 %1379
%1383 = load double, double* %1382
%1384 = load double, double* %50
%1385 = fsub double %1383, %1384
%1386 = load double, double* %1351
%1387 = fsub double %1386, %1384
%1388 = fdiv double %1385, %1387
store double %1388, double* %1382
br label %1389
1389: ; preds = %1381, %1378, %1344
store double 0.000000e+00, double* %18
br i1 %123, label %1390, label %1433
1390: ; preds = %1389
br i1 %138, label %1417, label %1391
1391: ; preds = %1390, %1391
%1392 = phi i64 [ %1414, %1391 ], [ 0, %1390 ]
%1393 = phi double [ %1413, %1391 ], [ 0.000000e+00, %1390 ]
%1394 = phi i64 [ %1415, %1391 ], [ 0, %1390 ]
%1395 = getelementptr inbounds i32, i32* %7, i64 %1392
%1396 = load i32, i32* %1395
%1397 = sitofp i32 %1396 to double
%1398 = getelementptr inbounds double, double* %2, i64 %1392
%1399 = load double, double* %1398
%1400 = getelementptr inbounds double, double* %36, i64 %1392
%1401 = load double, double* %1400
%1402 = fadd double %1399, %1401
%1403 = call double @llvm.fmuladd.f64(double %1397, double %1402, double %1393)
%1404 = or i64 %1392, 1
%1405 = getelementptr inbounds i32, i32* %7, i64 %1404
%1406 = load i32, i32* %1405
%1407 = sitofp i32 %1406 to double
%1408 = getelementptr inbounds double, double* %2, i64 %1404
%1409 = load double, double* %1408
%1410 = getelementptr inbounds double, double* %36, i64 %1404
%1411 = load double, double* %1410
%1412 = fadd double %1409, %1411
%1413 = call double @llvm.fmuladd.f64(double %1407, double %1412, double %1403)
%1414 = add nuw nsw i64 %1392, 2
%1415 = add i64 %1394, 2
%1416 = icmp eq i64 %1415, %139
br i1 %1416, label %1417, label %1391
1417: ; preds = %1391, %1390
%1418 = phi double [ undef, %1390 ], [ %1413, %1391 ]
%1419 = phi i64 [ 0, %1390 ], [ %1414, %1391 ]
%1420 = phi double [ 0.000000e+00, %1390 ], [ %1413, %1391 ]
br i1 %140, label %1431, label %1421
1421: ; preds = %1417
%1422 = getelementptr inbounds i32, i32* %7, i64 %1419
%1423 = load i32, i32* %1422
%1424 = sitofp i32 %1423 to double
%1425 = getelementptr inbounds double, double* %2, i64 %1419
%1426 = load double, double* %1425
%1427 = getelementptr inbounds double, double* %36, i64 %1419
%1428 = load double, double* %1427
%1429 = fadd double %1426, %1428
%1430 = call double @llvm.fmuladd.f64(double %1424, double %1429, double %1420)
br label %1431
1431: ; preds = %1417, %1421
%1432 = phi double [ %1418, %1417 ], [ %1430, %1421 ]
store double %1432, double* %18
br label %1433
1433: ; preds = %1431, %1389
%1434 = phi double [ %1432, %1431 ], [ 0.000000e+00, %1389 ]
%1435 = load double, double* %17
%1436 = call double @log(double %1435)
%1437 = fsub double %1434, %1436
%1438 = getelementptr inbounds double, double* %52, i64 %154
store double %1437, double* %1438
br i1 %125, label %1439, label %1442
1439: ; preds = %1433
%1440 = trunc i64 %154 to i32
%1441 = call i32 @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str, i64 0, i64 0), i32 %1440, double %1437)
br label %1442
1442: ; preds = %1439, %1433
%1443 = icmp ugt i64 %154, 1
br i1 %1443, label %1444, label %1455
1444: ; preds = %1442
%1445 = add nsw i64 %154, -1
%1446 = getelementptr inbounds double, double* %52, i64 %1445
%1447 = load double, double* %1446
%1448 = fsub double %1437, %1447
%1449 = call double @llvm.fabs.f64(double %1448)
%1450 = fcmp uge double %1449, %24
%1451 = fcmp uge double %1448, 0.000000e+00
%1452 = select i1 %1450, i1 %1451, i1 false
%1453 = icmp slt i64 %154, %126
%1454 = select i1 %1452, i1 %1453, i1 false
br i1 %1454, label %1457, label %1460
1455: ; preds = %1442
%1456 = icmp slt i64 %154, %126
br i1 %1456, label %1457, label %1460
1457: ; preds = %1455, %1444
%1458 = add nuw i64 %154, 1
%1459 = load i32, i32* %15
br label %152
1460: ; preds = %1444, %1455
%1461 = load i32, i32* %15
%1462 = icmp sgt i32 %1461, 1
br i1 %1462, label %1463, label %1471
1463: ; preds = %1460
%1464 = getelementptr double, double* %12, i64 1
%1465 = bitcast double* %1464 to i8*
%1466 = getelementptr inbounds double, double* %50, i64 1
%1467 = bitcast double* %1466 to i8*
%1468 = add nsw i32 %1461, -1
%1469 = zext i32 %1468 to i64
%1470 = shl nuw nsw i64 %1469, 3
br label %1471
1471: ; preds = %1463, %1460
%1472 = call i32 @free(double* %54)
ret void
}