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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double DBL_EPSILON;
double acos(double);
double cos(int);
int /*<<< orphan*/ cumtrapz(int *, double *, double *, double *);
double fabs(double);
int /*<<< orphan*/ free(double *);
int /*<<< orphan*/ gradient(int *, int *, double *, double *, double *);
int /*<<< orphan*/ invertGamma(int, double *, double *);
double *malloc(int);
double sin(int);
double sqrt(double);
int /*<<< orphan*/ trapz(int *, int *, double *, double *, double *);
void SqrtMeanInverse(int *T1, int *n1, double *ti, double *gami, double *out) {
  int T = *T1, n = *n1;
  double psi[T * n], gam[T * n], mu[T], vec[T * n], v[T], y[T], tmpi, len,
      vm[T], mnpsi[T], dqq[n];
  double eps = DBL_EPSILON, tmpv[T], min = 0.0, binsize, tmp, gam_mu[T];
  int k, iter, l, n2 = 1, min_ind = 0;
  int maxiter = 30, tt = 1;
  double lvm[maxiter];
  double *x = malloc(sizeof(double) * (T));
  for (k = 0; k < maxiter; k++)
    lvm[k] = 0;
  for (k = 0; k < T; k++)
    gam_mu[k] = 0;
  for (k = 0; k < T; k++)
    x[k] = (double)k / ((double)(T - 1));
  double *psi_ptr, *gam_ptr, *tmp1_ptr, *y_ptr, *gam_mu_ptr;
  binsize = 0;
  for (k = 0; k < T - 1; k++)
    binsize += ti[k + 1] - ti[k];
  binsize = binsize / (T - 1);
  for (k = 0; k < T * n; k++) {
    gam[k] = gami[k];
  }
  psi_ptr = psi;
  gam_ptr = gam;
  gradient(&T, &n, gam_ptr, &binsize, psi_ptr);
  for (k = 0; k < T * n; k++)
    psi[k] = sqrt(fabs(psi[k]) + eps);
  for (k = 0; k < T; k++) {
    tmp = 0;
    for (l = 0; l < n; l++)
      tmp += psi[k + l * T];
    mnpsi[k] = tmp / n;
  }
  for (k = 0; k < n; k++) {
    for (l = 0; l < T; l++)
      tmpv[l] = psi[k * T + l] - mnpsi[l];
    tmp = 0;
    for (l = 0; l < T; l++)
      tmp += tmpv[l];
    dqq[k] = tmp;
  }
  for (k = 0; k < n; k++) {
    if (k == 0) {
      min_ind = 0;
      min = dqq[k];
    } else {
      if (dqq[k] < min) {
        min = dqq[k];
        min_ind = k;
      }
    }
  }
  for (k = 0; k < T; k++)
    mu[k] = psi[(min_ind - 1) * T + k];
  for (iter = 1; iter < maxiter; iter++) {
    for (k = 0; k < n; k++) {
      for (l = 0; l < T; l++)
        v[l] = psi[k * T + l] - mu[l];
      for (l = 0; l < T; l++)
        y[l] = psi[k * T + l] * mu[l];
      y_ptr = y;
      trapz(T1, &n2, ti, y_ptr, &tmpi);
      if (tmpi > 1) {
        tmpi = 1;
      } else if (tmpi < (-1)) {
        tmpi = 1;
      }
      len = acos(tmpi);
      if (len > 0.0001) {
        for (l = 0; l < T; l++)
          vec[k * T + l] =
              (len / sin(len)) * (psi[k * T + l] - cos(len) * mu[l]);
      } else {
        for (l = 0; l < T; l++)
          vec[k * T + l] = 0;
      }
    }
    for (k = 0; k < T; k++) {
      tmp = 0;
      for (l = 0; l < n; l++) {
        tmp += vec[k + l * T];
      }
      vm[k] = tmp / n;
    }
    for (k = 0; k < T; k++)
      tmpv[k] = vm[k] * vm[k];
    tmp = 0;
    for (k = 0; k < T; k++)
      tmp += tmpv[k];
    lvm[iter] = sqrt(tmp * binsize);
    if (lvm[iter] == 0) {
      break;
    }
    for (k = 0; k < T; k++)
      mu[k] = cos(tt * lvm[iter]) * mu[k] +
              (sin(tt * lvm[iter]) / lvm[iter]) * vm[k];
    if (lvm[iter] < 1e-6 || iter >= maxiter)
      break;
  }
  for (k = 0; k < T; k++)
    tmpv[k] = mu[k] * mu[k];
  tmp1_ptr = tmpv;
  gam_mu_ptr = gam_mu;
  cumtrapz(T1, ti, tmp1_ptr, gam_mu_ptr);
  for (k = 0; k < T; k++)
    gam_mu_ptr[k] =
        (gam_mu_ptr[k] - gam_mu_ptr[0]) / (gam_mu_ptr[T - 1] - gam_mu_ptr[0]);
  invertGamma(T, gam_mu_ptr, out);
  free(x);
  return;
}


