#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 exp(double);
int /*<<< orphan*/ free(double *);
double gaussian_cache(double, double, double *);
int /*<<< orphan*/ isfinite(double);
double log(int);
double log10(double);
scalar_t__ malloc(int);
double pow(int, double);
double sqrt(double);
void convolved_fit(double *af_key, double *af_val, int num_af_points,
                   double *smm, double *mf, int MASS_BINS, double scatter,
                   int repeat, double sm_step) {
  if (!repeat || !scatter)
    return;
  int i, j, k, jstart, jend;
  double sm, fid_sm;
  double nh, new_nh, lnh, lnnh, mnh, sum;
  double *new_smm = (double *)malloc(MASS_BINS * sizeof(double));
  double *smm_conv = (double *)malloc(MASS_BINS * sizeof(double));
  double *g_cache = (double *)malloc(4097 * sizeof(double));
  for (i = 0; i < 4097; i++) {
    sm = ((double)i) / 256 - 8;
    g_cache[i] = exp(-0.5 * sm * sm) / sqrt(2.0 * 3.1415926535);
  }
  for (k = 0; k < repeat; ++k) {
    jstart = 0;
    jend = MASS_BINS;
    fid_sm = af_key[num_af_points - 1] + 1;
    nh = pow(10, af_val[num_af_points - 1]) *
         (af_key[num_af_points - 1] - af_key[num_af_points - 2]);
    new_smm[0] = 0;
    for (i = 1; i < MASS_BINS; i++) {
      new_smm[i] = 0;
      if (smm[i] && !smm[i - 1])
        jstart = i;
      if (!smm[i] && smm[i - 1])
        jend = i;
    }
    mnh = 0;
    while (mnh < nh) {
      sum = 0;
      for (j = jstart; j < jend; j++) {
        smm_conv[j] = gaussian_cache(fid_sm - smm[j], scatter, g_cache);
        sum += smm_conv[j] * mf[j];
      }
      mnh += sum * sm_step;
      if (!isfinite(mnh))
        mnh = 0;
      for (j = jstart; j < jend; j++) {
        new_smm[j] += smm_conv[j] * sm_step * af_key[num_af_points - 1];
      }
      fid_sm -= sm_step;
    }
    lnh = log10(nh);
    for (i = num_af_points - 1; i > 0; i--) {
      new_nh = nh + (pow(10, af_val[i - 1]) - pow(10, af_val[i])) *
                        (af_key[i] - af_key[i - 1]) /
                        (log(10) * (af_val[i - 1] - af_val[i]));
      lnnh = log10(new_nh);
      while (mnh < new_nh && fid_sm >= 0) {
        sum = 0;
        for (j = jstart; j < jend; j++) {
          smm_conv[j] = gaussian_cache(fid_sm - smm[j], scatter, g_cache);
          sum += smm_conv[j] * mf[j];
        }
        mnh += sum * sm_step;
        sm = af_key[i - 1] +
             (log10(mnh) - lnnh) / (lnh - lnnh) * (af_key[i] - af_key[i - 1]);
        for (j = jstart; j < jend; j++)
          new_smm[j] += smm_conv[j] * sm * sm_step;
        fid_sm -= sm_step;
      }
      nh = new_nh;
      lnh = lnnh;
    }
    for (j = jstart; j < jend; j++)
      smm[j] = new_smm[j];
  }
  free(new_smm);
  free(smm_conv);
  free(g_cache);
}


