void SampleEwaldU(int NRS, long STEPU, int N, double Rc, double a, double d,
                  int M, double *X0, double *Y0, double *XX, double *YY,
                  double Rmax, double *U00, double *U0, double *U6,
                  double *U12) {
  double dr2 = Rmax * Rmax / ((double)NRS);
  int NTH = 5;
  double dt = 3.1415926535898f / ((double)(6 * (NTH - 1)));
  double u00;
  double *x, *y, *u;
  x = (double *)malloc(NRS * NTH * sizeof(double));
  y = (double *)malloc(NRS * NTH * sizeof(double));
  u = (double *)malloc(NRS * NTH * sizeof(double));
  for (int j = 0; j < NTH; ++j) {
    double t = dt * ((double)j);
    double c = cos(t), s = sin(t);
    for (int i = 0; i < NRS; ++i) {
      int id = i + j * NRS;
      double r2 = dr2 * ((double)(i + 1));
      double r = sqrt(r2);
      x[id] = r * c;
      y[id] = r * s;
    }
  }
  int *INNER, NI;
  INNER = (int *)malloc(N * sizeof(int));
  NI = 0;
  for (int i = 0; i < N; ++i) {
    if (XX[i] * XX[i] + YY[i] * YY[i] < (Rc * Rc) * (a * a) * 0.1) {
      INNER[NI] = i;
      NI++;
    }
  }
  long NACCEP, STRIDE = 4 * N;
  double x0, y0;
  u00 = 0.0;
  memset(u, 0, NRS * NTH * sizeof(double));
  double c = cos(3.1415926535898f / 3.0), s = sin(3.1415926535898f / 3.0);
  for (long i = 0; i < STEPU; ++i) {
    metropolis_host_(&N, X0, Y0, XX, YY, &M, &d, &a, &STRIDE, &NACCEP);
    for (int j = 0; j < NI; ++j) {
      x0 = X0[INNER[j]] - XX[INNER[j]];
      y0 = Y0[INNER[j]] - YY[INNER[j]];
      for (int irfl = 0; irfl <= 1; ++irfl) {
        for (int irot = 0; irot < 6; ++irot) {
          u00 += approxU(x0, y0, NRS, Rmax, U0, U6, U12);
          for (int k = 0; k < NRS * NTH; ++k) {
            u[k] += approxU(x[k] + x0, y[k] + y0, NRS, Rmax, U0, U6, U12);
          }
          double x1 = x0, y1 = y0;
          x0 = c * x1 - s * y1;
          y0 = s * x1 + c * y1;
        }
        y0 = -y0;
      }
    }
  }
  u00 /= ((double)(12 * STEPU * NI));
  for (int i = 0; i < NRS * NTH; ++i) {
    u[i] /= ((double)(12 * STEPU * NI));
  }
  for (int i = 0; i < NRS; ++i) {
    double u0 = 0.0;
    double u6 = 0.0;
    double u12 = 0.0;
    for (int j = 0; j < NTH; ++j) {
      double t = dt * ((double)j);
      double uu;
      int id = i + j * NRS;
      uu = u[id];
      if (j == 0 || j == NTH - 1)
        uu *= 0.5;
      u0 += uu;
      u6 += uu * cos(6.0 * t);
      u12 += uu * cos(12.0 * t);
    }
    *U00 = u00;
    U0[i] = u0 / ((double)(NTH - 1)) - u00;
    U6[i] = u6 / ((double)(NTH - 1)) * 2.0;
    U12[i] = u12 / ((double)(NTH - 1)) * 2.0;
  }
  free(x);
  free(y);
  free(u);
  free(INNER);
}