x86 assembly (clang, -O0):
<SqrtMeanInverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1a0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
imul   %ecx,%eax
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x178(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
imul   %ecx,%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x170(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x168(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%ecx
imul   %ecx,%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x160(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x158(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x150(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x148(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x80(%rbp)
mov    -0x2c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x140(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x88(%rbp)
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x138(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x90(%rbp)
mov    0x3cb6(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x2c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x130(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xa0(%rbp)
movq   $0x0,-0xa8(%rbp)
mov    -0x2c(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x128(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xc0(%rbp)
movl   $0x1,-0xd0(%rbp)
movl   $0x0,-0xd4(%rbp)
movl   $0x1e,-0xd8(%rbp)
movl   $0x1,-0xdc(%rbp)
mov    -0xd8(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x120(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xe8(%rbp)
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1090 <malloc@plt>
mov    %rax,-0xf0(%rbp)
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jge    1442 <SqrtMeanInverse+0x2a2>
mov    -0x120(%rbp),%rax
movslq -0xc4(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1406 <SqrtMeanInverse+0x266>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1485 <SqrtMeanInverse+0x2e5>
mov    -0x128(%rbp),%rax
movslq -0xc4(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    144c <SqrtMeanInverse+0x2ac>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    14db <SqrtMeanInverse+0x33b>
cvtsi2sdl -0xc4(%rbp),%xmm0
ff
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
mov    -0xf0(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    148f <SqrtMeanInverse+0x2ef>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    154d <SqrtMeanInverse+0x3ad>
mov    -0x18(%rbp),%rax
mov    -0xc4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0xc4(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    14f0 <SqrtMeanInverse+0x350>
movsd  -0xb0(%rbp),%xmm0
ff
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
cmp    %ecx,%eax
jge    15c1 <SqrtMeanInverse+0x421>
mov    -0x170(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1575 <SqrtMeanInverse+0x3d5>
mov    -0x170(%rbp),%rax
mov    -0x178(%rbp),%rcx
mov    %rcx,-0xf8(%rbp)
mov    %rax,-0x100(%rbp)
mov    -0x100(%rbp),%rdx
mov    -0xf8(%rbp),%r8
lea    -0x2c(%rbp),%rdi
lea    -0x30(%rbp),%rsi
lea    -0xb0(%rbp),%rcx
call   1080 <gradient@plt>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x2c(%rbp),%ecx
imul   -0x30(%rbp),%ecx
cmp    %ecx,%eax
jge    1670 <SqrtMeanInverse+0x4d0>
mov    -0x178(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x19e8(%rip),%xmm1
pand   %xmm1,%xmm0
addsd  -0x98(%rbp),%xmm0
ff
call   10c0 <sqrt@plt>
mov    -0x178(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1609 <SqrtMeanInverse+0x469>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    172a <SqrtMeanInverse+0x58a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    16f2 <SqrtMeanInverse+0x552>
mov    -0x178(%rbp),%rax
mov    -0xc4(%rbp),%ecx
mov    -0xcc(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    169e <SqrtMeanInverse+0x4fe>
mov    -0x140(%rbp),%rax
movsd  -0xb8(%rbp),%xmm0
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    167a <SqrtMeanInverse+0x4da>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    183f <SqrtMeanInverse+0x69f>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    17b5 <SqrtMeanInverse+0x615>
mov    -0x130(%rbp),%rax
mov    -0x140(%rbp),%rcx
mov    -0x178(%rbp),%rdx
mov    -0xc4(%rbp),%esi
imul   -0x2c(%rbp),%esi
add    -0xcc(%rbp),%esi
movslq %esi,%rsi
movsd  (%rdx,%rsi,8),%xmm0
movslq -0xcc(%rbp),%rdx
subsd  (%rcx,%rdx,8),%xmm0
movslq -0xcc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    174d <SqrtMeanInverse+0x5ad>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1810 <SqrtMeanInverse+0x670>
mov    -0x130(%rbp),%rax
movslq -0xcc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    17ca <SqrtMeanInverse+0x62a>
mov    -0x138(%rbp),%rax
movsd  -0xb8(%rbp),%xmm0
ff
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1734 <SqrtMeanInverse+0x594>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    18f9 <SqrtMeanInverse+0x759>
cmpl   $0x0,-0xc4(%rbp)
jne    188f <SqrtMeanInverse+0x6ef>
mov    -0x138(%rbp),%rax
movl   $0x0,-0xd4(%rbp)
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    18e0 <SqrtMeanInverse+0x740>
mov    -0x138(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    18db <SqrtMeanInverse+0x73b>
mov    -0x138(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0xc4(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    18e0 <SqrtMeanInverse+0x740>
jmp    18e5 <SqrtMeanInverse+0x745>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1849 <SqrtMeanInverse+0x6a9>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    195b <SqrtMeanInverse+0x7bb>
mov    -0x168(%rbp),%rax
mov    -0x178(%rbp),%rcx
mov    -0xd4(%rbp),%edx
sub    $0x1,%edx
imul   -0x2c(%rbp),%edx
add    -0xc4(%rbp),%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1903 <SqrtMeanInverse+0x763>
movl   $0x1,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jge    1f78 <SqrtMeanInverse+0xdd8>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1c7b <SqrtMeanInverse+0xadb>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1a02 <SqrtMeanInverse+0x862>
mov    -0x158(%rbp),%rax
mov    -0x168(%rbp),%rcx
mov    -0x178(%rbp),%rdx
mov    -0xc4(%rbp),%esi
imul   -0x2c(%rbp),%esi
add    -0xcc(%rbp),%esi
movslq %esi,%rsi
movsd  (%rdx,%rsi,8),%xmm0
movslq -0xcc(%rbp),%rdx
subsd  (%rcx,%rdx,8),%xmm0
movslq -0xcc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    199a <SqrtMeanInverse+0x7fa>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1a74 <SqrtMeanInverse+0x8d4>
mov    -0x150(%rbp),%rax
mov    -0x168(%rbp),%rcx
mov    -0x178(%rbp),%rdx
mov    -0xc4(%rbp),%esi
imul   -0x2c(%rbp),%esi
add    -0xcc(%rbp),%esi
movslq %esi,%rsi
movsd  (%rdx,%rsi,8),%xmm0
movslq -0xcc(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movslq -0xcc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1a0c <SqrtMeanInverse+0x86c>
mov    -0x150(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rdx
mov    -0x110(%rbp),%rcx
lea    -0xd0(%rbp),%rsi
lea    -0x70(%rbp),%r8
call   1060 <trapz@plt>
movsd  -0x70(%rbp),%xmm0
movsd  0x155a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1aca <SqrtMeanInverse+0x92a>
movsd  0x1548(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1aef <SqrtMeanInverse+0x94f>
movsd  0x153e(%rip),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    1aea <SqrtMeanInverse+0x94a>
movsd  0x1523(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1aef <SqrtMeanInverse+0x94f>
movsd  -0x70(%rbp),%xmm0
call   1040 <acos@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
movsd  0x150d(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1c0e <SqrtMeanInverse+0xa6e>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1c09 <SqrtMeanInverse+0xa69>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
cvttsd2si -0x78(%rbp),%edi
call   1070 <sin@plt>
mov    -0x178(%rbp),%rax
movaps %xmm0,%xmm1
movsd  -0x190(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0xc4(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0xcc(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
cvttsd2si -0x78(%rbp),%edi
call   10a0 <cos@plt>
mov    -0x168(%rbp),%rcx
movsd  -0x188(%rbp),%xmm2
ff
mov    -0x160(%rbp),%rax
movaps %xmm0,%xmm1
movsd  -0x180(%rbp),%xmm0
ff
movslq -0xcc(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm3
movq   %xmm1,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0xc4(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0xcc(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1b1f <SqrtMeanInverse+0x97f>
jmp    1c62 <SqrtMeanInverse+0xac2>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1c5d <SqrtMeanInverse+0xabd>
mov    -0x160(%rbp),%rax
mov    -0xc4(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0xcc(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1c18 <SqrtMeanInverse+0xa78>
jmp    1c62 <SqrtMeanInverse+0xac2>
jmp    1c67 <SqrtMeanInverse+0xac7>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1981 <SqrtMeanInverse+0x7e1>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1d35 <SqrtMeanInverse+0xb95>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1cfd <SqrtMeanInverse+0xb5d>
mov    -0x160(%rbp),%rax
mov    -0xc4(%rbp),%ecx
mov    -0xcc(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1ca9 <SqrtMeanInverse+0xb09>
mov    -0x148(%rbp),%rax
movsd  -0xb8(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1c85 <SqrtMeanInverse+0xae5>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1d94 <SqrtMeanInverse+0xbf4>
mov    -0x130(%rbp),%rax
mov    -0x148(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0xc4(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1d3f <SqrtMeanInverse+0xb9f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1def <SqrtMeanInverse+0xc4f>
mov    -0x130(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1da9 <SqrtMeanInverse+0xc09>
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
call   10c0 <sqrt@plt>
mov    -0x120(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movslq -0xc8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1e3b <SqrtMeanInverse+0xc9b>
jp     1e3b <SqrtMeanInverse+0xc9b>
jmp    1f78 <SqrtMeanInverse+0xdd8>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1f27 <SqrtMeanInverse+0xd87>
mov    -0x120(%rbp),%rax
cvtsi2sdl -0xdc(%rbp),%xmm0
ff
movslq -0xc8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%edi
call   10a0 <cos@plt>
mov    -0x120(%rbp),%rax
mov    -0x168(%rbp),%rcx
movsd  %xmm0,-0x198(%rbp)
ff
movslq -0xc4(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
cvtsi2sdl -0xdc(%rbp),%xmm0
ff
movslq -0xc8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
cvttsd2si %xmm0,%edi
call   1070 <sin@plt>
mov    -0x120(%rbp),%rdx
mov    -0x148(%rbp),%rcx
movsd  -0x1a0(%rbp),%xmm2
ff
mov    -0x168(%rbp),%rax
movaps %xmm0,%xmm1
movsd  -0x198(%rbp),%xmm0
ff
movslq -0xc8(%rbp),%rsi
divsd  (%rdx,%rsi,8),%xmm1
movslq -0xc4(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1e45 <SqrtMeanInverse+0xca5>
mov    -0x120(%rbp),%rax
movslq -0xc8(%rbp),%rcx
movsd  0x10c3(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
ja     1f5a <SqrtMeanInverse+0xdba>
mov    -0xc8(%rbp),%eax
cmp    -0xd8(%rbp),%eax
jl     1f5f <SqrtMeanInverse+0xdbf>
jmp    1f78 <SqrtMeanInverse+0xdd8>
jmp    1f64 <SqrtMeanInverse+0xdc4>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    1965 <SqrtMeanInverse+0x7c5>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1fd7 <SqrtMeanInverse+0xe37>
mov    -0x130(%rbp),%rax
mov    -0x168(%rbp),%rcx
movslq -0xc4(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0xc4(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    1f82 <SqrtMeanInverse+0xde2>
mov    -0x128(%rbp),%rax
mov    -0x130(%rbp),%rcx
mov    %rcx,-0x108(%rbp)
mov    %rax,-0x118(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x108(%rbp),%rdx
mov    -0x118(%rbp),%rcx
call   1050 <cumtrapz@plt>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    2090 <SqrtMeanInverse+0xef0>
mov    -0x118(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x118(%rbp),%rax
subsd  (%rax),%xmm0
mov    -0x118(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x118(%rbp),%rax
subsd  (%rax),%xmm1
divsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    2018 <SqrtMeanInverse+0xe78>
mov    -0x2c(%rbp),%edi
mov    -0x118(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   10b0 <invertGamma@plt>
mov    -0xf0(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SqrtMeanInverse>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %r8,-0xd8(%rbp)
mov    %rcx,%rbx
mov    %rdx,-0x80(%rbp)
mov    %rsp,-0xd0(%rbp)
mov    %rdi,-0xb0(%rbp)
mov    (%rdi),%r15d
mov    %r15d,-0x2c(%rbp)
mov    (%rsi),%eax
mov    %eax,-0x4c(%rbp)
mov    %eax,%r13d
imul   %r15d,%r13d
lea    0xf(,%r13,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rsp
mov    %rsp,%r14
lea    0xf(,%r15,8),%rcx
and    $0xfffffffffffffff0,%rcx
sub    %rcx,%r14
mov    %r14,%rsp
mov    %rsp,%rsi
sub    %rdx,%rsi
mov    %rsi,-0x88(%rbp)
mov    %rsi,%rsp
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x100(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0xa8(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x48(%rbp)
mov    %rdx,%rsp
mov    %rsp,%rdx
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rdx
mov    %rdx,-0x68(%rbp)
mov    %rdx,%rsp
mov    0x3d4d(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    %rsp,%rax
sub    %rcx,%rax
mov    %rax,-0x70(%rbp)
mov    %rax,%rsp
mov    %rsp,%r12
sub    %rcx,%r12
mov    %r12,%rsp
movl   $0x1,-0x9c(%rbp)
lea    0x0(,%r15,8),%edi
call   10b0 <malloc@plt>
mov    %rax,-0x78(%rbp)
test   %r15d,%r15d
mov    %r12,-0xc8(%rbp)
jle    1318 <SqrtMeanInverse+0x158>
mov    %rbx,-0x60(%rbp)
lea    0x0(,%r15,8),%rdx
xor    %ebx,%ebx
mov    %r12,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
lea    -0x1(%r15),%r8d
xorps  %xmm0,%xmm0
cvtsi2sd %r8d,%xmm0
cmp    $0x1,%r15d
jne    132f <SqrtMeanInverse+0x16f>
mov    -0x80(%rbp),%rdi
mov    -0x78(%rbp),%rax
jmp    13d0 <SqrtMeanInverse+0x210>
mov    %rbx,%rsi
add    $0xffffffff,%r15d
xorpd  %xmm0,%xmm0
mov    %r15d,%r8d
mov    -0x38(%rbp),%rbx
jmp    14ae <SqrtMeanInverse+0x2ee>
mov    %r15d,%ebx
and    $0xfffffffe,%ebx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rbx),%rdx
mov    %rdx,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdx,%rdx
mov    -0x80(%rbp),%rdi
je     220c <SqrtMeanInverse+0x104c>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
movdqa 0x1c99(%rip),%xmm2
xor    %edx,%edx
movdqa 0x1c9f(%rip),%xmm3
movdqa 0x1ca7(%rip),%xmm4
mov    -0x78(%rbp),%rax
nopl   (%rax)
cvtdq2pd %xmm2,%xmm5
divpd  %xmm1,%xmm5
movupd %xmm5,(%rax,%rdx,8)
movdqa %xmm2,%xmm5
paddd  %xmm3,%xmm5
cvtdq2pd %xmm5,%xmm5
divpd  %xmm1,%xmm5
movupd %xmm5,0x10(%rax,%rdx,8)
add    $0x4,%rdx
paddd  %xmm4,%xmm2
add    $0xfffffffffffffffe,%rsi
jne    1380 <SqrtMeanInverse+0x1c0>
test   $0x1,%cl
je     13c3 <SqrtMeanInverse+0x203>
cvtdq2pd %xmm2,%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rax,%rdx,8)
cmp    %r15,%rbx
je     13e9 <SqrtMeanInverse+0x229>
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    13d0 <SqrtMeanInverse+0x210>
xorpd  %xmm0,%xmm0
cmp    $0x2,%r15d
jl     1419 <SqrtMeanInverse+0x259>
mov    %r8d,%edx
movsd  (%rdi),%xmm1
lea    -0x1(%rdx),%rsi
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x3,%rsi
mov    -0x60(%rbp),%rsi
mov    -0x38(%rbp),%rbx
jae    1426 <SqrtMeanInverse+0x266>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
jmp    1479 <SqrtMeanInverse+0x2b9>
mov    -0x60(%rbp),%rsi
mov    -0x38(%rbp),%rbx
jmp    14ae <SqrtMeanInverse+0x2ee>
and    $0xfffffffc,%edx
xorpd  %xmm0,%xmm0
xor    %eax,%eax
nop
movsd  0x8(%rdi,%rax,8),%xmm2
movsd  0x10(%rdi,%rax,8),%xmm3
movsd  0x18(%rdi,%rax,8),%xmm4
movapd %xmm4,%xmm5
subsd  %xmm3,%xmm5
subsd  %xmm2,%xmm3
subsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm5
movsd  0x20(%rdi,%rax,8),%xmm1
add    $0x4,%rax
movapd %xmm1,%xmm0
subsd  %xmm4,%xmm0
addsd  %xmm5,%xmm0
cmp    %rax,%rdx
jne    1430 <SqrtMeanInverse+0x270>
test   %rcx,%rcx
je     14ae <SqrtMeanInverse+0x2ee>
lea    (%rdi,%rax,8),%rdx
add    $0x8,%rdx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm2
movapd %xmm2,%xmm3
subsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
add    $0x1,%rax
movapd %xmm2,%xmm1
cmp    %rax,%rcx
jne    1490 <SqrtMeanInverse+0x2d0>
xorps  %xmm1,%xmm1
cvtsi2sd %r8d,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
test   %r13d,%r13d
jle    14d6 <SqrtMeanInverse+0x316>
shl    $0x3,%r13
mov    %rbx,%rdi
mov    %r13,%rdx
call   1090 <memcpy@plt>
lea    -0x2c(%rbp),%rdi
lea    -0x4c(%rbp),%rsi
lea    -0xb8(%rbp),%rcx
mov    %rbx,%rdx
mov    -0x58(%rbp),%rbx
mov    %rbx,%r8
call   10a0 <gradient@plt>
mov    -0x2c(%rbp),%edx
mov    -0x4c(%rbp),%esi
mov    %esi,%eax
imul   %edx,%eax
test   %eax,%eax
mov    -0xa8(%rbp),%r13
jle    156a <SqrtMeanInverse+0x3aa>
mov    %rbx,%rcx
xor    %ebx,%ebx
movapd 0x1b19(%rip),%xmm1
pxor   %xmm2,%xmm2
jmp    1550 <SqrtMeanInverse+0x390>
nopl   (%rax)
call   10e0 <sqrt@plt>
xorpd  %xmm2,%xmm2
movapd 0x1aff(%rip),%xmm1
mov    -0x58(%rbp),%rcx
movsd  %xmm0,(%rcx,%rbx,8)
add    $0x1,%rbx
mov    -0x2c(%rbp),%edx
mov    -0x4c(%rbp),%esi
mov    %esi,%eax
imul   %edx,%eax
cltq
cmp    %rax,%rbx
jge    156a <SqrtMeanInverse+0x3aa>
movsd  (%rcx,%rbx,8),%xmm0
andpd  %xmm1,%xmm0
addsd  -0x40(%rbp),%xmm0
ucomisd %xmm2,%xmm0
jb     1520 <SqrtMeanInverse+0x360>
sqrtsd %xmm0,%xmm0
jmp    1535 <SqrtMeanInverse+0x375>
mov    %edx,%r9d
mov    %esi,-0x40(%rbp)
mov    %esi,%eax
mov    %rax,-0x60(%rbp)
mov    %rdx,-0x38(%rbp)
test   %edx,%edx
jle    1672 <SqrtMeanInverse+0x4b2>
xorps  %xmm0,%xmm0
cvtsi2sdl -0x40(%rbp),%xmm0
mov    -0x60(%rbp),%r10
lea    -0x1(%r10),%rax
mov    %rax,-0x90(%rbp)
mov    %r10d,%r8d
and    $0x3,%r8d
and    $0xfffffffc,%r10d
mov    %r9,%rdx
shl    $0x4,%rdx
mov    %r9,%rcx
shl    $0x5,%rcx
lea    0x0(,%r9,8),%rsi
lea    (%rsi,%rsi,2),%rdi
xor    %r12d,%r12d
mov    -0x58(%rbp),%r11
jmp    15f3 <SqrtMeanInverse+0x433>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
divsd  %xmm0,%xmm1
mov    -0x48(%rbp),%rax
movsd  %xmm1,(%rax,%r12,8)
add    $0x1,%r12
add    $0x8,%r11
cmp    %r9,%r12
je     1672 <SqrtMeanInverse+0x4b2>
cmpl   $0x0,-0x40(%rbp)
jle    15d0 <SqrtMeanInverse+0x410>
cmpq   $0x3,-0x90(%rbp)
jae    1610 <SqrtMeanInverse+0x450>
xorpd  %xmm1,%xmm1
xor    %r15d,%r15d
jmp    1640 <SqrtMeanInverse+0x480>
nopl   0x0(%rax)
xorpd  %xmm1,%xmm1
mov    %r11,%rbx
xor    %r15d,%r15d
nopw   0x0(%rax,%rax,1)
addsd  (%rbx),%xmm1
addsd  (%rbx,%r9,8),%xmm1
addsd  (%rbx,%rdx,1),%xmm1
addsd  (%rbx,%rdi,1),%xmm1
add    $0x4,%r15
add    %rcx,%rbx
cmp    %r15,%r10
jne    1620 <SqrtMeanInverse+0x460>
test   %r8,%r8
je     15d4 <SqrtMeanInverse+0x414>
imul   %r9,%r15
add    %r12,%r15
mov    -0x58(%rbp),%rax
lea    (%rax,%r15,8),%rbx
mov    %r8,%rax
nopw   0x0(%rax,%rax,1)
addsd  (%rbx),%xmm1
add    %rsi,%rbx
add    $0xffffffffffffffff,%rax
jne    1660 <SqrtMeanInverse+0x4a0>
jmp    15d4 <SqrtMeanInverse+0x414>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    -0x40(%rbp),%ebx
test   %ebx,%ebx
jle    1912 <SqrtMeanInverse+0x752>
mov    %r14,-0xc0(%rbp)
mov    -0x38(%rbp),%rsi
movslq %esi,%rdx
mov    %r9d,%r14d
and    $0xfffffffc,%r14d
lea    -0x4(%r14),%rcx
mov    %rcx,-0xf8(%rbp)
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
lea    -0x1(%r9),%rcx
mov    %rcx,-0x90(%rbp)
mov    %rdi,%rcx
mov    %rdi,-0xf0(%rbp)
and    %rax,%rdi
mov    %rdi,-0xe8(%rbp)
mov    %r9d,%ecx
and    $0x7,%ecx
mov    %r9d,%edi
and    $0xfffffff8,%edi
mov    -0x58(%rbp),%r11
lea    0x30(%r11),%r8
mov    %rdx,-0xe0(%rbp)
lea    0x0(,%rdx,8),%r10
xor    %edx,%edx
mov    -0x70(%rbp),%r12
mov    -0x48(%rbp),%r15
jmp    171d <SqrtMeanInverse+0x55d>
mov    -0x68(%rbp),%rax
movsd  %xmm0,(%rax,%rdx,8)
add    $0x1,%rdx
add    %r10,%r8
add    %r10,%r11
cmp    -0x60(%rbp),%rdx
je     18c7 <SqrtMeanInverse+0x707>
xorpd  %xmm0,%xmm0
test   %esi,%esi
jle    1700 <SqrtMeanInverse+0x540>
cmp    $0x4,%esi
jae    1740 <SqrtMeanInverse+0x580>
xor    %eax,%eax
mov    -0x48(%rbp),%rbx
jmp    1810 <SqrtMeanInverse+0x650>
cs nopw 0x0(%rax,%rax,1)
nop
cmpq   $0x0,-0xf8(%rbp)
je     18b3 <SqrtMeanInverse+0x6f3>
mov    -0xe8(%rbp),%rax
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movupd -0x30(%r8,%rbx,8),%xmm1
movupd -0x20(%r8,%rbx,8),%xmm2
subpd  (%r15,%rbx,8),%xmm1
subpd  0x10(%r15,%rbx,8),%xmm2
movapd %xmm1,(%r12,%rbx,8)
movapd %xmm2,0x10(%r12,%rbx,8)
movupd -0x10(%r8,%rbx,8),%xmm1
movupd (%r8,%rbx,8),%xmm2
subpd  0x20(%r15,%rbx,8),%xmm1
subpd  0x30(%r15,%rbx,8),%xmm2
movapd %xmm1,0x20(%r12,%rbx,8)
movapd %xmm2,0x30(%r12,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    1760 <SqrtMeanInverse+0x5a0>
testb  $0x1,-0xf0(%rbp)
je     1801 <SqrtMeanInverse+0x641>
mov    %rdx,%rax
imul   -0xe0(%rbp),%rax
ff
add    %rbx,%rax
mov    -0x58(%rbp),%rsi
movupd (%rsi,%rax,8),%xmm1
movupd 0x10(%rsi,%rax,8),%xmm2
mov    -0x38(%rbp),%rsi
mov    -0x48(%rbp),%rax
subpd  (%rax,%rbx,8),%xmm1
subpd  0x10(%rax,%rbx,8),%xmm2
movapd %xmm1,(%r12,%rbx,8)
movapd %xmm2,0x10(%r12,%rbx,8)
mov    %r14,%rax
cmp    %r9,%r14
mov    -0x48(%rbp),%rbx
je     182a <SqrtMeanInverse+0x66a>
nopl   (%rax)
movsd  (%r11,%rax,8),%xmm1
subsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    1810 <SqrtMeanInverse+0x650>
test   %esi,%esi
jle    1700 <SqrtMeanInverse+0x540>
cmpq   $0x7,-0x90(%rbp)
07
jae    1844 <SqrtMeanInverse+0x684>
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
jmp    1890 <SqrtMeanInverse+0x6d0>
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
addsd  (%r12,%rbx,8),%xmm0
addsd  0x8(%r12,%rbx,8),%xmm0
addsd  0x10(%r12,%rbx,8),%xmm0
addsd  0x18(%r12,%rbx,8),%xmm0
addsd  0x20(%r12,%rbx,8),%xmm0
addsd  0x28(%r12,%rbx,8),%xmm0
addsd  0x30(%r12,%rbx,8),%xmm0
addsd  0x38(%r12,%rbx,8),%xmm0
add    $0x8,%rbx
cmp    %rbx,%rdi
jne    1850 <SqrtMeanInverse+0x690>
test   %rcx,%rcx
je     1700 <SqrtMeanInverse+0x540>
lea    (%r12,%rbx,8),%rax
xor    %ebx,%ebx
nop
addsd  (%rax,%rbx,8),%xmm0
add    $0x1,%rbx
cmp    %rbx,%rcx
jne    18a0 <SqrtMeanInverse+0x6e0>
jmp    1700 <SqrtMeanInverse+0x540>
xor    %ebx,%ebx
testb  $0x1,-0xf0(%rbp)
jne    17c4 <SqrtMeanInverse+0x604>
jmp    1801 <SqrtMeanInverse+0x641>
xor    %ecx,%ecx
mov    -0x40(%rbp),%ebx
test   %ebx,%ebx
mov    -0xc0(%rbp),%r14
jle    19bf <SqrtMeanInverse+0x7ff>
cmp    $0x1,%ebx
mov    -0x68(%rbp),%r10
je     19bf <SqrtMeanInverse+0x7ff>
movsd  (%r10),%xmm0
mov    -0x60(%rbp),%rax
lea    -0x1(%rax),%r8
add    $0xfffffffffffffffe,%rax
mov    %r8d,%r11d
and    $0x3,%r11d
cmp    $0x3,%rax
jae    191d <SqrtMeanInverse+0x75d>
xor    %ecx,%ecx
mov    $0x1,%eax
jmp    198d <SqrtMeanInverse+0x7cd>
xor    %ecx,%ecx
mov    -0x70(%rbp),%r12
jmp    19bf <SqrtMeanInverse+0x7ff>
and    $0xfffffffffffffffc,%r8
xor    %ecx,%ecx
mov    $0x1,%eax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%r10,%rax,8),%xmm1
ucomisd %xmm1,%xmm0
cmova  %eax,%ecx
movsd  0x8(%r10,%rax,8),%xmm2
minsd  %xmm0,%xmm1
ucomisd %xmm2,%xmm1
lea    0x1(%rax),%edx
cmovbe %ecx,%edx
minsd  %xmm1,%xmm2
movsd  0x10(%r10,%rax,8),%xmm1
ucomisd %xmm1,%xmm2
lea    0x2(%rax),%edi
cmovbe %edx,%edi
minsd  %xmm2,%xmm1
movsd  0x18(%r10,%rax,8),%xmm0
ucomisd %xmm0,%xmm1
lea    0x3(%rax),%ecx
cmovbe %edi,%ecx
minsd  %xmm1,%xmm0
add    $0x4,%rax
add    $0x4,%rsi
cmp    %r8,%rsi
jne    1930 <SqrtMeanInverse+0x770>
test   %r11,%r11
je     19bf <SqrtMeanInverse+0x7ff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r10,%rax,8),%xmm1
ucomisd %xmm1,%xmm0
cmova  %eax,%ecx
minsd  %xmm0,%xmm1
add    $0x1,%rax
movapd %xmm1,%xmm0
add    $0xffffffffffffffff,%r11
jne    19a0 <SqrtMeanInverse+0x7e0>
mov    -0x38(%rbp),%rsi
test   %esi,%esi
mov    -0x58(%rbp),%r15
jle    19ee <SqrtMeanInverse+0x82e>
add    $0xffffffff,%ecx
imul   %esi,%ecx
movslq %ecx,%rax
lea    (%r15,%rax,8),%rsi
shl    $0x3,%r9
mov    %r14,%rdi
mov    %r9,%rdx
call   1090 <memcpy@plt>
mov    -0x40(%rbp),%ebx
mov    -0x38(%rbp),%rsi
lea    0x30(%r15),%rax
mov    %rax,-0x60(%rbp)
movl   $0x1,-0x68(%rbp)
test   %ebx,%ebx
jle    1cc0 <SqrtMeanInverse+0xb00>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %r13d,%r13d
jmp    1a3b <SqrtMeanInverse+0x87b>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13d
mov    -0x4c(%rbp),%ebx
cmp    %ebx,%r13d
mov    -0x70(%rbp),%r12
mov    -0xa8(%rbp),%rax
jge    1cc3 <SqrtMeanInverse+0xb03>
test   %esi,%esi
mov    -0x100(%rbp),%rcx
jle    1b69 <SqrtMeanInverse+0x9a9>
mov    %esi,%eax
imul   %r13d,%eax
movslq %eax,%r8
mov    %esi,%ebx
cmp    $0x4,%esi
jae    1a70 <SqrtMeanInverse+0x8b0>
xor    %eax,%eax
jmp    1b39 <SqrtMeanInverse+0x979>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebx,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1ca5 <SqrtMeanInverse+0xae5>
mov    %r9,%rsi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rsi
mov    -0x60(%rbp),%rdx
lea    (%rdx,%r8,8),%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rdi,8),%xmm0
movupd -0x20(%rdx,%rdi,8),%xmm1
mulpd  (%r14,%rdi,8),%xmm0
mulpd  0x10(%r14,%rdi,8),%xmm1
movapd %xmm0,(%rcx,%rdi,8)
movapd %xmm1,0x10(%rcx,%rdi,8)
movupd -0x10(%rdx,%rdi,8),%xmm0
movupd (%rdx,%rdi,8),%xmm1
mulpd  0x20(%r14,%rdi,8),%xmm0
mulpd  0x30(%r14,%rdi,8),%xmm1
movapd %xmm0,0x20(%rcx,%rdi,8)
movapd %xmm1,0x30(%rcx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1ab0 <SqrtMeanInverse+0x8f0>
test   $0x1,%r9b
je     1b34 <SqrtMeanInverse+0x974>
lea    (%rdi,%r8,1),%rdx
mov    -0x58(%rbp),%rsi
movupd (%rsi,%rdx,8),%xmm0
movupd 0x10(%rsi,%rdx,8),%xmm1
mulpd  (%r14,%rdi,8),%xmm0
mulpd  0x10(%r14,%rdi,8),%xmm1
movapd %xmm0,(%rcx,%rdi,8)
movapd %xmm1,0x10(%rcx,%rdi,8)
cmp    %rbx,%rax
je     1b69 <SqrtMeanInverse+0x9a9>
mov    -0x58(%rbp),%rdx
lea    (%rdx,%r8,8),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rax,8),%xmm0
mulsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbx
jne    1b50 <SqrtMeanInverse+0x990>
mov    -0xb0(%rbp),%rdi
lea    -0x9c(%rbp),%rsi
mov    -0x80(%rbp),%rdx
lea    -0x98(%rbp),%r8
call   1070 <trapz@plt>
movsd  -0x98(%rbp),%xmm0
ff
movsd  0x14a9(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1bab <SqrtMeanInverse+0x9eb>
movsd  0x14a3(%rip),%xmm2
ucomisd %xmm0,%xmm2
jbe    1bc0 <SqrtMeanInverse+0xa00>
movabs $0x3ff0000000000000,%rax
mov    %rax,-0x98(%rbp)
movapd %xmm1,%xmm0
call   1040 <acos@plt>
ucomisd 0x1483(%rip),%xmm0
mov    -0x2c(%rbp),%esi
jbe    1c70 <SqrtMeanInverse+0xab0>
test   %esi,%esi
mov    -0x88(%rbp),%r15
movsd  %xmm0,-0x38(%rbp)
jle    1a20 <SqrtMeanInverse+0x860>
cvttsd2si -0x38(%rbp),%ebx
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,%edi
call   1080 <sin@plt>
movsd  -0x38(%rbp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,-0x48(%rbp)
movslq -0x2c(%rbp),%rax
movslq %r13d,%rcx
imul   %rax,%rcx
add    %r12,%rcx
mov    -0x58(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    %ebx,%edi
call   10c0 <cos@plt>
mulsd  (%r14,%r12,8),%xmm0
movsd  -0x40(%rbp),%xmm1
subsd  %xmm0,%xmm1
mulsd  -0x48(%rbp),%xmm1
movslq -0x2c(%rbp),%rsi
mov    %r13d,%eax
imul   %esi,%eax
cltq
add    %r12,%rax
movsd  %xmm1,(%r15,%rax,8)
add    $0x1,%r12
cmp    %rsi,%r12
jl     1c00 <SqrtMeanInverse+0xa40>
jmp    1a20 <SqrtMeanInverse+0x860>
nop
test   %esi,%esi
jle    1a20 <SqrtMeanInverse+0x860>
mov    %esi,%eax
imul   %r13d,%eax
cltq
mov    -0x88(%rbp),%rcx
lea    (%rcx,%rax,8),%rdi
lea    0x0(,%rsi,8),%rdx
mov    %rsi,%rbx
xor    %esi,%esi
call   1050 <memset@plt>
mov    %rbx,%rsi
jmp    1a20 <SqrtMeanInverse+0x860>
xor    %edi,%edi
test   $0x1,%r9b
jne    1b09 <SqrtMeanInverse+0x949>
jmp    1b34 <SqrtMeanInverse+0x974>
cs nopw 0x0(%rax,%rax,1)
mov    %r13,%rax
mov    %rax,%r13
test   %esi,%esi
jle    1df0 <SqrtMeanInverse+0xc30>
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
mov    %rsi,-0x38(%rbp)
mov    %esi,%r10d
mov    %ebx,%r8d
mov    %ebx,%r12d
lea    -0x1(%r12),%rax
mov    %rax,-0x48(%rbp)
mov    %r12d,%r9d
and    $0x3,%r9d
and    $0xfffffffc,%r12d
mov    %r10,%rdi
shl    $0x4,%rdi
mov    %r10,%rax
shl    $0x5,%rax
lea    0x0(,%r10,8),%rbx
lea    (%rbx,%rbx,2),%rsi
mov    -0x88(%rbp),%r11
xor    %r15d,%r15d
jmp    1d40 <SqrtMeanInverse+0xb80>
nopl   0x0(%rax)
xorpd  %xmm1,%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%r15,8)
add    $0x1,%r15
add    $0x8,%r11
cmp    %r10,%r15
je     1dd0 <SqrtMeanInverse+0xc10>
test   %r8d,%r8d
jle    1d20 <SqrtMeanInverse+0xb60>
cmpq   $0x3,-0x48(%rbp)
jae    1d60 <SqrtMeanInverse+0xba0>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    1d90 <SqrtMeanInverse+0xbd0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xorpd  %xmm1,%xmm1
mov    %r11,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
addsd  (%rcx),%xmm1
addsd  (%rcx,%r10,8),%xmm1
addsd  (%rcx,%rdi,1),%xmm1
addsd  (%rcx,%rsi,1),%xmm1
add    $0x4,%rdx
add    %rax,%rcx
cmp    %rdx,%r12
jne    1d70 <SqrtMeanInverse+0xbb0>
test   %r9,%r9
je     1d24 <SqrtMeanInverse+0xb64>
imul   %r10,%rdx
add    %r15,%rdx
mov    -0x88(%rbp),%rcx
lea    (%rcx,%rdx,8),%rcx
mov    %r9,%rdx
nopw   0x0(%rax,%rax,1)
addsd  (%rcx),%xmm1
add    %rbx,%rcx
add    $0xffffffffffffffff,%rdx
jne    1db0 <SqrtMeanInverse+0xbf0>
jmp    1d24 <SqrtMeanInverse+0xb64>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
mov    -0x38(%rbp),%rcx
test   %ecx,%ecx
jle    1e00 <SqrtMeanInverse+0xc40>
cmp    $0x4,%ecx
mov    -0x70(%rbp),%r12
jae    1e10 <SqrtMeanInverse+0xc50>
xor    %eax,%eax
jmp    1ed0 <SqrtMeanInverse+0xd10>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
jmp    1f80 <SqrtMeanInverse+0xdc0>
nopl   0x0(%rax)
mov    -0x70(%rbp),%r12
jmp    1f80 <SqrtMeanInverse+0xdc0>
nopl   0x0(%rax)
mov    %r10d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1e93 <SqrtMeanInverse+0xcd3>
mov    %rcx,%rsi
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rsi
xor    %edx,%edx
nopl   0x0(%rax)
movapd 0x0(%r13,%rdx,8),%xmm1
movapd 0x10(%r13,%rdx,8),%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
movapd %xmm1,(%r12,%rdx,8)
movapd %xmm2,0x10(%r12,%rdx,8)
movapd 0x20(%r13,%rdx,8),%xmm1
movapd 0x30(%r13,%rdx,8),%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
movapd %xmm1,0x20(%r12,%rdx,8)
movapd %xmm2,0x30(%r12,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1e40 <SqrtMeanInverse+0xc80>
jmp    1e95 <SqrtMeanInverse+0xcd5>
xor    %edx,%edx
test   $0x1,%cl
mov    -0x38(%rbp),%rcx
je     1ec1 <SqrtMeanInverse+0xd01>
movapd 0x0(%r13,%rdx,8),%xmm1
movapd 0x10(%r13,%rdx,8),%xmm2
mulpd  %xmm1,%xmm1
mulpd  %xmm2,%xmm2
movapd %xmm1,(%r12,%rdx,8)
movapd %xmm2,0x10(%r12,%rdx,8)
cmp    %r10,%rax
je     1eea <SqrtMeanInverse+0xd2a>
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
movsd  %xmm1,(%r12,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    1ed0 <SqrtMeanInverse+0xd10>
test   %ecx,%ecx
jle    1f80 <SqrtMeanInverse+0xdc0>
lea    -0x1(%r10),%rcx
mov    %r10d,%eax
and    $0x7,%eax
cmp    $0x7,%rcx
jae    1f10 <SqrtMeanInverse+0xd50>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1f60 <SqrtMeanInverse+0xda0>
nopw   0x0(%rax,%rax,1)
and    $0xfffffff8,%r10d
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
addsd  (%r12,%rcx,8),%xmm0
addsd  0x8(%r12,%rcx,8),%xmm0
addsd  0x10(%r12,%rcx,8),%xmm0
addsd  0x18(%r12,%rcx,8),%xmm0
addsd  0x20(%r12,%rcx,8),%xmm0
addsd  0x28(%r12,%rcx,8),%xmm0
addsd  0x30(%r12,%rcx,8),%xmm0
addsd  0x38(%r12,%rcx,8),%xmm0
add    $0x8,%rcx
cmp    %rcx,%r10
jne    1f20 <SqrtMeanInverse+0xd60>
test   %rax,%rax
je     1f80 <SqrtMeanInverse+0xdc0>
lea    (%r12,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
addsd  (%rcx,%rdx,8),%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1f70 <SqrtMeanInverse+0xdb0>
xchg   %ax,%ax
mulsd  -0xb8(%rbp),%xmm0
ff
ucomisd 0x10d0(%rip),%xmm0
jb     1fa0 <SqrtMeanInverse+0xde0>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    1fa9 <SqrtMeanInverse+0xde9>
nopl   0x0(%rax,%rax,1)
call   10e0 <sqrt@plt>
movapd %xmm0,%xmm1
ucomisd 0x10af(%rip),%xmm1
mov    -0x2c(%rbp),%esi
jne    1fbc <SqrtMeanInverse+0xdfc>
jnp    203f <SqrtMeanInverse+0xe7f>
test   %esi,%esi
jle    2013 <SqrtMeanInverse+0xe53>
cvttsd2si %xmm1,%r15d
xor    %ebx,%ebx
movsd  %xmm1,-0x40(%rbp)
nopl   0x0(%rax)
mov    %r15d,%edi
call   10c0 <cos@plt>
mulsd  (%r14,%rbx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    %r15d,%edi
call   1080 <sin@plt>
movsd  -0x40(%rbp),%xmm1
divsd  %xmm1,%xmm0
mulsd  0x0(%r13,%rbx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,(%r14,%rbx,8)
add    $0x1,%rbx
movslq -0x2c(%rbp),%rsi
cmp    %rsi,%rbx
jl     1fd0 <SqrtMeanInverse+0xe10>
movsd  0x103d(%rip),%xmm0
ucomisd %xmm1,%xmm0
ja     203f <SqrtMeanInverse+0xe7f>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
cmp    $0x1e,%eax
je     203f <SqrtMeanInverse+0xe7f>
mov    -0x4c(%rbp),%ebx
test   %ebx,%ebx
jg     1a10 <SqrtMeanInverse+0x850>
jmp    1cc0 <SqrtMeanInverse+0xb00>
test   %esi,%esi
jle    2129 <SqrtMeanInverse+0xf69>
mov    %esi,%eax
cmp    $0x4,%esi
jae    2055 <SqrtMeanInverse+0xe95>
xor    %ecx,%ecx
jmp    2110 <SqrtMeanInverse+0xf50>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     2228 <SqrtMeanInverse+0x1068>
movabs $0x7ffffffffffffffe,%rdi
ff ff 7f
and    %rsi,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd (%r14,%rdx,8),%xmm0
movapd 0x10(%r14,%rdx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movapd %xmm0,(%r12,%rdx,8)
movapd %xmm1,0x10(%r12,%rdx,8)
movapd 0x20(%r14,%rdx,8),%xmm0
movapd 0x30(%r14,%rdx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movapd %xmm0,0x20(%r12,%rdx,8)
movapd %xmm1,0x30(%r12,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    2090 <SqrtMeanInverse+0xed0>
test   $0x1,%sil
je     2108 <SqrtMeanInverse+0xf48>
movapd (%r14,%rdx,8),%xmm0
movapd 0x10(%r14,%rdx,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movapd %xmm0,(%r12,%rdx,8)
movapd %xmm1,0x10(%r12,%rdx,8)
cmp    %rax,%rcx
je     2129 <SqrtMeanInverse+0xf69>
nopl   (%rax)
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2110 <SqrtMeanInverse+0xf50>
mov    -0xb0(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    %r12,%rdx
mov    -0xc8(%rbp),%rbx
mov    %rbx,%rcx
call   1060 <cumtrapz@plt>
mov    -0x2c(%rbp),%edi
test   %edi,%edi
jle    21de <SqrtMeanInverse+0x101e>
lea    -0x1(%rdi),%eax
cmp    $0x1,%edi
jne    215d <SqrtMeanInverse+0xf9d>
xor    %ecx,%ecx
jmp    21b9 <SqrtMeanInverse+0xff9>
mov    %edi,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx),%xmm0
movsd  (%rbx,%rcx,8),%xmm1
movsd  0x8(%rbx,%rcx,8),%xmm2
subsd  %xmm0,%xmm1
movsd  (%rbx,%rax,8),%xmm3
subsd  %xmm0,%xmm3
divsd  %xmm3,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
movsd  (%rbx),%xmm0
subsd  %xmm0,%xmm2
movsd  (%rbx,%rax,8),%xmm1
subsd  %xmm0,%xmm1
divsd  %xmm1,%xmm2
movsd  %xmm2,0x8(%rbx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    2170 <SqrtMeanInverse+0xfb0>
test   $0x1,%dil
je     21de <SqrtMeanInverse+0x101e>
movsd  (%rbx,%rcx,8),%xmm0
movsd  (%rbx),%xmm1
subsd  %xmm1,%xmm0
movsd  (%rbx,%rax,8),%xmm2
subsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
mov    %rbx,%rsi
mov    -0xd8(%rbp),%rdx
call   10d0 <invertGamma@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movdqa 0xdec(%rip),%xmm2
xor    %edx,%edx
mov    -0x78(%rbp),%rax
test   $0x1,%cl
jne    13b6 <SqrtMeanInverse+0x1f6>
jmp    13c3 <SqrtMeanInverse+0x203>
xor    %edx,%edx
test   $0x1,%sil
jne    20e6 <SqrtMeanInverse+0xf26>
jmp    2108 <SqrtMeanInverse+0xf48>

LLVM IR (-O0):
@DBL_EPSILON = global double 0.000000e+00
define void @SqrtMeanInverse(i32* %0, i32* %1, double* %2, double* %3, double* %4) {
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i8*
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca double
%21 = alloca double
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca double
%26 = alloca i64
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca i64
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i64
%39 = alloca double*
%40 = alloca double*
%41 = alloca double*
%42 = alloca double*
%43 = alloca double*
%44 = alloca double*
store i32* %0, i32** %6
store i32* %1, i32** %7
store double* %2, double** %8
store double* %3, double** %9
store double* %4, double** %10
%45 = load i32*, i32** %6
%46 = load i32, i32* %45
store i32 %46, i32* %11
%47 = load i32*, i32** %7
%48 = load i32, i32* %47
store i32 %48, i32* %12
%49 = load i32, i32* %11
%50 = load i32, i32* %12
%51 = mul nsw i32 %49, %50
%52 = zext i32 %51 to i64
%53 = call i8* @llvm.stacksave()
store i8* %53, i8** %13
%54 = alloca double, i64 %52
store i64 %52, i64* %14
%55 = load i32, i32* %11
%56 = load i32, i32* %12
%57 = mul nsw i32 %55, %56
%58 = zext i32 %57 to i64
%59 = alloca double, i64 %58
store i64 %58, i64* %15
%60 = load i32, i32* %11
%61 = zext i32 %60 to i64
%62 = alloca double, i64 %61
store i64 %61, i64* %16
%63 = load i32, i32* %11
%64 = load i32, i32* %12
%65 = mul nsw i32 %63, %64
%66 = zext i32 %65 to i64
%67 = alloca double, i64 %66
store i64 %66, i64* %17
%68 = load i32, i32* %11
%69 = zext i32 %68 to i64
%70 = alloca double, i64 %69
store i64 %69, i64* %18
%71 = load i32, i32* %11
%72 = zext i32 %71 to i64
%73 = alloca double, i64 %72
store i64 %72, i64* %19
%74 = load i32, i32* %11
%75 = zext i32 %74 to i64
%76 = alloca double, i64 %75
store i64 %75, i64* %22
%77 = load i32, i32* %11
%78 = zext i32 %77 to i64
%79 = alloca double, i64 %78
store i64 %78, i64* %23
%80 = load i32, i32* %12
%81 = zext i32 %80 to i64
%82 = alloca double, i64 %81
store i64 %81, i64* %24
%83 = load double, double* @DBL_EPSILON
store double %83, double* %25
%84 = load i32, i32* %11
%85 = zext i32 %84 to i64
%86 = alloca double, i64 %85
store i64 %85, i64* %26
store double 0.000000e+00, double* %27
%87 = load i32, i32* %11
%88 = zext i32 %87 to i64
%89 = alloca double, i64 %88
store i64 %88, i64* %30
store i32 1, i32* %34
store i32 0, i32* %35
store i32 30, i32* %36
store i32 1, i32* %37
%90 = load i32, i32* %36
%91 = zext i32 %90 to i64
%92 = alloca double, i64 %91
store i64 %91, i64* %38
%93 = load i32, i32* %11
%94 = sext i32 %93 to i64
%95 = mul i64 8, %94
%96 = trunc i64 %95 to i32
%97 = call double* @malloc(i32 %96)
store double* %97, double** %39
store i32 0, i32* %31
br label %98
98: ; preds = %106, %5
%99 = load i32, i32* %31
%100 = load i32, i32* %36
%101 = icmp slt i32 %99, %100
br i1 %101, label %102, label %109
102: ; preds = %98
%103 = load i32, i32* %31
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds double, double* %92, i64 %104
store double 0.000000e+00, double* %105
br label %106
106: ; preds = %102
%107 = load i32, i32* %31
%108 = add nsw i32 %107, 1
store i32 %108, i32* %31
br label %98
109: ; preds = %98
store i32 0, i32* %31
br label %110
110: ; preds = %118, %109
%111 = load i32, i32* %31
%112 = load i32, i32* %11
%113 = icmp slt i32 %111, %112
br i1 %113, label %114, label %121
114: ; preds = %110
%115 = load i32, i32* %31
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double, double* %89, i64 %116
store double 0.000000e+00, double* %117
br label %118
118: ; preds = %114
%119 = load i32, i32* %31
%120 = add nsw i32 %119, 1
store i32 %120, i32* %31
br label %110
121: ; preds = %110
store i32 0, i32* %31
br label %122
122: ; preds = %137, %121
%123 = load i32, i32* %31
%124 = load i32, i32* %11
%125 = icmp slt i32 %123, %124
br i1 %125, label %126, label %140
126: ; preds = %122
%127 = load i32, i32* %31
%128 = sitofp i32 %127 to double
%129 = load i32, i32* %11
%130 = sub nsw i32 %129, 1
%131 = sitofp i32 %130 to double
%132 = fdiv double %128, %131
%133 = load double*, double** %39
%134 = load i32, i32* %31
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %133, i64 %135
store double %132, double* %136
br label %137
137: ; preds = %126
%138 = load i32, i32* %31
%139 = add nsw i32 %138, 1
store i32 %139, i32* %31
br label %122
140: ; preds = %122
store double 0.000000e+00, double* %28
store i32 0, i32* %31
br label %141
141: ; preds = %161, %140
%142 = load i32, i32* %31
%143 = load i32, i32* %11
%144 = sub nsw i32 %143, 1
%145 = icmp slt i32 %142, %144
br i1 %145, label %146, label %164
146: ; preds = %141
%147 = load double*, double** %8
%148 = load i32, i32* %31
%149 = add nsw i32 %148, 1
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %147, i64 %150
%152 = load double, double* %151
%153 = load double*, double** %8
%154 = load i32, i32* %31
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %153, i64 %155
%157 = load double, double* %156
%158 = fsub double %152, %157
%159 = load double, double* %28
%160 = fadd double %159, %158
store double %160, double* %28
br label %161
161: ; preds = %146
%162 = load i32, i32* %31
%163 = add nsw i32 %162, 1
store i32 %163, i32* %31
br label %141
164: ; preds = %141
%165 = load double, double* %28
%166 = load i32, i32* %11
%167 = sub nsw i32 %166, 1
%168 = sitofp i32 %167 to double
%169 = fdiv double %165, %168
store double %169, double* %28
store i32 0, i32* %31
br label %170
170: ; preds = %185, %164
%171 = load i32, i32* %31
%172 = load i32, i32* %11
%173 = load i32, i32* %12
%174 = mul nsw i32 %172, %173
%175 = icmp slt i32 %171, %174
br i1 %175, label %176, label %188
176: ; preds = %170
%177 = load double*, double** %9
%178 = load i32, i32* %31
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
%181 = load double, double* %180
%182 = load i32, i32* %31
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double, double* %59, i64 %183
store double %181, double* %184
br label %185
185: ; preds = %176
%186 = load i32, i32* %31
%187 = add nsw i32 %186, 1
store i32 %187, i32* %31
br label %170
188: ; preds = %170
store double* %54, double** %40
store double* %59, double** %41
%189 = load double*, double** %41
%190 = load double*, double** %40
%191 = call i32 @gradient(i32* %11, i32* %12, double* %189, double* %28, double* %190)
store i32 0, i32* %31
br label %192
192: ; preds = %210, %188
%193 = load i32, i32* %31
%194 = load i32, i32* %11
%195 = load i32, i32* %12
%196 = mul nsw i32 %194, %195
%197 = icmp slt i32 %193, %196
br i1 %197, label %198, label %213
198: ; preds = %192
%199 = load i32, i32* %31
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds double, double* %54, i64 %200
%202 = load double, double* %201
%203 = call double @llvm.fabs.f64(double %202)
%204 = load double, double* %25
%205 = fadd double %203, %204
%206 = call double @sqrt(double %205)
%207 = load i32, i32* %31
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds double, double* %54, i64 %208
store double %206, double* %209
br label %210
210: ; preds = %198
%211 = load i32, i32* %31
%212 = add nsw i32 %211, 1
store i32 %212, i32* %31
br label %192
213: ; preds = %192
store i32 0, i32* %31
br label %214
214: ; preds = %245, %213
%215 = load i32, i32* %31
%216 = load i32, i32* %11
%217 = icmp slt i32 %215, %216
br i1 %217, label %218, label %248
218: ; preds = %214
store double 0.000000e+00, double* %29
store i32 0, i32* %33
br label %219
219: ; preds = %234, %218
%220 = load i32, i32* %33
%221 = load i32, i32* %12
%222 = icmp slt i32 %220, %221
br i1 %222, label %223, label %237
223: ; preds = %219
%224 = load i32, i32* %31
%225 = load i32, i32* %33
%226 = load i32, i32* %11
%227 = mul nsw i32 %225, %226
%228 = add nsw i32 %224, %227
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds double, double* %54, i64 %229
%231 = load double, double* %230
%232 = load double, double* %29
%233 = fadd double %232, %231
store double %233, double* %29
br label %234
234: ; preds = %223
%235 = load i32, i32* %33
%236 = add nsw i32 %235, 1
store i32 %236, i32* %33
br label %219
237: ; preds = %219
%238 = load double, double* %29
%239 = load i32, i32* %12
%240 = sitofp i32 %239 to double
%241 = fdiv double %238, %240
%242 = load i32, i32* %31
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds double, double* %79, i64 %243
store double %241, double* %244
br label %245
245: ; preds = %237
%246 = load i32, i32* %31
%247 = add nsw i32 %246, 1
store i32 %247, i32* %31
br label %214
248: ; preds = %214
store i32 0, i32* %31
br label %249
249: ; preds = %298, %248
%250 = load i32, i32* %31
%251 = load i32, i32* %12
%252 = icmp slt i32 %250, %251
br i1 %252, label %253, label %301
253: ; preds = %249
store i32 0, i32* %33
br label %254
254: ; preds = %275, %253
%255 = load i32, i32* %33
%256 = load i32, i32* %11
%257 = icmp slt i32 %255, %256
br i1 %257, label %258, label %278
258: ; preds = %254
%259 = load i32, i32* %31
%260 = load i32, i32* %11
%261 = mul nsw i32 %259, %260
%262 = load i32, i32* %33
%263 = add nsw i32 %261, %262
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds double, double* %54, i64 %264
%266 = load double, double* %265
%267 = load i32, i32* %33
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds double, double* %79, i64 %268
%270 = load double, double* %269
%271 = fsub double %266, %270
%272 = load i32, i32* %33
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds double, double* %86, i64 %273
store double %271, double* %274
br label %275
275: ; preds = %258
%276 = load i32, i32* %33
%277 = add nsw i32 %276, 1
store i32 %277, i32* %33
br label %254
278: ; preds = %254
store double 0.000000e+00, double* %29
store i32 0, i32* %33
br label %279
279: ; preds = %290, %278
%280 = load i32, i32* %33
%281 = load i32, i32* %11
%282 = icmp slt i32 %280, %281
br i1 %282, label %283, label %293
283: ; preds = %279
%284 = load i32, i32* %33
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %86, i64 %285
%287 = load double, double* %286
%288 = load double, double* %29
%289 = fadd double %288, %287
store double %289, double* %29
br label %290
290: ; preds = %283
%291 = load i32, i32* %33
%292 = add nsw i32 %291, 1
store i32 %292, i32* %33
br label %279
293: ; preds = %279
%294 = load double, double* %29
%295 = load i32, i32* %31
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds double, double* %82, i64 %296
store double %294, double* %297
br label %298
298: ; preds = %293
%299 = load i32, i32* %31
%300 = add nsw i32 %299, 1
store i32 %300, i32* %31
br label %249
301: ; preds = %249
store i32 0, i32* %31
br label %302
302: ; preds = %329, %301
%303 = load i32, i32* %31
%304 = load i32, i32* %12
%305 = icmp slt i32 %303, %304
br i1 %305, label %306, label %332
306: ; preds = %302
%307 = load i32, i32* %31
%308 = icmp eq i32 %307, 0
br i1 %308, label %309, label %314
309: ; preds = %306
store i32 0, i32* %35
%310 = load i32, i32* %31
%311 = sext i32 %310 to i64
%312 = getelementptr inbounds double, double* %82, i64 %311
%313 = load double, double* %312
store double %313, double* %27
br label %328
314: ; preds = %306
%315 = load i32, i32* %31
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double, double* %82, i64 %316
%318 = load double, double* %317
%319 = load double, double* %27
%320 = fcmp olt double %318, %319
br i1 %320, label %321, label %327
321: ; preds = %314
%322 = load i32, i32* %31
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds double, double* %82, i64 %323
%325 = load double, double* %324
store double %325, double* %27
%326 = load i32, i32* %31
store i32 %326, i32* %35
br label %327
327: ; preds = %321, %314
br label %328
328: ; preds = %327, %309
br label %329
329: ; preds = %328
%330 = load i32, i32* %31
%331 = add nsw i32 %330, 1
store i32 %331, i32* %31
br label %302
332: ; preds = %302
store i32 0, i32* %31
br label %333
333: ; preds = %350, %332
%334 = load i32, i32* %31
%335 = load i32, i32* %11
%336 = icmp slt i32 %334, %335
br i1 %336, label %337, label %353
337: ; preds = %333
%338 = load i32, i32* %35
%339 = sub nsw i32 %338, 1
%340 = load i32, i32* %11
%341 = mul nsw i32 %339, %340
%342 = load i32, i32* %31
%343 = add nsw i32 %341, %342
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds double, double* %54, i64 %344
%346 = load double, double* %345
%347 = load i32, i32* %31
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds double, double* %62, i64 %348
store double %346, double* %349
br label %350
350: ; preds = %337
%351 = load i32, i32* %31
%352 = add nsw i32 %351, 1
store i32 %352, i32* %31
br label %333
353: ; preds = %333
store i32 1, i32* %32
br label %354
354: ; preds = %634, %353
%355 = load i32, i32* %32
%356 = load i32, i32* %36
%357 = icmp slt i32 %355, %356
br i1 %357, label %358, label %637
358: ; preds = %354
store i32 0, i32* %31
br label %359
359: ; preds = %489, %358
%360 = load i32, i32* %31
%361 = load i32, i32* %12
%362 = icmp slt i32 %360, %361
br i1 %362, label %363, label %492
363: ; preds = %359
store i32 0, i32* %33
br label %364
364: ; preds = %385, %363
%365 = load i32, i32* %33
%366 = load i32, i32* %11
%367 = icmp slt i32 %365, %366
br i1 %367, label %368, label %388
368: ; preds = %364
%369 = load i32, i32* %31
%370 = load i32, i32* %11
%371 = mul nsw i32 %369, %370
%372 = load i32, i32* %33
%373 = add nsw i32 %371, %372
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds double, double* %54, i64 %374
%376 = load double, double* %375
%377 = load i32, i32* %33
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds double, double* %62, i64 %378
%380 = load double, double* %379
%381 = fsub double %376, %380
%382 = load i32, i32* %33
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds double, double* %70, i64 %383
store double %381, double* %384
br label %385
385: ; preds = %368
%386 = load i32, i32* %33
%387 = add nsw i32 %386, 1
store i32 %387, i32* %33
br label %364
388: ; preds = %364
store i32 0, i32* %33
br label %389
389: ; preds = %410, %388
%390 = load i32, i32* %33
%391 = load i32, i32* %11
%392 = icmp slt i32 %390, %391
br i1 %392, label %393, label %413
393: ; preds = %389
%394 = load i32, i32* %31
%395 = load i32, i32* %11
%396 = mul nsw i32 %394, %395
%397 = load i32, i32* %33
%398 = add nsw i32 %396, %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double, double* %54, i64 %399
%401 = load double, double* %400
%402 = load i32, i32* %33
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double, double* %62, i64 %403
%405 = load double, double* %404
%406 = fmul double %401, %405
%407 = load i32, i32* %33
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds double, double* %73, i64 %408
store double %406, double* %409
br label %410
410: ; preds = %393
%411 = load i32, i32* %33
%412 = add nsw i32 %411, 1
store i32 %412, i32* %33
br label %389
413: ; preds = %389
store double* %73, double** %43
%414 = load i32*, i32** %6
%415 = load double*, double** %8
%416 = load double*, double** %43
%417 = call i32 @trapz(i32* %414, i32* %34, double* %415, double* %416, double* %20)
%418 = load double, double* %20
%419 = fcmp ogt double %418, 1.000000e+00
br i1 %419, label %420, label %421
420: ; preds = %413
store double 1.000000e+00, double* %20
br label %426
421: ; preds = %413
%422 = load double, double* %20
%423 = fcmp olt double %422, -1.000000e+00
br i1 %423, label %424, label %425
424: ; preds = %421
store double 1.000000e+00, double* %20
br label %425
425: ; preds = %424, %421
br label %426
426: ; preds = %425, %420
%427 = load double, double* %20
%428 = call double @acos(double %427)
store double %428, double* %21
%429 = load double, double* %21
%430 = fcmp ogt double %429, 1.000000e-04
br i1 %430, label %431, label %471
431: ; preds = %426
store i32 0, i32* %33
br label %432
432: ; preds = %467, %431
%433 = load i32, i32* %33
%434 = load i32, i32* %11
%435 = icmp slt i32 %433, %434
br i1 %435, label %436, label %470
436: ; preds = %432
%437 = load double, double* %21
%438 = load double, double* %21
%439 = fptosi double %438 to i32
%440 = call double @sin(i32 %439)
%441 = fdiv double %437, %440
%442 = load i32, i32* %31
%443 = load i32, i32* %11
%444 = mul nsw i32 %442, %443
%445 = load i32, i32* %33
%446 = add nsw i32 %444, %445
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double, double* %54, i64 %447
%449 = load double, double* %448
%450 = load double, double* %21
%451 = fptosi double %450 to i32
%452 = call double @cos(i32 %451)
%453 = load i32, i32* %33
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds double, double* %62, i64 %454
%456 = load double, double* %455
%457 = fneg double %452
%458 = call double @llvm.fmuladd.f64(double %457, double %456, double %449)
%459 = fmul double %441, %458
%460 = load i32, i32* %31
%461 = load i32, i32* %11
%462 = mul nsw i32 %460, %461
%463 = load i32, i32* %33
%464 = add nsw i32 %462, %463
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds double, double* %67, i64 %465
store double %459, double* %466
br label %467
467: ; preds = %436
%468 = load i32, i32* %33
%469 = add nsw i32 %468, 1
store i32 %469, i32* %33
br label %432
470: ; preds = %432
br label %488
471: ; preds = %426
store i32 0, i32* %33
br label %472
472: ; preds = %484, %471
%473 = load i32, i32* %33
%474 = load i32, i32* %11
%475 = icmp slt i32 %473, %474
br i1 %475, label %476, label %487
476: ; preds = %472
%477 = load i32, i32* %31
%478 = load i32, i32* %11
%479 = mul nsw i32 %477, %478
%480 = load i32, i32* %33
%481 = add nsw i32 %479, %480
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds double, double* %67, i64 %482
store double 0.000000e+00, double* %483
br label %484
484: ; preds = %476
%485 = load i32, i32* %33
%486 = add nsw i32 %485, 1
store i32 %486, i32* %33
br label %472
487: ; preds = %472
br label %488
488: ; preds = %487, %470
br label %489
489: ; preds = %488
%490 = load i32, i32* %31
%491 = add nsw i32 %490, 1
store i32 %491, i32* %31
br label %359
492: ; preds = %359
store i32 0, i32* %31
br label %493
493: ; preds = %524, %492
%494 = load i32, i32* %31
%495 = load i32, i32* %11
%496 = icmp slt i32 %494, %495
br i1 %496, label %497, label %527
497: ; preds = %493
store double 0.000000e+00, double* %29
store i32 0, i32* %33
br label %498
498: ; preds = %513, %497
%499 = load i32, i32* %33
%500 = load i32, i32* %12
%501 = icmp slt i32 %499, %500
br i1 %501, label %502, label %516
502: ; preds = %498
%503 = load i32, i32* %31
%504 = load i32, i32* %33
%505 = load i32, i32* %11
%506 = mul nsw i32 %504, %505
%507 = add nsw i32 %503, %506
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds double, double* %67, i64 %508
%510 = load double, double* %509
%511 = load double, double* %29
%512 = fadd double %511, %510
store double %512, double* %29
br label %513
513: ; preds = %502
%514 = load i32, i32* %33
%515 = add nsw i32 %514, 1
store i32 %515, i32* %33
br label %498
516: ; preds = %498
%517 = load double, double* %29
%518 = load i32, i32* %12
%519 = sitofp i32 %518 to double
%520 = fdiv double %517, %519
%521 = load i32, i32* %31
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds double, double* %76, i64 %522
store double %520, double* %523
br label %524
524: ; preds = %516
%525 = load i32, i32* %31
%526 = add nsw i32 %525, 1
store i32 %526, i32* %31
br label %493
527: ; preds = %493
store i32 0, i32* %31
br label %528
528: ; preds = %545, %527
%529 = load i32, i32* %31
%530 = load i32, i32* %11
%531 = icmp slt i32 %529, %530
br i1 %531, label %532, label %548
532: ; preds = %528
%533 = load i32, i32* %31
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds double, double* %76, i64 %534
%536 = load double, double* %535
%537 = load i32, i32* %31
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds double, double* %76, i64 %538
%540 = load double, double* %539
%541 = fmul double %536, %540
%542 = load i32, i32* %31
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds double, double* %86, i64 %543
store double %541, double* %544
br label %545
545: ; preds = %532
%546 = load i32, i32* %31
%547 = add nsw i32 %546, 1
store i32 %547, i32* %31
br label %528
548: ; preds = %528
store double 0.000000e+00, double* %29
store i32 0, i32* %31
br label %549
549: ; preds = %560, %548
%550 = load i32, i32* %31
%551 = load i32, i32* %11
%552 = icmp slt i32 %550, %551
br i1 %552, label %553, label %563
553: ; preds = %549
%554 = load i32, i32* %31
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds double, double* %86, i64 %555
%557 = load double, double* %556
%558 = load double, double* %29
%559 = fadd double %558, %557
store double %559, double* %29
br label %560
560: ; preds = %553
%561 = load i32, i32* %31
%562 = add nsw i32 %561, 1
store i32 %562, i32* %31
br label %549
563: ; preds = %549
%564 = load double, double* %29
%565 = load double, double* %28
%566 = fmul double %564, %565
%567 = call double @sqrt(double %566)
%568 = load i32, i32* %32
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds double, double* %92, i64 %569
store double %567, double* %570
%571 = load i32, i32* %32
%572 = sext i32 %571 to i64
%573 = getelementptr inbounds double, double* %92, i64 %572
%574 = load double, double* %573
%575 = fcmp oeq double %574, 0.000000e+00
br i1 %575, label %576, label %577
576: ; preds = %563
br label %637
577: ; preds = %563
store i32 0, i32* %31
br label %578
578: ; preds = %619, %577
%579 = load i32, i32* %31
%580 = load i32, i32* %11
%581 = icmp slt i32 %579, %580
br i1 %581, label %582, label %622
582: ; preds = %578
%583 = load i32, i32* %37
%584 = sitofp i32 %583 to double
%585 = load i32, i32* %32
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds double, double* %92, i64 %586
%588 = load double, double* %587
%589 = fmul double %584, %588
%590 = fptosi double %589 to i32
%591 = call double @cos(i32 %590)
%592 = load i32, i32* %31
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds double, double* %62, i64 %593
%595 = load double, double* %594
%596 = load i32, i32* %37
%597 = sitofp i32 %596 to double
%598 = load i32, i32* %32
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds double, double* %92, i64 %599
%601 = load double, double* %600
%602 = fmul double %597, %601
%603 = fptosi double %602 to i32
%604 = call double @sin(i32 %603)
%605 = load i32, i32* %32
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds double, double* %92, i64 %606
%608 = load double, double* %607
%609 = fdiv double %604, %608
%610 = load i32, i32* %31
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds double, double* %76, i64 %611
%613 = load double, double* %612
%614 = fmul double %609, %613
%615 = call double @llvm.fmuladd.f64(double %591, double %595, double %614)
%616 = load i32, i32* %31
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds double, double* %62, i64 %617
store double %615, double* %618
br label %619
619: ; preds = %582
%620 = load i32, i32* %31
%621 = add nsw i32 %620, 1
store i32 %621, i32* %31
br label %578
622: ; preds = %578
%623 = load i32, i32* %32
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds double, double* %92, i64 %624
%626 = load double, double* %625
%627 = fcmp olt double %626, 0x3EB0C6F7A0B5ED8D
br i1 %627, label %632, label %628
628: ; preds = %622
%629 = load i32, i32* %32
%630 = load i32, i32* %36
%631 = icmp sge i32 %629, %630
br i1 %631, label %632, label %633
632: ; preds = %628, %622
br label %637
633: ; preds = %628
br label %634
634: ; preds = %633
%635 = load i32, i32* %32
%636 = add nsw i32 %635, 1
store i32 %636, i32* %32
br label %354
637: ; preds = %632, %576, %354
store i32 0, i32* %31
br label %638
638: ; preds = %655, %637
%639 = load i32, i32* %31
%640 = load i32, i32* %11
%641 = icmp slt i32 %639, %640
br i1 %641, label %642, label %658
642: ; preds = %638
%643 = load i32, i32* %31
%644 = sext i32 %643 to i64
%645 = getelementptr inbounds double, double* %62, i64 %644
%646 = load double, double* %645
%647 = load i32, i32* %31
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds double, double* %62, i64 %648
%650 = load double, double* %649
%651 = fmul double %646, %650
%652 = load i32, i32* %31
%653 = sext i32 %652 to i64
%654 = getelementptr inbounds double, double* %86, i64 %653
store double %651, double* %654
br label %655
655: ; preds = %642
%656 = load i32, i32* %31
%657 = add nsw i32 %656, 1
store i32 %657, i32* %31
br label %638
658: ; preds = %638
store double* %86, double** %42
store double* %89, double** %44
%659 = load i32*, i32** %6
%660 = load double*, double** %8
%661 = load double*, double** %42
%662 = load double*, double** %44
%663 = call i32 @cumtrapz(i32* %659, double* %660, double* %661, double* %662)
store i32 0, i32* %31
br label %664
664: ; preds = %693, %658
%665 = load i32, i32* %31
%666 = load i32, i32* %11
%667 = icmp slt i32 %665, %666
br i1 %667, label %668, label %696
668: ; preds = %664
%669 = load double*, double** %44
%670 = load i32, i32* %31
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds double, double* %669, i64 %671
%673 = load double, double* %672
%674 = load double*, double** %44
%675 = getelementptr inbounds double, double* %674, i64 0
%676 = load double, double* %675
%677 = fsub double %673, %676
%678 = load double*, double** %44
%679 = load i32, i32* %11
%680 = sub nsw i32 %679, 1
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds double, double* %678, i64 %681
%683 = load double, double* %682
%684 = load double*, double** %44
%685 = getelementptr inbounds double, double* %684, i64 0
%686 = load double, double* %685
%687 = fsub double %683, %686
%688 = fdiv double %677, %687
%689 = load double*, double** %44
%690 = load i32, i32* %31
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds double, double* %689, i64 %691
store double %688, double* %692
br label %693
693: ; preds = %668
%694 = load i32, i32* %31
%695 = add nsw i32 %694, 1
store i32 %695, i32* %31
br label %664
696: ; preds = %664
%697 = load i32, i32* %11
%698 = load double*, double** %44
%699 = load double*, double** %10
%700 = call i32 @invertGamma(i32 %697, double* %698, double* %699)
%701 = load double*, double** %39
%702 = call i32 @free(double* %701)
%703 = load i8*, i8** %13
ret void
}

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