x86 assembly (clang, -O0):
<convolved_fit>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
cmpl   $0x0,0x10(%rbp)
je     11e1 <convolved_fit+0x51>
movsd  -0x38(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11e6 <convolved_fit+0x56>
jp     11e6 <convolved_fit+0x56>
jmp    1916 <convolved_fit+0x786>
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0xa8(%rbp)
mov    $0x8008,%edi
call   1060 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x1001,-0x44(%rbp)
jge    12b2 <convolved_fit+0x122>
cvtsi2sdl -0x44(%rbp),%xmm0
movsd  0xddc(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0xdc8(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xdaf(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
call   1070 <exp@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xd88(%rip),%xmm0
call   10b0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    122a <convolved_fit+0x9a>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    18f2 <convolved_fit+0x762>
movl   $0x0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xd19(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0xa,%edi
call   1090 <pow@plt>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0xa0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1421 <convolved_fit+0x291>
mov    -0xa0(%rbp),%rax
movslq -0x44(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1393 <convolved_fit+0x203>
jp     1393 <convolved_fit+0x203>
jmp    13be <convolved_fit+0x22e>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13be <convolved_fit+0x22e>
jp     13be <convolved_fit+0x22e>
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    140e <convolved_fit+0x27e>
jp     140e <convolved_fit+0x27e>
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1408 <convolved_fit+0x278>
jp     1408 <convolved_fit+0x278>
jmp    140e <convolved_fit+0x27e>
mov    -0x44(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    1413 <convolved_fit+0x283>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    134f <convolved_fit+0x1bf>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x70(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1598 <convolved_fit+0x408>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x50(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    14d6 <convolved_fit+0x346>
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm1
mov    -0xb0(%rbp),%rdi
call   1040 <gaussian_cache@plt>
mov    -0xa8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1454 <convolved_fit+0x2c4>
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x40(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1050 <isfinite@plt>
cmp    $0x0,%eax
jne    151c <convolved_fit+0x38c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x50(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1580 <convolved_fit+0x3f0>
mov    -0xa8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0xa0(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1522 <convolved_fit+0x392>
movsd  -0x40(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    142c <convolved_fit+0x29c>
movsd  -0x70(%rbp),%xmm0
call   10a0 <log10@plt>
movsd  %xmm0,-0x80(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jle    18a2 <convolved_fit+0x712>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0xa,%edi
call   1090 <pow@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0xa,%edi
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    $0xa,%edi
call   1080 <log@plt>
movsd  -0xc8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
call   10a0 <log10@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm0
xor    %eax,%eax
ucomisd %xmm1,%xmm0
mov    %al,-0xd1(%rbp)
jbe    16cf <convolved_fit+0x53f>
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setae  %al
mov    %al,-0xd1(%rbp)
mov    -0xd1(%rbp),%al
test   $0x1,%al
jne    16e2 <convolved_fit+0x552>
jmp    187d <convolved_fit+0x6ed>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x50(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1775 <convolved_fit+0x5e5>
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  -0x38(%rbp),%xmm1
mov    -0xb0(%rbp),%rdi
call   1040 <gaussian_cache@plt>
mov    -0xa8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    16f3 <convolved_fit+0x563>
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x40(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   10a0 <log10@plt>
movsd  -0xe0(%rbp),%xmm1
ff
subsd  -0x88(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
subsd  -0x88(%rbp),%xmm2
ff
divsd  %xmm2,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1865 <convolved_fit+0x6d5>
mov    -0xa8(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
mov    -0xa0(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1814 <convolved_fit+0x684>
movsd  -0x40(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    169b <convolved_fit+0x50b>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    15b0 <convolved_fit+0x420>
mov    -0x50(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    18df <convolved_fit+0x74f>
mov    -0xa0(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    18a8 <convolved_fit+0x718>
jmp    18e4 <convolved_fit+0x754>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12b9 <convolved_fit+0x129>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
mov    -0xb0(%rbp),%rdi
call   1030 <free@plt>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convolved_fit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,0x50(%rsp)
mov    %r8,0xe8(%rsp)
mov    %edx,0x74(%rsp)
mov    %rsi,0xf0(%rsp)
mov    %rdi,0x68(%rsp)
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
jne    11bf <convolved_fit+0x3f>
jnp    1ec5 <convolved_fit+0xd45>
mov    0x1c0(%rsp),%eax
mov    %eax,0x70(%rsp)
test   %eax,%eax
je     1ec5 <convolved_fit+0xd45>
mov    %rcx,%r13
movsd  %xmm0,0xb8(%rsp)
movapd %xmm1,0xc0(%rsp)
mov    0x50(%rsp),%rax
lea    0x0(,%rax,8),%r14d
mov    %r14d,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    %r14d,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0x8008,%edi
call   1060 <malloc@plt>
mov    %rax,%r12
xor    %ebx,%ebx
nopl   0x0(%rax)
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
mulsd  0xdd1(%rip),%xmm1
addsd  0xdd1(%rip),%xmm1
movapd %xmm1,%xmm0
mulsd  0xdcd(%rip),%xmm0
mulsd  %xmm1,%xmm0
call   1070 <exp@plt>
divsd  0xdc4(%rip),%xmm0
movsd  %xmm0,(%r12,%rbx,8)
add    $0x1,%rbx
cmp    $0x1001,%rbx
jne    1220 <convolved_fit+0xa0>
cmpl   $0x0,0x70(%rsp)
movapd 0xc0(%rsp),%xmm0
jle    1ed7 <convolved_fit+0xd57>
movslq 0x74(%rsp),%rax
lea    -0x1(%rax),%rcx
mov    %rcx,0x148(%rsp)
lea    -0x1(%rax),%ecx
mov    %rcx,0x138(%rsp)
mov    0x68(%rsp),%rdx
lea    -0x8(%rdx,%rax,8),%rcx
mov    %rcx,0xe0(%rsp)
lea    -0x2(%rax),%ecx
movslq %ecx,%rcx
mov    %rcx,0x140(%rsp)
mov    0x50(%rsp),%ecx
lea    (%rdx,%rax,8),%rax
mov    %rax,0x128(%rsp)
add    $0xffffffffffffffff,%rcx
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
mov    %rcx,0x130(%rsp)
and    $0xfffffffffffffffe,%rcx
neg    %rcx
mov    %rcx,0x120(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0xd8(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0x90(%rsp)
lea    0x70(%r13),%rax
mov    %rax,0x110(%rsp)
lea    0x70(%r15),%rax
mov    %rax,0x108(%rsp)
lea    0x10(%r13),%rax
mov    %rax,0x118(%rsp)
xor    %ebp,%ebp
mov    %r13,0xb0(%rsp)
mov    %r15,0x100(%rsp)
mov    %r12,0xa8(%rsp)
movapd %xmm2,0x170(%rsp)
mov    %r14,0x98(%rsp)
jmp    136d <convolved_fit+0x1ed>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%ebp
cmp    0x70(%rsp),%ebp
je     1ed7 <convolved_fit+0xd57>
mov    %rbp,0x150(%rsp)
mov    0x68(%rsp),%r12
mov    0x148(%rsp),%rbx
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0xf0(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
mov    $0xa,%edi
call   1090 <pow@plt>
movsd  0x10(%rsp),%xmm4
xorpd  %xmm3,%xmm3
movsd  (%r12,%rbx,8),%xmm5
mov    0x140(%rsp),%rax
subsd  (%r12,%rax,8),%xmm5
addsd  0xc55(%rip),%xmm4
movq   $0x0,(%r15)
mov    0x50(%rsp),%rax
mov    %eax,%r8d
mov    $0x0,%ebp
cmp    $0x2,%eax
jl     1500 <convolved_fit+0x380>
jne    1440 <convolved_fit+0x2c0>
xor    %ebp,%ebp
mov    $0x1,%eax
mov    0x50(%rsp),%rcx
mov    %ecx,%r8d
testb  $0x1,0x130(%rsp)
je     1500 <convolved_fit+0x380>
movq   $0x0,(%r15,%rax,8)
movsd  -0x8(%r13,%rax,8),%xmm1
movsd  0x0(%r13,%rax,8),%xmm2
ucomisd %xmm3,%xmm2
jne    1429 <convolved_fit+0x2a9>
jnp    14f5 <convolved_fit+0x375>
ucomisd %xmm3,%xmm1
jne    1500 <convolved_fit+0x380>
jp     1500 <convolved_fit+0x380>
mov    %eax,%ebp
jmp    1500 <convolved_fit+0x380>
xor    %ebp,%ebp
mov    $0x1,%eax
mov    0x50(%rsp),%rcx
mov    %ecx,%r8d
mov    0x120(%rsp),%rdx
jmp    1472 <convolved_fit+0x2f2>
nopl   0x0(%rax)
lea    (%rdx,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
je     13f9 <convolved_fit+0x279>
movq   $0x0,(%r15,%rax,8)
movsd  -0x8(%r13,%rax,8),%xmm1
movsd  0x0(%r13,%rax,8),%xmm2
ucomisd %xmm3,%xmm2
jne    1490 <convolved_fit+0x310>
jnp    14a0 <convolved_fit+0x320>
ucomisd %xmm3,%xmm1
jne    14ab <convolved_fit+0x32b>
jp     14ab <convolved_fit+0x32b>
mov    %eax,%ebp
jmp    14ab <convolved_fit+0x32b>
nopl   0x0(%rax)
ucomisd %xmm3,%xmm1
jne    14a8 <convolved_fit+0x328>
jnp    14ab <convolved_fit+0x32b>
mov    %eax,%r8d
movq   $0x0,0x8(%r15,%rax,8)
movsd  0x0(%r13,%rax,8),%xmm1
movsd  0x8(%r13,%rax,8),%xmm2
ucomisd %xmm3,%xmm2
jne    14ca <convolved_fit+0x34a>
jnp    14e0 <convolved_fit+0x360>
ucomisd %xmm3,%xmm1
jne    1460 <convolved_fit+0x2e0>
jp     1460 <convolved_fit+0x2e0>
lea    0x1(%rax),%ebp
jmp    1460 <convolved_fit+0x2e0>
nopw   0x0(%rax,%rax,1)
ucomisd %xmm3,%xmm1
jne    14ec <convolved_fit+0x36c>
jnp    1460 <convolved_fit+0x2e0>
lea    0x1(%rax),%r8d
jmp    1460 <convolved_fit+0x2e0>
ucomisd %xmm3,%xmm1
jne    14fd <convolved_fit+0x37d>
jnp    1500 <convolved_fit+0x380>
mov    %eax,%r8d
mulsd  %xmm5,%xmm0
xorpd  %xmm1,%xmm1
movsd  %xmm0,0x28(%rsp)
ucomisd %xmm1,%xmm0
mov    %r8,0x40(%rsp)
mov    %ebp,0x24(%rsp)
jbe    1810 <convolved_fit+0x690>
movslq %ebp,%rbx
movslq %r8d,%rdi
lea    (%r15,%rbx,8),%rax
lea    (%r15,%rdi,8),%rcx
lea    (%r14,%rbx,8),%r9
lea    (%r14,%rdi,8),%rdx
mov    %rdi,%rsi
sub    %rbx,%rsi
cmp    %rdx,%rax
setb   %r10b
cmp    %rcx,%r9
setb   %dl
and    %r10b,%dl
cmp    0x128(%rsp),%rax
setb   %al
cmp    %rcx,0xe0(%rsp)
setb   %cl
and    %al,%cl
or     %dl,%cl
mov    %cl,0xa0(%rsp)
mov    %rsi,0x88(%rsp)
and    $0xfffffffffffffffc,%rsi
mov    %rsi,0x58(%rsp)
lea    (%rsi,%rbx,1),%rax
mov    %rax,0x38(%rsp)
mov    %rdi,%rax
neg    %rax
mov    %rax,0x80(%rsp)
mov    0xd8(%rsp),%rax
lea    (%rax,%rbx,8),%rax
mov    %rax,0x78(%rsp)
mov    0x90(%rsp),%rax
mov    %rbx,0x60(%rsp)
lea    (%rax,%rbx,8),%rbx
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %rbx,0x48(%rsp)
jmp    15f0 <convolved_fit+0x470>
nopl   0x0(%rax)
movsd  0x10(%rsp),%xmm4
subsd  %xmm5,%xmm4
movsd  0x28(%rsp),%xmm0
movsd  %xmm7,0x30(%rsp)
ucomisd %xmm7,%xmm0
jbe    181a <convolved_fit+0x69a>
xorpd  %xmm0,%xmm0
cmp    %r8d,%ebp
mov    0xb0(%rsp),%r12
mov    0xa8(%rsp),%r13
mov    0xe8(%rsp),%rbp
mov    %rdi,%rbx
movsd  %xmm4,0x10(%rsp)
jge    1683 <convolved_fit+0x503>
xorpd  %xmm0,%xmm0
mov    0x60(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm0,0x18(%rsp)
movapd %xmm4,%xmm0
subsd  (%r12,%r15,8),%xmm0
movsd  0xb8(%rsp),%xmm1
mov    %r13,%rdi
call   1040 <gaussian_cache@plt>
movsd  0x10(%rsp),%xmm4
movsd  %xmm0,(%r14,%r15,8)
mulsd  0x0(%rbp,%r15,8),%xmm0
movsd  0x18(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0x18(%rsp),%xmm0
add    $0x1,%r15
cmp    %r15,%rbx
jne    1630 <convolved_fit+0x4b0>
mulsd  0xc0(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
call   1050 <isfinite@plt>
xorpd  %xmm7,%xmm7
test   %eax,%eax
je     16ab <convolved_fit+0x52b>
movsd  0x18(%rsp),%xmm7
mov    0x40(%rsp),%r8
mov    0x24(%rsp),%ebp
cmp    %r8d,%ebp
movapd 0xc0(%rsp),%xmm5
mov    0x100(%rsp),%r15
mov    0xe0(%rsp),%rsi
movapd 0x170(%rsp),%xmm6
mov    %rbx,%rdi
mov    0x48(%rsp),%rbx
jge    15d0 <convolved_fit+0x450>
cmpq   $0x4,0x88(%rsp)
setb   %al
or     0xa0(%rsp),%al
mov    0x60(%rsp),%rcx
jne    1775 <convolved_fit+0x5f5>
movsd  (%rsi),%xmm0
unpcklpd %xmm0,%xmm0
xor    %eax,%eax
mov    0x58(%rsp),%rdx
mov    0x78(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rcx,%rax,8),%xmm1
movupd (%rcx,%rax,8),%xmm2
mulpd  %xmm6,%xmm1
mulpd  %xmm6,%xmm2
movupd -0x10(%rbx,%rax,8),%xmm3
movupd (%rbx,%rax,8),%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,-0x10(%rbx,%rax,8)
movupd %xmm2,(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1720 <convolved_fit+0x5a0>
mov    0x38(%rsp),%rcx
cmp    %rdx,0x88(%rsp)
je     15d0 <convolved_fit+0x450>
mov    %r8d,%edx
sub    %ecx,%edx
mov    %rcx,%rax
test   $0x1,%dl
je     17a0 <convolved_fit+0x620>
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
mulsd  (%rsi),%xmm0
addsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
lea    0x1(%rcx),%rax
not    %rcx
cmp    0x80(%rsp),%rcx
je     15d0 <convolved_fit+0x450>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
mulsd  (%rsi),%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
mulsd  (%rsi),%xmm0
addsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    17c0 <convolved_fit+0x640>
jmp    15d0 <convolved_fit+0x450>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  %xmm4,0x10(%rsp)
movsd  0x28(%rsp),%xmm0
call   10a0 <log10@plt>
mov    %ebp,%edi
mov    0x40(%rsp),%r8
movsd  %xmm0,0x38(%rsp)
cmpl   $0x2,0x74(%rsp)
mov    0xe8(%rsp),%r12
jl     1cc0 <convolved_fit+0xb40>
movslq %edi,%rbx
movslq %r8d,%rcx
lea    (%r15,%rbx,8),%rax
lea    (%r15,%rcx,8),%r8
lea    (%r14,%rbx,8),%rdx
lea    (%r14,%rcx,8),%rsi
mov    %rcx,%rdi
sub    %rbx,%rdi
cmp    %rsi,%rax
setb   %al
cmp    %r8,%rdx
setb   %dl
and    %al,%dl
mov    %dl,0xf(%rsp)
mov    %rdi,0x80(%rsp)
and    $0xfffffffffffffffc,%rdi
mov    %rdi,0x160(%rsp)
lea    (%rdi,%rbx,1),%rax
mov    %rax,0x158(%rsp)
mov    %rcx,%rax
neg    %rax
mov    %rax,0x168(%rsp)
mov    0xd8(%rsp),%rax
lea    (%rax,%rbx,8),%rsi
mov    0x90(%rsp),%rax
mov    %rbx,0x60(%rsp)
lea    (%rax,%rbx,8),%rbp
mov    %rcx,%rbx
mov    0x138(%rsp),%rax
mov    %rax,0xf8(%rsp)
mov    %rsi,0x88(%rsp)
mov    %rbp,0xa0(%rsp)
jmp    191f <convolved_fit+0x79f>
nopl   0x0(%rax)
mov    0x98(%rsp),%r14
mov    0x40(%rsp),%r8
mov    0x24(%rsp),%edi
movsd  %xmm1,0x10(%rsp)
movsd  0x58(%rsp),%xmm0
movsd  %xmm0,0x38(%rsp)
cmpq   $0x1,0x78(%rsp)
jle    1cc0 <convolved_fit+0xb40>
movsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    0xf8(%rsp),%rbp
lea    -0x1(%rbp),%rax
mov    %rax,0xf8(%rsp)
mov    %eax,%r13d
mov    0xf0(%rsp),%r14
movsd  (%r14,%r13,8),%xmm0
mov    $0xa,%edi
call   1090 <pow@plt>
movsd  %xmm0,0x48(%rsp)
movsd  (%r14,%rbp,8),%xmm0
mov    $0xa,%edi
call   1090 <pow@plt>
movsd  0x48(%rsp),%xmm1
subsd  %xmm0,%xmm1
mov    0x68(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
subsd  (%rax,%r13,8),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x28(%rsp)
mov    $0xa,%edi
call   1080 <log@plt>
mov    %r13,0x48(%rsp)
movsd  (%r14,%r13,8),%xmm1
mov    %rbp,0x78(%rsp)
subsd  (%r14,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x28(%rsp),%xmm0
divsd  %xmm1,%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
call   10a0 <log10@plt>
movsd  %xmm0,0x58(%rsp)
movsd  0x28(%rsp),%xmm0
ucomisd 0x30(%rsp),%xmm0
jbe    1ca0 <convolved_fit+0xb20>
xorpd  %xmm0,%xmm0
movsd  0x10(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jb     18f0 <convolved_fit+0x770>
movsd  0x38(%rsp),%xmm0
subsd  0x58(%rsp),%xmm0
movsd  %xmm0,0x38(%rsp)
mov    0x98(%rsp),%r14
mov    0x40(%rsp),%r8
mov    0x24(%rsp),%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorpd  %xmm2,%xmm2
cmp    %r8d,%edi
movsd  0xb8(%rsp),%xmm3
mov    %r12,%r15
mov    %rbx,%r13
mov    %r14,%rbx
mov    0xb0(%rsp),%r14
mov    0xa8(%rsp),%rbp
movsd  %xmm1,0x10(%rsp)
jge    1ab6 <convolved_fit+0x936>
xorpd  %xmm2,%xmm2
mov    0x60(%rsp),%r12
nopw   0x0(%rax,%rax,1)
movsd  %xmm2,0x18(%rsp)
movsd  0x10(%rsp),%xmm0
subsd  (%r14,%r12,8),%xmm0
movapd %xmm3,%xmm1
mov    %rbp,%rdi
call   1040 <gaussian_cache@plt>
movsd  0xb8(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
movsd  %xmm0,(%rbx,%r12,8)
mulsd  (%r15,%r12,8),%xmm0
addsd  %xmm0,%xmm2
add    $0x1,%r12
cmp    %r12,%r13
jne    1a70 <convolved_fit+0x8f0>
mulsd  0xc0(%rsp),%xmm2
movsd  0x30(%rsp),%xmm0
addsd  %xmm2,%xmm0
mov    0x68(%rsp),%rax
mov    0x48(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  %xmm0,0x30(%rsp)
call   10a0 <log10@plt>
movapd 0xc0(%rsp),%xmm6
mov    0x40(%rsp),%r8
mov    0x24(%rsp),%edi
cmp    %r8d,%edi
mov    %r15,%r12
mov    0x100(%rsp),%r15
mov    %rbx,%r14
movapd 0x170(%rsp),%xmm7
mov    %r13,%rbx
mov    0x88(%rsp),%rsi
mov    0xa0(%rsp),%rbp
jge    1c70 <convolved_fit+0xaf0>
subsd  0x58(%rsp),%xmm0
divsd  0x38(%rsp),%xmm0
mov    0x68(%rsp),%rax
mov    0x78(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x48(%rsp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rsp),%xmm1
cmpq   $0x4,0x80(%rsp)
setb   %al
or     0xf(%rsp),%al
mov    0x60(%rsp),%rcx
jne    1bed <convolved_fit+0xa6d>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
xor    %eax,%eax
mov    0x160(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rsi,%rax,8),%xmm2
movupd (%rsi,%rax,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd -0x10(%rbp,%rax,8),%xmm4
movupd 0x0(%rbp,%rax,8),%xmm5
mulpd  %xmm7,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%rbp,%rax,8)
movupd %xmm3,0x0(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1b90 <convolved_fit+0xa10>
mov    %rcx,%rax
mov    0x158(%rsp),%rcx
cmp    %rax,0x80(%rsp)
je     1c70 <convolved_fit+0xaf0>
mov    %r8d,%edx
sub    %ecx,%edx
mov    %rcx,%rax
test   $0x1,%dl
je     1c18 <convolved_fit+0xa98>
movsd  (%r14,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm6,%xmm0
addsd  (%r15,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rcx,8)
lea    0x1(%rcx),%rax
not    %rcx
cmp    0x168(%rsp),%rcx
je     1c70 <convolved_fit+0xaf0>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r14,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm6,%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  %xmm6,%xmm0
addsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    1c30 <convolved_fit+0xab0>
movsd  0x10(%rsp),%xmm1
subsd  %xmm6,%xmm1
movsd  0x28(%rsp),%xmm0
ucomisd 0x30(%rsp),%xmm0
jbe    1901 <convolved_fit+0x781>
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jae    1a30 <convolved_fit+0x8b0>
jmp    1901 <convolved_fit+0x781>
nop
mov    0x98(%rsp),%r14
mov    0x40(%rsp),%r8
movsd  0x10(%rsp),%xmm1
jmp    18fd <convolved_fit+0x77d>
nopl   0x0(%rax,%rax,1)
cmp    %r8d,%edi
mov    0xb0(%rsp),%r13
mov    0xa8(%rsp),%r12
mov    0x150(%rsp),%rbp
jge    1360 <convolved_fit+0x1e0>
mov    %edi,%eax
movslq %edi,%rax
movslq %r8d,%r11
mov    %r11,%r9
sub    %rax,%r9
cmp    $0x4,%r9
jb     1e30 <convolved_fit+0xcb0>
lea    0x0(,%rax,8),%rdx
add    %r13,%rdx
lea    (%r15,%r11,8),%rsi
cmp    %rsi,%rdx
jae    1d25 <convolved_fit+0xba5>
lea    0x0(,%r11,8),%rdx
add    %r13,%rdx
lea    (%r15,%rax,8),%rsi
cmp    %rdx,%rsi
jb     1e30 <convolved_fit+0xcb0>
mov    %r9,%rdi
and    $0xfffffffffffffffc,%rdi
lea    -0x4(%rdi),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
cmp    $0xc,%rdx
jae    1d4f <convolved_fit+0xbcf>
xor    %ebx,%ebx
jmp    1dcc <convolved_fit+0xc4c>
and    $0xfffffffffffffffc,%rcx
mov    0x110(%rsp),%rdx
lea    (%rdx,%rax,8),%rsi
mov    0x108(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
xor    %ebx,%ebx
nopl   (%rax)
movups -0x70(%rdx,%rbx,8),%xmm0
movups -0x60(%rdx,%rbx,8),%xmm1
movups %xmm0,-0x70(%rsi,%rbx,8)
movups %xmm1,-0x60(%rsi,%rbx,8)
movups -0x50(%rdx,%rbx,8),%xmm0
movups -0x40(%rdx,%rbx,8),%xmm1
movups %xmm0,-0x50(%rsi,%rbx,8)
movups %xmm1,-0x40(%rsi,%rbx,8)
movups -0x30(%rdx,%rbx,8),%xmm0
movups -0x20(%rdx,%rbx,8),%xmm1
movups %xmm0,-0x30(%rsi,%rbx,8)
movups %xmm1,-0x20(%rsi,%rbx,8)
movupd -0x10(%rdx,%rbx,8),%xmm0
movupd (%rdx,%rbx,8),%xmm1
movupd %xmm0,-0x10(%rsi,%rbx,8)
movupd %xmm1,(%rsi,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rcx
jne    1d70 <convolved_fit+0xbf0>
test   %r10,%r10
je     1e1f <convolved_fit+0xc9f>
add    %rax,%rbx
mov    0x118(%rsp),%rdx
lea    (%rdx,%rbx,8),%rdx
mov    0x90(%rsp),%rsi
lea    (%rsi,%rbx,8),%rsi
shl    $0x5,%r10
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%rsi,%rcx,1),%xmm0
movupd (%rsi,%rcx,1),%xmm1
movupd %xmm0,-0x10(%rdx,%rcx,1)
movupd %xmm1,(%rdx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r10
jne    1e00 <convolved_fit+0xc80>
cmp    %rdi,%r9
je     1360 <convolved_fit+0x1e0>
add    %rdi,%rax
nopl   0x0(%rax,%rax,1)
sub    %eax,%r8d
mov    %rax,%rdx
not    %rdx
add    %r11,%rdx
and    $0x3,%r8
je     1e67 <convolved_fit+0xce7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%r8
jne    1e50 <convolved_fit+0xcd0>
cmp    $0x3,%rdx
jb     1360 <convolved_fit+0x1e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%r11
jne    1e80 <convolved_fit+0xd00>
jmp    1360 <convolved_fit+0x1e0>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
define void @convolved_fit(double* %0, double* %1, i32 %2, double* %3, double* %4, i32 %5, double %6, i32 %7, double %8) {
%10 = alloca double*
%11 = alloca double*
%12 = alloca i32
%13 = alloca double*
%14 = alloca double*
%15 = alloca i32
%16 = alloca double
%17 = alloca i32
%18 = alloca double
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double*
%33 = alloca double*
%34 = alloca double*
store double* %0, double** %10
store double* %1, double** %11
store i32 %2, i32* %12
store double* %3, double** %13
store double* %4, double** %14
store i32 %5, i32* %15
store double %6, double* %16
store i32 %7, i32* %17
store double %8, double* %18
%35 = load i32, i32* %17
%36 = icmp ne i32 %35, 0
br i1 %36, label %37, label %40
37: ; preds = %9
%38 = load double, double* %16
%39 = fcmp une double %38, 0.000000e+00
br i1 %39, label %41, label %40
40: ; preds = %37, %9
br label %439
41: ; preds = %37
%42 = load i32, i32* %15
%43 = sext i32 %42 to i64
%44 = mul i64 %43, 8
%45 = trunc i64 %44 to i32
%46 = call i64 @malloc(i32 %45)
%47 = inttoptr i64 %46 to double*
store double* %47, double** %32
%48 = load i32, i32* %15
%49 = sext i32 %48 to i64
%50 = mul i64 %49, 8
%51 = trunc i64 %50 to i32
%52 = call i64 @malloc(i32 %51)
%53 = inttoptr i64 %52 to double*
store double* %53, double** %33
%54 = call i64 @malloc(i32 32776)
%55 = inttoptr i64 %54 to double*
store double* %55, double** %34
store i32 0, i32* %19
br label %56
56: ; preds = %75, %41
%57 = load i32, i32* %19
%58 = icmp slt i32 %57, 4097
br i1 %58, label %59, label %78
59: ; preds = %56
%60 = load i32, i32* %19
%61 = sitofp i32 %60 to double
%62 = fdiv double %61, 2.560000e+02
%63 = fsub double %62, 8.000000e+00
store double %63, double* %24
%64 = load double, double* %24
%65 = fmul double -5.000000e-01, %64
%66 = load double, double* %24
%67 = fmul double %65, %66
%68 = call double @exp(double %67)
%69 = call double @sqrt(double 0x401921FB54411744)
%70 = fdiv double %68, %69
%71 = load double*, double** %34
%72 = load i32, i32* %19
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double, double* %71, i64 %73
store double %70, double* %74
br label %75
75: ; preds = %59
%76 = load i32, i32* %19
%77 = add nsw i32 %76, 1
store i32 %77, i32* %19
br label %56
78: ; preds = %56
store i32 0, i32* %21
br label %79
79: ; preds = %429, %78
%80 = load i32, i32* %21
%81 = load i32, i32* %17
%82 = icmp slt i32 %80, %81
br i1 %82, label %83, label %432
83: ; preds = %79
store i32 0, i32* %22
%84 = load i32, i32* %15
store i32 %84, i32* %23
%85 = load double*, double** %10
%86 = load i32, i32* %12
%87 = sub nsw i32 %86, 1
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %85, i64 %88
%90 = load double, double* %89
%91 = fadd double %90, 1.000000e+00
store double %91, double* %25
%92 = load double*, double** %11
%93 = load i32, i32* %12
%94 = sub nsw i32 %93, 1
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %92, i64 %95
%97 = load double, double* %96
%98 = call double @pow(i32 10, double %97)
%99 = load double*, double** %10
%100 = load i32, i32* %12
%101 = sub nsw i32 %100, 1
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %99, i64 %102
%104 = load double, double* %103
%105 = load double*, double** %10
%106 = load i32, i32* %12
%107 = sub nsw i32 %106, 2
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds double, double* %105, i64 %108
%110 = load double, double* %109
%111 = fsub double %104, %110
%112 = fmul double %98, %111
store double %112, double* %26
%113 = load double*, double** %32
%114 = getelementptr inbounds double, double* %113, i64 0
store double 0.000000e+00, double* %114
store i32 1, i32* %19
br label %115
115: ; preds = %158, %83
%116 = load i32, i32* %19
%117 = load i32, i32* %15
%118 = icmp slt i32 %116, %117
br i1 %118, label %119, label %161
119: ; preds = %115
%120 = load double*, double** %32
%121 = load i32, i32* %19
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %120, i64 %122
store double 0.000000e+00, double* %123
%124 = load double*, double** %13
%125 = load i32, i32* %19
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds double, double* %124, i64 %126
%128 = load double, double* %127
%129 = fcmp une double %128, 0.000000e+00
br i1 %129, label %130, label %140
130: ; preds = %119
%131 = load double*, double** %13
%132 = load i32, i32* %19
%133 = sub nsw i32 %132, 1
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %131, i64 %134
%136 = load double, double* %135
%137 = fcmp une double %136, 0.000000e+00
br i1 %137, label %140, label %138
138: ; preds = %130
%139 = load i32, i32* %19
store i32 %139, i32* %22
br label %140
140: ; preds = %138, %130, %119
%141 = load double*, double** %13
%142 = load i32, i32* %19
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %141, i64 %143
%145 = load double, double* %144
%146 = fcmp une double %145, 0.000000e+00
br i1 %146, label %157, label %147
147: ; preds = %140
%148 = load double*, double** %13
%149 = load i32, i32* %19
%150 = sub nsw i32 %149, 1
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds double, double* %148, i64 %151
%153 = load double, double* %152
%154 = fcmp une double %153, 0.000000e+00
br i1 %154, label %155, label %157
155: ; preds = %147
%156 = load i32, i32* %19
store i32 %156, i32* %23
br label %157
157: ; preds = %155, %147, %140
br label %158
158: ; preds = %157
%159 = load i32, i32* %19
%160 = add nsw i32 %159, 1
store i32 %160, i32* %19
br label %115
161: ; preds = %115
store double 0.000000e+00, double* %30
br label %162
162: ; preds = %240, %161
%163 = load double, double* %30
%164 = load double, double* %26
%165 = fcmp olt double %163, %164
br i1 %165, label %166, label %244
166: ; preds = %162
store double 0.000000e+00, double* %31
%167 = load i32, i32* %22
store i32 %167, i32* %20
br label %168
168: ; preds = %199, %166
%169 = load i32, i32* %20
%170 = load i32, i32* %23
%171 = icmp slt i32 %169, %170
br i1 %171, label %172, label %202
172: ; preds = %168
%173 = load double, double* %25
%174 = load double*, double** %13
%175 = load i32, i32* %20
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds double, double* %174, i64 %176
%178 = load double, double* %177
%179 = fsub double %173, %178
%180 = load double, double* %16
%181 = load double*, double** %34
%182 = call double @gaussian_cache(double %179, double %180, double* %181)
%183 = load double*, double** %33
%184 = load i32, i32* %20
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %183, i64 %185
store double %182, double* %186
%187 = load double*, double** %33
%188 = load i32, i32* %20
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds double, double* %187, i64 %189
%191 = load double, double* %190
%192 = load double*, double** %14
%193 = load i32, i32* %20
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds double, double* %192, i64 %194
%196 = load double, double* %195
%197 = load double, double* %31
%198 = call double @llvm.fmuladd.f64(double %191, double %196, double %197)
store double %198, double* %31
br label %199
199: ; preds = %172
%200 = load i32, i32* %20
%201 = add nsw i32 %200, 1
store i32 %201, i32* %20
br label %168
202: ; preds = %168
%203 = load double, double* %31
%204 = load double, double* %18
%205 = load double, double* %30
%206 = call double @llvm.fmuladd.f64(double %203, double %204, double %205)
store double %206, double* %30
%207 = load double, double* %30
%208 = call i32 @isfinite(double %207)
%209 = icmp ne i32 %208, 0
br i1 %209, label %211, label %210
210: ; preds = %202
store double 0.000000e+00, double* %30
br label %211
211: ; preds = %210, %202
%212 = load i32, i32* %22
store i32 %212, i32* %20
br label %213
213: ; preds = %237, %211
%214 = load i32, i32* %20
%215 = load i32, i32* %23
%216 = icmp slt i32 %214, %215
br i1 %216, label %217, label %240
217: ; preds = %213
%218 = load double*, double** %33
%219 = load i32, i32* %20
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds double, double* %218, i64 %220
%222 = load double, double* %221
%223 = load double, double* %18
%224 = fmul double %222, %223
%225 = load double*, double** %10
%226 = load i32, i32* %12
%227 = sub nsw i32 %226, 1
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds double, double* %225, i64 %228
%230 = load double, double* %229
%231 = load double*, double** %32
%232 = load i32, i32* %20
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds double, double* %231, i64 %233
%235 = load double, double* %234
%236 = call double @llvm.fmuladd.f64(double %224, double %230, double %235)
store double %236, double* %234
br label %237
237: ; preds = %217
%238 = load i32, i32* %20
%239 = add nsw i32 %238, 1
store i32 %239, i32* %20
br label %213
240: ; preds = %213
%241 = load double, double* %18
%242 = load double, double* %25
%243 = fsub double %242, %241
store double %243, double* %25
br label %162
244: ; preds = %162
%245 = load double, double* %26
%246 = call double @log10(double %245)
store double %246, double* %28
%247 = load i32, i32* %12
%248 = sub nsw i32 %247, 1
store i32 %248, i32* %19
br label %249
249: ; preds = %406, %244
%250 = load i32, i32* %19
%251 = icmp sgt i32 %250, 0
br i1 %251, label %252, label %409
252: ; preds = %249
%253 = load double, double* %26
%254 = load double*, double** %11
%255 = load i32, i32* %19
%256 = sub nsw i32 %255, 1
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double, double* %254, i64 %257
%259 = load double, double* %258
%260 = call double @pow(i32 10, double %259)
%261 = load double*, double** %11
%262 = load i32, i32* %19
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %261, i64 %263
%265 = load double, double* %264
%266 = call double @pow(i32 10, double %265)
%267 = fsub double %260, %266
%268 = load double*, double** %10
%269 = load i32, i32* %19
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %268, i64 %270
%272 = load double, double* %271
%273 = load double*, double** %10
%274 = load i32, i32* %19
%275 = sub nsw i32 %274, 1
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double, double* %273, i64 %276
%278 = load double, double* %277
%279 = fsub double %272, %278
%280 = fmul double %267, %279
%281 = call double @log(i32 10)
%282 = load double*, double** %11
%283 = load i32, i32* %19
%284 = sub nsw i32 %283, 1
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %282, i64 %285
%287 = load double, double* %286
%288 = load double*, double** %11
%289 = load i32, i32* %19
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %288, i64 %290
%292 = load double, double* %291
%293 = fsub double %287, %292
%294 = fmul double %281, %293
%295 = fdiv double %280, %294
%296 = fadd double %253, %295
store double %296, double* %27
%297 = load double, double* %27
%298 = call double @log10(double %297)
store double %298, double* %29
br label %299
299: ; preds = %399, %252
%300 = load double, double* %30
%301 = load double, double* %27
%302 = fcmp olt double %300, %301
br i1 %302, label %303, label %306
303: ; preds = %299
%304 = load double, double* %25
%305 = fcmp oge double %304, 0.000000e+00
br label %306
306: ; preds = %303, %299
%307 = phi i1 [ false, %299 ], [ %305, %303 ]
br i1 %307, label %308, label %403
308: ; preds = %306
store double 0.000000e+00, double* %31
%309 = load i32, i32* %22
store i32 %309, i32* %20
br label %310
310: ; preds = %341, %308
%311 = load i32, i32* %20
%312 = load i32, i32* %23
%313 = icmp slt i32 %311, %312
br i1 %313, label %314, label %344
314: ; preds = %310
%315 = load double, double* %25
%316 = load double*, double** %13
%317 = load i32, i32* %20
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds double, double* %316, i64 %318
%320 = load double, double* %319
%321 = fsub double %315, %320
%322 = load double, double* %16
%323 = load double*, double** %34
%324 = call double @gaussian_cache(double %321, double %322, double* %323)
%325 = load double*, double** %33
%326 = load i32, i32* %20
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds double, double* %325, i64 %327
store double %324, double* %328
%329 = load double*, double** %33
%330 = load i32, i32* %20
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds double, double* %329, i64 %331
%333 = load double, double* %332
%334 = load double*, double** %14
%335 = load i32, i32* %20
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds double, double* %334, i64 %336
%338 = load double, double* %337
%339 = load double, double* %31
%340 = call double @llvm.fmuladd.f64(double %333, double %338, double %339)
store double %340, double* %31
br label %341
341: ; preds = %314
%342 = load i32, i32* %20
%343 = add nsw i32 %342, 1
store i32 %343, i32* %20
br label %310
344: ; preds = %310
%345 = load double, double* %31
%346 = load double, double* %18
%347 = load double, double* %30
%348 = call double @llvm.fmuladd.f64(double %345, double %346, double %347)
store double %348, double* %30
%349 = load double*, double** %10
%350 = load i32, i32* %19
%351 = sub nsw i32 %350, 1
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds double, double* %349, i64 %352
%354 = load double, double* %353
%355 = load double, double* %30
%356 = call double @log10(double %355)
%357 = load double, double* %29
%358 = fsub double %356, %357
%359 = load double, double* %28
%360 = load double, double* %29
%361 = fsub double %359, %360
%362 = fdiv double %358, %361
%363 = load double*, double** %10
%364 = load i32, i32* %19
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds double, double* %363, i64 %365
%367 = load double, double* %366
%368 = load double*, double** %10
%369 = load i32, i32* %19
%370 = sub nsw i32 %369, 1
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds double, double* %368, i64 %371
%373 = load double, double* %372
%374 = fsub double %367, %373
%375 = call double @llvm.fmuladd.f64(double %362, double %374, double %354)
store double %375, double* %24
%376 = load i32, i32* %22
store i32 %376, i32* %20
br label %377
377: ; preds = %396, %344
%378 = load i32, i32* %20
%379 = load i32, i32* %23
%380 = icmp slt i32 %378, %379
br i1 %380, label %381, label %399
381: ; preds = %377
%382 = load double*, double** %33
%383 = load i32, i32* %20
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds double, double* %382, i64 %384
%386 = load double, double* %385
%387 = load double, double* %24
%388 = fmul double %386, %387
%389 = load double, double* %18
%390 = load double*, double** %32
%391 = load i32, i32* %20
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds double, double* %390, i64 %392
%394 = load double, double* %393
%395 = call double @llvm.fmuladd.f64(double %388, double %389, double %394)
store double %395, double* %393
br label %396
396: ; preds = %381
%397 = load i32, i32* %20
%398 = add nsw i32 %397, 1
store i32 %398, i32* %20
br label %377
399: ; preds = %377
%400 = load double, double* %18
%401 = load double, double* %25
%402 = fsub double %401, %400
store double %402, double* %25
br label %299
403: ; preds = %306
%404 = load double, double* %27
store double %404, double* %26
%405 = load double, double* %29
store double %405, double* %28
br label %406
406: ; preds = %403
%407 = load i32, i32* %19
%408 = add nsw i32 %407, -1
store i32 %408, i32* %19
br label %249
409: ; preds = %249
%410 = load i32, i32* %22
store i32 %410, i32* %20
br label %411
411: ; preds = %425, %409
%412 = load i32, i32* %20
%413 = load i32, i32* %23
%414 = icmp slt i32 %412, %413
br i1 %414, label %415, label %428
415: ; preds = %411
%416 = load double*, double** %32
%417 = load i32, i32* %20
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds double, double* %416, i64 %418
%420 = load double, double* %419
%421 = load double*, double** %13
%422 = load i32, i32* %20
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds double, double* %421, i64 %423
store double %420, double* %424
br label %425
425: ; preds = %415
%426 = load i32, i32* %20
%427 = add nsw i32 %426, 1
store i32 %427, i32* %20
br label %411
428: ; preds = %411
br label %429
429: ; preds = %428
%430 = load i32, i32* %21
%431 = add nsw i32 %430, 1
store i32 %431, i32* %21
br label %79
432: ; preds = %79
%433 = load double*, double** %32
%434 = call i32 @free(double* %433)
%435 = load double*, double** %33
%436 = call i32 @free(double* %435)
%437 = load double*, double** %34
%438 = call i32 @free(double* %437)
br label %439
439: ; preds = %432, %40
ret void
}

LLVM IR (-O2):
define void @convolved_fit(double* nocapture %0, double* nocapture %1, i32 %2, double* nocapture %3, double* nocapture %4, i32 %5, double %6, i32 %7, double %8) {
%10 = icmp ne i32 %7, 0
%11 = fcmp une double %6, 0.000000e+00
%12 = and i1 %11, %10
br i1 %12, label %13, label %559
13: ; preds = %9
%14 = shl i32 %5, 3
%15 = tail call i64 @malloc(i32 %14)
%16 = tail call i64 @malloc(i32 %14)
%17 = tail call i64 @malloc(i32 32776)
%18 = inttoptr i64 %17 to double*
br label %50
19: ; preds = %50
%20 = inttoptr i64 %15 to double*
%21 = inttoptr i64 %16 to double*
%22 = icmp sgt i32 %7, 0
br i1 %22, label %23, label %555
23: ; preds = %19
%24 = add nsw i32 %2, -1
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds double, double* %0, i64 %25
%27 = getelementptr inbounds double, double* %1, i64 %25
%28 = add nsw i32 %2, -2
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds double, double* %0, i64 %29
%31 = icmp sgt i32 %5, 1
%32 = icmp sgt i32 %2, 1
%33 = zext i32 %24 to i64
%34 = zext i32 %5 to i64
%35 = add nsw i64 %25, 1
%36 = getelementptr double, double* %0, i64 %35
%37 = add nsw i64 %34, -1
%38 = and i64 %37, 1
%39 = icmp eq i32 %5, 2
%40 = and i64 %37, -2
%41 = icmp eq i64 %38, 0
%42 = insertelement <2 x double> poison, double %8, i64 0
%43 = shufflevector <2 x double> %42, <2 x double> poison, <2 x i32> zeroinitializer
%44 = insertelement <2 x double> poison, double %8, i64 0
%45 = shufflevector <2 x double> %44, <2 x double> poison, <2 x i32> zeroinitializer
%46 = insertelement <2 x double> poison, double %8, i64 0
%47 = shufflevector <2 x double> %46, <2 x double> poison, <2 x i32> zeroinitializer
%48 = insertelement <2 x double> poison, double %8, i64 0
%49 = shufflevector <2 x double> %48, <2 x double> poison, <2 x i32> zeroinitializer
br label %63
50: ; preds = %13, %50
%51 = phi i64 [ 0, %13 ], [ %61, %50 ]
%52 = trunc i64 %51 to i32
%53 = sitofp i32 %52 to double
%54 = fmul double %53, 3.906250e-03
%55 = fadd double %54, -8.000000e+00
%56 = fmul double %55, -5.000000e-01
%57 = fmul double %55, %56
%58 = tail call double @exp(double %57)
%59 = fdiv double %58, 0x40040D931FF4EBED
%60 = getelementptr inbounds double, double* %18, i64 %51
store double %59, double* %60
%61 = add nuw nsw i64 %51, 1
%62 = icmp eq i64 %61, 4097
br i1 %62, label %19, label %50
63: ; preds = %23, %552
%64 = phi i32 [ 0, %23 ], [ %553, %552 ]
%65 = load double, double* %26
%66 = fadd double %65, 1.000000e+00
%67 = load double, double* %27
%68 = tail call double @pow(i32 10, double %67)
%69 = load double, double* %26
%70 = load double, double* %30
%71 = fsub double %69, %70
%72 = fmul double %68, %71
store double 0.000000e+00, double* %20
br i1 %31, label %73, label %95
73: ; preds = %63
br i1 %39, label %74, label %121
74: ; preds = %157, %73
%75 = phi i32 [ undef, %73 ], [ %158, %157 ]
%76 = phi i32 [ undef, %73 ], [ %159, %157 ]
%77 = phi i64 [ 1, %73 ], [ %160, %157 ]
%78 = phi i32 [ 0, %73 ], [ %158, %157 ]
%79 = phi i32 [ %5, %73 ], [ %159, %157 ]
br i1 %41, label %95, label %80
80: ; preds = %74
%81 = getelementptr inbounds double, double* %20, i64 %77
store double 0.000000e+00, double* %81
%82 = getelementptr inbounds double, double* %3, i64 %77
%83 = load double, double* %82
%84 = fcmp une double %83, 0.000000e+00
%85 = add nsw i64 %77, -1
%86 = getelementptr inbounds double, double* %3, i64 %85
%87 = load double, double* %86
%88 = fcmp une double %87, 0.000000e+00
br i1 %84, label %92, label %89
89: ; preds = %80
br i1 %88, label %90, label %95
90: ; preds = %89
%91 = trunc i64 %77 to i32
br label %95
92: ; preds = %80
br i1 %88, label %95, label %93
93: ; preds = %92
%94 = trunc i64 %77 to i32
br label %95
95: ; preds = %74, %93, %92, %90, %89, %63
%96 = phi i32 [ %5, %63 ], [ %76, %74 ], [ %91, %90 ], [ %79, %89 ], [ %79, %93 ], [ %79, %92 ]
%97 = phi i32 [ 0, %63 ], [ %75, %74 ], [ %78, %90 ], [ %78, %89 ], [ %94, %93 ], [ %78, %92 ]
%98 = fcmp ogt double %72, 0.000000e+00
br i1 %98, label %99, label %257
99: ; preds = %95
%100 = icmp slt i32 %97, %96
%101 = sext i32 %97 to i64
%102 = sext i32 %96 to i64
%103 = sext i32 %96 to i64
%104 = getelementptr double, double* %20, i64 %101
%105 = getelementptr double, double* %20, i64 %102
%106 = getelementptr double, double* %21, i64 %101
%107 = getelementptr double, double* %21, i64 %102
%108 = sub nsw i64 %102, %101
%109 = icmp ult i64 %108, 4
%110 = icmp ult double* %104, %107
%111 = icmp ult double* %106, %105
%112 = and i1 %110, %111
%113 = icmp ult double* %104, %36
%114 = icmp ult double* %26, %105
%115 = and i1 %113, %114
%116 = or i1 %112, %115
%117 = and i64 %108, -4
%118 = add nsw i64 %117, %101
%119 = icmp eq i64 %108, %117
%120 = sub nsw i64 0, %102
br label %163
121: ; preds = %73, %157
%122 = phi i64 [ %160, %157 ], [ 1, %73 ]
%123 = phi i32 [ %158, %157 ], [ 0, %73 ]
%124 = phi i32 [ %159, %157 ], [ %5, %73 ]
%125 = phi i64 [ %161, %157 ], [ 0, %73 ]
%126 = getelementptr inbounds double, double* %20, i64 %122
store double 0.000000e+00, double* %126
%127 = getelementptr inbounds double, double* %3, i64 %122
%128 = load double, double* %127
%129 = fcmp une double %128, 0.000000e+00
%130 = add nsw i64 %122, -1
%131 = getelementptr inbounds double, double* %3, i64 %130
%132 = load double, double* %131
%133 = fcmp une double %132, 0.000000e+00
br i1 %129, label %134, label %137
134: ; preds = %121
br i1 %133, label %140, label %135
135: ; preds = %134
%136 = trunc i64 %122 to i32
br label %140
137: ; preds = %121
br i1 %133, label %138, label %140
138: ; preds = %137
%139 = trunc i64 %122 to i32
br label %140
140: ; preds = %134, %135, %137, %138
%141 = phi i32 [ %123, %138 ], [ %123, %137 ], [ %136, %135 ], [ %123, %134 ]
%142 = phi i32 [ %139, %138 ], [ %124, %137 ], [ %124, %135 ], [ %124, %134 ]
%143 = add nuw nsw i64 %122, 1
%144 = getelementptr inbounds double, double* %20, i64 %143
store double 0.000000e+00, double* %144
%145 = getelementptr inbounds double, double* %3, i64 %143
%146 = load double, double* %145
%147 = fcmp une double %146, 0.000000e+00
%148 = getelementptr inbounds double, double* %3, i64 %122
%149 = load double, double* %148
%150 = fcmp une double %149, 0.000000e+00
br i1 %147, label %154, label %151
151: ; preds = %140
br i1 %150, label %152, label %157
152: ; preds = %151
%153 = trunc i64 %143 to i32
br label %157
154: ; preds = %140
br i1 %150, label %157, label %155
155: ; preds = %154
%156 = trunc i64 %143 to i32
br label %157
157: ; preds = %155, %154, %152, %151
%158 = phi i32 [ %141, %152 ], [ %141, %151 ], [ %156, %155 ], [ %141, %154 ]
%159 = phi i32 [ %153, %152 ], [ %142, %151 ], [ %142, %155 ], [ %142, %154 ]
%160 = add nuw nsw i64 %122, 2
%161 = add i64 %125, 2
%162 = icmp eq i64 %161, %40
br i1 %162, label %74, label %121
163: ; preds = %99, %254
%164 = phi double [ 0.000000e+00, %99 ], [ %184, %254 ]
%165 = phi double [ %66, %99 ], [ %255, %254 ]
br i1 %100, label %166, label %179
166: ; preds = %163, %166
%167 = phi i64 [ %177, %166 ], [ %101, %163 ]
%168 = phi double [ %176, %166 ], [ 0.000000e+00, %163 ]
%169 = getelementptr inbounds double, double* %3, i64 %167
%170 = load double, double* %169
%171 = fsub double %165, %170
%172 = tail call double @gaussian_cache(double %171, double %6, double* %18)
%173 = getelementptr inbounds double, double* %21, i64 %167
store double %172, double* %173
%174 = getelementptr inbounds double, double* %4, i64 %167
%175 = load double, double* %174
%176 = tail call double @llvm.fmuladd.f64(double %172, double %175, double %168)
%177 = add nsw i64 %167, 1
%178 = icmp eq i64 %177, %102
br i1 %178, label %179, label %166
179: ; preds = %166, %163
%180 = phi double [ 0.000000e+00, %163 ], [ %176, %166 ]
%181 = tail call double @llvm.fmuladd.f64(double %180, double %8, double %164)
%182 = tail call i32 @isfinite(double %181)
%183 = icmp eq i32 %182, 0
%184 = select i1 %183, double 0.000000e+00, double %181
br i1 %100, label %185, label %254
185: ; preds = %179
%186 = select i1 %109, i1 true, i1 %116
br i1 %186, label %217, label %187
187: ; preds = %185
%188 = load double, double* %26
%189 = insertelement <2 x double> poison, double %188, i64 0
%190 = shufflevector <2 x double> %189, <2 x double> poison, <2 x i32> zeroinitializer
%191 = insertelement <2 x double> poison, double %188, i64 0
%192 = shufflevector <2 x double> %191, <2 x double> poison, <2 x i32> zeroinitializer
br label %193
193: ; preds = %193, %187
%194 = phi i64 [ 0, %187 ], [ %214, %193 ]
%195 = add i64 %194, %101
%196 = getelementptr inbounds double, double* %21, i64 %195
%197 = bitcast double* %196 to <2 x double>*
%198 = load <2 x double>, <2 x double>* %197
%199 = getelementptr inbounds double, double* %196, i64 2
%200 = bitcast double* %199 to <2 x double>*
%201 = load <2 x double>, <2 x double>* %200
%202 = fmul <2 x double> %198, %43
%203 = fmul <2 x double> %201, %45
%204 = getelementptr inbounds double, double* %20, i64 %195
%205 = bitcast double* %204 to <2 x double>*
%206 = load <2 x double>, <2 x double>* %205
%207 = getelementptr inbounds double, double* %204, i64 2
%208 = bitcast double* %207 to <2 x double>*
%209 = load <2 x double>, <2 x double>* %208
%210 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %202, <2 x double> %190, <2 x double> %206)
%211 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %203, <2 x double> %192, <2 x double> %209)
%212 = bitcast double* %204 to <2 x double>*
store <2 x double> %210, <2 x double>* %212
%213 = bitcast double* %207 to <2 x double>*
store <2 x double> %211, <2 x double>* %213
%214 = add nuw i64 %194, 4
%215 = icmp eq i64 %214, %117
br i1 %215, label %216, label %193
216: ; preds = %193
br i1 %119, label %254, label %217
217: ; preds = %185, %216
%218 = phi i64 [ %101, %185 ], [ %118, %216 ]
%219 = sub nsw i64 %102, %218
%220 = xor i64 %218, -1
%221 = and i64 %219, 1
%222 = icmp eq i64 %221, 0
br i1 %222, label %232, label %223
223: ; preds = %217
%224 = getelementptr inbounds double, double* %21, i64 %218
%225 = load double, double* %224
%226 = fmul double %225, %8
%227 = load double, double* %26
%228 = getelementptr inbounds double, double* %20, i64 %218
%229 = load double, double* %228
%230 = tail call double @llvm.fmuladd.f64(double %226, double %227, double %229)
store double %230, double* %228
%231 = add nsw i64 %218, 1
br label %232
232: ; preds = %223, %217
%233 = phi i64 [ %218, %217 ], [ %231, %223 ]
%234 = icmp eq i64 %220, %120
br i1 %234, label %254, label %235
235: ; preds = %232, %235
%236 = phi i64 [ %252, %235 ], [ %233, %232 ]
%237 = getelementptr inbounds double, double* %21, i64 %236
%238 = load double, double* %237
%239 = fmul double %238, %8
%240 = load double, double* %26
%241 = getelementptr inbounds double, double* %20, i64 %236
%242 = load double, double* %241
%243 = tail call double @llvm.fmuladd.f64(double %239, double %240, double %242)
store double %243, double* %241
%244 = add nsw i64 %236, 1
%245 = getelementptr inbounds double, double* %21, i64 %244
%246 = load double, double* %245
%247 = fmul double %246, %8
%248 = load double, double* %26
%249 = getelementptr inbounds double, double* %20, i64 %244
%250 = load double, double* %249
%251 = tail call double @llvm.fmuladd.f64(double %247, double %248, double %250)
store double %251, double* %249
%252 = add nsw i64 %236, 2
%253 = icmp eq i64 %252, %103
br i1 %253, label %254, label %235
254: ; preds = %232, %235, %216, %179
%255 = fsub double %165, %8
%256 = fcmp olt double %184, %72
br i1 %256, label %163, label %257
257: ; preds = %254, %95
%258 = phi double [ %66, %95 ], [ %255, %254 ]
%259 = phi double [ 0.000000e+00, %95 ], [ %184, %254 ]
%260 = tail call double @log10(double %72)
br i1 %32, label %261, label %283
261: ; preds = %257
%262 = icmp slt i32 %97, %96
%263 = sext i32 %97 to i64
%264 = sext i32 %96 to i64
%265 = sext i32 %96 to i64
%266 = getelementptr double, double* %20, i64 %263
%267 = getelementptr double, double* %20, i64 %264
%268 = getelementptr double, double* %21, i64 %263
%269 = getelementptr double, double* %21, i64 %264
%270 = sub nsw i64 %264, %263
%271 = icmp ult i64 %270, 4
%272 = icmp ult double* %266, %269
%273 = icmp ult double* %268, %267
%274 = and i1 %272, %273
%275 = and i64 %270, -4
%276 = add nsw i64 %275, %263
%277 = icmp eq i64 %270, %275
%278 = sub nsw i64 0, %264
br label %402
279: ; preds = %528, %402
%280 = phi double [ %407, %402 ], [ %529, %528 ]
%281 = phi double [ %404, %402 ], [ %454, %528 ]
%282 = icmp sgt i64 %403, 1
br i1 %282, label %402, label %283
283: ; preds = %279, %257
%284 = icmp slt i32 %97, %96
br i1 %284, label %285, label %552
285: ; preds = %283
%286 = sext i32 %97 to i64
%287 = sext i32 %96 to i64
%288 = sub nsw i64 %287, %286
%289 = icmp ult i64 %288, 4
br i1 %289, label %383, label %290
290: ; preds = %285
%291 = getelementptr double, double* %3, i64 %286
%292 = getelementptr double, double* %3, i64 %287
%293 = getelementptr double, double* %20, i64 %286
%294 = getelementptr double, double* %20, i64 %287
%295 = icmp ult double* %291, %294
%296 = icmp ult double* %293, %292
%297 = and i1 %295, %296
br i1 %297, label %383, label %298
298: ; preds = %290
%299 = and i64 %288, -4
%300 = add nsw i64 %299, %286
%301 = add nsw i64 %299, -4
%302 = lshr exact i64 %301, 2
%303 = add nuw nsw i64 %302, 1
%304 = and i64 %303, 3
%305 = icmp ult i64 %301, 12
br i1 %305, label %361, label %306
306: ; preds = %298
%307 = and i64 %303, 9223372036854775804
br label %308
308: ; preds = %308, %306
%309 = phi i64 [ 0, %306 ], [ %358, %308 ]
%310 = phi i64 [ 0, %306 ], [ %359, %308 ]
%311 = add i64 %309, %286
%312 = getelementptr inbounds double, double* %20, i64 %311
%313 = bitcast double* %312 to <2 x double>*
%314 = load <2 x double>, <2 x double>* %313
%315 = getelementptr inbounds double, double* %312, i64 2
%316 = bitcast double* %315 to <2 x double>*
%317 = load <2 x double>, <2 x double>* %316
%318 = getelementptr inbounds double, double* %3, i64 %311
%319 = bitcast double* %318 to <2 x double>*
store <2 x double> %314, <2 x double>* %319
%320 = getelementptr inbounds double, double* %318, i64 2
%321 = bitcast double* %320 to <2 x double>*
store <2 x double> %317, <2 x double>* %321
%322 = or i64 %309, 4
%323 = add i64 %322, %286
%324 = getelementptr inbounds double, double* %20, i64 %323
%325 = bitcast double* %324 to <2 x double>*
%326 = load <2 x double>, <2 x double>* %325
%327 = getelementptr inbounds double, double* %324, i64 2
%328 = bitcast double* %327 to <2 x double>*
%329 = load <2 x double>, <2 x double>* %328
%330 = getelementptr inbounds double, double* %3, i64 %323
%331 = bitcast double* %330 to <2 x double>*
store <2 x double> %326, <2 x double>* %331
%332 = getelementptr inbounds double, double* %330, i64 2
%333 = bitcast double* %332 to <2 x double>*
store <2 x double> %329, <2 x double>* %333
%334 = or i64 %309, 8
%335 = add i64 %334, %286
%336 = getelementptr inbounds double, double* %20, i64 %335
%337 = bitcast double* %336 to <2 x double>*
%338 = load <2 x double>, <2 x double>* %337
%339 = getelementptr inbounds double, double* %336, i64 2
%340 = bitcast double* %339 to <2 x double>*
%341 = load <2 x double>, <2 x double>* %340
%342 = getelementptr inbounds double, double* %3, i64 %335
%343 = bitcast double* %342 to <2 x double>*
store <2 x double> %338, <2 x double>* %343
%344 = getelementptr inbounds double, double* %342, i64 2
%345 = bitcast double* %344 to <2 x double>*
store <2 x double> %341, <2 x double>* %345
%346 = or i64 %309, 12
%347 = add i64 %346, %286
%348 = getelementptr inbounds double, double* %20, i64 %347
%349 = bitcast double* %348 to <2 x double>*
%350 = load <2 x double>, <2 x double>* %349
%351 = getelementptr inbounds double, double* %348, i64 2
%352 = bitcast double* %351 to <2 x double>*
%353 = load <2 x double>, <2 x double>* %352
%354 = getelementptr inbounds double, double* %3, i64 %347
%355 = bitcast double* %354 to <2 x double>*
store <2 x double> %350, <2 x double>* %355
%356 = getelementptr inbounds double, double* %354, i64 2
%357 = bitcast double* %356 to <2 x double>*
store <2 x double> %353, <2 x double>* %357
%358 = add nuw i64 %309, 16
%359 = add nuw i64 %310, 4
%360 = icmp eq i64 %359, %307
br i1 %360, label %361, label %308
361: ; preds = %308, %298
%362 = phi i64 [ 0, %298 ], [ %358, %308 ]
%363 = icmp eq i64 %304, 0
br i1 %363, label %381, label %364
364: ; preds = %361, %364
%365 = phi i64 [ %378, %364 ], [ %362, %361 ]
%366 = phi i64 [ %379, %364 ], [ 0, %361 ]
%367 = add i64 %365, %286
%368 = getelementptr inbounds double, double* %20, i64 %367
%369 = bitcast double* %368 to <2 x double>*
%370 = load <2 x double>, <2 x double>* %369
%371 = getelementptr inbounds double, double* %368, i64 2
%372 = bitcast double* %371 to <2 x double>*
%373 = load <2 x double>, <2 x double>* %372
%374 = getelementptr inbounds double, double* %3, i64 %367
%375 = bitcast double* %374 to <2 x double>*
store <2 x double> %370, <2 x double>* %375
%376 = getelementptr inbounds double, double* %374, i64 2
%377 = bitcast double* %376 to <2 x double>*
store <2 x double> %373, <2 x double>* %377
%378 = add nuw i64 %365, 4
%379 = add i64 %366, 1
%380 = icmp eq i64 %379, %304
br i1 %380, label %381, label %364
381: ; preds = %364, %361
%382 = icmp eq i64 %288, %299
br i1 %382, label %552, label %383
383: ; preds = %290, %285, %381
%384 = phi i64 [ %286, %290 ], [ %286, %285 ], [ %300, %381 ]
%385 = sub nsw i64 %287, %384
%386 = xor i64 %384, -1
%387 = add nsw i64 %386, %287
%388 = and i64 %385, 3
%389 = icmp eq i64 %388, 0
br i1 %389, label %399, label %390
390: ; preds = %383, %390
%391 = phi i64 [ %396, %390 ], [ %384, %383 ]
%392 = phi i64 [ %397, %390 ], [ 0, %383 ]
%393 = getelementptr inbounds double, double* %20, i64 %391
%394 = load double, double* %393
%395 = getelementptr inbounds double, double* %3, i64 %391
store double %394, double* %395
%396 = add nsw i64 %391, 1
%397 = add i64 %392, 1
%398 = icmp eq i64 %397, %388
br i1 %398, label %399, label %390
399: ; preds = %390, %383
%400 = phi i64 [ %384, %383 ], [ %396, %390 ]
%401 = icmp ult i64 %387, 3
br i1 %401, label %552, label %533
402: ; preds = %261, %279
%403 = phi i64 [ %33, %261 ], [ %408, %279 ]
%404 = phi double [ %259, %261 ], [ %281, %279 ]
%405 = phi double [ %260, %261 ], [ %430, %279 ]
%406 = phi double [ %72, %261 ], [ %429, %279 ]
%407 = phi double [ %258, %261 ], [ %280, %279 ]
%408 = add nsw i64 %403, -1
%409 = and i64 %408, 4294967295
%410 = getelementptr inbounds double, double* %1, i64 %409
%411 = load double, double* %410
%412 = tail call double @pow(i32 10, double %411)
%413 = getelementptr inbounds double, double* %1, i64 %403
%414 = load double, double* %413
%415 = tail call double @pow(i32 10, double %414)
%416 = fsub double %412, %415
%417 = getelementptr inbounds double, double* %0, i64 %403
%418 = load double, double* %417
%419 = getelementptr inbounds double, double* %0, i64 %409
%420 = load double, double* %419
%421 = fsub double %418, %420
%422 = fmul double %416, %421
%423 = tail call double @log(i32 10)
%424 = load double, double* %410
%425 = load double, double* %413
%426 = fsub double %424, %425
%427 = fmul double %423, %426
%428 = fdiv double %422, %427
%429 = fadd double %406, %428
%430 = tail call double @log10(double %429)
%431 = fcmp olt double %404, %429
%432 = fcmp oge double %407, 0.000000e+00
%433 = select i1 %431, i1 %432, i1 false
br i1 %433, label %434, label %279
434: ; preds = %402
%435 = fsub double %405, %430
br label %436
436: ; preds = %434, %528
%437 = phi double [ %404, %434 ], [ %454, %528 ]
%438 = phi double [ %407, %434 ], [ %529, %528 ]
br i1 %262, label %439, label %452
439: ; preds = %436, %439
%440 = phi i64 [ %450, %439 ], [ %263, %436 ]
%441 = phi double [ %449, %439 ], [ 0.000000e+00, %436 ]
%442 = getelementptr inbounds double, double* %3, i64 %440
%443 = load double, double* %442
%444 = fsub double %438, %443
%445 = tail call double @gaussian_cache(double %444, double %6, double* %18)
%446 = getelementptr inbounds double, double* %21, i64 %440
store double %445, double* %446
%447 = getelementptr inbounds double, double* %4, i64 %440
%448 = load double, double* %447
%449 = tail call double @llvm.fmuladd.f64(double %445, double %448, double %441)
%450 = add nsw i64 %440, 1
%451 = icmp eq i64 %450, %264
br i1 %451, label %452, label %439
452: ; preds = %439, %436
%453 = phi double [ 0.000000e+00, %436 ], [ %449, %439 ]
%454 = tail call double @llvm.fmuladd.f64(double %453, double %8, double %437)
%455 = load double, double* %419
%456 = tail call double @log10(double %454)
%457 = fsub double %456, %430
%458 = fdiv double %457, %435
%459 = load double, double* %417
%460 = load double, double* %419
%461 = fsub double %459, %460
%462 = tail call double @llvm.fmuladd.f64(double %458, double %461, double %455)
br i1 %262, label %463, label %528
463: ; preds = %452
%464 = select i1 %271, i1 true, i1 %274
br i1 %464, label %494, label %465
465: ; preds = %463
%466 = insertelement <2 x double> poison, double %462, i64 0
%467 = shufflevector <2 x double> %466, <2 x double> poison, <2 x i32> zeroinitializer
%468 = insertelement <2 x double> poison, double %462, i64 0
%469 = shufflevector <2 x double> %468, <2 x double> poison, <2 x i32> zeroinitializer
br label %470
470: ; preds = %470, %465
%471 = phi i64 [ 0, %465 ], [ %491, %470 ]
%472 = add i64 %471, %263
%473 = getelementptr inbounds double, double* %21, i64 %472
%474 = bitcast double* %473 to <2 x double>*
%475 = load <2 x double>, <2 x double>* %474
%476 = getelementptr inbounds double, double* %473, i64 2
%477 = bitcast double* %476 to <2 x double>*
%478 = load <2 x double>, <2 x double>* %477
%479 = fmul <2 x double> %467, %475
%480 = fmul <2 x double> %469, %478
%481 = getelementptr inbounds double, double* %20, i64 %472
%482 = bitcast double* %481 to <2 x double>*
%483 = load <2 x double>, <2 x double>* %482
%484 = getelementptr inbounds double, double* %481, i64 2
%485 = bitcast double* %484 to <2 x double>*
%486 = load <2 x double>, <2 x double>* %485
%487 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %479, <2 x double> %47, <2 x double> %483)
%488 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %480, <2 x double> %49, <2 x double> %486)
%489 = bitcast double* %481 to <2 x double>*
store <2 x double> %487, <2 x double>* %489
%490 = bitcast double* %484 to <2 x double>*
store <2 x double> %488, <2 x double>* %490
%491 = add nuw i64 %471, 4
%492 = icmp eq i64 %491, %275
br i1 %492, label %493, label %470
493: ; preds = %470
br i1 %277, label %528, label %494
494: ; preds = %463, %493
%495 = phi i64 [ %263, %463 ], [ %276, %493 ]
%496 = sub nsw i64 %264, %495
%497 = xor i64 %495, -1
%498 = and i64 %496, 1
%499 = icmp eq i64 %498, 0
br i1 %499, label %508, label %500
500: ; preds = %494
%501 = getelementptr inbounds double, double* %21, i64 %495
%502 = load double, double* %501
%503 = fmul double %462, %502
%504 = getelementptr inbounds double, double* %20, i64 %495
%505 = load double, double* %504
%506 = tail call double @llvm.fmuladd.f64(double %503, double %8, double %505)
store double %506, double* %504
%507 = add nsw i64 %495, 1
br label %508
508: ; preds = %500, %494
%509 = phi i64 [ %495, %494 ], [ %507, %500 ]
%510 = icmp eq i64 %497, %278
br i1 %510, label %528, label %511
511: ; preds = %508, %511
%512 = phi i64 [ %526, %511 ], [ %509, %508 ]
%513 = getelementptr inbounds double, double* %21, i64 %512
%514 = load double, double* %513
%515 = fmul double %462, %514
%516 = getelementptr inbounds double, double* %20, i64 %512
%517 = load double, double* %516
%518 = tail call double @llvm.fmuladd.f64(double %515, double %8, double %517)
store double %518, double* %516
%519 = add nsw i64 %512, 1
%520 = getelementptr inbounds double, double* %21, i64 %519
%521 = load double, double* %520
%522 = fmul double %462, %521
%523 = getelementptr inbounds double, double* %20, i64 %519
%524 = load double, double* %523
%525 = tail call double @llvm.fmuladd.f64(double %522, double %8, double %524)
store double %525, double* %523
%526 = add nsw i64 %512, 2
%527 = icmp eq i64 %526, %265
br i1 %527, label %528, label %511
528: ; preds = %508, %511, %493, %452
%529 = fsub double %438, %8
%530 = fcmp olt double %454, %429
%531 = fcmp oge double %529, 0.000000e+00
%532 = select i1 %530, i1 %531, i1 false
br i1 %532, label %436, label %279
533: ; preds = %399, %533
%534 = phi i64 [ %550, %533 ], [ %400, %399 ]
%535 = getelementptr inbounds double, double* %20, i64 %534
%536 = load double, double* %535
%537 = getelementptr inbounds double, double* %3, i64 %534
store double %536, double* %537
%538 = add nsw i64 %534, 1
%539 = getelementptr inbounds double, double* %20, i64 %538
%540 = load double, double* %539
%541 = getelementptr inbounds double, double* %3, i64 %538
store double %540, double* %541
%542 = add nsw i64 %534, 2
%543 = getelementptr inbounds double, double* %20, i64 %542
%544 = load double, double* %543
%545 = getelementptr inbounds double, double* %3, i64 %542
store double %544, double* %545
%546 = add nsw i64 %534, 3
%547 = getelementptr inbounds double, double* %20, i64 %546
%548 = load double, double* %547
%549 = getelementptr inbounds double, double* %3, i64 %546
store double %548, double* %549
%550 = add nsw i64 %534, 4
%551 = icmp eq i64 %550, %287
br i1 %551, label %552, label %533
552: ; preds = %399, %533, %381, %283
%553 = add nuw nsw i32 %64, 1
%554 = icmp eq i32 %553, %7
br i1 %554, label %555, label %63
555: ; preds = %552, %19
%556 = tail call i32 @free(double* %20)
%557 = tail call i32 @free(double* %21)
%558 = tail call i32 @free(double* %18)
br label %559
559: ; preds = %9, %555
ret void
}