void evolve2D(double *Pops, double *OutsidePop, double *AF, int npop, int n1,
              int n2, int nSNP, double m1, double m2, double minf, int Ne,
              int Loss) {
  int l, p1, p2, p;
  double af, r_af;
  for (l = 0; l < nSNP; l++) {
    for (p2 = 0; p2 < n2; p2++) {
      if (p2 == 0) {
        for (p1 = 0; p1 < n1; p1++) {
          if (p1 == 0) {
            AF[0] = (1 - m1 - m2 - minf) * Pops[l] + m1 * (Pops[(nSNP + l)]) +
                    m2 * (Pops[n1 * nSNP + l]) + minf * OutsidePop[l];
          } else if (p1 == n1 - 1) {
            AF[p1 + p2 * n1] =
                (1 - m1 - m2 - minf) * Pops[(p1 + p2 * n1) * nSNP + l] +
                m1 * (Pops[(p1 + p2 * n1 - 1) * nSNP + l]) +
                m2 * (Pops[(p1 + (p2 + 1) * n1) * nSNP + l]) +
                minf * OutsidePop[l];
          } else {
            AF[p1 + p2 * n1] =
                (1 - m1 - m2 - minf) * Pops[(p1 + p2 * n1) * nSNP + l] +
                .5 * m1 *
                    (Pops[(p1 + p2 * n1 - 1) * nSNP + l] +
                     Pops[(p1 + p2 * n1 + 1) * nSNP + l]) +
                m2 * (Pops[(p1 + (p2 + 1) * n1) * nSNP + l]) +
                minf * OutsidePop[l];
          }
        }
      } else if (p2 == n2 - 1) {
        for (p1 = 0; p1 < n1; p1++) {
          if (p1 == 0) {
            AF[p1 + p2 * n1] =
                (1 - m1 - m2 - minf) * Pops[(p1 + p2 * n1) * nSNP + l] +
                m1 * (Pops[(p1 + p2 * n1 + 1) * nSNP + l]) +
                m2 * (Pops[(p1 + (p2 - 1) * n1) * nSNP + l]) +
                minf * OutsidePop[l];
          } else if (p1 == n1 - 1) {
            AF[p1 + p2 * n1] =
                (1 - m1 - m2 - minf) * Pops[(p1 + p2 * n1) * nSNP + l] +
                m1 * (Pops[(p1 + p2 * n1 - 1) * nSNP + l]) +
                m2 * (Pops[(p1 + (p2 - 1) * n1) * nSNP + l]) +
                minf * OutsidePop[l];
          } else {
            AF[p1 + p2 * n1] =
                (1 - m1 - m2 - minf) * Pops[(p1 + p2 * n1) * nSNP + l] +
                .5 * m1 *
                    (Pops[(p1 + p2 * n1 - 1) * nSNP + l] +
                     Pops[(p1 + p2 * n1 + 1) * nSNP + l]) +
                m2 * (Pops[(p1 + (p2 - 1) * n1) * nSNP + l]) +
                minf * OutsidePop[l];
          }
        }
      } else {
        for (p1 = 0; p1 < n1; p1++) {
          if (p1 == 0) {
            AF[p1 + p2 * n1] =
                (1 - m1 - m2 - minf) * Pops[(p1 + p2 * n1) * nSNP + l] +
                m1 * (Pops[(p1 + p2 * n1 + 1) * nSNP + l]) +
                .5 * m2 *
                    (Pops[(p1 + (p2 - 1) * n1) * nSNP + l] +
                     Pops[(p1 + (p2 + 1) * n1) * nSNP + l]) +
                minf * OutsidePop[l];
          } else if (p1 == n1 - 1) {
            AF[p1 + p2 * n1] =
                (1 - m1 - m2 - minf) * Pops[(p1 + p2 * n1) * nSNP + l] +
                m1 * (Pops[(p1 + p2 * n1 - 1) * nSNP + l]) +
                .5 * m2 *
                    (Pops[(p1 + (p2 - 1) * n1) * nSNP + l] +
                     Pops[(p1 + (p2 + 1) * n1) * nSNP + l]) +
                minf * OutsidePop[l];
          } else {
            AF[p1 + p2 * n1] =
                (1 - m1 - m2 - minf) * Pops[(p1 + p2 * n1) * nSNP + l] +
                .5 * m1 *
                    (Pops[(p1 + p2 * n1 - 1) * nSNP + l] +
                     Pops[(p1 + p2 * n1 + 1) * nSNP + l]) +
                .5 * m2 *
                    (Pops[(p1 + (p2 - 1) * n1) * nSNP + l] +
                     Pops[(p1 + (p2 + 1) * n1) * nSNP + l]) +
                minf * OutsidePop[l];
          }
        }
      }
    }
    for (p = 0; p < npop; p++) {
      if (!Loss || ((AF[p] > .0) && (AF[p] < 1.0))) {
        af = AF[p];
        r_af = (double)rand_normal(af, af * (1 - af) / (2 * Ne));
        if (r_af > 1)
          r_af = 1;
        if (r_af < 0)
          r_af = 0;
        Pops[p * nSNP + l] = r_af;
      }
    }
  }
}


