void equilibration(double ****lattice, double temperature) {
  int eq, sw, sw1, sw2, sw3;
  int i, j, k, ip, im, jp, jm, kp, km;
  double theta, thetaPrime, phi, phiPrime;
  double spin1theta, spin1phi, spin2theta, spin2phi, spin3theta, spin3phi,
      spin4theta, spin4phi, spin5theta, spin5phi, spin6theta, spin6phi;
  double newSpin[2], currentSpin[2];
  double spinDiff[3], spinSum[3];
  double dotProduct;
  double deltaE;
  double prob;
  double randNum;
  double beta = 1.0 / temperature;
  for (eq = 0; eq < 250; eq++) {
    for (sw = 0; sw < 250; sw++) {
      for (sw1 = 0; sw1 < 10; sw1++) {
        for (sw2 = 0; sw2 < 10; sw2++) {
          for (sw3 = 0; sw3 < 10; sw3++) {
            i = sw1;
            j = sw2;
            k = sw3;
            ip = (i + 10 - 1) % 10;
            im = (i + 1) % 10;
            jp = (j + 10 - 1) % 10;
            jm = (j + 1) % 10;
            kp = (k + 10 - 1) % 10;
            km = (k + 1) % 10;
            currentSpin[0] = lattice[i][j][k][0];
            currentSpin[1] = lattice[i][j][k][1];
            newSpin[0] = rng_theta();
            newSpin[1] = rng_phi();
            theta = currentSpin[0];
            phi = currentSpin[1];
            thetaPrime = newSpin[0];
            phiPrime = phi;
            spinDiff[0] =
                sin(thetaPrime) * cos(phiPrime) - sin(theta) * cos(phi);
            spinDiff[1] =
                sin(thetaPrime) * sin(phiPrime) - sin(theta) * sin(phi);
            spinDiff[2] = cos(thetaPrime) - cos(theta);
            spin1theta = lattice[im][j][k][0];
            spin1phi = lattice[im][j][k][1];
            spin2theta = lattice[ip][j][k][0];
            spin2phi = lattice[ip][j][k][1];
            spin3theta = lattice[i][jm][k][0];
            spin3phi = lattice[i][jm][k][1];
            spin4theta = lattice[i][jp][k][0];
            spin4phi = lattice[i][jp][k][1];
            spin5theta = lattice[i][j][km][0];
            spin5phi = lattice[i][j][km][1];
            spin6theta = lattice[i][j][kp][0];
            spin6phi = lattice[i][j][kp][1];
            spinSum[0] = sin(spin1theta) * cos(spin1phi) +
                         sin(spin2theta) * cos(spin2phi) +
                         sin(spin3theta) * cos(spin3phi) +
                         sin(spin4theta) * cos(spin4phi) +
                         sin(spin5theta) * cos(spin5phi) +
                         sin(spin6theta) * cos(spin6phi);
            spinSum[1] = sin(spin1theta) * sin(spin1phi) +
                         sin(spin2theta) * sin(spin2phi) +
                         sin(spin3theta) * sin(spin3phi) +
                         sin(spin4theta) * sin(spin4phi) +
                         sin(spin5theta) * sin(spin5phi) +
                         sin(spin6theta) * sin(spin6phi);
            spinSum[2] = cos(spin1theta) + cos(spin2theta) + cos(spin3theta) +
                         cos(spin4theta) + cos(spin5theta) + cos(spin6theta);
            dotProduct = spinDiff[0] * spinSum[0] + spinDiff[1] * spinSum[1] +
                         spinDiff[2] * spinSum[2];
            deltaE = -1.0 * dotProduct;
            if (deltaE <= 0) {
              lattice[i][j][k][0] = thetaPrime;
              lattice[i][j][k][1] = phiPrime;
            } else {
              prob = (sin(thetaPrime) / sin(theta)) * exp(-beta * deltaE);
              randNum = rng();
              if (randNum <= prob) {
                lattice[i][j][k][0] = thetaPrime;
                lattice[i][j][k][1] = phiPrime;
              }
            }
            thetaPrime = theta;
            phiPrime = newSpin[1];
            spinDiff[0] =
                sin(thetaPrime) * cos(phiPrime) - sin(theta) * cos(phi);
            spinDiff[1] =
                sin(thetaPrime) * sin(phiPrime) - sin(theta) * sin(phi);
            spinDiff[2] = cos(thetaPrime) - cos(theta);
            spin1theta = lattice[im][j][k][0];
            spin1phi = lattice[im][j][k][1];
            spin2theta = lattice[ip][j][k][0];
            spin2phi = lattice[ip][j][k][1];
            spin3theta = lattice[i][jm][k][0];
            spin3phi = lattice[i][jm][k][1];
            spin4theta = lattice[i][jp][k][0];
            spin4phi = lattice[i][jp][k][1];
            spin5theta = lattice[i][j][km][0];
            spin5phi = lattice[i][j][km][1];
            spin6theta = lattice[i][j][kp][0];
            spin6phi = lattice[i][j][kp][1];
            spinSum[0] = sin(spin1theta) * cos(spin1phi) +
                         sin(spin2theta) * cos(spin2phi) +
                         sin(spin3theta) * cos(spin4phi) +
                         sin(spin4theta) * cos(spin4phi) +
                         sin(spin5theta) * cos(spin5phi) +
                         sin(spin6theta) * cos(spin6phi);
            spinSum[1] = sin(spin1theta) * sin(spin1phi) +
                         sin(spin2theta) * sin(spin2phi) +
                         sin(spin3theta) * sin(spin4phi) +
                         sin(spin4theta) * sin(spin4phi) +
                         sin(spin5theta) * sin(spin5phi) +
                         sin(spin6theta) * sin(spin6phi);
            spinSum[2] = cos(spin1theta) + cos(spin2theta) + cos(spin3theta) +
                         cos(spin4theta) + cos(spin5theta) + cos(spin6theta);
            dotProduct = spinDiff[0] * spinSum[0] + spinDiff[1] * spinSum[1] +
                         spinDiff[2] * spinSum[2];
            deltaE = -1.0 * dotProduct;
            if (deltaE <= 0) {
              lattice[i][j][k][0] = thetaPrime;
              lattice[i][j][k][1] = phiPrime;
            } else {
              prob = (sin(thetaPrime) / sin(theta)) * exp(-beta * deltaE);
              randNum = rng();
              if (randNum <= prob) {
                lattice[i][j][k][0] = thetaPrime;
                lattice[i][j][k][1] = phiPrime;
              }
            }
          }
        }
      }
    }
    if (0) {
      printf("\t\tEquilibration runs (0-%d): %d\n", 250, eq);
    }
  }
}


