#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 */
int M_PI;
double acos(double);
int /*<<< orphan*/ approx(double *, double *, int, double *, double *, int, int,
                          int /*<<< orphan*/, int, int /*<<< orphan*/);
int /*<<< orphan*/ col_gradient(int, int, double *, double, double *);
int cos(double);
int /*<<< orphan*/ cumtrapz(int *, double *, double *, double *);
double exp(double);
int /*<<< orphan*/ group_action_by_gamma(int *, int *, double *, double *,
                                         double *);
double innerprod_q2(int *, double *, double *);
int /*<<< orphan*/ linspace(int /*<<< orphan*/, int, int, double *);
double log(double);
int /*<<< orphan*/ printf(char *, int, double);
int /*<<< orphan*/ product(int, int, int, double *, double *, double *);
int /*<<< orphan*/ pvecnorm(int *, double *, double *, double *);
int sin(double);
int sqrt(int);
void ocmlogit_warp_grad(int *n1, int *T1, int *m1, double *alpha, double *nu,
                        double *q, int *y, int *max_itri, double *toli,
                        double *deltaOi, double *deltagi, int *displayi,
                        double *gamout, double *Oout) {
  int TT = *T1;
  int m = *m1;
  int n = *n1;
  int max_itr = *max_itri;
  double tol = *toli, deltaO = *deltaOi, deltag = *deltagi;
  double display = *displayi;
  int k, j, l, kk, jj;
  int p = 20;
  int p1 = 10;
  int itr = 0;
  double binsize1 = 1.0;
  double t[TT], O1[4], O2[4], binsize, E[4], A[m], O_tmp[4];
  double gam1[TT], f_basis[TT * p], max_val[max_itr + 1];
  double q_tilde[TT * n], B[m], q_tmp[TT * n];
  double tmpi, tmp1, tmp2[m], tmp3, tmp4, tmpi1;
  double hO, q_tilde_diff[TT * n], c[TT * m], cbar[TT], ftmp[TT];
  double tmp5[TT * p], tmp6[TT * m], tmp7[TT], tmp8[TT * m];
  double hpsi[TT], ones[TT], psi[TT], gam2[TT], gam_tmp[TT];
  double max_val_change, res_cos, res_sin, theta, thetanew;
  double *t_ptr, *f_basis_ptr, *A_ptr, *tmpi_ptr, *q_tilde_ptr;
  double *nu_ptr, *B_ptr, *E_ptr, *q_tmp_ptr, *alpha_ptr;
  double *tmp2_ptr, *tmp3_ptr, *O1_ptr, *O2_ptr, *tmp4_ptr;
  double *hO_ptr, *O_tmp_ptr, *q_tilde_diff_ptr, *c_ptr, *cbar_ptr;
  double *ftmp_ptr, *tmp5_ptr, *tmp6_ptr, *tmp7_ptr, *tmp8_ptr;
  double *hpsi_ptr, *psi_ptr, *gam1_ptr, *gam2_ptr, *ones_ptr;
  double *gam_tmp_ptr, *q_ptr;
  int *y_ptr;
  t_ptr = t;
  linspace(0, 1, TT, t_ptr);
  binsize = 1.0 / (TT - 1);
  gam1_ptr = gam1;
  for (k = 0; k < TT; k++) {
    gam1[k] = t[k];
    ones[k] = 1.0;
  }
  O1[0] = 1;
  O1[1] = 0;
  O1[2] = 0;
  O1[3] = 1;
  f_basis_ptr = f_basis;
  for (k = 0; k < p1; k++) {
    for (j = 0; j < TT; j++) {
      f_basis[j + 2 * k * TT] = 1 / sqrt(M_PI) * sin(2 * M_PI * (k + 1) * t[j]);
      f_basis[j + (2 * k + 1) * TT] =
          1 / sqrt(M_PI) * cos(2 * M_PI * (k + 1) * t[j]);
    }
  }
  q_tilde_ptr = q_tilde;
  for (k = 0; k < TT * n; k++)
    q_tilde[k] = q[k];
  do {
    A_ptr = A;
    nu_ptr = nu;
    q_tilde_ptr = q_tilde;
    for (j = 0; j < m; j++) {
      A[j] = innerprod_q2(T1, q_tilde_ptr, nu_ptr);
      nu_ptr += n * TT;
    }
    theta = acos(O1[0]);
    O_tmp[0] = -1 * sin(theta);
    O_tmp[1] = cos(theta);
    O_tmp[2] = -1 * cos(theta);
    O_tmp[3] = -1 * sin(theta);
    B_ptr = B;
    O_tmp_ptr = O_tmp;
    q_tilde_ptr = q_tilde;
    q_tmp_ptr = q_tmp;
    product(n, n, TT, O_tmp_ptr, q_tilde_ptr, q_tmp_ptr);
    nu_ptr = nu;
    for (j = 0; j < m; j++) {
      B[j] = innerprod_q2(T1, q_tmp_ptr, nu_ptr);
      nu_ptr += n * TT;
    }
    tmp1 = 0;
    A_ptr = A;
    alpha_ptr = alpha;
    for (j = 0; j < m; j++)
      tmp1 += exp(alpha_ptr[j] + A_ptr[j]);
    tmp2_ptr = tmp2;
    B_ptr = B;
    for (j = 0; j < m; j++) {
      tmp2_ptr[j] = exp(alpha_ptr[j] + A_ptr[j]) * B_ptr[j];
    }
    tmp2_ptr = tmp2;
    tmp3 = 0;
    for (k = 0; k < m; k++) {
      tmp3 += tmp2_ptr[k];
    }
    tmp3 = tmp3 / tmp1;
    tmp4 = 0;
    B_ptr = B;
    y_ptr = y;
    for (k = 0; k < m; k++) {
      tmp4 += y_ptr[k] * B_ptr[k];
    }
    hO = tmp4 - tmp3;
    thetanew = theta + deltaO * hO;
    O2[0] = cos(thetanew);
    O2[1] = sin(thetanew);
    O2[2] = -1 * sin(thetanew);
    O2[3] = cos(thetanew);
    q_tilde_diff_ptr = q_tilde_diff;
    q_tilde_ptr = q_tilde;
    col_gradient(n, TT, q_tilde_ptr, binsize, q_tilde_diff_ptr);
    cbar_ptr = cbar;
    ftmp_ptr = ftmp;
    q_tmp_ptr = q_tmp;
    c_ptr = c;
    nu_ptr = nu;
    for (j = 0; j < m; j++) {
      tmp5_ptr = tmp5;
      for (k = 0; k < p; k++) {
        for (l = 0; l < TT; l++)
          ftmp[l] = f_basis[l + k * TT];
        cumtrapz(T1, t_ptr, ftmp_ptr, cbar_ptr);
        for (jj = 0; jj < n; jj++) {
          for (l = 0; l < TT; l++)
            q_tmp[n * l + jj] = 2 * q_tilde_diff[n * l + jj] * cbar[l] +
                                q_tilde[n * l + jj] * f_basis[l + k * TT];
        }
        tmpi = innerprod_q2(T1, q_tmp_ptr, nu_ptr);
        for (l = 0; l < TT; l++)
          tmp5[l + k * TT] = tmpi * f_basis[l + k * TT];
      }
      for (jj = 0; jj < TT; jj++) {
        c[jj + TT * j] = tmp5[jj];
        for (l = 1; l < p; l++)
          c[jj + TT * j] = c[jj + TT * j] + tmp5[jj + l * TT];
      }
      nu_ptr += n * TT;
    }
    tmp6_ptr = tmp6;
    c_ptr = c;
    A_ptr = A;
    for (j = 0; j < m; j++) {
      for (k = 0; k < TT; k++) {
        tmp6_ptr[k] = exp(alpha_ptr[j] + A_ptr[j]) * c_ptr[k];
      }
      c_ptr += TT;
      tmp6_ptr += TT;
    }
    tmp6_ptr = tmp6;
    tmp7_ptr = tmp7;
    for (k = 0; k < TT; k++) {
      tmp7_ptr[k] = tmp6_ptr[k];
      for (j = 1; j < m; j++)
        tmp7_ptr[k] = tmp7_ptr[k] + tmp6_ptr[k + j * TT];
      tmp7_ptr[k] = tmp7_ptr[k] / tmp1;
    }
    tmp8_ptr = tmp8;
    c_ptr = c;
    y_ptr = y;
    for (j = 0; j < m; j++) {
      for (k = 0; k < TT; k++) {
        tmp8_ptr[k] = y_ptr[j] * c_ptr[k];
      }
      c_ptr += TT;
      tmp8_ptr += TT;
    }
    hpsi_ptr = hpsi;
    tmp8_ptr = tmp8;
    tmp7_ptr = tmp7;
    for (k = 0; k < TT; k++) {
      hpsi_ptr[k] = tmp8_ptr[k];
      for (j = 1; j < m; j++)
        hpsi_ptr[k] += tmp8_ptr[k + j * TT];
      hpsi_ptr[k] = hpsi_ptr[k] - tmp7_ptr[k];
    }
    psi_ptr = psi;
    ones_ptr = ones;
    gam2_ptr = gam2;
    gam_tmp_ptr = gam_tmp;
    hpsi_ptr = hpsi;
    pvecnorm(T1, hpsi_ptr, &binsize1, &tmpi);
    res_cos = cos(deltag * tmpi);
    res_sin = sin(deltag * tmpi);
    for (j = 0; j < TT; j++)
      psi_ptr[j] = res_cos * ones_ptr[j] + res_sin * (hpsi_ptr[j] / tmpi);
    for (j = 0; j < TT; j++)
      tmp8[j] = psi_ptr[j] * psi_ptr[j];
    tmp8_ptr = tmp8;
    cumtrapz(T1, t_ptr, tmp8_ptr, gam_tmp_ptr);
    for (j = 0; j < TT; j++)
      gam_tmp_ptr[j] = (gam_tmp_ptr[j] - gam_tmp_ptr[0]) /
                       (gam_tmp_ptr[TT - 1] - gam_tmp_ptr[0]);
    approx(t, gam1_ptr, TT, gam_tmp_ptr, gam2_ptr, TT, 1, 0, 1, 0);
    tmpi1 = 0;
    alpha_ptr = alpha;
    A_ptr = A;
    for (j = 0; j < m; j++)
      tmpi1 += y[j] * (alpha_ptr[j] + A_ptr[j]);
    max_val[itr] = tmpi1 - log(tmp1);
    if (display == 1)
      printf("Iteration %d : Cost %f\n", (itr + 1), max_val[itr]);
    gam1_ptr = gam2;
    O1_ptr = O2;
    O1[0] = O2[0];
    O1[1] = O2[1];
    O1[2] = O2[2];
    O1[3] = O2[3];
    q_tilde_ptr = q_tilde;
    q_tmp_ptr = q_tmp;
    q_ptr = q;
    product(n, n, TT, O1_ptr, q_ptr, q_tmp_ptr);
    group_action_by_gamma(n1, T1, q_tmp_ptr, gam1_ptr, q_tilde_ptr);
    if (itr >= 2) {
      max_val_change = max_val[itr] - max_val[itr - 1];
      if (hO < tol && tmpi < tol)
        break;
    }
    itr++;
  } while (max_itr >= itr);
  for (k = 0; k < TT; k++) {
    gamout[k] = gam1_ptr[k];
  }
  for (k = 0; k < n * n; k++) {
    Oout[k] = O1_ptr[k];
  }
}


