void Worley(double at[3], long max_order, double *F, double (*delta)[3],
            unsigned long *ID) {
  double x2, y2, z2, mx2, my2, mz2;
  double new_at[3];
  long int_at[3], i;
  for (i = 0; i < max_order; i++)
    F[i] = 999999.9;
  new_at[0] = 0.398150 * at[0];
  new_at[1] = 0.398150 * at[1];
  new_at[2] = 0.398150 * at[2];
  int_at[0] = (((new_at[0]) < (long)(new_at[0])) ? ((long)(new_at[0]) - 1)
                                                 : ((long)(new_at[0])));
  int_at[1] = (((new_at[1]) < (long)(new_at[1])) ? ((long)(new_at[1]) - 1)
                                                 : ((long)(new_at[1])));
  int_at[2] = (((new_at[2]) < (long)(new_at[2])) ? ((long)(new_at[2]) - 1)
                                                 : ((long)(new_at[2])));
  AddSamples(int_at[0], int_at[1], int_at[2], max_order, new_at, F, delta, ID);
  x2 = new_at[0] - int_at[0];
  y2 = new_at[1] - int_at[1];
  z2 = new_at[2] - int_at[2];
  mx2 = (1.0 - x2) * (1.0 - x2);
  my2 = (1.0 - y2) * (1.0 - y2);
  mz2 = (1.0 - z2) * (1.0 - z2);
  x2 *= x2;
  y2 *= y2;
  z2 *= z2;
  if (x2 < F[max_order - 1])
    AddSamples(int_at[0] - 1, int_at[1], int_at[2], max_order, new_at, F, delta,
               ID);
  if (y2 < F[max_order - 1])
    AddSamples(int_at[0], int_at[1] - 1, int_at[2], max_order, new_at, F, delta,
               ID);
  if (z2 < F[max_order - 1])
    AddSamples(int_at[0], int_at[1], int_at[2] - 1, max_order, new_at, F, delta,
               ID);
  if (mx2 < F[max_order - 1])
    AddSamples(int_at[0] + 1, int_at[1], int_at[2], max_order, new_at, F, delta,
               ID);
  if (my2 < F[max_order - 1])
    AddSamples(int_at[0], int_at[1] + 1, int_at[2], max_order, new_at, F, delta,
               ID);
  if (mz2 < F[max_order - 1])
    AddSamples(int_at[0], int_at[1], int_at[2] + 1, max_order, new_at, F, delta,
               ID);
  if (x2 + y2 < F[max_order - 1])
    AddSamples(int_at[0] - 1, int_at[1] - 1, int_at[2], max_order, new_at, F,
               delta, ID);
  if (x2 + z2 < F[max_order - 1])
    AddSamples(int_at[0] - 1, int_at[1], int_at[2] - 1, max_order, new_at, F,
               delta, ID);
  if (y2 + z2 < F[max_order - 1])
    AddSamples(int_at[0], int_at[1] - 1, int_at[2] - 1, max_order, new_at, F,
               delta, ID);
  if (mx2 + my2 < F[max_order - 1])
    AddSamples(int_at[0] + 1, int_at[1] + 1, int_at[2], max_order, new_at, F,
               delta, ID);
  if (mx2 + mz2 < F[max_order - 1])
    AddSamples(int_at[0] + 1, int_at[1], int_at[2] + 1, max_order, new_at, F,
               delta, ID);
  if (my2 + mz2 < F[max_order - 1])
    AddSamples(int_at[0], int_at[1] + 1, int_at[2] + 1, max_order, new_at, F,
               delta, ID);
  if (x2 + my2 < F[max_order - 1])
    AddSamples(int_at[0] - 1, int_at[1] + 1, int_at[2], max_order, new_at, F,
               delta, ID);
  if (x2 + mz2 < F[max_order - 1])
    AddSamples(int_at[0] - 1, int_at[1], int_at[2] + 1, max_order, new_at, F,
               delta, ID);
  if (y2 + mz2 < F[max_order - 1])
    AddSamples(int_at[0], int_at[1] - 1, int_at[2] + 1, max_order, new_at, F,
               delta, ID);
  if (mx2 + y2 < F[max_order - 1])
    AddSamples(int_at[0] + 1, int_at[1] - 1, int_at[2], max_order, new_at, F,
               delta, ID);
  if (mx2 + z2 < F[max_order - 1])
    AddSamples(int_at[0] + 1, int_at[1], int_at[2] - 1, max_order, new_at, F,
               delta, ID);
  if (my2 + z2 < F[max_order - 1])
    AddSamples(int_at[0], int_at[1] + 1, int_at[2] - 1, max_order, new_at, F,
               delta, ID);
  if (x2 + y2 + z2 < F[max_order - 1])
    AddSamples(int_at[0] - 1, int_at[1] - 1, int_at[2] - 1, max_order, new_at,
               F, delta, ID);
  if (x2 + y2 + mz2 < F[max_order - 1])
    AddSamples(int_at[0] - 1, int_at[1] - 1, int_at[2] + 1, max_order, new_at,
               F, delta, ID);
  if (x2 + my2 + z2 < F[max_order - 1])
    AddSamples(int_at[0] - 1, int_at[1] + 1, int_at[2] - 1, max_order, new_at,
               F, delta, ID);
  if (x2 + my2 + mz2 < F[max_order - 1])
    AddSamples(int_at[0] - 1, int_at[1] + 1, int_at[2] + 1, max_order, new_at,
               F, delta, ID);
  if (mx2 + y2 + z2 < F[max_order - 1])
    AddSamples(int_at[0] + 1, int_at[1] - 1, int_at[2] - 1, max_order, new_at,
               F, delta, ID);
  if (mx2 + y2 + mz2 < F[max_order - 1])
    AddSamples(int_at[0] + 1, int_at[1] - 1, int_at[2] + 1, max_order, new_at,
               F, delta, ID);
  if (mx2 + my2 + z2 < F[max_order - 1])
    AddSamples(int_at[0] + 1, int_at[1] + 1, int_at[2] - 1, max_order, new_at,
               F, delta, ID);
  if (mx2 + my2 + mz2 < F[max_order - 1])
    AddSamples(int_at[0] + 1, int_at[1] + 1, int_at[2] + 1, max_order, new_at,
               F, delta, ID);
  for (i = 0; i < max_order; i++) {
    F[i] = sqrt(F[i]) * (1.0 / 0.398150);
    delta[i][0] *= (1.0 / 0.398150);
    delta[i][1] *= (1.0 / 0.398150);
    delta[i][2] *= (1.0 / 0.398150);
  }
  return;
}


