void measurement(double ****lattice, double data[][13], double temperature,
                 double ***energy, double ***magnetization, int t) {
  int RUNS_ = (double)250;
  int N_ = (double)13824;
  int eq, sk, sw, sw1, sw2, sw3;
  int ii;
  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;
  double accept, test;
  double Mxsum = 0.0, Mysum = 0.0, Mzsum = 0.0;
  double spinX, spinY, spinZ;
  double X, Y, Z;
  double Mx[RUNS_], My[RUNS_], Mz[RUNS_];
  double m[RUNS_], m2[RUNS_], e[RUNS_], e2[RUNS_];
  double e_storage = 0;
  double eSum = 0, e2Sum = 0, mSum = 0, m2Sum = 0;
  double SxSum = 0, SySum = 0, SzSum = 0;
  double SxAvg, SyAvg, SzAvg;
  double SxAvgSqr, SyAvgSqr, SzAvgSqr;
  for (eq = 0; eq < 250; eq++) {
    for (sk = 1; sk <= 30; sk++) {
      for (sw = 0; sw < 250; sw++) {
        for (sw1 = 0; sw1 < 24; sw1++) {
          for (sw2 = 0; sw2 < 24; sw2++) {
            for (sw3 = 0; sw3 < 24; sw3++) {
              i = sw1;
              j = sw2;
              k = sw3;
              ip = (i + 24 - 1) % 24;
              im = (i + 1) % 24;
              jp = (j + 24 - 1) % 24;
              jm = (j + 1) % 24;
              kp = (k + 24 - 1) % 24;
              km = (k + 1) % 24;
              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 = theta;
              phiPrime = currentSpin[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(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;
              test++;
              if (deltaE <= 0) {
                lattice[i][j][k][0] = thetaPrime;
                lattice[i][j][k][1] = phiPrime;
                accept++;
              } 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;
                  accept++;
                }
              }
              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;
              test++;
              if (deltaE <= 0) {
                lattice[i][j][k][0] = thetaPrime;
                lattice[i][j][k][1] = phiPrime;
                accept++;
              } 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;
                  accept++;
                }
              }
            }
          }
        }
      }
    }
    e_storage = 0;
    Mxsum = 0.0;
    Mysum = 0.0;
    Mzsum = 0.0;
    for (sw1 = 0; sw1 < 24; sw1++) {
      for (sw2 = 0; sw2 < 24; sw2++) {
        for (sw3 = 0; sw3 < 24; sw3++) {
          i = sw1;
          j = sw2;
          k = sw3;
          ip = (i + 24 - 1) % 24;
          im = (i + 1) % 24;
          jp = (j + 24 - 1) % 24;
          jm = (j + 1) % 24;
          kp = (k + 24 - 1) % 24;
          km = (k + 1) % 24;
          theta = lattice[i][j][k][0];
          phi = lattice[i][j][k][1];
          spinX = sin(theta) * cos(phi);
          spinY = sin(theta) * sin(phi);
          spinZ = 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 =
              spinX * spinSum[0] + spinY * spinSum[1] + spinZ * spinSum[2];
          e_storage = e_storage + -1.0 * dotProduct;
          X = spinX;
          Y = spinY;
          Z = spinZ;
          Mxsum += X;
          Mysum += Y;
          Mzsum += Z;
        }
      }
    }
    e[eq] = e_storage / 2.0;
    e2[eq] = e[eq] * e[eq];
    Mx[eq] = Mxsum / N_;
    My[eq] = Mysum / N_;
    Mz[eq] = Mzsum / N_;
    m[eq] = sqrt(Mx[eq] * Mx[eq] + My[eq] * My[eq] + Mz[eq] * Mz[eq]);
    m2[eq] = m[eq] * m[eq];
    if (0) {
      printf("\t\tMeasurement runs (0-%d): %d\n", 250, eq);
    }
  }
  eSum = 0;
  e2Sum = 0;
  mSum = 0;
  m2Sum = 0;
  SxSum = 0;
  SySum = 0;
  SzSum = 0;
  for (ii = 0; ii < RUNS_; ii++) {
    printf("eSum 1: %f\n", eSum);
    eSum += e[ii];
    printf("eSum 2: %f\n", eSum);
    e2Sum += e2[ii];
    mSum += m[ii];
    m2Sum += m2[ii];
    SxSum += Mx[ii];
    SySum += My[ii];
    SzSum += Mz[ii];
  }
  SxAvg = SxSum / RUNS_;
  SyAvg = SySum / RUNS_;
  SzAvg = SzSum / RUNS_;
  SxAvgSqr = (SxSum * SxSum) / RUNS_;
  SyAvgSqr = (SxSum * SxSum) / RUNS_;
  SzAvgSqr = (SxSum * SxSum) / RUNS_;
  data[t][0] = temperature;
  data[t][1] = eSum / RUNS_;
  data[t][2] = e2Sum / RUNS_;
  data[t][3] = data[t][1] * data[t][1];
  data[t][4] = mSum / RUNS_;
  data[t][5] = m2Sum / RUNS_;
  data[t][6] = data[t][4] * data[t][4];
  data[t][7] = data[t][1] / N_;
  data[t][8] = data[t][4] / N_;
  data[t][9] = (data[t][2] - data[t][3]) / (temperature * temperature * N_);
  data[t][10] = data[t][9] / N_;
  data[t][11] = (1.0 / temperature) *
                (SxAvgSqr + SyAvgSqr + SzAvgSqr - SxAvg - SyAvg - SzAvg);
  printf("Chi: %f\n", data[t][11]);
  data[t][12] = data[t][11] / N_;
  printf("\t\tAcceptance Ratio: %f\n", accept / test);
}


