void cu_photom_converge(int profile_type, int patch_half_width, int dp, int ds,
                        int nfiles, int *nkernel, int *kxindex, int *kyindex,
                        int *ext_basis, int *n_coeff, double *coeff,
                        double *psf_parameters, double *psf_0, double *psf_xd,
                        double *psf_yd, double *diff, double *inv_var,
                        double *im_qual, double im_qual_threshold,
                        double *xpos0, double *ypos0, double xpos, double ypos,
                        int nx, int ny, int blockDimx, int blockDimy,
                        double *flux, double *dflux, double gain, int converge,
                        double max_converge_distance) {
  int id, txa, tyb, txag, tybg;
  int np, ns, i, j, ip, jp, ic, ki, a, b;
  int d1, sidx, l, m, l1, m1, ig, jg, ifile;
  int psf_size, ix, jx, iteration;
  int patch_size, patch_area, im_id;
  double xpos1, ypos1;
  int k_index_start, c_index_start;
  double x, y, p0, p1, p1g, cpsf_pixel, dd;
  double psf_height, psf_sigma_x, psf_sigma_y, psf_sigma_xy, psf_xpos, psf_ypos;
  double subx, suby, psf_norm, bgnd;
  double psf_sum, max_flux;
  double cpsf[256], cpsf0[256];
  double *cpsf_stack;
  double mpsf[256], psfxd[256], psfyd[256], psf_rad, psf_rad2;
  double fsum1, fsum2, fsum3, fsum4, fsum5, fsum6, fl;
  double sx2, sy2, sxy2, sx2msy2, sx2psy2;
  double a1, sa1px, sa1py, spx, spy, spxy, px, py;
  double sjx1, sjx2, sjy1, sjy2, dx, dy, inv_v, rr, det;
  int blockIdx, idx, idy;
  double pi = 3.14159265, fwtosig = 0.8493218;
  double max_shift = 0.2;
  int converge_iterations = 40, fitbg = 0;
  int good_images;
  cpsf_stack = malloc(256 * nfiles * sizeof(double));
  patch_size = 2 * patch_half_width + 1;
  patch_area = patch_size * patch_size;
  xpos1 = xpos;
  ypos1 = ypos;
  np = (dp + 1) * (dp + 2) / 2;
  ns = (ds + 1) * (ds + 2) / 2;
  psf_size = (int)psf_parameters[0];
  psf_height = psf_parameters[1];
  psf_sigma_x = psf_parameters[2];
  psf_sigma_y = psf_parameters[3];
  psf_ypos = psf_parameters[4];
  psf_xpos = psf_parameters[5];
  psf_rad = psf_parameters[6];
  gain = psf_parameters[7];
  if (psf_rad > 6.0) {
    printf("Warning: resetting psf_rad to maximum value 6\n");
    psf_rad = 6.0;
  }
  psf_rad2 = psf_rad * psf_rad;
  psf_sum = 0.0;
  for (i = 1; i < psf_size - 1; i++) {
    for (j = 1; j < psf_size - 1; j++) {
      psf_sum += psf_0[i + j * psf_size];
    }
  }
  if (profile_type == 0) {
    psf_norm = 0.25 * psf_sum + psf_height * 2 * pi * fwtosig * fwtosig;
  } else if (profile_type == 1) {
    psf_sigma_xy = psf_parameters[8];
    sx2 = psf_sigma_x * psf_sigma_x;
    sy2 = psf_sigma_y * psf_sigma_y;
    sxy2 = psf_sigma_xy * psf_sigma_xy;
    sx2msy2 = 1.0 / sx2 - 1.0 / sy2;
    sx2psy2 = 1.0 / sx2 + 1.0 / sy2;
    px = 1.0 / sqrt(sx2psy2 + sqrt(sx2msy2 * sx2msy2 + sxy2));
    py = 1.0 / sqrt(sx2psy2 - sqrt(sx2msy2 * sx2msy2 + sxy2));
    psf_norm = 0.25 * psf_sum +
               psf_height * pi * (px * py) / (psf_sigma_x * psf_sigma_y);
  }
  for (idx = 0; idx < blockDimx; idx++) {
    for (idy = 0; idy < blockDimy; idy++) {
      id = idx + idy * blockDimx;
      cpsf0[id] = 0.0;
    }
  }
  x = (*xpos0 - 0.5 * (nx - 1)) / (nx - 1);
  y = (*ypos0 - 0.5 * (ny - 1)) / (ny - 1);
  k_index_start = 0;
  c_index_start = 0;
  for (ifile = 0; ifile < nfiles; ifile++) {
    for (idx = 0; idx < blockDimx; idx++) {
      for (idy = 0; idy < blockDimy; idy++) {
        id = idx + idy * blockDimx;
        p0 = integrated_profile(profile_type, idx, idy, *xpos0, *ypos0,
                                psf_parameters, psf_0, psf_xd, psf_yd);
        cpsf_pixel = 0.0;
        for (ic = 0; ic < n_coeff[ifile]; ic++) {
          ki = ic < np ? 0 : (ic - np) / ns + 1;
          if (ki < nkernel[ifile]) {
            a = kxindex[k_index_start + ki];
            b = kyindex[k_index_start + ki];
            if (ki == 0) {
              d1 = dp;
              sidx = ic;
            } else {
              d1 = ds;
              sidx = ic - np - (ki - 1) * ns;
            }
            l1 = m1 = 0;
            if (d1 > 0) {
              i = 0;
              for (l = 0; l <= d1; l++) {
                for (m = 0; m <= d1 - l; m++) {
                  if (i == sidx) {
                    l1 = l;
                    m1 = m;
                  }
                  i++;
                }
              }
            }
            if (ki > 0) {
              txa = idx + a;
              tyb = idy + b;
              p1 = integrated_profile(profile_type, txa, tyb, *xpos0, *ypos0,
                                      psf_parameters, psf_0, psf_xd, psf_yd);
              if (ext_basis[k_index_start + ki]) {
                p1 = 0.0;
                for (ig = -1; ig < 2; ig++) {
                  for (jg = -1; jg < 2; jg++) {
                    txag = txa + ig;
                    tybg = tyb + jg;
                    p1g = integrated_profile(profile_type, txag, tybg, *xpos0,
                                             *ypos0, psf_parameters, psf_0,
                                             psf_xd, psf_yd);
                    p1 += p1g;
                  }
                }
                p1 /= 9.0;
              }
              cpsf_pixel += coeff[c_index_start + ic] * (p1 - p0) * pow(x, l1) *
                            pow(y, m1);
            } else {
              cpsf_pixel +=
                  coeff[c_index_start + ic] * p0 * pow(x, l1) * pow(y, m1);
            }
          }
        }
        cpsf0[id] = cpsf_pixel / psf_norm;
      }
    }
    for (i = 0; i < 256; i++)
      cpsf[i] = cpsf0[i];
    resolve_coeffs_2d(16, 16, 16, cpsf);
    for (i = 0; i < 256; i++) {
      cpsf_stack[ifile * 256 + i] = cpsf[i];
    }
    k_index_start += nkernel[ifile];
    c_index_start += n_coeff[ifile];
  }
  if (converge == 1) {
    iteration = 0;
    do {
      max_flux = 0.0;
      subx = ceil(xpos + 0.5) - (xpos + 0.5);
      suby = ceil(ypos + 0.5) - (ypos + 0.5);
      sjx1 = sjx2 = sjy1 = sjy2 = 0.0;
      for (ifile = 0; ifile < nfiles; ifile++) {
        for (i = 0; i < 256; i++) {
          mpsf[i] = 0.0;
          psfxd[i] = 0.0;
          psfyd[i] = 0.0;
        }
        psf_sum = 0.0;
        for (idx = 1; idx < 15; idx++) {
          for (idy = 1; idy < 15; idy++) {
            id = idx + idy * blockDimx;
            mpsf[id] = interpolate_2d(
                subx, suby, 16,
                &cpsf_stack[ifile * 256 + (idx) + (idy)*blockDimx]);
            mpsf[id] = mpsf[id] > 0.0 ? mpsf[id] : 0.0;
            psf_sum += mpsf[id];
          }
        }
        if (psf_sum < 0.0) {
          sjx1 = 0.0;
          sjx2 = 1.0;
          sjy1 = 0.0;
          sjy2 = 1.0;
          flux[ifile] = 0.0;
          dflux[ifile] = 1.0e6;
        } else {
          for (idx = 1; idx < 15; idx++) {
            for (idy = 1; idy < 15; idy++) {
              id = idx + idy * blockDimx;
            }
          }
          fl = 0.0;
          for (j = 0; j < 1; j++) {
            fsum1 = fsum2 = fsum3 = fsum4 = fsum5 = fsum6 = 0.0;
            for (idx = 0; idx < 16; idx++) {
              for (idy = 0; idy < 16; idy++) {
                id = idx + idy * blockDimx;
                if (pow(idx - 8.0, 2) + pow(idy - 8.0, 2) < psf_rad2) {
                  ix = (int)floor(xpos + 0.5) + idx - 8.0;
                  jx = (int)floor(ypos + 0.5) + idy - 8.0;
                  im_id = ifile * patch_area + ix + patch_size * jx;
                  inv_v = inv_var[im_id];
                  fsum1 += mpsf[id] * diff[im_id] * inv_v;
                  fsum2 += mpsf[id] * mpsf[id] * inv_v;
                  fsum3 += mpsf[id];
                  fsum4 += mpsf[id] * inv_v;
                  fsum5 += inv_v;
                  fsum6 += diff[im_id] * inv_v;
                  if (ifile == 375) {
                    printf(
                        "ifile,idx,idy,ix,jx,mpsf,inv_v,diff, inv_var[im_id], "
                        "gain: %d %d %d %d %d %f %f %f %f %f\n",
                        ifile, idx, idy, ix, jx, mpsf[id], inv_v, diff[im_id],
                        inv_var[im_id], gain);
                    printf("fsum1, fsum2: %f %f\n", fsum1, fsum2);
                  }
                }
              }
            }
            if (fitbg == 1) {
              det = fsum2 * fsum5 - fsum4 * fsum4;
              fl = (fsum1 * fsum5 - fsum4 * fsum6) / det;
            } else {
              fl = fsum1 / fsum2;
            }
            if (isnan(fl)) {
              for (idx = 0; idx < 16; idx++) {
                for (idy = 0; idy < 16; idy++) {
                  id = idx + idy * blockDimx;
                  if (pow(idx - 7.5, 2) + pow(idy - 7.5, 2) < psf_rad2) {
                    ix = (int)floor(xpos + 0.5) + idx - 8.0;
                    jx = (int)floor(ypos + 0.5) + idy - 8.0;
                    im_id = ifile * patch_area + ix + patch_size * jx;
                    inv_v = inv_var[im_id];
                  }
                }
              }
              fl = 0.0;
            }
          }
          flux[ifile] = fl;
          dflux[ifile] = sqrt(1.0 / fsum2);
          if ((fabs(fl) > max_flux) && (fabs(fl) < 1.e5) &&
              (im_qual[ifile] < im_qual_threshold)) {
            max_flux = fabs(fl);
          }
        }
      }
      if (iteration > 0) {
        printf(
            "Iteration %d: computing contribution to coordinate correction.\n",
            iteration);
        printf("im_qual_threshold = %f\n", im_qual_threshold);
        printf("flux_threshold = %f\n", max_flux * 0.1);
        good_images = 0;
        for (ifile = 0; ifile < nfiles; ifile++) {
          printf(
              "ifile, flux[ifile], dflux[ifile], im_qual[ifile]: %d %g %g %g\n",
              ifile, flux[ifile], dflux[ifile], im_qual[ifile]);
          if ((!isnan(flux[ifile])) && (fabs(flux[ifile]) > 0.1 * max_flux) &&
              (im_qual[ifile] < im_qual_threshold)) {
            good_images++;
            for (i = 0; i < 256; i++) {
              mpsf[i] = 0.0;
              psfxd[i] = 0.0;
              psfyd[i] = 0.0;
            }
            psf_sum = 0.0;
            for (idx = 1; idx < 15; idx++) {
              for (idy = 1; idy < 15; idy++) {
                id = idx + idy * blockDimx;
                mpsf[id] = interpolate_2d(
                    subx, suby, 16,
                    &cpsf_stack[ifile * 256 + (idx) + (idy)*blockDimx]);
                mpsf[id] = mpsf[id] > 0.0 ? mpsf[id] : 0.0;
                psf_sum += mpsf[id];
              }
            }
            for (idx = 2; idx < 14; idx++) {
              for (idy = 2; idy < 14; idy++) {
                id = idx + idy * blockDimx;
                psfxd[id] = 0.5 *
                            (mpsf[idx + 1 + idy * blockDimx] -
                             mpsf[idx - 1 + idy * blockDimx]) /
                            psf_sum;
                psfyd[id] = 0.5 *
                            (mpsf[idx + (idy + 1) * blockDimx] -
                             mpsf[idx + (idy - 1) * blockDimx]) /
                            psf_sum;
              }
            }
            sa1px = sa1py = spx = spy = spxy = 0.0;
            for (idx = 2; idx < 14; idx++) {
              for (idy = 2; idy < 14; idy++) {
                id = idx + idy * blockDimx;
                ix = (int)floor(xpos + 0.5) + idx - 7;
                jx = (int)floor(ypos + 0.5) + idy - 7;
                im_id = ifile * patch_area + ix + patch_size * jx;
                inv_v = inv_var[im_id];
                if ((inv_v > 0.0) && (fabs(psfxd[id]) > 1.e-8) &&
                    (fabs(psfyd[id]) > 1.e-8)) {
                  a1 = diff[im_id] - flux[ifile] * mpsf[id];
                  sa1px += a1 * psfxd[id] * inv_v;
                  sa1py += a1 * psfyd[id] * inv_v;
                  spx += psfxd[id] * psfxd[id] * inv_v;
                  spy += psfyd[id] * psfyd[id] * inv_v;
                  spxy += psfxd[id] * psfyd[id] * inv_v;
                  if (isnan(a1)) {
                    printf("diff,fl,mpsf: %f %f %f\n", diff[im_id], flux[ifile],
                           mpsf[id]);
                    printf("%d %d %f %f %f %f %f %f\n", idx, idy, a1, sa1px,
                           sa1py, spx, spy, spxy);
                    exit(1);
                  }
                  if ((isnan(sa1px)) || (isnan(sa1px)) || (isnan(sa1px)) ||
                      (isnan(sa1px)) || (isnan(sa1px))) {
                    printf("Error: NaN detected in cu_photom_converge\n");
                    printf("%d %d %f %f %f %f %f %f\n", idx, idy, a1, sa1px,
                           sa1py, spx, spy, spxy);
                    exit(1);
                  }
                }
              }
            }
            sjx1 += flux[ifile] * (sa1px - sa1py * spxy / spy);
            sjx2 += flux[ifile] * flux[ifile] * (spx - spxy * spxy / spy);
            sjy1 += flux[ifile] * (sa1py - sa1px * spxy / spx);
            sjy2 += flux[ifile] * flux[ifile] * (spy - spxy * spxy / spx);
          }
        }
        printf("Iteration %d: %d images used.\n", iteration, good_images);
        if (good_images > 0) {
          dx = sjx1 / sjx2;
          dy = sjy1 / sjy2;
          if (isnan(dx)) {
            printf("Error: Nan detected in dx. %f %f %f %f\n", sjx1, sjx2, dx,
                   max_flux);
          }
          if (isnan(dy)) {
            printf("Error: Nan detected in dy. %f %f %f %f\n", sjy1, sjy2, dy,
                   max_flux);
          }
          if (fabs(dx) > max_shift) {
            dx = dx > 0 ? max_shift : -max_shift;
          }
          if (fabs(dy) > max_shift) {
            dy = dy > 0 ? max_shift : -max_shift;
          }
          xpos -= dx;
          ypos -= dy;
          printf("dx dy: %f %f    +    %f %f    ->    %f %f\n", xpos + dx,
                 ypos + dy, dx, dy, xpos, ypos);
          rr = ((xpos - xpos1) * (xpos - xpos1) +
                (ypos - ypos1) * (ypos - ypos1));
        }
      } else {
        rr = 0.0;
        dx = 1.0;
      }
      iteration++;
    } while (
        (iteration < converge_iterations) &&
        ((fabs(dx) > 0.00001) || (fabs(dy) > 0.00001) || (iteration == 0)) &&
        (rr < 100));
    if (rr >= max_converge_distance * max_converge_distance) {
      xpos = xpos1;
      ypos = ypos1;
      printf("Warning: position has diverged. Reverting to original "
             "coordinates\n");
    }
    *xpos0 += (xpos - xpos1);
    *ypos0 += (ypos - ypos1);
  }
  printf("Final position: %f %f %f %f\n", *xpos0, *ypos0, xpos, ypos);
  subx = ceil(xpos + 0.5) - (xpos + 0.5);
  suby = ceil(ypos + 0.5) - (ypos + 0.5);
  for (ifile = 0; ifile < nfiles; ifile++) {
    for (i = 0; i < 256; i++) {
      mpsf[i] = 0.0;
      psfxd[i] = 0.0;
      psfyd[i] = 0.0;
    }
    psf_sum = 0.0;
    for (idx = 1; idx < 15; idx++) {
      for (idy = 1; idy < 15; idy++) {
        id = idx + idy * blockDimx;
        mpsf[id] = interpolate_2d(
            subx, suby, 16, &cpsf_stack[ifile * 256 + (idx) + (idy)*blockDimx]);
        mpsf[id] = mpsf[id] > 0.0 ? mpsf[id] : 0.0;
        psf_sum += mpsf[id];
      }
    }
    if (psf_sum < 1.e-6) {
      flux[ifile] = 0.0;
      dflux[ifile] = 1.0e6;
    } else {
      fl = 0.0;
      for (j = 0; j < 1; j++) {
        fsum1 = fsum2 = fsum3 = fsum4 = fsum5 = fsum6 = 0.0;
        for (idx = 0; idx < 16; idx++) {
          for (idy = 0; idy < 16; idy++) {
            id = idx + idy * blockDimx;
            if (pow(idx - 8.0, 2) + pow(idy - 8.0, 2) < psf_rad2) {
              ix = (int)floor(xpos + 0.5) + idx - 7;
              jx = (int)floor(ypos + 0.5) + idy - 7;
              im_id = ifile * patch_area + ix + patch_size * jx;
              inv_v = inv_var[im_id];
              fsum1 += mpsf[id] * diff[im_id] * inv_v;
              fsum2 += mpsf[id] * mpsf[id] * inv_v;
              fsum3 += mpsf[id];
              fsum4 += mpsf[id] * inv_v;
              fsum5 += inv_v;
              fsum6 += diff[im_id] * inv_v;
            }
          }
        }
        if (fitbg == 1) {
          det = fsum2 * fsum5 - fsum4 * fsum4;
          fl = (fsum1 * fsum5 - fsum4 * fsum6) / det;
        } else {
          fl = fsum1 / fsum2;
        }
        if (isnan(fl)) {
          for (idx = 0; idx < 16; idx++) {
            for (idy = 0; idy < 16; idy++) {
              id = idx + idy * blockDimx;
              if (pow(idx - 8.0, 2) + pow(idy - 8.0, 2) < psf_rad2) {
                ix = (int)floor(xpos + 0.5) + idx - 8.0;
                jx = (int)floor(ypos + 0.5) + idy - 8.0;
                im_id = ifile * patch_area + ix + patch_size * jx;
                inv_v = 1.0 / (fl * mpsf[id] / gain);
                inv_v = inv_var[im_id];
              }
            }
          }
        }
      }
      flux[ifile] = fl;
      dflux[ifile] = sqrt(1.0 / fsum2);
      for (idx = 0; idx < 16; idx++) {
        for (idy = 0; idy < 16; idy++) {
          id = idx + idy * blockDimx;
          ix = (int)floor(xpos + 0.5) + idx - 7;
          jx = (int)floor(ypos + 0.5) + idy - 7;
          im_id = ifile * patch_area + ix + patch_size * jx;
          diff[im_id] -= flux[ifile] * mpsf[id];
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<cu_photom_converge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2b50,%rsp
mov    0xb0(%rbp),%eax
mov    0xa8(%rbp),%rax
mov    0xa0(%rbp),%rax
mov    0x98(%rbp),%eax
mov    0x90(%rbp),%eax
mov    0x88(%rbp),%eax
mov    0x80(%rbp),%eax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %r9,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
movsd  %xmm1,-0x30(%rbp)
movsd  %xmm2,-0x38(%rbp)
movsd  %xmm3,-0x40(%rbp)
movsd  %xmm4,-0x48(%rbp)
movsd  0x3dc4(%rip),%xmm0
movsd  %xmm0,-0x2aa0(%rbp)
ff
movsd  0x3dac(%rip),%xmm0
movsd  %xmm0,-0x2aa8(%rbp)
ff
movsd  0x3d94(%rip),%xmm0
movsd  %xmm0,-0x2ab0(%rbp)
ff
movl   $0x28,-0x2ab4(%rbp)
movl   $0x0,-0x2ab8(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x8,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1060 <malloc@plt>
mov    %rax,-0x1188(%rbp)
mov    -0x8(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
imul   -0xbc(%rbp),%eax
mov    %eax,-0xc0(%rbp)
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x60(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    -0x10(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x64(%rbp)
mov    0x38(%rbp),%rax
cvttsd2si (%rax),%eax
mov    %eax,-0xac(%rbp)
mov    0x38(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    0x38(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    0x38(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    0x38(%rbp),%rax
movsd  0x20(%rax),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    0x38(%rbp),%rax
movsd  0x28(%rax),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    0x38(%rbp),%rax
movsd  0x30(%rax),%xmm0
movsd  %xmm0,-0x2998(%rbp)
ff
mov    0x38(%rbp),%rax
movsd  0x38(%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x2998(%rbp),%xmm0
ff
movsd  0x3c55(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    13d3 <cu_photom_converge+0x223>
lea    0x3cf4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  0x3c35(%rip),%xmm0
movsd  %xmm0,-0x2998(%rbp)
ff
movsd  -0x2998(%rbp),%xmm0
ff
mulsd  -0x2998(%rbp),%xmm0
ff
movsd  %xmm0,-0x29a0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movl   $0x1,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    -0xac(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1478 <cu_photom_converge+0x2c8>
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0xac(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1465 <cu_photom_converge+0x2b5>
mov    0x40(%rbp),%rax
mov    -0x68(%rbp),%ecx
mov    -0x6c(%rbp),%edx
imul   -0xac(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1418 <cu_photom_converge+0x268>
jmp    146a <cu_photom_converge+0x2ba>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13fd <cu_photom_converge+0x24d>
cmpl   $0x0,-0x4(%rbp)
jne    14cf <cu_photom_converge+0x31f>
movsd  -0x170(%rbp),%xmm0
ff
movsd  0x3b9e(%rip),%xmm1
mulsd  -0x120(%rbp),%xmm1
ff
mulsd  -0x2aa0(%rbp),%xmm1
ff
mulsd  -0x2aa8(%rbp),%xmm1
ff
mulsd  -0x2aa8(%rbp),%xmm1
ff
movsd  0x3b66(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
jmp    16a7 <cu_photom_converge+0x4f7>
cmpl   $0x1,-0x4(%rbp)
jne    16a2 <cu_photom_converge+0x4f2>
mov    0x38(%rbp),%rax
movsd  0x40(%rax),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
mulsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x29e0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
mulsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x29e8(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
mulsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x29f0(%rbp)
ff
movsd  0x3aee(%rip),%xmm0
divsd  -0x29e0(%rbp),%xmm0
ff
movsd  0x3ade(%rip),%xmm1
divsd  -0x29e8(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x29f8(%rbp)
ff
movsd  0x3ac2(%rip),%xmm0
divsd  -0x29e0(%rbp),%xmm0
ff
movsd  0x3ab2(%rip),%xmm1
divsd  -0x29e8(%rbp),%xmm1
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a00(%rbp)
ff
movsd  -0x2a00(%rbp),%xmm0
ff
movsd  %xmm0,-0x2ad0(%rbp)
ff
movsd  -0x29f8(%rbp),%xmm0
ff
movsd  -0x29f8(%rbp),%xmm2
ff
movsd  -0x29f0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x2ad0(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x3a4a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a38(%rbp)
ff
movsd  -0x2a00(%rbp),%xmm0
ff
movsd  %xmm0,-0x2ac8(%rbp)
ff
movsd  -0x29f8(%rbp),%xmm0
ff
movsd  -0x29f8(%rbp),%xmm2
ff
movsd  -0x29f0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x2ac8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x39ea(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a40(%rbp)
ff
movsd  -0x170(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm1
ff
mulsd  -0x2aa0(%rbp),%xmm1
ff
movsd  -0x2a38(%rbp),%xmm2
ff
mulsd  -0x2a40(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
movsd  -0x128(%rbp),%xmm2
ff
mulsd  -0x130(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
movsd  0x398e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
jmp    16a7 <cu_photom_converge+0x4f7>
movl   $0x0,-0x2a90(%rbp)
mov    -0x2a90(%rbp),%eax
cmp    0x90(%rbp),%eax
jge    1734 <cu_photom_converge+0x584>
movl   $0x0,-0x2a94(%rbp)
mov    -0x2a94(%rbp),%eax
cmp    0x98(%rbp),%eax
jge    171b <cu_photom_converge+0x56b>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
movslq -0x4c(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1180(%rbp,%rax,8)
ff ff
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    16cd <cu_photom_converge+0x51d>
jmp    1720 <cu_photom_converge+0x570>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    16b1 <cu_photom_converge+0x501>
mov    0x70(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x80(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0x38e7(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x80(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    0x78(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x88(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0x38a9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x88(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x0,-0xdc(%rbp)
movl   $0x0,-0xe0(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1dfe <cu_photom_converge+0xc4e>
movl   $0x0,-0x2a90(%rbp)
mov    -0x2a90(%rbp),%eax
cmp    0x90(%rbp),%eax
jge    1d19 <cu_photom_converge+0xb69>
movl   $0x0,-0x2a94(%rbp)
mov    -0x2a94(%rbp),%eax
cmp    0x98(%rbp),%eax
jge    1d00 <cu_photom_converge+0xb50>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x2a90(%rbp),%esi
mov    -0x2a94(%rbp),%edx
mov    0x70(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x78(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x38(%rbp),%rcx
mov    0x40(%rbp),%r8
mov    0x48(%rbp),%r9
mov    0x50(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x2,%al
call   1070 <integrated_profile@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    0x28(%rbp),%rcx
movslq -0xa8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1ccf <cu_photom_converge+0xb1f>
mov    -0x78(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    18b5 <cu_photom_converge+0x705>
xor    %eax,%eax
mov    %eax,-0x2ad4(%rbp)
jmp    18c8 <cu_photom_converge+0x718>
mov    -0x78(%rbp),%eax
sub    -0x60(%rbp),%eax
cltd
idivl  -0x64(%rbp)
add    $0x1,%eax
mov    %eax,-0x2ad4(%rbp)
mov    -0x2ad4(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0xa8(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1cbc <cu_photom_converge+0xb0c>
mov    0x10(%rbp),%rax
mov    -0xdc(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x80(%rbp)
mov    0x18(%rbp),%rax
mov    -0xdc(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jne    1938 <cu_photom_converge+0x788>
mov    -0xc(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x8c(%rbp)
jmp    1959 <cu_photom_converge+0x7a9>
mov    -0x10(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x78(%rbp),%eax
sub    -0x60(%rbp),%eax
mov    -0x7c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x64(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x9c(%rbp)
movl   $0x0,-0x98(%rbp)
cmpl   $0x0,-0x88(%rbp)
jle    1a23 <cu_photom_converge+0x873>
movl   $0x0,-0x68(%rbp)
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x88(%rbp),%eax
jg     1a1e <cu_photom_converge+0x86e>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x88(%rbp),%ecx
sub    -0x90(%rbp),%ecx
cmp    %ecx,%eax
jg     1a05 <cu_photom_converge+0x855>
mov    -0x68(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jne    19e8 <cu_photom_converge+0x838>
mov    -0x90(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x94(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    19a7 <cu_photom_converge+0x7f7>
jmp    1a0a <cu_photom_converge+0x85a>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    198b <cu_photom_converge+0x7db>
jmp    1a23 <cu_photom_converge+0x873>
cmpl   $0x0,-0x7c(%rbp)
jle    1c2e <cu_photom_converge+0xa7e>
mov    -0x2a90(%rbp),%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x2a94(%rbp),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x50(%rbp),%esi
mov    -0x54(%rbp),%edx
mov    0x70(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x78(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x38(%rbp),%rcx
mov    0x40(%rbp),%r8
mov    0x48(%rbp),%r9
mov    0x50(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x2,%al
call   1070 <integrated_profile@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    0x20(%rbp),%rax
mov    -0xdc(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1b94 <cu_photom_converge+0x9e4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movl   $0xffffffff,-0xa0(%rbp)
ff ff ff
cmpl   $0x2,-0xa0(%rbp)
jge    1b78 <cu_photom_converge+0x9c8>
movl   $0xffffffff,-0xa4(%rbp)
ff ff ff
cmpl   $0x2,-0xa4(%rbp)
jge    1b5f <cu_photom_converge+0x9af>
mov    -0x50(%rbp),%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x58(%rbp),%esi
mov    -0x5c(%rbp),%edx
mov    0x70(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x78(%rbp),%rax
movsd  (%rax),%xmm1
mov    0x38(%rbp),%rcx
mov    0x40(%rbp),%r8
mov    0x48(%rbp),%r9
mov    0x50(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x2,%al
call   1070 <integrated_profile@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1ace <cu_photom_converge+0x91e>
jmp    1b64 <cu_photom_converge+0x9b4>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1ab7 <cu_photom_converge+0x907>
movsd  -0x100(%rbp),%xmm0
ff
movsd  0x3508(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    0x30(%rbp),%rax
mov    -0xe0(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x100(%rbp),%xmm1
ff
subsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x2ae8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
cvtsi2sdl -0x98(%rbp),%xmm1
ff
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x2ae8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x2ae0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
cvtsi2sdl -0x9c(%rbp),%xmm1
call   1090 <pow@plt>
movaps %xmm0,%xmm2
movsd  -0x2ae0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
jmp    1cb7 <cu_photom_converge+0xb07>
mov    0x30(%rbp),%rax
mov    -0xe0(%rbp),%ecx
add    -0x78(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x2af8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
cvtsi2sdl -0x98(%rbp),%xmm1
ff
call   1090 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x2af8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x2af0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
cvtsi2sdl -0x9c(%rbp),%xmm1
ff
call   1090 <pow@plt>
movaps %xmm0,%xmm2
movsd  -0x2af0(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
jmp    1cbc <cu_photom_converge+0xb0c>
jmp    1cc1 <cu_photom_converge+0xb11>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1885 <cu_photom_converge+0x6d5>
movsd  -0x110(%rbp),%xmm0
ff
divsd  -0x160(%rbp),%xmm0
ff
movslq -0x4c(%rbp),%rax
movsd  %xmm0,-0x1180(%rbp,%rax,8)
ff ff
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    1803 <cu_photom_converge+0x653>
jmp    1d05 <cu_photom_converge+0xb55>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    17e7 <cu_photom_converge+0x637>
movl   $0x0,-0x68(%rbp)
cmpl   $0x100,-0x68(%rbp)
jge    1d55 <cu_photom_converge+0xba5>
movslq -0x68(%rbp),%rax
movsd  -0x1180(%rbp,%rax,8),%xmm0
ff ff
movslq -0x68(%rbp),%rax
movsd  %xmm0,-0x980(%rbp,%rax,8)
ff ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1d20 <cu_photom_converge+0xb70>
lea    -0x980(%rbp),%rcx
mov    $0x10,%edx
mov    %edx,%edi
mov    %edx,%esi
mov    $0x0,%al
call   10c0 <resolve_coeffs_2d@plt>
movl   $0x0,-0x68(%rbp)
cmpl   $0x100,-0x68(%rbp)
jge    1db6 <cu_photom_converge+0xc06>
movslq -0x68(%rbp),%rax
movsd  -0x980(%rbp,%rax,8),%xmm0
ff ff
mov    -0x1188(%rbp),%rax
mov    -0xa8(%rbp),%ecx
shl    $0x8,%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1d73 <cu_photom_converge+0xbc3>
mov    -0x20(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0xdc(%rbp),%eax
mov    %eax,-0xdc(%rbp)
mov    0x28(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0xe0(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    17ce <cu_photom_converge+0x61e>
cmpl   $0x1,0xb0(%rbp)
jne    365e <cu_photom_converge+0x24ae>
movl   $0x0,-0xb8(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  0x3218(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
call   1030 <ceil@plt>
movsd  0x3206(%rip),%xmm1
addsd  -0x30(%rbp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0x31ed(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
call   1030 <ceil@plt>
movsd  0x31db(%rip),%xmm1
addsd  -0x38(%rbp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a60(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a58(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a50(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a48(%rbp)
ff
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    283d <cu_photom_converge+0x168d>
movl   $0x0,-0x68(%rbp)
cmpl   $0x100,-0x68(%rbp)
jge    1f0d <cu_photom_converge+0xd5d>
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1990(%rbp,%rax,8)
ff ff
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2190(%rbp,%rax,8)
ff ff
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2990(%rbp,%rax,8)
ff ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1ec2 <cu_photom_converge+0xd12>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movl   $0x1,-0x2a90(%rbp)
cmpl   $0xf,-0x2a90(%rbp)
jge    205c <cu_photom_converge+0xeac>
movl   $0x1,-0x2a94(%rbp)
cmpl   $0xf,-0x2a94(%rbp)
jge    2043 <cu_photom_converge+0xe93>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
movsd  -0x150(%rbp),%xmm0
ff
movsd  -0x158(%rbp),%xmm1
ff
mov    -0x1188(%rbp),%rsi
mov    -0xa8(%rbp),%eax
shl    $0x8,%eax
add    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x10,%edi
mov    $0x2,%al
call   1050 <interpolate_2d@plt>
cvtsi2sd %eax,%xmm0
movslq -0x4c(%rbp),%rax
movsd  %xmm0,-0x1990(%rbp,%rax,8)
ff ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1fed <cu_photom_converge+0xe3d>
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x2b00(%rbp)
ff
jmp    1ffd <cu_photom_converge+0xe4d>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2b00(%rbp)
ff
jmp    1ffd <cu_photom_converge+0xe4d>
movsd  -0x2b00(%rbp),%xmm0
movslq -0x4c(%rbp),%rax
movsd  %xmm0,-0x1990(%rbp,%rax,8)
ff ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    1f39 <cu_photom_converge+0xd89>
jmp    2048 <cu_photom_converge+0xe98>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    1f22 <cu_photom_converge+0xd72>
xorps  %xmm0,%xmm0
ucomisd -0x170(%rbp),%xmm0
ff
jbe    20d9 <cu_photom_converge+0xf29>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a48(%rbp)
ff
movsd  0x2fa8(%rip),%xmm0
movsd  %xmm0,-0x2a50(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a58(%rbp)
ff
movsd  0x2f8d(%rip),%xmm0
movsd  %xmm0,-0x2a60(%rbp)
ff
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0xa8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  0x2fa1(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2824 <cu_photom_converge+0x1674>
movl   $0x1,-0x2a90(%rbp)
cmpl   $0xf,-0x2a90(%rbp)
jge    214c <cu_photom_converge+0xf9c>
movl   $0x1,-0x2a94(%rbp)
cmpl   $0xf,-0x2a94(%rbp)
jge    2133 <cu_photom_converge+0xf83>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    20fa <cu_photom_converge+0xf4a>
jmp    2138 <cu_photom_converge+0xf88>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    20e3 <cu_photom_converge+0xf33>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29d8(%rbp)
ff
movl   $0x0,-0x6c(%rbp)
cmpl   $0x1,-0x6c(%rbp)
jge    275c <cu_photom_converge+0x15ac>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29c0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29b8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29b0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29a8(%rbp)
ff
movl   $0x0,-0x2a90(%rbp)
cmpl   $0x10,-0x2a90(%rbp)
jge    24da <cu_photom_converge+0x132a>
movl   $0x0,-0x2a94(%rbp)
cmpl   $0x10,-0x2a94(%rbp)
jge    24c1 <cu_photom_converge+0x1311>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
cvtsi2sdl -0x2a90(%rbp),%xmm0
ff
movsd  0x2e68(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x2e24(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,-0x2b08(%rbp)
ff
cvtsi2sdl -0x2a94(%rbp),%xmm0
ff
movsd  0x2e3f(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x2dfb(%rip),%xmm1
call   1090 <pow@plt>
movsd  -0x2b08(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  -0x29a0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    24a8 <cu_photom_converge+0x12f8>
movsd  0x2de0(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a90(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0x2de8(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xb0(%rbp)
movsd  0x2daa(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a94(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0x2db2(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0xc0(%rbp),%eax
add    -0xb0(%rbp),%eax
mov    -0xbc(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    0x60(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2a78(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
mov    0x58(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x29a8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x29a8(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
movslq -0x4c(%rbp),%rax
mulsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x29b0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x29b0(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x29b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x29b8(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x29c0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x29c0(%rbp)
ff
movsd  -0x2a78(%rbp),%xmm0
ff
addsd  -0x29c8(%rbp),%xmm0
ff
movsd  %xmm0,-0x29c8(%rbp)
ff
mov    0x58(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x29d0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x29d0(%rbp)
ff
cmpl   $0x177,-0xa8(%rbp)
jne    24a3 <cu_photom_converge+0x12f3>
mov    -0xa8(%rbp),%esi
mov    -0x2a90(%rbp),%edx
mov    -0x2a94(%rbp),%ecx
mov    -0xb0(%rbp),%r8d
mov    -0xb4(%rbp),%r9d
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x2a78(%rbp),%xmm1
ff
mov    0x58(%rbp),%rax
movslq -0xc4(%rbp),%rdi
movsd  (%rax,%rdi,8),%xmm2
mov    0x60(%rbp),%rax
movslq -0xc4(%rbp),%rdi
movsd  (%rax,%rdi,8),%xmm3
movsd  -0x40(%rbp),%xmm4
lea    0x2c61(%rip),%rdi
mov    $0x5,%al
call   1040 <printf@plt>
movsd  -0x29a8(%rbp),%xmm0
ff
movsd  -0x29b0(%rbp),%xmm1
ff
lea    0x2c9d(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
jmp    24a8 <cu_photom_converge+0x12f8>
jmp    24ad <cu_photom_converge+0x12fd>
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    21cb <cu_photom_converge+0x101b>
jmp    24c6 <cu_photom_converge+0x1316>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    21b4 <cu_photom_converge+0x1004>
cmpl   $0x1,-0x2ab8(%rbp)
jne    2582 <cu_photom_converge+0x13d2>
movsd  -0x29b0(%rbp),%xmm0
ff
movsd  -0x29c8(%rbp),%xmm2
ff
movsd  -0x29c0(%rbp),%xmm1
ff
mulsd  -0x29c0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a88(%rbp)
ff
movsd  -0x29a8(%rbp),%xmm0
ff
movsd  -0x29c8(%rbp),%xmm2
ff
movsd  -0x29c0(%rbp),%xmm1
ff
mulsd  -0x29d0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x2a88(%rbp),%xmm0
ff
movsd  %xmm0,-0x29d8(%rbp)
ff
jmp    259a <cu_photom_converge+0x13ea>
movsd  -0x29a8(%rbp),%xmm0
ff
divsd  -0x29b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x29d8(%rbp)
ff
movsd  -0x29d8(%rbp),%xmm0
ff
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
je     2749 <cu_photom_converge+0x1599>
movl   $0x0,-0x2a90(%rbp)
cmpl   $0x10,-0x2a90(%rbp)
jge    273e <cu_photom_converge+0x158e>
movl   $0x0,-0x2a94(%rbp)
cmpl   $0x10,-0x2a94(%rbp)
jge    2725 <cu_photom_converge+0x1575>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
cvtsi2sdl -0x2a90(%rbp),%xmm0
ff
movsd  0x2a80(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x2a1c(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,-0x2b10(%rbp)
ff
cvtsi2sdl -0x2a94(%rbp),%xmm0
ff
movsd  0x2a57(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x29f3(%rip),%xmm1
call   1090 <pow@plt>
movsd  -0x2b10(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  -0x29a0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    270c <cu_photom_converge+0x155c>
movsd  0x29d8(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a90(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0x29e0(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xb0(%rbp)
movsd  0x29a2(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a94(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0x29aa(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0xc0(%rbp),%eax
add    -0xb0(%rbp),%eax
mov    -0xbc(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    0x60(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2a78(%rbp)
ff
jmp    2711 <cu_photom_converge+0x1561>
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    25d3 <cu_photom_converge+0x1423>
jmp    272a <cu_photom_converge+0x157a>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    25bc <cu_photom_converge+0x140c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29d8(%rbp)
ff
jmp    274e <cu_photom_converge+0x159e>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    215e <cu_photom_converge+0xfae>
movsd  -0x29d8(%rbp),%xmm0
ff
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x28a9(%rip),%xmm0
divsd  -0x29b0(%rbp),%xmm0
ff
call   10a0 <sqrt@plt>
mov    0xa8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x29d8(%rbp),%xmm0
ff
movaps 0x28f2(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x178(%rbp),%xmm0
ff
jbe    281f <cu_photom_converge+0x166f>
movsd  -0x29d8(%rbp),%xmm1
ff
movaps 0x28d1(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x28a5(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    281f <cu_photom_converge+0x166f>
mov    0x68(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    281f <cu_photom_converge+0x166f>
movsd  -0x29d8(%rbp),%xmm0
ff
movaps 0x288d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
jmp    2824 <cu_photom_converge+0x1674>
jmp    2829 <cu_photom_converge+0x1679>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1eac <cu_photom_converge+0xcfc>
cmpl   $0x0,-0xb8(%rbp)
jle    351e <cu_photom_converge+0x236e>
mov    -0xb8(%rbp),%esi
lea    0x28f7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  -0x28(%rbp),%xmm0
lea    0x2924(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movsd  0x27cf(%rip),%xmm0
mulsd  -0x178(%rbp),%xmm0
ff
lea    0x291e(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x0,-0x2abc(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    327c <cu_photom_converge+0x20cc>
mov    -0xa8(%rbp),%esi
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0xa8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
lea    0x28c6(%rip),%rdi
mov    $0x3,%al
call   1040 <printf@plt>
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
jne    3263 <cu_photom_converge+0x20b3>
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2767(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x2703(%rip),%xmm1
mulsd  -0x178(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jbe    3263 <cu_photom_converge+0x20b3>
mov    0x68(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    3263 <cu_photom_converge+0x20b3>
mov    -0x2abc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2abc(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x100,-0x68(%rbp)
jge    29d7 <cu_photom_converge+0x1827>
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1990(%rbp,%rax,8)
ff ff
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2190(%rbp,%rax,8)
ff ff
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2990(%rbp,%rax,8)
ff ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    298c <cu_photom_converge+0x17dc>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movl   $0x1,-0x2a90(%rbp)
cmpl   $0xf,-0x2a90(%rbp)
jge    2b26 <cu_photom_converge+0x1976>
movl   $0x1,-0x2a94(%rbp)
cmpl   $0xf,-0x2a94(%rbp)
jge    2b0d <cu_photom_converge+0x195d>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
movsd  -0x150(%rbp),%xmm0
ff
movsd  -0x158(%rbp),%xmm1
ff
mov    -0x1188(%rbp),%rsi
mov    -0xa8(%rbp),%eax
shl    $0x8,%eax
add    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x10,%edi
mov    $0x2,%al
call   1050 <interpolate_2d@plt>
cvtsi2sd %eax,%xmm0
movslq -0x4c(%rbp),%rax
movsd  %xmm0,-0x1990(%rbp,%rax,8)
ff ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2ab7 <cu_photom_converge+0x1907>
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x2b18(%rbp)
ff
jmp    2ac7 <cu_photom_converge+0x1917>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2b18(%rbp)
ff
jmp    2ac7 <cu_photom_converge+0x1917>
movsd  -0x2b18(%rbp),%xmm0
ff
movslq -0x4c(%rbp),%rax
movsd  %xmm0,-0x1990(%rbp,%rax,8)
ff ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    2a03 <cu_photom_converge+0x1853>
jmp    2b12 <cu_photom_converge+0x1962>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    29ec <cu_photom_converge+0x183c>
movl   $0x2,-0x2a90(%rbp)
cmpl   $0xe,-0x2a90(%rbp)
jge    2c67 <cu_photom_converge+0x1ab7>
movl   $0x2,-0x2a94(%rbp)
cmpl   $0xe,-0x2a94(%rbp)
jge    2c4e <cu_photom_converge+0x1a9e>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
cltq
movsd  -0x1990(%rbp,%rax,8),%xmm1
ff ff
mov    -0x2a90(%rbp),%eax
sub    $0x1,%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
cltq
subsd  -0x1990(%rbp,%rax,8),%xmm1
ff ff
movsd  0x2486(%rip),%xmm0
mulsd  %xmm1,%xmm0
divsd  -0x170(%rbp),%xmm0
ff
movslq -0x4c(%rbp),%rax
movsd  %xmm0,-0x2190(%rbp,%rax,8)
ff ff
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
add    $0x1,%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
cltq
movsd  -0x1990(%rbp,%rax,8),%xmm1
ff ff
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
sub    $0x1,%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
cltq
subsd  -0x1990(%rbp,%rax,8),%xmm1
ff ff
movsd  0x241f(%rip),%xmm0
mulsd  %xmm1,%xmm0
divsd  -0x170(%rbp),%xmm0
ff
movslq -0x4c(%rbp),%rax
movsd  %xmm0,-0x2990(%rbp,%rax,8)
ff ff
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    2b47 <cu_photom_converge+0x1997>
jmp    2c53 <cu_photom_converge+0x1aa3>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    2b30 <cu_photom_converge+0x1980>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a30(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a28(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a20(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a18(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a10(%rbp)
ff
movl   $0x2,-0x2a90(%rbp)
cmpl   $0xe,-0x2a90(%rbp)
jge    3101 <cu_photom_converge+0x1f51>
movl   $0x2,-0x2a94(%rbp)
cmpl   $0xe,-0x2a94(%rbp)
jge    30e8 <cu_photom_converge+0x1f38>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
movsd  0x2354(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a90(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0xb0(%rbp)
movsd  0x232f(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a94(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0xc0(%rbp),%eax
add    -0xb0(%rbp),%eax
mov    -0xbc(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    0x60(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2a78(%rbp)
ff
movsd  -0x2a78(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    30cf <cu_photom_converge+0x1f1f>
movslq -0x4c(%rbp),%rax
movsd  -0x2190(%rbp,%rax,8),%xmm0
ff ff
movaps 0x2309(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x22d5(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    30cf <cu_photom_converge+0x1f1f>
movslq -0x4c(%rbp),%rax
movsd  -0x2990(%rbp,%rax,8),%xmm0
ff ff
movaps 0x22df(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x22ab(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    30cf <cu_photom_converge+0x1f1f>
mov    0x58(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm2
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a08(%rbp)
ff
movsd  -0x2a08(%rbp),%xmm0
ff
movslq -0x4c(%rbp),%rax
mulsd  -0x2190(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x2a10(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a10(%rbp)
ff
movsd  -0x2a08(%rbp),%xmm0
ff
movslq -0x4c(%rbp),%rax
mulsd  -0x2990(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x2a18(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a18(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x2190(%rbp,%rax,8),%xmm0
ff ff
movslq -0x4c(%rbp),%rax
mulsd  -0x2190(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x2a20(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a20(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x2990(%rbp,%rax,8),%xmm0
ff ff
movslq -0x4c(%rbp),%rax
mulsd  -0x2990(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x2a28(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a28(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x2190(%rbp,%rax,8),%xmm0
ff ff
movslq -0x4c(%rbp),%rax
mulsd  -0x2990(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x2a30(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a30(%rbp)
ff
movsd  -0x2a08(%rbp),%xmm0
ff
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
je     2ff0 <cu_photom_converge+0x1e40>
mov    0x58(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm2
ff ff
lea    0x2265(%rip),%rdi
mov    $0x3,%al
call   1040 <printf@plt>
mov    -0x2a90(%rbp),%esi
mov    -0x2a94(%rbp),%edx
movsd  -0x2a08(%rbp),%xmm0
ff
movsd  -0x2a10(%rbp),%xmm1
ff
movsd  -0x2a18(%rbp),%xmm2
ff
movsd  -0x2a20(%rbp),%xmm3
ff
movsd  -0x2a28(%rbp),%xmm4
ff
movsd  -0x2a30(%rbp),%xmm5
ff
lea    0x2233(%rip),%rdi
mov    $0x6,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
movsd  -0x2a10(%rbp),%xmm0
ff
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
jne    3068 <cu_photom_converge+0x1eb8>
movsd  -0x2a10(%rbp),%xmm0
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
jne    3068 <cu_photom_converge+0x1eb8>
movsd  -0x2a10(%rbp),%xmm0
ff
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
jne    3068 <cu_photom_converge+0x1eb8>
movsd  -0x2a10(%rbp),%xmm0
ff
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
jne    3068 <cu_photom_converge+0x1eb8>
movsd  -0x2a10(%rbp),%xmm0
ff
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
je     30ca <cu_photom_converge+0x1f1a>
lea    0x21bc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2a90(%rbp),%esi
mov    -0x2a94(%rbp),%edx
movsd  -0x2a08(%rbp),%xmm0
ff
movsd  -0x2a10(%rbp),%xmm1
ff
movsd  -0x2a18(%rbp),%xmm2
ff
movsd  -0x2a20(%rbp),%xmm3
ff
movsd  -0x2a28(%rbp),%xmm4
ff
movsd  -0x2a30(%rbp),%xmm5
ff
lea    0x2159(%rip),%rdi
mov    $0x6,%al
call   1040 <printf@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
jmp    30cf <cu_photom_converge+0x1f1f>
jmp    30d4 <cu_photom_converge+0x1f24>
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    2cbf <cu_photom_converge+0x1b0f>
jmp    30ed <cu_photom_converge+0x1f3d>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    2ca8 <cu_photom_converge+0x1af8>
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x2a10(%rbp),%xmm2
ff
movsd  -0x2a18(%rbp),%xmm1
ff
mulsd  -0x2a30(%rbp),%xmm1
ff
divsd  -0x2a28(%rbp),%xmm1
ff
subsd  %xmm1,%xmm2
movsd  -0x2a48(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a48(%rbp)
ff
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x2a20(%rbp),%xmm2
ff
movsd  -0x2a30(%rbp),%xmm1
ff
mulsd  -0x2a30(%rbp),%xmm1
ff
divsd  -0x2a28(%rbp),%xmm1
ff
subsd  %xmm1,%xmm2
movsd  -0x2a50(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a50(%rbp)
ff
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x2a18(%rbp),%xmm2
ff
movsd  -0x2a10(%rbp),%xmm1
ff
mulsd  -0x2a30(%rbp),%xmm1
ff
divsd  -0x2a20(%rbp),%xmm1
ff
subsd  %xmm1,%xmm2
movsd  -0x2a58(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a58(%rbp)
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x2a28(%rbp),%xmm2
ff
movsd  -0x2a30(%rbp),%xmm1
ff
mulsd  -0x2a30(%rbp),%xmm1
ff
divsd  -0x2a20(%rbp),%xmm1
ff
subsd  %xmm1,%xmm2
movsd  -0x2a60(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a60(%rbp)
ff
jmp    3268 <cu_photom_converge+0x20b8>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    28a3 <cu_photom_converge+0x16f3>
mov    -0xb8(%rbp),%esi
mov    -0x2abc(%rbp),%edx
lea    0x1fc7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpl   $0x0,-0x2abc(%rbp)
jle    3519 <cu_photom_converge+0x2369>
movsd  -0x2a48(%rbp),%xmm0
ff
divsd  -0x2a50(%rbp),%xmm0
ff
movsd  %xmm0,-0x2a68(%rbp)
ff
movsd  -0x2a58(%rbp),%xmm0
ff
divsd  -0x2a60(%rbp),%xmm0
ff
movsd  %xmm0,-0x2a70(%rbp)
ff
movsd  -0x2a68(%rbp),%xmm0
ff
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
je     3319 <cu_photom_converge+0x2169>
movsd  -0x2a48(%rbp),%xmm0
ff
movsd  -0x2a50(%rbp),%xmm1
ff
movsd  -0x2a68(%rbp),%xmm2
ff
movsd  -0x178(%rbp),%xmm3
ff
lea    0x1f63(%rip),%rdi
mov    $0x4,%al
call   1040 <printf@plt>
movsd  -0x2a70(%rbp),%xmm0
ff
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
je     335f <cu_photom_converge+0x21af>
movsd  -0x2a58(%rbp),%xmm0
ff
movsd  -0x2a60(%rbp),%xmm1
ff
movsd  -0x2a70(%rbp),%xmm2
ff
movsd  -0x178(%rbp),%xmm3
ff
lea    0x1f45(%rip),%rdi
mov    $0x4,%al
call   1040 <printf@plt>
movsd  -0x2a68(%rbp),%xmm0
ff
movaps 0x1d32(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x2ab0(%rbp),%xmm0
ff
jbe    33e1 <cu_photom_converge+0x2231>
movsd  -0x2a68(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    33aa <cu_photom_converge+0x21fa>
movsd  -0x2ab0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2b20(%rbp)
ff
jmp    33d1 <cu_photom_converge+0x2221>
movsd  -0x2ab0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x2b20(%rbp)
ff
movsd  -0x2b20(%rbp),%xmm0
ff
movsd  %xmm0,-0x2a68(%rbp)
ff
movsd  -0x2a70(%rbp),%xmm0
ff
movaps 0x1cb0(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x2ab0(%rbp),%xmm0
ff
jbe    3463 <cu_photom_converge+0x22b3>
movsd  -0x2a70(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    342c <cu_photom_converge+0x227c>
movsd  -0x2ab0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2b28(%rbp)
ff
jmp    3453 <cu_photom_converge+0x22a3>
movsd  -0x2ab0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x2b28(%rbp)
ff
movsd  -0x2b28(%rbp),%xmm0
ff
movsd  %xmm0,-0x2a70(%rbp)
ff
movsd  -0x2a68(%rbp),%xmm1
ff
movsd  -0x30(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x2a70(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x30(%rbp),%xmm0
addsd  -0x2a68(%rbp),%xmm0
ff
movsd  -0x38(%rbp),%xmm1
addsd  -0x2a70(%rbp),%xmm1
ff
movsd  -0x2a68(%rbp),%xmm2
ff
movsd  -0x2a70(%rbp),%xmm3
ff
movsd  -0x30(%rbp),%xmm4
movsd  -0x38(%rbp),%xmm5
lea    0x1dfb(%rip),%rdi
mov    $0x6,%al
call   1040 <printf@plt>
movsd  -0x30(%rbp),%xmm0
subsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x30(%rbp),%xmm2
subsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x38(%rbp),%xmm1
subsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm3
subsd  -0xd8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a80(%rbp)
ff
jmp    3539 <cu_photom_converge+0x2389>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2a80(%rbp)
ff
movsd  0x1af7(%rip),%xmm0
movsd  %xmm0,-0x2a68(%rbp)
ff
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%ecx
xor    %eax,%eax
cmp    -0x2ab4(%rbp),%ecx
mov    %al,-0x2b29(%rbp)
jge    35da <cu_photom_converge+0x242a>
movsd  -0x2a68(%rbp),%xmm0
ff
movaps 0x1b2f(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x1ad3(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     35c1 <cu_photom_converge+0x2411>
movsd  -0x2a70(%rbp),%xmm0
ff
movaps 0x1b0a(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x1aae(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     35c1 <cu_photom_converge+0x2411>
xor    %eax,%eax
cmpl   $0x0,-0xb8(%rbp)
mov    %al,-0x2b29(%rbp)
jne    35da <cu_photom_converge+0x242a>
movsd  0x1a8f(%rip),%xmm0
ucomisd -0x2a80(%rbp),%xmm0
ff
seta   %al
mov    %al,-0x2b29(%rbp)
mov    -0x2b29(%rbp),%al
test   $0x1,%al
jne    1e15 <cu_photom_converge+0xc65>
movsd  -0x2a80(%rbp),%xmm0
ff
movsd  -0x48(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jb     362c <cu_photom_converge+0x247c>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x30(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x38(%rbp)
lea    0x1ccb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movsd  -0x30(%rbp),%xmm0
subsd  -0xd0(%rbp),%xmm0
ff
mov    0x70(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x38(%rbp),%xmm0
subsd  -0xd8(%rbp),%xmm0
ff
mov    0x78(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    0x70(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x78(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x30(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm3
lea    0x1cb4(%rip),%rdi
mov    $0x4,%al
call   1040 <printf@plt>
movsd  0x19b2(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
call   1030 <ceil@plt>
movsd  0x19a0(%rip),%xmm1
addsd  -0x30(%rbp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  0x1987(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
call   1030 <ceil@plt>
movsd  0x1975(%rip),%xmm1
addsd  -0x38(%rbp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    3ff7 <cu_photom_converge+0x2e47>
movl   $0x0,-0x68(%rbp)
cmpl   $0x100,-0x68(%rbp)
jge    3747 <cu_photom_converge+0x2597>
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1990(%rbp,%rax,8)
ff ff
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2190(%rbp,%rax,8)
ff ff
movslq -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2990(%rbp,%rax,8)
ff ff
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    36fc <cu_photom_converge+0x254c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movl   $0x1,-0x2a90(%rbp)
cmpl   $0xf,-0x2a90(%rbp)
jge    3896 <cu_photom_converge+0x26e6>
movl   $0x1,-0x2a94(%rbp)
cmpl   $0xf,-0x2a94(%rbp)
jge    387d <cu_photom_converge+0x26cd>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
movsd  -0x150(%rbp),%xmm0
ff
movsd  -0x158(%rbp),%xmm1
ff
mov    -0x1188(%rbp),%rsi
mov    -0xa8(%rbp),%eax
shl    $0x8,%eax
add    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
mov    $0x10,%edi
mov    $0x2,%al
call   1050 <interpolate_2d@plt>
cvtsi2sd %eax,%xmm0
movslq -0x4c(%rbp),%rax
movsd  %xmm0,-0x1990(%rbp,%rax,8)
ff ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    3827 <cu_photom_converge+0x2677>
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x2b38(%rbp)
ff
jmp    3837 <cu_photom_converge+0x2687>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x2b38(%rbp)
ff
jmp    3837 <cu_photom_converge+0x2687>
movsd  -0x2b38(%rbp),%xmm0
ff
movslq -0x4c(%rbp),%rax
movsd  %xmm0,-0x1990(%rbp,%rax,8)
ff ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    3773 <cu_photom_converge+0x25c3>
jmp    3882 <cu_photom_converge+0x26d2>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    375c <cu_photom_converge+0x25ac>
movsd  0x17c2(%rip),%xmm0
ucomisd -0x170(%rbp),%xmm0
ff
jbe    38e2 <cu_photom_converge+0x2732>
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0xa8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  0x1798(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    3fde <cu_photom_converge+0x2e2e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29d8(%rbp)
ff
movl   $0x0,-0x6c(%rbp)
cmpl   $0x1,-0x6c(%rbp)
jge    3e5d <cu_photom_converge+0x2cad>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29d0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29c8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29c0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29b8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29b0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x29a8(%rbp)
ff
movl   $0x0,-0x2a90(%rbp)
cmpl   $0x10,-0x2a90(%rbp)
jge    3bb3 <cu_photom_converge+0x2a03>
movl   $0x0,-0x2a94(%rbp)
cmpl   $0x10,-0x2a94(%rbp)
jge    3b9a <cu_photom_converge+0x29ea>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
cvtsi2sdl -0x2a90(%rbp),%xmm0
ff
movsd  0x16d2(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x168e(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,-0x2b40(%rbp)
ff
cvtsi2sdl -0x2a94(%rbp),%xmm0
ff
movsd  0x16a9(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x1665(%rip),%xmm1
call   1090 <pow@plt>
movsd  -0x2b40(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  -0x29a0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    3b81 <cu_photom_converge+0x29d1>
movsd  0x164a(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a90(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0xb0(%rbp)
movsd  0x1625(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a94(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0xc0(%rbp),%eax
add    -0xb0(%rbp),%eax
mov    -0xbc(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    0x60(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2a78(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
mov    0x58(%rbp),%rax
movslq -0xc4(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x29a8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x29a8(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
movslq -0x4c(%rbp),%rax
mulsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x29b0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x29b0(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
addsd  -0x29b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x29b8(%rbp)
ff
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x29c0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x29c0(%rbp)
ff
movsd  -0x2a78(%rbp),%xmm0
ff
addsd  -0x29c8(%rbp),%xmm0
ff
movsd  %xmm0,-0x29c8(%rbp)
ff
mov    0x58(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x2a78(%rbp),%xmm2
ff
movsd  -0x29d0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x29d0(%rbp)
ff
jmp    3b86 <cu_photom_converge+0x29d6>
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    3961 <cu_photom_converge+0x27b1>
jmp    3b9f <cu_photom_converge+0x29ef>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    394a <cu_photom_converge+0x279a>
cmpl   $0x1,-0x2ab8(%rbp)
jne    3c5b <cu_photom_converge+0x2aab>
movsd  -0x29b0(%rbp),%xmm0
ff
movsd  -0x29c8(%rbp),%xmm2
ff
movsd  -0x29c0(%rbp),%xmm1
ff
mulsd  -0x29c0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a88(%rbp)
ff
movsd  -0x29a8(%rbp),%xmm0
ff
movsd  -0x29c8(%rbp),%xmm2
ff
movsd  -0x29c0(%rbp),%xmm1
ff
mulsd  -0x29d0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x2a88(%rbp),%xmm0
ff
movsd  %xmm0,-0x29d8(%rbp)
ff
jmp    3c73 <cu_photom_converge+0x2ac3>
movsd  -0x29a8(%rbp),%xmm0
ff
divsd  -0x29b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x29d8(%rbp)
ff
movsd  -0x29d8(%rbp),%xmm0
ff
mov    $0x1,%al
call   1080 <isnan@plt>
cmp    $0x0,%eax
je     3e4a <cu_photom_converge+0x2c9a>
movl   $0x0,-0x2a90(%rbp)
cmpl   $0x10,-0x2a90(%rbp)
jge    3e45 <cu_photom_converge+0x2c95>
movl   $0x0,-0x2a94(%rbp)
cmpl   $0x10,-0x2a94(%rbp)
jge    3e2c <cu_photom_converge+0x2c7c>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
cvtsi2sdl -0x2a90(%rbp),%xmm0
ff
movsd  0x1387(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x1343(%rip),%xmm1
call   1090 <pow@plt>
movsd  %xmm0,-0x2b48(%rbp)
ff
cvtsi2sdl -0x2a94(%rbp),%xmm0
ff
movsd  0x135e(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  0x131a(%rip),%xmm1
call   1090 <pow@plt>
movsd  -0x2b48(%rbp),%xmm1
ff
addsd  %xmm0,%xmm1
movsd  -0x29a0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    3e13 <cu_photom_converge+0x2c63>
movsd  0x12ff(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a90(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0x1307(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xb0(%rbp)
movsd  0x12c9(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a94(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  0x12d1(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0xc0(%rbp),%eax
add    -0xb0(%rbp),%eax
mov    -0xbc(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
movsd  -0x29d8(%rbp),%xmm1
ff
movslq -0x4c(%rbp),%rax
mulsd  -0x1990(%rbp,%rax,8),%xmm1
ff ff
divsd  -0x40(%rbp),%xmm1
movsd  0x1239(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2a78(%rbp)
ff
mov    0x60(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2a78(%rbp)
ff
jmp    3e18 <cu_photom_converge+0x2c68>
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    3cac <cu_photom_converge+0x2afc>
jmp    3e31 <cu_photom_converge+0x2c81>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    3c95 <cu_photom_converge+0x2ae5>
jmp    3e4a <cu_photom_converge+0x2c9a>
jmp    3e4f <cu_photom_converge+0x2c9f>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    38f4 <cu_photom_converge+0x2744>
movsd  -0x29d8(%rbp),%xmm0
ff
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x11a8(%rip),%xmm0
divsd  -0x29b0(%rbp),%xmm0
ff
call   10a0 <sqrt@plt>
mov    0xa8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x2a90(%rbp)
cmpl   $0x10,-0x2a90(%rbp)
jge    3fd9 <cu_photom_converge+0x2e29>
movl   $0x0,-0x2a94(%rbp)
cmpl   $0x10,-0x2a94(%rbp)
jge    3fc0 <cu_photom_converge+0x2e10>
mov    -0x2a90(%rbp),%eax
mov    -0x2a94(%rbp),%ecx
imul   0x90(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
movsd  0x1152(%rip),%xmm0
addsd  -0x30(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a90(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0xb0(%rbp)
movsd  0x112d(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
call   10d0 <floor@plt>
cvttsd2si %xmm0,%eax
add    -0x2a94(%rbp),%eax
sub    $0x7,%eax
mov    %eax,-0xb4(%rbp)
mov    -0xa8(%rbp),%eax
imul   -0xc0(%rbp),%eax
add    -0xb0(%rbp),%eax
mov    -0xbc(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x4c(%rbp),%rax
movsd  -0x1990(%rbp,%rax,8),%xmm2
ff ff
mov    0x58(%rbp),%rax
movslq -0xc4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2a94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a94(%rbp)
jmp    3ec1 <cu_photom_converge+0x2d11>
jmp    3fc5 <cu_photom_converge+0x2e15>
mov    -0x2a90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2a90(%rbp)
jmp    3eaa <cu_photom_converge+0x2cfa>
jmp    3fde <cu_photom_converge+0x2e2e>
jmp    3fe3 <cu_photom_converge+0x2e33>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    36e6 <cu_photom_converge+0x2536>
add    $0x2b50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cu_photom_converge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2a48,%rsp
movsd  %xmm4,0x1f8(%rsp)
movapd %xmm2,0x1e0(%rsp)
movapd %xmm1,0x1d0(%rsp)
movsd  %xmm0,0x1c8(%rsp)
mov    %r9,0x170(%rsp)
mov    %rcx,0xf0(%rsp)
mov    %rdx,0x140(%rsp)
mov    %rsi,0x1c0(%rsp)
mov    %edi,%r13d
mov    0x2aa8(%rsp),%rbx
mov    %r8d,0x84(%rsp)
mov    %r8d,%eax
shl    $0x8,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1090 <malloc@plt>
cvttsd2si (%rbx),%r14d
mov    %rax,0x1b0(%rsp)
movsd  0x8(%rbx),%xmm5
movupd 0x10(%rbx),%xmm6
movsd  0x30(%rbx),%xmm3
movsd  0x38(%rbx),%xmm0
movsd  %xmm0,0x1b8(%rsp)
ucomisd 0x2d74(%rip),%xmm3
jbe    12ba <cu_photom_converge+0xda>
lea    0x309a(%rip),%rdi
movsd  %xmm5,0x10(%rsp)
movapd %xmm6,0x40(%rsp)
call   1030 <puts@plt>
movapd 0x40(%rsp),%xmm6
movsd  0x10(%rsp),%xmm5
movsd  0x2d46(%rip),%xmm3
mov    0x2ab0(%rsp),%r10
xorpd  %xmm4,%xmm4
cmp    $0x3,%r14d
jl     139f <cu_photom_converge+0x1bf>
mov    %r14d,%r15d
add    $0xffffffff,%r14d
lea    -0x1(%r14),%r12
lea    -0x2(%r14),%r8
mov    %r12d,%r9d
and    $0x3,%r9d
mov    %r15,%rdi
shl    $0x5,%rdi
lea    0x0(,%r15,8),%rbp
lea    0x0(,%rbp,2),%rdx
add    %rbp,%rdx
mov    %r15,%rax
shl    $0x4,%rax
and    $0xfffffffffffffffc,%r12
neg    %r12
xorpd  %xmm4,%xmm4
mov    $0x1,%r11d
jmp    132d <cu_photom_converge+0x14d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    $0x8,%r10
cmp    %r14,%r11
je     139f <cu_photom_converge+0x1bf>
mov    $0x1,%esi
cmp    $0x3,%r8
jb     136e <cu_photom_converge+0x18e>
mov    %r10,%rbx
nopl   0x0(%rax,%rax,1)
addsd  0x8(%rbx,%r15,8),%xmm4
addsd  0x8(%rbx,%rax,1),%xmm4
addsd  0x8(%rbx,%rdx,1),%xmm4
addsd  0x8(%rbx,%rdi,1),%xmm4
add    %rdi,%rbx
lea    (%r12,%rsi,1),%rcx
add    $0x4,%rcx
add    $0x4,%rsi
cmp    $0x1,%rcx
jne    1340 <cu_photom_converge+0x160>
test   %r9,%r9
mov    0x2ab0(%rsp),%rcx
je     1320 <cu_photom_converge+0x140>
imul   %r15,%rsi
add    %r11,%rsi
lea    (%rcx,%rsi,8),%rsi
mov    %r9,%rbx
nopl   0x0(%rax)
addsd  (%rsi),%xmm4
add    %rbp,%rsi
add    $0xffffffffffffffff,%rbx
jne    1390 <cu_photom_converge+0x1b0>
jmp    1320 <cu_photom_converge+0x140>
mov    0x2b00(%rsp),%eax
cmp    $0x1,%r13d
movsd  %xmm3,0x148(%rsp)
je     13f3 <cu_photom_converge+0x213>
test   %r13d,%r13d
mov    0x170(%rsp),%r15
jne    154e <cu_photom_converge+0x36e>
addsd  %xmm5,%xmm5
mulsd  0x2c36(%rip),%xmm5
movsd  0x2c3e(%rip),%xmm0
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm5
mulsd  0x2c26(%rip),%xmm4
addsd  %xmm5,%xmm4
jmp    154e <cu_photom_converge+0x36e>
mov    0x2aa8(%rsp),%rax
movsd  0x40(%rax),%xmm7
movapd %xmm6,%xmm1
mulpd  %xmm6,%xmm1
mulsd  %xmm7,%xmm7
movapd 0x2c6c(%rip),%xmm2
divpd  %xmm1,%xmm2
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
movapd %xmm2,%xmm0
subsd  %xmm1,%xmm0
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm7,%xmm0
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
movsd  %xmm4,0x30(%rsp)
movsd  %xmm5,0x10(%rsp)
movapd %xmm6,0x40(%rsp)
movapd %xmm1,0xa0(%rsp)
movapd %xmm0,0x120(%rsp)
jb     1468 <cu_photom_converge+0x288>
sqrtsd %xmm0,%xmm0
jmp    147a <cu_photom_converge+0x29a>
call   10d0 <sqrt@plt>
xorpd  %xmm2,%xmm2
movapd 0xa0(%rsp),%xmm1
mov    0x170(%rsp),%r15
addsd  %xmm1,%xmm0
ucomisd %xmm2,%xmm0
jb     1495 <cu_photom_converge+0x2b5>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    149e <cu_photom_converge+0x2be>
call   10d0 <sqrt@plt>
movapd %xmm0,%xmm1
movapd 0x120(%rsp),%xmm0
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
movapd %xmm1,0x60(%rsp)
jb     14bd <cu_photom_converge+0x2dd>
sqrtsd %xmm0,%xmm0
jmp    14c6 <cu_photom_converge+0x2e6>
call   10d0 <sqrt@plt>
xorpd  %xmm2,%xmm2
movapd 0xa0(%rsp),%xmm1
subsd  %xmm0,%xmm1
ucomisd %xmm2,%xmm1
jb     14e2 <cu_photom_converge+0x302>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    14eb <cu_photom_converge+0x30b>
movapd %xmm1,%xmm0
call   10d0 <sqrt@plt>
mov    0x2b00(%rsp),%eax
movsd  0x30(%rsp),%xmm4
movsd  0x10(%rsp),%xmm1
movapd 0x40(%rsp),%xmm2
movapd 0x2b74(%rip),%xmm3
movapd 0x60(%rsp),%xmm5
unpcklpd %xmm0,%xmm5
divpd  %xmm5,%xmm3
mulsd  0x2ae6(%rip),%xmm1
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
mulsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mulsd  0x2ac6(%rip),%xmm4
addsd  %xmm0,%xmm4
mov    %eax,%r12d
test   %eax,%eax
jle    1645 <cu_photom_converge+0x465>
mov    0x2b08(%rsp),%r14d
lea    -0x1(%r14),%r8
mov    %r14d,%r9d
and    $0x3,%r9d
and    $0xfffffffc,%r14d
mov    %r12,%rbx
shl    $0x4,%rbx
mov    %r12,%rdi
shl    $0x5,%rdi
lea    0x0(,%r12,8),%rsi
lea    (%rsi,%rsi,2),%rdx
lea    0x1a40(%rsp),%r10
xor    %r11d,%r11d
jmp    15b1 <cu_photom_converge+0x3d1>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    $0x8,%r10
cmp    %r12,%r11
je     1645 <cu_photom_converge+0x465>
cmpl   $0x0,0x2b08(%rsp)
jle    15a0 <cu_photom_converge+0x3c0>
cmp    $0x3,%r8
jae    15d0 <cu_photom_converge+0x3f0>
xor    %eax,%eax
jmp    160b <cu_photom_converge+0x42b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r10,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movq   $0x0,(%rcx)
movq   $0x0,(%rcx,%r12,8)
movq   $0x0,(%rcx,%rbx,1)
movq   $0x0,(%rcx,%rdx,1)
add    $0x4,%rax
add    %rdi,%rcx
cmp    %rax,%r14
jne    15e0 <cu_photom_converge+0x400>
test   %r9,%r9
je     15a0 <cu_photom_converge+0x3c0>
imul   %r12,%rax
add    %r11,%rax
lea    (%rsp,%rax,8),%rax
add    $0x1a40,%rax
mov    %r9,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%rax)
add    %rsi,%rax
add    $0xffffffffffffffff,%rcx
jne    1630 <cu_photom_converge+0x450>
jmp    15a0 <cu_photom_converge+0x3c0>
mov    %r13d,0x90(%rsp)
mov    0x2b00(%rsp),%esi
movslq %esi,%rax
mov    %rax,0x88(%rsp)
mov    0x84(%rsp),%eax
mov    %eax,%ecx
mov    %rcx,0x1a0(%rsp)
test   %eax,%eax
jle    2005 <cu_photom_converge+0xe25>
mov    0x140(%rsp),%rcx
lea    0x1(%rcx),%eax
add    $0x2,%ecx
imul   %eax,%ecx
mov    0xf0(%rsp),%rdx
lea    0x1(%rdx),%eax
add    $0x2,%edx
imul   %eax,%edx
mov    %ecx,%r14d
shr    $0x1f,%r14d
mov    %edx,%ebx
shr    $0x1f,%ebx
add    %ecx,%r14d
add    %edx,%ebx
mov    0x2af8(%rsp),%eax
mov    0x2af0(%rsp),%ecx
mov    0x2ac0(%rsp),%r13
mov    0x2ab8(%rsp),%rbp
sar    %r14d
add    $0xffffffff,%ecx
xorps  %xmm0,%xmm0
cvtsi2sd %ecx,%xmm0
movsd  0x2942(%rip),%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
mov    0x2ae0(%rsp),%rcx
addsd  (%rcx),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x118(%rsp)
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
sar    %ebx
mulsd  %xmm0,%xmm1
mov    0x2ae8(%rsp),%rax
addsd  (%rax),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x138(%rsp)
movslq %r14d,%rax
mov    %rax,0x60(%rsp)
xor    %ecx,%ecx
movl   $0x0,0x150(%rsp)
movl   $0x0,0x180(%rsp)
movsd  %xmm4,0x30(%rsp)
mov    %r12,0x70(%rsp)
mov    %r14d,0xb8(%rsp)
mov    %ebx,0x78(%rsp)
jmp    180b <cu_photom_converge+0x62b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x800,%edx
lea    0x2240(%rsp),%rdi
lea    0x1a40(%rsp),%rsi
call   1070 <memcpy@plt>
mov    $0x10,%edi
mov    $0x10,%esi
mov    $0x10,%edx
lea    0x2240(%rsp),%rcx
xor    %eax,%eax
call   10f0 <resolve_coeffs_2d@plt>
mov    $0x800,%edx
mov    0x198(%rsp),%rdi
lea    0x2240(%rsp),%rsi
call   1070 <memcpy@plt>
mov    0x38(%rsp),%rcx
mov    0x150(%rsp),%eax
add    (%r15,%rcx,4),%eax
mov    %eax,0x150(%rsp)
mov    0x2a98(%rsp),%rax
mov    0x180(%rsp),%edx
add    (%rax,%rcx,4),%edx
mov    %edx,0x180(%rsp)
add    $0x1,%rcx
cmp    0x1a0(%rsp),%rcx
mov    0x2b00(%rsp),%esi
je     2005 <cu_photom_converge+0xe25>
mov    %rcx,0x38(%rsp)
and    $0xffffff,%ecx
shl    $0xb,%rcx
add    0x1b0(%rsp),%rcx
mov    %rcx,0x198(%rsp)
test   %esi,%esi
mov    0x88(%rsp),%rax
jle    1770 <cu_photom_converge+0x590>
movslq 0x180(%rsp),%rcx
mov    %rcx,0x58(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x110(%rsp)
jmp    1880 <cu_photom_converge+0x6a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x110(%rsp),%rdx
add    $0x1,%rdx
mov    %rdx,%rcx
mov    %rdx,0x110(%rsp)
cmp    %r12,%rdx
je     1770 <cu_photom_converge+0x590>
cmpl   $0x0,0x2b08(%rsp)
jle    1860 <cu_photom_converge+0x680>
xor    %edx,%edx
jmp    18cf <cu_photom_converge+0x6ef>
xchg   %ax,%ax
xorpd  %xmm1,%xmm1
movsd  0x30(%rsp),%xmm0
divsd  %xmm0,%xmm1
mov    0xd0(%rsp),%rax
movsd  %xmm1,0x1a40(%rsp,%rax,8)
mov    0x160(%rsp),%rdx
add    $0x1,%rdx
mov    0x2b08(%rsp),%eax
cmp    %rax,%rdx
mov    0x88(%rsp),%rax
je     1860 <cu_photom_converge+0x680>
mov    %rdx,%rcx
imul   %rax,%rcx
mov    0x110(%rsp),%rsi
add    %rsi,%rcx
mov    %rcx,0xd0(%rsp)
mov    0x2ae0(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
mov    %r13,(%rsp)
mov    0x90(%rsp),%edi
mov    %rdx,0x160(%rsp)
mov    0x2aa8(%rsp),%rcx
mov    0x2ab0(%rsp),%r8
mov    %rbp,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
mov    0x2a98(%rsp),%rcx
mov    0x38(%rsp),%rdx
cmpl   $0x0,(%rcx,%rdx,4)
jle    1890 <cu_photom_converge+0x6b0>
mov    %rdx,%rcx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x100(%rsp)
xorpd  %xmm1,%xmm1
xor    %esi,%esi
xor    %edi,%edi
movsd  0x30(%rsp),%xmm0
jmp    1a41 <cu_photom_converge+0x861>
mov    0x58(%rsp),%rax
mov    0xa0(%rsp),%rcx
add    %rcx,%rax
mov    0x2aa0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  0x100(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0xb8(%rsp),%r14d
mov    0x78(%rsp),%ebx
mov    0x2ac0(%rsp),%r13
xorps  %xmm1,%xmm1
cvtsi2sd %r15d,%xmm1
movsd  0x118(%rsp),%xmm0
call   10c0 <pow@plt>
mulsd  0x10(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
movsd  0x138(%rsp),%xmm0
call   10c0 <pow@plt>
mulsd  0x10(%rsp),%xmm0
movsd  0xc0(%rsp),%xmm1
addsd  %xmm0,%xmm1
mov    0x170(%rsp),%r15
movsd  0x30(%rsp),%xmm0
mov    0x70(%rsp),%r12
mov    0x2ab8(%rsp),%rbp
mov    0x38(%rsp),%rcx
mov    0x120(%rsp),%rsi
mov    0xa0(%rsp),%rdi
add    $0x1,%rdi
mov    0x2a98(%rsp),%rax
movslq (%rax,%rcx,4),%rax
add    $0xffffffff,%esi
cmp    %rax,%rdi
jge    189a <cu_photom_converge+0x6ba>
mov    $0x0,%eax
cmp    0x60(%rsp),%rdi
jl     1a58 <cu_photom_converge+0x878>
mov    %edi,%eax
sub    %r14d,%eax
cltd
idiv   %ebx
add    $0x1,%eax
cmp    (%r15,%rcx,4),%eax
jge    1a25 <cu_photom_converge+0x845>
mov    %rdi,0xa0(%rsp)
mov    %rsi,0x120(%rsp)
mov    %eax,%r8d
sub    $0x1,%r8d
mov    0xf0(%rsp),%r10
cmovb  0x140(%rsp),%r10d
imul   %ebx,%r8d
add    %r14d,%r8d
xor    %ebp,%ebp
mov    %eax,0x28(%rsp)
cmp    $0x1,%eax
cmovb  %ebp,%r8d
mov    $0x0,%r15d
test   %r10d,%r10d
jle    1bb0 <cu_photom_converge+0x9d0>
mov    0xa0(%rsp),%rax
mov    %eax,%r13d
sub    %r8d,%r13d
lea    0x1(%r10),%r11d
add    0x120(%rsp),%r8d
xor    %r14d,%r14d
xor    %ecx,%ecx
xor    %r15d,%r15d
xor    %ebp,%ebp
mov    %r8,0x40(%rsp)
jmp    1af2 <cu_photom_converge+0x912>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rcx),%eax
add    $0xffffffff,%r11d
cmp    %ecx,%r10d
mov    %eax,%ecx
je     1bb0 <cu_photom_converge+0x9d0>
mov    %r10d,%edx
sub    %ecx,%edx
jl     1ae0 <cu_photom_converge+0x900>
xor    %ebx,%ebx
cmp    $0x3,%edx
jb     1b77 <cu_photom_converge+0x997>
mov    %r11d,%edi
and    $0xfffffffc,%edi
lea    (%r8,%r14,1),%r9d
xor    %ebx,%ebx
mov    %r14,0x10(%rsp)
mov    %r14d,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rdx),%esi
lea    0x1(%rbx),%r12d
lea    0x2(%rdx),%r8d
mov    %r9d,%r14d
add    %ebx,%r14d
cmove  %ebx,%ebp
lea    0x2(%rbx),%eax
cmove  %ecx,%r15d
cmp    %r13d,%esi
cmove  %r12d,%ebp
cmove  %ecx,%r15d
lea    0x3(%rdx),%esi
cmp    %r13d,%r8d
cmove  %eax,%ebp
lea    0x3(%rbx),%eax
cmove  %ecx,%r15d
cmp    %r13d,%esi
cmove  %eax,%ebp
cmove  %ecx,%r15d
add    $0x4,%edx
add    $0x4,%ebx
cmp    %edi,%ebx
jne    1b20 <cu_photom_converge+0x940>
mov    0x10(%rsp),%r14
add    %ebx,%r14d
mov    0x40(%rsp),%r8
test   $0x3,%r11b
je     1ae0 <cu_photom_converge+0x900>
mov    %r11d,%edx
and    $0x3,%edx
neg    %edx
lea    (%r8,%r14,1),%esi
xor    %edi,%edi
nop
cmp    %edi,%esi
cmove  %ebx,%ebp
cmove  %ecx,%r15d
add    $0x1,%ebx
add    $0xffffffff,%edi
cmp    %edi,%edx
jne    1b90 <cu_photom_converge+0x9b0>
sub    %edi,%r14d
jmp    1ae0 <cu_photom_converge+0x900>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%eax
test   %eax,%eax
movsd  %xmm1,0xc0(%rsp)
jle    196b <cu_photom_converge+0x78b>
add    0x150(%rsp),%eax
movslq %eax,%rbx
mov    0x2a80(%rsp),%rax
mov    (%rax,%rbx,4),%r14d
add    0x110(%rsp),%r14d
mov    0x2a88(%rsp),%rax
mov    (%rax,%rbx,4),%edx
add    0x160(%rsp),%edx
mov    0x2ae0(%rsp),%r12
movsd  (%r12),%xmm0
mov    0x2ae8(%rsp),%r13
movsd  0x0(%r13),%xmm1
mov    0x2ac0(%rsp),%r12
mov    %r12,(%rsp)
mov    0x90(%rsp),%edi
mov    %r14d,%esi
mov    %rdx,%r12
mov    0x2aa8(%rsp),%rcx
mov    0x2ab0(%rsp),%r8
mov    0x2ab8(%rsp),%r13
mov    %r13,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
mov    0x2a90(%rsp),%rcx
cmpl   $0x0,(%rcx,%rbx,4)
je     1fd3 <cu_photom_converge+0xdf3>
mov    %r12,0x10(%rsp)
lea    -0x1(%r12),%edx
mov    %edx,0x40(%rsp)
lea    -0x1(%r14),%ecx
mov    0x2ae0(%rsp),%rbx
movsd  (%rbx),%xmm0
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x2ac0(%rsp),%r12
mov    %r12,(%rsp)
mov    0x90(%rsp),%r12d
mov    %r12d,%edi
mov    %ecx,%ebx
mov    %ecx,0xe0(%rsp)
mov    %ecx,%esi
mov    0x2aa8(%rsp),%rcx
mov    0x2ab0(%rsp),%r8
mov    %r13,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,0x28(%rsp)
mov    0x2ae0(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x2ac0(%rsp),%rax
mov    %rax,(%rsp)
mov    %r12d,%edi
mov    %ebx,%esi
mov    0x10(%rsp),%rbx
mov    %ebx,%edx
mov    0x2aa8(%rsp),%rcx
mov    0x2ab0(%rsp),%r8
mov    %r13,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x28(%rsp),%xmm0
movsd  %xmm0,0x1a8(%rsp)
lea    0x1(%rbx),%edx
mov    %edx,0x28(%rsp)
mov    0x2ae0(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x2ac0(%rsp),%rax
mov    %rax,(%rsp)
mov    %r12d,%edi
mov    0xe0(%rsp),%esi
mov    0x2aa8(%rsp),%rcx
mov    0x2ab0(%rsp),%rbx
mov    %rbx,%r8
mov    %r13,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x1a8(%rsp),%xmm0
movsd  %xmm0,0xe0(%rsp)
mov    0x2ae0(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x2ac0(%rsp),%rax
mov    %rax,(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    0x40(%rsp),%edx
mov    0x2aa8(%rsp),%rcx
mov    %rbx,%r8
mov    %r13,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0xe0(%rsp),%xmm0
movsd  %xmm0,0xe0(%rsp)
mov    0x2ae0(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x2ac0(%rsp),%rax
mov    %rax,(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    0x10(%rsp),%rdx
mov    0x2aa8(%rsp),%rcx
mov    %rbx,%r8
mov    %r13,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0xe0(%rsp),%xmm0
movsd  %xmm0,0xe0(%rsp)
mov    0x2ae0(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x2ac0(%rsp),%rax
mov    %rax,(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    0x28(%rsp),%ebx
mov    %ebx,%edx
mov    0x2aa8(%rsp),%rcx
mov    0x2ab0(%rsp),%r8
mov    %r13,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0xe0(%rsp),%xmm0
movsd  %xmm0,0xe0(%rsp)
add    $0x1,%r14d
mov    0x2ae0(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x2ac0(%rsp),%rax
mov    %rax,(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    0x40(%rsp),%edx
mov    0x2aa8(%rsp),%rcx
mov    0x2ab0(%rsp),%r8
mov    %r13,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0xe0(%rsp),%xmm0
movsd  %xmm0,0x40(%rsp)
mov    0x2ae0(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x2ac0(%rsp),%rax
mov    %rax,(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    0x10(%rsp),%rdx
mov    0x2aa8(%rsp),%rcx
mov    0x2ab0(%rsp),%r8
mov    %r13,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    0x2ae0(%rsp),%rax
movsd  (%rax),%xmm0
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x2ac0(%rsp),%rax
mov    %rax,(%rsp)
mov    %r12d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
mov    0x2aa8(%rsp),%rcx
mov    0x2ab0(%rsp),%r8
mov    %r13,%r9
mov    $0x2,%al
call   10a0 <integrated_profile@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  0x10(%rsp),%xmm0
divsd  0x2057(%rip),%xmm0
jmp    1fda <cu_photom_converge+0xdfa>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    0x58(%rsp),%rax
mov    0xa0(%rsp),%rcx
add    %rcx,%rax
subsd  0x100(%rsp),%xmm0
mov    0x2aa0(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm0
jmp    1991 <cu_photom_converge+0x7b1>
mov    0x2b10(%rsp),%r15
mov    0x1c0(%rsp),%rax
add    %eax,%eax
add    $0x1,%eax
movsd  0x148(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x148(%rsp)
cmpl   $0x1,0x2b20(%rsp)
01
mov    %eax,0x28(%rsp)
jne    2fcf <cu_photom_converge+0x1def>
movapd 0x1e0(%rsp),%xmm0
unpcklpd 0x1d0(%rsp),%xmm0
lea    0x1(%rsi),%ecx
mov    %ecx,0x1a8(%rsp)
mov    0x88(%rsp),%rcx
lea    (%rsp,%rcx,8),%r13
add    $0x248,%r13
lea    0x0(,%rcx,8),%rdx
imul   %eax,%eax
mov    %eax,0x140(%rsp)
lea    (%rsi,%rsi,1),%eax
add    $0x1,%eax
mov    %eax,0x1c0(%rsp)
mov    %rcx,%rax
shl    $0x4,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x1250,%rsi
mov    %rsi,0x218(%rsp)
lea    0xa50(%rsp,%rax,1),%rsi
mov    %rsi,0x210(%rsp)
lea    (%rcx,%rcx,2),%rcx
lea    0x250(%rsp,%rcx,8),%rcx
mov    %rcx,0x208(%rsp)
lea    0x250(%rsp,%rax,1),%rax
mov    %rax,0x200(%rsp)
movsd  0x1f4a(%rip),%xmm2
xor    %ebx,%ebx
movapd %xmm0,0x220(%rsp)
movapd %xmm0,%xmm1
mov    %r13,0xb8(%rsp)
mov    %rdx,0x40(%rsp)
jmp    2127 <cu_photom_converge+0xf47>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x1f48(%rip),%xmm0
ucomisd 0x160(%rsp),%xmm0
jbe    2f5e <cu_photom_converge+0x1d7e>
movapd %xmm1,0xd0(%rsp)
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm2,%xmm0
movapd %xmm0,0x150(%rsp)
mov    %ebx,%r14d
call   1040 <ceil@plt>
subsd  0x150(%rsp),%xmm0
movsd  %xmm0,0xa0(%rsp)
movapd 0xd0(%rsp),%xmm0
addsd  0x1ec0(%rip),%xmm0
movapd %xmm0,0x180(%rsp)
call   1040 <ceil@plt>
subsd  0x180(%rsp),%xmm0
movsd  %xmm0,0x120(%rsp)
movapd 0x150(%rsp),%xmm0
call   1100 <floor@plt>
cvttsd2si %xmm0,%ebx
movapd 0x180(%rsp),%xmm0
call   1100 <floor@plt>
cvttsd2si %xmm0,%eax
add    $0xfffffff8,%eax
mov    %rax,0x90(%rsp)
imul   0x28(%rsp),%eax
mov    %rbx,%rcx
mov    %rbx,0x100(%rsp)
add    %ebx,%eax
add    $0xfffffff8,%eax
mov    %eax,0x138(%rsp)
mov    %r14d,%eax
movapd 0xe0(%rsp),%xmm0
movaps 0x160(%rsp),%xmm1
movsd  %xmm1,0x70(%rsp)
jmp    2230 <cu_photom_converge+0x1050>
nopw   0x0(%rax,%rax,1)
movsd  %xmm0,0x70(%rsp)
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x78(%rsp)
mov    $0x1,%eax
movsd  0x1e17(%rip),%xmm0
mov    0x118(%rsp),%ebx
test   %ebx,%ebx
jne    26c0 <cu_photom_converge+0x14e0>
movsd  0x70(%rsp),%xmm1
movapd %xmm1,0x160(%rsp)
movapd %xmm0,0xe0(%rsp)
cmpl   $0x0,0x84(%rsp)
mov    %eax,0x118(%rsp)
xorpd  %xmm0,%xmm0
jle    2200 <cu_photom_converge+0x1020>
movsd  %xmm0,0x70(%rsp)
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x78(%rsp)
mov    0x138(%rsp),%eax
mov    %eax,0x58(%rsp)
mov    0x1a8(%rsp),%ebx
xor    %ebp,%ebp
jmp    22f4 <cu_photom_converge+0x1114>
nopw   0x0(%rax,%rax,1)
mov    0x2b10(%rsp),%r15
movq   $0x0,(%r15,%rbp,8)
mov    0x2b18(%rsp),%rax
movabs $0x412e848000000000,%rcx
84 2e 41
mov    %rcx,(%rax,%rbp,8)
movapd 0x1dc2(%rip),%xmm1
mov    0xb8(%rsp),%r13
mov    0x170(%rsp),%ebx
add    $0x1,%rbp
add    $0x100,%ebx
mov    0x58(%rsp),%eax
add    0x140(%rsp),%eax
mov    %eax,0x58(%rsp)
cmp    0x1a0(%rsp),%rbp
je     2214 <cu_photom_converge+0x1034>
mov    %rbp,0xc0(%rsp)
movapd %xmm1,0xf0(%rsp)
mov    $0x800,%edx
lea    0x240(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x800,%edx
lea    0x1240(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x800,%edx
lea    0xa40(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x1,%eax
mov    %ebx,0x170(%rsp)
mov    %ebx,%ecx
xorpd  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,0x60(%rsp)
mov    $0xe,%ebp
mov    %r13,0x38(%rsp)
mov    %r13,%rbx
mov    %ecx,0x30(%rsp)
mov    %ecx,%r15d
mov    0x1b0(%rsp),%r14
mov    0x2b00(%rsp),%r12d
xor    %r13d,%r13d
nopl   0x0(%rax)
movsd  %xmm1,0x10(%rsp)
movslq %r15d,%r15
lea    (%r14,%r15,8),%rsi
movsd  0xa0(%rsp),%xmm0
movsd  0x120(%rsp),%xmm1
mov    $0x10,%edi
mov    $0x2,%al
call   1080 <interpolate_2d@plt>
movsd  0x10(%rsp),%xmm1
mov    0x40(%rsp),%rdi
test   %eax,%eax
cmovs  %r13d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rbx)
addsd  %xmm0,%xmm1
add    %r12d,%r15d
add    %rdi,%rbx
add    $0xffffffffffffffff,%rbp
jne    2390 <cu_photom_converge+0x11b0>
mov    0x60(%rsp),%rax
add    $0x1,%rax
mov    0x30(%rsp),%ecx
add    $0x1,%ecx
mov    0x38(%rsp),%r13
add    $0x8,%r13
cmp    $0xf,%rax
jne    2360 <cu_photom_converge+0x1180>
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
mov    0x28(%rsp),%esi
mov    0xc0(%rsp),%rbp
ja     2290 <cu_photom_converge+0x10b0>
xorpd  %xmm6,%xmm6
lea    0x240(%rsp),%r14
mov    0x58(%rsp),%r13d
xor    %r12d,%r12d
movsd  0x148(%rsp),%xmm5
mov    0x2ac8(%rsp),%rcx
mov    0x2ad0(%rsp),%rdx
jmp    2480 <cu_photom_converge+0x12a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12
mov    0x30(%rsp),%r13d
add    $0x1,%r13d
mov    0x38(%rsp),%r14
add    $0x8,%r14
cmp    $0x10,%r12
je     25c0 <cu_photom_converge+0x13e0>
lea    -0x8(%r12),%eax
xorps  %xmm7,%xmm7
cvtsi2sd %eax,%xmm7
mulsd  %xmm7,%xmm7
mov    0x100(%rsp),%rax
lea    (%r12,%rax,1),%r15d
add    $0xfffffff8,%r15d
mov    %r14,0x38(%rsp)
mov    %r13d,0x30(%rsp)
xor    %ebx,%ebx
movsd  %xmm7,0x60(%rsp)
jmp    24d0 <cu_photom_converge+0x12f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
add    %esi,%r13d
add    %rdi,%r14
cmp    $0x10,%rbx
je     2460 <cu_photom_converge+0x1280>
lea    -0x8(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm7,%xmm0
ucomisd %xmm0,%xmm5
jbe    24c0 <cu_photom_converge+0x12e0>
movslq %r13d,%rax
movsd  (%rdx,%rax,8),%xmm1
movsd  (%r14),%xmm0
movsd  (%rcx,%rax,8),%xmm2
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm2,%xmm4
unpcklpd %xmm0,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm3,%xmm6
cmp    $0x177,%rbp
jne    24c0 <cu_photom_converge+0x12e0>
mov    0x90(%rsp),%rax
lea    (%rax,%rbx,1),%r9
lea    0x1b86(%rip),%rdi
mov    $0x177,%esi
mov    %r12d,%edx
mov    %ebx,%ecx
mov    %r15d,%r8d
movapd %xmm1,%xmm3
movsd  0x1b8(%rsp),%xmm4
mov    $0x5,%al
movapd %xmm6,0x10(%rsp)
call   1050 <printf@plt>
movapd 0x10(%rsp),%xmm1
unpckhpd %xmm1,%xmm1
lea    0x1ba8(%rip),%rdi
movapd 0x10(%rsp),%xmm0
mov    $0x2,%al
call   1050 <printf@plt>
movsd  0x60(%rsp),%xmm7
movapd 0x10(%rsp),%xmm6
mov    0xc0(%rsp),%rbp
mov    0x40(%rsp),%rdi
mov    0x28(%rsp),%esi
mov    0x2ad0(%rsp),%rdx
mov    0x2ac8(%rsp),%rcx
movsd  0x148(%rsp),%xmm5
jmp    24c0 <cu_photom_converge+0x12e0>
nopw   0x0(%rax,%rax,1)
movapd %xmm6,%xmm0
unpckhpd %xmm6,%xmm0
movapd %xmm0,0x60(%rsp)
divsd  %xmm0,%xmm6
movapd %xmm6,0x10(%rsp)
movapd %xmm6,%xmm0
mov    $0x1,%al
call   10b0 <isnan@plt>
movapd 0x10(%rsp),%xmm2
xorpd  %xmm1,%xmm1
test   %eax,%eax
je     25f5 <cu_photom_converge+0x1415>
xorpd  %xmm2,%xmm2
mov    0x2b10(%rsp),%r15
mov    0xc0(%rsp),%rbp
movsd  %xmm2,(%r15,%rbp,8)
movsd  0x1a25(%rip),%xmm0
divsd  0x60(%rsp),%xmm0
ucomisd %xmm1,%xmm0
mov    0xb8(%rsp),%r13
mov    0x170(%rsp),%ebx
jb     2640 <cu_photom_converge+0x1460>
sqrtsd %xmm0,%xmm0
jmp    2659 <cu_photom_converge+0x1479>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm2,0x10(%rsp)
call   10d0 <sqrt@plt>
movapd 0x10(%rsp),%xmm2
mov    0xc0(%rsp),%rbp
movapd 0x1a2f(%rip),%xmm1
mov    0x2b18(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
andpd  %xmm1,%xmm2
ucomisd 0x78(%rsp),%xmm2
jbe    26a6 <cu_photom_converge+0x14c6>
movsd  0x19be(%rip),%xmm0
ucomisd %xmm2,%xmm0
jbe    26a6 <cu_photom_converge+0x14c6>
movsd  0x1c8(%rsp),%xmm0
mov    0x2ad8(%rsp),%rax
ucomisd (%rax,%rbp,8),%xmm0
jbe    26a6 <cu_photom_converge+0x14c6>
movsd  %xmm2,0x78(%rsp)
movapd 0xf0(%rsp),%xmm1
jmp    22cd <cu_photom_converge+0x10ed>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm1,0xf0(%rsp)
lea    0x1a5f(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x1a8f(%rip),%rdi
movsd  0x1c8(%rsp),%xmm0
mov    $0x1,%al
call   1050 <printf@plt>
movsd  0x78(%rsp),%xmm0
mulsd  0x194a(%rip),%xmm0
lea    0x1a82(%rip),%rdi
movsd  %xmm0,0x110(%rsp)
mov    $0x1,%al
call   1050 <printf@plt>
cmpl   $0x0,0x84(%rsp)
jle    2ee0 <cu_photom_converge+0x1d00>
movapd 0x150(%rsp),%xmm0
call   1100 <floor@plt>
cvttsd2si %xmm0,%ebx
movapd 0x180(%rsp),%xmm0
call   1100 <floor@plt>
cvttsd2si %xmm0,%eax
add    $0xfffffffb,%eax
imul   0x28(%rsp),%eax
lea    (%rbx,%rax,1),%r14d
add    $0xfffffffb,%r14d
xorpd  %xmm0,%xmm0
movapd %xmm0,0x100(%rsp)
xor    %ebx,%ebx
mov    0x1a8(%rsp),%r12d
movl   $0x0,0x198(%rsp)
jmp    2851 <cu_photom_converge+0x1671>
mov    0x2b10(%rsp),%r15
mov    0x58(%rsp),%rbx
movsd  (%r15,%rbx,8),%xmm1
movapd %xmm1,%xmm0
mulsd  %xmm1,%xmm0
movapd %xmm11,%xmm2
mulsd  %xmm11,%xmm2
unpcklpd %xmm11,%xmm11
mulpd  %xmm10,%xmm11
movapd %xmm9,%xmm3
shufpd $0x1,%xmm9,%xmm3
divpd  %xmm9,%xmm11
shufpd $0x1,%xmm11,%xmm11
subpd  %xmm11,%xmm10
unpcklpd %xmm1,%xmm1
mulpd  %xmm10,%xmm1
addpd  %xmm1,%xmm8
movapd %xmm8,0x100(%rsp)
unpcklpd %xmm2,%xmm2
divpd  %xmm3,%xmm2
subpd  %xmm2,%xmm9
unpcklpd %xmm0,%xmm0
mulpd  %xmm9,%xmm0
movapd 0xf0(%rsp),%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0xf0(%rsp)
mov    0xb8(%rsp),%r13
mov    0x150(%rsp),%r14d
mov    0x180(%rsp),%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
add    $0x100,%r12d
add    0x140(%rsp),%r14d
cmp    0x1a0(%rsp),%rbx
je     2d20 <cu_photom_converge+0x1b40>
movsd  (%r15,%rbx,8),%xmm0
mov    0x2b18(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm1
mov    0x2ad8(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm2
lea    0x1924(%rip),%rdi
mov    %ebx,%esi
mov    $0x3,%al
call   1050 <printf@plt>
movsd  (%r15,%rbx,8),%xmm0
mov    $0x1,%al
call   10b0 <isnan@plt>
test   %eax,%eax
jne    2830 <cu_photom_converge+0x1650>
movsd  (%r15,%rbx,8),%xmm0
andpd  0x17f0(%rip),%xmm0
ucomisd 0x110(%rsp),%xmm0
jbe    2830 <cu_photom_converge+0x1650>
movsd  0x1c8(%rsp),%xmm0
mov    0x2ad8(%rsp),%rax
ucomisd (%rax,%rbx,8),%xmm0
jbe    2830 <cu_photom_converge+0x1650>
mov    %r14d,0x150(%rsp)
mov    %rbx,0x58(%rsp)
mov    $0x800,%edx
lea    0x240(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x800,%edx
lea    0x1240(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x800,%edx
lea    0xa40(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
xorpd  %xmm2,%xmm2
mov    $0x1,%eax
mov    %r13,%rbx
mov    %r12d,0x180(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,0x60(%rsp)
mov    $0xe,%r15d
mov    %rbx,0xc0(%rsp)
mov    %r12d,0x90(%rsp)
mov    %r12d,%ebp
mov    0x1b0(%rsp),%r14
mov    0x40(%rsp),%r12
xor    %r13d,%r13d
xchg   %ax,%ax
movsd  %xmm2,0x10(%rsp)
movslq %ebp,%rbp
lea    (%r14,%rbp,8),%rsi
movsd  0xa0(%rsp),%xmm0
movsd  0x120(%rsp),%xmm1
mov    $0x10,%edi
mov    $0x2,%al
call   1080 <interpolate_2d@plt>
movsd  0x10(%rsp),%xmm2
mov    0x2b00(%rsp),%ecx
test   %eax,%eax
cmovs  %r13d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%rbx)
addsd  %xmm0,%xmm2
add    %ecx,%ebp
add    %r12,%rbx
add    $0xffffffffffffffff,%r15
jne    2960 <cu_photom_converge+0x1780>
mov    0x60(%rsp),%rax
add    $0x1,%rax
mov    0x90(%rsp),%r12d
add    $0x1,%r12d
mov    0xc0(%rsp),%rbx
add    $0x8,%rbx
cmp    $0xf,%rax
jne    2930 <cu_photom_converge+0x1750>
mov    $0x2,%r8d
xor    %r9d,%r9d
mov    0x1c0(%rsp),%r11d
mov    0x2ad0(%rsp),%r10
mov    0x28(%rsp),%r15d
mov    0xb8(%rsp),%r13
mov    0x218(%rsp),%r14
mov    0x210(%rsp),%r12
mov    0x208(%rsp),%rax
movsd  0x1607(%rip),%xmm1
xorpd  %xmm4,%xmm4
movapd 0x165b(%rip),%xmm7
movsd  0x1613(%rip),%xmm6
movapd 0x100(%rsp),%xmm8
nopw   0x0(%rax,%rax,1)
mov    $0xc,%esi
mov    %r9,%rdi
mov    %r11d,%ebp
mov    0x40(%rsp),%rdx
lea    0x2(%rbp),%ebx
movslq %ebx,%rbx
movsd  0x240(%rsp,%rbx,8),%xmm0
movslq %ebp,%rbp
subsd  0x240(%rsp,%rbp,8),%xmm0
mulsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%r14,%rdi,1)
movsd  (%rax,%rdi,1),%xmm0
subsd  0x8(%r13,%rdi,1),%xmm0
mulsd  %xmm1,%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%r12,%rdi,1)
add    %ecx,%ebp
add    %rdx,%rdi
add    $0xffffffffffffffff,%rsi
jne    2a60 <cu_photom_converge+0x1880>
add    $0x1,%r8
add    $0x1,%r11d
add    $0x8,%r9
cmp    $0xe,%r8
jne    2a50 <cu_photom_converge+0x1870>
addl   $0x1,0x198(%rsp)
01
xorpd  %xmm9,%xmm9
xorpd  %xmm11,%xmm11
mov    $0x2,%edx
mov    0x150(%rsp),%r13d
mov    0x200(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    %r12,%rsi
xorpd  %xmm10,%xmm10
mov    0x2ac8(%rsp),%rax
mov    0x40(%rsp),%rcx
jmp    2b3d <cu_photom_converge+0x195d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x70(%rsp),%rdx
add    $0x1,%rdx
add    $0x8,%r14
add    $0x8,%rsi
addq   $0x8,0x38(%rsp)
mov    0x138(%rsp),%r13d
add    $0x1,%r13d
cmp    $0xe,%rdx
je     277e <cu_photom_converge+0x159e>
mov    %rdx,0x70(%rsp)
mov    $0xfffffffffffffff4,%rbx
mov    %r13d,0x138(%rsp)
xor    %r12d,%r12d
mov    %r14,0x30(%rsp)
jmp    2b6b <cu_photom_converge+0x198b>
nopl   0x0(%rax,%rax,1)
add    %rcx,%r12
add    %r15d,%r13d
inc    %rbx
je     2b10 <cu_photom_converge+0x1930>
movslq %r13d,%rbp
movsd  (%r10,%rbp,8),%xmm5
ucomisd %xmm4,%xmm5
jbe    2b60 <cu_photom_converge+0x1980>
movsd  (%r14,%r12,1),%xmm1
movapd %xmm1,%xmm2
andpd  %xmm7,%xmm2
ucomisd %xmm6,%xmm2
jbe    2b60 <cu_photom_converge+0x1980>
movsd  (%rsi,%r12,1),%xmm2
movapd %xmm2,%xmm3
andpd  %xmm7,%xmm3
ucomisd %xmm6,%xmm3
jbe    2b60 <cu_photom_converge+0x1980>
mov    %rsi,%r14
movsd  (%rax,%rbp,8),%xmm0
mov    0x38(%rsp),%rax
movsd  (%rax,%r12,1),%xmm4
mov    0x2b10(%rsp),%r15
mov    0x58(%rsp),%rax
movsd  (%r15,%rax,8),%xmm3
movsd  %xmm4,0x10(%rsp)
mulsd  %xmm4,%xmm3
subsd  %xmm3,%xmm0
movapd %xmm2,%xmm3
unpcklpd %xmm1,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm5,%xmm6
unpcklpd %xmm5,%xmm6
mulpd  %xmm6,%xmm4
addpd  %xmm4,%xmm10
movapd %xmm10,0x60(%rsp)
mulpd  %xmm3,%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm3,%xmm9
movapd %xmm9,0xc0(%rsp)
mulsd  %xmm2,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm1,%xmm11
movapd %xmm11,0x90(%rsp)
movapd %xmm0,0x170(%rsp)
mov    $0x1,%al
call   10b0 <isnan@plt>
test   %eax,%eax
jne    34d6 <cu_photom_converge+0x22f6>
movapd 0x60(%rsp),%xmm0
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x10(%rsp)
mov    $0x1,%al
call   10b0 <isnan@plt>
test   %eax,%eax
jne    347f <cu_photom_converge+0x229f>
movapd 0x10(%rsp),%xmm0
mov    $0x1,%al
call   10b0 <isnan@plt>
test   %eax,%eax
jne    347f <cu_photom_converge+0x229f>
movapd 0x10(%rsp),%xmm0
mov    $0x1,%al
call   10b0 <isnan@plt>
test   %eax,%eax
jne    347f <cu_photom_converge+0x229f>
movapd 0x10(%rsp),%xmm0
mov    $0x1,%al
call   10b0 <isnan@plt>
test   %eax,%eax
jne    347f <cu_photom_converge+0x229f>
movapd 0x10(%rsp),%xmm0
mov    $0x1,%al
call   10b0 <isnan@plt>
test   %eax,%eax
jne    347f <cu_photom_converge+0x229f>
mov    0x2ac8(%rsp),%rax
mov    0x2ad0(%rsp),%r10
mov    0x28(%rsp),%r15d
mov    0x40(%rsp),%rcx
xorpd  %xmm4,%xmm4
movapd 0x13af(%rip),%xmm7
movsd  0x1367(%rip),%xmm6
movapd 0x100(%rsp),%xmm8
movapd 0xc0(%rsp),%xmm9
movapd 0x90(%rsp),%xmm11
movapd 0x60(%rsp),%xmm10
mov    %r14,%rsi
mov    0x30(%rsp),%r14
jmp    2b60 <cu_photom_converge+0x1980>
nopl   0x0(%rax,%rax,1)
lea    0x14e5(%rip),%rdi
mov    0x118(%rsp),%esi
mov    0x198(%rsp),%ebx
mov    %ebx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
test   %ebx,%ebx
jle    2f00 <cu_photom_converge+0x1d20>
movapd 0x100(%rsp),%xmm0
divpd  0xf0(%rsp),%xmm0
movapd %xmm0,0x10(%rsp)
unpckhpd %xmm0,%xmm0
movapd %xmm0,0xa0(%rsp)
mov    $0x1,%al
call   10b0 <isnan@plt>
test   %eax,%eax
je     2dad <cu_photom_converge+0x1bcd>
movapd 0x100(%rsp),%xmm0
unpckhpd %xmm0,%xmm0
movapd 0xf0(%rsp),%xmm1
unpckhpd %xmm1,%xmm1
lea    0x1494(%rip),%rdi
movapd 0xa0(%rsp),%xmm2
movsd  0x78(%rsp),%xmm3
mov    $0x4,%al
call   1050 <printf@plt>
movaps 0x10(%rsp),%xmm0
mov    $0x1,%al
call   10b0 <isnan@plt>
test   %eax,%eax
je     2de8 <cu_photom_converge+0x1c08>
lea    0x148f(%rip),%rdi
movaps 0x100(%rsp),%xmm0
movapd 0xf0(%rsp),%xmm1
movapd 0x10(%rsp),%xmm2
movsd  0x78(%rsp),%xmm3
mov    $0x4,%al
call   1050 <printf@plt>
movapd 0x10(%rsp),%xmm2
movapd %xmm2,%xmm0
andpd  0x1296(%rip),%xmm0
movapd 0x129e(%rip),%xmm1
movapd %xmm1,%xmm3
cmpltpd %xmm0,%xmm3
xorpd  %xmm0,%xmm0
cmpltpd %xmm2,%xmm0
andpd  %xmm0,%xmm1
andnpd 0x1290(%rip),%xmm0
orpd   %xmm1,%xmm0
andpd  %xmm3,%xmm0
andnpd %xmm2,%xmm3
orpd   %xmm0,%xmm3
movapd 0xd0(%rsp),%xmm0
subpd  %xmm3,%xmm0
movapd %xmm0,%xmm1
movapd %xmm0,%xmm5
movapd %xmm0,0xd0(%rsp)
unpckhpd %xmm0,%xmm1
pshufd $0xee,%xmm3,%xmm2
movdqa %xmm2,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm1,%xmm4
movapd %xmm1,0x160(%rsp)
movapd %xmm3,%xmm1
addsd  %xmm5,%xmm1
lea    0x1400(%rip),%rdi
movdqa %xmm2,0xe0(%rsp)
movaps %xmm3,0x230(%rsp)
mov    $0x6,%al
call   1050 <printf@plt>
movapd 0xd0(%rsp),%xmm1
movapd 0x160(%rsp),%xmm2
subsd  0x1d0(%rsp),%xmm2
movapd %xmm1,%xmm0
subsd  0x1e0(%rsp),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,0x160(%rsp)
jmp    2f09 <cu_photom_converge+0x1d29>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1325(%rip),%rdi
mov    %ebx,%esi
xor    %edx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
movapd 0xd0(%rsp),%xmm1
jmp    2f10 <cu_photom_converge+0x1d30>
nopl   (%rax)
movapd 0xd0(%rsp),%xmm1
mov    0x118(%rsp),%ebx
cmp    $0x26,%ebx
movsd  0x1115(%rip),%xmm2
movapd 0x116d(%rip),%xmm3
movsd  0x112d(%rip),%xmm4
ja     2f5e <cu_photom_converge+0x1d7e>
add    $0x1,%ebx
movapd 0xe0(%rsp),%xmm0
andpd  %xmm3,%xmm0
ucomisd %xmm4,%xmm0
ja     2110 <cu_photom_converge+0xf30>
movapd 0x230(%rsp),%xmm0
andpd  %xmm3,%xmm0
ucomisd %xmm4,%xmm0
ja     2110 <cu_photom_converge+0xf30>
movsd  0x1f8(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movapd 0x160(%rsp),%xmm2
ucomisd %xmm0,%xmm2
jb     2f8f <cu_photom_converge+0x1daf>
lea    0x1342(%rip),%rdi
call   1030 <puts@plt>
movapd 0x220(%rsp),%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
subsd  0x1d0(%rsp),%xmm0
mov    0x2ae0(%rsp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movapd %xmm1,%xmm3
subsd  0x1e0(%rsp),%xmm1
mov    0x2ae8(%rsp),%rcx
addsd  (%rcx),%xmm1
movsd  %xmm1,(%rcx)
jmp    2ff9 <cu_photom_converge+0x1e19>
mov    0x2ae8(%rsp),%rax
movsd  (%rax),%xmm1
movapd 0x1e0(%rsp),%xmm0
unpcklpd 0x1d0(%rsp),%xmm0
movapd %xmm0,%xmm3
mov    0x2ae0(%rsp),%rax
movsd  (%rax),%xmm0
movapd %xmm3,%xmm2
unpckhpd %xmm3,%xmm2
movapd %xmm2,0x10(%rsp)
lea    0x1294(%rip),%rdi
movapd %xmm3,0xd0(%rsp)
mov    $0x4,%al
call   1050 <printf@plt>
movapd 0x10(%rsp),%xmm0
addsd  0x1000(%rip),%xmm0
movapd %xmm0,0x10(%rsp)
call   1040 <ceil@plt>
movsd  %xmm0,0x40(%rsp)
movapd 0xd0(%rsp),%xmm0
addsd  0xfde(%rip),%xmm0
movapd %xmm0,0xd0(%rsp)
call   1040 <ceil@plt>
cmpl   $0x0,0x84(%rsp)
jle    346d <cu_photom_converge+0x228d>
movapd %xmm0,%xmm1
movsd  0x40(%rsp),%xmm0
movapd 0x10(%rsp),%xmm2
subsd  %xmm2,%xmm0
movsd  %xmm0,0x40(%rsp)
subsd  0xd0(%rsp),%xmm1
movsd  %xmm1,0xa0(%rsp)
movapd %xmm2,%xmm0
call   1100 <floor@plt>
cvttsd2si %xmm0,%ebx
movapd 0xd0(%rsp),%xmm0
call   1100 <floor@plt>
cvttsd2si %xmm0,%eax
mov    0x2b00(%rsp),%ecx
lea    0x1(%rcx),%r15d
mov    0x88(%rsp),%rcx
lea    (%rsp,%rcx,8),%rdx
add    $0x248,%rdx
mov    %rdx,0x30(%rsp)
shl    $0x3,%rcx
mov    %rcx,0x88(%rsp)
add    $0xfffffff9,%eax
mov    0x28(%rsp),%ecx
imul   %ecx,%eax
lea    (%rbx,%rax,1),%r12d
add    $0xfffffff9,%r12d
imul   %ecx,%ecx
mov    %ecx,0x100(%rsp)
lea    0x240(%rsp),%r13
xor    %edx,%edx
jmp    3174 <cu_photom_converge+0x1f94>
mov    0x2b10(%rsp),%rax
mov    0x90(%rsp),%rdx
movq   $0x0,(%rax,%rdx,8)
mov    0x2b18(%rsp),%rax
movabs $0x412e848000000000,%rcx
84 2e 41
mov    %rcx,(%rax,%rdx,8)
mov    0x38(%rsp),%r15d
mov    0x1b8(%rsp),%r12d
lea    0x240(%rsp),%r13
add    $0x1,%rdx
add    $0x100,%r15d
add    0x100(%rsp),%r12d
cmp    0x1a0(%rsp),%rdx
je     346d <cu_photom_converge+0x228d>
mov    %rdx,0x90(%rsp)
mov    %r12d,0x1b8(%rsp)
mov    $0x800,%edx
mov    %r13,%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x800,%edx
lea    0x1240(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x800,%edx
lea    0xa40(%rsp),%rdi
xor    %esi,%esi
call   1060 <memset@plt>
mov    $0x1,%eax
mov    0x30(%rsp),%r12
mov    %r15d,0x38(%rsp)
xorpd  %xmm1,%xmm1
xchg   %ax,%ax
mov    %rax,0x120(%rsp)
mov    $0xe,%ebp
mov    %r12,0x60(%rsp)
mov    %r15d,0xc0(%rsp)
mov    0x1b0(%rsp),%r13
mov    0x88(%rsp),%rbx
xor    %r14d,%r14d
nopl   (%rax)
movsd  %xmm1,0x10(%rsp)
movslq %r15d,%r15
lea    0x0(,%r15,8),%rsi
add    %r13,%rsi
movsd  0x40(%rsp),%xmm0
movsd  0xa0(%rsp),%xmm1
mov    $0x10,%edi
mov    $0x2,%al
call   1080 <interpolate_2d@plt>
movsd  0x10(%rsp),%xmm1
test   %eax,%eax
cmovs  %r14d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,(%r12)
addsd  %xmm0,%xmm1
mov    0x2b00(%rsp),%eax
add    %eax,%r15d
add    %rbx,%r12
add    $0xffffffffffffffff,%rbp
jne    3200 <cu_photom_converge+0x2020>
mov    0x120(%rsp),%rax
add    $0x1,%rax
mov    0xc0(%rsp),%r15d
add    $0x1,%r15d
mov    0x60(%rsp),%r12
add    $0x8,%r12
cmp    $0xf,%rax
jne    31d0 <cu_photom_converge+0x1ff0>
movsd  0xdd6(%rip),%xmm0
ucomisd %xmm1,%xmm0
mov    0x2ac8(%rsp),%r10
mov    0x28(%rsp),%eax
ja     3110 <cu_photom_converge+0x1f30>
xorpd  %xmm0,%xmm0
mov    0x1b8(%rsp),%r12d
mov    %r12d,%r8d
lea    0x240(%rsp),%r13
mov    %r13,%r9
xor    %edx,%edx
movsd  0x148(%rsp),%xmm3
mov    0x2b10(%rsp),%r14
mov    0x2ad0(%rsp),%rcx
jmp    32f2 <cu_photom_converge+0x2112>
nop
add    $0x1,%rdx
add    $0x8,%r9
add    $0x1,%r8d
cmp    $0x10,%rdx
je     3370 <cu_photom_converge+0x2190>
lea    -0x8(%rdx),%esi
xorps  %xmm4,%xmm4
cvtsi2sd %esi,%xmm4
mulsd  %xmm4,%xmm4
mov    %r8d,%esi
mov    %r9,%rdi
xor    %ebx,%ebx
jmp    3324 <cu_photom_converge+0x2144>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    0x88(%rsp),%rdi
add    %eax,%esi
cmp    $0x10,%rbx
je     32e0 <cu_photom_converge+0x2100>
lea    -0x8(%rbx),%ebp
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm4,%xmm1
ucomisd %xmm1,%xmm3
jbe    3310 <cu_photom_converge+0x2130>
movslq %esi,%rbp
movsd  (%rdi),%xmm1
movsd  (%r10,%rbp,8),%xmm2
unpcklpd %xmm1,%xmm2
unpcklpd %xmm1,%xmm1
mulpd  %xmm2,%xmm1
movsd  (%rcx,%rbp,8),%xmm2
unpcklpd %xmm2,%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm2,%xmm0
jmp    3310 <cu_photom_converge+0x2130>
nopl   0x0(%rax,%rax,1)
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
movapd %xmm1,0x10(%rsp)
divsd  %xmm1,%xmm0
movapd %xmm0,0x120(%rsp)
mov    $0x1,%al
call   10b0 <isnan@plt>
mov    0x90(%rsp),%rdx
movaps 0x120(%rsp),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
movsd  0xc88(%rip),%xmm0
divsd  0x10(%rsp),%xmm0
ucomisd 0xcb2(%rip),%xmm0
jb     33d0 <cu_photom_converge+0x21f0>
sqrtsd %xmm0,%xmm0
jmp    33dd <cu_photom_converge+0x21fd>
cs nopw 0x0(%rax,%rax,1)
call   10d0 <sqrt@plt>
mov    0x90(%rsp),%rdx
mov    0x2ac8(%rsp),%rax
mov    0x28(%rsp),%ebp
mov    0x38(%rsp),%r15d
mov    0x2b18(%rsp),%rcx
movsd  %xmm0,(%rcx,%rdx,8)
mov    %r12d,%r8d
mov    %r13,%r9
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x10,%esi
mov    %r8d,%edi
mov    %r9,%rcx
mov    0x88(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r14,%rdx,8),%xmm0
movslq %edi,%rdi
movsd  (%rax,%rdi,8),%xmm1
mulsd  (%rcx),%xmm0
subsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%rdi,8)
add    %rbx,%rcx
add    %ebp,%edi
add    $0xffffffffffffffff,%rsi
jne    3430 <cu_photom_converge+0x2250>
add    $0x1,%r10
add    $0x8,%r9
add    $0x1,%r8d
cmp    $0x10,%r10
jne    3410 <cu_photom_converge+0x2230>
jmp    3153 <cu_photom_converge+0x1f73>
add    $0x2a48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0xe,%ebx
lea    0xe7c(%rip),%rdi
call   1030 <puts@plt>
movaps 0xc0(%rsp),%xmm4
movaps %xmm4,%xmm3
unpckhpd %xmm4,%xmm3
lea    0xd4f(%rip),%rdi
mov    0x70(%rsp),%rsi
mov    %ebx,%edx
movaps 0x170(%rsp),%xmm0
movaps 0x10(%rsp),%xmm1
movaps 0x60(%rsp),%xmm2
movaps 0x90(%rsp),%xmm5
mov    $0x6,%al
call   1050 <printf@plt>
mov    $0x1,%edi
call   10e0 <exit@plt>
add    $0xe,%ebx
mov    0x2ac8(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    0x58(%rsp),%rax
movsd  (%r15,%rax,8),%xmm1
lea    0xce3(%rip),%rdi
movsd  0x10(%rsp),%xmm2
mov    $0x3,%al
call   1050 <printf@plt>
movaps 0xc0(%rsp),%xmm4
movaps %xmm4,%xmm3
unpckhpd %xmm4,%xmm3
movaps 0x60(%rsp),%xmm2
movaps %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
lea    0xccc(%rip),%rdi
mov    0x70(%rsp),%rsi
mov    %ebx,%edx
movaps 0x170(%rsp),%xmm0
jmp    34bd <cu_photom_converge+0x22dd>

LLVM IR (-O0):
@.str = [47 x i8] c"Warning: resetting psf_rad to maximum value 6\0A\00"
@.str.1 = [90 x i8] c"ifile,idx,idy,ix,jx,mpsf,inv_v,diff, inv_var[im_id], gain: %d %d %d %d %d %f %f %f %f %f\0A\00"
@.str.2 = [21 x i8] c"fsum1, fsum2: %f %f\0A\00"
@.str.3 = [64 x i8] c"Iteration %d: computing contribution to coordinate correction.\0A\00"
@.str.4 = [24 x i8] c"im_qual_threshold = %f\0A\00"
@.str.5 = [21 x i8] c"flux_threshold = %f\0A\00"
@.str.6 = [63 x i8] c"ifile, flux[ifile], dflux[ifile], im_qual[ifile]: %d %g %g %g\0A\00"
@.str.7 = [24 x i8] c"diff,fl,mpsf: %f %f %f\0A\00"
@.str.8 = [25 x i8] c"%d %d %f %f %f %f %f %f\0A\00"
@.str.9 = [43 x i8] c"Error: NaN detected in cu_photom_converge\0A\00"
@.str.10 = [31 x i8] c"Iteration %d: %d images used.\0A\00"
@.str.11 = [40 x i8] c"Error: Nan detected in dx. %f %f %f %f\0A\00"
@.str.12 = [40 x i8] c"Error: Nan detected in dy. %f %f %f %f\0A\00"
@.str.13 = [43 x i8] c"dx dy: %f %f + %f %f -> %f %f\0A\00"
@.str.14 = [67 x i8] c"Warning: position has diverged. Reverting to original coordinates\0A\00"
@.str.15 = [29 x i8] c"Final position: %f %f %f %f\0A\00"
define void @cu_photom_converge(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, i32* %5, i32* %6, i32* %7, i32* %8, i32* %9, double* %10, double* %11, double* %12, double* %13, double* %14, double* %15, double* %16, double* %17, double %18, double* %19, double* %20, double %21, double %22, i32 %23, i32 %24, i32 %25, i32 %26, double* %27, double* %28, double %29, i32 %30, double %31) {
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32*
%39 = alloca i32*
%40 = alloca i32*
%41 = alloca i32*
%42 = alloca i32*
%43 = alloca double*
%44 = alloca double*
%45 = alloca double*
%46 = alloca double*
%47 = alloca double*
%48 = alloca double*
%49 = alloca double*
%50 = alloca double*
%51 = alloca double
%52 = alloca double*
%53 = alloca double*
%54 = alloca double
%55 = alloca double
%56 = alloca i32
%57 = alloca i32
%58 = alloca i32
%59 = alloca i32
%60 = alloca double*
%61 = alloca double*
%62 = alloca double
%63 = alloca i32
%64 = alloca double
%65 = alloca i32
%66 = alloca i32
%67 = alloca i32
%68 = alloca i32
%69 = alloca i32
%70 = alloca i32
%71 = alloca i32
%72 = alloca i32
%73 = alloca i32
%74 = alloca i32
%75 = alloca i32
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
%79 = alloca i32
%80 = alloca i32
%81 = alloca i32
%82 = alloca i32
%83 = alloca i32
%84 = alloca i32
%85 = alloca i32
%86 = alloca i32
%87 = alloca i32
%88 = alloca i32
%89 = alloca i32
%90 = alloca i32
%91 = alloca i32
%92 = alloca i32
%93 = alloca i32
%94 = alloca i32
%95 = alloca i32
%96 = alloca double
%97 = alloca double
%98 = alloca i32
%99 = alloca i32
%100 = alloca double
%101 = alloca double
%102 = alloca double
%103 = alloca double
%104 = alloca double
%105 = alloca double
%106 = alloca double
%107 = alloca double
%108 = alloca double
%109 = alloca double
%110 = alloca double
%111 = alloca double
%112 = alloca double
%113 = alloca double
%114 = alloca double
%115 = alloca double
%116 = alloca double
%117 = alloca double
%118 = alloca double
%119 = alloca [256 x double]
%120 = alloca [256 x double]
%121 = alloca double*
%122 = alloca [256 x double]
%123 = alloca [256 x double]
%124 = alloca [256 x double]
%125 = alloca double
%126 = alloca double
%127 = alloca double
%128 = alloca double
%129 = alloca double
%130 = alloca double
%131 = alloca double
%132 = alloca double
%133 = alloca double
%134 = alloca double
%135 = alloca double
%136 = alloca double
%137 = alloca double
%138 = alloca double
%139 = alloca double
%140 = alloca double
%141 = alloca double
%142 = alloca double
%143 = alloca double
%144 = alloca double
%145 = alloca double
%146 = alloca double
%147 = alloca double
%148 = alloca double
%149 = alloca double
%150 = alloca double
%151 = alloca double
%152 = alloca double
%153 = alloca double
%154 = alloca double
%155 = alloca double
%156 = alloca i32
%157 = alloca i32
%158 = alloca i32
%159 = alloca double
%160 = alloca double
%161 = alloca double
%162 = alloca i32
%163 = alloca i32
%164 = alloca i32
store i32 %0, i32* %33
store i32 %1, i32* %34
store i32 %2, i32* %35
store i32 %3, i32* %36
store i32 %4, i32* %37
store i32* %5, i32** %38
store i32* %6, i32** %39
store i32* %7, i32** %40
store i32* %8, i32** %41
store i32* %9, i32** %42
store double* %10, double** %43
store double* %11, double** %44
store double* %12, double** %45
store double* %13, double** %46
store double* %14, double** %47
store double* %15, double** %48
store double* %16, double** %49
store double* %17, double** %50
store double %18, double* %51
store double* %19, double** %52
store double* %20, double** %53
store double %21, double* %54
store double %22, double* %55
store i32 %23, i32* %56
store i32 %24, i32* %57
store i32 %25, i32* %58
store i32 %26, i32* %59
store double* %27, double** %60
store double* %28, double** %61
store double %29, double* %62
store i32 %30, i32* %63
store double %31, double* %64
store double 0x400921FB53C8D4F1, double* %159
store double 0x3FEB2DA4E958F48E, double* %160
store double 2.000000e-01, double* %161
store i32 40, i32* %162
store i32 0, i32* %163
%165 = load i32, i32* %37
%166 = mul nsw i32 256, %165
%167 = sext i32 %166 to i64
%168 = mul i64 %167, 8
%169 = call i8* @malloc(i64 %168)
%170 = bitcast i8* %169 to double*
store double* %170, double** %121
%171 = load i32, i32* %34
%172 = mul nsw i32 2, %171
%173 = add nsw i32 %172, 1
store i32 %173, i32* %93
%174 = load i32, i32* %93
%175 = load i32, i32* %93
%176 = mul nsw i32 %174, %175
store i32 %176, i32* %94
%177 = load double, double* %54
store double %177, double* %96
%178 = load double, double* %55
store double %178, double* %97
%179 = load i32, i32* %35
%180 = add nsw i32 %179, 1
%181 = load i32, i32* %35
%182 = add nsw i32 %181, 2
%183 = mul nsw i32 %180, %182
%184 = sdiv i32 %183, 2
store i32 %184, i32* %70
%185 = load i32, i32* %36
%186 = add nsw i32 %185, 1
%187 = load i32, i32* %36
%188 = add nsw i32 %187, 2
%189 = mul nsw i32 %186, %188
%190 = sdiv i32 %189, 2
store i32 %190, i32* %71
%191 = load double*, double** %44
%192 = getelementptr inbounds double, double* %191, i64 0
%193 = load double, double* %192
%194 = fptosi double %193 to i32
store i32 %194, i32* %89
%195 = load double*, double** %44
%196 = getelementptr inbounds double, double* %195, i64 1
%197 = load double, double* %196
store double %197, double* %107
%198 = load double*, double** %44
%199 = getelementptr inbounds double, double* %198, i64 2
%200 = load double, double* %199
store double %200, double* %108
%201 = load double*, double** %44
%202 = getelementptr inbounds double, double* %201, i64 3
%203 = load double, double* %202
store double %203, double* %109
%204 = load double*, double** %44
%205 = getelementptr inbounds double, double* %204, i64 4
%206 = load double, double* %205
store double %206, double* %112
%207 = load double*, double** %44
%208 = getelementptr inbounds double, double* %207, i64 5
%209 = load double, double* %208
store double %209, double* %111
%210 = load double*, double** %44
%211 = getelementptr inbounds double, double* %210, i64 6
%212 = load double, double* %211
store double %212, double* %125
%213 = load double*, double** %44
%214 = getelementptr inbounds double, double* %213, i64 7
%215 = load double, double* %214
store double %215, double* %62
%216 = load double, double* %125
%217 = fcmp ogt double %216, 6.000000e+00
br i1 %217, label %218, label %220
218: ; preds = %32
%219 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([47 x i8], [47 x i8]* @.str, i64 0, i64 0))
store double 6.000000e+00, double* %125
br label %220
220: ; preds = %218, %32
%221 = load double, double* %125
%222 = load double, double* %125
%223 = fmul double %221, %222
store double %223, double* %126
store double 0.000000e+00, double* %117
store i32 1, i32* %72
br label %224
224: ; preds = %251, %220
%225 = load i32, i32* %72
%226 = load i32, i32* %89
%227 = sub nsw i32 %226, 1
%228 = icmp slt i32 %225, %227
br i1 %228, label %229, label %254
229: ; preds = %224
store i32 1, i32* %73
br label %230
230: ; preds = %247, %229
%231 = load i32, i32* %73
%232 = load i32, i32* %89
%233 = sub nsw i32 %232, 1
%234 = icmp slt i32 %231, %233
br i1 %234, label %235, label %250
235: ; preds = %230
%236 = load double*, double** %45
%237 = load i32, i32* %72
%238 = load i32, i32* %73
%239 = load i32, i32* %89
%240 = mul nsw i32 %238, %239
%241 = add nsw i32 %237, %240
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds double, double* %236, i64 %242
%244 = load double, double* %243
%245 = load double, double* %117
%246 = fadd double %245, %244
store double %246, double* %117
br label %247
247: ; preds = %235
%248 = load i32, i32* %73
%249 = add nsw i32 %248, 1
store i32 %249, i32* %73
br label %230
250: ; preds = %230
br label %251
251: ; preds = %250
%252 = load i32, i32* %72
%253 = add nsw i32 %252, 1
store i32 %253, i32* %72
br label %224
254: ; preds = %224
%255 = load i32, i32* %33
%256 = icmp eq i32 %255, 0
br i1 %256, label %257, label %268
257: ; preds = %254
%258 = load double, double* %117
%259 = load double, double* %107
%260 = fmul double %259, 2.000000e+00
%261 = load double, double* %159
%262 = fmul double %260, %261
%263 = load double, double* %160
%264 = fmul double %262, %263
%265 = load double, double* %160
%266 = fmul double %264, %265
%267 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %258, double %266)
store double %267, double* %115
br label %326
268: ; preds = %254
%269 = load i32, i32* %33
%270 = icmp eq i32 %269, 1
br i1 %270, label %271, label %325
271: ; preds = %268
%272 = load double*, double** %44
%273 = getelementptr inbounds double, double* %272, i64 8
%274 = load double, double* %273
store double %274, double* %110
%275 = load double, double* %108
%276 = load double, double* %108
%277 = fmul double %275, %276
store double %277, double* %134
%278 = load double, double* %109
%279 = load double, double* %109
%280 = fmul double %278, %279
store double %280, double* %135
%281 = load double, double* %110
%282 = load double, double* %110
%283 = fmul double %281, %282
store double %283, double* %136
%284 = load double, double* %134
%285 = fdiv double 1.000000e+00, %284
%286 = load double, double* %135
%287 = fdiv double 1.000000e+00, %286
%288 = fsub double %285, %287
store double %288, double* %137
%289 = load double, double* %134
%290 = fdiv double 1.000000e+00, %289
%291 = load double, double* %135
%292 = fdiv double 1.000000e+00, %291
%293 = fadd double %290, %292
store double %293, double* %138
%294 = load double, double* %138
%295 = load double, double* %137
%296 = load double, double* %137
%297 = load double, double* %136
%298 = call double @llvm.fmuladd.f64(double %295, double %296, double %297)
%299 = call double @sqrt(double %298)
%300 = fadd double %294, %299
%301 = call double @sqrt(double %300)
%302 = fdiv double 1.000000e+00, %301
store double %302, double* %145
%303 = load double, double* %138
%304 = load double, double* %137
%305 = load double, double* %137
%306 = load double, double* %136
%307 = call double @llvm.fmuladd.f64(double %304, double %305, double %306)
%308 = call double @sqrt(double %307)
%309 = fsub double %303, %308
%310 = call double @sqrt(double %309)
%311 = fdiv double 1.000000e+00, %310
store double %311, double* %146
%312 = load double, double* %117
%313 = load double, double* %107
%314 = load double, double* %159
%315 = fmul double %313, %314
%316 = load double, double* %145
%317 = load double, double* %146
%318 = fmul double %316, %317
%319 = fmul double %315, %318
%320 = load double, double* %108
%321 = load double, double* %109
%322 = fmul double %320, %321
%323 = fdiv double %319, %322
%324 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %312, double %323)
store double %324, double* %115
br label %325
325: ; preds = %271, %268
br label %326
326: ; preds = %325, %257
store i32 0, i32* %157
br label %327
327: ; preds = %349, %326
%328 = load i32, i32* %157
%329 = load i32, i32* %58
%330 = icmp slt i32 %328, %329
br i1 %330, label %331, label %352
331: ; preds = %327
store i32 0, i32* %158
br label %332
332: ; preds = %345, %331
%333 = load i32, i32* %158
%334 = load i32, i32* %59
%335 = icmp slt i32 %333, %334
br i1 %335, label %336, label %348
336: ; preds = %332
%337 = load i32, i32* %157
%338 = load i32, i32* %158
%339 = load i32, i32* %58
%340 = mul nsw i32 %338, %339
%341 = add nsw i32 %337, %340
store i32 %341, i32* %65
%342 = load i32, i32* %65
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds [256 x double], [256 x double]* %120, i64 0, i64 %343
store double 0.000000e+00, double* %344
br label %345
345: ; preds = %336
%346 = load i32, i32* %158
%347 = add nsw i32 %346, 1
store i32 %347, i32* %158
br label %332
348: ; preds = %332
br label %349
349: ; preds = %348
%350 = load i32, i32* %157
%351 = add nsw i32 %350, 1
store i32 %351, i32* %157
br label %327
352: ; preds = %327
%353 = load double*, double** %52
%354 = load double, double* %353
%355 = load i32, i32* %56
%356 = sub nsw i32 %355, 1
%357 = sitofp i32 %356 to double
%358 = call double @llvm.fmuladd.f64(double -5.000000e-01, double %357, double %354)
%359 = load i32, i32* %56
%360 = sub nsw i32 %359, 1
%361 = sitofp i32 %360 to double
%362 = fdiv double %358, %361
store double %362, double* %100
%363 = load double*, double** %53
%364 = load double, double* %363
%365 = load i32, i32* %57
%366 = sub nsw i32 %365, 1
%367 = sitofp i32 %366 to double
%368 = call double @llvm.fmuladd.f64(double -5.000000e-01, double %367, double %364)
%369 = load i32, i32* %57
%370 = sub nsw i32 %369, 1
%371 = sitofp i32 %370 to double
%372 = fdiv double %368, %371
store double %372, double* %101
store i32 0, i32* %98
store i32 0, i32* %99
store i32 0, i32* %88
br label %373
373: ; preds = %684, %352
%374 = load i32, i32* %88
%375 = load i32, i32* %37
%376 = icmp slt i32 %374, %375
br i1 %376, label %377, label %687
377: ; preds = %373
store i32 0, i32* %157
br label %378
378: ; preds = %630, %377
%379 = load i32, i32* %157
%380 = load i32, i32* %58
%381 = icmp slt i32 %379, %380
br i1 %381, label %382, label %633
382: ; preds = %378
store i32 0, i32* %158
br label %383
383: ; preds = %626, %382
%384 = load i32, i32* %158
%385 = load i32, i32* %59
%386 = icmp slt i32 %384, %385
br i1 %386, label %387, label %629
387: ; preds = %383
%388 = load i32, i32* %157
%389 = load i32, i32* %158
%390 = load i32, i32* %58
%391 = mul nsw i32 %389, %390
%392 = add nsw i32 %388, %391
store i32 %392, i32* %65
%393 = load i32, i32* %33
%394 = load i32, i32* %157
%395 = load i32, i32* %158
%396 = load double*, double** %52
%397 = load double, double* %396
%398 = load double*, double** %53
%399 = load double, double* %398
%400 = load double*, double** %44
%401 = load double*, double** %45
%402 = load double*, double** %46
%403 = load double*, double** %47
%404 = call i32 (i32, i32, i32, double, double, double*, double*, double*, double*, ...) bitcast (i32 (...)* @integrated_profile to i32 (i32, i32, i32, double, double, double*, double*, double*, double*, ...)*)(i32 %393, i32 %394, i32 %395, double %397, double %399, double* %400, double* %401, double* %402, double* %403)
%405 = sitofp i32 %404 to double
store double %405, double* %102
store double 0.000000e+00, double* %105
store i32 0, i32* %76
br label %406
406: ; preds = %616, %387
%407 = load i32, i32* %76
%408 = load i32*, i32** %42
%409 = load i32, i32* %88
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds i32, i32* %408, i64 %410
%412 = load i32, i32* %411
%413 = icmp slt i32 %407, %412
br i1 %413, label %414, label %619
414: ; preds = %406
%415 = load i32, i32* %76
%416 = load i32, i32* %70
%417 = icmp slt i32 %415, %416
br i1 %417, label %418, label %419
418: ; preds = %414
br label %426
419: ; preds = %414
%420 = load i32, i32* %76
%421 = load i32, i32* %70
%422 = sub nsw i32 %420, %421
%423 = load i32, i32* %71
%424 = sdiv i32 %422, %423
%425 = add nsw i32 %424, 1
br label %426
426: ; preds = %419, %418
%427 = phi i32 [ 0, %418 ], [ %425, %419 ]
store i32 %427, i32* %77
%428 = load i32, i32* %77
%429 = load i32*, i32** %38
%430 = load i32, i32* %88
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds i32, i32* %429, i64 %431
%433 = load i32, i32* %432
%434 = icmp slt i32 %428, %433
br i1 %434, label %435, label %615
435: ; preds = %426
%436 = load i32*, i32** %39
%437 = load i32, i32* %98
%438 = load i32, i32* %77
%439 = add nsw i32 %437, %438
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds i32, i32* %436, i64 %440
%442 = load i32, i32* %441
store i32 %442, i32* %78
%443 = load i32*, i32** %40
%444 = load i32, i32* %98
%445 = load i32, i32* %77
%446 = add nsw i32 %444, %445
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds i32, i32* %443, i64 %447
%449 = load i32, i32* %448
store i32 %449, i32* %79
%450 = load i32, i32* %77
%451 = icmp eq i32 %450, 0
br i1 %451, label %452, label %455
452: ; preds = %435
%453 = load i32, i32* %35
store i32 %453, i32* %80
%454 = load i32, i32* %76
store i32 %454, i32* %81
br label %465
455: ; preds = %435
%456 = load i32, i32* %36
store i32 %456, i32* %80
%457 = load i32, i32* %76
%458 = load i32, i32* %70
%459 = sub nsw i32 %457, %458
%460 = load i32, i32* %77
%461 = sub nsw i32 %460, 1
%462 = load i32, i32* %71
%463 = mul nsw i32 %461, %462
%464 = sub nsw i32 %459, %463
store i32 %464, i32* %81
br label %465
465: ; preds = %455, %452
store i32 0, i32* %85
store i32 0, i32* %84
%466 = load i32, i32* %80
%467 = icmp sgt i32 %466, 0
br i1 %467, label %468, label %498
468: ; preds = %465
store i32 0, i32* %72
store i32 0, i32* %82
br label %469
469: ; preds = %494, %468
%470 = load i32, i32* %82
%471 = load i32, i32* %80
%472 = icmp sle i32 %470, %471
br i1 %472, label %473, label %497
473: ; preds = %469
store i32 0, i32* %83
br label %474
474: ; preds = %490, %473
%475 = load i32, i32* %83
%476 = load i32, i32* %80
%477 = load i32, i32* %82
%478 = sub nsw i32 %476, %477
%479 = icmp sle i32 %475, %478
br i1 %479, label %480, label %493
480: ; preds = %474
%481 = load i32, i32* %72
%482 = load i32, i32* %81
%483 = icmp eq i32 %481, %482
br i1 %483, label %484, label %487
484: ; preds = %480
%485 = load i32, i32* %82
store i32 %485, i32* %84
%486 = load i32, i32* %83
store i32 %486, i32* %85
br label %487
487: ; preds = %484, %480
%488 = load i32, i32* %72
%489 = add nsw i32 %488, 1
store i32 %489, i32* %72
br label %490
490: ; preds = %487
%491 = load i32, i32* %83
%492 = add nsw i32 %491, 1
store i32 %492, i32* %83
br label %474
493: ; preds = %474
br label %494
494: ; preds = %493
%495 = load i32, i32* %82
%496 = add nsw i32 %495, 1
store i32 %496, i32* %82
br label %469
497: ; preds = %469
br label %498
498: ; preds = %497, %465
%499 = load i32, i32* %77
%500 = icmp sgt i32 %499, 0
br i1 %500, label %501, label %593
501: ; preds = %498
%502 = load i32, i32* %157
%503 = load i32, i32* %78
%504 = add nsw i32 %502, %503
store i32 %504, i32* %66
%505 = load i32, i32* %158
%506 = load i32, i32* %79
%507 = add nsw i32 %505, %506
store i32 %507, i32* %67
%508 = load i32, i32* %33
%509 = load i32, i32* %66
%510 = load i32, i32* %67
%511 = load double*, double** %52
%512 = load double, double* %511
%513 = load double*, double** %53
%514 = load double, double* %513
%515 = load double*, double** %44
%516 = load double*, double** %45
%517 = load double*, double** %46
%518 = load double*, double** %47
%519 = call i32 (i32, i32, i32, double, double, double*, double*, double*, double*, ...) bitcast (i32 (...)* @integrated_profile to i32 (i32, i32, i32, double, double, double*, double*, double*, double*, ...)*)(i32 %508, i32 %509, i32 %510, double %512, double %514, double* %515, double* %516, double* %517, double* %518)
%520 = sitofp i32 %519 to double
store double %520, double* %103
%521 = load i32*, i32** %41
%522 = load i32, i32* %98
%523 = load i32, i32* %77
%524 = add nsw i32 %522, %523
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds i32, i32* %521, i64 %525
%527 = load i32, i32* %526
%528 = icmp ne i32 %527, 0
br i1 %528, label %529, label %570
529: ; preds = %501
store double 0.000000e+00, double* %103
store i32 -1, i32* %86
br label %530
530: ; preds = %564, %529
%531 = load i32, i32* %86
%532 = icmp slt i32 %531, 2
br i1 %532, label %533, label %567
533: ; preds = %530
store i32 -1, i32* %87
br label %534
534: ; preds = %560, %533
%535 = load i32, i32* %87
%536 = icmp slt i32 %535, 2
br i1 %536, label %537, label %563
537: ; preds = %534
%538 = load i32, i32* %66
%539 = load i32, i32* %86
%540 = add nsw i32 %538, %539
store i32 %540, i32* %68
%541 = load i32, i32* %67
%542 = load i32, i32* %87
%543 = add nsw i32 %541, %542
store i32 %543, i32* %69
%544 = load i32, i32* %33
%545 = load i32, i32* %68
%546 = load i32, i32* %69
%547 = load double*, double** %52
%548 = load double, double* %547
%549 = load double*, double** %53
%550 = load double, double* %549
%551 = load double*, double** %44
%552 = load double*, double** %45
%553 = load double*, double** %46
%554 = load double*, double** %47
%555 = call i32 (i32, i32, i32, double, double, double*, double*, double*, double*, ...) bitcast (i32 (...)* @integrated_profile to i32 (i32, i32, i32, double, double, double*, double*, double*, double*, ...)*)(i32 %544, i32 %545, i32 %546, double %548, double %550, double* %551, double* %552, double* %553, double* %554)
%556 = sitofp i32 %555 to double
store double %556, double* %104
%557 = load double, double* %104
%558 = load double, double* %103
%559 = fadd double %558, %557
store double %559, double* %103
br label %560
560: ; preds = %537
%561 = load i32, i32* %87
%562 = add nsw i32 %561, 1
store i32 %562, i32* %87
br label %534
563: ; preds = %534
br label %564
564: ; preds = %563
%565 = load i32, i32* %86
%566 = add nsw i32 %565, 1
store i32 %566, i32* %86
br label %530
567: ; preds = %530
%568 = load double, double* %103
%569 = fdiv double %568, 9.000000e+00
store double %569, double* %103
br label %570
570: ; preds = %567, %501
%571 = load double*, double** %43
%572 = load i32, i32* %99
%573 = load i32, i32* %76
%574 = add nsw i32 %572, %573
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds double, double* %571, i64 %575
%577 = load double, double* %576
%578 = load double, double* %103
%579 = load double, double* %102
%580 = fsub double %578, %579
%581 = fmul double %577, %580
%582 = load double, double* %100
%583 = load i32, i32* %84
%584 = sitofp i32 %583 to double
%585 = call double @pow(double %582, double %584)
%586 = fmul double %581, %585
%587 = load double, double* %101
%588 = load i32, i32* %85
%589 = sitofp i32 %588 to double
%590 = call double @pow(double %587, double %589)
%591 = load double, double* %105
%592 = call double @llvm.fmuladd.f64(double %586, double %590, double %591)
store double %592, double* %105
br label %614
593: ; preds = %498
%594 = load double*, double** %43
%595 = load i32, i32* %99
%596 = load i32, i32* %76
%597 = add nsw i32 %595, %596
%598 = sext i32 %597 to i64
%599 = getelementptr inbounds double, double* %594, i64 %598
%600 = load double, double* %599
%601 = load double, double* %102
%602 = fmul double %600, %601
%603 = load double, double* %100
%604 = load i32, i32* %84
%605 = sitofp i32 %604 to double
%606 = call double @pow(double %603, double %605)
%607 = fmul double %602, %606
%608 = load double, double* %101
%609 = load i32, i32* %85
%610 = sitofp i32 %609 to double
%611 = call double @pow(double %608, double %610)
%612 = load double, double* %105
%613 = call double @llvm.fmuladd.f64(double %607, double %611, double %612)
store double %613, double* %105
br label %614
614: ; preds = %593, %570
br label %615
615: ; preds = %614, %426
br label %616
616: ; preds = %615
%617 = load i32, i32* %76
%618 = add nsw i32 %617, 1
store i32 %618, i32* %76
br label %406
619: ; preds = %406
%620 = load double, double* %105
%621 = load double, double* %115
%622 = fdiv double %620, %621
%623 = load i32, i32* %65
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds [256 x double], [256 x double]* %120, i64 0, i64 %624
store double %622, double* %625
br label %626
626: ; preds = %619
%627 = load i32, i32* %158
%628 = add nsw i32 %627, 1
store i32 %628, i32* %158
br label %383
629: ; preds = %383
br label %630
630: ; preds = %629
%631 = load i32, i32* %157
%632 = add nsw i32 %631, 1
store i32 %632, i32* %157
br label %378
633: ; preds = %378
store i32 0, i32* %72
br label %634
634: ; preds = %645, %633
%635 = load i32, i32* %72
%636 = icmp slt i32 %635, 256
br i1 %636, label %637, label %648
637: ; preds = %634
%638 = load i32, i32* %72
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds [256 x double], [256 x double]* %120, i64 0, i64 %639
%641 = load double, double* %640
%642 = load i32, i32* %72
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds [256 x double], [256 x double]* %119, i64 0, i64 %643
store double %641, double* %644
br label %645
645: ; preds = %637
%646 = load i32, i32* %72
%647 = add nsw i32 %646, 1
store i32 %647, i32* %72
br label %634
648: ; preds = %634
%649 = getelementptr inbounds [256 x double], [256 x double]* %119, i64 0, i64 0
%650 = call i32 (i32, i32, i32, double*, ...) bitcast (i32 (...)* @resolve_coeffs_2d to i32 (i32, i32, i32, double*, ...)*)(i32 16, i32 16, i32 16, double* %649)
store i32 0, i32* %72
br label %651
651: ; preds = %666, %648
%652 = load i32, i32* %72
%653 = icmp slt i32 %652, 256
br i1 %653, label %654, label %669
654: ; preds = %651
%655 = load i32, i32* %72
%656 = sext i32 %655 to i64
%657 = getelementptr inbounds [256 x double], [256 x double]* %119, i64 0, i64 %656
%658 = load double, double* %657
%659 = load double*, double** %121
%660 = load i32, i32* %88
%661 = mul nsw i32 %660, 256
%662 = load i32, i32* %72
%663 = add nsw i32 %661, %662
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds double, double* %659, i64 %664
store double %658, double* %665
br label %666
666: ; preds = %654
%667 = load i32, i32* %72
%668 = add nsw i32 %667, 1
store i32 %668, i32* %72
br label %651
669: ; preds = %651
%670 = load i32*, i32** %38
%671 = load i32, i32* %88
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds i32, i32* %670, i64 %672
%674 = load i32, i32* %673
%675 = load i32, i32* %98
%676 = add nsw i32 %675, %674
store i32 %676, i32* %98
%677 = load i32*, i32** %42
%678 = load i32, i32* %88
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds i32, i32* %677, i64 %679
%681 = load i32, i32* %680
%682 = load i32, i32* %99
%683 = add nsw i32 %682, %681
store i32 %683, i32* %99
br label %684
684: ; preds = %669
%685 = load i32, i32* %88
%686 = add nsw i32 %685, 1
store i32 %686, i32* %88
br label %373
687: ; preds = %373
%688 = load i32, i32* %63
%689 = icmp eq i32 %688, 1
br i1 %689, label %690, label %1724
690: ; preds = %687
store i32 0, i32* %92
br label %691
691: ; preds = %1699, %690
store double 0.000000e+00, double* %118
%692 = load double, double* %54
%693 = fadd double %692, 5.000000e-01
%694 = call double @llvm.ceil.f64(double %693)
%695 = load double, double* %54
%696 = fadd double %695, 5.000000e-01
%697 = fsub double %694, %696
store double %697, double* %113
%698 = load double, double* %55
%699 = fadd double %698, 5.000000e-01
%700 = call double @llvm.ceil.f64(double %699)
%701 = load double, double* %55
%702 = fadd double %701, 5.000000e-01
%703 = fsub double %700, %702
store double %703, double* %114
store double 0.000000e+00, double* %150
store double 0.000000e+00, double* %149
store double 0.000000e+00, double* %148
store double 0.000000e+00, double* %147
store i32 0, i32* %88
br label %704
704: ; preds = %1100, %691
%705 = load i32, i32* %88
%706 = load i32, i32* %37
%707 = icmp slt i32 %705, %706
br i1 %707, label %708, label %1103
708: ; preds = %704
store i32 0, i32* %72
br label %709
709: ; preds = %722, %708
%710 = load i32, i32* %72
%711 = icmp slt i32 %710, 256
br i1 %711, label %712, label %725
712: ; preds = %709
%713 = load i32, i32* %72
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %714
store double 0.000000e+00, double* %715
%716 = load i32, i32* %72
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds [256 x double], [256 x double]* %123, i64 0, i64 %717
store double 0.000000e+00, double* %718
%719 = load i32, i32* %72
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds [256 x double], [256 x double]* %124, i64 0, i64 %720
store double 0.000000e+00, double* %721
br label %722
722: ; preds = %712
%723 = load i32, i32* %72
%724 = add nsw i32 %723, 1
store i32 %724, i32* %72
br label %709
725: ; preds = %709
store double 0.000000e+00, double* %117
store i32 1, i32* %157
br label %726
726: ; preds = %783, %725
%727 = load i32, i32* %157
%728 = icmp slt i32 %727, 15
br i1 %728, label %729, label %786
729: ; preds = %726
store i32 1, i32* %158
br label %730
730: ; preds = %779, %729
%731 = load i32, i32* %158
%732 = icmp slt i32 %731, 15
br i1 %732, label %733, label %782
733: ; preds = %730
%734 = load i32, i32* %157
%735 = load i32, i32* %158
%736 = load i32, i32* %58
%737 = mul nsw i32 %735, %736
%738 = add nsw i32 %734, %737
store i32 %738, i32* %65
%739 = load double, double* %113
%740 = load double, double* %114
%741 = load double*, double** %121
%742 = load i32, i32* %88
%743 = mul nsw i32 %742, 256
%744 = load i32, i32* %157
%745 = add nsw i32 %743, %744
%746 = load i32, i32* %158
%747 = load i32, i32* %58
%748 = mul nsw i32 %746, %747
%749 = add nsw i32 %745, %748
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds double, double* %741, i64 %750
%752 = call i32 (double, double, i32, double*, ...) bitcast (i32 (...)* @interpolate_2d to i32 (double, double, i32, double*, ...)*)(double %739, double %740, i32 16, double* %751)
%753 = sitofp i32 %752 to double
%754 = load i32, i32* %65
%755 = sext i32 %754 to i64
%756 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %755
store double %753, double* %756
%757 = load i32, i32* %65
%758 = sext i32 %757 to i64
%759 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %758
%760 = load double, double* %759
%761 = fcmp ogt double %760, 0.000000e+00
br i1 %761, label %762, label %767
762: ; preds = %733
%763 = load i32, i32* %65
%764 = sext i32 %763 to i64
%765 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %764
%766 = load double, double* %765
br label %768
767: ; preds = %733
br label %768
768: ; preds = %767, %762
%769 = phi double [ %766, %762 ], [ 0.000000e+00, %767 ]
%770 = load i32, i32* %65
%771 = sext i32 %770 to i64
%772 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %771
store double %769, double* %772
%773 = load i32, i32* %65
%774 = sext i32 %773 to i64
%775 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %774
%776 = load double, double* %775
%777 = load double, double* %117
%778 = fadd double %777, %776
store double %778, double* %117
br label %779
779: ; preds = %768
%780 = load i32, i32* %158
%781 = add nsw i32 %780, 1
store i32 %781, i32* %158
br label %730
782: ; preds = %730
br label %783
783: ; preds = %782
%784 = load i32, i32* %157
%785 = add nsw i32 %784, 1
store i32 %785, i32* %157
br label %726
786: ; preds = %726
%787 = load double, double* %117
%788 = fcmp olt double %787, 0.000000e+00
br i1 %788, label %789, label %798
789: ; preds = %786
store double 0.000000e+00, double* %147
store double 1.000000e+00, double* %148
store double 0.000000e+00, double* %149
store double 1.000000e+00, double* %150
%790 = load double*, double** %60
%791 = load i32, i32* %88
%792 = sext i32 %791 to i64
%793 = getelementptr inbounds double, double* %790, i64 %792
store double 0.000000e+00, double* %793
%794 = load double*, double** %61
%795 = load i32, i32* %88
%796 = sext i32 %795 to i64
%797 = getelementptr inbounds double, double* %794, i64 %796
store double 1.000000e+06, double* %797
br label %1099
798: ; preds = %786
store i32 1, i32* %157
br label %799
799: ; preds = %816, %798
%800 = load i32, i32* %157
%801 = icmp slt i32 %800, 15
br i1 %801, label %802, label %819
802: ; preds = %799
store i32 1, i32* %158
br label %803
803: ; preds = %812, %802
%804 = load i32, i32* %158
%805 = icmp slt i32 %804, 15
br i1 %805, label %806, label %815
806: ; preds = %803
%807 = load i32, i32* %157
%808 = load i32, i32* %158
%809 = load i32, i32* %58
%810 = mul nsw i32 %808, %809
%811 = add nsw i32 %807, %810
store i32 %811, i32* %65
br label %812
812: ; preds = %806
%813 = load i32, i32* %158
%814 = add nsw i32 %813, 1
store i32 %814, i32* %158
br label %803
815: ; preds = %803
br label %816
816: ; preds = %815
%817 = load i32, i32* %157
%818 = add nsw i32 %817, 1
store i32 %818, i32* %157
br label %799
819: ; preds = %799
store double 0.000000e+00, double* %133
store i32 0, i32* %73
br label %820
820: ; preds = %1063, %819
%821 = load i32, i32* %73
%822 = icmp slt i32 %821, 1
br i1 %822, label %823, label %1066
823: ; preds = %820
store double 0.000000e+00, double* %132
store double 0.000000e+00, double* %131
store double 0.000000e+00, double* %130
store double 0.000000e+00, double* %129
store double 0.000000e+00, double* %128
store double 0.000000e+00, double* %127
store i32 0, i32* %157
br label %824
824: ; preds = %964, %823
%825 = load i32, i32* %157
%826 = icmp slt i32 %825, 16
br i1 %826, label %827, label %967
827: ; preds = %824
store i32 0, i32* %158
br label %828
828: ; preds = %960, %827
%829 = load i32, i32* %158
%830 = icmp slt i32 %829, 16
br i1 %830, label %831, label %963
831: ; preds = %828
%832 = load i32, i32* %157
%833 = load i32, i32* %158
%834 = load i32, i32* %58
%835 = mul nsw i32 %833, %834
%836 = add nsw i32 %832, %835
store i32 %836, i32* %65
%837 = load i32, i32* %157
%838 = sitofp i32 %837 to double
%839 = fsub double %838, 8.000000e+00
%840 = call double @pow(double %839, double 2.000000e+00)
%841 = load i32, i32* %158
%842 = sitofp i32 %841 to double
%843 = fsub double %842, 8.000000e+00
%844 = call double @pow(double %843, double 2.000000e+00)
%845 = fadd double %840, %844
%846 = load double, double* %126
%847 = fcmp olt double %845, %846
br i1 %847, label %848, label %959
848: ; preds = %831
%849 = load double, double* %54
%850 = fadd double %849, 5.000000e-01
%851 = call double @llvm.floor.f64(double %850)
%852 = fptosi double %851 to i32
%853 = load i32, i32* %157
%854 = add nsw i32 %852, %853
%855 = sitofp i32 %854 to double
%856 = fsub double %855, 8.000000e+00
%857 = fptosi double %856 to i32
store i32 %857, i32* %90
%858 = load double, double* %55
%859 = fadd double %858, 5.000000e-01
%860 = call double @llvm.floor.f64(double %859)
%861 = fptosi double %860 to i32
%862 = load i32, i32* %158
%863 = add nsw i32 %861, %862
%864 = sitofp i32 %863 to double
%865 = fsub double %864, 8.000000e+00
%866 = fptosi double %865 to i32
store i32 %866, i32* %91
%867 = load i32, i32* %88
%868 = load i32, i32* %94
%869 = mul nsw i32 %867, %868
%870 = load i32, i32* %90
%871 = add nsw i32 %869, %870
%872 = load i32, i32* %93
%873 = load i32, i32* %91
%874 = mul nsw i32 %872, %873
%875 = add nsw i32 %871, %874
store i32 %875, i32* %95
%876 = load double*, double** %49
%877 = load i32, i32* %95
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds double, double* %876, i64 %878
%880 = load double, double* %879
store double %880, double* %153
%881 = load i32, i32* %65
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %882
%884 = load double, double* %883
%885 = load double*, double** %48
%886 = load i32, i32* %95
%887 = sext i32 %886 to i64
%888 = getelementptr inbounds double, double* %885, i64 %887
%889 = load double, double* %888
%890 = fmul double %884, %889
%891 = load double, double* %153
%892 = load double, double* %127
%893 = call double @llvm.fmuladd.f64(double %890, double %891, double %892)
store double %893, double* %127
%894 = load i32, i32* %65
%895 = sext i32 %894 to i64
%896 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %895
%897 = load double, double* %896
%898 = load i32, i32* %65
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %899
%901 = load double, double* %900
%902 = fmul double %897, %901
%903 = load double, double* %153
%904 = load double, double* %128
%905 = call double @llvm.fmuladd.f64(double %902, double %903, double %904)
store double %905, double* %128
%906 = load i32, i32* %65
%907 = sext i32 %906 to i64
%908 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %907
%909 = load double, double* %908
%910 = load double, double* %129
%911 = fadd double %910, %909
store double %911, double* %129
%912 = load i32, i32* %65
%913 = sext i32 %912 to i64
%914 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %913
%915 = load double, double* %914
%916 = load double, double* %153
%917 = load double, double* %130
%918 = call double @llvm.fmuladd.f64(double %915, double %916, double %917)
store double %918, double* %130
%919 = load double, double* %153
%920 = load double, double* %131
%921 = fadd double %920, %919
store double %921, double* %131
%922 = load double*, double** %48
%923 = load i32, i32* %95
%924 = sext i32 %923 to i64
%925 = getelementptr inbounds double, double* %922, i64 %924
%926 = load double, double* %925
%927 = load double, double* %153
%928 = load double, double* %132
%929 = call double @llvm.fmuladd.f64(double %926, double %927, double %928)
store double %929, double* %132
%930 = load i32, i32* %88
%931 = icmp eq i32 %930, 375
br i1 %931, label %932, label %958
932: ; preds = %848
%933 = load i32, i32* %88
%934 = load i32, i32* %157
%935 = load i32, i32* %158
%936 = load i32, i32* %90
%937 = load i32, i32* %91
%938 = load i32, i32* %65
%939 = sext i32 %938 to i64
%940 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %939
%941 = load double, double* %940
%942 = load double, double* %153
%943 = load double*, double** %48
%944 = load i32, i32* %95
%945 = sext i32 %944 to i64
%946 = getelementptr inbounds double, double* %943, i64 %945
%947 = load double, double* %946
%948 = load double*, double** %49
%949 = load i32, i32* %95
%950 = sext i32 %949 to i64
%951 = getelementptr inbounds double, double* %948, i64 %950
%952 = load double, double* %951
%953 = load double, double* %62
%954 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([90 x i8], [90 x i8]* @.str.1, i64 0, i64 0), i32 %933, i32 %934, i32 %935, i32 %936, i32 %937, double %941, double %942, double %947, double %952, double %953)
%955 = load double, double* %127
%956 = load double, double* %128
%957 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.2, i64 0, i64 0), double %955, double %956)
br label %958
958: ; preds = %932, %848
br label %959
959: ; preds = %958, %831
br label %960
960: ; preds = %959
%961 = load i32, i32* %158
%962 = add nsw i32 %961, 1
store i32 %962, i32* %158
br label %828
963: ; preds = %828
br label %964
964: ; preds = %963
%965 = load i32, i32* %157
%966 = add nsw i32 %965, 1
store i32 %966, i32* %157
br label %824
967: ; preds = %824
%968 = load i32, i32* %163
%969 = icmp eq i32 %968, 1
br i1 %969, label %970, label %987
970: ; preds = %967
%971 = load double, double* %128
%972 = load double, double* %131
%973 = load double, double* %130
%974 = load double, double* %130
%975 = fmul double %973, %974
%976 = fneg double %975
%977 = call double @llvm.fmuladd.f64(double %971, double %972, double %976)
store double %977, double* %155
%978 = load double, double* %127
%979 = load double, double* %131
%980 = load double, double* %130
%981 = load double, double* %132
%982 = fmul double %980, %981
%983 = fneg double %982
%984 = call double @llvm.fmuladd.f64(double %978, double %979, double %983)
%985 = load double, double* %155
%986 = fdiv double %984, %985
store double %986, double* %133
br label %991
987: ; preds = %967
%988 = load double, double* %127
%989 = load double, double* %128
%990 = fdiv double %988, %989
store double %990, double* %133
br label %991
991: ; preds = %987, %970
%992 = load double, double* %133
%993 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %992)
%994 = icmp ne i32 %993, 0
br i1 %994, label %995, label %1062
995: ; preds = %991
store i32 0, i32* %157
br label %996
996: ; preds = %1058, %995
%997 = load i32, i32* %157
%998 = icmp slt i32 %997, 16
br i1 %998, label %999, label %1061
999: ; preds = %996
store i32 0, i32* %158
br label %1000
1000: ; preds = %1054, %999
%1001 = load i32, i32* %158
%1002 = icmp slt i32 %1001, 16
br i1 %1002, label %1003, label %1057
1003: ; preds = %1000
%1004 = load i32, i32* %157
%1005 = load i32, i32* %158
%1006 = load i32, i32* %58
%1007 = mul nsw i32 %1005, %1006
%1008 = add nsw i32 %1004, %1007
store i32 %1008, i32* %65
%1009 = load i32, i32* %157
%1010 = sitofp i32 %1009 to double
%1011 = fsub double %1010, 7.500000e+00
%1012 = call double @pow(double %1011, double 2.000000e+00)
%1013 = load i32, i32* %158
%1014 = sitofp i32 %1013 to double
%1015 = fsub double %1014, 7.500000e+00
%1016 = call double @pow(double %1015, double 2.000000e+00)
%1017 = fadd double %1012, %1016
%1018 = load double, double* %126
%1019 = fcmp olt double %1017, %1018
br i1 %1019, label %1020, label %1053
1020: ; preds = %1003
%1021 = load double, double* %54
%1022 = fadd double %1021, 5.000000e-01
%1023 = call double @llvm.floor.f64(double %1022)
%1024 = fptosi double %1023 to i32
%1025 = load i32, i32* %157
%1026 = add nsw i32 %1024, %1025
%1027 = sitofp i32 %1026 to double
%1028 = fsub double %1027, 8.000000e+00
%1029 = fptosi double %1028 to i32
store i32 %1029, i32* %90
%1030 = load double, double* %55
%1031 = fadd double %1030, 5.000000e-01
%1032 = call double @llvm.floor.f64(double %1031)
%1033 = fptosi double %1032 to i32
%1034 = load i32, i32* %158
%1035 = add nsw i32 %1033, %1034
%1036 = sitofp i32 %1035 to double
%1037 = fsub double %1036, 8.000000e+00
%1038 = fptosi double %1037 to i32
store i32 %1038, i32* %91
%1039 = load i32, i32* %88
%1040 = load i32, i32* %94
%1041 = mul nsw i32 %1039, %1040
%1042 = load i32, i32* %90
%1043 = add nsw i32 %1041, %1042
%1044 = load i32, i32* %93
%1045 = load i32, i32* %91
%1046 = mul nsw i32 %1044, %1045
%1047 = add nsw i32 %1043, %1046
store i32 %1047, i32* %95
%1048 = load double*, double** %49
%1049 = load i32, i32* %95
%1050 = sext i32 %1049 to i64
%1051 = getelementptr inbounds double, double* %1048, i64 %1050
%1052 = load double, double* %1051
store double %1052, double* %153
br label %1053
1053: ; preds = %1020, %1003
br label %1054
1054: ; preds = %1053
%1055 = load i32, i32* %158
%1056 = add nsw i32 %1055, 1
store i32 %1056, i32* %158
br label %1000
1057: ; preds = %1000
br label %1058
1058: ; preds = %1057
%1059 = load i32, i32* %157
%1060 = add nsw i32 %1059, 1
store i32 %1060, i32* %157
br label %996
1061: ; preds = %996
store double 0.000000e+00, double* %133
br label %1062
1062: ; preds = %1061, %991
br label %1063
1063: ; preds = %1062
%1064 = load i32, i32* %73
%1065 = add nsw i32 %1064, 1
store i32 %1065, i32* %73
br label %820
1066: ; preds = %820
%1067 = load double, double* %133
%1068 = load double*, double** %60
%1069 = load i32, i32* %88
%1070 = sext i32 %1069 to i64
%1071 = getelementptr inbounds double, double* %1068, i64 %1070
store double %1067, double* %1071
%1072 = load double, double* %128
%1073 = fdiv double 1.000000e+00, %1072
%1074 = call double @sqrt(double %1073)
%1075 = load double*, double** %61
%1076 = load i32, i32* %88
%1077 = sext i32 %1076 to i64
%1078 = getelementptr inbounds double, double* %1075, i64 %1077
store double %1074, double* %1078
%1079 = load double, double* %133
%1080 = call double @llvm.fabs.f64(double %1079)
%1081 = load double, double* %118
%1082 = fcmp ogt double %1080, %1081
br i1 %1082, label %1083, label %1098
1083: ; preds = %1066
%1084 = load double, double* %133
%1085 = call double @llvm.fabs.f64(double %1084)
%1086 = fcmp olt double %1085, 1.000000e+05
br i1 %1086, label %1087, label %1098
1087: ; preds = %1083
%1088 = load double*, double** %50
%1089 = load i32, i32* %88
%1090 = sext i32 %1089 to i64
%1091 = getelementptr inbounds double, double* %1088, i64 %1090
%1092 = load double, double* %1091
%1093 = load double, double* %51
%1094 = fcmp olt double %1092, %1093
br i1 %1094, label %1095, label %1098
1095: ; preds = %1087
%1096 = load double, double* %133
%1097 = call double @llvm.fabs.f64(double %1096)
store double %1097, double* %118
br label %1098
1098: ; preds = %1095, %1087, %1083, %1066
br label %1099
1099: ; preds = %1098, %789
br label %1100
1100: ; preds = %1099
%1101 = load i32, i32* %88
%1102 = add nsw i32 %1101, 1
store i32 %1102, i32* %88
br label %704
1103: ; preds = %704
%1104 = load i32, i32* %92
%1105 = icmp sgt i32 %1104, 0
br i1 %1105, label %1106, label %1677
1106: ; preds = %1103
%1107 = load i32, i32* %92
%1108 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.3, i64 0, i64 0), i32 %1107)
%1109 = load double, double* %51
%1110 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.4, i64 0, i64 0), double %1109)
%1111 = load double, double* %118
%1112 = fmul double %1111, 1.000000e-01
%1113 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.5, i64 0, i64 0), double %1112)
store i32 0, i32* %164
store i32 0, i32* %88
br label %1114
1114: ; preds = %1579, %1106
%1115 = load i32, i32* %88
%1116 = load i32, i32* %37
%1117 = icmp slt i32 %1115, %1116
br i1 %1117, label %1118, label %1582
1118: ; preds = %1114
%1119 = load i32, i32* %88
%1120 = load double*, double** %60
%1121 = load i32, i32* %88
%1122 = sext i32 %1121 to i64
%1123 = getelementptr inbounds double, double* %1120, i64 %1122
%1124 = load double, double* %1123
%1125 = load double*, double** %61
%1126 = load i32, i32* %88
%1127 = sext i32 %1126 to i64
%1128 = getelementptr inbounds double, double* %1125, i64 %1127
%1129 = load double, double* %1128
%1130 = load double*, double** %50
%1131 = load i32, i32* %88
%1132 = sext i32 %1131 to i64
%1133 = getelementptr inbounds double, double* %1130, i64 %1132
%1134 = load double, double* %1133
%1135 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([63 x i8], [63 x i8]* @.str.6, i64 0, i64 0), i32 %1119, double %1124, double %1129, double %1134)
%1136 = load double*, double** %60
%1137 = load i32, i32* %88
%1138 = sext i32 %1137 to i64
%1139 = getelementptr inbounds double, double* %1136, i64 %1138
%1140 = load double, double* %1139
%1141 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %1140)
%1142 = icmp ne i32 %1141, 0
br i1 %1142, label %1578, label %1143
1143: ; preds = %1118
%1144 = load double*, double** %60
%1145 = load i32, i32* %88
%1146 = sext i32 %1145 to i64
%1147 = getelementptr inbounds double, double* %1144, i64 %1146
%1148 = load double, double* %1147
%1149 = call double @llvm.fabs.f64(double %1148)
%1150 = load double, double* %118
%1151 = fmul double 1.000000e-01, %1150
%1152 = fcmp ogt double %1149, %1151
br i1 %1152, label %1153, label %1578
1153: ; preds = %1143
%1154 = load double*, double** %50
%1155 = load i32, i32* %88
%1156 = sext i32 %1155 to i64
%1157 = getelementptr inbounds double, double* %1154, i64 %1156
%1158 = load double, double* %1157
%1159 = load double, double* %51
%1160 = fcmp olt double %1158, %1159
br i1 %1160, label %1161, label %1578
1161: ; preds = %1153
%1162 = load i32, i32* %164
%1163 = add nsw i32 %1162, 1
store i32 %1163, i32* %164
store i32 0, i32* %72
br label %1164
1164: ; preds = %1177, %1161
%1165 = load i32, i32* %72
%1166 = icmp slt i32 %1165, 256
br i1 %1166, label %1167, label %1180
1167: ; preds = %1164
%1168 = load i32, i32* %72
%1169 = sext i32 %1168 to i64
%1170 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1169
store double 0.000000e+00, double* %1170
%1171 = load i32, i32* %72
%1172 = sext i32 %1171 to i64
%1173 = getelementptr inbounds [256 x double], [256 x double]* %123, i64 0, i64 %1172
store double 0.000000e+00, double* %1173
%1174 = load i32, i32* %72
%1175 = sext i32 %1174 to i64
%1176 = getelementptr inbounds [256 x double], [256 x double]* %124, i64 0, i64 %1175
store double 0.000000e+00, double* %1176
br label %1177
1177: ; preds = %1167
%1178 = load i32, i32* %72
%1179 = add nsw i32 %1178, 1
store i32 %1179, i32* %72
br label %1164
1180: ; preds = %1164
store double 0.000000e+00, double* %117
store i32 1, i32* %157
br label %1181
1181: ; preds = %1238, %1180
%1182 = load i32, i32* %157
%1183 = icmp slt i32 %1182, 15
br i1 %1183, label %1184, label %1241
1184: ; preds = %1181
store i32 1, i32* %158
br label %1185
1185: ; preds = %1234, %1184
%1186 = load i32, i32* %158
%1187 = icmp slt i32 %1186, 15
br i1 %1187, label %1188, label %1237
1188: ; preds = %1185
%1189 = load i32, i32* %157
%1190 = load i32, i32* %158
%1191 = load i32, i32* %58
%1192 = mul nsw i32 %1190, %1191
%1193 = add nsw i32 %1189, %1192
store i32 %1193, i32* %65
%1194 = load double, double* %113
%1195 = load double, double* %114
%1196 = load double*, double** %121
%1197 = load i32, i32* %88
%1198 = mul nsw i32 %1197, 256
%1199 = load i32, i32* %157
%1200 = add nsw i32 %1198, %1199
%1201 = load i32, i32* %158
%1202 = load i32, i32* %58
%1203 = mul nsw i32 %1201, %1202
%1204 = add nsw i32 %1200, %1203
%1205 = sext i32 %1204 to i64
%1206 = getelementptr inbounds double, double* %1196, i64 %1205
%1207 = call i32 (double, double, i32, double*, ...) bitcast (i32 (...)* @interpolate_2d to i32 (double, double, i32, double*, ...)*)(double %1194, double %1195, i32 16, double* %1206)
%1208 = sitofp i32 %1207 to double
%1209 = load i32, i32* %65
%1210 = sext i32 %1209 to i64
%1211 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1210
store double %1208, double* %1211
%1212 = load i32, i32* %65
%1213 = sext i32 %1212 to i64
%1214 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1213
%1215 = load double, double* %1214
%1216 = fcmp ogt double %1215, 0.000000e+00
br i1 %1216, label %1217, label %1222
1217: ; preds = %1188
%1218 = load i32, i32* %65
%1219 = sext i32 %1218 to i64
%1220 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1219
%1221 = load double, double* %1220
br label %1223
1222: ; preds = %1188
br label %1223
1223: ; preds = %1222, %1217
%1224 = phi double [ %1221, %1217 ], [ 0.000000e+00, %1222 ]
%1225 = load i32, i32* %65
%1226 = sext i32 %1225 to i64
%1227 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1226
store double %1224, double* %1227
%1228 = load i32, i32* %65
%1229 = sext i32 %1228 to i64
%1230 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1229
%1231 = load double, double* %1230
%1232 = load double, double* %117
%1233 = fadd double %1232, %1231
store double %1233, double* %117
br label %1234
1234: ; preds = %1223
%1235 = load i32, i32* %158
%1236 = add nsw i32 %1235, 1
store i32 %1236, i32* %158
br label %1185
1237: ; preds = %1185
br label %1238
1238: ; preds = %1237
%1239 = load i32, i32* %157
%1240 = add nsw i32 %1239, 1
store i32 %1240, i32* %157
br label %1181
1241: ; preds = %1181
store i32 2, i32* %157
br label %1242
1242: ; preds = %1309, %1241
%1243 = load i32, i32* %157
%1244 = icmp slt i32 %1243, 14
br i1 %1244, label %1245, label %1312
1245: ; preds = %1242
store i32 2, i32* %158
br label %1246
1246: ; preds = %1305, %1245
%1247 = load i32, i32* %158
%1248 = icmp slt i32 %1247, 14
br i1 %1248, label %1249, label %1308
1249: ; preds = %1246
%1250 = load i32, i32* %157
%1251 = load i32, i32* %158
%1252 = load i32, i32* %58
%1253 = mul nsw i32 %1251, %1252
%1254 = add nsw i32 %1250, %1253
store i32 %1254, i32* %65
%1255 = load i32, i32* %157
%1256 = add nsw i32 %1255, 1
%1257 = load i32, i32* %158
%1258 = load i32, i32* %58
%1259 = mul nsw i32 %1257, %1258
%1260 = add nsw i32 %1256, %1259
%1261 = sext i32 %1260 to i64
%1262 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1261
%1263 = load double, double* %1262
%1264 = load i32, i32* %157
%1265 = sub nsw i32 %1264, 1
%1266 = load i32, i32* %158
%1267 = load i32, i32* %58
%1268 = mul nsw i32 %1266, %1267
%1269 = add nsw i32 %1265, %1268
%1270 = sext i32 %1269 to i64
%1271 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1270
%1272 = load double, double* %1271
%1273 = fsub double %1263, %1272
%1274 = fmul double 5.000000e-01, %1273
%1275 = load double, double* %117
%1276 = fdiv double %1274, %1275
%1277 = load i32, i32* %65
%1278 = sext i32 %1277 to i64
%1279 = getelementptr inbounds [256 x double], [256 x double]* %123, i64 0, i64 %1278
store double %1276, double* %1279
%1280 = load i32, i32* %157
%1281 = load i32, i32* %158
%1282 = add nsw i32 %1281, 1
%1283 = load i32, i32* %58
%1284 = mul nsw i32 %1282, %1283
%1285 = add nsw i32 %1280, %1284
%1286 = sext i32 %1285 to i64
%1287 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1286
%1288 = load double, double* %1287
%1289 = load i32, i32* %157
%1290 = load i32, i32* %158
%1291 = sub nsw i32 %1290, 1
%1292 = load i32, i32* %58
%1293 = mul nsw i32 %1291, %1292
%1294 = add nsw i32 %1289, %1293
%1295 = sext i32 %1294 to i64
%1296 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1295
%1297 = load double, double* %1296
%1298 = fsub double %1288, %1297
%1299 = fmul double 5.000000e-01, %1298
%1300 = load double, double* %117
%1301 = fdiv double %1299, %1300
%1302 = load i32, i32* %65
%1303 = sext i32 %1302 to i64
%1304 = getelementptr inbounds [256 x double], [256 x double]* %124, i64 0, i64 %1303
store double %1301, double* %1304
br label %1305
1305: ; preds = %1249
%1306 = load i32, i32* %158
%1307 = add nsw i32 %1306, 1
store i32 %1307, i32* %158
br label %1246
1308: ; preds = %1246
br label %1309
1309: ; preds = %1308
%1310 = load i32, i32* %157
%1311 = add nsw i32 %1310, 1
store i32 %1311, i32* %157
br label %1242
1312: ; preds = %1242
store double 0.000000e+00, double* %144
store double 0.000000e+00, double* %143
store double 0.000000e+00, double* %142
store double 0.000000e+00, double* %141
store double 0.000000e+00, double* %140
store i32 2, i32* %157
br label %1313
1313: ; preds = %1506, %1312
%1314 = load i32, i32* %157
%1315 = icmp slt i32 %1314, 14
br i1 %1315, label %1316, label %1509
1316: ; preds = %1313
store i32 2, i32* %158
br label %1317
1317: ; preds = %1502, %1316
%1318 = load i32, i32* %158
%1319 = icmp slt i32 %1318, 14
br i1 %1319, label %1320, label %1505
1320: ; preds = %1317
%1321 = load i32, i32* %157
%1322 = load i32, i32* %158
%1323 = load i32, i32* %58
%1324 = mul nsw i32 %1322, %1323
%1325 = add nsw i32 %1321, %1324
store i32 %1325, i32* %65
%1326 = load double, double* %54
%1327 = fadd double %1326, 5.000000e-01
%1328 = call double @llvm.floor.f64(double %1327)
%1329 = fptosi double %1328 to i32
%1330 = load i32, i32* %157
%1331 = add nsw i32 %1329, %1330
%1332 = sub nsw i32 %1331, 7
store i32 %1332, i32* %90
%1333 = load double, double* %55
%1334 = fadd double %1333, 5.000000e-01
%1335 = call double @llvm.floor.f64(double %1334)
%1336 = fptosi double %1335 to i32
%1337 = load i32, i32* %158
%1338 = add nsw i32 %1336, %1337
%1339 = sub nsw i32 %1338, 7
store i32 %1339, i32* %91
%1340 = load i32, i32* %88
%1341 = load i32, i32* %94
%1342 = mul nsw i32 %1340, %1341
%1343 = load i32, i32* %90
%1344 = add nsw i32 %1342, %1343
%1345 = load i32, i32* %93
%1346 = load i32, i32* %91
%1347 = mul nsw i32 %1345, %1346
%1348 = add nsw i32 %1344, %1347
store i32 %1348, i32* %95
%1349 = load double*, double** %49
%1350 = load i32, i32* %95
%1351 = sext i32 %1350 to i64
%1352 = getelementptr inbounds double, double* %1349, i64 %1351
%1353 = load double, double* %1352
store double %1353, double* %153
%1354 = load double, double* %153
%1355 = fcmp ogt double %1354, 0.000000e+00
br i1 %1355, label %1356, label %1501
1356: ; preds = %1320
%1357 = load i32, i32* %65
%1358 = sext i32 %1357 to i64
%1359 = getelementptr inbounds [256 x double], [256 x double]* %123, i64 0, i64 %1358
%1360 = load double, double* %1359
%1361 = call double @llvm.fabs.f64(double %1360)
%1362 = fcmp ogt double %1361, 1.000000e-08
br i1 %1362, label %1363, label %1501
1363: ; preds = %1356
%1364 = load i32, i32* %65
%1365 = sext i32 %1364 to i64
%1366 = getelementptr inbounds [256 x double], [256 x double]* %124, i64 0, i64 %1365
%1367 = load double, double* %1366
%1368 = call double @llvm.fabs.f64(double %1367)
%1369 = fcmp ogt double %1368, 1.000000e-08
br i1 %1369, label %1370, label %1501
1370: ; preds = %1363
%1371 = load double*, double** %48
%1372 = load i32, i32* %95
%1373 = sext i32 %1372 to i64
%1374 = getelementptr inbounds double, double* %1371, i64 %1373
%1375 = load double, double* %1374
%1376 = load double*, double** %60
%1377 = load i32, i32* %88
%1378 = sext i32 %1377 to i64
%1379 = getelementptr inbounds double, double* %1376, i64 %1378
%1380 = load double, double* %1379
%1381 = load i32, i32* %65
%1382 = sext i32 %1381 to i64
%1383 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1382
%1384 = load double, double* %1383
%1385 = fneg double %1380
%1386 = call double @llvm.fmuladd.f64(double %1385, double %1384, double %1375)
store double %1386, double* %139
%1387 = load double, double* %139
%1388 = load i32, i32* %65
%1389 = sext i32 %1388 to i64
%1390 = getelementptr inbounds [256 x double], [256 x double]* %123, i64 0, i64 %1389
%1391 = load double, double* %1390
%1392 = fmul double %1387, %1391
%1393 = load double, double* %153
%1394 = load double, double* %140
%1395 = call double @llvm.fmuladd.f64(double %1392, double %1393, double %1394)
store double %1395, double* %140
%1396 = load double, double* %139
%1397 = load i32, i32* %65
%1398 = sext i32 %1397 to i64
%1399 = getelementptr inbounds [256 x double], [256 x double]* %124, i64 0, i64 %1398
%1400 = load double, double* %1399
%1401 = fmul double %1396, %1400
%1402 = load double, double* %153
%1403 = load double, double* %141
%1404 = call double @llvm.fmuladd.f64(double %1401, double %1402, double %1403)
store double %1404, double* %141
%1405 = load i32, i32* %65
%1406 = sext i32 %1405 to i64
%1407 = getelementptr inbounds [256 x double], [256 x double]* %123, i64 0, i64 %1406
%1408 = load double, double* %1407
%1409 = load i32, i32* %65
%1410 = sext i32 %1409 to i64
%1411 = getelementptr inbounds [256 x double], [256 x double]* %123, i64 0, i64 %1410
%1412 = load double, double* %1411
%1413 = fmul double %1408, %1412
%1414 = load double, double* %153
%1415 = load double, double* %142
%1416 = call double @llvm.fmuladd.f64(double %1413, double %1414, double %1415)
store double %1416, double* %142
%1417 = load i32, i32* %65
%1418 = sext i32 %1417 to i64
%1419 = getelementptr inbounds [256 x double], [256 x double]* %124, i64 0, i64 %1418
%1420 = load double, double* %1419
%1421 = load i32, i32* %65
%1422 = sext i32 %1421 to i64
%1423 = getelementptr inbounds [256 x double], [256 x double]* %124, i64 0, i64 %1422
%1424 = load double, double* %1423
%1425 = fmul double %1420, %1424
%1426 = load double, double* %153
%1427 = load double, double* %143
%1428 = call double @llvm.fmuladd.f64(double %1425, double %1426, double %1427)
store double %1428, double* %143
%1429 = load i32, i32* %65
%1430 = sext i32 %1429 to i64
%1431 = getelementptr inbounds [256 x double], [256 x double]* %123, i64 0, i64 %1430
%1432 = load double, double* %1431
%1433 = load i32, i32* %65
%1434 = sext i32 %1433 to i64
%1435 = getelementptr inbounds [256 x double], [256 x double]* %124, i64 0, i64 %1434
%1436 = load double, double* %1435
%1437 = fmul double %1432, %1436
%1438 = load double, double* %153
%1439 = load double, double* %144
%1440 = call double @llvm.fmuladd.f64(double %1437, double %1438, double %1439)
store double %1440, double* %144
%1441 = load double, double* %139
%1442 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %1441)
%1443 = icmp ne i32 %1442, 0
br i1 %1443, label %1444, label %1469
1444: ; preds = %1370
%1445 = load double*, double** %48
%1446 = load i32, i32* %95
%1447 = sext i32 %1446 to i64
%1448 = getelementptr inbounds double, double* %1445, i64 %1447
%1449 = load double, double* %1448
%1450 = load double*, double** %60
%1451 = load i32, i32* %88
%1452 = sext i32 %1451 to i64
%1453 = getelementptr inbounds double, double* %1450, i64 %1452
%1454 = load double, double* %1453
%1455 = load i32, i32* %65
%1456 = sext i32 %1455 to i64
%1457 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1456
%1458 = load double, double* %1457
%1459 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.7, i64 0, i64 0), double %1449, double %1454, double %1458)
%1460 = load i32, i32* %157
%1461 = load i32, i32* %158
%1462 = load double, double* %139
%1463 = load double, double* %140
%1464 = load double, double* %141
%1465 = load double, double* %142
%1466 = load double, double* %143
%1467 = load double, double* %144
%1468 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.8, i64 0, i64 0), i32 %1460, i32 %1461, double %1462, double %1463, double %1464, double %1465, double %1466, double %1467)
unreachable
1469: ; preds = %1370
%1470 = load double, double* %140
%1471 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %1470)
%1472 = icmp ne i32 %1471, 0
br i1 %1472, label %1489, label %1473
1473: ; preds = %1469
%1474 = load double, double* %140
%1475 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %1474)
%1476 = icmp ne i32 %1475, 0
br i1 %1476, label %1489, label %1477
1477: ; preds = %1473
%1478 = load double, double* %140
%1479 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %1478)
%1480 = icmp ne i32 %1479, 0
br i1 %1480, label %1489, label %1481
1481: ; preds = %1477
%1482 = load double, double* %140
%1483 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %1482)
%1484 = icmp ne i32 %1483, 0
br i1 %1484, label %1489, label %1485
1485: ; preds = %1481
%1486 = load double, double* %140
%1487 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %1486)
%1488 = icmp ne i32 %1487, 0
br i1 %1488, label %1489, label %1500
1489: ; preds = %1485, %1481, %1477, %1473, %1469
%1490 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.9, i64 0, i64 0))
%1491 = load i32, i32* %157
%1492 = load i32, i32* %158
%1493 = load double, double* %139
%1494 = load double, double* %140
%1495 = load double, double* %141
%1496 = load double, double* %142
%1497 = load double, double* %143
%1498 = load double, double* %144
%1499 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.8, i64 0, i64 0), i32 %1491, i32 %1492, double %1493, double %1494, double %1495, double %1496, double %1497, double %1498)
unreachable
1500: ; preds = %1485
br label %1501
1501: ; preds = %1500, %1363, %1356, %1320
br label %1502
1502: ; preds = %1501
%1503 = load i32, i32* %158
%1504 = add nsw i32 %1503, 1
store i32 %1504, i32* %158
br label %1317
1505: ; preds = %1317
br label %1506
1506: ; preds = %1505
%1507 = load i32, i32* %157
%1508 = add nsw i32 %1507, 1
store i32 %1508, i32* %157
br label %1313
1509: ; preds = %1313
%1510 = load double*, double** %60
%1511 = load i32, i32* %88
%1512 = sext i32 %1511 to i64
%1513 = getelementptr inbounds double, double* %1510, i64 %1512
%1514 = load double, double* %1513
%1515 = load double, double* %140
%1516 = load double, double* %141
%1517 = load double, double* %144
%1518 = fmul double %1516, %1517
%1519 = load double, double* %143
%1520 = fdiv double %1518, %1519
%1521 = fsub double %1515, %1520
%1522 = load double, double* %147
%1523 = call double @llvm.fmuladd.f64(double %1514, double %1521, double %1522)
store double %1523, double* %147
%1524 = load double*, double** %60
%1525 = load i32, i32* %88
%1526 = sext i32 %1525 to i64
%1527 = getelementptr inbounds double, double* %1524, i64 %1526
%1528 = load double, double* %1527
%1529 = load double*, double** %60
%1530 = load i32, i32* %88
%1531 = sext i32 %1530 to i64
%1532 = getelementptr inbounds double, double* %1529, i64 %1531
%1533 = load double, double* %1532
%1534 = fmul double %1528, %1533
%1535 = load double, double* %142
%1536 = load double, double* %144
%1537 = load double, double* %144
%1538 = fmul double %1536, %1537
%1539 = load double, double* %143
%1540 = fdiv double %1538, %1539
%1541 = fsub double %1535, %1540
%1542 = load double, double* %148
%1543 = call double @llvm.fmuladd.f64(double %1534, double %1541, double %1542)
store double %1543, double* %148
%1544 = load double*, double** %60
%1545 = load i32, i32* %88
%1546 = sext i32 %1545 to i64
%1547 = getelementptr inbounds double, double* %1544, i64 %1546
%1548 = load double, double* %1547
%1549 = load double, double* %141
%1550 = load double, double* %140
%1551 = load double, double* %144
%1552 = fmul double %1550, %1551
%1553 = load double, double* %142
%1554 = fdiv double %1552, %1553
%1555 = fsub double %1549, %1554
%1556 = load double, double* %149
%1557 = call double @llvm.fmuladd.f64(double %1548, double %1555, double %1556)
store double %1557, double* %149
%1558 = load double*, double** %60
%1559 = load i32, i32* %88
%1560 = sext i32 %1559 to i64
%1561 = getelementptr inbounds double, double* %1558, i64 %1560
%1562 = load double, double* %1561
%1563 = load double*, double** %60
%1564 = load i32, i32* %88
%1565 = sext i32 %1564 to i64
%1566 = getelementptr inbounds double, double* %1563, i64 %1565
%1567 = load double, double* %1566
%1568 = fmul double %1562, %1567
%1569 = load double, double* %143
%1570 = load double, double* %144
%1571 = load double, double* %144
%1572 = fmul double %1570, %1571
%1573 = load double, double* %142
%1574 = fdiv double %1572, %1573
%1575 = fsub double %1569, %1574
%1576 = load double, double* %150
%1577 = call double @llvm.fmuladd.f64(double %1568, double %1575, double %1576)
store double %1577, double* %150
br label %1578
1578: ; preds = %1509, %1153, %1143, %1118
br label %1579
1579: ; preds = %1578
%1580 = load i32, i32* %88
%1581 = add nsw i32 %1580, 1
store i32 %1581, i32* %88
br label %1114
1582: ; preds = %1114
%1583 = load i32, i32* %92
%1584 = load i32, i32* %164
%1585 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.10, i64 0, i64 0), i32 %1583, i32 %1584)
%1586 = load i32, i32* %164
%1587 = icmp sgt i32 %1586, 0
br i1 %1587, label %1588, label %1676
1588: ; preds = %1582
%1589 = load double, double* %147
%1590 = load double, double* %148
%1591 = fdiv double %1589, %1590
store double %1591, double* %151
%1592 = load double, double* %149
%1593 = load double, double* %150
%1594 = fdiv double %1592, %1593
store double %1594, double* %152
%1595 = load double, double* %151
%1596 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %1595)
%1597 = icmp ne i32 %1596, 0
br i1 %1597, label %1598, label %1604
1598: ; preds = %1588
%1599 = load double, double* %147
%1600 = load double, double* %148
%1601 = load double, double* %151
%1602 = load double, double* %118
%1603 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.11, i64 0, i64 0), double %1599, double %1600, double %1601, double %1602)
br label %1604
1604: ; preds = %1598, %1588
%1605 = load double, double* %152
%1606 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %1605)
%1607 = icmp ne i32 %1606, 0
br i1 %1607, label %1608, label %1614
1608: ; preds = %1604
%1609 = load double, double* %149
%1610 = load double, double* %150
%1611 = load double, double* %152
%1612 = load double, double* %118
%1613 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.12, i64 0, i64 0), double %1609, double %1610, double %1611, double %1612)
br label %1614
1614: ; preds = %1608, %1604
%1615 = load double, double* %151
%1616 = call double @llvm.fabs.f64(double %1615)
%1617 = load double, double* %161
%1618 = fcmp ogt double %1616, %1617
br i1 %1618, label %1619, label %1629
1619: ; preds = %1614
%1620 = load double, double* %151
%1621 = fcmp ogt double %1620, 0.000000e+00
br i1 %1621, label %1622, label %1624
1622: ; preds = %1619
%1623 = load double, double* %161
br label %1627
1624: ; preds = %1619
%1625 = load double, double* %161
%1626 = fneg double %1625
br label %1627
1627: ; preds = %1624, %1622
%1628 = phi double [ %1623, %1622 ], [ %1626, %1624 ]
store double %1628, double* %151
br label %1629
1629: ; preds = %1627, %1614
%1630 = load double, double* %152
%1631 = call double @llvm.fabs.f64(double %1630)
%1632 = load double, double* %161
%1633 = fcmp ogt double %1631, %1632
br i1 %1633, label %1634, label %1644
1634: ; preds = %1629
%1635 = load double, double* %152
%1636 = fcmp ogt double %1635, 0.000000e+00
br i1 %1636, label %1637, label %1639
1637: ; preds = %1634
%1638 = load double, double* %161
br label %1642
1639: ; preds = %1634
%1640 = load double, double* %161
%1641 = fneg double %1640
br label %1642
1642: ; preds = %1639, %1637
%1643 = phi double [ %1638, %1637 ], [ %1641, %1639 ]
store double %1643, double* %152
br label %1644
1644: ; preds = %1642, %1629
%1645 = load double, double* %151
%1646 = load double, double* %54
%1647 = fsub double %1646, %1645
store double %1647, double* %54
%1648 = load double, double* %152
%1649 = load double, double* %55
%1650 = fsub double %1649, %1648
store double %1650, double* %55
%1651 = load double, double* %54
%1652 = load double, double* %151
%1653 = fadd double %1651, %1652
%1654 = load double, double* %55
%1655 = load double, double* %152
%1656 = fadd double %1654, %1655
%1657 = load double, double* %151
%1658 = load double, double* %152
%1659 = load double, double* %54
%1660 = load double, double* %55
%1661 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.13, i64 0, i64 0), double %1653, double %1656, double %1657, double %1658, double %1659, double %1660)
%1662 = load double, double* %54
%1663 = load double, double* %96
%1664 = fsub double %1662, %1663
%1665 = load double, double* %54
%1666 = load double, double* %96
%1667 = fsub double %1665, %1666
%1668 = load double, double* %55
%1669 = load double, double* %97
%1670 = fsub double %1668, %1669
%1671 = load double, double* %55
%1672 = load double, double* %97
%1673 = fsub double %1671, %1672
%1674 = fmul double %1670, %1673
%1675 = call double @llvm.fmuladd.f64(double %1664, double %1667, double %1674)
store double %1675, double* %154
br label %1676
1676: ; preds = %1644, %1582
br label %1678
1677: ; preds = %1103
store double 0.000000e+00, double* %154
store double 1.000000e+00, double* %151
br label %1678
1678: ; preds = %1677, %1676
%1679 = load i32, i32* %92
%1680 = add nsw i32 %1679, 1
store i32 %1680, i32* %92
br label %1681
1681: ; preds = %1678
%1682 = load i32, i32* %92
%1683 = load i32, i32* %162
%1684 = icmp slt i32 %1682, %1683
br i1 %1684, label %1685, label %1699
1685: ; preds = %1681
%1686 = load double, double* %151
%1687 = call double @llvm.fabs.f64(double %1686)
%1688 = fcmp ogt double %1687, 1.000000e-05
br i1 %1688, label %1696, label %1689
1689: ; preds = %1685
%1690 = load double, double* %152
%1691 = call double @llvm.fabs.f64(double %1690)
%1692 = fcmp ogt double %1691, 1.000000e-05
br i1 %1692, label %1696, label %1693
1693: ; preds = %1689
%1694 = load i32, i32* %92
%1695 = icmp eq i32 %1694, 0
br i1 %1695, label %1696, label %1699
1696: ; preds = %1693, %1689, %1685
%1697 = load double, double* %154
%1698 = fcmp olt double %1697, 1.000000e+02
br label %1699
1699: ; preds = %1696, %1693, %1681
%1700 = phi i1 [ false, %1693 ], [ false, %1681 ], [ %1698, %1696 ]
br i1 %1700, label %691, label %1701
1701: ; preds = %1699
%1702 = load double, double* %154
%1703 = load double, double* %64
%1704 = load double, double* %64
%1705 = fmul double %1703, %1704
%1706 = fcmp oge double %1702, %1705
br i1 %1706, label %1707, label %1711
1707: ; preds = %1701
%1708 = load double, double* %96
store double %1708, double* %54
%1709 = load double, double* %97
store double %1709, double* %55
%1710 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([67 x i8], [67 x i8]* @.str.14, i64 0, i64 0))
br label %1711
1711: ; preds = %1707, %1701
%1712 = load double, double* %54
%1713 = load double, double* %96
%1714 = fsub double %1712, %1713
%1715 = load double*, double** %52
%1716 = load double, double* %1715
%1717 = fadd double %1716, %1714
store double %1717, double* %1715
%1718 = load double, double* %55
%1719 = load double, double* %97
%1720 = fsub double %1718, %1719
%1721 = load double*, double** %53
%1722 = load double, double* %1721
%1723 = fadd double %1722, %1720
store double %1723, double* %1721
br label %1724
1724: ; preds = %1711, %687
%1725 = load double*, double** %52
%1726 = load double, double* %1725
%1727 = load double*, double** %53
%1728 = load double, double* %1727
%1729 = load double, double* %54
%1730 = load double, double* %55
%1731 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.15, i64 0, i64 0), double %1726, double %1728, double %1729, double %1730)
%1732 = load double, double* %54
%1733 = fadd double %1732, 5.000000e-01
%1734 = call double @llvm.ceil.f64(double %1733)
%1735 = load double, double* %54
%1736 = fadd double %1735, 5.000000e-01
%1737 = fsub double %1734, %1736
store double %1737, double* %113
%1738 = load double, double* %55
%1739 = fadd double %1738, 5.000000e-01
%1740 = call double @llvm.ceil.f64(double %1739)
%1741 = load double, double* %55
%1742 = fadd double %1741, 5.000000e-01
%1743 = fsub double %1740, %1742
store double %1743, double* %114
store i32 0, i32* %88
br label %1744
1744: ; preds = %2135, %1724
%1745 = load i32, i32* %88
%1746 = load i32, i32* %37
%1747 = icmp slt i32 %1745, %1746
br i1 %1747, label %1748, label %2138
1748: ; preds = %1744
store i32 0, i32* %72
br label %1749
1749: ; preds = %1762, %1748
%1750 = load i32, i32* %72
%1751 = icmp slt i32 %1750, 256
br i1 %1751, label %1752, label %1765
1752: ; preds = %1749
%1753 = load i32, i32* %72
%1754 = sext i32 %1753 to i64
%1755 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1754
store double 0.000000e+00, double* %1755
%1756 = load i32, i32* %72
%1757 = sext i32 %1756 to i64
%1758 = getelementptr inbounds [256 x double], [256 x double]* %123, i64 0, i64 %1757
store double 0.000000e+00, double* %1758
%1759 = load i32, i32* %72
%1760 = sext i32 %1759 to i64
%1761 = getelementptr inbounds [256 x double], [256 x double]* %124, i64 0, i64 %1760
store double 0.000000e+00, double* %1761
br label %1762
1762: ; preds = %1752
%1763 = load i32, i32* %72
%1764 = add nsw i32 %1763, 1
store i32 %1764, i32* %72
br label %1749
1765: ; preds = %1749
store double 0.000000e+00, double* %117
store i32 1, i32* %157
br label %1766
1766: ; preds = %1823, %1765
%1767 = load i32, i32* %157
%1768 = icmp slt i32 %1767, 15
br i1 %1768, label %1769, label %1826
1769: ; preds = %1766
store i32 1, i32* %158
br label %1770
1770: ; preds = %1819, %1769
%1771 = load i32, i32* %158
%1772 = icmp slt i32 %1771, 15
br i1 %1772, label %1773, label %1822
1773: ; preds = %1770
%1774 = load i32, i32* %157
%1775 = load i32, i32* %158
%1776 = load i32, i32* %58
%1777 = mul nsw i32 %1775, %1776
%1778 = add nsw i32 %1774, %1777
store i32 %1778, i32* %65
%1779 = load double, double* %113
%1780 = load double, double* %114
%1781 = load double*, double** %121
%1782 = load i32, i32* %88
%1783 = mul nsw i32 %1782, 256
%1784 = load i32, i32* %157
%1785 = add nsw i32 %1783, %1784
%1786 = load i32, i32* %158
%1787 = load i32, i32* %58
%1788 = mul nsw i32 %1786, %1787
%1789 = add nsw i32 %1785, %1788
%1790 = sext i32 %1789 to i64
%1791 = getelementptr inbounds double, double* %1781, i64 %1790
%1792 = call i32 (double, double, i32, double*, ...) bitcast (i32 (...)* @interpolate_2d to i32 (double, double, i32, double*, ...)*)(double %1779, double %1780, i32 16, double* %1791)
%1793 = sitofp i32 %1792 to double
%1794 = load i32, i32* %65
%1795 = sext i32 %1794 to i64
%1796 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1795
store double %1793, double* %1796
%1797 = load i32, i32* %65
%1798 = sext i32 %1797 to i64
%1799 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1798
%1800 = load double, double* %1799
%1801 = fcmp ogt double %1800, 0.000000e+00
br i1 %1801, label %1802, label %1807
1802: ; preds = %1773
%1803 = load i32, i32* %65
%1804 = sext i32 %1803 to i64
%1805 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1804
%1806 = load double, double* %1805
br label %1808
1807: ; preds = %1773
br label %1808
1808: ; preds = %1807, %1802
%1809 = phi double [ %1806, %1802 ], [ 0.000000e+00, %1807 ]
%1810 = load i32, i32* %65
%1811 = sext i32 %1810 to i64
%1812 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1811
store double %1809, double* %1812
%1813 = load i32, i32* %65
%1814 = sext i32 %1813 to i64
%1815 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1814
%1816 = load double, double* %1815
%1817 = load double, double* %117
%1818 = fadd double %1817, %1816
store double %1818, double* %117
br label %1819
1819: ; preds = %1808
%1820 = load i32, i32* %158
%1821 = add nsw i32 %1820, 1
store i32 %1821, i32* %158
br label %1770
1822: ; preds = %1770
br label %1823
1823: ; preds = %1822
%1824 = load i32, i32* %157
%1825 = add nsw i32 %1824, 1
store i32 %1825, i32* %157
br label %1766
1826: ; preds = %1766
%1827 = load double, double* %117
%1828 = fcmp olt double %1827, 0x3EB0C6F7A0B5ED8D
br i1 %1828, label %1829, label %1838
1829: ; preds = %1826
%1830 = load double*, double** %60
%1831 = load i32, i32* %88
%1832 = sext i32 %1831 to i64
%1833 = getelementptr inbounds double, double* %1830, i64 %1832
store double 0.000000e+00, double* %1833
%1834 = load double*, double** %61
%1835 = load i32, i32* %88
%1836 = sext i32 %1835 to i64
%1837 = getelementptr inbounds double, double* %1834, i64 %1836
store double 1.000000e+06, double* %1837
br label %2134
1838: ; preds = %1826
store double 0.000000e+00, double* %133
store i32 0, i32* %73
br label %1839
1839: ; preds = %2058, %1838
%1840 = load i32, i32* %73
%1841 = icmp slt i32 %1840, 1
br i1 %1841, label %1842, label %2061
1842: ; preds = %1839
store double 0.000000e+00, double* %132
store double 0.000000e+00, double* %131
store double 0.000000e+00, double* %130
store double 0.000000e+00, double* %129
store double 0.000000e+00, double* %128
store double 0.000000e+00, double* %127
store i32 0, i32* %157
br label %1843
1843: ; preds = %1950, %1842
%1844 = load i32, i32* %157
%1845 = icmp slt i32 %1844, 16
br i1 %1845, label %1846, label %1953
1846: ; preds = %1843
store i32 0, i32* %158
br label %1847
1847: ; preds = %1946, %1846
%1848 = load i32, i32* %158
%1849 = icmp slt i32 %1848, 16
br i1 %1849, label %1850, label %1949
1850: ; preds = %1847
%1851 = load i32, i32* %157
%1852 = load i32, i32* %158
%1853 = load i32, i32* %58
%1854 = mul nsw i32 %1852, %1853
%1855 = add nsw i32 %1851, %1854
store i32 %1855, i32* %65
%1856 = load i32, i32* %157
%1857 = sitofp i32 %1856 to double
%1858 = fsub double %1857, 8.000000e+00
%1859 = call double @pow(double %1858, double 2.000000e+00)
%1860 = load i32, i32* %158
%1861 = sitofp i32 %1860 to double
%1862 = fsub double %1861, 8.000000e+00
%1863 = call double @pow(double %1862, double 2.000000e+00)
%1864 = fadd double %1859, %1863
%1865 = load double, double* %126
%1866 = fcmp olt double %1864, %1865
br i1 %1866, label %1867, label %1945
1867: ; preds = %1850
%1868 = load double, double* %54
%1869 = fadd double %1868, 5.000000e-01
%1870 = call double @llvm.floor.f64(double %1869)
%1871 = fptosi double %1870 to i32
%1872 = load i32, i32* %157
%1873 = add nsw i32 %1871, %1872
%1874 = sub nsw i32 %1873, 7
store i32 %1874, i32* %90
%1875 = load double, double* %55
%1876 = fadd double %1875, 5.000000e-01
%1877 = call double @llvm.floor.f64(double %1876)
%1878 = fptosi double %1877 to i32
%1879 = load i32, i32* %158
%1880 = add nsw i32 %1878, %1879
%1881 = sub nsw i32 %1880, 7
store i32 %1881, i32* %91
%1882 = load i32, i32* %88
%1883 = load i32, i32* %94
%1884 = mul nsw i32 %1882, %1883
%1885 = load i32, i32* %90
%1886 = add nsw i32 %1884, %1885
%1887 = load i32, i32* %93
%1888 = load i32, i32* %91
%1889 = mul nsw i32 %1887, %1888
%1890 = add nsw i32 %1886, %1889
store i32 %1890, i32* %95
%1891 = load double*, double** %49
%1892 = load i32, i32* %95
%1893 = sext i32 %1892 to i64
%1894 = getelementptr inbounds double, double* %1891, i64 %1893
%1895 = load double, double* %1894
store double %1895, double* %153
%1896 = load i32, i32* %65
%1897 = sext i32 %1896 to i64
%1898 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1897
%1899 = load double, double* %1898
%1900 = load double*, double** %48
%1901 = load i32, i32* %95
%1902 = sext i32 %1901 to i64
%1903 = getelementptr inbounds double, double* %1900, i64 %1902
%1904 = load double, double* %1903
%1905 = fmul double %1899, %1904
%1906 = load double, double* %153
%1907 = load double, double* %127
%1908 = call double @llvm.fmuladd.f64(double %1905, double %1906, double %1907)
store double %1908, double* %127
%1909 = load i32, i32* %65
%1910 = sext i32 %1909 to i64
%1911 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1910
%1912 = load double, double* %1911
%1913 = load i32, i32* %65
%1914 = sext i32 %1913 to i64
%1915 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1914
%1916 = load double, double* %1915
%1917 = fmul double %1912, %1916
%1918 = load double, double* %153
%1919 = load double, double* %128
%1920 = call double @llvm.fmuladd.f64(double %1917, double %1918, double %1919)
store double %1920, double* %128
%1921 = load i32, i32* %65
%1922 = sext i32 %1921 to i64
%1923 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1922
%1924 = load double, double* %1923
%1925 = load double, double* %129
%1926 = fadd double %1925, %1924
store double %1926, double* %129
%1927 = load i32, i32* %65
%1928 = sext i32 %1927 to i64
%1929 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %1928
%1930 = load double, double* %1929
%1931 = load double, double* %153
%1932 = load double, double* %130
%1933 = call double @llvm.fmuladd.f64(double %1930, double %1931, double %1932)
store double %1933, double* %130
%1934 = load double, double* %153
%1935 = load double, double* %131
%1936 = fadd double %1935, %1934
store double %1936, double* %131
%1937 = load double*, double** %48
%1938 = load i32, i32* %95
%1939 = sext i32 %1938 to i64
%1940 = getelementptr inbounds double, double* %1937, i64 %1939
%1941 = load double, double* %1940
%1942 = load double, double* %153
%1943 = load double, double* %132
%1944 = call double @llvm.fmuladd.f64(double %1941, double %1942, double %1943)
store double %1944, double* %132
br label %1945
1945: ; preds = %1867, %1850
br label %1946
1946: ; preds = %1945
%1947 = load i32, i32* %158
%1948 = add nsw i32 %1947, 1
store i32 %1948, i32* %158
br label %1847
1949: ; preds = %1847
br label %1950
1950: ; preds = %1949
%1951 = load i32, i32* %157
%1952 = add nsw i32 %1951, 1
store i32 %1952, i32* %157
br label %1843
1953: ; preds = %1843
%1954 = load i32, i32* %163
%1955 = icmp eq i32 %1954, 1
br i1 %1955, label %1956, label %1973
1956: ; preds = %1953
%1957 = load double, double* %128
%1958 = load double, double* %131
%1959 = load double, double* %130
%1960 = load double, double* %130
%1961 = fmul double %1959, %1960
%1962 = fneg double %1961
%1963 = call double @llvm.fmuladd.f64(double %1957, double %1958, double %1962)
store double %1963, double* %155
%1964 = load double, double* %127
%1965 = load double, double* %131
%1966 = load double, double* %130
%1967 = load double, double* %132
%1968 = fmul double %1966, %1967
%1969 = fneg double %1968
%1970 = call double @llvm.fmuladd.f64(double %1964, double %1965, double %1969)
%1971 = load double, double* %155
%1972 = fdiv double %1970, %1971
store double %1972, double* %133
br label %1977
1973: ; preds = %1953
%1974 = load double, double* %127
%1975 = load double, double* %128
%1976 = fdiv double %1974, %1975
store double %1976, double* %133
br label %1977
1977: ; preds = %1973, %1956
%1978 = load double, double* %133
%1979 = call i32 (double, ...) bitcast (i32 (...)* @isnan to i32 (double, ...)*)(double %1978)
%1980 = icmp ne i32 %1979, 0
br i1 %1980, label %1981, label %2057
1981: ; preds = %1977
store i32 0, i32* %157
br label %1982
1982: ; preds = %2053, %1981
%1983 = load i32, i32* %157
%1984 = icmp slt i32 %1983, 16
br i1 %1984, label %1985, label %2056
1985: ; preds = %1982
store i32 0, i32* %158
br label %1986
1986: ; preds = %2049, %1985
%1987 = load i32, i32* %158
%1988 = icmp slt i32 %1987, 16
br i1 %1988, label %1989, label %2052
1989: ; preds = %1986
%1990 = load i32, i32* %157
%1991 = load i32, i32* %158
%1992 = load i32, i32* %58
%1993 = mul nsw i32 %1991, %1992
%1994 = add nsw i32 %1990, %1993
store i32 %1994, i32* %65
%1995 = load i32, i32* %157
%1996 = sitofp i32 %1995 to double
%1997 = fsub double %1996, 8.000000e+00
%1998 = call double @pow(double %1997, double 2.000000e+00)
%1999 = load i32, i32* %158
%2000 = sitofp i32 %1999 to double
%2001 = fsub double %2000, 8.000000e+00
%2002 = call double @pow(double %2001, double 2.000000e+00)
%2003 = fadd double %1998, %2002
%2004 = load double, double* %126
%2005 = fcmp olt double %2003, %2004
br i1 %2005, label %2006, label %2048
2006: ; preds = %1989
%2007 = load double, double* %54
%2008 = fadd double %2007, 5.000000e-01
%2009 = call double @llvm.floor.f64(double %2008)
%2010 = fptosi double %2009 to i32
%2011 = load i32, i32* %157
%2012 = add nsw i32 %2010, %2011
%2013 = sitofp i32 %2012 to double
%2014 = fsub double %2013, 8.000000e+00
%2015 = fptosi double %2014 to i32
store i32 %2015, i32* %90
%2016 = load double, double* %55
%2017 = fadd double %2016, 5.000000e-01
%2018 = call double @llvm.floor.f64(double %2017)
%2019 = fptosi double %2018 to i32
%2020 = load i32, i32* %158
%2021 = add nsw i32 %2019, %2020
%2022 = sitofp i32 %2021 to double
%2023 = fsub double %2022, 8.000000e+00
%2024 = fptosi double %2023 to i32
store i32 %2024, i32* %91
%2025 = load i32, i32* %88
%2026 = load i32, i32* %94
%2027 = mul nsw i32 %2025, %2026
%2028 = load i32, i32* %90
%2029 = add nsw i32 %2027, %2028
%2030 = load i32, i32* %93
%2031 = load i32, i32* %91
%2032 = mul nsw i32 %2030, %2031
%2033 = add nsw i32 %2029, %2032
store i32 %2033, i32* %95
%2034 = load double, double* %133
%2035 = load i32, i32* %65
%2036 = sext i32 %2035 to i64
%2037 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %2036
%2038 = load double, double* %2037
%2039 = fmul double %2034, %2038
%2040 = load double, double* %62
%2041 = fdiv double %2039, %2040
%2042 = fdiv double 1.000000e+00, %2041
store double %2042, double* %153
%2043 = load double*, double** %49
%2044 = load i32, i32* %95
%2045 = sext i32 %2044 to i64
%2046 = getelementptr inbounds double, double* %2043, i64 %2045
%2047 = load double, double* %2046
store double %2047, double* %153
br label %2048
2048: ; preds = %2006, %1989
br label %2049
2049: ; preds = %2048
%2050 = load i32, i32* %158
%2051 = add nsw i32 %2050, 1
store i32 %2051, i32* %158
br label %1986
2052: ; preds = %1986
br label %2053
2053: ; preds = %2052
%2054 = load i32, i32* %157
%2055 = add nsw i32 %2054, 1
store i32 %2055, i32* %157
br label %1982
2056: ; preds = %1982
br label %2057
2057: ; preds = %2056, %1977
br label %2058
2058: ; preds = %2057
%2059 = load i32, i32* %73
%2060 = add nsw i32 %2059, 1
store i32 %2060, i32* %73
br label %1839
2061: ; preds = %1839
%2062 = load double, double* %133
%2063 = load double*, double** %60
%2064 = load i32, i32* %88
%2065 = sext i32 %2064 to i64
%2066 = getelementptr inbounds double, double* %2063, i64 %2065
store double %2062, double* %2066
%2067 = load double, double* %128
%2068 = fdiv double 1.000000e+00, %2067
%2069 = call double @sqrt(double %2068)
%2070 = load double*, double** %61
%2071 = load i32, i32* %88
%2072 = sext i32 %2071 to i64
%2073 = getelementptr inbounds double, double* %2070, i64 %2072
store double %2069, double* %2073
store i32 0, i32* %157
br label %2074
2074: ; preds = %2130, %2061
%2075 = load i32, i32* %157
%2076 = icmp slt i32 %2075, 16
br i1 %2076, label %2077, label %2133
2077: ; preds = %2074
store i32 0, i32* %158
br label %2078
2078: ; preds = %2126, %2077
%2079 = load i32, i32* %158
%2080 = icmp slt i32 %2079, 16
br i1 %2080, label %2081, label %2129
2081: ; preds = %2078
%2082 = load i32, i32* %157
%2083 = load i32, i32* %158
%2084 = load i32, i32* %58
%2085 = mul nsw i32 %2083, %2084
%2086 = add nsw i32 %2082, %2085
store i32 %2086, i32* %65
%2087 = load double, double* %54
%2088 = fadd double %2087, 5.000000e-01
%2089 = call double @llvm.floor.f64(double %2088)
%2090 = fptosi double %2089 to i32
%2091 = load i32, i32* %157
%2092 = add nsw i32 %2090, %2091
%2093 = sub nsw i32 %2092, 7
store i32 %2093, i32* %90
%2094 = load double, double* %55
%2095 = fadd double %2094, 5.000000e-01
%2096 = call double @llvm.floor.f64(double %2095)
%2097 = fptosi double %2096 to i32
%2098 = load i32, i32* %158
%2099 = add nsw i32 %2097, %2098
%2100 = sub nsw i32 %2099, 7
store i32 %2100, i32* %91
%2101 = load i32, i32* %88
%2102 = load i32, i32* %94
%2103 = mul nsw i32 %2101, %2102
%2104 = load i32, i32* %90
%2105 = add nsw i32 %2103, %2104
%2106 = load i32, i32* %93
%2107 = load i32, i32* %91
%2108 = mul nsw i32 %2106, %2107
%2109 = add nsw i32 %2105, %2108
store i32 %2109, i32* %95
%2110 = load double*, double** %60
%2111 = load i32, i32* %88
%2112 = sext i32 %2111 to i64
%2113 = getelementptr inbounds double, double* %2110, i64 %2112
%2114 = load double, double* %2113
%2115 = load i32, i32* %65
%2116 = sext i32 %2115 to i64
%2117 = getelementptr inbounds [256 x double], [256 x double]* %122, i64 0, i64 %2116
%2118 = load double, double* %2117
%2119 = load double*, double** %48
%2120 = load i32, i32* %95
%2121 = sext i32 %2120 to i64
%2122 = getelementptr inbounds double, double* %2119, i64 %2121
%2123 = load double, double* %2122
%2124 = fneg double %2114
%2125 = call double @llvm.fmuladd.f64(double %2124, double %2118, double %2123)
store double %2125, double* %2122
br label %2126
2126: ; preds = %2081
%2127 = load i32, i32* %158
%2128 = add nsw i32 %2127, 1
store i32 %2128, i32* %158
br label %2078
2129: ; preds = %2078
br label %2130
2130: ; preds = %2129
%2131 = load i32, i32* %157
%2132 = add nsw i32 %2131, 1
store i32 %2132, i32* %157
br label %2074
2133: ; preds = %2074
br label %2134
2134: ; preds = %2133, %1829
br label %2135
2135: ; preds = %2134
%2136 = load i32, i32* %88
%2137 = add nsw i32 %2136, 1
store i32 %2137, i32* %88
br label %1744
2138: ; preds = %1744
ret void
}

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