x86 assembly (clang, -O0):
<SampleEwaldU>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x198,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0xc(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
movsd  %xmm2,-0x38(%rbp)
mov    %ecx,-0x3c(%rbp)
mov    %r8,-0x48(%rbp)
mov    %r9,-0x50(%rbp)
movsd  %xmm3,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x5,-0x64(%rbp)
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
imul   $0x6,%eax,%eax
cvtsi2sd %eax,%xmm1
movsd  0xdff(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x64(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x64(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x88(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x64(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x90(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    1385 <SampleEwaldU+0x205>
movsd  -0x70(%rbp),%xmm0
cvtsi2sdl -0x94(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1090 <cos@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1060 <sin@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    136c <SampleEwaldU+0x1ec>
mov    -0xb4(%rbp),%eax
mov    -0x94(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xb8(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   10a0 <sqrt@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movslq -0xb8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    12bb <SampleEwaldU+0x13b>
jmp    1371 <SampleEwaldU+0x1f1>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    125f <SampleEwaldU+0xdf>
movslq -0x1c(%rbp),%rdi
shl    $0x2,%rdi
call   1080 <malloc@plt>
mov    %rax,-0xd0(%rbp)
movl   $0x0,-0xd4(%rbp)
movl   $0x0,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1471 <SampleEwaldU+0x2f1>
mov    0x10(%rbp),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0xd8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0xd8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x28(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
mulsd  -0x30(%rbp),%xmm2
mulsd  %xmm2,%xmm0
movsd  0xc0c(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1458 <SampleEwaldU+0x2d8>
mov    -0xd8(%rbp),%edx
mov    -0xd0(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    145d <SampleEwaldU+0x2dd>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    13ad <SampleEwaldU+0x22d>
mov    -0x1c(%rbp),%eax
shl    $0x2,%eax
cltq
mov    %rax,-0xe8(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x90(%rbp),%rdi
mov    -0xc(%rbp),%eax
imul   -0x64(%rbp),%eax
movslq %eax,%rdx
shl    $0x3,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
movsd  0xb5c(%rip),%xmm0
call   1090 <cos@plt>
movsd  %xmm0,-0x100(%rbp)
ff
movsd  0xb47(%rip),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0x108(%rbp)
ff
movq   $0x0,-0x110(%rbp)
mov    -0x110(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    17e9 <SampleEwaldU+0x669>
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    0x10(%rbp),%rcx
mov    0x18(%rbp),%r8
lea    -0x1c(%rbp),%rdi
lea    -0x3c(%rbp),%r9
lea    -0x38(%rbp),%rbx
lea    -0x30(%rbp),%r11
lea    -0xe8(%rbp),%r10
lea    -0xe0(%rbp),%rax
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x0,%al
call   1040 <metropolis_host_@plt>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
cmp    -0xd4(%rbp),%eax
jge    17cd <SampleEwaldU+0x64d>
mov    -0x48(%rbp),%rax
mov    -0xd0(%rbp),%rcx
movslq -0x114(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0xd0(%rbp),%rcx
movslq -0x114(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x50(%rbp),%rax
mov    -0xd0(%rbp),%rcx
movslq -0x114(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0xd0(%rbp),%rcx
movslq -0x114(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movl   $0x0,-0x118(%rbp)
cmpl   $0x1,-0x118(%rbp)
jg     17b4 <SampleEwaldU+0x634>
movl   $0x0,-0x11c(%rbp)
cmpl   $0x6,-0x11c(%rbp)
jge    1779 <SampleEwaldU+0x5f9>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
mov    -0xc(%rbp),%edi
movsd  -0x58(%rbp),%xmm2
mov    0x28(%rbp),%rsi
mov    0x30(%rbp),%rdx
mov    0x38(%rbp),%rcx
mov    $0x3,%al
call   1070 <approxU@plt>
cvtsi2sd %eax,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x120(%rbp)
mov    -0x120(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0x64(%rbp),%ecx
cmp    %ecx,%eax
jge    16ce <SampleEwaldU+0x54e>
mov    -0x80(%rbp),%rax
movslq -0x120(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xf0(%rbp),%xmm0
ff
mov    -0x88(%rbp),%rax
movslq -0x120(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  -0xf8(%rbp),%xmm1
ff
mov    -0xc(%rbp),%edi
movsd  -0x58(%rbp),%xmm2
mov    0x28(%rbp),%rsi
mov    0x30(%rbp),%rdx
mov    0x38(%rbp),%rcx
mov    $0x3,%al
call   1070 <approxU@plt>
cvtsi2sd %eax,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x120(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x120(%rbp)
jmp    163b <SampleEwaldU+0x4bb>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x128(%rbp),%xmm2
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x130(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x11c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x11c(%rbp)
jmp    15eb <SampleEwaldU+0x46b>
movsd  -0xf8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x118(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x118(%rbp)
jmp    15d4 <SampleEwaldU+0x454>
jmp    17b9 <SampleEwaldU+0x639>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    153c <SampleEwaldU+0x3bc>
jmp    17d2 <SampleEwaldU+0x652>
mov    -0x110(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x110(%rbp)
jmp    14d9 <SampleEwaldU+0x359>
imul   $0xc,-0x18(%rbp),%rax
movslq -0xd4(%rbp),%rcx
imul   %rcx,%rax
cvtsi2sd %rax,%xmm1
movsd  -0x78(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x134(%rbp)
mov    -0x134(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   -0x64(%rbp),%ecx
cmp    %ecx,%eax
jge    1870 <SampleEwaldU+0x6f0>
imul   $0xc,-0x18(%rbp),%rax
movslq -0xd4(%rbp),%rcx
imul   %rcx,%rax
cvtsi2sd %rax,%xmm1
mov    -0x90(%rbp),%rax
movslq -0x134(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1816 <SampleEwaldU+0x696>
movl   $0x0,-0x138(%rbp)
mov    -0x138(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ab4 <SampleEwaldU+0x934>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    1a04 <SampleEwaldU+0x884>
movsd  -0x70(%rbp),%xmm0
cvtsi2sdl -0x154(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x138(%rbp),%eax
mov    -0x154(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x16c(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x16c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
cmpl   $0x0,-0x154(%rbp)
je     1930 <SampleEwaldU+0x7b0>
mov    -0x154(%rbp),%eax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1948 <SampleEwaldU+0x7c8>
movsd  0x6e0(%rip),%xmm0
mulsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
addsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
movsd  0x6b0(%rip),%xmm0
mulsd  -0x160(%rbp),%xmm0
ff
call   1090 <cos@plt>
movaps %xmm0,%xmm2
movsd  -0x180(%rbp),%xmm0
ff
movsd  -0x148(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  0x660(%rip),%xmm0
mulsd  -0x160(%rbp),%xmm0
ff
call   1090 <cos@plt>
movaps %xmm0,%xmm2
movsd  -0x178(%rbp),%xmm0
ff
movsd  -0x150(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    18b4 <SampleEwaldU+0x734>
movsd  -0x78(%rbp),%xmm0
mov    0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
subsd  -0x78(%rbp),%xmm0
mov    0x28(%rbp),%rax
movslq -0x138(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x148(%rbp),%xmm0
ff
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  0x5b6(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    0x30(%rbp),%rax
movslq -0x138(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x150(%rbp),%xmm0
ff
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  0x584(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x138(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    187a <SampleEwaldU+0x6fa>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x88(%rbp),%rdi
call   1030 <free@plt>
mov    -0x90(%rbp),%rdi
call   1030 <free@plt>
mov    -0xd0(%rbp),%rdi
call   1030 <free@plt>
add    $0x198,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<SampleEwaldU>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
movsd  %xmm3,0x58(%rsp)
mov    %r9,0xc0(%rsp)
mov    %r8,0xb8(%rsp)
movsd  %xmm0,0x80(%rsp)
mov    %rsi,0xa8(%rsp)
mov    %edi,%ebx
mov    %edx,0x70(%rsp)
mov    %edx,0xb4(%rsp)
movsd  %xmm1,0x50(%rsp)
movsd  %xmm1,0xe8(%rsp)
movsd  %xmm2,0xe0(%rsp)
mov    %ecx,0xb0(%rsp)
lea    (%rbx,%rbx,4),%eax
mov    %eax,0x8c(%rsp)
movslq %eax,%rbp
shl    $0x3,%rbp
mov    %rbp,%rdi
call   1070 <malloc@plt>
mov    %rax,%r13
mov    %rbp,%rdi
call   1070 <malloc@plt>
mov    %rax,(%rsp)
mov    %rbp,0x90(%rsp)
mov    %rbp,%rdi
call   1070 <malloc@plt>
movsd  0x58(%rsp),%xmm2
mov    %rax,0x78(%rsp)
movslq %ebx,%r12
mov    %ebx,%r14d
mov    %rbx,0x30(%rsp)
test   %ebx,%ebx
mov    %r13,0x10(%rsp)
mov    %r14,0x8(%rsp)
mov    %r12,0x60(%rsp)
jle    195b <SampleEwaldU+0x7fb>
mulsd  %xmm2,%xmm2
xorps  %xmm0,%xmm0
cvtsi2sdl 0x30(%rsp),%xmm0
divsd  %xmm0,%xmm2
mov    %r14,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x68(%rsp)
movsd  %xmm2,0x20(%rsp)
je     12f5 <SampleEwaldU+0x195>
and    $0xfffffffe,%r14d
xor    %ebp,%ebp
xorpd  %xmm3,%xmm3
jmp    1290 <SampleEwaldU+0x130>
xchg   %ax,%ax
movapd %xmm1,%xmm0
call   1080 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm2
mov    (%rsp),%rax
movsd  %xmm0,0x8(%r13,%rbp,8)
mulsd  %xmm3,%xmm0
movsd  %xmm0,0x8(%rax,%rbp,8)
mov    %rbx,%rbp
cmp    %rbx,%r14
je     12f7 <SampleEwaldU+0x197>
lea    0x1(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm3,%xmm0
jb     12b0 <SampleEwaldU+0x150>
sqrtsd %xmm0,%xmm0
jmp    12bf <SampleEwaldU+0x15f>
nopw   0x0(%rax,%rax,1)
call   1080 <sqrt@plt>
xorpd  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm2
movsd  %xmm0,0x0(%r13,%rbp,8)
mulsd  %xmm3,%xmm0
lea    0x2(%rbp),%rbx
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
mulsd  %xmm2,%xmm1
ucomisd %xmm3,%xmm1
jb     1260 <SampleEwaldU+0x100>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    1277 <SampleEwaldU+0x117>
xor    %ebx,%ebx
mov    0x8(%rsp),%rbp
test   $0x1,%bpl
mov    0x30(%rsp),%r14
je     1348 <SampleEwaldU+0x1e8>
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm2,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1325 <SampleEwaldU+0x1c5>
sqrtsd %xmm0,%xmm0
jmp    1334 <SampleEwaldU+0x1d4>
call   1080 <sqrt@plt>
xorpd  %xmm1,%xmm1
movsd  0x20(%rsp),%xmm2
mov    (%rsp),%rax
movsd  %xmm0,0x0(%r13,%rbx,8)
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rbx,8)
test   %r14d,%r14d
jle    195b <SampleEwaldU+0x7fb>
cmpq   $0x0,0x68(%rsp)
je     145e <SampleEwaldU+0x2fe>
mov    %ebp,%r15d
and    $0xfffffffe,%r15d
mov    (%rsp),%rax
lea    (%rax,%r12,8),%r13
add    $0x8,%r13
mov    0x10(%rsp),%rax
lea    (%rax,%r12,8),%rbp
add    $0x8,%rbp
xor    %ebx,%ebx
xorpd  %xmm3,%xmm3
movsd  0x1c75(%rip),%xmm4
movsd  0x1c75(%rip),%xmm5
jmp    13e4 <SampleEwaldU+0x284>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm1,%xmm0
call   1080 <sqrt@plt>
movsd  0x1c57(%rip),%xmm5
movsd  0x1c47(%rip),%xmm4
xorpd  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
mulsd  %xmm5,%xmm0
movsd  %xmm0,0x0(%r13,%rbx,8)
mov    %r14,%rbx
cmp    %r14,%r15
je     1461 <SampleEwaldU+0x301>
lea    0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm3,%xmm0
jb     1400 <SampleEwaldU+0x2a0>
sqrtsd %xmm0,%xmm0
jmp    141f <SampleEwaldU+0x2bf>
xchg   %ax,%ax
call   1080 <sqrt@plt>
movsd  0x1bfb(%rip),%xmm5
movsd  0x1beb(%rip),%xmm4
xorpd  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,-0x8(%rbp,%rbx,8)
mulsd  %xmm5,%xmm0
lea    0x2(%rbx),%r14
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
movsd  %xmm0,-0x8(%r13,%rbx,8)
mulsd  %xmm2,%xmm1
ucomisd %xmm3,%xmm1
jb     13a0 <SampleEwaldU+0x240>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    13c3 <SampleEwaldU+0x263>
xor    %r14d,%r14d
testb  $0x1,0x8(%rsp)
mov    0x10(%rsp),%rbp
je     14bf <SampleEwaldU+0x35f>
lea    (%r14,%r12,1),%rbx
add    $0x1,%r14d
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
mulsd  %xmm2,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1491 <SampleEwaldU+0x331>
sqrtsd %xmm0,%xmm0
jmp    149c <SampleEwaldU+0x33c>
call   1080 <sqrt@plt>
movsd  0x20(%rsp),%xmm2
movsd  0x1b5c(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rbx,8)
mulsd  0x1b52(%rip),%xmm0
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
cmpl   $0x0,0x30(%rsp)
mov    0x8(%rsp),%rax
jle    195b <SampleEwaldU+0x7fb>
cmpq   $0x0,0x68(%rsp)
je     15de <SampleEwaldU+0x47e>
mov    %eax,%r12d
and    $0xfffffffe,%r12d
mov    0x60(%rsp),%rax
shl    $0x4,%rax
mov    (%rsp),%rcx
lea    (%rcx,%rax,1),%r13
add    $0x8,%r13
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,1),%rbx
add    $0x8,%rbx
xor    %ebp,%ebp
xorpd  %xmm3,%xmm3
movsd  0x1afe(%rip),%xmm4
movsd  0x1afe(%rip),%xmm5
jmp    1563 <SampleEwaldU+0x403>
nopl   0x0(%rax)
movapd %xmm1,%xmm0
call   1080 <sqrt@plt>
movsd  0x1ae7(%rip),%xmm5
movsd  0x1ad7(%rip),%xmm4
xorpd  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
mulsd  %xmm5,%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
mov    %r14,%rbp
cmp    %r14,%r12
je     15e1 <SampleEwaldU+0x481>
lea    0x1(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm3,%xmm0
jb     1580 <SampleEwaldU+0x420>
sqrtsd %xmm0,%xmm0
jmp    159f <SampleEwaldU+0x43f>
nopl   (%rax)
call   1080 <sqrt@plt>
movsd  0x1a8b(%rip),%xmm5
movsd  0x1a7b(%rip),%xmm4
xorpd  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,-0x8(%rbx,%rbp,8)
mulsd  %xmm5,%xmm0
lea    0x2(%rbp),%r14
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
movsd  %xmm0,-0x8(%r13,%rbp,8)
mulsd  %xmm2,%xmm1
ucomisd %xmm3,%xmm1
jb     1520 <SampleEwaldU+0x3c0>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    1543 <SampleEwaldU+0x3e3>
xor    %r14d,%r14d
mov    0x8(%rsp),%rax
test   $0x1,%al
mov    0x10(%rsp),%r13
mov    0x60(%rsp),%r12
je     164f <SampleEwaldU+0x4ef>
lea    (%r12,%r12,1),%rbp
add    %r14,%rbp
add    $0x1,%r14d
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
mulsd  %xmm2,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     161b <SampleEwaldU+0x4bb>
sqrtsd %xmm0,%xmm0
jmp    1626 <SampleEwaldU+0x4c6>
call   1080 <sqrt@plt>
movsd  0x20(%rsp),%xmm2
movsd  0x19e2(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rbp,8)
mulsd  0x19d7(%rip),%xmm0
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
mov    0x8(%rsp),%rax
cmpl   $0x0,0x30(%rsp)
jle    195b <SampleEwaldU+0x7fb>
lea    (%r12,%r12,2),%rcx
cmpq   $0x0,0x68(%rsp)
mov    %rcx,0x48(%rsp)
je     176e <SampleEwaldU+0x60e>
mov    %eax,%r15d
and    $0xfffffffe,%r15d
mov    (%rsp),%rax
lea    (%rax,%rcx,8),%rbx
add    $0x8,%rbx
lea    0x8(,%rcx,8),%r14
add    %r13,%r14
xor    %ebp,%ebp
xorpd  %xmm3,%xmm3
movsd  0x1985(%rip),%xmm4
movsd  0x1985(%rip),%xmm5
jmp    16f2 <SampleEwaldU+0x592>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm1,%xmm0
call   1080 <sqrt@plt>
movsd  0x1967(%rip),%xmm5
movsd  0x1957(%rip),%xmm4
xorpd  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,(%r14,%rbp,8)
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
mov    %r13,%rbp
cmp    %r13,%r15
je     1771 <SampleEwaldU+0x611>
lea    0x1(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm3,%xmm0
jb     1710 <SampleEwaldU+0x5b0>
sqrtsd %xmm0,%xmm0
jmp    172f <SampleEwaldU+0x5cf>
nopl   0x0(%rax)
call   1080 <sqrt@plt>
movsd  0x190b(%rip),%xmm5
movsd  0x18fb(%rip),%xmm4
xorpd  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,-0x8(%r14,%rbp,8)
mulsd  %xmm5,%xmm0
lea    0x2(%rbp),%r13
xorps  %xmm1,%xmm1
cvtsi2sd %r13d,%xmm1
movsd  %xmm0,-0x8(%rbx,%rbp,8)
mulsd  %xmm2,%xmm1
ucomisd %xmm3,%xmm1
jb     16b0 <SampleEwaldU+0x550>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    16d3 <SampleEwaldU+0x573>
xor    %r13d,%r13d
mov    0x8(%rsp),%rbx
test   $0x1,%bl
mov    0x30(%rsp),%r14
je     17da <SampleEwaldU+0x67a>
mov    0x48(%rsp),%rbp
add    %r13,%rbp
add    $0x1,%r13d
xorps  %xmm0,%xmm0
cvtsi2sd %r13d,%xmm0
mulsd  %xmm2,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     17a8 <SampleEwaldU+0x648>
sqrtsd %xmm0,%xmm0
jmp    17b3 <SampleEwaldU+0x653>
call   1080 <sqrt@plt>
movsd  0x20(%rsp),%xmm2
mov    0x10(%rsp),%rax
movsd  0x1860(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rbp,8)
mulsd  0x1857(%rip),%xmm0
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
test   %r14d,%r14d
mov    0x10(%rsp),%rcx
jle    195b <SampleEwaldU+0x7fb>
cmpq   $0x0,0x68(%rsp)
je     18ee <SampleEwaldU+0x78e>
and    $0xfffffffe,%ebx
mov    %r12,%rax
mov    %rbx,%r12
shl    $0x5,%rax
mov    (%rsp),%rdx
lea    (%rdx,%rax,1),%rbx
add    $0x8,%rbx
lea    (%rcx,%rax,1),%r13
add    $0x8,%r13
xor    %ebp,%ebp
xorpd  %xmm3,%xmm3
movsd  0x180d(%rip),%xmm4
movsd  0x180d(%rip),%xmm5
jmp    1873 <SampleEwaldU+0x713>
nopl   (%rax)
movapd %xmm1,%xmm0
call   1080 <sqrt@plt>
movsd  0x17f7(%rip),%xmm5
movsd  0x17e7(%rip),%xmm4
xorpd  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,0x0(%r13,%rbp,8)
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
mov    %r14,%rbp
cmp    %r14,%r12
je     18f1 <SampleEwaldU+0x791>
lea    0x1(%rbp),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm3,%xmm0
jb     1890 <SampleEwaldU+0x730>
sqrtsd %xmm0,%xmm0
jmp    18af <SampleEwaldU+0x74f>
nopl   (%rax)
call   1080 <sqrt@plt>
movsd  0x179b(%rip),%xmm5
movsd  0x178b(%rip),%xmm4
xorpd  %xmm3,%xmm3
movsd  0x20(%rsp),%xmm2
movapd %xmm0,%xmm1
mulsd  %xmm4,%xmm1
movsd  %xmm1,-0x8(%r13,%rbp,8)
mulsd  %xmm5,%xmm0
lea    0x2(%rbp),%r14
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
movsd  %xmm0,-0x8(%rbx,%rbp,8)
mulsd  %xmm2,%xmm1
ucomisd %xmm3,%xmm1
jb     1830 <SampleEwaldU+0x6d0>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    1853 <SampleEwaldU+0x6f3>
xor    %r14d,%r14d
testb  $0x1,0x8(%rsp)
mov    0x10(%rsp),%rbx
mov    0x60(%rsp),%r12
je     195b <SampleEwaldU+0x7fb>
lea    0x0(,%r12,4),%rbp
add    %r14,%rbp
add    $0x1,%r14d
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
mulsd  %xmm0,%xmm2
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jb     1930 <SampleEwaldU+0x7d0>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    1939 <SampleEwaldU+0x7d9>
movapd %xmm2,%xmm0
call   1080 <sqrt@plt>
mov    (%rsp),%rax
movsd  0x16eb(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rbp,8)
mulsd  0x16e2(%rip),%xmm0
movsd  %xmm0,(%rax,%rbp,8)
mov    0x70(%rsp),%ebx
movslq %ebx,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,0x48(%rsp)
test   %ebx,%ebx
jle    1a06 <SampleEwaldU+0x8a6>
movsd  0x80(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  0x50(%rsp),%xmm2
mulsd  %xmm2,%xmm2
mulsd  %xmm0,%xmm2
mulsd  0x16a5(%rip),%xmm2
mov    %ebx,%r8d
cmp    $0x1,%ebx
jne    1e72 <SampleEwaldU+0xd12>
xor    %eax,%eax
xor    %edx,%edx
mov    %rdx,0x18(%rsp)
mov    0x30(%rsp),%r14
mov    0x78(%rsp),%rdi
test   $0x1,%r8b
je     1a17 <SampleEwaldU+0x8b7>
mov    0x130(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    0x138(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm0,%xmm2
jbe    1a17 <SampleEwaldU+0x8b7>
mov    0x18(%rsp),%rdx
movslq %edx,%rdx
mov    0x48(%rsp),%rcx
mov    %eax,(%rcx,%rdx,4)
add    $0x1,%edx
mov    %rdx,0x18(%rsp)
jmp    1a17 <SampleEwaldU+0x8b7>
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    0x30(%rsp),%r14
mov    0x78(%rsp),%rdi
mov    0x158(%rsp),%r12
mov    0x150(%rsp),%r15
mov    0x148(%rsp),%r13
shl    $0x2,%ebx
movslq %ebx,%rax
mov    %rax,0xd8(%rsp)
xor    %esi,%esi
mov    0x90(%rsp),%rdx
call   1050 <memset@plt>
cmpq   $0x0,0xa8(%rsp)
jle    1e05 <SampleEwaldU+0xca5>
mov    0x8c(%rsp),%eax
cmp    $0x2,%eax
mov    $0x1,%ecx
cmovge %eax,%ecx
mov    %rcx,0x70(%rsp)
mov    0x18(%rsp),%eax
mov    %rax,0xd0(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x90(%rsp)
xor    %eax,%eax
jmp    1aaa <SampleEwaldU+0x94a>
nop
mov    0xc8(%rsp),%rax
add    $0x1,%rax
cmp    0xa8(%rsp),%rax
je     1e12 <SampleEwaldU+0xcb2>
mov    %rax,0xc8(%rsp)
lea    0xb4(%rsp),%rdi
mov    0xb8(%rsp),%rsi
mov    0xc0(%rsp),%rdx
mov    0x130(%rsp),%rcx
mov    0x138(%rsp),%r8
lea    0xb0(%rsp),%r9
xor    %eax,%eax
lea    0xf0(%rsp),%rbp
push   %rbp
lea    0xe0(%rsp),%rbp
push   %rbp
lea    0xf8(%rsp),%rbp
push   %rbp
lea    0xf8(%rsp),%rbp
push   %rbp
call   1040 <metropolis_host_@plt>
add    $0x20,%rsp
cmpl   $0x0,0x18(%rsp)
jle    1a90 <SampleEwaldU+0x930>
xor    %ecx,%ecx
jmp    1b37 <SampleEwaldU+0x9d7>
mov    0x68(%rsp),%rcx
add    $0x1,%rcx
cmp    0xd0(%rsp),%rcx
je     1a90 <SampleEwaldU+0x930>
mov    0x48(%rsp),%rax
mov    %rcx,0x68(%rsp)
movslq (%rax,%rcx,4),%rax
mov    0xc0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm2
mov    0xb8(%rsp),%rcx
movhpd (%rcx,%rax,8),%xmm2
mov    0x138(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mov    0x130(%rsp),%rcx
movhpd (%rcx,%rax,8),%xmm0
subpd  %xmm0,%xmm2
xor    %eax,%eax
jmp    1bf2 <SampleEwaldU+0xa92>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x80(%rsp),%xmm0
movapd 0x90(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0x90(%rsp)
movapd 0x20(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
mulpd  0x14cc(%rip),%xmm0
movapd 0x30(%rsp),%xmm2
mulpd  0x14ce(%rip),%xmm2
addpd  %xmm0,%xmm2
mov    0x50(%rsp),%eax
add    $0x1,%eax
cmp    $0x6,%eax
mov    %r12,%r14
mov    %rbp,%r12
mov    %r13,%r15
mov    %rbx,%r13
je     1cc0 <SampleEwaldU+0xb60>
mov    %eax,0x50(%rsp)
movapd %xmm2,%xmm0
unpckhpd %xmm2,%xmm0
movapd %xmm0,0x30(%rsp)
movapd %xmm2,0x20(%rsp)
movapd %xmm2,%xmm1
mov    %r14d,%edi
movsd  0x58(%rsp),%xmm2
mov    %r13,%rsi
mov    %r15,%rdx
mov    %r12,%rcx
mov    $0x3,%al
call   1060 <approxU@plt>
mov    %eax,0x80(%rsp)
test   %r14d,%r14d
mov    0x10(%rsp),%rax
mov    %r12,%rbp
mov    (%rsp),%rcx
mov    %r14,%r12
mov    %r13,%rbx
mov    %r15,%r13
jle    1b90 <SampleEwaldU+0xa30>
xor    %r14d,%r14d
nop
movsd  (%rax,%r14,8),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  (%rcx,%r14,8),%xmm1
addsd  0x20(%rsp),%xmm1
mov    %r12d,%edi
movsd  0x58(%rsp),%xmm2
mov    %rbx,%rsi
mov    %r13,%rdx
mov    %rcx,%r15
mov    %rbp,%rcx
mov    $0x3,%al
call   1060 <approxU@plt>
mov    0x70(%rsp),%rsi
mov    0x78(%rsp),%rdx
mov    %r15,%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x10(%rsp),%rax
addsd  (%rdx,%r14,8),%xmm0
movsd  %xmm0,(%rdx,%r14,8)
add    $0x1,%r14
cmp    %r14,%rsi
jne    1c50 <SampleEwaldU+0xaf0>
jmp    1b90 <SampleEwaldU+0xa30>
nopw   0x0(%rax,%rax,1)
movapd %xmm2,%xmm0
xorpd  0x13e4(%rip),%xmm0
shufpd $0x1,%xmm0,%xmm2
xor    %eax,%eax
jmp    1d3c <SampleEwaldU+0xbdc>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
cvtsi2sdl 0x80(%rsp),%xmm0
movapd 0x90(%rsp),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0x90(%rsp)
movapd 0x30(%rsp),%xmm0
mulpd  0x13b0(%rip),%xmm0
movapd 0x20(%rsp),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  0x13ae(%rip),%xmm2
addpd  %xmm0,%xmm2
mov    0x50(%rsp),%eax
add    $0x1,%eax
cmp    $0x6,%eax
mov    %rcx,%r12
mov    %rbp,%r13
je     1b20 <SampleEwaldU+0x9c0>
movapd %xmm2,0x20(%rsp)
mov    %eax,0x50(%rsp)
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movapd %xmm2,%xmm0
movapd %xmm1,0x30(%rsp)
mov    %r14d,%edi
movsd  0x58(%rsp),%xmm2
mov    %r13,%rsi
mov    %r15,%rdx
mov    %r12,%rcx
mov    $0x3,%al
call   1060 <approxU@plt>
mov    %eax,0x80(%rsp)
test   %r14d,%r14d
mov    0x10(%rsp),%rax
mov    (%rsp),%rsi
mov    %r13,%rbp
mov    %r12,%rcx
mov    0x70(%rsp),%r12
jle    1ce0 <SampleEwaldU+0xb80>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rbx,8),%xmm0
addsd  0x20(%rsp),%xmm0
movsd  (%rsi,%rbx,8),%xmm1
addsd  0x30(%rsp),%xmm1
mov    %r14d,%edi
movsd  0x58(%rsp),%xmm2
mov    %rbp,%rsi
mov    %r15,%r13
mov    %r15,%rdx
mov    $0x3,%al
mov    %rcx,%r15
call   1060 <approxU@plt>
mov    0x78(%rsp),%rdi
mov    (%rsp),%rsi
mov    %r15,%rcx
mov    %r13,%r15
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x10(%rsp),%rax
addsd  (%rdi,%rbx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1da0 <SampleEwaldU+0xc40>
jmp    1ce0 <SampleEwaldU+0xb80>
xorpd  %xmm0,%xmm0
movapd %xmm0,0x90(%rsp)
test   %r14d,%r14d
mov    0x10(%rsp),%rdi
mov    0x60(%rsp),%r9
mov    0x8(%rsp),%rbp
mov    0x78(%rsp),%rbx
jle    212f <SampleEwaldU+0xfcf>
movslq 0x18(%rsp),%rax
mov    0xa8(%rsp),%rcx
imul   %rax,%rcx
shl    $0x2,%rcx
lea    (%rcx,%rcx,2),%rax
xorps  %xmm0,%xmm0
cvtsi2sd %rax,%xmm0
mov    0x8c(%rsp),%ecx
cmp    $0x2,%ecx
mov    $0x1,%eax
cmovge %ecx,%eax
cmp    $0x2,%eax
jae    1f30 <SampleEwaldU+0xdd0>
xor    %ecx,%ecx
jmp    1fb0 <SampleEwaldU+0xe50>
mov    %r8d,%edx
and    $0xfffffffe,%edx
xor    %eax,%eax
xor    %esi,%esi
mov    %rsi,0x18(%rsp)
mov    0x30(%rsp),%r14
mov    0x78(%rsp),%rdi
jmp    1e9d <SampleEwaldU+0xd3d>
nopl   (%rax)
add    $0x2,%rax
cmp    %rax,%rdx
je     19ba <SampleEwaldU+0x85a>
mov    0x130(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
mov    0x138(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm0,%xmm2
jbe    1ee1 <SampleEwaldU+0xd81>
mov    0x18(%rsp),%rbp
movslq %ebp,%rbp
mov    0x48(%rsp),%rsi
mov    %eax,(%rsi,%rbp,4)
add    $0x1,%ebp
mov    %rbp,0x18(%rsp)
mov    0x130(%rsp),%rsi
movsd  0x8(%rsi,%rax,8),%xmm0
mov    0x138(%rsp),%rsi
movsd  0x8(%rsi,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm0,%xmm2
jbe    1e90 <SampleEwaldU+0xd30>
mov    0x18(%rsp),%rcx
movslq %ecx,%rcx
lea    0x1(%rax),%esi
mov    0x48(%rsp),%rbp
mov    %esi,0x0(%rbp,%rcx,4)
add    $0x1,%ecx
mov    %rcx,0x18(%rsp)
jmp    1e90 <SampleEwaldU+0xd30>
mov    %eax,%ecx
and    $0x7ffffffe,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rcx),%rsi
mov    %rsi,%rbp
shr    %rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     23ac <SampleEwaldU+0x124c>
mov    %rbp,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %esi,%esi
movupd (%rbx,%rsi,8),%xmm2
movupd 0x10(%rbx,%rsi,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rbx,%rsi,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rbx,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdx
jne    1f60 <SampleEwaldU+0xe00>
test   $0x1,%bpl
je     1f9c <SampleEwaldU+0xe3c>
movupd (%rbx,%rsi,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rbx,%rsi,8)
cmp    %rax,%rcx
mov    0x8(%rsp),%rbp
je     1fc7 <SampleEwaldU+0xe67>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1fb0 <SampleEwaldU+0xe50>
test   %r14d,%r14d
movapd 0x90(%rsp),%xmm3
jle    212f <SampleEwaldU+0xfcf>
mov    0x140(%rsp),%rax
divsd  %xmm0,%xmm3
cmp    $0x1,%r14d
jne    2161 <SampleEwaldU+0x1001>
xor    %ecx,%ecx
lea    0x0(,%r9,8),%rdx
movsd  0x1046(%rip),%xmm13
xorpd  %xmm8,%xmm8
movsd  0x1040(%rip),%xmm9
movsd  0x103f(%rip),%xmm14
movsd  0x103f(%rip),%xmm4
movsd  0x103e(%rip),%xmm10
movsd  0x103d(%rip),%xmm11
movsd  0x103c(%rip),%xmm12
movsd  0x103c(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rbx,%rcx,8),%rsi
movsd  (%rbx,%rcx,8),%xmm2
mulsd  %xmm13,%xmm2
addsd  %xmm8,%xmm2
movsd  (%rsi,%r9,8),%xmm6
add    %rdx,%rsi
movapd %xmm2,%xmm5
addsd  %xmm6,%xmm5
movapd %xmm6,%xmm7
mulsd  %xmm9,%xmm7
addsd  %xmm2,%xmm7
mulsd  %xmm14,%xmm6
addsd  %xmm2,%xmm6
movsd  (%rsi,%r9,8),%xmm2
add    %rdx,%rsi
addsd  %xmm2,%xmm5
movapd %xmm2,%xmm0
mulsd  %xmm14,%xmm0
addsd  %xmm7,%xmm0
mulsd  %xmm4,%xmm2
addsd  %xmm6,%xmm2
movsd  (%rsi,%r9,8),%xmm6
add    %rdx,%rsi
addsd  %xmm6,%xmm5
movapd %xmm6,%xmm7
mulsd  %xmm10,%xmm7
addsd  %xmm0,%xmm7
mulsd  %xmm11,%xmm6
addsd  %xmm2,%xmm6
movsd  (%rsi,%r9,8),%xmm0
mulsd  %xmm13,%xmm0
addsd  %xmm0,%xmm5
movapd %xmm0,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm7,%xmm2
mulsd  %xmm12,%xmm0
addsd  %xmm6,%xmm0
movsd  %xmm3,(%rax)
mulsd  %xmm1,%xmm5
subsd  %xmm3,%xmm5
movsd  %xmm5,0x0(%r13,%rcx,8)
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm2
movsd  %xmm2,(%r15,%rcx,8)
mulsd  %xmm1,%xmm0
addsd  %xmm0,%xmm0
movsd  %xmm0,(%r12,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    2050 <SampleEwaldU+0xef0>
call   1030 <free@plt>
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x0(,%rbp,8),%r8
add    %r13,%r8
cmp    %rax,%r8
seta   0x20(%rsp)
lea    0x8(%rax),%rsi
cmp    %r13,%rsi
mov    %r13,%rcx
seta   0x58(%rsp)
mov    %rbp,%rdi
lea    (%r15,%rbp,8),%rbp
cmp    %rax,%rbp
seta   %r9b
cmp    %r15,%rsi
seta   0x30(%rsp)
lea    (%r12,%rdi,8),%rdi
cmp    %rax,%rdi
mov    %r15,%rdx
mov    %r12,%r15
seta   %r12b
cmp    %r15,%rsi
seta   0x70(%rsp)
cmp    %r13,%rbp
seta   %sil
cmp    %rdx,%r8
seta   0x90(%rsp)
cmp    %r13,%rdi
seta   %r14b
cmp    %r15,%r8
seta   0x50(%rsp)
mov    %rdx,%r10
cmp    %rdx,%rdi
seta   %r8b
mov    %r15,%r11
cmp    %r15,%rbp
seta   %bpl
xor    %ecx,%ecx
mov    0x58(%rsp),%dl
test   %dl,0x20(%rsp)
jne    23d4 <SampleEwaldU+0x1274>
and    0x30(%rsp),%r9b
mov    0x10(%rsp),%rdi
mov    0x60(%rsp),%r9
mov    %r10,%r15
jne    23c7 <SampleEwaldU+0x1267>
and    0x70(%rsp),%r12b
jne    23c7 <SampleEwaldU+0x1267>
and    0x90(%rsp),%sil
mov    %r11,%r12
jne    23bd <SampleEwaldU+0x125d>
and    0x50(%rsp),%r14b
jne    23bd <SampleEwaldU+0x125d>
and    %bpl,%r8b
mov    0x8(%rsp),%rbp
jne    1ff1 <SampleEwaldU+0xe91>
mov    %ebp,%ecx
and    $0xfffffffe,%ecx
movapd %xmm3,%xmm15
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
lea    0x0(,%r9,8),%rdx
xor    %esi,%esi
movapd 0xe77(%rip),%xmm13
xorpd  %xmm8,%xmm8
movapd 0xe79(%rip),%xmm9
movapd 0xe80(%rip),%xmm14
movapd 0xe88(%rip),%xmm5
movapd 0xe8f(%rip),%xmm10
movapd 0xe96(%rip),%xmm11
movapd 0xe9d(%rip),%xmm12
movapd 0xea5(%rip),%xmm3
nopl   0x0(%rax,%rax,1)
lea    (%rbx,%rsi,8),%rbp
movupd (%rbx,%rsi,8),%xmm6
mulpd  %xmm13,%xmm6
addpd  %xmm8,%xmm6
movupd 0x0(%rbp,%r9,8),%xmm2
add    %rdx,%rbp
movapd %xmm6,%xmm7
addpd  %xmm2,%xmm7
movapd %xmm2,%xmm1
mulpd  %xmm9,%xmm1
addpd  %xmm6,%xmm1
mulpd  %xmm14,%xmm2
addpd  %xmm6,%xmm2
movupd 0x0(%rbp,%r9,8),%xmm6
add    %rdx,%rbp
addpd  %xmm6,%xmm7
movapd %xmm6,%xmm4
mulpd  %xmm14,%xmm4
addpd  %xmm1,%xmm4
mulpd  %xmm5,%xmm6
addpd  %xmm2,%xmm6
movupd 0x0(%rbp,%r9,8),%xmm1
add    %rdx,%rbp
addpd  %xmm1,%xmm7
movapd %xmm1,%xmm2
mulpd  %xmm10,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm11,%xmm1
addpd  %xmm6,%xmm1
movupd 0x0(%rbp,%r9,8),%xmm4
mulpd  %xmm13,%xmm4
addpd  %xmm4,%xmm7
movapd %xmm4,%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm2,%xmm6
mulpd  %xmm12,%xmm4
addpd  %xmm1,%xmm4
mulpd  %xmm3,%xmm7
subpd  %xmm0,%xmm7
movupd %xmm7,0x0(%r13,%rsi,8)
mulpd  %xmm3,%xmm6
addpd  %xmm6,%xmm6
movupd %xmm6,(%r15,%rsi,8)
mulpd  %xmm3,%xmm4
addpd  %xmm4,%xmm4
movupd %xmm4,(%r12,%rsi,8)
add    $0x2,%rsi
cmp    %rsi,%rcx
jne    22b0 <SampleEwaldU+0x1150>
movapd %xmm15,%xmm3
movsd  %xmm15,(%rax)
mov    0x8(%rsp),%rbp
cmp    %rbp,%rcx
jne    1ff1 <SampleEwaldU+0xe91>
jmp    212f <SampleEwaldU+0xfcf>
xor    %esi,%esi
test   $0x1,%bpl
jne    1f8e <SampleEwaldU+0xe2e>
jmp    1f9c <SampleEwaldU+0xe3c>
mov    0x8(%rsp),%rbp
jmp    1ff1 <SampleEwaldU+0xe91>
mov    0x8(%rsp),%rbp
mov    %r11,%r12
jmp    1ff1 <SampleEwaldU+0xe91>
mov    0x10(%rsp),%rdi
mov    0x60(%rsp),%r9
mov    0x8(%rsp),%rbp
mov    %r11,%r12
mov    %r10,%r15
jmp    1ff1 <SampleEwaldU+0xe91>

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

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