void interpolate_skewed_map_to_cubic(
    double **pphiout, unsigned *pextx, unsigned *pexty, unsigned *pextz,
    double *porigx, double *porigy, double *porigz, double *pwidth,
    double *phiin, unsigned nx, unsigned ny, unsigned nz, int nxstart,
    int nystart, int nzstart, double xorigin, double yorigin, double zorigin,
    double widthx, double widthy, double widthz, double alpha, double beta,
    double gamma) {
  unsigned long pnvox;
  double ax, ay, az, bx, by, bz, cx, cy, cz, aix, aiy, aiz, bix, biy, biz, cix,
      ciy, ciz;
  double t1x, t1y, t2x, t2y, t3x, t3y, t4x, t4y, cdet, scz;
  double ux[8], uy[8], uz[8], uxmin, uxmax, uymin, uymax, uzmin, uzmax;
  double xpos, ypos, zpos, gx, gy, gz, a, b, c;
  int x0, y0, z0, x1, y1, z1;
  double endox, endoy, endoz;
  int i, indx, indy, indz;
  double origx, origy, origz;
  ax = 1.0;
  ay = 0.0;
  az = 0.0;
  bx = cos(3.14159265358979323846 * gamma / 180.0);
  by = sin(3.14159265358979323846 * gamma / 180.0);
  bz = 0.0;
  t1x = cos(3.14159265358979323846 * (gamma + alpha) / 180.0);
  t1y = sin(3.14159265358979323846 * (gamma + alpha) / 180.0);
  t2x = cos(3.14159265358979323846 * (gamma - alpha) / 180.0);
  t2y = sin(3.14159265358979323846 * (gamma - alpha) / 180.0);
  t3x = cos(3.14159265358979323846 * beta / 180.0);
  t3y = sin(3.14159265358979323846 * beta / 180.0);
  t4x = cos(3.14159265358979323846 * beta / 180.0);
  t4y = -1.0 * sin(3.14159265358979323846 * beta / 180.0);
  cdet = (t4y - t3y) * (t2x - t1x) - (t2y - t1y) * (t4x - t3x);
  if (fabs(cdet) < 1E-15) {
    error_divide_zero(71330, "lib_vio");
  }
  cx = ((t4x - t3x) * (t1y * t2x - t2y * t1x) -
        (t2x - t1x) * (t3y * t4x - t4y * t3x)) /
       cdet;
  cy = ((t4y - t3y) * (t1y * t2x - t2y * t1x) -
        (t2y - t1y) * (t3y * t4x - t4y * t3x)) /
       cdet;
  scz = 1.0 - (cx * cx + cy * cy);
  if (scz < 0.0) {
    error_sqrt_negative(71340, "lib_vio");
  }
  cz = sqrt(scz);
  aix = 1.0;
  aiy = 0.0;
  aiz = 0.0;
  bix = -bx / by;
  biy = 1.0 / by;
  biz = 0.0;
  cix = (bx * cy - cx * by) / (by * cz);
  ciy = -cy / (by * cz);
  ciz = 1.0 / cz;
  if (set_origin_get_mode(nxstart, nystart, nzstart, widthx, widthy, widthz,
                          xorigin, yorigin, zorigin, &origx, &origy, &origz)) {
    gx = aix * origx + bix * origy + cix * origz;
    gy = aiy * origx + biy * origy + ciy * origz;
    gz = aiz * origx + biz * origy + ciz * origz;
    origx = gx;
    origy = gy;
    origz = gz;
  }
  endox = origx + (nx - 1) * widthx;
  endoy = origy + (ny - 1) * widthy;
  endoz = origz + (nz - 1) * widthz;
  ux[0] = ax * origx + bx * origy + cx * origz;
  uy[0] = ay * origx + by * origy + cy * origz;
  uz[0] = az * origx + bz * origy + cz * origz;
  ux[1] = ax * endox + bx * origy + cx * origz;
  uy[1] = ay * endox + by * origy + cy * origz;
  uz[1] = az * endox + bz * origy + cz * origz;
  ux[2] = ax * origx + bx * endoy + cx * origz;
  uy[2] = ay * origx + by * endoy + cy * origz;
  uz[2] = az * origx + bz * endoy + cz * origz;
  ux[3] = ax * origx + bx * origy + cx * endoz;
  uy[3] = ay * origx + by * origy + cy * endoz;
  uz[3] = az * origx + bz * origy + cz * endoz;
  ux[4] = ax * endox + bx * endoy + cx * origz;
  uy[4] = ay * endox + by * endoy + cy * origz;
  uz[4] = az * endox + bz * endoy + cz * origz;
  ux[5] = ax * origx + bx * endoy + cx * endoz;
  uy[5] = ay * origx + by * endoy + cy * endoz;
  uz[5] = az * origx + bz * endoy + cz * endoz;
  ux[6] = ax * endox + bx * origy + cx * endoz;
  uy[6] = ay * endox + by * origy + cy * endoz;
  uz[6] = az * endox + bz * origy + cz * endoz;
  ux[7] = ax * endox + bx * endoy + cx * endoz;
  uy[7] = ay * endox + by * endoy + cy * endoz;
  uz[7] = az * endox + bz * endoy + cz * endoz;
  uxmin = 1E20;
  for (i = 0; i < 8; i++)
    if (ux[i] < uxmin)
      uxmin = ux[i];
  uymin = 1E20;
  for (i = 0; i < 8; i++)
    if (uy[i] < uymin)
      uymin = uy[i];
  uzmin = 1E20;
  for (i = 0; i < 8; i++)
    if (uz[i] < uzmin)
      uzmin = uz[i];
  uxmax = -1E20;
  for (i = 0; i < 8; i++)
    if (ux[i] > uxmax)
      uxmax = ux[i];
  uymax = -1E20;
  for (i = 0; i < 8; i++)
    if (uy[i] > uymax)
      uymax = uy[i];
  uzmax = -1E20;
  for (i = 0; i < 8; i++)
    if (uz[i] > uzmax)
      uzmax = uz[i];
  *pwidth = widthx;
  if ((widthy * by) < *pwidth)
    *pwidth = widthy * by;
  if ((widthz * cz) < *pwidth)
    *pwidth = widthz * cz;
  *pwidth = floor(*pwidth * 10.0 + 0.5) / 10.0;
  *porigx = *pwidth * floor(uxmin / *pwidth);
  *porigy = *pwidth * floor(uymin / *pwidth);
  *porigz = *pwidth * floor(uzmin / *pwidth);
  *pextx = (int)(ceil(uxmax / *pwidth) - floor(uxmin / *pwidth) + 1.5);
  *pexty = (int)(ceil(uymax / *pwidth) - floor(uymin / *pwidth) + 1.5);
  *pextz = (int)(ceil(uzmax / *pwidth) - floor(uzmin / *pwidth) + 1.5);
  pnvox = *pextx * *pexty * *pextz;
  do_vect(pphiout, pnvox);
  for (indz = 0; indz < (int)*pextz; indz++)
    for (indy = 0; indy < (int)*pexty; indy++)
      for (indx = 0; indx < (int)*pextx; indx++) {
        xpos = *porigx + indx * *pwidth;
        ypos = *porigy + indy * *pwidth;
        zpos = *porigz + indz * *pwidth;
        gx = (aix * xpos + bix * ypos + cix * zpos - origx) / widthx;
        gy = (aiy * xpos + biy * ypos + ciy * zpos - origy) / widthy;
        gz = (aiz * xpos + biz * ypos + ciz * zpos - origz) / widthz;
        x0 = (int)floor(gx);
        y0 = (int)floor(gy);
        z0 = (int)floor(gz);
        x1 = x0 + 1;
        y1 = y0 + 1;
        z1 = z0 + 1;
        if (x0 >= 0 && x1 < (int)nx && y0 >= 0 && y1 < (int)ny && z0 >= 0 &&
            z1 < (int)nz) {
          a = gx - x0;
          b = gy - y0;
          c = gz - z0;
          *(*pphiout + gidz_general(indz, indy, indx, *pexty, *pextx)) =
              a * b * c * *(phiin + gidz_general(z1, y1, x1, ny, nx)) +
              (1 - a) * b * c * *(phiin + gidz_general(z1, y1, x0, ny, nx)) +
              a * (1 - b) * c * *(phiin + gidz_general(z1, y0, x1, ny, nx)) +
              a * b * (1 - c) * *(phiin + gidz_general(z0, y1, x1, ny, nx)) +
              a * (1 - b) * (1 - c) *
                  *(phiin + gidz_general(z0, y0, x1, ny, nx)) +
              (1 - a) * b * (1 - c) *
                  *(phiin + gidz_general(z0, y1, x0, ny, nx)) +
              (1 - a) * (1 - b) * c *
                  *(phiin + gidz_general(z1, y0, x0, ny, nx)) +
              (1 - a) * (1 - b) * (1 - c) *
                  *(phiin + gidz_general(z0, y0, x0, ny, nx));
        }
      }
  printf("lib_vio> Conversion to cubic lattice completed. \n");
}