x86 assembly (clang, -O0):
<measurement>:
push   %rbp
mov    %rsp,%rbp
sub    $0x5f0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
movl   $0xfa,-0x30(%rbp)
movl   $0x3600,-0x34(%rbp)
movsd  -0x18(%rbp),%xmm1
movsd  0x2e41(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movq   $0x0,-0x1a0(%rbp)
movq   $0x0,-0x1a8(%rbp)
movq   $0x0,-0x1b0(%rbp)
mov    -0x30(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x1e8(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x2c8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x1f0(%rbp)
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x2c0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x1f8(%rbp)
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x2b8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x200(%rbp)
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x2b0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x208(%rbp)
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x2a8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x210(%rbp)
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x2a0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x218(%rbp)
mov    -0x30(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x298(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x220(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
movl   $0x0,-0x38(%rbp)
cmpl   $0xfa,-0x38(%rbp)
jge    318a <measurement+0x200a>
movl   $0x1,-0x3c(%rbp)
cmpl   $0x1e,-0x3c(%rbp)
jg     27ca <measurement+0x164a>
movl   $0x0,-0x40(%rbp)
cmpl   $0xfa,-0x40(%rbp)
jge    27b7 <measurement+0x1637>
movl   $0x0,-0x44(%rbp)
cmpl   $0x18,-0x44(%rbp)
jge    27a4 <measurement+0x1624>
movl   $0x0,-0x48(%rbp)
cmpl   $0x18,-0x48(%rbp)
jge    2791 <measurement+0x1611>
movl   $0x0,-0x4c(%rbp)
cmpl   $0x18,-0x4c(%rbp)
jge    277e <measurement+0x15fe>
mov    -0x44(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
add    $0x18,%eax
sub    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x64(%rbp)
mov    -0x58(%rbp),%eax
add    $0x18,%eax
sub    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x68(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x6c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x18,%eax
sub    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x70(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x74(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    $0x0,%al
call   1070 <rng_theta@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    $0x0,%al
call   10a0 <rng_phi@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x3c8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  %xmm0,-0x3d0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x3d8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x3d8(%rbp),%xmm1
ff
movsd  -0x3d0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x3c8(%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,-0x140(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x3b0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x3b8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x3c0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x3c0(%rbp),%xmm1
ff
movsd  -0x3b8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x3b0(%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,-0x138(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  %xmm0,-0x3a8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x3a8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x390(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  %xmm0,-0x398(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x3a0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x3a0(%rbp),%xmm1
ff
movsd  -0x398(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x390(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x388(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x380(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x388(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x380(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x378(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x370(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x378(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x370(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x368(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x360(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x368(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x360(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x358(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x350(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x358(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x350(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x338(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x340(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x348(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x348(%rbp),%xmm1
ff
movsd  -0x340(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x338(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x330(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x328(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x330(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x328(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x320(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x318(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x320(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x318(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x308(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x310(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x308(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x300(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x2f8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x300(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x2f8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  %xmm0,-0x2f0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x2f0(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x2e8(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x2e0(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x2d8(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x2d0(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x140(%rbp),%xmm1
ff
movsd  -0x160(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm0
ff
mulsd  -0x158(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x150(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  0x23a9(%rip),%xmm0
mulsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
movsd  0x2381(%rip),%xmm0
addsd  -0x198(%rbp),%xmm0
ff
movsd  %xmm0,-0x198(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x170(%rbp),%xmm0
ff
jb     1d0e <measurement+0xb8e>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
movsd  0x2307(%rip),%xmm0
addsd  -0x190(%rbp),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
jmp    1e22 <measurement+0xca2>
movsd  -0x88(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x3e8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x3e8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x3e0(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x170(%rbp),%xmm0
ff
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x3e0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    $0x0,%al
call   1080 <rng@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x180(%rbp),%xmm1
ff
movsd  -0x178(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     1e1d <measurement+0xc9d>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
movsd  0x21f3(%rip),%xmm0
addsd  -0x190(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
jmp    1e22 <measurement+0xca2>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x4e8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  %xmm0,-0x4f0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x4f8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x4f8(%rbp),%xmm1
ff
movsd  -0x4f0(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x4e8(%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,-0x140(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x4d0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x4d8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x4e0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x4e0(%rbp),%xmm1
ff
movsd  -0x4d8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x4d0(%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,-0x138(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  %xmm0,-0x4c8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x4c8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x4b0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  %xmm0,-0x4b8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x4c0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x4c0(%rbp),%xmm1
ff
movsd  -0x4b8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x4b0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x4a8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x4a0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x4a8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x4a0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x498(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x490(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x498(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x490(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x488(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x480(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x488(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x480(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x478(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x470(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x478(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x470(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x458(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x460(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x468(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x468(%rbp),%xmm1
ff
movsd  -0x460(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x458(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x450(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x448(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x450(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x448(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x440(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x438(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x440(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x438(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x430(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x428(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x430(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x428(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x420(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x418(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x420(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x418(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  %xmm0,-0x410(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x410(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x408(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x408(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x400(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x400(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x3f8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x3f8(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x3f0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x3f0(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x140(%rbp),%xmm1
ff
movsd  -0x160(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm0
ff
mulsd  -0x158(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x150(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  0x1a60(%rip),%xmm0
mulsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
movsd  0x1a38(%rip),%xmm0
addsd  -0x198(%rbp),%xmm0
ff
movsd  %xmm0,-0x198(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x170(%rbp),%xmm0
ff
jb     2657 <measurement+0x14d7>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
movsd  0x19be(%rip),%xmm0
addsd  -0x190(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
jmp    276b <measurement+0x15eb>
movsd  -0x88(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x508(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x508(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x500(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x170(%rbp),%xmm0
ff
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x500(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
mov    $0x0,%al
call   1080 <rng@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x180(%rbp),%xmm1
ff
movsd  -0x178(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     2766 <measurement+0x15e6>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
movsd  0x18aa(%rip),%xmm0
addsd  -0x190(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
jmp    276b <measurement+0x15eb>
jmp    2770 <measurement+0x15f0>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    13ba <measurement+0x23a>
jmp    2783 <measurement+0x1603>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13a9 <measurement+0x229>
jmp    2796 <measurement+0x1616>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1398 <measurement+0x218>
jmp    27a9 <measurement+0x1629>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1384 <measurement+0x204>
jmp    27bc <measurement+0x163c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1373 <measurement+0x1f3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movl   $0x0,-0x44(%rbp)
cmpl   $0x18,-0x44(%rbp)
jge    3053 <measurement+0x1ed3>
movl   $0x0,-0x48(%rbp)
cmpl   $0x18,-0x48(%rbp)
jge    3040 <measurement+0x1ec0>
movl   $0x0,-0x4c(%rbp)
cmpl   $0x18,-0x4c(%rbp)
jge    302d <measurement+0x1ead>
mov    -0x44(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
add    $0x18,%eax
sub    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x64(%rbp)
mov    -0x58(%rbp),%eax
add    $0x18,%eax
sub    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x68(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x6c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x18,%eax
sub    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x70(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    $0x18,%ecx
cltd
idiv   %ecx
mov    %edx,-0x74(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x5f0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x5f0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x5e8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x5e8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,-0x1c8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x6c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x5d0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  %xmm0,-0x5d8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x5e0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x5e0(%rbp),%xmm1
ff
movsd  -0x5d8(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x5d0(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x5c8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x5c0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x5c8(%rbp),%xmm1
movaps %xmm0,%xmm2
movsd  -0x5c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x5b8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x5b0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x5b8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x5b0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x5a8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x5a0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x5a8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x5a0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x598(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x590(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  -0x598(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x590(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x578(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x580(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x588(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x588(%rbp),%xmm1
ff
movsd  -0x580(%rbp),%xmm2
ff
movaps %xmm0,%xmm3
movsd  -0x578(%rbp),%xmm0
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x570(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x568(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x570(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x568(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x560(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x558(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x560(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x558(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x550(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x548(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x550(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x548(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x540(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  %xmm0,-0x538(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
call   1040 <sin@plt>
movsd  -0x540(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x538(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movsd  %xmm0,-0x530(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x530(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x528(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x528(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x520(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x520(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x518(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x518(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x510(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1060 <cos@plt>
movaps %xmm0,%xmm1
movsd  -0x510(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm1
ff
movsd  -0x160(%rbp),%xmm2
ff
movsd  -0x1c0(%rbp),%xmm0
ff
mulsd  -0x158(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  -0x150(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x228(%rbp),%xmm0
ff
movsd  -0x168(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x1c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x1d0(%rbp),%xmm0
ff
addsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
addsd  -0x1a8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a8(%rbp)
movsd  -0x1e0(%rbp),%xmm0
addsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b0(%rbp)
ff
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    281f <measurement+0x169f>
jmp    3032 <measurement+0x1eb2>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    280e <measurement+0x168e>
jmp    3045 <measurement+0x1ec5>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    27fd <measurement+0x167d>
mov    -0x2b8(%rbp),%rax
mov    -0x2c0(%rbp),%rcx
mov    -0x2c8(%rbp),%rdx
mov    -0x298(%rbp),%rsi
mov    -0x2a0(%rbp),%rdi
movsd  -0x228(%rbp),%xmm0
ff
movsd  0xf82(%rip),%xmm1
divsd  %xmm1,%xmm0
movslq -0x38(%rbp),%r8
movsd  %xmm0,(%rdi,%r8,8)
movslq -0x38(%rbp),%r8
movsd  (%rdi,%r8,8),%xmm0
movslq -0x38(%rbp),%r8
mulsd  (%rdi,%r8,8),%xmm0
movslq -0x38(%rbp),%rdi
movsd  %xmm0,(%rsi,%rdi,8)
movsd  -0x1a0(%rbp),%xmm0
ff
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rsi
movsd  %xmm0,(%rdx,%rsi,8)
movsd  -0x1a8(%rbp),%xmm0
ff
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rsi
movsd  %xmm0,(%rcx,%rsi,8)
movsd  -0x1b0(%rbp),%xmm0
ff
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
movslq -0x38(%rbp),%rsi
movsd  %xmm0,(%rax,%rsi,8)
movslq -0x38(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm1
movslq -0x38(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm2
movslq -0x38(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x38(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1090 <sqrt@plt>
mov    -0x2b0(%rbp),%rcx
mov    -0x2a8(%rbp),%rax
movslq -0x38(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
movslq -0x38(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x38(%rbp),%rdx
mulsd  (%rcx,%rdx,8),%xmm0
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    135f <measurement+0x1df>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    3306 <measurement+0x2186>
movsd  -0x230(%rbp),%xmm0
ff
lea    0xe1f(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x2a0(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x230(%rbp),%xmm0
ff
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
lea    0xdf5(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x298(%rbp),%r8
mov    -0x2b0(%rbp),%rdi
mov    -0x2a8(%rbp),%rsi
mov    -0x2c8(%rbp),%rdx
mov    -0x2c0(%rbp),%rcx
mov    -0x2b8(%rbp),%rax
movslq -0x50(%rbp),%r9
movsd  (%r8,%r9,8),%xmm0
addsd  -0x238(%rbp),%xmm0
ff
movsd  %xmm0,-0x238(%rbp)
ff
movslq -0x50(%rbp),%r8
movsd  (%rdi,%r8,8),%xmm0
addsd  -0x240(%rbp),%xmm0
ff
movsd  %xmm0,-0x240(%rbp)
ff
movslq -0x50(%rbp),%rdi
movsd  (%rsi,%rdi,8),%xmm0
addsd  -0x248(%rbp),%xmm0
ff
movsd  %xmm0,-0x248(%rbp)
ff
movslq -0x50(%rbp),%rsi
movsd  (%rdx,%rsi,8),%xmm0
addsd  -0x250(%rbp),%xmm0
ff
movsd  %xmm0,-0x250(%rbp)
ff
movslq -0x50(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
addsd  -0x258(%rbp),%xmm0
ff
movsd  %xmm0,-0x258(%rbp)
ff
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x260(%rbp),%xmm0
ff
movsd  %xmm0,-0x260(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    31de <measurement+0x205e>
movsd  -0x250(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x268(%rbp)
ff
movsd  -0x258(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0x260(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
movsd  -0x250(%rbp),%xmm0
ff
mulsd  -0x250(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0x250(%rbp),%xmm0
ff
mulsd  -0x250(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movsd  -0x250(%rbp),%xmm0
ff
mulsd  -0x250(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0x18(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,(%rax)
movsd  -0x230(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x238(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x10(%rax)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
mulsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x240(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x248(%rbp),%xmm0
ff
cvtsi2sdl -0x30(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x28(%rax)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
mulsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x30(%rax)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x38(%rax)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  0x20(%rax),%xmm0
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x40(%rax)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
subsd  0x18(%rax),%xmm0
movsd  -0x18(%rbp),%xmm1
mulsd  -0x18(%rbp),%xmm1
cvtsi2sdl -0x34(%rbp),%xmm2
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x48(%rax)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  0x48(%rax),%xmm0
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x50(%rax)
movsd  0xa3a(%rip),%xmm0
divsd  -0x18(%rbp),%xmm0
movsd  -0x280(%rbp),%xmm1
ff
addsd  -0x288(%rbp),%xmm1
ff
addsd  -0x290(%rbp),%xmm1
ff
subsd  -0x268(%rbp),%xmm1
ff
subsd  -0x270(%rbp),%xmm1
ff
subsd  -0x278(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x58(%rax)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  0x58(%rax),%xmm0
lea    0xa02(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  0x58(%rax),%xmm0
cvtsi2sdl -0x34(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x68,%rcx,%rcx
add    %rcx,%rax
movsd  %xmm0,0x60(%rax)
movsd  -0x190(%rbp),%xmm0
ff
divsd  -0x198(%rbp),%xmm0
ff
lea    0x9bc(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x1e8(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<measurement>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3838,%rsp
mov    %r8d,0x154(%rsp)
mov    %rsi,0x168(%rsp)
movsd  0x1e57(%rip),%xmm1
movsd  %xmm0,0x160(%rsp)
divsd  %xmm0,%xmm1
movsd  %xmm1,0x128(%rsp)
movabs $0xaaaaaaaaaaaaaaab,%rbp
aa aa aa
xor    %ebx,%ebx
mov    %rdi,0x100(%rsp)
jmp    1210 <measurement+0x90>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm1,%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,0x18f0(%rsp,%rbx,8)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x1120(%rsp,%rbx,8)
add    $0x1,%rbx
cmp    $0xfa,%rbx
je     2725 <measurement+0x15a5>
mov    %rbx,0x170(%rsp)
mov    $0x1,%eax
jmp    1233 <measurement+0xb3>
nop
mov    0x158(%rsp),%eax
add    $0x1,%eax
cmp    $0x1f,%eax
je     2020 <measurement+0xea0>
mov    %eax,0x158(%rsp)
xor    %eax,%eax
jmp    1251 <measurement+0xd1>
xchg   %ax,%ax
mov    0x15c(%rsp),%eax
add    $0x1,%eax
cmp    $0xfa,%eax
je     1220 <measurement+0xa0>
mov    %eax,0x15c(%rsp)
xor    %edx,%edx
jmp    1271 <measurement+0xf1>
nopl   0x0(%rax)
mov    0x178(%rsp),%rax
mov    %rax,%rdx
cmp    $0x18,%rax
je     1240 <measurement+0xc0>
lea    0x17(%rdx),%esi
mov    %rsi,%rax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x24,%rax
shl    $0x3,%eax
lea    (%rax,%rax,2),%eax
sub    %eax,%esi
mov    %rsi,0xf8(%rsp)
mov    %rdx,0x130(%rsp)
lea    0x1(%rdx),%rax
cmp    $0x18,%rax
mov    %rax,0x178(%rsp)
mov    %eax,%ecx
mov    $0x0,%eax
cmove  %rax,%rcx
mov    %rcx,0xf0(%rsp)
xor    %edx,%edx
jmp    12e5 <measurement+0x165>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x120(%rsp),%rax
mov    %rax,%rdx
cmp    $0x18,%rax
je     1260 <measurement+0xe0>
lea    0x17(%rdx),%r12d
mov    %r12,%rax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x24,%rax
shl    $0x3,%eax
lea    (%rax,%rax,2),%eax
sub    %eax,%r12d
mov    %rdx,0x140(%rsp)
lea    0x1(%rdx),%rax
cmp    $0x18,%rax
mov    %rax,0x120(%rsp)
mov    %eax,%ecx
mov    $0x0,%eax
cmove  %rax,%rcx
mov    %rcx,0x108(%rsp)
mov    $0x17,%eax
mov    $0x1,%ecx
xor    %r15d,%r15d
mov    %r12,0x138(%rsp)
jmp    13b2 <measurement+0x232>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rbx,%r14,8),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax,%r15,1),%rax
movaps 0x80(%rsp),%xmm0
movsd  %xmm0,(%rax)
movsd  0xc0(%rsp),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  0x110(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x110(%rsp)
mov    0xe8(%rsp),%rax
mov    0x70(%rsp),%rcx
add    $0x8,%r15
add    $0x1,%rax
add    $0x1,%rcx
cmp    $0xc0,%r15
je     12d0 <measurement+0x150>
mov    %rax,0xe8(%rsp)
mul    %rbp
shl    $0x2,%rdx
and    $0xffffffffffffffc0,%rdx
lea    (%rdx,%rdx,2),%rbx
mov    $0xb8,%eax
sub    %rbx,%rax
mov    %rax,0xd0(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rcx,%rax
mul    %rbp
shl    $0x2,%rdx
and    $0xffffffffffffffc0,%rdx
lea    (%rdx,%rdx,2),%rbp
mov    $0x8,%eax
sub    %rbp,%rax
mov    %rax,0xd8(%rsp)
mov    0x100(%rsp),%r14
mov    0x130(%rsp),%r12
mov    (%r14,%r12,8),%rax
mov    0x140(%rsp),%r13
mov    (%rax,%r13,8),%rax
mov    (%rax,%r15,1),%rax
movups (%rax),%xmm0
movaps %xmm0,0x80(%rsp)
xor    %eax,%eax
call   1070 <rng_theta@plt>
xor    %eax,%eax
call   10a0 <rng_phi@plt>
mov    %eax,0xe0(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movaps 0x80(%rsp),%xmm0
movhlps %xmm0,%xmm0
movaps %xmm0,0x60(%rsp)
call   1060 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movapd 0x60(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x20(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x50(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movaps 0x60(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x48(%rsp)
movapd 0x60(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x48(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  0x50(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
movaps 0x80(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x50(%rsp)
movapd 0x80(%rsp),%xmm0
call   1060 <cos@plt>
movsd  0x50(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%rsp)
mov    0xf0(%rsp),%rax
mov    (%r14,%rax,8),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax,%r15,1),%rax
movsd  (%rax),%xmm1
movsd  %xmm1,0xc0(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x38(%rsp)
mov    0xf8(%rsp),%rax
mov    (%r14,%rax,8),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax,%r15,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xb8(%rsp)
mov    (%r14,%r12,8),%rax
mov    %r12,%r14
mov    0x138(%rsp),%r12
mov    0x108(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    (%rcx,%r15,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0xb0(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x98(%rsp)
mov    (%rax,%r12,8),%rcx
mov    (%rcx,%r15,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    (%rax,%r13,8),%rax
neg    %rbp
lea    (%rax,%rbp,1),%rcx
add    $0x8,%rcx
mov    (%r15,%rcx,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0xa8(%rsp)
neg    %rbx
add    %rbx,%rax
add    $0xb8,%rax
mov    (%r15,%rax,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xc8(%rsp)
movaps %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x90(%rsp)
movsd  0x38(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x78(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x148(%rsp)
movsd  0xb8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x148(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
mulsd  0x90(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x90(%rsp)
movsd  0x98(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x90(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x90(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x90(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x90(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x90(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x48(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x90(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x90(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0xc0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x90(%rsp)
movsd  0x38(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x78(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0xb8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x38(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x90(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xb8(%rsp)
movsd  0x98(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xb8(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x98(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x98(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xa0(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xa0(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x48(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xa8(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xa8(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0xc0(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x78(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x78(%rsp),%xmm0
movsd  %xmm0,0xb0(%rsp)
movsd  0x40(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0xb0(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x10(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x48(%rsp),%xmm0
call   1060 <cos@plt>
movapd %xmm0,%xmm2
addsd  0x40(%rsp),%xmm2
mulsd  0x50(%rsp),%xmm2
addsd  0x20(%rsp),%xmm2
movsd  0x118(%rsp),%xmm0
movsd  0x167a(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x118(%rsp)
ucomisd 0x167d(%rip),%xmm2
jae    1a40 <measurement+0x8c0>
movaps 0x80(%rsp),%xmm0
movsd  %xmm2,0x20(%rsp)
call   1040 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movapd 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  0x50(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%rsp)
movsd  0x20(%rsp),%xmm0
mulsd  0x128(%rsp),%xmm0
call   1050 <exp@plt>
mulsd  0x50(%rsp),%xmm0
movsd  %xmm0,0x50(%rsp)
xor    %eax,%eax
call   1080 <rng@plt>
movsd  0x15f9(%rip),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x50(%rsp),%xmm2
ucomisd %xmm0,%xmm2
jae    1a40 <measurement+0x8c0>
mov    0x100(%rsp),%rbx
movabs $0xaaaaaaaaaaaaaaab,%rbp
aa aa aa
movapd 0x80(%rsp),%xmm0
jmp    1a85 <measurement+0x905>
nopw   0x0(%rax,%rax,1)
mov    0x100(%rsp),%rbx
mov    (%rbx,%r14,8),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax,%r15,1),%rax
movapd 0x80(%rsp),%xmm2
movupd %xmm2,(%rax)
movsd  0x110(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x110(%rsp)
movabs $0xaaaaaaaaaaaaaaab,%rbp
aa aa aa
movapd %xmm2,%xmm0
mov    0xe0(%rsp),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm1,0xc0(%rsp)
call   1040 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0xc0(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movapd 0x60(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x20(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x50(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x50(%rsp)
movsd  0xc0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x48(%rsp)
movapd 0x60(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x48(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  0x50(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
movaps 0x80(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x50(%rsp)
movapd 0x80(%rsp),%xmm0
call   1060 <cos@plt>
movsd  0x50(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x50(%rsp)
mov    0xf0(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax,%r15,1),%rax
movsd  (%rax),%xmm1
movsd  %xmm1,0xc8(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xb8(%rsp)
mov    0xf8(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax,%r15,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x98(%rsp)
mov    (%rbx,%r14,8),%rax
mov    0x108(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    (%rcx,%r15,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0xb0(%rsp)
mov    (%rax,%r12,8),%rcx
mov    (%rcx,%r15,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x60(%rsp)
mov    (%rax,%r13,8),%rax
mov    0xd8(%rsp),%rcx
add    %rax,%rcx
mov    (%r15,%rcx,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    0xd0(%rsp),%rcx
add    %rax,%rcx
mov    (%r15,%rcx,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xa8(%rsp)
movaps %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0xb8(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x78(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xd0(%rsp)
movsd  0x98(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0xd0(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
mulsd  0x38(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0x60(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x38(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0x60(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x38(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x38(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x48(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x38(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x38(%rsp)
movsd  0xb8(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0x78(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xb8(%rsp)
movsd  0x98(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xb8(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x38(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x98(%rsp)
movsd  0x60(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x98(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x98(%rsp)
movsd  0x60(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x98(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x8(%rsp),%xmm0
addsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x48(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x8(%rsp),%xmm0
addsd  0x60(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x78(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x10(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x40(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x48(%rsp),%xmm0
call   1060 <cos@plt>
movapd %xmm0,%xmm2
addsd  0x20(%rsp),%xmm2
mulsd  0x50(%rsp),%xmm2
addsd  0x60(%rsp),%xmm2
movsd  0x118(%rsp),%xmm0
movsd  0x107d(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x118(%rsp)
ucomisd 0x1080(%rip),%xmm2
jae    1350 <measurement+0x1d0>
movaps 0x80(%rsp),%xmm0
movsd  %xmm2,0x50(%rsp)
call   1040 <sin@plt>
movsd  %xmm0,0x60(%rsp)
movapd 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  0x60(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x60(%rsp)
movsd  0x50(%rsp),%xmm0
mulsd  0x128(%rsp),%xmm0
call   1050 <exp@plt>
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
xor    %eax,%eax
call   1080 <rng@plt>
movsd  0xffc(%rip),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x60(%rsp),%xmm2
ucomisd %xmm0,%xmm2
jae    1350 <measurement+0x1d0>
jmp    138c <measurement+0x20c>
xorpd  %xmm0,%xmm0
xor    %edx,%edx
xorpd  %xmm1,%xmm1
xorps  %xmm3,%xmm3
xorpd  %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x17(%rdx),%esi
mov    %rsi,%rax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x24,%rax
shl    $0x3,%eax
lea    (%rax,%rax,2),%eax
sub    %eax,%esi
mov    %rsi,0x140(%rsp)
mov    %rdx,0x148(%rsp)
lea    0x1(%rdx),%rax
cmp    $0x18,%rax
mov    %rax,0x120(%rsp)
mov    %eax,%ecx
mov    $0x0,%eax
cmove  %rax,%rcx
mov    %rcx,0x138(%rsp)
xor    %eax,%eax
mov    %rax,0xd8(%rsp)
nopl   0x0(%rax,%rax,1)
mov    0xd8(%rsp),%rdx
lea    0x17(%rdx),%esi
mov    %rsi,%rax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x24,%rax
shl    $0x3,%eax
lea    (%rax,%rax,2),%eax
sub    %eax,%esi
mov    %rsi,0xe0(%rsp)
lea    0x1(%rdx),%rax
cmp    $0x18,%rax
mov    %rax,0x130(%rsp)
mov    %eax,%ecx
mov    $0x0,%eax
cmove  %rax,%rcx
mov    %rcx,0x90(%rsp)
mov    $0x17,%eax
mov    $0x1,%ecx
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
mov    %rcx,0x108(%rsp)
mov    %rax,0xb0(%rsp)
movsd  %xmm0,0x80(%rsp)
movsd  %xmm3,0x38(%rsp)
movsd  %xmm2,0xb8(%rsp)
movsd  %xmm1,0x98(%rsp)
mov    0xb0(%rsp),%rax
mul    %rbp
shl    $0x2,%rdx
and    $0xffffffffffffffc0,%rdx
lea    (%rdx,%rdx,2),%r13
mov    %rcx,%rax
mul    %rbp
shl    $0x2,%rdx
and    $0xffffffffffffffc0,%rdx
lea    (%rdx,%rdx,2),%r14
mov    0x100(%rsp),%rbx
mov    0x148(%rsp),%r12
mov    (%rbx,%r12,8),%rax
mov    0xd8(%rsp),%rbp
mov    (%rax,%rbp,8),%rax
mov    (%rax,%r15,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x8(%rax),%xmm1
movsd  %xmm1,0x50(%rsp)
call   1040 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x50(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0xf8(%rsp)
movsd  0x60(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x50(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0xe8(%rsp)
movsd  0x60(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0xf0(%rsp)
mov    0x138(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax,%r15,1),%rax
movsd  (%rax),%xmm1
movsd  %xmm1,0x78(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    0x140(%rsp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%rbp,8),%rax
mov    (%rax,%r15,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    (%rbx,%r12,8),%rax
mov    0x90(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    (%rcx,%r15,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0xc8(%rsp)
mov    0xe0(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    (%rcx,%r15,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0xc0(%rsp)
mov    (%rax,%rbp,8),%rax
mov    %rax,%rcx
sub    %r14,%rcx
movabs $0xaaaaaaaaaaaaaaab,%rbp
aa aa aa
mov    0x8(%r15,%rcx,1),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x50(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x18(%rsp)
sub    %r13,%rax
mov    0xb8(%r15,%rax,1),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rsp)
movaps %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x70(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xd0(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0xd0(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x70(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x48(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x70(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x70(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x20(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x70(%rsp)
movsd  0xc0(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x70(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x50(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x70(%rsp)
movsd  0x18(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x70(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x60(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x70(%rsp)
movsd  0x8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x70(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0x78(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xd0(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xa0(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xa0(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0xd0(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x48(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xa8(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xa8(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x20(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xc8(%rsp)
movsd  0xc0(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xc8(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x50(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xc0(%rsp)
movsd  0x18(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xc0(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x60(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0x8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x18(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x78(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x78(%rsp)
movsd  0x40(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x78(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x48(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x48(%rsp)
movsd  0x20(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x50(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x50(%rsp)
movsd  0x60(%rsp),%xmm0
call   1060 <cos@plt>
mov    0x108(%rsp),%rcx
mov    0xb0(%rsp),%rax
movsd  0x38(%rsp),%xmm3
movsd  0xb8(%rsp),%xmm2
movsd  0x98(%rsp),%xmm1
addsd  0x50(%rsp),%xmm0
movsd  0xe8(%rsp),%xmm6
movsd  0x10(%rsp),%xmm7
mulsd  %xmm6,%xmm7
movsd  0xf8(%rsp),%xmm5
movsd  0x70(%rsp),%xmm4
mulsd  %xmm5,%xmm4
addsd  %xmm7,%xmm4
movsd  0xf0(%rsp),%xmm7
mulsd  %xmm7,%xmm0
addsd  %xmm4,%xmm0
movsd  0x80(%rsp),%xmm4
subsd  %xmm0,%xmm4
movsd  %xmm4,0x80(%rsp)
movsd  0x80(%rsp),%xmm0
addsd  %xmm5,%xmm2
addsd  %xmm6,%xmm3
addsd  %xmm7,%xmm1
add    $0x1,%rax
add    $0x8,%r15
add    $0x1,%rcx
cmp    $0xc0,%r15
jne    2100 <measurement+0xf80>
mov    0x130(%rsp),%rax
mov    %rax,0xd8(%rsp)
cmp    $0x18,%rax
jne    20a0 <measurement+0xf20>
mov    0x120(%rsp),%rax
mov    %rax,%rdx
cmp    $0x18,%rax
jne    2040 <measurement+0xec0>
mulsd  0x95e(%rip),%xmm0
mov    0x170(%rsp),%rbx
movsd  %xmm0,0x950(%rsp,%rbx,8)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x180(%rsp,%rbx,8)
movsd  0x940(%rip),%xmm0
divsd  %xmm0,%xmm2
movsd  %xmm2,0x3060(%rsp,%rbx,8)
divsd  %xmm0,%xmm3
movsd  %xmm3,0x2890(%rsp,%rbx,8)
divsd  %xmm0,%xmm1
movsd  %xmm1,0x20c0(%rsp,%rbx,8)
mulsd  %xmm3,%xmm3
mulsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
ucomisd 0x905(%rip),%xmm1
jb     11e0 <measurement+0x60>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    11e9 <measurement+0x69>
xorpd  %xmm6,%xmm6
xorpd  %xmm0,%xmm0
movapd %xmm0,0x80(%rsp)
xor    %ebx,%ebx
lea    0x901(%rip),%r14
lea    0x906(%rip),%rbp
xorpd  %xmm4,%xmm4
xorpd  %xmm2,%xmm2
xchg   %ax,%ax
movapd %xmm2,0x20(%rsp)
movapd %xmm6,0x50(%rsp)
movapd %xmm4,0x60(%rsp)
mov    %r14,%rdi
movaps 0x80(%rsp),%xmm0
mov    $0x1,%al
call   1030 <printf@plt>
movapd 0x80(%rsp),%xmm0
addsd  0x950(%rsp,%rbx,1),%xmm0
mov    %rbp,%rdi
movapd %xmm0,0x80(%rsp)
mov    $0x1,%al
call   1030 <printf@plt>
movapd 0x20(%rsp),%xmm2
movapd 0x50(%rsp),%xmm6
movapd 0x60(%rsp),%xmm4
movsd  0x18f0(%rsp,%rbx,1),%xmm0
movhpd 0x1120(%rsp,%rbx,1),%xmm0
movsd  0x3060(%rsp,%rbx,1),%xmm1
movhpd 0x180(%rsp,%rbx,1),%xmm1
addpd  %xmm0,%xmm6
movsd  0x2890(%rsp,%rbx,1),%xmm0
movhpd 0x20c0(%rsp,%rbx,1),%xmm0
addpd  %xmm1,%xmm2
addpd  %xmm0,%xmm4
add    $0x8,%rbx
cmp    $0x7d0,%rbx
jne    2750 <measurement+0x15d0>
movapd 0x81a(%rip),%xmm1
divpd  %xmm1,%xmm4
movapd %xmm2,%xmm0
mulpd  %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
divpd  %xmm1,%xmm0
movslq 0x154(%rsp),%rax
imul   $0x68,%rax,%rbx
mov    0x168(%rsp),%rbp
movsd  0x160(%rsp),%xmm3
movsd  %xmm3,0x0(%rbp,%rbx,1)
movapd 0x80(%rsp),%xmm5
shufpd $0x2,%xmm2,%xmm5
divpd  %xmm1,%xmm5
movupd %xmm5,0x8(%rbp,%rbx,1)
movapd %xmm5,%xmm2
mulsd  %xmm5,%xmm2
movsd  %xmm2,0x18(%rbp,%rbx,1)
divpd  %xmm1,%xmm6
movupd %xmm6,0x20(%rbp,%rbx,1)
movapd %xmm5,%xmm1
unpcklpd %xmm6,%xmm1
mulsd  %xmm6,%xmm6
movsd  %xmm6,0x30(%rbp,%rbx,1)
divpd  0x7a9(%rip),%xmm1
movupd %xmm1,0x38(%rbp,%rbx,1)
unpckhpd %xmm5,%xmm5
subsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm3
movsd  0x76f(%rip),%xmm1
mulsd  %xmm1,%xmm3
divsd  %xmm3,%xmm5
movsd  %xmm5,0x48(%rbp,%rbx,1)
divsd  %xmm1,%xmm5
movsd  %xmm5,0x50(%rbp,%rbx,1)
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
subsd  %xmm0,%xmm1
subsd  %xmm4,%xmm1
unpckhpd %xmm4,%xmm4
subsd  %xmm4,%xmm1
movsd  0x128(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x58(%rbp,%rbx,1)
lea    0x765(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  0x58(%rbp,%rbx,1),%xmm0
divsd  0x708(%rip),%xmm0
movsd  %xmm0,0x60(%rbp,%rbx,1)
movsd  0x110(%rsp),%xmm0
divsd  0x118(%rsp),%xmm0
lea    0x73a(%rip),%rdi
mov    $0x1,%al
add    $0x3838,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <printf@plt>

LLVM IR (-O0):
@.str = [12 x i8] c"eSum 1: %f\0A\00"
@.str.1 = [12 x i8] c"eSum 2: %f\0A\00"
@.str.2 = [9 x i8] c"Chi: %f\0A\00"
@.str.3 = [24 x i8] c"\09\09Acceptance Ratio: %f\0A\00"
define void @measurement(double**** %0, [13 x double]* %1, double %2, double*** %3, double*** %4, i32 %5) {
%7 = alloca double****
%8 = alloca [13 x double]*
%9 = alloca double
%10 = alloca double***
%11 = alloca double***
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca double
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca [2 x double]
%48 = alloca [2 x double]
%49 = alloca [3 x double]
%50 = alloca [3 x double]
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca i8*
%68 = alloca i64
%69 = alloca i64
%70 = alloca i64
%71 = alloca i64
%72 = alloca i64
%73 = alloca i64
%74 = alloca i64
%75 = alloca double
%76 = alloca double
%77 = alloca double
%78 = alloca double
%79 = alloca double
%80 = alloca double
%81 = alloca double
%82 = alloca double
%83 = alloca double
%84 = alloca double
%85 = alloca double
%86 = alloca double
%87 = alloca double
%88 = alloca double
store double**** %0, double***** %7
store [13 x double]* %1, [13 x double]** %8
store double %2, double* %9
store double*** %3, double**** %10
store double*** %4, double**** %11
store i32 %5, i32* %12
store i32 250, i32* %13
store i32 13824, i32* %14
%89 = load double, double* %9
%90 = fdiv double 1.000000e+00, %89
store double %90, double* %55
store double 0.000000e+00, double* %58
store double 0.000000e+00, double* %59
store double 0.000000e+00, double* %60
%91 = load i32, i32* %13
%92 = zext i32 %91 to i64
%93 = call i8* @llvm.stacksave()
store i8* %93, i8** %67
%94 = alloca double, i64 %92
store i64 %92, i64* %68
%95 = load i32, i32* %13
%96 = zext i32 %95 to i64
%97 = alloca double, i64 %96
store i64 %96, i64* %69
%98 = load i32, i32* %13
%99 = zext i32 %98 to i64
%100 = alloca double, i64 %99
store i64 %99, i64* %70
%101 = load i32, i32* %13
%102 = zext i32 %101 to i64
%103 = alloca double, i64 %102
store i64 %102, i64* %71
%104 = load i32, i32* %13
%105 = zext i32 %104 to i64
%106 = alloca double, i64 %105
store i64 %105, i64* %72
%107 = load i32, i32* %13
%108 = zext i32 %107 to i64
%109 = alloca double, i64 %108
store i64 %108, i64* %73
%110 = load i32, i32* %13
%111 = zext i32 %110 to i64
%112 = alloca double, i64 %111
store i64 %111, i64* %74
store double 0.000000e+00, double* %75
store double 0.000000e+00, double* %76
store double 0.000000e+00, double* %77
store double 0.000000e+00, double* %78
store double 0.000000e+00, double* %79
store double 0.000000e+00, double* %80
store double 0.000000e+00, double* %81
store double 0.000000e+00, double* %82
store i32 0, i32* %15
br label %113
113: ; preds = %1479, %6
%114 = load i32, i32* %15
%115 = icmp slt i32 %114, 250
br i1 %115, label %116, label %1482
116: ; preds = %113
store i32 1, i32* %16
br label %117
117: ; preds = %1017, %116
%118 = load i32, i32* %16
%119 = icmp sle i32 %118, 30
br i1 %119, label %120, label %1020
120: ; preds = %117
store i32 0, i32* %17
br label %121
121: ; preds = %1013, %120
%122 = load i32, i32* %17
%123 = icmp slt i32 %122, 250
br i1 %123, label %124, label %1016
124: ; preds = %121
store i32 0, i32* %18
br label %125
125: ; preds = %1009, %124
%126 = load i32, i32* %18
%127 = icmp slt i32 %126, 24
br i1 %127, label %128, label %1012
128: ; preds = %125
store i32 0, i32* %19
br label %129
129: ; preds = %1005, %128
%130 = load i32, i32* %19
%131 = icmp slt i32 %130, 24
br i1 %131, label %132, label %1008
132: ; preds = %129
store i32 0, i32* %20
br label %133
133: ; preds = %1001, %132
%134 = load i32, i32* %20
%135 = icmp slt i32 %134, 24
br i1 %135, label %136, label %1004
136: ; preds = %133
%137 = load i32, i32* %18
store i32 %137, i32* %22
%138 = load i32, i32* %19
store i32 %138, i32* %23
%139 = load i32, i32* %20
store i32 %139, i32* %24
%140 = load i32, i32* %22
%141 = add nsw i32 %140, 24
%142 = sub nsw i32 %141, 1
%143 = srem i32 %142, 24
store i32 %143, i32* %25
%144 = load i32, i32* %22
%145 = add nsw i32 %144, 1
%146 = srem i32 %145, 24
store i32 %146, i32* %26
%147 = load i32, i32* %23
%148 = add nsw i32 %147, 24
%149 = sub nsw i32 %148, 1
%150 = srem i32 %149, 24
store i32 %150, i32* %27
%151 = load i32, i32* %23
%152 = add nsw i32 %151, 1
%153 = srem i32 %152, 24
store i32 %153, i32* %28
%154 = load i32, i32* %24
%155 = add nsw i32 %154, 24
%156 = sub nsw i32 %155, 1
%157 = srem i32 %156, 24
store i32 %157, i32* %29
%158 = load i32, i32* %24
%159 = add nsw i32 %158, 1
%160 = srem i32 %159, 24
store i32 %160, i32* %30
%161 = load double****, double***** %7
%162 = load i32, i32* %22
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds double***, double**** %161, i64 %163
%165 = load double***, double**** %164
%166 = load i32, i32* %23
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds double**, double*** %165, i64 %167
%169 = load double**, double*** %168
%170 = load i32, i32* %24
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double*, double** %169, i64 %171
%173 = load double*, double** %172
%174 = getelementptr inbounds double, double* %173, i64 0
%175 = load double, double* %174
%176 = getelementptr inbounds [2 x double], [2 x double]* %48, i64 0, i64 0
store double %175, double* %176
%177 = load double****, double***** %7
%178 = load i32, i32* %22
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double***, double**** %177, i64 %179
%181 = load double***, double**** %180
%182 = load i32, i32* %23
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds double**, double*** %181, i64 %183
%185 = load double**, double*** %184
%186 = load i32, i32* %24
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds double*, double** %185, i64 %187
%189 = load double*, double** %188
%190 = getelementptr inbounds double, double* %189, i64 1
%191 = load double, double* %190
%192 = getelementptr inbounds [2 x double], [2 x double]* %48, i64 0, i64 1
store double %191, double* %192
%193 = call i32 (...) @rng_theta()
%194 = sitofp i32 %193 to double
%195 = getelementptr inbounds [2 x double], [2 x double]* %47, i64 0, i64 0
store double %194, double* %195
%196 = call i32 (...) @rng_phi()
%197 = sitofp i32 %196 to double
%198 = getelementptr inbounds [2 x double], [2 x double]* %47, i64 0, i64 1
store double %197, double* %198
%199 = getelementptr inbounds [2 x double], [2 x double]* %48, i64 0, i64 0
%200 = load double, double* %199
store double %200, double* %31
%201 = getelementptr inbounds [2 x double], [2 x double]* %48, i64 0, i64 1
%202 = load double, double* %201
store double %202, double* %33
%203 = load double, double* %31
store double %203, double* %32
%204 = getelementptr inbounds [2 x double], [2 x double]* %48, i64 0, i64 1
%205 = load double, double* %204
store double %205, double* %34
%206 = load double, double* %32
%207 = call double @sin(double %206)
%208 = load double, double* %34
%209 = call double @cos(double %208)
%210 = load double, double* %31
%211 = call double @sin(double %210)
%212 = load double, double* %33
%213 = call double @cos(double %212)
%214 = fmul double %211, %213
%215 = fneg double %214
%216 = call double @llvm.fmuladd.f64(double %207, double %209, double %215)
%217 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
store double %216, double* %217
%218 = load double, double* %32
%219 = call double @sin(double %218)
%220 = load double, double* %34
%221 = call double @sin(double %220)
%222 = load double, double* %31
%223 = call double @sin(double %222)
%224 = load double, double* %33
%225 = call double @sin(double %224)
%226 = fmul double %223, %225
%227 = fneg double %226
%228 = call double @llvm.fmuladd.f64(double %219, double %221, double %227)
%229 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
store double %228, double* %229
%230 = load double, double* %32
%231 = call double @cos(double %230)
%232 = load double, double* %31
%233 = call double @cos(double %232)
%234 = fsub double %231, %233
%235 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
store double %234, double* %235
%236 = load double****, double***** %7
%237 = load i32, i32* %26
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double***, double**** %236, i64 %238
%240 = load double***, double**** %239
%241 = load i32, i32* %23
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double**, double*** %240, i64 %242
%244 = load double**, double*** %243
%245 = load i32, i32* %24
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double*, double** %244, i64 %246
%248 = load double*, double** %247
%249 = getelementptr inbounds double, double* %248, i64 0
%250 = load double, double* %249
store double %250, double* %35
%251 = load double****, double***** %7
%252 = load i32, i32* %26
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double***, double**** %251, i64 %253
%255 = load double***, double**** %254
%256 = load i32, i32* %23
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds double**, double*** %255, i64 %257
%259 = load double**, double*** %258
%260 = load i32, i32* %24
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds double*, double** %259, i64 %261
%263 = load double*, double** %262
%264 = getelementptr inbounds double, double* %263, i64 1
%265 = load double, double* %264
store double %265, double* %36
%266 = load double****, double***** %7
%267 = load i32, i32* %25
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds double***, double**** %266, i64 %268
%270 = load double***, double**** %269
%271 = load i32, i32* %23
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds double**, double*** %270, i64 %272
%274 = load double**, double*** %273
%275 = load i32, i32* %24
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds double*, double** %274, i64 %276
%278 = load double*, double** %277
%279 = getelementptr inbounds double, double* %278, i64 0
%280 = load double, double* %279
store double %280, double* %37
%281 = load double****, double***** %7
%282 = load i32, i32* %25
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds double***, double**** %281, i64 %283
%285 = load double***, double**** %284
%286 = load i32, i32* %23
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds double**, double*** %285, i64 %287
%289 = load double**, double*** %288
%290 = load i32, i32* %24
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds double*, double** %289, i64 %291
%293 = load double*, double** %292
%294 = getelementptr inbounds double, double* %293, i64 1
%295 = load double, double* %294
store double %295, double* %38
%296 = load double****, double***** %7
%297 = load i32, i32* %22
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds double***, double**** %296, i64 %298
%300 = load double***, double**** %299
%301 = load i32, i32* %28
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds double**, double*** %300, i64 %302
%304 = load double**, double*** %303
%305 = load i32, i32* %24
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds double*, double** %304, i64 %306
%308 = load double*, double** %307
%309 = getelementptr inbounds double, double* %308, i64 0
%310 = load double, double* %309
store double %310, double* %39
%311 = load double****, double***** %7
%312 = load i32, i32* %22
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds double***, double**** %311, i64 %313
%315 = load double***, double**** %314
%316 = load i32, i32* %28
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double**, double*** %315, i64 %317
%319 = load double**, double*** %318
%320 = load i32, i32* %24
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds double*, double** %319, i64 %321
%323 = load double*, double** %322
%324 = getelementptr inbounds double, double* %323, i64 1
%325 = load double, double* %324
store double %325, double* %40
%326 = load double****, double***** %7
%327 = load i32, i32* %22
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds double***, double**** %326, i64 %328
%330 = load double***, double**** %329
%331 = load i32, i32* %27
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds double**, double*** %330, i64 %332
%334 = load double**, double*** %333
%335 = load i32, i32* %24
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds double*, double** %334, i64 %336
%338 = load double*, double** %337
%339 = getelementptr inbounds double, double* %338, i64 0
%340 = load double, double* %339
store double %340, double* %41
%341 = load double****, double***** %7
%342 = load i32, i32* %22
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds double***, double**** %341, i64 %343
%345 = load double***, double**** %344
%346 = load i32, i32* %27
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds double**, double*** %345, i64 %347
%349 = load double**, double*** %348
%350 = load i32, i32* %24
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds double*, double** %349, i64 %351
%353 = load double*, double** %352
%354 = getelementptr inbounds double, double* %353, i64 1
%355 = load double, double* %354
store double %355, double* %42
%356 = load double****, double***** %7
%357 = load i32, i32* %22
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double***, double**** %356, i64 %358
%360 = load double***, double**** %359
%361 = load i32, i32* %23
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds double**, double*** %360, i64 %362
%364 = load double**, double*** %363
%365 = load i32, i32* %30
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double*, double** %364, i64 %366
%368 = load double*, double** %367
%369 = getelementptr inbounds double, double* %368, i64 0
%370 = load double, double* %369
store double %370, double* %43
%371 = load double****, double***** %7
%372 = load i32, i32* %22
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double***, double**** %371, i64 %373
%375 = load double***, double**** %374
%376 = load i32, i32* %23
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds double**, double*** %375, i64 %377
%379 = load double**, double*** %378
%380 = load i32, i32* %30
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds double*, double** %379, i64 %381
%383 = load double*, double** %382
%384 = getelementptr inbounds double, double* %383, i64 1
%385 = load double, double* %384
store double %385, double* %44
%386 = load double****, double***** %7
%387 = load i32, i32* %22
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds double***, double**** %386, i64 %388
%390 = load double***, double**** %389
%391 = load i32, i32* %23
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds double**, double*** %390, i64 %392
%394 = load double**, double*** %393
%395 = load i32, i32* %29
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double*, double** %394, i64 %396
%398 = load double*, double** %397
%399 = getelementptr inbounds double, double* %398, i64 0
%400 = load double, double* %399
store double %400, double* %45
%401 = load double****, double***** %7
%402 = load i32, i32* %22
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double***, double**** %401, i64 %403
%405 = load double***, double**** %404
%406 = load i32, i32* %23
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds double**, double*** %405, i64 %407
%409 = load double**, double*** %408
%410 = load i32, i32* %29
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds double*, double** %409, i64 %411
%413 = load double*, double** %412
%414 = getelementptr inbounds double, double* %413, i64 1
%415 = load double, double* %414
store double %415, double* %46
%416 = load double, double* %35
%417 = call double @sin(double %416)
%418 = load double, double* %36
%419 = call double @cos(double %418)
%420 = load double, double* %37
%421 = call double @sin(double %420)
%422 = load double, double* %38
%423 = call double @cos(double %422)
%424 = fmul double %421, %423
%425 = call double @llvm.fmuladd.f64(double %417, double %419, double %424)
%426 = load double, double* %39
%427 = call double @sin(double %426)
%428 = load double, double* %40
%429 = call double @cos(double %428)
%430 = call double @llvm.fmuladd.f64(double %427, double %429, double %425)
%431 = load double, double* %41
%432 = call double @sin(double %431)
%433 = load double, double* %42
%434 = call double @cos(double %433)
%435 = call double @llvm.fmuladd.f64(double %432, double %434, double %430)
%436 = load double, double* %43
%437 = call double @sin(double %436)
%438 = load double, double* %44
%439 = call double @cos(double %438)
%440 = call double @llvm.fmuladd.f64(double %437, double %439, double %435)
%441 = load double, double* %45
%442 = call double @sin(double %441)
%443 = load double, double* %46
%444 = call double @cos(double %443)
%445 = call double @llvm.fmuladd.f64(double %442, double %444, double %440)
%446 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 0
store double %445, double* %446
%447 = load double, double* %35
%448 = call double @sin(double %447)
%449 = load double, double* %36
%450 = call double @sin(double %449)
%451 = load double, double* %37
%452 = call double @sin(double %451)
%453 = load double, double* %38
%454 = call double @sin(double %453)
%455 = fmul double %452, %454
%456 = call double @llvm.fmuladd.f64(double %448, double %450, double %455)
%457 = load double, double* %39
%458 = call double @sin(double %457)
%459 = load double, double* %40
%460 = call double @sin(double %459)
%461 = call double @llvm.fmuladd.f64(double %458, double %460, double %456)
%462 = load double, double* %41
%463 = call double @sin(double %462)
%464 = load double, double* %42
%465 = call double @sin(double %464)
%466 = call double @llvm.fmuladd.f64(double %463, double %465, double %461)
%467 = load double, double* %43
%468 = call double @sin(double %467)
%469 = load double, double* %44
%470 = call double @sin(double %469)
%471 = call double @llvm.fmuladd.f64(double %468, double %470, double %466)
%472 = load double, double* %45
%473 = call double @sin(double %472)
%474 = load double, double* %46
%475 = call double @sin(double %474)
%476 = call double @llvm.fmuladd.f64(double %473, double %475, double %471)
%477 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 1
store double %476, double* %477
%478 = load double, double* %35
%479 = call double @cos(double %478)
%480 = load double, double* %37
%481 = call double @cos(double %480)
%482 = fadd double %479, %481
%483 = load double, double* %39
%484 = call double @cos(double %483)
%485 = fadd double %482, %484
%486 = load double, double* %41
%487 = call double @cos(double %486)
%488 = fadd double %485, %487
%489 = load double, double* %43
%490 = call double @cos(double %489)
%491 = fadd double %488, %490
%492 = load double, double* %45
%493 = call double @cos(double %492)
%494 = fadd double %491, %493
%495 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 2
store double %494, double* %495
%496 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
%497 = load double, double* %496
%498 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 0
%499 = load double, double* %498
%500 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
%501 = load double, double* %500
%502 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 1
%503 = load double, double* %502
%504 = fmul double %501, %503
%505 = call double @llvm.fmuladd.f64(double %497, double %499, double %504)
%506 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
%507 = load double, double* %506
%508 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 2
%509 = load double, double* %508
%510 = call double @llvm.fmuladd.f64(double %507, double %509, double %505)
store double %510, double* %51
%511 = load double, double* %51
%512 = fmul double -1.000000e+00, %511
store double %512, double* %52
%513 = load double, double* %57
%514 = fadd double %513, 1.000000e+00
store double %514, double* %57
%515 = load double, double* %52
%516 = fcmp ole double %515, 0.000000e+00
br i1 %516, label %517, label %550
517: ; preds = %136
%518 = load double, double* %32
%519 = load double****, double***** %7
%520 = load i32, i32* %22
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds double***, double**** %519, i64 %521
%523 = load double***, double**** %522
%524 = load i32, i32* %23
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds double**, double*** %523, i64 %525
%527 = load double**, double*** %526
%528 = load i32, i32* %24
%529 = sext i32 %528 to i64
%530 = getelementptr inbounds double*, double** %527, i64 %529
%531 = load double*, double** %530
%532 = getelementptr inbounds double, double* %531, i64 0
store double %518, double* %532
%533 = load double, double* %34
%534 = load double****, double***** %7
%535 = load i32, i32* %22
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds double***, double**** %534, i64 %536
%538 = load double***, double**** %537
%539 = load i32, i32* %23
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds double**, double*** %538, i64 %540
%542 = load double**, double*** %541
%543 = load i32, i32* %24
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds double*, double** %542, i64 %544
%546 = load double*, double** %545
%547 = getelementptr inbounds double, double* %546, i64 1
store double %533, double* %547
%548 = load double, double* %56
%549 = fadd double %548, 1.000000e+00
store double %549, double* %56
br label %601
550: ; preds = %136
%551 = load double, double* %32
%552 = call double @sin(double %551)
%553 = load double, double* %31
%554 = call double @sin(double %553)
%555 = fdiv double %552, %554
%556 = load double, double* %55
%557 = fneg double %556
%558 = load double, double* %52
%559 = fmul double %557, %558
%560 = call double @exp(double %559)
%561 = fmul double %555, %560
store double %561, double* %53
%562 = call i32 (...) @rng()
%563 = sitofp i32 %562 to double
store double %563, double* %54
%564 = load double, double* %54
%565 = load double, double* %53
%566 = fcmp ole double %564, %565
br i1 %566, label %567, label %600
567: ; preds = %550
%568 = load double, double* %32
%569 = load double****, double***** %7
%570 = load i32, i32* %22
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds double***, double**** %569, i64 %571
%573 = load double***, double**** %572
%574 = load i32, i32* %23
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds double**, double*** %573, i64 %575
%577 = load double**, double*** %576
%578 = load i32, i32* %24
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds double*, double** %577, i64 %579
%581 = load double*, double** %580
%582 = getelementptr inbounds double, double* %581, i64 0
store double %568, double* %582
%583 = load double, double* %34
%584 = load double****, double***** %7
%585 = load i32, i32* %22
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds double***, double**** %584, i64 %586
%588 = load double***, double**** %587
%589 = load i32, i32* %23
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds double**, double*** %588, i64 %590
%592 = load double**, double*** %591
%593 = load i32, i32* %24
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds double*, double** %592, i64 %594
%596 = load double*, double** %595
%597 = getelementptr inbounds double, double* %596, i64 1
store double %583, double* %597
%598 = load double, double* %56
%599 = fadd double %598, 1.000000e+00
store double %599, double* %56
br label %600
600: ; preds = %567, %550
br label %601
601: ; preds = %600, %517
%602 = load double, double* %31
store double %602, double* %32
%603 = getelementptr inbounds [2 x double], [2 x double]* %47, i64 0, i64 1
%604 = load double, double* %603
store double %604, double* %34
%605 = load double, double* %32
%606 = call double @sin(double %605)
%607 = load double, double* %34
%608 = call double @cos(double %607)
%609 = load double, double* %31
%610 = call double @sin(double %609)
%611 = load double, double* %33
%612 = call double @cos(double %611)
%613 = fmul double %610, %612
%614 = fneg double %613
%615 = call double @llvm.fmuladd.f64(double %606, double %608, double %614)
%616 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
store double %615, double* %616
%617 = load double, double* %32
%618 = call double @sin(double %617)
%619 = load double, double* %34
%620 = call double @sin(double %619)
%621 = load double, double* %31
%622 = call double @sin(double %621)
%623 = load double, double* %33
%624 = call double @sin(double %623)
%625 = fmul double %622, %624
%626 = fneg double %625
%627 = call double @llvm.fmuladd.f64(double %618, double %620, double %626)
%628 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
store double %627, double* %628
%629 = load double, double* %32
%630 = call double @cos(double %629)
%631 = load double, double* %31
%632 = call double @cos(double %631)
%633 = fsub double %630, %632
%634 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
store double %633, double* %634
%635 = load double****, double***** %7
%636 = load i32, i32* %26
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double***, double**** %635, i64 %637
%639 = load double***, double**** %638
%640 = load i32, i32* %23
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds double**, double*** %639, i64 %641
%643 = load double**, double*** %642
%644 = load i32, i32* %24
%645 = sext i32 %644 to i64
%646 = getelementptr inbounds double*, double** %643, i64 %645
%647 = load double*, double** %646
%648 = getelementptr inbounds double, double* %647, i64 0
%649 = load double, double* %648
store double %649, double* %35
%650 = load double****, double***** %7
%651 = load i32, i32* %26
%652 = sext i32 %651 to i64
%653 = getelementptr inbounds double***, double**** %650, i64 %652
%654 = load double***, double**** %653
%655 = load i32, i32* %23
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds double**, double*** %654, i64 %656
%658 = load double**, double*** %657
%659 = load i32, i32* %24
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds double*, double** %658, i64 %660
%662 = load double*, double** %661
%663 = getelementptr inbounds double, double* %662, i64 1
%664 = load double, double* %663
store double %664, double* %36
%665 = load double****, double***** %7
%666 = load i32, i32* %25
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds double***, double**** %665, i64 %667
%669 = load double***, double**** %668
%670 = load i32, i32* %23
%671 = sext i32 %670 to i64
%672 = getelementptr inbounds double**, double*** %669, i64 %671
%673 = load double**, double*** %672
%674 = load i32, i32* %24
%675 = sext i32 %674 to i64
%676 = getelementptr inbounds double*, double** %673, i64 %675
%677 = load double*, double** %676
%678 = getelementptr inbounds double, double* %677, i64 0
%679 = load double, double* %678
store double %679, double* %37
%680 = load double****, double***** %7
%681 = load i32, i32* %25
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds double***, double**** %680, i64 %682
%684 = load double***, double**** %683
%685 = load i32, i32* %23
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds double**, double*** %684, i64 %686
%688 = load double**, double*** %687
%689 = load i32, i32* %24
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds double*, double** %688, i64 %690
%692 = load double*, double** %691
%693 = getelementptr inbounds double, double* %692, i64 1
%694 = load double, double* %693
store double %694, double* %38
%695 = load double****, double***** %7
%696 = load i32, i32* %22
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds double***, double**** %695, i64 %697
%699 = load double***, double**** %698
%700 = load i32, i32* %28
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds double**, double*** %699, i64 %701
%703 = load double**, double*** %702
%704 = load i32, i32* %24
%705 = sext i32 %704 to i64
%706 = getelementptr inbounds double*, double** %703, i64 %705
%707 = load double*, double** %706
%708 = getelementptr inbounds double, double* %707, i64 0
%709 = load double, double* %708
store double %709, double* %39
%710 = load double****, double***** %7
%711 = load i32, i32* %22
%712 = sext i32 %711 to i64
%713 = getelementptr inbounds double***, double**** %710, i64 %712
%714 = load double***, double**** %713
%715 = load i32, i32* %28
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds double**, double*** %714, i64 %716
%718 = load double**, double*** %717
%719 = load i32, i32* %24
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds double*, double** %718, i64 %720
%722 = load double*, double** %721
%723 = getelementptr inbounds double, double* %722, i64 1
%724 = load double, double* %723
store double %724, double* %40
%725 = load double****, double***** %7
%726 = load i32, i32* %22
%727 = sext i32 %726 to i64
%728 = getelementptr inbounds double***, double**** %725, i64 %727
%729 = load double***, double**** %728
%730 = load i32, i32* %27
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds double**, double*** %729, i64 %731
%733 = load double**, double*** %732
%734 = load i32, i32* %24
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds double*, double** %733, i64 %735
%737 = load double*, double** %736
%738 = getelementptr inbounds double, double* %737, i64 0
%739 = load double, double* %738
store double %739, double* %41
%740 = load double****, double***** %7
%741 = load i32, i32* %22
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds double***, double**** %740, i64 %742
%744 = load double***, double**** %743
%745 = load i32, i32* %27
%746 = sext i32 %745 to i64
%747 = getelementptr inbounds double**, double*** %744, i64 %746
%748 = load double**, double*** %747
%749 = load i32, i32* %24
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds double*, double** %748, i64 %750
%752 = load double*, double** %751
%753 = getelementptr inbounds double, double* %752, i64 1
%754 = load double, double* %753
store double %754, double* %42
%755 = load double****, double***** %7
%756 = load i32, i32* %22
%757 = sext i32 %756 to i64
%758 = getelementptr inbounds double***, double**** %755, i64 %757
%759 = load double***, double**** %758
%760 = load i32, i32* %23
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds double**, double*** %759, i64 %761
%763 = load double**, double*** %762
%764 = load i32, i32* %30
%765 = sext i32 %764 to i64
%766 = getelementptr inbounds double*, double** %763, i64 %765
%767 = load double*, double** %766
%768 = getelementptr inbounds double, double* %767, i64 0
%769 = load double, double* %768
store double %769, double* %43
%770 = load double****, double***** %7
%771 = load i32, i32* %22
%772 = sext i32 %771 to i64
%773 = getelementptr inbounds double***, double**** %770, i64 %772
%774 = load double***, double**** %773
%775 = load i32, i32* %23
%776 = sext i32 %775 to i64
%777 = getelementptr inbounds double**, double*** %774, i64 %776
%778 = load double**, double*** %777
%779 = load i32, i32* %30
%780 = sext i32 %779 to i64
%781 = getelementptr inbounds double*, double** %778, i64 %780
%782 = load double*, double** %781
%783 = getelementptr inbounds double, double* %782, i64 1
%784 = load double, double* %783
store double %784, double* %44
%785 = load double****, double***** %7
%786 = load i32, i32* %22
%787 = sext i32 %786 to i64
%788 = getelementptr inbounds double***, double**** %785, i64 %787
%789 = load double***, double**** %788
%790 = load i32, i32* %23
%791 = sext i32 %790 to i64
%792 = getelementptr inbounds double**, double*** %789, i64 %791
%793 = load double**, double*** %792
%794 = load i32, i32* %29
%795 = sext i32 %794 to i64
%796 = getelementptr inbounds double*, double** %793, i64 %795
%797 = load double*, double** %796
%798 = getelementptr inbounds double, double* %797, i64 0
%799 = load double, double* %798
store double %799, double* %45
%800 = load double****, double***** %7
%801 = load i32, i32* %22
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds double***, double**** %800, i64 %802
%804 = load double***, double**** %803
%805 = load i32, i32* %23
%806 = sext i32 %805 to i64
%807 = getelementptr inbounds double**, double*** %804, i64 %806
%808 = load double**, double*** %807
%809 = load i32, i32* %29
%810 = sext i32 %809 to i64
%811 = getelementptr inbounds double*, double** %808, i64 %810
%812 = load double*, double** %811
%813 = getelementptr inbounds double, double* %812, i64 1
%814 = load double, double* %813
store double %814, double* %46
%815 = load double, double* %35
%816 = call double @sin(double %815)
%817 = load double, double* %36
%818 = call double @cos(double %817)
%819 = load double, double* %37
%820 = call double @sin(double %819)
%821 = load double, double* %38
%822 = call double @cos(double %821)
%823 = fmul double %820, %822
%824 = call double @llvm.fmuladd.f64(double %816, double %818, double %823)
%825 = load double, double* %39
%826 = call double @sin(double %825)
%827 = load double, double* %42
%828 = call double @cos(double %827)
%829 = call double @llvm.fmuladd.f64(double %826, double %828, double %824)
%830 = load double, double* %41
%831 = call double @sin(double %830)
%832 = load double, double* %42
%833 = call double @cos(double %832)
%834 = call double @llvm.fmuladd.f64(double %831, double %833, double %829)
%835 = load double, double* %43
%836 = call double @sin(double %835)
%837 = load double, double* %44
%838 = call double @cos(double %837)
%839 = call double @llvm.fmuladd.f64(double %836, double %838, double %834)
%840 = load double, double* %45
%841 = call double @sin(double %840)
%842 = load double, double* %46
%843 = call double @cos(double %842)
%844 = call double @llvm.fmuladd.f64(double %841, double %843, double %839)
%845 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 0
store double %844, double* %845
%846 = load double, double* %35
%847 = call double @sin(double %846)
%848 = load double, double* %36
%849 = call double @sin(double %848)
%850 = load double, double* %37
%851 = call double @sin(double %850)
%852 = load double, double* %38
%853 = call double @sin(double %852)
%854 = fmul double %851, %853
%855 = call double @llvm.fmuladd.f64(double %847, double %849, double %854)
%856 = load double, double* %39
%857 = call double @sin(double %856)
%858 = load double, double* %42
%859 = call double @sin(double %858)
%860 = call double @llvm.fmuladd.f64(double %857, double %859, double %855)
%861 = load double, double* %41
%862 = call double @sin(double %861)
%863 = load double, double* %42
%864 = call double @sin(double %863)
%865 = call double @llvm.fmuladd.f64(double %862, double %864, double %860)
%866 = load double, double* %43
%867 = call double @sin(double %866)
%868 = load double, double* %44
%869 = call double @sin(double %868)
%870 = call double @llvm.fmuladd.f64(double %867, double %869, double %865)
%871 = load double, double* %45
%872 = call double @sin(double %871)
%873 = load double, double* %46
%874 = call double @sin(double %873)
%875 = call double @llvm.fmuladd.f64(double %872, double %874, double %870)
%876 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 1
store double %875, double* %876
%877 = load double, double* %35
%878 = call double @cos(double %877)
%879 = load double, double* %37
%880 = call double @cos(double %879)
%881 = fadd double %878, %880
%882 = load double, double* %39
%883 = call double @cos(double %882)
%884 = fadd double %881, %883
%885 = load double, double* %41
%886 = call double @cos(double %885)
%887 = fadd double %884, %886
%888 = load double, double* %43
%889 = call double @cos(double %888)
%890 = fadd double %887, %889
%891 = load double, double* %45
%892 = call double @cos(double %891)
%893 = fadd double %890, %892
%894 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 2
store double %893, double* %894
%895 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 0
%896 = load double, double* %895
%897 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 0
%898 = load double, double* %897
%899 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 1
%900 = load double, double* %899
%901 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 1
%902 = load double, double* %901
%903 = fmul double %900, %902
%904 = call double @llvm.fmuladd.f64(double %896, double %898, double %903)
%905 = getelementptr inbounds [3 x double], [3 x double]* %49, i64 0, i64 2
%906 = load double, double* %905
%907 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 2
%908 = load double, double* %907
%909 = call double @llvm.fmuladd.f64(double %906, double %908, double %904)
store double %909, double* %51
%910 = load double, double* %51
%911 = fmul double -1.000000e+00, %910
store double %911, double* %52
%912 = load double, double* %57
%913 = fadd double %912, 1.000000e+00
store double %913, double* %57
%914 = load double, double* %52
%915 = fcmp ole double %914, 0.000000e+00
br i1 %915, label %916, label %949
916: ; preds = %601
%917 = load double, double* %32
%918 = load double****, double***** %7
%919 = load i32, i32* %22
%920 = sext i32 %919 to i64
%921 = getelementptr inbounds double***, double**** %918, i64 %920
%922 = load double***, double**** %921
%923 = load i32, i32* %23
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds double**, double*** %922, i64 %924
%926 = load double**, double*** %925
%927 = load i32, i32* %24
%928 = sext i32 %927 to i64
%929 = getelementptr inbounds double*, double** %926, i64 %928
%930 = load double*, double** %929
%931 = getelementptr inbounds double, double* %930, i64 0
store double %917, double* %931
%932 = load double, double* %34
%933 = load double****, double***** %7
%934 = load i32, i32* %22
%935 = sext i32 %934 to i64
%936 = getelementptr inbounds double***, double**** %933, i64 %935
%937 = load double***, double**** %936
%938 = load i32, i32* %23
%939 = sext i32 %938 to i64
%940 = getelementptr inbounds double**, double*** %937, i64 %939
%941 = load double**, double*** %940
%942 = load i32, i32* %24
%943 = sext i32 %942 to i64
%944 = getelementptr inbounds double*, double** %941, i64 %943
%945 = load double*, double** %944
%946 = getelementptr inbounds double, double* %945, i64 1
store double %932, double* %946
%947 = load double, double* %56
%948 = fadd double %947, 1.000000e+00
store double %948, double* %56
br label %1000
949: ; preds = %601
%950 = load double, double* %32
%951 = call double @sin(double %950)
%952 = load double, double* %31
%953 = call double @sin(double %952)
%954 = fdiv double %951, %953
%955 = load double, double* %55
%956 = fneg double %955
%957 = load double, double* %52
%958 = fmul double %956, %957
%959 = call double @exp(double %958)
%960 = fmul double %954, %959
store double %960, double* %53
%961 = call i32 (...) @rng()
%962 = sitofp i32 %961 to double
store double %962, double* %54
%963 = load double, double* %54
%964 = load double, double* %53
%965 = fcmp ole double %963, %964
br i1 %965, label %966, label %999
966: ; preds = %949
%967 = load double, double* %32
%968 = load double****, double***** %7
%969 = load i32, i32* %22
%970 = sext i32 %969 to i64
%971 = getelementptr inbounds double***, double**** %968, i64 %970
%972 = load double***, double**** %971
%973 = load i32, i32* %23
%974 = sext i32 %973 to i64
%975 = getelementptr inbounds double**, double*** %972, i64 %974
%976 = load double**, double*** %975
%977 = load i32, i32* %24
%978 = sext i32 %977 to i64
%979 = getelementptr inbounds double*, double** %976, i64 %978
%980 = load double*, double** %979
%981 = getelementptr inbounds double, double* %980, i64 0
store double %967, double* %981
%982 = load double, double* %34
%983 = load double****, double***** %7
%984 = load i32, i32* %22
%985 = sext i32 %984 to i64
%986 = getelementptr inbounds double***, double**** %983, i64 %985
%987 = load double***, double**** %986
%988 = load i32, i32* %23
%989 = sext i32 %988 to i64
%990 = getelementptr inbounds double**, double*** %987, i64 %989
%991 = load double**, double*** %990
%992 = load i32, i32* %24
%993 = sext i32 %992 to i64
%994 = getelementptr inbounds double*, double** %991, i64 %993
%995 = load double*, double** %994
%996 = getelementptr inbounds double, double* %995, i64 1
store double %982, double* %996
%997 = load double, double* %56
%998 = fadd double %997, 1.000000e+00
store double %998, double* %56
br label %999
999: ; preds = %966, %949
br label %1000
1000: ; preds = %999, %916
br label %1001
1001: ; preds = %1000
%1002 = load i32, i32* %20
%1003 = add nsw i32 %1002, 1
store i32 %1003, i32* %20
br label %133
1004: ; preds = %133
br label %1005
1005: ; preds = %1004
%1006 = load i32, i32* %19
%1007 = add nsw i32 %1006, 1
store i32 %1007, i32* %19
br label %129
1008: ; preds = %129
br label %1009
1009: ; preds = %1008
%1010 = load i32, i32* %18
%1011 = add nsw i32 %1010, 1
store i32 %1011, i32* %18
br label %125
1012: ; preds = %125
br label %1013
1013: ; preds = %1012
%1014 = load i32, i32* %17
%1015 = add nsw i32 %1014, 1
store i32 %1015, i32* %17
br label %121
1016: ; preds = %121
br label %1017
1017: ; preds = %1016
%1018 = load i32, i32* %16
%1019 = add nsw i32 %1018, 1
store i32 %1019, i32* %16
br label %117
1020: ; preds = %117
store double 0.000000e+00, double* %75
store double 0.000000e+00, double* %58
store double 0.000000e+00, double* %59
store double 0.000000e+00, double* %60
store i32 0, i32* %18
br label %1021
1021: ; preds = %1394, %1020
%1022 = load i32, i32* %18
%1023 = icmp slt i32 %1022, 24
br i1 %1023, label %1024, label %1397
1024: ; preds = %1021
store i32 0, i32* %19
br label %1025
1025: ; preds = %1390, %1024
%1026 = load i32, i32* %19
%1027 = icmp slt i32 %1026, 24
br i1 %1027, label %1028, label %1393
1028: ; preds = %1025
store i32 0, i32* %20
br label %1029
1029: ; preds = %1386, %1028
%1030 = load i32, i32* %20
%1031 = icmp slt i32 %1030, 24
br i1 %1031, label %1032, label %1389
1032: ; preds = %1029
%1033 = load i32, i32* %18
store i32 %1033, i32* %22
%1034 = load i32, i32* %19
store i32 %1034, i32* %23
%1035 = load i32, i32* %20
store i32 %1035, i32* %24
%1036 = load i32, i32* %22
%1037 = add nsw i32 %1036, 24
%1038 = sub nsw i32 %1037, 1
%1039 = srem i32 %1038, 24
store i32 %1039, i32* %25
%1040 = load i32, i32* %22
%1041 = add nsw i32 %1040, 1
%1042 = srem i32 %1041, 24
store i32 %1042, i32* %26
%1043 = load i32, i32* %23
%1044 = add nsw i32 %1043, 24
%1045 = sub nsw i32 %1044, 1
%1046 = srem i32 %1045, 24
store i32 %1046, i32* %27
%1047 = load i32, i32* %23
%1048 = add nsw i32 %1047, 1
%1049 = srem i32 %1048, 24
store i32 %1049, i32* %28
%1050 = load i32, i32* %24
%1051 = add nsw i32 %1050, 24
%1052 = sub nsw i32 %1051, 1
%1053 = srem i32 %1052, 24
store i32 %1053, i32* %29
%1054 = load i32, i32* %24
%1055 = add nsw i32 %1054, 1
%1056 = srem i32 %1055, 24
store i32 %1056, i32* %30
%1057 = load double****, double***** %7
%1058 = load i32, i32* %22
%1059 = sext i32 %1058 to i64
%1060 = getelementptr inbounds double***, double**** %1057, i64 %1059
%1061 = load double***, double**** %1060
%1062 = load i32, i32* %23
%1063 = sext i32 %1062 to i64
%1064 = getelementptr inbounds double**, double*** %1061, i64 %1063
%1065 = load double**, double*** %1064
%1066 = load i32, i32* %24
%1067 = sext i32 %1066 to i64
%1068 = getelementptr inbounds double*, double** %1065, i64 %1067
%1069 = load double*, double** %1068
%1070 = getelementptr inbounds double, double* %1069, i64 0
%1071 = load double, double* %1070
store double %1071, double* %31
%1072 = load double****, double***** %7
%1073 = load i32, i32* %22
%1074 = sext i32 %1073 to i64
%1075 = getelementptr inbounds double***, double**** %1072, i64 %1074
%1076 = load double***, double**** %1075
%1077 = load i32, i32* %23
%1078 = sext i32 %1077 to i64
%1079 = getelementptr inbounds double**, double*** %1076, i64 %1078
%1080 = load double**, double*** %1079
%1081 = load i32, i32* %24
%1082 = sext i32 %1081 to i64
%1083 = getelementptr inbounds double*, double** %1080, i64 %1082
%1084 = load double*, double** %1083
%1085 = getelementptr inbounds double, double* %1084, i64 1
%1086 = load double, double* %1085
store double %1086, double* %33
%1087 = load double, double* %31
%1088 = call double @sin(double %1087)
%1089 = load double, double* %33
%1090 = call double @cos(double %1089)
%1091 = fmul double %1088, %1090
store double %1091, double* %61
%1092 = load double, double* %31
%1093 = call double @sin(double %1092)
%1094 = load double, double* %33
%1095 = call double @sin(double %1094)
%1096 = fmul double %1093, %1095
store double %1096, double* %62
%1097 = load double, double* %31
%1098 = call double @cos(double %1097)
store double %1098, double* %63
%1099 = load double****, double***** %7
%1100 = load i32, i32* %26
%1101 = sext i32 %1100 to i64
%1102 = getelementptr inbounds double***, double**** %1099, i64 %1101
%1103 = load double***, double**** %1102
%1104 = load i32, i32* %23
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds double**, double*** %1103, i64 %1105
%1107 = load double**, double*** %1106
%1108 = load i32, i32* %24
%1109 = sext i32 %1108 to i64
%1110 = getelementptr inbounds double*, double** %1107, i64 %1109
%1111 = load double*, double** %1110
%1112 = getelementptr inbounds double, double* %1111, i64 0
%1113 = load double, double* %1112
store double %1113, double* %35
%1114 = load double****, double***** %7
%1115 = load i32, i32* %26
%1116 = sext i32 %1115 to i64
%1117 = getelementptr inbounds double***, double**** %1114, i64 %1116
%1118 = load double***, double**** %1117
%1119 = load i32, i32* %23
%1120 = sext i32 %1119 to i64
%1121 = getelementptr inbounds double**, double*** %1118, i64 %1120
%1122 = load double**, double*** %1121
%1123 = load i32, i32* %24
%1124 = sext i32 %1123 to i64
%1125 = getelementptr inbounds double*, double** %1122, i64 %1124
%1126 = load double*, double** %1125
%1127 = getelementptr inbounds double, double* %1126, i64 1
%1128 = load double, double* %1127
store double %1128, double* %36
%1129 = load double****, double***** %7
%1130 = load i32, i32* %25
%1131 = sext i32 %1130 to i64
%1132 = getelementptr inbounds double***, double**** %1129, i64 %1131
%1133 = load double***, double**** %1132
%1134 = load i32, i32* %23
%1135 = sext i32 %1134 to i64
%1136 = getelementptr inbounds double**, double*** %1133, i64 %1135
%1137 = load double**, double*** %1136
%1138 = load i32, i32* %24
%1139 = sext i32 %1138 to i64
%1140 = getelementptr inbounds double*, double** %1137, i64 %1139
%1141 = load double*, double** %1140
%1142 = getelementptr inbounds double, double* %1141, i64 0
%1143 = load double, double* %1142
store double %1143, double* %37
%1144 = load double****, double***** %7
%1145 = load i32, i32* %25
%1146 = sext i32 %1145 to i64
%1147 = getelementptr inbounds double***, double**** %1144, i64 %1146
%1148 = load double***, double**** %1147
%1149 = load i32, i32* %23
%1150 = sext i32 %1149 to i64
%1151 = getelementptr inbounds double**, double*** %1148, i64 %1150
%1152 = load double**, double*** %1151
%1153 = load i32, i32* %24
%1154 = sext i32 %1153 to i64
%1155 = getelementptr inbounds double*, double** %1152, i64 %1154
%1156 = load double*, double** %1155
%1157 = getelementptr inbounds double, double* %1156, i64 1
%1158 = load double, double* %1157
store double %1158, double* %38
%1159 = load double****, double***** %7
%1160 = load i32, i32* %22
%1161 = sext i32 %1160 to i64
%1162 = getelementptr inbounds double***, double**** %1159, i64 %1161
%1163 = load double***, double**** %1162
%1164 = load i32, i32* %28
%1165 = sext i32 %1164 to i64
%1166 = getelementptr inbounds double**, double*** %1163, i64 %1165
%1167 = load double**, double*** %1166
%1168 = load i32, i32* %24
%1169 = sext i32 %1168 to i64
%1170 = getelementptr inbounds double*, double** %1167, i64 %1169
%1171 = load double*, double** %1170
%1172 = getelementptr inbounds double, double* %1171, i64 0
%1173 = load double, double* %1172
store double %1173, double* %39
%1174 = load double****, double***** %7
%1175 = load i32, i32* %22
%1176 = sext i32 %1175 to i64
%1177 = getelementptr inbounds double***, double**** %1174, i64 %1176
%1178 = load double***, double**** %1177
%1179 = load i32, i32* %28
%1180 = sext i32 %1179 to i64
%1181 = getelementptr inbounds double**, double*** %1178, i64 %1180
%1182 = load double**, double*** %1181
%1183 = load i32, i32* %24
%1184 = sext i32 %1183 to i64
%1185 = getelementptr inbounds double*, double** %1182, i64 %1184
%1186 = load double*, double** %1185
%1187 = getelementptr inbounds double, double* %1186, i64 1
%1188 = load double, double* %1187
store double %1188, double* %40
%1189 = load double****, double***** %7
%1190 = load i32, i32* %22
%1191 = sext i32 %1190 to i64
%1192 = getelementptr inbounds double***, double**** %1189, i64 %1191
%1193 = load double***, double**** %1192
%1194 = load i32, i32* %27
%1195 = sext i32 %1194 to i64
%1196 = getelementptr inbounds double**, double*** %1193, i64 %1195
%1197 = load double**, double*** %1196
%1198 = load i32, i32* %24
%1199 = sext i32 %1198 to i64
%1200 = getelementptr inbounds double*, double** %1197, i64 %1199
%1201 = load double*, double** %1200
%1202 = getelementptr inbounds double, double* %1201, i64 0
%1203 = load double, double* %1202
store double %1203, double* %41
%1204 = load double****, double***** %7
%1205 = load i32, i32* %22
%1206 = sext i32 %1205 to i64
%1207 = getelementptr inbounds double***, double**** %1204, i64 %1206
%1208 = load double***, double**** %1207
%1209 = load i32, i32* %27
%1210 = sext i32 %1209 to i64
%1211 = getelementptr inbounds double**, double*** %1208, i64 %1210
%1212 = load double**, double*** %1211
%1213 = load i32, i32* %24
%1214 = sext i32 %1213 to i64
%1215 = getelementptr inbounds double*, double** %1212, i64 %1214
%1216 = load double*, double** %1215
%1217 = getelementptr inbounds double, double* %1216, i64 1
%1218 = load double, double* %1217
store double %1218, double* %42
%1219 = load double****, double***** %7
%1220 = load i32, i32* %22
%1221 = sext i32 %1220 to i64
%1222 = getelementptr inbounds double***, double**** %1219, i64 %1221
%1223 = load double***, double**** %1222
%1224 = load i32, i32* %23
%1225 = sext i32 %1224 to i64
%1226 = getelementptr inbounds double**, double*** %1223, i64 %1225
%1227 = load double**, double*** %1226
%1228 = load i32, i32* %30
%1229 = sext i32 %1228 to i64
%1230 = getelementptr inbounds double*, double** %1227, i64 %1229
%1231 = load double*, double** %1230
%1232 = getelementptr inbounds double, double* %1231, i64 0
%1233 = load double, double* %1232
store double %1233, double* %43
%1234 = load double****, double***** %7
%1235 = load i32, i32* %22
%1236 = sext i32 %1235 to i64
%1237 = getelementptr inbounds double***, double**** %1234, i64 %1236
%1238 = load double***, double**** %1237
%1239 = load i32, i32* %23
%1240 = sext i32 %1239 to i64
%1241 = getelementptr inbounds double**, double*** %1238, i64 %1240
%1242 = load double**, double*** %1241
%1243 = load i32, i32* %30
%1244 = sext i32 %1243 to i64
%1245 = getelementptr inbounds double*, double** %1242, i64 %1244
%1246 = load double*, double** %1245
%1247 = getelementptr inbounds double, double* %1246, i64 1
%1248 = load double, double* %1247
store double %1248, double* %44
%1249 = load double****, double***** %7
%1250 = load i32, i32* %22
%1251 = sext i32 %1250 to i64
%1252 = getelementptr inbounds double***, double**** %1249, i64 %1251
%1253 = load double***, double**** %1252
%1254 = load i32, i32* %23
%1255 = sext i32 %1254 to i64
%1256 = getelementptr inbounds double**, double*** %1253, i64 %1255
%1257 = load double**, double*** %1256
%1258 = load i32, i32* %29
%1259 = sext i32 %1258 to i64
%1260 = getelementptr inbounds double*, double** %1257, i64 %1259
%1261 = load double*, double** %1260
%1262 = getelementptr inbounds double, double* %1261, i64 0
%1263 = load double, double* %1262
store double %1263, double* %45
%1264 = load double****, double***** %7
%1265 = load i32, i32* %22
%1266 = sext i32 %1265 to i64
%1267 = getelementptr inbounds double***, double**** %1264, i64 %1266
%1268 = load double***, double**** %1267
%1269 = load i32, i32* %23
%1270 = sext i32 %1269 to i64
%1271 = getelementptr inbounds double**, double*** %1268, i64 %1270
%1272 = load double**, double*** %1271
%1273 = load i32, i32* %29
%1274 = sext i32 %1273 to i64
%1275 = getelementptr inbounds double*, double** %1272, i64 %1274
%1276 = load double*, double** %1275
%1277 = getelementptr inbounds double, double* %1276, i64 1
%1278 = load double, double* %1277
store double %1278, double* %46
%1279 = load double, double* %35
%1280 = call double @sin(double %1279)
%1281 = load double, double* %36
%1282 = call double @cos(double %1281)
%1283 = load double, double* %37
%1284 = call double @sin(double %1283)
%1285 = load double, double* %38
%1286 = call double @cos(double %1285)
%1287 = fmul double %1284, %1286
%1288 = call double @llvm.fmuladd.f64(double %1280, double %1282, double %1287)
%1289 = load double, double* %39
%1290 = call double @sin(double %1289)
%1291 = load double, double* %40
%1292 = call double @cos(double %1291)
%1293 = call double @llvm.fmuladd.f64(double %1290, double %1292, double %1288)
%1294 = load double, double* %41
%1295 = call double @sin(double %1294)
%1296 = load double, double* %42
%1297 = call double @cos(double %1296)
%1298 = call double @llvm.fmuladd.f64(double %1295, double %1297, double %1293)
%1299 = load double, double* %43
%1300 = call double @sin(double %1299)
%1301 = load double, double* %44
%1302 = call double @cos(double %1301)
%1303 = call double @llvm.fmuladd.f64(double %1300, double %1302, double %1298)
%1304 = load double, double* %45
%1305 = call double @sin(double %1304)
%1306 = load double, double* %46
%1307 = call double @cos(double %1306)
%1308 = call double @llvm.fmuladd.f64(double %1305, double %1307, double %1303)
%1309 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 0
store double %1308, double* %1309
%1310 = load double, double* %35
%1311 = call double @sin(double %1310)
%1312 = load double, double* %36
%1313 = call double @sin(double %1312)
%1314 = load double, double* %37
%1315 = call double @sin(double %1314)
%1316 = load double, double* %38
%1317 = call double @sin(double %1316)
%1318 = fmul double %1315, %1317
%1319 = call double @llvm.fmuladd.f64(double %1311, double %1313, double %1318)
%1320 = load double, double* %39
%1321 = call double @sin(double %1320)
%1322 = load double, double* %40
%1323 = call double @sin(double %1322)
%1324 = call double @llvm.fmuladd.f64(double %1321, double %1323, double %1319)
%1325 = load double, double* %41
%1326 = call double @sin(double %1325)
%1327 = load double, double* %42
%1328 = call double @sin(double %1327)
%1329 = call double @llvm.fmuladd.f64(double %1326, double %1328, double %1324)
%1330 = load double, double* %43
%1331 = call double @sin(double %1330)
%1332 = load double, double* %44
%1333 = call double @sin(double %1332)
%1334 = call double @llvm.fmuladd.f64(double %1331, double %1333, double %1329)
%1335 = load double, double* %45
%1336 = call double @sin(double %1335)
%1337 = load double, double* %46
%1338 = call double @sin(double %1337)
%1339 = call double @llvm.fmuladd.f64(double %1336, double %1338, double %1334)
%1340 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 1
store double %1339, double* %1340
%1341 = load double, double* %35
%1342 = call double @cos(double %1341)
%1343 = load double, double* %37
%1344 = call double @cos(double %1343)
%1345 = fadd double %1342, %1344
%1346 = load double, double* %39
%1347 = call double @cos(double %1346)
%1348 = fadd double %1345, %1347
%1349 = load double, double* %41
%1350 = call double @cos(double %1349)
%1351 = fadd double %1348, %1350
%1352 = load double, double* %43
%1353 = call double @cos(double %1352)
%1354 = fadd double %1351, %1353
%1355 = load double, double* %45
%1356 = call double @cos(double %1355)
%1357 = fadd double %1354, %1356
%1358 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 2
store double %1357, double* %1358
%1359 = load double, double* %61
%1360 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 0
%1361 = load double, double* %1360
%1362 = load double, double* %62
%1363 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 1
%1364 = load double, double* %1363
%1365 = fmul double %1362, %1364
%1366 = call double @llvm.fmuladd.f64(double %1359, double %1361, double %1365)
%1367 = load double, double* %63
%1368 = getelementptr inbounds [3 x double], [3 x double]* %50, i64 0, i64 2
%1369 = load double, double* %1368
%1370 = call double @llvm.fmuladd.f64(double %1367, double %1369, double %1366)
store double %1370, double* %51
%1371 = load double, double* %75
%1372 = load double, double* %51
%1373 = call double @llvm.fmuladd.f64(double -1.000000e+00, double %1372, double %1371)
store double %1373, double* %75
%1374 = load double, double* %61
store double %1374, double* %64
%1375 = load double, double* %62
store double %1375, double* %65
%1376 = load double, double* %63
store double %1376, double* %66
%1377 = load double, double* %64
%1378 = load double, double* %58
%1379 = fadd double %1378, %1377
store double %1379, double* %58
%1380 = load double, double* %65
%1381 = load double, double* %59
%1382 = fadd double %1381, %1380
store double %1382, double* %59
%1383 = load double, double* %66
%1384 = load double, double* %60
%1385 = fadd double %1384, %1383
store double %1385, double* %60
br label %1386
1386: ; preds = %1032
%1387 = load i32, i32* %20
%1388 = add nsw i32 %1387, 1
store i32 %1388, i32* %20
br label %1029
1389: ; preds = %1029
br label %1390
1390: ; preds = %1389
%1391 = load i32, i32* %19
%1392 = add nsw i32 %1391, 1
store i32 %1392, i32* %19
br label %1025
1393: ; preds = %1025
br label %1394
1394: ; preds = %1393
%1395 = load i32, i32* %18
%1396 = add nsw i32 %1395, 1
store i32 %1396, i32* %18
br label %1021
1397: ; preds = %1021
%1398 = load double, double* %75
%1399 = fdiv double %1398, 2.000000e+00
%1400 = load i32, i32* %15
%1401 = sext i32 %1400 to i64
%1402 = getelementptr inbounds double, double* %109, i64 %1401
store double %1399, double* %1402
%1403 = load i32, i32* %15
%1404 = sext i32 %1403 to i64
%1405 = getelementptr inbounds double, double* %109, i64 %1404
%1406 = load double, double* %1405
%1407 = load i32, i32* %15
%1408 = sext i32 %1407 to i64
%1409 = getelementptr inbounds double, double* %109, i64 %1408
%1410 = load double, double* %1409
%1411 = fmul double %1406, %1410
%1412 = load i32, i32* %15
%1413 = sext i32 %1412 to i64
%1414 = getelementptr inbounds double, double* %112, i64 %1413
store double %1411, double* %1414
%1415 = load double, double* %58
%1416 = load i32, i32* %14
%1417 = sitofp i32 %1416 to double
%1418 = fdiv double %1415, %1417
%1419 = load i32, i32* %15
%1420 = sext i32 %1419 to i64
%1421 = getelementptr inbounds double, double* %94, i64 %1420
store double %1418, double* %1421
%1422 = load double, double* %59
%1423 = load i32, i32* %14
%1424 = sitofp i32 %1423 to double
%1425 = fdiv double %1422, %1424
%1426 = load i32, i32* %15
%1427 = sext i32 %1426 to i64
%1428 = getelementptr inbounds double, double* %97, i64 %1427
store double %1425, double* %1428
%1429 = load double, double* %60
%1430 = load i32, i32* %14
%1431 = sitofp i32 %1430 to double
%1432 = fdiv double %1429, %1431
%1433 = load i32, i32* %15
%1434 = sext i32 %1433 to i64
%1435 = getelementptr inbounds double, double* %100, i64 %1434
store double %1432, double* %1435
%1436 = load i32, i32* %15
%1437 = sext i32 %1436 to i64
%1438 = getelementptr inbounds double, double* %94, i64 %1437
%1439 = load double, double* %1438
%1440 = load i32, i32* %15
%1441 = sext i32 %1440 to i64
%1442 = getelementptr inbounds double, double* %94, i64 %1441
%1443 = load double, double* %1442
%1444 = load i32, i32* %15
%1445 = sext i32 %1444 to i64
%1446 = getelementptr inbounds double, double* %97, i64 %1445
%1447 = load double, double* %1446
%1448 = load i32, i32* %15
%1449 = sext i32 %1448 to i64
%1450 = getelementptr inbounds double, double* %97, i64 %1449
%1451 = load double, double* %1450
%1452 = fmul double %1447, %1451
%1453 = call double @llvm.fmuladd.f64(double %1439, double %1443, double %1452)
%1454 = load i32, i32* %15
%1455 = sext i32 %1454 to i64
%1456 = getelementptr inbounds double, double* %100, i64 %1455
%1457 = load double, double* %1456
%1458 = load i32, i32* %15
%1459 = sext i32 %1458 to i64
%1460 = getelementptr inbounds double, double* %100, i64 %1459
%1461 = load double, double* %1460
%1462 = call double @llvm.fmuladd.f64(double %1457, double %1461, double %1453)
%1463 = call double @sqrt(double %1462)
%1464 = load i32, i32* %15
%1465 = sext i32 %1464 to i64
%1466 = getelementptr inbounds double, double* %103, i64 %1465
store double %1463, double* %1466
%1467 = load i32, i32* %15
%1468 = sext i32 %1467 to i64
%1469 = getelementptr inbounds double, double* %103, i64 %1468
%1470 = load double, double* %1469
%1471 = load i32, i32* %15
%1472 = sext i32 %1471 to i64
%1473 = getelementptr inbounds double, double* %103, i64 %1472
%1474 = load double, double* %1473
%1475 = fmul double %1470, %1474
%1476 = load i32, i32* %15
%1477 = sext i32 %1476 to i64
%1478 = getelementptr inbounds double, double* %106, i64 %1477
store double %1475, double* %1478
br label %1479
1479: ; preds = %1397
%1480 = load i32, i32* %15
%1481 = add nsw i32 %1480, 1
store i32 %1481, i32* %15
br label %113
1482: ; preds = %113
store double 0.000000e+00, double* %76
store double 0.000000e+00, double* %77
store double 0.000000e+00, double* %78
store double 0.000000e+00, double* %79
store double 0.000000e+00, double* %80
store double 0.000000e+00, double* %81
store double 0.000000e+00, double* %82
store i32 0, i32* %21
br label %1483
1483: ; preds = %1534, %1482
%1484 = load i32, i32* %21
%1485 = load i32, i32* %13
%1486 = icmp slt i32 %1484, %1485
br i1 %1486, label %1487, label %1537
1487: ; preds = %1483
%1488 = load double, double* %76
%1489 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), double %1488)
%1490 = load i32, i32* %21
%1491 = sext i32 %1490 to i64
%1492 = getelementptr inbounds double, double* %109, i64 %1491
%1493 = load double, double* %1492
%1494 = load double, double* %76
%1495 = fadd double %1494, %1493
store double %1495, double* %76
%1496 = load double, double* %76
%1497 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), double %1496)
%1498 = load i32, i32* %21
%1499 = sext i32 %1498 to i64
%1500 = getelementptr inbounds double, double* %112, i64 %1499
%1501 = load double, double* %1500
%1502 = load double, double* %77
%1503 = fadd double %1502, %1501
store double %1503, double* %77
%1504 = load i32, i32* %21
%1505 = sext i32 %1504 to i64
%1506 = getelementptr inbounds double, double* %103, i64 %1505
%1507 = load double, double* %1506
%1508 = load double, double* %78
%1509 = fadd double %1508, %1507
store double %1509, double* %78
%1510 = load i32, i32* %21
%1511 = sext i32 %1510 to i64
%1512 = getelementptr inbounds double, double* %106, i64 %1511
%1513 = load double, double* %1512
%1514 = load double, double* %79
%1515 = fadd double %1514, %1513
store double %1515, double* %79
%1516 = load i32, i32* %21
%1517 = sext i32 %1516 to i64
%1518 = getelementptr inbounds double, double* %94, i64 %1517
%1519 = load double, double* %1518
%1520 = load double, double* %80
%1521 = fadd double %1520, %1519
store double %1521, double* %80
%1522 = load i32, i32* %21
%1523 = sext i32 %1522 to i64
%1524 = getelementptr inbounds double, double* %97, i64 %1523
%1525 = load double, double* %1524
%1526 = load double, double* %81
%1527 = fadd double %1526, %1525
store double %1527, double* %81
%1528 = load i32, i32* %21
%1529 = sext i32 %1528 to i64
%1530 = getelementptr inbounds double, double* %100, i64 %1529
%1531 = load double, double* %1530
%1532 = load double, double* %82
%1533 = fadd double %1532, %1531
store double %1533, double* %82
br label %1534
1534: ; preds = %1487
%1535 = load i32, i32* %21
%1536 = add nsw i32 %1535, 1
store i32 %1536, i32* %21
br label %1483
1537: ; preds = %1483
%1538 = load double, double* %80
%1539 = load i32, i32* %13
%1540 = sitofp i32 %1539 to double
%1541 = fdiv double %1538, %1540
store double %1541, double* %83
%1542 = load double, double* %81
%1543 = load i32, i32* %13
%1544 = sitofp i32 %1543 to double
%1545 = fdiv double %1542, %1544
store double %1545, double* %84
%1546 = load double, double* %82
%1547 = load i32, i32* %13
%1548 = sitofp i32 %1547 to double
%1549 = fdiv double %1546, %1548
store double %1549, double* %85
%1550 = load double, double* %80
%1551 = load double, double* %80
%1552 = fmul double %1550, %1551
%1553 = load i32, i32* %13
%1554 = sitofp i32 %1553 to double
%1555 = fdiv double %1552, %1554
store double %1555, double* %86
%1556 = load double, double* %80
%1557 = load double, double* %80
%1558 = fmul double %1556, %1557
%1559 = load i32, i32* %13
%1560 = sitofp i32 %1559 to double
%1561 = fdiv double %1558, %1560
store double %1561, double* %87
%1562 = load double, double* %80
%1563 = load double, double* %80
%1564 = fmul double %1562, %1563
%1565 = load i32, i32* %13
%1566 = sitofp i32 %1565 to double
%1567 = fdiv double %1564, %1566
store double %1567, double* %88
%1568 = load double, double* %9
%1569 = load [13 x double]*, [13 x double]** %8
%1570 = load i32, i32* %12
%1571 = sext i32 %1570 to i64
%1572 = getelementptr inbounds [13 x double], [13 x double]* %1569, i64 %1571
%1573 = getelementptr inbounds [13 x double], [13 x double]* %1572, i64 0, i64 0
store double %1568, double* %1573
%1574 = load double, double* %76
%1575 = load i32, i32* %13
%1576 = sitofp i32 %1575 to double
%1577 = fdiv double %1574, %1576
%1578 = load [13 x double]*, [13 x double]** %8
%1579 = load i32, i32* %12
%1580 = sext i32 %1579 to i64
%1581 = getelementptr inbounds [13 x double], [13 x double]* %1578, i64 %1580
%1582 = getelementptr inbounds [13 x double], [13 x double]* %1581, i64 0, i64 1
store double %1577, double* %1582
%1583 = load double, double* %77
%1584 = load i32, i32* %13
%1585 = sitofp i32 %1584 to double
%1586 = fdiv double %1583, %1585
%1587 = load [13 x double]*, [13 x double]** %8
%1588 = load i32, i32* %12
%1589 = sext i32 %1588 to i64
%1590 = getelementptr inbounds [13 x double], [13 x double]* %1587, i64 %1589
%1591 = getelementptr inbounds [13 x double], [13 x double]* %1590, i64 0, i64 2
store double %1586, double* %1591
%1592 = load [13 x double]*, [13 x double]** %8
%1593 = load i32, i32* %12
%1594 = sext i32 %1593 to i64
%1595 = getelementptr inbounds [13 x double], [13 x double]* %1592, i64 %1594
%1596 = getelementptr inbounds [13 x double], [13 x double]* %1595, i64 0, i64 1
%1597 = load double, double* %1596
%1598 = load [13 x double]*, [13 x double]** %8
%1599 = load i32, i32* %12
%1600 = sext i32 %1599 to i64
%1601 = getelementptr inbounds [13 x double], [13 x double]* %1598, i64 %1600
%1602 = getelementptr inbounds [13 x double], [13 x double]* %1601, i64 0, i64 1
%1603 = load double, double* %1602
%1604 = fmul double %1597, %1603
%1605 = load [13 x double]*, [13 x double]** %8
%1606 = load i32, i32* %12
%1607 = sext i32 %1606 to i64
%1608 = getelementptr inbounds [13 x double], [13 x double]* %1605, i64 %1607
%1609 = getelementptr inbounds [13 x double], [13 x double]* %1608, i64 0, i64 3
store double %1604, double* %1609
%1610 = load double, double* %78
%1611 = load i32, i32* %13
%1612 = sitofp i32 %1611 to double
%1613 = fdiv double %1610, %1612
%1614 = load [13 x double]*, [13 x double]** %8
%1615 = load i32, i32* %12
%1616 = sext i32 %1615 to i64
%1617 = getelementptr inbounds [13 x double], [13 x double]* %1614, i64 %1616
%1618 = getelementptr inbounds [13 x double], [13 x double]* %1617, i64 0, i64 4
store double %1613, double* %1618
%1619 = load double, double* %79
%1620 = load i32, i32* %13
%1621 = sitofp i32 %1620 to double
%1622 = fdiv double %1619, %1621
%1623 = load [13 x double]*, [13 x double]** %8
%1624 = load i32, i32* %12
%1625 = sext i32 %1624 to i64
%1626 = getelementptr inbounds [13 x double], [13 x double]* %1623, i64 %1625
%1627 = getelementptr inbounds [13 x double], [13 x double]* %1626, i64 0, i64 5
store double %1622, double* %1627
%1628 = load [13 x double]*, [13 x double]** %8
%1629 = load i32, i32* %12
%1630 = sext i32 %1629 to i64
%1631 = getelementptr inbounds [13 x double], [13 x double]* %1628, i64 %1630
%1632 = getelementptr inbounds [13 x double], [13 x double]* %1631, i64 0, i64 4
%1633 = load double, double* %1632
%1634 = load [13 x double]*, [13 x double]** %8
%1635 = load i32, i32* %12
%1636 = sext i32 %1635 to i64
%1637 = getelementptr inbounds [13 x double], [13 x double]* %1634, i64 %1636
%1638 = getelementptr inbounds [13 x double], [13 x double]* %1637, i64 0, i64 4
%1639 = load double, double* %1638
%1640 = fmul double %1633, %1639
%1641 = load [13 x double]*, [13 x double]** %8
%1642 = load i32, i32* %12
%1643 = sext i32 %1642 to i64
%1644 = getelementptr inbounds [13 x double], [13 x double]* %1641, i64 %1643
%1645 = getelementptr inbounds [13 x double], [13 x double]* %1644, i64 0, i64 6
store double %1640, double* %1645
%1646 = load [13 x double]*, [13 x double]** %8
%1647 = load i32, i32* %12
%1648 = sext i32 %1647 to i64
%1649 = getelementptr inbounds [13 x double], [13 x double]* %1646, i64 %1648
%1650 = getelementptr inbounds [13 x double], [13 x double]* %1649, i64 0, i64 1
%1651 = load double, double* %1650
%1652 = load i32, i32* %14
%1653 = sitofp i32 %1652 to double
%1654 = fdiv double %1651, %1653
%1655 = load [13 x double]*, [13 x double]** %8
%1656 = load i32, i32* %12
%1657 = sext i32 %1656 to i64
%1658 = getelementptr inbounds [13 x double], [13 x double]* %1655, i64 %1657
%1659 = getelementptr inbounds [13 x double], [13 x double]* %1658, i64 0, i64 7
store double %1654, double* %1659
%1660 = load [13 x double]*, [13 x double]** %8
%1661 = load i32, i32* %12
%1662 = sext i32 %1661 to i64
%1663 = getelementptr inbounds [13 x double], [13 x double]* %1660, i64 %1662
%1664 = getelementptr inbounds [13 x double], [13 x double]* %1663, i64 0, i64 4
%1665 = load double, double* %1664
%1666 = load i32, i32* %14
%1667 = sitofp i32 %1666 to double
%1668 = fdiv double %1665, %1667
%1669 = load [13 x double]*, [13 x double]** %8
%1670 = load i32, i32* %12
%1671 = sext i32 %1670 to i64
%1672 = getelementptr inbounds [13 x double], [13 x double]* %1669, i64 %1671
%1673 = getelementptr inbounds [13 x double], [13 x double]* %1672, i64 0, i64 8
store double %1668, double* %1673
%1674 = load [13 x double]*, [13 x double]** %8
%1675 = load i32, i32* %12
%1676 = sext i32 %1675 to i64
%1677 = getelementptr inbounds [13 x double], [13 x double]* %1674, i64 %1676
%1678 = getelementptr inbounds [13 x double], [13 x double]* %1677, i64 0, i64 2
%1679 = load double, double* %1678
%1680 = load [13 x double]*, [13 x double]** %8
%1681 = load i32, i32* %12
%1682 = sext i32 %1681 to i64
%1683 = getelementptr inbounds [13 x double], [13 x double]* %1680, i64 %1682
%1684 = getelementptr inbounds [13 x double], [13 x double]* %1683, i64 0, i64 3
%1685 = load double, double* %1684
%1686 = fsub double %1679, %1685
%1687 = load double, double* %9
%1688 = load double, double* %9
%1689 = fmul double %1687, %1688
%1690 = load i32, i32* %14
%1691 = sitofp i32 %1690 to double
%1692 = fmul double %1689, %1691
%1693 = fdiv double %1686, %1692
%1694 = load [13 x double]*, [13 x double]** %8
%1695 = load i32, i32* %12
%1696 = sext i32 %1695 to i64
%1697 = getelementptr inbounds [13 x double], [13 x double]* %1694, i64 %1696
%1698 = getelementptr inbounds [13 x double], [13 x double]* %1697, i64 0, i64 9
store double %1693, double* %1698
%1699 = load [13 x double]*, [13 x double]** %8
%1700 = load i32, i32* %12
%1701 = sext i32 %1700 to i64
%1702 = getelementptr inbounds [13 x double], [13 x double]* %1699, i64 %1701
%1703 = getelementptr inbounds [13 x double], [13 x double]* %1702, i64 0, i64 9
%1704 = load double, double* %1703
%1705 = load i32, i32* %14
%1706 = sitofp i32 %1705 to double
%1707 = fdiv double %1704, %1706
%1708 = load [13 x double]*, [13 x double]** %8
%1709 = load i32, i32* %12
%1710 = sext i32 %1709 to i64
%1711 = getelementptr inbounds [13 x double], [13 x double]* %1708, i64 %1710
%1712 = getelementptr inbounds [13 x double], [13 x double]* %1711, i64 0, i64 10
store double %1707, double* %1712
%1713 = load double, double* %9
%1714 = fdiv double 1.000000e+00, %1713
%1715 = load double, double* %86
%1716 = load double, double* %87
%1717 = fadd double %1715, %1716
%1718 = load double, double* %88
%1719 = fadd double %1717, %1718
%1720 = load double, double* %83
%1721 = fsub double %1719, %1720
%1722 = load double, double* %84
%1723 = fsub double %1721, %1722
%1724 = load double, double* %85
%1725 = fsub double %1723, %1724
%1726 = fmul double %1714, %1725
%1727 = load [13 x double]*, [13 x double]** %8
%1728 = load i32, i32* %12
%1729 = sext i32 %1728 to i64
%1730 = getelementptr inbounds [13 x double], [13 x double]* %1727, i64 %1729
%1731 = getelementptr inbounds [13 x double], [13 x double]* %1730, i64 0, i64 11
store double %1726, double* %1731
%1732 = load [13 x double]*, [13 x double]** %8
%1733 = load i32, i32* %12
%1734 = sext i32 %1733 to i64
%1735 = getelementptr inbounds [13 x double], [13 x double]* %1732, i64 %1734
%1736 = getelementptr inbounds [13 x double], [13 x double]* %1735, i64 0, i64 11
%1737 = load double, double* %1736
%1738 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %1737)
%1739 = load [13 x double]*, [13 x double]** %8
%1740 = load i32, i32* %12
%1741 = sext i32 %1740 to i64
%1742 = getelementptr inbounds [13 x double], [13 x double]* %1739, i64 %1741
%1743 = getelementptr inbounds [13 x double], [13 x double]* %1742, i64 0, i64 11
%1744 = load double, double* %1743
%1745 = load i32, i32* %14
%1746 = sitofp i32 %1745 to double
%1747 = fdiv double %1744, %1746
%1748 = load [13 x double]*, [13 x double]** %8
%1749 = load i32, i32* %12
%1750 = sext i32 %1749 to i64
%1751 = getelementptr inbounds [13 x double], [13 x double]* %1748, i64 %1750
%1752 = getelementptr inbounds [13 x double], [13 x double]* %1751, i64 0, i64 12
store double %1747, double* %1752
%1753 = load double, double* %56
%1754 = load double, double* %57
%1755 = fdiv double %1753, %1754
%1756 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), double %1755)
%1757 = load i8*, i8** %67
ret void
}

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