x86 assembly (clang, -O0):
<evolve2D>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
movsd  %xmm2,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1b77 <evolve2D+0xa67>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1a5f <evolve2D+0x94f>
cmpl   $0x0,-0x4c(%rbp)
jne    140e <evolve2D+0x2fe>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1409 <evolve2D+0x2f9>
cmpl   $0x0,-0x48(%rbp)
jne    1221 <evolve2D+0x111>
movsd  0xe64(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    13f6 <evolve2D+0x2e6>
mov    -0x48(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    12fd <evolve2D+0x1ed>
movsd  0xdc6(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13f1 <evolve2D+0x2e1>
movsd  0xcfb(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0xccd(%rip),%xmm1
mulsd  -0x30(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    13f6 <evolve2D+0x2e6>
jmp    13fb <evolve2D+0x2eb>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    117e <evolve2D+0x6e>
jmp    1a4c <evolve2D+0x93c>
mov    -0x4c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    16f4 <evolve2D+0x5e4>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    16ef <evolve2D+0x5df>
cmpl   $0x0,-0x48(%rbp)
jne    1507 <evolve2D+0x3f7>
movsd  0xbbc(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16dc <evolve2D+0x5cc>
mov    -0x48(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    15e3 <evolve2D+0x4d3>
movsd  0xae0(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16d7 <evolve2D+0x5c7>
movsd  0xa15(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x9e7(%rip),%xmm1
mulsd  -0x30(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16dc <evolve2D+0x5cc>
jmp    16e1 <evolve2D+0x5d1>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1426 <evolve2D+0x316>
jmp    1a47 <evolve2D+0x937>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1a42 <evolve2D+0x932>
cmpl   $0x0,-0x48(%rbp)
jne    1806 <evolve2D+0x6f6>
movsd  0x8e7(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x88a(%rip),%xmm1
mulsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a2f <evolve2D+0x91f>
mov    -0x48(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    190c <evolve2D+0x7fc>
movsd  0x7e1(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x784(%rip),%xmm1
mulsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a2a <evolve2D+0x91a>
movsd  0x6ec(%rip),%xmm0
subsd  -0x30(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x6be(%rip),%xmm1
mulsd  -0x30(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
sub    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
add    $0x1,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x661(%rip),%xmm1
mulsd  -0x38(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
sub    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x20(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1a2f <evolve2D+0x91f>
jmp    1a34 <evolve2D+0x924>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    16fb <evolve2D+0x5eb>
jmp    1a47 <evolve2D+0x937>
jmp    1a4c <evolve2D+0x93c>
jmp    1a51 <evolve2D+0x941>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1161 <evolve2D+0x51>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1b64 <evolve2D+0xa54>
cmpl   $0x0,0x20(%rbp)
je     1ab1 <evolve2D+0x9a1>
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b51 <evolve2D+0xa41>
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  0x55a(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1b51 <evolve2D+0xa41>
mov    -0x18(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  0x52b(%rip),%xmm2
subsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm1
mov    0x18(%rbp),%eax
shl    $0x1,%eax
cvtsi2sd %eax,%xmm2
divsd  %xmm2,%xmm1
mov    $0x2,%al
call   1030 <rand_normal@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0x4f7(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1b20 <evolve2D+0xa10>
movsd  0x4e5(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    1b36 <evolve2D+0xa26>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   0x10(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b56 <evolve2D+0xa46>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1a66 <evolve2D+0x956>
jmp    1b69 <evolve2D+0xa59>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    114e <evolve2D+0x3e>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<evolve2D>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e8,%rsp
mov    %r9,0x38(%rsp)
mov    %r8,(%rsp)
mov    %ecx,0xc(%rsp)
mov    0x220(%rsp),%eax
test   %eax,%eax
jle    1a8e <evolve2D+0x97e>
movapd %xmm1,%xmm4
movapd %xmm0,%xmm5
mov    %rdi,%rbp
mov    %eax,%edi
mov    0x228(%rsp),%eax
mov    0x38(%rsp),%r9
lea    -0x1(%r9),%r10d
mov    (%rsp),%rbx
lea    -0x1(%rbx),%r15d
movsd  0xe96(%rip),%xmm6
subsd  %xmm0,%xmm6
subsd  %xmm1,%xmm6
subsd  %xmm2,%xmm6
movsd  0xe89(%rip),%xmm8
movapd %xmm0,%xmm7
mulsd  %xmm8,%xmm7
mulsd  %xmm1,%xmm8
add    %eax,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xf0(%rsp)
mov    %edi,%ecx
imul   %ebx,%edi
mov    %rdx,%r8
movslq %ebx,%r14
mov    %edi,0x34(%rsp)
movslq %edi,%r11
mov    %r10,%r13
imul   %r14,%r13
lea    -0x1(%r10),%rax
mov    %rax,%rbx
imul   %r14,%rbx
mov    %r11,%rdi
mov    %r11,0xa8(%rsp)
imul   %r11d,%eax
cltq
mov    %rax,0xa0(%rsp)
lea    0x1(%r13),%rax
imul   %rcx,%rax
mov    %rax,0x58(%rsp)
mov    %r13,%rax
imul   %rcx,%rax
mov    %rax,0x98(%rsp)
lea    (%r15,%r13,1),%rdi
mov    %rdi,%rax
mov    %rdi,0x180(%rsp)
imul   %rcx,%rdi
mov    %rdi,0x90(%rsp)
lea    (%r15,%r13,1),%rax
add    $0xffffffffffffffff,%rax
imul   %rcx,%rax
mov    %rax,0x88(%rsp)
lea    (%rbx,%r15,1),%rax
imul   %rcx,%rax
mov    %rax,0x80(%rsp)
mov    %r15,%rax
imul   %rcx,%rax
mov    %rax,0x78(%rsp)
lea    -0x1(%r15),%rax
imul   %rcx,%rax
mov    %rax,0x70(%rsp)
lea    (%r15,%r14,1),%rax
imul   %rcx,%rax
mov    %rax,0x68(%rsp)
lea    0x1(%r14),%r11
imul   %rcx,%r11
mov    %r14,%rdi
imul   %rcx,%rdi
mov    $0x1,%eax
sub    %r14,%rax
imul   %rcx,%rax
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
mov    %rax,0x170(%rsp)
mov    %rcx,%rax
shl    $0x4,%rax
add    $0x1,%rbx
imul   %rcx,%rbx
mov    %rbx,0x188(%rsp)
lea    0x0(,%rdi,8),%rbx
mov    %rbx,0x140(%rsp)
mov    %r10,0xe8(%rsp)
imul   %r10,%rdi
mov    %rdi,0x178(%rsp)
lea    0x2(%r13),%rdi
imul   %rcx,%rdi
mov    %rdi,0x168(%rsp)
mov    %r9d,%edi
mov    %rdi,0x138(%rsp)
mov    %r14d,%edx
mov    %rdx,0x60(%rsp)
mov    0xc(%rsp),%edx
mov    %rdx,0x130(%rsp)
mov    %r11,0x1c8(%rsp)
lea    0x0(%rbp,%r11,8),%rdx
mov    %rdx,0x160(%rsp)
lea    0x0(,%rcx,8),%r12
mov    %r14,0x48(%rsp)
lea    0x0(,%r14,8),%rdx
mov    %rdx,0x128(%rsp)
mov    %r8,%rdx
mov    %rax,0x1c0(%rsp)
add    %rbp,%rax
mov    %rax,0x158(%rsp)
mov    %rcx,0x18(%rsp)
lea    0x0(%rbp,%rcx,8),%rax
mov    %rax,0x150(%rsp)
mov    %r13,0xb8(%rsp)
lea    (%r8,%r13,8),%rax
mov    %rax,0x148(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    %rbp,0x10(%rsp)
xor    %r13d,%r13d
movsd  %xmm2,0x120(%rsp)
movsd  %xmm1,0x118(%rsp)
movsd  %xmm5,0x110(%rsp)
mov    %r8,0x50(%rsp)
mov    %rsi,0xb0(%rsp)
movsd  %xmm6,0x108(%rsp)
movsd  %xmm8,0x100(%rsp)
movsd  %xmm7,0xf8(%rsp)
jmp    13e8 <evolve2D+0x2d8>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
addq   $0x8,0x40(%rsp)
addq   $0x8,0x10(%rsp)
cmp    0x18(%rsp),%r13
mov    0x50(%rsp),%rdx
mov    0xb0(%rsp),%rsi
je     1a8e <evolve2D+0x97e>
cmpl   $0x0,0x38(%rsp)
mov    0x60(%rsp),%rcx
jle    19b0 <evolve2D+0x8a0>
mov    0x18(%rsp),%rax
add    %r13,%rax
mov    %rax,0xe0(%rsp)
mov    0xa8(%rsp),%rax
lea    0x0(%r13,%rax,1),%rax
mov    %rax,0xd8(%rsp)
mov    0xa0(%rsp),%rax
lea    0x0(%r13,%rax,1),%rax
mov    %rax,0xd0(%rsp)
mov    0x58(%rsp),%rax
lea    (%rax,%r13,1),%rax
mov    %rax,0xc8(%rsp)
mov    0x98(%rsp),%rax
lea    (%rax,%r13,1),%rax
mov    %rax,0xc0(%rsp)
mov    0x90(%rsp),%rax
lea    (%rax,%r13,1),%rax
mov    %rax,0x1a0(%rsp)
mov    0x88(%rsp),%rax
lea    (%rax,%r13,1),%rax
mov    %rax,0x198(%rsp)
mov    0x80(%rsp),%rax
lea    (%rax,%r13,1),%rax
mov    %rax,0x190(%rsp)
mov    0x78(%rsp),%rax
lea    (%rax,%r13,1),%rax
mov    %rax,0x1e0(%rsp)
mov    0x70(%rsp),%rax
add    %r13,%rax
mov    %rax,0x1d8(%rsp)
mov    0x68(%rsp),%rax
add    %r13,%rax
mov    %rax,0x1d0(%rsp)
mov    %rdx,%r10
mov    0x40(%rsp),%rax
mov    %rax,0x28(%rsp)
xor    %r8d,%r8d
jmp    150c <evolve2D+0x3fc>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r8
mov    0x28(%rsp),%rax
add    0x140(%rsp),%rax
mov    %rax,0x28(%rsp)
add    0x128(%rsp),%r10
cmp    0x138(%rsp),%r8
je     19b0 <evolve2D+0x8a0>
test   %r8,%r8
je     1670 <evolve2D+0x560>
cmp    0xe8(%rsp),%r8
jne    17a0 <evolve2D+0x690>
cmpl   $0x0,(%rsp)
jle    14e0 <evolve2D+0x3d0>
mov    0xc8(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
mov    0xc0(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
mov    0xd0(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%r13,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0xb8(%rsp),%rax
movsd  %xmm1,(%rdx,%rax,8)
cmpl   $0x1,(%rsp)
je     14e0 <evolve2D+0x3d0>
mov    $0x1,%eax
mov    0x10(%rsp),%rdi
jmp    1610 <evolve2D+0x500>
nopl   0x0(%rax,%rax,1)
mov    0x178(%rsp),%rbx
movsd  (%rdi,%rbx,8),%xmm0
mov    0x168(%rsp),%rbx
addsd  (%rdi,%rbx,8),%xmm0
mulsd  %xmm7,%xmm0
mov    0x58(%rsp),%rbx
movsd  (%rdi,%rbx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
mov    0x188(%rsp),%rbx
movsd  (%rdi,%rbx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%r13,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x148(%rsp),%rbx
movsd  %xmm1,(%rbx,%rax,8)
add    $0x1,%rax
add    %r12,%rdi
cmp    %rax,%rcx
je     14e0 <evolve2D+0x3d0>
cmp    %rax,%r15
jne    15a0 <evolve2D+0x490>
mov    0x198(%rsp),%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  %xmm5,%xmm0
mov    0x1a0(%rsp),%rbx
movsd  0x0(%rbp,%rbx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
mov    0x190(%rsp),%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%r13,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x180(%rsp),%rbx
movsd  %xmm1,(%rdx,%rbx,8)
jmp    1600 <evolve2D+0x4f0>
cmpl   $0x0,(%rsp)
jle    14e0 <evolve2D+0x3d0>
mov    0xe0(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  0x0(%rbp,%r13,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
mov    0xd8(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%r13,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx)
cmpl   $0x1,(%rsp)
je     14e0 <evolve2D+0x3d0>
mov    $0x1,%eax
mov    0x10(%rsp),%rdi
jmp    173b <evolve2D+0x62b>
nopl   0x0(%rax)
movsd  (%rdi),%xmm0
mov    0x1c0(%rsp),%rbx
addsd  (%rdi,%rbx,1),%xmm0
mulsd  %xmm7,%xmm0
movsd  (%rdi,%r12,1),%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
mov    0x1c8(%rsp),%rbx
movsd  (%rdi,%rbx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%r13,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%rax,8)
add    $0x1,%rax
add    %r12,%rdi
cmp    %rax,%rcx
je     14e0 <evolve2D+0x3d0>
cmp    %rax,%r15
jne    16e0 <evolve2D+0x5d0>
mov    0x1d8(%rsp),%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  %xmm5,%xmm0
mov    0x1e0(%rsp),%rbx
movsd  0x0(%rbp,%rbx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
mov    0x1d0(%rsp),%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%r13,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rdx,%r15,8)
jmp    172b <evolve2D+0x61b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpl   $0x0,(%rsp)
jle    14e0 <evolve2D+0x3d0>
mov    %r8,%r9
imul   0x48(%rsp),%r9
lea    -0x1(%r8),%rbx
lea    0x1(%r8),%r14
lea    0x1(%r9),%rdi
mov    0x18(%rsp),%rax
imul   %rax,%rdi
add    %r13,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm0
mov    %r9,%rdi
imul   %rax,%rdi
add    %r13,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm1
mov    0x34(%rsp),%eax
mov    %eax,%edi
mov    %rbx,0x20(%rsp)
imul   %ebx,%edi
movslq %edi,%rdi
add    %r13,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm3
mov    %r14d,%edi
imul   %eax,%edi
movslq %edi,%rdi
add    %r13,%rdi
addsd  0x0(%rbp,%rdi,8),%xmm3
mulsd  %xmm5,%xmm0
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm8,%xmm3
addsd  %xmm1,%xmm3
movsd  (%rsi,%r13,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rdx,%r9,8)
cmpl   $0x1,(%rsp)
je     14e0 <evolve2D+0x3d0>
mov    %r14,%r11
mov    0x48(%rsp),%rax
mov    0x20(%rsp),%rbx
imul   %rax,%rbx
imul   %rax,%r14
lea    (%r9,%r15,1),%r11
mov    %r11,%rax
mov    %r11,0x1b0(%rsp)
mov    %r11,%rdi
mov    0x18(%rsp),%r11
imul   %r11,%rdi
add    %r13,%rdi
mov    %rdi,0x1a8(%rsp)
lea    (%r9,%r15,1),%rax
add    $0xffffffffffffffff,%rax
imul   %r11,%rax
add    %r13,%rax
add    %r15,%rbx
imul   %r11,%rbx
add    %r13,%rbx
mov    %rbx,0x20(%rsp)
add    %r15,%r14
imul   %r11,%r14
add    %r13,%r14
mov    %r14,0x1b8(%rsp)
mov    $0x1,%r9d
mov    0x28(%rsp),%r11
jmp    193d <evolve2D+0x82d>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r11,1),%xmm0
mov    0x158(%rsp),%rcx
addsd  (%rcx,%r11,1),%xmm0
mulsd  %xmm7,%xmm0
mov    0x150(%rsp),%rcx
movsd  (%rcx,%r11,1),%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
mov    0x170(%rsp),%r14
movsd  (%r14,%r11,1),%xmm0
mov    0x60(%rsp),%rcx
mov    0x160(%rsp),%rbx
addsd  (%rbx,%r11,1),%xmm0
mulsd  %xmm8,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%r13,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%r9,8)
add    $0x1,%r9
add    %r12,%r11
cmp    %r9,%rcx
je     14e0 <evolve2D+0x3d0>
cmp    %r9,%r15
jne    18c0 <evolve2D+0x7b0>
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
mov    0x1a8(%rsp),%rdi
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
mov    0x20(%rsp),%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
mov    0x1b8(%rsp),%rbx
addsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  %xmm8,%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%r13,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x1b0(%rsp),%rdi
movsd  %xmm1,(%rdx,%rdi,8)
jmp    192d <evolve2D+0x81d>
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x0,0xc(%rsp)
jle    13c0 <evolve2D+0x2b0>
mov    0x10(%rsp),%rbx
xor    %r14d,%r14d
jmp    1a2f <evolve2D+0x91f>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
xorpd  %xmm1,%xmm1
maxsd  %xmm0,%xmm1
movsd  %xmm1,(%rbx)
movsd  0x120(%rsp),%xmm2
movsd  0x118(%rsp),%xmm4
movsd  0x110(%rsp),%xmm5
movsd  0x108(%rsp),%xmm6
movsd  0x100(%rsp),%xmm8
movsd  0xf8(%rsp),%xmm7
add    $0x1,%r14
add    %r12,%rbx
cmp    %r14,0x130(%rsp)
je     13c0 <evolve2D+0x2b0>
mov    0x50(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
cmpl   $0x0,0x230(%rsp)
je     1a5c <evolve2D+0x94c>
ucomisd 0x5c4(%rip),%xmm0
jbe    1a1a <evolve2D+0x90a>
movsd  0x5aa(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1a1a <evolve2D+0x90a>
movsd  0x59c(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
divsd  0xf0(%rsp),%xmm1
mov    $0x2,%al
call   1030 <rand_normal@plt>
test   %eax,%eax
jle    19d0 <evolve2D+0x8c0>
mov    $0x1,%eax
jmp    19d0 <evolve2D+0x8c0>
add    $0x1e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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