double vrr(double xa, double ya, double za, double norma, int la, int ma,
           int na, double alphaa, double xb, double yb, double zb, double normb,
           double alphab, double xc, double yc, double zc, double normc, int lc,
           int mc, int nc, double alphac, double xd, double yd, double zd,
           double normd, double alphad, int m) {
  int *ac_lmax_prod = (int *)malloc(sizeof(int) * 6);
  ac_lmax_prod[0] = la + 1;
  ac_lmax_prod[1] = ac_lmax_prod[0] * (ma + 1);
  ac_lmax_prod[2] = ac_lmax_prod[1] * (na + 1);
  ac_lmax_prod[3] = ac_lmax_prod[2] * (lc + 1);
  ac_lmax_prod[4] = ac_lmax_prod[3] * (mc + 1);
  ac_lmax_prod[5] = ac_lmax_prod[4] * (nc + 1);
  double px, py, pz, qx, qy, qz, zeta, eta, wx, wy, wz, rab2, rcd2, Kcd, rpq2,
      T, Kab, val;
  int i, j, k, q, r, s, im, mtot;
  px = product_center_1D(alphaa, xa, alphab, xb);
  py = product_center_1D(alphaa, ya, alphab, yb);
  pz = product_center_1D(alphaa, za, alphab, zb);
  qx = product_center_1D(alphac, xc, alphad, xd);
  qy = product_center_1D(alphac, yc, alphad, yd);
  qz = product_center_1D(alphac, zc, alphad, zd);
  zeta = alphaa + alphab;
  eta = alphac + alphad;
  double ZE = zeta + eta;
  double SQRT_ZE = sqrt(ZE);
  double inv_ZE = 1.0 / ZE;
  double E_ZE = eta * inv_ZE;
  double Z_ZE = zeta * inv_ZE;
  wx = product_center_1D(zeta, px, eta, qx);
  wy = product_center_1D(zeta, py, eta, qy);
  wz = product_center_1D(zeta, pz, eta, qz);
  rab2 = dist2(xa, ya, za, xb, yb, zb);
  Kab = 5.91496717279561323721 / (alphaa + alphab) *
        exp(-alphaa * alphab / (alphaa + alphab) * rab2);
  rcd2 = dist2(xc, yc, zc, xd, yd, zd);
  Kcd = 5.91496717279561323721 / (alphac + alphad) *
        exp(-alphac * alphad / (alphac + alphad) * rcd2);
  rpq2 = dist2(px, py, pz, qx, qy, qz);
  T = zeta * E_ZE * rpq2;
  mtot = la + ma + na + lc + mc + nc + m;
  double maxterms = ac_lmax_prod[5] * (mtot + 1);
  double *Fgterms = (double *)malloc(sizeof(double) * (mtot + 1));
  double *vrr_terms = (double *)malloc(sizeof(double) * maxterms);
  Fgterms[mtot] = Fgamma(mtot, T);
  for (im = mtot - 1; im >= 0; --im) {
    Fgterms[im] = (2. * T * Fgterms[im + 1] + exp(-T)) / (2. * im + 1);
  }
  for (im = 0; im < mtot + 1; ++im) {
    vrr_terms[iindex(0, 0, 0, 0, 0, 0, im, ac_lmax_prod)] =
        norma * normb * normc * normd * Kab * Kcd / SQRT_ZE * Fgterms[im];
  }
  free(Fgterms);
  for (i = 0; i < la; ++i) {
    for (im = 0; im < mtot - i; ++im) {
      vrr_terms[iindex(i + 1, 0, 0, 0, 0, 0, im, ac_lmax_prod)] =
          (px - xa) * vrr_terms[iindex(i, 0, 0, 0, 0, 0, im, ac_lmax_prod)] +
          (wx - px) * vrr_terms[iindex(i, 0, 0, 0, 0, 0, im + 1, ac_lmax_prod)];
      if (i > 0) {
        vrr_terms[iindex(i + 1, 0, 0, 0, 0, 0, im, ac_lmax_prod)] +=
            i / 2. / zeta *
            (vrr_terms[iindex(i - 1, 0, 0, 0, 0, 0, im, ac_lmax_prod)] -
             E_ZE *
                 vrr_terms[iindex(i - 1, 0, 0, 0, 0, 0, im + 1, ac_lmax_prod)]);
      }
    }
  }
  for (j = 0; j < ma; ++j) {
    for (i = 0; i < la + 1; ++i) {
      for (im = 0; im < mtot - i - j; ++im) {
        vrr_terms[iindex(i, j + 1, 0, 0, 0, 0, im, ac_lmax_prod)] =
            (py - ya) * vrr_terms[iindex(i, j, 0, 0, 0, 0, im, ac_lmax_prod)] +
            (wy - py) *
                vrr_terms[iindex(i, j, 0, 0, 0, 0, im + 1, ac_lmax_prod)];
        if (j > 0) {
          vrr_terms[iindex(i, j + 1, 0, 0, 0, 0, im, ac_lmax_prod)] +=
              j / 2. / zeta *
              (vrr_terms[iindex(i, j - 1, 0, 0, 0, 0, im, ac_lmax_prod)] -
               E_ZE * vrr_terms[iindex(i, j - 1, 0, 0, 0, 0, im + 1,
                                       ac_lmax_prod)]);
        }
      }
    }
  }
  for (k = 0; k < na; ++k) {
    for (j = 0; j < ma + 1; ++j) {
      for (i = 0; i < la + 1; ++i) {
        for (im = 0; im < mtot - i - j - k; ++im) {
          vrr_terms[iindex(i, j, k + 1, 0, 0, 0, im, ac_lmax_prod)] =
              (pz - za) *
                  vrr_terms[iindex(i, j, k, 0, 0, 0, im, ac_lmax_prod)] +
              (wz - pz) *
                  vrr_terms[iindex(i, j, k, 0, 0, 0, im + 1, ac_lmax_prod)];
          if (k > 0) {
            vrr_terms[iindex(i, j, k + 1, 0, 0, 0, im, ac_lmax_prod)] +=
                k / 2. / zeta *
                (vrr_terms[iindex(i, j, k - 1, 0, 0, 0, im, ac_lmax_prod)] -
                 E_ZE * vrr_terms[iindex(i, j, k - 1, 0, 0, 0, im + 1,
                                         ac_lmax_prod)]);
          }
        }
      }
    }
  }
  for (q = 0; q < lc; ++q) {
    for (k = 0; k < na + 1; ++k) {
      for (j = 0; j < ma + 1; ++j) {
        for (i = 0; i < la + 1; ++i) {
          for (im = 0; im < mtot - i - j - k - q; ++im) {
            vrr_terms[iindex(i, j, k, q + 1, 0, 0, im, ac_lmax_prod)] =
                (qx - xc) *
                    vrr_terms[iindex(i, j, k, q, 0, 0, im, ac_lmax_prod)] +
                (wx - qx) *
                    vrr_terms[iindex(i, j, k, q, 0, 0, im + 1, ac_lmax_prod)];
            if (q > 0) {
              vrr_terms[iindex(i, j, k, q + 1, 0, 0, im, ac_lmax_prod)] +=
                  q / 2. / eta *
                  (vrr_terms[iindex(i, j, k, q - 1, 0, 0, im, ac_lmax_prod)] -
                   Z_ZE * vrr_terms[iindex(i, j, k, q - 1, 0, 0, im + 1,
                                           ac_lmax_prod)]);
            }
            if (i > 0) {
              vrr_terms[iindex(i, j, k, q + 1, 0, 0, im, ac_lmax_prod)] +=
                  i / 2. * inv_ZE *
                  vrr_terms[iindex(i - 1, j, k, q, 0, 0, im + 1, ac_lmax_prod)];
            }
          }
        }
      }
    }
  }
  for (r = 0; r < mc; ++r) {
    for (q = 0; q < lc + 1; ++q) {
      for (k = 0; k < na + 1; ++k) {
        for (j = 0; j < ma + 1; ++j) {
          for (i = 0; i < la + 1; ++i) {
            for (im = 0; im < mtot - i - j - k - q - r; ++im) {
              vrr_terms[iindex(i, j, k, q, r + 1, 0, im, ac_lmax_prod)] =
                  (qy - yc) *
                      vrr_terms[iindex(i, j, k, q, r, 0, im, ac_lmax_prod)] +
                  (wy - qy) *
                      vrr_terms[iindex(i, j, k, q, r, 0, im + 1, ac_lmax_prod)];
              if (r > 0) {
                vrr_terms[iindex(i, j, k, q, r + 1, 0, im, ac_lmax_prod)] +=
                    r / 2. / eta *
                    (vrr_terms[iindex(i, j, k, q, r - 1, 0, im, ac_lmax_prod)] -
                     Z_ZE * vrr_terms[iindex(i, j, k, q, r - 1, 0, im + 1,
                                             ac_lmax_prod)]);
              }
              if (j > 0) {
                vrr_terms[iindex(i, j, k, q, r + 1, 0, im, ac_lmax_prod)] +=
                    j / 2. * inv_ZE *
                    vrr_terms[iindex(i, j - 1, k, q, r, 0, im + 1,
                                     ac_lmax_prod)];
              }
            }
          }
        }
      }
    }
  }
  for (s = 0; s < nc; ++s) {
    for (r = 0; r < mc + 1; ++r) {
      for (q = 0; q < lc + 1; ++q) {
        for (k = 0; k < na + 1; ++k) {
          for (j = 0; j < ma + 1; ++j) {
            for (i = 0; i < la + 1; ++i) {
              for (im = 0; im < mtot - i - j - k - q - r - s; ++im) {
                vrr_terms[iindex(i, j, k, q, r, s + 1, im, ac_lmax_prod)] =
                    (qz - zc) *
                        vrr_terms[iindex(i, j, k, q, r, s, im, ac_lmax_prod)] +
                    (wz - qz) * vrr_terms[iindex(i, j, k, q, r, s, im + 1,
                                                 ac_lmax_prod)];
                if (s > 0) {
                  vrr_terms[iindex(i, j, k, q, r, s + 1, im, ac_lmax_prod)] +=
                      s / 2. / eta *
                      (vrr_terms[iindex(i, j, k, q, r, s - 1, im,
                                        ac_lmax_prod)] -
                       Z_ZE * vrr_terms[iindex(i, j, k, q, r, s - 1, im + 1,
                                               ac_lmax_prod)]);
                }
                if (k > 0) {
                  vrr_terms[iindex(i, j, k, q, r, s + 1, im, ac_lmax_prod)] +=
                      k / 2. * inv_ZE *
                      vrr_terms[iindex(i, j, k - 1, q, r, s, im + 1,
                                       ac_lmax_prod)];
                }
              }
            }
          }
        }
      }
    }
  }
  val = vrr_terms[iindex(la, ma, na, lc, mc, nc, m, ac_lmax_prod)];
  free(ac_lmax_prod);
  free(vrr_terms);
  return val;
}


