#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 C_sumof2uniforms_cdf(double const *, double const *, double const *,
                            int const *);
double fabs(double const);
double C_sumof3uniforms_cdf(const double *p, const double *ax, const double *ay,
                            const double *az, const int *k) {
  double s = 0.;
  if ((fabs(ax[*k]) > 0.000000000001) && (fabs(ay[*k]) > 0.000000000001) &&
      (fabs(az[*k]) > 0.000000000001)) {
    s += (((*p + ax[*k] + ay[*k] + az[*k] < 0.
                ? 0.
                : *p + ax[*k] + ay[*k] + az[*k])) *
          ((*p + ax[*k] + ay[*k] + az[*k] < 0.
                ? 0.
                : *p + ax[*k] + ay[*k] + az[*k])) *
          ((*p + ax[*k] + ay[*k] + az[*k] < 0.
                ? 0.
                : *p + ax[*k] + ay[*k] + az[*k])));
    s += (((*p + ax[*k] - ay[*k] - az[*k] < 0.
                ? 0.
                : *p + ax[*k] - ay[*k] - az[*k])) *
          ((*p + ax[*k] - ay[*k] - az[*k] < 0.
                ? 0.
                : *p + ax[*k] - ay[*k] - az[*k])) *
          ((*p + ax[*k] - ay[*k] - az[*k] < 0.
                ? 0.
                : *p + ax[*k] - ay[*k] - az[*k])));
    s += (((*p - ax[*k] + ay[*k] - az[*k] < 0.
                ? 0.
                : *p - ax[*k] + ay[*k] - az[*k])) *
          ((*p - ax[*k] + ay[*k] - az[*k] < 0.
                ? 0.
                : *p - ax[*k] + ay[*k] - az[*k])) *
          ((*p - ax[*k] + ay[*k] - az[*k] < 0.
                ? 0.
                : *p - ax[*k] + ay[*k] - az[*k])));
    s += (((*p - ax[*k] - ay[*k] + az[*k] < 0.
                ? 0.
                : *p - ax[*k] - ay[*k] + az[*k])) *
          ((*p - ax[*k] - ay[*k] + az[*k] < 0.
                ? 0.
                : *p - ax[*k] - ay[*k] + az[*k])) *
          ((*p - ax[*k] - ay[*k] + az[*k] < 0.
                ? 0.
                : *p - ax[*k] - ay[*k] + az[*k])));
    s -= (((*p - ax[*k] - ay[*k] - az[*k] < 0.
                ? 0.
                : *p - ax[*k] - ay[*k] - az[*k])) *
          ((*p - ax[*k] - ay[*k] - az[*k] < 0.
                ? 0.
                : *p - ax[*k] - ay[*k] - az[*k])) *
          ((*p - ax[*k] - ay[*k] - az[*k] < 0.
                ? 0.
                : *p - ax[*k] - ay[*k] - az[*k])));
    s -= (((*p - ax[*k] + ay[*k] + az[*k] < 0.
                ? 0.
                : *p - ax[*k] + ay[*k] + az[*k])) *
          ((*p - ax[*k] + ay[*k] + az[*k] < 0.
                ? 0.
                : *p - ax[*k] + ay[*k] + az[*k])) *
          ((*p - ax[*k] + ay[*k] + az[*k] < 0.
                ? 0.
                : *p - ax[*k] + ay[*k] + az[*k])));
    s -= (((*p + ax[*k] - ay[*k] + az[*k] < 0.
                ? 0.
                : *p + ax[*k] - ay[*k] + az[*k])) *
          ((*p + ax[*k] - ay[*k] + az[*k] < 0.
                ? 0.
                : *p + ax[*k] - ay[*k] + az[*k])) *
          ((*p + ax[*k] - ay[*k] + az[*k] < 0.
                ? 0.
                : *p + ax[*k] - ay[*k] + az[*k])));
    s -= (((*p + ax[*k] + ay[*k] - az[*k] < 0.
                ? 0.
                : *p + ax[*k] + ay[*k] - az[*k])) *
          ((*p + ax[*k] + ay[*k] - az[*k] < 0.
                ? 0.
                : *p + ax[*k] + ay[*k] - az[*k])) *
          ((*p + ax[*k] + ay[*k] - az[*k] < 0.
                ? 0.
                : *p + ax[*k] + ay[*k] - az[*k])));
    return (s / (48 * ax[*k] * ay[*k] * az[*k]));
  } else if ((fabs(ax[*k]) <= 0.000000000001))
    return (C_sumof2uniforms_cdf(p, ay, az, k));
  else if ((fabs(ay[*k]) <= 0.000000000001))
    return (C_sumof2uniforms_cdf(p, ax, az, k));
  else
    return (C_sumof2uniforms_cdf(p, ax, ay, k));
}