x86 assembly (clang, -O0):
<Worley>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    118a <Worley+0x6a>
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  0xeaa(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    114a <Worley+0x2a>
mov    -0x8(%rbp),%rax
movsd  0xe6a(%rip),%xmm0
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movsd  0xe55(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movsd  0xe3f(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x70(%rbp),%xmm1
cvttsd2si -0x70(%rbp),%rax
cvtsi2sd %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    11fb <Worley+0xdb>
cvttsd2si -0x70(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0xa0(%rbp)
jmp    1208 <Worley+0xe8>
cvttsd2si -0x70(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0x90(%rbp)
movsd  -0x68(%rbp),%xmm1
cvttsd2si -0x68(%rbp),%rax
cvtsi2sd %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1246 <Worley+0x126>
cvttsd2si -0x68(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0xa8(%rbp)
jmp    1253 <Worley+0x133>
cvttsd2si -0x68(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0x88(%rbp)
movsd  -0x60(%rbp),%xmm1
cvttsd2si -0x60(%rbp),%rax
cvtsi2sd %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1291 <Worley+0x171>
cvttsd2si -0x60(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0xb0(%rbp)
jmp    129e <Worley+0x17e>
cvttsd2si -0x60(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x90(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x80(%rbp),%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x70(%rbp),%xmm0
cvtsi2sdq -0x90(%rbp),%xmm1
ff ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x68(%rbp),%xmm0
cvtsi2sdq -0x88(%rbp),%xmm1
ff ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x60(%rbp),%xmm0
cvtsi2sdq -0x80(%rbp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xcdf(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  0xcd2(%rip),%xmm1
subsd  -0x30(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xcbc(%rip),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  0xcaf(%rip),%xmm1
subsd  -0x38(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xc99(%rip),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  0xc8c(%rip),%xmm1
subsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x30(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x38(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x40(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x30(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1411 <Worley+0x2f1>
mov    -0x90(%rbp),%rdi
sub    $0x1,%rdi
mov    -0x88(%rbp),%rsi
mov    -0x80(%rbp),%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x38(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    146b <Worley+0x34b>
mov    -0x90(%rbp),%rdi
mov    -0x88(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x80(%rbp),%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    14c5 <Worley+0x3a5>
mov    -0x90(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x80(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x48(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    151f <Worley+0x3ff>
mov    -0x90(%rbp),%rdi
add    $0x1,%rdi
mov    -0x88(%rbp),%rsi
mov    -0x80(%rbp),%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x50(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1579 <Worley+0x459>
mov    -0x90(%rbp),%rdi
mov    -0x88(%rbp),%rsi
add    $0x1,%rsi
mov    -0x80(%rbp),%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    15d3 <Worley+0x4b3>
mov    -0x90(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x80(%rbp),%rdx
add    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x30(%rbp),%xmm1
addsd  -0x38(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1636 <Worley+0x516>
mov    -0x90(%rbp),%rdi
sub    $0x1,%rdi
mov    -0x88(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x80(%rbp),%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x30(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1699 <Worley+0x579>
mov    -0x90(%rbp),%rdi
sub    $0x1,%rdi
mov    -0x88(%rbp),%rsi
mov    -0x80(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x38(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    16fc <Worley+0x5dc>
mov    -0x90(%rbp),%rdi
mov    -0x88(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x80(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x48(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    175f <Worley+0x63f>
mov    -0x90(%rbp),%rdi
add    $0x1,%rdi
mov    -0x88(%rbp),%rsi
add    $0x1,%rsi
mov    -0x80(%rbp),%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x48(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    17c2 <Worley+0x6a2>
mov    -0x90(%rbp),%rdi
add    $0x1,%rdi
mov    -0x88(%rbp),%rsi
mov    -0x80(%rbp),%rdx
add    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x50(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1825 <Worley+0x705>
mov    -0x90(%rbp),%rdi
mov    -0x88(%rbp),%rsi
add    $0x1,%rsi
mov    -0x80(%rbp),%rdx
add    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x30(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1888 <Worley+0x768>
mov    -0x90(%rbp),%rdi
sub    $0x1,%rdi
mov    -0x88(%rbp),%rsi
add    $0x1,%rsi
mov    -0x80(%rbp),%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x30(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    18eb <Worley+0x7cb>
mov    -0x90(%rbp),%rdi
sub    $0x1,%rdi
mov    -0x88(%rbp),%rsi
mov    -0x80(%rbp),%rdx
add    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x38(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    194e <Worley+0x82e>
mov    -0x90(%rbp),%rdi
mov    -0x88(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x80(%rbp),%rdx
add    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x48(%rbp),%xmm1
addsd  -0x38(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    19b1 <Worley+0x891>
mov    -0x90(%rbp),%rdi
add    $0x1,%rdi
mov    -0x88(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x80(%rbp),%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x48(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a14 <Worley+0x8f4>
mov    -0x90(%rbp),%rdi
add    $0x1,%rdi
mov    -0x88(%rbp),%rsi
mov    -0x80(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x50(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a77 <Worley+0x957>
mov    -0x90(%rbp),%rdi
mov    -0x88(%rbp),%rsi
add    $0x1,%rsi
mov    -0x80(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x30(%rbp),%xmm1
addsd  -0x38(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1ae3 <Worley+0x9c3>
mov    -0x90(%rbp),%rdi
sub    $0x1,%rdi
mov    -0x88(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x80(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x30(%rbp),%xmm1
addsd  -0x38(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1b4f <Worley+0xa2f>
mov    -0x90(%rbp),%rdi
sub    $0x1,%rdi
mov    -0x88(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x80(%rbp),%rdx
add    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x30(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1bbb <Worley+0xa9b>
mov    -0x90(%rbp),%rdi
sub    $0x1,%rdi
mov    -0x88(%rbp),%rsi
add    $0x1,%rsi
mov    -0x80(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x30(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c27 <Worley+0xb07>
mov    -0x90(%rbp),%rdi
sub    $0x1,%rdi
mov    -0x88(%rbp),%rsi
add    $0x1,%rsi
mov    -0x80(%rbp),%rdx
add    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x48(%rbp),%xmm1
addsd  -0x38(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c93 <Worley+0xb73>
mov    -0x90(%rbp),%rdi
add    $0x1,%rdi
mov    -0x88(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x80(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x48(%rbp),%xmm1
addsd  -0x38(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1cff <Worley+0xbdf>
mov    -0x90(%rbp),%rdi
add    $0x1,%rdi
mov    -0x88(%rbp),%rsi
sub    $0x1,%rsi
mov    -0x80(%rbp),%rdx
add    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x48(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1d6b <Worley+0xc4b>
mov    -0x90(%rbp),%rdi
add    $0x1,%rdi
mov    -0x88(%rbp),%rsi
add    $0x1,%rsi
mov    -0x80(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movsd  -0x48(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1dd7 <Worley+0xcb7>
mov    -0x90(%rbp),%rdi
add    $0x1,%rdi
mov    -0x88(%rbp),%rsi
add    $0x1,%rsi
mov    -0x80(%rbp),%rdx
add    $0x1,%rdx
mov    -0x10(%rbp),%rcx
lea    -0x70(%rbp),%r8
mov    -0x18(%rbp),%r9
mov    -0x20(%rbp),%r10
mov    -0x28(%rbp),%rax
mov    %r10,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1030 <AddSamples@plt>
movq   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1e9c <Worley+0xd7c>
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1040 <sqrt@plt>
movsd  0x200(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x98(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
imul   $0x18,-0x98(%rbp),%rcx
18
add    %rcx,%rax
movsd  0x1d5(%rip),%xmm0
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
imul   $0x18,-0x98(%rbp),%rcx
18
add    %rcx,%rax
movsd  0x1b6(%rip),%xmm0
mulsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
imul   $0x18,-0x98(%rbp),%rcx
18
add    %rcx,%rax
movsd  0x195(%rip),%xmm0
mulsd  0x10(%rax),%xmm0
movsd  %xmm0,0x10(%rax)
mov    -0x98(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
jmp    1de2 <Worley+0xcc2>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Worley>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r8,(%rsp)
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %rsi,%r15
test   %rsi,%rsi
jle    126d <Worley+0x14d>
cmp    $0x4,%r15
jae    1151 <Worley+0x31>
xor    %eax,%eax
jmp    1247 <Worley+0x127>
mov    %r15,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x1c,%rsi
jae    1179 <Worley+0x59>
xor    %esi,%esi
jmp    1215 <Worley+0xf5>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
movaps 0xe7a(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
movups %xmm0,(%r14,%rsi,8)
movups %xmm0,0x10(%r14,%rsi,8)
movups %xmm0,0x20(%r14,%rsi,8)
movups %xmm0,0x30(%r14,%rsi,8)
movups %xmm0,0x40(%r14,%rsi,8)
movups %xmm0,0x50(%r14,%rsi,8)
movups %xmm0,0x60(%r14,%rsi,8)
movups %xmm0,0x70(%r14,%rsi,8)
movups %xmm0,0x80(%r14,%rsi,8)
movups %xmm0,0x90(%r14,%rsi,8)
movups %xmm0,0xa0(%r14,%rsi,8)
movups %xmm0,0xb0(%r14,%rsi,8)
movups %xmm0,0xc0(%r14,%rsi,8)
movups %xmm0,0xd0(%r14,%rsi,8)
movups %xmm0,0xe0(%r14,%rsi,8)
movups %xmm0,0xf0(%r14,%rsi,8)
add    $0x20,%rsi
add    $0xfffffffffffffff8,%rdx
jne    1190 <Worley+0x70>
test   %rcx,%rcx
je     1242 <Worley+0x122>
lea    (%r14,%rsi,8),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movaps 0xdd1(%rip),%xmm0
nop
movups %xmm0,-0x10(%rdx,%rsi,1)
movups %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1230 <Worley+0x110>
cmp    %r15,%rax
je     126d <Worley+0x14d>
movabs $0x412e847fcccccccd,%rcx
84 2e 41
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rcx,(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1260 <Worley+0x140>
movupd (%rdi),%xmm0
mulpd  0xd97(%rip),%xmm0
movapd %xmm0,0x30(%rsp)
movsd  0x10(%rdi),%xmm1
mulsd  0xda4(%rip),%xmm1
cvttsd2si %xmm0,%r13
cvtsi2sd %r13,%xmm2
xor    %eax,%eax
ucomisd %xmm0,%xmm2
seta   %al
unpckhpd %xmm0,%xmm0
cvttsd2si %xmm0,%rbp
sub    %rax,%r13
xorps  %xmm2,%xmm2
cvtsi2sd %rbp,%xmm2
xor    %eax,%eax
ucomisd %xmm0,%xmm2
seta   %al
cvttsd2si %xmm1,%r12
xorps  %xmm0,%xmm0
cvtsi2sd %r12,%xmm0
sub    %rax,%rbp
xor    %eax,%eax
ucomisd %xmm1,%xmm0
movsd  %xmm1,0x40(%rsp)
seta   %al
sub    %rax,%r12
lea    0x30(%rsp),%r8
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
add    $0x10,%rsp
xorps  %xmm0,%xmm0
cvtsi2sd %r13,%xmm0
movsd  0x30(%rsp),%xmm7
subsd  %xmm0,%xmm7
xorps  %xmm0,%xmm0
cvtsi2sd %rbp,%xmm0
movsd  0x38(%rsp),%xmm5
subsd  %xmm0,%xmm5
xorps  %xmm0,%xmm0
cvtsi2sd %r12,%xmm0
movsd  0x40(%rsp),%xmm4
subsd  %xmm0,%xmm4
movsd  0xcf9(%rip),%xmm1
movapd %xmm7,%xmm3
mulsd  %xmm7,%xmm3
movapd %xmm5,%xmm2
mulsd  %xmm5,%xmm2
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  %xmm3,0x58(%rsp)
ucomisd %xmm3,%xmm0
movsd  %xmm2,0x8(%rsp)
movsd  %xmm4,0x18(%rsp)
movsd  %xmm5,0x10(%rsp)
jbe    13c5 <Worley+0x2a5>
lea    -0x1(%r13),%rdi
lea    0x30(%rsp),%r8
mov    %rbp,%rsi
mov    %r12,%rdx
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
movsd  %xmm7,0x38(%rsp)
call   1030 <AddSamples@plt>
movsd  0x38(%rsp),%xmm7
movsd  0x20(%rsp),%xmm5
movsd  0x28(%rsp),%xmm4
movsd  0x18(%rsp),%xmm2
movsd  0xc7e(%rip),%xmm1
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movapd %xmm1,%xmm6
subsd  %xmm7,%xmm6
movapd %xmm4,%xmm7
mulsd  %xmm4,%xmm7
ucomisd %xmm2,%xmm0
movsd  %xmm7,0x28(%rsp)
jbe    1438 <Worley+0x318>
lea    -0x1(%rbp),%rsi
lea    0x30(%rsp),%r8
mov    %r13,%rdi
mov    %r12,%rdx
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
movsd  %xmm6,0x58(%rsp)
call   1030 <AddSamples@plt>
movsd  0x38(%rsp),%xmm7
movsd  0x58(%rsp),%xmm6
movsd  0x20(%rsp),%xmm5
movsd  0x28(%rsp),%xmm4
movsd  0x18(%rsp),%xmm2
movsd  0xc0b(%rip),%xmm1
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movapd %xmm1,%xmm3
subsd  %xmm5,%xmm3
mulsd  %xmm6,%xmm6
ucomisd %xmm7,%xmm0
movsd  %xmm6,0x48(%rsp)
jbe    14a2 <Worley+0x382>
lea    -0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
movsd  %xmm3,0x60(%rsp)
call   1030 <AddSamples@plt>
movsd  0x58(%rsp),%xmm6
movsd  0x28(%rsp),%xmm4
movsd  0x60(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
movsd  0xba1(%rip),%xmm1
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
subsd  %xmm4,%xmm1
mulsd  %xmm3,%xmm3
ucomisd %xmm6,%xmm0
movsd  %xmm3,0x50(%rsp)
jbe    14f9 <Worley+0x3d9>
lea    0x1(%r13),%rdi
lea    0x30(%rsp),%r8
mov    %rbp,%rsi
mov    %r12,%rdx
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
movsd  %xmm1,0x28(%rsp)
call   1030 <AddSamples@plt>
movsd  0x60(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
movsd  0x28(%rsp),%xmm1
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
mulsd  %xmm1,%xmm1
ucomisd %xmm3,%xmm0
movsd  %xmm1,0x18(%rsp)
jbe    1540 <Worley+0x420>
lea    0x1(%rbp),%rsi
lea    0x30(%rsp),%r8
mov    %r13,%rdi
mov    %r12,%rdx
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x18(%rsp),%xmm2
movsd  0x28(%rsp),%xmm1
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1578 <Worley+0x458>
lea    0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x58(%rsp),%xmm1
movapd %xmm1,%xmm5
addsd  %xmm2,%xmm5
ucomisd %xmm5,%xmm0
movsd  %xmm5,0x20(%rsp)
jbe    15d0 <Worley+0x4b0>
lea    -0x1(%r13),%rdi
lea    -0x1(%rbp),%rsi
lea    0x30(%rsp),%r8
mov    %r12,%rdx
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x30(%rsp),%xmm5
movsd  0x68(%rsp),%xmm1
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x28(%rsp),%xmm3
addsd  %xmm3,%xmm1
ucomisd %xmm1,%xmm0
jbe    161f <Worley+0x4ff>
lea    -0x1(%r13),%rdi
lea    -0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %rbp,%rsi
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x38(%rsp),%xmm3
movsd  0x30(%rsp),%xmm5
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movapd %xmm2,%xmm1
addsd  %xmm3,%xmm1
ucomisd %xmm1,%xmm0
jbe    1666 <Worley+0x546>
lea    -0x1(%rbp),%rsi
lea    -0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r13,%rdi
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x30(%rsp),%xmm5
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x48(%rsp),%xmm1
movapd %xmm1,%xmm3
addsd  0x50(%rsp),%xmm3
ucomisd %xmm3,%xmm0
movsd  %xmm3,0x10(%rsp)
jbe    16c6 <Worley+0x5a6>
lea    0x1(%r13),%rdi
lea    0x1(%rbp),%rsi
lea    0x30(%rsp),%r8
mov    %r12,%rdx
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x30(%rsp),%xmm5
movsd  0x58(%rsp),%xmm1
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x18(%rsp),%xmm4
addsd  %xmm4,%xmm1
ucomisd %xmm1,%xmm0
jbe    171b <Worley+0x5fb>
lea    0x1(%r13),%rdi
lea    0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %rbp,%rsi
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x28(%rsp),%xmm4
movsd  0x30(%rsp),%xmm5
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x50(%rsp),%xmm6
movapd %xmm6,%xmm1
addsd  %xmm4,%xmm1
ucomisd %xmm1,%xmm0
jbe    1774 <Worley+0x654>
lea    0x1(%rbp),%rsi
lea    0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r13,%rdi
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x60(%rsp),%xmm6
movsd  0x30(%rsp),%xmm5
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x58(%rsp),%xmm1
movapd %xmm1,%xmm4
addsd  %xmm6,%xmm4
movsd  %xmm4,0x60(%rsp)
ucomisd %xmm4,%xmm0
jbe    17d2 <Worley+0x6b2>
lea    -0x1(%r13),%rdi
lea    0x1(%rbp),%rsi
lea    0x30(%rsp),%r8
mov    %r12,%rdx
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x30(%rsp),%xmm5
movsd  0x68(%rsp),%xmm1
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x18(%rsp),%xmm4
addsd  %xmm4,%xmm1
ucomisd %xmm1,%xmm0
jbe    1827 <Worley+0x707>
lea    -0x1(%r13),%rdi
lea    0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %rbp,%rsi
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x28(%rsp),%xmm4
movsd  0x30(%rsp),%xmm5
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movapd %xmm2,%xmm1
addsd  %xmm4,%xmm1
ucomisd %xmm1,%xmm0
jbe    1874 <Worley+0x754>
lea    -0x1(%rbp),%rsi
lea    0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r13,%rdi
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x30(%rsp),%xmm5
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x48(%rsp),%xmm4
addsd  %xmm4,%xmm2
ucomisd %xmm2,%xmm0
movsd  %xmm2,0x8(%rsp)
jbe    18ce <Worley+0x7ae>
lea    0x1(%r13),%rdi
lea    -0x1(%rbp),%rsi
lea    0x30(%rsp),%r8
mov    %r12,%rdx
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x58(%rsp),%xmm4
movsd  0x30(%rsp),%xmm5
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x28(%rsp),%xmm1
addsd  %xmm1,%xmm4
ucomisd %xmm4,%xmm0
jbe    1923 <Worley+0x803>
lea    0x1(%r13),%rdi
lea    -0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %rbp,%rsi
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x30(%rsp),%xmm5
movsd  0x20(%rsp),%xmm3
movsd  0x38(%rsp),%xmm1
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x50(%rsp),%xmm4
addsd  %xmm1,%xmm4
ucomisd %xmm4,%xmm0
movapd %xmm1,%xmm4
jbe    197c <Worley+0x85c>
lea    0x1(%rbp),%rsi
lea    -0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r13,%rdi
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x38(%rsp),%xmm4
movsd  0x30(%rsp),%xmm5
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movapd %xmm5,%xmm1
addsd  %xmm4,%xmm1
ucomisd %xmm1,%xmm0
jbe    19ca <Worley+0x8aa>
lea    -0x1(%r13),%rdi
lea    -0x1(%rbp),%rsi
lea    -0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x30(%rsp),%xmm5
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
addsd  0x18(%rsp),%xmm5
ucomisd %xmm5,%xmm0
jbe    1a10 <Worley+0x8f0>
lea    -0x1(%r13),%rdi
lea    -0x1(%rbp),%rsi
lea    0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x60(%rsp),%xmm4
movapd %xmm4,%xmm1
addsd  0x28(%rsp),%xmm1
ucomisd %xmm1,%xmm0
jbe    1a66 <Worley+0x946>
lea    -0x1(%r13),%rdi
lea    0x1(%rbp),%rsi
lea    -0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x70(%rsp),%xmm4
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
addsd  0x18(%rsp),%xmm4
ucomisd %xmm4,%xmm0
jbe    1aac <Worley+0x98c>
lea    -0x1(%r13),%rdi
lea    0x1(%rbp),%rsi
lea    0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movapd %xmm2,%xmm1
addsd  0x28(%rsp),%xmm1
ucomisd %xmm1,%xmm0
jbe    1af6 <Worley+0x9d6>
lea    0x1(%r13),%rdi
lea    -0x1(%rbp),%rsi
lea    -0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x20(%rsp),%xmm3
movsd  0x18(%rsp),%xmm2
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x18(%rsp),%xmm1
addsd  %xmm1,%xmm2
ucomisd %xmm2,%xmm0
jbe    1b40 <Worley+0xa20>
lea    0x1(%r13),%rdi
lea    -0x1(%rbp),%rsi
lea    0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x20(%rsp),%xmm3
movsd  0x28(%rsp),%xmm1
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
movsd  0x28(%rsp),%xmm2
addsd  %xmm3,%xmm2
ucomisd %xmm2,%xmm0
jbe    1b8a <Worley+0xa6a>
lea    0x1(%r13),%rdi
lea    0x1(%rbp),%rsi
lea    -0x1(%r12),%rdx
lea    0x30(%rsp),%r8
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
movsd  0x20(%rsp),%xmm3
movsd  0x28(%rsp),%xmm1
add    $0x10,%rsp
movsd  -0x8(%r14,%r15,8),%xmm0
addsd  %xmm1,%xmm3
ucomisd %xmm3,%xmm0
jbe    1bc3 <Worley+0xaa3>
add    $0x1,%r13
add    $0x1,%rbp
add    $0x1,%r12
lea    0x30(%rsp),%r8
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
mov    %r15,%rcx
mov    %r14,%r9
xor    %eax,%eax
push   (%rsp)
push   %rbx
call   1030 <AddSamples@plt>
add    $0x10,%rsp
test   %r15,%r15
jle    1c4c <Worley+0xb2c>
add    $0x10,%rbx
xor    %ebp,%ebp
xorpd  %xmm1,%xmm1
movsd  0x462(%rip),%xmm2
movapd 0x43a(%rip),%xmm3
jmp    1c3a <Worley+0xb1a>
nopl   0x0(%rax,%rax,1)
call   1040 <sqrt@plt>
movapd 0x423(%rip),%xmm3
movsd  0x43b(%rip),%xmm2
xorpd  %xmm1,%xmm1
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%r14,%rbp,8)
movupd -0x10(%rbx),%xmm0
mulpd  %xmm3,%xmm0
movupd %xmm0,-0x10(%rbx)
movsd  (%rbx),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,(%rbx)
add    $0x1,%rbp
add    $0x18,%rbx
cmp    %rbp,%r15
je     1c4c <Worley+0xb2c>
movsd  (%r14,%rbp,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1bf0 <Worley+0xad0>
sqrtsd %xmm0,%xmm0
jmp    1c09 <Worley+0xae9>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @Worley(double* nocapture %0, i64 %1, double* %2, [3 x double]* %3, i64* %4) {
%6 = alloca [3 x double]
%7 = bitcast [3 x double]* %6 to i8*
%8 = icmp sgt i64 %1, 0
br i1 %8, label %9, label %87
9: ; preds = %5
%10 = icmp ult i64 %1, 4
br i1 %10, label %80, label %11
11: ; preds = %9
%12 = and i64 %1, -4
%13 = add i64 %12, -4
%14 = lshr exact i64 %13, 2
%15 = add nuw nsw i64 %14, 1
%16 = and i64 %15, 7
%17 = icmp ult i64 %13, 28
br i1 %17, label %65, label %18
18: ; preds = %11
%19 = and i64 %15, 9223372036854775800
br label %20
20: ; preds = %20, %18
%21 = phi i64 [ 0, %18 ], [ %62, %20 ]
%22 = phi i64 [ 0, %18 ], [ %63, %20 ]
%23 = getelementptr inbounds double, double* %2, i64 %21
%24 = bitcast double* %23 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %24
%25 = getelementptr inbounds double, double* %23, i64 2
%26 = bitcast double* %25 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %26
%27 = or i64 %21, 4
%28 = getelementptr inbounds double, double* %2, i64 %27
%29 = bitcast double* %28 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %29
%30 = getelementptr inbounds double, double* %28, i64 2
%31 = bitcast double* %30 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %31
%32 = or i64 %21, 8
%33 = getelementptr inbounds double, double* %2, i64 %32
%34 = bitcast double* %33 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %34
%35 = getelementptr inbounds double, double* %33, i64 2
%36 = bitcast double* %35 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %36
%37 = or i64 %21, 12
%38 = getelementptr inbounds double, double* %2, i64 %37
%39 = bitcast double* %38 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %39
%40 = getelementptr inbounds double, double* %38, i64 2
%41 = bitcast double* %40 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %41
%42 = or i64 %21, 16
%43 = getelementptr inbounds double, double* %2, i64 %42
%44 = bitcast double* %43 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %44
%45 = getelementptr inbounds double, double* %43, i64 2
%46 = bitcast double* %45 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %46
%47 = or i64 %21, 20
%48 = getelementptr inbounds double, double* %2, i64 %47
%49 = bitcast double* %48 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %49
%50 = getelementptr inbounds double, double* %48, i64 2
%51 = bitcast double* %50 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %51
%52 = or i64 %21, 24
%53 = getelementptr inbounds double, double* %2, i64 %52
%54 = bitcast double* %53 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %54
%55 = getelementptr inbounds double, double* %53, i64 2
%56 = bitcast double* %55 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %56
%57 = or i64 %21, 28
%58 = getelementptr inbounds double, double* %2, i64 %57
%59 = bitcast double* %58 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %59
%60 = getelementptr inbounds double, double* %58, i64 2
%61 = bitcast double* %60 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %61
%62 = add nuw i64 %21, 32
%63 = add i64 %22, 8
%64 = icmp eq i64 %63, %19
br i1 %64, label %65, label %20
65: ; preds = %20, %11
%66 = phi i64 [ 0, %11 ], [ %62, %20 ]
%67 = icmp eq i64 %16, 0
br i1 %67, label %78, label %68
68: ; preds = %65, %68
%69 = phi i64 [ %75, %68 ], [ %66, %65 ]
%70 = phi i64 [ %76, %68 ], [ 0, %65 ]
%71 = getelementptr inbounds double, double* %2, i64 %69
%72 = bitcast double* %71 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %72
%73 = getelementptr inbounds double, double* %71, i64 2
%74 = bitcast double* %73 to <2 x double>*
store <2 x double> <double 0x412E847FCCCCCCCD, double 0x412E847FCCCCCCCD>, <2 x double>* %74
%75 = add nuw i64 %69, 4
%76 = add i64 %70, 1
%77 = icmp eq i64 %76, %16
br i1 %77, label %78, label %68
78: ; preds = %68, %65
%79 = icmp eq i64 %12, %1
br i1 %79, label %87, label %80
80: ; preds = %9, %78
%81 = phi i64 [ 0, %9 ], [ %12, %78 ]
br label %82
82: ; preds = %80, %82
%83 = phi i64 [ %85, %82 ], [ %81, %80 ]
%84 = getelementptr inbounds double, double* %2, i64 %83
store double 0x412E847FCCCCCCCD, double* %84
%85 = add nuw nsw i64 %83, 1
%86 = icmp eq i64 %85, %1
br i1 %86, label %87, label %82
87: ; preds = %82, %78, %5
%88 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 0
%89 = bitcast double* %0 to <2 x double>*
%90 = load <2 x double>, <2 x double>* %89
%91 = fmul <2 x double> %90, <double 3.981500e-01, double 3.981500e-01>
%92 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 1
%93 = bitcast [3 x double]* %6 to <2 x double>*
store <2 x double> %91, <2 x double>* %93
%94 = getelementptr inbounds double, double* %0, i64 2
%95 = load double, double* %94
%96 = fmul double %95, 3.981500e-01
%97 = getelementptr inbounds [3 x double], [3 x double]* %6, i64 0, i64 2
store double %96, double* %97
%98 = extractelement <2 x double> %91, i64 0
%99 = fptosi double %98 to i64
%100 = sitofp i64 %99 to double
%101 = fcmp olt double %98, %100
%102 = sext i1 %101 to i64
%103 = add nsw i64 %102, %99
%104 = extractelement <2 x double> %91, i64 1
%105 = fptosi double %104 to i64
%106 = sitofp i64 %105 to double
%107 = fcmp olt double %104, %106
%108 = sext i1 %107 to i64
%109 = add nsw i64 %108, %105
%110 = fptosi double %96 to i64
%111 = sitofp i64 %110 to double
%112 = fcmp olt double %96, %111
%113 = sext i1 %112 to i64
%114 = add nsw i64 %113, %110
%115 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %103, i64 %109, i64 %114, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%116 = load double, double* %88
%117 = sitofp i64 %103 to double
%118 = fsub double %116, %117
%119 = load double, double* %92
%120 = sitofp i64 %109 to double
%121 = fsub double %119, %120
%122 = load double, double* %97
%123 = sitofp i64 %114 to double
%124 = fsub double %122, %123
%125 = fsub double 1.000000e+00, %118
%126 = fmul double %125, %125
%127 = fsub double 1.000000e+00, %121
%128 = fmul double %127, %127
%129 = fsub double 1.000000e+00, %124
%130 = fmul double %129, %129
%131 = fmul double %118, %118
%132 = fmul double %121, %121
%133 = fmul double %124, %124
%134 = add nsw i64 %1, -1
%135 = getelementptr inbounds double, double* %2, i64 %134
%136 = load double, double* %135
%137 = fcmp olt double %131, %136
br i1 %137, label %138, label %142
138: ; preds = %87
%139 = add nsw i64 %103, -1
%140 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %139, i64 %109, i64 %114, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%141 = load double, double* %135
br label %142
142: ; preds = %138, %87
%143 = phi double [ %141, %138 ], [ %136, %87 ]
%144 = fcmp olt double %132, %143
br i1 %144, label %145, label %149
145: ; preds = %142
%146 = add nsw i64 %109, -1
%147 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %103, i64 %146, i64 %114, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%148 = load double, double* %135
br label %149
149: ; preds = %145, %142
%150 = phi double [ %148, %145 ], [ %143, %142 ]
%151 = fcmp olt double %133, %150
br i1 %151, label %152, label %156
152: ; preds = %149
%153 = add nsw i64 %114, -1
%154 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %103, i64 %109, i64 %153, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%155 = load double, double* %135
br label %156
156: ; preds = %152, %149
%157 = phi double [ %155, %152 ], [ %150, %149 ]
%158 = fcmp olt double %126, %157
br i1 %158, label %159, label %163
159: ; preds = %156
%160 = add nsw i64 %103, 1
%161 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %160, i64 %109, i64 %114, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%162 = load double, double* %135
br label %163
163: ; preds = %159, %156
%164 = phi double [ %162, %159 ], [ %157, %156 ]
%165 = fcmp olt double %128, %164
br i1 %165, label %166, label %170
166: ; preds = %163
%167 = add nsw i64 %109, 1
%168 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %103, i64 %167, i64 %114, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%169 = load double, double* %135
br label %170
170: ; preds = %166, %163
%171 = phi double [ %169, %166 ], [ %164, %163 ]
%172 = fcmp olt double %130, %171
br i1 %172, label %173, label %177
173: ; preds = %170
%174 = add nsw i64 %114, 1
%175 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %103, i64 %109, i64 %174, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%176 = load double, double* %135
br label %177
177: ; preds = %173, %170
%178 = phi double [ %176, %173 ], [ %171, %170 ]
%179 = fadd double %131, %132
%180 = fcmp olt double %179, %178
br i1 %180, label %181, label %186
181: ; preds = %177
%182 = add nsw i64 %103, -1
%183 = add nsw i64 %109, -1
%184 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %182, i64 %183, i64 %114, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%185 = load double, double* %135
br label %186
186: ; preds = %181, %177
%187 = phi double [ %185, %181 ], [ %178, %177 ]
%188 = fadd double %131, %133
%189 = fcmp olt double %188, %187
br i1 %189, label %190, label %195
190: ; preds = %186
%191 = add nsw i64 %103, -1
%192 = add nsw i64 %114, -1
%193 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %191, i64 %109, i64 %192, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%194 = load double, double* %135
br label %195
195: ; preds = %190, %186
%196 = phi double [ %194, %190 ], [ %187, %186 ]
%197 = fadd double %132, %133
%198 = fcmp olt double %197, %196
br i1 %198, label %199, label %204
199: ; preds = %195
%200 = add nsw i64 %109, -1
%201 = add nsw i64 %114, -1
%202 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %103, i64 %200, i64 %201, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%203 = load double, double* %135
br label %204
204: ; preds = %199, %195
%205 = phi double [ %203, %199 ], [ %196, %195 ]
%206 = fadd double %126, %128
%207 = fcmp olt double %206, %205
br i1 %207, label %208, label %213
208: ; preds = %204
%209 = add nsw i64 %103, 1
%210 = add nsw i64 %109, 1
%211 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %209, i64 %210, i64 %114, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%212 = load double, double* %135
br label %213
213: ; preds = %208, %204
%214 = phi double [ %212, %208 ], [ %205, %204 ]
%215 = fadd double %126, %130
%216 = fcmp olt double %215, %214
br i1 %216, label %217, label %222
217: ; preds = %213
%218 = add nsw i64 %103, 1
%219 = add nsw i64 %114, 1
%220 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %218, i64 %109, i64 %219, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%221 = load double, double* %135
br label %222
222: ; preds = %217, %213
%223 = phi double [ %221, %217 ], [ %214, %213 ]
%224 = fadd double %128, %130
%225 = fcmp olt double %224, %223
br i1 %225, label %226, label %231
226: ; preds = %222
%227 = add nsw i64 %109, 1
%228 = add nsw i64 %114, 1
%229 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %103, i64 %227, i64 %228, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%230 = load double, double* %135
br label %231
231: ; preds = %226, %222
%232 = phi double [ %230, %226 ], [ %223, %222 ]
%233 = fadd double %131, %128
%234 = fcmp olt double %233, %232
br i1 %234, label %235, label %240
235: ; preds = %231
%236 = add nsw i64 %103, -1
%237 = add nsw i64 %109, 1
%238 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %236, i64 %237, i64 %114, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%239 = load double, double* %135
br label %240
240: ; preds = %235, %231
%241 = phi double [ %239, %235 ], [ %232, %231 ]
%242 = fadd double %131, %130
%243 = fcmp olt double %242, %241
br i1 %243, label %244, label %249
244: ; preds = %240
%245 = add nsw i64 %103, -1
%246 = add nsw i64 %114, 1
%247 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %245, i64 %109, i64 %246, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%248 = load double, double* %135
br label %249
249: ; preds = %244, %240
%250 = phi double [ %248, %244 ], [ %241, %240 ]
%251 = fadd double %132, %130
%252 = fcmp olt double %251, %250
br i1 %252, label %253, label %258
253: ; preds = %249
%254 = add nsw i64 %109, -1
%255 = add nsw i64 %114, 1
%256 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %103, i64 %254, i64 %255, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%257 = load double, double* %135
br label %258
258: ; preds = %253, %249
%259 = phi double [ %257, %253 ], [ %250, %249 ]
%260 = fadd double %126, %132
%261 = fcmp olt double %260, %259
br i1 %261, label %262, label %267
262: ; preds = %258
%263 = add nsw i64 %103, 1
%264 = add nsw i64 %109, -1
%265 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %263, i64 %264, i64 %114, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%266 = load double, double* %135
br label %267
267: ; preds = %262, %258
%268 = phi double [ %266, %262 ], [ %259, %258 ]
%269 = fadd double %126, %133
%270 = fcmp olt double %269, %268
br i1 %270, label %271, label %276
271: ; preds = %267
%272 = add nsw i64 %103, 1
%273 = add nsw i64 %114, -1
%274 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %272, i64 %109, i64 %273, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%275 = load double, double* %135
br label %276
276: ; preds = %271, %267
%277 = phi double [ %275, %271 ], [ %268, %267 ]
%278 = fadd double %128, %133
%279 = fcmp olt double %278, %277
br i1 %279, label %280, label %285
280: ; preds = %276
%281 = add nsw i64 %109, 1
%282 = add nsw i64 %114, -1
%283 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %103, i64 %281, i64 %282, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%284 = load double, double* %135
br label %285
285: ; preds = %280, %276
%286 = phi double [ %284, %280 ], [ %277, %276 ]
%287 = fadd double %179, %133
%288 = fcmp olt double %287, %286
br i1 %288, label %289, label %295
289: ; preds = %285
%290 = add nsw i64 %103, -1
%291 = add nsw i64 %109, -1
%292 = add nsw i64 %114, -1
%293 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %290, i64 %291, i64 %292, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%294 = load double, double* %135
br label %295
295: ; preds = %289, %285
%296 = phi double [ %294, %289 ], [ %286, %285 ]
%297 = fadd double %179, %130
%298 = fcmp olt double %297, %296
br i1 %298, label %299, label %305
299: ; preds = %295
%300 = add nsw i64 %103, -1
%301 = add nsw i64 %109, -1
%302 = add nsw i64 %114, 1
%303 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %300, i64 %301, i64 %302, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%304 = load double, double* %135
br label %305
305: ; preds = %299, %295
%306 = phi double [ %304, %299 ], [ %296, %295 ]
%307 = fadd double %233, %133
%308 = fcmp olt double %307, %306
br i1 %308, label %309, label %315
309: ; preds = %305
%310 = add nsw i64 %103, -1
%311 = add nsw i64 %109, 1
%312 = add nsw i64 %114, -1
%313 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %310, i64 %311, i64 %312, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%314 = load double, double* %135
br label %315
315: ; preds = %309, %305
%316 = phi double [ %314, %309 ], [ %306, %305 ]
%317 = fadd double %233, %130
%318 = fcmp olt double %317, %316
br i1 %318, label %319, label %325
319: ; preds = %315
%320 = add nsw i64 %103, -1
%321 = add nsw i64 %109, 1
%322 = add nsw i64 %114, 1
%323 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %320, i64 %321, i64 %322, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%324 = load double, double* %135
br label %325
325: ; preds = %319, %315
%326 = phi double [ %324, %319 ], [ %316, %315 ]
%327 = fadd double %260, %133
%328 = fcmp olt double %327, %326
br i1 %328, label %329, label %335
329: ; preds = %325
%330 = add nsw i64 %103, 1
%331 = add nsw i64 %109, -1
%332 = add nsw i64 %114, -1
%333 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %330, i64 %331, i64 %332, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%334 = load double, double* %135
br label %335
335: ; preds = %329, %325
%336 = phi double [ %334, %329 ], [ %326, %325 ]
%337 = fadd double %260, %130
%338 = fcmp olt double %337, %336
br i1 %338, label %339, label %345
339: ; preds = %335
%340 = add nsw i64 %103, 1
%341 = add nsw i64 %109, -1
%342 = add nsw i64 %114, 1
%343 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %340, i64 %341, i64 %342, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%344 = load double, double* %135
br label %345
345: ; preds = %339, %335
%346 = phi double [ %344, %339 ], [ %336, %335 ]
%347 = fadd double %206, %133
%348 = fcmp olt double %347, %346
br i1 %348, label %349, label %355
349: ; preds = %345
%350 = add nsw i64 %103, 1
%351 = add nsw i64 %109, 1
%352 = add nsw i64 %114, -1
%353 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %350, i64 %351, i64 %352, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
%354 = load double, double* %135
br label %355
355: ; preds = %349, %345
%356 = phi double [ %354, %349 ], [ %346, %345 ]
%357 = fadd double %206, %130
%358 = fcmp olt double %357, %356
br i1 %358, label %359, label %364
359: ; preds = %355
%360 = add nsw i64 %103, 1
%361 = add nsw i64 %109, 1
%362 = add nsw i64 %114, 1
%363 = call i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...) bitcast (i32 (...)* @AddSamples to i32 (i64, i64, i64, i64, double*, double*, [3 x double]*, i64*, ...)*)(i64 %360, i64 %361, i64 %362, i64 %1, double* %88, double* %2, [3 x double]* %3, i64* %4)
br label %364
364: ; preds = %359, %355
br i1 %8, label %365, label %381
365: ; preds = %364, %365
%366 = phi i64 [ %379, %365 ], [ 0, %364 ]
%367 = getelementptr inbounds double, double* %2, i64 %366
%368 = load double, double* %367
%369 = call double @sqrt(double %368)
%370 = fmul double %369, 0x400417CA3F5539E6
store double %370, double* %367
%371 = getelementptr inbounds [3 x double], [3 x double]* %3, i64 %366, i64 0
%372 = bitcast double* %371 to <2 x double>*
%373 = load <2 x double>, <2 x double>* %372
%374 = fmul <2 x double> %373, <double 0x400417CA3F5539E6, double 0x400417CA3F5539E6>
%375 = bitcast double* %371 to <2 x double>*
store <2 x double> %374, <2 x double>* %375
%376 = getelementptr inbounds [3 x double], [3 x double]* %3, i64 %366, i64 2
%377 = load double, double* %376
%378 = fmul double %377, 0x400417CA3F5539E6
store double %378, double* %376
%379 = add nuw nsw i64 %366, 1
%380 = icmp eq i64 %379, %1
br i1 %380, label %381, label %365
381: ; preds = %365, %364
ret void
}