x86 assembly (clang, -O0):
<interpolate_skewed_map_to_cubic>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3f0,%rsp
movsd  0x58(%rbp),%xmm8
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
movsd  %xmm2,-0x48(%rbp)
movsd  %xmm3,-0x50(%rbp)
movsd  %xmm4,-0x58(%rbp)
movsd  %xmm5,-0x60(%rbp)
movsd  %xmm6,-0x68(%rbp)
movsd  %xmm7,-0x70(%rbp)
movsd  0x1df9(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x1dce(%rip),%xmm0
mulsd  0x58(%rbp),%xmm0
movsd  0x1db9(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1090 <cos@plt>
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x1da8(%rip),%xmm0
mulsd  0x58(%rbp),%xmm0
movsd  0x1d93(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x58(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0x1d6d(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1d59(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1090 <cos@plt>
movsd  %xmm0,-0x110(%rbp)
ff
movsd  0x58(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0x1d3e(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1d2a(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0x118(%rbp)
ff
movsd  0x58(%rbp),%xmm1
subsd  -0x68(%rbp),%xmm1
movsd  0x1d0f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1cfb(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1090 <cos@plt>
movsd  %xmm0,-0x120(%rbp)
ff
movsd  0x58(%rbp),%xmm1
subsd  -0x68(%rbp),%xmm1
movsd  0x1ce0(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1ccc(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0x128(%rbp)
ff
movsd  0x1cbb(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  0x1ca6(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1090 <cos@plt>
movsd  %xmm0,-0x130(%rbp)
ff
movsd  0x1c95(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  0x1c80(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <sin@plt>
movsd  %xmm0,-0x138(%rbp)
ff
movsd  0x1c6f(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  0x1c5a(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1090 <cos@plt>
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0x1c49(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  0x1c34(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1060 <sin@plt>
movaps %xmm0,%xmm1
movsd  0x1c18(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
subsd  -0x138(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
subsd  -0x110(%rbp),%xmm2
ff
movsd  -0x128(%rbp),%xmm1
ff
subsd  -0x118(%rbp),%xmm1
ff
movsd  -0x140(%rbp),%xmm3
ff
subsd  -0x130(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x150(%rbp),%xmm1
ff
movaps 0x1bda(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1b7e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    149f <interpolate_skewed_map_to_cubic+0x2ef>
mov    $0x116a2,%edi
lea    0x1bc8(%rip),%rsi
mov    $0x0,%al
call   1070 <error_divide_zero@plt>
movsd  -0x140(%rbp),%xmm0
ff
subsd  -0x130(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0x120(%rbp),%xmm3
ff
movsd  -0x128(%rbp),%xmm1
ff
mulsd  -0x110(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x120(%rbp),%xmm1
ff
subsd  -0x110(%rbp),%xmm1
ff
movsd  -0x138(%rbp),%xmm3
ff
movsd  -0x140(%rbp),%xmm5
ff
movsd  -0x148(%rbp),%xmm4
ff
mulsd  -0x130(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
subsd  -0x138(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0x120(%rbp),%xmm3
ff
movsd  -0x128(%rbp),%xmm1
ff
mulsd  -0x110(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x128(%rbp),%xmm1
ff
subsd  -0x118(%rbp),%xmm1
ff
movsd  -0x138(%rbp),%xmm3
ff
movsd  -0x140(%rbp),%xmm5
ff
movsd  -0x148(%rbp),%xmm4
ff
mulsd  -0x130(%rbp),%xmm4
ff
movq   %xmm4,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xb8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x19af(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x158(%rbp),%xmm0
ff
jbe    16a1 <interpolate_skewed_map_to_cubic+0x4f1>
mov    $0x116ac,%edi
lea    0x19c6(%rip),%rsi
mov    $0x0,%al
call   10c0 <error_sqrt_negative@plt>
movsd  -0x158(%rbp),%xmm0
ff
call   10b0 <sqrt@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x1962(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0x190d(%rip),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  0x1854(%rip),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
mov    0x40(%rbp),%edi
mov    0x48(%rbp),%esi
mov    0x50(%rbp),%edx
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm3
movsd  -0x40(%rbp),%xmm4
movsd  -0x48(%rbp),%xmm5
lea    -0x2e0(%rbp),%rcx
lea    -0x2e8(%rbp),%r8
lea    -0x2f0(%rbp),%r9
mov    $0x6,%al
call   1040 <set_origin_get_mode@plt>
cmp    $0x0,%eax
je     1930 <interpolate_skewed_map_to_cubic+0x780>
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0x270(%rbp),%xmm0
ff
movsd  %xmm0,-0x2e0(%rbp)
ff
movsd  -0x278(%rbp),%xmm0
ff
movsd  %xmm0,-0x2e8(%rbp)
ff
movsd  -0x280(%rbp),%xmm0
ff
movsd  %xmm0,-0x2f0(%rbp)
ff
movsd  -0x2e0(%rbp),%xmm1
ff
mov    0x28(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm0
movsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
movsd  -0x2e8(%rbp),%xmm1
ff
mov    0x30(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm0
movsd  -0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c0(%rbp)
ff
movsd  -0x2f0(%rbp),%xmm1
ff
mov    0x38(%rbp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm0
movsd  -0x60(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2c8(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x2f0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x2e0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x2e8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
movsd  -0x90(%rbp),%xmm1
movsd  -0x2b8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x2c0(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0x2c8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  0xfd0(%rip),%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movl   $0x0,-0x2cc(%rbp)
cmpl   $0x8,-0x2cc(%rbp)
jge    20ca <interpolate_skewed_map_to_cubic+0xf1a>
movslq -0x2cc(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x228(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    20b1 <interpolate_skewed_map_to_cubic+0xf01>
movslq -0x2cc(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x228(%rbp)
ff
jmp    20b6 <interpolate_skewed_map_to_cubic+0xf06>
mov    -0x2cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2cc(%rbp)
jmp    206a <interpolate_skewed_map_to_cubic+0xeba>
movsd  0xf56(%rip),%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
movl   $0x0,-0x2cc(%rbp)
cmpl   $0x8,-0x2cc(%rbp)
jge    2144 <interpolate_skewed_map_to_cubic+0xf94>
movslq -0x2cc(%rbp),%rax
movsd  -0x1e0(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x238(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    212b <interpolate_skewed_map_to_cubic+0xf7b>
movslq -0x2cc(%rbp),%rax
movsd  -0x1e0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x238(%rbp)
ff
jmp    2130 <interpolate_skewed_map_to_cubic+0xf80>
mov    -0x2cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2cc(%rbp)
jmp    20e4 <interpolate_skewed_map_to_cubic+0xf34>
movsd  0xedc(%rip),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
movl   $0x0,-0x2cc(%rbp)
cmpl   $0x8,-0x2cc(%rbp)
jge    21be <interpolate_skewed_map_to_cubic+0x100e>
movslq -0x2cc(%rbp),%rax
movsd  -0x220(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x248(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    21a5 <interpolate_skewed_map_to_cubic+0xff5>
movslq -0x2cc(%rbp),%rax
movsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x248(%rbp)
ff
jmp    21aa <interpolate_skewed_map_to_cubic+0xffa>
mov    -0x2cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2cc(%rbp)
jmp    215e <interpolate_skewed_map_to_cubic+0xfae>
movsd  0xe6a(%rip),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
movl   $0x0,-0x2cc(%rbp)
cmpl   $0x8,-0x2cc(%rbp)
jge    2234 <interpolate_skewed_map_to_cubic+0x1084>
movslq -0x2cc(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x230(%rbp),%xmm0
ff
jbe    221b <interpolate_skewed_map_to_cubic+0x106b>
movslq -0x2cc(%rbp),%rax
movsd  -0x1a0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x230(%rbp)
ff
jmp    2220 <interpolate_skewed_map_to_cubic+0x1070>
mov    -0x2cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2cc(%rbp)
jmp    21d8 <interpolate_skewed_map_to_cubic+0x1028>
movsd  0xdf4(%rip),%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
movl   $0x0,-0x2cc(%rbp)
cmpl   $0x8,-0x2cc(%rbp)
jge    22aa <interpolate_skewed_map_to_cubic+0x10fa>
movslq -0x2cc(%rbp),%rax
movsd  -0x1e0(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x240(%rbp),%xmm0
ff
jbe    2291 <interpolate_skewed_map_to_cubic+0x10e1>
movslq -0x2cc(%rbp),%rax
movsd  -0x1e0(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x240(%rbp)
ff
jmp    2296 <interpolate_skewed_map_to_cubic+0x10e6>
mov    -0x2cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2cc(%rbp)
jmp    224e <interpolate_skewed_map_to_cubic+0x109e>
movsd  0xd7e(%rip),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
movl   $0x0,-0x2cc(%rbp)
cmpl   $0x8,-0x2cc(%rbp)
jge    2320 <interpolate_skewed_map_to_cubic+0x1170>
movslq -0x2cc(%rbp),%rax
movsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
ucomisd -0x250(%rbp),%xmm0
ff
jbe    2307 <interpolate_skewed_map_to_cubic+0x1157>
movslq -0x2cc(%rbp),%rax
movsd  -0x220(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x250(%rbp)
ff
jmp    230c <interpolate_skewed_map_to_cubic+0x115c>
mov    -0x2cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2cc(%rbp)
jmp    22c4 <interpolate_skewed_map_to_cubic+0x1114>
movsd  -0x50(%rbp),%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    2361 <interpolate_skewed_map_to_cubic+0x11b1>
movsd  -0x58(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x60(%rbp),%xmm1
mulsd  -0xc0(%rbp),%xmm1
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    2395 <interpolate_skewed_map_to_cubic+0x11e5>
movsd  -0x60(%rbp),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  0xc9b(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc97(%rip),%xmm1
addsd  %xmm1,%xmm0
call   10d0 <floor@plt>
movsd  0xc7e(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x320(%rbp)
ff
movsd  -0x228(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
divsd  (%rax),%xmm0
call   10d0 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0x320(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x318(%rbp)
ff
movsd  -0x238(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
divsd  (%rax),%xmm0
call   10d0 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0x318(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x310(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
divsd  (%rax),%xmm0
call   10d0 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0x310(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x230(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
divsd  (%rax),%xmm0
call   1030 <ceil@plt>
movsd  %xmm0,-0x308(%rbp)
ff
movsd  -0x228(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
divsd  (%rax),%xmm0
call   10d0 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0x308(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  0xb6d(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x240(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
divsd  (%rax),%xmm0
call   1030 <ceil@plt>
movsd  %xmm0,-0x300(%rbp)
ff
movsd  -0x238(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
divsd  (%rax),%xmm0
call   10d0 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0x300(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  0xb16(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0x250(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
divsd  (%rax),%xmm0
call   1030 <ceil@plt>
movsd  %xmm0,-0x2f8(%rbp)
ff
movsd  -0x248(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
divsd  (%rax),%xmm0
call   10d0 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0x2f8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  0xabf(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x18(%rbp),%rcx
imul   (%rcx),%eax
mov    -0x20(%rbp),%rcx
imul   (%rcx),%eax
mov    %eax,%eax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    $0x0,%al
call   10a0 <do_vect@plt>
movl   $0x0,-0x2d8(%rbp)
mov    -0x2d8(%rbp),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    2d7d <interpolate_skewed_map_to_cubic+0x1bcd>
movl   $0x0,-0x2d4(%rbp)
mov    -0x2d4(%rbp),%eax
mov    -0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    2d64 <interpolate_skewed_map_to_cubic+0x1bb4>
movl   $0x0,-0x2d0(%rbp)
mov    -0x2d0(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    2d4b <interpolate_skewed_map_to_cubic+0x1b9b>
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm1
cvtsi2sdl -0x2d0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x258(%rbp)
ff
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm1
cvtsi2sdl -0x2d4(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm1
cvtsi2sdl -0x2d8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x268(%rbp)
ff
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x258(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  -0x260(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x268(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x2e0(%rbp),%xmm0
ff
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0xd0(%rbp),%xmm1
ff
movsd  -0x258(%rbp),%xmm2
ff
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  -0x260(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
movsd  -0x268(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x2e8(%rbp),%xmm0
ff
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x278(%rbp)
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x258(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  -0x260(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x268(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
subsd  -0x2f0(%rbp),%xmm0
ff
divsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x280(%rbp)
ff
movsd  -0x270(%rbp),%xmm0
ff
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x29c(%rbp)
movsd  -0x278(%rbp),%xmm0
ff
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x2a0(%rbp)
movsd  -0x280(%rbp),%xmm0
ff
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
mov    %eax,-0x2a4(%rbp)
mov    -0x29c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a8(%rbp)
mov    -0x2a0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2ac(%rbp)
mov    -0x2a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2b0(%rbp)
cmpl   $0x0,-0x29c(%rbp)
jl     2d32 <interpolate_skewed_map_to_cubic+0x1b82>
mov    -0x2a8(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    2d32 <interpolate_skewed_map_to_cubic+0x1b82>
cmpl   $0x0,-0x2a0(%rbp)
jl     2d32 <interpolate_skewed_map_to_cubic+0x1b82>
mov    -0x2ac(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    2d32 <interpolate_skewed_map_to_cubic+0x1b82>
cmpl   $0x0,-0x2a4(%rbp)
jl     2d32 <interpolate_skewed_map_to_cubic+0x1b82>
mov    -0x2b0(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    2d32 <interpolate_skewed_map_to_cubic+0x1b82>
movsd  -0x270(%rbp),%xmm0
ff
cvtsi2sdl -0x29c(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x288(%rbp)
ff
movsd  -0x278(%rbp),%xmm0
ff
cvtsi2sdl -0x2a0(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movsd  -0x280(%rbp),%xmm0
ff
cvtsi2sdl -0x2a4(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
movsd  -0x288(%rbp),%xmm0
ff
mulsd  -0x290(%rbp),%xmm0
ff
mulsd  -0x298(%rbp),%xmm0
ff
movsd  %xmm0,-0x3d8(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x3e8(%rbp)
mov    -0x2b0(%rbp),%edi
mov    -0x2ac(%rbp),%esi
mov    -0x2a8(%rbp),%edx
mov    0x30(%rbp),%ecx
mov    0x28(%rbp),%r8d
mov    $0x0,%al
call   1080 <gidz_general@plt>
mov    %eax,%ecx
mov    -0x3e8(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x3d0(%rbp)
ff
movsd  0x71f(%rip),%xmm0
subsd  -0x288(%rbp),%xmm0
ff
mulsd  -0x290(%rbp),%xmm0
ff
mulsd  -0x298(%rbp),%xmm0
ff
movsd  %xmm0,-0x3e0(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x3c8(%rbp)
mov    -0x2b0(%rbp),%edi
mov    -0x2ac(%rbp),%esi
mov    -0x29c(%rbp),%edx
mov    0x30(%rbp),%ecx
mov    0x28(%rbp),%r8d
mov    $0x0,%al
call   1080 <gidz_general@plt>
movsd  -0x3e0(%rbp),%xmm1
ff
movsd  -0x3d8(%rbp),%xmm0
ff
movsd  -0x3d0(%rbp),%xmm2
ff
mov    %eax,%ecx
mov    -0x3c8(%rbp),%rax
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x3b8(%rbp)
ff
movsd  -0x288(%rbp),%xmm0
ff
movsd  0x68b(%rip),%xmm1
subsd  -0x290(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mulsd  -0x298(%rbp),%xmm0
ff
movsd  %xmm0,-0x3c0(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x3b0(%rbp)
mov    -0x2b0(%rbp),%edi
mov    -0x2a0(%rbp),%esi
mov    -0x2a8(%rbp),%edx
mov    0x30(%rbp),%ecx
mov    0x28(%rbp),%r8d
mov    $0x0,%al
call   1080 <gidz_general@plt>
movsd  -0x3c0(%rbp),%xmm0
ff
movsd  -0x3b8(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x3b0(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x3a0(%rbp)
ff
movsd  -0x288(%rbp),%xmm0
ff
mulsd  -0x290(%rbp),%xmm0
ff
movsd  0x5fb(%rip),%xmm1
subsd  -0x298(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x3a8(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x398(%rbp)
mov    -0x2a4(%rbp),%edi
mov    -0x2ac(%rbp),%esi
mov    -0x2a8(%rbp),%edx
mov    0x30(%rbp),%ecx
mov    0x28(%rbp),%r8d
mov    $0x0,%al
call   1080 <gidz_general@plt>
movsd  -0x3a8(%rbp),%xmm0
ff
movsd  -0x3a0(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x398(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x388(%rbp)
ff
movsd  -0x288(%rbp),%xmm0
ff
movsd  0x57b(%rip),%xmm1
subsd  -0x290(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x567(%rip),%xmm1
subsd  -0x298(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x390(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x380(%rbp)
mov    -0x2a4(%rbp),%edi
mov    -0x2a0(%rbp),%esi
mov    -0x2a8(%rbp),%edx
mov    0x30(%rbp),%ecx
mov    0x28(%rbp),%r8d
mov    $0x0,%al
call   1080 <gidz_general@plt>
movsd  -0x390(%rbp),%xmm0
ff
movsd  -0x388(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x380(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x370(%rbp)
ff
movsd  0x4ef(%rip),%xmm0
subsd  -0x288(%rbp),%xmm0
ff
mulsd  -0x290(%rbp),%xmm0
ff
movsd  0x4d7(%rip),%xmm1
subsd  -0x298(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x378(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x368(%rbp)
mov    -0x2a4(%rbp),%edi
mov    -0x2ac(%rbp),%esi
mov    -0x29c(%rbp),%edx
mov    0x30(%rbp),%ecx
mov    0x28(%rbp),%r8d
mov    $0x0,%al
call   1080 <gidz_general@plt>
movsd  -0x378(%rbp),%xmm0
ff
movsd  -0x370(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x368(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x358(%rbp)
ff
movsd  0x45f(%rip),%xmm0
subsd  -0x288(%rbp),%xmm0
ff
movsd  0x44f(%rip),%xmm1
subsd  -0x290(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mulsd  -0x298(%rbp),%xmm0
ff
movsd  %xmm0,-0x360(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x350(%rbp)
mov    -0x2b0(%rbp),%edi
mov    -0x2a0(%rbp),%esi
mov    -0x29c(%rbp),%edx
mov    0x30(%rbp),%ecx
mov    0x28(%rbp),%r8d
mov    $0x0,%al
call   1080 <gidz_general@plt>
movsd  -0x360(%rbp),%xmm0
ff
movsd  -0x358(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x350(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x340(%rbp)
ff
movsd  0x3cf(%rip),%xmm0
subsd  -0x288(%rbp),%xmm0
ff
movsd  0x3bf(%rip),%xmm1
subsd  -0x290(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0x3ab(%rip),%xmm1
subsd  -0x298(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x348(%rbp)
ff
mov    0x20(%rbp),%rax
mov    %rax,-0x338(%rbp)
mov    -0x2a4(%rbp),%edi
mov    -0x2a0(%rbp),%esi
mov    -0x29c(%rbp),%edx
mov    0x30(%rbp),%ecx
mov    0x28(%rbp),%r8d
mov    $0x0,%al
call   1080 <gidz_general@plt>
movsd  -0x348(%rbp),%xmm0
ff
movsd  -0x340(%rbp),%xmm1
ff
mov    %eax,%ecx
mov    -0x338(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x330(%rbp)
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x328(%rbp)
mov    -0x2d8(%rbp),%edi
mov    -0x2d4(%rbp),%esi
mov    -0x2d0(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
mov    (%rax),%r8d
mov    $0x0,%al
call   1080 <gidz_general@plt>
movsd  -0x330(%rbp),%xmm0
ff
mov    %eax,%ecx
mov    -0x328(%rbp),%rax
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2d37 <interpolate_skewed_map_to_cubic+0x1b87>
mov    -0x2d0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2d0(%rbp)
jmp    25f2 <interpolate_skewed_map_to_cubic+0x1442>
jmp    2d50 <interpolate_skewed_map_to_cubic+0x1ba0>
mov    -0x2d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2d4(%rbp)
jmp    25d6 <interpolate_skewed_map_to_cubic+0x1426>
jmp    2d69 <interpolate_skewed_map_to_cubic+0x1bb9>
mov    -0x2d8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2d8(%rbp)
jmp    25ba <interpolate_skewed_map_to_cubic+0x140a>
lea    0x2e4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
add    $0x3f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<interpolate_skewed_map_to_cubic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
movsd  %xmm7,(%rsp)
movsd  %xmm6,0x20(%rsp)
movaps %xmm5,0x170(%rsp)
movaps %xmm4,0xf0(%rsp)
movsd  %xmm3,0xa0(%rsp)
movsd  %xmm2,0x70(%rsp)
movsd  %xmm1,0x60(%rsp)
movsd  %xmm0,0xe0(%rsp)
mov    %r9,0x1a8(%rsp)
mov    %r8,0x1a0(%rsp)
mov    %rcx,0x190(%rsp)
mov    %rdx,0x90(%rsp)
mov    %rsi,0x108(%rsp)
mov    %rdi,0x198(%rsp)
movsd  0x298(%rsp),%xmm0
mulsd  0x1dc5(%rip),%xmm0
divsd  0x1dc5(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
call   1090 <cos@plt>
movapd %xmm0,0x50(%rsp)
movsd  0x10(%rsp),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,0x40(%rsp)
movsd  0x20(%rsp),%xmm0
addsd  0x298(%rsp),%xmm0
mulsd  0x1d84(%rip),%xmm0
divsd  0x1d84(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
call   1090 <cos@plt>
movsd  %xmm0,0xc0(%rsp)
movsd  0x10(%rsp),%xmm0
call   1060 <sin@plt>
movaps %xmm0,0x80(%rsp)
movsd  0x298(%rsp),%xmm0
subsd  0x20(%rsp),%xmm0
mulsd  0x1d3e(%rip),%xmm0
divsd  0x1d3e(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
call   1090 <cos@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x10(%rsp),%xmm0
call   1060 <sin@plt>
movsd  %xmm0,0xb0(%rsp)
movsd  (%rsp),%xmm0
mulsd  0x1d04(%rip),%xmm0
divsd  0x1d04(%rip),%xmm0
movsd  %xmm0,(%rsp)
call   1090 <cos@plt>
movapd %xmm0,0x180(%rsp)
movsd  (%rsp),%xmm0
call   1060 <sin@plt>
movaps %xmm0,0x160(%rsp)
movsd  (%rsp),%xmm0
call   1090 <cos@plt>
movaps %xmm0,0x30(%rsp)
movsd  (%rsp),%xmm0
call   1060 <sin@plt>
movapd 0x30(%rsp),%xmm10
movsd  0xb0(%rsp),%xmm8
movapd 0x180(%rsp),%xmm11
movapd 0x160(%rsp),%xmm6
movsd  0x20(%rsp),%xmm9
movsd  0xc0(%rsp),%xmm13
movapd 0x80(%rsp),%xmm3
movapd 0x1cc7(%rip),%xmm12
movapd %xmm0,%xmm2
xorpd  %xmm12,%xmm2
movapd %xmm9,%xmm14
subsd  %xmm13,%xmm14
movapd %xmm8,%xmm5
subsd  %xmm3,%xmm5
unpcklpd %xmm10,%xmm2
movapd %xmm6,%xmm1
unpcklpd %xmm11,%xmm1
subpd  %xmm1,%xmm2
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
mulsd  %xmm5,%xmm1
xorpd  %xmm12,%xmm5
movapd %xmm2,%xmm7
mulsd  %xmm14,%xmm7
subsd  %xmm1,%xmm7
movapd 0x1c83(%rip),%xmm4
andpd  %xmm7,%xmm4
movsd  0x1c27(%rip),%xmm1
ucomisd %xmm4,%xmm1
jbe    1492 <interpolate_skewed_map_to_cubic+0x2e2>
lea    0x1ca6(%rip),%rsi
mov    $0x116a2,%edi
xor    %eax,%eax
movapd %xmm2,0x10(%rsp)
movapd %xmm5,(%rsp)
movapd %xmm14,0x150(%rsp)
movapd %xmm0,0x140(%rsp)
movapd %xmm7,0x130(%rsp)
call   1070 <error_divide_zero@plt>
movapd 0x130(%rsp),%xmm7
movapd 0x140(%rsp),%xmm0
movapd 0x150(%rsp),%xmm14
movapd 0x30(%rsp),%xmm10
movapd (%rsp),%xmm5
movsd  0xb0(%rsp),%xmm8
movapd 0x180(%rsp),%xmm11
movapd 0x160(%rsp),%xmm6
movsd  0x20(%rsp),%xmm9
movsd  0xc0(%rsp),%xmm13
movapd 0x80(%rsp),%xmm3
movapd 0x10(%rsp),%xmm2
mulsd  %xmm8,%xmm13
mulsd  %xmm9,%xmm3
subsd  %xmm13,%xmm3
mulsd  %xmm0,%xmm11
mulsd  %xmm10,%xmm6
addsd  %xmm11,%xmm6
xorpd  0x1b97(%rip),%xmm14
unpcklpd %xmm6,%xmm6
unpcklpd %xmm14,%xmm5
mulpd  %xmm6,%xmm5
unpcklpd %xmm3,%xmm3
mulpd  %xmm3,%xmm2
addpd  %xmm5,%xmm2
unpcklpd %xmm7,%xmm7
divpd  %xmm7,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm2,%xmm10
unpckhpd %xmm2,%xmm10
movapd %xmm10,%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
movsd  0x1b16(%rip),%xmm0
subsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm2,0x10(%rsp)
movapd %xmm10,0x20(%rsp)
jbe    154b <interpolate_skewed_map_to_cubic+0x39b>
lea    0x1b7c(%rip),%rsi
mov    $0x116ac,%edi
xor    %eax,%eax
movsd  %xmm0,(%rsp)
call   10c0 <error_sqrt_negative@plt>
xorpd  %xmm1,%xmm1
movsd  (%rsp),%xmm0
movapd 0x20(%rsp),%xmm10
movapd 0x10(%rsp),%xmm2
mov    0x290(%rsp),%r14d
mov    0x288(%rsp),%ebp
mov    0x280(%rsp),%ebx
ucomisd %xmm1,%xmm0
jb     1572 <interpolate_skewed_map_to_cubic+0x3c2>
xorps  %xmm8,%xmm8
sqrtsd %xmm0,%xmm8
jmp    1589 <interpolate_skewed_map_to_cubic+0x3d9>
call   10b0 <sqrt@plt>
movapd 0x20(%rsp),%xmm10
movapd 0x10(%rsp),%xmm2
movapd %xmm0,%xmm8
movapd 0xf0(%rsp),%xmm1
movapd 0x50(%rsp),%xmm9
movsd  0x70(%rsp),%xmm5
movsd  0x60(%rsp),%xmm4
movsd  0xe0(%rsp),%xmm3
mov    0x278(%rsp),%r15d
movapd %xmm9,%xmm6
movapd 0x1a8c(%rip),%xmm11
xorpd  %xmm11,%xmm6
movsd  0x40(%rsp),%xmm7
divsd  %xmm7,%xmm6
movapd %xmm6,0x160(%rsp)
movsd  0x1a34(%rip),%xmm0
divsd  %xmm7,%xmm0
movapd %xmm0,0xd0(%rsp)
movapd %xmm7,%xmm0
mulsd  %xmm10,%xmm0
mulsd  %xmm2,%xmm9
subsd  %xmm0,%xmm9
movapd %xmm7,%xmm0
mulsd  %xmm8,%xmm0
divsd  %xmm0,%xmm9
movapd %xmm9,0x180(%rsp)
xorpd  %xmm2,%xmm11
movapd 0x1a47(%rip),%xmm6
unpcklpd %xmm11,%xmm6
movapd %xmm8,0xc0(%rsp)
unpcklpd %xmm0,%xmm8
divpd  %xmm8,%xmm6
movapd %xmm6,0x80(%rsp)
lea    0x118(%rsp),%rcx
lea    0x110(%rsp),%r8
lea    0xa8(%rsp),%r9
mov    %ebx,%edi
mov    %ebp,%esi
mov    %r14d,%edx
movsd  0xa0(%rsp),%xmm0
movapd 0x170(%rsp),%xmm2
mov    $0x6,%al
call   1050 <set_origin_get_mode@plt>
movapd 0x80(%rsp),%xmm6
movsd  0x118(%rsp),%xmm3
movsd  0x110(%rsp),%xmm4
test   %eax,%eax
je     1738 <interpolate_skewed_map_to_cubic+0x588>
movapd 0x160(%rsp),%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm3,%xmm1
movsd  0xa8(%rsp),%xmm11
movapd 0x180(%rsp),%xmm2
mulsd  %xmm11,%xmm2
addsd  %xmm1,%xmm2
movapd 0xd0(%rsp),%xmm1
mulsd  %xmm4,%xmm1
xorpd  %xmm8,%xmm8
mulsd  %xmm8,%xmm3
addsd  %xmm3,%xmm1
movapd %xmm6,%xmm5
unpckhpd %xmm6,%xmm5
mulsd  %xmm11,%xmm5
addsd  %xmm1,%xmm5
mulsd  %xmm8,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm6,%xmm11
addsd  %xmm4,%xmm11
movsd  %xmm2,0x118(%rsp)
movsd  %xmm5,0x110(%rsp)
movsd  %xmm11,0xa8(%rsp)
movapd %xmm5,%xmm4
movapd %xmm2,%xmm3
jmp    1742 <interpolate_skewed_map_to_cubic+0x592>
movsd  0xa8(%rsp),%xmm11
movsd  %xmm3,(%rsp)
mov    0x268(%rsp),%eax
add    $0xffffffff,%eax
cvtsi2sd %rax,%xmm13
mulsd  0xa0(%rsp),%xmm13
addsd  %xmm3,%xmm13
mov    0x270(%rsp),%eax
lea    -0x1(%rax),%eax
cvtsi2sd %rax,%xmm12
mulsd  0xf0(%rsp),%xmm12
addsd  %xmm4,%xmm12
lea    -0x1(%r15),%eax
xorps  %xmm6,%xmm6
cvtsi2sd %rax,%xmm6
mulsd  0x170(%rsp),%xmm6
addsd  %xmm11,%xmm6
movapd 0x50(%rsp),%xmm0
movapd %xmm0,%xmm15
mulsd  %xmm4,%xmm15
movapd %xmm3,%xmm10
addsd  %xmm15,%xmm10
movsd  0x40(%rsp),%xmm2
mulsd  %xmm4,%xmm2
xorpd  %xmm1,%xmm1
movapd %xmm3,%xmm9
mulsd  %xmm1,%xmm9
xorpd  %xmm5,%xmm5
movapd %xmm9,%xmm1
addsd  %xmm2,%xmm1
movapd %xmm11,%xmm7
unpcklpd %xmm11,%xmm7
movapd %xmm1,0x30(%rsp)
unpcklpd %xmm10,%xmm1
movapd 0x10(%rsp),%xmm14
movapd %xmm14,%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm1,%xmm3
mulsd  %xmm5,%xmm4
movapd %xmm9,%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,0x60(%rsp)
movapd 0xc0(%rsp),%xmm1
mulsd  %xmm11,%xmm1
movapd %xmm1,0xb0(%rsp)
addsd  %xmm13,%xmm15
movapd 0x20(%rsp),%xmm8
movapd %xmm8,%xmm5
mulsd  %xmm11,%xmm5
movapd %xmm5,%xmm1
addsd  %xmm15,%xmm1
movsd  %xmm1,0x150(%rsp)
mulsd  %xmm12,%xmm0
movsd  (%rsp),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rsp)
addsd  %xmm13,%xmm0
movapd %xmm13,%xmm1
xorpd  %xmm13,%xmm13
mulsd  %xmm13,%xmm1
addsd  %xmm1,%xmm2
movsd  %xmm2,0x50(%rsp)
movapd %xmm0,%xmm2
mulsd  %xmm14,%xmm11
movapd %xmm11,%xmm0
addsd  %xmm1,%xmm4
movapd %xmm5,%xmm7
addsd  (%rsp),%xmm7
movsd  %xmm7,0x140(%rsp)
movsd  0x40(%rsp),%xmm7
mulsd  %xmm12,%xmm7
mulsd  %xmm13,%xmm12
movapd %xmm9,%xmm11
addsd  %xmm7,%xmm11
addsd  %xmm12,%xmm9
mulsd  %xmm6,%xmm8
addsd  %xmm8,%xmm10
movapd %xmm10,0x70(%rsp)
mulsd  %xmm6,%xmm14
mulsd  0xc0(%rsp),%xmm6
addsd  %xmm2,%xmm5
movsd  %xmm5,0x98(%rsp)
addsd  %xmm1,%xmm7
addsd  %xmm1,%xmm12
movsd  (%rsp),%xmm1
addsd  %xmm8,%xmm1
movsd  %xmm1,(%rsp)
addsd  %xmm8,%xmm15
movapd %xmm15,0x130(%rsp)
movapd %xmm3,%xmm1
cmpltpd 0x1755(%rip),%xmm1
movmskpd %xmm1,%eax
movapd %xmm3,0x1b0(%rsp)
unpckhpd %xmm3,%xmm3
movapd %xmm3,0x1e0(%rsp)
test   $0x2,%al
jne    1951 <interpolate_skewed_map_to_cubic+0x7a1>
movsd  0x16cf(%rip),%xmm3
movsd  %xmm3,0x10(%rsp)
mov    0x258(%rsp),%rbx
mov    0x250(%rsp),%rbp
movapd 0xb0(%rsp),%xmm13
movapd %xmm13,%xmm1
movsd  0x60(%rsp),%xmm15
addsd  %xmm15,%xmm1
movapd %xmm1,0x120(%rsp)
movapd %xmm0,%xmm1
movsd  0x50(%rsp),%xmm10
addsd  %xmm10,%xmm1
movapd %xmm1,0x1f0(%rsp)
movapd %xmm13,%xmm1
addsd  %xmm4,%xmm1
movapd %xmm1,0x200(%rsp)
addsd  %xmm2,%xmm8
movapd %xmm8,0x20(%rsp)
movapd %xmm0,%xmm1
addsd  %xmm11,%xmm1
movapd 0x30(%rsp),%xmm3
addsd  %xmm14,%xmm3
addsd  %xmm7,%xmm0
addsd  %xmm14,%xmm11
addsd  %xmm14,%xmm10
addsd  %xmm7,%xmm14
movapd %xmm13,%xmm5
addsd  %xmm9,%xmm5
addsd  %xmm6,%xmm15
addsd  %xmm12,%xmm13
movapd %xmm13,0xb0(%rsp)
addsd  %xmm6,%xmm9
addsd  %xmm6,%xmm4
movsd  %xmm4,0x1c8(%rsp)
addsd  %xmm12,%xmm6
movsd  %xmm6,0x30(%rsp)
movsd  0x150(%rsp),%xmm6
minsd  0x10(%rsp),%xmm6
movsd  0x140(%rsp),%xmm7
minsd  %xmm6,%xmm7
movapd 0x70(%rsp),%xmm6
minsd  %xmm7,%xmm6
movsd  0x98(%rsp),%xmm7
minsd  %xmm6,%xmm7
movapd %xmm14,%xmm8
movsd  (%rsp),%xmm2
minsd  %xmm7,%xmm2
movapd 0x130(%rsp),%xmm7
minsd  %xmm2,%xmm7
movapd %xmm7,0x1d0(%rsp)
movapd 0x1b0(%rsp),%xmm7
test   $0x1,%al
movapd %xmm15,%xmm12
movapd %xmm3,%xmm15
movapd %xmm10,%xmm4
movapd %xmm9,%xmm10
jne    1aa4 <interpolate_skewed_map_to_cubic+0x8f4>
movsd  0x157c(%rip),%xmm7
movapd 0x1f0(%rsp),%xmm14
movapd %xmm14,%xmm2
minsd  %xmm7,%xmm2
movapd %xmm1,%xmm7
minsd  %xmm2,%xmm7
movapd %xmm15,%xmm2
minsd  %xmm7,%xmm2
movapd %xmm0,%xmm7
minsd  %xmm2,%xmm7
movapd %xmm11,%xmm2
minsd  %xmm7,%xmm2
movapd %xmm4,%xmm7
minsd  %xmm2,%xmm7
movapd %xmm8,%xmm2
minsd  %xmm7,%xmm2
movapd %xmm2,0xe0(%rsp)
movsd  %xmm4,0x50(%rsp)
movapd 0x120(%rsp),%xmm4
movapd %xmm4,%xmm2
minsd  0x1512(%rip),%xmm2
movapd 0x200(%rsp),%xmm9
movapd %xmm9,%xmm7
minsd  %xmm2,%xmm7
movapd %xmm5,%xmm2
minsd  %xmm7,%xmm2
movapd %xmm12,%xmm7
minsd  %xmm2,%xmm7
movapd %xmm8,0x10(%rsp)
movapd 0xb0(%rsp),%xmm6
movapd %xmm6,%xmm2
minsd  %xmm7,%xmm2
movapd %xmm10,%xmm7
minsd  %xmm2,%xmm7
movsd  0x1c8(%rsp),%xmm8
movapd %xmm8,%xmm2
minsd  %xmm7,%xmm2
movsd  0x30(%rsp),%xmm3
movapd %xmm3,%xmm7
minsd  %xmm2,%xmm7
movsd  %xmm7,0x60(%rsp)
movapd 0x1e0(%rsp),%xmm7
maxsd  0x149d(%rip),%xmm7
movsd  0x150(%rsp),%xmm2
maxsd  %xmm7,%xmm2
movapd %xmm3,%xmm7
movsd  0x140(%rsp),%xmm13
maxsd  %xmm2,%xmm13
movapd 0x70(%rsp),%xmm2
maxsd  %xmm13,%xmm2
movsd  0x98(%rsp),%xmm3
maxsd  %xmm2,%xmm3
movsd  (%rsp),%xmm2
maxsd  %xmm3,%xmm2
movapd %xmm5,%xmm13
movapd %xmm0,%xmm5
movapd 0x130(%rsp),%xmm0
maxsd  %xmm2,%xmm0
movapd 0x20(%rsp),%xmm2
movapd %xmm2,%xmm3
maxsd  %xmm0,%xmm3
movsd  %xmm3,0x70(%rsp)
movapd 0x1b0(%rsp),%xmm3
maxsd  0x1421(%rip),%xmm3
maxsd  %xmm3,%xmm14
maxsd  %xmm14,%xmm1
maxsd  %xmm1,%xmm15
maxsd  %xmm15,%xmm5
maxsd  %xmm5,%xmm11
movsd  0x50(%rsp),%xmm0
maxsd  %xmm11,%xmm0
movapd 0x10(%rsp),%xmm1
maxsd  %xmm0,%xmm1
movapd %xmm1,0x10(%rsp)
maxsd  0x13e5(%rip),%xmm4
maxsd  %xmm4,%xmm9
maxsd  %xmm9,%xmm13
maxsd  %xmm13,%xmm12
maxsd  %xmm12,%xmm6
maxsd  %xmm6,%xmm10
maxsd  %xmm10,%xmm8
maxsd  %xmm8,%xmm7
movsd  %xmm7,0x30(%rsp)
minsd  0x1d0(%rsp),%xmm2
movapd %xmm2,0x20(%rsp)
movsd  0x40(%rsp),%xmm1
mulsd  0xf0(%rsp),%xmm1
minsd  0xa0(%rsp),%xmm1
movapd 0xc0(%rsp),%xmm0
mulsd  0x170(%rsp),%xmm0
minsd  %xmm1,%xmm0
mulsd  0x137f(%rip),%xmm0
addsd  0x137f(%rip),%xmm0
call   10d0 <floor@plt>
movapd %xmm0,%xmm1
divsd  0x1366(%rip),%xmm1
movsd  %xmm1,(%rsp)
movsd  %xmm1,(%rbx)
movapd 0x20(%rsp),%xmm0
divsd  %xmm1,%xmm0
call   10d0 <floor@plt>
mulsd  (%rsp),%xmm0
mov    0x1a0(%rsp),%rax
movsd  %xmm0,(%rax)
movsd  (%rbx),%xmm1
movsd  %xmm1,(%rsp)
movapd 0xe0(%rsp),%xmm0
divsd  %xmm1,%xmm0
call   10d0 <floor@plt>
mulsd  (%rsp),%xmm0
mov    0x1a8(%rsp),%rax
movsd  %xmm0,(%rax)
movsd  (%rbx),%xmm1
movsd  %xmm1,(%rsp)
movsd  0x60(%rsp),%xmm0
divsd  %xmm1,%xmm0
call   10d0 <floor@plt>
mulsd  (%rsp),%xmm0
movsd  %xmm0,0x0(%rbp)
movsd  (%rbx),%xmm1
movsd  %xmm1,(%rsp)
movsd  0x70(%rsp),%xmm0
divsd  %xmm1,%xmm0
call   1040 <ceil@plt>
movsd  %xmm0,0x40(%rsp)
movapd 0x20(%rsp),%xmm0
divsd  (%rsp),%xmm0
call   10d0 <floor@plt>
movsd  0x40(%rsp),%xmm1
subsd  %xmm0,%xmm1
addsd  0x12bf(%rip),%xmm1
cvttsd2si %xmm1,%eax
mov    0x108(%rsp),%r14
mov    %eax,(%r14)
movapd 0x10(%rsp),%xmm0
divsd  (%rsp),%xmm0
call   1040 <ceil@plt>
movsd  %xmm0,0x20(%rsp)
movapd 0xe0(%rsp),%xmm0
divsd  (%rsp),%xmm0
call   10d0 <floor@plt>
movsd  0x20(%rsp),%xmm1
subsd  %xmm0,%xmm1
addsd  0x1275(%rip),%xmm1
cvttsd2si %xmm1,%eax
mov    0x90(%rsp),%rbp
mov    %eax,0x0(%rbp)
movsd  0x30(%rsp),%xmm0
divsd  (%rsp),%xmm0
call   1040 <ceil@plt>
movsd  %xmm0,0x20(%rsp)
movsd  0x60(%rsp),%xmm0
divsd  (%rsp),%xmm0
call   10d0 <floor@plt>
movsd  0x20(%rsp),%xmm1
subsd  %xmm0,%xmm1
addsd  0x122e(%rip),%xmm1
cvttsd2si %xmm1,%eax
mov    0x190(%rsp),%rbx
mov    %eax,(%rbx)
mov    0x0(%rbp),%esi
imul   (%r14),%esi
imul   %eax,%esi
mov    0x198(%rsp),%rdi
xor    %eax,%eax
call   10a0 <do_vect@plt>
mov    (%rbx),%ecx
test   %ecx,%ecx
movapd 0x160(%rsp),%xmm2
movapd 0x80(%rsp),%xmm3
jle    24b1 <interpolate_skewed_map_to_cubic+0x1301>
mov    0x90(%rsp),%rax
mov    (%rax),%eax
xorpd  %xmm0,%xmm0
unpcklpd 0xd0(%rsp),%xmm0
movapd %xmm0,0xb0(%rsp)
movaps 0x170(%rsp),%xmm0
unpcklpd 0xf0(%rsp),%xmm0
movaps %xmm0,0x170(%rsp)
mov    0x270(%rsp),%edx
movd   %edx,%xmm0
movd   %r15d,%xmm1
punpckldq %xmm0,%xmm1
movdqa %xmm1,0xe0(%rsp)
movl   $0x0,0x120(%rsp)
jmp    1ee3 <interpolate_skewed_map_to_cubic+0xd33>
nopl   0x0(%rax,%rax,1)
mov    0x190(%rsp),%rcx
mov    (%rcx),%ecx
mov    0x120(%rsp),%edx
add    $0x1,%edx
mov    %edx,0x120(%rsp)
cmp    %ecx,%edx
jge    24b1 <interpolate_skewed_map_to_cubic+0x1301>
test   %eax,%eax
jle    1eca <interpolate_skewed_map_to_cubic+0xd1a>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x120(%rsp),%xmm0
movsd  %xmm0,0xc0(%rsp)
mov    0x108(%rsp),%rcx
mov    (%rcx),%r13d
movl   $0x0,0xd0(%rsp)
jmp    1f3f <interpolate_skewed_map_to_cubic+0xd8f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x90(%rsp),%rax
mov    (%rax),%eax
mov    0xd0(%rsp),%ecx
add    $0x1,%ecx
mov    %ecx,0xd0(%rsp)
cmp    %eax,%ecx
jge    1ec0 <interpolate_skewed_map_to_cubic+0xd10>
test   %r13d,%r13d
jle    1f2a <interpolate_skewed_map_to_cubic+0xd7a>
xorps  %xmm0,%xmm0
cvtsi2sdl 0xd0(%rsp),%xmm0
movsd  %xmm0,0xf0(%rsp)
xor    %r12d,%r12d
jmp    1f7b <interpolate_skewed_map_to_cubic+0xdcb>
xchg   %ax,%ax
movapd 0x80(%rsp),%xmm3
add    $0x1,%r12d
cmp    %r13d,%r12d
movapd 0x160(%rsp),%xmm2
jge    1f20 <interpolate_skewed_map_to_cubic+0xd70>
xorps  %xmm4,%xmm4
cvtsi2sd %r12d,%xmm4
mov    0x258(%rsp),%rax
movsd  (%rax),%xmm5
mulsd  %xmm5,%xmm4
mov    0x1a0(%rsp),%rax
addsd  (%rax),%xmm4
movsd  0xf0(%rsp),%xmm1
mulsd  %xmm5,%xmm1
mov    0x1a8(%rsp),%rax
addsd  (%rax),%xmm1
mulsd  0xc0(%rsp),%xmm5
mov    0x250(%rsp),%rax
addsd  (%rax),%xmm5
mulsd  %xmm1,%xmm2
addsd  %xmm4,%xmm2
movapd 0x180(%rsp),%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
subsd  0x118(%rsp),%xmm0
divsd  0xa0(%rsp),%xmm0
unpcklpd %xmm1,%xmm1
mulpd  0xb0(%rsp),%xmm1
mulsd  0x103b(%rip),%xmm4
unpcklpd %xmm4,%xmm4
addpd  %xmm1,%xmm4
unpcklpd %xmm5,%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm4,%xmm5
movsd  0xa8(%rsp),%xmm1
movhpd 0x110(%rsp),%xmm1
subpd  %xmm1,%xmm5
divpd  0x170(%rsp),%xmm5
movapd %xmm5,(%rsp)
movapd %xmm0,0x20(%rsp)
call   10d0 <floor@plt>
cvttsd2si %xmm0,%r15d
movaps (%rsp),%xmm0
call   10d0 <floor@plt>
movaps %xmm0,0x40(%rsp)
movapd (%rsp),%xmm0
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
call   10d0 <floor@plt>
test   %r15d,%r15d
js     1f60 <interpolate_skewed_map_to_cubic+0xdb0>
lea    0x1(%r15),%ebp
mov    0x268(%rsp),%eax
cmp    %eax,%ebp
jge    1f60 <interpolate_skewed_map_to_cubic+0xdb0>
movapd 0x40(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
cvttpd2dq %xmm1,%xmm1
pshufd $0x55,%xmm1,%xmm0
movd   %xmm0,%ebx
test   %ebx,%ebx
js     1f60 <interpolate_skewed_map_to_cubic+0xdb0>
movdqa %xmm1,%xmm0
psubd  0xfd2(%rip),%xmm0
movdqa 0xe0(%rsp),%xmm2
pcmpgtd %xmm0,%xmm2
pshufd $0x50,%xmm2,%xmm2
movmskpd %xmm2,%eax
test   $0x2,%al
movapd 0x80(%rsp),%xmm3
je     1f69 <interpolate_skewed_map_to_cubic+0xdb9>
movd   %xmm1,%ecx
test   %ecx,%ecx
js     1f69 <interpolate_skewed_map_to_cubic+0xdb9>
test   $0x1,%al
je     1f69 <interpolate_skewed_map_to_cubic+0xdb9>
xorps  %xmm1,%xmm1
cvtsi2sd %r15d,%xmm1
movapd 0x20(%rsp),%xmm3
subsd  %xmm1,%xmm3
movapd %xmm3,0x20(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
movapd 0x10(%rsp),%xmm4
subsd  %xmm1,%xmm4
movapd %xmm4,0x10(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
movapd (%rsp),%xmm2
subsd  %xmm1,%xmm2
movapd %xmm2,(%rsp)
movapd %xmm3,%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm1,0x50(%rsp)
mulsd  %xmm1,%xmm2
movapd %xmm2,0x30(%rsp)
mov    %ecx,0x130(%rsp)
movd   %xmm0,%r13d
pshufd $0x55,%xmm0,%xmm0
mov    %ebx,0x1b0(%rsp)
movd   %xmm0,%r14d
mov    %r13d,%edi
mov    %r14d,%esi
mov    %ebp,%edx
mov    0x270(%rsp),%eax
mov    %rax,%rcx
mov    0x268(%rsp),%eax
mov    %rax,%r8
xor    %eax,%eax
call   1080 <gidz_general@plt>
cltq
movsd  0xe79(%rip),%xmm0
subsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x150(%rsp)
movapd 0x10(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,0x40(%rsp)
movapd (%rsp),%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm0,0x70(%rsp)
mov    0x260(%rsp),%rcx
movapd 0x30(%rsp),%xmm0
mulsd  (%rcx,%rax,8),%xmm0
movapd %xmm0,0x30(%rsp)
mov    %r13d,%edi
mov    %r13d,0x140(%rsp)
mov    %r14d,0x98(%rsp)
mov    %r14d,%esi
mov    %r15d,%edx
mov    0x270(%rsp),%ecx
mov    0x268(%rsp),%r8d
xor    %eax,%eax
call   1080 <gidz_general@plt>
cltq
movapd 0x70(%rsp),%xmm0
mov    0x260(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm0
addsd  0x30(%rsp),%xmm0
movapd %xmm0,0x70(%rsp)
movsd  0xdda(%rip),%xmm1
subsd  0x10(%rsp),%xmm1
movsd  %xmm1,0x10(%rsp)
movapd 0x20(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm0,0x20(%rsp)
movapd (%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,0x60(%rsp)
mov    %r13d,%edi
mov    %ebx,%esi
mov    %ebp,%edx
mov    0x270(%rsp),%eax
mov    %rax,%rcx
mov    0x268(%rsp),%eax
mov    %rax,%r8
xor    %eax,%eax
call   1080 <gidz_general@plt>
cltq
mov    0x260(%rsp),%r13
movapd 0x60(%rsp),%xmm0
mulsd  0x0(%r13,%rax,8),%xmm0
addsd  0x70(%rsp),%xmm0
movapd %xmm0,0x60(%rsp)
movsd  0xd62(%rip),%xmm1
subsd  (%rsp),%xmm1
movsd  %xmm1,0x30(%rsp)
movapd 0x50(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm0,0x50(%rsp)
mov    0x130(%rsp),%ebx
mov    %ebx,%edi
mov    %r14d,%esi
mov    %ebp,%edx
mov    0x270(%rsp),%ecx
mov    0x268(%rsp),%r8d
xor    %eax,%eax
call   1080 <gidz_general@plt>
cltq
movapd 0x50(%rsp),%xmm0
mulsd  0x0(%r13,%rax,8),%xmm0
addsd  0x60(%rsp),%xmm0
movapd %xmm0,0x50(%rsp)
movapd 0x20(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
movapd %xmm0,0x20(%rsp)
mov    %ebx,%edi
mov    %ebx,%r14d
mov    0x1b0(%rsp),%ebx
mov    %ebx,%esi
mov    %ebp,%edx
mov    0x270(%rsp),%r13d
mov    %r13d,%ecx
mov    0x268(%rsp),%r8d
xor    %eax,%eax
call   1080 <gidz_general@plt>
cltq
movapd 0x20(%rsp),%xmm0
mov    0x260(%rsp),%rbp
mulsd  0x0(%rbp,%rax,8),%xmm0
addsd  0x50(%rsp),%xmm0
movapd %xmm0,0x20(%rsp)
movapd 0x40(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
movapd %xmm0,0x40(%rsp)
mov    %r14d,%edi
mov    0x98(%rsp),%esi
mov    %r15d,%edx
mov    %r13d,%ecx
mov    0x268(%rsp),%r8d
xor    %eax,%eax
call   1080 <gidz_general@plt>
cltq
movapd 0x40(%rsp),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
addsd  0x20(%rsp),%xmm0
movapd %xmm0,0x40(%rsp)
movsd  0x10(%rsp),%xmm1
mulsd  0x150(%rsp),%xmm1
movsd  %xmm1,0x10(%rsp)
movapd (%rsp),%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm0,(%rsp)
mov    0x140(%rsp),%edi
mov    %ebx,%esi
mov    %r15d,%edx
mov    %r13d,%ecx
mov    0x268(%rsp),%r13d
mov    %r13d,%r8d
xor    %eax,%eax
call   1080 <gidz_general@plt>
cltq
movapd (%rsp),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
addsd  0x40(%rsp),%xmm0
movapd %xmm0,(%rsp)
movsd  0x10(%rsp),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r15d,%edx
mov    0x270(%rsp),%ecx
mov    %r13d,%r8d
xor    %eax,%eax
call   1080 <gidz_general@plt>
cltq
movsd  0x10(%rsp),%xmm0
mulsd  0x0(%rbp,%rax,8),%xmm0
addsd  (%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x198(%rsp),%rax
mov    (%rax),%rbx
mov    0x90(%rsp),%rax
mov    (%rax),%ecx
mov    0x108(%rsp),%rbp
mov    0x0(%rbp),%r8d
mov    0x120(%rsp),%edi
mov    0xd0(%rsp),%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1080 <gidz_general@plt>
movapd 0x80(%rsp),%xmm3
cltq
movq   0x10(%rsp),%xmm0
movq   %xmm0,(%rbx,%rax,8)
mov    0x0(%rbp),%r13d
jmp    1f69 <interpolate_skewed_map_to_cubic+0xdb9>
lea    0xbf0(%rip),%rdi
call   1030 <puts@plt>
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [8 x i8] c"lib_vio\00"
@str = [49 x i8] c"lib_vio> Conversion to cubic lattice completed. \00"
define void @interpolate_skewed_map_to_cubic(double** %0, i32* nocapture %1, i32* nocapture %2, i32* nocapture %3, double* nocapture %4, double* nocapture %5, double* nocapture %6, double* nocapture %7, double* nocapture %8, i32 %9, i32 %10, i32 %11, i32 %12, i32 %13, i32 %14, double %15, double %16, double %17, double %18, double %19, double %20, double %21, double %22, double %23) {
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = bitcast double* %25 to i8*
%29 = bitcast double* %26 to i8*
%30 = bitcast double* %27 to i8*
%31 = fmul double %23, 0x400921FB54442D18
%32 = fdiv double %31, 1.800000e+02
%33 = tail call double @cos(double %32)
%34 = tail call double @sin(double %32)
%35 = fadd double %21, %23
%36 = fmul double %35, 0x400921FB54442D18
%37 = fdiv double %36, 1.800000e+02
%38 = tail call double @cos(double %37)
%39 = tail call double @sin(double %37)
%40 = fsub double %23, %21
%41 = fmul double %40, 0x400921FB54442D18
%42 = fdiv double %41, 1.800000e+02
%43 = tail call double @cos(double %42)
%44 = tail call double @sin(double %42)
%45 = fmul double %22, 0x400921FB54442D18
%46 = fdiv double %45, 1.800000e+02
%47 = tail call double @cos(double %46)
%48 = tail call double @sin(double %46)
%49 = tail call double @cos(double %46)
%50 = tail call double @sin(double %46)
%51 = fneg double %50
%52 = fsub double %43, %38
%53 = fsub double %44, %39
%54 = insertelement <2 x double> poison, double %51, i64 0
%55 = insertelement <2 x double> %54, double %49, i64 1
%56 = insertelement <2 x double> poison, double %48, i64 0
%57 = insertelement <2 x double> %56, double %47, i64 1
%58 = fsub <2 x double> %55, %57
%59 = fneg double %53
%60 = extractelement <2 x double> %58, i64 1
%61 = fmul double %60, %59
%62 = extractelement <2 x double> %58, i64 0
%63 = tail call double @llvm.fmuladd.f64(double %62, double %52, double %61)
%64 = tail call double @llvm.fabs.f64(double %63)
%65 = fcmp olt double %64, 1.000000e-15
br i1 %65, label %66, label %68
66: ; preds = %24
%67 = tail call i32 (i32, i8*, ...) bitcast (i32 (...)* @error_divide_zero to i32 (i32, i8*, ...)*)(i32 71330, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
br label %68
68: ; preds = %66, %24
%69 = fneg double %44
%70 = fmul double %38, %69
%71 = tail call double @llvm.fmuladd.f64(double %39, double %43, double %70)
%72 = fmul double %47, %50
%73 = tail call double @llvm.fmuladd.f64(double %48, double %49, double %72)
%74 = fneg double %52
%75 = insertelement <2 x double> poison, double %73, i64 0
%76 = shufflevector <2 x double> %75, <2 x double> poison, <2 x i32> zeroinitializer
%77 = insertelement <2 x double> poison, double %59, i64 0
%78 = insertelement <2 x double> %77, double %74, i64 1
%79 = fmul <2 x double> %76, %78
%80 = insertelement <2 x double> poison, double %71, i64 0
%81 = shufflevector <2 x double> %80, <2 x double> poison, <2 x i32> zeroinitializer
%82 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %58, <2 x double> %81, <2 x double> %79)
%83 = insertelement <2 x double> poison, double %63, i64 0
%84 = shufflevector <2 x double> %83, <2 x double> poison, <2 x i32> zeroinitializer
%85 = fdiv <2 x double> %82, %84
%86 = extractelement <2 x double> %85, i64 0
%87 = fmul <2 x double> %85, %85
%88 = extractelement <2 x double> %87, i64 0
%89 = extractelement <2 x double> %85, i64 1
%90 = tail call double @llvm.fmuladd.f64(double %89, double %89, double %88)
%91 = fsub double 1.000000e+00, %90
%92 = fcmp olt double %91, 0.000000e+00
br i1 %92, label %93, label %95
93: ; preds = %68
%94 = tail call i32 (i32, i8*, ...) bitcast (i32 (...)* @error_sqrt_negative to i32 (i32, i8*, ...)*)(i32 71340, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
br label %95
95: ; preds = %93, %68
%96 = tail call double @sqrt(double %91)
%97 = fneg double %33
%98 = fdiv double %97, %34
%99 = fdiv double 1.000000e+00, %34
%100 = fneg double %89
%101 = fmul double %34, %100
%102 = tail call double @llvm.fmuladd.f64(double %33, double %86, double %101)
%103 = fmul double %34, %96
%104 = fdiv double %102, %103
%105 = fneg double %86
%106 = insertelement <2 x double> <double 1.000000e+00, double poison>, double %105, i64 1
%107 = insertelement <2 x double> poison, double %96, i64 0
%108 = insertelement <2 x double> %107, double %103, i64 1
%109 = fdiv <2 x double> %106, %108
%110 = call i32 (i32, i32, i32, double, double, double, double, double, double, double*, double*, double*, ...) bitcast (i32 (...)* @set_origin_get_mode to i32 (i32, i32, i32, double, double, double, double, double, double, double*, double*, double*, ...)*)(i32 %12, i32 %13, i32 %14, double %18, double %19, double %20, double %15, double %16, double %17, double* %25, double* %26, double* %27)
%111 = icmp eq i32 %110, 0
%112 = load double, double* %25
%113 = load double, double* %26
br i1 %111, label %114, label %116
114: ; preds = %95
%115 = load double, double* %27
br label %129
116: ; preds = %95
%117 = fmul double %98, %113
%118 = fadd double %112, %117
%119 = load double, double* %27
%120 = call double @llvm.fmuladd.f64(double %104, double %119, double %118)
%121 = fmul double %99, %113
%122 = call double @llvm.fmuladd.f64(double %112, double 0.000000e+00, double %121)
%123 = extractelement <2 x double> %109, i64 1
%124 = call double @llvm.fmuladd.f64(double %123, double %119, double %122)
%125 = fmul double %113, 0.000000e+00
%126 = call double @llvm.fmuladd.f64(double %112, double 0.000000e+00, double %125)
%127 = extractelement <2 x double> %109, i64 0
%128 = call double @llvm.fmuladd.f64(double %127, double %119, double %126)
store double %120, double* %25
store double %124, double* %26
store double %128, double* %27
br label %129
129: ; preds = %114, %116
%130 = phi double [ %115, %114 ], [ %128, %116 ]
%131 = phi double [ %113, %114 ], [ %124, %116 ]
%132 = phi double [ %112, %114 ], [ %120, %116 ]
%133 = add i32 %9, -1
%134 = uitofp i32 %133 to double
%135 = call double @llvm.fmuladd.f64(double %134, double %18, double %132)
%136 = add i32 %10, -1
%137 = uitofp i32 %136 to double
%138 = call double @llvm.fmuladd.f64(double %137, double %19, double %131)
%139 = add i32 %11, -1
%140 = uitofp i32 %139 to double
%141 = call double @llvm.fmuladd.f64(double %140, double %20, double %130)
%142 = fmul double %33, %131
%143 = fadd double %132, %142
%144 = fmul double %34, %131
%145 = call double @llvm.fmuladd.f64(double %132, double 0.000000e+00, double %144)
%146 = insertelement <2 x double> poison, double %130, i64 0
%147 = shufflevector <2 x double> %146, <2 x double> poison, <2 x i32> zeroinitializer
%148 = insertelement <2 x double> poison, double %145, i64 0
%149 = insertelement <2 x double> %148, double %143, i64 1
%150 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %85, <2 x double> %147, <2 x double> %149)
%151 = fmul double %131, 0.000000e+00
%152 = call double @llvm.fmuladd.f64(double %132, double 0.000000e+00, double %151)
%153 = call double @llvm.fmuladd.f64(double %96, double %130, double %152)
%154 = fadd double %135, %142
%155 = call double @llvm.fmuladd.f64(double %89, double %130, double %154)
%156 = call double @llvm.fmuladd.f64(double %135, double 0.000000e+00, double %144)
%157 = call double @llvm.fmuladd.f64(double %86, double %130, double %156)
%158 = call double @llvm.fmuladd.f64(double %135, double 0.000000e+00, double %151)
%159 = call double @llvm.fmuladd.f64(double %96, double %130, double %158)
%160 = fmul double %33, %138
%161 = fadd double %132, %160
%162 = call double @llvm.fmuladd.f64(double %89, double %130, double %161)
%163 = fmul double %34, %138
%164 = call double @llvm.fmuladd.f64(double %132, double 0.000000e+00, double %163)
%165 = call double @llvm.fmuladd.f64(double %86, double %130, double %164)
%166 = fmul double %138, 0.000000e+00
%167 = call double @llvm.fmuladd.f64(double %132, double 0.000000e+00, double %166)
%168 = call double @llvm.fmuladd.f64(double %96, double %130, double %167)
%169 = call double @llvm.fmuladd.f64(double %89, double %141, double %143)
%170 = call double @llvm.fmuladd.f64(double %86, double %141, double %145)
%171 = call double @llvm.fmuladd.f64(double %96, double %141, double %152)
%172 = fadd double %135, %160
%173 = call double @llvm.fmuladd.f64(double %89, double %130, double %172)
%174 = call double @llvm.fmuladd.f64(double %135, double 0.000000e+00, double %163)
%175 = call double @llvm.fmuladd.f64(double %86, double %130, double %174)
%176 = call double @llvm.fmuladd.f64(double %135, double 0.000000e+00, double %166)
%177 = call double @llvm.fmuladd.f64(double %96, double %130, double %176)
%178 = call double @llvm.fmuladd.f64(double %89, double %141, double %161)
%179 = call double @llvm.fmuladd.f64(double %86, double %141, double %164)
%180 = call double @llvm.fmuladd.f64(double %96, double %141, double %167)
%181 = call double @llvm.fmuladd.f64(double %89, double %141, double %154)
%182 = call double @llvm.fmuladd.f64(double %86, double %141, double %156)
%183 = call double @llvm.fmuladd.f64(double %96, double %141, double %158)
%184 = call double @llvm.fmuladd.f64(double %89, double %141, double %172)
%185 = call double @llvm.fmuladd.f64(double %86, double %141, double %174)
%186 = call double @llvm.fmuladd.f64(double %96, double %141, double %176)
%187 = fcmp olt <2 x double> %150, <double 1.000000e+20, double 1.000000e+20>
%188 = extractelement <2 x i1> %187, i64 1
%189 = extractelement <2 x double> %150, i64 1
%190 = select i1 %188, double %189, double 1.000000e+20
%191 = fcmp olt double %155, %190
%192 = select i1 %191, double %155, double %190
%193 = fcmp olt double %162, %192
%194 = select i1 %193, double %162, double %192
%195 = fcmp olt double %169, %194
%196 = select i1 %195, double %169, double %194
%197 = fcmp olt double %173, %196
%198 = select i1 %197, double %173, double %196
%199 = fcmp olt double %178, %198
%200 = select i1 %199, double %178, double %198
%201 = fcmp olt double %181, %200
%202 = select i1 %201, double %181, double %200
%203 = fcmp olt double %184, %202
%204 = extractelement <2 x i1> %187, i64 0
%205 = extractelement <2 x double> %150, i64 0
%206 = select i1 %204, double %205, double 1.000000e+20
%207 = fcmp olt double %157, %206
%208 = select i1 %207, double %157, double %206
%209 = fcmp olt double %165, %208
%210 = select i1 %209, double %165, double %208
%211 = fcmp olt double %170, %210
%212 = select i1 %211, double %170, double %210
%213 = fcmp olt double %175, %212
%214 = select i1 %213, double %175, double %212
%215 = fcmp olt double %179, %214
%216 = select i1 %215, double %179, double %214
%217 = fcmp olt double %182, %216
%218 = select i1 %217, double %182, double %216
%219 = fcmp olt double %185, %218
%220 = select i1 %219, double %185, double %218
%221 = fcmp olt double %153, 1.000000e+20
%222 = select i1 %221, double %153, double 1.000000e+20
%223 = fcmp olt double %159, %222
%224 = select i1 %223, double %159, double %222
%225 = fcmp olt double %168, %224
%226 = select i1 %225, double %168, double %224
%227 = fcmp olt double %171, %226
%228 = select i1 %227, double %171, double %226
%229 = fcmp olt double %177, %228
%230 = select i1 %229, double %177, double %228
%231 = fcmp olt double %180, %230
%232 = select i1 %231, double %180, double %230
%233 = fcmp olt double %183, %232
%234 = select i1 %233, double %183, double %232
%235 = fcmp olt double %186, %234
%236 = select i1 %235, double %186, double %234
%237 = fcmp ogt double %189, -1.000000e+20
%238 = select i1 %237, double %189, double -1.000000e+20
%239 = fcmp ogt double %155, %238
%240 = select i1 %239, double %155, double %238
%241 = fcmp ogt double %162, %240
%242 = select i1 %241, double %162, double %240
%243 = fcmp ogt double %169, %242
%244 = select i1 %243, double %169, double %242
%245 = fcmp ogt double %173, %244
%246 = select i1 %245, double %173, double %244
%247 = fcmp ogt double %178, %246
%248 = select i1 %247, double %178, double %246
%249 = fcmp ogt double %181, %248
%250 = select i1 %249, double %181, double %248
%251 = fcmp ogt double %184, %250
%252 = select i1 %251, double %184, double %250
%253 = fcmp ogt double %205, -1.000000e+20
%254 = select i1 %253, double %205, double -1.000000e+20
%255 = fcmp ogt double %157, %254
%256 = select i1 %255, double %157, double %254
%257 = fcmp ogt double %165, %256
%258 = select i1 %257, double %165, double %256
%259 = fcmp ogt double %170, %258
%260 = select i1 %259, double %170, double %258
%261 = fcmp ogt double %175, %260
%262 = select i1 %261, double %175, double %260
%263 = fcmp ogt double %179, %262
%264 = select i1 %263, double %179, double %262
%265 = fcmp ogt double %182, %264
%266 = select i1 %265, double %182, double %264
%267 = fcmp ogt double %185, %266
%268 = select i1 %267, double %185, double %266
%269 = fcmp ogt double %153, -1.000000e+20
%270 = select i1 %269, double %153, double -1.000000e+20
%271 = fcmp ogt double %159, %270
%272 = select i1 %271, double %159, double %270
%273 = fcmp ogt double %168, %272
%274 = select i1 %273, double %168, double %272
%275 = fcmp ogt double %171, %274
%276 = select i1 %275, double %171, double %274
%277 = fcmp ogt double %177, %276
%278 = select i1 %277, double %177, double %276
%279 = fcmp ogt double %180, %278
%280 = select i1 %279, double %180, double %278
%281 = fcmp ogt double %183, %280
%282 = select i1 %281, double %183, double %280
%283 = fcmp ogt double %186, %282
%284 = select i1 %283, double %186, double %282
%285 = select i1 %203, double %184, double %202
%286 = fmul double %34, %19
%287 = fcmp olt double %286, %18
%288 = select i1 %287, double %286, double %18
%289 = fmul double %96, %20
%290 = fcmp olt double %289, %288
%291 = select i1 %290, double %289, double %288
%292 = call double @llvm.fmuladd.f64(double %291, double 1.000000e+01, double 5.000000e-01)
%293 = call double @llvm.floor.f64(double %292)
%294 = fdiv double %293, 1.000000e+01
store double %294, double* %7
%295 = fdiv double %285, %294
%296 = call double @llvm.floor.f64(double %295)
%297 = fmul double %294, %296
store double %297, double* %4
%298 = load double, double* %7
%299 = fdiv double %220, %298
%300 = call double @llvm.floor.f64(double %299)
%301 = fmul double %298, %300
store double %301, double* %5
%302 = load double, double* %7
%303 = fdiv double %236, %302
%304 = call double @llvm.floor.f64(double %303)
%305 = fmul double %302, %304
store double %305, double* %6
%306 = load double, double* %7
%307 = fdiv double %252, %306
%308 = call double @llvm.ceil.f64(double %307)
%309 = fdiv double %285, %306
%310 = call double @llvm.floor.f64(double %309)
%311 = fsub double %308, %310
%312 = fadd double %311, 1.500000e+00
%313 = fptosi double %312 to i32
store i32 %313, i32* %1
%314 = fdiv double %268, %306
%315 = call double @llvm.ceil.f64(double %314)
%316 = fdiv double %220, %306
%317 = call double @llvm.floor.f64(double %316)
%318 = fsub double %315, %317
%319 = fadd double %318, 1.500000e+00
%320 = fptosi double %319 to i32
store i32 %320, i32* %2
%321 = fdiv double %284, %306
%322 = call double @llvm.ceil.f64(double %321)
%323 = fdiv double %236, %306
%324 = call double @llvm.floor.f64(double %323)
%325 = fsub double %322, %324
%326 = fadd double %325, 1.500000e+00
%327 = fptosi double %326 to i32
store i32 %327, i32* %3
%328 = load i32, i32* %1
%329 = load i32, i32* %2
%330 = mul i32 %329, %328
%331 = mul i32 %330, %327
%332 = zext i32 %331 to i64
%333 = call i32 (double**, i64, ...) bitcast (i32 (...)* @do_vect to i32 (double**, i64, ...)*)(double** %0, i64 %332)
%334 = load i32, i32* %3
%335 = icmp sgt i32 %334, 0
br i1 %335, label %336, label %505
336: ; preds = %129
%337 = load i32, i32* %2
%338 = insertelement <2 x double> <double 0.000000e+00, double poison>, double %99, i64 1
%339 = insertelement <2 x double> poison, double %20, i64 0
%340 = insertelement <2 x double> %339, double %19, i64 1
%341 = insertelement <2 x i32> poison, i32 %11, i64 0
%342 = insertelement <2 x i32> %341, i32 %10, i64 1
br label %343
343: ; preds = %336, %499
%344 = phi i32 [ %500, %499 ], [ %334, %336 ]
%345 = phi i32 [ %501, %499 ], [ %337, %336 ]
%346 = phi i32 [ %502, %499 ], [ %337, %336 ]
%347 = phi i32 [ %503, %499 ], [ 0, %336 ]
%348 = icmp sgt i32 %346, 0
br i1 %348, label %349, label %499
349: ; preds = %343
%350 = sitofp i32 %347 to double
%351 = load i32, i32* %1
br label %352
352: ; preds = %349, %491
%353 = phi i32 [ %345, %349 ], [ %492, %491 ]
%354 = phi i32 [ %351, %349 ], [ %493, %491 ]
%355 = phi i32 [ %351, %349 ], [ %494, %491 ]
%356 = phi i32 [ 0, %349 ], [ %495, %491 ]
%357 = icmp sgt i32 %355, 0
br i1 %357, label %358, label %491
358: ; preds = %352
%359 = sitofp i32 %356 to double
br label %360
360: ; preds = %358, %485
%361 = phi i32 [ %354, %358 ], [ %486, %485 ]
%362 = phi i32 [ 0, %358 ], [ %487, %485 ]
%363 = load double, double* %4
%364 = sitofp i32 %362 to double
%365 = load double, double* %7
%366 = call double @llvm.fmuladd.f64(double %364, double %365, double %363)
%367 = load double, double* %5
%368 = call double @llvm.fmuladd.f64(double %359, double %365, double %367)
%369 = load double, double* %6
%370 = call double @llvm.fmuladd.f64(double %350, double %365, double %369)
%371 = fmul double %98, %368
%372 = fadd double %366, %371
%373 = call double @llvm.fmuladd.f64(double %104, double %370, double %372)
%374 = load double, double* %25
%375 = fsub double %373, %374
%376 = fdiv double %375, %18
%377 = load double, double* %26
%378 = insertelement <2 x double> poison, double %368, i64 0
%379 = shufflevector <2 x double> %378, <2 x double> poison, <2 x i32> zeroinitializer
%380 = fmul <2 x double> %338, %379
%381 = insertelement <2 x double> poison, double %366, i64 0
%382 = shufflevector <2 x double> %381, <2 x double> poison, <2 x i32> zeroinitializer
%383 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %382, <2 x double> zeroinitializer, <2 x double> %380)
%384 = insertelement <2 x double> poison, double %370, i64 0
%385 = shufflevector <2 x double> %384, <2 x double> poison, <2 x i32> zeroinitializer
%386 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %109, <2 x double> %385, <2 x double> %383)
%387 = load double, double* %27
%388 = insertelement <2 x double> poison, double %387, i64 0
%389 = insertelement <2 x double> %388, double %377, i64 1
%390 = fsub <2 x double> %386, %389
%391 = fdiv <2 x double> %390, %340
%392 = call double @llvm.floor.f64(double %376)
%393 = fptosi double %392 to i32
%394 = call <2 x double> @llvm.floor.v2f64(<2 x double> %391)
%395 = fptosi <2 x double> %394 to <2 x i32>
%396 = add nsw i32 %393, 1
%397 = add nsw <2 x i32> %395, <i32 1, i32 1>
%398 = icmp sgt i32 %393, -1
br i1 %398, label %399, label %485
399: ; preds = %360
%400 = icmp slt i32 %396, %9
%401 = extractelement <2 x i32> %395, i64 1
%402 = icmp sgt i32 %401, -1
%403 = select i1 %400, i1 %402, i1 false
br i1 %403, label %404, label %485
404: ; preds = %399
%405 = extractelement <2 x i32> %395, i64 0
%406 = icmp sgt i32 %405, -1
%407 = icmp slt <2 x i32> %397, %342
%408 = extractelement <2 x i1> %407, i64 1
%409 = select i1 %408, i1 %406, i1 false
%410 = extractelement <2 x i1> %407, i64 0
%411 = select i1 %409, i1 %410, i1 false
br i1 %411, label %412, label %485
412: ; preds = %404
%413 = sitofp i32 %393 to double
%414 = fsub double %376, %413
%415 = sitofp i32 %401 to double
%416 = extractelement <2 x double> %391, i64 1
%417 = fsub double %416, %415
%418 = sitofp i32 %405 to double
%419 = extractelement <2 x double> %391, i64 0
%420 = fsub double %419, %418
%421 = fmul double %414, %417
%422 = fmul double %420, %421
%423 = extractelement <2 x i32> %397, i64 0
%424 = extractelement <2 x i32> %397, i64 1
%425 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @gidz_general to i32 (i32, i32, i32, i32, i32, ...)*)(i32 %423, i32 %424, i32 %396, i32 %10, i32 %9)
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds double, double* %8, i64 %426
%428 = load double, double* %427
%429 = fsub double 1.000000e+00, %414
%430 = fmul double %417, %429
%431 = fmul double %420, %430
%432 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @gidz_general to i32 (i32, i32, i32, i32, i32, ...)*)(i32 %423, i32 %424, i32 %393, i32 %10, i32 %9)
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %8, i64 %433
%435 = load double, double* %434
%436 = fmul double %431, %435
%437 = call double @llvm.fmuladd.f64(double %422, double %428, double %436)
%438 = fsub double 1.000000e+00, %417
%439 = fmul double %414, %438
%440 = fmul double %420, %439
%441 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @gidz_general to i32 (i32, i32, i32, i32, i32, ...)*)(i32 %423, i32 %401, i32 %396, i32 %10, i32 %9)
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds double, double* %8, i64 %442
%444 = load double, double* %443
%445 = call double @llvm.fmuladd.f64(double %440, double %444, double %437)
%446 = fsub double 1.000000e+00, %420
%447 = fmul double %421, %446
%448 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @gidz_general to i32 (i32, i32, i32, i32, i32, ...)*)(i32 %405, i32 %424, i32 %396, i32 %10, i32 %9)
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds double, double* %8, i64 %449
%451 = load double, double* %450
%452 = call double @llvm.fmuladd.f64(double %447, double %451, double %445)
%453 = fmul double %446, %439
%454 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @gidz_general to i32 (i32, i32, i32, i32, i32, ...)*)(i32 %405, i32 %401, i32 %396, i32 %10, i32 %9)
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %8, i64 %455
%457 = load double, double* %456
%458 = call double @llvm.fmuladd.f64(double %453, double %457, double %452)
%459 = fmul double %446, %430
%460 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @gidz_general to i32 (i32, i32, i32, i32, i32, ...)*)(i32 %405, i32 %424, i32 %393, i32 %10, i32 %9)
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double, double* %8, i64 %461
%463 = load double, double* %462
%464 = call double @llvm.fmuladd.f64(double %459, double %463, double %458)
%465 = fmul double %429, %438
%466 = fmul double %420, %465
%467 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @gidz_general to i32 (i32, i32, i32, i32, i32, ...)*)(i32 %423, i32 %401, i32 %393, i32 %10, i32 %9)
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds double, double* %8, i64 %468
%470 = load double, double* %469
%471 = call double @llvm.fmuladd.f64(double %466, double %470, double %464)
%472 = fmul double %446, %465
%473 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @gidz_general to i32 (i32, i32, i32, i32, i32, ...)*)(i32 %405, i32 %401, i32 %393, i32 %10, i32 %9)
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds double, double* %8, i64 %474
%476 = load double, double* %475
%477 = call double @llvm.fmuladd.f64(double %472, double %476, double %471)
%478 = load double*, double** %0
%479 = load i32, i32* %2
%480 = load i32, i32* %1
%481 = call i32 (i32, i32, i32, i32, i32, ...) bitcast (i32 (...)* @gidz_general to i32 (i32, i32, i32, i32, i32, ...)*)(i32 %347, i32 %356, i32 %362, i32 %479, i32 %480)
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds double, double* %478, i64 %482
store double %477, double* %483
%484 = load i32, i32* %1
br label %485
485: ; preds = %360, %399, %404, %412
%486 = phi i32 [ %361, %360 ], [ %361, %399 ], [ %361, %404 ], [ %484, %412 ]
%487 = add nuw nsw i32 %362, 1
%488 = icmp slt i32 %487, %486
br i1 %488, label %360, label %489
489: ; preds = %485
%490 = load i32, i32* %2
br label %491
491: ; preds = %489, %352
%492 = phi i32 [ %490, %489 ], [ %353, %352 ]
%493 = phi i32 [ %486, %489 ], [ %354, %352 ]
%494 = phi i32 [ %486, %489 ], [ %355, %352 ]
%495 = add nuw nsw i32 %356, 1
%496 = icmp slt i32 %495, %492
br i1 %496, label %352, label %497
497: ; preds = %491
%498 = load i32, i32* %3
br label %499
499: ; preds = %497, %343
%500 = phi i32 [ %498, %497 ], [ %344, %343 ]
%501 = phi i32 [ %492, %497 ], [ %345, %343 ]
%502 = phi i32 [ %492, %497 ], [ %346, %343 ]
%503 = add nuw nsw i32 %347, 1
%504 = icmp slt i32 %503, %500
br i1 %504, label %343, label %505
505: ; preds = %499, %129
%506 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @str, i64 0, i64 0))
ret void
}