x86 assembly (clang, -O0):
<C_sumof3uniforms_cdf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1ec2(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x1ea6(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    2288 <C_sumof3uniforms_cdf+0x1178>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1e95(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x1e79(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    2288 <C_sumof3uniforms_cdf+0x1178>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1e68(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x1e4c(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    2288 <C_sumof3uniforms_cdf+0x1178>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1210 <C_sumof3uniforms_cdf+0x100>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    124d <C_sumof3uniforms_cdf+0x13d>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    12a9 <C_sumof3uniforms_cdf+0x199>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    12e6 <C_sumof3uniforms_cdf+0x1d6>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    134b <C_sumof3uniforms_cdf+0x23b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1388 <C_sumof3uniforms_cdf+0x278>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    13f6 <C_sumof3uniforms_cdf+0x2e6>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1433 <C_sumof3uniforms_cdf+0x323>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    148f <C_sumof3uniforms_cdf+0x37f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
jmp    14cc <C_sumof3uniforms_cdf+0x3bc>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1534 <C_sumof3uniforms_cdf+0x424>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1574 <C_sumof3uniforms_cdf+0x464>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    15e8 <C_sumof3uniforms_cdf+0x4d8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1628 <C_sumof3uniforms_cdf+0x518>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    168d <C_sumof3uniforms_cdf+0x57d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    16cd <C_sumof3uniforms_cdf+0x5bd>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    173e <C_sumof3uniforms_cdf+0x62e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    177e <C_sumof3uniforms_cdf+0x66e>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    17f5 <C_sumof3uniforms_cdf+0x6e5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1835 <C_sumof3uniforms_cdf+0x725>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    189a <C_sumof3uniforms_cdf+0x78a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    18da <C_sumof3uniforms_cdf+0x7ca>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    194b <C_sumof3uniforms_cdf+0x83b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    198b <C_sumof3uniforms_cdf+0x87b>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1a02 <C_sumof3uniforms_cdf+0x8f2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1a42 <C_sumof3uniforms_cdf+0x932>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1aa7 <C_sumof3uniforms_cdf+0x997>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    1ae7 <C_sumof3uniforms_cdf+0x9d7>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1b58 <C_sumof3uniforms_cdf+0xa48>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
jmp    1b98 <C_sumof3uniforms_cdf+0xa88>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1c26 <C_sumof3uniforms_cdf+0xb16>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
jmp    1c66 <C_sumof3uniforms_cdf+0xb56>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1ccb <C_sumof3uniforms_cdf+0xbbb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
jmp    1d0b <C_sumof3uniforms_cdf+0xbfb>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1d7c <C_sumof3uniforms_cdf+0xc6c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    1dbc <C_sumof3uniforms_cdf+0xcac>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1e4a <C_sumof3uniforms_cdf+0xd3a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1e8a <C_sumof3uniforms_cdf+0xd7a>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1eef <C_sumof3uniforms_cdf+0xddf>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
jmp    1f2f <C_sumof3uniforms_cdf+0xe1f>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x140(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1fa0 <C_sumof3uniforms_cdf+0xe90>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
jmp    1fe0 <C_sumof3uniforms_cdf+0xed0>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
movsd  -0x150(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    206e <C_sumof3uniforms_cdf+0xf5e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
jmp    20ae <C_sumof3uniforms_cdf+0xf9e>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    2113 <C_sumof3uniforms_cdf+0x1003>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
jmp    2153 <C_sumof3uniforms_cdf+0x1043>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
movsd  -0x168(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    21c4 <C_sumof3uniforms_cdf+0x10b4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
jmp    2204 <C_sumof3uniforms_cdf+0x10f4>
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x170(%rbp),%xmm0
ff
movsd  -0x178(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  0xdb3(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    233a <C_sumof3uniforms_cdf+0x122a>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xd71(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xd55(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     22d4 <C_sumof3uniforms_cdf+0x11c4>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1030 <C_sumof2uniforms_cdf@plt>
movsd  %xmm0,-0x8(%rbp)
jmp    233a <C_sumof3uniforms_cdf+0x122a>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xd25(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xd09(%rip),%xmm0
ucomisd %xmm1,%xmm0
jb     2320 <C_sumof3uniforms_cdf+0x1210>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1030 <C_sumof2uniforms_cdf@plt>
movsd  %xmm0,-0x8(%rbp)
jmp    233a <C_sumof3uniforms_cdf+0x122a>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1030 <C_sumof2uniforms_cdf@plt>
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<C_sumof3uniforms_cdf>:
movslq (%r8),%rax
movsd  (%rsi,%rax,8),%xmm1
movapd 0xee0(%rip),%xmm0
andpd  %xmm1,%xmm0
ucomisd 0xee4(%rip),%xmm0
jbe    12b7 <C_sumof3uniforms_cdf+0x1a7>
movsd  (%rdx,%rax,8),%xmm10
movapd 0xec0(%rip),%xmm2
andpd  %xmm10,%xmm2
ucomisd 0xec3(%rip),%xmm2
jbe    12b7 <C_sumof3uniforms_cdf+0x1a7>
movsd  (%rcx,%rax,8),%xmm11
movapd 0xe9f(%rip),%xmm2
andpd  %xmm11,%xmm2
ucomisd 0xea2(%rip),%xmm2
jbe    12b7 <C_sumof3uniforms_cdf+0x1a7>
movsd  (%rdi),%xmm7
movapd %xmm1,%xmm6
addsd  %xmm7,%xmm6
movapd %xmm10,%xmm9
addsd  %xmm6,%xmm9
movapd %xmm11,%xmm0
addsd  %xmm9,%xmm0
xorpd  %xmm8,%xmm8
xorpd  %xmm2,%xmm2
maxsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm8,%xmm0
subsd  %xmm10,%xmm6
movapd %xmm6,%xmm2
subsd  %xmm11,%xmm2
xorpd  %xmm4,%xmm4
maxsd  %xmm2,%xmm4
movapd %xmm4,%xmm5
mulsd  %xmm4,%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm0,%xmm5
subsd  %xmm1,%xmm7
movapd %xmm10,%xmm2
addsd  %xmm7,%xmm2
movapd %xmm2,%xmm0
subsd  %xmm11,%xmm0
xorpd  %xmm3,%xmm3
maxsd  %xmm0,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm5,%xmm4
subsd  %xmm10,%xmm7
movapd %xmm11,%xmm0
addsd  %xmm7,%xmm0
xorpd  %xmm3,%xmm3
maxsd  %xmm0,%xmm3
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm4,%xmm0
subsd  %xmm11,%xmm7
xorpd  %xmm3,%xmm3
maxsd  %xmm7,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm0
addsd  %xmm11,%xmm2
xorpd  %xmm3,%xmm3
maxsd  %xmm2,%xmm3
movapd %xmm3,%xmm2
mulsd  %xmm3,%xmm2
mulsd  %xmm3,%xmm2
subsd  %xmm2,%xmm0
addsd  %xmm11,%xmm6
xorpd  %xmm2,%xmm2
maxsd  %xmm6,%xmm2
movapd %xmm2,%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm0
subsd  %xmm11,%xmm9
maxsd  %xmm9,%xmm8
movapd %xmm8,%xmm2
mulsd  %xmm8,%xmm2
mulsd  %xmm8,%xmm2
mulsd  0xd74(%rip),%xmm1
subsd  %xmm2,%xmm0
mulsd  %xmm10,%xmm1
mulsd  %xmm11,%xmm1
divsd  %xmm1,%xmm0
ret
movsd  0xd51(%rip),%xmm1
ucomisd %xmm0,%xmm1
jae    12e0 <C_sumof3uniforms_cdf+0x1d0>
movsd  (%rdx,%rax,8),%xmm0
andpd  0xd2e(%rip),%xmm0
ucomisd %xmm0,%xmm1
jae    12e3 <C_sumof3uniforms_cdf+0x1d3>
mov    %r8,%rcx
jmp    1030 <C_sumof2uniforms_cdf@plt>
mov    %rdx,%rsi
mov    %rcx,%rdx
mov    %r8,%rcx
jmp    1030 <C_sumof2uniforms_cdf@plt>

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

LLVM IR (-O2):
define double @C_sumof3uniforms_cdf(double* %0, double* %1, double* %2, double* %3, i32* %4) {
%6 = load i32, i32* %4
%7 = sext i32 %6 to i64
%8 = getelementptr inbounds double, double* %1, i64 %7
%9 = load double, double* %8
%10 = tail call double @llvm.fabs.f64(double %9)
%11 = fcmp ogt double %10, 0x3D719799812DEA11
br i1 %11, label %12, label %78
12: ; preds = %5
%13 = getelementptr inbounds double, double* %2, i64 %7
%14 = load double, double* %13
%15 = tail call double @llvm.fabs.f64(double %14)
%16 = fcmp ogt double %15, 0x3D719799812DEA11
br i1 %16, label %17, label %78
17: ; preds = %12
%18 = getelementptr inbounds double, double* %3, i64 %7
%19 = load double, double* %18
%20 = tail call double @llvm.fabs.f64(double %19)
%21 = fcmp ogt double %20, 0x3D719799812DEA11
br i1 %21, label %22, label %78
22: ; preds = %17
%23 = load double, double* %0
%24 = fadd double %9, %23
%25 = fadd double %14, %24
%26 = fadd double %19, %25
%27 = fcmp olt double %26, 0.000000e+00
%28 = select i1 %27, double 0.000000e+00, double %26
%29 = fmul double %28, %28
%30 = tail call double @llvm.fmuladd.f64(double %29, double %28, double 0.000000e+00)
%31 = fsub double %24, %14
%32 = fsub double %31, %19
%33 = fcmp olt double %32, 0.000000e+00
%34 = select i1 %33, double 0.000000e+00, double %32
%35 = fmul double %34, %34
%36 = tail call double @llvm.fmuladd.f64(double %35, double %34, double %30)
%37 = fsub double %23, %9
%38 = fadd double %14, %37
%39 = fsub double %38, %19
%40 = fcmp olt double %39, 0.000000e+00
%41 = select i1 %40, double 0.000000e+00, double %39
%42 = fmul double %41, %41
%43 = tail call double @llvm.fmuladd.f64(double %42, double %41, double %36)
%44 = fsub double %37, %14
%45 = fadd double %19, %44
%46 = fcmp olt double %45, 0.000000e+00
%47 = select i1 %46, double 0.000000e+00, double %45
%48 = fmul double %47, %47
%49 = tail call double @llvm.fmuladd.f64(double %48, double %47, double %43)
%50 = fsub double %44, %19
%51 = fcmp olt double %50, 0.000000e+00
%52 = select i1 %51, double 0.000000e+00, double %50
%53 = fneg double %52
%54 = fmul double %52, %53
%55 = tail call double @llvm.fmuladd.f64(double %54, double %52, double %49)
%56 = fadd double %19, %38
%57 = fcmp olt double %56, 0.000000e+00
%58 = select i1 %57, double 0.000000e+00, double %56
%59 = fneg double %58
%60 = fmul double %58, %59
%61 = tail call double @llvm.fmuladd.f64(double %60, double %58, double %55)
%62 = fadd double %19, %31
%63 = fcmp olt double %62, 0.000000e+00
%64 = select i1 %63, double 0.000000e+00, double %62
%65 = fneg double %64
%66 = fmul double %64, %65
%67 = tail call double @llvm.fmuladd.f64(double %66, double %64, double %61)
%68 = fsub double %25, %19
%69 = fcmp olt double %68, 0.000000e+00
%70 = select i1 %69, double 0.000000e+00, double %68
%71 = fneg double %70
%72 = fmul double %70, %71
%73 = tail call double @llvm.fmuladd.f64(double %72, double %70, double %67)
%74 = fmul double %9, 4.800000e+01
%75 = fmul double %74, %14
%76 = fmul double %75, %19
%77 = fdiv double %73, %76
br label %91
78: ; preds = %17, %12, %5
%79 = fcmp ugt double %10, 0x3D719799812DEA11
br i1 %79, label %82, label %80
80: ; preds = %78
%81 = tail call double @C_sumof2uniforms_cdf(double* %0, double* %2, double* %3, i32* %4)
br label %91
82: ; preds = %78
%83 = getelementptr inbounds double, double* %2, i64 %7
%84 = load double, double* %83
%85 = tail call double @llvm.fabs.f64(double %84)
%86 = fcmp ugt double %85, 0x3D719799812DEA11
br i1 %86, label %89, label %87
87: ; preds = %82
%88 = tail call double @C_sumof2uniforms_cdf(double* %0, double* %1, double* %3, i32* %4)
br label %91
89: ; preds = %82
%90 = tail call double @C_sumof2uniforms_cdf(double* %0, double* %1, double* %2, i32* %4)
br label %91
91: ; preds = %89, %87, %80, %22
%92 = phi double [ %77, %22 ], [ %81, %80 ], [ %88, %87 ], [ %90, %89 ]
ret double %92
}