x86 assembly (clang, -O0):
<ocmlogit_warp_grad>:
push   %rbp
mov    %rsp,%rbp
sub    $0x400,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
mov    0x20(%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   $0x14,-0x78(%rbp)
movl   $0xa,-0x7c(%rbp)
movl   $0x0,-0x80(%rbp)
movabs $0x3ff0000000000000,%rax
mov    %rax,-0x88(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,%ecx
mov    %rsp,%rax
mov    %rax,-0x90(%rbp)
lea    0xf(,%rcx,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rax
sub    %rdx,%rax
mov    %rax,-0x3f0(%rbp)
mov    %rax,%rsp
mov    %rcx,-0x98(%rbp)
mov    -0x38(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3e8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x118(%rbp)
mov    -0x34(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x348(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x148(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   %edx,%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3e0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x150(%rbp)
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3d8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x158(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   %edx,%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3d0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x160(%rbp)
mov    -0x38(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3c8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x168(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   %edx,%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3c0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x170(%rbp)
mov    -0x38(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3b8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x188(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   %edx,%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3b0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1b0(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   %edx,%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3a8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1b8(%rbp)
mov    -0x34(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x3a0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1c0(%rbp)
mov    -0x34(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x398(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1c8(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x78(%rbp),%edx
imul   %edx,%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x390(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1d0(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   %edx,%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x388(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1d8(%rbp)
mov    -0x34(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x380(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1e0(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x38(%rbp),%edx
imul   %edx,%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x378(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1e8(%rbp)
mov    -0x34(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x370(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1f0(%rbp)
mov    -0x34(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x368(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x1f8(%rbp)
mov    -0x34(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x360(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x200(%rbp)
mov    -0x34(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x358(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x208(%rbp)
mov    -0x34(%rbp),%ecx
lea    0xf(,%rcx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x350(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x210(%rbp)
mov    %rax,-0x240(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x240(%rbp),%rcx
xor    %edi,%edi
mov    $0x1,%esi
call   10e0 <linspace@plt>
mov    -0x348(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cvtsi2sd %ecx,%xmm1
movsd  0x1996(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    %rax,-0x318(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    16d6 <ocmlogit_warp_grad+0x4e6>
mov    -0x368(%rbp),%rax
mov    -0x348(%rbp),%rcx
mov    -0x3f0(%rbp),%rdx
movslq -0x64(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
movslq -0x64(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
movslq -0x64(%rbp),%rcx
movsd  0x193d(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1684 <ocmlogit_warp_grad+0x494>
mov    -0x3e0(%rbp),%rax
movsd  0x191b(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x18f5(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    %rax,-0x248(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x7c(%rbp),%eax
jge    185a <ocmlogit_warp_grad+0x66a>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1847 <ocmlogit_warp_grad+0x657>
mov    0x38a1(%rip),%rax
mov    (%rax),%edi
call   1110 <sqrt@plt>
mov    %eax,%ecx
mov    $0x1,%eax
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3f0(%rbp),%rax
mov    %ecx,-0x3f8(%rbp)
mov    0x387a(%rip),%rcx
mov    (%rcx),%ecx
shl    $0x1,%ecx
mov    -0x64(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
cvtsi2sd %ecx,%xmm0
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
call   1090 <sin@plt>
mov    -0x3f8(%rbp),%ecx
mov    %eax,%edx
mov    -0x3e0(%rbp),%rax
imul   %edx,%ecx
cvtsi2sd %ecx,%xmm0
mov    -0x68(%rbp),%ecx
mov    -0x64(%rbp),%edx
shl    $0x1,%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3826(%rip),%rax
mov    (%rax),%edi
call   1110 <sqrt@plt>
mov    %eax,%ecx
mov    $0x1,%eax
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3f0(%rbp),%rax
mov    %ecx,-0x3f4(%rbp)
mov    0x37ff(%rip),%rcx
mov    (%rcx),%ecx
shl    $0x1,%ecx
mov    -0x64(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
cvtsi2sd %ecx,%xmm0
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
call   10f0 <cos@plt>
mov    -0x3f4(%rbp),%ecx
mov    %eax,%edx
mov    -0x3e0(%rbp),%rax
imul   %edx,%ecx
cvtsi2sd %ecx,%xmm0
mov    -0x68(%rbp),%ecx
mov    -0x64(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1734 <ocmlogit_warp_grad+0x544>
jmp    184c <ocmlogit_warp_grad+0x65c>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1721 <ocmlogit_warp_grad+0x531>
mov    -0x3d0(%rbp),%rax
mov    %rax,-0x260(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jge    18ac <ocmlogit_warp_grad+0x6bc>
mov    -0x3d0(%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    186f <ocmlogit_warp_grad+0x67f>
jmp    18b1 <ocmlogit_warp_grad+0x6c1>
mov    -0x3d0(%rbp),%rax
mov    -0x3e8(%rbp),%rcx
mov    %rcx,-0x250(%rbp)
mov    -0x28(%rbp),%rcx
mov    %rcx,-0x268(%rbp)
mov    %rax,-0x260(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    193f <ocmlogit_warp_grad+0x74f>
mov    -0x10(%rbp),%rdi
mov    -0x260(%rbp),%rsi
mov    -0x268(%rbp),%rdx
call   1080 <innerprod_q2@plt>
mov    -0x3e8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x268(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x268(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    18df <ocmlogit_warp_grad+0x6ef>
movsd  -0xc0(%rbp),%xmm0
ff
call   1060 <acos@plt>
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
call   1090 <sin@plt>
imul   $0xffffffff,%eax,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
call   10f0 <cos@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
call   10f0 <cos@plt>
imul   $0xffffffff,%eax,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
call   1090 <sin@plt>
mov    -0x3c8(%rbp),%rdx
mov    -0x3d0(%rbp),%rcx
mov    %eax,%esi
mov    -0x3c0(%rbp),%rax
imul   $0xffffffff,%esi,%esi
cvtsi2sd %esi,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    %rdx,-0x270(%rbp)
lea    -0x140(%rbp),%rdx
mov    %rdx,-0x2c0(%rbp)
mov    %rcx,-0x260(%rbp)
mov    %rax,-0x280(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x34(%rbp),%edx
mov    -0x2c0(%rbp),%rcx
mov    -0x260(%rbp),%r8
mov    -0x280(%rbp),%r9
call   10c0 <product@plt>
mov    -0x28(%rbp),%rax
mov    %rax,-0x268(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1a99 <ocmlogit_warp_grad+0x8a9>
mov    -0x10(%rbp),%rdi
mov    -0x280(%rbp),%rsi
mov    -0x268(%rbp),%rdx
call   1080 <innerprod_q2@plt>
mov    -0x3c8(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x268(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x268(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1a39 <ocmlogit_warp_grad+0x849>
mov    -0x3e8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    %rax,-0x250(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x288(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1b13 <ocmlogit_warp_grad+0x923>
mov    -0x288(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x250(%rbp),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
call   10d0 <exp@plt>
addsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1ac4 <ocmlogit_warp_grad+0x8d4>
mov    -0x3c8(%rbp),%rax
mov    -0x3b8(%rbp),%rcx
mov    %rcx,-0x290(%rbp)
mov    %rax,-0x270(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1b95 <ocmlogit_warp_grad+0x9a5>
mov    -0x288(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x250(%rbp),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
call   10d0 <exp@plt>
mov    -0x270(%rbp),%rax
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x290(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1b36 <ocmlogit_warp_grad+0x946>
mov    -0x3b8(%rbp),%rax
mov    %rax,-0x290(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1bef <ocmlogit_warp_grad+0x9ff>
mov    -0x290(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x190(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1bb5 <ocmlogit_warp_grad+0x9c5>
mov    -0x3c8(%rbp),%rax
movsd  -0x190(%rbp),%xmm0
ff
divsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    %rax,-0x270(%rbp)
mov    0x10(%rbp),%rax
mov    %rax,-0x340(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1c84 <ocmlogit_warp_grad+0xa94>
mov    -0x340(%rbp),%rax
movslq -0x64(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x270(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x198(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1c32 <ocmlogit_warp_grad+0xa42>
movsd  -0x198(%rbp),%xmm0
ff
subsd  -0x190(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x230(%rbp),%xmm1
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x1a8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
movsd  -0x238(%rbp),%xmm0
ff
call   10f0 <cos@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x238(%rbp),%xmm0
ff
call   1090 <sin@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x238(%rbp),%xmm0
ff
call   1090 <sin@plt>
imul   $0xffffffff,%eax,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x238(%rbp),%xmm0
ff
call   10f0 <cos@plt>
mov    -0x3b0(%rbp),%rcx
mov    %eax,%edx
mov    -0x3d0(%rbp),%rax
cvtsi2sd %edx,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    %rcx,-0x2c8(%rbp)
mov    %rax,-0x260(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x34(%rbp),%esi
mov    -0x260(%rbp),%rdx
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x2c8(%rbp),%rcx
call   10a0 <col_gradient@plt>
mov    -0x3a0(%rbp),%rsi
mov    -0x398(%rbp),%rdx
mov    -0x3c0(%rbp),%rcx
mov    -0x3a8(%rbp),%rax
mov    %rsi,-0x2d8(%rbp)
mov    %rdx,-0x2e0(%rbp)
mov    %rcx,-0x280(%rbp)
mov    %rax,-0x2d0(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x268(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    2096 <ocmlogit_warp_grad+0xea6>
mov    -0x390(%rbp),%rax
mov    %rax,-0x2e8(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1fad <ocmlogit_warp_grad+0xdbd>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1e2d <ocmlogit_warp_grad+0xc3d>
mov    -0x398(%rbp),%rax
mov    -0x3e0(%rbp),%rcx
mov    -0x6c(%rbp),%edx
mov    -0x64(%rbp),%esi
imul   -0x34(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x6c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1de8 <ocmlogit_warp_grad+0xbf8>
mov    -0x10(%rbp),%rdi
mov    -0x240(%rbp),%rsi
mov    -0x2e0(%rbp),%rdx
mov    -0x2d8(%rbp),%rcx
call   1070 <cumtrapz@plt>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1f1c <ocmlogit_warp_grad+0xd2c>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1f09 <ocmlogit_warp_grad+0xd19>
mov    -0x3c0(%rbp),%rax
mov    -0x3e0(%rbp),%rcx
mov    -0x3d0(%rbp),%rdx
mov    -0x3a0(%rbp),%rsi
mov    -0x3b0(%rbp),%rdi
mov    -0x3c(%rbp),%r8d
imul   -0x6c(%rbp),%r8d
add    -0x74(%rbp),%r8d
movslq %r8d,%r8
movsd  0x115c(%rip),%xmm0
mulsd  (%rdi,%r8,8),%xmm0
movslq -0x6c(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm2
mov    -0x3c(%rbp),%esi
imul   -0x6c(%rbp),%esi
add    -0x74(%rbp),%esi
movslq %esi,%rsi
movsd  (%rdx,%rsi,8),%xmm1
mov    -0x6c(%rbp),%edx
mov    -0x64(%rbp),%esi
imul   -0x34(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
mulsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x3c(%rbp),%ecx
imul   -0x6c(%rbp),%ecx
add    -0x74(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1e65 <ocmlogit_warp_grad+0xc75>
jmp    1f0e <ocmlogit_warp_grad+0xd1e>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1e52 <ocmlogit_warp_grad+0xc62>
mov    -0x10(%rbp),%rdi
mov    -0x280(%rbp),%rsi
mov    -0x268(%rbp),%rdx
call   1080 <innerprod_q2@plt>
movsd  %xmm0,-0x178(%rbp)
ff
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1f9a <ocmlogit_warp_grad+0xdaa>
mov    -0x390(%rbp),%rax
mov    -0x3e0(%rbp),%rcx
movsd  -0x178(%rbp),%xmm0
ff
mov    -0x6c(%rbp),%edx
mov    -0x64(%rbp),%esi
imul   -0x34(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
mulsd  (%rcx,%rdx,8),%xmm0
mov    -0x6c(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1f42 <ocmlogit_warp_grad+0xd52>
jmp    1f9f <ocmlogit_warp_grad+0xdaf>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1dd5 <ocmlogit_warp_grad+0xbe5>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2069 <ocmlogit_warp_grad+0xe79>
mov    -0x3a8(%rbp),%rax
mov    -0x390(%rbp),%rcx
movslq -0x74(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x74(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    2056 <ocmlogit_warp_grad+0xe66>
mov    -0x3a8(%rbp),%rax
mov    -0x390(%rbp),%rcx
mov    -0x74(%rbp),%edx
mov    -0x34(%rbp),%esi
imul   -0x68(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
movsd  (%rax,%rdx,8),%xmm0
mov    -0x74(%rbp),%edx
mov    -0x6c(%rbp),%esi
imul   -0x34(%rbp),%esi
add    %esi,%edx
movslq %edx,%rdx
addsd  (%rcx,%rdx,8),%xmm0
mov    -0x74(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1ff2 <ocmlogit_warp_grad+0xe02>
jmp    205b <ocmlogit_warp_grad+0xe6b>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1fb4 <ocmlogit_warp_grad+0xdc4>
mov    -0x3c(%rbp),%ecx
imul   -0x34(%rbp),%ecx
mov    -0x268(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x268(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1db4 <ocmlogit_warp_grad+0xbc4>
mov    -0x3e8(%rbp),%rax
mov    -0x3a8(%rbp),%rcx
mov    -0x388(%rbp),%rdx
mov    %rdx,-0x2f0(%rbp)
mov    %rcx,-0x2d0(%rbp)
mov    %rax,-0x250(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    217d <ocmlogit_warp_grad+0xf8d>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2139 <ocmlogit_warp_grad+0xf49>
mov    -0x288(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x250(%rbp),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
call   10d0 <exp@plt>
mov    -0x2d0(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x2f0(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    20da <ocmlogit_warp_grad+0xeea>
mov    -0x34(%rbp),%ecx
mov    -0x2d0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x2d0(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x2f0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x2f0(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    20c7 <ocmlogit_warp_grad+0xed7>
mov    -0x380(%rbp),%rax
mov    -0x388(%rbp),%rcx
mov    %rcx,-0x2f0(%rbp)
mov    %rax,-0x2f8(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    225e <ocmlogit_warp_grad+0x106e>
mov    -0x2f0(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x2f8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    2228 <ocmlogit_warp_grad+0x1038>
mov    -0x2f8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x2f0(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x68(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x2f8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    21d3 <ocmlogit_warp_grad+0xfe3>
mov    -0x2f8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x180(%rbp),%xmm0
ff
mov    -0x2f8(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    21a0 <ocmlogit_warp_grad+0xfb0>
mov    -0x3a8(%rbp),%rax
mov    -0x378(%rbp),%rcx
mov    %rcx,-0x300(%rbp)
mov    %rax,-0x2d0(%rbp)
mov    0x10(%rbp),%rax
mov    %rax,-0x340(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    232d <ocmlogit_warp_grad+0x113d>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    22e9 <ocmlogit_warp_grad+0x10f9>
mov    -0x340(%rbp),%rax
movslq -0x68(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x2d0(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x300(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    229f <ocmlogit_warp_grad+0x10af>
mov    -0x34(%rbp),%ecx
mov    -0x2d0(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x2d0(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x300(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x300(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    228c <ocmlogit_warp_grad+0x109c>
mov    -0x380(%rbp),%rax
mov    -0x378(%rbp),%rcx
mov    -0x370(%rbp),%rdx
mov    %rdx,-0x308(%rbp)
mov    %rcx,-0x300(%rbp)
mov    %rax,-0x2f8(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2419 <ocmlogit_warp_grad+0x1229>
mov    -0x300(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x308(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    23db <ocmlogit_warp_grad+0x11eb>
mov    -0x300(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x68(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x308(%rbp),%rax
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    2391 <ocmlogit_warp_grad+0x11a1>
mov    -0x308(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x2f8(%rbp),%rax
movslq -0x64(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x308(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    235e <ocmlogit_warp_grad+0x116e>
mov    -0x370(%rbp),%rax
mov    -0x350(%rbp),%rcx
mov    -0x358(%rbp),%rdx
mov    -0x368(%rbp),%rsi
mov    -0x360(%rbp),%rdi
mov    %rdi,-0x310(%rbp)
mov    %rsi,-0x328(%rbp)
mov    %rdx,-0x320(%rbp)
mov    %rcx,-0x330(%rbp)
mov    %rax,-0x308(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x308(%rbp),%rsi
lea    -0x88(%rbp),%rdx
lea    -0x178(%rbp),%rcx
call   10b0 <pvecnorm@plt>
movsd  -0x58(%rbp),%xmm0
mulsd  -0x178(%rbp),%xmm0
ff
call   10f0 <cos@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mulsd  -0x178(%rbp),%xmm0
ff
call   1090 <sin@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    252e <ocmlogit_warp_grad+0x133e>
movsd  -0x220(%rbp),%xmm0
ff
mov    -0x328(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x228(%rbp),%xmm1
ff
mov    -0x308(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
divsd  -0x178(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x310(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    24c0 <ocmlogit_warp_grad+0x12d0>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    257f <ocmlogit_warp_grad+0x138f>
mov    -0x378(%rbp),%rax
mov    -0x310(%rbp),%rcx
movslq -0x68(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x310(%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    2535 <ocmlogit_warp_grad+0x1345>
mov    -0x378(%rbp),%rax
mov    %rax,-0x300(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x240(%rbp),%rsi
mov    -0x300(%rbp),%rdx
mov    -0x330(%rbp),%rcx
call   1070 <cumtrapz@plt>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    261b <ocmlogit_warp_grad+0x142b>
mov    -0x330(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x330(%rbp),%rax
subsd  (%rax),%xmm0
mov    -0x330(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x330(%rbp),%rax
subsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x330(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    25b2 <ocmlogit_warp_grad+0x13c2>
mov    -0x3f0(%rbp),%rdi
mov    -0x318(%rbp),%rsi
mov    -0x34(%rbp),%edx
mov    -0x330(%rbp),%rcx
mov    -0x320(%rbp),%r8
mov    -0x34(%rbp),%r9d
xor    %eax,%eax
sub    $0x20,%rsp
movl   $0x1,(%rsp)
movl   $0x0,0x8(%rsp)
movl   $0x1,0x10(%rsp)
movl   $0x0,0x18(%rsp)
call   1030 <approx@plt>
add    $0x20,%rsp
mov    -0x3e8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x20(%rbp),%rcx
mov    %rcx,-0x288(%rbp)
mov    %rax,-0x250(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    26f6 <ocmlogit_warp_grad+0x1506>
mov    0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    -0x288(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x250(%rbp),%rax
movslq -0x68(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  -0x1a0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    2697 <ocmlogit_warp_grad+0x14a7>
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x400(%rbp)
ff
movsd  -0x180(%rbp),%xmm0
ff
call   1100 <log@plt>
mov    -0x3d8(%rbp),%rax
movaps %xmm0,%xmm1
movsd  -0x400(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movslq -0x80(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
movsd  0x8c1(%rip),%xmm1
ucomisd %xmm1,%xmm0
jne    2771 <ocmlogit_warp_grad+0x1581>
jp     2771 <ocmlogit_warp_grad+0x1581>
mov    -0x3d8(%rbp),%rax
mov    -0x80(%rbp),%esi
add    $0x1,%esi
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x8a4(%rip),%rdi
call   1050 <printf@plt>
mov    -0x3c0(%rbp),%rax
mov    -0x3d0(%rbp),%rcx
mov    -0x358(%rbp),%rdx
mov    %rdx,-0x318(%rbp)
lea    -0xe0(%rbp),%rdx
mov    %rdx,-0x2a0(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    %rcx,-0x260(%rbp)
mov    %rax,-0x280(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x338(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x34(%rbp),%edx
mov    -0x2a0(%rbp),%rcx
mov    -0x338(%rbp),%r8
mov    -0x280(%rbp),%r9
call   10c0 <product@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x280(%rbp),%rdx
mov    -0x318(%rbp),%rcx
mov    -0x260(%rbp),%r8
call   1040 <group_action_by_gamma@plt>
cmpl   $0x2,-0x80(%rbp)
jl     28a1 <ocmlogit_warp_grad+0x16b1>
mov    -0x3d8(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x1a8(%rbp),%xmm1
ff
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    289c <ocmlogit_warp_grad+0x16ac>
movsd  -0x178(%rbp),%xmm1
ff
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    289c <ocmlogit_warp_grad+0x16ac>
jmp    28b6 <ocmlogit_warp_grad+0x16c6>
jmp    28a1 <ocmlogit_warp_grad+0x16b1>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x80(%rbp),%eax
jge    18b1 <ocmlogit_warp_grad+0x6c1>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    28f4 <ocmlogit_warp_grad+0x1704>
mov    -0x318(%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    28bd <ocmlogit_warp_grad+0x16cd>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    -0x3c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jge    2938 <ocmlogit_warp_grad+0x1748>
mov    -0x2a0(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    28fb <ocmlogit_warp_grad+0x170b>
mov    -0x90(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ocmlogit_warp_grad>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x268,%rsp
mov    %r9,-0x158(%rbp)
mov    %r8,-0xf8(%rbp)
mov    %rcx,-0xb0(%rbp)
mov    %rsp,-0x1c0(%rbp)
mov    0x38(%rbp),%r8
mov    0x30(%rbp),%r9
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rcx
mov    0x18(%rbp),%r10
movsd  (%rcx),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
mov    %rsi,-0x70(%rbp)
movslq (%rsi),%r13
mov    (%rdx),%r11d
movsd  (%rax),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    %rdi,-0x220(%rbp)
movslq (%rdi),%r14
mov    (%r10),%eax
mov    %eax,-0x144(%rbp)
movsd  (%r9),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    (%r8),%eax
mov    %eax,-0x148(%rbp)
movabs $0x3ff0000000000000,%rax
mov    %rax,-0x248(%rbp)
mov    %r13d,%r15d
mov    %rsp,%rdi
lea    0xf(,%r15,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rdi
mov    %rdi,%rsp
mov    %rsp,%rcx
lea    0xf(,%r11,8),%rdx
and    $0xfffffffffffffff0,%rdx
sub    %rdx,%rcx
mov    %rcx,-0x98(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x100(%rbp)
mov    %rcx,%rsp
lea    0x0(,%r13,4),%ecx
lea    (%rcx,%rcx,4),%ecx
shl    $0x3,%rcx
mov    %rsp,%rsi
sub    %rcx,%rsi
mov    %rsi,-0x80(%rbp)
mov    %rsi,%rsp
mov    %r14d,%esi
imul   %r13d,%esi
mov    %rsi,-0xa0(%rbp)
lea    0xf(,%rsi,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rbx
sub    %rsi,%rbx
mov    %rbx,-0x68(%rbp)
mov    %rbx,%rsp
mov    %rsp,%rbx
sub    %rdx,%rbx
mov    %rbx,-0xe0(%rbp)
mov    %rbx,%rsp
mov    %rsp,%rbx
sub    %rsi,%rbx
mov    %rbx,-0xc8(%rbp)
mov    %rbx,%rsp
mov    %rsp,%rbx
sub    %rdx,%rbx
mov    %rbx,-0x180(%rbp)
mov    %rbx,%rsp
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x1b8(%rbp)
mov    %rdx,%rsp
mov    %r11,-0x40(%rbp)
mov    %r11d,%edx
mov    %rdi,%rbx
imul   %r13d,%edx
lea    0xf(,%rdx,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rsi
sub    %rdx,%rsi
mov    %rsi,-0xf0(%rbp)
mov    %rsi,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    %rsp,%rsi
sub    %rax,%rsi
mov    %rsi,-0xe8(%rbp)
mov    %rsi,%rsp
mov    %rsp,%rsi
sub    %rcx,%rsi
mov    %rsi,-0xb8(%rbp)
mov    %rsi,%rsp
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x120(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x1b0(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x90(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x198(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x208(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x170(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x88(%rbp)
mov    %rcx,%rsp
xor    %edi,%edi
mov    $0x1,%esi
mov    %r13d,%edx
mov    %rbx,%rcx
call   10f0 <linspace@plt>
lea    -0x1(%r13),%eax
mov    %r14d,%ecx
mov    %rcx,-0xc0(%rbp)
cvtsi2sd %eax,%xmm1
movsd  0x1b9a(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
test   %r13,%r13
mov    %r13,-0x38(%rbp)
jle    15ed <ocmlogit_warp_grad+0x3ed>
movsd  %xmm1,-0x58(%rbp)
lea    0x0(,%r15,8),%rdx
mov    -0x100(%rbp),%rdi
mov    %rbx,%rsi
call   10a0 <memcpy@plt>
cmp    $0x4,%r15d
jae    14bb <ocmlogit_warp_grad+0x2bb>
xor    %eax,%eax
mov    -0x38(%rbp),%r13
mov    -0xd8(%rbp),%rdi
movabs $0x3ff0000000000000,%rcx
movsd  -0x58(%rbp),%xmm1
jmp    15e0 <ocmlogit_warp_grad+0x3e0>
mov    %r15d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x1c,%rsi
jae    14f2 <ocmlogit_warp_grad+0x2f2>
xor    %esi,%esi
mov    -0x38(%rbp),%r13
mov    -0xd8(%rbp),%rdi
movsd  -0x58(%rbp),%xmm1
jmp    1591 <ocmlogit_warp_grad+0x391>
movabs $0x7ffffffffffffff8,%rsi
ff ff 7f
and    %rsi,%rdx
xor    %esi,%esi
movaps 0x1b08(%rip),%xmm0
mov    -0x38(%rbp),%r13
mov    -0xd8(%rbp),%rdi
movsd  -0x58(%rbp),%xmm1
nopl   0x0(%rax,%rax,1)
movaps %xmm0,(%rdi,%rsi,8)
movaps %xmm0,0x10(%rdi,%rsi,8)
movaps %xmm0,0x20(%rdi,%rsi,8)
movaps %xmm0,0x30(%rdi,%rsi,8)
movaps %xmm0,0x40(%rdi,%rsi,8)
movaps %xmm0,0x50(%rdi,%rsi,8)
movaps %xmm0,0x60(%rdi,%rsi,8)
movaps %xmm0,0x70(%rdi,%rsi,8)
movaps %xmm0,0x80(%rdi,%rsi,8)
movaps %xmm0,0x90(%rdi,%rsi,8)
movaps %xmm0,0xa0(%rdi,%rsi,8)
movaps %xmm0,0xb0(%rdi,%rsi,8)
movaps %xmm0,0xc0(%rdi,%rsi,8)
movaps %xmm0,0xd0(%rdi,%rsi,8)
movaps %xmm0,0xe0(%rdi,%rsi,8)
movaps %xmm0,0xf0(%rdi,%rsi,8)
add    $0x20,%rsi
add    $0xfffffffffffffff8,%rdx
jne    1520 <ocmlogit_warp_grad+0x320>
test   %rcx,%rcx
je     15c2 <ocmlogit_warp_grad+0x3c2>
lea    (%rdi,%rsi,8),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movaps 0x1a65(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movaps %xmm0,-0x10(%rdx,%rsi,1)
movaps %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    15b0 <ocmlogit_warp_grad+0x3b0>
cmp    %r15,%rax
movabs $0x3ff0000000000000,%rcx
je     15ed <ocmlogit_warp_grad+0x3ed>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rcx,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    15e0 <ocmlogit_warp_grad+0x3e0>
mov    %rbx,-0x58(%rbp)
movsd  0x1a07(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    -0x80(%rbp),%rax
lea    (%rax,%r13,8),%rdx
mov    %r13,%rcx
shl    $0x4,%rcx
mov    %rcx,-0x168(%rbp)
mov    0x39c6(%rip),%rbx
xor    %esi,%esi
jmp    1656 <ocmlogit_warp_grad+0x456>
cs nopw 0x0(%rax,%rax,1)
mov    -0x168(%rbp),%rax
add    %rax,%rdx
mov    -0x60(%rbp),%rdi
add    %rax,%rdi
mov    -0x50(%rbp),%rsi
cmp    $0xa,%rsi
mov    -0x38(%rbp),%r13
mov    %rdi,%rax
je     172b <ocmlogit_warp_grad+0x52b>
mov    %rax,-0x60(%rbp)
add    $0x1,%rsi
mov    %rsi,-0x50(%rbp)
test   %r13d,%r13d
jle    1630 <ocmlogit_warp_grad+0x430>
mov    -0x50(%rbp),%rax
add    %eax,%eax
mov    %eax,-0x30(%rbp)
xor    %r13d,%r13d
mov    %rdx,-0xa8(%rbp)
nopw   0x0(%rax,%rax,1)
mov    (%rbx),%edi
call   1120 <sqrt@plt>
lea    0x1(%rax),%ecx
cmp    $0x3,%ecx
mov    $0x0,%ecx
cmovae %ecx,%eax
mov    %rax,-0x78(%rbp)
mov    (%rbx),%eax
imul   -0x30(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    -0x58(%rbp),%rax
mulsd  (%rax,%r13,8),%xmm0
call   1090 <sin@plt>
imul   -0x78(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    -0x60(%rbp),%rax
movsd  %xmm0,(%rax,%r13,8)
mov    (%rbx),%edi
call   1120 <sqrt@plt>
mov    %eax,%ecx
lea    0x1(%rcx),%eax
cmp    $0x3,%eax
mov    $0x0,%eax
cmovae %eax,%ecx
mov    %rcx,-0x78(%rbp)
mov    (%rbx),%eax
imul   -0x30(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    -0x58(%rbp),%rax
mulsd  (%rax,%r13,8),%xmm0
call   1100 <cos@plt>
mov    -0xa8(%rbp),%rdx
imul   -0x78(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rdx,%r13,8)
add    $0x1,%r13
cmp    %r13,%r15
jne    1680 <ocmlogit_warp_grad+0x480>
jmp    1630 <ocmlogit_warp_grad+0x430>
mov    -0xa0(%rbp),%rbx
test   %ebx,%ebx
jle    1752 <ocmlogit_warp_grad+0x552>
lea    0x0(,%rbx,8),%rdx
mov    -0x68(%rbp),%rdi
mov    -0x158(%rbp),%rsi
call   10a0 <memcpy@plt>
mov    -0x38(%rbp),%r13
movslq %ebx,%r8
mov    -0x40(%rbp),%rcx
lea    -0x1(%rcx),%rsi
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0xa0(%rbp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x140(%rbp)
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %r15d,%eax
and    $0xfffffffe,%eax
mov    %rax,-0x108(%rbp)
add    $0xfffffffffffffffe,%rax
mov    %rax,-0x1f0(%rbp)
mov    %rax,%rdx
shr    %rdx
add    $0x1,%rdx
mov    %ecx,%eax
and    $0x7,%eax
mov    %rax,-0x1d8(%rbp)
mov    %ecx,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x1d0(%rbp)
mov    %ecx,%eax
and    $0x3,%eax
mov    %rax,-0x150(%rbp)
mov    %ecx,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x1c8(%rbp)
movabs $0x7ffffffffffffff8,%rax
ff ff 7f
add    $0x6,%rax
mov    %rbx,%rdi
mov    %rbx,-0x138(%rbp)
and    %rbx,%rax
mov    %rax,-0x130(%rbp)
mov    %esi,%eax
and    $0x3,%eax
mov    %rax,-0x128(%rbp)
mov    %rdx,%rax
mov    %rdx,-0x1e8(%rbp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x1e0(%rbp)
mov    %ecx,%eax
and    $0xfffffffe,%eax
mov    %rax,-0x1f8(%rbp)
mov    %r13,%rax
shl    $0x5,%rax
mov    %rax,-0x190(%rbp)
mov    %rsi,-0x110(%rbp)
and    $0xfffffffffffffffc,%rsi
neg    %rsi
mov    %rsi,-0x118(%rbp)
lea    0x0(,%r15,8),%rax
mov    %rax,-0x78(%rbp)
lea    0x0(,%r13,8),%rdx
lea    -0x2(%rcx),%rax
mov    %rax,-0x1a0(%rbp)
mov    %r8,-0x230(%rbp)
lea    0x0(,%r8,8),%rcx
mov    -0xb8(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x240(%rbp)
mov    -0x80(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x238(%rbp)
mov    %rdx,-0x50(%rbp)
lea    (%rdx,%rdx,2),%rax
mov    %rax,-0x188(%rbp)
xor    %eax,%eax
mov    %rcx,-0x1a8(%rbp)
nopl   0x0(%rax,%rax,1)
mov    %rax,-0x160(%rbp)
cmpl   $0x0,-0x40(%rbp)
jle    1900 <ocmlogit_warp_grad+0x700>
mov    -0xf8(%rbp),%r13
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    -0x70(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    %r13,%rdx
call   1080 <innerprod_q2@plt>
mov    -0x1a8(%rbp),%rcx
mov    -0x98(%rbp),%rax
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
add    %rcx,%r13
cmp    %rbx,-0x40(%rbp)
jne    18d0 <ocmlogit_warp_grad+0x6d0>
movsd  -0x48(%rbp),%xmm0
call   1060 <acos@plt>
movsd  %xmm0,-0x30(%rbp)
call   1090 <sin@plt>
neg    %eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1100 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1100 <cos@plt>
neg    %eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1090 <sin@plt>
neg    %eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
mov    -0xc0(%rbp),%rdi
mov    %edi,%esi
mov    -0x38(%rbp),%rdx
lea    -0x290(%rbp),%rcx
mov    -0x68(%rbp),%rbx
mov    %rbx,%r8
mov    -0xc8(%rbp),%r9
call   10d0 <product@plt>
xorpd  %xmm1,%xmm1
mov    -0x40(%rbp),%r13
test   %r13d,%r13d
jle    1b00 <ocmlogit_warp_grad+0x900>
mov    -0xf8(%rbp),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x70(%rbp),%rdi
mov    -0xc8(%rbp),%rsi
mov    %rax,%r13
mov    %rax,%rdx
call   1080 <innerprod_q2@plt>
mov    %r13,%rax
mov    -0xe0(%rbp),%rcx
movsd  %xmm0,(%rcx,%rbx,8)
add    $0x1,%rbx
add    -0x1a8(%rbp),%rax
cmp    %rbx,-0x40(%rbp)
jne    19c0 <ocmlogit_warp_grad+0x7c0>
xorpd  %xmm1,%xmm1
mov    -0x40(%rbp),%r13
test   %r13d,%r13d
mov    -0x68(%rbp),%rbx
jle    1b00 <ocmlogit_warp_grad+0x900>
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
mov    -0xb0(%rbp),%r13
nopl   0x0(%rax,%rax,1)
movsd  %xmm1,-0x48(%rbp)
movsd  0x0(%r13,%rbx,8),%xmm0
mov    -0x98(%rbp),%rax
addsd  (%rax,%rbx,8),%xmm0
call   10e0 <exp@plt>
movsd  -0x48(%rbp),%xmm1
addsd  %xmm0,%xmm1
add    $0x1,%rbx
cmp    %rbx,-0x40(%rbp)
jne    1a20 <ocmlogit_warp_grad+0x820>
mov    -0x40(%rbp),%r13
test   %r13d,%r13d
jle    1aed <ocmlogit_warp_grad+0x8ed>
movsd  %xmm1,-0x48(%rbp)
xor    %ebx,%ebx
mov    -0xb0(%rbp),%r13
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbx,8),%xmm0
mov    -0x98(%rbp),%rax
addsd  (%rax,%rbx,8),%xmm0
call   10e0 <exp@plt>
mov    -0xe0(%rbp),%rax
mulsd  (%rax,%rbx,8),%xmm0
mov    -0x180(%rbp),%rax
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,-0x40(%rbp)
jne    1a70 <ocmlogit_warp_grad+0x870>
mov    -0x40(%rbp),%r13
test   %r13d,%r13d
mov    -0x68(%rbp),%rbx
jle    1af3 <ocmlogit_warp_grad+0x8f3>
mov    -0x110(%rbp),%rsi
cmp    $0x7,%rsi
mov    -0x180(%rbp),%rcx
mov    -0x1d8(%rbp),%rdi
mov    -0x1d0(%rbp),%rdx
movsd  -0x48(%rbp),%xmm1
xorpd  %xmm0,%xmm0
jae    29f2 <ocmlogit_warp_grad+0x17f2>
xor    %eax,%eax
jmp    2a38 <ocmlogit_warp_grad+0x1838>
mov    -0x68(%rbp),%rbx
jmp    1b00 <ocmlogit_warp_grad+0x900>
movsd  -0x48(%rbp),%xmm1
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
movsd  %xmm1,-0x48(%rbp)
divsd  %xmm1,%xmm0
xorpd  %xmm3,%xmm3
movsd  -0x30(%rbp),%xmm1
subsd  %xmm0,%xmm3
movsd  -0x210(%rbp),%xmm0
ff
movsd  %xmm3,-0x228(%rbp)
ff
mulsd  %xmm3,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
call   1100 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1090 <sin@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x268(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1090 <sin@plt>
neg    %eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
call   1100 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
mov    %r14d,%edi
mov    %r15d,%esi
mov    %rbx,%rdx
movsd  -0x200(%rbp),%xmm0
ff
mov    -0x1b8(%rbp),%rcx
call   10b0 <col_gradient@plt>
test   %r13d,%r13d
mov    -0x38(%rbp),%r8
jle    2140 <ocmlogit_warp_grad+0xf40>
mov    -0xf0(%rbp),%rax
mov    %rax,-0x60(%rbp)
xor    %ecx,%ecx
mov    -0xf8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x70(%rbp),%rbx
mov    -0xe8(%rbp),%rdx
jmp    1c27 <ocmlogit_warp_grad+0xa27>
nopw   0x0(%rax,%rax,1)
mov    -0x230(%rbp),%rax
mov    -0x30(%rbp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,-0x30(%rbp)
mov    -0xa8(%rbp),%rcx
add    $0x1,%rcx
mov    -0x60(%rbp),%rax
add    -0x50(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%r13
cmp    %r13,%rcx
je     2080 <ocmlogit_warp_grad+0xe80>
mov    %rcx,-0xa8(%rbp)
xor    %r13d,%r13d
jmp    1c51 <ocmlogit_warp_grad+0xa51>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r13
cmp    $0x14,%r13
mov    -0xe8(%rbp),%rdx
je     1bf0 <ocmlogit_warp_grad+0x9f0>
test   %r15d,%r15d
jle    1c7a <ocmlogit_warp_grad+0xa7a>
mov    %r13d,%eax
imul   -0x38(%rbp),%eax
cltq
mov    -0x80(%rbp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    %rdx,%rdi
mov    -0x78(%rbp),%rdx
call   10a0 <memcpy@plt>
mov    -0xe8(%rbp),%rdx
mov    %rbx,%rdi
mov    -0x58(%rbp),%rsi
mov    %r12,%rcx
call   1070 <cumtrapz@plt>
test   %r14d,%r14d
mov    -0x38(%rbp),%r9
mov    -0xc8(%rbp),%rsi
mov    -0xc0(%rbp),%r11
jle    1d30 <ocmlogit_warp_grad+0xb30>
mov    %r13,%rax
imul   %r9,%rax
mov    -0x80(%rbp),%rcx
lea    (%rcx,%rax,8),%r10
mov    %rsi,%rcx
mov    -0x68(%rbp),%rdx
mov    -0x1b8(%rbp),%rax
xor    %r8d,%r8d
jmp    1ce5 <ocmlogit_warp_grad+0xae5>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r8
add    $0x8,%rax
add    $0x8,%rdx
add    $0x8,%rcx
cmp    %r11,%r8
je     1d30 <ocmlogit_warp_grad+0xb30>
test   %r9d,%r9d
jle    1cd0 <ocmlogit_warp_grad+0xad0>
xor    %ebx,%ebx
xor    %edi,%edi
xchg   %ax,%ax
movsd  (%rax,%rbx,8),%xmm0
movsd  (%rdx,%rbx,8),%xmm1
mulsd  (%r10,%rdi,8),%xmm1
addsd  %xmm0,%xmm0
mulsd  (%r12,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
add    $0x1,%rdi
add    %r14,%rbx
cmp    %rdi,%r15
jne    1cf0 <ocmlogit_warp_grad+0xaf0>
jmp    1cd0 <ocmlogit_warp_grad+0xad0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x70(%rbp),%rbx
mov    %rbx,%rdi
mov    -0x30(%rbp),%rdx
call   1080 <innerprod_q2@plt>
mov    -0x38(%rbp),%r8
movsd  %xmm0,-0xd0(%rbp)
ff
test   %r8d,%r8d
jle    1c40 <ocmlogit_warp_grad+0xa40>
mov    %r13,%rax
imul   %r8,%rax
cmp    $0x4,%r8d
jae    1d70 <ocmlogit_warp_grad+0xb70>
xor    %ecx,%ecx
jmp    1e3c <ocmlogit_warp_grad+0xc3c>
nopl   0x0(%rax)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,-0x140(%rbp)
je     1e7e <ocmlogit_warp_grad+0xc7e>
mov    -0x240(%rbp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    -0x238(%rbp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    -0x130(%rbp),%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x30(%rsi,%rcx,8),%xmm2
movupd -0x20(%rsi,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rdx,%rcx,8)
movupd %xmm3,-0x20(%rdx,%rcx,8)
movupd -0x10(%rsi,%rcx,8),%xmm2
movupd (%rsi,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rdx,%rcx,8)
movupd %xmm3,(%rdx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1db0 <ocmlogit_warp_grad+0xbb0>
testb  $0x1,-0x138(%rbp)
je     1e2d <ocmlogit_warp_grad+0xc2d>
add    %rax,%rcx
mov    -0x80(%rbp),%rdx
movupd (%rdx,%rcx,8),%xmm2
movupd 0x10(%rdx,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
mov    -0xb8(%rbp),%rdx
movupd %xmm2,(%rdx,%rcx,8)
movupd %xmm3,0x10(%rdx,%rcx,8)
mov    -0xa0(%rbp),%rdx
mov    %rdx,%rcx
cmp    %r15,%rdx
je     1e67 <ocmlogit_warp_grad+0xc67>
mov    -0x80(%rbp),%rdx
lea    (%rdx,%rax,8),%rdx
mov    -0xb8(%rbp),%rsi
lea    (%rsi,%rax,8),%rax
nop
movsd  (%rdx,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1e50 <ocmlogit_warp_grad+0xc50>
add    $0x1,%r13
cmp    $0x14,%r13
mov    -0xe8(%rbp),%rdx
jne    1c51 <ocmlogit_warp_grad+0xa51>
jmp    1e90 <ocmlogit_warp_grad+0xc90>
xor    %ecx,%ecx
testb  $0x1,-0x138(%rbp)
jne    1e01 <ocmlogit_warp_grad+0xc01>
jmp    1e2d <ocmlogit_warp_grad+0xc2d>
nop
test   %r15d,%r15d
jle    1bf0 <ocmlogit_warp_grad+0x9f0>
xor    %eax,%eax
cmp    $0x1,%r8d
je     1fb0 <ocmlogit_warp_grad+0xdb0>
mov    -0xb8(%rbp),%rsi
mov    -0x108(%rbp),%r9
mov    -0x50(%rbp),%rdi
mov    -0x60(%rbp),%r10
nopl   0x0(%rax,%rax,1)
lea    (%rsi,%rax,8),%rcx
movupd (%rdi,%rcx,1),%xmm0
add    %rdi,%rcx
addpd  (%rsi,%rax,8),%xmm0
addpd  (%rdi,%rcx,1),%xmm0
add    %rdi,%rcx
movupd (%rdi,%rcx,1),%xmm1
add    %rdi,%rcx
addpd  %xmm0,%xmm1
addpd  (%rdi,%rcx,1),%xmm1
add    %rdi,%rcx
movupd (%rdi,%rcx,1),%xmm0
add    %rdi,%rcx
addpd  %xmm1,%xmm0
addpd  (%rdi,%rcx,1),%xmm0
add    %rdi,%rcx
movupd (%rdi,%rcx,1),%xmm1
add    %rdi,%rcx
addpd  %xmm0,%xmm1
addpd  (%rdi,%rcx,1),%xmm1
add    %rdi,%rcx
movupd (%rdi,%rcx,1),%xmm0
add    %rdi,%rcx
addpd  %xmm1,%xmm0
addpd  (%rdi,%rcx,1),%xmm0
add    %rdi,%rcx
movupd (%rdi,%rcx,1),%xmm1
add    %rdi,%rcx
addpd  %xmm0,%xmm1
addpd  (%rdi,%rcx,1),%xmm1
add    %rdi,%rcx
movupd (%rdi,%rcx,1),%xmm0
add    %rdi,%rcx
addpd  %xmm1,%xmm0
addpd  (%rdi,%rcx,1),%xmm0
add    %rdi,%rcx
movupd (%rdi,%rcx,1),%xmm1
add    %rdi,%rcx
addpd  %xmm0,%xmm1
addpd  (%rdi,%rcx,1),%xmm1
add    %rdi,%rcx
movupd (%rdi,%rcx,1),%xmm0
add    %rdi,%rcx
addpd  %xmm1,%xmm0
addpd  (%rdi,%rcx,1),%xmm0
add    %rdi,%rcx
movupd (%rdi,%rcx,1),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%r10,%rax,8)
add    $0x2,%rax
cmp    %rax,%r9
jne    1ec0 <ocmlogit_warp_grad+0xcc0>
mov    %r9,%rax
cmp    %r15,%r9
je     1bf0 <ocmlogit_warp_grad+0x9f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0xb8(%rbp),%rsi
lea    (%rsi,%rax,8),%rcx
movsd  (%rsi,%rax,8),%xmm0
mov    -0x50(%rbp),%rsi
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
add    %rsi,%rcx
addsd  (%rsi,%rcx,1),%xmm0
mov    -0x60(%rbp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1fb0 <ocmlogit_warp_grad+0xdb0>
jmp    1bf0 <ocmlogit_warp_grad+0x9f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r13d,%r13d
jle    2140 <ocmlogit_warp_grad+0xf40>
mov    -0xf0(%rbp),%rcx
mov    -0x120(%rbp),%rdx
xor    %esi,%esi
jmp    20bf <ocmlogit_warp_grad+0xebf>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
mov    -0x50(%rbp),%rax
add    %rax,%rdx
add    %rax,%rcx
mov    -0x40(%rbp),%r13
cmp    %r13,%rsi
mov    -0x38(%rbp),%r8
je     2140 <ocmlogit_warp_grad+0xf40>
test   %r8d,%r8d
mov    -0xb0(%rbp),%rdi
jle    20a0 <ocmlogit_warp_grad+0xea0>
mov    -0x98(%rbp),%rax
movsd  (%rax,%rsi,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
xor    %ebx,%ebx
mov    %rcx,-0x30(%rbp)
mov    %rsi,-0x60(%rbp)
nopl   0x0(%rax)
movsd  (%rdi,%rsi,8),%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
mov    %rdx,%r13
call   10e0 <exp@plt>
mov    -0xb0(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    %r13,%rdx
mov    -0x30(%rbp),%rcx
mulsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    20f0 <ocmlogit_warp_grad+0xef0>
jmp    20a0 <ocmlogit_warp_grad+0xea0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r8d,%r8d
mov    -0x120(%rbp),%rdi
mov    0x10(%rbp),%r11
mov    -0x40(%rbp),%r13
mov    -0x168(%rbp),%r9
mov    -0x118(%rbp),%r10
mov    -0x50(%rbp),%rbx
movsd  -0x48(%rbp),%xmm1
jle    2280 <ocmlogit_warp_grad+0x1080>
mov    %rdi,%rax
xor    %ecx,%ecx
jmp    21a1 <ocmlogit_warp_grad+0xfa1>
cs nopw 0x0(%rax,%rax,1)
divsd  %xmm1,%xmm0
mov    -0x1b0(%rbp),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x1,%rcx
add    $0x8,%rax
cmp    %r15,%rcx
je     2280 <ocmlogit_warp_grad+0x1080>
movsd  (%rdi,%rcx,8),%xmm0
cmp    $0x2,%r13d
jl     2180 <ocmlogit_warp_grad+0xf80>
mov    $0x1,%edx
cmpq   $0x3,-0x1a0(%rbp)
03
jae    21d0 <ocmlogit_warp_grad+0xfd0>
mov    -0x118(%rbp),%r13
mov    -0x50(%rbp),%rbx
jmp    222c <ocmlogit_warp_grad+0x102c>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%edx
mov    %rax,%rsi
mov    -0x190(%rbp),%r10
mov    -0x118(%rbp),%r13
mov    -0x50(%rbp),%rbx
mov    -0x188(%rbp),%r11
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
addsd  (%rsi,%rbx,1),%xmm0
addsd  (%rsi,%r9,1),%xmm0
addsd  (%rsi,%r11,1),%xmm0
addsd  (%rsi,%r10,1),%xmm0
add    %r10,%rsi
lea    (%rdx,%r13,1),%rdi
add    $0x4,%rdi
add    $0x4,%rdx
cmp    $0x1,%rdi
jne    2200 <ocmlogit_warp_grad+0x1000>
cmpq   $0x0,-0x128(%rbp)
mov    %r13,%r10
mov    -0x40(%rbp),%r13
mov    0x10(%rbp),%r11
mov    -0x120(%rbp),%rdi
je     2180 <ocmlogit_warp_grad+0xf80>
imul   %r8,%rdx
add    %rcx,%rdx
lea    (%rdi,%rdx,8),%rdx
mov    -0x128(%rbp),%rsi
xchg   %ax,%ax
addsd  (%rdx),%xmm0
add    %rbx,%rdx
add    $0xffffffffffffffff,%rsi
jne    2260 <ocmlogit_warp_grad+0x1060>
jmp    2180 <ocmlogit_warp_grad+0xf80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
test   %r13d,%r13d
jle    23b0 <ocmlogit_warp_grad+0x11b0>
mov    -0x90(%rbp),%rax
mov    -0xf0(%rbp),%rcx
xor    %edx,%edx
jmp    22b3 <ocmlogit_warp_grad+0x10b3>
nopl   0x0(%rax,%rax,1)
add    %rbx,%rcx
add    %rbx,%rax
add    $0x1,%rdx
cmp    %r13,%rdx
je     23b0 <ocmlogit_warp_grad+0x11b0>
test   %r15d,%r15d
jle    22a0 <ocmlogit_warp_grad+0x10a0>
xorps  %xmm0,%xmm0
cvtsi2sdl (%r11,%rdx,4),%xmm0
cmp    $0x4,%r15d
jae    22d0 <ocmlogit_warp_grad+0x10d0>
xor    %esi,%esi
jmp    2380 <ocmlogit_warp_grad+0x1180>
xchg   %ax,%ax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,-0x140(%rbp)
je     239c <ocmlogit_warp_grad+0x119c>
mov    -0x130(%rbp),%rdi
xor    %esi,%esi
nop
movupd (%rcx,%rsi,8),%xmm2
movupd 0x10(%rcx,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rax,%rsi,8)
movupd %xmm3,0x10(%rax,%rsi,8)
movupd 0x20(%rcx,%rsi,8),%xmm2
movupd 0x30(%rcx,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rax,%rsi,8)
movupd %xmm3,0x30(%rax,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    22f0 <ocmlogit_warp_grad+0x10f0>
testb  $0x1,-0x138(%rbp)
je     235f <ocmlogit_warp_grad+0x115f>
movupd (%rcx,%rsi,8),%xmm2
movupd 0x10(%rcx,%rsi,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rax,%rsi,8)
movupd %xmm3,0x10(%rax,%rsi,8)
mov    -0xa0(%rbp),%rdi
mov    %rdi,%rsi
cmp    %r15,%rdi
je     22a0 <ocmlogit_warp_grad+0x10a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%r15
jne    2380 <ocmlogit_warp_grad+0x1180>
jmp    22a0 <ocmlogit_warp_grad+0x10a0>
xor    %esi,%esi
testb  $0x1,-0x138(%rbp)
jne    2341 <ocmlogit_warp_grad+0x1141>
jmp    235f <ocmlogit_warp_grad+0x115f>
nopl   0x0(%rax)
test   %r8d,%r8d
mov    -0x198(%rbp),%rbx
jle    24c0 <ocmlogit_warp_grad+0x12c0>
mov    -0x90(%rbp),%rax
xor    %ecx,%ecx
jmp    23f2 <ocmlogit_warp_grad+0x11f2>
nopl   0x0(%rax,%rax,1)
mov    -0x1b0(%rbp),%rdx
subsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0x8,%rax
cmp    %r15,%rcx
je     24c0 <ocmlogit_warp_grad+0x12c0>
mov    -0x90(%rbp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
cmp    $0x2,%r13d
jl     23d0 <ocmlogit_warp_grad+0x11d0>
mov    $0x1,%edx
cmpq   $0x3,-0x1a0(%rbp)
03
jae    2420 <ocmlogit_warp_grad+0x1220>
mov    -0x50(%rbp),%r11
jmp    246c <ocmlogit_warp_grad+0x126c>
nopl   0x0(%rax)
mov    $0x1,%edx
mov    %rax,%rsi
mov    -0x190(%rbp),%rbx
mov    -0x50(%rbp),%r11
mov    -0x188(%rbp),%r13
nopw   0x0(%rax,%rax,1)
addsd  (%rsi,%r11,1),%xmm0
addsd  (%rsi,%r9,1),%xmm0
addsd  (%rsi,%r13,1),%xmm0
addsd  (%rsi,%rbx,1),%xmm0
add    %rbx,%rsi
lea    (%r10,%rdx,1),%rdi
add    $0x4,%rdi
add    $0x4,%rdx
cmp    $0x1,%rdi
jne    2440 <ocmlogit_warp_grad+0x1240>
testb  $0x3,-0x110(%rbp)
mov    -0x40(%rbp),%r13
mov    -0x198(%rbp),%rbx
je     23d0 <ocmlogit_warp_grad+0x11d0>
imul   %r8,%rdx
add    %rcx,%rdx
mov    -0x90(%rbp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    -0x128(%rbp),%rsi
nopl   (%rax)
addsd  (%rdx),%xmm0
add    %r11,%rdx
add    $0xffffffffffffffff,%rsi
jne    24a0 <ocmlogit_warp_grad+0x12a0>
jmp    23d0 <ocmlogit_warp_grad+0x11d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x70(%rbp),%rdi
mov    %rbx,%rsi
lea    -0x248(%rbp),%rdx
lea    -0xd0(%rbp),%rcx
call   10c0 <pvecnorm@plt>
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x178(%rbp),%xmm0
ff
call   1100 <cos@plt>
mov    %eax,-0x30(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  -0x178(%rbp),%xmm0
ff
call   1090 <sin@plt>
mov    -0x90(%rbp),%rdx
mov    -0x38(%rbp),%r8
test   %r8d,%r8d
mov    -0xd8(%rbp),%rdi
mov    -0x208(%rbp),%rsi
jle    2650 <ocmlogit_warp_grad+0x1450>
xorps  %xmm0,%xmm0
cvtsi2sdl -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  -0xd0(%rbp),%xmm2
ff
cmp    $0x1,%r8d
jne    2550 <ocmlogit_warp_grad+0x1350>
xor    %eax,%eax
jmp    2600 <ocmlogit_warp_grad+0x1400>
nopl   (%rax)
movapd %xmm2,%xmm4
unpcklpd %xmm2,%xmm4
movapd %xmm1,%xmm5
unpcklpd %xmm1,%xmm5
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
cmpq   $0x0,-0x1f0(%rbp)
je     29de <ocmlogit_warp_grad+0x17de>
mov    -0x1e0(%rbp),%rcx
xor    %eax,%eax
nop
movapd (%rbx,%rax,8),%xmm6
divpd  %xmm4,%xmm6
mulpd  %xmm5,%xmm6
movapd (%rdi,%rax,8),%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm6,%xmm7
movapd %xmm7,(%rsi,%rax,8)
movapd 0x10(%rbx,%rax,8),%xmm6
divpd  %xmm4,%xmm6
mulpd  %xmm5,%xmm6
movapd 0x10(%rdi,%rax,8),%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm6,%xmm7
movapd %xmm7,0x10(%rsi,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    2580 <ocmlogit_warp_grad+0x1380>
testb  $0x1,-0x1e8(%rbp)
je     25ef <ocmlogit_warp_grad+0x13ef>
movapd (%rbx,%rax,8),%xmm6
divpd  %xmm4,%xmm6
mulpd  %xmm5,%xmm6
mulpd  (%rdi,%rax,8),%xmm3
addpd  %xmm6,%xmm3
movapd %xmm3,(%rsi,%rax,8)
mov    -0x108(%rbp),%rcx
mov    %rcx,%rax
cmp    %r15,%rcx
je     2628 <ocmlogit_warp_grad+0x1428>
xchg   %ax,%ax
movsd  (%rbx,%rax,8),%xmm3
divsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm3
movsd  (%rdi,%rax,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rsi,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    2600 <ocmlogit_warp_grad+0x1400>
test   %r15d,%r15d
jle    2650 <ocmlogit_warp_grad+0x1450>
cmp    $0x4,%r8d
jae    2864 <ocmlogit_warp_grad+0x1664>
xor    %eax,%eax
mov    -0x88(%rbp),%rcx
jmp    2910 <ocmlogit_warp_grad+0x1710>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x70(%rbp),%rdi
mov    -0x58(%rbp),%rbx
mov    %rbx,%rsi
mov    -0x88(%rbp),%r13
mov    %r13,%rcx
call   1070 <cumtrapz@plt>
mov    %r13,%rcx
mov    -0x40(%rbp),%r13
mov    -0x38(%rbp),%rdx
mov    %rbx,%rdi
mov    -0x100(%rbp),%rsi
mov    -0x170(%rbp),%r8
mov    %r15d,%r9d
push   $0x0
push   $0x1
push   $0x0
push   $0x1
call   1030 <approx@plt>
add    $0x20,%rsp
test   %r13d,%r13d
jle    2730 <ocmlogit_warp_grad+0x1530>
cmpq   $0x0,-0x110(%rbp)
mov    -0x98(%rbp),%rcx
mov    -0xb0(%rbp),%rsi
je     2740 <ocmlogit_warp_grad+0x1540>
xorpd  %xmm3,%xmm3
xor    %eax,%eax
mov    -0x1f8(%rbp),%rdx
movsd  -0x48(%rbp),%xmm0
mov    0x10(%rbp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm1,%xmm1
cvtsi2sdl (%rdi,%rax,4),%xmm1
movsd  (%rsi,%rax,8),%xmm2
movsd  0x8(%rsi,%rax,8),%xmm4
addsd  (%rcx,%rax,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
xorps  %xmm1,%xmm1
cvtsi2sdl 0x4(%rdi,%rax,4),%xmm1
addsd  0x8(%rcx,%rax,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm2,%xmm4
add    $0x2,%rax
movapd %xmm4,%xmm3
cmp    %rax,%rdx
jne    26e0 <ocmlogit_warp_grad+0x14e0>
test   $0x1,%r13b
jne    2755 <ocmlogit_warp_grad+0x1555>
jmp    276f <ocmlogit_warp_grad+0x156f>
nopl   0x0(%rax)
xorpd  %xmm4,%xmm4
movsd  -0x48(%rbp),%xmm0
jmp    276f <ocmlogit_warp_grad+0x156f>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm4,%xmm4
xor    %eax,%eax
movsd  -0x48(%rbp),%xmm0
mov    0x10(%rbp),%rdi
test   $0x1,%r13b
je     276f <ocmlogit_warp_grad+0x156f>
xorps  %xmm2,%xmm2
cvtsi2sdl (%rdi,%rax,4),%xmm2
movsd  (%rsi,%rax,8),%xmm1
addsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm1,%xmm4
movsd  %xmm4,-0x30(%rbp)
call   1110 <log@plt>
cmpl   $0x1,-0x148(%rbp)
jne    27b0 <ocmlogit_warp_grad+0x15b0>
movsd  -0x30(%rbp),%xmm1
subsd  %xmm0,%xmm1
mov    -0x160(%rbp),%r13
lea    0x1(%r13),%esi
lea    0x883(%rip),%rdi
mov    %esi,-0x30(%rbp)
movapd %xmm1,%xmm0
call   1050 <printf@plt>
jmp    27be <ocmlogit_warp_grad+0x15be>
nopl   0x0(%rax,%rax,1)
mov    -0x160(%rbp),%r13
lea    0x1(%r13),%eax
mov    %eax,-0x30(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0xc8(%rbp),%rbx
mov    -0xc0(%rbp),%rdi
movsd  -0x270(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
mov    %r14d,%esi
lea    -0x270(%rbp),%rcx
mov    -0x158(%rbp),%r8
mov    %rbx,%r9
call   10d0 <product@plt>
mov    -0x220(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    %rbx,%rdx
mov    -0x170(%rbp),%rbx
mov    %rbx,%rcx
mov    -0x68(%rbp),%r8
call   1040 <group_action_by_gamma@plt>
cmp    $0x2,%r13d
setb   %al
movsd  -0x218(%rbp),%xmm0
ff
ucomisd -0x228(%rbp),%xmm0
ff
setbe  %cl
or     %al,%cl
ucomisd -0xd0(%rbp),%xmm0
ff
setbe  %al
or     %cl,%al
cmp    $0x1,%al
jne    2b4f <ocmlogit_warp_grad+0x194f>
mov    %rbx,-0x100(%rbp)
cmp    %r13d,-0x144(%rbp)
mov    -0x30(%rbp),%eax
jg     18b0 <ocmlogit_warp_grad+0x6b0>
jmp    2b4f <ocmlogit_warp_grad+0x194f>
cmpq   $0x0,-0x140(%rbp)
je     2a8a <ocmlogit_warp_grad+0x188a>
mov    -0x130(%rbp),%rdi
xor    %eax,%eax
mov    -0x88(%rbp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd (%rsi,%rax,8),%xmm0
movapd 0x10(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movapd %xmm0,(%rdx,%rax,8)
movapd %xmm1,0x10(%rdx,%rax,8)
movapd 0x20(%rsi,%rax,8),%xmm0
movapd 0x30(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movapd %xmm0,0x20(%rdx,%rax,8)
movapd %xmm1,0x30(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdi
jne    2890 <ocmlogit_warp_grad+0x1690>
testb  $0x1,-0x138(%rbp)
je     28ff <ocmlogit_warp_grad+0x16ff>
movapd (%rsi,%rax,8),%xmm0
movapd 0x10(%rsi,%rax,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movapd %xmm0,(%rdx,%rax,8)
movapd %xmm1,0x10(%rdx,%rax,8)
mov    -0xa0(%rbp),%rdi
mov    %rdi,%rax
cmp    %r15,%rdi
je     2927 <ocmlogit_warp_grad+0x1727>
xchg   %ax,%ax
movsd  (%rsi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    2910 <ocmlogit_warp_grad+0x1710>
mov    -0x70(%rbp),%rdi
mov    -0x58(%rbp),%rbx
mov    %rbx,%rsi
call   1070 <cumtrapz@plt>
mov    -0x88(%rbp),%rcx
mov    -0x38(%rbp),%rdx
test   %edx,%edx
jle    2675 <ocmlogit_warp_grad+0x1475>
xor    %eax,%eax
cmp    $0x1,%r15d
je     29ab <ocmlogit_warp_grad+0x17ab>
mov    -0x108(%rbp),%rsi
nopl   0x0(%rax)
movsd  (%rcx),%xmm0
movsd  (%rcx,%rax,8),%xmm1
movsd  0x8(%rcx,%rax,8),%xmm2
subsd  %xmm0,%xmm1
movsd  -0x8(%rcx,%rdx,8),%xmm3
subsd  %xmm0,%xmm3
divsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%rax,8)
movsd  (%rcx),%xmm0
subsd  %xmm0,%xmm2
movsd  -0x8(%rcx,%rdx,8),%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rsi
jne    2960 <ocmlogit_warp_grad+0x1760>
test   $0x1,%r15b
mov    -0x58(%rbp),%rbx
je     2675 <ocmlogit_warp_grad+0x1475>
movsd  (%rcx,%rax,8),%xmm0
movsd  (%rcx),%xmm1
subsd  %xmm1,%xmm0
movsd  -0x8(%rcx,%rdx,8),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%rax,8)
jmp    2675 <ocmlogit_warp_grad+0x1475>
xor    %eax,%eax
testb  $0x1,-0x1e8(%rbp)
jne    25d4 <ocmlogit_warp_grad+0x13d4>
jmp    25ef <ocmlogit_warp_grad+0x13ef>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addsd  (%rcx,%rax,8),%xmm0
addsd  0x8(%rcx,%rax,8),%xmm0
addsd  0x10(%rcx,%rax,8),%xmm0
addsd  0x18(%rcx,%rax,8),%xmm0
addsd  0x20(%rcx,%rax,8),%xmm0
addsd  0x28(%rcx,%rax,8),%xmm0
addsd  0x30(%rcx,%rax,8),%xmm0
addsd  0x38(%rcx,%rax,8),%xmm0
add    $0x8,%rax
cmp    %rax,%rdx
jne    2a00 <ocmlogit_warp_grad+0x1800>
test   %rdi,%rdi
mov    0x10(%rbp),%rdx
je     2a5e <ocmlogit_warp_grad+0x185e>
lea    (%rcx,%rax,8),%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
addsd  (%rax,%rcx,8),%xmm0
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    2a50 <ocmlogit_warp_grad+0x1850>
divsd  %xmm1,%xmm0
test   %r13d,%r13d
jle    1b0d <ocmlogit_warp_grad+0x90d>
xorpd  %xmm3,%xmm3
xor    %eax,%eax
cmp    $0x3,%rsi
jae    2aa5 <ocmlogit_warp_grad+0x18a5>
mov    -0xe0(%rbp),%rcx
mov    -0x150(%rbp),%rsi
jmp    2b13 <ocmlogit_warp_grad+0x1913>
xor    %eax,%eax
mov    -0x88(%rbp),%rcx
testb  $0x1,-0x138(%rbp)
jne    28e1 <ocmlogit_warp_grad+0x16e1>
jmp    28ff <ocmlogit_warp_grad+0x16ff>
mov    -0xe0(%rbp),%rcx
mov    -0x150(%rbp),%rsi
mov    -0x1c8(%rbp),%rdi
nopw   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sdl (%rdx,%rax,4),%xmm1
mulsd  (%rcx,%rax,8),%xmm1
xorps  %xmm2,%xmm2
cvtsi2sdl 0x4(%rdx,%rax,4),%xmm2
addsd  %xmm3,%xmm1
mulsd  0x8(%rcx,%rax,8),%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsi2sdl 0x8(%rdx,%rax,4),%xmm1
mulsd  0x10(%rcx,%rax,8),%xmm1
xorps  %xmm3,%xmm3
cvtsi2sdl 0xc(%rdx,%rax,4),%xmm3
mulsd  0x18(%rcx,%rax,8),%xmm3
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm3
add    $0x4,%rax
cmp    %rax,%rdi
jne    2ac0 <ocmlogit_warp_grad+0x18c0>
test   %rsi,%rsi
je     1b11 <ocmlogit_warp_grad+0x911>
lea    (%rcx,%rax,8),%rcx
lea    (%rdx,%rax,4),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%rdx,4),%xmm1
mulsd  (%rcx,%rdx,8),%xmm1
addsd  %xmm1,%xmm3
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    2b30 <ocmlogit_warp_grad+0x1930>
jmp    1b11 <ocmlogit_warp_grad+0x911>
cmpl   $0x0,-0x38(%rbp)
jle    2b65 <ocmlogit_warp_grad+0x1965>
mov    0x40(%rbp),%rdi
mov    %rbx,%rsi
mov    -0x78(%rbp),%rdx
call   10a0 <memcpy@plt>
mov    -0xc0(%rbp),%rax
imul   %r14d,%eax
test   %eax,%eax
je     2b8a <ocmlogit_warp_grad+0x198a>
mov    %eax,%edx
shl    $0x3,%rdx
lea    -0x270(%rbp),%rsi
mov    0x48(%rbp),%rdi
call   10a0 <memcpy@plt>
mov    -0x1c0(%rbp),%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@M_PI = global i32 0
@.str = [24 x i8] c"Iteration %d : Cost %f\0A\00"
define void @ocmlogit_warp_grad(i32* %0, i32* %1, i32* nocapture %2, double* nocapture %3, double* %4, double* %5, i32* nocapture %6, i32* nocapture %7, double* nocapture %8, double* nocapture %9, double* nocapture %10, i32* nocapture %11, double* nocapture writeonly %12, double* nocapture writeonly %13) {
%15 = bitcast double* %5 to i8*
%16 = bitcast double* %12 to i8*
%17 = bitcast double* %13 to i8*
%18 = alloca double
%19 = alloca [4 x double]
%20 = bitcast [4 x double]* %19 to i8*
%21 = alloca [4 x double]
%22 = alloca double
%23 = load i32, i32* %1
%24 = load i32, i32* %2
%25 = load i32, i32* %0
%26 = load i32, i32* %7
%27 = load double, double* %8
%28 = load double, double* %9
%29 = load double, double* %10
%30 = load i32, i32* %11
%31 = bitcast double* %18 to i8*
store double 1.000000e+00, double* %18
%32 = zext i32 %23 to i64
%33 = tail call i8* @llvm.stacksave()
%34 = alloca double, i64 %32
%35 = zext i32 %24 to i64
%36 = alloca double, i64 %35
%37 = bitcast [4 x double]* %21 to i8*
%38 = alloca double, i64 %32
%39 = mul nsw i32 %23, 20
%40 = zext i32 %39 to i64
%41 = alloca double, i64 %40
%42 = mul i32 %25, %23
%43 = zext i32 %42 to i64
%44 = alloca double, i64 %43
%45 = bitcast double* %44 to i8*
%46 = alloca double, i64 %35
%47 = alloca double, i64 %43
%48 = bitcast double* %22 to i8*
%49 = alloca double, i64 %35
%50 = alloca double, i64 %43
%51 = mul nsw i32 %24, %23
%52 = zext i32 %51 to i64
%53 = alloca double, i64 %52
%54 = alloca double, i64 %32
%55 = alloca double, i64 %32
%56 = bitcast double* %55 to i8*
%57 = alloca double, i64 %40
%58 = alloca double, i64 %52
%59 = alloca double, i64 %32
%60 = alloca double, i64 %52
%61 = alloca double, i64 %32
%62 = alloca double, i64 %32
%63 = alloca double, i64 %32
%64 = alloca double, i64 %32
%65 = bitcast double* %64 to i8*
%66 = alloca double, i64 %32
%67 = call i32 @linspace(i32 0, i32 1, i32 %23, double* %34)
%68 = add nsw i32 %23, -1
%69 = sitofp i32 %68 to double
%70 = fdiv double 1.000000e+00, %69
%71 = icmp sgt i32 %23, 0
br i1 %71, label %72, label %148
72: ; preds = %14
%73 = bitcast double* %38 to i8*
%74 = bitcast double* %34 to i8*
%75 = shl nuw nsw i64 %32, 3
%76 = icmp ult i32 %23, 4
br i1 %76, label %146, label %77
77: ; preds = %72
%78 = and i64 %32, 4294967292
%79 = add nsw i64 %78, -4
%80 = lshr exact i64 %79, 2
%81 = add nuw nsw i64 %80, 1
%82 = and i64 %81, 7
%83 = icmp ult i64 %79, 28
br i1 %83, label %131, label %84
84: ; preds = %77
%85 = and i64 %81, 9223372036854775800
br label %86
86: ; preds = %86, %84
%87 = phi i64 [ 0, %84 ], [ %128, %86 ]
%88 = phi i64 [ 0, %84 ], [ %129, %86 ]
%89 = getelementptr inbounds double, double* %62, i64 %87
%90 = bitcast double* %89 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %90
%91 = getelementptr inbounds double, double* %89, i64 2
%92 = bitcast double* %91 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %92
%93 = or i64 %87, 4
%94 = getelementptr inbounds double, double* %62, i64 %93
%95 = bitcast double* %94 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %95
%96 = getelementptr inbounds double, double* %94, i64 2
%97 = bitcast double* %96 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %97
%98 = or i64 %87, 8
%99 = getelementptr inbounds double, double* %62, i64 %98
%100 = bitcast double* %99 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %100
%101 = getelementptr inbounds double, double* %99, i64 2
%102 = bitcast double* %101 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %102
%103 = or i64 %87, 12
%104 = getelementptr inbounds double, double* %62, i64 %103
%105 = bitcast double* %104 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %105
%106 = getelementptr inbounds double, double* %104, i64 2
%107 = bitcast double* %106 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %107
%108 = or i64 %87, 16
%109 = getelementptr inbounds double, double* %62, i64 %108
%110 = bitcast double* %109 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %110
%111 = getelementptr inbounds double, double* %109, i64 2
%112 = bitcast double* %111 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %112
%113 = or i64 %87, 20
%114 = getelementptr inbounds double, double* %62, i64 %113
%115 = bitcast double* %114 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %115
%116 = getelementptr inbounds double, double* %114, i64 2
%117 = bitcast double* %116 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %117
%118 = or i64 %87, 24
%119 = getelementptr inbounds double, double* %62, i64 %118
%120 = bitcast double* %119 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %120
%121 = getelementptr inbounds double, double* %119, i64 2
%122 = bitcast double* %121 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %122
%123 = or i64 %87, 28
%124 = getelementptr inbounds double, double* %62, i64 %123
%125 = bitcast double* %124 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %125
%126 = getelementptr inbounds double, double* %124, i64 2
%127 = bitcast double* %126 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %127
%128 = add nuw i64 %87, 32
%129 = add i64 %88, 8
%130 = icmp eq i64 %129, %85
br i1 %130, label %131, label %86
131: ; preds = %86, %77
%132 = phi i64 [ 0, %77 ], [ %128, %86 ]
%133 = icmp eq i64 %82, 0
br i1 %133, label %144, label %134
134: ; preds = %131, %134
%135 = phi i64 [ %141, %134 ], [ %132, %131 ]
%136 = phi i64 [ %142, %134 ], [ 0, %131 ]
%137 = getelementptr inbounds double, double* %62, i64 %135
%138 = bitcast double* %137 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %138
%139 = getelementptr inbounds double, double* %137, i64 2
%140 = bitcast double* %139 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %140
%141 = add nuw i64 %135, 4
%142 = add i64 %136, 1
%143 = icmp eq i64 %142, %82
br i1 %143, label %144, label %134
144: ; preds = %134, %131
%145 = icmp eq i64 %78, %32
br i1 %145, label %148, label %146
146: ; preds = %72, %144
%147 = phi i64 [ 0, %72 ], [ %78, %144 ]
br label %150
148: ; preds = %150, %144, %14
%149 = sext i32 %23 to i64
br label %155
150: ; preds = %146, %150
%151 = phi i64 [ %153, %150 ], [ %147, %146 ]
%152 = getelementptr inbounds double, double* %62, i64 %151
store double 1.000000e+00, double* %152
%153 = add nuw nsw i64 %151, 1
%154 = icmp eq i64 %153, %32
br i1 %154, label %148, label %150
155: ; preds = %148, %204
%156 = phi i64 [ 0, %148 ], [ %157, %204 ]
%157 = add nuw nsw i64 %156, 1
br i1 %71, label %158, label %204
158: ; preds = %155
%159 = shl nuw nsw i64 %156, 1
%160 = mul nsw i64 %159, %149
%161 = or i64 %159, 1
%162 = mul nsw i64 %161, %149
%163 = trunc i64 %157 to i32
%164 = shl i32 %163, 1
br label %169
165: ; preds = %204
%166 = icmp sgt i32 %42, 0
br i1 %166, label %167, label %206
167: ; preds = %165
%168 = shl nuw nsw i64 %43, 3
br label %206
169: ; preds = %158, %169
%170 = phi i64 [ 0, %158 ], [ %202, %169 ]
%171 = load i32, i32* @M_PI
%172 = call i32 @sqrt(i32 %171)
%173 = add i32 %172, 1
%174 = icmp ult i32 %173, 3
%175 = select i1 %174, i32 %172, i32 0
%176 = load i32, i32* @M_PI
%177 = mul i32 %164, %176
%178 = sitofp i32 %177 to double
%179 = getelementptr inbounds double, double* %34, i64 %170
%180 = load double, double* %179
%181 = fmul double %180, %178
%182 = call i32 @sin(double %181)
%183 = mul nsw i32 %175, %182
%184 = sitofp i32 %183 to double
%185 = add nsw i64 %170, %160
%186 = getelementptr inbounds double, double* %41, i64 %185
store double %184, double* %186
%187 = load i32, i32* @M_PI
%188 = call i32 @sqrt(i32 %187)
%189 = add i32 %188, 1
%190 = icmp ult i32 %189, 3
%191 = select i1 %190, i32 %188, i32 0
%192 = load i32, i32* @M_PI
%193 = mul i32 %164, %192
%194 = sitofp i32 %193 to double
%195 = load double, double* %179
%196 = fmul double %195, %194
%197 = call i32 @cos(double %196)
%198 = mul nsw i32 %191, %197
%199 = sitofp i32 %198 to double
%200 = add nsw i64 %170, %162
%201 = getelementptr inbounds double, double* %41, i64 %200
store double %199, double* %201
%202 = add nuw nsw i64 %170, 1
%203 = icmp eq i64 %202, %32
br i1 %203, label %204, label %169
204: ; preds = %169, %155
%205 = icmp eq i64 %157, 10
br i1 %205, label %165, label %155
206: ; preds = %167, %165
%207 = icmp sgt i32 %24, 0
%208 = sext i32 %42 to i64
%209 = getelementptr inbounds [4 x double], [4 x double]* %21, i64 0, i64 0
%210 = getelementptr inbounds [4 x double], [4 x double]* %21, i64 0, i64 1
%211 = getelementptr inbounds [4 x double], [4 x double]* %21, i64 0, i64 2
%212 = getelementptr inbounds [4 x double], [4 x double]* %21, i64 0, i64 3
%213 = getelementptr inbounds [4 x double], [4 x double]* %19, i64 0, i64 0
%214 = getelementptr inbounds [4 x double], [4 x double]* %19, i64 0, i64 1
%215 = getelementptr inbounds [4 x double], [4 x double]* %19, i64 0, i64 2
%216 = getelementptr inbounds [4 x double], [4 x double]* %19, i64 0, i64 3
%217 = icmp sgt i32 %25, 0
%218 = icmp sgt i32 %24, 1
%219 = sext i32 %68 to i64
%220 = getelementptr inbounds double, double* %66, i64 %219
%221 = icmp eq i32 %30, 1
%222 = shl nuw nsw i64 %32, 3
%223 = sext i32 %25 to i64
%224 = zext i32 %25 to i64
%225 = shl nsw i64 %149, 1
%226 = mul nsw i64 %149, 3
%227 = shl nsw i64 %149, 2
%228 = mul nsw i64 %149, 5
%229 = mul nsw i64 %149, 6
%230 = mul nsw i64 %149, 7
%231 = shl nsw i64 %149, 3
%232 = mul nsw i64 %149, 9
%233 = mul nsw i64 %149, 10
%234 = mul nsw i64 %149, 11
%235 = mul nsw i64 %149, 12
%236 = mul nsw i64 %149, 13
%237 = mul nsw i64 %149, 14
%238 = mul nsw i64 %149, 15
%239 = shl nsw i64 %149, 4
%240 = mul nsw i64 %149, 17
%241 = mul nsw i64 %149, 18
%242 = mul nsw i64 %149, 19
%243 = add nsw i64 %35, -1
%244 = and i64 %32, 4294967292
%245 = add nsw i64 %244, -4
%246 = lshr exact i64 %245, 2
%247 = add nuw nsw i64 %246, 1
%248 = add nsw i64 %35, -2
%249 = and i64 %32, 4294967294
%250 = add nsw i64 %249, -2
%251 = lshr exact i64 %250, 1
%252 = add nuw i64 %251, 1
%253 = and i64 %35, 7
%254 = icmp ult i64 %243, 7
%255 = and i64 %35, 4294967288
%256 = icmp eq i64 %253, 0
%257 = and i64 %35, 3
%258 = icmp ult i64 %243, 3
%259 = and i64 %35, 4294967292
%260 = icmp eq i64 %257, 0
%261 = icmp ult i32 %23, 4
%262 = and i64 %32, 4294967292
%263 = and i64 %247, 1
%264 = icmp eq i64 %245, 0
%265 = and i64 %247, 9223372036854775806
%266 = icmp eq i64 %263, 0
%267 = icmp eq i64 %262, %32
%268 = icmp eq i32 %23, 1
%269 = and i64 %32, 4294967294
%270 = icmp eq i64 %269, %32
%271 = and i64 %243, 3
%272 = icmp ult i64 %248, 3
%273 = and i64 %243, -4
%274 = icmp eq i64 %271, 0
%275 = icmp ult i32 %23, 4
%276 = and i64 %32, 4294967292
%277 = and i64 %247, 1
%278 = icmp eq i64 %245, 0
%279 = and i64 %247, 9223372036854775806
%280 = icmp eq i64 %277, 0
%281 = icmp eq i64 %276, %32
%282 = and i64 %243, 3
%283 = icmp ult i64 %248, 3
%284 = and i64 %243, -4
%285 = icmp eq i64 %282, 0
%286 = icmp eq i32 %23, 1
%287 = and i64 %32, 4294967294
%288 = and i64 %252, 1
%289 = icmp eq i64 %250, 0
%290 = and i64 %252, -2
%291 = icmp eq i64 %288, 0
%292 = icmp eq i64 %287, %32
%293 = icmp ult i32 %23, 4
%294 = and i64 %32, 4294967292
%295 = and i64 %247, 1
%296 = icmp eq i64 %245, 0
%297 = and i64 %247, 9223372036854775806
%298 = icmp eq i64 %295, 0
%299 = icmp eq i64 %294, %32
%300 = and i64 %32, 1
%301 = icmp eq i32 %23, 1
%302 = and i64 %32, 4294967294
%303 = icmp eq i64 %300, 0
%304 = and i64 %35, 1
%305 = icmp eq i64 %243, 0
%306 = and i64 %35, 4294967294
%307 = icmp eq i64 %304, 0
br label %308
308: ; preds = %206, %1258
%309 = phi double [ %1260, %1258 ], [ 1.000000e+00, %206 ]
%310 = phi i32 [ %1259, %1258 ], [ 0, %206 ]
%311 = phi double* [ %64, %1258 ], [ %38, %206 ]
br i1 %207, label %312, label %320
312: ; preds = %308, %312
%313 = phi i64 [ %318, %312 ], [ 0, %308 ]
%314 = phi double* [ %317, %312 ], [ %4, %308 ]
%315 = call double @innerprod_q2(i32* %1, double* %44, double* %314)
%316 = getelementptr inbounds double, double* %36, i64 %313
store double %315, double* %316
%317 = getelementptr inbounds double, double* %314, i64 %208
%318 = add nuw nsw i64 %313, 1
%319 = icmp eq i64 %318, %35
br i1 %319, label %320, label %312
320: ; preds = %312, %308
%321 = call double @acos(double %309)
%322 = call i32 @sin(double %321)
%323 = sub nsw i32 0, %322
%324 = sitofp i32 %323 to double
store double %324, double* %209
%325 = call i32 @cos(double %321)
%326 = sitofp i32 %325 to double
store double %326, double* %210
%327 = call i32 @cos(double %321)
%328 = sub nsw i32 0, %327
%329 = sitofp i32 %328 to double
store double %329, double* %211
%330 = call i32 @sin(double %321)
%331 = sub nsw i32 0, %330
%332 = sitofp i32 %331 to double
store double %332, double* %212
%333 = call i32 @product(i32 %25, i32 %25, i32 %23, double* %209, double* %44, double* %47)
br i1 %207, label %335, label %410
334: ; preds = %335
br i1 %207, label %344, label %410
335: ; preds = %320, %335
%336 = phi i64 [ %341, %335 ], [ 0, %320 ]
%337 = phi double* [ %340, %335 ], [ %4, %320 ]
%338 = call double @innerprod_q2(i32* %1, double* %47, double* %337)
%339 = getelementptr inbounds double, double* %46, i64 %336
store double %338, double* %339
%340 = getelementptr inbounds double, double* %337, i64 %208
%341 = add nuw nsw i64 %336, 1
%342 = icmp eq i64 %341, %35
br i1 %342, label %334, label %335
343: ; preds = %344
br i1 %207, label %358, label %410
344: ; preds = %334, %344
%345 = phi i64 [ %354, %344 ], [ 0, %334 ]
%346 = phi double [ %353, %344 ], [ 0.000000e+00, %334 ]
%347 = getelementptr inbounds double, double* %3, i64 %345
%348 = load double, double* %347
%349 = getelementptr inbounds double, double* %36, i64 %345
%350 = load double, double* %349
%351 = fadd double %348, %350
%352 = call double @exp(double %351)
%353 = fadd double %346, %352
%354 = add nuw nsw i64 %345, 1
%355 = icmp eq i64 %354, %35
br i1 %355, label %343, label %344
356: ; preds = %358
br i1 %207, label %357, label %410
357: ; preds = %356
br i1 %254, label %413, label %372
358: ; preds = %343, %358
%359 = phi i64 [ %370, %358 ], [ 0, %343 ]
%360 = getelementptr inbounds double, double* %3, i64 %359
%361 = load double, double* %360
%362 = getelementptr inbounds double, double* %36, i64 %359
%363 = load double, double* %362
%364 = fadd double %361, %363
%365 = call double @exp(double %364)
%366 = getelementptr inbounds double, double* %46, i64 %359
%367 = load double, double* %366
%368 = fmul double %365, %367
%369 = getelementptr inbounds double, double* %49, i64 %359
store double %368, double* %369
%370 = add nuw nsw i64 %359, 1
%371 = icmp eq i64 %370, %35
br i1 %371, label %356, label %358
372: ; preds = %357, %372
%373 = phi i64 [ %407, %372 ], [ 0, %357 ]
%374 = phi double [ %406, %372 ], [ 0.000000e+00, %357 ]
%375 = phi i64 [ %408, %372 ], [ 0, %357 ]
%376 = getelementptr inbounds double, double* %49, i64 %373
%377 = load double, double* %376
%378 = fadd double %374, %377
%379 = or i64 %373, 1
%380 = getelementptr inbounds double, double* %49, i64 %379
%381 = load double, double* %380
%382 = fadd double %378, %381
%383 = or i64 %373, 2
%384 = getelementptr inbounds double, double* %49, i64 %383
%385 = load double, double* %384
%386 = fadd double %382, %385
%387 = or i64 %373, 3
%388 = getelementptr inbounds double, double* %49, i64 %387
%389 = load double, double* %388
%390 = fadd double %386, %389
%391 = or i64 %373, 4
%392 = getelementptr inbounds double, double* %49, i64 %391
%393 = load double, double* %392
%394 = fadd double %390, %393
%395 = or i64 %373, 5
%396 = getelementptr inbounds double, double* %49, i64 %395
%397 = load double, double* %396
%398 = fadd double %394, %397
%399 = or i64 %373, 6
%400 = getelementptr inbounds double, double* %49, i64 %399
%401 = load double, double* %400
%402 = fadd double %398, %401
%403 = or i64 %373, 7
%404 = getelementptr inbounds double, double* %49, i64 %403
%405 = load double, double* %404
%406 = fadd double %402, %405
%407 = add nuw nsw i64 %373, 8
%408 = add i64 %375, 8
%409 = icmp eq i64 %408, %255
br i1 %409, label %413, label %372
410: ; preds = %356, %343, %334, %320
%411 = phi double [ %353, %356 ], [ %353, %343 ], [ 0.000000e+00, %334 ], [ 0.000000e+00, %320 ]
%412 = fdiv double 0.000000e+00, %411
br label %482
413: ; preds = %372, %357
%414 = phi double [ undef, %357 ], [ %406, %372 ]
%415 = phi i64 [ 0, %357 ], [ %407, %372 ]
%416 = phi double [ 0.000000e+00, %357 ], [ %406, %372 ]
br i1 %256, label %427, label %417
417: ; preds = %413, %417
%418 = phi i64 [ %424, %417 ], [ %415, %413 ]
%419 = phi double [ %423, %417 ], [ %416, %413 ]
%420 = phi i64 [ %425, %417 ], [ 0, %413 ]
%421 = getelementptr inbounds double, double* %49, i64 %418
%422 = load double, double* %421
%423 = fadd double %419, %422
%424 = add nuw nsw i64 %418, 1
%425 = add i64 %420, 1
%426 = icmp eq i64 %425, %253
br i1 %426, label %427, label %417
427: ; preds = %417, %413
%428 = phi double [ %414, %413 ], [ %423, %417 ]
%429 = fdiv double %428, %353
br i1 %207, label %430, label %482
430: ; preds = %427
br i1 %258, label %465, label %431
431: ; preds = %430, %431
%432 = phi i64 [ %462, %431 ], [ 0, %430 ]
%433 = phi double [ %461, %431 ], [ 0.000000e+00, %430 ]
%434 = phi i64 [ %463, %431 ], [ 0, %430 ]
%435 = getelementptr inbounds i32, i32* %6, i64 %432
%436 = load i32, i32* %435
%437 = sitofp i32 %436 to double
%438 = getelementptr inbounds double, double* %46, i64 %432
%439 = load double, double* %438
%440 = call double @llvm.fmuladd.f64(double %437, double %439, double %433)
%441 = or i64 %432, 1
%442 = getelementptr inbounds i32, i32* %6, i64 %441
%443 = load i32, i32* %442
%444 = sitofp i32 %443 to double
%445 = getelementptr inbounds double, double* %46, i64 %441
%446 = load double, double* %445
%447 = call double @llvm.fmuladd.f64(double %444, double %446, double %440)
%448 = or i64 %432, 2
%449 = getelementptr inbounds i32, i32* %6, i64 %448
%450 = load i32, i32* %449
%451 = sitofp i32 %450 to double
%452 = getelementptr inbounds double, double* %46, i64 %448
%453 = load double, double* %452
%454 = call double @llvm.fmuladd.f64(double %451, double %453, double %447)
%455 = or i64 %432, 3
%456 = getelementptr inbounds i32, i32* %6, i64 %455
%457 = load i32, i32* %456
%458 = sitofp i32 %457 to double
%459 = getelementptr inbounds double, double* %46, i64 %455
%460 = load double, double* %459
%461 = call double @llvm.fmuladd.f64(double %458, double %460, double %454)
%462 = add nuw nsw i64 %432, 4
%463 = add i64 %434, 4
%464 = icmp eq i64 %463, %259
br i1 %464, label %465, label %431
465: ; preds = %431, %430
%466 = phi double [ undef, %430 ], [ %461, %431 ]
%467 = phi i64 [ 0, %430 ], [ %462, %431 ]
%468 = phi double [ 0.000000e+00, %430 ], [ %461, %431 ]
br i1 %260, label %482, label %469
469: ; preds = %465, %469
%470 = phi i64 [ %479, %469 ], [ %467, %465 ]
%471 = phi double [ %478, %469 ], [ %468, %465 ]
%472 = phi i64 [ %480, %469 ], [ 0, %465 ]
%473 = getelementptr inbounds i32, i32* %6, i64 %470
%474 = load i32, i32* %473
%475 = sitofp i32 %474 to double
%476 = getelementptr inbounds double, double* %46, i64 %470
%477 = load double, double* %476
%478 = call double @llvm.fmuladd.f64(double %475, double %477, double %471)
%479 = add nuw nsw i64 %470, 1
%480 = add i64 %472, 1
%481 = icmp eq i64 %480, %257
br i1 %481, label %482, label %469
482: ; preds = %465, %469, %410, %427
%483 = phi double [ %429, %427 ], [ %412, %410 ], [ %429, %469 ], [ %429, %465 ]
%484 = phi double [ %353, %427 ], [ %411, %410 ], [ %353, %469 ], [ %353, %465 ]
%485 = phi double [ 0.000000e+00, %427 ], [ 0.000000e+00, %410 ], [ %466, %465 ], [ %478, %469 ]
%486 = fsub double %485, %483
%487 = call double @llvm.fmuladd.f64(double %28, double %486, double %321)
%488 = call i32 @cos(double %487)
%489 = sitofp i32 %488 to double
store double %489, double* %213
%490 = call i32 @sin(double %487)
%491 = sitofp i32 %490 to double
store double %491, double* %214
%492 = call i32 @sin(double %487)
%493 = sub nsw i32 0, %492
%494 = sitofp i32 %493 to double
store double %494, double* %215
%495 = call i32 @cos(double %487)
%496 = sitofp i32 %495 to double
store double %496, double* %216
%497 = call i32 @col_gradient(i32 %25, i32 %23, double* %44, double %70, double* %50)
br i1 %207, label %499, label %815
498: ; preds = %811
br i1 %207, label %816, label %815
499: ; preds = %482, %811
%500 = phi i64 [ %813, %811 ], [ 0, %482 ]
%501 = phi double* [ %812, %811 ], [ %4, %482 ]
br label %613
502: ; preds = %719
br i1 %71, label %503, label %811
503: ; preds = %502
%504 = mul nsw i64 %500, %149
br i1 %268, label %611, label %505
505: ; preds = %503, %505
%506 = phi i64 [ %608, %505 ], [ 0, %503 ]
%507 = getelementptr inbounds double, double* %57, i64 %506
%508 = bitcast double* %507 to <2 x double>*
%509 = load <2 x double>, <2 x double>* %508
%510 = add nsw i64 %506, %504
%511 = getelementptr inbounds double, double* %53, i64 %510
%512 = add nsw i64 %506, %149
%513 = getelementptr inbounds double, double* %57, i64 %512
%514 = bitcast double* %513 to <2 x double>*
%515 = load <2 x double>, <2 x double>* %514
%516 = fadd <2 x double> %509, %515
%517 = add nsw i64 %225, %506
%518 = getelementptr inbounds double, double* %57, i64 %517
%519 = bitcast double* %518 to <2 x double>*
%520 = load <2 x double>, <2 x double>* %519
%521 = fadd <2 x double> %516, %520
%522 = add nsw i64 %226, %506
%523 = getelementptr inbounds double, double* %57, i64 %522
%524 = bitcast double* %523 to <2 x double>*
%525 = load <2 x double>, <2 x double>* %524
%526 = fadd <2 x double> %521, %525
%527 = add nsw i64 %227, %506
%528 = getelementptr inbounds double, double* %57, i64 %527
%529 = bitcast double* %528 to <2 x double>*
%530 = load <2 x double>, <2 x double>* %529
%531 = fadd <2 x double> %526, %530
%532 = add nsw i64 %228, %506
%533 = getelementptr inbounds double, double* %57, i64 %532
%534 = bitcast double* %533 to <2 x double>*
%535 = load <2 x double>, <2 x double>* %534
%536 = fadd <2 x double> %531, %535
%537 = add nsw i64 %229, %506
%538 = getelementptr inbounds double, double* %57, i64 %537
%539 = bitcast double* %538 to <2 x double>*
%540 = load <2 x double>, <2 x double>* %539
%541 = fadd <2 x double> %536, %540
%542 = add nsw i64 %230, %506
%543 = getelementptr inbounds double, double* %57, i64 %542
%544 = bitcast double* %543 to <2 x double>*
%545 = load <2 x double>, <2 x double>* %544
%546 = fadd <2 x double> %541, %545
%547 = add nsw i64 %231, %506
%548 = getelementptr inbounds double, double* %57, i64 %547
%549 = bitcast double* %548 to <2 x double>*
%550 = load <2 x double>, <2 x double>* %549
%551 = fadd <2 x double> %546, %550
%552 = add nsw i64 %232, %506
%553 = getelementptr inbounds double, double* %57, i64 %552
%554 = bitcast double* %553 to <2 x double>*
%555 = load <2 x double>, <2 x double>* %554
%556 = fadd <2 x double> %551, %555
%557 = add nsw i64 %233, %506
%558 = getelementptr inbounds double, double* %57, i64 %557
%559 = bitcast double* %558 to <2 x double>*
%560 = load <2 x double>, <2 x double>* %559
%561 = fadd <2 x double> %556, %560
%562 = add nsw i64 %234, %506
%563 = getelementptr inbounds double, double* %57, i64 %562
%564 = bitcast double* %563 to <2 x double>*
%565 = load <2 x double>, <2 x double>* %564
%566 = fadd <2 x double> %561, %565
%567 = add nsw i64 %235, %506
%568 = getelementptr inbounds double, double* %57, i64 %567
%569 = bitcast double* %568 to <2 x double>*
%570 = load <2 x double>, <2 x double>* %569
%571 = fadd <2 x double> %566, %570
%572 = add nsw i64 %236, %506
%573 = getelementptr inbounds double, double* %57, i64 %572
%574 = bitcast double* %573 to <2 x double>*
%575 = load <2 x double>, <2 x double>* %574
%576 = fadd <2 x double> %571, %575
%577 = add nsw i64 %237, %506
%578 = getelementptr inbounds double, double* %57, i64 %577
%579 = bitcast double* %578 to <2 x double>*
%580 = load <2 x double>, <2 x double>* %579
%581 = fadd <2 x double> %576, %580
%582 = add nsw i64 %238, %506
%583 = getelementptr inbounds double, double* %57, i64 %582
%584 = bitcast double* %583 to <2 x double>*
%585 = load <2 x double>, <2 x double>* %584
%586 = fadd <2 x double> %581, %585
%587 = add nsw i64 %239, %506
%588 = getelementptr inbounds double, double* %57, i64 %587
%589 = bitcast double* %588 to <2 x double>*
%590 = load <2 x double>, <2 x double>* %589
%591 = fadd <2 x double> %586, %590
%592 = add nsw i64 %240, %506
%593 = getelementptr inbounds double, double* %57, i64 %592
%594 = bitcast double* %593 to <2 x double>*
%595 = load <2 x double>, <2 x double>* %594
%596 = fadd <2 x double> %591, %595
%597 = add nsw i64 %241, %506
%598 = getelementptr inbounds double, double* %57, i64 %597
%599 = bitcast double* %598 to <2 x double>*
%600 = load <2 x double>, <2 x double>* %599
%601 = fadd <2 x double> %596, %600
%602 = add nsw i64 %242, %506
%603 = getelementptr inbounds double, double* %57, i64 %602
%604 = bitcast double* %603 to <2 x double>*
%605 = load <2 x double>, <2 x double>* %604
%606 = fadd <2 x double> %601, %605
%607 = bitcast double* %511 to <2 x double>*
store <2 x double> %606, <2 x double>* %607
%608 = add nuw i64 %506, 2
%609 = icmp eq i64 %608, %269
br i1 %609, label %610, label %505
610: ; preds = %505
br i1 %270, label %811, label %611
611: ; preds = %503, %610
%612 = phi i64 [ 0, %503 ], [ %269, %610 ]
br label %727
613: ; preds = %722, %499
%614 = phi i64 [ 0, %499 ], [ %723, %722 ]
br i1 %71, label %615, label %621
615: ; preds = %613
%616 = trunc i64 %614 to i32
%617 = mul i32 %23, %616
%618 = sext i32 %617 to i64
%619 = getelementptr double, double* %41, i64 %618
%620 = bitcast double* %619 to i8*
br label %621
621: ; preds = %615, %613
%622 = call i32 @cumtrapz(i32* %1, double* %34, double* %55, double* %54)
br i1 %217, label %623, label %649
623: ; preds = %621
%624 = mul nsw i64 %614, %149
br label %625
625: ; preds = %623, %646
%626 = phi i64 [ 0, %623 ], [ %647, %646 ]
br i1 %71, label %627, label %646
627: ; preds = %625, %627
%628 = phi i64 [ %644, %627 ], [ 0, %625 ]
%629 = mul nsw i64 %628, %223
%630 = add nsw i64 %629, %626
%631 = getelementptr inbounds double, double* %50, i64 %630
%632 = load double, double* %631
%633 = fmul double %632, 2.000000e+00
%634 = getelementptr inbounds double, double* %54, i64 %628
%635 = load double, double* %634
%636 = getelementptr inbounds double, double* %44, i64 %630
%637 = load double, double* %636
%638 = add nsw i64 %628, %624
%639 = getelementptr inbounds double, double* %41, i64 %638
%640 = load double, double* %639
%641 = fmul double %637, %640
%642 = call double @llvm.fmuladd.f64(double %633, double %635, double %641)
%643 = getelementptr inbounds double, double* %47, i64 %630
store double %642, double* %643
%644 = add nuw nsw i64 %628, 1
%645 = icmp eq i64 %644, %32
br i1 %645, label %646, label %627
646: ; preds = %627, %625
%647 = add nuw nsw i64 %626, 1
%648 = icmp eq i64 %647, %224
br i1 %648, label %649, label %625
649: ; preds = %646, %621
%650 = call double @innerprod_q2(i32* %1, double* %47, double* %501)
store double %650, double* %22
br i1 %71, label %651, label %724
651: ; preds = %649
%652 = mul nsw i64 %614, %149
br i1 %261, label %708, label %653
653: ; preds = %651
%654 = insertelement <2 x double> poison, double %650, i64 0
%655 = shufflevector <2 x double> %654, <2 x double> poison, <2 x i32> zeroinitializer
%656 = insertelement <2 x double> poison, double %650, i64 0
%657 = shufflevector <2 x double> %656, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %264, label %691, label %658
658: ; preds = %653, %658
%659 = phi i64 [ %688, %658 ], [ 0, %653 ]
%660 = phi i64 [ %689, %658 ], [ 0, %653 ]
%661 = add nsw i64 %659, %652
%662 = getelementptr inbounds double, double* %41, i64 %661
%663 = bitcast double* %662 to <2 x double>*
%664 = load <2 x double>, <2 x double>* %663
%665 = getelementptr inbounds double, double* %662, i64 2
%666 = bitcast double* %665 to <2 x double>*
%667 = load <2 x double>, <2 x double>* %666
%668 = fmul <2 x double> %655, %664
%669 = fmul <2 x double> %657, %667
%670 = getelementptr inbounds double, double* %57, i64 %661
%671 = bitcast double* %670 to <2 x double>*
store <2 x double> %668, <2 x double>* %671
%672 = getelementptr inbounds double, double* %670, i64 2
%673 = bitcast double* %672 to <2 x double>*
store <2 x double> %669, <2 x double>* %673
%674 = or i64 %659, 4
%675 = add nsw i64 %674, %652
%676 = getelementptr inbounds double, double* %41, i64 %675
%677 = bitcast double* %676 to <2 x double>*
%678 = load <2 x double>, <2 x double>* %677
%679 = getelementptr inbounds double, double* %676, i64 2
%680 = bitcast double* %679 to <2 x double>*
%681 = load <2 x double>, <2 x double>* %680
%682 = fmul <2 x double> %655, %678
%683 = fmul <2 x double> %657, %681
%684 = getelementptr inbounds double, double* %57, i64 %675
%685 = bitcast double* %684 to <2 x double>*
store <2 x double> %682, <2 x double>* %685
%686 = getelementptr inbounds double, double* %684, i64 2
%687 = bitcast double* %686 to <2 x double>*
store <2 x double> %683, <2 x double>* %687
%688 = add nuw i64 %659, 8
%689 = add i64 %660, 2
%690 = icmp eq i64 %689, %265
br i1 %690, label %691, label %658
691: ; preds = %658, %653
%692 = phi i64 [ 0, %653 ], [ %688, %658 ]
br i1 %266, label %707, label %693
693: ; preds = %691
%694 = add nsw i64 %692, %652
%695 = getelementptr inbounds double, double* %41, i64 %694
%696 = bitcast double* %695 to <2 x double>*
%697 = load <2 x double>, <2 x double>* %696
%698 = getelementptr inbounds double, double* %695, i64 2
%699 = bitcast double* %698 to <2 x double>*
%700 = load <2 x double>, <2 x double>* %699
%701 = fmul <2 x double> %655, %697
%702 = fmul <2 x double> %657, %700
%703 = getelementptr inbounds double, double* %57, i64 %694
%704 = bitcast double* %703 to <2 x double>*
store <2 x double> %701, <2 x double>* %704
%705 = getelementptr inbounds double, double* %703, i64 2
%706 = bitcast double* %705 to <2 x double>*
store <2 x double> %702, <2 x double>* %706
br label %707
707: ; preds = %691, %693
br i1 %267, label %719, label %708
708: ; preds = %651, %707
%709 = phi i64 [ 0, %651 ], [ %262, %707 ]
br label %710
710: ; preds = %708, %710
%711 = phi i64 [ %717, %710 ], [ %709, %708 ]
%712 = add nsw i64 %711, %652
%713 = getelementptr inbounds double, double* %41, i64 %712
%714 = load double, double* %713
%715 = fmul double %650, %714
%716 = getelementptr inbounds double, double* %57, i64 %712
store double %715, double* %716
%717 = add nuw nsw i64 %711, 1
%718 = icmp eq i64 %717, %32
br i1 %718, label %719, label %710
719: ; preds = %710, %707
%720 = add nuw nsw i64 %614, 1
%721 = icmp eq i64 %720, 20
br i1 %721, label %502, label %722
722: ; preds = %719, %724
%723 = phi i64 [ %720, %719 ], [ %725, %724 ]
br label %613
724: ; preds = %649
%725 = add nuw nsw i64 %614, 1
%726 = icmp eq i64 %725, 20
br i1 %726, label %811, label %722
727: ; preds = %611, %727
%728 = phi i64 [ %809, %727 ], [ %612, %611 ]
%729 = getelementptr inbounds double, double* %57, i64 %728
%730 = load double, double* %729
%731 = add nsw i64 %728, %504
%732 = getelementptr inbounds double, double* %53, i64 %731
%733 = add nsw i64 %728, %149
%734 = getelementptr inbounds double, double* %57, i64 %733
%735 = load double, double* %734
%736 = fadd double %730, %735
%737 = add nsw i64 %225, %728
%738 = getelementptr inbounds double, double* %57, i64 %737
%739 = load double, double* %738
%740 = fadd double %736, %739
%741 = add nsw i64 %226, %728
%742 = getelementptr inbounds double, double* %57, i64 %741
%743 = load double, double* %742
%744 = fadd double %740, %743
%745 = add nsw i64 %227, %728
%746 = getelementptr inbounds double, double* %57, i64 %745
%747 = load double, double* %746
%748 = fadd double %744, %747
%749 = add nsw i64 %228, %728
%750 = getelementptr inbounds double, double* %57, i64 %749
%751 = load double, double* %750
%752 = fadd double %748, %751
%753 = add nsw i64 %229, %728
%754 = getelementptr inbounds double, double* %57, i64 %753
%755 = load double, double* %754
%756 = fadd double %752, %755
%757 = add nsw i64 %230, %728
%758 = getelementptr inbounds double, double* %57, i64 %757
%759 = load double, double* %758
%760 = fadd double %756, %759
%761 = add nsw i64 %231, %728
%762 = getelementptr inbounds double, double* %57, i64 %761
%763 = load double, double* %762
%764 = fadd double %760, %763
%765 = add nsw i64 %232, %728
%766 = getelementptr inbounds double, double* %57, i64 %765
%767 = load double, double* %766
%768 = fadd double %764, %767
%769 = add nsw i64 %233, %728
%770 = getelementptr inbounds double, double* %57, i64 %769
%771 = load double, double* %770
%772 = fadd double %768, %771
%773 = add nsw i64 %234, %728
%774 = getelementptr inbounds double, double* %57, i64 %773
%775 = load double, double* %774
%776 = fadd double %772, %775
%777 = add nsw i64 %235, %728
%778 = getelementptr inbounds double, double* %57, i64 %777
%779 = load double, double* %778
%780 = fadd double %776, %779
%781 = add nsw i64 %236, %728
%782 = getelementptr inbounds double, double* %57, i64 %781
%783 = load double, double* %782
%784 = fadd double %780, %783
%785 = add nsw i64 %237, %728
%786 = getelementptr inbounds double, double* %57, i64 %785
%787 = load double, double* %786
%788 = fadd double %784, %787
%789 = add nsw i64 %238, %728
%790 = getelementptr inbounds double, double* %57, i64 %789
%791 = load double, double* %790
%792 = fadd double %788, %791
%793 = add nsw i64 %239, %728
%794 = getelementptr inbounds double, double* %57, i64 %793
%795 = load double, double* %794
%796 = fadd double %792, %795
%797 = add nsw i64 %240, %728
%798 = getelementptr inbounds double, double* %57, i64 %797
%799 = load double, double* %798
%800 = fadd double %796, %799
%801 = add nsw i64 %241, %728
%802 = getelementptr inbounds double, double* %57, i64 %801
%803 = load double, double* %802
%804 = fadd double %800, %803
%805 = add nsw i64 %242, %728
%806 = getelementptr inbounds double, double* %57, i64 %805
%807 = load double, double* %806
%808 = fadd double %804, %807
store double %808, double* %732
%809 = add nuw nsw i64 %728, 1
%810 = icmp eq i64 %809, %32
br i1 %810, label %811, label %727
811: ; preds = %724, %727, %610, %502
%812 = getelementptr inbounds double, double* %501, i64 %208
%813 = add nuw nsw i64 %500, 1
%814 = icmp eq i64 %813, %35
br i1 %814, label %498, label %499
815: ; preds = %835, %482, %498
br i1 %71, label %841, label %840
816: ; preds = %498, %835
%817 = phi i64 [ %838, %835 ], [ 0, %498 ]
%818 = phi double* [ %837, %835 ], [ %58, %498 ]
%819 = phi double* [ %836, %835 ], [ %53, %498 ]
br i1 %71, label %820, label %835
820: ; preds = %816
%821 = getelementptr inbounds double, double* %3, i64 %817
%822 = getelementptr inbounds double, double* %36, i64 %817
%823 = load double, double* %822
br label %824
824: ; preds = %820, %824
%825 = phi i64 [ 0, %820 ], [ %833, %824 ]
%826 = load double, double* %821
%827 = fadd double %826, %823
%828 = call double @exp(double %827)
%829 = getelementptr inbounds double, double* %819, i64 %825
%830 = load double, double* %829
%831 = fmul double %828, %830
%832 = getelementptr inbounds double, double* %818, i64 %825
store double %831, double* %832
%833 = add nuw nsw i64 %825, 1
%834 = icmp eq i64 %833, %32
br i1 %834, label %835, label %824
835: ; preds = %824, %816
%836 = getelementptr inbounds double, double* %819, i64 %149
%837 = getelementptr inbounds double, double* %818, i64 %149
%838 = add nuw nsw i64 %817, 1
%839 = icmp eq i64 %838, %35
br i1 %839, label %815, label %816
840: ; preds = %893, %815
br i1 %207, label %899, label %898
841: ; preds = %815, %893
%842 = phi i64 [ %896, %893 ], [ 0, %815 ]
%843 = getelementptr inbounds double, double* %58, i64 %842
%844 = load double, double* %843
%845 = getelementptr inbounds double, double* %59, i64 %842
br i1 %218, label %846, label %893
846: ; preds = %841
br i1 %272, label %877, label %847
847: ; preds = %846, %847
%848 = phi i64 [ %874, %847 ], [ 1, %846 ]
%849 = phi double [ %873, %847 ], [ %844, %846 ]
%850 = phi i64 [ %875, %847 ], [ 0, %846 ]
%851 = mul nsw i64 %848, %149
%852 = add nsw i64 %851, %842
%853 = getelementptr inbounds double, double* %58, i64 %852
%854 = load double, double* %853
%855 = fadd double %849, %854
%856 = add nuw nsw i64 %848, 1
%857 = mul nsw i64 %856, %149
%858 = add nsw i64 %857, %842
%859 = getelementptr inbounds double, double* %58, i64 %858
%860 = load double, double* %859
%861 = fadd double %855, %860
%862 = add nuw nsw i64 %848, 2
%863 = mul nsw i64 %862, %149
%864 = add nsw i64 %863, %842
%865 = getelementptr inbounds double, double* %58, i64 %864
%866 = load double, double* %865
%867 = fadd double %861, %866
%868 = add nuw nsw i64 %848, 3
%869 = mul nsw i64 %868, %149
%870 = add nsw i64 %869, %842
%871 = getelementptr inbounds double, double* %58, i64 %870
%872 = load double, double* %871
%873 = fadd double %867, %872
%874 = add nuw nsw i64 %848, 4
%875 = add nuw i64 %850, 4
%876 = icmp eq i64 %875, %273
br i1 %876, label %877, label %847
877: ; preds = %847, %846
%878 = phi double [ undef, %846 ], [ %873, %847 ]
%879 = phi i64 [ 1, %846 ], [ %874, %847 ]
%880 = phi double [ %844, %846 ], [ %873, %847 ]
br i1 %274, label %893, label %881
881: ; preds = %877, %881
%882 = phi i64 [ %890, %881 ], [ %879, %877 ]
%883 = phi double [ %889, %881 ], [ %880, %877 ]
%884 = phi i64 [ %891, %881 ], [ 0, %877 ]
%885 = mul nsw i64 %882, %149
%886 = add nsw i64 %885, %842
%887 = getelementptr inbounds double, double* %58, i64 %886
%888 = load double, double* %887
%889 = fadd double %883, %888
%890 = add nuw nsw i64 %882, 1
%891 = add i64 %884, 1
%892 = icmp eq i64 %891, %271
br i1 %892, label %893, label %881
893: ; preds = %877, %881, %841
%894 = phi double [ %844, %841 ], [ %878, %877 ], [ %889, %881 ]
%895 = fdiv double %894, %484
store double %895, double* %845
%896 = add nuw nsw i64 %842, 1
%897 = icmp eq i64 %896, %32
br i1 %897, label %840, label %841
898: ; preds = %969, %840
br i1 %71, label %974, label %1033
899: ; preds = %840, %969
%900 = phi i64 [ %972, %969 ], [ 0, %840 ]
%901 = phi double* [ %971, %969 ], [ %60, %840 ]
%902 = phi double* [ %970, %969 ], [ %53, %840 ]
br i1 %71, label %903, label %969
903: ; preds = %899
%904 = getelementptr inbounds i32, i32* %6, i64 %900
%905 = load i32, i32* %904
%906 = sitofp i32 %905 to double
br i1 %275, label %959, label %907
907: ; preds = %903
%908 = insertelement <2 x double> poison, double %906, i64 0
%909 = shufflevector <2 x double> %908, <2 x double> poison, <2 x i32> zeroinitializer
%910 = insertelement <2 x double> poison, double %906, i64 0
%911 = shufflevector <2 x double> %910, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %278, label %943, label %912
912: ; preds = %907, %912
%913 = phi i64 [ %940, %912 ], [ 0, %907 ]
%914 = phi i64 [ %941, %912 ], [ 0, %907 ]
%915 = getelementptr inbounds double, double* %902, i64 %913
%916 = bitcast double* %915 to <2 x double>*
%917 = load <2 x double>, <2 x double>* %916
%918 = getelementptr inbounds double, double* %915, i64 2
%919 = bitcast double* %918 to <2 x double>*
%920 = load <2 x double>, <2 x double>* %919
%921 = fmul <2 x double> %917, %909
%922 = fmul <2 x double> %920, %911
%923 = getelementptr inbounds double, double* %901, i64 %913
%924 = bitcast double* %923 to <2 x double>*
store <2 x double> %921, <2 x double>* %924
%925 = getelementptr inbounds double, double* %923, i64 2
%926 = bitcast double* %925 to <2 x double>*
store <2 x double> %922, <2 x double>* %926
%927 = or i64 %913, 4
%928 = getelementptr inbounds double, double* %902, i64 %927
%929 = bitcast double* %928 to <2 x double>*
%930 = load <2 x double>, <2 x double>* %929
%931 = getelementptr inbounds double, double* %928, i64 2
%932 = bitcast double* %931 to <2 x double>*
%933 = load <2 x double>, <2 x double>* %932
%934 = fmul <2 x double> %930, %909
%935 = fmul <2 x double> %933, %911
%936 = getelementptr inbounds double, double* %901, i64 %927
%937 = bitcast double* %936 to <2 x double>*
store <2 x double> %934, <2 x double>* %937
%938 = getelementptr inbounds double, double* %936, i64 2
%939 = bitcast double* %938 to <2 x double>*
store <2 x double> %935, <2 x double>* %939
%940 = add nuw i64 %913, 8
%941 = add i64 %914, 2
%942 = icmp eq i64 %941, %279
br i1 %942, label %943, label %912
943: ; preds = %912, %907
%944 = phi i64 [ 0, %907 ], [ %940, %912 ]
br i1 %280, label %958, label %945
945: ; preds = %943
%946 = getelementptr inbounds double, double* %902, i64 %944
%947 = bitcast double* %946 to <2 x double>*
%948 = load <2 x double>, <2 x double>* %947
%949 = getelementptr inbounds double, double* %946, i64 2
%950 = bitcast double* %949 to <2 x double>*
%951 = load <2 x double>, <2 x double>* %950
%952 = fmul <2 x double> %948, %909
%953 = fmul <2 x double> %951, %911
%954 = getelementptr inbounds double, double* %901, i64 %944
%955 = bitcast double* %954 to <2 x double>*
store <2 x double> %952, <2 x double>* %955
%956 = getelementptr inbounds double, double* %954, i64 2
%957 = bitcast double* %956 to <2 x double>*
store <2 x double> %953, <2 x double>* %957
br label %958
958: ; preds = %943, %945
br i1 %281, label %969, label %959
959: ; preds = %903, %958
%960 = phi i64 [ 0, %903 ], [ %276, %958 ]
br label %961
961: ; preds = %959, %961
%962 = phi i64 [ %967, %961 ], [ %960, %959 ]
%963 = getelementptr inbounds double, double* %902, i64 %962
%964 = load double, double* %963
%965 = fmul double %964, %906
%966 = getelementptr inbounds double, double* %901, i64 %962
store double %965, double* %966
%967 = add nuw nsw i64 %962, 1
%968 = icmp eq i64 %967, %32
br i1 %968, label %969, label %961
969: ; preds = %961, %958, %899
%970 = getelementptr inbounds double, double* %902, i64 %149
%971 = getelementptr inbounds double, double* %901, i64 %149
%972 = add nuw nsw i64 %900, 1
%973 = icmp eq i64 %972, %35
br i1 %973, label %898, label %899
974: ; preds = %898, %1026
%975 = phi i64 [ %1031, %1026 ], [ 0, %898 ]
%976 = getelementptr inbounds double, double* %60, i64 %975
%977 = load double, double* %976
%978 = getelementptr inbounds double, double* %61, i64 %975
br i1 %218, label %979, label %1026
979: ; preds = %974
br i1 %283, label %1010, label %980
980: ; preds = %979, %980
%981 = phi i64 [ %1007, %980 ], [ 1, %979 ]
%982 = phi double [ %1006, %980 ], [ %977, %979 ]
%983 = phi i64 [ %1008, %980 ], [ 0, %979 ]
%984 = mul nsw i64 %981, %149
%985 = add nsw i64 %984, %975
%986 = getelementptr inbounds double, double* %60, i64 %985
%987 = load double, double* %986
%988 = fadd double %987, %982
%989 = add nuw nsw i64 %981, 1
%990 = mul nsw i64 %989, %149
%991 = add nsw i64 %990, %975
%992 = getelementptr inbounds double, double* %60, i64 %991
%993 = load double, double* %992
%994 = fadd double %993, %988
%995 = add nuw nsw i64 %981, 2
%996 = mul nsw i64 %995, %149
%997 = add nsw i64 %996, %975
%998 = getelementptr inbounds double, double* %60, i64 %997
%999 = load double, double* %998
%1000 = fadd double %999, %994
%1001 = add nuw nsw i64 %981, 3
%1002 = mul nsw i64 %1001, %149
%1003 = add nsw i64 %1002, %975
%1004 = getelementptr inbounds double, double* %60, i64 %1003
%1005 = load double, double* %1004
%1006 = fadd double %1005, %1000
%1007 = add nuw nsw i64 %981, 4
%1008 = add nuw i64 %983, 4
%1009 = icmp eq i64 %1008, %284
br i1 %1009, label %1010, label %980
1010: ; preds = %980, %979
%1011 = phi double [ undef, %979 ], [ %1006, %980 ]
%1012 = phi i64 [ 1, %979 ], [ %1007, %980 ]
%1013 = phi double [ %977, %979 ], [ %1006, %980 ]
br i1 %285, label %1026, label %1014
1014: ; preds = %1010, %1014
%1015 = phi i64 [ %1023, %1014 ], [ %1012, %1010 ]
%1016 = phi double [ %1022, %1014 ], [ %1013, %1010 ]
%1017 = phi i64 [ %1024, %1014 ], [ 0, %1010 ]
%1018 = mul nsw i64 %1015, %149
%1019 = add nsw i64 %1018, %975
%1020 = getelementptr inbounds double, double* %60, i64 %1019
%1021 = load double, double* %1020
%1022 = fadd double %1021, %1016
%1023 = add nuw nsw i64 %1015, 1
%1024 = add i64 %1017, 1
%1025 = icmp eq i64 %1024, %282
br i1 %1025, label %1026, label %1014
1026: ; preds = %1010, %1014, %974
%1027 = phi double [ %977, %974 ], [ %1011, %1010 ], [ %1022, %1014 ]
%1028 = getelementptr inbounds double, double* %59, i64 %975
%1029 = load double, double* %1028
%1030 = fsub double %1027, %1029
store double %1030, double* %978
%1031 = add nuw nsw i64 %975, 1
%1032 = icmp eq i64 %1031, %32
br i1 %1032, label %1033, label %974
1033: ; preds = %1026, %898
%1034 = call i32 @pvecnorm(i32* %1, double* %61, double* %18, double* %22)
%1035 = load double, double* %22
%1036 = fmul double %29, %1035
%1037 = call i32 @cos(double %1036)
%1038 = sitofp i32 %1037 to double
%1039 = load double, double* %22
%1040 = fmul double %29, %1039
%1041 = call i32 @sin(double %1040)
%1042 = sitofp i32 %1041 to double
br i1 %71, label %1043, label %1170
1043: ; preds = %1033
%1044 = load double, double* %22
br i1 %286, label %1096, label %1045
1045: ; preds = %1043
%1046 = insertelement <2 x double> poison, double %1044, i64 0
%1047 = shufflevector <2 x double> %1046, <2 x double> poison, <2 x i32> zeroinitializer
%1048 = insertelement <2 x double> poison, double %1042, i64 0
%1049 = shufflevector <2 x double> %1048, <2 x double> poison, <2 x i32> zeroinitializer
%1050 = insertelement <2 x double> poison, double %1038, i64 0
%1051 = shufflevector <2 x double> %1050, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %289, label %1081, label %1052
1052: ; preds = %1045, %1052
%1053 = phi i64 [ %1078, %1052 ], [ 0, %1045 ]
%1054 = phi i64 [ %1079, %1052 ], [ 0, %1045 ]
%1055 = getelementptr inbounds double, double* %62, i64 %1053
%1056 = bitcast double* %1055 to <2 x double>*
%1057 = load <2 x double>, <2 x double>* %1056
%1058 = getelementptr inbounds double, double* %61, i64 %1053
%1059 = bitcast double* %1058 to <2 x double>*
%1060 = load <2 x double>, <2 x double>* %1059
%1061 = fdiv <2 x double> %1060, %1047
%1062 = fmul <2 x double> %1061, %1049
%1063 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1051, <2 x double> %1057, <2 x double> %1062)
%1064 = getelementptr inbounds double, double* %63, i64 %1053
%1065 = bitcast double* %1064 to <2 x double>*
store <2 x double> %1063, <2 x double>* %1065
%1066 = or i64 %1053, 2
%1067 = getelementptr inbounds double, double* %62, i64 %1066
%1068 = bitcast double* %1067 to <2 x double>*
%1069 = load <2 x double>, <2 x double>* %1068
%1070 = getelementptr inbounds double, double* %61, i64 %1066
%1071 = bitcast double* %1070 to <2 x double>*
%1072 = load <2 x double>, <2 x double>* %1071
%1073 = fdiv <2 x double> %1072, %1047
%1074 = fmul <2 x double> %1073, %1049
%1075 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1051, <2 x double> %1069, <2 x double> %1074)
%1076 = getelementptr inbounds double, double* %63, i64 %1066
%1077 = bitcast double* %1076 to <2 x double>*
store <2 x double> %1075, <2 x double>* %1077
%1078 = add nuw i64 %1053, 4
%1079 = add nuw i64 %1054, 2
%1080 = icmp eq i64 %1079, %290
br i1 %1080, label %1081, label %1052
1081: ; preds = %1052, %1045
%1082 = phi i64 [ 0, %1045 ], [ %1078, %1052 ]
br i1 %291, label %1095, label %1083
1083: ; preds = %1081
%1084 = getelementptr inbounds double, double* %62, i64 %1082
%1085 = bitcast double* %1084 to <2 x double>*
%1086 = load <2 x double>, <2 x double>* %1085
%1087 = getelementptr inbounds double, double* %61, i64 %1082
%1088 = bitcast double* %1087 to <2 x double>*
%1089 = load <2 x double>, <2 x double>* %1088
%1090 = fdiv <2 x double> %1089, %1047
%1091 = fmul <2 x double> %1090, %1049
%1092 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1051, <2 x double> %1086, <2 x double> %1091)
%1093 = getelementptr inbounds double, double* %63, i64 %1082
%1094 = bitcast double* %1093 to <2 x double>*
store <2 x double> %1092, <2 x double>* %1094
br label %1095
1095: ; preds = %1081, %1083
br i1 %292, label %1098, label %1096
1096: ; preds = %1043, %1095
%1097 = phi i64 [ 0, %1043 ], [ %287, %1095 ]
br label %1150
1098: ; preds = %1150, %1095
br i1 %71, label %1099, label %1170
1099: ; preds = %1098
br i1 %293, label %1148, label %1100
1100: ; preds = %1099
br i1 %296, label %1132, label %1101
1101: ; preds = %1100, %1101
%1102 = phi i64 [ %1129, %1101 ], [ 0, %1100 ]
%1103 = phi i64 [ %1130, %1101 ], [ 0, %1100 ]
%1104 = getelementptr inbounds double, double* %63, i64 %1102
%1105 = bitcast double* %1104 to <2 x double>*
%1106 = load <2 x double>, <2 x double>* %1105
%1107 = getelementptr inbounds double, double* %1104, i64 2
%1108 = bitcast double* %1107 to <2 x double>*
%1109 = load <2 x double>, <2 x double>* %1108
%1110 = fmul <2 x double> %1106, %1106
%1111 = fmul <2 x double> %1109, %1109
%1112 = getelementptr inbounds double, double* %60, i64 %1102
%1113 = bitcast double* %1112 to <2 x double>*
store <2 x double> %1110, <2 x double>* %1113
%1114 = getelementptr inbounds double, double* %1112, i64 2
%1115 = bitcast double* %1114 to <2 x double>*
store <2 x double> %1111, <2 x double>* %1115
%1116 = or i64 %1102, 4
%1117 = getelementptr inbounds double, double* %63, i64 %1116
%1118 = bitcast double* %1117 to <2 x double>*
%1119 = load <2 x double>, <2 x double>* %1118
%1120 = getelementptr inbounds double, double* %1117, i64 2
%1121 = bitcast double* %1120 to <2 x double>*
%1122 = load <2 x double>, <2 x double>* %1121
%1123 = fmul <2 x double> %1119, %1119
%1124 = fmul <2 x double> %1122, %1122
%1125 = getelementptr inbounds double, double* %60, i64 %1116
%1126 = bitcast double* %1125 to <2 x double>*
store <2 x double> %1123, <2 x double>* %1126
%1127 = getelementptr inbounds double, double* %1125, i64 2
%1128 = bitcast double* %1127 to <2 x double>*
store <2 x double> %1124, <2 x double>* %1128
%1129 = add nuw i64 %1102, 8
%1130 = add i64 %1103, 2
%1131 = icmp eq i64 %1130, %297
br i1 %1131, label %1132, label %1101
1132: ; preds = %1101, %1100
%1133 = phi i64 [ 0, %1100 ], [ %1129, %1101 ]
br i1 %298, label %1147, label %1134
1134: ; preds = %1132
%1135 = getelementptr inbounds double, double* %63, i64 %1133
%1136 = bitcast double* %1135 to <2 x double>*
%1137 = load <2 x double>, <2 x double>* %1136
%1138 = getelementptr inbounds double, double* %1135, i64 2
%1139 = bitcast double* %1138 to <2 x double>*
%1140 = load <2 x double>, <2 x double>* %1139
%1141 = fmul <2 x double> %1137, %1137
%1142 = fmul <2 x double> %1140, %1140
%1143 = getelementptr inbounds double, double* %60, i64 %1133
%1144 = bitcast double* %1143 to <2 x double>*
store <2 x double> %1141, <2 x double>* %1144
%1145 = getelementptr inbounds double, double* %1143, i64 2
%1146 = bitcast double* %1145 to <2 x double>*
store <2 x double> %1142, <2 x double>* %1146
br label %1147
1147: ; preds = %1132, %1134
br i1 %299, label %1172, label %1148
1148: ; preds = %1099, %1147
%1149 = phi i64 [ 0, %1099 ], [ %294, %1147 ]
br label %1162
1150: ; preds = %1096, %1150
%1151 = phi i64 [ %1160, %1150 ], [ %1097, %1096 ]
%1152 = getelementptr inbounds double, double* %62, i64 %1151
%1153 = load double, double* %1152
%1154 = getelementptr inbounds double, double* %61, i64 %1151
%1155 = load double, double* %1154
%1156 = fdiv double %1155, %1044
%1157 = fmul double %1156, %1042
%1158 = call double @llvm.fmuladd.f64(double %1038, double %1153, double %1157)
%1159 = getelementptr inbounds double, double* %63, i64 %1151
store double %1158, double* %1159
%1160 = add nuw nsw i64 %1151, 1
%1161 = icmp eq i64 %1160, %32
br i1 %1161, label %1098, label %1150
1162: ; preds = %1148, %1162
%1163 = phi i64 [ %1168, %1162 ], [ %1149, %1148 ]
%1164 = getelementptr inbounds double, double* %63, i64 %1163
%1165 = load double, double* %1164
%1166 = fmul double %1165, %1165
%1167 = getelementptr inbounds double, double* %60, i64 %1163
store double %1166, double* %1167
%1168 = add nuw nsw i64 %1163, 1
%1169 = icmp eq i64 %1168, %32
br i1 %1169, label %1172, label %1162
1170: ; preds = %1098, %1033
%1171 = call i32 @cumtrapz(i32* %1, double* %34, double* %60, double* %66)
br label %1206
1172: ; preds = %1162, %1147
%1173 = call i32 @cumtrapz(i32* %1, double* %34, double* %60, double* %66)
br i1 %71, label %1174, label %1206
1174: ; preds = %1172
br i1 %301, label %1196, label %1175
1175: ; preds = %1174, %1175
%1176 = phi i64 [ %1193, %1175 ], [ 0, %1174 ]
%1177 = phi i64 [ %1194, %1175 ], [ 0, %1174 ]
%1178 = getelementptr inbounds double, double* %66, i64 %1176
%1179 = load double, double* %1178
%1180 = load double, double* %66
%1181 = fsub double %1179, %1180
%1182 = load double, double* %220
%1183 = fsub double %1182, %1180
%1184 = fdiv double %1181, %1183
store double %1184, double* %1178
%1185 = or i64 %1176, 1
%1186 = getelementptr inbounds double, double* %66, i64 %1185
%1187 = load double, double* %1186
%1188 = load double, double* %66
%1189 = fsub double %1187, %1188
%1190 = load double, double* %220
%1191 = fsub double %1190, %1188
%1192 = fdiv double %1189, %1191
store double %1192, double* %1186
%1193 = add nuw nsw i64 %1176, 2
%1194 = add i64 %1177, 2
%1195 = icmp eq i64 %1194, %302
br i1 %1195, label %1196, label %1175
1196: ; preds = %1175, %1174
%1197 = phi i64 [ 0, %1174 ], [ %1193, %1175 ]
br i1 %303, label %1206, label %1198
1198: ; preds = %1196
%1199 = getelementptr inbounds double, double* %66, i64 %1197
%1200 = load double, double* %1199
%1201 = load double, double* %66
%1202 = fsub double %1200, %1201
%1203 = load double, double* %220
%1204 = fsub double %1203, %1201
%1205 = fdiv double %1202, %1204
store double %1205, double* %1199
br label %1206
1206: ; preds = %1198, %1196, %1170, %1172
%1207 = call i32 @approx(double* %34, double* %311, i32 %23, double* %66, double* %64, i32 %23, i32 1, i32 0, i32 1, i32 0)
br i1 %207, label %1208, label %1249
1208: ; preds = %1206
br i1 %305, label %1235, label %1209
1209: ; preds = %1208, %1209
%1210 = phi i64 [ %1232, %1209 ], [ 0, %1208 ]
%1211 = phi double [ %1231, %1209 ], [ 0.000000e+00, %1208 ]
%1212 = phi i64 [ %1233, %1209 ], [ 0, %1208 ]
%1213 = getelementptr inbounds i32, i32* %6, i64 %1210
%1214 = load i32, i32* %1213
%1215 = sitofp i32 %1214 to double
%1216 = getelementptr inbounds double, double* %3, i64 %1210
%1217 = load double, double* %1216
%1218 = getelementptr inbounds double, double* %36, i64 %1210
%1219 = load double, double* %1218
%1220 = fadd double %1217, %1219
%1221 = call double @llvm.fmuladd.f64(double %1215, double %1220, double %1211)
%1222 = or i64 %1210, 1
%1223 = getelementptr inbounds i32, i32* %6, i64 %1222
%1224 = load i32, i32* %1223
%1225 = sitofp i32 %1224 to double
%1226 = getelementptr inbounds double, double* %3, i64 %1222
%1227 = load double, double* %1226
%1228 = getelementptr inbounds double, double* %36, i64 %1222
%1229 = load double, double* %1228
%1230 = fadd double %1227, %1229
%1231 = call double @llvm.fmuladd.f64(double %1225, double %1230, double %1221)
%1232 = add nuw nsw i64 %1210, 2
%1233 = add i64 %1212, 2
%1234 = icmp eq i64 %1233, %306
br i1 %1234, label %1235, label %1209
1235: ; preds = %1209, %1208
%1236 = phi double [ undef, %1208 ], [ %1231, %1209 ]
%1237 = phi i64 [ 0, %1208 ], [ %1232, %1209 ]
%1238 = phi double [ 0.000000e+00, %1208 ], [ %1231, %1209 ]
br i1 %307, label %1249, label %1239
1239: ; preds = %1235
%1240 = getelementptr inbounds i32, i32* %6, i64 %1237
%1241 = load i32, i32* %1240
%1242 = sitofp i32 %1241 to double
%1243 = getelementptr inbounds double, double* %3, i64 %1237
%1244 = load double, double* %1243
%1245 = getelementptr inbounds double, double* %36, i64 %1237
%1246 = load double, double* %1245
%1247 = fadd double %1244, %1246
%1248 = call double @llvm.fmuladd.f64(double %1242, double %1247, double %1238)
br label %1249
1249: ; preds = %1239, %1235, %1206
%1250 = phi double [ 0.000000e+00, %1206 ], [ %1236, %1235 ], [ %1248, %1239 ]
%1251 = call double @log(double %484)
br i1 %221, label %1254, label %1252
1252: ; preds = %1249
%1253 = add nuw nsw i32 %310, 1
br label %1258
1254: ; preds = %1249
%1255 = fsub double %1250, %1251
%1256 = add nuw nsw i32 %310, 1
%1257 = call i32 @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str, i64 0, i64 0), i32 %1256, double %1255)
br label %1258
1258: ; preds = %1252, %1254
%1259 = phi i32 [ %1253, %1252 ], [ %1256, %1254 ]
%1260 = load double, double* %213
%1261 = call i32 @product(i32 %25, i32 %25, i32 %23, double* %213, double* %5, double* %47)
%1262 = call i32 @group_action_by_gamma(i32* %0, i32* %1, double* %47, double* %64, double* %44)
%1263 = icmp ult i32 %310, 2
%1264 = fcmp uge double %486, %27
%1265 = select i1 %1263, i1 true, i1 %1264
%1266 = load double, double* %22
%1267 = fcmp uge double %1266, %27
%1268 = select i1 %1265, i1 true, i1 %1267
%1269 = icmp sgt i32 %26, %310
%1270 = select i1 %1268, i1 %1269, i1 false
br i1 %1270, label %308, label %1271
1271: ; preds = %1258
br i1 %71, label %1272, label %1273
1272: ; preds = %1271
br label %1273
1273: ; preds = %1272, %1271
%1274 = mul i32 %25, %25
%1275 = icmp eq i32 %1274, 0
br i1 %1275, label %1279, label %1276
1276: ; preds = %1273
%1277 = zext i32 %1274 to i64
%1278 = shl nuw nsw i64 %1277, 3
br label %1279
1279: ; preds = %1276, %1273
ret void
}