x86 assembly (clang, -O0):
<equilibration>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3a0,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  0x1e84(%rip),%xmm0
divsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movl   $0x0,-0x14(%rbp)
cmpl   $0xfa,-0x14(%rbp)
jge    24c1 <equilibration+0x1361>
movl   $0x0,-0x18(%rbp)
cmpl   $0xfa,-0x18(%rbp)
jge    24ae <equilibration+0x134e>
movl   $0x0,-0x1c(%rbp)
cmpl   $0xa,-0x1c(%rbp)
jge    249b <equilibration+0x133b>
movl   $0x0,-0x20(%rbp)
cmpl   $0xa,-0x20(%rbp)
jge    2488 <equilibration+0x1328>
movl   $0x0,-0x24(%rbp)
cmpl   $0xa,-0x24(%rbp)
jge    2475 <equilibration+0x1315>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    $0xa,%eax
sub    $0x1,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x34(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xa,%eax
sub    $0x1,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x40(%rbp)
mov    -0x30(%rbp),%eax
add    $0xa,%eax
sub    $0x1,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x44(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %edx,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    $0x0,%al
call   1060 <rng_theta@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    $0x0,%al
call   1080 <rng_phi@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x258(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x260(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x268(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
call   1050 <cos@plt>
movsd  -0x268(%rbp),%xmm1
ff
movsd  -0x260(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x258(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x250(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x250(%rbp),%xmm1
ff
movsd  -0x248(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x240(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x238(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x238(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x228(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  -0x230(%rbp),%xmm1
ff
movsd  -0x228(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x220(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  -0x218(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x210(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  -0x208(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x200(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  -0x1f8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x1f0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  -0x1e8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x1e0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  -0x1d8(%rbp),%xmm1
ff
movsd  -0x1d0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x1c8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  -0x1c0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x1b8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  -0x1b0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x1a8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  -0x1a0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x198(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  -0x190(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x188(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x180(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x178(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x170(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x168(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x160(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0x130(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm0
ff
mulsd  -0x128(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  0x15c0(%rip),%xmm0
mulsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x140(%rbp),%xmm0
ff
jb     1ab9 <equilibration+0x959>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
jmp    1bac <equilibration+0xa4c>
movsd  -0x58(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x278(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x278(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x140(%rbp),%xmm0
ff
call   1040 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x270(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    $0x0,%al
call   1070 <rng@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1ba7 <equilibration+0xa47>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
jmp    1bac <equilibration+0xa4c>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x378(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x380(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x388(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
call   1050 <cos@plt>
movsd  -0x388(%rbp),%xmm1
ff
movsd  -0x380(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x378(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x360(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x368(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x370(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
call   1030 <sin@plt>
movsd  -0x370(%rbp),%xmm1
ff
movsd  -0x368(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x360(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x358(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x358(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x340(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x348(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x350(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  -0x350(%rbp),%xmm1
ff
movsd  -0x348(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x340(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x338(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x330(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  -0x338(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x330(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x328(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x320(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  -0x328(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x320(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x310(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  -0x318(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x310(%rbp),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x308(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x300(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
call   1050 <cos@plt>
movsd  -0x308(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x300(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x2e8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x2f0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x2f8(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  -0x2f8(%rbp),%xmm1
ff
movsd  -0x2f0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x2d8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  -0x2e0(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x2d8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x2c8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  -0x2d0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x2c8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x2b8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  -0x2c0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x2b8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  %xmm0,-0x2a8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
call   1030 <sin@plt>
movsd  -0x2b0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x2a8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,-0x2a0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x2a0(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x298(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x290(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x288(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1050 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x280(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0x130(%rbp),%xmm2
ff
movsd  -0x108(%rbp),%xmm0
ff
mulsd  -0x128(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  0xd0a(%rip),%xmm0
mulsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x140(%rbp),%xmm0
ff
jb     236f <equilibration+0x120f>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
jmp    2462 <equilibration+0x1302>
movsd  -0x58(%rbp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,-0x398(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
call   1030 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x398(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x390(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x140(%rbp),%xmm0
ff
call   1040 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x390(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    $0x0,%al
call   1070 <rng@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm1
ff
movsd  -0x148(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     245d <equilibration+0x12fd>
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
jmp    2462 <equilibration+0x1302>
jmp    2467 <equilibration+0x1307>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11da <equilibration+0x7a>
jmp    247a <equilibration+0x131a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11c9 <equilibration+0x69>
jmp    248d <equilibration+0x132d>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b8 <equilibration+0x58>
jmp    24a0 <equilibration+0x1340>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11a4 <equilibration+0x44>
jmp    24b3 <equilibration+0x1353>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1190 <equilibration+0x30>
add    $0x3a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<equilibration>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %rdi,%rbx
movsd  0xe84(%rip),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xb8(%rsp)
xor    %eax,%eax
jmp    11a5 <equilibration+0x45>
nopl   (%rax)
mov    0xac(%rsp),%eax
add    $0x1,%eax
cmp    $0xfa,%eax
je     1e28 <equilibration+0xcc8>
mov    %eax,0xac(%rsp)
xor    %eax,%eax
jmp    11c1 <equilibration+0x61>
mov    0xb0(%rsp),%eax
add    $0x1,%eax
cmp    $0xfa,%eax
je     1190 <equilibration+0x30>
mov    %eax,0xb0(%rsp)
xor    %r13d,%r13d
jmp    11e1 <equilibration+0x81>
nopl   (%rax)
mov    0xe0(%rsp),%rax
mov    %rax,%r13
cmp    $0xa,%rax
je     11b0 <equilibration+0x50>
lea    0x9(%r13),%edx
mov    %rdx,%rax
mov    $0xcccccccd,%ecx
imul   %rcx,%rax
shr    $0x23,%rax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%edx
mov    %rdx,0xc8(%rsp)
lea    0x1(%r13),%rax
cmp    $0xa,%rax
mov    %rax,0xe0(%rsp)
mov    %eax,%ecx
mov    $0x0,%eax
cmove  %rax,%rcx
mov    %rcx,0xc0(%rsp)
xor    %r12d,%r12d
jmp    1241 <equilibration+0xe1>
nopl   0x0(%rax)
mov    0xe8(%rsp),%rax
mov    %rax,%r12
cmp    $0xa,%rax
je     11d0 <equilibration+0x70>
lea    0x9(%r12),%edx
mov    %rdx,%rax
mov    $0xcccccccd,%ecx
imul   %rcx,%rax
shr    $0x23,%rax
add    %eax,%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%edx
mov    %rdx,0xd8(%rsp)
lea    0x1(%r12),%rax
cmp    $0xa,%rax
mov    %rax,0xe8(%rsp)
mov    %eax,%ecx
mov    $0x0,%eax
cmove  %rax,%rcx
mov    %rcx,0xd0(%rsp)
mov    $0x9,%eax
mov    $0x1,%esi
xor    %ebp,%ebp
jmp    12e7 <equilibration+0x187>
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%r13,8),%rax
mov    (%rax,%r12,8),%rax
mov    (%rax,%rbp,1),%rax
movsd  0x48(%rsp),%xmm0
movsd  %xmm0,(%rax)
movsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x8(%rax)
add    $0x8,%rbp
mov    0x110(%rsp),%rax
add    $0x1,%rax
mov    0x108(%rsp),%rsi
add    $0x1,%rsi
cmp    $0x50,%rbp
je     1230 <equilibration+0xd0>
mov    %rax,0x110(%rsp)
movabs $0xcccccccccccccccd,%rcx
cc cc cc
mul    %rcx
add    %rdx,%rdx
and    $0xfffffffffffffff0,%rdx
lea    (%rdx,%rdx,4),%r15
mov    $0x48,%eax
sub    %r15,%rax
mov    %rax,0x100(%rsp)
mov    %rsi,0x108(%rsp)
mov    %rsi,%rax
mul    %rcx
add    %rdx,%rdx
and    $0xfffffffffffffff0,%rdx
lea    (%rdx,%rdx,4),%r14
mov    $0x8,%eax
sub    %r14,%rax
mov    %rax,0xf8(%rsp)
mov    (%rbx,%r13,8),%rax
mov    (%rax,%r12,8),%rax
mov    (%rax,%rbp,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x18(%rsp)
xor    %eax,%eax
call   1060 <rng_theta@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x40(%rsp)
xor    %eax,%eax
call   1080 <rng_phi@plt>
mov    %eax,0xb4(%rsp)
movsd  0x40(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x18(%rsp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x48(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0x18(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x38(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x8(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x40(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0x48(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x78(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x78(%rsp),%xmm0
movsd  0x38(%rsp),%xmm1
mulsd  0x8(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x38(%rsp)
movsd  0x40(%rsp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x48(%rsp),%xmm0
call   1050 <cos@plt>
movsd  0x8(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
mov    0xc0(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%r12,8),%rax
mov    (%rax,%rbp,1),%rax
movsd  (%rax),%xmm1
movsd  %xmm1,0xa0(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x90(%rsp)
mov    0xc8(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%r12,8),%rax
mov    (%rax,%rbp,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    (%rbx,%r13,8),%rax
mov    0xd0(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    (%rcx,%rbp,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x68(%rsp)
mov    0xd8(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    (%rcx,%rbp,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x58(%rsp)
mov    (%rax,%r12,8),%rax
neg    %r14
lea    (%rax,%r14,1),%rcx
add    $0x8,%rcx
mov    0x0(%rbp,%rcx,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x88(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x80(%rsp)
neg    %r15
add    %r15,%rax
add    $0x48,%rax
mov    0x0(%rbp,%rax,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x98(%rsp)
movaps %xmm1,%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0x90(%rsp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0x20(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0xf0(%rsp)
movsd  0x28(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0xf0(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
mulsd  0x50(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  0x70(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0x68(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x50(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x60(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0x58(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x50(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x88(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0x80(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x50(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x78(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0x98(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x50(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0x90(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x20(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x90(%rsp)
movsd  0x28(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x90(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x50(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x70(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x68(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x28(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x60(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x68(%rsp)
movsd  0x58(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x68(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x88(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x58(%rsp)
movsd  0x80(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x58(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x78(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x80(%rsp)
movsd  0x98(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x80(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
mulsd  0x38(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x20(%rsp),%xmm0
call   1050 <cos@plt>
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x70(%rsp),%xmm0
call   1050 <cos@plt>
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0x60(%rsp),%xmm0
call   1050 <cos@plt>
addsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x88(%rsp),%xmm0
call   1050 <cos@plt>
addsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x78(%rsp),%xmm0
call   1050 <cos@plt>
addsd  0x60(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
addsd  0x38(%rsp),%xmm0
ucomisd 0x7b1(%rip),%xmm0
jae    18c5 <equilibration+0x765>
movsd  %xmm0,0x38(%rsp)
movsd  0x40(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x48(%rsp),%xmm0
call   1030 <sin@plt>
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x38(%rsp),%xmm0
mulsd  0xb8(%rsp),%xmm0
call   1040 <exp@plt>
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %eax,%eax
call   1070 <rng@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x8(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jb     18e6 <equilibration+0x786>
mov    (%rbx,%r13,8),%rax
mov    (%rax,%r12,8),%rax
mov    (%rax,%rbp,1),%rax
movsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%rax)
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x8(%rax)
xorps  %xmm0,%xmm0
cvtsi2sdl 0xb4(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x48(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x40(%rsp)
movsd  0x30(%rsp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x48(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x18(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x8(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  0x40(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
movsd  0x48(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x40(%rsp)
movsd  0x30(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x48(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x38(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x40(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x48(%rsp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,0x40(%rsp)
movsd  0x48(%rsp),%xmm0
call   1050 <cos@plt>
movsd  0x40(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rsp)
mov    0xc0(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%r12,8),%rax
mov    (%rax,%rbp,1),%rax
movsd  (%rax),%xmm1
movsd  %xmm1,0xa0(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x68(%rsp)
mov    0xc8(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%r12,8),%rax
mov    (%rax,%rbp,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x58(%rsp)
mov    (%rbx,%r13,8),%rax
mov    0xd0(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    (%rcx,%rbp,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x88(%rsp)
mov    0xd8(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    (%rcx,%rbp,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    (%rax,%r12,8),%rax
mov    0xf8(%rsp),%rcx
add    %rax,%rcx
mov    0x0(%rbp,%rcx,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x80(%rsp)
mov    0x100(%rsp),%rcx
add    %rax,%rcx
mov    0x0(%rbp,%rcx,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x38(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x98(%rsp)
movaps %xmm1,%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x68(%rsp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x70(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x90(%rsp)
movsd  0x58(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x90(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x28(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x88(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x18(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x28(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x60(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x18(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x28(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x78(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x80(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x28(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x38(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x98(%rsp),%xmm0
call   1050 <cos@plt>
mulsd  0x28(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x68(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x70(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x68(%rsp)
movsd  0x58(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x68(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  0x28(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
movsd  0x88(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x58(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x58(%rsp),%xmm0
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x60(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x58(%rsp)
movsd  0x18(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x58(%rsp),%xmm0
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x78(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x80(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x20(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x38(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x98(%rsp),%xmm0
call   1030 <sin@plt>
mulsd  0x20(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1050 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x70(%rsp),%xmm0
call   1050 <cos@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x88(%rsp),%xmm0
call   1050 <cos@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x60(%rsp),%xmm0
call   1050 <cos@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x78(%rsp),%xmm0
call   1050 <cos@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x38(%rsp),%xmm0
call   1050 <cos@plt>
addsd  0x8(%rsp),%xmm0
mulsd  0x40(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
ucomisd 0x25b(%rip),%xmm0
jae    12a0 <equilibration+0x140>
movsd  %xmm0,0x40(%rsp)
movsd  0x48(%rsp),%xmm0
call   1030 <sin@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x48(%rsp),%xmm0
call   1030 <sin@plt>
movsd  0x18(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0x40(%rsp),%xmm0
mulsd  0xb8(%rsp),%xmm0
call   1040 <exp@plt>
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
xor    %eax,%eax
call   1070 <rng@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x18(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jae    12a0 <equilibration+0x140>
jmp    12c1 <equilibration+0x161>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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