void measurement(double ****lattice, double data[][13], double temperature,
                 double ***energy, double ***magnetization, int t) {
  int RUNS_ = (double)250;
  int N_ = (double)64;
  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 < 4; sw1++) {
          for (sw2 = 0; sw2 < 4; sw2++) {
            for (sw3 = 0; sw3 < 4; sw3++) {
              i = sw1;
              j = sw2;
              k = sw3;
              ip = (i + 4 - 1) % 4;
              im = (i + 1) % 4;
              jp = (j + 4 - 1) % 4;
              jm = (j + 1) % 4;
              kp = (k + 4 - 1) % 4;
              km = (k + 1) % 4;
              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 < 4; sw1++) {
      for (sw2 = 0; sw2 < 4; sw2++) {
        for (sw3 = 0; sw3 < 4; sw3++) {
          i = sw1;
          j = sw2;
          k = sw3;
          ip = (i + 4 - 1) % 4;
          im = (i + 1) % 4;
          jp = (j + 4 - 1) % 4;
          jm = (j + 1) % 4;
          kp = (k + 4 - 1) % 4;
          km = (k + 1) % 4;
          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   $0x40,-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   $0x4,-0x44(%rbp)
jge    27a4 <measurement+0x1624>
movl   $0x0,-0x48(%rbp)
cmpl   $0x4,-0x48(%rbp)
jge    2791 <measurement+0x1611>
movl   $0x0,-0x4c(%rbp)
cmpl   $0x4,-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    $0x4,%eax
sub    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x64(%rbp)
mov    -0x58(%rbp),%eax
add    $0x4,%eax
sub    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x68(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x6c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x4,%eax
sub    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x70(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%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   $0x4,-0x44(%rbp)
jge    3053 <measurement+0x1ed3>
movl   $0x0,-0x48(%rbp)
cmpl   $0x4,-0x48(%rbp)
jge    3040 <measurement+0x1ec0>
movl   $0x0,-0x4c(%rbp)
cmpl   $0x4,-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    $0x4,%eax
sub    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x64(%rbp)
mov    -0x58(%rbp),%eax
add    $0x4,%eax
sub    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x68(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x6c(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x4,%eax
sub    $0x1,%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x70(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    $0x4,%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    $0x3808,%rsp
mov    %r8d,0x130(%rsp)
mov    %rsi,0x140(%rsp)
mov    %rdi,%rbp
movsd  0x1e54(%rip),%xmm1
movsd  %xmm0,0x138(%rsp)
divsd  %xmm0,%xmm1
movsd  %xmm1,0x120(%rsp)
xor    %ebx,%ebx
jmp    1200 <measurement+0x80>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
call   1090 <sqrt@plt>
movsd  %xmm0,0x18c0(%rsp,%rbx,8)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10f0(%rsp,%rbx,8)
add    $0x1,%rbx
cmp    $0xfa,%rbx
je     252e <measurement+0x13ae>
mov    %rbx,0x148(%rsp)
mov    $0x1,%eax
jmp    1223 <measurement+0xa3>
nop
mov    0x134(%rsp),%eax
add    $0x1,%eax
cmp    $0x1f,%eax
je     1f00 <measurement+0xd80>
mov    %eax,0x134(%rsp)
xor    %eax,%eax
jmp    1241 <measurement+0xc1>
xchg   %ax,%ax
mov    0x108(%rsp),%eax
add    $0x1,%eax
cmp    $0xfa,%eax
je     1210 <measurement+0x90>
mov    %eax,0x108(%rsp)
xor    %r15d,%r15d
jmp    1261 <measurement+0xe1>
nopl   (%rax)
mov    0x110(%rsp),%rax
mov    %rax,%r15
cmp    $0x4,%rax
je     1230 <measurement+0xb0>
lea    -0x1(%r15),%eax
and    $0x3,%eax
mov    %rax,0x70(%rsp)
lea    0x1(%r15),%rax
mov    %rax,0x110(%rsp)
and    $0x3,%eax
mov    %rax,0xe0(%rsp)
xor    %r14d,%r14d
jmp    12a1 <measurement+0x121>
nopl   0x0(%rax)
mov    0x118(%rsp),%rax
mov    %rax,%r14
cmp    $0x4,%rax
je     1250 <measurement+0xd0>
lea    -0x1(%r14),%eax
and    $0x3,%eax
mov    %rax,0xf0(%rsp)
lea    0x1(%r14),%rax
mov    %rax,0x118(%rsp)
and    $0x3,%eax
mov    %rax,0xe8(%rsp)
mov    $0x3,%r12d
jmp    131c <measurement+0x19c>
nop
mov    0x0(%rbp,%r15,8),%rax
mov    (%rax,%r14,8),%rax
mov    -0x18(%rax,%r12,8),%rax
movaps 0x80(%rsp),%xmm0
movsd  %xmm0,(%rax)
movsd  0xc0(%rsp),%xmm0
movsd  %xmm0,0x8(%rax)
movsd  0xf8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0xf8(%rsp)
add    $0x1,%r12
cmp    $0x7,%r12
je     1290 <measurement+0x110>
mov    %r12d,%r13d
and    $0x3,%r13d
lea    -0x2(%r12),%ebx
and    $0x3,%ebx
mov    0x0(%rbp,%r15,8),%rax
mov    (%rax,%r14,8),%rax
mov    -0x18(%rax,%r12,8),%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,0xd8(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x30(%rsp)
movaps 0x80(%rsp),%xmm0
movhlps %xmm0,%xmm0
movaps %xmm0,0x40(%rsp)
call   1060 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x60(%rsp)
movapd 0x40(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x60(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x30(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x30(%rsp)
movaps 0x40(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x60(%rsp)
movapd 0x40(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x60(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  0x30(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
movaps 0x80(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movapd 0x80(%rsp),%xmm0
call   1060 <cos@plt>
movsd  0x30(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp)
mov    0xe0(%rsp),%rax
mov    0x0(%rbp,%rax,8),%rax
mov    (%rax,%r14,8),%rax
mov    -0x18(%rax,%r12,8),%rax
movsd  (%rax),%xmm1
movsd  %xmm1,0xc0(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x70(%rsp),%rax
mov    0x0(%rbp,%rax,8),%rax
mov    (%rax,%r14,8),%rax
mov    -0x18(%rax,%r12,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0xb0(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xb8(%rsp)
mov    0x0(%rbp,%r15,8),%rax
mov    0xe8(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x18(%rcx,%r12,8),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    0xf0(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x18(%rcx,%r12,8),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0xd0(%rsp)
mov    (%rax,%r14,8),%rax
mov    (%rax,%rbx,8),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    (%rax,%r13,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xc8(%rsp)
movaps %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x98(%rsp)
movsd  0x28(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x128(%rsp)
movsd  0xb8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x128(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
mulsd  0x98(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0x78(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x98(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x98(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x98(%rsp)
movsd  0xd0(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x98(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x58(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x98(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x98(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x60(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x98(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x98(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0xc0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x98(%rsp)
movsd  0x28(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0xb8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x28(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x98(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x78(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xb8(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xb8(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xa0(%rsp)
movsd  0xd0(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xa0(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x58(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xd0(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xd0(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x60(%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  0xb0(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0xb0(%rsp)
movsd  0x78(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0xb0(%rsp),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  0x10(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x78(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x58(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x60(%rsp),%xmm0
call   1060 <cos@plt>
movapd %xmm0,%xmm2
addsd  0x58(%rsp),%xmm2
mulsd  0x30(%rsp),%xmm2
addsd  0x20(%rsp),%xmm2
movsd  0x100(%rsp),%xmm0
movsd  0x177b(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x100(%rsp)
ucomisd 0x1786(%rip),%xmm2
jae    1930 <measurement+0x7b0>
movaps 0x80(%rsp),%xmm0
movsd  %xmm2,0x60(%rsp)
call   1040 <sin@plt>
movsd  %xmm0,0x30(%rsp)
movapd 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  0x30(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp)
movsd  0x60(%rsp),%xmm0
mulsd  0x120(%rsp),%xmm0
call   1050 <exp@plt>
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
xor    %eax,%eax
call   1080 <rng@plt>
movsd  0x16fa(%rip),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x30(%rsp),%xmm2
ucomisd %xmm0,%xmm2
jae    1930 <measurement+0x7b0>
movapd 0x80(%rsp),%xmm0
jmp    1965 <measurement+0x7e5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%rbp,%r15,8),%rax
mov    (%rax,%r14,8),%rax
mov    -0x18(%rax,%r12,8),%rax
movapd 0x80(%rsp),%xmm2
movupd %xmm2,(%rax)
movsd  0xf8(%rsp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0xf8(%rsp)
movapd %xmm2,%xmm0
mov    0xd8(%rsp),%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  %xmm1,0xc0(%rsp)
call   1040 <sin@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0xc0(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x8(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x60(%rsp)
movapd 0x40(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x60(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x30(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x30(%rsp)
movsd  0xc0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x20(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x60(%rsp)
movapd 0x40(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x60(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
mulsd  0x30(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x20(%rsp)
movaps 0x80(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x30(%rsp)
movapd 0x80(%rsp),%xmm0
call   1060 <cos@plt>
movsd  0x30(%rsp),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x30(%rsp)
mov    0xe0(%rsp),%rax
mov    0x0(%rbp,%rax,8),%rax
mov    (%rax,%r14,8),%rax
mov    -0x18(%rax,%r12,8),%rax
movsd  (%rax),%xmm1
movsd  %xmm1,0xc8(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xb8(%rsp)
mov    0x70(%rsp),%rax
mov    0x0(%rbp,%rax,8),%rax
mov    (%rax,%r14,8),%rax
mov    -0x18(%rax,%r12,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0xb0(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    0x0(%rbp,%r15,8),%rax
mov    0xe8(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x18(%rcx,%r12,8),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0xf0(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x18(%rcx,%r12,8),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    (%rax,%r14,8),%rax
mov    (%rax,%rbx,8),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0xd0(%rsp)
mov    (%rax,%r13,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xa8(%rsp)
movaps %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0xb8(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x18(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xd8(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0xd8(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
mulsd  0x28(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%rsp)
movsd  0x78(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x40(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x28(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0x40(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x28(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x58(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0xd0(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x28(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0x60(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x28(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0xb8(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xb8(%rsp)
movsd  0xa0(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xb8(%rsp),%xmm0
movsd  0x8(%rsp),%xmm1
mulsd  0x28(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0x78(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xa0(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xa0(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  0x10(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xa0(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xa0(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x58(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0xd0(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x8(%rsp),%xmm0
addsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x60(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x8(%rsp),%xmm0
addsd  0x40(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x78(%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  0x58(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x60(%rsp),%xmm0
call   1060 <cos@plt>
movapd %xmm0,%xmm2
addsd  0x20(%rsp),%xmm2
mulsd  0x30(%rsp),%xmm2
addsd  0x40(%rsp),%xmm2
movsd  0x100(%rsp),%xmm0
movsd  0x11a7(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x100(%rsp)
ucomisd 0x11b2(%rip),%xmm2
jae    12d0 <measurement+0x150>
movaps 0x80(%rsp),%xmm0
movsd  %xmm2,0x30(%rsp)
call   1040 <sin@plt>
movsd  %xmm0,0x40(%rsp)
movapd 0x80(%rsp),%xmm0
call   1040 <sin@plt>
movsd  0x40(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x40(%rsp)
movsd  0x30(%rsp),%xmm0
mulsd  0x120(%rsp),%xmm0
call   1050 <exp@plt>
mulsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
xor    %eax,%eax
call   1080 <rng@plt>
movsd  0x1126(%rip),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  0x40(%rsp),%xmm2
ucomisd %xmm0,%xmm2
jae    12d0 <measurement+0x150>
jmp    130e <measurement+0x18e>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %r13d,%r13d
xorpd  %xmm1,%xmm1
xorps  %xmm3,%xmm3
xorpd  %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x1(%r13),%eax
and    $0x3,%eax
mov    %rax,0x128(%rsp)
lea    0x1(%r13),%rax
mov    %rax,0x108(%rsp)
and    $0x3,%eax
mov    %rax,0x118(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rbx),%eax
and    $0x3,%eax
mov    %rax,0xd8(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0x110(%rsp)
and    $0x3,%eax
mov    %rax,0x98(%rsp)
mov    $0x3,%r15d
nopl   0x0(%rax,%rax,1)
movsd  %xmm0,0x80(%rsp)
movsd  %xmm3,0xb8(%rsp)
movsd  %xmm2,0xa0(%rsp)
movsd  %xmm1,0xd0(%rsp)
mov    %r15d,%r12d
and    $0x3,%r12d
lea    -0x2(%r15),%r14d
and    $0x3,%r14d
mov    0x0(%rbp,%r13,8),%rax
mov    (%rax,%rbx,8),%rax
mov    -0x18(%rax,%r15,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x8(%rax),%xmm1
movsd  %xmm1,0x30(%rsp)
call   1040 <sin@plt>
movsd  %xmm0,0x60(%rsp)
movsd  0x30(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x60(%rsp)
movsd  0x30(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0xe8(%rsp)
movsd  0x40(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0xf0(%rsp)
mov    0x118(%rsp),%rax
mov    0x0(%rbp,%rax,8),%rax
mov    (%rax,%rbx,8),%rax
mov    -0x18(%rax,%r15,8),%rax
movsd  (%rax),%xmm1
movsd  %xmm1,0x78(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xa8(%rsp)
mov    0x128(%rsp),%rax
mov    0x0(%rbp,%rax,8),%rax
mov    (%rax,%rbx,8),%rax
mov    -0x18(%rax,%r15,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xc8(%rsp)
mov    0x0(%rbp,%r13,8),%rax
mov    0x98(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x18(%rcx,%r15,8),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0xc0(%rsp)
mov    0xd8(%rsp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x18(%rcx,%r15,8),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    (%rax,%rbx,8),%rax
mov    (%rax,%r14,8),%rcx
movsd  (%rcx),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x8(%rcx),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    (%rax,%r12,8),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  0x8(%rax),%xmm0
movsd  %xmm0,0xb0(%rsp)
movaps %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x70(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x58(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xe0(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1060 <cos@plt>
mulsd  0xe0(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0x70(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,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  0x60(%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  0x30(%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,0x10(%rsp)
movsd  0x40(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x70(%rsp)
movsd  0xb0(%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,0xe0(%rsp)
movsd  0xa8(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x10(%rsp)
movsd  0x58(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0xa8(%rsp)
movsd  0xc8(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0xa8(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mulsd  0xe0(%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,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  0x60(%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  0x30(%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  0x40(%rsp),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,0x8(%rsp)
movsd  0xb0(%rsp),%xmm0
call   1040 <sin@plt>
mulsd  0x8(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x78(%rsp),%xmm0
call   1060 <cos@plt>
movsd  %xmm0,0x78(%rsp)
movsd  0x58(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x78(%rsp),%xmm0
movsd  %xmm0,0x58(%rsp)
movsd  0x20(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x58(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
movsd  0x60(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x60(%rsp)
movsd  0x30(%rsp),%xmm0
call   1060 <cos@plt>
addsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x40(%rsp),%xmm0
call   1060 <cos@plt>
movsd  0xb8(%rsp),%xmm3
movsd  0xa0(%rsp),%xmm2
movsd  0xd0(%rsp),%xmm1
addsd  0x30(%rsp),%xmm0
movsd  0xe8(%rsp),%xmm6
movsd  0x10(%rsp),%xmm7
mulsd  %xmm6,%xmm7
movsd  0x28(%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,%r15
cmp    $0x7,%r15
jne    1f80 <measurement+0xe00>
mov    0x110(%rsp),%rax
mov    %rax,%rbx
cmp    $0x4,%rax
jne    1f50 <measurement+0xdd0>
mov    0x108(%rsp),%rax
mov    %rax,%r13
cmp    $0x4,%rax
jne    1f20 <measurement+0xda0>
mulsd  0xb55(%rip),%xmm0
mov    0x148(%rsp),%rbx
movsd  %xmm0,0x920(%rsp,%rbx,8)
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x150(%rsp,%rbx,8)
movsd  0xb37(%rip),%xmm0
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x3030(%rsp,%rbx,8)
mulsd  %xmm0,%xmm3
movsd  %xmm3,0x2860(%rsp,%rbx,8)
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x2090(%rsp,%rbx,8)
mulsd  %xmm3,%xmm3
mulsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
ucomisd 0xb04(%rip),%xmm1
jb     11d0 <measurement+0x50>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    11d9 <measurement+0x59>
xorpd  %xmm2,%xmm2
xorpd  %xmm0,%xmm0
movapd %xmm0,0x80(%rsp)
xor    %ebx,%ebx
lea    0xaf8(%rip),%r14
lea    0xafd(%rip),%rbp
xorpd  %xmm6,%xmm6
xorpd  %xmm3,%xmm3
nopw   0x0(%rax,%rax,1)
movapd %xmm3,0x60(%rsp)
movapd %xmm2,0x30(%rsp)
movapd %xmm6,0x40(%rsp)
mov    %r14,%rdi
movaps 0x80(%rsp),%xmm0
mov    $0x1,%al
call   1030 <printf@plt>
movapd 0x80(%rsp),%xmm0
addsd  0x920(%rsp,%rbx,1),%xmm0
mov    %rbp,%rdi
movapd %xmm0,0x80(%rsp)
mov    $0x1,%al
call   1030 <printf@plt>
movapd 0x60(%rsp),%xmm3
movapd 0x30(%rsp),%xmm2
movapd 0x40(%rsp),%xmm6
movsd  0x18c0(%rsp,%rbx,1),%xmm0
movhpd 0x10f0(%rsp,%rbx,1),%xmm0
movsd  0x3030(%rsp,%rbx,1),%xmm1
movhpd 0x150(%rsp,%rbx,1),%xmm1
addpd  %xmm0,%xmm2
movsd  0x2860(%rsp,%rbx,1),%xmm0
movhpd 0x2090(%rsp,%rbx,1),%xmm0
addpd  %xmm1,%xmm3
addpd  %xmm0,%xmm6
add    $0x8,%rbx
cmp    $0x7d0,%rbx
jne    2560 <measurement+0x13e0>
movapd 0xa1a(%rip),%xmm1
divpd  %xmm1,%xmm6
movapd %xmm3,%xmm0
mulpd  %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
divpd  %xmm1,%xmm0
movslq 0x130(%rsp),%rax
imul   $0x68,%rax,%rbx
mov    0x140(%rsp),%rbp
movsd  0x138(%rsp),%xmm5
movsd  %xmm5,0x0(%rbp,%rbx,1)
movapd 0x80(%rsp),%xmm7
shufpd $0x2,%xmm3,%xmm7
divpd  %xmm1,%xmm7
movupd %xmm7,0x8(%rbp,%rbx,1)
movapd %xmm7,%xmm8
mulsd  %xmm7,%xmm8
movsd  %xmm8,0x18(%rbp,%rbx,1)
divpd  %xmm1,%xmm2
movupd %xmm2,0x20(%rbp,%rbx,1)
movapd %xmm2,%xmm1
unpcklpd %xmm7,%xmm1
movapd %xmm2,%xmm3
movsd  0x97c(%rip),%xmm4
unpcklpd %xmm4,%xmm3
mulpd  %xmm1,%xmm3
movupd %xmm3,0x30(%rbp,%rbx,1)
mulsd  %xmm4,%xmm2
movsd  %xmm2,0x40(%rbp,%rbx,1)
unpckhpd %xmm7,%xmm7
subsd  %xmm8,%xmm7
mulsd  %xmm5,%xmm5
mulsd  0x957(%rip),%xmm5
divsd  %xmm5,%xmm7
movsd  %xmm7,0x48(%rbp,%rbx,1)
mulsd  %xmm4,%xmm7
movsd  %xmm7,0x50(%rbp,%rbx,1)
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
subsd  %xmm0,%xmm1
subsd  %xmm6,%xmm1
unpckhpd %xmm6,%xmm6
subsd  %xmm6,%xmm1
movsd  0x120(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,0x58(%rbp,%rbx,1)
lea    0x949(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  0x8f2(%rip),%xmm0
mulsd  0x58(%rbp,%rbx,1),%xmm0
movsd  %xmm0,0x60(%rbp,%rbx,1)
movsd  0xf8(%rsp),%xmm0
divsd  0x100(%rsp),%xmm0
lea    0x91e(%rip),%rdi
mov    $0x1,%al
add    $0x3808,%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 64, 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, 4
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, 4
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, 4
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, 4
%142 = sub nsw i32 %141, 1
%143 = srem i32 %142, 4
store i32 %143, i32* %25
%144 = load i32, i32* %22
%145 = add nsw i32 %144, 1
%146 = srem i32 %145, 4
store i32 %146, i32* %26
%147 = load i32, i32* %23
%148 = add nsw i32 %147, 4
%149 = sub nsw i32 %148, 1
%150 = srem i32 %149, 4
store i32 %150, i32* %27
%151 = load i32, i32* %23
%152 = add nsw i32 %151, 1
%153 = srem i32 %152, 4
store i32 %153, i32* %28
%154 = load i32, i32* %24
%155 = add nsw i32 %154, 4
%156 = sub nsw i32 %155, 1
%157 = srem i32 %156, 4
store i32 %157, i32* %29
%158 = load i32, i32* %24
%159 = add nsw i32 %158, 1
%160 = srem i32 %159, 4
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, 4
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, 4
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, 4
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, 4
%1038 = sub nsw i32 %1037, 1
%1039 = srem i32 %1038, 4
store i32 %1039, i32* %25
%1040 = load i32, i32* %22
%1041 = add nsw i32 %1040, 1
%1042 = srem i32 %1041, 4
store i32 %1042, i32* %26
%1043 = load i32, i32* %23
%1044 = add nsw i32 %1043, 4
%1045 = sub nsw i32 %1044, 1
%1046 = srem i32 %1045, 4
store i32 %1046, i32* %27
%1047 = load i32, i32* %23
%1048 = add nsw i32 %1047, 1
%1049 = srem i32 %1048, 4
store i32 %1049, i32* %28
%1050 = load i32, i32* %24
%1051 = add nsw i32 %1050, 4
%1052 = sub nsw i32 %1051, 1
%1053 = srem i32 %1052, 4
store i32 %1053, i32* %29
%1054 = load i32, i32* %24
%1055 = add nsw i32 %1054, 1
%1056 = srem i32 %1055, 4
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, %489
%16 = phi i64 [ 0, %6 ], [ %507, %489 ]
%17 = phi double [ undef, %6 ], [ %306, %489 ]
%18 = phi double [ undef, %6 ], [ %327, %489 ]
br label %19
19: ; preds = %15, %336
%20 = phi i32 [ 1, %15 ], [ %337, %336 ]
%21 = phi double [ %17, %15 ], [ %306, %336 ]
%22 = phi double [ %18, %15 ], [ %327, %336 ]
br label %23
23: ; preds = %19, %333
%24 = phi i32 [ 0, %19 ], [ %334, %333 ]
%25 = phi double [ %21, %19 ], [ %306, %333 ]
%26 = phi double [ %22, %19 ], [ %327, %333 ]
br label %27
27: ; preds = %23, %331
%28 = phi i64 [ 0, %23 ], [ %33, %331 ]
%29 = phi double [ %25, %23 ], [ %306, %331 ]
%30 = phi double [ %26, %23 ], [ %327, %331 ]
%31 = add nuw i64 %28, 3
%32 = and i64 %31, 3
%33 = add nuw nsw i64 %28, 1
%34 = and i64 %33, 3
%35 = getelementptr inbounds double***, double**** %0, i64 %28
%36 = getelementptr inbounds double***, double**** %0, i64 %34
%37 = getelementptr inbounds double***, double**** %0, i64 %32
br label %38
38: ; preds = %27, %329
%39 = phi i64 [ 0, %27 ], [ %44, %329 ]
%40 = phi double [ %29, %27 ], [ %306, %329 ]
%41 = phi double [ %30, %27 ], [ %327, %329 ]
%42 = add nuw i64 %39, 3
%43 = and i64 %42, 3
%44 = add nuw nsw i64 %39, 1
%45 = and i64 %44, 3
br label %46
46: ; preds = %38, %326
%47 = phi i64 [ 0, %38 ], [ %52, %326 ]
%48 = phi double [ %40, %38 ], [ %306, %326 ]
%49 = phi double [ %41, %38 ], [ %327, %326 ]
%50 = add nuw i64 %47, 3
%51 = and i64 %50, 3
%52 = add nuw nsw i64 %47, 1
%53 = and i64 %52, 3
%54 = load double***, double**** %35
%55 = getelementptr inbounds double**, double*** %54, i64 %39
%56 = load double**, double*** %55
%57 = getelementptr inbounds double*, double** %56, i64 %47
%58 = bitcast double** %57 to <2 x double>**
%59 = load <2 x double>*, <2 x double>** %58
%60 = load <2 x double>, <2 x double>* %59
%61 = tail call i32 (...) @rng_theta()
%62 = tail call i32 (...) @rng_phi()
%63 = sitofp i32 %62 to double
%64 = extractelement <2 x double> %60, i64 0
%65 = tail call double @sin(double %64)
%66 = extractelement <2 x double> %60, i64 1
%67 = tail call double @cos(double %66)
%68 = tail call double @sin(double %64)
%69 = tail call double @cos(double %66)
%70 = fneg double %68
%71 = fmul double %69, %70
%72 = tail call double @llvm.fmuladd.f64(double %65, double %67, double %71)
%73 = tail call double @sin(double %64)
%74 = tail call double @sin(double %66)
%75 = tail call double @sin(double %64)
%76 = tail call double @sin(double %66)
%77 = fneg double %75
%78 = fmul double %76, %77
%79 = tail call double @llvm.fmuladd.f64(double %73, double %74, double %78)
%80 = tail call double @cos(double %64)
%81 = tail call double @cos(double %64)
%82 = fsub double %80, %81
%83 = load double***, double**** %36
%84 = getelementptr inbounds double**, double*** %83, i64 %39
%85 = load double**, double*** %84
%86 = getelementptr inbounds double*, double** %85, i64 %47
%87 = load double*, double** %86
%88 = load double, double* %87
%89 = getelementptr inbounds double, double* %87, i64 1
%90 = load double, double* %89
%91 = load double***, double**** %37
%92 = getelementptr inbounds double**, double*** %91, i64 %39
%93 = load double**, double*** %92
%94 = getelementptr inbounds double*, double** %93, i64 %47
%95 = load double*, double** %94
%96 = load double, double* %95
%97 = getelementptr inbounds double, double* %95, i64 1
%98 = load double, double* %97
%99 = load double***, double**** %35
%100 = getelementptr inbounds double**, double*** %99, i64 %45
%101 = load double**, double*** %100
%102 = getelementptr inbounds double*, double** %101, i64 %47
%103 = load double*, double** %102
%104 = load double, double* %103
%105 = getelementptr inbounds double, double* %103, i64 1
%106 = load double, double* %105
%107 = getelementptr inbounds double**, double*** %99, i64 %43
%108 = load double**, double*** %107
%109 = getelementptr inbounds double*, double** %108, i64 %47
%110 = load double*, double** %109
%111 = load double, double* %110
%112 = getelementptr inbounds double, double* %110, i64 1
%113 = load double, double* %112
%114 = getelementptr inbounds double**, double*** %99, i64 %39
%115 = load double**, double*** %114
%116 = getelementptr inbounds double*, double** %115, i64 %53
%117 = load double*, double** %116
%118 = load double, double* %117
%119 = getelementptr inbounds double, double* %117, i64 1
%120 = load double, double* %119
%121 = getelementptr inbounds double*, double** %115, i64 %51
%122 = load double*, double** %121
%123 = load double, double* %122
%124 = getelementptr inbounds double, double* %122, i64 1
%125 = load double, double* %124
%126 = tail call double @sin(double %88)
%127 = tail call double @cos(double %90)
%128 = tail call double @sin(double %96)
%129 = tail call double @cos(double %98)
%130 = fmul double %128, %129
%131 = tail call double @llvm.fmuladd.f64(double %126, double %127, double %130)
%132 = tail call double @sin(double %104)
%133 = tail call double @cos(double %106)
%134 = tail call double @llvm.fmuladd.f64(double %132, double %133, double %131)
%135 = tail call double @sin(double %111)
%136 = tail call double @cos(double %113)
%137 = tail call double @llvm.fmuladd.f64(double %135, double %136, double %134)
%138 = tail call double @sin(double %118)
%139 = tail call double @cos(double %120)
%140 = tail call double @llvm.fmuladd.f64(double %138, double %139, double %137)
%141 = tail call double @sin(double %123)
%142 = tail call double @cos(double %125)
%143 = tail call double @llvm.fmuladd.f64(double %141, double %142, double %140)
%144 = tail call double @sin(double %88)
%145 = tail call double @sin(double %90)
%146 = tail call double @sin(double %96)
%147 = tail call double @sin(double %98)
%148 = fmul double %146, %147
%149 = tail call double @llvm.fmuladd.f64(double %144, double %145, double %148)
%150 = tail call double @sin(double %104)
%151 = tail call double @sin(double %106)
%152 = tail call double @llvm.fmuladd.f64(double %150, double %151, double %149)
%153 = tail call double @sin(double %111)
%154 = tail call double @sin(double %113)
%155 = tail call double @llvm.fmuladd.f64(double %153, double %154, double %152)
%156 = tail call double @sin(double %118)
%157 = tail call double @sin(double %120)
%158 = tail call double @llvm.fmuladd.f64(double %156, double %157, double %155)
%159 = tail call double @sin(double %123)
%160 = tail call double @sin(double %125)
%161 = tail call double @llvm.fmuladd.f64(double %159, double %160, double %158)
%162 = tail call double @cos(double %88)
%163 = tail call double @cos(double %96)
%164 = fadd double %162, %163
%165 = tail call double @cos(double %104)
%166 = fadd double %164, %165
%167 = tail call double @cos(double %111)
%168 = fadd double %166, %167
%169 = tail call double @cos(double %118)
%170 = fadd double %168, %169
%171 = tail call double @cos(double %123)
%172 = fadd double %170, %171
%173 = fmul double %79, %161
%174 = tail call double @llvm.fmuladd.f64(double %72, double %143, double %173)
%175 = tail call double @llvm.fmuladd.f64(double %82, double %172, double %174)
%176 = fadd double %48, 1.000000e+00
%177 = fcmp ult double %175, 0.000000e+00
br i1 %177, label %178, label %188
178: ; preds = %46
%179 = tail call double @sin(double %64)
%180 = tail call double @sin(double %64)
%181 = fdiv double %179, %180
%182 = fmul double %7, %175
%183 = tail call double @exp(double %182)
%184 = fmul double %181, %183
%185 = tail call i32 (...) @rng()
%186 = sitofp i32 %185 to double
%187 = fcmp ult double %184, %186
br i1 %187, label %196, label %188
188: ; preds = %178, %46
%189 = load double***, double**** %35
%190 = getelementptr inbounds double**, double*** %189, i64 %39
%191 = load double**, double*** %190
%192 = getelementptr inbounds double*, double** %191, i64 %47
%193 = bitcast double** %192 to <2 x double>**
%194 = load <2 x double>*, <2 x double>** %193
store <2 x double> %60, <2 x double>* %194
%195 = fadd double %49, 1.000000e+00
br label %196
196: ; preds = %188, %178
%197 = phi double [ %49, %178 ], [ %195, %188 ]
%198 = tail call double @sin(double %64)
%199 = tail call double @cos(double %63)
%200 = tail call double @sin(double %64)
%201 = tail call double @cos(double %66)
%202 = fneg double %200
%203 = fmul double %201, %202
%204 = tail call double @llvm.fmuladd.f64(double %198, double %199, double %203)
%205 = tail call double @sin(double %64)
%206 = tail call double @sin(double %63)
%207 = tail call double @sin(double %64)
%208 = tail call double @sin(double %66)
%209 = fneg double %207
%210 = fmul double %208, %209
%211 = tail call double @llvm.fmuladd.f64(double %205, double %206, double %210)
%212 = tail call double @cos(double %64)
%213 = tail call double @cos(double %64)
%214 = fsub double %212, %213
%215 = load double***, double**** %36
%216 = getelementptr inbounds double**, double*** %215, i64 %39
%217 = load double**, double*** %216
%218 = getelementptr inbounds double*, double** %217, i64 %47
%219 = load double*, double** %218
%220 = load double, double* %219
%221 = getelementptr inbounds double, double* %219, i64 1
%222 = load double, double* %221
%223 = load double***, double**** %37
%224 = getelementptr inbounds double**, double*** %223, i64 %39
%225 = load double**, double*** %224
%226 = getelementptr inbounds double*, double** %225, i64 %47
%227 = load double*, double** %226
%228 = load double, double* %227
%229 = getelementptr inbounds double, double* %227, i64 1
%230 = load double, double* %229
%231 = load double***, double**** %35
%232 = getelementptr inbounds double**, double*** %231, i64 %45
%233 = load double**, double*** %232
%234 = getelementptr inbounds double*, double** %233, i64 %47
%235 = load double*, double** %234
%236 = load double, double* %235
%237 = getelementptr inbounds double**, double*** %231, i64 %43
%238 = load double**, double*** %237
%239 = getelementptr inbounds double*, double** %238, i64 %47
%240 = load double*, double** %239
%241 = load double, double* %240
%242 = getelementptr inbounds double, double* %240, i64 1
%243 = load double, double* %242
%244 = getelementptr inbounds double**, double*** %231, i64 %39
%245 = load double**, double*** %244
%246 = getelementptr inbounds double*, double** %245, i64 %53
%247 = load double*, double** %246
%248 = load double, double* %247
%249 = getelementptr inbounds double, double* %247, i64 1
%250 = load double, double* %249
%251 = getelementptr inbounds double*, double** %245, i64 %51
%252 = load double*, double** %251
%253 = load double, double* %252
%254 = getelementptr inbounds double, double* %252, i64 1
%255 = load double, double* %254
%256 = tail call double @sin(double %220)
%257 = tail call double @cos(double %222)
%258 = tail call double @sin(double %228)
%259 = tail call double @cos(double %230)
%260 = fmul double %258, %259
%261 = tail call double @llvm.fmuladd.f64(double %256, double %257, double %260)
%262 = tail call double @sin(double %236)
%263 = tail call double @cos(double %243)
%264 = tail call double @llvm.fmuladd.f64(double %262, double %263, double %261)
%265 = tail call double @sin(double %241)
%266 = tail call double @cos(double %243)
%267 = tail call double @llvm.fmuladd.f64(double %265, double %266, double %264)
%268 = tail call double @sin(double %248)
%269 = tail call double @cos(double %250)
%270 = tail call double @llvm.fmuladd.f64(double %268, double %269, double %267)
%271 = tail call double @sin(double %253)
%272 = tail call double @cos(double %255)
%273 = tail call double @llvm.fmuladd.f64(double %271, double %272, double %270)
%274 = tail call double @sin(double %220)
%275 = tail call double @sin(double %222)
%276 = tail call double @sin(double %228)
%277 = tail call double @sin(double %230)
%278 = fmul double %276, %277
%279 = tail call double @llvm.fmuladd.f64(double %274, double %275, double %278)
%280 = tail call double @sin(double %236)
%281 = tail call double @sin(double %243)
%282 = tail call double @llvm.fmuladd.f64(double %280, double %281, double %279)
%283 = tail call double @sin(double %241)
%284 = tail call double @sin(double %243)
%285 = tail call double @llvm.fmuladd.f64(double %283, double %284, double %282)
%286 = tail call double @sin(double %248)
%287 = tail call double @sin(double %250)
%288 = tail call double @llvm.fmuladd.f64(double %286, double %287, double %285)
%289 = tail call double @sin(double %253)
%290 = tail call double @sin(double %255)
%291 = tail call double @llvm.fmuladd.f64(double %289, double %290, double %288)
%292 = tail call double @cos(double %220)
%293 = tail call double @cos(double %228)
%294 = fadd double %292, %293
%295 = tail call double @cos(double %236)
%296 = fadd double %294, %295
%297 = tail call double @cos(double %241)
%298 = fadd double %296, %297
%299 = tail call double @cos(double %248)
%300 = fadd double %298, %299
%301 = tail call double @cos(double %253)
%302 = fadd double %300, %301
%303 = fmul double %211, %291
%304 = tail call double @llvm.fmuladd.f64(double %204, double %273, double %303)
%305 = tail call double @llvm.fmuladd.f64(double %214, double %302, double %304)
%306 = fadd double %176, 1.000000e+00
%307 = fcmp ult double %305, 0.000000e+00
br i1 %307, label %308, label %318
308: ; preds = %196
%309 = tail call double @sin(double %64)
%310 = tail call double @sin(double %64)
%311 = fdiv double %309, %310
%312 = fmul double %7, %305
%313 = tail call double @exp(double %312)
%314 = fmul double %311, %313
%315 = tail call i32 (...) @rng()
%316 = sitofp i32 %315 to double
%317 = fcmp ult double %314, %316
br i1 %317, label %326, label %318
318: ; preds = %308, %196
%319 = load double***, double**** %35
%320 = getelementptr inbounds double**, double*** %319, i64 %39
%321 = load double**, double*** %320
%322 = getelementptr inbounds double*, double** %321, i64 %47
%323 = load double*, double** %322
store double %64, double* %323
%324 = getelementptr inbounds double, double* %323, i64 1
store double %63, double* %324
%325 = fadd double %197, 1.000000e+00
br label %326
326: ; preds = %318, %308
%327 = phi double [ %197, %308 ], [ %325, %318 ]
%328 = icmp eq i64 %52, 4
br i1 %328, label %329, label %46
329: ; preds = %326
%330 = icmp eq i64 %44, 4
br i1 %330, label %331, label %38
331: ; preds = %329
%332 = icmp eq i64 %33, 4
br i1 %332, label %333, label %27
333: ; preds = %331
%334 = add nuw nsw i32 %24, 1
%335 = icmp eq i32 %334, 250
br i1 %335, label %336, label %23
336: ; preds = %333
%337 = add nuw nsw i32 %20, 1
%338 = icmp eq i32 %337, 31
br i1 %338, label %339, label %19
339: ; preds = %336, %487
%340 = phi i64 [ %347, %487 ], [ 0, %336 ]
%341 = phi double [ %480, %487 ], [ 0.000000e+00, %336 ]
%342 = phi double [ %483, %487 ], [ 0.000000e+00, %336 ]
%343 = phi double [ %482, %487 ], [ 0.000000e+00, %336 ]
%344 = phi double [ %481, %487 ], [ 0.000000e+00, %336 ]
%345 = add nuw i64 %340, 3
%346 = and i64 %345, 3
%347 = add nuw nsw i64 %340, 1
%348 = and i64 %347, 3
%349 = getelementptr inbounds double***, double**** %0, i64 %340
%350 = getelementptr inbounds double***, double**** %0, i64 %348
%351 = getelementptr inbounds double***, double**** %0, i64 %346
br label %352
352: ; preds = %339, %485
%353 = phi i64 [ 0, %339 ], [ %360, %485 ]
%354 = phi double [ %341, %339 ], [ %480, %485 ]
%355 = phi double [ %342, %339 ], [ %483, %485 ]
%356 = phi double [ %343, %339 ], [ %482, %485 ]
%357 = phi double [ %344, %339 ], [ %481, %485 ]
%358 = add nuw i64 %353, 3
%359 = and i64 %358, 3
%360 = add nuw nsw i64 %353, 1
%361 = and i64 %360, 3
br label %362
362: ; preds = %352, %362
%363 = phi i64 [ 0, %352 ], [ %370, %362 ]
%364 = phi double [ %354, %352 ], [ %480, %362 ]
%365 = phi double [ %355, %352 ], [ %483, %362 ]
%366 = phi double [ %356, %352 ], [ %482, %362 ]
%367 = phi double [ %357, %352 ], [ %481, %362 ]
%368 = add nuw i64 %363, 3
%369 = and i64 %368, 3
%370 = add nuw nsw i64 %363, 1
%371 = and i64 %370, 3
%372 = load double***, double**** %349
%373 = getelementptr inbounds double**, double*** %372, i64 %353
%374 = load double**, double*** %373
%375 = getelementptr inbounds double*, double** %374, i64 %363
%376 = load double*, double** %375
%377 = load double, double* %376
%378 = getelementptr inbounds double, double* %376, i64 1
%379 = load double, double* %378
%380 = tail call double @sin(double %377)
%381 = tail call double @cos(double %379)
%382 = fmul double %380, %381
%383 = tail call double @sin(double %377)
%384 = tail call double @sin(double %379)
%385 = fmul double %383, %384
%386 = tail call double @cos(double %377)
%387 = load double***, double**** %350
%388 = getelementptr inbounds double**, double*** %387, i64 %353
%389 = load double**, double*** %388
%390 = getelementptr inbounds double*, double** %389, i64 %363
%391 = load double*, double** %390
%392 = load double, double* %391
%393 = getelementptr inbounds double, double* %391, i64 1
%394 = load double, double* %393
%395 = load double***, double**** %351
%396 = getelementptr inbounds double**, double*** %395, i64 %353
%397 = load double**, double*** %396
%398 = getelementptr inbounds double*, double** %397, i64 %363
%399 = load double*, double** %398
%400 = load double, double* %399
%401 = getelementptr inbounds double, double* %399, i64 1
%402 = load double, double* %401
%403 = load double***, double**** %349
%404 = getelementptr inbounds double**, double*** %403, i64 %361
%405 = load double**, double*** %404
%406 = getelementptr inbounds double*, double** %405, i64 %363
%407 = load double*, double** %406
%408 = load double, double* %407
%409 = getelementptr inbounds double, double* %407, i64 1
%410 = load double, double* %409
%411 = getelementptr inbounds double**, double*** %403, i64 %359
%412 = load double**, double*** %411
%413 = getelementptr inbounds double*, double** %412, i64 %363
%414 = load double*, double** %413
%415 = load double, double* %414
%416 = getelementptr inbounds double, double* %414, i64 1
%417 = load double, double* %416
%418 = getelementptr inbounds double**, double*** %403, i64 %353
%419 = load double**, double*** %418
%420 = getelementptr inbounds double*, double** %419, i64 %371
%421 = load double*, double** %420
%422 = load double, double* %421
%423 = getelementptr inbounds double, double* %421, i64 1
%424 = load double, double* %423
%425 = getelementptr inbounds double*, double** %419, i64 %369
%426 = load double*, double** %425
%427 = load double, double* %426
%428 = getelementptr inbounds double, double* %426, i64 1
%429 = load double, double* %428
%430 = tail call double @sin(double %392)
%431 = tail call double @cos(double %394)
%432 = tail call double @sin(double %400)
%433 = tail call double @cos(double %402)
%434 = fmul double %432, %433
%435 = tail call double @llvm.fmuladd.f64(double %430, double %431, double %434)
%436 = tail call double @sin(double %408)
%437 = tail call double @cos(double %410)
%438 = tail call double @llvm.fmuladd.f64(double %436, double %437, double %435)
%439 = tail call double @sin(double %415)
%440 = tail call double @cos(double %417)
%441 = tail call double @llvm.fmuladd.f64(double %439, double %440, double %438)
%442 = tail call double @sin(double %422)
%443 = tail call double @cos(double %424)
%444 = tail call double @llvm.fmuladd.f64(double %442, double %443, double %441)
%445 = tail call double @sin(double %427)
%446 = tail call double @cos(double %429)
%447 = tail call double @llvm.fmuladd.f64(double %445, double %446, double %444)
%448 = tail call double @sin(double %392)
%449 = tail call double @sin(double %394)
%450 = tail call double @sin(double %400)
%451 = tail call double @sin(double %402)
%452 = fmul double %450, %451
%453 = tail call double @llvm.fmuladd.f64(double %448, double %449, double %452)
%454 = tail call double @sin(double %408)
%455 = tail call double @sin(double %410)
%456 = tail call double @llvm.fmuladd.f64(double %454, double %455, double %453)
%457 = tail call double @sin(double %415)
%458 = tail call double @sin(double %417)
%459 = tail call double @llvm.fmuladd.f64(double %457, double %458, double %456)
%460 = tail call double @sin(double %422)
%461 = tail call double @sin(double %424)
%462 = tail call double @llvm.fmuladd.f64(double %460, double %461, double %459)
%463 = tail call double @sin(double %427)
%464 = tail call double @sin(double %429)
%465 = tail call double @llvm.fmuladd.f64(double %463, double %464, double %462)
%466 = tail call double @cos(double %392)
%467 = tail call double @cos(double %400)
%468 = fadd double %466, %467
%469 = tail call double @cos(double %408)
%470 = fadd double %468, %469
%471 = tail call double @cos(double %415)
%472 = fadd double %470, %471
%473 = tail call double @cos(double %422)
%474 = fadd double %472, %473
%475 = tail call double @cos(double %427)
%476 = fadd double %474, %475
%477 = fmul double %385, %465
%478 = tail call double @llvm.fmuladd.f64(double %382, double %447, double %477)
%479 = tail call double @llvm.fmuladd.f64(double %386, double %476, double %478)
%480 = tail call double @llvm.fmuladd.f64(double %479, double -1.000000e+00, double %364)
%481 = fadd double %367, %382
%482 = fadd double %366, %385
%483 = fadd double %365, %386
%484 = icmp eq i64 %370, 4
br i1 %484, label %485, label %362
485: ; preds = %362
%486 = icmp eq i64 %360, 4
br i1 %486, label %487, label %352
487: ; preds = %485
%488 = icmp eq i64 %347, 4
br i1 %488, label %489, label %339
489: ; preds = %487
%490 = fmul double %480, 5.000000e-01
%491 = getelementptr inbounds [250 x double], [250 x double]* %13, i64 0, i64 %16
store double %490, double* %491
%492 = fmul double %490, %490
%493 = getelementptr inbounds [250 x double], [250 x double]* %14, i64 0, i64 %16
store double %492, double* %493
%494 = fmul double %481, 1.562500e-02
%495 = getelementptr inbounds [250 x double], [250 x double]* %8, i64 0, i64 %16
store double %494, double* %495
%496 = fmul double %482, 1.562500e-02
%497 = getelementptr inbounds [250 x double], [250 x double]* %9, i64 0, i64 %16
store double %496, double* %497
%498 = fmul double %483, 1.562500e-02
%499 = getelementptr inbounds [250 x double], [250 x double]* %10, i64 0, i64 %16
store double %498, double* %499
%500 = fmul double %496, %496
%501 = tail call double @llvm.fmuladd.f64(double %494, double %494, double %500)
%502 = tail call double @llvm.fmuladd.f64(double %498, double %498, double %501)
%503 = tail call double @sqrt(double %502)
%504 = getelementptr inbounds [250 x double], [250 x double]* %11, i64 0, i64 %16
store double %503, double* %504
%505 = fmul double %503, %503
%506 = getelementptr inbounds [250 x double], [250 x double]* %12, i64 0, i64 %16
store double %505, double* %506
%507 = add nuw nsw i64 %16, 1
%508 = icmp eq i64 %507, 250
br i1 %508, label %509, label %15
509: ; preds = %489, %509
%510 = phi i64 [ %541, %509 ], [ 0, %489 ]
%511 = phi double [ %518, %509 ], [ 0.000000e+00, %489 ]
%512 = phi <2 x double> [ %528, %509 ], [ zeroinitializer, %489 ]
%513 = phi <2 x double> [ %540, %509 ], [ zeroinitializer, %489 ]
%514 = phi <2 x double> [ %533, %509 ], [ zeroinitializer, %489 ]
%515 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str, i64 0, i64 0), double %511)
%516 = getelementptr inbounds [250 x double], [250 x double]* %13, i64 0, i64 %510
%517 = load double, double* %516
%518 = fadd double %511, %517
%519 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.1, i64 0, i64 0), double %518)
%520 = getelementptr inbounds [250 x double], [250 x double]* %14, i64 0, i64 %510
%521 = load double, double* %520
%522 = getelementptr inbounds [250 x double], [250 x double]* %11, i64 0, i64 %510
%523 = load double, double* %522
%524 = getelementptr inbounds [250 x double], [250 x double]* %12, i64 0, i64 %510
%525 = load double, double* %524
%526 = insertelement <2 x double> poison, double %523, i64 0
%527 = insertelement <2 x double> %526, double %525, i64 1
%528 = fadd <2 x double> %512, %527
%529 = getelementptr inbounds [250 x double], [250 x double]* %8, i64 0, i64 %510
%530 = load double, double* %529
%531 = insertelement <2 x double> poison, double %530, i64 0
%532 = insertelement <2 x double> %531, double %521, i64 1
%533 = fadd <2 x double> %514, %532
%534 = getelementptr inbounds [250 x double], [250 x double]* %9, i64 0, i64 %510
%535 = load double, double* %534
%536 = getelementptr inbounds [250 x double], [250 x double]* %10, i64 0, i64 %510
%537 = load double, double* %536
%538 = insertelement <2 x double> poison, double %535, i64 0
%539 = insertelement <2 x double> %538, double %537, i64 1
%540 = fadd <2 x double> %513, %539
%541 = add nuw nsw i64 %510, 1
%542 = icmp eq i64 %541, 250
br i1 %542, label %543, label %509
543: ; preds = %509
%544 = fdiv <2 x double> %540, <double 2.500000e+02, double 2.500000e+02>
%545 = fmul <2 x double> %533, %533
%546 = shufflevector <2 x double> %545, <2 x double> %533, <2 x i32> <i32 0, i32 2>
%547 = fdiv <2 x double> %546, <double 2.500000e+02, double 2.500000e+02>
%548 = sext i32 %5 to i64
%549 = getelementptr inbounds [13 x double], [13 x double]* %1, i64 %548, i64 0
store double %2, double* %549
%550 = getelementptr inbounds [13 x double], [13 x double]* %1, i64 %548, i64 1
%551 = insertelement <2 x double> %533, double %518, i64 0
%552 = fdiv <2 x double> %551, <double 2.500000e+02, double 2.500000e+02>
%553 = bitcast double* %550 to <2 x double>*
store <2 x double> %552, <2 x double>* %553
%554 = fmul <2 x double> %552, %552
%555 = extractelement <2 x double> %554, i64 0
%556 = getelementptr inbounds [13 x double], [13 x double]* %1, i64 %548, i64 3
store double %555, double* %556
%557 = getelementptr inbounds [13 x double], [13 x double]* %1, i64 %548, i64 4
%558 = fdiv <2 x double> %528, <double 2.500000e+02, double 2.500000e+02>
%559 = bitcast double* %557 to <2 x double>*
store <2 x double> %558, <2 x double>* %559
%560 = extractelement <2 x double> %558, i64 0
%561 = getelementptr inbounds [13 x double], [13 x double]* %1, i64 %548, i64 6
%562 = shufflevector <2 x double> %558, <2 x double> %552, <2 x i32> <i32 0, i32 2>
%563 = insertelement <2 x double> %558, double 1.562500e-02, i64 1
%564 = fmul <2 x double> %562, %563
%565 = bitcast double* %561 to <2 x double>*
store <2 x double> %564, <2 x double>* %565
%566 = fmul double %560, 1.562500e-02
%567 = getelementptr inbounds [13 x double], [13 x double]* %1, i64 %548, i64 8
store double %566, double* %567
%568 = shufflevector <2 x double> %552, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%569 = fsub <2 x double> %568, %554
%570 = extractelement <2 x double> %569, i64 0
%571 = fmul double %2, %2
%572 = fmul double %571, 6.400000e+01
%573 = fdiv double %570, %572
%574 = getelementptr inbounds [13 x double], [13 x double]* %1, i64 %548, i64 9
store double %573, double* %574
%575 = fmul double %573, 1.562500e-02
%576 = getelementptr inbounds [13 x double], [13 x double]* %1, i64 %548, i64 10
store double %575, double* %576
%577 = fadd <2 x double> %547, %547
%578 = fadd <2 x double> %547, %577
%579 = shufflevector <2 x double> %547, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%580 = fsub <2 x double> %578, %579
%581 = fsub <2 x double> %580, %544
%582 = shufflevector <2 x double> %544, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%583 = fsub <2 x double> %581, %582
%584 = extractelement <2 x double> %583, i64 0
%585 = fmul double %7, %584
%586 = getelementptr inbounds [13 x double], [13 x double]* %1, i64 %548, i64 11
store double %585, double* %586
%587 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), double %585)
%588 = load double, double* %586
%589 = fmul double %588, 1.562500e-02
%590 = getelementptr inbounds [13 x double], [13 x double]* %1, i64 %548, i64 12
store double %589, double* %590
%591 = fdiv double %327, %306
%592 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.3, i64 0, i64 0), double %591)
ret void
}