x86 assembly (clang, -O0):
<vrr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4d0,%rsp
mov    0x70(%rbp),%eax
movsd  0x68(%rbp),%xmm8
movsd  0x60(%rbp),%xmm8
movsd  0x58(%rbp),%xmm8
movsd  0x50(%rbp),%xmm8
movsd  0x48(%rbp),%xmm8
movsd  0x40(%rbp),%xmm8
movsd  0x38(%rbp),%xmm8
movsd  0x30(%rbp),%xmm8
movsd  0x28(%rbp),%xmm8
movsd  0x20(%rbp),%xmm8
movsd  0x18(%rbp),%xmm8
movsd  0x10(%rbp),%xmm8
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
movsd  %xmm3,-0x20(%rbp)
mov    %edi,-0x24(%rbp)
mov    %esi,-0x28(%rbp)
mov    %edx,-0x2c(%rbp)
movsd  %xmm4,-0x38(%rbp)
movsd  %xmm5,-0x40(%rbp)
movsd  %xmm6,-0x48(%rbp)
movsd  %xmm7,-0x50(%rbp)
mov    %ecx,-0x54(%rbp)
mov    %r8d,-0x58(%rbp)
mov    %r9d,-0x5c(%rbp)
mov    $0x18,%edi
call   1080 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%rax
mov    (%rax),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
mov    %ecx,0x4(%rax)
mov    -0x68(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
mov    %ecx,0x8(%rax)
mov    -0x68(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x54(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
mov    %ecx,0xc(%rax)
mov    -0x68(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x58(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
mov    %ecx,0x10(%rax)
mov    -0x68(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x5c(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
mov    %ecx,0x14(%rax)
movsd  -0x38(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm1
movsd  0x18(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm3
mov    $0x4,%al
mov    %al,-0x191(%rbp)
call   1050 <product_center_1D@plt>
mov    %eax,%ecx
mov    -0x191(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
movsd  0x18(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm3
call   1050 <product_center_1D@plt>
mov    %eax,%ecx
mov    -0x191(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
movsd  0x18(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm3
call   1050 <product_center_1D@plt>
mov    %eax,%ecx
mov    -0x191(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x40(%rbp),%xmm0
movsd  0x20(%rbp),%xmm1
movsd  0x68(%rbp),%xmm2
movsd  0x48(%rbp),%xmm3
call   1050 <product_center_1D@plt>
mov    %eax,%ecx
mov    -0x191(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x40(%rbp),%xmm0
movsd  0x28(%rbp),%xmm1
movsd  0x68(%rbp),%xmm2
movsd  0x50(%rbp),%xmm3
call   1050 <product_center_1D@plt>
mov    %eax,%ecx
mov    -0x191(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x40(%rbp),%xmm0
movsd  0x30(%rbp),%xmm1
movsd  0x68(%rbp),%xmm2
movsd  0x58(%rbp),%xmm3
call   1050 <product_center_1D@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  0x18(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x40(%rbp),%xmm0
movsd  0x68(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
call   10a0 <sqrt@plt>
mov    -0x191(%rbp),%al
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x120(%rbp),%xmm1
ff
movsd  0x2bfe(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0x130(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x130(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x70(%rbp),%xmm1
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm3
ff
call   1050 <product_center_1D@plt>
mov    %eax,%ecx
mov    -0x191(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x90(%rbp),%xmm3
ff
call   1050 <product_center_1D@plt>
mov    %eax,%ecx
mov    -0x191(%rbp),%al
cvtsi2sd %ecx,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm3
ff
call   1050 <product_center_1D@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x8(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm4
movsd  -0x50(%rbp),%xmm5
mov    $0x6,%al
mov    %al,-0x161(%rbp)
call   1070 <dist2@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  0x18(%rbp),%xmm2
movaps %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  0x2ad8(%rip),%xmm3
movsd  %xmm3,-0x188(%rbp)
ff
divsd  %xmm1,%xmm3
movsd  %xmm3,-0x190(%rbp)
ff
movapd 0x2ae4(%rip),%xmm3
movaps %xmm3,-0x180(%rbp)
pxor   %xmm3,%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
call   1090 <exp@plt>
mov    -0x161(%rbp),%al
movaps %xmm0,%xmm1
movsd  -0x190(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  0x20(%rbp),%xmm0
movsd  0x28(%rbp),%xmm1
movsd  0x30(%rbp),%xmm2
movsd  0x48(%rbp),%xmm3
movsd  0x50(%rbp),%xmm4
movsd  0x58(%rbp),%xmm5
call   1070 <dist2@plt>
movsd  -0x188(%rbp),%xmm4
ff
movaps -0x180(%rbp),%xmm3
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0x40(%rbp),%xmm0
movsd  0x68(%rbp),%xmm2
movaps %xmm0,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm4
movsd  %xmm4,-0x160(%rbp)
ff
pxor   %xmm3,%xmm0
mulsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
call   1090 <exp@plt>
mov    -0x161(%rbp),%al
movaps %xmm0,%xmm1
movsd  -0x160(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movsd  -0x88(%rbp),%xmm3
ff
movsd  -0x90(%rbp),%xmm4
ff
movsd  -0x98(%rbp),%xmm5
ff
call   1070 <dist2@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x24(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    %ecx,%eax
mov    -0x2c(%rbp),%ecx
add    %ecx,%eax
mov    -0x54(%rbp),%ecx
add    %ecx,%eax
mov    -0x58(%rbp),%ecx
add    %ecx,%eax
mov    -0x5c(%rbp),%ecx
add    %ecx,%eax
mov    0x70(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x118(%rbp)
mov    -0x68(%rbp),%rax
mov    0x14(%rax),%eax
mov    -0x118(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movslq -0x118(%rbp),%rax
lea    0x8(,%rax,8),%rdi
call   1080 <malloc@plt>
mov    %rax,-0x150(%rbp)
movsd  -0x148(%rbp),%xmm0
ff
movsd  0x291d(%rip),%xmm1
mulsd  %xmm1,%xmm0
movaps %xmm0,%xmm1
cvttsd2si %xmm1,%rdi
mov    %rdi,%rcx
sar    $0x3f,%rcx
movsd  0x290a(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%rax
and    %rcx,%rax
or     %rax,%rdi
call   1080 <malloc@plt>
mov    %rax,-0x158(%rbp)
mov    -0x118(%rbp),%edi
movsd  -0xe8(%rbp),%xmm0
ff
mov    $0x1,%al
call   1040 <Fgamma@plt>
cvtsi2sd %eax,%xmm0
mov    -0x150(%rbp),%rax
movslq -0x118(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x118(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x114(%rbp)
cmpl   $0x0,-0x114(%rbp)
jl     182b <vrr+0x6ab>
movsd  0x28a7(%rip),%xmm0
mulsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x150(%rbp),%rax
mov    -0x114(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
call   1090 <exp@plt>
movsd  -0x1a8(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x1a0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsi2sdl -0x114(%rbp),%xmm1
ff
addsd  %xmm1,%xmm1
movsd  0x2804(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x150(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x114(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x114(%rbp)
jmp    1764 <vrr+0x5e4>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
mov    -0x118(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    18fb <vrr+0x77b>
movsd  -0x20(%rbp),%xmm0
mulsd  0x10(%rbp),%xmm0
mulsd  0x38(%rbp),%xmm0
mulsd  0x60(%rbp),%xmm0
mulsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0xd8(%rbp),%xmm0
ff
divsd  -0x128(%rbp),%xmm0
ff
mov    -0x150(%rbp),%rax
movslq -0x114(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%edi
mov    %r9d,%esi
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x1b8(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0x1b0(%rbp),%rax
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    1835 <vrr+0x6b5>
mov    -0x150(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1c60 <vrr+0xae0>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
mov    -0x118(%rbp),%ecx
sub    -0xfc(%rbp),%ecx
cmp    %ecx,%eax
jge    1c47 <vrr+0xac7>
movsd  -0x70(%rbp),%xmm0
subsd  -0x8(%rbp),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%esi
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x1f0(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%esi
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x1e8(%rbp),%xmm1
ff
movsd  -0x1e0(%rbp),%xmm0
ff
movsd  -0x1d8(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x1d0(%rbp),%rax
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x1c0(%rbp)
mov    -0xfc(%rbp),%edi
add    $0x1,%edi
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%esi
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x1c8(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0x1c0(%rbp),%rax
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0xfc(%rbp)
jle    1c2e <vrr+0xaae>
cvtsi2sdl -0xfc(%rbp),%xmm0
ff
movsd  0x256c(%rip),%xmm1
divsd  %xmm1,%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x208(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x228(%rbp)
mov    -0xfc(%rbp),%edi
sub    $0x1,%edi
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%esi
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x228(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x220(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x210(%rbp)
mov    -0xfc(%rbp),%edi
sub    $0x1,%edi
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%esi
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x220(%rbp),%xmm0
ff
movsd  -0x218(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x210(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
mov    -0xfc(%rbp),%edi
add    $0x1,%edi
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%esi
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x208(%rbp),%xmm0
ff
movsd  -0x200(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x1f8(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c33 <vrr+0xab3>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    192a <vrr+0x7aa>
jmp    1c4c <vrr+0xacc>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    1911 <vrr+0x791>
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    2008 <vrr+0xe88>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1fef <vrr+0xe6f>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
mov    -0x118(%rbp),%ecx
sub    -0xfc(%rbp),%ecx
sub    -0x100(%rbp),%ecx
cmp    %ecx,%eax
jge    1fd6 <vrr+0xe56>
movsd  -0x78(%rbp),%xmm0
subsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x260(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x240(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x258(%rbp),%xmm1
ff
movsd  -0x250(%rbp),%xmm0
ff
movsd  -0x248(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x240(%rbp),%rax
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x230(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
add    $0x1,%esi
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x238(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0x230(%rbp),%rax
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x100(%rbp)
jle    1fbd <vrr+0xe3d>
cvtsi2sdl -0x100(%rbp),%xmm0
ff
movsd  0x21e6(%rip),%xmm1
divsd  %xmm1,%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x278(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x298(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
sub    $0x1,%esi
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x298(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x290(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x280(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
sub    $0x1,%esi
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x290(%rbp),%xmm0
ff
movsd  -0x288(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x280(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x268(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
add    $0x1,%esi
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%edx
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x278(%rbp),%xmm0
ff
movsd  -0x270(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x268(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1fc2 <vrr+0xe42>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    1ca1 <vrr+0xb21>
jmp    1fdb <vrr+0xe5b>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    1c83 <vrr+0xb03>
jmp    1ff4 <vrr+0xe74>
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    1c6a <vrr+0xaea>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    23ff <vrr+0x127f>
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    23e6 <vrr+0x1266>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    23cd <vrr+0x124d>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
mov    -0x118(%rbp),%ecx
sub    -0xfc(%rbp),%ecx
sub    -0x100(%rbp),%ecx
sub    -0x104(%rbp),%ecx
cmp    %ecx,%eax
jge    23b4 <vrr+0x1234>
movsd  -0x80(%rbp),%xmm0
subsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x2d0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x2d0(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x2b0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x2c8(%rbp),%xmm1
ff
movsd  -0x2c0(%rbp),%xmm0
ff
movsd  -0x2b8(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x2b0(%rbp),%rax
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a8(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x2a0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
add    $0x1,%edx
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x2a8(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0x2a0(%rbp),%rax
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x104(%rbp)
jle    239b <vrr+0x121b>
cvtsi2sdl -0x104(%rbp),%xmm0
ff
movsd  0x1e11(%rip),%xmm1
divsd  %xmm1,%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2e8(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x308(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
sub    $0x1,%edx
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x308(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2f8(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x300(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x2f0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
sub    $0x1,%edx
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x300(%rbp),%xmm0
ff
movsd  -0x2f8(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x2f0(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2e0(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x2d8(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
add    $0x1,%edx
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%ecx
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x2e8(%rbp),%xmm0
ff
movsd  -0x2e0(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x2d8(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    23a0 <vrr+0x1220>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    2067 <vrr+0xee7>
jmp    23b9 <vrr+0x1239>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    2049 <vrr+0xec9>
jmp    23d2 <vrr+0x1252>
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    202b <vrr+0xeab>
jmp    23eb <vrr+0x126b>
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    2012 <vrr+0xe92>
movl   $0x0,-0x108(%rbp)
mov    -0x108(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    295b <vrr+0x17db>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2942 <vrr+0x17c2>
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2929 <vrr+0x17a9>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2910 <vrr+0x1790>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
mov    -0x118(%rbp),%ecx
sub    -0xfc(%rbp),%ecx
sub    -0x100(%rbp),%ecx
sub    -0x104(%rbp),%ecx
sub    -0x108(%rbp),%ecx
cmp    %ecx,%eax
jge    28f7 <vrr+0x1777>
movsd  -0x88(%rbp),%xmm0
ff
subsd  0x20(%rbp),%xmm0
movsd  %xmm0,-0x330(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x340(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x340(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x328(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x338(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x320(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x338(%rbp),%xmm1
ff
movsd  -0x330(%rbp),%xmm0
ff
movsd  -0x328(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x320(%rbp),%rax
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x310(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
add    $0x1,%ecx
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x318(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0x310(%rbp),%rax
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x108(%rbp)
jle    27ce <vrr+0x164e>
cvtsi2sdl -0x108(%rbp),%xmm0
ff
movsd  0x19e7(%rip),%xmm1
divsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x358(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x378(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x378(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x368(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x370(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x360(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x370(%rbp),%xmm0
ff
movsd  -0x368(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x360(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x350(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x348(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
add    $0x1,%ecx
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x358(%rbp),%xmm0
ff
movsd  -0x350(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x348(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0xfc(%rbp)
jle    28de <vrr+0x175e>
cvtsi2sdl -0xfc(%rbp),%xmm0
ff
movsd  0x1835(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x390(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x398(%rbp)
mov    -0xfc(%rbp),%edi
sub    $0x1,%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x398(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x388(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x380(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
add    $0x1,%ecx
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r9d,%r8d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x390(%rbp),%xmm0
ff
movsd  -0x388(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x380(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    28e3 <vrr+0x1763>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    247c <vrr+0x12fc>
jmp    28fc <vrr+0x177c>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    245e <vrr+0x12de>
jmp    2915 <vrr+0x1795>
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    2440 <vrr+0x12c0>
jmp    292e <vrr+0x17ae>
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    2422 <vrr+0x12a2>
jmp    2947 <vrr+0x17c7>
mov    -0x108(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x108(%rbp)
jmp    2409 <vrr+0x1289>
movl   $0x0,-0x10c(%rbp)
mov    -0x10c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    2f19 <vrr+0x1d99>
movl   $0x0,-0x108(%rbp)
mov    -0x108(%rbp),%eax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2f00 <vrr+0x1d80>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2ee7 <vrr+0x1d67>
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2ece <vrr+0x1d4e>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2eb5 <vrr+0x1d35>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
mov    -0x118(%rbp),%ecx
sub    -0xfc(%rbp),%ecx
sub    -0x100(%rbp),%ecx
sub    -0x104(%rbp),%ecx
sub    -0x108(%rbp),%ecx
sub    -0x10c(%rbp),%ecx
cmp    %ecx,%eax
jge    2e9c <vrr+0x1d1c>
movsd  -0x90(%rbp),%xmm0
ff
subsd  0x28(%rbp),%xmm0
movsd  %xmm0,-0x3c0(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x3d0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x3d0(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x3b8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
subsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x3c8(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x3b0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x3c8(%rbp),%xmm1
ff
movsd  -0x3c0(%rbp),%xmm0
ff
movsd  -0x3b8(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x3b0(%rbp),%rax
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x3a8(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x3a0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
add    $0x1,%r8d
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x3a8(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0x3a0(%rbp),%rax
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x10c(%rbp)
jle    2d6a <vrr+0x1bea>
cvtsi2sdl -0x10c(%rbp),%xmm0
ff
movsd  0x145a(%rip),%xmm1
divsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x3e8(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x408(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
sub    $0x1,%r8d
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x408(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x3f8(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x400(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x3f0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
sub    $0x1,%r8d
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x400(%rbp),%xmm0
ff
movsd  -0x3f8(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x3f0(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x3e0(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x3d8(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
add    $0x1,%r8d
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x3e8(%rbp),%xmm0
ff
movsd  -0x3e0(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x3d8(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x100(%rbp)
jle    2e83 <vrr+0x1d03>
cvtsi2sdl -0x100(%rbp),%xmm0
ff
movsd  0x1299(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x420(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x428(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
sub    $0x1,%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x428(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x418(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x410(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
add    $0x1,%r8d
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
xor    %r9d,%r9d
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x420(%rbp),%xmm0
ff
movsd  -0x418(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x410(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2e88 <vrr+0x1d08>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    29f6 <vrr+0x1876>
jmp    2ea1 <vrr+0x1d21>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    29d8 <vrr+0x1858>
jmp    2eba <vrr+0x1d3a>
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    29ba <vrr+0x183a>
jmp    2ed3 <vrr+0x1d53>
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    299c <vrr+0x181c>
jmp    2eec <vrr+0x1d6c>
mov    -0x108(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x108(%rbp)
jmp    297e <vrr+0x17fe>
jmp    2f05 <vrr+0x1d85>
mov    -0x10c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10c(%rbp)
jmp    2965 <vrr+0x17e5>
movl   $0x0,-0x110(%rbp)
mov    -0x110(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jge    3534 <vrr+0x23b4>
movl   $0x0,-0x10c(%rbp)
mov    -0x10c(%rbp),%eax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    351b <vrr+0x239b>
movl   $0x0,-0x108(%rbp)
mov    -0x108(%rbp),%eax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    3502 <vrr+0x2382>
movl   $0x0,-0x104(%rbp)
mov    -0x104(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    34e9 <vrr+0x2369>
movl   $0x0,-0x100(%rbp)
mov    -0x100(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    34d0 <vrr+0x2350>
movl   $0x0,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    34b7 <vrr+0x2337>
movl   $0x0,-0x114(%rbp)
mov    -0x114(%rbp),%eax
mov    -0x118(%rbp),%ecx
sub    -0xfc(%rbp),%ecx
sub    -0x100(%rbp),%ecx
sub    -0x104(%rbp),%ecx
sub    -0x108(%rbp),%ecx
sub    -0x10c(%rbp),%ecx
sub    -0x110(%rbp),%ecx
cmp    %ecx,%eax
jge    349e <vrr+0x231e>
movsd  -0x98(%rbp),%xmm0
ff
subsd  0x30(%rbp),%xmm0
movsd  %xmm0,-0x450(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x460(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x110(%rbp),%r9d
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x460(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x448(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x458(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x440(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x110(%rbp),%r9d
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x458(%rbp),%xmm1
ff
movsd  -0x450(%rbp),%xmm0
ff
movsd  -0x448(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x440(%rbp),%rax
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x438(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x430(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x110(%rbp),%r9d
add    $0x1,%r9d
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x438(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0x430(%rbp),%rax
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x110(%rbp)
jle    3364 <vrr+0x21e4>
cvtsi2sdl -0x110(%rbp),%xmm0
ff
movsd  0xe6c(%rip),%xmm1
divsd  %xmm1,%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x478(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x498(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x110(%rbp),%r9d
sub    $0x1,%r9d
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x498(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x488(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x490(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x480(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x110(%rbp),%r9d
sub    $0x1,%r9d
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x490(%rbp),%xmm0
ff
movsd  -0x488(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x480(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x470(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x468(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x110(%rbp),%r9d
add    $0x1,%r9d
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x478(%rbp),%xmm0
ff
movsd  -0x470(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x468(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x104(%rbp)
jle    3485 <vrr+0x2305>
cvtsi2sdl -0x104(%rbp),%xmm0
ff
movsd  0xc9f(%rip),%xmm1
divsd  %xmm1,%xmm0
mulsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x4b0(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x4b8(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
sub    $0x1,%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x110(%rbp),%r9d
mov    -0x114(%rbp),%r10d
add    $0x1,%r10d
mov    -0x68(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x4b8(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x4a8(%rbp)
ff
mov    -0x158(%rbp),%rax
mov    %rax,-0x4a0(%rbp)
mov    -0xfc(%rbp),%edi
mov    -0x100(%rbp),%esi
mov    -0x104(%rbp),%edx
mov    -0x108(%rbp),%ecx
mov    -0x10c(%rbp),%r8d
mov    -0x110(%rbp),%r9d
add    $0x1,%r9d
mov    -0x114(%rbp),%r10d
mov    -0x68(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
movsd  -0x4b0(%rbp),%xmm0
ff
movsd  -0x4a8(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x4a0(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    348a <vrr+0x230a>
mov    -0x114(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    2fd2 <vrr+0x1e52>
jmp    34a3 <vrr+0x2323>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    2fb4 <vrr+0x1e34>
jmp    34bc <vrr+0x233c>
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    2f96 <vrr+0x1e16>
jmp    34d5 <vrr+0x2355>
mov    -0x104(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
jmp    2f78 <vrr+0x1df8>
jmp    34ee <vrr+0x236e>
mov    -0x108(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x108(%rbp)
jmp    2f5a <vrr+0x1dda>
jmp    3507 <vrr+0x2387>
mov    -0x10c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10c(%rbp)
jmp    2f3c <vrr+0x1dbc>
jmp    3520 <vrr+0x23a0>
mov    -0x110(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x110(%rbp)
jmp    2f23 <vrr+0x1da3>
mov    -0x158(%rbp),%rax
mov    %rax,-0x4c0(%rbp)
mov    -0x24(%rbp),%edi
mov    -0x28(%rbp),%esi
mov    -0x2c(%rbp),%edx
mov    -0x54(%rbp),%ecx
mov    -0x58(%rbp),%r8d
mov    -0x5c(%rbp),%r9d
mov    0x70(%rbp),%r10d
mov    -0x68(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1060 <iindex@plt>
mov    %eax,%ecx
mov    -0x4c0(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x158(%rbp),%rdi
call   1030 <free@plt>
movsd  -0xf8(%rbp),%xmm0
ff
add    $0x4d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vrr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r9d,%r14d
mov    %r8d,%r15d
mov    %ecx,%r13d
movsd  %xmm7,0x8(%rsp)
movsd  %xmm6,0x50(%rsp)
movsd  %xmm5,0xa0(%rsp)
movaps %xmm4,0x70(%rsp)
mov    %edx,%ebp
mov    %esi,%ebx
mov    %edi,%r12d
movsd  %xmm3,0x28(%rsp)
movsd  %xmm2,0x90(%rsp)
movsd  %xmm1,0x68(%rsp)
movsd  %xmm0,0x20(%rsp)
mov    $0x18,%edi
call   1080 <malloc@plt>
mov    %rax,%rdx
mov    %r12,0x48(%rsp)
lea    0x1(%r12),%eax
mov    %eax,(%rdx)
mov    %rbx,0x60(%rsp)
lea    0x1(%rbx),%ecx
imul   %eax,%ecx
mov    %ecx,0x4(%rdx)
mov    %rbp,0x88(%rsp)
lea    0x1(%rbp),%eax
imul   %ecx,%eax
mov    %eax,0x8(%rdx)
mov    %r13,0xb8(%rsp)
lea    0x1(%r13),%ecx
imul   %eax,%ecx
mov    %ecx,0xc(%rdx)
mov    %r15,0xe0(%rsp)
lea    0x1(%r15),%eax
mov    %rdx,%rbx
imul   %ecx,%eax
mov    %eax,0x10(%rdx)
mov    %r14,0x128(%rsp)
lea    0x1(%r14),%ecx
imul   %eax,%ecx
mov    %ecx,0x14(%rdx)
movaps 0x70(%rsp),%xmm0
movsd  0x20(%rsp),%xmm1
movsd  0x1d8(%rsp),%xmm2
movsd  0xa0(%rsp),%xmm3
mov    $0x4,%al
call   1050 <product_center_1D@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x18(%rsp)
movaps 0x70(%rsp),%xmm0
movsd  0x68(%rsp),%xmm1
movsd  0x1d8(%rsp),%xmm2
movsd  0x50(%rsp),%xmm3
mov    $0x4,%al
call   1050 <product_center_1D@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x10(%rsp)
movaps 0x70(%rsp),%xmm0
movsd  0x90(%rsp),%xmm1
movsd  0x1d8(%rsp),%xmm2
movsd  0x8(%rsp),%xmm3
mov    $0x4,%al
call   1050 <product_center_1D@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x30(%rsp)
movsd  0x200(%rsp),%xmm0
movsd  0x1e0(%rsp),%xmm1
movsd  0x228(%rsp),%xmm2
movsd  0x208(%rsp),%xmm3
mov    $0x4,%al
call   1050 <product_center_1D@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xc8(%rsp)
movsd  0x200(%rsp),%xmm0
movsd  0x1e8(%rsp),%xmm1
movsd  0x228(%rsp),%xmm2
movsd  0x210(%rsp),%xmm3
mov    $0x4,%al
call   1050 <product_center_1D@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0xe8(%rsp)
movsd  0x200(%rsp),%xmm0
movsd  0x1f0(%rsp),%xmm1
movsd  0x228(%rsp),%xmm2
movsd  0x218(%rsp),%xmm3
mov    $0x4,%al
call   1050 <product_center_1D@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x138(%rsp)
movapd 0x70(%rsp),%xmm2
addsd  0x1d8(%rsp),%xmm2
movsd  0x200(%rsp),%xmm1
addsd  0x228(%rsp),%xmm1
movapd %xmm2,0xd0(%rsp)
movapd %xmm1,0x170(%rsp)
addsd  %xmm1,%xmm2
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jb     13d2 <vrr+0x252>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    13ed <vrr+0x26d>
movapd %xmm2,%xmm0
movapd %xmm2,0x100(%rsp)
call   10a0 <sqrt@plt>
movapd 0x100(%rsp),%xmm2
movsd  %xmm0,0x98(%rsp)
movsd  0x1c02(%rip),%xmm0
divsd  %xmm2,%xmm0
movapd 0x170(%rsp),%xmm2
movapd %xmm2,%xmm1
movsd  %xmm0,0x168(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0xf0(%rsp)
movaps 0xd0(%rsp),%xmm0
movsd  0x18(%rsp),%xmm1
movsd  0xc8(%rsp),%xmm3
mov    $0x4,%al
call   1050 <product_center_1D@plt>
mov    %eax,%r14d
movaps 0xd0(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
movaps 0x170(%rsp),%xmm2
movsd  0xe8(%rsp),%xmm3
mov    $0x4,%al
call   1050 <product_center_1D@plt>
mov    %eax,0xc0(%rsp)
movaps 0xd0(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
movaps 0x170(%rsp),%xmm2
movsd  0x138(%rsp),%xmm3
mov    $0x4,%al
call   1050 <product_center_1D@plt>
mov    %eax,0x150(%rsp)
movsd  0x20(%rsp),%xmm0
movsd  0x68(%rsp),%xmm1
movsd  0x90(%rsp),%xmm2
movsd  0xa0(%rsp),%xmm3
movsd  0x50(%rsp),%xmm4
movsd  0x8(%rsp),%xmm5
mov    $0x6,%al
call   1070 <dist2@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movapd 0x70(%rsp),%xmm0
xorpd  0x1b3a(%rip),%xmm0
mulsd  0x1d8(%rsp),%xmm0
divsd  0xd0(%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1090 <exp@plt>
movsd  %xmm0,0x100(%rsp)
movsd  0x1e0(%rsp),%xmm0
movsd  0x1e8(%rsp),%xmm1
movsd  0x1f0(%rsp),%xmm2
movsd  0x208(%rsp),%xmm3
movsd  0x210(%rsp),%xmm4
movsd  0x218(%rsp),%xmm5
mov    $0x6,%al
call   1070 <dist2@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
movsd  0x200(%rsp),%xmm0
xorpd  0x1ac1(%rip),%xmm0
mulsd  0x228(%rsp),%xmm0
divsd  0x170(%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1090 <exp@plt>
movsd  %xmm0,0x140(%rsp)
movsd  0x18(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
movsd  0x30(%rsp),%xmm2
movsd  0xc8(%rsp),%xmm3
movsd  0xe8(%rsp),%xmm4
movsd  0x138(%rsp),%xmm5
mov    $0x6,%al
call   1070 <dist2@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd 0xd0(%rsp),%xmm1
mulsd  0xf0(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,0x50(%rsp)
mov    0x60(%rsp),%rax
mov    0x48(%rsp),%rcx
add    %ecx,%eax
add    0x88(%rsp),%eax
add    0xb8(%rsp),%eax
add    0xe0(%rsp),%eax
add    0x128(%rsp),%eax
mov    0x230(%rsp),%ecx
add    %ecx,%eax
mov    %rbx,0x38(%rsp)
movslq 0x14(%rbx),%rbx
mov    %eax,0x44(%rsp)
movslq %eax,%r15
lea    0x1(%r15),%rax
imul   %rax,%rbx
movslq %eax,%rdi
shl    $0x3,%rdi
call   1080 <malloc@plt>
mov    %rax,%rbp
shl    $0x3,%rbx
mov    %rbx,%rdi
call   1080 <malloc@plt>
mov    %rax,0x70(%rsp)
mov    %r15d,%edi
movaps 0x50(%rsp),%xmm0
mov    $0x1,%al
call   1040 <Fgamma@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x0(%rbp,%r15,8)
test   %r15d,%r15d
jle    16e1 <vrr+0x561>
movapd 0x50(%rsp),%xmm0
movapd %xmm0,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,0xa0(%rsp)
xorpd  0x199c(%rip),%xmm0
movapd %xmm0,0x50(%rsp)
mov    0x44(%rsp),%ebx
xchg   %ax,%ax
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
add    $0xffffffffffffffff,%rbx
movapd 0x50(%rsp),%xmm0
call   1090 <exp@plt>
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
addsd  0x8(%rsp),%xmm0
addsd  %xmm1,%xmm1
addsd  0x1933(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    %ebx,%eax
movsd  %xmm0,0x0(%rbp,%rax,8)
lea    0x1(%rbx),%eax
cmp    $0x1,%eax
jg     1690 <vrr+0x510>
cmpl   $0x0,0x44(%rsp)
mov    0x38(%rsp),%r12
mov    0x70(%rsp),%r13
movsd  0x28(%rsp),%xmm2
js     17ea <vrr+0x66a>
movsd  0x1904(%rip),%xmm0
movapd %xmm0,%xmm1
divsd  0xd0(%rsp),%xmm1
divsd  0x170(%rsp),%xmm0
mulsd  0x100(%rsp),%xmm1
mulsd  0x140(%rsp),%xmm0
mulsd  0x1d0(%rsp),%xmm2
mulsd  0x1f8(%rsp),%xmm2
mulsd  0x220(%rsp),%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
divsd  0x98(%rsp),%xmm2
mov    0x128(%rsp),%rax
mov    0x230(%rsp),%ecx
add    %ecx,%eax
add    0xe0(%rsp),%eax
add    0xb8(%rsp),%eax
add    0x88(%rsp),%eax
add    0x60(%rsp),%eax
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,1),%r15d
add    $0x1,%r15d
xor    %ebx,%ebx
movsd  %xmm2,0x28(%rsp)
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r12
push   %rbx
call   1060 <iindex@plt>
movsd  0x38(%rsp),%xmm2
add    $0x10,%rsp
cltq
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    17a0 <vrr+0x620>
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
movsd  %xmm0,0x98(%rsp)
mov    %rbp,%rdi
call   1030 <free@plt>
cmpl   $0x0,0x48(%rsp)
jle    1a3e <vrr+0x8be>
movsd  0x98(%rsp),%xmm1
movsd  0x18(%rsp),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,0x28(%rsp)
subsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
movapd 0x17e5(%rip),%xmm0
xorpd  0xf0(%rsp),%xmm0
movapd %xmm0,0x140(%rsp)
xorpd  %xmm0,%xmm0
xor    %r13d,%r13d
xorpd  %xmm1,%xmm1
mov    0x38(%rsp),%r15
mov    0x70(%rsp),%r14
jmp    188b <vrr+0x70b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x110(%rsp),%xmm1
movapd %xmm1,%xmm0
mov    %r12d,%r13d
cmp    0x48(%rsp),%r12d
je     1a3e <vrr+0x8be>
lea    0x1(%r13),%r12d
mov    0x44(%rsp),%eax
addsd  0x1765(%rip),%xmm1
movsd  %xmm1,0x110(%rsp)
sub    %r13d,%eax
mov    %eax,0x50(%rsp)
jle    1870 <vrr+0x6f0>
mulsd  0x175b(%rip),%xmm0
divsd  0xd0(%rsp),%xmm0
movsd  %xmm0,0xa0(%rsp)
lea    -0x1(%r13),%eax
mov    %eax,0x20(%rsp)
xor    %ebp,%ebp
mov    %r13,0x100(%rsp)
jmp    18e8 <vrr+0x768>
nopl   0x0(%rax,%rax,1)
mov    %ebx,%ebp
cmp    0x50(%rsp),%ebx
jge    1870 <vrr+0x6f0>
mov    %r13d,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r15
push   %rbp
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
lea    0x1(%rbp),%ebx
movsd  (%r14,%rax,8),%xmm0
mulsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r13d,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r15
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%r14,%rax,8),%xmm0
mulsd  0x28(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r12d,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r15
push   %rbp
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%r14,%rax,8)
test   %r13d,%r13d
je     18e0 <vrr+0x760>
mov    %r12d,%r13d
mov    0x20(%rsp),%r12d
mov    %r12d,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r15
push   %rbp
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r12d,%edi
mov    %r13d,%r12d
mov    0x100(%rsp),%r13
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r15
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%r14,%rax,8),%xmm0
mulsd  0x140(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
mulsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r12d,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r15
push   %rbp
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x8(%rsp),%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
jmp    18e0 <vrr+0x760>
xorps  %xmm0,%xmm0
cvtsi2sdl 0xc0(%rsp),%xmm0
movsd  %xmm0,0x140(%rsp)
cmpl   $0x0,0x60(%rsp)
movsd  0x15a0(%rip),%xmm1
jle    1cbf <vrr+0xb3f>
movsd  0x140(%rsp),%xmm2
movsd  0x10(%rsp),%xmm0
subsd  %xmm0,%xmm2
movsd  %xmm2,0xa0(%rsp)
subsd  0x68(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movapd 0x158a(%rip),%xmm0
xorpd  0xf0(%rsp),%xmm0
movapd %xmm0,0x110(%rsp)
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
xorpd  %xmm2,%xmm2
mov    0x38(%rsp),%r12
mov    0x70(%rsp),%r15
jmp    1ae2 <vrr+0x962>
xchg   %ax,%ax
movsd  0x68(%rsp),%xmm2
movapd %xmm2,%xmm0
mov    0x50(%rsp),%eax
mov    %eax,%ecx
cmp    0x60(%rsp),%eax
movsd  0x1524(%rip),%xmm1
je     1cbf <vrr+0xb3f>
lea    0x1(%rcx),%eax
mov    %eax,0x50(%rsp)
addsd  %xmm1,%xmm2
movsd  %xmm2,0x68(%rsp)
cmpl   $0x0,0x48(%rsp)
js     1ac0 <vrr+0x940>
mulsd  0x150e(%rip),%xmm0
divsd  0xd0(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
lea    -0x1(%rcx),%eax
mov    %eax,0x100(%rsp)
xor    %r13d,%r13d
mov    %rcx,0x18(%rsp)
jmp    1b47 <vrr+0x9c7>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%r13),%eax
cmp    0x48(%rsp),%r13d
mov    %eax,%r13d
mov    0x18(%rsp),%rcx
je     1ac0 <vrr+0x940>
lea    (%rcx,%r13,1),%eax
mov    0x44(%rsp),%ecx
sub    %eax,%ecx
mov    %ecx,0x28(%rsp)
test   %ecx,%ecx
jle    1b30 <vrr+0x9b0>
xor    %ebx,%ebx
jmp    1b6a <vrr+0x9ea>
nopl   (%rax)
mov    %r14d,%ebx
cmp    0x28(%rsp),%r14d
jge    1b30 <vrr+0x9b0>
mov    %r13d,%edi
mov    0x18(%rsp),%rbp
mov    %ebp,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r12
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
lea    0x1(%rbx),%r14d
movsd  (%r15,%rax,8),%xmm0
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r13d,%edi
mov    %ebp,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r12
push   %r14
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%r15,%rax,8),%xmm0
mulsd  0xa0(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r13d,%edi
mov    0x50(%rsp),%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r12
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x8(%rsp),%xmm0
movsd  %xmm0,(%r15,%rax,8)
test   %ebp,%ebp
je     1b60 <vrr+0x9e0>
mov    %r13d,%edi
mov    0x100(%rsp),%ebp
mov    %ebp,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r12
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r13d,%edi
mov    %ebp,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r12
push   %r14
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%r15,%rax,8),%xmm0
mulsd  0x110(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %r13d,%edi
mov    0x50(%rsp),%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r12
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x8(%rsp),%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
jmp    1b60 <vrr+0x9e0>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x150(%rsp),%xmm0
movsd  %xmm0,0x100(%rsp)
cmpl   $0x0,0x88(%rsp)
jle    1fc3 <vrr+0xe43>
movsd  0x100(%rsp),%xmm2
movsd  0x30(%rsp),%xmm0
subsd  %xmm0,%xmm2
movsd  %xmm2,0x110(%rsp)
subsd  0x90(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
movapd 0xf0(%rsp),%xmm0
xorpd  0x1302(%rip),%xmm0
movapd %xmm0,0xf0(%rsp)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
xorpd  %xmm2,%xmm2
mov    0x38(%rsp),%r13
jmp    1d68 <vrr+0xbe8>
nopl   0x0(%rax,%rax,1)
movsd  0xc0(%rsp),%xmm2
movapd %xmm2,%xmm0
mov    0x10(%rsp),%ecx
mov    %ecx,%eax
cmp    0x88(%rsp),%ecx
movsd  0x129e(%rip),%xmm1
je     1fc3 <vrr+0xe43>
mov    %rax,0x20(%rsp)
add    $0x1,%eax
mov    %eax,0x10(%rsp)
addsd  %xmm1,%xmm2
movsd  %xmm2,0xc0(%rsp)
cmpl   $0x0,0x60(%rsp)
js     1d40 <vrr+0xbc0>
mulsd  0x1280(%rip),%xmm0
divsd  0xd0(%rsp),%xmm0
movsd  %xmm0,0x68(%rsp)
mov    0x20(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x90(%rsp)
xor    %r12d,%r12d
jmp    1dd3 <vrr+0xc53>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%r12),%eax
cmp    0x60(%rsp),%r12d
mov    %eax,%r12d
je     1d40 <vrr+0xbc0>
cmpl   $0x0,0x48(%rsp)
js     1dc0 <vrr+0xc40>
mov    0x20(%rsp),%rax
add    %r12d,%eax
mov    %rax,0x150(%rsp)
xor    %ecx,%ecx
jmp    1e00 <vrr+0xc80>
xchg   %ax,%ax
mov    0x28(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0x48(%rsp),%ecx
mov    %eax,%ecx
je     1dc0 <vrr+0xc40>
mov    0x150(%rsp),%rax
mov    %rcx,0x28(%rsp)
add    %ecx,%eax
mov    0x44(%rsp),%ecx
sub    %eax,%ecx
mov    %ecx,0xa0(%rsp)
test   %ecx,%ecx
jle    1df0 <vrr+0xc70>
xor    %ebx,%ebx
jmp    1e40 <vrr+0xcc0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x50(%rsp),%rax
mov    %eax,%ebx
cmp    0xa0(%rsp),%eax
jge    1df0 <vrr+0xc70>
mov    %rbx,0x8(%rsp)
mov    0x28(%rsp),%r15
mov    %r15d,%edi
mov    %r12d,%esi
mov    0x20(%rsp),%r14
mov    %r14d,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r13
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
lea    0x1(%rbx),%ebp
mov    0x70(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %r15d,%edi
mov    %r12d,%esi
mov    %r14d,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r13
mov    %rbp,0x58(%rsp)
push   %rbp
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%rbx,%rax,8),%xmm0
mulsd  0x110(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %r15d,%edi
mov    %r12d,%esi
mov    0x10(%rsp),%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r13
push   0x10(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x18(%rsp),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
test   %r14d,%r14d
je     1e30 <vrr+0xcb0>
mov    0x28(%rsp),%r15
mov    %r15d,%edi
mov    %r12d,%esi
mov    0x90(%rsp),%ebp
mov    %ebp,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
mov    0x38(%rsp),%r14
push   %r14
push   0x10(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
mov    0x70(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %r15d,%edi
mov    %r12d,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r14
push   0x58(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%rbx,%rax,8),%xmm0
mulsd  0xf0(%rsp),%xmm0
addsd  0x18(%rsp),%xmm0
mulsd  0x68(%rsp),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    %r15d,%edi
mov    %r12d,%esi
mov    0x10(%rsp),%edx
xor    %ecx,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r14
push   0x10(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x18(%rsp),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
jmp    1e30 <vrr+0xcb0>
movapd 0xd0(%rsp),%xmm0
mulsd  0x168(%rsp),%xmm0
movapd %xmm0,0xd0(%rsp)
cmpl   $0x0,0xb8(%rsp)
mov    0x70(%rsp),%rbx
jle    23ec <vrr+0x126c>
movsd  0xc8(%rsp),%xmm0
movsd  0x98(%rsp),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x98(%rsp)
subsd  0x1e0(%rsp),%xmm0
movsd  %xmm0,0xc8(%rsp)
movapd 0xff6(%rip),%xmm0
xorpd  0xd0(%rsp),%xmm0
movapd %xmm0,0x150(%rsp)
xorpd  %xmm0,%xmm0
xor    %r13d,%r13d
xorpd  %xmm2,%xmm2
jmp    2079 <vrr+0xef9>
nopl   0x0(%rax)
movsd  0x188(%rsp),%xmm2
movapd %xmm2,%xmm0
mov    0x28(%rsp),%eax
mov    %eax,%r13d
cmp    0xb8(%rsp),%eax
movsd  0xf8d(%rip),%xmm1
je     23ec <vrr+0x126c>
lea    0x1(%r13),%eax
mov    %eax,0x28(%rsp)
addsd  %xmm1,%xmm2
movsd  %xmm2,0x188(%rsp)
cmpl   $0x0,0x88(%rsp)
js     2050 <vrr+0xed0>
mulsd  0xf70(%rip),%xmm0
divsd  0x170(%rsp),%xmm0
movsd  %xmm0,0x90(%rsp)
lea    -0x1(%r13),%eax
mov    %eax,0xf0(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    %r13,0x30(%rsp)
jmp    20ea <vrr+0xf6a>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rdx
lea    0x1(%rdx),%eax
cmp    0x88(%rsp),%edx
mov    %rax,0x8(%rsp)
je     2050 <vrr+0xed0>
cmpl   $0x0,0x60(%rsp)
js     20d0 <vrr+0xf50>
mov    0x8(%rsp),%rax
add    %r13d,%eax
mov    %rax,0x130(%rsp)
xor    %r14d,%r14d
jmp    211e <vrr+0xf9e>
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%r14),%eax
cmp    0x60(%rsp),%r14d
mov    %eax,%r14d
je     20d0 <vrr+0xf50>
cmpl   $0x0,0x48(%rsp)
js     2110 <vrr+0xf90>
mov    0x130(%rsp),%rax
add    %r14d,%eax
mov    %rax,0xc0(%rsp)
xor    %r12d,%r12d
jmp    214f <vrr+0xfcf>
nopl   (%rax)
lea    0x1(%r12),%eax
cmp    0x48(%rsp),%r12d
mov    %eax,%r12d
je     2110 <vrr+0xf90>
mov    0xc0(%rsp),%rax
add    %r12d,%eax
mov    0x44(%rsp),%edx
sub    %eax,%edx
mov    %edx,0xa0(%rsp)
test   %edx,%edx
jle    2140 <vrr+0xfc0>
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
mulsd  0xe95(%rip),%xmm0
mulsd  0x168(%rsp),%xmm0
movsd  %xmm0,0x110(%rsp)
lea    -0x1(%r12),%eax
mov    %eax,0x68(%rsp)
xor    %r10d,%r10d
mov    %r12,0x20(%rsp)
jmp    21ad <vrr+0x102d>
mov    %r15d,%r10d
cmp    0xa0(%rsp),%r15d
jge    2140 <vrr+0xfc0>
mov    %r12d,%edi
mov    %r14d,%esi
mov    0x8(%rsp),%rdx
mov    %rbx,%r15
mov    %rdx,0x8(%rsp)
mov    %r13d,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
mov    0x38(%rsp),%r12
push   %r12
push   %r10
mov    %r10,%rbx
mov    %r10,0x60(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
lea    0x1(%rbx),%ebp
movsd  (%r15,%rax,8),%xmm0
mulsd  0xc8(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x20(%rsp),%r15
mov    %r15d,%edi
mov    %r14d,%esi
mov    0x8(%rsp),%rbx
mov    %ebx,%edx
mov    %r13d,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r12
mov    %rbp,0x20(%rsp)
push   %rbp
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
mov    0x70(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x98(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
mov    %r12,%rbp
mov    %r15,%r12
mov    %rcx,%rbx
mov    0x28(%rsp),%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %rbp
push   0x58(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x10(%rsp),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
test   %r13d,%r13d
je     2356 <vrr+0x11d6>
mov    %r12d,%edi
mov    %r14d,%esi
mov    0x8(%rsp),%r13
mov    %r13d,%edx
mov    %r14,%r15
mov    0xf0(%rsp),%r14d
mov    %r14d,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   0x38(%rsp)
mov    0x58(%rsp),%rbp
push   %rbp
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
mov    %r14d,%ecx
mov    %r15,%r14
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
mov    0x38(%rsp),%r15
push   %r15
push   0x20(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%rbx,%rax,8),%xmm0
mulsd  0x150(%rsp),%xmm0
addsd  0x10(%rsp),%xmm0
mulsd  0x90(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    %r13d,%edx
mov    0x28(%rsp),%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r15
push   %rbp
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x10(%rsp),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
test   %r12d,%r12d
mov    0x30(%rsp),%r13
mov    0x18(%rsp),%r15
je     21a0 <vrr+0x1020>
mov    0x68(%rsp),%edi
mov    %r14d,%esi
mov    0x8(%rsp),%rbp
mov    %ebp,%edx
mov    %r13d,%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
mov    0x38(%rsp),%rbx
push   %rbx
push   %r15
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
mov    0x70(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x110(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    %ebp,%edx
mov    0x28(%rsp),%ecx
xor    %r8d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %rbx
mov    0x78(%rsp),%rbx
push   0x58(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x10(%rsp),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
jmp    21a0 <vrr+0x1020>
cmpl   $0x0,0xe0(%rsp)
jle    285f <vrr+0x16df>
movsd  0xe8(%rsp),%xmm0
movsd  0x140(%rsp),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x140(%rsp)
subsd  0x1e8(%rsp),%xmm0
movsd  %xmm0,0xe8(%rsp)
movapd 0xbed(%rip),%xmm0
xorpd  0xd0(%rsp),%xmm0
movapd %xmm0,0x150(%rsp)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
xorpd  %xmm2,%xmm2
jmp    2488 <vrr+0x1308>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x190(%rsp),%xmm2
movapd %xmm2,%xmm0
mov    0x10(%rsp),%ecx
mov    %ecx,%eax
cmp    0xe0(%rsp),%ecx
movsd  0xb7e(%rip),%xmm1
je     285f <vrr+0x16df>
mov    %rax,0x28(%rsp)
add    $0x1,%eax
mov    %eax,0x10(%rsp)
addsd  %xmm1,%xmm2
movsd  %xmm2,0x190(%rsp)
cmpl   $0x0,0xb8(%rsp)
js     2460 <vrr+0x12e0>
mulsd  0xb5d(%rip),%xmm0
divsd  0x170(%rsp),%xmm0
movsd  %xmm0,0x90(%rsp)
mov    0x28(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0xf0(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
jmp    24fa <vrr+0x137a>
nopl   (%rax)
mov    0x8(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0xb8(%rsp),%ecx
mov    %rax,0x8(%rsp)
je     2460 <vrr+0x12e0>
cmpl   $0x0,0x88(%rsp)
js     24e0 <vrr+0x1360>
mov    0x28(%rsp),%rax
mov    0x8(%rsp),%rcx
add    %ecx,%eax
mov    %rax,0x188(%rsp)
xor    %eax,%eax
jmp    2531 <vrr+0x13b1>
nopl   0x0(%rax)
mov    0x30(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0x88(%rsp),%ecx
je     24e0 <vrr+0x1360>
mov    %rax,0x30(%rsp)
cmpl   $0x0,0x60(%rsp)
js     2520 <vrr+0x13a0>
mov    0x188(%rsp),%rax
mov    0x30(%rsp),%rcx
add    %ecx,%eax
mov    %rax,0x130(%rsp)
xor    %r13d,%r13d
jmp    256e <vrr+0x13ee>
nopl   0x0(%rax)
lea    0x1(%r13),%eax
cmp    0x60(%rsp),%r13d
mov    %eax,%r13d
je     2520 <vrr+0x13a0>
cmpl   $0x0,0x48(%rsp)
js     2560 <vrr+0x13e0>
mov    0x130(%rsp),%rax
add    %r13d,%eax
mov    %rax,0xc0(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %r13d,%xmm0
mulsd  0xa78(%rip),%xmm0
mulsd  0x168(%rsp),%xmm0
movsd  %xmm0,0x110(%rsp)
lea    -0x1(%r13),%eax
mov    %eax,0x68(%rsp)
xor    %ebp,%ebp
mov    %r13,0x98(%rsp)
jmp    25cb <vrr+0x144b>
xchg   %ax,%ax
lea    0x1(%rbp),%eax
cmp    0x48(%rsp),%ebp
mov    %eax,%ebp
je     2560 <vrr+0x13e0>
mov    0xc0(%rsp),%rax
add    %ebp,%eax
mov    0x44(%rsp),%ecx
sub    %eax,%ecx
mov    %ecx,0xc8(%rsp)
test   %ecx,%ecx
jle    25c0 <vrr+0x1440>
xor    %ebx,%ebx
mov    %rbp,0x18(%rsp)
jmp    2600 <vrr+0x1480>
nop
mov    0x50(%rsp),%rax
mov    %eax,%ebx
cmp    0xc8(%rsp),%eax
jge    25c0 <vrr+0x1440>
mov    %ebp,%edi
mov    %r13d,%esi
mov    0x30(%rsp),%r14
mov    %r14d,%edx
mov    0x8(%rsp),%rcx
mov    0x28(%rsp),%r12
mov    %r12d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
mov    0x38(%rsp),%r15
push   %r15
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
lea    0x1(%rbx),%ebp
mov    0x70(%rsp),%r13
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  0xe8(%rsp),%xmm0
movsd  %xmm0,0xa0(%rsp)
mov    0x18(%rsp),%rdi
mov    0x98(%rsp),%rsi
mov    %r14d,%edx
mov    0x8(%rsp),%rcx
mov    %r12d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r15
mov    %rbp,0x58(%rsp)
push   %rbp
mov    %rdi,%r12
mov    %rsi,%rbp
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x0(%r13,%rax,8),%xmm0
mulsd  0x140(%rsp),%xmm0
addsd  0xa0(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    %r12d,%edi
mov    %ebp,%esi
mov    %r14,%r12
mov    %r14d,%edx
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r15
mov    %rbx,0xa8(%rsp)
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
cmpl   $0x0,0x28(%rsp)
je     27c2 <vrr+0x1642>
mov    %r13,%r14
mov    0x18(%rsp),%r15
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r12,%r13
mov    %r13d,%edx
mov    0x8(%rsp),%rcx
mov    0xf0(%rsp),%r12d
mov    %r12d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   0x38(%rsp)
mov    0xa8(%rsp),%rbx
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    0x8(%rsp),%rcx
mov    %r12d,%r8d
xor    %r9d,%r9d
xor    %eax,%eax
mov    0x38(%rsp),%r12
push   %r12
push   0x58(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%r14,%rax,8),%xmm0
mulsd  0x150(%rsp),%xmm0
addsd  0x20(%rsp),%xmm0
mulsd  0x90(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r13d,%edx
mov    0x8(%rsp),%rcx
mov    0x10(%rsp),%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r12
push   %rbx
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x20(%rsp),%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r14,%rax,8)
test   %ebp,%ebp
mov    %rbp,%r13
mov    0x18(%rsp),%rbp
je     25f0 <vrr+0x1470>
mov    %ebp,%edi
mov    0x68(%rsp),%esi
mov    0x30(%rsp),%r14
mov    %r14d,%edx
mov    0x8(%rsp),%r12
mov    %r12d,%ecx
mov    0x28(%rsp),%r8
xor    %r9d,%r9d
xor    %eax,%eax
mov    0x38(%rsp),%r15
push   %r15
push   0x58(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
mov    0x70(%rsp),%rbx
movsd  (%rbx,%rax,8),%xmm0
mulsd  0x110(%rsp),%xmm0
movsd  %xmm0,0x20(%rsp)
mov    %ebp,%edi
mov    %r13d,%esi
mov    %r14d,%edx
mov    %r12d,%ecx
mov    0x10(%rsp),%r8d
xor    %r9d,%r9d
xor    %eax,%eax
push   %r15
push   0xa8(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  0x20(%rsp),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
jmp    25f0 <vrr+0x1470>
cmpl   $0x0,0x128(%rsp)
mov    0x70(%rsp),%r10
jle    2d4b <vrr+0x1bcb>
movsd  0x138(%rsp),%xmm0
movsd  0x100(%rsp),%xmm2
subsd  %xmm0,%xmm2
movsd  %xmm2,0x100(%rsp)
subsd  0x1f0(%rsp),%xmm0
movsd  %xmm0,0x138(%rsp)
movapd 0xd0(%rsp),%xmm0
xorpd  0x76c(%rip),%xmm0
movapd %xmm0,0xd0(%rsp)
xorpd  %xmm0,%xmm0
xor    %r9d,%r9d
xorpd  %xmm2,%xmm2
jmp    28f9 <vrr+0x1779>
nopw   0x0(%rax,%rax,1)
movsd  0x130(%rsp),%xmm2
movapd %xmm2,%xmm0
mov    0x20(%rsp),%eax
mov    %eax,%r9d
cmp    0x128(%rsp),%eax
movsd  0x70d(%rip),%xmm1
je     2d4b <vrr+0x1bcb>
lea    0x1(%r9),%eax
mov    %eax,0x20(%rsp)
addsd  %xmm1,%xmm2
movsd  %xmm2,0x130(%rsp)
cmpl   $0x0,0xe0(%rsp)
js     28d0 <vrr+0x1750>
mulsd  0x6f0(%rip),%xmm0
divsd  0x170(%rsp),%xmm0
movsd  %xmm0,0x110(%rsp)
lea    -0x1(%r9),%eax
mov    %eax,0x68(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    %r9,0x18(%rsp)
jmp    296a <vrr+0x17ea>
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    0xe0(%rsp),%ecx
mov    %rax,0x8(%rsp)
je     28d0 <vrr+0x1750>
cmpl   $0x0,0xb8(%rsp)
js     2950 <vrr+0x17d0>
mov    0x8(%rsp),%rax
add    %r9d,%eax
mov    %rax,0xc0(%rsp)
xor    %r13d,%r13d
jmp    29a1 <vrr+0x1821>
nopl   0x0(%rax)
lea    0x1(%r13),%eax
cmp    0xb8(%rsp),%r13d
mov    %eax,%r13d
je     2950 <vrr+0x17d0>
cmpl   $0x0,0x88(%rsp)
js     2990 <vrr+0x1810>
mov    0xc0(%rsp),%rax
add    %r13d,%eax
mov    %rax,0x150(%rsp)
xor    %r11d,%r11d
mov    %r13,0x98(%rsp)
jmp    29e1 <vrr+0x1861>
nopl   0x0(%rax,%rax,1)
lea    0x1(%r11),%eax
cmp    0x88(%rsp),%r11d
mov    %eax,%r11d
je     2990 <vrr+0x1810>
cmpl   $0x0,0x60(%rsp)
js     29d0 <vrr+0x1850>
mov    0x150(%rsp),%rax
add    %r11d,%eax
mov    %rax,0xf0(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sd %r11d,%xmm0
mulsd  0x605(%rip),%xmm0
mulsd  0x168(%rsp),%xmm0
movsd  %xmm0,0xe8(%rsp)
lea    -0x1(%r11),%eax
mov    %eax,0x140(%rsp)
xor    %ebx,%ebx
jmp    2a3b <vrr+0x18bb>
nopl   0x0(%rax)
lea    0x1(%rbx),%eax
cmp    0x60(%rsp),%ebx
mov    %eax,%ebx
je     29d0 <vrr+0x1850>
cmpl   $0x0,0x48(%rsp)
js     2a30 <vrr+0x18b0>
mov    0xf0(%rsp),%rax
add    %ebx,%eax
mov    %rax,0x90(%rsp)
xor    %r12d,%r12d
mov    %rbx,0xa0(%rsp)
jmp    2a7f <vrr+0x18ff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1(%r12),%eax
cmp    0x48(%rsp),%r12d
mov    %eax,%r12d
je     2a30 <vrr+0x18b0>
mov    0x90(%rsp),%rax
add    %r12d,%eax
mov    0x44(%rsp),%edx
sub    %eax,%edx
mov    %edx,0xc8(%rsp)
test   %edx,%edx
jle    2a70 <vrr+0x18f0>
xor    %ebp,%ebp
mov    %r12,0x10(%rsp)
jmp    2ac0 <vrr+0x1940>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x28(%rsp),%rax
mov    %eax,%ebp
cmp    0xc8(%rsp),%eax
jge    2a70 <vrr+0x18f0>
mov    %r12d,%edi
mov    %ebx,%esi
mov    %r11d,%edx
mov    %r13d,%ecx
mov    0x8(%rsp),%r15
mov    %r15d,%r8d
xor    %eax,%eax
mov    0x38(%rsp),%r13
push   %r13
push   %rbp
mov    %rbp,0x60(%rsp)
mov    %r11,%r14
mov    %r15,0x18(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
lea    0x1(%rbp),%r10d
mov    %r10,0x28(%rsp)
mov    0x70(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x138(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %r12d,%edi
mov    %ebx,%esi
mov    %r14d,%edx
mov    0x98(%rsp),%rbp
mov    %ebp,%ecx
mov    %r15d,%r8d
mov    0x18(%rsp),%r9
xor    %eax,%eax
push   %r13
push   %r10
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
mov    0x70(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x100(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %r12d,%edi
mov    %ebx,%esi
mov    %r14d,%edx
mov    %rbp,%rbx
mov    %ebx,%ecx
mov    %r15d,%r8d
mov    0x20(%rsp),%r9d
xor    %eax,%eax
push   %r13
push   0x58(%rsp)
call   1060 <iindex@plt>
mov    0x80(%rsp),%r10
add    $0x10,%rsp
cltq
movsd  0x30(%rsp),%xmm0
movsd  %xmm0,(%r10,%rax,8)
cmpl   $0x0,0x18(%rsp)
je     2c8d <vrr+0x1b0d>
mov    0x10(%rsp),%r15
mov    %r15d,%edi
mov    0xa0(%rsp),%rsi
mov    %r14d,%edx
mov    %ebx,%ecx
mov    0x8(%rsp),%rbp
mov    %ebp,%r8d
mov    0x68(%rsp),%r13d
mov    %r13d,%r9d
xor    %eax,%eax
push   0x38(%rsp)
push   0x58(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
mov    0x70(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %r15d,%edi
mov    0xa0(%rsp),%r15
mov    %r15d,%esi
mov    %r14d,%edx
mov    %ebx,%ecx
mov    %ebp,%r8d
mov    %r13d,%r9d
xor    %eax,%eax
mov    0x38(%rsp),%rbp
push   %rbp
push   0x30(%rsp)
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
mov    0x70(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0xd0(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
mulsd  0x110(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    0x10(%rsp),%rdi
mov    %r15d,%esi
mov    %r14d,%edx
mov    %ebx,%ecx
mov    0x8(%rsp),%r8
mov    0x20(%rsp),%r9d
xor    %eax,%eax
push   %rbp
push   0x58(%rsp)
call   1060 <iindex@plt>
mov    0x80(%rsp),%r10
add    $0x10,%rsp
cltq
movsd  0x30(%rsp),%xmm0
addsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,(%r10,%rax,8)
test   %r14d,%r14d
mov    0x18(%rsp),%r9
mov    %rbx,%r13
mov    %r14,%r11
mov    0xa0(%rsp),%rbx
mov    0x10(%rsp),%r12
je     2ab0 <vrr+0x1930>
mov    %r12d,%edi
mov    %ebx,%esi
mov    0x140(%rsp),%edx
mov    %r13d,%ecx
mov    0x8(%rsp),%rbp
mov    %ebp,%r8d
xor    %eax,%eax
mov    %rbx,%r14
mov    0x38(%rsp),%rbx
push   %rbx
push   0x30(%rsp)
mov    %r11,%r15
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
mov    0x70(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0xe8(%rsp),%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    %r15d,%edx
mov    %r13d,%ecx
mov    %ebp,%r8d
mov    0x20(%rsp),%r9d
xor    %eax,%eax
push   %rbx
mov    0x78(%rsp),%rbx
push   0x58(%rsp)
call   1060 <iindex@plt>
mov    %r15,%r11
mov    0x28(%rsp),%r9
mov    %rbx,%r10
mov    %r14,%rbx
add    $0x10,%rsp
cltq
movsd  0x30(%rsp),%xmm0
addsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,(%r10,%rax,8)
jmp    2ab0 <vrr+0x1930>
mov    0x48(%rsp),%rdi
mov    0x60(%rsp),%rsi
mov    0x88(%rsp),%rdx
mov    0xb8(%rsp),%rcx
mov    0xe0(%rsp),%r8
mov    0x128(%rsp),%r9
xor    %eax,%eax
mov    %r10,%r14
mov    0x38(%rsp),%rbx
push   %rbx
mov    0x238(%rsp),%ebp
push   %rbp
call   1060 <iindex@plt>
add    $0x10,%rsp
cltq
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%rsp)
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
movsd  0x8(%rsp),%xmm0
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @vrr(double %0, double %1, double %2, double %3, i32 %4, i32 %5, i32 %6, double %7, double %8, double %9, double %10, double %11, double %12, double %13, double %14, double %15, double %16, i32 %17, i32 %18, i32 %19, double %20, double %21, double %22, double %23, double %24, double %25, i32 %26) {
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%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 i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca double
%49 = alloca double
%50 = alloca double
%51 = alloca double
%52 = alloca double
%53 = alloca double
%54 = alloca i32
%55 = alloca i32*
%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 double
%68 = alloca double
%69 = alloca double
%70 = alloca double
%71 = alloca double
%72 = alloca double
%73 = alloca double
%74 = alloca i32
%75 = alloca i32
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
%79 = alloca i32
%80 = alloca i32
%81 = alloca i32
%82 = alloca double
%83 = alloca double
%84 = alloca double
%85 = alloca double
%86 = alloca double
%87 = alloca double
%88 = alloca double*
%89 = alloca double*
store double %0, double* %28
store double %1, double* %29
store double %2, double* %30
store double %3, double* %31
store i32 %4, i32* %32
store i32 %5, i32* %33
store i32 %6, i32* %34
store double %7, double* %35
store double %8, double* %36
store double %9, double* %37
store double %10, double* %38
store double %11, double* %39
store double %12, double* %40
store double %13, double* %41
store double %14, double* %42
store double %15, double* %43
store double %16, double* %44
store i32 %17, i32* %45
store i32 %18, i32* %46
store i32 %19, i32* %47
store double %20, double* %48
store double %21, double* %49
store double %22, double* %50
store double %23, double* %51
store double %24, double* %52
store double %25, double* %53
store i32 %26, i32* %54
%90 = call i8* @malloc(i64 24)
%91 = bitcast i8* %90 to i32*
store i32* %91, i32** %55
%92 = load i32, i32* %32
%93 = add nsw i32 %92, 1
%94 = load i32*, i32** %55
%95 = getelementptr inbounds i32, i32* %94, i64 0
store i32 %93, i32* %95
%96 = load i32*, i32** %55
%97 = getelementptr inbounds i32, i32* %96, i64 0
%98 = load i32, i32* %97
%99 = load i32, i32* %33
%100 = add nsw i32 %99, 1
%101 = mul nsw i32 %98, %100
%102 = load i32*, i32** %55
%103 = getelementptr inbounds i32, i32* %102, i64 1
store i32 %101, i32* %103
%104 = load i32*, i32** %55
%105 = getelementptr inbounds i32, i32* %104, i64 1
%106 = load i32, i32* %105
%107 = load i32, i32* %34
%108 = add nsw i32 %107, 1
%109 = mul nsw i32 %106, %108
%110 = load i32*, i32** %55
%111 = getelementptr inbounds i32, i32* %110, i64 2
store i32 %109, i32* %111
%112 = load i32*, i32** %55
%113 = getelementptr inbounds i32, i32* %112, i64 2
%114 = load i32, i32* %113
%115 = load i32, i32* %45
%116 = add nsw i32 %115, 1
%117 = mul nsw i32 %114, %116
%118 = load i32*, i32** %55
%119 = getelementptr inbounds i32, i32* %118, i64 3
store i32 %117, i32* %119
%120 = load i32*, i32** %55
%121 = getelementptr inbounds i32, i32* %120, i64 3
%122 = load i32, i32* %121
%123 = load i32, i32* %46
%124 = add nsw i32 %123, 1
%125 = mul nsw i32 %122, %124
%126 = load i32*, i32** %55
%127 = getelementptr inbounds i32, i32* %126, i64 4
store i32 %125, i32* %127
%128 = load i32*, i32** %55
%129 = getelementptr inbounds i32, i32* %128, i64 4
%130 = load i32, i32* %129
%131 = load i32, i32* %47
%132 = add nsw i32 %131, 1
%133 = mul nsw i32 %130, %132
%134 = load i32*, i32** %55
%135 = getelementptr inbounds i32, i32* %134, i64 5
store i32 %133, i32* %135
%136 = load double, double* %35
%137 = load double, double* %28
%138 = load double, double* %40
%139 = load double, double* %36
%140 = call i32 (double, double, double, double, ...) bitcast (i32 (...)* @product_center_1D to i32 (double, double, double, double, ...)*)(double %136, double %137, double %138, double %139)
%141 = sitofp i32 %140 to double
store double %141, double* %56
%142 = load double, double* %35
%143 = load double, double* %29
%144 = load double, double* %40
%145 = load double, double* %37
%146 = call i32 (double, double, double, double, ...) bitcast (i32 (...)* @product_center_1D to i32 (double, double, double, double, ...)*)(double %142, double %143, double %144, double %145)
%147 = sitofp i32 %146 to double
store double %147, double* %57
%148 = load double, double* %35
%149 = load double, double* %30
%150 = load double, double* %40
%151 = load double, double* %38
%152 = call i32 (double, double, double, double, ...) bitcast (i32 (...)* @product_center_1D to i32 (double, double, double, double, ...)*)(double %148, double %149, double %150, double %151)
%153 = sitofp i32 %152 to double
store double %153, double* %58
%154 = load double, double* %48
%155 = load double, double* %41
%156 = load double, double* %53
%157 = load double, double* %49
%158 = call i32 (double, double, double, double, ...) bitcast (i32 (...)* @product_center_1D to i32 (double, double, double, double, ...)*)(double %154, double %155, double %156, double %157)
%159 = sitofp i32 %158 to double
store double %159, double* %59
%160 = load double, double* %48
%161 = load double, double* %42
%162 = load double, double* %53
%163 = load double, double* %50
%164 = call i32 (double, double, double, double, ...) bitcast (i32 (...)* @product_center_1D to i32 (double, double, double, double, ...)*)(double %160, double %161, double %162, double %163)
%165 = sitofp i32 %164 to double
store double %165, double* %60
%166 = load double, double* %48
%167 = load double, double* %43
%168 = load double, double* %53
%169 = load double, double* %51
%170 = call i32 (double, double, double, double, ...) bitcast (i32 (...)* @product_center_1D to i32 (double, double, double, double, ...)*)(double %166, double %167, double %168, double %169)
%171 = sitofp i32 %170 to double
store double %171, double* %61
%172 = load double, double* %35
%173 = load double, double* %40
%174 = fadd double %172, %173
store double %174, double* %62
%175 = load double, double* %48
%176 = load double, double* %53
%177 = fadd double %175, %176
store double %177, double* %63
%178 = load double, double* %62
%179 = load double, double* %63
%180 = fadd double %178, %179
store double %180, double* %82
%181 = load double, double* %82
%182 = call double @sqrt(double %181)
store double %182, double* %83
%183 = load double, double* %82
%184 = fdiv double 1.000000e+00, %183
store double %184, double* %84
%185 = load double, double* %63
%186 = load double, double* %84
%187 = fmul double %185, %186
store double %187, double* %85
%188 = load double, double* %62
%189 = load double, double* %84
%190 = fmul double %188, %189
store double %190, double* %86
%191 = load double, double* %62
%192 = load double, double* %56
%193 = load double, double* %63
%194 = load double, double* %59
%195 = call i32 (double, double, double, double, ...) bitcast (i32 (...)* @product_center_1D to i32 (double, double, double, double, ...)*)(double %191, double %192, double %193, double %194)
%196 = sitofp i32 %195 to double
store double %196, double* %64
%197 = load double, double* %62
%198 = load double, double* %57
%199 = load double, double* %63
%200 = load double, double* %60
%201 = call i32 (double, double, double, double, ...) bitcast (i32 (...)* @product_center_1D to i32 (double, double, double, double, ...)*)(double %197, double %198, double %199, double %200)
%202 = sitofp i32 %201 to double
store double %202, double* %65
%203 = load double, double* %62
%204 = load double, double* %58
%205 = load double, double* %63
%206 = load double, double* %61
%207 = call i32 (double, double, double, double, ...) bitcast (i32 (...)* @product_center_1D to i32 (double, double, double, double, ...)*)(double %203, double %204, double %205, double %206)
%208 = sitofp i32 %207 to double
store double %208, double* %66
%209 = load double, double* %28
%210 = load double, double* %29
%211 = load double, double* %30
%212 = load double, double* %36
%213 = load double, double* %37
%214 = load double, double* %38
%215 = call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @dist2 to i32 (double, double, double, double, double, double, ...)*)(double %209, double %210, double %211, double %212, double %213, double %214)
%216 = sitofp i32 %215 to double
store double %216, double* %67
%217 = load double, double* %35
%218 = load double, double* %40
%219 = fadd double %217, %218
%220 = fdiv double 0x4017A8ED27904870, %219
%221 = load double, double* %35
%222 = fneg double %221
%223 = load double, double* %40
%224 = fmul double %222, %223
%225 = load double, double* %35
%226 = load double, double* %40
%227 = fadd double %225, %226
%228 = fdiv double %224, %227
%229 = load double, double* %67
%230 = fmul double %228, %229
%231 = call double @exp(double %230)
%232 = fmul double %220, %231
store double %232, double* %72
%233 = load double, double* %41
%234 = load double, double* %42
%235 = load double, double* %43
%236 = load double, double* %49
%237 = load double, double* %50
%238 = load double, double* %51
%239 = call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @dist2 to i32 (double, double, double, double, double, double, ...)*)(double %233, double %234, double %235, double %236, double %237, double %238)
%240 = sitofp i32 %239 to double
store double %240, double* %68
%241 = load double, double* %48
%242 = load double, double* %53
%243 = fadd double %241, %242
%244 = fdiv double 0x4017A8ED27904870, %243
%245 = load double, double* %48
%246 = fneg double %245
%247 = load double, double* %53
%248 = fmul double %246, %247
%249 = load double, double* %48
%250 = load double, double* %53
%251 = fadd double %249, %250
%252 = fdiv double %248, %251
%253 = load double, double* %68
%254 = fmul double %252, %253
%255 = call double @exp(double %254)
%256 = fmul double %244, %255
store double %256, double* %69
%257 = load double, double* %56
%258 = load double, double* %57
%259 = load double, double* %58
%260 = load double, double* %59
%261 = load double, double* %60
%262 = load double, double* %61
%263 = call i32 (double, double, double, double, double, double, ...) bitcast (i32 (...)* @dist2 to i32 (double, double, double, double, double, double, ...)*)(double %257, double %258, double %259, double %260, double %261, double %262)
%264 = sitofp i32 %263 to double
store double %264, double* %70
%265 = load double, double* %62
%266 = load double, double* %85
%267 = fmul double %265, %266
%268 = load double, double* %70
%269 = fmul double %267, %268
store double %269, double* %71
%270 = load i32, i32* %32
%271 = load i32, i32* %33
%272 = add nsw i32 %270, %271
%273 = load i32, i32* %34
%274 = add nsw i32 %272, %273
%275 = load i32, i32* %45
%276 = add nsw i32 %274, %275
%277 = load i32, i32* %46
%278 = add nsw i32 %276, %277
%279 = load i32, i32* %47
%280 = add nsw i32 %278, %279
%281 = load i32, i32* %54
%282 = add nsw i32 %280, %281
store i32 %282, i32* %81
%283 = load i32*, i32** %55
%284 = getelementptr inbounds i32, i32* %283, i64 5
%285 = load i32, i32* %284
%286 = load i32, i32* %81
%287 = add nsw i32 %286, 1
%288 = mul nsw i32 %285, %287
%289 = sitofp i32 %288 to double
store double %289, double* %87
%290 = load i32, i32* %81
%291 = add nsw i32 %290, 1
%292 = sext i32 %291 to i64
%293 = mul i64 8, %292
%294 = call i8* @malloc(i64 %293)
%295 = bitcast i8* %294 to double*
store double* %295, double** %88
%296 = load double, double* %87
%297 = fmul double 8.000000e+00, %296
%298 = fptoui double %297 to i64
%299 = call i8* @malloc(i64 %298)
%300 = bitcast i8* %299 to double*
store double* %300, double** %89
%301 = load i32, i32* %81
%302 = load double, double* %71
%303 = call i32 (i32, double, ...) bitcast (i32 (...)* @Fgamma to i32 (i32, double, ...)*)(i32 %301, double %302)
%304 = sitofp i32 %303 to double
%305 = load double*, double** %88
%306 = load i32, i32* %81
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds double, double* %305, i64 %307
store double %304, double* %308
%309 = load i32, i32* %81
%310 = sub nsw i32 %309, 1
store i32 %310, i32* %80
br label %311
311: ; preds = %335, %27
%312 = load i32, i32* %80
%313 = icmp sge i32 %312, 0
br i1 %313, label %314, label %338
314: ; preds = %311
%315 = load double, double* %71
%316 = fmul double 2.000000e+00, %315
%317 = load double*, double** %88
%318 = load i32, i32* %80
%319 = add nsw i32 %318, 1
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds double, double* %317, i64 %320
%322 = load double, double* %321
%323 = load double, double* %71
%324 = fneg double %323
%325 = call double @exp(double %324)
%326 = call double @llvm.fmuladd.f64(double %316, double %322, double %325)
%327 = load i32, i32* %80
%328 = sitofp i32 %327 to double
%329 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %328, double 1.000000e+00)
%330 = fdiv double %326, %329
%331 = load double*, double** %88
%332 = load i32, i32* %80
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds double, double* %331, i64 %333
store double %330, double* %334
br label %335
335: ; preds = %314
%336 = load i32, i32* %80
%337 = add nsw i32 %336, -1
store i32 %337, i32* %80
br label %311
338: ; preds = %311
store i32 0, i32* %80
br label %339
339: ; preds = %370, %338
%340 = load i32, i32* %80
%341 = load i32, i32* %81
%342 = add nsw i32 %341, 1
%343 = icmp slt i32 %340, %342
br i1 %343, label %344, label %373
344: ; preds = %339
%345 = load double, double* %31
%346 = load double, double* %39
%347 = fmul double %345, %346
%348 = load double, double* %44
%349 = fmul double %347, %348
%350 = load double, double* %52
%351 = fmul double %349, %350
%352 = load double, double* %72
%353 = fmul double %351, %352
%354 = load double, double* %69
%355 = fmul double %353, %354
%356 = load double, double* %83
%357 = fdiv double %355, %356
%358 = load double*, double** %88
%359 = load i32, i32* %80
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds double, double* %358, i64 %360
%362 = load double, double* %361
%363 = fmul double %357, %362
%364 = load double*, double** %89
%365 = load i32, i32* %80
%366 = load i32*, i32** %55
%367 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 %365, i32* %366)
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds double, double* %364, i64 %368
store double %363, double* %369
br label %370
370: ; preds = %344
%371 = load i32, i32* %80
%372 = add nsw i32 %371, 1
store i32 %372, i32* %80
br label %339
373: ; preds = %339
%374 = load double*, double** %88
%375 = bitcast double* %374 to i8*
store i32 0, i32* %74
br label %376
376: ; preds = %466, %373
%377 = load i32, i32* %74
%378 = load i32, i32* %32
%379 = icmp slt i32 %377, %378
br i1 %379, label %380, label %469
380: ; preds = %376
store i32 0, i32* %80
br label %381
381: ; preds = %462, %380
%382 = load i32, i32* %80
%383 = load i32, i32* %81
%384 = load i32, i32* %74
%385 = sub nsw i32 %383, %384
%386 = icmp slt i32 %382, %385
br i1 %386, label %387, label %465
387: ; preds = %381
%388 = load double, double* %56
%389 = load double, double* %28
%390 = fsub double %388, %389
%391 = load double*, double** %89
%392 = load i32, i32* %74
%393 = load i32, i32* %80
%394 = load i32*, i32** %55
%395 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %392, i32 0, i32 0, i32 0, i32 0, i32 0, i32 %393, i32* %394)
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds double, double* %391, i64 %396
%398 = load double, double* %397
%399 = load double, double* %64
%400 = load double, double* %56
%401 = fsub double %399, %400
%402 = load double*, double** %89
%403 = load i32, i32* %74
%404 = load i32, i32* %80
%405 = add nsw i32 %404, 1
%406 = load i32*, i32** %55
%407 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %403, i32 0, i32 0, i32 0, i32 0, i32 0, i32 %405, i32* %406)
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds double, double* %402, i64 %408
%410 = load double, double* %409
%411 = fmul double %401, %410
%412 = call double @llvm.fmuladd.f64(double %390, double %398, double %411)
%413 = load double*, double** %89
%414 = load i32, i32* %74
%415 = add nsw i32 %414, 1
%416 = load i32, i32* %80
%417 = load i32*, i32** %55
%418 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %415, i32 0, i32 0, i32 0, i32 0, i32 0, i32 %416, i32* %417)
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds double, double* %413, i64 %419
store double %412, double* %420
%421 = load i32, i32* %74
%422 = icmp sgt i32 %421, 0
br i1 %422, label %423, label %461
423: ; preds = %387
%424 = load i32, i32* %74
%425 = sitofp i32 %424 to double
%426 = fdiv double %425, 2.000000e+00
%427 = load double, double* %62
%428 = fdiv double %426, %427
%429 = load double*, double** %89
%430 = load i32, i32* %74
%431 = sub nsw i32 %430, 1
%432 = load i32, i32* %80
%433 = load i32*, i32** %55
%434 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %431, i32 0, i32 0, i32 0, i32 0, i32 0, i32 %432, i32* %433)
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds double, double* %429, i64 %435
%437 = load double, double* %436
%438 = load double, double* %85
%439 = load double*, double** %89
%440 = load i32, i32* %74
%441 = sub nsw i32 %440, 1
%442 = load i32, i32* %80
%443 = add nsw i32 %442, 1
%444 = load i32*, i32** %55
%445 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %441, i32 0, i32 0, i32 0, i32 0, i32 0, i32 %443, i32* %444)
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds double, double* %439, i64 %446
%448 = load double, double* %447
%449 = fneg double %438
%450 = call double @llvm.fmuladd.f64(double %449, double %448, double %437)
%451 = load double*, double** %89
%452 = load i32, i32* %74
%453 = add nsw i32 %452, 1
%454 = load i32, i32* %80
%455 = load i32*, i32** %55
%456 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %453, i32 0, i32 0, i32 0, i32 0, i32 0, i32 %454, i32* %455)
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds double, double* %451, i64 %457
%459 = load double, double* %458
%460 = call double @llvm.fmuladd.f64(double %428, double %450, double %459)
store double %460, double* %458
br label %461
461: ; preds = %423, %387
br label %462
462: ; preds = %461
%463 = load i32, i32* %80
%464 = add nsw i32 %463, 1
store i32 %464, i32* %80
br label %381
465: ; preds = %381
br label %466
466: ; preds = %465
%467 = load i32, i32* %74
%468 = add nsw i32 %467, 1
store i32 %468, i32* %74
br label %376
469: ; preds = %376
store i32 0, i32* %75
br label %470
470: ; preds = %578, %469
%471 = load i32, i32* %75
%472 = load i32, i32* %33
%473 = icmp slt i32 %471, %472
br i1 %473, label %474, label %581
474: ; preds = %470
store i32 0, i32* %74
br label %475
475: ; preds = %574, %474
%476 = load i32, i32* %74
%477 = load i32, i32* %32
%478 = add nsw i32 %477, 1
%479 = icmp slt i32 %476, %478
br i1 %479, label %480, label %577
480: ; preds = %475
store i32 0, i32* %80
br label %481
481: ; preds = %570, %480
%482 = load i32, i32* %80
%483 = load i32, i32* %81
%484 = load i32, i32* %74
%485 = sub nsw i32 %483, %484
%486 = load i32, i32* %75
%487 = sub nsw i32 %485, %486
%488 = icmp slt i32 %482, %487
br i1 %488, label %489, label %573
489: ; preds = %481
%490 = load double, double* %57
%491 = load double, double* %29
%492 = fsub double %490, %491
%493 = load double*, double** %89
%494 = load i32, i32* %74
%495 = load i32, i32* %75
%496 = load i32, i32* %80
%497 = load i32*, i32** %55
%498 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %494, i32 %495, i32 0, i32 0, i32 0, i32 0, i32 %496, i32* %497)
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds double, double* %493, i64 %499
%501 = load double, double* %500
%502 = load double, double* %65
%503 = load double, double* %57
%504 = fsub double %502, %503
%505 = load double*, double** %89
%506 = load i32, i32* %74
%507 = load i32, i32* %75
%508 = load i32, i32* %80
%509 = add nsw i32 %508, 1
%510 = load i32*, i32** %55
%511 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %506, i32 %507, i32 0, i32 0, i32 0, i32 0, i32 %509, i32* %510)
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds double, double* %505, i64 %512
%514 = load double, double* %513
%515 = fmul double %504, %514
%516 = call double @llvm.fmuladd.f64(double %492, double %501, double %515)
%517 = load double*, double** %89
%518 = load i32, i32* %74
%519 = load i32, i32* %75
%520 = add nsw i32 %519, 1
%521 = load i32, i32* %80
%522 = load i32*, i32** %55
%523 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %518, i32 %520, i32 0, i32 0, i32 0, i32 0, i32 %521, i32* %522)
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds double, double* %517, i64 %524
store double %516, double* %525
%526 = load i32, i32* %75
%527 = icmp sgt i32 %526, 0
br i1 %527, label %528, label %569
528: ; preds = %489
%529 = load i32, i32* %75
%530 = sitofp i32 %529 to double
%531 = fdiv double %530, 2.000000e+00
%532 = load double, double* %62
%533 = fdiv double %531, %532
%534 = load double*, double** %89
%535 = load i32, i32* %74
%536 = load i32, i32* %75
%537 = sub nsw i32 %536, 1
%538 = load i32, i32* %80
%539 = load i32*, i32** %55
%540 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %535, i32 %537, i32 0, i32 0, i32 0, i32 0, i32 %538, i32* %539)
%541 = sext i32 %540 to i64
%542 = getelementptr inbounds double, double* %534, i64 %541
%543 = load double, double* %542
%544 = load double, double* %85
%545 = load double*, double** %89
%546 = load i32, i32* %74
%547 = load i32, i32* %75
%548 = sub nsw i32 %547, 1
%549 = load i32, i32* %80
%550 = add nsw i32 %549, 1
%551 = load i32*, i32** %55
%552 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %546, i32 %548, i32 0, i32 0, i32 0, i32 0, i32 %550, i32* %551)
%553 = sext i32 %552 to i64
%554 = getelementptr inbounds double, double* %545, i64 %553
%555 = load double, double* %554
%556 = fneg double %544
%557 = call double @llvm.fmuladd.f64(double %556, double %555, double %543)
%558 = load double*, double** %89
%559 = load i32, i32* %74
%560 = load i32, i32* %75
%561 = add nsw i32 %560, 1
%562 = load i32, i32* %80
%563 = load i32*, i32** %55
%564 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %559, i32 %561, i32 0, i32 0, i32 0, i32 0, i32 %562, i32* %563)
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds double, double* %558, i64 %565
%567 = load double, double* %566
%568 = call double @llvm.fmuladd.f64(double %533, double %557, double %567)
store double %568, double* %566
br label %569
569: ; preds = %528, %489
br label %570
570: ; preds = %569
%571 = load i32, i32* %80
%572 = add nsw i32 %571, 1
store i32 %572, i32* %80
br label %481
573: ; preds = %481
br label %574
574: ; preds = %573
%575 = load i32, i32* %74
%576 = add nsw i32 %575, 1
store i32 %576, i32* %74
br label %475
577: ; preds = %475
br label %578
578: ; preds = %577
%579 = load i32, i32* %75
%580 = add nsw i32 %579, 1
store i32 %580, i32* %75
br label %470
581: ; preds = %470
store i32 0, i32* %76
br label %582
582: ; preds = %708, %581
%583 = load i32, i32* %76
%584 = load i32, i32* %34
%585 = icmp slt i32 %583, %584
br i1 %585, label %586, label %711
586: ; preds = %582
store i32 0, i32* %75
br label %587
587: ; preds = %704, %586
%588 = load i32, i32* %75
%589 = load i32, i32* %33
%590 = add nsw i32 %589, 1
%591 = icmp slt i32 %588, %590
br i1 %591, label %592, label %707
592: ; preds = %587
store i32 0, i32* %74
br label %593
593: ; preds = %700, %592
%594 = load i32, i32* %74
%595 = load i32, i32* %32
%596 = add nsw i32 %595, 1
%597 = icmp slt i32 %594, %596
br i1 %597, label %598, label %703
598: ; preds = %593
store i32 0, i32* %80
br label %599
599: ; preds = %696, %598
%600 = load i32, i32* %80
%601 = load i32, i32* %81
%602 = load i32, i32* %74
%603 = sub nsw i32 %601, %602
%604 = load i32, i32* %75
%605 = sub nsw i32 %603, %604
%606 = load i32, i32* %76
%607 = sub nsw i32 %605, %606
%608 = icmp slt i32 %600, %607
br i1 %608, label %609, label %699
609: ; preds = %599
%610 = load double, double* %58
%611 = load double, double* %30
%612 = fsub double %610, %611
%613 = load double*, double** %89
%614 = load i32, i32* %74
%615 = load i32, i32* %75
%616 = load i32, i32* %76
%617 = load i32, i32* %80
%618 = load i32*, i32** %55
%619 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %614, i32 %615, i32 %616, i32 0, i32 0, i32 0, i32 %617, i32* %618)
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds double, double* %613, i64 %620
%622 = load double, double* %621
%623 = load double, double* %66
%624 = load double, double* %58
%625 = fsub double %623, %624
%626 = load double*, double** %89
%627 = load i32, i32* %74
%628 = load i32, i32* %75
%629 = load i32, i32* %76
%630 = load i32, i32* %80
%631 = add nsw i32 %630, 1
%632 = load i32*, i32** %55
%633 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %627, i32 %628, i32 %629, i32 0, i32 0, i32 0, i32 %631, i32* %632)
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds double, double* %626, i64 %634
%636 = load double, double* %635
%637 = fmul double %625, %636
%638 = call double @llvm.fmuladd.f64(double %612, double %622, double %637)
%639 = load double*, double** %89
%640 = load i32, i32* %74
%641 = load i32, i32* %75
%642 = load i32, i32* %76
%643 = add nsw i32 %642, 1
%644 = load i32, i32* %80
%645 = load i32*, i32** %55
%646 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %640, i32 %641, i32 %643, i32 0, i32 0, i32 0, i32 %644, i32* %645)
%647 = sext i32 %646 to i64
%648 = getelementptr inbounds double, double* %639, i64 %647
store double %638, double* %648
%649 = load i32, i32* %76
%650 = icmp sgt i32 %649, 0
br i1 %650, label %651, label %695
651: ; preds = %609
%652 = load i32, i32* %76
%653 = sitofp i32 %652 to double
%654 = fdiv double %653, 2.000000e+00
%655 = load double, double* %62
%656 = fdiv double %654, %655
%657 = load double*, double** %89
%658 = load i32, i32* %74
%659 = load i32, i32* %75
%660 = load i32, i32* %76
%661 = sub nsw i32 %660, 1
%662 = load i32, i32* %80
%663 = load i32*, i32** %55
%664 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %658, i32 %659, i32 %661, i32 0, i32 0, i32 0, i32 %662, i32* %663)
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds double, double* %657, i64 %665
%667 = load double, double* %666
%668 = load double, double* %85
%669 = load double*, double** %89
%670 = load i32, i32* %74
%671 = load i32, i32* %75
%672 = load i32, i32* %76
%673 = sub nsw i32 %672, 1
%674 = load i32, i32* %80
%675 = add nsw i32 %674, 1
%676 = load i32*, i32** %55
%677 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %670, i32 %671, i32 %673, i32 0, i32 0, i32 0, i32 %675, i32* %676)
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds double, double* %669, i64 %678
%680 = load double, double* %679
%681 = fneg double %668
%682 = call double @llvm.fmuladd.f64(double %681, double %680, double %667)
%683 = load double*, double** %89
%684 = load i32, i32* %74
%685 = load i32, i32* %75
%686 = load i32, i32* %76
%687 = add nsw i32 %686, 1
%688 = load i32, i32* %80
%689 = load i32*, i32** %55
%690 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %684, i32 %685, i32 %687, i32 0, i32 0, i32 0, i32 %688, i32* %689)
%691 = sext i32 %690 to i64
%692 = getelementptr inbounds double, double* %683, i64 %691
%693 = load double, double* %692
%694 = call double @llvm.fmuladd.f64(double %656, double %682, double %693)
store double %694, double* %692
br label %695
695: ; preds = %651, %609
br label %696
696: ; preds = %695
%697 = load i32, i32* %80
%698 = add nsw i32 %697, 1
store i32 %698, i32* %80
br label %599
699: ; preds = %599
br label %700
700: ; preds = %699
%701 = load i32, i32* %74
%702 = add nsw i32 %701, 1
store i32 %702, i32* %74
br label %593
703: ; preds = %593
br label %704
704: ; preds = %703
%705 = load i32, i32* %75
%706 = add nsw i32 %705, 1
store i32 %706, i32* %75
br label %587
707: ; preds = %587
br label %708
708: ; preds = %707
%709 = load i32, i32* %76
%710 = add nsw i32 %709, 1
store i32 %710, i32* %76
br label %582
711: ; preds = %582
store i32 0, i32* %77
br label %712
712: ; preds = %891, %711
%713 = load i32, i32* %77
%714 = load i32, i32* %45
%715 = icmp slt i32 %713, %714
br i1 %715, label %716, label %894
716: ; preds = %712
store i32 0, i32* %76
br label %717
717: ; preds = %887, %716
%718 = load i32, i32* %76
%719 = load i32, i32* %34
%720 = add nsw i32 %719, 1
%721 = icmp slt i32 %718, %720
br i1 %721, label %722, label %890
722: ; preds = %717
store i32 0, i32* %75
br label %723
723: ; preds = %883, %722
%724 = load i32, i32* %75
%725 = load i32, i32* %33
%726 = add nsw i32 %725, 1
%727 = icmp slt i32 %724, %726
br i1 %727, label %728, label %886
728: ; preds = %723
store i32 0, i32* %74
br label %729
729: ; preds = %879, %728
%730 = load i32, i32* %74
%731 = load i32, i32* %32
%732 = add nsw i32 %731, 1
%733 = icmp slt i32 %730, %732
br i1 %733, label %734, label %882
734: ; preds = %729
store i32 0, i32* %80
br label %735
735: ; preds = %875, %734
%736 = load i32, i32* %80
%737 = load i32, i32* %81
%738 = load i32, i32* %74
%739 = sub nsw i32 %737, %738
%740 = load i32, i32* %75
%741 = sub nsw i32 %739, %740
%742 = load i32, i32* %76
%743 = sub nsw i32 %741, %742
%744 = load i32, i32* %77
%745 = sub nsw i32 %743, %744
%746 = icmp slt i32 %736, %745
br i1 %746, label %747, label %878
747: ; preds = %735
%748 = load double, double* %59
%749 = load double, double* %41
%750 = fsub double %748, %749
%751 = load double*, double** %89
%752 = load i32, i32* %74
%753 = load i32, i32* %75
%754 = load i32, i32* %76
%755 = load i32, i32* %77
%756 = load i32, i32* %80
%757 = load i32*, i32** %55
%758 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %752, i32 %753, i32 %754, i32 %755, i32 0, i32 0, i32 %756, i32* %757)
%759 = sext i32 %758 to i64
%760 = getelementptr inbounds double, double* %751, i64 %759
%761 = load double, double* %760
%762 = load double, double* %64
%763 = load double, double* %59
%764 = fsub double %762, %763
%765 = load double*, double** %89
%766 = load i32, i32* %74
%767 = load i32, i32* %75
%768 = load i32, i32* %76
%769 = load i32, i32* %77
%770 = load i32, i32* %80
%771 = add nsw i32 %770, 1
%772 = load i32*, i32** %55
%773 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %766, i32 %767, i32 %768, i32 %769, i32 0, i32 0, i32 %771, i32* %772)
%774 = sext i32 %773 to i64
%775 = getelementptr inbounds double, double* %765, i64 %774
%776 = load double, double* %775
%777 = fmul double %764, %776
%778 = call double @llvm.fmuladd.f64(double %750, double %761, double %777)
%779 = load double*, double** %89
%780 = load i32, i32* %74
%781 = load i32, i32* %75
%782 = load i32, i32* %76
%783 = load i32, i32* %77
%784 = add nsw i32 %783, 1
%785 = load i32, i32* %80
%786 = load i32*, i32** %55
%787 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %780, i32 %781, i32 %782, i32 %784, i32 0, i32 0, i32 %785, i32* %786)
%788 = sext i32 %787 to i64
%789 = getelementptr inbounds double, double* %779, i64 %788
store double %778, double* %789
%790 = load i32, i32* %77
%791 = icmp sgt i32 %790, 0
br i1 %791, label %792, label %839
792: ; preds = %747
%793 = load i32, i32* %77
%794 = sitofp i32 %793 to double
%795 = fdiv double %794, 2.000000e+00
%796 = load double, double* %63
%797 = fdiv double %795, %796
%798 = load double*, double** %89
%799 = load i32, i32* %74
%800 = load i32, i32* %75
%801 = load i32, i32* %76
%802 = load i32, i32* %77
%803 = sub nsw i32 %802, 1
%804 = load i32, i32* %80
%805 = load i32*, i32** %55
%806 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %799, i32 %800, i32 %801, i32 %803, i32 0, i32 0, i32 %804, i32* %805)
%807 = sext i32 %806 to i64
%808 = getelementptr inbounds double, double* %798, i64 %807
%809 = load double, double* %808
%810 = load double, double* %86
%811 = load double*, double** %89
%812 = load i32, i32* %74
%813 = load i32, i32* %75
%814 = load i32, i32* %76
%815 = load i32, i32* %77
%816 = sub nsw i32 %815, 1
%817 = load i32, i32* %80
%818 = add nsw i32 %817, 1
%819 = load i32*, i32** %55
%820 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %812, i32 %813, i32 %814, i32 %816, i32 0, i32 0, i32 %818, i32* %819)
%821 = sext i32 %820 to i64
%822 = getelementptr inbounds double, double* %811, i64 %821
%823 = load double, double* %822
%824 = fneg double %810
%825 = call double @llvm.fmuladd.f64(double %824, double %823, double %809)
%826 = load double*, double** %89
%827 = load i32, i32* %74
%828 = load i32, i32* %75
%829 = load i32, i32* %76
%830 = load i32, i32* %77
%831 = add nsw i32 %830, 1
%832 = load i32, i32* %80
%833 = load i32*, i32** %55
%834 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %827, i32 %828, i32 %829, i32 %831, i32 0, i32 0, i32 %832, i32* %833)
%835 = sext i32 %834 to i64
%836 = getelementptr inbounds double, double* %826, i64 %835
%837 = load double, double* %836
%838 = call double @llvm.fmuladd.f64(double %797, double %825, double %837)
store double %838, double* %836
br label %839
839: ; preds = %792, %747
%840 = load i32, i32* %74
%841 = icmp sgt i32 %840, 0
br i1 %841, label %842, label %874
842: ; preds = %839
%843 = load i32, i32* %74
%844 = sitofp i32 %843 to double
%845 = fdiv double %844, 2.000000e+00
%846 = load double, double* %84
%847 = fmul double %845, %846
%848 = load double*, double** %89
%849 = load i32, i32* %74
%850 = sub nsw i32 %849, 1
%851 = load i32, i32* %75
%852 = load i32, i32* %76
%853 = load i32, i32* %77
%854 = load i32, i32* %80
%855 = add nsw i32 %854, 1
%856 = load i32*, i32** %55
%857 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %850, i32 %851, i32 %852, i32 %853, i32 0, i32 0, i32 %855, i32* %856)
%858 = sext i32 %857 to i64
%859 = getelementptr inbounds double, double* %848, i64 %858
%860 = load double, double* %859
%861 = load double*, double** %89
%862 = load i32, i32* %74
%863 = load i32, i32* %75
%864 = load i32, i32* %76
%865 = load i32, i32* %77
%866 = add nsw i32 %865, 1
%867 = load i32, i32* %80
%868 = load i32*, i32** %55
%869 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %862, i32 %863, i32 %864, i32 %866, i32 0, i32 0, i32 %867, i32* %868)
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds double, double* %861, i64 %870
%872 = load double, double* %871
%873 = call double @llvm.fmuladd.f64(double %847, double %860, double %872)
store double %873, double* %871
br label %874
874: ; preds = %842, %839
br label %875
875: ; preds = %874
%876 = load i32, i32* %80
%877 = add nsw i32 %876, 1
store i32 %877, i32* %80
br label %735
878: ; preds = %735
br label %879
879: ; preds = %878
%880 = load i32, i32* %74
%881 = add nsw i32 %880, 1
store i32 %881, i32* %74
br label %729
882: ; preds = %729
br label %883
883: ; preds = %882
%884 = load i32, i32* %75
%885 = add nsw i32 %884, 1
store i32 %885, i32* %75
br label %723
886: ; preds = %723
br label %887
887: ; preds = %886
%888 = load i32, i32* %76
%889 = add nsw i32 %888, 1
store i32 %889, i32* %76
br label %717
890: ; preds = %717
br label %891
891: ; preds = %890
%892 = load i32, i32* %77
%893 = add nsw i32 %892, 1
store i32 %893, i32* %77
br label %712
894: ; preds = %712
store i32 0, i32* %78
br label %895
895: ; preds = %1094, %894
%896 = load i32, i32* %78
%897 = load i32, i32* %46
%898 = icmp slt i32 %896, %897
br i1 %898, label %899, label %1097
899: ; preds = %895
store i32 0, i32* %77
br label %900
900: ; preds = %1090, %899
%901 = load i32, i32* %77
%902 = load i32, i32* %45
%903 = add nsw i32 %902, 1
%904 = icmp slt i32 %901, %903
br i1 %904, label %905, label %1093
905: ; preds = %900
store i32 0, i32* %76
br label %906
906: ; preds = %1086, %905
%907 = load i32, i32* %76
%908 = load i32, i32* %34
%909 = add nsw i32 %908, 1
%910 = icmp slt i32 %907, %909
br i1 %910, label %911, label %1089
911: ; preds = %906
store i32 0, i32* %75
br label %912
912: ; preds = %1082, %911
%913 = load i32, i32* %75
%914 = load i32, i32* %33
%915 = add nsw i32 %914, 1
%916 = icmp slt i32 %913, %915
br i1 %916, label %917, label %1085
917: ; preds = %912
store i32 0, i32* %74
br label %918
918: ; preds = %1078, %917
%919 = load i32, i32* %74
%920 = load i32, i32* %32
%921 = add nsw i32 %920, 1
%922 = icmp slt i32 %919, %921
br i1 %922, label %923, label %1081
923: ; preds = %918
store i32 0, i32* %80
br label %924
924: ; preds = %1074, %923
%925 = load i32, i32* %80
%926 = load i32, i32* %81
%927 = load i32, i32* %74
%928 = sub nsw i32 %926, %927
%929 = load i32, i32* %75
%930 = sub nsw i32 %928, %929
%931 = load i32, i32* %76
%932 = sub nsw i32 %930, %931
%933 = load i32, i32* %77
%934 = sub nsw i32 %932, %933
%935 = load i32, i32* %78
%936 = sub nsw i32 %934, %935
%937 = icmp slt i32 %925, %936
br i1 %937, label %938, label %1077
938: ; preds = %924
%939 = load double, double* %60
%940 = load double, double* %42
%941 = fsub double %939, %940
%942 = load double*, double** %89
%943 = load i32, i32* %74
%944 = load i32, i32* %75
%945 = load i32, i32* %76
%946 = load i32, i32* %77
%947 = load i32, i32* %78
%948 = load i32, i32* %80
%949 = load i32*, i32** %55
%950 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %943, i32 %944, i32 %945, i32 %946, i32 %947, i32 0, i32 %948, i32* %949)
%951 = sext i32 %950 to i64
%952 = getelementptr inbounds double, double* %942, i64 %951
%953 = load double, double* %952
%954 = load double, double* %65
%955 = load double, double* %60
%956 = fsub double %954, %955
%957 = load double*, double** %89
%958 = load i32, i32* %74
%959 = load i32, i32* %75
%960 = load i32, i32* %76
%961 = load i32, i32* %77
%962 = load i32, i32* %78
%963 = load i32, i32* %80
%964 = add nsw i32 %963, 1
%965 = load i32*, i32** %55
%966 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %958, i32 %959, i32 %960, i32 %961, i32 %962, i32 0, i32 %964, i32* %965)
%967 = sext i32 %966 to i64
%968 = getelementptr inbounds double, double* %957, i64 %967
%969 = load double, double* %968
%970 = fmul double %956, %969
%971 = call double @llvm.fmuladd.f64(double %941, double %953, double %970)
%972 = load double*, double** %89
%973 = load i32, i32* %74
%974 = load i32, i32* %75
%975 = load i32, i32* %76
%976 = load i32, i32* %77
%977 = load i32, i32* %78
%978 = add nsw i32 %977, 1
%979 = load i32, i32* %80
%980 = load i32*, i32** %55
%981 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %973, i32 %974, i32 %975, i32 %976, i32 %978, i32 0, i32 %979, i32* %980)
%982 = sext i32 %981 to i64
%983 = getelementptr inbounds double, double* %972, i64 %982
store double %971, double* %983
%984 = load i32, i32* %78
%985 = icmp sgt i32 %984, 0
br i1 %985, label %986, label %1036
986: ; preds = %938
%987 = load i32, i32* %78
%988 = sitofp i32 %987 to double
%989 = fdiv double %988, 2.000000e+00
%990 = load double, double* %63
%991 = fdiv double %989, %990
%992 = load double*, double** %89
%993 = load i32, i32* %74
%994 = load i32, i32* %75
%995 = load i32, i32* %76
%996 = load i32, i32* %77
%997 = load i32, i32* %78
%998 = sub nsw i32 %997, 1
%999 = load i32, i32* %80
%1000 = load i32*, i32** %55
%1001 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %993, i32 %994, i32 %995, i32 %996, i32 %998, i32 0, i32 %999, i32* %1000)
%1002 = sext i32 %1001 to i64
%1003 = getelementptr inbounds double, double* %992, i64 %1002
%1004 = load double, double* %1003
%1005 = load double, double* %86
%1006 = load double*, double** %89
%1007 = load i32, i32* %74
%1008 = load i32, i32* %75
%1009 = load i32, i32* %76
%1010 = load i32, i32* %77
%1011 = load i32, i32* %78
%1012 = sub nsw i32 %1011, 1
%1013 = load i32, i32* %80
%1014 = add nsw i32 %1013, 1
%1015 = load i32*, i32** %55
%1016 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1007, i32 %1008, i32 %1009, i32 %1010, i32 %1012, i32 0, i32 %1014, i32* %1015)
%1017 = sext i32 %1016 to i64
%1018 = getelementptr inbounds double, double* %1006, i64 %1017
%1019 = load double, double* %1018
%1020 = fneg double %1005
%1021 = call double @llvm.fmuladd.f64(double %1020, double %1019, double %1004)
%1022 = load double*, double** %89
%1023 = load i32, i32* %74
%1024 = load i32, i32* %75
%1025 = load i32, i32* %76
%1026 = load i32, i32* %77
%1027 = load i32, i32* %78
%1028 = add nsw i32 %1027, 1
%1029 = load i32, i32* %80
%1030 = load i32*, i32** %55
%1031 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1023, i32 %1024, i32 %1025, i32 %1026, i32 %1028, i32 0, i32 %1029, i32* %1030)
%1032 = sext i32 %1031 to i64
%1033 = getelementptr inbounds double, double* %1022, i64 %1032
%1034 = load double, double* %1033
%1035 = call double @llvm.fmuladd.f64(double %991, double %1021, double %1034)
store double %1035, double* %1033
br label %1036
1036: ; preds = %986, %938
%1037 = load i32, i32* %75
%1038 = icmp sgt i32 %1037, 0
br i1 %1038, label %1039, label %1073
1039: ; preds = %1036
%1040 = load i32, i32* %75
%1041 = sitofp i32 %1040 to double
%1042 = fdiv double %1041, 2.000000e+00
%1043 = load double, double* %84
%1044 = fmul double %1042, %1043
%1045 = load double*, double** %89
%1046 = load i32, i32* %74
%1047 = load i32, i32* %75
%1048 = sub nsw i32 %1047, 1
%1049 = load i32, i32* %76
%1050 = load i32, i32* %77
%1051 = load i32, i32* %78
%1052 = load i32, i32* %80
%1053 = add nsw i32 %1052, 1
%1054 = load i32*, i32** %55
%1055 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1046, i32 %1048, i32 %1049, i32 %1050, i32 %1051, i32 0, i32 %1053, i32* %1054)
%1056 = sext i32 %1055 to i64
%1057 = getelementptr inbounds double, double* %1045, i64 %1056
%1058 = load double, double* %1057
%1059 = load double*, double** %89
%1060 = load i32, i32* %74
%1061 = load i32, i32* %75
%1062 = load i32, i32* %76
%1063 = load i32, i32* %77
%1064 = load i32, i32* %78
%1065 = add nsw i32 %1064, 1
%1066 = load i32, i32* %80
%1067 = load i32*, i32** %55
%1068 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1060, i32 %1061, i32 %1062, i32 %1063, i32 %1065, i32 0, i32 %1066, i32* %1067)
%1069 = sext i32 %1068 to i64
%1070 = getelementptr inbounds double, double* %1059, i64 %1069
%1071 = load double, double* %1070
%1072 = call double @llvm.fmuladd.f64(double %1044, double %1058, double %1071)
store double %1072, double* %1070
br label %1073
1073: ; preds = %1039, %1036
br label %1074
1074: ; preds = %1073
%1075 = load i32, i32* %80
%1076 = add nsw i32 %1075, 1
store i32 %1076, i32* %80
br label %924
1077: ; preds = %924
br label %1078
1078: ; preds = %1077
%1079 = load i32, i32* %74
%1080 = add nsw i32 %1079, 1
store i32 %1080, i32* %74
br label %918
1081: ; preds = %918
br label %1082
1082: ; preds = %1081
%1083 = load i32, i32* %75
%1084 = add nsw i32 %1083, 1
store i32 %1084, i32* %75
br label %912
1085: ; preds = %912
br label %1086
1086: ; preds = %1085
%1087 = load i32, i32* %76
%1088 = add nsw i32 %1087, 1
store i32 %1088, i32* %76
br label %906
1089: ; preds = %906
br label %1090
1090: ; preds = %1089
%1091 = load i32, i32* %77
%1092 = add nsw i32 %1091, 1
store i32 %1092, i32* %77
br label %900
1093: ; preds = %900
br label %1094
1094: ; preds = %1093
%1095 = load i32, i32* %78
%1096 = add nsw i32 %1095, 1
store i32 %1096, i32* %78
br label %895
1097: ; preds = %895
store i32 0, i32* %79
br label %1098
1098: ; preds = %1317, %1097
%1099 = load i32, i32* %79
%1100 = load i32, i32* %47
%1101 = icmp slt i32 %1099, %1100
br i1 %1101, label %1102, label %1320
1102: ; preds = %1098
store i32 0, i32* %78
br label %1103
1103: ; preds = %1313, %1102
%1104 = load i32, i32* %78
%1105 = load i32, i32* %46
%1106 = add nsw i32 %1105, 1
%1107 = icmp slt i32 %1104, %1106
br i1 %1107, label %1108, label %1316
1108: ; preds = %1103
store i32 0, i32* %77
br label %1109
1109: ; preds = %1309, %1108
%1110 = load i32, i32* %77
%1111 = load i32, i32* %45
%1112 = add nsw i32 %1111, 1
%1113 = icmp slt i32 %1110, %1112
br i1 %1113, label %1114, label %1312
1114: ; preds = %1109
store i32 0, i32* %76
br label %1115
1115: ; preds = %1305, %1114
%1116 = load i32, i32* %76
%1117 = load i32, i32* %34
%1118 = add nsw i32 %1117, 1
%1119 = icmp slt i32 %1116, %1118
br i1 %1119, label %1120, label %1308
1120: ; preds = %1115
store i32 0, i32* %75
br label %1121
1121: ; preds = %1301, %1120
%1122 = load i32, i32* %75
%1123 = load i32, i32* %33
%1124 = add nsw i32 %1123, 1
%1125 = icmp slt i32 %1122, %1124
br i1 %1125, label %1126, label %1304
1126: ; preds = %1121
store i32 0, i32* %74
br label %1127
1127: ; preds = %1297, %1126
%1128 = load i32, i32* %74
%1129 = load i32, i32* %32
%1130 = add nsw i32 %1129, 1
%1131 = icmp slt i32 %1128, %1130
br i1 %1131, label %1132, label %1300
1132: ; preds = %1127
store i32 0, i32* %80
br label %1133
1133: ; preds = %1293, %1132
%1134 = load i32, i32* %80
%1135 = load i32, i32* %81
%1136 = load i32, i32* %74
%1137 = sub nsw i32 %1135, %1136
%1138 = load i32, i32* %75
%1139 = sub nsw i32 %1137, %1138
%1140 = load i32, i32* %76
%1141 = sub nsw i32 %1139, %1140
%1142 = load i32, i32* %77
%1143 = sub nsw i32 %1141, %1142
%1144 = load i32, i32* %78
%1145 = sub nsw i32 %1143, %1144
%1146 = load i32, i32* %79
%1147 = sub nsw i32 %1145, %1146
%1148 = icmp slt i32 %1134, %1147
br i1 %1148, label %1149, label %1296
1149: ; preds = %1133
%1150 = load double, double* %61
%1151 = load double, double* %43
%1152 = fsub double %1150, %1151
%1153 = load double*, double** %89
%1154 = load i32, i32* %74
%1155 = load i32, i32* %75
%1156 = load i32, i32* %76
%1157 = load i32, i32* %77
%1158 = load i32, i32* %78
%1159 = load i32, i32* %79
%1160 = load i32, i32* %80
%1161 = load i32*, i32** %55
%1162 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1154, i32 %1155, i32 %1156, i32 %1157, i32 %1158, i32 %1159, i32 %1160, i32* %1161)
%1163 = sext i32 %1162 to i64
%1164 = getelementptr inbounds double, double* %1153, i64 %1163
%1165 = load double, double* %1164
%1166 = load double, double* %66
%1167 = load double, double* %61
%1168 = fsub double %1166, %1167
%1169 = load double*, double** %89
%1170 = load i32, i32* %74
%1171 = load i32, i32* %75
%1172 = load i32, i32* %76
%1173 = load i32, i32* %77
%1174 = load i32, i32* %78
%1175 = load i32, i32* %79
%1176 = load i32, i32* %80
%1177 = add nsw i32 %1176, 1
%1178 = load i32*, i32** %55
%1179 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1170, i32 %1171, i32 %1172, i32 %1173, i32 %1174, i32 %1175, i32 %1177, i32* %1178)
%1180 = sext i32 %1179 to i64
%1181 = getelementptr inbounds double, double* %1169, i64 %1180
%1182 = load double, double* %1181
%1183 = fmul double %1168, %1182
%1184 = call double @llvm.fmuladd.f64(double %1152, double %1165, double %1183)
%1185 = load double*, double** %89
%1186 = load i32, i32* %74
%1187 = load i32, i32* %75
%1188 = load i32, i32* %76
%1189 = load i32, i32* %77
%1190 = load i32, i32* %78
%1191 = load i32, i32* %79
%1192 = add nsw i32 %1191, 1
%1193 = load i32, i32* %80
%1194 = load i32*, i32** %55
%1195 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1186, i32 %1187, i32 %1188, i32 %1189, i32 %1190, i32 %1192, i32 %1193, i32* %1194)
%1196 = sext i32 %1195 to i64
%1197 = getelementptr inbounds double, double* %1185, i64 %1196
store double %1184, double* %1197
%1198 = load i32, i32* %79
%1199 = icmp sgt i32 %1198, 0
br i1 %1199, label %1200, label %1253
1200: ; preds = %1149
%1201 = load i32, i32* %79
%1202 = sitofp i32 %1201 to double
%1203 = fdiv double %1202, 2.000000e+00
%1204 = load double, double* %63
%1205 = fdiv double %1203, %1204
%1206 = load double*, double** %89
%1207 = load i32, i32* %74
%1208 = load i32, i32* %75
%1209 = load i32, i32* %76
%1210 = load i32, i32* %77
%1211 = load i32, i32* %78
%1212 = load i32, i32* %79
%1213 = sub nsw i32 %1212, 1
%1214 = load i32, i32* %80
%1215 = load i32*, i32** %55
%1216 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1207, i32 %1208, i32 %1209, i32 %1210, i32 %1211, i32 %1213, i32 %1214, i32* %1215)
%1217 = sext i32 %1216 to i64
%1218 = getelementptr inbounds double, double* %1206, i64 %1217
%1219 = load double, double* %1218
%1220 = load double, double* %86
%1221 = load double*, double** %89
%1222 = load i32, i32* %74
%1223 = load i32, i32* %75
%1224 = load i32, i32* %76
%1225 = load i32, i32* %77
%1226 = load i32, i32* %78
%1227 = load i32, i32* %79
%1228 = sub nsw i32 %1227, 1
%1229 = load i32, i32* %80
%1230 = add nsw i32 %1229, 1
%1231 = load i32*, i32** %55
%1232 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1222, i32 %1223, i32 %1224, i32 %1225, i32 %1226, i32 %1228, i32 %1230, i32* %1231)
%1233 = sext i32 %1232 to i64
%1234 = getelementptr inbounds double, double* %1221, i64 %1233
%1235 = load double, double* %1234
%1236 = fneg double %1220
%1237 = call double @llvm.fmuladd.f64(double %1236, double %1235, double %1219)
%1238 = load double*, double** %89
%1239 = load i32, i32* %74
%1240 = load i32, i32* %75
%1241 = load i32, i32* %76
%1242 = load i32, i32* %77
%1243 = load i32, i32* %78
%1244 = load i32, i32* %79
%1245 = add nsw i32 %1244, 1
%1246 = load i32, i32* %80
%1247 = load i32*, i32** %55
%1248 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1239, i32 %1240, i32 %1241, i32 %1242, i32 %1243, i32 %1245, i32 %1246, i32* %1247)
%1249 = sext i32 %1248 to i64
%1250 = getelementptr inbounds double, double* %1238, i64 %1249
%1251 = load double, double* %1250
%1252 = call double @llvm.fmuladd.f64(double %1205, double %1237, double %1251)
store double %1252, double* %1250
br label %1253
1253: ; preds = %1200, %1149
%1254 = load i32, i32* %76
%1255 = icmp sgt i32 %1254, 0
br i1 %1255, label %1256, label %1292
1256: ; preds = %1253
%1257 = load i32, i32* %76
%1258 = sitofp i32 %1257 to double
%1259 = fdiv double %1258, 2.000000e+00
%1260 = load double, double* %84
%1261 = fmul double %1259, %1260
%1262 = load double*, double** %89
%1263 = load i32, i32* %74
%1264 = load i32, i32* %75
%1265 = load i32, i32* %76
%1266 = sub nsw i32 %1265, 1
%1267 = load i32, i32* %77
%1268 = load i32, i32* %78
%1269 = load i32, i32* %79
%1270 = load i32, i32* %80
%1271 = add nsw i32 %1270, 1
%1272 = load i32*, i32** %55
%1273 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1263, i32 %1264, i32 %1266, i32 %1267, i32 %1268, i32 %1269, i32 %1271, i32* %1272)
%1274 = sext i32 %1273 to i64
%1275 = getelementptr inbounds double, double* %1262, i64 %1274
%1276 = load double, double* %1275
%1277 = load double*, double** %89
%1278 = load i32, i32* %74
%1279 = load i32, i32* %75
%1280 = load i32, i32* %76
%1281 = load i32, i32* %77
%1282 = load i32, i32* %78
%1283 = load i32, i32* %79
%1284 = add nsw i32 %1283, 1
%1285 = load i32, i32* %80
%1286 = load i32*, i32** %55
%1287 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1278, i32 %1279, i32 %1280, i32 %1281, i32 %1282, i32 %1284, i32 %1285, i32* %1286)
%1288 = sext i32 %1287 to i64
%1289 = getelementptr inbounds double, double* %1277, i64 %1288
%1290 = load double, double* %1289
%1291 = call double @llvm.fmuladd.f64(double %1261, double %1276, double %1290)
store double %1291, double* %1289
br label %1292
1292: ; preds = %1256, %1253
br label %1293
1293: ; preds = %1292
%1294 = load i32, i32* %80
%1295 = add nsw i32 %1294, 1
store i32 %1295, i32* %80
br label %1133
1296: ; preds = %1133
br label %1297
1297: ; preds = %1296
%1298 = load i32, i32* %74
%1299 = add nsw i32 %1298, 1
store i32 %1299, i32* %74
br label %1127
1300: ; preds = %1127
br label %1301
1301: ; preds = %1300
%1302 = load i32, i32* %75
%1303 = add nsw i32 %1302, 1
store i32 %1303, i32* %75
br label %1121
1304: ; preds = %1121
br label %1305
1305: ; preds = %1304
%1306 = load i32, i32* %76
%1307 = add nsw i32 %1306, 1
store i32 %1307, i32* %76
br label %1115
1308: ; preds = %1115
br label %1309
1309: ; preds = %1308
%1310 = load i32, i32* %77
%1311 = add nsw i32 %1310, 1
store i32 %1311, i32* %77
br label %1109
1312: ; preds = %1109
br label %1313
1313: ; preds = %1312
%1314 = load i32, i32* %78
%1315 = add nsw i32 %1314, 1
store i32 %1315, i32* %78
br label %1103
1316: ; preds = %1103
br label %1317
1317: ; preds = %1316
%1318 = load i32, i32* %79
%1319 = add nsw i32 %1318, 1
store i32 %1319, i32* %79
br label %1098
1320: ; preds = %1098
%1321 = load double*, double** %89
%1322 = load i32, i32* %32
%1323 = load i32, i32* %33
%1324 = load i32, i32* %34
%1325 = load i32, i32* %45
%1326 = load i32, i32* %46
%1327 = load i32, i32* %47
%1328 = load i32, i32* %54
%1329 = load i32*, i32** %55
%1330 = call i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...) bitcast (i32 (...)* @iindex to i32 (i32, i32, i32, i32, i32, i32, i32, i32*, ...)*)(i32 %1322, i32 %1323, i32 %1324, i32 %1325, i32 %1326, i32 %1327, i32 %1328, i32* %1329)
%1331 = sext i32 %1330 to i64
%1332 = getelementptr inbounds double, double* %1321, i64 %1331
%1333 = load double, double* %1332
store double %1333, double* %73
%1334 = load i32*, i32** %55
%1335 = bitcast i32* %1334 to i8*
%1336 = load double*, double** %89
%1337 = bitcast double* %1336 to i8*
%1338 = load double, double* %73
ret double %1338
}

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