void contrast(void) {
  int rec = 1;
  int nlat, nlon;
  int i, j, size = 0;
  double missval;
  double **work;
  double **in;
  double **out;
  double *lon;
  double *lat;
  static double *xin_array, **xin, **xout, **xwork[17];
  static double **r, **r_bar, **r_new, **r_bar_new;
  static double **p, **p_bar, **p_new, **p_bar_new, **swap;
  static double a0, a1, a2, a3, a4, a5, a6, a7, a8;
  static double dlon0, dlon1, dslat0, dslat1;
  static double w00, w01, w10, w11, wsum;
  static double lon0, lon1, lon2, lat0, lat1, lat2;
  static double flat00, flat01, flat10, flat11;
  static long ilon, ilat;
  static int determine_matrix, wrap_around, stop_iteration;
  static double table[2][2][2][4] = {
      {{{8 / 32., 8 / 32., 8 / 32., 8 / 32.}, {12 / 32., 8 / 32., 0, 12 / 32.}},
       {{12 / 32., 0, 8 / 32., 12 / 32.}, {16 / 32., 0, 0, 16 / 32.}}},
      {{{0, 12 / 32., 12 / 32., 8 / 32.}, {0, 16 / 32., 0, 16 / 32.}},
       {{0, 0, 16 / 32., 16 / 32.}, {0, 0, 0, 32 / 32.}}}};
  static double *case_table;
  static double f;
  static double nom, denom, a, b;
  static const double eps = 1e-20;
  static double max;
  static int iter;
  static float iter_sum = 0, iter_n = 0;
  nlat = 0;
  nlon = 0;
  missval = 0;
  work = 0;
  in = 0;
  out = 0;
  lon = 0;
  lat = 0;
  if (rec == 1) {
    xin_array = (double *)Malloc(
        __func__,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/interpol.c",
        1540, ((nlat + 2) * (nlon + 2) * sizeof(double)));
    xin = (double **)Malloc(
        __func__,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/interpol.c",
        1541, ((nlat + 2) * sizeof(double *)));
    *xin = *(xin + 1);
    for (ilat = -1; ilat <= nlat; ilat++)
      xin[ilat] = xin_array + (ilat + 1) * (nlon + 2) + 1;
    xout = (double **)Malloc(
        __func__,
        "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
        "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/interpol.c",
        1545, (nlat * sizeof(double *)));
    for (ilat = 0; ilat < nlat; ilat++)
      xout[ilat] = out[0] + ilat * nlon;
    for (j = 0; j < 17; j++) {
      xwork[j] = (double **)Malloc(
          __func__,
          "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
          "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/interpol.c",
          1550, (nlat * sizeof(double *)));
      for (ilat = 0; ilat < nlat; ilat++)
        xwork[j][ilat] = work[j] + ilat * nlon;
    }
    wrap_around = nlon > 1 && (lon[nlon - 1] >= lon[-1] + 360 - 0.001 ||
                               lon[nlon] >= lon[0] + 360 - 0.001);
    determine_matrix = 1;
  } else {
    determine_matrix = 0;
    for (i = 0; i < size; i++)
      if ((((in[0][i]) != (in[0][i])) || ((missval) != (missval))
               ? (((in[0][i]) != (in[0][i])) && ((missval) != (missval)) ? 1
                                                                         : 0)
               : !(in[0][i] < missval || missval < in[0][i])) !=
          (((out[0][i]) != (out[0][i])) || ((missval) != (missval))
               ? (((out[0][i]) != (out[0][i])) && ((missval) != (missval)) ? 1
                                                                           : 0)
               : !(out[0][i] < missval || missval < out[0][i]))) {
        determine_matrix = 1;
        break;
      }
  }
  for (ilon = 0; ilon < nlon; ilon++) {
    for (ilat = 0; ilat < nlat; ilat++)
      xin[ilat][ilon] = in[0][ilon + ilat * nlon];
    xin[-1][ilon] = xin[nlat][ilon] = missval;
  }
  if (wrap_around)
    for (ilat = -1; ilat <= nlat; ilat++) {
      xin[ilat][-1] = xin[ilat][nlon - 1];
      xin[ilat][nlon] = xin[ilat][0];
    }
  else
    for (ilat = -1; ilat <= nlat; ilat++)
      xin[ilat][-1] = xin[ilat][nlon] = missval;
  if (determine_matrix) {
    for (ilon = 0; ilon < nlon; ilon++) {
      lon1 = lon[ilon];
      lon0 = (lon[ilon - 1] + lon1) / 2;
      lon2 = (lon[ilon + 1] + lon1) / 2;
      dlon0 = lon1 - lon0;
      dlon1 = lon2 - lon1;
      for (ilat = 0; ilat < nlat; ilat++) {
        lat1 = lat[ilat] * 3.14159265358979323846 / 180;
        lat0 = (lat[ilat - 1] * 3.14159265358979323846 / 180 + lat1) / 2;
        lat2 = (lat[ilat + 1] * 3.14159265358979323846 / 180 + lat1) / 2;
        dslat0 = sin(lat1) - sin(lat0);
        dslat1 = sin(lat2) - sin(lat1);
        flat00 = 2 / (lat1 - lat0) * sin((lat1 + lat0) / 2) *
                     sin((lat1 - lat0) / 2) -
                 sin(lat0);
        flat01 = dslat0 - flat00;
        flat10 = 2 / (lat2 - lat1) * sin((lat2 + lat1) / 2) *
                     sin((lat2 - lat1) / 2) -
                 sin(lat1);
        flat11 = dslat1 - flat10;
        flat00 /= 2;
        flat01 /= 2;
        flat10 /= 2;
        flat11 /= 2;
        if ((((xin[ilat][ilon]) != (xin[ilat][ilon])) ||
                     ((missval) != (missval))
                 ? (((xin[ilat][ilon]) != (xin[ilat][ilon])) &&
                            ((missval) != (missval))
                        ? 1
                        : 0)
                 : !(xin[ilat][ilon] < missval || missval < xin[ilat][ilon]))) {
          xwork[4][ilat][ilon] = 1;
          xwork[0][ilat][ilon] = xwork[1][ilat][ilon] = xwork[2][ilat][ilon] =
              xwork[3][ilat][ilon] = xwork[5][ilat][ilon] =
                  xwork[6][ilat][ilon] = xwork[7][ilat][ilon] =
                      xwork[8][ilat][ilon] = 0;
        } else {
          w00 = dslat0 * dlon0;
          w01 = dslat0 * dlon1;
          w10 = dslat1 * dlon0;
          w11 = dslat1 * dlon1;
          wsum = w00 + w01 + w10 + w11;
          a4 = dlon0 * flat01;
          if ((((xin[ilat - 1][ilon]) != (xin[ilat - 1][ilon])) ||
                       ((missval) != (missval))
                   ? (((xin[ilat - 1][ilon]) != (xin[ilat - 1][ilon])) &&
                              ((missval) != (missval))
                          ? 1
                          : 0)
                   : !(xin[ilat - 1][ilon] < missval ||
                       missval < xin[ilat - 1][ilon]))) {
            a1 = 0;
            a4 += dlon0 * flat00;
          } else {
            a1 = dlon0 * flat00 / 2;
            a4 += a1;
          }
          if ((((xin[ilat][ilon - 1]) != (xin[ilat][ilon - 1])) ||
                       ((missval) != (missval))
                   ? (((xin[ilat][ilon - 1]) != (xin[ilat][ilon - 1])) &&
                              ((missval) != (missval))
                          ? 1
                          : 0)
                   : !(xin[ilat][ilon - 1] < missval ||
                       missval < xin[ilat][ilon - 1]))) {
            a3 = 0;
            a4 += dlon0 * flat01;
          } else {
            a3 = dlon0 * flat01 / 2;
            a4 += a3;
          }
          case_table =
              table[(((xin[ilat - 1][ilon - 1]) != (xin[ilat - 1][ilon - 1])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat - 1][ilon - 1]) !=
                             (xin[ilat - 1][ilon - 1])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat - 1][ilon - 1] < missval ||
                             missval < xin[ilat - 1][ilon - 1]))]
                   [(((xin[ilat - 1][ilon]) != (xin[ilat - 1][ilon])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat - 1][ilon]) != (xin[ilat - 1][ilon])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat - 1][ilon] < missval ||
                             missval < xin[ilat - 1][ilon]))]
                   [(((xin[ilat][ilon - 1]) != (xin[ilat][ilon - 1])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat][ilon - 1]) != (xin[ilat][ilon - 1])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat][ilon - 1] < missval ||
                             missval < xin[ilat][ilon - 1]))];
          f = dlon0 * flat00;
          a0 = case_table[0] * f;
          a1 += case_table[1] * f;
          a3 += case_table[2] * f;
          a4 += case_table[3] * f;
          xwork[0][ilat][ilon] = a0;
          xwork[1][ilat][ilon] = a1;
          xwork[3][ilat][ilon] = a3;
          xwork[4][ilat][ilon] = a4;
          a4 = dlon1 * flat01;
          if ((((xin[ilat - 1][ilon]) != (xin[ilat - 1][ilon])) ||
                       ((missval) != (missval))
                   ? (((xin[ilat - 1][ilon]) != (xin[ilat - 1][ilon])) &&
                              ((missval) != (missval))
                          ? 1
                          : 0)
                   : !(xin[ilat - 1][ilon] < missval ||
                       missval < xin[ilat - 1][ilon]))) {
            a1 = 0;
            a4 += dlon1 * flat00;
          } else {
            a1 = dlon1 * flat00 / 2;
            a4 += a1;
          }
          if ((((xin[ilat][ilon + 1]) != (xin[ilat][ilon + 1])) ||
                       ((missval) != (missval))
                   ? (((xin[ilat][ilon + 1]) != (xin[ilat][ilon + 1])) &&
                              ((missval) != (missval))
                          ? 1
                          : 0)
                   : !(xin[ilat][ilon + 1] < missval ||
                       missval < xin[ilat][ilon + 1]))) {
            a5 = 0;
            a4 += dlon1 * flat01;
          } else {
            a5 = dlon1 * flat01 / 2;
            a4 += a5;
          }
          case_table =
              table[(((xin[ilat - 1][ilon + 1]) != (xin[ilat - 1][ilon + 1])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat - 1][ilon + 1]) !=
                             (xin[ilat - 1][ilon + 1])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat - 1][ilon + 1] < missval ||
                             missval < xin[ilat - 1][ilon + 1]))]
                   [(((xin[ilat - 1][ilon]) != (xin[ilat - 1][ilon])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat - 1][ilon]) != (xin[ilat - 1][ilon])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat - 1][ilon] < missval ||
                             missval < xin[ilat - 1][ilon]))]
                   [(((xin[ilat][ilon + 1]) != (xin[ilat][ilon + 1])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat][ilon + 1]) != (xin[ilat][ilon + 1])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat][ilon + 1] < missval ||
                             missval < xin[ilat][ilon + 1]))];
          f = dlon1 * flat00;
          a2 = case_table[0] * f;
          a1 += case_table[1] * f;
          a5 += case_table[2] * f;
          a4 += case_table[3] * f;
          xwork[2][ilat][ilon] += a2;
          xwork[1][ilat][ilon] += a1;
          xwork[5][ilat][ilon] += a5;
          xwork[4][ilat][ilon] += a4;
          a4 = dlon0 * flat10;
          if ((((xin[ilat + 1][ilon]) != (xin[ilat + 1][ilon])) ||
                       ((missval) != (missval))
                   ? (((xin[ilat + 1][ilon]) != (xin[ilat + 1][ilon])) &&
                              ((missval) != (missval))
                          ? 1
                          : 0)
                   : !(xin[ilat + 1][ilon] < missval ||
                       missval < xin[ilat + 1][ilon]))) {
            a7 = 0;
            a4 += dlon0 * flat11;
          } else {
            a7 = dlon0 * flat11 / 2;
            a4 += a7;
          }
          if ((((xin[ilat][ilon - 1]) != (xin[ilat][ilon - 1])) ||
                       ((missval) != (missval))
                   ? (((xin[ilat][ilon - 1]) != (xin[ilat][ilon - 1])) &&
                              ((missval) != (missval))
                          ? 1
                          : 0)
                   : !(xin[ilat][ilon - 1] < missval ||
                       missval < xin[ilat][ilon - 1]))) {
            a3 = 0;
            a4 += dlon0 * flat10;
          } else {
            a3 = dlon0 * flat10 / 2;
            a4 += a3;
          }
          case_table =
              table[(((xin[ilat + 1][ilon - 1]) != (xin[ilat + 1][ilon - 1])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat + 1][ilon - 1]) !=
                             (xin[ilat + 1][ilon - 1])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat + 1][ilon - 1] < missval ||
                             missval < xin[ilat + 1][ilon - 1]))]
                   [(((xin[ilat + 1][ilon]) != (xin[ilat + 1][ilon])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat + 1][ilon]) != (xin[ilat + 1][ilon])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat + 1][ilon] < missval ||
                             missval < xin[ilat + 1][ilon]))]
                   [(((xin[ilat][ilon - 1]) != (xin[ilat][ilon - 1])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat][ilon - 1]) != (xin[ilat][ilon - 1])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat][ilon - 1] < missval ||
                             missval < xin[ilat][ilon - 1]))];
          f = dlon0 * flat11;
          a6 = case_table[0] * f;
          a7 += case_table[1] * f;
          a3 += case_table[2] * f;
          a4 += case_table[3] * f;
          xwork[6][ilat][ilon] += a6;
          xwork[7][ilat][ilon] += a7;
          xwork[3][ilat][ilon] += a3;
          xwork[4][ilat][ilon] += a4;
          a4 = dlon1 * flat10;
          if ((((xin[ilat + 1][ilon]) != (xin[ilat + 1][ilon])) ||
                       ((missval) != (missval))
                   ? (((xin[ilat + 1][ilon]) != (xin[ilat + 1][ilon])) &&
                              ((missval) != (missval))
                          ? 1
                          : 0)
                   : !(xin[ilat + 1][ilon] < missval ||
                       missval < xin[ilat + 1][ilon]))) {
            a7 = 0;
            a4 += dlon1 * flat11;
          } else {
            a7 = dlon1 * flat11 / 2;
            a4 += a7;
          }
          if ((((xin[ilat][ilon + 1]) != (xin[ilat][ilon + 1])) ||
                       ((missval) != (missval))
                   ? (((xin[ilat][ilon + 1]) != (xin[ilat][ilon + 1])) &&
                              ((missval) != (missval))
                          ? 1
                          : 0)
                   : !(xin[ilat][ilon + 1] < missval ||
                       missval < xin[ilat][ilon + 1]))) {
            a5 = 0;
            a4 += dlon1 * flat10;
          } else {
            a5 = dlon1 * flat10 / 2;
            a4 += a5;
          }
          case_table =
              table[(((xin[ilat + 1][ilon + 1]) != (xin[ilat + 1][ilon + 1])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat + 1][ilon + 1]) !=
                             (xin[ilat + 1][ilon + 1])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat + 1][ilon + 1] < missval ||
                             missval < xin[ilat + 1][ilon + 1]))]
                   [(((xin[ilat + 1][ilon]) != (xin[ilat + 1][ilon])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat + 1][ilon]) != (xin[ilat + 1][ilon])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat + 1][ilon] < missval ||
                             missval < xin[ilat + 1][ilon]))]
                   [(((xin[ilat][ilon + 1]) != (xin[ilat][ilon + 1])) ||
                             ((missval) != (missval))
                         ? (((xin[ilat][ilon + 1]) != (xin[ilat][ilon + 1])) &&
                                    ((missval) != (missval))
                                ? 1
                                : 0)
                         : !(xin[ilat][ilon + 1] < missval ||
                             missval < xin[ilat][ilon + 1]))];
          f = dlon1 * flat11;
          a8 = case_table[0] * f;
          a7 += case_table[1] * f;
          a5 += case_table[2] * f;
          a4 += case_table[3] * f;
          xwork[8][ilat][ilon] += a8;
          xwork[7][ilat][ilon] += a7;
          xwork[5][ilat][ilon] += a5;
          xwork[4][ilat][ilon] += a4;
          xwork[0][ilat][ilon] /= wsum;
          xwork[1][ilat][ilon] /= wsum;
          xwork[2][ilat][ilon] /= wsum;
          xwork[3][ilat][ilon] /= wsum;
          xwork[4][ilat][ilon] /= wsum;
          xwork[5][ilat][ilon] /= wsum;
          xwork[6][ilat][ilon] /= wsum;
          xwork[7][ilat][ilon] /= wsum;
          xwork[8][ilat][ilon] /= wsum;
        }
      }
    }
  }
  max = 0;
  for (ilat = 0; ilat < nlat; ilat++)
    for (ilon = 0; ilon < nlon; ilon++) {
      f = xin[ilat][ilon];
      if (!(((f) != (f)) || ((missval) != (missval))
                ? (((f) != (f)) && ((missval) != (missval)) ? 1 : 0)
                : !(f < missval || missval < f)) &&
          f > max)
        max = f;
    }
  r = xwork[9];
  r_bar = xwork[10];
  r_new = xwork[11];
  r_bar_new = xwork[12];
  p = xwork[13];
  p_bar = xwork[14];
  p_new = xwork[15];
  p_bar_new = xwork[16];
  for (ilat = 0; ilat < nlat; ilat++)
    for (ilon = 0; ilon < nlon; ilon++)
      xout[ilat][ilon] = xin[ilat][ilon];
  for (ilat = 0; ilat < nlat; ilat++)
    for (ilon = 0; ilon < nlon; ilon++)
      r[ilat][ilon] = r_bar[ilat][ilon] = p[ilat][ilon] = p_bar[ilat][ilon] =
          xin[ilat][ilon] - (xwork[0][ilat][ilon] * xin[ilat - 1][ilon - 1] +
                             xwork[1][ilat][ilon] * xin[ilat - 1][ilon] +
                             xwork[2][ilat][ilon] * xin[ilat - 1][ilon + 1] +
                             xwork[3][ilat][ilon] * xin[ilat][ilon - 1] +
                             xwork[4][ilat][ilon] * xin[ilat][ilon] +
                             xwork[5][ilat][ilon] * xin[ilat][ilon + 1] +
                             xwork[6][ilat][ilon] * xin[ilat + 1][ilon - 1] +
                             xwork[7][ilat][ilon] * xin[ilat + 1][ilon] +
                             xwork[8][ilat][ilon] * xin[ilat + 1][ilon + 1]);
  for (iter = 1;; iter++) {
    stop_iteration = 1;
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        if (fabs(r[ilat][ilon]) > eps * max) {
          stop_iteration = 0;
          break;
        }
    if (stop_iteration)
      break;
    if (iter == 1) {
      nom = 0;
      for (ilat = 0; ilat < nlat; ilat++)
        for (ilon = 0; ilon < nlon; ilon++)
          nom += r[ilat][ilon] * r_bar[ilat][ilon];
    }
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        r_new[ilat][ilon] = xwork[4][ilat][ilon] * p[ilat][ilon];
    for (ilat = 1; ilat < nlat; ilat++) {
      for (ilon = 1; ilon < nlon; ilon++)
        r_new[ilat][ilon] += xwork[0][ilat][ilon] * p[ilat - 1][ilon - 1];
      r_new[ilat][0] += xwork[0][ilat][0] * p[ilat - 1][nlon - 1];
    }
    for (ilat = 1; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        r_new[ilat][ilon] += xwork[1][ilat][ilon] * p[ilat - 1][ilon];
    for (ilat = 1; ilat < nlat; ilat++) {
      for (ilon = 0; ilon < nlon - 1; ilon++)
        r_new[ilat][ilon] += xwork[2][ilat][ilon] * p[ilat - 1][ilon + 1];
      r_new[ilat][nlon - 1] += xwork[2][ilat][nlon - 1] * p[ilat - 1][0];
    }
    for (ilat = 0; ilat < nlat; ilat++) {
      for (ilon = 1; ilon < nlon; ilon++)
        r_new[ilat][ilon] += xwork[3][ilat][ilon] * p[ilat][ilon - 1];
      r_new[ilat][0] += xwork[3][ilat][0] * p[ilat][nlon - 1];
    }
    for (ilat = 0; ilat < nlat; ilat++) {
      for (ilon = 0; ilon < nlon - 1; ilon++)
        r_new[ilat][ilon] += xwork[5][ilat][ilon] * p[ilat][ilon + 1];
      r_new[ilat][nlon - 1] += xwork[5][ilat][nlon - 1] * p[ilat][0];
    }
    for (ilat = 0; ilat < nlat - 1; ilat++) {
      for (ilon = 1; ilon < nlon; ilon++)
        r_new[ilat][ilon] += xwork[6][ilat][ilon] * p[ilat + 1][ilon - 1];
      r_new[ilat][0] += xwork[6][ilat][0] * p[ilat + 1][nlon - 1];
    }
    for (ilat = 0; ilat < nlat - 1; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        r_new[ilat][ilon] += xwork[7][ilat][ilon] * p[ilat + 1][ilon];
    for (ilat = 0; ilat < nlat - 1; ilat++) {
      for (ilon = 0; ilon < nlon - 1; ilon++)
        r_new[ilat][ilon] += xwork[8][ilat][ilon] * p[ilat + 1][ilon + 1];
      r_new[ilat][nlon - 1] += xwork[8][ilat][nlon - 1] * p[ilat + 1][0];
    }
    denom = 0;
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        denom += p_bar[ilat][ilon] * r_new[ilat][ilon];
    if ((!(denom < 0 || 0 < denom)))
      break;
    a = nom / denom;
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        r_new[ilat][ilon] = r[ilat][ilon] - a * r_new[ilat][ilon];
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        r_bar_new[ilat][ilon] = xwork[4][ilat][ilon] * p_bar[ilat][ilon];
    for (ilat = 1; ilat < nlat; ilat++) {
      for (ilon = 1; ilon < nlon; ilon++)
        r_bar_new[ilat][ilon] +=
            xwork[8][ilat - 1][ilon - 1] * p_bar[ilat - 1][ilon - 1];
      r_bar_new[ilat][0] +=
          xwork[8][ilat - 1][nlon - 1] * p_bar[ilat - 1][nlon - 1];
    }
    for (ilat = 1; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        r_bar_new[ilat][ilon] +=
            xwork[7][ilat - 1][ilon] * p_bar[ilat - 1][ilon];
    for (ilat = 1; ilat < nlat; ilat++) {
      for (ilon = 0; ilon < nlon - 1; ilon++)
        r_bar_new[ilat][ilon] +=
            xwork[6][ilat - 1][ilon + 1] * p_bar[ilat - 1][ilon + 1];
      r_bar_new[ilat][nlon - 1] += xwork[6][ilat - 1][0] * p_bar[ilat - 1][0];
    }
    for (ilat = 0; ilat < nlat; ilat++) {
      for (ilon = 1; ilon < nlon; ilon++)
        r_bar_new[ilat][ilon] +=
            xwork[5][ilat][ilon - 1] * p_bar[ilat][ilon - 1];
      r_bar_new[ilat][0] += xwork[5][ilat][nlon - 1] * p_bar[ilat][nlon - 1];
    }
    for (ilat = 0; ilat < nlat; ilat++) {
      for (ilon = 0; ilon < nlon - 1; ilon++)
        r_bar_new[ilat][ilon] +=
            xwork[3][ilat][ilon + 1] * p_bar[ilat][ilon + 1];
      r_bar_new[ilat][nlon - 1] += xwork[3][ilat][0] * p_bar[ilat][0];
    }
    for (ilat = 0; ilat < nlat - 1; ilat++) {
      for (ilon = 1; ilon < nlon; ilon++)
        r_bar_new[ilat][ilon] +=
            xwork[2][ilat + 1][ilon - 1] * p_bar[ilat + 1][ilon - 1];
      r_bar_new[ilat][0] +=
          xwork[2][ilat + 1][nlon - 1] * p_bar[ilat + 1][nlon - 1];
    }
    for (ilat = 0; ilat < nlat - 1; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        r_bar_new[ilat][ilon] +=
            xwork[1][ilat + 1][ilon] * p_bar[ilat + 1][ilon];
    for (ilat = 0; ilat < nlat - 1; ilat++) {
      for (ilon = 0; ilon < nlon - 1; ilon++)
        r_bar_new[ilat][ilon] +=
            xwork[0][ilat + 1][ilon + 1] * p_bar[ilat + 1][ilon + 1];
      r_bar_new[ilat][nlon - 1] += xwork[0][ilat + 1][0] * p_bar[ilat + 1][0];
    }
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        r_bar_new[ilat][ilon] = r_bar[ilat][ilon] - a * r_bar_new[ilat][ilon];
    denom = nom;
    nom = 0;
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        nom += r_bar_new[ilat][ilon] * r_new[ilat][ilon];
    if ((!(denom < 0 || 0 < denom)))
      break;
    b = nom / denom;
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++) {
        p_new[ilat][ilon] = r_new[ilat][ilon] + b * p[ilat][ilon];
        p_bar_new[ilat][ilon] = r_bar_new[ilat][ilon] + b * p_bar[ilat][ilon];
      }
    for (ilat = 0; ilat < nlat; ilat++)
      for (ilon = 0; ilon < nlon; ilon++)
        if (!(((xout[ilat][ilon]) != (xout[ilat][ilon])) ||
                      ((missval) != (missval))
                  ? (((xout[ilat][ilon]) != (xout[ilat][ilon])) &&
                             ((missval) != (missval))
                         ? 1
                         : 0)
                  : !(xout[ilat][ilon] < missval ||
                      missval < xout[ilat][ilon])))
          xout[ilat][ilon] += a * p[ilat][ilon];
    swap = r_new;
    r_new = r;
    r = swap;
    swap = r_bar_new;
    r_bar_new = r_bar;
    r_bar = swap;
    swap = p_new;
    p_new = p;
    p = swap;
    swap = p_bar_new;
    p_bar_new = p_bar;
    p_bar = swap;
  }
  iter_sum = iter_sum * 0.9 + iter;
  iter_n = iter_n * 0.9 + 1;
  Free(__func__,
       "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
       "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/interpol.c",
       2020, (xin_array));
  Free(__func__,
       "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
       "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/interpol.c",
       2021, (xin));
  Free(__func__,
       "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
       "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/interpol.c",
       2022, (xout));
  for (j = 0; j < 17; j++)
    Free(__func__,
         "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/"
         "2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/interpol.c",
         2024, (xwork[j]));
}


x86 assembly (clang, -O0):
<contrast>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
movl   $0x1,-0x4(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    147e <contrast+0x34e>
mov    -0x8(%rbp),%eax
add    $0x2,%eax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
movslq %eax,%rcx
shl    $0x3,%rcx
lea    0x5eaa(%rip),%rdi
lea    0x5eac(%rip),%rsi
mov    $0x604,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,0x7f86(%rip)
mov    -0x8(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
shl    $0x3,%rcx
lea    0x5e7a(%rip),%rdi
lea    0x5e7c(%rip),%rsi
mov    $0x605,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,0x7f5e(%rip)
mov    0x7f57(%rip),%rax
mov    0x8(%rax),%rcx
mov    0x7f4c(%rip),%rax
mov    %rcx,(%rax)
movq   $0xffffffffffffffff,0x810e(%rip)
ff ff ff ff
mov    0x8107(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jg     1281 <contrast+0x151>
mov    0x7f1b(%rip),%rdx
mov    0x80ec(%rip),%rax
add    $0x1,%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
imul   %rcx,%rax
shl    $0x3,%rax
add    %rax,%rdx
add    $0x8,%rdx
mov    0x7ef9(%rip),%rax
mov    0x80c2(%rip),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x80b7(%rip),%rax
add    $0x1,%rax
mov    %rax,0x80ac(%rip)
jmp    121a <contrast+0xea>
movslq -0x8(%rbp),%rcx
shl    $0x3,%rcx
lea    0x5dc8(%rip),%rdi
lea    0x5dca(%rip),%rsi
mov    $0x609,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
cltq
mov    %rax,0x7eb4(%rip)
movq   $0x0,0x8071(%rip)
mov    0x806a(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    1311 <contrast+0x1e1>
mov    -0x38(%rbp),%rax
mov    (%rax),%rdx
mov    0x804f(%rip),%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
shl    $0x3,%rax
add    %rax,%rdx
mov    0x7e71(%rip),%rax
mov    0x8032(%rip),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x8027(%rip),%rax
add    $0x1,%rax
mov    %rax,0x801c(%rip)
jmp    12b7 <contrast+0x187>
movl   $0x0,-0x14(%rbp)
cmpl   $0x11,-0x14(%rbp)
jge    13db <contrast+0x2ab>
movslq -0x8(%rbp),%rcx
shl    $0x3,%rcx
lea    0x5d27(%rip),%rdi
lea    0x5d29(%rip),%rsi
mov    $0x60e,%edx
mov    $0x0,%al
call   1030 <Malloc@plt>
movslq %eax,%rdx
movslq -0x14(%rbp),%rcx
lea    0x7e1e(%rip),%rax
mov    %rdx,(%rax,%rcx,8)
movq   $0x0,0x7fc7(%rip)
mov    0x7fc0(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    13c8 <contrast+0x298>
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    0x7fa0(%rip),%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
shl    $0x3,%rax
add    %rax,%rdx
movslq -0x14(%rbp),%rcx
lea    0x7dce(%rip),%rax
mov    (%rax,%rcx,8),%rax
mov    0x7f7b(%rip),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x7f70(%rip),%rax
add    $0x1,%rax
mov    %rax,0x7f65(%rip)
jmp    1361 <contrast+0x231>
jmp    13cd <contrast+0x29d>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1318 <contrast+0x1e8>
xor    %eax,%eax
cmpl   $0x1,-0xc(%rbp)
mov    %al,-0x49(%rbp)
jle    1461 <contrast+0x331>
mov    -0x40(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movsd  0x5c00(%rip),%xmm1
addsd  -0x8(%rax),%xmm1
movsd  0x5beb(%rip),%xmm2
subsd  %xmm2,%xmm1
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x4a(%rbp)
jae    145b <contrast+0x32b>
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movsd  0x5bc7(%rip),%xmm1
addsd  (%rax),%xmm1
movsd  0x5bb3(%rip),%xmm2
subsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
setae  %al
mov    %al,-0x4a(%rbp)
mov    -0x4a(%rbp),%al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,0x7ec5(%rip)
movl   $0x1,0x7eb7(%rip)
jmp    16ca <contrast+0x59a>
movl   $0x0,0x7ea8(%rip)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16c5 <contrast+0x595>
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    14e2 <contrast+0x3b2>
jp     14e2 <contrast+0x3b2>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    14e2 <contrast+0x3b2>
jp     14e2 <contrast+0x3b2>
jmp    1545 <contrast+0x415>
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    (%rax),%rcx
movslq -0x10(%rbp),%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0x4b(%rbp)
jne    1518 <contrast+0x3e8>
jp     1518 <contrast+0x3e8>
jmp    152d <contrast+0x3fd>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x4b(%rbp)
mov    -0x4b(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x50(%rbp)
jmp    1595 <contrast+0x465>
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x51(%rbp)
ja     1588 <contrast+0x458>
movsd  -0x20(%rbp),%xmm1
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    15e2 <contrast+0x4b2>
jp     15e2 <contrast+0x4b2>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    15e2 <contrast+0x4b2>
jp     15e2 <contrast+0x4b2>
jmp    1645 <contrast+0x515>
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    (%rax),%rcx
movslq -0x10(%rbp),%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0x59(%rbp)
jne    1618 <contrast+0x4e8>
jp     1618 <contrast+0x4e8>
jmp    162d <contrast+0x4fd>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x60(%rbp)
jmp    1695 <contrast+0x565>
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x61(%rbp)
ja     1688 <contrast+0x558>
movsd  -0x20(%rbp),%xmm1
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x60(%rbp),%ecx
cmp    %ecx,%eax
je     16b2 <contrast+0x582>
movl   $0x1,0x7c83(%rip)
jmp    16c5 <contrast+0x595>
jmp    16b7 <contrast+0x587>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    148f <contrast+0x35f>
jmp    16ca <contrast+0x59a>
movq   $0x0,0x7c4b(%rip)
mov    0x7c44(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    17b0 <contrast+0x680>
movq   $0x0,0x7c34(%rip)
mov    0x7c2d(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    1762 <contrast+0x632>
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    0x7c0a(%rip),%rcx
mov    0x7c0b(%rip),%rdx
movslq -0xc(%rbp),%rsi
imul   %rsi,%rdx
add    %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x7a24(%rip),%rax
mov    0x7bed(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7bda(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x7bd6(%rip),%rax
add    $0x1,%rax
mov    %rax,0x7bcb(%rip)
jmp    16f4 <contrast+0x5c4>
movsd  -0x20(%rbp),%xmm0
mov    0x79ea(%rip),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7ba3(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x79cf(%rip),%rax
mov    -0x8(%rax),%rax
mov    0x7b8c(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x7b80(%rip),%rax
add    $0x1,%rax
mov    %rax,0x7b75(%rip)
jmp    16d5 <contrast+0x5a5>
cmpl   $0x0,0x7b7d(%rip)
je     1860 <contrast+0x730>
movq   $0xffffffffffffffff,0x7b60(%rip)
ff ff ff ff
mov    0x7b59(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jg     185b <contrast+0x72b>
mov    0x7975(%rip),%rax
mov    0x7b3e(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x7955(%rip),%rax
mov    0x7b1e(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,-0x8(%rax)
mov    0x793e(%rip),%rax
mov    0x7b07(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x7928(%rip),%rax
mov    0x7af1(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x7add(%rip),%rax
add    $0x1,%rax
mov    %rax,0x7ad2(%rip)
jmp    17c8 <contrast+0x698>
jmp    18d2 <contrast+0x7a2>
movq   $0xffffffffffffffff,0x7abd(%rip)
ff ff ff ff
mov    0x7ab6(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jg     18cd <contrast+0x79d>
movsd  -0x20(%rbp),%xmm0
mov    0x78cd(%rip),%rax
mov    0x7a96(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x78b2(%rip),%rax
mov    0x7a7b(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,-0x8(%rax)
mov    0x7a6b(%rip),%rax
add    $0x1,%rax
mov    %rax,0x7a60(%rip)
jmp    186b <contrast+0x73b>
jmp    18d2 <contrast+0x7a2>
cmpl   $0x0,0x7a57(%rip)
je     4915 <contrast+0x37e5>
movq   $0x0,0x7a36(%rip)
mov    0x7a2f(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    4910 <contrast+0x37e0>
mov    -0x40(%rbp),%rax
mov    0x7a17(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x79c2(%rip)
mov    -0x40(%rbp),%rax
mov    0x79ff(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  0x79a6(%rip),%xmm0
movsd  0x56ee(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x798a(%rip)
mov    -0x40(%rbp),%rax
mov    0x79cf(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
addsd  0x7979(%rip),%xmm0
movsd  0x56c1(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x796d(%rip)
movsd  0x795d(%rip),%xmm0
subsd  0x794d(%rip),%xmm0
movsd  %xmm0,0x78fd(%rip)
movsd  0x794d(%rip),%xmm0
subsd  0x793d(%rip),%xmm0
movsd  %xmm0,0x78ed(%rip)
movq   $0x0,0x797a(%rip)
mov    0x7973(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    48f4 <contrast+0x37c4>
mov    -0x48(%rbp),%rax
mov    0x795b(%rip),%rcx
movsd  0x5663(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x564e(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x7902(%rip)
mov    -0x48(%rbp),%rax
mov    0x792f(%rip),%rcx
sub    $0x1,%rcx
movsd  0x5633(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x561e(%rip),%xmm1
divsd  %xmm1,%xmm0
addsd  0x78d2(%rip),%xmm0
movsd  0x5602(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x78b6(%rip)
mov    -0x48(%rbp),%rax
mov    0x78eb(%rip),%rcx
movsd  0x55f3(%rip),%xmm0
mulsd  0x8(%rax,%rcx,8),%xmm0
movsd  0x55dd(%rip),%xmm1
divsd  %xmm1,%xmm0
addsd  0x7891(%rip),%xmm0
movsd  0x55c1(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x7885(%rip)
movsd  0x7875(%rip),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x7858(%rip),%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,0x77ec(%rip)
movsd  0x7844(%rip),%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x7827(%rip),%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,0x77bb(%rip)
movsd  0x7803(%rip),%xmm1
subsd  0x77f3(%rip),%xmm1
movsd  0x552b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x77df(%rip),%xmm0
addsd  0x77cf(%rip),%xmm0
movsd  0x5507(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x77a7(%rip),%xmm0
subsd  0x7797(%rip),%xmm0
movsd  0x54cf(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x7776(%rip),%xmm0
call   1040 <sin@plt>
movsd  -0x90(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x774f(%rip)
movsd  0x76df(%rip),%xmm0
subsd  0x773f(%rip),%xmm0
movsd  %xmm0,0x773f(%rip)
movsd  0x7727(%rip),%xmm1
subsd  0x7717(%rip),%xmm1
movsd  0x5447(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0x7706(%rip),%xmm0
addsd  0x76f6(%rip),%xmm0
movsd  0x5426(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1040 <sin@plt>
movaps %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x76d4(%rip),%xmm0
subsd  0x76c4(%rip),%xmm0
movsd  0x53f4(%rip),%xmm1
divsd  %xmm1,%xmm0
call   1040 <sin@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  0x76a6(%rip),%xmm0
call   1040 <sin@plt>
movsd  -0x78(%rbp),%xmm2
movaps %xmm0,%xmm1
movsd  -0x70(%rbp),%xmm0
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x768d(%rip)
movsd  0x7615(%rip),%xmm0
subsd  0x767d(%rip),%xmm0
movsd  %xmm0,0x767d(%rip)
movsd  0x765d(%rip),%xmm0
movsd  0x537d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x7649(%rip)
movsd  0x7649(%rip),%xmm0
movsd  0x5361(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x7635(%rip)
movsd  0x7635(%rip),%xmm0
movsd  0x5345(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x7621(%rip)
movsd  0x7621(%rip),%xmm0
movsd  0x5329(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x760d(%rip)
mov    0x7446(%rip),%rax
mov    0x760f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x75fc(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x7428(%rip),%rax
mov    0x75f1(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x75de(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1d6e <contrast+0xc3e>
jp     1d6e <contrast+0xc3e>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    1d6e <contrast+0xc3e>
jp     1d6e <contrast+0xc3e>
jmp    1df4 <contrast+0xcc4>
mov    0x73e3(%rip),%rax
mov    0x75ac(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7599(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x73c5(%rip),%rax
mov    0x758e(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x757b(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    1dbb <contrast+0xc8b>
jp     1dbb <contrast+0xc8b>
jmp    1de5 <contrast+0xcb5>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    1dd6 <contrast+0xca6>
jp     1dd6 <contrast+0xca6>
jmp    1de5 <contrast+0xcb5>
mov    $0x1,%al
test   $0x1,%al
jne    1e4e <contrast+0xd1e>
jmp    1f81 <contrast+0xe51>
xor    %eax,%eax
test   $0x1,%al
jne    1e4e <contrast+0xd1e>
jmp    1f81 <contrast+0xe51>
mov    0x735d(%rip),%rax
mov    0x7526(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7513(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     1f81 <contrast+0xe51>
movsd  -0x20(%rbp),%xmm1
mov    0x732b(%rip),%rax
mov    0x74f4(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x74e1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
ja     1f81 <contrast+0xe51>
mov    0x733b(%rip),%rax
mov    0x74cc(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x74b9(%rip),%rcx
movsd  0x51a9(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x7335(%rip),%rax
mov    0x74a6(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7493(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x730c(%rip),%rax
mov    0x7485(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7472(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x72e3(%rip),%rax
mov    0x7464(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7451(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x72ba(%rip),%rax
mov    0x7443(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7430(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x7289(%rip),%rax
mov    0x7422(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x740f(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x7260(%rip),%rax
mov    0x7401(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x73ee(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x7237(%rip),%rax
mov    0x73e0(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x73cd(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x720e(%rip),%rax
mov    0x73bf(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x73ac(%rip),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    48d8 <contrast+0x37a8>
movsd  0x730f(%rip),%xmm0
mulsd  0x72f7(%rip),%xmm0
movsd  %xmm0,0x730f(%rip)
movsd  0x72f7(%rip),%xmm0
mulsd  0x72e7(%rip),%xmm0
movsd  %xmm0,0x72ff(%rip)
movsd  0x72e7(%rip),%xmm0
mulsd  0x72c7(%rip),%xmm0
movsd  %xmm0,0x72ef(%rip)
movsd  0x72cf(%rip),%xmm0
mulsd  0x72b7(%rip),%xmm0
movsd  %xmm0,0x72df(%rip)
movsd  0x72bf(%rip),%xmm0
addsd  0x72bf(%rip),%xmm0
addsd  0x72bf(%rip),%xmm0
addsd  0x72bf(%rip),%xmm0
movsd  %xmm0,0x72bf(%rip)
movsd  0x7277(%rip),%xmm0
mulsd  0x72ef(%rip),%xmm0
movsd  %xmm0,0x723f(%rip)
mov    0x7130(%rip),%rax
mov    0x72f9(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x72e2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x710e(%rip),%rax
mov    0x72d7(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x72c0(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    208c <contrast+0xf5c>
jp     208c <contrast+0xf5c>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    208c <contrast+0xf5c>
jp     208c <contrast+0xf5c>
jmp    211a <contrast+0xfea>
mov    0x70c5(%rip),%rax
mov    0x728e(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7277(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70a3(%rip),%rax
mov    0x726c(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7255(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    20e1 <contrast+0xfb1>
jp     20e1 <contrast+0xfb1>
jmp    210b <contrast+0xfdb>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    20fc <contrast+0xfcc>
jp     20fc <contrast+0xfcc>
jmp    210b <contrast+0xfdb>
mov    $0x1,%al
test   $0x1,%al
jne    217c <contrast+0x104c>
jmp    21b4 <contrast+0x1084>
xor    %eax,%eax
test   $0x1,%al
jne    217c <contrast+0x104c>
jmp    21b4 <contrast+0x1084>
mov    0x7037(%rip),%rax
mov    0x7200(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x71e9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     21b4 <contrast+0x1084>
movsd  -0x20(%rbp),%xmm1
mov    0x7001(%rip),%rax
mov    0x71ca(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x71b3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
ja     21b4 <contrast+0x1084>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x70c1(%rip)
movsd  0x70f9(%rip),%xmm0
movsd  0x7169(%rip),%xmm2
movsd  0x70c1(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x70b1(%rip)
jmp    21f0 <contrast+0x10c0>
movsd  0x70cc(%rip),%xmm0
mulsd  0x713c(%rip),%xmm0
movsd  0x4e5c(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x7070(%rip)
movsd  0x7068(%rip),%xmm0
addsd  0x7078(%rip),%xmm0
movsd  %xmm0,0x7070(%rip)
mov    0x6f61(%rip),%rax
mov    0x712a(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x7117(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x6f3f(%rip),%rax
mov    0x7108(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x70f5(%rip),%rcx
sub    $0x1,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    225b <contrast+0x112b>
jp     225b <contrast+0x112b>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    225b <contrast+0x112b>
jp     225b <contrast+0x112b>
jmp    22e9 <contrast+0x11b9>
mov    0x6ef6(%rip),%rax
mov    0x70bf(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x70ac(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x6ed4(%rip),%rax
mov    0x709d(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x708a(%rip),%rcx
sub    $0x1,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    22b0 <contrast+0x1180>
jp     22b0 <contrast+0x1180>
jmp    22da <contrast+0x11aa>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    22cb <contrast+0x119b>
jp     22cb <contrast+0x119b>
jmp    22da <contrast+0x11aa>
mov    $0x1,%al
test   $0x1,%al
jne    234b <contrast+0x121b>
jmp    2383 <contrast+0x1253>
xor    %eax,%eax
test   $0x1,%al
jne    234b <contrast+0x121b>
jmp    2383 <contrast+0x1253>
mov    0x6e68(%rip),%rax
mov    0x7031(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x701e(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     2383 <contrast+0x1253>
movsd  -0x20(%rbp),%xmm1
mov    0x6e32(%rip),%rax
mov    0x6ffb(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6fe8(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
ja     2383 <contrast+0x1253>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x6f02(%rip)
movsd  0x6f2a(%rip),%xmm0
movsd  0x6fa2(%rip),%xmm2
movsd  0x6ef2(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x6ee2(%rip)
jmp    23bf <contrast+0x128f>
movsd  0x6efd(%rip),%xmm0
mulsd  0x6f75(%rip),%xmm0
movsd  0x4c8d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x6eb1(%rip)
movsd  0x6ea9(%rip),%xmm0
addsd  0x6ea9(%rip),%xmm0
movsd  %xmm0,0x6ea1(%rip)
mov    0x6d92(%rip),%rax
mov    0x6f5b(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6f44(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x6d6c(%rip),%rax
mov    0x6f35(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6f1e(%rip),%rcx
sub    $0x1,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    2432 <contrast+0x1302>
jp     2432 <contrast+0x1302>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    2432 <contrast+0x1302>
jp     2432 <contrast+0x1302>
jmp    24cd <contrast+0x139d>
mov    0x6d1f(%rip),%rax
mov    0x6ee8(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6ed1(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x6cf9(%rip),%rax
mov    0x6ec2(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x6eab(%rip),%rdx
sub    $0x1,%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0xa9(%rbp)
jne    2497 <contrast+0x1367>
jp     2497 <contrast+0x1367>
jmp    24af <contrast+0x137f>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0xa9(%rbp)
mov    -0xa9(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0xb0(%rbp)
jmp    2555 <contrast+0x1425>
mov    0x6c84(%rip),%rax
mov    0x6e4d(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6e36(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0xb1(%rbp)
ja     2542 <contrast+0x1412>
movsd  -0x20(%rbp),%xmm1
mov    0x6c42(%rip),%rax
mov    0x6e0b(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6df4(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xb0(%rbp)
mov    -0xb0(%rbp),%eax
movslq %eax,%rcx
lea    0x6adb(%rip),%rax
shl    $0x7,%rcx
add    %rcx,%rax
mov    %rax,-0xc0(%rbp)
mov    0x6bde(%rip),%rax
mov    0x6da7(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6d90(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x6bbc(%rip),%rax
mov    0x6d85(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6d6e(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    25de <contrast+0x14ae>
jp     25de <contrast+0x14ae>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    25de <contrast+0x14ae>
jp     25de <contrast+0x14ae>
jmp    2671 <contrast+0x1541>
mov    0x6b73(%rip),%rax
mov    0x6d3c(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6d25(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x6b51(%rip),%rax
mov    0x6d1a(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x6d03(%rip),%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0xc1(%rbp)
jne    263b <contrast+0x150b>
jp     263b <contrast+0x150b>
jmp    2653 <contrast+0x1523>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0xc1(%rbp)
mov    -0xc1(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0xc8(%rbp)
jmp    26f1 <contrast+0x15c1>
mov    0x6ae0(%rip),%rax
mov    0x6ca9(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6c92(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0xc9(%rbp)
ja     26de <contrast+0x15ae>
movsd  -0x20(%rbp),%xmm1
mov    0x6aa2(%rip),%rax
mov    0x6c6b(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6c54(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xc9(%rbp)
mov    -0xc9(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x6,%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    0x6a42(%rip),%rax
mov    0x6c0b(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6bf8(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x6a20(%rip),%rax
mov    0x6be9(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6bd6(%rip),%rcx
sub    $0x1,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    277a <contrast+0x164a>
jp     277a <contrast+0x164a>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    277a <contrast+0x164a>
jp     277a <contrast+0x164a>
jmp    280d <contrast+0x16dd>
mov    0x69d7(%rip),%rax
mov    0x6ba0(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6b8d(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x69b5(%rip),%rax
mov    0x6b7e(%rip),%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x6b6b(%rip),%rdx
sub    $0x1,%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0xd9(%rbp)
jne    27d7 <contrast+0x16a7>
jp     27d7 <contrast+0x16a7>
jmp    27ef <contrast+0x16bf>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0xd9(%rbp)
mov    -0xd9(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0xe0(%rbp)
jmp    288d <contrast+0x175d>
mov    0x6944(%rip),%rax
mov    0x6b0d(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6afa(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0xe1(%rbp)
ja     287a <contrast+0x174a>
movsd  -0x20(%rbp),%xmm1
mov    0x6906(%rip),%rax
mov    0x6acf(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6abc(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xe1(%rbp)
mov    -0xe1(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xe0(%rbp)
mov    -0xd8(%rbp),%rax
mov    -0xe0(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x5,%rcx
add    %rcx,%rax
mov    %rax,0x6a95(%rip)
movsd  0x69d5(%rip),%xmm0
mulsd  0x6a45(%rip),%xmm0
movsd  %xmm0,0x6a85(%rip)
mov    0x6a76(%rip),%rax
movsd  (%rax),%xmm0
mulsd  0x6a72(%rip),%xmm0
movsd  %xmm0,0x6962(%rip)
mov    0x6a5b(%rip),%rax
movsd  0x8(%rax),%xmm0
movsd  0x6a56(%rip),%xmm2
movsd  0x694e(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x693e(%rip)
mov    0x6a2f(%rip),%rax
movsd  0x10(%rax),%xmm0
movsd  0x6a2a(%rip),%xmm2
movsd  0x6932(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x6922(%rip)
mov    0x6a03(%rip),%rax
movsd  0x18(%rax),%xmm0
movsd  0x69fe(%rip),%xmm2
movsd  0x690e(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x68fe(%rip)
movsd  0x68d6(%rip),%xmm0
mov    0x67ff(%rip),%rax
mov    0x69b0(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x699d(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x68b8(%rip),%xmm0
mov    0x67e1(%rip),%rax
mov    0x698a(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6977(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x68a2(%rip),%xmm0
mov    0x67cb(%rip),%rax
mov    0x6964(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6951(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x6884(%rip),%xmm0
mov    0x67ad(%rip),%rax
mov    0x693e(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x692b(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x688e(%rip),%xmm0
mulsd  0x68fe(%rip),%xmm0
movsd  %xmm0,0x684e(%rip)
mov    0x673f(%rip),%rax
mov    0x6908(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x68f1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x671d(%rip),%rax
mov    0x68e6(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x68cf(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    2a7d <contrast+0x194d>
jp     2a7d <contrast+0x194d>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    2a7d <contrast+0x194d>
jp     2a7d <contrast+0x194d>
jmp    2b0b <contrast+0x19db>
mov    0x66d4(%rip),%rax
mov    0x689d(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6886(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x66b2(%rip),%rax
mov    0x687b(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6864(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    2ad2 <contrast+0x19a2>
jp     2ad2 <contrast+0x19a2>
jmp    2afc <contrast+0x19cc>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    2aed <contrast+0x19bd>
jp     2aed <contrast+0x19bd>
jmp    2afc <contrast+0x19cc>
mov    $0x1,%al
test   $0x1,%al
jne    2b6d <contrast+0x1a3d>
jmp    2ba5 <contrast+0x1a75>
xor    %eax,%eax
test   $0x1,%al
jne    2b6d <contrast+0x1a3d>
jmp    2ba5 <contrast+0x1a75>
mov    0x6646(%rip),%rax
mov    0x680f(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x67f8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     2ba5 <contrast+0x1a75>
movsd  -0x20(%rbp),%xmm1
mov    0x6610(%rip),%rax
mov    0x67d9(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x67c2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
ja     2ba5 <contrast+0x1a75>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x66d0(%rip)
movsd  0x6710(%rip),%xmm0
movsd  0x6778(%rip),%xmm2
movsd  0x66d0(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x66c0(%rip)
jmp    2be1 <contrast+0x1ab1>
movsd  0x66e3(%rip),%xmm0
mulsd  0x674b(%rip),%xmm0
movsd  0x446b(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x667f(%rip)
movsd  0x6677(%rip),%xmm0
addsd  0x6687(%rip),%xmm0
movsd  %xmm0,0x667f(%rip)
mov    0x6570(%rip),%rax
mov    0x6739(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6726(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x6551(%rip),%rax
mov    0x671a(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6707(%rip),%rcx
ucomisd 0x8(%rax,%rcx,8),%xmm0
jne    2c46 <contrast+0x1b16>
jp     2c46 <contrast+0x1b16>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    2c46 <contrast+0x1b16>
jp     2c46 <contrast+0x1b16>
jmp    2cce <contrast+0x1b9e>
mov    0x650b(%rip),%rax
mov    0x66d4(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x66c1(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x64ec(%rip),%rax
mov    0x66b5(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x66a2(%rip),%rcx
ucomisd 0x8(%rax,%rcx,8),%xmm0
jne    2c95 <contrast+0x1b65>
jp     2c95 <contrast+0x1b65>
jmp    2cbf <contrast+0x1b8f>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    2cb0 <contrast+0x1b80>
jp     2cb0 <contrast+0x1b80>
jmp    2cbf <contrast+0x1b8f>
mov    $0x1,%al
test   $0x1,%al
jne    2d2a <contrast+0x1bfa>
jmp    2d62 <contrast+0x1c32>
xor    %eax,%eax
test   $0x1,%al
jne    2d2a <contrast+0x1bfa>
jmp    2d62 <contrast+0x1c32>
mov    0x6483(%rip),%rax
mov    0x664c(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6639(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     2d62 <contrast+0x1c32>
movsd  -0x20(%rbp),%xmm1
mov    0x6450(%rip),%rax
mov    0x6619(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6606(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
ja     2d62 <contrast+0x1c32>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x6533(%rip)
movsd  0x6553(%rip),%xmm0
movsd  0x65c3(%rip),%xmm2
movsd  0x6513(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x6503(%rip)
jmp    2d9e <contrast+0x1c6e>
movsd  0x6526(%rip),%xmm0
mulsd  0x6596(%rip),%xmm0
movsd  0x42ae(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x64e2(%rip)
movsd  0x64da(%rip),%xmm0
addsd  0x64ca(%rip),%xmm0
movsd  %xmm0,0x64c2(%rip)
mov    0x63b3(%rip),%rax
mov    0x657c(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6565(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x6390(%rip),%rax
mov    0x6559(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6542(%rip),%rcx
ucomisd 0x8(%rax,%rcx,8),%xmm0
jne    2e0b <contrast+0x1cdb>
jp     2e0b <contrast+0x1cdb>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    2e0b <contrast+0x1cdb>
jp     2e0b <contrast+0x1cdb>
jmp    2ea0 <contrast+0x1d70>
mov    0x6346(%rip),%rax
mov    0x650f(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x64f8(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x6323(%rip),%rax
mov    0x64ec(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x64d5(%rip),%rdx
xor    %eax,%eax
ucomisd 0x8(%rcx,%rdx,8),%xmm0
mov    %al,-0xe2(%rbp)
jne    2e6a <contrast+0x1d3a>
jp     2e6a <contrast+0x1d3a>
jmp    2e82 <contrast+0x1d52>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0xe2(%rbp)
mov    -0xe2(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0xe8(%rbp)
jmp    2f22 <contrast+0x1df2>
mov    0x62b1(%rip),%rax
mov    0x647a(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6463(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0xe9(%rbp)
ja     2f0f <contrast+0x1ddf>
movsd  -0x20(%rbp),%xmm1
mov    0x6272(%rip),%rax
mov    0x643b(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6424(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xe9(%rbp)
mov    -0xe9(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
movslq %eax,%rcx
lea    0x610e(%rip),%rax
shl    $0x7,%rcx
add    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    0x6211(%rip),%rax
mov    0x63da(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x63c3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x61ef(%rip),%rax
mov    0x63b8(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x63a1(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    2fab <contrast+0x1e7b>
jp     2fab <contrast+0x1e7b>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    2fab <contrast+0x1e7b>
jp     2fab <contrast+0x1e7b>
jmp    303e <contrast+0x1f0e>
mov    0x61a6(%rip),%rax
mov    0x636f(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6358(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x6184(%rip),%rax
mov    0x634d(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x6336(%rip),%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0xf9(%rbp)
jne    3008 <contrast+0x1ed8>
jp     3008 <contrast+0x1ed8>
jmp    3020 <contrast+0x1ef0>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0xf9(%rbp)
mov    -0xf9(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x100(%rbp)
jmp    30be <contrast+0x1f8e>
mov    0x6113(%rip),%rax
mov    0x62dc(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x62c5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x101(%rbp)
ja     30ab <contrast+0x1f7b>
movsd  -0x20(%rbp),%xmm1
mov    0x60d5(%rip),%rax
mov    0x629e(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6287(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x101(%rbp)
mov    -0x101(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x100(%rbp)
mov    -0xf8(%rbp),%rax
mov    -0x100(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x6,%rcx
add    %rcx,%rax
mov    %rax,-0x110(%rbp)
mov    0x6075(%rip),%rax
mov    0x623e(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x622b(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x6056(%rip),%rax
mov    0x621f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x620c(%rip),%rcx
ucomisd 0x8(%rax,%rcx,8),%xmm0
jne    3141 <contrast+0x2011>
jp     3141 <contrast+0x2011>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    3141 <contrast+0x2011>
jp     3141 <contrast+0x2011>
jmp    31ce <contrast+0x209e>
mov    0x6010(%rip),%rax
mov    0x61d9(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x61c6(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x5ff1(%rip),%rax
mov    0x61ba(%rip),%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x61a7(%rip),%rdx
xor    %eax,%eax
ucomisd 0x8(%rcx,%rdx,8),%xmm0
mov    %al,-0x111(%rbp)
jne    3198 <contrast+0x2068>
jp     3198 <contrast+0x2068>
jmp    31b0 <contrast+0x2080>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x111(%rbp)
mov    -0x111(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x118(%rbp)
jmp    3248 <contrast+0x2118>
mov    0x5f83(%rip),%rax
mov    0x614c(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x6139(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x119(%rbp)
ja     3235 <contrast+0x2105>
movsd  -0x20(%rbp),%xmm1
mov    0x5f48(%rip),%rax
mov    0x6111(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x60fe(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x119(%rbp)
mov    -0x119(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x118(%rbp)
mov    -0x110(%rbp),%rax
mov    -0x118(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x5,%rcx
add    %rcx,%rax
mov    %rax,0x60da(%rip)
movsd  0x6022(%rip),%xmm0
mulsd  0x608a(%rip),%xmm0
movsd  %xmm0,0x60ca(%rip)
mov    0x60bb(%rip),%rax
movsd  (%rax),%xmm0
mulsd  0x60b7(%rip),%xmm0
movsd  %xmm0,0x5fb7(%rip)
mov    0x60a0(%rip),%rax
movsd  0x8(%rax),%xmm0
movsd  0x609b(%rip),%xmm2
movsd  0x5f93(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5f83(%rip)
mov    0x6074(%rip),%rax
movsd  0x10(%rax),%xmm0
movsd  0x606f(%rip),%xmm2
movsd  0x5f87(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5f77(%rip)
mov    0x6048(%rip),%rax
movsd  0x18(%rax),%xmm0
movsd  0x6043(%rip),%xmm2
movsd  0x5f53(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5f43(%rip)
movsd  0x5f2b(%rip),%xmm0
mov    0x5e54(%rip),%rax
mov    0x5ff5(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5fe2(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5ef8(%rip),%xmm0
mov    0x5e21(%rip),%rax
mov    0x5fca(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5fb7(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5eed(%rip),%xmm0
mov    0x5e16(%rip),%rax
mov    0x5f9f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5f8c(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5eba(%rip),%xmm0
mov    0x5de3(%rip),%rax
mov    0x5f74(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5f61(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5eb7(%rip),%xmm0
mulsd  0x5f37(%rip),%xmm0
movsd  %xmm0,0x5e7f(%rip)
mov    0x5d70(%rip),%rax
mov    0x5f39(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5f25(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x5d51(%rip),%rax
mov    0x5f1a(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5f06(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    3446 <contrast+0x2316>
jp     3446 <contrast+0x2316>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    3446 <contrast+0x2316>
jp     3446 <contrast+0x2316>
jmp    34ce <contrast+0x239e>
mov    0x5d0b(%rip),%rax
mov    0x5ed4(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5ec0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x5cec(%rip),%rax
mov    0x5eb5(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5ea1(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    3495 <contrast+0x2365>
jp     3495 <contrast+0x2365>
jmp    34bf <contrast+0x238f>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    34b0 <contrast+0x2380>
jp     34b0 <contrast+0x2380>
jmp    34bf <contrast+0x238f>
mov    $0x1,%al
test   $0x1,%al
jne    352a <contrast+0x23fa>
jmp    3562 <contrast+0x2432>
xor    %eax,%eax
test   $0x1,%al
jne    352a <contrast+0x23fa>
jmp    3562 <contrast+0x2432>
mov    0x5c83(%rip),%rax
mov    0x5e4c(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5e38(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     3562 <contrast+0x2432>
movsd  -0x20(%rbp),%xmm1
mov    0x5c50(%rip),%rax
mov    0x5e19(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5e05(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
ja     3562 <contrast+0x2432>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x5d43(%rip)
movsd  0x5d4b(%rip),%xmm0
movsd  0x5dd3(%rip),%xmm2
movsd  0x5d13(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5d03(%rip)
jmp    359e <contrast+0x246e>
movsd  0x5d1e(%rip),%xmm0
mulsd  0x5da6(%rip),%xmm0
movsd  0x3aae(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5cf2(%rip)
movsd  0x5cea(%rip),%xmm0
addsd  0x5cca(%rip),%xmm0
movsd  %xmm0,0x5cc2(%rip)
mov    0x5bb3(%rip),%rax
mov    0x5d7c(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5d69(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x5b91(%rip),%rax
mov    0x5d5a(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5d47(%rip),%rcx
sub    $0x1,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    3609 <contrast+0x24d9>
jp     3609 <contrast+0x24d9>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    3609 <contrast+0x24d9>
jp     3609 <contrast+0x24d9>
jmp    3697 <contrast+0x2567>
mov    0x5b48(%rip),%rax
mov    0x5d11(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5cfe(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x5b26(%rip),%rax
mov    0x5cef(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5cdc(%rip),%rcx
sub    $0x1,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    365e <contrast+0x252e>
jp     365e <contrast+0x252e>
jmp    3688 <contrast+0x2558>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    3679 <contrast+0x2549>
jp     3679 <contrast+0x2549>
jmp    3688 <contrast+0x2558>
mov    $0x1,%al
test   $0x1,%al
jne    36f9 <contrast+0x25c9>
jmp    3731 <contrast+0x2601>
xor    %eax,%eax
test   $0x1,%al
jne    36f9 <contrast+0x25c9>
jmp    3731 <contrast+0x2601>
mov    0x5aba(%rip),%rax
mov    0x5c83(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5c70(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     3731 <contrast+0x2601>
movsd  -0x20(%rbp),%xmm1
mov    0x5a84(%rip),%rax
mov    0x5c4d(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5c3a(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
ja     3731 <contrast+0x2601>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x5b54(%rip)
movsd  0x5b7c(%rip),%xmm0
movsd  0x5bfc(%rip),%xmm2
movsd  0x5b44(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5b34(%rip)
jmp    376d <contrast+0x263d>
movsd  0x5b4f(%rip),%xmm0
mulsd  0x5bcf(%rip),%xmm0
movsd  0x38df(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5b03(%rip)
movsd  0x5afb(%rip),%xmm0
addsd  0x5afb(%rip),%xmm0
movsd  %xmm0,0x5af3(%rip)
mov    0x59e4(%rip),%rax
mov    0x5bad(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5b99(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x59c1(%rip),%rax
mov    0x5b8a(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5b76(%rip),%rcx
sub    $0x1,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    37da <contrast+0x26aa>
jp     37da <contrast+0x26aa>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    37da <contrast+0x26aa>
jp     37da <contrast+0x26aa>
jmp    386f <contrast+0x273f>
mov    0x5977(%rip),%rax
mov    0x5b40(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5b2c(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x5954(%rip),%rax
mov    0x5b1d(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rcx
mov    0x5b09(%rip),%rdx
sub    $0x1,%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0x11a(%rbp)
jne    3839 <contrast+0x2709>
jp     3839 <contrast+0x2709>
jmp    3851 <contrast+0x2721>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x11a(%rbp)
mov    -0x11a(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x120(%rbp)
jmp    38f1 <contrast+0x27c1>
mov    0x58e2(%rip),%rax
mov    0x5aab(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5a97(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x121(%rbp)
ja     38de <contrast+0x27ae>
movsd  -0x20(%rbp),%xmm1
mov    0x58a3(%rip),%rax
mov    0x5a6c(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5a58(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x121(%rbp)
mov    -0x121(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x120(%rbp)
mov    -0x120(%rbp),%eax
movslq %eax,%rcx
lea    0x573f(%rip),%rax
shl    $0x7,%rcx
add    %rcx,%rax
mov    %rax,-0x130(%rbp)
mov    0x5842(%rip),%rax
mov    0x5a0b(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x59f7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x5823(%rip),%rax
mov    0x59ec(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x59d8(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    3974 <contrast+0x2844>
jp     3974 <contrast+0x2844>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    3974 <contrast+0x2844>
jp     3974 <contrast+0x2844>
jmp    3a01 <contrast+0x28d1>
mov    0x57dd(%rip),%rax
mov    0x59a6(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5992(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x57be(%rip),%rax
mov    0x5987(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rcx
mov    0x5973(%rip),%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0x131(%rbp)
jne    39cb <contrast+0x289b>
jp     39cb <contrast+0x289b>
jmp    39e3 <contrast+0x28b3>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x131(%rbp)
mov    -0x131(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x138(%rbp)
jmp    3a7b <contrast+0x294b>
mov    0x5750(%rip),%rax
mov    0x5919(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5905(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x139(%rbp)
ja     3a68 <contrast+0x2938>
movsd  -0x20(%rbp),%xmm1
mov    0x5715(%rip),%rax
mov    0x58de(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x58ca(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x139(%rbp)
mov    -0x139(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x138(%rbp)
mov    -0x130(%rbp),%rax
mov    -0x138(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x6,%rcx
add    %rcx,%rax
mov    %rax,-0x148(%rbp)
mov    0x56b8(%rip),%rax
mov    0x5881(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x586e(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x5696(%rip),%rax
mov    0x585f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x584c(%rip),%rcx
sub    $0x1,%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    3b04 <contrast+0x29d4>
jp     3b04 <contrast+0x29d4>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    3b04 <contrast+0x29d4>
jp     3b04 <contrast+0x29d4>
jmp    3b97 <contrast+0x2a67>
mov    0x564d(%rip),%rax
mov    0x5816(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5803(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x562b(%rip),%rax
mov    0x57f4(%rip),%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x57e1(%rip),%rdx
sub    $0x1,%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0x149(%rbp)
jne    3b61 <contrast+0x2a31>
jp     3b61 <contrast+0x2a31>
jmp    3b79 <contrast+0x2a49>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x149(%rbp)
mov    -0x149(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x150(%rbp)
jmp    3c17 <contrast+0x2ae7>
mov    0x55ba(%rip),%rax
mov    0x5783(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5770(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x151(%rbp)
ja     3c04 <contrast+0x2ad4>
movsd  -0x20(%rbp),%xmm1
mov    0x557c(%rip),%rax
mov    0x5745(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5732(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x151(%rbp)
mov    -0x151(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x150(%rbp)
mov    -0x148(%rbp),%rax
mov    -0x150(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x5,%rcx
add    %rcx,%rax
mov    %rax,0x570b(%rip)
movsd  0x564b(%rip),%xmm0
mulsd  0x56d3(%rip),%xmm0
movsd  %xmm0,0x56fb(%rip)
mov    0x56ec(%rip),%rax
movsd  (%rax),%xmm0
mulsd  0x56e8(%rip),%xmm0
movsd  %xmm0,0x5608(%rip)
mov    0x56d1(%rip),%rax
movsd  0x8(%rax),%xmm0
movsd  0x56cc(%rip),%xmm2
movsd  0x55f4(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x55e4(%rip)
mov    0x56a5(%rip),%rax
movsd  0x10(%rax),%xmm0
movsd  0x56a0(%rip),%xmm2
movsd  0x55a8(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5598(%rip)
mov    0x5679(%rip),%rax
movsd  0x18(%rax),%xmm0
movsd  0x5674(%rip),%xmm2
movsd  0x5584(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5574(%rip)
movsd  0x557c(%rip),%xmm0
mov    0x54a5(%rip),%rax
mov    0x5626(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5613(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x5559(%rip),%xmm0
mov    0x5482(%rip),%rax
mov    0x55fb(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x55e8(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x550e(%rip),%xmm0
mov    0x5437(%rip),%rax
mov    0x55d0(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x55bd(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x54eb(%rip),%xmm0
mov    0x5414(%rip),%rax
mov    0x55a5(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5592(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x54f0(%rip),%xmm0
mulsd  0x5568(%rip),%xmm0
movsd  %xmm0,0x54b0(%rip)
mov    0x53a1(%rip),%rax
mov    0x556a(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5556(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x5382(%rip),%rax
mov    0x554b(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5537(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    3e15 <contrast+0x2ce5>
jp     3e15 <contrast+0x2ce5>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    3e15 <contrast+0x2ce5>
jp     3e15 <contrast+0x2ce5>
jmp    3e9d <contrast+0x2d6d>
mov    0x533c(%rip),%rax
mov    0x5505(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x54f1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x531d(%rip),%rax
mov    0x54e6(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x54d2(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    3e64 <contrast+0x2d34>
jp     3e64 <contrast+0x2d34>
jmp    3e8e <contrast+0x2d5e>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    3e7f <contrast+0x2d4f>
jp     3e7f <contrast+0x2d4f>
jmp    3e8e <contrast+0x2d5e>
mov    $0x1,%al
test   $0x1,%al
jne    3ef9 <contrast+0x2dc9>
jmp    3f31 <contrast+0x2e01>
xor    %eax,%eax
test   $0x1,%al
jne    3ef9 <contrast+0x2dc9>
jmp    3f31 <contrast+0x2e01>
mov    0x52b4(%rip),%rax
mov    0x547d(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5469(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     3f31 <contrast+0x2e01>
movsd  -0x20(%rbp),%xmm1
mov    0x5281(%rip),%rax
mov    0x544a(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5436(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
ja     3f31 <contrast+0x2e01>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x5374(%rip)
movsd  0x5384(%rip),%xmm0
movsd  0x5404(%rip),%xmm2
movsd  0x5344(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5334(%rip)
jmp    3f6d <contrast+0x2e3d>
movsd  0x5357(%rip),%xmm0
mulsd  0x53d7(%rip),%xmm0
movsd  0x30df(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5323(%rip)
movsd  0x531b(%rip),%xmm0
addsd  0x52fb(%rip),%xmm0
movsd  %xmm0,0x52f3(%rip)
mov    0x51e4(%rip),%rax
mov    0x53ad(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x539a(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x51c5(%rip),%rax
mov    0x538e(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x537b(%rip),%rcx
ucomisd 0x8(%rax,%rcx,8),%xmm0
jne    3fd2 <contrast+0x2ea2>
jp     3fd2 <contrast+0x2ea2>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    3fd2 <contrast+0x2ea2>
jp     3fd2 <contrast+0x2ea2>
jmp    405a <contrast+0x2f2a>
mov    0x517f(%rip),%rax
mov    0x5348(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5335(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x5160(%rip),%rax
mov    0x5329(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x5316(%rip),%rcx
ucomisd 0x8(%rax,%rcx,8),%xmm0
jne    4021 <contrast+0x2ef1>
jp     4021 <contrast+0x2ef1>
jmp    404b <contrast+0x2f1b>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    403c <contrast+0x2f0c>
jp     403c <contrast+0x2f0c>
jmp    404b <contrast+0x2f1b>
mov    $0x1,%al
test   $0x1,%al
jne    40b6 <contrast+0x2f86>
jmp    40ee <contrast+0x2fbe>
xor    %eax,%eax
test   $0x1,%al
jne    40b6 <contrast+0x2f86>
jmp    40ee <contrast+0x2fbe>
mov    0x50f7(%rip),%rax
mov    0x52c0(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x52ad(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     40ee <contrast+0x2fbe>
movsd  -0x20(%rbp),%xmm1
mov    0x50c4(%rip),%rax
mov    0x528d(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x527a(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
ja     40ee <contrast+0x2fbe>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x51a7(%rip)
movsd  0x51c7(%rip),%xmm0
movsd  0x523f(%rip),%xmm2
movsd  0x5187(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x5177(%rip)
jmp    412a <contrast+0x2ffa>
movsd  0x519a(%rip),%xmm0
mulsd  0x5212(%rip),%xmm0
movsd  0x2f22(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,0x5156(%rip)
movsd  0x514e(%rip),%xmm0
addsd  0x513e(%rip),%xmm0
movsd  %xmm0,0x5136(%rip)
mov    0x5027(%rip),%rax
mov    0x51f0(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x51dc(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x5007(%rip),%rax
mov    0x51d0(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x51bc(%rip),%rcx
ucomisd 0x8(%rax,%rcx,8),%xmm0
jne    4191 <contrast+0x3061>
jp     4191 <contrast+0x3061>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    4191 <contrast+0x3061>
jp     4191 <contrast+0x3061>
jmp    4220 <contrast+0x30f0>
mov    0x4fc0(%rip),%rax
mov    0x5189(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x5175(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x4fa0(%rip),%rax
mov    0x5169(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rcx
mov    0x5155(%rip),%rdx
xor    %eax,%eax
ucomisd 0x8(%rcx,%rdx,8),%xmm0
mov    %al,-0x152(%rbp)
jne    41ea <contrast+0x30ba>
jp     41ea <contrast+0x30ba>
jmp    4202 <contrast+0x30d2>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x152(%rbp)
mov    -0x152(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x158(%rbp)
jmp    429c <contrast+0x316c>
mov    0x4f31(%rip),%rax
mov    0x50fa(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x50e6(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x159(%rbp)
ja     4289 <contrast+0x3159>
movsd  -0x20(%rbp),%xmm1
mov    0x4ef5(%rip),%rax
mov    0x50be(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x50aa(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x159(%rbp)
mov    -0x159(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x158(%rbp)
mov    -0x158(%rbp),%eax
movslq %eax,%rcx
lea    0x4d94(%rip),%rax
shl    $0x7,%rcx
add    %rcx,%rax
mov    %rax,-0x168(%rbp)
mov    0x4e97(%rip),%rax
mov    0x5060(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x504c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x4e78(%rip),%rax
mov    0x5041(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x502d(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    431f <contrast+0x31ef>
jp     431f <contrast+0x31ef>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    431f <contrast+0x31ef>
jp     431f <contrast+0x31ef>
jmp    43ac <contrast+0x327c>
mov    0x4e32(%rip),%rax
mov    0x4ffb(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x4fe7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x4e13(%rip),%rax
mov    0x4fdc(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rcx
mov    0x4fc8(%rip),%rdx
xor    %eax,%eax
ucomisd (%rcx,%rdx,8),%xmm0
mov    %al,-0x169(%rbp)
jne    4376 <contrast+0x3246>
jp     4376 <contrast+0x3246>
jmp    438e <contrast+0x325e>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x169(%rbp)
mov    -0x169(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x170(%rbp)
jmp    4426 <contrast+0x32f6>
mov    0x4da5(%rip),%rax
mov    0x4f6e(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x4f5a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x171(%rbp)
ja     4413 <contrast+0x32e3>
movsd  -0x20(%rbp),%xmm1
mov    0x4d6a(%rip),%rax
mov    0x4f33(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x4f1f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x171(%rbp)
mov    -0x171(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x170(%rbp)
mov    -0x168(%rbp),%rax
mov    -0x170(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x6,%rcx
add    %rcx,%rax
mov    %rax,-0x180(%rbp)
mov    0x4d0d(%rip),%rax
mov    0x4ed6(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4ec3(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x4cee(%rip),%rax
mov    0x4eb7(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4ea4(%rip),%rcx
ucomisd 0x8(%rax,%rcx,8),%xmm0
jne    44a9 <contrast+0x3379>
jp     44a9 <contrast+0x3379>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    44a9 <contrast+0x3379>
jp     44a9 <contrast+0x3379>
jmp    4536 <contrast+0x3406>
mov    0x4ca8(%rip),%rax
mov    0x4e71(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4e5e(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x4c89(%rip),%rax
mov    0x4e52(%rip),%rcx
mov    (%rax,%rcx,8),%rcx
mov    0x4e3f(%rip),%rdx
xor    %eax,%eax
ucomisd 0x8(%rcx,%rdx,8),%xmm0
mov    %al,-0x181(%rbp)
jne    4500 <contrast+0x33d0>
jp     4500 <contrast+0x33d0>
jmp    4518 <contrast+0x33e8>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
setne  %al
setp   %cl
or     %cl,%al
mov    %al,-0x181(%rbp)
mov    -0x181(%rbp),%dl
xor    %eax,%eax
mov    $0x1,%ecx
test   $0x1,%dl
cmovne %ecx,%eax
mov    %eax,-0x188(%rbp)
jmp    45b0 <contrast+0x3480>
mov    0x4c1b(%rip),%rax
mov    0x4de4(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4dd1(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0x189(%rbp)
ja     459d <contrast+0x346d>
movsd  -0x20(%rbp),%xmm1
mov    0x4be0(%rip),%rax
mov    0x4da9(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4d96(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x189(%rbp)
mov    -0x189(%rbp),%al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x188(%rbp)
mov    -0x180(%rbp),%rax
mov    -0x188(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x5,%rcx
add    %rcx,%rax
mov    %rax,0x4d72(%rip)
movsd  0x4cba(%rip),%xmm0
mulsd  0x4d3a(%rip),%xmm0
movsd  %xmm0,0x4d62(%rip)
mov    0x4d53(%rip),%rax
movsd  (%rax),%xmm0
mulsd  0x4d4f(%rip),%xmm0
movsd  %xmm0,0x4c7f(%rip)
mov    0x4d38(%rip),%rax
movsd  0x8(%rax),%xmm0
movsd  0x4d33(%rip),%xmm2
movsd  0x4c5b(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4c4b(%rip)
mov    0x4d0c(%rip),%rax
movsd  0x10(%rax),%xmm0
movsd  0x4d07(%rip),%xmm2
movsd  0x4c1f(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4c0f(%rip)
mov    0x4ce0(%rip),%rax
movsd  0x18(%rax),%xmm0
movsd  0x4cdb(%rip),%xmm2
movsd  0x4beb(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4bdb(%rip)
movsd  0x4bf3(%rip),%xmm0
mov    0x4b1c(%rip),%rax
mov    0x4c8d(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4c7a(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4bc0(%rip),%xmm0
mov    0x4ae9(%rip),%rax
mov    0x4c62(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4c4f(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4b85(%rip),%xmm0
mov    0x4aae(%rip),%rax
mov    0x4c37(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4c24(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4b52(%rip),%xmm0
mov    0x4a7b(%rip),%rax
mov    0x4c0c(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4bf9(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4b8f(%rip),%xmm1
mov    0x4a30(%rip),%rax
mov    0x4be1(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4bce(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4b60(%rip),%xmm1
mov    0x4a09(%rip),%rax
mov    0x4bb2(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4b9f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4b31(%rip),%xmm1
mov    0x49e2(%rip),%rax
mov    0x4b83(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4b70(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4b02(%rip),%xmm1
mov    0x49bb(%rip),%rax
mov    0x4b54(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4b41(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4ad3(%rip),%xmm1
mov    0x4994(%rip),%rax
mov    0x4b25(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4b12(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4aa4(%rip),%xmm1
mov    0x496d(%rip),%rax
mov    0x4af6(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4ae3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4a75(%rip),%xmm1
mov    0x4946(%rip),%rax
mov    0x4ac7(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4ab4(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4a46(%rip),%xmm1
mov    0x491f(%rip),%rax
mov    0x4a98(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4a85(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x4a17(%rip),%xmm1
mov    0x48f8(%rip),%rax
mov    0x4a69(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4a56(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    48dd <contrast+0x37ad>
mov    0x4a44(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4a39(%rip)
jmp    19ae <contrast+0x87e>
jmp    48f9 <contrast+0x37c9>
mov    0x4a20(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4a15(%rip)
jmp    18ea <contrast+0x7ba>
jmp    4915 <contrast+0x37e5>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x4a50(%rip)
movq   $0x0,0x49fd(%rip)
mov    0x49f6(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    4aa1 <contrast+0x3971>
movq   $0x0,0x49d6(%rip)
mov    0x49cf(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    4a85 <contrast+0x3955>
mov    0x47f3(%rip),%rax
mov    0x49bc(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x49a9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x49c4(%rip)
movsd  0x49bc(%rip),%xmm0
ucomisd 0x49b4(%rip),%xmm0
jne    49bb <contrast+0x388b>
jp     49bb <contrast+0x388b>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    49bb <contrast+0x388b>
jp     49bb <contrast+0x388b>
jmp    4a15 <contrast+0x38e5>
movsd  0x4985(%rip),%xmm0
ucomisd 0x497d(%rip),%xmm0
jne    49dc <contrast+0x38ac>
jp     49dc <contrast+0x38ac>
jmp    4a06 <contrast+0x38d6>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    49f7 <contrast+0x38c7>
jp     49f7 <contrast+0x38c7>
jmp    4a06 <contrast+0x38d6>
mov    $0x1,%al
test   $0x1,%al
jne    4a69 <contrast+0x3939>
jmp    4a43 <contrast+0x3913>
xor    %eax,%eax
test   $0x1,%al
jne    4a69 <contrast+0x3939>
jmp    4a43 <contrast+0x3913>
movsd  0x492b(%rip),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     4a43 <contrast+0x3913>
movsd  -0x20(%rbp),%xmm1
movsd  0x490f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    4a69 <contrast+0x3939>
movsd  0x48fd(%rip),%xmm0
ucomisd 0x491d(%rip),%xmm0
jbe    4a69 <contrast+0x3939>
movsd  0x48e7(%rip),%xmm0
movsd  %xmm0,0x4907(%rip)
jmp    4a6e <contrast+0x393e>
mov    0x48ab(%rip),%rax
add    $0x1,%rax
mov    %rax,0x48a0(%rip)
jmp    494a <contrast+0x381a>
jmp    4a8a <contrast+0x395a>
mov    0x4897(%rip),%rax
add    $0x1,%rax
mov    %rax,0x488c(%rip)
jmp    492b <contrast+0x37fb>
mov    0x4710(%rip),%rax
mov    %rax,0x4749(%rip)
mov    0x470a(%rip),%rax
mov    %rax,0x4743(%rip)
mov    0x4704(%rip),%rax
mov    %rax,0x473d(%rip)
mov    0x46fe(%rip),%rax
mov    %rax,0x4737(%rip)
mov    0x46f8(%rip),%rax
mov    %rax,0x4731(%rip)
mov    0x46f2(%rip),%rax
mov    %rax,0x472b(%rip)
mov    0x46ec(%rip),%rax
mov    %rax,0x4725(%rip)
mov    0x46e6(%rip),%rax
mov    %rax,0x471f(%rip)
movq   $0x0,0x480c(%rip)
mov    0x4805(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    4bbe <contrast+0x3a8e>
movq   $0x0,0x47e5(%rip)
mov    0x47de(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    4ba2 <contrast+0x3a72>
mov    0x4602(%rip),%rax
mov    0x47cb(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x47b8(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x45ec(%rip),%rax
mov    0x47ad(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x479a(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x478e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4783(%rip)
jmp    4b3b <contrast+0x3a0b>
jmp    4ba7 <contrast+0x3a77>
mov    0x477a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x476f(%rip)
jmp    4b1c <contrast+0x39ec>
movq   $0x0,0x475f(%rip)
mov    0x4758(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    4f43 <contrast+0x3e13>
movq   $0x0,0x4738(%rip)
mov    0x4731(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    4f27 <contrast+0x3df7>
mov    0x4555(%rip),%rax
mov    0x471e(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x470b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x454f(%rip),%rax
mov    0x4700(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x46ed(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x4519(%rip),%rax
mov    0x46e2(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x46cb(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    0x4513(%rip),%rax
mov    0x46bc(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x46a9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x44d5(%rip),%rax
mov    0x469e(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4687(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x44d3(%rip),%rax
mov    0x4674(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4661(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x448d(%rip),%rax
mov    0x4656(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x463f(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    0x4492(%rip),%rax
mov    0x462b(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4618(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x4444(%rip),%rax
mov    0x460d(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x45fa(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x4452(%rip),%rax
mov    0x45e3(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x45d0(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x43fc(%rip),%rax
mov    0x45c5(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x45b2(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    0x4416(%rip),%rax
mov    0x459f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x458c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x43b8(%rip),%rax
mov    0x4581(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x456e(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x43d9(%rip),%rax
mov    0x455a(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4547(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x4373(%rip),%rax
mov    0x453c(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x4528(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mov    0x4398(%rip),%rax
mov    0x4511(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x44fe(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x432a(%rip),%rax
mov    0x44f3(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x44df(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x435b(%rip),%rax
mov    0x44cc(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x44b9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x42e5(%rip),%rax
mov    0x44ae(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x449a(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    0x4381(%rip),%rax
mov    0x4482(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x446f(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x435b(%rip),%rax
mov    0x4464(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4451(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x4325(%rip),%rax
mov    0x4446(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4433(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x42ff(%rip),%rax
mov    0x4428(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4415(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x4409(%rip),%rax
add    $0x1,%rax
mov    %rax,0x43fe(%rip)
jmp    4be8 <contrast+0x3ab8>
jmp    4f2c <contrast+0x3dfc>
mov    0x43f5(%rip),%rax
add    $0x1,%rax
mov    %rax,0x43ea(%rip)
jmp    4bc9 <contrast+0x3a99>
movl   $0x1,0x442b(%rip)
movl   $0x1,0x43e1(%rip)
movq   $0x0,0x43c6(%rip)
mov    0x43bf(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    501f <contrast+0x3eef>
movq   $0x0,0x439f(%rip)
mov    0x4398(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    5003 <contrast+0x3ed3>
mov    0x425c(%rip),%rax
mov    0x4385(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4372(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x2086(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x205a(%rip),%xmm1
mulsd  0x43a2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    4fe7 <contrast+0x3eb7>
movl   $0x0,0x4356(%rip)
jmp    5003 <contrast+0x3ed3>
jmp    4fec <contrast+0x3ebc>
mov    0x432d(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4322(%rip)
jmp    4f81 <contrast+0x3e51>
jmp    5008 <contrast+0x3ed8>
mov    0x4319(%rip),%rax
add    $0x1,%rax
mov    %rax,0x430e(%rip)
jmp    4f62 <contrast+0x3e32>
cmpl   $0x0,0x4312(%rip)
je     5031 <contrast+0x3f01>
jmp    6d28 <contrast+0x5bf8>
cmpl   $0x1,0x4340(%rip)
jne    5113 <contrast+0x3fe3>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x4307(%rip)
movq   $0x0,0x42d4(%rip)
mov    0x42cd(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    510e <contrast+0x3fde>
movq   $0x0,0x42ad(%rip)
mov    0x42a6(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    50f2 <contrast+0x3fc2>
mov    0x416a(%rip),%rax
mov    0x4293(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4280(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x4154(%rip),%rax
mov    0x4275(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4262(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x4285(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x4275(%rip)
mov    0x423e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4233(%rip)
jmp    5073 <contrast+0x3f43>
jmp    50f7 <contrast+0x3fc7>
mov    0x422a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x421f(%rip)
jmp    5054 <contrast+0x3f24>
jmp    5113 <contrast+0x3fe3>
movq   $0x0,0x420a(%rip)
mov    0x4203(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    51de <contrast+0x40ae>
movq   $0x0,0x41e3(%rip)
mov    0x41dc(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    51c2 <contrast+0x4092>
mov    0x4038(%rip),%rax
mov    0x41c9(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x41b6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40a2(%rip),%rax
mov    0x41ab(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4198(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x4074(%rip),%rax
mov    0x418d(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x417a(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x416e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4163(%rip)
jmp    513d <contrast+0x400d>
jmp    51c7 <contrast+0x4097>
mov    0x415a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x414f(%rip)
jmp    511e <contrast+0x3fee>
movq   $0x1,0x413f(%rip)
mov    0x4138(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    5315 <contrast+0x41e5>
movq   $0x1,0x4118(%rip)
mov    0x4111(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    52a2 <contrast+0x4172>
mov    0x3f4d(%rip),%rax
mov    0x40fe(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40eb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3fd7(%rip),%rax
mov    0x40e0(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40c9(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x3fa1(%rip),%rax
mov    0x40ba(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x40a7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x408e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4083(%rip)
jmp    5208 <contrast+0x40d8>
mov    0x3ec7(%rip),%rax
mov    0x4078(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x3f59(%rip),%rax
mov    0x4062(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x3f25(%rip),%rax
mov    0x403e(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    0x4023(%rip),%rax
add    $0x1,%rax
mov    %rax,0x4018(%rip)
jmp    51e9 <contrast+0x40b9>
movq   $0x1,0x4008(%rip)
mov    0x4001(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    53f1 <contrast+0x42c1>
movq   $0x0,0x3fe1(%rip)
mov    0x3fda(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    53d5 <contrast+0x42a5>
mov    0x3e1e(%rip),%rax
mov    0x3fc7(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3fb4(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3ea0(%rip),%rax
mov    0x3fa9(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3f92(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x3e6e(%rip),%rax
mov    0x3f87(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3f74(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3f5b(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3f50(%rip)
jmp    533f <contrast+0x420f>
jmp    53da <contrast+0x42aa>
mov    0x3f47(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3f3c(%rip)
jmp    5320 <contrast+0x41f0>
movq   $0x1,0x3f2c(%rip)
mov    0x3f25(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    5535 <contrast+0x4405>
movq   $0x0,0x3f05(%rip)
mov    0x3efe(%rip),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    54b7 <contrast+0x4387>
mov    0x3d45(%rip),%rax
mov    0x3ee6(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3ed3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3dbf(%rip),%rax
mov    0x3ec8(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3eb1(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    0x3d8c(%rip),%rax
mov    0x3ea5(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3e92(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3e79(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3e6e(%rip)
jmp    541b <contrast+0x42eb>
mov    0x3cc2(%rip),%rax
mov    0x3e63(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3d3a(%rip),%rax
mov    0x3e43(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm2
mov    0x3d10(%rip),%rax
mov    0x3e29(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3e03(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3df8(%rip)
jmp    53fc <contrast+0x42cc>
movq   $0x0,0x3de8(%rip)
mov    0x3de1(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    5664 <contrast+0x4534>
movq   $0x1,0x3dc1(%rip)
mov    0x3dba(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    55f5 <contrast+0x44c5>
mov    0x3c0e(%rip),%rax
mov    0x3da7(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3d94(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3c80(%rip),%rax
mov    0x3d89(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3d76(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x3c4e(%rip),%rax
mov    0x3d67(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3d54(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3d3b(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3d30(%rip)
jmp    555f <contrast+0x442f>
mov    0x3b8c(%rip),%rax
mov    0x3d25(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x3c06(%rip),%rax
mov    0x3d0f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x3bd6(%rip),%rax
mov    0x3cef(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    0x3cd4(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3cc9(%rip)
jmp    5540 <contrast+0x4410>
movq   $0x0,0x3cb9(%rip)
mov    0x3cb2(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    57a0 <contrast+0x4670>
movq   $0x0,0x3c92(%rip)
mov    0x3c8b(%rip),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    5726 <contrast+0x45f6>
mov    0x3aea(%rip),%rax
mov    0x3c73(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3c60(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3b4c(%rip),%rax
mov    0x3c55(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3c42(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    0x3b1d(%rip),%rax
mov    0x3c36(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3c23(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3c0a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3bff(%rip)
jmp    568e <contrast+0x455e>
mov    0x3a6b(%rip),%rax
mov    0x3bf4(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3acb(%rip),%rax
mov    0x3bd4(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm2
mov    0x3aa5(%rip),%rax
mov    0x3bbe(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3b98(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3b8d(%rip)
jmp    566f <contrast+0x453f>
movq   $0x0,0x3b7d(%rip)
mov    0x3b76(%rip),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    58d6 <contrast+0x47a6>
movq   $0x1,0x3b51(%rip)
mov    0x3b4a(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    5866 <contrast+0x4736>
mov    0x39b6(%rip),%rax
mov    0x3b37(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3b24(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3a10(%rip),%rax
mov    0x3b19(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x3b05(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x39dd(%rip),%rax
mov    0x3af6(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3ae3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3aca(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3abf(%rip)
jmp    57cf <contrast+0x469f>
mov    0x3933(%rip),%rax
mov    0x3ab4(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x3995(%rip),%rax
mov    0x3a9e(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x3964(%rip),%rax
mov    0x3a7d(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    0x3a62(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3a57(%rip)
jmp    57ab <contrast+0x467b>
movq   $0x0,0x3a47(%rip)
mov    0x3a40(%rip),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    59b4 <contrast+0x4884>
movq   $0x0,0x3a1b(%rip)
mov    0x3a14(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    5998 <contrast+0x4868>
mov    0x3888(%rip),%rax
mov    0x3a01(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x39ee(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38da(%rip),%rax
mov    0x39e3(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x39cf(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x38ab(%rip),%rax
mov    0x39c4(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x39b1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3998(%rip),%rax
add    $0x1,%rax
mov    %rax,0x398d(%rip)
jmp    5905 <contrast+0x47d5>
jmp    599d <contrast+0x486d>
mov    0x3984(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3979(%rip)
jmp    58e1 <contrast+0x47b1>
movq   $0x0,0x3969(%rip)
mov    0x3962(%rip),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    5af7 <contrast+0x49c7>
movq   $0x0,0x393d(%rip)
mov    0x3936(%rip),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    5a7c <contrast+0x494c>
mov    0x37ad(%rip),%rax
mov    0x391e(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x390b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x37f7(%rip),%rax
mov    0x3900(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x38ec(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    0x37c7(%rip),%rax
mov    0x38e0(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x38cd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x38b4(%rip),%rax
add    $0x1,%rax
mov    %rax,0x38a9(%rip)
jmp    59e3 <contrast+0x48b3>
mov    0x372d(%rip),%rax
mov    0x389e(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3775(%rip),%rax
mov    0x387e(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
movsd  (%rax),%xmm2
mov    0x374e(%rip),%rax
mov    0x3867(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3841(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3836(%rip)
jmp    59bf <contrast+0x488f>
xorps  %xmm0,%xmm0
movsd  %xmm0,0x3856(%rip)
movq   $0x0,0x381b(%rip)
mov    0x3814(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    5bc7 <contrast+0x4a97>
movq   $0x0,0x37f4(%rip)
mov    0x37ed(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    5bab <contrast+0x4a7b>
mov    0x36d9(%rip),%rax
mov    0x37da(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x37c7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x36a3(%rip),%rax
mov    0x37bc(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x37a9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x37d4(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x37c4(%rip)
mov    0x3785(%rip),%rax
add    $0x1,%rax
mov    %rax,0x377a(%rip)
jmp    5b2c <contrast+0x49fc>
jmp    5bb0 <contrast+0x4a80>
mov    0x3771(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3766(%rip)
jmp    5b0d <contrast+0x49dd>
xorps  %xmm0,%xmm0
ucomisd 0x3786(%rip),%xmm0
ja     5bf2 <contrast+0x4ac2>
movsd  0x3778(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
ja     5bf2 <contrast+0x4ac2>
jmp    6d28 <contrast+0x5bf8>
movsd  0x3756(%rip),%xmm0
divsd  0x3756(%rip),%xmm0
movsd  %xmm0,0x3756(%rip)
movq   $0x0,0x3713(%rip)
mov    0x370c(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    5cfc <contrast+0x4bcc>
movq   $0x0,0x36ec(%rip)
mov    0x36e5(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    5ce0 <contrast+0x4bb0>
mov    0x35a9(%rip),%rax
mov    0x36d2(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x36bf(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x36f2(%rip),%xmm0
mov    0x3593(%rip),%rax
mov    0x36ac(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3699(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x3556(%rip),%rax
mov    0x366f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x365c(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3650(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3645(%rip)
jmp    5c34 <contrast+0x4b04>
jmp    5ce5 <contrast+0x4bb5>
mov    0x363c(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3631(%rip)
jmp    5c15 <contrast+0x4ae5>
movq   $0x0,0x3621(%rip)
mov    0x361a(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    5dc7 <contrast+0x4c97>
movq   $0x0,0x35fa(%rip)
mov    0x35f3(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    5dab <contrast+0x4c7b>
mov    0x344f(%rip),%rax
mov    0x35e0(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x35cd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x34c1(%rip),%rax
mov    0x35c2(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x35af(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x3493(%rip),%rax
mov    0x35a4(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3591(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3585(%rip),%rax
add    $0x1,%rax
mov    %rax,0x357a(%rip)
jmp    5d26 <contrast+0x4bf6>
jmp    5db0 <contrast+0x4c80>
mov    0x3571(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3566(%rip)
jmp    5d07 <contrast+0x4bd7>
movq   $0x1,0x3556(%rip)
mov    0x354f(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    5f14 <contrast+0x4de4>
movq   $0x1,0x352f(%rip)
mov    0x3528(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    5e93 <contrast+0x4d63>
mov    0x33a4(%rip),%rax
mov    0x3515(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x34fe(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x33ee(%rip),%rax
mov    0x34ef(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x34d8(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x33b8(%rip),%rax
mov    0x34c9(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x34b6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x349d(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3492(%rip)
jmp    5df1 <contrast+0x4cc1>
mov    0x3316(%rip),%rax
mov    0x3487(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3362(%rip),%rax
mov    0x3463(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x332e(%rip),%rax
mov    0x343f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    0x3424(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3419(%rip)
jmp    5dd2 <contrast+0x4ca2>
movq   $0x1,0x3409(%rip)
mov    0x3402(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    5ff4 <contrast+0x4ec4>
movq   $0x0,0x33e2(%rip)
mov    0x33db(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    5fd8 <contrast+0x4ea8>
mov    0x324f(%rip),%rax
mov    0x33c8(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x33b1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x32a5(%rip),%rax
mov    0x33a6(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x338f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x3273(%rip),%rax
mov    0x3384(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3371(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3358(%rip),%rax
add    $0x1,%rax
mov    %rax,0x334d(%rip)
jmp    5f3e <contrast+0x4e0e>
jmp    5fdd <contrast+0x4ead>
mov    0x3344(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3339(%rip)
jmp    5f1f <contrast+0x4def>
movq   $0x1,0x3329(%rip)
mov    0x3322(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    6137 <contrast+0x5007>
movq   $0x0,0x3302(%rip)
mov    0x32fb(%rip),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    60bf <contrast+0x4f8f>
mov    0x3162(%rip),%rax
mov    0x32e3(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x32cc(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x31bf(%rip),%rax
mov    0x32c0(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    0x32a9(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    0x318c(%rip),%rax
mov    0x329d(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x328a(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3271(%rip),%rax
add    $0x1,%rax
mov    %rax,0x3266(%rip)
jmp    601e <contrast+0x4eee>
mov    0x30da(%rip),%rax
mov    0x325b(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x3140(%rip),%rax
mov    0x3241(%rip),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm2
mov    0x3116(%rip),%rax
mov    0x3227(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3201(%rip),%rax
add    $0x1,%rax
mov    %rax,0x31f6(%rip)
jmp    5fff <contrast+0x4ecf>
movq   $0x0,0x31e6(%rip)
mov    0x31df(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    6274 <contrast+0x5144>
movq   $0x1,0x31bf(%rip)
mov    0x31b8(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    61fb <contrast+0x50cb>
mov    0x301c(%rip),%rax
mov    0x31a5(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3192(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x3082(%rip),%rax
mov    0x3183(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3170(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x3050(%rip),%rax
mov    0x3161(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x314e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x3135(%rip),%rax
add    $0x1,%rax
mov    %rax,0x312a(%rip)
jmp    6161 <contrast+0x5031>
mov    0x2f96(%rip),%rax
mov    0x311f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2ffe(%rip),%rax
mov    0x30ff(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x2fce(%rip),%rax
mov    0x30df(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    0x30c4(%rip),%rax
add    $0x1,%rax
mov    %rax,0x30b9(%rip)
jmp    6142 <contrast+0x5012>
movq   $0x0,0x30a9(%rip)
mov    0x30a2(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    63a7 <contrast+0x5277>
movq   $0x0,0x3082(%rip)
mov    0x307b(%rip),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    6337 <contrast+0x5207>
mov    0x2eca(%rip),%rax
mov    0x3063(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3050(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x2f43(%rip),%rax
mov    0x3044(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3031(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    0x2f14(%rip),%rax
mov    0x3025(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x3012(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2ff9(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2fee(%rip)
jmp    629e <contrast+0x516e>
mov    0x2e4a(%rip),%rax
mov    0x2fe3(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x2ecc(%rip),%rax
mov    0x2fcd(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm2
mov    0x2ea6(%rip),%rax
mov    0x2fb7(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2f91(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2f86(%rip)
jmp    627f <contrast+0x514f>
movq   $0x0,0x2f76(%rip)
mov    0x2f6f(%rip),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    64ed <contrast+0x53bd>
movq   $0x1,0x2f4a(%rip)
mov    0x2f43(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    6472 <contrast+0x5342>
mov    0x2d8f(%rip),%rax
mov    0x2f30(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x2f1c(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2e0c(%rip),%rax
mov    0x2f0d(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x2ef9(%rip),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x2dd9(%rip),%rax
mov    0x2eea(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2ed7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2ebe(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2eb3(%rip)
jmp    63d6 <contrast+0x52a6>
mov    0x2d07(%rip),%rax
mov    0x2ea8(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2d86(%rip),%rax
mov    0x2e87(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x2d55(%rip),%rax
mov    0x2e66(%rip),%rcx
mov    (%rax,%rcx,8),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    0x2e4b(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2e40(%rip)
jmp    63b2 <contrast+0x5282>
movq   $0x0,0x2e30(%rip)
mov    0x2e29(%rip),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    65cc <contrast+0x549c>
movq   $0x0,0x2e04(%rip)
mov    0x2dfd(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    65b0 <contrast+0x5480>
mov    0x2c41(%rip),%rax
mov    0x2dea(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x2dd6(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2cca(%rip),%rax
mov    0x2dcb(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x2db7(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x2c9b(%rip),%rax
mov    0x2dac(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2d99(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2d80(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2d75(%rip)
jmp    651c <contrast+0x53ec>
jmp    65b5 <contrast+0x5485>
mov    0x2d6c(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2d61(%rip)
jmp    64f8 <contrast+0x53c8>
movq   $0x0,0x2d51(%rip)
mov    0x2d4a(%rip),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    6708 <contrast+0x55d8>
movq   $0x0,0x2d25(%rip)
mov    0x2d1e(%rip),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jge    6696 <contrast+0x5566>
mov    0x2b55(%rip),%rax
mov    0x2d06(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x2cf2(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x2be5(%rip),%rax
mov    0x2ce6(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    0x2cd2(%rip),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    0x2bb5(%rip),%rax
mov    0x2cc6(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2cb3(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2c9a(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2c8f(%rip)
jmp    65fb <contrast+0x54cb>
mov    0x2ad3(%rip),%rax
mov    0x2c84(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
movsd  (%rax),%xmm0
mov    0x2b6c(%rip),%rax
mov    0x2c6d(%rip),%rcx
mov    0x8(%rax,%rcx,8),%rax
movsd  (%rax),%xmm2
mov    0x2b45(%rip),%rax
mov    0x2c56(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2c30(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2c25(%rip)
jmp    65d7 <contrast+0x54a7>
movq   $0x0,0x2c15(%rip)
mov    0x2c0e(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    67fa <contrast+0x56ca>
movq   $0x0,0x2bee(%rip)
mov    0x2be7(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    67de <contrast+0x56ae>
mov    0x2ab3(%rip),%rax
mov    0x2bd4(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2bc1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x2bf4(%rip),%xmm0
mov    0x2a9d(%rip),%rax
mov    0x2bae(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2b9b(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x2a60(%rip),%rax
mov    0x2b71(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2b5e(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2b52(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2b47(%rip)
jmp    6732 <contrast+0x5602>
jmp    67e3 <contrast+0x56b3>
mov    0x2b3e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2b33(%rip)
jmp    6713 <contrast+0x55e3>
movsd  0x2b4e(%rip),%xmm0
movsd  %xmm0,0x2b4e(%rip)
xorps  %xmm0,%xmm0
movsd  %xmm0,0x2b3b(%rip)
movq   $0x0,0x2b08(%rip)
mov    0x2b01(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    68da <contrast+0x57aa>
movq   $0x0,0x2ae1(%rip)
mov    0x2ada(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    68be <contrast+0x578e>
mov    0x29b6(%rip),%rax
mov    0x2ac7(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2ab4(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2990(%rip),%rax
mov    0x2aa9(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2a96(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x2ab9(%rip),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2aa9(%rip)
mov    0x2a72(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2a67(%rip)
jmp    683f <contrast+0x570f>
jmp    68c3 <contrast+0x5793>
mov    0x2a5e(%rip),%rax
add    $0x1,%rax
mov    %rax,0x2a53(%rip)
jmp    6820 <contrast+0x56f0>
xorps  %xmm0,%xmm0
ucomisd 0x2a73(%rip),%xmm0
ja     6905 <contrast+0x57d5>
movsd  0x2a65(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
ja     6905 <contrast+0x57d5>
jmp    6d28 <contrast+0x5bf8>
movsd  0x2a43(%rip),%xmm0
divsd  0x2a43(%rip),%xmm0
movsd  %xmm0,0x2a4b(%rip)
movq   $0x0,0x2a00(%rip)
mov    0x29f9(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    6a62 <contrast+0x5932>
movq   $0x0,0x29d9(%rip)
mov    0x29d2(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    6a46 <contrast+0x5916>
mov    0x28a6(%rip),%rax
mov    0x29bf(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x29ac(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x29e7(%rip),%xmm0
mov    0x2890(%rip),%rax
mov    0x2999(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2986(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x287a(%rip),%rax
mov    0x2973(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2960(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2844(%rip),%rax
mov    0x2955(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2942(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x297d(%rip),%xmm0
mov    0x282e(%rip),%rax
mov    0x292f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x291c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x2818(%rip),%rax
mov    0x2909(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x28f6(%rip),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28ea(%rip),%rax
add    $0x1,%rax
mov    %rax,0x28df(%rip)
jmp    6947 <contrast+0x5817>
jmp    6a4b <contrast+0x591b>
mov    0x28d6(%rip),%rax
add    $0x1,%rax
mov    %rax,0x28cb(%rip)
jmp    6928 <contrast+0x57f8>
movq   $0x0,0x28bb(%rip)
mov    0x28b4(%rip),%rax
movslq -0x8(%rbp),%rcx
cmp    %rcx,%rax
jge    6c6c <contrast+0x5b3c>
movq   $0x0,0x2894(%rip)
mov    0x288d(%rip),%rax
movslq -0xc(%rbp),%rcx
cmp    %rcx,%rax
jge    6c50 <contrast+0x5b20>
mov    0x26b9(%rip),%rax
mov    0x287a(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2867(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x269b(%rip),%rax
mov    0x285c(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2849(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    6b03 <contrast+0x59d3>
jp     6b03 <contrast+0x59d3>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    6b03 <contrast+0x59d3>
jp     6b03 <contrast+0x59d3>
jmp    6b89 <contrast+0x5a59>
mov    0x2656(%rip),%rax
mov    0x2817(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x2804(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2638(%rip),%rax
mov    0x27f9(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x27e6(%rip),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    6b50 <contrast+0x5a20>
jp     6b50 <contrast+0x5a20>
jmp    6b7a <contrast+0x5a4a>
movsd  -0x20(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jne    6b6b <contrast+0x5a3b>
jp     6b6b <contrast+0x5a3b>
jmp    6b7a <contrast+0x5a4a>
mov    $0x1,%al
test   $0x1,%al
jne    6c34 <contrast+0x5b04>
jmp    6be3 <contrast+0x5ab3>
xor    %eax,%eax
test   $0x1,%al
jne    6c34 <contrast+0x5b04>
jmp    6be3 <contrast+0x5ab3>
mov    0x25d0(%rip),%rax
mov    0x2791(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x277e(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     6be3 <contrast+0x5ab3>
movsd  -0x20(%rbp),%xmm1
mov    0x259e(%rip),%rax
mov    0x275f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x274c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    6c34 <contrast+0x5b04>
movsd  0x2775(%rip),%xmm0
mov    0x2626(%rip),%rax
mov    0x272f(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x271c(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x2550(%rip),%rax
mov    0x2711(%rip),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x26fe(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    6c39 <contrast+0x5b09>
mov    0x26e0(%rip),%rax
add    $0x1,%rax
mov    %rax,0x26d5(%rip)
jmp    6a8c <contrast+0x595c>
jmp    6c55 <contrast+0x5b25>
mov    0x26cc(%rip),%rax
add    $0x1,%rax
mov    %rax,0x26c1(%rip)
jmp    6a6d <contrast+0x593d>
mov    0x2595(%rip),%rax
mov    %rax,0x25be(%rip)
mov    0x2577(%rip),%rax
mov    %rax,0x2580(%rip)
mov    0x25a9(%rip),%rax
mov    %rax,0x2562(%rip)
mov    0x2573(%rip),%rax
mov    %rax,0x2594(%rip)
mov    0x2555(%rip),%rax
mov    %rax,0x255e(%rip)
mov    0x257f(%rip),%rax
mov    %rax,0x2540(%rip)
mov    0x2561(%rip),%rax
mov    %rax,0x256a(%rip)
mov    0x2543(%rip),%rax
mov    %rax,0x254c(%rip)
mov    0x2555(%rip),%rax
mov    %rax,0x252e(%rip)
mov    0x253f(%rip),%rax
mov    %rax,0x2540(%rip)
mov    0x2521(%rip),%rax
mov    %rax,0x252a(%rip)
mov    0x252b(%rip),%rax
mov    %rax,0x250c(%rip)
mov    0x265e(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2655(%rip)
jmp    4f4d <contrast+0x3e1d>
movss  0x264c(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl 0x263c(%rip),%xmm1
movsd  0x2cc(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2624(%rip)
movss  0x2620(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x2a4(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x2a0(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x25f8(%rip)
mov    0x23c1(%rip),%rcx
lea    0x2c2(%rip),%rdi
lea    0x2c4(%rip),%rsi
mov    $0x7e4,%edx
mov    $0x0,%al
call   1050 <Free@plt>
mov    0x23a8(%rip),%rcx
lea    0x2a1(%rip),%rdi
lea    0x2a3(%rip),%rsi
mov    $0x7e5,%edx
mov    $0x0,%al
call   1050 <Free@plt>
mov    0x238f(%rip),%rcx
lea    0x280(%rip),%rdi
lea    0x282(%rip),%rsi
mov    $0x7e6,%edx
mov    $0x0,%al
call   1050 <Free@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x11,-0x14(%rbp)
jge    6e33 <contrast+0x5d03>
movslq -0x14(%rbp),%rcx
lea    0x2369(%rip),%rax
mov    (%rax,%rcx,8),%rcx
lea    0x246(%rip),%rdi
lea    0x248(%rip),%rsi
mov    $0x7e8,%edx
mov    $0x0,%al
call   1050 <Free@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    6df2 <contrast+0x5cc2>
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<contrast>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
lea    0xef1(%rip),%r14
lea    0xef3(%rip),%r15
mov    $0x20,%ecx
mov    %r14,%rdi
mov    %r15,%rsi
mov    $0x604,%edx
xor    %eax,%eax
call   1030 <Malloc@plt>
cltq
mov    %rax,0x2eea(%rip)
mov    $0x10,%ecx
mov    %r14,%rdi
mov    %r15,%rsi
mov    $0x605,%edx
xor    %eax,%eax
call   1030 <Malloc@plt>
cltq
mov    %rax,0x2ed2(%rip)
mov    0x8(%rax),%rcx
mov    %rcx,(%rax)
mov    0x2ec4(%rip),%rax
movq   0x2eb4(%rip),%xmm0
pshufd $0x44,%xmm0,%xmm0
paddq  0xe67(%rip),%xmm0
movdqu %xmm0,-0x8(%rax)
mov    %r14,%rdi
mov    %r15,%rsi
mov    $0x609,%edx
xor    %ecx,%ecx
xor    %eax,%eax
call   1030 <Malloc@plt>
cltq
mov    %rax,0x2e95(%rip)
lea    0x2e9e(%rip),%r12
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14,%rdi
mov    %r15,%rsi
mov    $0x60e,%edx
xor    %ecx,%ecx
xor    %eax,%eax
call   1030 <Malloc@plt>
cltq
mov    %rax,(%rbx,%r12,1)
add    $0x8,%rbx
cmp    $0x88,%rbx
jne    11d0 <contrast+0xb0>
mov    0x2e4a(%rip),%rax
mov    -0x8(%rax),%rcx
pxor   %xmm0,%xmm0
movdqu %xmm0,-0x8(%rcx)
mov    (%rax),%rax
movdqu %xmm0,-0x8(%rax)
mov    0x2e8e(%rip),%rax
mov    %rax,0x2ec7(%rip)
mov    0x2e88(%rip),%rax
mov    %rax,0x2ec1(%rip)
mov    0x2e82(%rip),%rax
mov    %rax,0x2ebb(%rip)
mov    0x2e7c(%rip),%rax
mov    %rax,0x2eb5(%rip)
mov    0x2e76(%rip),%rax
mov    %rax,0x2eaf(%rip)
mov    0x2e70(%rip),%rax
mov    %rax,0x2ea9(%rip)
mov    0x2e6a(%rip),%rax
mov    %rax,0x2ea3(%rip)
mov    0x2e64(%rip),%rax
mov    %rax,0x2e9d(%rip)
movss  0x2e9d(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd79(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xd75(%rip),%xmm2
addsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2e75(%rip)
movss  0x2e71(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x2e59(%rip)
mov    0x2d66(%rip),%rcx
lea    0xd3f(%rip),%rbx
lea    0xd41(%rip),%r14
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e4,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2d47(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e5,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2d36(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e6,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2d2d(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2d1c(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2d0b(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2cfa(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2ce9(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2cd8(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2cc7(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2cb6(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2ca5(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2c94(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2c83(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2c72(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2c61(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2c50(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2c3f(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2c2e(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
call   1040 <Free@plt>
mov    0x2c1d(%rip),%rcx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    $0x7e8,%edx
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1040 <Free@plt>

LLVM IR (-O0):
@contrast.xin_array = internal global double* null
@contrast.xin = internal global double** null
@contrast.xout = internal global double** null
@contrast.xwork = internal global [17 x double**] zeroinitializer
@contrast.r = internal global double** null
@contrast.r_bar = internal global double** null
@contrast.r_new = internal global double** null
@contrast.r_bar_new = internal global double** null
@contrast.p = internal global double** null
@contrast.p_bar = internal global double** null
@contrast.p_new = internal global double** null
@contrast.p_bar_new = internal global double** null
@contrast.swap = internal global double** null
@contrast.a0 = internal global double 0.000000e+00
@contrast.a1 = internal global double 0.000000e+00
@contrast.a2 = internal global double 0.000000e+00
@contrast.a3 = internal global double 0.000000e+00
@contrast.a4 = internal global double 0.000000e+00
@contrast.a5 = internal global double 0.000000e+00
@contrast.a6 = internal global double 0.000000e+00
@contrast.a7 = internal global double 0.000000e+00
@contrast.a8 = internal global double 0.000000e+00
@contrast.dlon0 = internal global double 0.000000e+00
@contrast.dlon1 = internal global double 0.000000e+00
@contrast.dslat0 = internal global double 0.000000e+00
@contrast.dslat1 = internal global double 0.000000e+00
@contrast.w00 = internal global double 0.000000e+00
@contrast.w01 = internal global double 0.000000e+00
@contrast.w10 = internal global double 0.000000e+00
@contrast.w11 = internal global double 0.000000e+00
@contrast.wsum = internal global double 0.000000e+00
@contrast.lon0 = internal global double 0.000000e+00
@contrast.lon1 = internal global double 0.000000e+00
@contrast.lon2 = internal global double 0.000000e+00
@contrast.lat0 = internal global double 0.000000e+00
@contrast.lat1 = internal global double 0.000000e+00
@contrast.lat2 = internal global double 0.000000e+00
@contrast.flat00 = internal global double 0.000000e+00
@contrast.flat01 = internal global double 0.000000e+00
@contrast.flat10 = internal global double 0.000000e+00
@contrast.flat11 = internal global double 0.000000e+00
@contrast.ilon = internal global i64 0
@contrast.ilat = internal global i64 0
@contrast.determine_matrix = internal global i32 0
@contrast.wrap_around = internal global i32 0
@contrast.stop_iteration = internal global i32 0
@contrast.table = internal global [2 x [2 x [2 x [4 x double]]]] [[2 x [2 x [4 x double]]] [[2 x [4 x double]] [[4 x double] [double 2.500000e-01, double 2.500000e-01, double 2.500000e-01, double 2.500000e-01], [4 x double] [double 3.750000e-01, double 2.500000e-01, double 0.000000e+00, double 3.750000e-01]], [2 x [4 x double]] [[4 x double] [double 3.750000e-01, double 0.000000e+00, double 2.500000e-01, double 3.750000e-01], [4 x double] [double 5.000000e-01, double 0.000000e+00, double 0.000000e+00, double 5.000000e-01]]], [2 x [2 x [4 x double]]] [[2 x [4 x double]] [[4 x double] [double 0.000000e+00, double 3.750000e-01, double 3.750000e-01, double 2.500000e-01], [4 x double] [double 0.000000e+00, double 5.000000e-01, double 0.000000e+00, double 5.000000e-01]], [2 x [4 x double]] [[4 x double] [double 0.000000e+00, double 0.000000e+00, double 5.000000e-01, double 5.000000e-01], [4 x double] [double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double 1.000000e+00]]]]
@contrast.case_table = internal global double* null
@contrast.f = internal global double 0.000000e+00
@contrast.nom = internal global double 0.000000e+00
@contrast.denom = internal global double 0.000000e+00
@contrast.a = internal global double 0.000000e+00
@contrast.b = internal global double 0.000000e+00
@contrast.eps = internal constant double 0x3BC79CA10C924223
@contrast.max = internal global double 0.000000e+00
@contrast.iter = internal global i32 0
@contrast.iter_sum = internal global float 0.000000e+00
@contrast.iter_n = internal global float 0.000000e+00
@__func__.contrast = [9 x i8] c"contrast\00"
@.str = [132 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/interpol.c\00"
define void @contrast() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca double
%8 = alloca double**
%9 = alloca double**
%10 = alloca double**
%11 = alloca double*
%12 = alloca double*
store i32 1, i32* %1
store i32 0, i32* %6
store i32 0, i32* %2
store i32 0, i32* %3
store double 0.000000e+00, double* %7
store double** null, double*** %8
store double** null, double*** %9
store double** null, double*** %10
store double* null, double** %11
store double* null, double** %12
%13 = load i32, i32* %1
%14 = icmp eq i32 %13, 1
br i1 %14, label %15, label %161
15: ; preds = %0
%16 = load i32, i32* %2
%17 = add nsw i32 %16, 2
%18 = load i32, i32* %3
%19 = add nsw i32 %18, 2
%20 = mul nsw i32 %17, %19
%21 = sext i32 %20 to i64
%22 = mul i64 %21, 8
%23 = call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 1540, i64 %22)
%24 = sext i32 %23 to i64
%25 = inttoptr i64 %24 to double*
store double* %25, double** @contrast.xin_array
%26 = load i32, i32* %2
%27 = add nsw i32 %26, 2
%28 = sext i32 %27 to i64
%29 = mul i64 %28, 8
%30 = call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 1541, i64 %29)
%31 = sext i32 %30 to i64
%32 = inttoptr i64 %31 to double**
store double** %32, double*** @contrast.xin
%33 = load double**, double*** @contrast.xin
%34 = getelementptr inbounds double*, double** %33, i64 1
%35 = load double*, double** %34
%36 = load double**, double*** @contrast.xin
store double* %35, double** %36
store i64 -1, i64* @contrast.ilat
br label %37
37: ; preds = %55, %15
%38 = load i64, i64* @contrast.ilat
%39 = load i32, i32* %2
%40 = sext i32 %39 to i64
%41 = icmp sle i64 %38, %40
br i1 %41, label %42, label %58
42: ; preds = %37
%43 = load double*, double** @contrast.xin_array
%44 = load i64, i64* @contrast.ilat
%45 = add nsw i64 %44, 1
%46 = load i32, i32* %3
%47 = add nsw i32 %46, 2
%48 = sext i32 %47 to i64
%49 = mul nsw i64 %45, %48
%50 = getelementptr inbounds double, double* %43, i64 %49
%51 = getelementptr inbounds double, double* %50, i64 1
%52 = load double**, double*** @contrast.xin
%53 = load i64, i64* @contrast.ilat
%54 = getelementptr inbounds double*, double** %52, i64 %53
store double* %51, double** %54
br label %55
55: ; preds = %42
%56 = load i64, i64* @contrast.ilat
%57 = add nsw i64 %56, 1
store i64 %57, i64* @contrast.ilat
br label %37
58: ; preds = %37
%59 = load i32, i32* %2
%60 = sext i32 %59 to i64
%61 = mul i64 %60, 8
%62 = call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 1545, i64 %61)
%63 = sext i32 %62 to i64
%64 = inttoptr i64 %63 to double**
store double** %64, double*** @contrast.xout
store i64 0, i64* @contrast.ilat
br label %65
65: ; preds = %82, %58
%66 = load i64, i64* @contrast.ilat
%67 = load i32, i32* %2
%68 = sext i32 %67 to i64
%69 = icmp slt i64 %66, %68
br i1 %69, label %70, label %85
70: ; preds = %65
%71 = load double**, double*** %10
%72 = getelementptr inbounds double*, double** %71, i64 0
%73 = load double*, double** %72
%74 = load i64, i64* @contrast.ilat
%75 = load i32, i32* %3
%76 = sext i32 %75 to i64
%77 = mul nsw i64 %74, %76
%78 = getelementptr inbounds double, double* %73, i64 %77
%79 = load double**, double*** @contrast.xout
%80 = load i64, i64* @contrast.ilat
%81 = getelementptr inbounds double*, double** %79, i64 %80
store double* %78, double** %81
br label %82
82: ; preds = %70
%83 = load i64, i64* @contrast.ilat
%84 = add nsw i64 %83, 1
store i64 %84, i64* @contrast.ilat
br label %65
85: ; preds = %65
store i32 0, i32* %5
br label %86
86: ; preds = %125, %85
%87 = load i32, i32* %5
%88 = icmp slt i32 %87, 17
br i1 %88, label %89, label %128
89: ; preds = %86
%90 = load i32, i32* %2
%91 = sext i32 %90 to i64
%92 = mul i64 %91, 8
%93 = call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 1550, i64 %92)
%94 = sext i32 %93 to i64
%95 = inttoptr i64 %94 to double**
%96 = load i32, i32* %5
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 %97
store double** %95, double*** %98
store i64 0, i64* @contrast.ilat
br label %99
99: ; preds = %121, %89
%100 = load i64, i64* @contrast.ilat
%101 = load i32, i32* %2
%102 = sext i32 %101 to i64
%103 = icmp slt i64 %100, %102
br i1 %103, label %104, label %124
104: ; preds = %99
%105 = load double**, double*** %8
%106 = load i32, i32* %5
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double*, double** %105, i64 %107
%109 = load double*, double** %108
%110 = load i64, i64* @contrast.ilat
%111 = load i32, i32* %3
%112 = sext i32 %111 to i64
%113 = mul nsw i64 %110, %112
%114 = getelementptr inbounds double, double* %109, i64 %113
%115 = load i32, i32* %5
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 %116
%118 = load double**, double*** %117
%119 = load i64, i64* @contrast.ilat
%120 = getelementptr inbounds double*, double** %118, i64 %119
store double* %114, double** %120
br label %121
121: ; preds = %104
%122 = load i64, i64* @contrast.ilat
%123 = add nsw i64 %122, 1
store i64 %123, i64* @contrast.ilat
br label %99
124: ; preds = %99
br label %125
125: ; preds = %124
%126 = load i32, i32* %5
%127 = add nsw i32 %126, 1
store i32 %127, i32* %5
br label %86
128: ; preds = %86
%129 = load i32, i32* %3
%130 = icmp sgt i32 %129, 1
br i1 %130, label %131, label %158
131: ; preds = %128
%132 = load double*, double** %11
%133 = load i32, i32* %3
%134 = sub nsw i32 %133, 1
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds double, double* %132, i64 %135
%137 = load double, double* %136
%138 = load double*, double** %11
%139 = getelementptr inbounds double, double* %138, i64 -1
%140 = load double, double* %139
%141 = fadd double %140, 3.600000e+02
%142 = fsub double %141, 1.000000e-03
%143 = fcmp oge double %137, %142
br i1 %143, label %156, label %144
144: ; preds = %131
%145 = load double*, double** %11
%146 = load i32, i32* %3
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double, double* %145, i64 %147
%149 = load double, double* %148
%150 = load double*, double** %11
%151 = getelementptr inbounds double, double* %150, i64 0
%152 = load double, double* %151
%153 = fadd double %152, 3.600000e+02
%154 = fsub double %153, 1.000000e-03
%155 = fcmp oge double %149, %154
br label %156
156: ; preds = %144, %131
%157 = phi i1 [ true, %131 ], [ %155, %144 ]
br label %158
158: ; preds = %156, %128
%159 = phi i1 [ false, %128 ], [ %157, %156 ]
%160 = zext i1 %159 to i32
store i32 %160, i32* @contrast.wrap_around
store i32 1, i32* @contrast.determine_matrix
br label %312
161: ; preds = %0
store i32 0, i32* @contrast.determine_matrix
store i32 0, i32* %4
br label %162
162: ; preds = %308, %161
%163 = load i32, i32* %4
%164 = load i32, i32* %6
%165 = icmp slt i32 %163, %164
br i1 %165, label %166, label %311
166: ; preds = %162
%167 = load double**, double*** %9
%168 = getelementptr inbounds double*, double** %167, i64 0
%169 = load double*, double** %168
%170 = load i32, i32* %4
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %169, i64 %171
%173 = load double, double* %172
%174 = load double**, double*** %9
%175 = getelementptr inbounds double*, double** %174, i64 0
%176 = load double*, double** %175
%177 = load i32, i32* %4
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds double, double* %176, i64 %178
%180 = load double, double* %179
%181 = fcmp une double %173, %180
br i1 %181, label %186, label %182
182: ; preds = %166
%183 = load double, double* %7
%184 = load double, double* %7
%185 = fcmp une double %183, %184
br i1 %185, label %186, label %210
186: ; preds = %182, %166
%187 = load double**, double*** %9
%188 = getelementptr inbounds double*, double** %187, i64 0
%189 = load double*, double** %188
%190 = load i32, i32* %4
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds double, double* %189, i64 %191
%193 = load double, double* %192
%194 = load double**, double*** %9
%195 = getelementptr inbounds double*, double** %194, i64 0
%196 = load double*, double** %195
%197 = load i32, i32* %4
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double, double* %196, i64 %198
%200 = load double, double* %199
%201 = fcmp une double %193, %200
br i1 %201, label %202, label %206
202: ; preds = %186
%203 = load double, double* %7
%204 = load double, double* %7
%205 = fcmp une double %203, %204
br label %206
206: ; preds = %202, %186
%207 = phi i1 [ false, %186 ], [ %205, %202 ]
%208 = zext i1 %207 to i64
%209 = select i1 %207, i32 1, i32 0
br label %234
210: ; preds = %182
%211 = load double**, double*** %9
%212 = getelementptr inbounds double*, double** %211, i64 0
%213 = load double*, double** %212
%214 = load i32, i32* %4
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds double, double* %213, i64 %215
%217 = load double, double* %216
%218 = load double, double* %7
%219 = fcmp olt double %217, %218
br i1 %219, label %230, label %220
220: ; preds = %210
%221 = load double, double* %7
%222 = load double**, double*** %9
%223 = getelementptr inbounds double*, double** %222, i64 0
%224 = load double*, double** %223
%225 = load i32, i32* %4
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds double, double* %224, i64 %226
%228 = load double, double* %227
%229 = fcmp olt double %221, %228
br label %230
230: ; preds = %220, %210
%231 = phi i1 [ true, %210 ], [ %229, %220 ]
%232 = xor i1 %231, true
%233 = zext i1 %232 to i32
br label %234
234: ; preds = %230, %206
%235 = phi i32 [ %209, %206 ], [ %233, %230 ]
%236 = load double**, double*** %10
%237 = getelementptr inbounds double*, double** %236, i64 0
%238 = load double*, double** %237
%239 = load i32, i32* %4
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds double, double* %238, i64 %240
%242 = load double, double* %241
%243 = load double**, double*** %10
%244 = getelementptr inbounds double*, double** %243, i64 0
%245 = load double*, double** %244
%246 = load i32, i32* %4
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %245, i64 %247
%249 = load double, double* %248
%250 = fcmp une double %242, %249
br i1 %250, label %255, label %251
251: ; preds = %234
%252 = load double, double* %7
%253 = load double, double* %7
%254 = fcmp une double %252, %253
br i1 %254, label %255, label %279
255: ; preds = %251, %234
%256 = load double**, double*** %10
%257 = getelementptr inbounds double*, double** %256, i64 0
%258 = load double*, double** %257
%259 = load i32, i32* %4
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %258, i64 %260
%262 = load double, double* %261
%263 = load double**, double*** %10
%264 = getelementptr inbounds double*, double** %263, i64 0
%265 = load double*, double** %264
%266 = load i32, i32* %4
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %265, i64 %267
%269 = load double, double* %268
%270 = fcmp une double %262, %269
br i1 %270, label %271, label %275
271: ; preds = %255
%272 = load double, double* %7
%273 = load double, double* %7
%274 = fcmp une double %272, %273
br label %275
275: ; preds = %271, %255
%276 = phi i1 [ false, %255 ], [ %274, %271 ]
%277 = zext i1 %276 to i64
%278 = select i1 %276, i32 1, i32 0
br label %303
279: ; preds = %251
%280 = load double**, double*** %10
%281 = getelementptr inbounds double*, double** %280, i64 0
%282 = load double*, double** %281
%283 = load i32, i32* %4
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds double, double* %282, i64 %284
%286 = load double, double* %285
%287 = load double, double* %7
%288 = fcmp olt double %286, %287
br i1 %288, label %299, label %289
289: ; preds = %279
%290 = load double, double* %7
%291 = load double**, double*** %10
%292 = getelementptr inbounds double*, double** %291, i64 0
%293 = load double*, double** %292
%294 = load i32, i32* %4
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds double, double* %293, i64 %295
%297 = load double, double* %296
%298 = fcmp olt double %290, %297
br label %299
299: ; preds = %289, %279
%300 = phi i1 [ true, %279 ], [ %298, %289 ]
%301 = xor i1 %300, true
%302 = zext i1 %301 to i32
br label %303
303: ; preds = %299, %275
%304 = phi i32 [ %278, %275 ], [ %302, %299 ]
%305 = icmp ne i32 %235, %304
br i1 %305, label %306, label %307
306: ; preds = %303
store i32 1, i32* @contrast.determine_matrix
br label %311
307: ; preds = %303
br label %308
308: ; preds = %307
%309 = load i32, i32* %4
%310 = add nsw i32 %309, 1
store i32 %310, i32* %4
br label %162
311: ; preds = %306, %162
br label %312
312: ; preds = %311, %158
store i64 0, i64* @contrast.ilon
br label %313
313: ; preds = %359, %312
%314 = load i64, i64* @contrast.ilon
%315 = load i32, i32* %3
%316 = sext i32 %315 to i64
%317 = icmp slt i64 %314, %316
br i1 %317, label %318, label %362
318: ; preds = %313
store i64 0, i64* @contrast.ilat
br label %319
319: ; preds = %342, %318
%320 = load i64, i64* @contrast.ilat
%321 = load i32, i32* %2
%322 = sext i32 %321 to i64
%323 = icmp slt i64 %320, %322
br i1 %323, label %324, label %345
324: ; preds = %319
%325 = load double**, double*** %9
%326 = getelementptr inbounds double*, double** %325, i64 0
%327 = load double*, double** %326
%328 = load i64, i64* @contrast.ilon
%329 = load i64, i64* @contrast.ilat
%330 = load i32, i32* %3
%331 = sext i32 %330 to i64
%332 = mul nsw i64 %329, %331
%333 = add nsw i64 %328, %332
%334 = getelementptr inbounds double, double* %327, i64 %333
%335 = load double, double* %334
%336 = load double**, double*** @contrast.xin
%337 = load i64, i64* @contrast.ilat
%338 = getelementptr inbounds double*, double** %336, i64 %337
%339 = load double*, double** %338
%340 = load i64, i64* @contrast.ilon
%341 = getelementptr inbounds double, double* %339, i64 %340
store double %335, double* %341
br label %342
342: ; preds = %324
%343 = load i64, i64* @contrast.ilat
%344 = add nsw i64 %343, 1
store i64 %344, i64* @contrast.ilat
br label %319
345: ; preds = %319
%346 = load double, double* %7
%347 = load double**, double*** @contrast.xin
%348 = load i32, i32* %2
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double*, double** %347, i64 %349
%351 = load double*, double** %350
%352 = load i64, i64* @contrast.ilon
%353 = getelementptr inbounds double, double* %351, i64 %352
store double %346, double* %353
%354 = load double**, double*** @contrast.xin
%355 = getelementptr inbounds double*, double** %354, i64 -1
%356 = load double*, double** %355
%357 = load i64, i64* @contrast.ilon
%358 = getelementptr inbounds double, double* %356, i64 %357
store double %346, double* %358
br label %359
359: ; preds = %345
%360 = load i64, i64* @contrast.ilon
%361 = add nsw i64 %360, 1
store i64 %361, i64* @contrast.ilon
br label %313
362: ; preds = %313
%363 = load i32, i32* @contrast.wrap_around
%364 = icmp ne i32 %363, 0
br i1 %364, label %365, label %403
365: ; preds = %362
store i64 -1, i64* @contrast.ilat
br label %366
366: ; preds = %399, %365
%367 = load i64, i64* @contrast.ilat
%368 = load i32, i32* %2
%369 = sext i32 %368 to i64
%370 = icmp sle i64 %367, %369
br i1 %370, label %371, label %402
371: ; preds = %366
%372 = load double**, double*** @contrast.xin
%373 = load i64, i64* @contrast.ilat
%374 = getelementptr inbounds double*, double** %372, i64 %373
%375 = load double*, double** %374
%376 = load i32, i32* %3
%377 = sub nsw i32 %376, 1
%378 = sext i32 %377 to i64
%379 = getelementptr inbounds double, double* %375, i64 %378
%380 = load double, double* %379
%381 = load double**, double*** @contrast.xin
%382 = load i64, i64* @contrast.ilat
%383 = getelementptr inbounds double*, double** %381, i64 %382
%384 = load double*, double** %383
%385 = getelementptr inbounds double, double* %384, i64 -1
store double %380, double* %385
%386 = load double**, double*** @contrast.xin
%387 = load i64, i64* @contrast.ilat
%388 = getelementptr inbounds double*, double** %386, i64 %387
%389 = load double*, double** %388
%390 = getelementptr inbounds double, double* %389, i64 0
%391 = load double, double* %390
%392 = load double**, double*** @contrast.xin
%393 = load i64, i64* @contrast.ilat
%394 = getelementptr inbounds double*, double** %392, i64 %393
%395 = load double*, double** %394
%396 = load i32, i32* %3
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds double, double* %395, i64 %397
store double %391, double* %398
br label %399
399: ; preds = %371
%400 = load i64, i64* @contrast.ilat
%401 = add nsw i64 %400, 1
store i64 %401, i64* @contrast.ilat
br label %366
402: ; preds = %366
br label %427
403: ; preds = %362
store i64 -1, i64* @contrast.ilat
br label %404
404: ; preds = %423, %403
%405 = load i64, i64* @contrast.ilat
%406 = load i32, i32* %2
%407 = sext i32 %406 to i64
%408 = icmp sle i64 %405, %407
br i1 %408, label %409, label %426
409: ; preds = %404
%410 = load double, double* %7
%411 = load double**, double*** @contrast.xin
%412 = load i64, i64* @contrast.ilat
%413 = getelementptr inbounds double*, double** %411, i64 %412
%414 = load double*, double** %413
%415 = load i32, i32* %3
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds double, double* %414, i64 %416
store double %410, double* %417
%418 = load double**, double*** @contrast.xin
%419 = load i64, i64* @contrast.ilat
%420 = getelementptr inbounds double*, double** %418, i64 %419
%421 = load double*, double** %420
%422 = getelementptr inbounds double, double* %421, i64 -1
store double %410, double* %422
br label %423
423: ; preds = %409
%424 = load i64, i64* @contrast.ilat
%425 = add nsw i64 %424, 1
store i64 %425, i64* @contrast.ilat
br label %404
426: ; preds = %404
br label %427
427: ; preds = %426, %402
%428 = load i32, i32* @contrast.determine_matrix
%429 = icmp ne i32 %428, 0
br i1 %429, label %430, label %2635
430: ; preds = %427
store i64 0, i64* @contrast.ilon
br label %431
431: ; preds = %2631, %430
%432 = load i64, i64* @contrast.ilon
%433 = load i32, i32* %3
%434 = sext i32 %433 to i64
%435 = icmp slt i64 %432, %434
br i1 %435, label %436, label %2634
436: ; preds = %431
%437 = load double*, double** %11
%438 = load i64, i64* @contrast.ilon
%439 = getelementptr inbounds double, double* %437, i64 %438
%440 = load double, double* %439
store double %440, double* @contrast.lon1
%441 = load double*, double** %11
%442 = load i64, i64* @contrast.ilon
%443 = sub nsw i64 %442, 1
%444 = getelementptr inbounds double, double* %441, i64 %443
%445 = load double, double* %444
%446 = load double, double* @contrast.lon1
%447 = fadd double %445, %446
%448 = fdiv double %447, 2.000000e+00
store double %448, double* @contrast.lon0
%449 = load double*, double** %11
%450 = load i64, i64* @contrast.ilon
%451 = add nsw i64 %450, 1
%452 = getelementptr inbounds double, double* %449, i64 %451
%453 = load double, double* %452
%454 = load double, double* @contrast.lon1
%455 = fadd double %453, %454
%456 = fdiv double %455, 2.000000e+00
store double %456, double* @contrast.lon2
%457 = load double, double* @contrast.lon1
%458 = load double, double* @contrast.lon0
%459 = fsub double %457, %458
store double %459, double* @contrast.dlon0
%460 = load double, double* @contrast.lon2
%461 = load double, double* @contrast.lon1
%462 = fsub double %460, %461
store double %462, double* @contrast.dlon1
store i64 0, i64* @contrast.ilat
br label %463
463: ; preds = %2627, %436
%464 = load i64, i64* @contrast.ilat
%465 = load i32, i32* %2
%466 = sext i32 %465 to i64
%467 = icmp slt i64 %464, %466
br i1 %467, label %468, label %2630
468: ; preds = %463
%469 = load double*, double** %12
%470 = load i64, i64* @contrast.ilat
%471 = getelementptr inbounds double, double* %469, i64 %470
%472 = load double, double* %471
%473 = fmul double %472, 0x400921FB54442D18
%474 = fdiv double %473, 1.800000e+02
store double %474, double* @contrast.lat1
%475 = load double*, double** %12
%476 = load i64, i64* @contrast.ilat
%477 = sub nsw i64 %476, 1
%478 = getelementptr inbounds double, double* %475, i64 %477
%479 = load double, double* %478
%480 = fmul double %479, 0x400921FB54442D18
%481 = fdiv double %480, 1.800000e+02
%482 = load double, double* @contrast.lat1
%483 = fadd double %481, %482
%484 = fdiv double %483, 2.000000e+00
store double %484, double* @contrast.lat0
%485 = load double*, double** %12
%486 = load i64, i64* @contrast.ilat
%487 = add nsw i64 %486, 1
%488 = getelementptr inbounds double, double* %485, i64 %487
%489 = load double, double* %488
%490 = fmul double %489, 0x400921FB54442D18
%491 = fdiv double %490, 1.800000e+02
%492 = load double, double* @contrast.lat1
%493 = fadd double %491, %492
%494 = fdiv double %493, 2.000000e+00
store double %494, double* @contrast.lat2
%495 = load double, double* @contrast.lat1
%496 = call double @sin(double %495)
%497 = load double, double* @contrast.lat0
%498 = call double @sin(double %497)
%499 = fsub double %496, %498
store double %499, double* @contrast.dslat0
%500 = load double, double* @contrast.lat2
%501 = call double @sin(double %500)
%502 = load double, double* @contrast.lat1
%503 = call double @sin(double %502)
%504 = fsub double %501, %503
store double %504, double* @contrast.dslat1
%505 = load double, double* @contrast.lat1
%506 = load double, double* @contrast.lat0
%507 = fsub double %505, %506
%508 = fdiv double 2.000000e+00, %507
%509 = load double, double* @contrast.lat1
%510 = load double, double* @contrast.lat0
%511 = fadd double %509, %510
%512 = fdiv double %511, 2.000000e+00
%513 = call double @sin(double %512)
%514 = fmul double %508, %513
%515 = load double, double* @contrast.lat1
%516 = load double, double* @contrast.lat0
%517 = fsub double %515, %516
%518 = fdiv double %517, 2.000000e+00
%519 = call double @sin(double %518)
%520 = load double, double* @contrast.lat0
%521 = call double @sin(double %520)
%522 = fneg double %521
%523 = call double @llvm.fmuladd.f64(double %514, double %519, double %522)
store double %523, double* @contrast.flat00
%524 = load double, double* @contrast.dslat0
%525 = load double, double* @contrast.flat00
%526 = fsub double %524, %525
store double %526, double* @contrast.flat01
%527 = load double, double* @contrast.lat2
%528 = load double, double* @contrast.lat1
%529 = fsub double %527, %528
%530 = fdiv double 2.000000e+00, %529
%531 = load double, double* @contrast.lat2
%532 = load double, double* @contrast.lat1
%533 = fadd double %531, %532
%534 = fdiv double %533, 2.000000e+00
%535 = call double @sin(double %534)
%536 = fmul double %530, %535
%537 = load double, double* @contrast.lat2
%538 = load double, double* @contrast.lat1
%539 = fsub double %537, %538
%540 = fdiv double %539, 2.000000e+00
%541 = call double @sin(double %540)
%542 = load double, double* @contrast.lat1
%543 = call double @sin(double %542)
%544 = fneg double %543
%545 = call double @llvm.fmuladd.f64(double %536, double %541, double %544)
store double %545, double* @contrast.flat10
%546 = load double, double* @contrast.dslat1
%547 = load double, double* @contrast.flat10
%548 = fsub double %546, %547
store double %548, double* @contrast.flat11
%549 = load double, double* @contrast.flat00
%550 = fdiv double %549, 2.000000e+00
store double %550, double* @contrast.flat00
%551 = load double, double* @contrast.flat01
%552 = fdiv double %551, 2.000000e+00
store double %552, double* @contrast.flat01
%553 = load double, double* @contrast.flat10
%554 = fdiv double %553, 2.000000e+00
store double %554, double* @contrast.flat10
%555 = load double, double* @contrast.flat11
%556 = fdiv double %555, 2.000000e+00
store double %556, double* @contrast.flat11
%557 = load double**, double*** @contrast.xin
%558 = load i64, i64* @contrast.ilat
%559 = getelementptr inbounds double*, double** %557, i64 %558
%560 = load double*, double** %559
%561 = load i64, i64* @contrast.ilon
%562 = getelementptr inbounds double, double* %560, i64 %561
%563 = load double, double* %562
%564 = load double**, double*** @contrast.xin
%565 = load i64, i64* @contrast.ilat
%566 = getelementptr inbounds double*, double** %564, i64 %565
%567 = load double*, double** %566
%568 = load i64, i64* @contrast.ilon
%569 = getelementptr inbounds double, double* %567, i64 %568
%570 = load double, double* %569
%571 = fcmp une double %563, %570
br i1 %571, label %576, label %572
572: ; preds = %468
%573 = load double, double* %7
%574 = load double, double* %7
%575 = fcmp une double %573, %574
br i1 %575, label %576, label %598
576: ; preds = %572, %468
%577 = load double**, double*** @contrast.xin
%578 = load i64, i64* @contrast.ilat
%579 = getelementptr inbounds double*, double** %577, i64 %578
%580 = load double*, double** %579
%581 = load i64, i64* @contrast.ilon
%582 = getelementptr inbounds double, double* %580, i64 %581
%583 = load double, double* %582
%584 = load double**, double*** @contrast.xin
%585 = load i64, i64* @contrast.ilat
%586 = getelementptr inbounds double*, double** %584, i64 %585
%587 = load double*, double** %586
%588 = load i64, i64* @contrast.ilon
%589 = getelementptr inbounds double, double* %587, i64 %588
%590 = load double, double* %589
%591 = fcmp une double %583, %590
br i1 %591, label %592, label %597
592: ; preds = %576
%593 = load double, double* %7
%594 = load double, double* %7
%595 = fcmp une double %593, %594
br i1 %595, label %596, label %597
596: ; preds = %592
br i1 true, label %618, label %673
597: ; preds = %592, %576
br i1 false, label %618, label %673
598: ; preds = %572
%599 = load double**, double*** @contrast.xin
%600 = load i64, i64* @contrast.ilat
%601 = getelementptr inbounds double*, double** %599, i64 %600
%602 = load double*, double** %601
%603 = load i64, i64* @contrast.ilon
%604 = getelementptr inbounds double, double* %602, i64 %603
%605 = load double, double* %604
%606 = load double, double* %7
%607 = fcmp olt double %605, %606
br i1 %607, label %673, label %608
608: ; preds = %598
%609 = load double, double* %7
%610 = load double**, double*** @contrast.xin
%611 = load i64, i64* @contrast.ilat
%612 = getelementptr inbounds double*, double** %610, i64 %611
%613 = load double*, double** %612
%614 = load i64, i64* @contrast.ilon
%615 = getelementptr inbounds double, double* %613, i64 %614
%616 = load double, double* %615
%617 = fcmp olt double %609, %616
br i1 %617, label %673, label %618
618: ; preds = %608, %597, %596
%619 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 4)
%620 = load i64, i64* @contrast.ilat
%621 = getelementptr inbounds double*, double** %619, i64 %620
%622 = load double*, double** %621
%623 = load i64, i64* @contrast.ilon
%624 = getelementptr inbounds double, double* %622, i64 %623
store double 1.000000e+00, double* %624
%625 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 8)
%626 = load i64, i64* @contrast.ilat
%627 = getelementptr inbounds double*, double** %625, i64 %626
%628 = load double*, double** %627
%629 = load i64, i64* @contrast.ilon
%630 = getelementptr inbounds double, double* %628, i64 %629
store double 0.000000e+00, double* %630
%631 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 7)
%632 = load i64, i64* @contrast.ilat
%633 = getelementptr inbounds double*, double** %631, i64 %632
%634 = load double*, double** %633
%635 = load i64, i64* @contrast.ilon
%636 = getelementptr inbounds double, double* %634, i64 %635
store double 0.000000e+00, double* %636
%637 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 6)
%638 = load i64, i64* @contrast.ilat
%639 = getelementptr inbounds double*, double** %637, i64 %638
%640 = load double*, double** %639
%641 = load i64, i64* @contrast.ilon
%642 = getelementptr inbounds double, double* %640, i64 %641
store double 0.000000e+00, double* %642
%643 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 5)
%644 = load i64, i64* @contrast.ilat
%645 = getelementptr inbounds double*, double** %643, i64 %644
%646 = load double*, double** %645
%647 = load i64, i64* @contrast.ilon
%648 = getelementptr inbounds double, double* %646, i64 %647
store double 0.000000e+00, double* %648
%649 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 3)
%650 = load i64, i64* @contrast.ilat
%651 = getelementptr inbounds double*, double** %649, i64 %650
%652 = load double*, double** %651
%653 = load i64, i64* @contrast.ilon
%654 = getelementptr inbounds double, double* %652, i64 %653
store double 0.000000e+00, double* %654
%655 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 2)
%656 = load i64, i64* @contrast.ilat
%657 = getelementptr inbounds double*, double** %655, i64 %656
%658 = load double*, double** %657
%659 = load i64, i64* @contrast.ilon
%660 = getelementptr inbounds double, double* %658, i64 %659
store double 0.000000e+00, double* %660
%661 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 1)
%662 = load i64, i64* @contrast.ilat
%663 = getelementptr inbounds double*, double** %661, i64 %662
%664 = load double*, double** %663
%665 = load i64, i64* @contrast.ilon
%666 = getelementptr inbounds double, double* %664, i64 %665
store double 0.000000e+00, double* %666
%667 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 0)
%668 = load i64, i64* @contrast.ilat
%669 = getelementptr inbounds double*, double** %667, i64 %668
%670 = load double*, double** %669
%671 = load i64, i64* @contrast.ilon
%672 = getelementptr inbounds double, double* %670, i64 %671
store double 0.000000e+00, double* %672
br label %2626
673: ; preds = %608, %598, %597, %596
%674 = load double, double* @contrast.dslat0
%675 = load double, double* @contrast.dlon0
%676 = fmul double %674, %675
store double %676, double* @contrast.w00
%677 = load double, double* @contrast.dslat0
%678 = load double, double* @contrast.dlon1
%679 = fmul double %677, %678
store double %679, double* @contrast.w01
%680 = load double, double* @contrast.dslat1
%681 = load double, double* @contrast.dlon0
%682 = fmul double %680, %681
store double %682, double* @contrast.w10
%683 = load double, double* @contrast.dslat1
%684 = load double, double* @contrast.dlon1
%685 = fmul double %683, %684
store double %685, double* @contrast.w11
%686 = load double, double* @contrast.w00
%687 = load double, double* @contrast.w01
%688 = fadd double %686, %687
%689 = load double, double* @contrast.w10
%690 = fadd double %688, %689
%691 = load double, double* @contrast.w11
%692 = fadd double %690, %691
store double %692, double* @contrast.wsum
%693 = load double, double* @contrast.dlon0
%694 = load double, double* @contrast.flat01
%695 = fmul double %693, %694
store double %695, double* @contrast.a4
%696 = load double**, double*** @contrast.xin
%697 = load i64, i64* @contrast.ilat
%698 = sub nsw i64 %697, 1
%699 = getelementptr inbounds double*, double** %696, i64 %698
%700 = load double*, double** %699
%701 = load i64, i64* @contrast.ilon
%702 = getelementptr inbounds double, double* %700, i64 %701
%703 = load double, double* %702
%704 = load double**, double*** @contrast.xin
%705 = load i64, i64* @contrast.ilat
%706 = sub nsw i64 %705, 1
%707 = getelementptr inbounds double*, double** %704, i64 %706
%708 = load double*, double** %707
%709 = load i64, i64* @contrast.ilon
%710 = getelementptr inbounds double, double* %708, i64 %709
%711 = load double, double* %710
%712 = fcmp une double %703, %711
br i1 %712, label %717, label %713
713: ; preds = %673
%714 = load double, double* %7
%715 = load double, double* %7
%716 = fcmp une double %714, %715
br i1 %716, label %717, label %741
717: ; preds = %713, %673
%718 = load double**, double*** @contrast.xin
%719 = load i64, i64* @contrast.ilat
%720 = sub nsw i64 %719, 1
%721 = getelementptr inbounds double*, double** %718, i64 %720
%722 = load double*, double** %721
%723 = load i64, i64* @contrast.ilon
%724 = getelementptr inbounds double, double* %722, i64 %723
%725 = load double, double* %724
%726 = load double**, double*** @contrast.xin
%727 = load i64, i64* @contrast.ilat
%728 = sub nsw i64 %727, 1
%729 = getelementptr inbounds double*, double** %726, i64 %728
%730 = load double*, double** %729
%731 = load i64, i64* @contrast.ilon
%732 = getelementptr inbounds double, double* %730, i64 %731
%733 = load double, double* %732
%734 = fcmp une double %725, %733
br i1 %734, label %735, label %740
735: ; preds = %717
%736 = load double, double* %7
%737 = load double, double* %7
%738 = fcmp une double %736, %737
br i1 %738, label %739, label %740
739: ; preds = %735
br i1 true, label %763, label %768
740: ; preds = %735, %717
br i1 false, label %763, label %768
741: ; preds = %713
%742 = load double**, double*** @contrast.xin
%743 = load i64, i64* @contrast.ilat
%744 = sub nsw i64 %743, 1
%745 = getelementptr inbounds double*, double** %742, i64 %744
%746 = load double*, double** %745
%747 = load i64, i64* @contrast.ilon
%748 = getelementptr inbounds double, double* %746, i64 %747
%749 = load double, double* %748
%750 = load double, double* %7
%751 = fcmp olt double %749, %750
br i1 %751, label %768, label %752
752: ; preds = %741
%753 = load double, double* %7
%754 = load double**, double*** @contrast.xin
%755 = load i64, i64* @contrast.ilat
%756 = sub nsw i64 %755, 1
%757 = getelementptr inbounds double*, double** %754, i64 %756
%758 = load double*, double** %757
%759 = load i64, i64* @contrast.ilon
%760 = getelementptr inbounds double, double* %758, i64 %759
%761 = load double, double* %760
%762 = fcmp olt double %753, %761
br i1 %762, label %768, label %763
763: ; preds = %752, %740, %739
store double 0.000000e+00, double* @contrast.a1
%764 = load double, double* @contrast.dlon0
%765 = load double, double* @contrast.flat00
%766 = load double, double* @contrast.a4
%767 = call double @llvm.fmuladd.f64(double %764, double %765, double %766)
store double %767, double* @contrast.a4
br label %776
768: ; preds = %752, %741, %740, %739
%769 = load double, double* @contrast.dlon0
%770 = load double, double* @contrast.flat00
%771 = fmul double %769, %770
%772 = fdiv double %771, 2.000000e+00
store double %772, double* @contrast.a1
%773 = load double, double* @contrast.a1
%774 = load double, double* @contrast.a4
%775 = fadd double %774, %773
store double %775, double* @contrast.a4
br label %776
776: ; preds = %768, %763
%777 = load double**, double*** @contrast.xin
%778 = load i64, i64* @contrast.ilat
%779 = getelementptr inbounds double*, double** %777, i64 %778
%780 = load double*, double** %779
%781 = load i64, i64* @contrast.ilon
%782 = sub nsw i64 %781, 1
%783 = getelementptr inbounds double, double* %780, i64 %782
%784 = load double, double* %783
%785 = load double**, double*** @contrast.xin
%786 = load i64, i64* @contrast.ilat
%787 = getelementptr inbounds double*, double** %785, i64 %786
%788 = load double*, double** %787
%789 = load i64, i64* @contrast.ilon
%790 = sub nsw i64 %789, 1
%791 = getelementptr inbounds double, double* %788, i64 %790
%792 = load double, double* %791
%793 = fcmp une double %784, %792
br i1 %793, label %798, label %794
794: ; preds = %776
%795 = load double, double* %7
%796 = load double, double* %7
%797 = fcmp une double %795, %796
br i1 %797, label %798, label %822
798: ; preds = %794, %776
%799 = load double**, double*** @contrast.xin
%800 = load i64, i64* @contrast.ilat
%801 = getelementptr inbounds double*, double** %799, i64 %800
%802 = load double*, double** %801
%803 = load i64, i64* @contrast.ilon
%804 = sub nsw i64 %803, 1
%805 = getelementptr inbounds double, double* %802, i64 %804
%806 = load double, double* %805
%807 = load double**, double*** @contrast.xin
%808 = load i64, i64* @contrast.ilat
%809 = getelementptr inbounds double*, double** %807, i64 %808
%810 = load double*, double** %809
%811 = load i64, i64* @contrast.ilon
%812 = sub nsw i64 %811, 1
%813 = getelementptr inbounds double, double* %810, i64 %812
%814 = load double, double* %813
%815 = fcmp une double %806, %814
br i1 %815, label %816, label %821
816: ; preds = %798
%817 = load double, double* %7
%818 = load double, double* %7
%819 = fcmp une double %817, %818
br i1 %819, label %820, label %821
820: ; preds = %816
br i1 true, label %844, label %849
821: ; preds = %816, %798
br i1 false, label %844, label %849
822: ; preds = %794
%823 = load double**, double*** @contrast.xin
%824 = load i64, i64* @contrast.ilat
%825 = getelementptr inbounds double*, double** %823, i64 %824
%826 = load double*, double** %825
%827 = load i64, i64* @contrast.ilon
%828 = sub nsw i64 %827, 1
%829 = getelementptr inbounds double, double* %826, i64 %828
%830 = load double, double* %829
%831 = load double, double* %7
%832 = fcmp olt double %830, %831
br i1 %832, label %849, label %833
833: ; preds = %822
%834 = load double, double* %7
%835 = load double**, double*** @contrast.xin
%836 = load i64, i64* @contrast.ilat
%837 = getelementptr inbounds double*, double** %835, i64 %836
%838 = load double*, double** %837
%839 = load i64, i64* @contrast.ilon
%840 = sub nsw i64 %839, 1
%841 = getelementptr inbounds double, double* %838, i64 %840
%842 = load double, double* %841
%843 = fcmp olt double %834, %842
br i1 %843, label %849, label %844
844: ; preds = %833, %821, %820
store double 0.000000e+00, double* @contrast.a3
%845 = load double, double* @contrast.dlon0
%846 = load double, double* @contrast.flat01
%847 = load double, double* @contrast.a4
%848 = call double @llvm.fmuladd.f64(double %845, double %846, double %847)
store double %848, double* @contrast.a4
br label %857
849: ; preds = %833, %822, %821, %820
%850 = load double, double* @contrast.dlon0
%851 = load double, double* @contrast.flat01
%852 = fmul double %850, %851
%853 = fdiv double %852, 2.000000e+00
store double %853, double* @contrast.a3
%854 = load double, double* @contrast.a3
%855 = load double, double* @contrast.a4
%856 = fadd double %855, %854
store double %856, double* @contrast.a4
br label %857
857: ; preds = %849, %844
%858 = load double**, double*** @contrast.xin
%859 = load i64, i64* @contrast.ilat
%860 = sub nsw i64 %859, 1
%861 = getelementptr inbounds double*, double** %858, i64 %860
%862 = load double*, double** %861
%863 = load i64, i64* @contrast.ilon
%864 = sub nsw i64 %863, 1
%865 = getelementptr inbounds double, double* %862, i64 %864
%866 = load double, double* %865
%867 = load double**, double*** @contrast.xin
%868 = load i64, i64* @contrast.ilat
%869 = sub nsw i64 %868, 1
%870 = getelementptr inbounds double*, double** %867, i64 %869
%871 = load double*, double** %870
%872 = load i64, i64* @contrast.ilon
%873 = sub nsw i64 %872, 1
%874 = getelementptr inbounds double, double* %871, i64 %873
%875 = load double, double* %874
%876 = fcmp une double %866, %875
br i1 %876, label %881, label %877
877: ; preds = %857
%878 = load double, double* %7
%879 = load double, double* %7
%880 = fcmp une double %878, %879
br i1 %880, label %881, label %909
881: ; preds = %877, %857
%882 = load double**, double*** @contrast.xin
%883 = load i64, i64* @contrast.ilat
%884 = sub nsw i64 %883, 1
%885 = getelementptr inbounds double*, double** %882, i64 %884
%886 = load double*, double** %885
%887 = load i64, i64* @contrast.ilon
%888 = sub nsw i64 %887, 1
%889 = getelementptr inbounds double, double* %886, i64 %888
%890 = load double, double* %889
%891 = load double**, double*** @contrast.xin
%892 = load i64, i64* @contrast.ilat
%893 = sub nsw i64 %892, 1
%894 = getelementptr inbounds double*, double** %891, i64 %893
%895 = load double*, double** %894
%896 = load i64, i64* @contrast.ilon
%897 = sub nsw i64 %896, 1
%898 = getelementptr inbounds double, double* %895, i64 %897
%899 = load double, double* %898
%900 = fcmp une double %890, %899
br i1 %900, label %901, label %905
901: ; preds = %881
%902 = load double, double* %7
%903 = load double, double* %7
%904 = fcmp une double %902, %903
br label %905
905: ; preds = %901, %881
%906 = phi i1 [ false, %881 ], [ %904, %901 ]
%907 = zext i1 %906 to i64
%908 = select i1 %906, i32 1, i32 0
br label %937
909: ; preds = %877
%910 = load double**, double*** @contrast.xin
%911 = load i64, i64* @contrast.ilat
%912 = sub nsw i64 %911, 1
%913 = getelementptr inbounds double*, double** %910, i64 %912
%914 = load double*, double** %913
%915 = load i64, i64* @contrast.ilon
%916 = sub nsw i64 %915, 1
%917 = getelementptr inbounds double, double* %914, i64 %916
%918 = load double, double* %917
%919 = load double, double* %7
%920 = fcmp olt double %918, %919
br i1 %920, label %933, label %921
921: ; preds = %909
%922 = load double, double* %7
%923 = load double**, double*** @contrast.xin
%924 = load i64, i64* @contrast.ilat
%925 = sub nsw i64 %924, 1
%926 = getelementptr inbounds double*, double** %923, i64 %925
%927 = load double*, double** %926
%928 = load i64, i64* @contrast.ilon
%929 = sub nsw i64 %928, 1
%930 = getelementptr inbounds double, double* %927, i64 %929
%931 = load double, double* %930
%932 = fcmp olt double %922, %931
br label %933
933: ; preds = %921, %909
%934 = phi i1 [ true, %909 ], [ %932, %921 ]
%935 = xor i1 %934, true
%936 = zext i1 %935 to i32
br label %937
937: ; preds = %933, %905
%938 = phi i32 [ %908, %905 ], [ %936, %933 ]
%939 = sext i32 %938 to i64
%940 = getelementptr inbounds [2 x [2 x [2 x [4 x double]]]], [2 x [2 x [2 x [4 x double]]]]* @contrast.table, i64 0, i64 %939
%941 = load double**, double*** @contrast.xin
%942 = load i64, i64* @contrast.ilat
%943 = sub nsw i64 %942, 1
%944 = getelementptr inbounds double*, double** %941, i64 %943
%945 = load double*, double** %944
%946 = load i64, i64* @contrast.ilon
%947 = getelementptr inbounds double, double* %945, i64 %946
%948 = load double, double* %947
%949 = load double**, double*** @contrast.xin
%950 = load i64, i64* @contrast.ilat
%951 = sub nsw i64 %950, 1
%952 = getelementptr inbounds double*, double** %949, i64 %951
%953 = load double*, double** %952
%954 = load i64, i64* @contrast.ilon
%955 = getelementptr inbounds double, double* %953, i64 %954
%956 = load double, double* %955
%957 = fcmp une double %948, %956
br i1 %957, label %962, label %958
958: ; preds = %937
%959 = load double, double* %7
%960 = load double, double* %7
%961 = fcmp une double %959, %960
br i1 %961, label %962, label %988
962: ; preds = %958, %937
%963 = load double**, double*** @contrast.xin
%964 = load i64, i64* @contrast.ilat
%965 = sub nsw i64 %964, 1
%966 = getelementptr inbounds double*, double** %963, i64 %965
%967 = load double*, double** %966
%968 = load i64, i64* @contrast.ilon
%969 = getelementptr inbounds double, double* %967, i64 %968
%970 = load double, double* %969
%971 = load double**, double*** @contrast.xin
%972 = load i64, i64* @contrast.ilat
%973 = sub nsw i64 %972, 1
%974 = getelementptr inbounds double*, double** %971, i64 %973
%975 = load double*, double** %974
%976 = load i64, i64* @contrast.ilon
%977 = getelementptr inbounds double, double* %975, i64 %976
%978 = load double, double* %977
%979 = fcmp une double %970, %978
br i1 %979, label %980, label %984
980: ; preds = %962
%981 = load double, double* %7
%982 = load double, double* %7
%983 = fcmp une double %981, %982
br label %984
984: ; preds = %980, %962
%985 = phi i1 [ false, %962 ], [ %983, %980 ]
%986 = zext i1 %985 to i64
%987 = select i1 %985, i32 1, i32 0
br label %1014
988: ; preds = %958
%989 = load double**, double*** @contrast.xin
%990 = load i64, i64* @contrast.ilat
%991 = sub nsw i64 %990, 1
%992 = getelementptr inbounds double*, double** %989, i64 %991
%993 = load double*, double** %992
%994 = load i64, i64* @contrast.ilon
%995 = getelementptr inbounds double, double* %993, i64 %994
%996 = load double, double* %995
%997 = load double, double* %7
%998 = fcmp olt double %996, %997
br i1 %998, label %1010, label %999
999: ; preds = %988
%1000 = load double, double* %7
%1001 = load double**, double*** @contrast.xin
%1002 = load i64, i64* @contrast.ilat
%1003 = sub nsw i64 %1002, 1
%1004 = getelementptr inbounds double*, double** %1001, i64 %1003
%1005 = load double*, double** %1004
%1006 = load i64, i64* @contrast.ilon
%1007 = getelementptr inbounds double, double* %1005, i64 %1006
%1008 = load double, double* %1007
%1009 = fcmp olt double %1000, %1008
br label %1010
1010: ; preds = %999, %988
%1011 = phi i1 [ true, %988 ], [ %1009, %999 ]
%1012 = xor i1 %1011, true
%1013 = zext i1 %1012 to i32
br label %1014
1014: ; preds = %1010, %984
%1015 = phi i32 [ %987, %984 ], [ %1013, %1010 ]
%1016 = sext i32 %1015 to i64
%1017 = getelementptr inbounds [2 x [2 x [4 x double]]], [2 x [2 x [4 x double]]]* %940, i64 0, i64 %1016
%1018 = load double**, double*** @contrast.xin
%1019 = load i64, i64* @contrast.ilat
%1020 = getelementptr inbounds double*, double** %1018, i64 %1019
%1021 = load double*, double** %1020
%1022 = load i64, i64* @contrast.ilon
%1023 = sub nsw i64 %1022, 1
%1024 = getelementptr inbounds double, double* %1021, i64 %1023
%1025 = load double, double* %1024
%1026 = load double**, double*** @contrast.xin
%1027 = load i64, i64* @contrast.ilat
%1028 = getelementptr inbounds double*, double** %1026, i64 %1027
%1029 = load double*, double** %1028
%1030 = load i64, i64* @contrast.ilon
%1031 = sub nsw i64 %1030, 1
%1032 = getelementptr inbounds double, double* %1029, i64 %1031
%1033 = load double, double* %1032
%1034 = fcmp une double %1025, %1033
br i1 %1034, label %1039, label %1035
1035: ; preds = %1014
%1036 = load double, double* %7
%1037 = load double, double* %7
%1038 = fcmp une double %1036, %1037
br i1 %1038, label %1039, label %1065
1039: ; preds = %1035, %1014
%1040 = load double**, double*** @contrast.xin
%1041 = load i64, i64* @contrast.ilat
%1042 = getelementptr inbounds double*, double** %1040, i64 %1041
%1043 = load double*, double** %1042
%1044 = load i64, i64* @contrast.ilon
%1045 = sub nsw i64 %1044, 1
%1046 = getelementptr inbounds double, double* %1043, i64 %1045
%1047 = load double, double* %1046
%1048 = load double**, double*** @contrast.xin
%1049 = load i64, i64* @contrast.ilat
%1050 = getelementptr inbounds double*, double** %1048, i64 %1049
%1051 = load double*, double** %1050
%1052 = load i64, i64* @contrast.ilon
%1053 = sub nsw i64 %1052, 1
%1054 = getelementptr inbounds double, double* %1051, i64 %1053
%1055 = load double, double* %1054
%1056 = fcmp une double %1047, %1055
br i1 %1056, label %1057, label %1061
1057: ; preds = %1039
%1058 = load double, double* %7
%1059 = load double, double* %7
%1060 = fcmp une double %1058, %1059
br label %1061
1061: ; preds = %1057, %1039
%1062 = phi i1 [ false, %1039 ], [ %1060, %1057 ]
%1063 = zext i1 %1062 to i64
%1064 = select i1 %1062, i32 1, i32 0
br label %1091
1065: ; preds = %1035
%1066 = load double**, double*** @contrast.xin
%1067 = load i64, i64* @contrast.ilat
%1068 = getelementptr inbounds double*, double** %1066, i64 %1067
%1069 = load double*, double** %1068
%1070 = load i64, i64* @contrast.ilon
%1071 = sub nsw i64 %1070, 1
%1072 = getelementptr inbounds double, double* %1069, i64 %1071
%1073 = load double, double* %1072
%1074 = load double, double* %7
%1075 = fcmp olt double %1073, %1074
br i1 %1075, label %1087, label %1076
1076: ; preds = %1065
%1077 = load double, double* %7
%1078 = load double**, double*** @contrast.xin
%1079 = load i64, i64* @contrast.ilat
%1080 = getelementptr inbounds double*, double** %1078, i64 %1079
%1081 = load double*, double** %1080
%1082 = load i64, i64* @contrast.ilon
%1083 = sub nsw i64 %1082, 1
%1084 = getelementptr inbounds double, double* %1081, i64 %1083
%1085 = load double, double* %1084
%1086 = fcmp olt double %1077, %1085
br label %1087
1087: ; preds = %1076, %1065
%1088 = phi i1 [ true, %1065 ], [ %1086, %1076 ]
%1089 = xor i1 %1088, true
%1090 = zext i1 %1089 to i32
br label %1091
1091: ; preds = %1087, %1061
%1092 = phi i32 [ %1064, %1061 ], [ %1090, %1087 ]
%1093 = sext i32 %1092 to i64
%1094 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %1017, i64 0, i64 %1093
%1095 = getelementptr inbounds [4 x double], [4 x double]* %1094, i64 0, i64 0
store double* %1095, double** @contrast.case_table
%1096 = load double, double* @contrast.dlon0
%1097 = load double, double* @contrast.flat00
%1098 = fmul double %1096, %1097
store double %1098, double* @contrast.f
%1099 = load double*, double** @contrast.case_table
%1100 = getelementptr inbounds double, double* %1099, i64 0
%1101 = load double, double* %1100
%1102 = load double, double* @contrast.f
%1103 = fmul double %1101, %1102
store double %1103, double* @contrast.a0
%1104 = load double*, double** @contrast.case_table
%1105 = getelementptr inbounds double, double* %1104, i64 1
%1106 = load double, double* %1105
%1107 = load double, double* @contrast.f
%1108 = load double, double* @contrast.a1
%1109 = call double @llvm.fmuladd.f64(double %1106, double %1107, double %1108)
store double %1109, double* @contrast.a1
%1110 = load double*, double** @contrast.case_table
%1111 = getelementptr inbounds double, double* %1110, i64 2
%1112 = load double, double* %1111
%1113 = load double, double* @contrast.f
%1114 = load double, double* @contrast.a3
%1115 = call double @llvm.fmuladd.f64(double %1112, double %1113, double %1114)
store double %1115, double* @contrast.a3
%1116 = load double*, double** @contrast.case_table
%1117 = getelementptr inbounds double, double* %1116, i64 3
%1118 = load double, double* %1117
%1119 = load double, double* @contrast.f
%1120 = load double, double* @contrast.a4
%1121 = call double @llvm.fmuladd.f64(double %1118, double %1119, double %1120)
store double %1121, double* @contrast.a4
%1122 = load double, double* @contrast.a0
%1123 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 0)
%1124 = load i64, i64* @contrast.ilat
%1125 = getelementptr inbounds double*, double** %1123, i64 %1124
%1126 = load double*, double** %1125
%1127 = load i64, i64* @contrast.ilon
%1128 = getelementptr inbounds double, double* %1126, i64 %1127
store double %1122, double* %1128
%1129 = load double, double* @contrast.a1
%1130 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 1)
%1131 = load i64, i64* @contrast.ilat
%1132 = getelementptr inbounds double*, double** %1130, i64 %1131
%1133 = load double*, double** %1132
%1134 = load i64, i64* @contrast.ilon
%1135 = getelementptr inbounds double, double* %1133, i64 %1134
store double %1129, double* %1135
%1136 = load double, double* @contrast.a3
%1137 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 3)
%1138 = load i64, i64* @contrast.ilat
%1139 = getelementptr inbounds double*, double** %1137, i64 %1138
%1140 = load double*, double** %1139
%1141 = load i64, i64* @contrast.ilon
%1142 = getelementptr inbounds double, double* %1140, i64 %1141
store double %1136, double* %1142
%1143 = load double, double* @contrast.a4
%1144 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 4)
%1145 = load i64, i64* @contrast.ilat
%1146 = getelementptr inbounds double*, double** %1144, i64 %1145
%1147 = load double*, double** %1146
%1148 = load i64, i64* @contrast.ilon
%1149 = getelementptr inbounds double, double* %1147, i64 %1148
store double %1143, double* %1149
%1150 = load double, double* @contrast.dlon1
%1151 = load double, double* @contrast.flat01
%1152 = fmul double %1150, %1151
store double %1152, double* @contrast.a4
%1153 = load double**, double*** @contrast.xin
%1154 = load i64, i64* @contrast.ilat
%1155 = sub nsw i64 %1154, 1
%1156 = getelementptr inbounds double*, double** %1153, i64 %1155
%1157 = load double*, double** %1156
%1158 = load i64, i64* @contrast.ilon
%1159 = getelementptr inbounds double, double* %1157, i64 %1158
%1160 = load double, double* %1159
%1161 = load double**, double*** @contrast.xin
%1162 = load i64, i64* @contrast.ilat
%1163 = sub nsw i64 %1162, 1
%1164 = getelementptr inbounds double*, double** %1161, i64 %1163
%1165 = load double*, double** %1164
%1166 = load i64, i64* @contrast.ilon
%1167 = getelementptr inbounds double, double* %1165, i64 %1166
%1168 = load double, double* %1167
%1169 = fcmp une double %1160, %1168
br i1 %1169, label %1174, label %1170
1170: ; preds = %1091
%1171 = load double, double* %7
%1172 = load double, double* %7
%1173 = fcmp une double %1171, %1172
br i1 %1173, label %1174, label %1198
1174: ; preds = %1170, %1091
%1175 = load double**, double*** @contrast.xin
%1176 = load i64, i64* @contrast.ilat
%1177 = sub nsw i64 %1176, 1
%1178 = getelementptr inbounds double*, double** %1175, i64 %1177
%1179 = load double*, double** %1178
%1180 = load i64, i64* @contrast.ilon
%1181 = getelementptr inbounds double, double* %1179, i64 %1180
%1182 = load double, double* %1181
%1183 = load double**, double*** @contrast.xin
%1184 = load i64, i64* @contrast.ilat
%1185 = sub nsw i64 %1184, 1
%1186 = getelementptr inbounds double*, double** %1183, i64 %1185
%1187 = load double*, double** %1186
%1188 = load i64, i64* @contrast.ilon
%1189 = getelementptr inbounds double, double* %1187, i64 %1188
%1190 = load double, double* %1189
%1191 = fcmp une double %1182, %1190
br i1 %1191, label %1192, label %1197
1192: ; preds = %1174
%1193 = load double, double* %7
%1194 = load double, double* %7
%1195 = fcmp une double %1193, %1194
br i1 %1195, label %1196, label %1197
1196: ; preds = %1192
br i1 true, label %1220, label %1225
1197: ; preds = %1192, %1174
br i1 false, label %1220, label %1225
1198: ; preds = %1170
%1199 = load double**, double*** @contrast.xin
%1200 = load i64, i64* @contrast.ilat
%1201 = sub nsw i64 %1200, 1
%1202 = getelementptr inbounds double*, double** %1199, i64 %1201
%1203 = load double*, double** %1202
%1204 = load i64, i64* @contrast.ilon
%1205 = getelementptr inbounds double, double* %1203, i64 %1204
%1206 = load double, double* %1205
%1207 = load double, double* %7
%1208 = fcmp olt double %1206, %1207
br i1 %1208, label %1225, label %1209
1209: ; preds = %1198
%1210 = load double, double* %7
%1211 = load double**, double*** @contrast.xin
%1212 = load i64, i64* @contrast.ilat
%1213 = sub nsw i64 %1212, 1
%1214 = getelementptr inbounds double*, double** %1211, i64 %1213
%1215 = load double*, double** %1214
%1216 = load i64, i64* @contrast.ilon
%1217 = getelementptr inbounds double, double* %1215, i64 %1216
%1218 = load double, double* %1217
%1219 = fcmp olt double %1210, %1218
br i1 %1219, label %1225, label %1220
1220: ; preds = %1209, %1197, %1196
store double 0.000000e+00, double* @contrast.a1
%1221 = load double, double* @contrast.dlon1
%1222 = load double, double* @contrast.flat00
%1223 = load double, double* @contrast.a4
%1224 = call double @llvm.fmuladd.f64(double %1221, double %1222, double %1223)
store double %1224, double* @contrast.a4
br label %1233
1225: ; preds = %1209, %1198, %1197, %1196
%1226 = load double, double* @contrast.dlon1
%1227 = load double, double* @contrast.flat00
%1228 = fmul double %1226, %1227
%1229 = fdiv double %1228, 2.000000e+00
store double %1229, double* @contrast.a1
%1230 = load double, double* @contrast.a1
%1231 = load double, double* @contrast.a4
%1232 = fadd double %1231, %1230
store double %1232, double* @contrast.a4
br label %1233
1233: ; preds = %1225, %1220
%1234 = load double**, double*** @contrast.xin
%1235 = load i64, i64* @contrast.ilat
%1236 = getelementptr inbounds double*, double** %1234, i64 %1235
%1237 = load double*, double** %1236
%1238 = load i64, i64* @contrast.ilon
%1239 = add nsw i64 %1238, 1
%1240 = getelementptr inbounds double, double* %1237, i64 %1239
%1241 = load double, double* %1240
%1242 = load double**, double*** @contrast.xin
%1243 = load i64, i64* @contrast.ilat
%1244 = getelementptr inbounds double*, double** %1242, i64 %1243
%1245 = load double*, double** %1244
%1246 = load i64, i64* @contrast.ilon
%1247 = add nsw i64 %1246, 1
%1248 = getelementptr inbounds double, double* %1245, i64 %1247
%1249 = load double, double* %1248
%1250 = fcmp une double %1241, %1249
br i1 %1250, label %1255, label %1251
1251: ; preds = %1233
%1252 = load double, double* %7
%1253 = load double, double* %7
%1254 = fcmp une double %1252, %1253
br i1 %1254, label %1255, label %1279
1255: ; preds = %1251, %1233
%1256 = load double**, double*** @contrast.xin
%1257 = load i64, i64* @contrast.ilat
%1258 = getelementptr inbounds double*, double** %1256, i64 %1257
%1259 = load double*, double** %1258
%1260 = load i64, i64* @contrast.ilon
%1261 = add nsw i64 %1260, 1
%1262 = getelementptr inbounds double, double* %1259, i64 %1261
%1263 = load double, double* %1262
%1264 = load double**, double*** @contrast.xin
%1265 = load i64, i64* @contrast.ilat
%1266 = getelementptr inbounds double*, double** %1264, i64 %1265
%1267 = load double*, double** %1266
%1268 = load i64, i64* @contrast.ilon
%1269 = add nsw i64 %1268, 1
%1270 = getelementptr inbounds double, double* %1267, i64 %1269
%1271 = load double, double* %1270
%1272 = fcmp une double %1263, %1271
br i1 %1272, label %1273, label %1278
1273: ; preds = %1255
%1274 = load double, double* %7
%1275 = load double, double* %7
%1276 = fcmp une double %1274, %1275
br i1 %1276, label %1277, label %1278
1277: ; preds = %1273
br i1 true, label %1301, label %1306
1278: ; preds = %1273, %1255
br i1 false, label %1301, label %1306
1279: ; preds = %1251
%1280 = load double**, double*** @contrast.xin
%1281 = load i64, i64* @contrast.ilat
%1282 = getelementptr inbounds double*, double** %1280, i64 %1281
%1283 = load double*, double** %1282
%1284 = load i64, i64* @contrast.ilon
%1285 = add nsw i64 %1284, 1
%1286 = getelementptr inbounds double, double* %1283, i64 %1285
%1287 = load double, double* %1286
%1288 = load double, double* %7
%1289 = fcmp olt double %1287, %1288
br i1 %1289, label %1306, label %1290
1290: ; preds = %1279
%1291 = load double, double* %7
%1292 = load double**, double*** @contrast.xin
%1293 = load i64, i64* @contrast.ilat
%1294 = getelementptr inbounds double*, double** %1292, i64 %1293
%1295 = load double*, double** %1294
%1296 = load i64, i64* @contrast.ilon
%1297 = add nsw i64 %1296, 1
%1298 = getelementptr inbounds double, double* %1295, i64 %1297
%1299 = load double, double* %1298
%1300 = fcmp olt double %1291, %1299
br i1 %1300, label %1306, label %1301
1301: ; preds = %1290, %1278, %1277
store double 0.000000e+00, double* @contrast.a5
%1302 = load double, double* @contrast.dlon1
%1303 = load double, double* @contrast.flat01
%1304 = load double, double* @contrast.a4
%1305 = call double @llvm.fmuladd.f64(double %1302, double %1303, double %1304)
store double %1305, double* @contrast.a4
br label %1314
1306: ; preds = %1290, %1279, %1278, %1277
%1307 = load double, double* @contrast.dlon1
%1308 = load double, double* @contrast.flat01
%1309 = fmul double %1307, %1308
%1310 = fdiv double %1309, 2.000000e+00
store double %1310, double* @contrast.a5
%1311 = load double, double* @contrast.a5
%1312 = load double, double* @contrast.a4
%1313 = fadd double %1312, %1311
store double %1313, double* @contrast.a4
br label %1314
1314: ; preds = %1306, %1301
%1315 = load double**, double*** @contrast.xin
%1316 = load i64, i64* @contrast.ilat
%1317 = sub nsw i64 %1316, 1
%1318 = getelementptr inbounds double*, double** %1315, i64 %1317
%1319 = load double*, double** %1318
%1320 = load i64, i64* @contrast.ilon
%1321 = add nsw i64 %1320, 1
%1322 = getelementptr inbounds double, double* %1319, i64 %1321
%1323 = load double, double* %1322
%1324 = load double**, double*** @contrast.xin
%1325 = load i64, i64* @contrast.ilat
%1326 = sub nsw i64 %1325, 1
%1327 = getelementptr inbounds double*, double** %1324, i64 %1326
%1328 = load double*, double** %1327
%1329 = load i64, i64* @contrast.ilon
%1330 = add nsw i64 %1329, 1
%1331 = getelementptr inbounds double, double* %1328, i64 %1330
%1332 = load double, double* %1331
%1333 = fcmp une double %1323, %1332
br i1 %1333, label %1338, label %1334
1334: ; preds = %1314
%1335 = load double, double* %7
%1336 = load double, double* %7
%1337 = fcmp une double %1335, %1336
br i1 %1337, label %1338, label %1366
1338: ; preds = %1334, %1314
%1339 = load double**, double*** @contrast.xin
%1340 = load i64, i64* @contrast.ilat
%1341 = sub nsw i64 %1340, 1
%1342 = getelementptr inbounds double*, double** %1339, i64 %1341
%1343 = load double*, double** %1342
%1344 = load i64, i64* @contrast.ilon
%1345 = add nsw i64 %1344, 1
%1346 = getelementptr inbounds double, double* %1343, i64 %1345
%1347 = load double, double* %1346
%1348 = load double**, double*** @contrast.xin
%1349 = load i64, i64* @contrast.ilat
%1350 = sub nsw i64 %1349, 1
%1351 = getelementptr inbounds double*, double** %1348, i64 %1350
%1352 = load double*, double** %1351
%1353 = load i64, i64* @contrast.ilon
%1354 = add nsw i64 %1353, 1
%1355 = getelementptr inbounds double, double* %1352, i64 %1354
%1356 = load double, double* %1355
%1357 = fcmp une double %1347, %1356
br i1 %1357, label %1358, label %1362
1358: ; preds = %1338
%1359 = load double, double* %7
%1360 = load double, double* %7
%1361 = fcmp une double %1359, %1360
br label %1362
1362: ; preds = %1358, %1338
%1363 = phi i1 [ false, %1338 ], [ %1361, %1358 ]
%1364 = zext i1 %1363 to i64
%1365 = select i1 %1363, i32 1, i32 0
br label %1394
1366: ; preds = %1334
%1367 = load double**, double*** @contrast.xin
%1368 = load i64, i64* @contrast.ilat
%1369 = sub nsw i64 %1368, 1
%1370 = getelementptr inbounds double*, double** %1367, i64 %1369
%1371 = load double*, double** %1370
%1372 = load i64, i64* @contrast.ilon
%1373 = add nsw i64 %1372, 1
%1374 = getelementptr inbounds double, double* %1371, i64 %1373
%1375 = load double, double* %1374
%1376 = load double, double* %7
%1377 = fcmp olt double %1375, %1376
br i1 %1377, label %1390, label %1378
1378: ; preds = %1366
%1379 = load double, double* %7
%1380 = load double**, double*** @contrast.xin
%1381 = load i64, i64* @contrast.ilat
%1382 = sub nsw i64 %1381, 1
%1383 = getelementptr inbounds double*, double** %1380, i64 %1382
%1384 = load double*, double** %1383
%1385 = load i64, i64* @contrast.ilon
%1386 = add nsw i64 %1385, 1
%1387 = getelementptr inbounds double, double* %1384, i64 %1386
%1388 = load double, double* %1387
%1389 = fcmp olt double %1379, %1388
br label %1390
1390: ; preds = %1378, %1366
%1391 = phi i1 [ true, %1366 ], [ %1389, %1378 ]
%1392 = xor i1 %1391, true
%1393 = zext i1 %1392 to i32
br label %1394
1394: ; preds = %1390, %1362
%1395 = phi i32 [ %1365, %1362 ], [ %1393, %1390 ]
%1396 = sext i32 %1395 to i64
%1397 = getelementptr inbounds [2 x [2 x [2 x [4 x double]]]], [2 x [2 x [2 x [4 x double]]]]* @contrast.table, i64 0, i64 %1396
%1398 = load double**, double*** @contrast.xin
%1399 = load i64, i64* @contrast.ilat
%1400 = sub nsw i64 %1399, 1
%1401 = getelementptr inbounds double*, double** %1398, i64 %1400
%1402 = load double*, double** %1401
%1403 = load i64, i64* @contrast.ilon
%1404 = getelementptr inbounds double, double* %1402, i64 %1403
%1405 = load double, double* %1404
%1406 = load double**, double*** @contrast.xin
%1407 = load i64, i64* @contrast.ilat
%1408 = sub nsw i64 %1407, 1
%1409 = getelementptr inbounds double*, double** %1406, i64 %1408
%1410 = load double*, double** %1409
%1411 = load i64, i64* @contrast.ilon
%1412 = getelementptr inbounds double, double* %1410, i64 %1411
%1413 = load double, double* %1412
%1414 = fcmp une double %1405, %1413
br i1 %1414, label %1419, label %1415
1415: ; preds = %1394
%1416 = load double, double* %7
%1417 = load double, double* %7
%1418 = fcmp une double %1416, %1417
br i1 %1418, label %1419, label %1445
1419: ; preds = %1415, %1394
%1420 = load double**, double*** @contrast.xin
%1421 = load i64, i64* @contrast.ilat
%1422 = sub nsw i64 %1421, 1
%1423 = getelementptr inbounds double*, double** %1420, i64 %1422
%1424 = load double*, double** %1423
%1425 = load i64, i64* @contrast.ilon
%1426 = getelementptr inbounds double, double* %1424, i64 %1425
%1427 = load double, double* %1426
%1428 = load double**, double*** @contrast.xin
%1429 = load i64, i64* @contrast.ilat
%1430 = sub nsw i64 %1429, 1
%1431 = getelementptr inbounds double*, double** %1428, i64 %1430
%1432 = load double*, double** %1431
%1433 = load i64, i64* @contrast.ilon
%1434 = getelementptr inbounds double, double* %1432, i64 %1433
%1435 = load double, double* %1434
%1436 = fcmp une double %1427, %1435
br i1 %1436, label %1437, label %1441
1437: ; preds = %1419
%1438 = load double, double* %7
%1439 = load double, double* %7
%1440 = fcmp une double %1438, %1439
br label %1441
1441: ; preds = %1437, %1419
%1442 = phi i1 [ false, %1419 ], [ %1440, %1437 ]
%1443 = zext i1 %1442 to i64
%1444 = select i1 %1442, i32 1, i32 0
br label %1471
1445: ; preds = %1415
%1446 = load double**, double*** @contrast.xin
%1447 = load i64, i64* @contrast.ilat
%1448 = sub nsw i64 %1447, 1
%1449 = getelementptr inbounds double*, double** %1446, i64 %1448
%1450 = load double*, double** %1449
%1451 = load i64, i64* @contrast.ilon
%1452 = getelementptr inbounds double, double* %1450, i64 %1451
%1453 = load double, double* %1452
%1454 = load double, double* %7
%1455 = fcmp olt double %1453, %1454
br i1 %1455, label %1467, label %1456
1456: ; preds = %1445
%1457 = load double, double* %7
%1458 = load double**, double*** @contrast.xin
%1459 = load i64, i64* @contrast.ilat
%1460 = sub nsw i64 %1459, 1
%1461 = getelementptr inbounds double*, double** %1458, i64 %1460
%1462 = load double*, double** %1461
%1463 = load i64, i64* @contrast.ilon
%1464 = getelementptr inbounds double, double* %1462, i64 %1463
%1465 = load double, double* %1464
%1466 = fcmp olt double %1457, %1465
br label %1467
1467: ; preds = %1456, %1445
%1468 = phi i1 [ true, %1445 ], [ %1466, %1456 ]
%1469 = xor i1 %1468, true
%1470 = zext i1 %1469 to i32
br label %1471
1471: ; preds = %1467, %1441
%1472 = phi i32 [ %1444, %1441 ], [ %1470, %1467 ]
%1473 = sext i32 %1472 to i64
%1474 = getelementptr inbounds [2 x [2 x [4 x double]]], [2 x [2 x [4 x double]]]* %1397, i64 0, i64 %1473
%1475 = load double**, double*** @contrast.xin
%1476 = load i64, i64* @contrast.ilat
%1477 = getelementptr inbounds double*, double** %1475, i64 %1476
%1478 = load double*, double** %1477
%1479 = load i64, i64* @contrast.ilon
%1480 = add nsw i64 %1479, 1
%1481 = getelementptr inbounds double, double* %1478, i64 %1480
%1482 = load double, double* %1481
%1483 = load double**, double*** @contrast.xin
%1484 = load i64, i64* @contrast.ilat
%1485 = getelementptr inbounds double*, double** %1483, i64 %1484
%1486 = load double*, double** %1485
%1487 = load i64, i64* @contrast.ilon
%1488 = add nsw i64 %1487, 1
%1489 = getelementptr inbounds double, double* %1486, i64 %1488
%1490 = load double, double* %1489
%1491 = fcmp une double %1482, %1490
br i1 %1491, label %1496, label %1492
1492: ; preds = %1471
%1493 = load double, double* %7
%1494 = load double, double* %7
%1495 = fcmp une double %1493, %1494
br i1 %1495, label %1496, label %1522
1496: ; preds = %1492, %1471
%1497 = load double**, double*** @contrast.xin
%1498 = load i64, i64* @contrast.ilat
%1499 = getelementptr inbounds double*, double** %1497, i64 %1498
%1500 = load double*, double** %1499
%1501 = load i64, i64* @contrast.ilon
%1502 = add nsw i64 %1501, 1
%1503 = getelementptr inbounds double, double* %1500, i64 %1502
%1504 = load double, double* %1503
%1505 = load double**, double*** @contrast.xin
%1506 = load i64, i64* @contrast.ilat
%1507 = getelementptr inbounds double*, double** %1505, i64 %1506
%1508 = load double*, double** %1507
%1509 = load i64, i64* @contrast.ilon
%1510 = add nsw i64 %1509, 1
%1511 = getelementptr inbounds double, double* %1508, i64 %1510
%1512 = load double, double* %1511
%1513 = fcmp une double %1504, %1512
br i1 %1513, label %1514, label %1518
1514: ; preds = %1496
%1515 = load double, double* %7
%1516 = load double, double* %7
%1517 = fcmp une double %1515, %1516
br label %1518
1518: ; preds = %1514, %1496
%1519 = phi i1 [ false, %1496 ], [ %1517, %1514 ]
%1520 = zext i1 %1519 to i64
%1521 = select i1 %1519, i32 1, i32 0
br label %1548
1522: ; preds = %1492
%1523 = load double**, double*** @contrast.xin
%1524 = load i64, i64* @contrast.ilat
%1525 = getelementptr inbounds double*, double** %1523, i64 %1524
%1526 = load double*, double** %1525
%1527 = load i64, i64* @contrast.ilon
%1528 = add nsw i64 %1527, 1
%1529 = getelementptr inbounds double, double* %1526, i64 %1528
%1530 = load double, double* %1529
%1531 = load double, double* %7
%1532 = fcmp olt double %1530, %1531
br i1 %1532, label %1544, label %1533
1533: ; preds = %1522
%1534 = load double, double* %7
%1535 = load double**, double*** @contrast.xin
%1536 = load i64, i64* @contrast.ilat
%1537 = getelementptr inbounds double*, double** %1535, i64 %1536
%1538 = load double*, double** %1537
%1539 = load i64, i64* @contrast.ilon
%1540 = add nsw i64 %1539, 1
%1541 = getelementptr inbounds double, double* %1538, i64 %1540
%1542 = load double, double* %1541
%1543 = fcmp olt double %1534, %1542
br label %1544
1544: ; preds = %1533, %1522
%1545 = phi i1 [ true, %1522 ], [ %1543, %1533 ]
%1546 = xor i1 %1545, true
%1547 = zext i1 %1546 to i32
br label %1548
1548: ; preds = %1544, %1518
%1549 = phi i32 [ %1521, %1518 ], [ %1547, %1544 ]
%1550 = sext i32 %1549 to i64
%1551 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %1474, i64 0, i64 %1550
%1552 = getelementptr inbounds [4 x double], [4 x double]* %1551, i64 0, i64 0
store double* %1552, double** @contrast.case_table
%1553 = load double, double* @contrast.dlon1
%1554 = load double, double* @contrast.flat00
%1555 = fmul double %1553, %1554
store double %1555, double* @contrast.f
%1556 = load double*, double** @contrast.case_table
%1557 = getelementptr inbounds double, double* %1556, i64 0
%1558 = load double, double* %1557
%1559 = load double, double* @contrast.f
%1560 = fmul double %1558, %1559
store double %1560, double* @contrast.a2
%1561 = load double*, double** @contrast.case_table
%1562 = getelementptr inbounds double, double* %1561, i64 1
%1563 = load double, double* %1562
%1564 = load double, double* @contrast.f
%1565 = load double, double* @contrast.a1
%1566 = call double @llvm.fmuladd.f64(double %1563, double %1564, double %1565)
store double %1566, double* @contrast.a1
%1567 = load double*, double** @contrast.case_table
%1568 = getelementptr inbounds double, double* %1567, i64 2
%1569 = load double, double* %1568
%1570 = load double, double* @contrast.f
%1571 = load double, double* @contrast.a5
%1572 = call double @llvm.fmuladd.f64(double %1569, double %1570, double %1571)
store double %1572, double* @contrast.a5
%1573 = load double*, double** @contrast.case_table
%1574 = getelementptr inbounds double, double* %1573, i64 3
%1575 = load double, double* %1574
%1576 = load double, double* @contrast.f
%1577 = load double, double* @contrast.a4
%1578 = call double @llvm.fmuladd.f64(double %1575, double %1576, double %1577)
store double %1578, double* @contrast.a4
%1579 = load double, double* @contrast.a2
%1580 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 2)
%1581 = load i64, i64* @contrast.ilat
%1582 = getelementptr inbounds double*, double** %1580, i64 %1581
%1583 = load double*, double** %1582
%1584 = load i64, i64* @contrast.ilon
%1585 = getelementptr inbounds double, double* %1583, i64 %1584
%1586 = load double, double* %1585
%1587 = fadd double %1586, %1579
store double %1587, double* %1585
%1588 = load double, double* @contrast.a1
%1589 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 1)
%1590 = load i64, i64* @contrast.ilat
%1591 = getelementptr inbounds double*, double** %1589, i64 %1590
%1592 = load double*, double** %1591
%1593 = load i64, i64* @contrast.ilon
%1594 = getelementptr inbounds double, double* %1592, i64 %1593
%1595 = load double, double* %1594
%1596 = fadd double %1595, %1588
store double %1596, double* %1594
%1597 = load double, double* @contrast.a5
%1598 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 5)
%1599 = load i64, i64* @contrast.ilat
%1600 = getelementptr inbounds double*, double** %1598, i64 %1599
%1601 = load double*, double** %1600
%1602 = load i64, i64* @contrast.ilon
%1603 = getelementptr inbounds double, double* %1601, i64 %1602
%1604 = load double, double* %1603
%1605 = fadd double %1604, %1597
store double %1605, double* %1603
%1606 = load double, double* @contrast.a4
%1607 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 4)
%1608 = load i64, i64* @contrast.ilat
%1609 = getelementptr inbounds double*, double** %1607, i64 %1608
%1610 = load double*, double** %1609
%1611 = load i64, i64* @contrast.ilon
%1612 = getelementptr inbounds double, double* %1610, i64 %1611
%1613 = load double, double* %1612
%1614 = fadd double %1613, %1606
store double %1614, double* %1612
%1615 = load double, double* @contrast.dlon0
%1616 = load double, double* @contrast.flat10
%1617 = fmul double %1615, %1616
store double %1617, double* @contrast.a4
%1618 = load double**, double*** @contrast.xin
%1619 = load i64, i64* @contrast.ilat
%1620 = add nsw i64 %1619, 1
%1621 = getelementptr inbounds double*, double** %1618, i64 %1620
%1622 = load double*, double** %1621
%1623 = load i64, i64* @contrast.ilon
%1624 = getelementptr inbounds double, double* %1622, i64 %1623
%1625 = load double, double* %1624
%1626 = load double**, double*** @contrast.xin
%1627 = load i64, i64* @contrast.ilat
%1628 = add nsw i64 %1627, 1
%1629 = getelementptr inbounds double*, double** %1626, i64 %1628
%1630 = load double*, double** %1629
%1631 = load i64, i64* @contrast.ilon
%1632 = getelementptr inbounds double, double* %1630, i64 %1631
%1633 = load double, double* %1632
%1634 = fcmp une double %1625, %1633
br i1 %1634, label %1639, label %1635
1635: ; preds = %1548
%1636 = load double, double* %7
%1637 = load double, double* %7
%1638 = fcmp une double %1636, %1637
br i1 %1638, label %1639, label %1663
1639: ; preds = %1635, %1548
%1640 = load double**, double*** @contrast.xin
%1641 = load i64, i64* @contrast.ilat
%1642 = add nsw i64 %1641, 1
%1643 = getelementptr inbounds double*, double** %1640, i64 %1642
%1644 = load double*, double** %1643
%1645 = load i64, i64* @contrast.ilon
%1646 = getelementptr inbounds double, double* %1644, i64 %1645
%1647 = load double, double* %1646
%1648 = load double**, double*** @contrast.xin
%1649 = load i64, i64* @contrast.ilat
%1650 = add nsw i64 %1649, 1
%1651 = getelementptr inbounds double*, double** %1648, i64 %1650
%1652 = load double*, double** %1651
%1653 = load i64, i64* @contrast.ilon
%1654 = getelementptr inbounds double, double* %1652, i64 %1653
%1655 = load double, double* %1654
%1656 = fcmp une double %1647, %1655
br i1 %1656, label %1657, label %1662
1657: ; preds = %1639
%1658 = load double, double* %7
%1659 = load double, double* %7
%1660 = fcmp une double %1658, %1659
br i1 %1660, label %1661, label %1662
1661: ; preds = %1657
br i1 true, label %1685, label %1690
1662: ; preds = %1657, %1639
br i1 false, label %1685, label %1690
1663: ; preds = %1635
%1664 = load double**, double*** @contrast.xin
%1665 = load i64, i64* @contrast.ilat
%1666 = add nsw i64 %1665, 1
%1667 = getelementptr inbounds double*, double** %1664, i64 %1666
%1668 = load double*, double** %1667
%1669 = load i64, i64* @contrast.ilon
%1670 = getelementptr inbounds double, double* %1668, i64 %1669
%1671 = load double, double* %1670
%1672 = load double, double* %7
%1673 = fcmp olt double %1671, %1672
br i1 %1673, label %1690, label %1674
1674: ; preds = %1663
%1675 = load double, double* %7
%1676 = load double**, double*** @contrast.xin
%1677 = load i64, i64* @contrast.ilat
%1678 = add nsw i64 %1677, 1
%1679 = getelementptr inbounds double*, double** %1676, i64 %1678
%1680 = load double*, double** %1679
%1681 = load i64, i64* @contrast.ilon
%1682 = getelementptr inbounds double, double* %1680, i64 %1681
%1683 = load double, double* %1682
%1684 = fcmp olt double %1675, %1683
br i1 %1684, label %1690, label %1685
1685: ; preds = %1674, %1662, %1661
store double 0.000000e+00, double* @contrast.a7
%1686 = load double, double* @contrast.dlon0
%1687 = load double, double* @contrast.flat11
%1688 = load double, double* @contrast.a4
%1689 = call double @llvm.fmuladd.f64(double %1686, double %1687, double %1688)
store double %1689, double* @contrast.a4
br label %1698
1690: ; preds = %1674, %1663, %1662, %1661
%1691 = load double, double* @contrast.dlon0
%1692 = load double, double* @contrast.flat11
%1693 = fmul double %1691, %1692
%1694 = fdiv double %1693, 2.000000e+00
store double %1694, double* @contrast.a7
%1695 = load double, double* @contrast.a7
%1696 = load double, double* @contrast.a4
%1697 = fadd double %1696, %1695
store double %1697, double* @contrast.a4
br label %1698
1698: ; preds = %1690, %1685
%1699 = load double**, double*** @contrast.xin
%1700 = load i64, i64* @contrast.ilat
%1701 = getelementptr inbounds double*, double** %1699, i64 %1700
%1702 = load double*, double** %1701
%1703 = load i64, i64* @contrast.ilon
%1704 = sub nsw i64 %1703, 1
%1705 = getelementptr inbounds double, double* %1702, i64 %1704
%1706 = load double, double* %1705
%1707 = load double**, double*** @contrast.xin
%1708 = load i64, i64* @contrast.ilat
%1709 = getelementptr inbounds double*, double** %1707, i64 %1708
%1710 = load double*, double** %1709
%1711 = load i64, i64* @contrast.ilon
%1712 = sub nsw i64 %1711, 1
%1713 = getelementptr inbounds double, double* %1710, i64 %1712
%1714 = load double, double* %1713
%1715 = fcmp une double %1706, %1714
br i1 %1715, label %1720, label %1716
1716: ; preds = %1698
%1717 = load double, double* %7
%1718 = load double, double* %7
%1719 = fcmp une double %1717, %1718
br i1 %1719, label %1720, label %1744
1720: ; preds = %1716, %1698
%1721 = load double**, double*** @contrast.xin
%1722 = load i64, i64* @contrast.ilat
%1723 = getelementptr inbounds double*, double** %1721, i64 %1722
%1724 = load double*, double** %1723
%1725 = load i64, i64* @contrast.ilon
%1726 = sub nsw i64 %1725, 1
%1727 = getelementptr inbounds double, double* %1724, i64 %1726
%1728 = load double, double* %1727
%1729 = load double**, double*** @contrast.xin
%1730 = load i64, i64* @contrast.ilat
%1731 = getelementptr inbounds double*, double** %1729, i64 %1730
%1732 = load double*, double** %1731
%1733 = load i64, i64* @contrast.ilon
%1734 = sub nsw i64 %1733, 1
%1735 = getelementptr inbounds double, double* %1732, i64 %1734
%1736 = load double, double* %1735
%1737 = fcmp une double %1728, %1736
br i1 %1737, label %1738, label %1743
1738: ; preds = %1720
%1739 = load double, double* %7
%1740 = load double, double* %7
%1741 = fcmp une double %1739, %1740
br i1 %1741, label %1742, label %1743
1742: ; preds = %1738
br i1 true, label %1766, label %1771
1743: ; preds = %1738, %1720
br i1 false, label %1766, label %1771
1744: ; preds = %1716
%1745 = load double**, double*** @contrast.xin
%1746 = load i64, i64* @contrast.ilat
%1747 = getelementptr inbounds double*, double** %1745, i64 %1746
%1748 = load double*, double** %1747
%1749 = load i64, i64* @contrast.ilon
%1750 = sub nsw i64 %1749, 1
%1751 = getelementptr inbounds double, double* %1748, i64 %1750
%1752 = load double, double* %1751
%1753 = load double, double* %7
%1754 = fcmp olt double %1752, %1753
br i1 %1754, label %1771, label %1755
1755: ; preds = %1744
%1756 = load double, double* %7
%1757 = load double**, double*** @contrast.xin
%1758 = load i64, i64* @contrast.ilat
%1759 = getelementptr inbounds double*, double** %1757, i64 %1758
%1760 = load double*, double** %1759
%1761 = load i64, i64* @contrast.ilon
%1762 = sub nsw i64 %1761, 1
%1763 = getelementptr inbounds double, double* %1760, i64 %1762
%1764 = load double, double* %1763
%1765 = fcmp olt double %1756, %1764
br i1 %1765, label %1771, label %1766
1766: ; preds = %1755, %1743, %1742
store double 0.000000e+00, double* @contrast.a3
%1767 = load double, double* @contrast.dlon0
%1768 = load double, double* @contrast.flat10
%1769 = load double, double* @contrast.a4
%1770 = call double @llvm.fmuladd.f64(double %1767, double %1768, double %1769)
store double %1770, double* @contrast.a4
br label %1779
1771: ; preds = %1755, %1744, %1743, %1742
%1772 = load double, double* @contrast.dlon0
%1773 = load double, double* @contrast.flat10
%1774 = fmul double %1772, %1773
%1775 = fdiv double %1774, 2.000000e+00
store double %1775, double* @contrast.a3
%1776 = load double, double* @contrast.a3
%1777 = load double, double* @contrast.a4
%1778 = fadd double %1777, %1776
store double %1778, double* @contrast.a4
br label %1779
1779: ; preds = %1771, %1766
%1780 = load double**, double*** @contrast.xin
%1781 = load i64, i64* @contrast.ilat
%1782 = add nsw i64 %1781, 1
%1783 = getelementptr inbounds double*, double** %1780, i64 %1782
%1784 = load double*, double** %1783
%1785 = load i64, i64* @contrast.ilon
%1786 = sub nsw i64 %1785, 1
%1787 = getelementptr inbounds double, double* %1784, i64 %1786
%1788 = load double, double* %1787
%1789 = load double**, double*** @contrast.xin
%1790 = load i64, i64* @contrast.ilat
%1791 = add nsw i64 %1790, 1
%1792 = getelementptr inbounds double*, double** %1789, i64 %1791
%1793 = load double*, double** %1792
%1794 = load i64, i64* @contrast.ilon
%1795 = sub nsw i64 %1794, 1
%1796 = getelementptr inbounds double, double* %1793, i64 %1795
%1797 = load double, double* %1796
%1798 = fcmp une double %1788, %1797
br i1 %1798, label %1803, label %1799
1799: ; preds = %1779
%1800 = load double, double* %7
%1801 = load double, double* %7
%1802 = fcmp une double %1800, %1801
br i1 %1802, label %1803, label %1831
1803: ; preds = %1799, %1779
%1804 = load double**, double*** @contrast.xin
%1805 = load i64, i64* @contrast.ilat
%1806 = add nsw i64 %1805, 1
%1807 = getelementptr inbounds double*, double** %1804, i64 %1806
%1808 = load double*, double** %1807
%1809 = load i64, i64* @contrast.ilon
%1810 = sub nsw i64 %1809, 1
%1811 = getelementptr inbounds double, double* %1808, i64 %1810
%1812 = load double, double* %1811
%1813 = load double**, double*** @contrast.xin
%1814 = load i64, i64* @contrast.ilat
%1815 = add nsw i64 %1814, 1
%1816 = getelementptr inbounds double*, double** %1813, i64 %1815
%1817 = load double*, double** %1816
%1818 = load i64, i64* @contrast.ilon
%1819 = sub nsw i64 %1818, 1
%1820 = getelementptr inbounds double, double* %1817, i64 %1819
%1821 = load double, double* %1820
%1822 = fcmp une double %1812, %1821
br i1 %1822, label %1823, label %1827
1823: ; preds = %1803
%1824 = load double, double* %7
%1825 = load double, double* %7
%1826 = fcmp une double %1824, %1825
br label %1827
1827: ; preds = %1823, %1803
%1828 = phi i1 [ false, %1803 ], [ %1826, %1823 ]
%1829 = zext i1 %1828 to i64
%1830 = select i1 %1828, i32 1, i32 0
br label %1859
1831: ; preds = %1799
%1832 = load double**, double*** @contrast.xin
%1833 = load i64, i64* @contrast.ilat
%1834 = add nsw i64 %1833, 1
%1835 = getelementptr inbounds double*, double** %1832, i64 %1834
%1836 = load double*, double** %1835
%1837 = load i64, i64* @contrast.ilon
%1838 = sub nsw i64 %1837, 1
%1839 = getelementptr inbounds double, double* %1836, i64 %1838
%1840 = load double, double* %1839
%1841 = load double, double* %7
%1842 = fcmp olt double %1840, %1841
br i1 %1842, label %1855, label %1843
1843: ; preds = %1831
%1844 = load double, double* %7
%1845 = load double**, double*** @contrast.xin
%1846 = load i64, i64* @contrast.ilat
%1847 = add nsw i64 %1846, 1
%1848 = getelementptr inbounds double*, double** %1845, i64 %1847
%1849 = load double*, double** %1848
%1850 = load i64, i64* @contrast.ilon
%1851 = sub nsw i64 %1850, 1
%1852 = getelementptr inbounds double, double* %1849, i64 %1851
%1853 = load double, double* %1852
%1854 = fcmp olt double %1844, %1853
br label %1855
1855: ; preds = %1843, %1831
%1856 = phi i1 [ true, %1831 ], [ %1854, %1843 ]
%1857 = xor i1 %1856, true
%1858 = zext i1 %1857 to i32
br label %1859
1859: ; preds = %1855, %1827
%1860 = phi i32 [ %1830, %1827 ], [ %1858, %1855 ]
%1861 = sext i32 %1860 to i64
%1862 = getelementptr inbounds [2 x [2 x [2 x [4 x double]]]], [2 x [2 x [2 x [4 x double]]]]* @contrast.table, i64 0, i64 %1861
%1863 = load double**, double*** @contrast.xin
%1864 = load i64, i64* @contrast.ilat
%1865 = add nsw i64 %1864, 1
%1866 = getelementptr inbounds double*, double** %1863, i64 %1865
%1867 = load double*, double** %1866
%1868 = load i64, i64* @contrast.ilon
%1869 = getelementptr inbounds double, double* %1867, i64 %1868
%1870 = load double, double* %1869
%1871 = load double**, double*** @contrast.xin
%1872 = load i64, i64* @contrast.ilat
%1873 = add nsw i64 %1872, 1
%1874 = getelementptr inbounds double*, double** %1871, i64 %1873
%1875 = load double*, double** %1874
%1876 = load i64, i64* @contrast.ilon
%1877 = getelementptr inbounds double, double* %1875, i64 %1876
%1878 = load double, double* %1877
%1879 = fcmp une double %1870, %1878
br i1 %1879, label %1884, label %1880
1880: ; preds = %1859
%1881 = load double, double* %7
%1882 = load double, double* %7
%1883 = fcmp une double %1881, %1882
br i1 %1883, label %1884, label %1910
1884: ; preds = %1880, %1859
%1885 = load double**, double*** @contrast.xin
%1886 = load i64, i64* @contrast.ilat
%1887 = add nsw i64 %1886, 1
%1888 = getelementptr inbounds double*, double** %1885, i64 %1887
%1889 = load double*, double** %1888
%1890 = load i64, i64* @contrast.ilon
%1891 = getelementptr inbounds double, double* %1889, i64 %1890
%1892 = load double, double* %1891
%1893 = load double**, double*** @contrast.xin
%1894 = load i64, i64* @contrast.ilat
%1895 = add nsw i64 %1894, 1
%1896 = getelementptr inbounds double*, double** %1893, i64 %1895
%1897 = load double*, double** %1896
%1898 = load i64, i64* @contrast.ilon
%1899 = getelementptr inbounds double, double* %1897, i64 %1898
%1900 = load double, double* %1899
%1901 = fcmp une double %1892, %1900
br i1 %1901, label %1902, label %1906
1902: ; preds = %1884
%1903 = load double, double* %7
%1904 = load double, double* %7
%1905 = fcmp une double %1903, %1904
br label %1906
1906: ; preds = %1902, %1884
%1907 = phi i1 [ false, %1884 ], [ %1905, %1902 ]
%1908 = zext i1 %1907 to i64
%1909 = select i1 %1907, i32 1, i32 0
br label %1936
1910: ; preds = %1880
%1911 = load double**, double*** @contrast.xin
%1912 = load i64, i64* @contrast.ilat
%1913 = add nsw i64 %1912, 1
%1914 = getelementptr inbounds double*, double** %1911, i64 %1913
%1915 = load double*, double** %1914
%1916 = load i64, i64* @contrast.ilon
%1917 = getelementptr inbounds double, double* %1915, i64 %1916
%1918 = load double, double* %1917
%1919 = load double, double* %7
%1920 = fcmp olt double %1918, %1919
br i1 %1920, label %1932, label %1921
1921: ; preds = %1910
%1922 = load double, double* %7
%1923 = load double**, double*** @contrast.xin
%1924 = load i64, i64* @contrast.ilat
%1925 = add nsw i64 %1924, 1
%1926 = getelementptr inbounds double*, double** %1923, i64 %1925
%1927 = load double*, double** %1926
%1928 = load i64, i64* @contrast.ilon
%1929 = getelementptr inbounds double, double* %1927, i64 %1928
%1930 = load double, double* %1929
%1931 = fcmp olt double %1922, %1930
br label %1932
1932: ; preds = %1921, %1910
%1933 = phi i1 [ true, %1910 ], [ %1931, %1921 ]
%1934 = xor i1 %1933, true
%1935 = zext i1 %1934 to i32
br label %1936
1936: ; preds = %1932, %1906
%1937 = phi i32 [ %1909, %1906 ], [ %1935, %1932 ]
%1938 = sext i32 %1937 to i64
%1939 = getelementptr inbounds [2 x [2 x [4 x double]]], [2 x [2 x [4 x double]]]* %1862, i64 0, i64 %1938
%1940 = load double**, double*** @contrast.xin
%1941 = load i64, i64* @contrast.ilat
%1942 = getelementptr inbounds double*, double** %1940, i64 %1941
%1943 = load double*, double** %1942
%1944 = load i64, i64* @contrast.ilon
%1945 = sub nsw i64 %1944, 1
%1946 = getelementptr inbounds double, double* %1943, i64 %1945
%1947 = load double, double* %1946
%1948 = load double**, double*** @contrast.xin
%1949 = load i64, i64* @contrast.ilat
%1950 = getelementptr inbounds double*, double** %1948, i64 %1949
%1951 = load double*, double** %1950
%1952 = load i64, i64* @contrast.ilon
%1953 = sub nsw i64 %1952, 1
%1954 = getelementptr inbounds double, double* %1951, i64 %1953
%1955 = load double, double* %1954
%1956 = fcmp une double %1947, %1955
br i1 %1956, label %1961, label %1957
1957: ; preds = %1936
%1958 = load double, double* %7
%1959 = load double, double* %7
%1960 = fcmp une double %1958, %1959
br i1 %1960, label %1961, label %1987
1961: ; preds = %1957, %1936
%1962 = load double**, double*** @contrast.xin
%1963 = load i64, i64* @contrast.ilat
%1964 = getelementptr inbounds double*, double** %1962, i64 %1963
%1965 = load double*, double** %1964
%1966 = load i64, i64* @contrast.ilon
%1967 = sub nsw i64 %1966, 1
%1968 = getelementptr inbounds double, double* %1965, i64 %1967
%1969 = load double, double* %1968
%1970 = load double**, double*** @contrast.xin
%1971 = load i64, i64* @contrast.ilat
%1972 = getelementptr inbounds double*, double** %1970, i64 %1971
%1973 = load double*, double** %1972
%1974 = load i64, i64* @contrast.ilon
%1975 = sub nsw i64 %1974, 1
%1976 = getelementptr inbounds double, double* %1973, i64 %1975
%1977 = load double, double* %1976
%1978 = fcmp une double %1969, %1977
br i1 %1978, label %1979, label %1983
1979: ; preds = %1961
%1980 = load double, double* %7
%1981 = load double, double* %7
%1982 = fcmp une double %1980, %1981
br label %1983
1983: ; preds = %1979, %1961
%1984 = phi i1 [ false, %1961 ], [ %1982, %1979 ]
%1985 = zext i1 %1984 to i64
%1986 = select i1 %1984, i32 1, i32 0
br label %2013
1987: ; preds = %1957
%1988 = load double**, double*** @contrast.xin
%1989 = load i64, i64* @contrast.ilat
%1990 = getelementptr inbounds double*, double** %1988, i64 %1989
%1991 = load double*, double** %1990
%1992 = load i64, i64* @contrast.ilon
%1993 = sub nsw i64 %1992, 1
%1994 = getelementptr inbounds double, double* %1991, i64 %1993
%1995 = load double, double* %1994
%1996 = load double, double* %7
%1997 = fcmp olt double %1995, %1996
br i1 %1997, label %2009, label %1998
1998: ; preds = %1987
%1999 = load double, double* %7
%2000 = load double**, double*** @contrast.xin
%2001 = load i64, i64* @contrast.ilat
%2002 = getelementptr inbounds double*, double** %2000, i64 %2001
%2003 = load double*, double** %2002
%2004 = load i64, i64* @contrast.ilon
%2005 = sub nsw i64 %2004, 1
%2006 = getelementptr inbounds double, double* %2003, i64 %2005
%2007 = load double, double* %2006
%2008 = fcmp olt double %1999, %2007
br label %2009
2009: ; preds = %1998, %1987
%2010 = phi i1 [ true, %1987 ], [ %2008, %1998 ]
%2011 = xor i1 %2010, true
%2012 = zext i1 %2011 to i32
br label %2013
2013: ; preds = %2009, %1983
%2014 = phi i32 [ %1986, %1983 ], [ %2012, %2009 ]
%2015 = sext i32 %2014 to i64
%2016 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %1939, i64 0, i64 %2015
%2017 = getelementptr inbounds [4 x double], [4 x double]* %2016, i64 0, i64 0
store double* %2017, double** @contrast.case_table
%2018 = load double, double* @contrast.dlon0
%2019 = load double, double* @contrast.flat11
%2020 = fmul double %2018, %2019
store double %2020, double* @contrast.f
%2021 = load double*, double** @contrast.case_table
%2022 = getelementptr inbounds double, double* %2021, i64 0
%2023 = load double, double* %2022
%2024 = load double, double* @contrast.f
%2025 = fmul double %2023, %2024
store double %2025, double* @contrast.a6
%2026 = load double*, double** @contrast.case_table
%2027 = getelementptr inbounds double, double* %2026, i64 1
%2028 = load double, double* %2027
%2029 = load double, double* @contrast.f
%2030 = load double, double* @contrast.a7
%2031 = call double @llvm.fmuladd.f64(double %2028, double %2029, double %2030)
store double %2031, double* @contrast.a7
%2032 = load double*, double** @contrast.case_table
%2033 = getelementptr inbounds double, double* %2032, i64 2
%2034 = load double, double* %2033
%2035 = load double, double* @contrast.f
%2036 = load double, double* @contrast.a3
%2037 = call double @llvm.fmuladd.f64(double %2034, double %2035, double %2036)
store double %2037, double* @contrast.a3
%2038 = load double*, double** @contrast.case_table
%2039 = getelementptr inbounds double, double* %2038, i64 3
%2040 = load double, double* %2039
%2041 = load double, double* @contrast.f
%2042 = load double, double* @contrast.a4
%2043 = call double @llvm.fmuladd.f64(double %2040, double %2041, double %2042)
store double %2043, double* @contrast.a4
%2044 = load double, double* @contrast.a6
%2045 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 6)
%2046 = load i64, i64* @contrast.ilat
%2047 = getelementptr inbounds double*, double** %2045, i64 %2046
%2048 = load double*, double** %2047
%2049 = load i64, i64* @contrast.ilon
%2050 = getelementptr inbounds double, double* %2048, i64 %2049
%2051 = load double, double* %2050
%2052 = fadd double %2051, %2044
store double %2052, double* %2050
%2053 = load double, double* @contrast.a7
%2054 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 7)
%2055 = load i64, i64* @contrast.ilat
%2056 = getelementptr inbounds double*, double** %2054, i64 %2055
%2057 = load double*, double** %2056
%2058 = load i64, i64* @contrast.ilon
%2059 = getelementptr inbounds double, double* %2057, i64 %2058
%2060 = load double, double* %2059
%2061 = fadd double %2060, %2053
store double %2061, double* %2059
%2062 = load double, double* @contrast.a3
%2063 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 3)
%2064 = load i64, i64* @contrast.ilat
%2065 = getelementptr inbounds double*, double** %2063, i64 %2064
%2066 = load double*, double** %2065
%2067 = load i64, i64* @contrast.ilon
%2068 = getelementptr inbounds double, double* %2066, i64 %2067
%2069 = load double, double* %2068
%2070 = fadd double %2069, %2062
store double %2070, double* %2068
%2071 = load double, double* @contrast.a4
%2072 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 4)
%2073 = load i64, i64* @contrast.ilat
%2074 = getelementptr inbounds double*, double** %2072, i64 %2073
%2075 = load double*, double** %2074
%2076 = load i64, i64* @contrast.ilon
%2077 = getelementptr inbounds double, double* %2075, i64 %2076
%2078 = load double, double* %2077
%2079 = fadd double %2078, %2071
store double %2079, double* %2077
%2080 = load double, double* @contrast.dlon1
%2081 = load double, double* @contrast.flat10
%2082 = fmul double %2080, %2081
store double %2082, double* @contrast.a4
%2083 = load double**, double*** @contrast.xin
%2084 = load i64, i64* @contrast.ilat
%2085 = add nsw i64 %2084, 1
%2086 = getelementptr inbounds double*, double** %2083, i64 %2085
%2087 = load double*, double** %2086
%2088 = load i64, i64* @contrast.ilon
%2089 = getelementptr inbounds double, double* %2087, i64 %2088
%2090 = load double, double* %2089
%2091 = load double**, double*** @contrast.xin
%2092 = load i64, i64* @contrast.ilat
%2093 = add nsw i64 %2092, 1
%2094 = getelementptr inbounds double*, double** %2091, i64 %2093
%2095 = load double*, double** %2094
%2096 = load i64, i64* @contrast.ilon
%2097 = getelementptr inbounds double, double* %2095, i64 %2096
%2098 = load double, double* %2097
%2099 = fcmp une double %2090, %2098
br i1 %2099, label %2104, label %2100
2100: ; preds = %2013
%2101 = load double, double* %7
%2102 = load double, double* %7
%2103 = fcmp une double %2101, %2102
br i1 %2103, label %2104, label %2128
2104: ; preds = %2100, %2013
%2105 = load double**, double*** @contrast.xin
%2106 = load i64, i64* @contrast.ilat
%2107 = add nsw i64 %2106, 1
%2108 = getelementptr inbounds double*, double** %2105, i64 %2107
%2109 = load double*, double** %2108
%2110 = load i64, i64* @contrast.ilon
%2111 = getelementptr inbounds double, double* %2109, i64 %2110
%2112 = load double, double* %2111
%2113 = load double**, double*** @contrast.xin
%2114 = load i64, i64* @contrast.ilat
%2115 = add nsw i64 %2114, 1
%2116 = getelementptr inbounds double*, double** %2113, i64 %2115
%2117 = load double*, double** %2116
%2118 = load i64, i64* @contrast.ilon
%2119 = getelementptr inbounds double, double* %2117, i64 %2118
%2120 = load double, double* %2119
%2121 = fcmp une double %2112, %2120
br i1 %2121, label %2122, label %2127
2122: ; preds = %2104
%2123 = load double, double* %7
%2124 = load double, double* %7
%2125 = fcmp une double %2123, %2124
br i1 %2125, label %2126, label %2127
2126: ; preds = %2122
br i1 true, label %2150, label %2155
2127: ; preds = %2122, %2104
br i1 false, label %2150, label %2155
2128: ; preds = %2100
%2129 = load double**, double*** @contrast.xin
%2130 = load i64, i64* @contrast.ilat
%2131 = add nsw i64 %2130, 1
%2132 = getelementptr inbounds double*, double** %2129, i64 %2131
%2133 = load double*, double** %2132
%2134 = load i64, i64* @contrast.ilon
%2135 = getelementptr inbounds double, double* %2133, i64 %2134
%2136 = load double, double* %2135
%2137 = load double, double* %7
%2138 = fcmp olt double %2136, %2137
br i1 %2138, label %2155, label %2139
2139: ; preds = %2128
%2140 = load double, double* %7
%2141 = load double**, double*** @contrast.xin
%2142 = load i64, i64* @contrast.ilat
%2143 = add nsw i64 %2142, 1
%2144 = getelementptr inbounds double*, double** %2141, i64 %2143
%2145 = load double*, double** %2144
%2146 = load i64, i64* @contrast.ilon
%2147 = getelementptr inbounds double, double* %2145, i64 %2146
%2148 = load double, double* %2147
%2149 = fcmp olt double %2140, %2148
br i1 %2149, label %2155, label %2150
2150: ; preds = %2139, %2127, %2126
store double 0.000000e+00, double* @contrast.a7
%2151 = load double, double* @contrast.dlon1
%2152 = load double, double* @contrast.flat11
%2153 = load double, double* @contrast.a4
%2154 = call double @llvm.fmuladd.f64(double %2151, double %2152, double %2153)
store double %2154, double* @contrast.a4
br label %2163
2155: ; preds = %2139, %2128, %2127, %2126
%2156 = load double, double* @contrast.dlon1
%2157 = load double, double* @contrast.flat11
%2158 = fmul double %2156, %2157
%2159 = fdiv double %2158, 2.000000e+00
store double %2159, double* @contrast.a7
%2160 = load double, double* @contrast.a7
%2161 = load double, double* @contrast.a4
%2162 = fadd double %2161, %2160
store double %2162, double* @contrast.a4
br label %2163
2163: ; preds = %2155, %2150
%2164 = load double**, double*** @contrast.xin
%2165 = load i64, i64* @contrast.ilat
%2166 = getelementptr inbounds double*, double** %2164, i64 %2165
%2167 = load double*, double** %2166
%2168 = load i64, i64* @contrast.ilon
%2169 = add nsw i64 %2168, 1
%2170 = getelementptr inbounds double, double* %2167, i64 %2169
%2171 = load double, double* %2170
%2172 = load double**, double*** @contrast.xin
%2173 = load i64, i64* @contrast.ilat
%2174 = getelementptr inbounds double*, double** %2172, i64 %2173
%2175 = load double*, double** %2174
%2176 = load i64, i64* @contrast.ilon
%2177 = add nsw i64 %2176, 1
%2178 = getelementptr inbounds double, double* %2175, i64 %2177
%2179 = load double, double* %2178
%2180 = fcmp une double %2171, %2179
br i1 %2180, label %2185, label %2181
2181: ; preds = %2163
%2182 = load double, double* %7
%2183 = load double, double* %7
%2184 = fcmp une double %2182, %2183
br i1 %2184, label %2185, label %2209
2185: ; preds = %2181, %2163
%2186 = load double**, double*** @contrast.xin
%2187 = load i64, i64* @contrast.ilat
%2188 = getelementptr inbounds double*, double** %2186, i64 %2187
%2189 = load double*, double** %2188
%2190 = load i64, i64* @contrast.ilon
%2191 = add nsw i64 %2190, 1
%2192 = getelementptr inbounds double, double* %2189, i64 %2191
%2193 = load double, double* %2192
%2194 = load double**, double*** @contrast.xin
%2195 = load i64, i64* @contrast.ilat
%2196 = getelementptr inbounds double*, double** %2194, i64 %2195
%2197 = load double*, double** %2196
%2198 = load i64, i64* @contrast.ilon
%2199 = add nsw i64 %2198, 1
%2200 = getelementptr inbounds double, double* %2197, i64 %2199
%2201 = load double, double* %2200
%2202 = fcmp une double %2193, %2201
br i1 %2202, label %2203, label %2208
2203: ; preds = %2185
%2204 = load double, double* %7
%2205 = load double, double* %7
%2206 = fcmp une double %2204, %2205
br i1 %2206, label %2207, label %2208
2207: ; preds = %2203
br i1 true, label %2231, label %2236
2208: ; preds = %2203, %2185
br i1 false, label %2231, label %2236
2209: ; preds = %2181
%2210 = load double**, double*** @contrast.xin
%2211 = load i64, i64* @contrast.ilat
%2212 = getelementptr inbounds double*, double** %2210, i64 %2211
%2213 = load double*, double** %2212
%2214 = load i64, i64* @contrast.ilon
%2215 = add nsw i64 %2214, 1
%2216 = getelementptr inbounds double, double* %2213, i64 %2215
%2217 = load double, double* %2216
%2218 = load double, double* %7
%2219 = fcmp olt double %2217, %2218
br i1 %2219, label %2236, label %2220
2220: ; preds = %2209
%2221 = load double, double* %7
%2222 = load double**, double*** @contrast.xin
%2223 = load i64, i64* @contrast.ilat
%2224 = getelementptr inbounds double*, double** %2222, i64 %2223
%2225 = load double*, double** %2224
%2226 = load i64, i64* @contrast.ilon
%2227 = add nsw i64 %2226, 1
%2228 = getelementptr inbounds double, double* %2225, i64 %2227
%2229 = load double, double* %2228
%2230 = fcmp olt double %2221, %2229
br i1 %2230, label %2236, label %2231
2231: ; preds = %2220, %2208, %2207
store double 0.000000e+00, double* @contrast.a5
%2232 = load double, double* @contrast.dlon1
%2233 = load double, double* @contrast.flat10
%2234 = load double, double* @contrast.a4
%2235 = call double @llvm.fmuladd.f64(double %2232, double %2233, double %2234)
store double %2235, double* @contrast.a4
br label %2244
2236: ; preds = %2220, %2209, %2208, %2207
%2237 = load double, double* @contrast.dlon1
%2238 = load double, double* @contrast.flat10
%2239 = fmul double %2237, %2238
%2240 = fdiv double %2239, 2.000000e+00
store double %2240, double* @contrast.a5
%2241 = load double, double* @contrast.a5
%2242 = load double, double* @contrast.a4
%2243 = fadd double %2242, %2241
store double %2243, double* @contrast.a4
br label %2244
2244: ; preds = %2236, %2231
%2245 = load double**, double*** @contrast.xin
%2246 = load i64, i64* @contrast.ilat
%2247 = add nsw i64 %2246, 1
%2248 = getelementptr inbounds double*, double** %2245, i64 %2247
%2249 = load double*, double** %2248
%2250 = load i64, i64* @contrast.ilon
%2251 = add nsw i64 %2250, 1
%2252 = getelementptr inbounds double, double* %2249, i64 %2251
%2253 = load double, double* %2252
%2254 = load double**, double*** @contrast.xin
%2255 = load i64, i64* @contrast.ilat
%2256 = add nsw i64 %2255, 1
%2257 = getelementptr inbounds double*, double** %2254, i64 %2256
%2258 = load double*, double** %2257
%2259 = load i64, i64* @contrast.ilon
%2260 = add nsw i64 %2259, 1
%2261 = getelementptr inbounds double, double* %2258, i64 %2260
%2262 = load double, double* %2261
%2263 = fcmp une double %2253, %2262
br i1 %2263, label %2268, label %2264
2264: ; preds = %2244
%2265 = load double, double* %7
%2266 = load double, double* %7
%2267 = fcmp une double %2265, %2266
br i1 %2267, label %2268, label %2296
2268: ; preds = %2264, %2244
%2269 = load double**, double*** @contrast.xin
%2270 = load i64, i64* @contrast.ilat
%2271 = add nsw i64 %2270, 1
%2272 = getelementptr inbounds double*, double** %2269, i64 %2271
%2273 = load double*, double** %2272
%2274 = load i64, i64* @contrast.ilon
%2275 = add nsw i64 %2274, 1
%2276 = getelementptr inbounds double, double* %2273, i64 %2275
%2277 = load double, double* %2276
%2278 = load double**, double*** @contrast.xin
%2279 = load i64, i64* @contrast.ilat
%2280 = add nsw i64 %2279, 1
%2281 = getelementptr inbounds double*, double** %2278, i64 %2280
%2282 = load double*, double** %2281
%2283 = load i64, i64* @contrast.ilon
%2284 = add nsw i64 %2283, 1
%2285 = getelementptr inbounds double, double* %2282, i64 %2284
%2286 = load double, double* %2285
%2287 = fcmp une double %2277, %2286
br i1 %2287, label %2288, label %2292
2288: ; preds = %2268
%2289 = load double, double* %7
%2290 = load double, double* %7
%2291 = fcmp une double %2289, %2290
br label %2292
2292: ; preds = %2288, %2268
%2293 = phi i1 [ false, %2268 ], [ %2291, %2288 ]
%2294 = zext i1 %2293 to i64
%2295 = select i1 %2293, i32 1, i32 0
br label %2324
2296: ; preds = %2264
%2297 = load double**, double*** @contrast.xin
%2298 = load i64, i64* @contrast.ilat
%2299 = add nsw i64 %2298, 1
%2300 = getelementptr inbounds double*, double** %2297, i64 %2299
%2301 = load double*, double** %2300
%2302 = load i64, i64* @contrast.ilon
%2303 = add nsw i64 %2302, 1
%2304 = getelementptr inbounds double, double* %2301, i64 %2303
%2305 = load double, double* %2304
%2306 = load double, double* %7
%2307 = fcmp olt double %2305, %2306
br i1 %2307, label %2320, label %2308
2308: ; preds = %2296
%2309 = load double, double* %7
%2310 = load double**, double*** @contrast.xin
%2311 = load i64, i64* @contrast.ilat
%2312 = add nsw i64 %2311, 1
%2313 = getelementptr inbounds double*, double** %2310, i64 %2312
%2314 = load double*, double** %2313
%2315 = load i64, i64* @contrast.ilon
%2316 = add nsw i64 %2315, 1
%2317 = getelementptr inbounds double, double* %2314, i64 %2316
%2318 = load double, double* %2317
%2319 = fcmp olt double %2309, %2318
br label %2320
2320: ; preds = %2308, %2296
%2321 = phi i1 [ true, %2296 ], [ %2319, %2308 ]
%2322 = xor i1 %2321, true
%2323 = zext i1 %2322 to i32
br label %2324
2324: ; preds = %2320, %2292
%2325 = phi i32 [ %2295, %2292 ], [ %2323, %2320 ]
%2326 = sext i32 %2325 to i64
%2327 = getelementptr inbounds [2 x [2 x [2 x [4 x double]]]], [2 x [2 x [2 x [4 x double]]]]* @contrast.table, i64 0, i64 %2326
%2328 = load double**, double*** @contrast.xin
%2329 = load i64, i64* @contrast.ilat
%2330 = add nsw i64 %2329, 1
%2331 = getelementptr inbounds double*, double** %2328, i64 %2330
%2332 = load double*, double** %2331
%2333 = load i64, i64* @contrast.ilon
%2334 = getelementptr inbounds double, double* %2332, i64 %2333
%2335 = load double, double* %2334
%2336 = load double**, double*** @contrast.xin
%2337 = load i64, i64* @contrast.ilat
%2338 = add nsw i64 %2337, 1
%2339 = getelementptr inbounds double*, double** %2336, i64 %2338
%2340 = load double*, double** %2339
%2341 = load i64, i64* @contrast.ilon
%2342 = getelementptr inbounds double, double* %2340, i64 %2341
%2343 = load double, double* %2342
%2344 = fcmp une double %2335, %2343
br i1 %2344, label %2349, label %2345
2345: ; preds = %2324
%2346 = load double, double* %7
%2347 = load double, double* %7
%2348 = fcmp une double %2346, %2347
br i1 %2348, label %2349, label %2375
2349: ; preds = %2345, %2324
%2350 = load double**, double*** @contrast.xin
%2351 = load i64, i64* @contrast.ilat
%2352 = add nsw i64 %2351, 1
%2353 = getelementptr inbounds double*, double** %2350, i64 %2352
%2354 = load double*, double** %2353
%2355 = load i64, i64* @contrast.ilon
%2356 = getelementptr inbounds double, double* %2354, i64 %2355
%2357 = load double, double* %2356
%2358 = load double**, double*** @contrast.xin
%2359 = load i64, i64* @contrast.ilat
%2360 = add nsw i64 %2359, 1
%2361 = getelementptr inbounds double*, double** %2358, i64 %2360
%2362 = load double*, double** %2361
%2363 = load i64, i64* @contrast.ilon
%2364 = getelementptr inbounds double, double* %2362, i64 %2363
%2365 = load double, double* %2364
%2366 = fcmp une double %2357, %2365
br i1 %2366, label %2367, label %2371
2367: ; preds = %2349
%2368 = load double, double* %7
%2369 = load double, double* %7
%2370 = fcmp une double %2368, %2369
br label %2371
2371: ; preds = %2367, %2349
%2372 = phi i1 [ false, %2349 ], [ %2370, %2367 ]
%2373 = zext i1 %2372 to i64
%2374 = select i1 %2372, i32 1, i32 0
br label %2401
2375: ; preds = %2345
%2376 = load double**, double*** @contrast.xin
%2377 = load i64, i64* @contrast.ilat
%2378 = add nsw i64 %2377, 1
%2379 = getelementptr inbounds double*, double** %2376, i64 %2378
%2380 = load double*, double** %2379
%2381 = load i64, i64* @contrast.ilon
%2382 = getelementptr inbounds double, double* %2380, i64 %2381
%2383 = load double, double* %2382
%2384 = load double, double* %7
%2385 = fcmp olt double %2383, %2384
br i1 %2385, label %2397, label %2386
2386: ; preds = %2375
%2387 = load double, double* %7
%2388 = load double**, double*** @contrast.xin
%2389 = load i64, i64* @contrast.ilat
%2390 = add nsw i64 %2389, 1
%2391 = getelementptr inbounds double*, double** %2388, i64 %2390
%2392 = load double*, double** %2391
%2393 = load i64, i64* @contrast.ilon
%2394 = getelementptr inbounds double, double* %2392, i64 %2393
%2395 = load double, double* %2394
%2396 = fcmp olt double %2387, %2395
br label %2397
2397: ; preds = %2386, %2375
%2398 = phi i1 [ true, %2375 ], [ %2396, %2386 ]
%2399 = xor i1 %2398, true
%2400 = zext i1 %2399 to i32
br label %2401
2401: ; preds = %2397, %2371
%2402 = phi i32 [ %2374, %2371 ], [ %2400, %2397 ]
%2403 = sext i32 %2402 to i64
%2404 = getelementptr inbounds [2 x [2 x [4 x double]]], [2 x [2 x [4 x double]]]* %2327, i64 0, i64 %2403
%2405 = load double**, double*** @contrast.xin
%2406 = load i64, i64* @contrast.ilat
%2407 = getelementptr inbounds double*, double** %2405, i64 %2406
%2408 = load double*, double** %2407
%2409 = load i64, i64* @contrast.ilon
%2410 = add nsw i64 %2409, 1
%2411 = getelementptr inbounds double, double* %2408, i64 %2410
%2412 = load double, double* %2411
%2413 = load double**, double*** @contrast.xin
%2414 = load i64, i64* @contrast.ilat
%2415 = getelementptr inbounds double*, double** %2413, i64 %2414
%2416 = load double*, double** %2415
%2417 = load i64, i64* @contrast.ilon
%2418 = add nsw i64 %2417, 1
%2419 = getelementptr inbounds double, double* %2416, i64 %2418
%2420 = load double, double* %2419
%2421 = fcmp une double %2412, %2420
br i1 %2421, label %2426, label %2422
2422: ; preds = %2401
%2423 = load double, double* %7
%2424 = load double, double* %7
%2425 = fcmp une double %2423, %2424
br i1 %2425, label %2426, label %2452
2426: ; preds = %2422, %2401
%2427 = load double**, double*** @contrast.xin
%2428 = load i64, i64* @contrast.ilat
%2429 = getelementptr inbounds double*, double** %2427, i64 %2428
%2430 = load double*, double** %2429
%2431 = load i64, i64* @contrast.ilon
%2432 = add nsw i64 %2431, 1
%2433 = getelementptr inbounds double, double* %2430, i64 %2432
%2434 = load double, double* %2433
%2435 = load double**, double*** @contrast.xin
%2436 = load i64, i64* @contrast.ilat
%2437 = getelementptr inbounds double*, double** %2435, i64 %2436
%2438 = load double*, double** %2437
%2439 = load i64, i64* @contrast.ilon
%2440 = add nsw i64 %2439, 1
%2441 = getelementptr inbounds double, double* %2438, i64 %2440
%2442 = load double, double* %2441
%2443 = fcmp une double %2434, %2442
br i1 %2443, label %2444, label %2448
2444: ; preds = %2426
%2445 = load double, double* %7
%2446 = load double, double* %7
%2447 = fcmp une double %2445, %2446
br label %2448
2448: ; preds = %2444, %2426
%2449 = phi i1 [ false, %2426 ], [ %2447, %2444 ]
%2450 = zext i1 %2449 to i64
%2451 = select i1 %2449, i32 1, i32 0
br label %2478
2452: ; preds = %2422
%2453 = load double**, double*** @contrast.xin
%2454 = load i64, i64* @contrast.ilat
%2455 = getelementptr inbounds double*, double** %2453, i64 %2454
%2456 = load double*, double** %2455
%2457 = load i64, i64* @contrast.ilon
%2458 = add nsw i64 %2457, 1
%2459 = getelementptr inbounds double, double* %2456, i64 %2458
%2460 = load double, double* %2459
%2461 = load double, double* %7
%2462 = fcmp olt double %2460, %2461
br i1 %2462, label %2474, label %2463
2463: ; preds = %2452
%2464 = load double, double* %7
%2465 = load double**, double*** @contrast.xin
%2466 = load i64, i64* @contrast.ilat
%2467 = getelementptr inbounds double*, double** %2465, i64 %2466
%2468 = load double*, double** %2467
%2469 = load i64, i64* @contrast.ilon
%2470 = add nsw i64 %2469, 1
%2471 = getelementptr inbounds double, double* %2468, i64 %2470
%2472 = load double, double* %2471
%2473 = fcmp olt double %2464, %2472
br label %2474
2474: ; preds = %2463, %2452
%2475 = phi i1 [ true, %2452 ], [ %2473, %2463 ]
%2476 = xor i1 %2475, true
%2477 = zext i1 %2476 to i32
br label %2478
2478: ; preds = %2474, %2448
%2479 = phi i32 [ %2451, %2448 ], [ %2477, %2474 ]
%2480 = sext i32 %2479 to i64
%2481 = getelementptr inbounds [2 x [4 x double]], [2 x [4 x double]]* %2404, i64 0, i64 %2480
%2482 = getelementptr inbounds [4 x double], [4 x double]* %2481, i64 0, i64 0
store double* %2482, double** @contrast.case_table
%2483 = load double, double* @contrast.dlon1
%2484 = load double, double* @contrast.flat11
%2485 = fmul double %2483, %2484
store double %2485, double* @contrast.f
%2486 = load double*, double** @contrast.case_table
%2487 = getelementptr inbounds double, double* %2486, i64 0
%2488 = load double, double* %2487
%2489 = load double, double* @contrast.f
%2490 = fmul double %2488, %2489
store double %2490, double* @contrast.a8
%2491 = load double*, double** @contrast.case_table
%2492 = getelementptr inbounds double, double* %2491, i64 1
%2493 = load double, double* %2492
%2494 = load double, double* @contrast.f
%2495 = load double, double* @contrast.a7
%2496 = call double @llvm.fmuladd.f64(double %2493, double %2494, double %2495)
store double %2496, double* @contrast.a7
%2497 = load double*, double** @contrast.case_table
%2498 = getelementptr inbounds double, double* %2497, i64 2
%2499 = load double, double* %2498
%2500 = load double, double* @contrast.f
%2501 = load double, double* @contrast.a5
%2502 = call double @llvm.fmuladd.f64(double %2499, double %2500, double %2501)
store double %2502, double* @contrast.a5
%2503 = load double*, double** @contrast.case_table
%2504 = getelementptr inbounds double, double* %2503, i64 3
%2505 = load double, double* %2504
%2506 = load double, double* @contrast.f
%2507 = load double, double* @contrast.a4
%2508 = call double @llvm.fmuladd.f64(double %2505, double %2506, double %2507)
store double %2508, double* @contrast.a4
%2509 = load double, double* @contrast.a8
%2510 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 8)
%2511 = load i64, i64* @contrast.ilat
%2512 = getelementptr inbounds double*, double** %2510, i64 %2511
%2513 = load double*, double** %2512
%2514 = load i64, i64* @contrast.ilon
%2515 = getelementptr inbounds double, double* %2513, i64 %2514
%2516 = load double, double* %2515
%2517 = fadd double %2516, %2509
store double %2517, double* %2515
%2518 = load double, double* @contrast.a7
%2519 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 7)
%2520 = load i64, i64* @contrast.ilat
%2521 = getelementptr inbounds double*, double** %2519, i64 %2520
%2522 = load double*, double** %2521
%2523 = load i64, i64* @contrast.ilon
%2524 = getelementptr inbounds double, double* %2522, i64 %2523
%2525 = load double, double* %2524
%2526 = fadd double %2525, %2518
store double %2526, double* %2524
%2527 = load double, double* @contrast.a5
%2528 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 5)
%2529 = load i64, i64* @contrast.ilat
%2530 = getelementptr inbounds double*, double** %2528, i64 %2529
%2531 = load double*, double** %2530
%2532 = load i64, i64* @contrast.ilon
%2533 = getelementptr inbounds double, double* %2531, i64 %2532
%2534 = load double, double* %2533
%2535 = fadd double %2534, %2527
store double %2535, double* %2533
%2536 = load double, double* @contrast.a4
%2537 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 4)
%2538 = load i64, i64* @contrast.ilat
%2539 = getelementptr inbounds double*, double** %2537, i64 %2538
%2540 = load double*, double** %2539
%2541 = load i64, i64* @contrast.ilon
%2542 = getelementptr inbounds double, double* %2540, i64 %2541
%2543 = load double, double* %2542
%2544 = fadd double %2543, %2536
store double %2544, double* %2542
%2545 = load double, double* @contrast.wsum
%2546 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 0)
%2547 = load i64, i64* @contrast.ilat
%2548 = getelementptr inbounds double*, double** %2546, i64 %2547
%2549 = load double*, double** %2548
%2550 = load i64, i64* @contrast.ilon
%2551 = getelementptr inbounds double, double* %2549, i64 %2550
%2552 = load double, double* %2551
%2553 = fdiv double %2552, %2545
store double %2553, double* %2551
%2554 = load double, double* @contrast.wsum
%2555 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 1)
%2556 = load i64, i64* @contrast.ilat
%2557 = getelementptr inbounds double*, double** %2555, i64 %2556
%2558 = load double*, double** %2557
%2559 = load i64, i64* @contrast.ilon
%2560 = getelementptr inbounds double, double* %2558, i64 %2559
%2561 = load double, double* %2560
%2562 = fdiv double %2561, %2554
store double %2562, double* %2560
%2563 = load double, double* @contrast.wsum
%2564 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 2)
%2565 = load i64, i64* @contrast.ilat
%2566 = getelementptr inbounds double*, double** %2564, i64 %2565
%2567 = load double*, double** %2566
%2568 = load i64, i64* @contrast.ilon
%2569 = getelementptr inbounds double, double* %2567, i64 %2568
%2570 = load double, double* %2569
%2571 = fdiv double %2570, %2563
store double %2571, double* %2569
%2572 = load double, double* @contrast.wsum
%2573 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 3)
%2574 = load i64, i64* @contrast.ilat
%2575 = getelementptr inbounds double*, double** %2573, i64 %2574
%2576 = load double*, double** %2575
%2577 = load i64, i64* @contrast.ilon
%2578 = getelementptr inbounds double, double* %2576, i64 %2577
%2579 = load double, double* %2578
%2580 = fdiv double %2579, %2572
store double %2580, double* %2578
%2581 = load double, double* @contrast.wsum
%2582 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 4)
%2583 = load i64, i64* @contrast.ilat
%2584 = getelementptr inbounds double*, double** %2582, i64 %2583
%2585 = load double*, double** %2584
%2586 = load i64, i64* @contrast.ilon
%2587 = getelementptr inbounds double, double* %2585, i64 %2586
%2588 = load double, double* %2587
%2589 = fdiv double %2588, %2581
store double %2589, double* %2587
%2590 = load double, double* @contrast.wsum
%2591 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 5)
%2592 = load i64, i64* @contrast.ilat
%2593 = getelementptr inbounds double*, double** %2591, i64 %2592
%2594 = load double*, double** %2593
%2595 = load i64, i64* @contrast.ilon
%2596 = getelementptr inbounds double, double* %2594, i64 %2595
%2597 = load double, double* %2596
%2598 = fdiv double %2597, %2590
store double %2598, double* %2596
%2599 = load double, double* @contrast.wsum
%2600 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 6)
%2601 = load i64, i64* @contrast.ilat
%2602 = getelementptr inbounds double*, double** %2600, i64 %2601
%2603 = load double*, double** %2602
%2604 = load i64, i64* @contrast.ilon
%2605 = getelementptr inbounds double, double* %2603, i64 %2604
%2606 = load double, double* %2605
%2607 = fdiv double %2606, %2599
store double %2607, double* %2605
%2608 = load double, double* @contrast.wsum
%2609 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 7)
%2610 = load i64, i64* @contrast.ilat
%2611 = getelementptr inbounds double*, double** %2609, i64 %2610
%2612 = load double*, double** %2611
%2613 = load i64, i64* @contrast.ilon
%2614 = getelementptr inbounds double, double* %2612, i64 %2613
%2615 = load double, double* %2614
%2616 = fdiv double %2615, %2608
store double %2616, double* %2614
%2617 = load double, double* @contrast.wsum
%2618 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 8)
%2619 = load i64, i64* @contrast.ilat
%2620 = getelementptr inbounds double*, double** %2618, i64 %2619
%2621 = load double*, double** %2620
%2622 = load i64, i64* @contrast.ilon
%2623 = getelementptr inbounds double, double* %2621, i64 %2622
%2624 = load double, double* %2623
%2625 = fdiv double %2624, %2617
store double %2625, double* %2623
br label %2626
2626: ; preds = %2478, %618
br label %2627
2627: ; preds = %2626
%2628 = load i64, i64* @contrast.ilat
%2629 = add nsw i64 %2628, 1
store i64 %2629, i64* @contrast.ilat
br label %463
2630: ; preds = %463
br label %2631
2631: ; preds = %2630
%2632 = load i64, i64* @contrast.ilon
%2633 = add nsw i64 %2632, 1
store i64 %2633, i64* @contrast.ilon
br label %431
2634: ; preds = %431
br label %2635
2635: ; preds = %2634, %427
store double 0.000000e+00, double* @contrast.max
store i64 0, i64* @contrast.ilat
br label %2636
2636: ; preds = %2691, %2635
%2637 = load i64, i64* @contrast.ilat
%2638 = load i32, i32* %2
%2639 = sext i32 %2638 to i64
%2640 = icmp slt i64 %2637, %2639
br i1 %2640, label %2641, label %2694
2641: ; preds = %2636
store i64 0, i64* @contrast.ilon
br label %2642
2642: ; preds = %2687, %2641
%2643 = load i64, i64* @contrast.ilon
%2644 = load i32, i32* %3
%2645 = sext i32 %2644 to i64
%2646 = icmp slt i64 %2643, %2645
br i1 %2646, label %2647, label %2690
2647: ; preds = %2642
%2648 = load double**, double*** @contrast.xin
%2649 = load i64, i64* @contrast.ilat
%2650 = getelementptr inbounds double*, double** %2648, i64 %2649
%2651 = load double*, double** %2650
%2652 = load i64, i64* @contrast.ilon
%2653 = getelementptr inbounds double, double* %2651, i64 %2652
%2654 = load double, double* %2653
store double %2654, double* @contrast.f
%2655 = load double, double* @contrast.f
%2656 = load double, double* @contrast.f
%2657 = fcmp une double %2655, %2656
br i1 %2657, label %2662, label %2658
2658: ; preds = %2647
%2659 = load double, double* %7
%2660 = load double, double* %7
%2661 = fcmp une double %2659, %2660
br i1 %2661, label %2662, label %2672
2662: ; preds = %2658, %2647
%2663 = load double, double* @contrast.f
%2664 = load double, double* @contrast.f
%2665 = fcmp une double %2663, %2664
br i1 %2665, label %2666, label %2671
2666: ; preds = %2662
%2667 = load double, double* %7
%2668 = load double, double* %7
%2669 = fcmp une double %2667, %2668
br i1 %2669, label %2670, label %2671
2670: ; preds = %2666
br i1 true, label %2686, label %2680
2671: ; preds = %2666, %2662
br i1 false, label %2686, label %2680
2672: ; preds = %2658
%2673 = load double, double* @contrast.f
%2674 = load double, double* %7
%2675 = fcmp olt double %2673, %2674
br i1 %2675, label %2680, label %2676
2676: ; preds = %2672
%2677 = load double, double* %7
%2678 = load double, double* @contrast.f
%2679 = fcmp olt double %2677, %2678
br i1 %2679, label %2680, label %2686
2680: ; preds = %2676, %2672, %2671, %2670
%2681 = load double, double* @contrast.f
%2682 = load double, double* @contrast.max
%2683 = fcmp ogt double %2681, %2682
br i1 %2683, label %2684, label %2686
2684: ; preds = %2680
%2685 = load double, double* @contrast.f
store double %2685, double* @contrast.max
br label %2686
2686: ; preds = %2684, %2680, %2676, %2671, %2670
br label %2687
2687: ; preds = %2686
%2688 = load i64, i64* @contrast.ilon
%2689 = add nsw i64 %2688, 1
store i64 %2689, i64* @contrast.ilon
br label %2642
2690: ; preds = %2642
br label %2691
2691: ; preds = %2690
%2692 = load i64, i64* @contrast.ilat
%2693 = add nsw i64 %2692, 1
store i64 %2693, i64* @contrast.ilat
br label %2636
2694: ; preds = %2636
%2695 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 9)
store double** %2695, double*** @contrast.r
%2696 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 10)
store double** %2696, double*** @contrast.r_bar
%2697 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 11)
store double** %2697, double*** @contrast.r_new
%2698 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 12)
store double** %2698, double*** @contrast.r_bar_new
%2699 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 13)
store double** %2699, double*** @contrast.p
%2700 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 14)
store double** %2700, double*** @contrast.p_bar
%2701 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 15)
store double** %2701, double*** @contrast.p_new
%2702 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 16)
store double** %2702, double*** @contrast.p_bar_new
store i64 0, i64* @contrast.ilat
br label %2703
2703: ; preds = %2732, %2694
%2704 = load i64, i64* @contrast.ilat
%2705 = load i32, i32* %2
%2706 = sext i32 %2705 to i64
%2707 = icmp slt i64 %2704, %2706
br i1 %2707, label %2708, label %2735
2708: ; preds = %2703
store i64 0, i64* @contrast.ilon
br label %2709
2709: ; preds = %2728, %2708
%2710 = load i64, i64* @contrast.ilon
%2711 = load i32, i32* %3
%2712 = sext i32 %2711 to i64
%2713 = icmp slt i64 %2710, %2712
br i1 %2713, label %2714, label %2731
2714: ; preds = %2709
%2715 = load double**, double*** @contrast.xin
%2716 = load i64, i64* @contrast.ilat
%2717 = getelementptr inbounds double*, double** %2715, i64 %2716
%2718 = load double*, double** %2717
%2719 = load i64, i64* @contrast.ilon
%2720 = getelementptr inbounds double, double* %2718, i64 %2719
%2721 = load double, double* %2720
%2722 = load double**, double*** @contrast.xout
%2723 = load i64, i64* @contrast.ilat
%2724 = getelementptr inbounds double*, double** %2722, i64 %2723
%2725 = load double*, double** %2724
%2726 = load i64, i64* @contrast.ilon
%2727 = getelementptr inbounds double, double* %2725, i64 %2726
store double %2721, double* %2727
br label %2728
2728: ; preds = %2714
%2729 = load i64, i64* @contrast.ilon
%2730 = add nsw i64 %2729, 1
store i64 %2730, i64* @contrast.ilon
br label %2709
2731: ; preds = %2709
br label %2732
2732: ; preds = %2731
%2733 = load i64, i64* @contrast.ilat
%2734 = add nsw i64 %2733, 1
store i64 %2734, i64* @contrast.ilat
br label %2703
2735: ; preds = %2703
store i64 0, i64* @contrast.ilat
br label %2736
2736: ; preds = %2931, %2735
%2737 = load i64, i64* @contrast.ilat
%2738 = load i32, i32* %2
%2739 = sext i32 %2738 to i64
%2740 = icmp slt i64 %2737, %2739
br i1 %2740, label %2741, label %2934
2741: ; preds = %2736
store i64 0, i64* @contrast.ilon
br label %2742
2742: ; preds = %2927, %2741
%2743 = load i64, i64* @contrast.ilon
%2744 = load i32, i32* %3
%2745 = sext i32 %2744 to i64
%2746 = icmp slt i64 %2743, %2745
br i1 %2746, label %2747, label %2930
2747: ; preds = %2742
%2748 = load double**, double*** @contrast.xin
%2749 = load i64, i64* @contrast.ilat
%2750 = getelementptr inbounds double*, double** %2748, i64 %2749
%2751 = load double*, double** %2750
%2752 = load i64, i64* @contrast.ilon
%2753 = getelementptr inbounds double, double* %2751, i64 %2752
%2754 = load double, double* %2753
%2755 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 0)
%2756 = load i64, i64* @contrast.ilat
%2757 = getelementptr inbounds double*, double** %2755, i64 %2756
%2758 = load double*, double** %2757
%2759 = load i64, i64* @contrast.ilon
%2760 = getelementptr inbounds double, double* %2758, i64 %2759
%2761 = load double, double* %2760
%2762 = load double**, double*** @contrast.xin
%2763 = load i64, i64* @contrast.ilat
%2764 = sub nsw i64 %2763, 1
%2765 = getelementptr inbounds double*, double** %2762, i64 %2764
%2766 = load double*, double** %2765
%2767 = load i64, i64* @contrast.ilon
%2768 = sub nsw i64 %2767, 1
%2769 = getelementptr inbounds double, double* %2766, i64 %2768
%2770 = load double, double* %2769
%2771 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 1)
%2772 = load i64, i64* @contrast.ilat
%2773 = getelementptr inbounds double*, double** %2771, i64 %2772
%2774 = load double*, double** %2773
%2775 = load i64, i64* @contrast.ilon
%2776 = getelementptr inbounds double, double* %2774, i64 %2775
%2777 = load double, double* %2776
%2778 = load double**, double*** @contrast.xin
%2779 = load i64, i64* @contrast.ilat
%2780 = sub nsw i64 %2779, 1
%2781 = getelementptr inbounds double*, double** %2778, i64 %2780
%2782 = load double*, double** %2781
%2783 = load i64, i64* @contrast.ilon
%2784 = getelementptr inbounds double, double* %2782, i64 %2783
%2785 = load double, double* %2784
%2786 = fmul double %2777, %2785
%2787 = call double @llvm.fmuladd.f64(double %2761, double %2770, double %2786)
%2788 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 2)
%2789 = load i64, i64* @contrast.ilat
%2790 = getelementptr inbounds double*, double** %2788, i64 %2789
%2791 = load double*, double** %2790
%2792 = load i64, i64* @contrast.ilon
%2793 = getelementptr inbounds double, double* %2791, i64 %2792
%2794 = load double, double* %2793
%2795 = load double**, double*** @contrast.xin
%2796 = load i64, i64* @contrast.ilat
%2797 = sub nsw i64 %2796, 1
%2798 = getelementptr inbounds double*, double** %2795, i64 %2797
%2799 = load double*, double** %2798
%2800 = load i64, i64* @contrast.ilon
%2801 = add nsw i64 %2800, 1
%2802 = getelementptr inbounds double, double* %2799, i64 %2801
%2803 = load double, double* %2802
%2804 = call double @llvm.fmuladd.f64(double %2794, double %2803, double %2787)
%2805 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 3)
%2806 = load i64, i64* @contrast.ilat
%2807 = getelementptr inbounds double*, double** %2805, i64 %2806
%2808 = load double*, double** %2807
%2809 = load i64, i64* @contrast.ilon
%2810 = getelementptr inbounds double, double* %2808, i64 %2809
%2811 = load double, double* %2810
%2812 = load double**, double*** @contrast.xin
%2813 = load i64, i64* @contrast.ilat
%2814 = getelementptr inbounds double*, double** %2812, i64 %2813
%2815 = load double*, double** %2814
%2816 = load i64, i64* @contrast.ilon
%2817 = sub nsw i64 %2816, 1
%2818 = getelementptr inbounds double, double* %2815, i64 %2817
%2819 = load double, double* %2818
%2820 = call double @llvm.fmuladd.f64(double %2811, double %2819, double %2804)
%2821 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 4)
%2822 = load i64, i64* @contrast.ilat
%2823 = getelementptr inbounds double*, double** %2821, i64 %2822
%2824 = load double*, double** %2823
%2825 = load i64, i64* @contrast.ilon
%2826 = getelementptr inbounds double, double* %2824, i64 %2825
%2827 = load double, double* %2826
%2828 = load double**, double*** @contrast.xin
%2829 = load i64, i64* @contrast.ilat
%2830 = getelementptr inbounds double*, double** %2828, i64 %2829
%2831 = load double*, double** %2830
%2832 = load i64, i64* @contrast.ilon
%2833 = getelementptr inbounds double, double* %2831, i64 %2832
%2834 = load double, double* %2833
%2835 = call double @llvm.fmuladd.f64(double %2827, double %2834, double %2820)
%2836 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 5)
%2837 = load i64, i64* @contrast.ilat
%2838 = getelementptr inbounds double*, double** %2836, i64 %2837
%2839 = load double*, double** %2838
%2840 = load i64, i64* @contrast.ilon
%2841 = getelementptr inbounds double, double* %2839, i64 %2840
%2842 = load double, double* %2841
%2843 = load double**, double*** @contrast.xin
%2844 = load i64, i64* @contrast.ilat
%2845 = getelementptr inbounds double*, double** %2843, i64 %2844
%2846 = load double*, double** %2845
%2847 = load i64, i64* @contrast.ilon
%2848 = add nsw i64 %2847, 1
%2849 = getelementptr inbounds double, double* %2846, i64 %2848
%2850 = load double, double* %2849
%2851 = call double @llvm.fmuladd.f64(double %2842, double %2850, double %2835)
%2852 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 6)
%2853 = load i64, i64* @contrast.ilat
%2854 = getelementptr inbounds double*, double** %2852, i64 %2853
%2855 = load double*, double** %2854
%2856 = load i64, i64* @contrast.ilon
%2857 = getelementptr inbounds double, double* %2855, i64 %2856
%2858 = load double, double* %2857
%2859 = load double**, double*** @contrast.xin
%2860 = load i64, i64* @contrast.ilat
%2861 = add nsw i64 %2860, 1
%2862 = getelementptr inbounds double*, double** %2859, i64 %2861
%2863 = load double*, double** %2862
%2864 = load i64, i64* @contrast.ilon
%2865 = sub nsw i64 %2864, 1
%2866 = getelementptr inbounds double, double* %2863, i64 %2865
%2867 = load double, double* %2866
%2868 = call double @llvm.fmuladd.f64(double %2858, double %2867, double %2851)
%2869 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 7)
%2870 = load i64, i64* @contrast.ilat
%2871 = getelementptr inbounds double*, double** %2869, i64 %2870
%2872 = load double*, double** %2871
%2873 = load i64, i64* @contrast.ilon
%2874 = getelementptr inbounds double, double* %2872, i64 %2873
%2875 = load double, double* %2874
%2876 = load double**, double*** @contrast.xin
%2877 = load i64, i64* @contrast.ilat
%2878 = add nsw i64 %2877, 1
%2879 = getelementptr inbounds double*, double** %2876, i64 %2878
%2880 = load double*, double** %2879
%2881 = load i64, i64* @contrast.ilon
%2882 = getelementptr inbounds double, double* %2880, i64 %2881
%2883 = load double, double* %2882
%2884 = call double @llvm.fmuladd.f64(double %2875, double %2883, double %2868)
%2885 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 8)
%2886 = load i64, i64* @contrast.ilat
%2887 = getelementptr inbounds double*, double** %2885, i64 %2886
%2888 = load double*, double** %2887
%2889 = load i64, i64* @contrast.ilon
%2890 = getelementptr inbounds double, double* %2888, i64 %2889
%2891 = load double, double* %2890
%2892 = load double**, double*** @contrast.xin
%2893 = load i64, i64* @contrast.ilat
%2894 = add nsw i64 %2893, 1
%2895 = getelementptr inbounds double*, double** %2892, i64 %2894
%2896 = load double*, double** %2895
%2897 = load i64, i64* @contrast.ilon
%2898 = add nsw i64 %2897, 1
%2899 = getelementptr inbounds double, double* %2896, i64 %2898
%2900 = load double, double* %2899
%2901 = call double @llvm.fmuladd.f64(double %2891, double %2900, double %2884)
%2902 = fsub double %2754, %2901
%2903 = load double**, double*** @contrast.p_bar
%2904 = load i64, i64* @contrast.ilat
%2905 = getelementptr inbounds double*, double** %2903, i64 %2904
%2906 = load double*, double** %2905
%2907 = load i64, i64* @contrast.ilon
%2908 = getelementptr inbounds double, double* %2906, i64 %2907
store double %2902, double* %2908
%2909 = load double**, double*** @contrast.p
%2910 = load i64, i64* @contrast.ilat
%2911 = getelementptr inbounds double*, double** %2909, i64 %2910
%2912 = load double*, double** %2911
%2913 = load i64, i64* @contrast.ilon
%2914 = getelementptr inbounds double, double* %2912, i64 %2913
store double %2902, double* %2914
%2915 = load double**, double*** @contrast.r_bar
%2916 = load i64, i64* @contrast.ilat
%2917 = getelementptr inbounds double*, double** %2915, i64 %2916
%2918 = load double*, double** %2917
%2919 = load i64, i64* @contrast.ilon
%2920 = getelementptr inbounds double, double* %2918, i64 %2919
store double %2902, double* %2920
%2921 = load double**, double*** @contrast.r
%2922 = load i64, i64* @contrast.ilat
%2923 = getelementptr inbounds double*, double** %2921, i64 %2922
%2924 = load double*, double** %2923
%2925 = load i64, i64* @contrast.ilon
%2926 = getelementptr inbounds double, double* %2924, i64 %2925
store double %2902, double* %2926
br label %2927
2927: ; preds = %2747
%2928 = load i64, i64* @contrast.ilon
%2929 = add nsw i64 %2928, 1
store i64 %2929, i64* @contrast.ilon
br label %2742
2930: ; preds = %2742
br label %2931
2931: ; preds = %2930
%2932 = load i64, i64* @contrast.ilat
%2933 = add nsw i64 %2932, 1
store i64 %2933, i64* @contrast.ilat
br label %2736
2934: ; preds = %2736
store i32 1, i32* @contrast.iter
br label %2935
2935: ; preds = %4463, %2934
store i32 1, i32* @contrast.stop_iteration
store i64 0, i64* @contrast.ilat
br label %2936
2936: ; preds = %2965, %2935
%2937 = load i64, i64* @contrast.ilat
%2938 = load i32, i32* %2
%2939 = sext i32 %2938 to i64
%2940 = icmp slt i64 %2937, %2939
br i1 %2940, label %2941, label %2968
2941: ; preds = %2936
store i64 0, i64* @contrast.ilon
br label %2942
2942: ; preds = %2961, %2941
%2943 = load i64, i64* @contrast.ilon
%2944 = load i32, i32* %3
%2945 = sext i32 %2944 to i64
%2946 = icmp slt i64 %2943, %2945
br i1 %2946, label %2947, label %2964
2947: ; preds = %2942
%2948 = load double**, double*** @contrast.r
%2949 = load i64, i64* @contrast.ilat
%2950 = getelementptr inbounds double*, double** %2948, i64 %2949
%2951 = load double*, double** %2950
%2952 = load i64, i64* @contrast.ilon
%2953 = getelementptr inbounds double, double* %2951, i64 %2952
%2954 = load double, double* %2953
%2955 = call double @llvm.fabs.f64(double %2954)
%2956 = load double, double* @contrast.max
%2957 = fmul double 0x3BC79CA10C924223, %2956
%2958 = fcmp ogt double %2955, %2957
br i1 %2958, label %2959, label %2960
2959: ; preds = %2947
store i32 0, i32* @contrast.stop_iteration
br label %2964
2960: ; preds = %2947
br label %2961
2961: ; preds = %2960
%2962 = load i64, i64* @contrast.ilon
%2963 = add nsw i64 %2962, 1
store i64 %2963, i64* @contrast.ilon
br label %2942
2964: ; preds = %2959, %2942
br label %2965
2965: ; preds = %2964
%2966 = load i64, i64* @contrast.ilat
%2967 = add nsw i64 %2966, 1
store i64 %2967, i64* @contrast.ilat
br label %2936
2968: ; preds = %2936
%2969 = load i32, i32* @contrast.stop_iteration
%2970 = icmp ne i32 %2969, 0
br i1 %2970, label %2971, label %2972
2971: ; preds = %2968
br label %4466
2972: ; preds = %2968
%2973 = load i32, i32* @contrast.iter
%2974 = icmp eq i32 %2973, 1
br i1 %2974, label %2975, label %3012
2975: ; preds = %2972
store double 0.000000e+00, double* @contrast.nom
store i64 0, i64* @contrast.ilat
br label %2976
2976: ; preds = %3008, %2975
%2977 = load i64, i64* @contrast.ilat
%2978 = load i32, i32* %2
%2979 = sext i32 %2978 to i64
%2980 = icmp slt i64 %2977, %2979
br i1 %2980, label %2981, label %3011
2981: ; preds = %2976
store i64 0, i64* @contrast.ilon
br label %2982
2982: ; preds = %3004, %2981
%2983 = load i64, i64* @contrast.ilon
%2984 = load i32, i32* %3
%2985 = sext i32 %2984 to i64
%2986 = icmp slt i64 %2983, %2985
br i1 %2986, label %2987, label %3007
2987: ; preds = %2982
%2988 = load double**, double*** @contrast.r
%2989 = load i64, i64* @contrast.ilat
%2990 = getelementptr inbounds double*, double** %2988, i64 %2989
%2991 = load double*, double** %2990
%2992 = load i64, i64* @contrast.ilon
%2993 = getelementptr inbounds double, double* %2991, i64 %2992
%2994 = load double, double* %2993
%2995 = load double**, double*** @contrast.r_bar
%2996 = load i64, i64* @contrast.ilat
%2997 = getelementptr inbounds double*, double** %2995, i64 %2996
%2998 = load double*, double** %2997
%2999 = load i64, i64* @contrast.ilon
%3000 = getelementptr inbounds double, double* %2998, i64 %2999
%3001 = load double, double* %3000
%3002 = load double, double* @contrast.nom
%3003 = call double @llvm.fmuladd.f64(double %2994, double %3001, double %3002)
store double %3003, double* @contrast.nom
br label %3004
3004: ; preds = %2987
%3005 = load i64, i64* @contrast.ilon
%3006 = add nsw i64 %3005, 1
store i64 %3006, i64* @contrast.ilon
br label %2982
3007: ; preds = %2982
br label %3008
3008: ; preds = %3007
%3009 = load i64, i64* @contrast.ilat
%3010 = add nsw i64 %3009, 1
store i64 %3010, i64* @contrast.ilat
br label %2976
3011: ; preds = %2976
br label %3012
3012: ; preds = %3011, %2972
store i64 0, i64* @contrast.ilat
br label %3013
3013: ; preds = %3050, %3012
%3014 = load i64, i64* @contrast.ilat
%3015 = load i32, i32* %2
%3016 = sext i32 %3015 to i64
%3017 = icmp slt i64 %3014, %3016
br i1 %3017, label %3018, label %3053
3018: ; preds = %3013
store i64 0, i64* @contrast.ilon
br label %3019
3019: ; preds = %3046, %3018
%3020 = load i64, i64* @contrast.ilon
%3021 = load i32, i32* %3
%3022 = sext i32 %3021 to i64
%3023 = icmp slt i64 %3020, %3022
br i1 %3023, label %3024, label %3049
3024: ; preds = %3019
%3025 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 4)
%3026 = load i64, i64* @contrast.ilat
%3027 = getelementptr inbounds double*, double** %3025, i64 %3026
%3028 = load double*, double** %3027
%3029 = load i64, i64* @contrast.ilon
%3030 = getelementptr inbounds double, double* %3028, i64 %3029
%3031 = load double, double* %3030
%3032 = load double**, double*** @contrast.p
%3033 = load i64, i64* @contrast.ilat
%3034 = getelementptr inbounds double*, double** %3032, i64 %3033
%3035 = load double*, double** %3034
%3036 = load i64, i64* @contrast.ilon
%3037 = getelementptr inbounds double, double* %3035, i64 %3036
%3038 = load double, double* %3037
%3039 = fmul double %3031, %3038
%3040 = load double**, double*** @contrast.r_new
%3041 = load i64, i64* @contrast.ilat
%3042 = getelementptr inbounds double*, double** %3040, i64 %3041
%3043 = load double*, double** %3042
%3044 = load i64, i64* @contrast.ilon
%3045 = getelementptr inbounds double, double* %3043, i64 %3044
store double %3039, double* %3045
br label %3046
3046: ; preds = %3024
%3047 = load i64, i64* @contrast.ilon
%3048 = add nsw i64 %3047, 1
store i64 %3048, i64* @contrast.ilon
br label %3019
3049: ; preds = %3019
br label %3050
3050: ; preds = %3049
%3051 = load i64, i64* @contrast.ilat
%3052 = add nsw i64 %3051, 1
store i64 %3052, i64* @contrast.ilat
br label %3013
3053: ; preds = %3013
store i64 1, i64* @contrast.ilat
br label %3054
3054: ; preds = %3117, %3053
%3055 = load i64, i64* @contrast.ilat
%3056 = load i32, i32* %2
%3057 = sext i32 %3056 to i64
%3058 = icmp slt i64 %3055, %3057
br i1 %3058, label %3059, label %3120
3059: ; preds = %3054
store i64 1, i64* @contrast.ilon
br label %3060
3060: ; preds = %3090, %3059
%3061 = load i64, i64* @contrast.ilon
%3062 = load i32, i32* %3
%3063 = sext i32 %3062 to i64
%3064 = icmp slt i64 %3061, %3063
br i1 %3064, label %3065, label %3093
3065: ; preds = %3060
%3066 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 0)
%3067 = load i64, i64* @contrast.ilat
%3068 = getelementptr inbounds double*, double** %3066, i64 %3067
%3069 = load double*, double** %3068
%3070 = load i64, i64* @contrast.ilon
%3071 = getelementptr inbounds double, double* %3069, i64 %3070
%3072 = load double, double* %3071
%3073 = load double**, double*** @contrast.p
%3074 = load i64, i64* @contrast.ilat
%3075 = sub nsw i64 %3074, 1
%3076 = getelementptr inbounds double*, double** %3073, i64 %3075
%3077 = load double*, double** %3076
%3078 = load i64, i64* @contrast.ilon
%3079 = sub nsw i64 %3078, 1
%3080 = getelementptr inbounds double, double* %3077, i64 %3079
%3081 = load double, double* %3080
%3082 = load double**, double*** @contrast.r_new
%3083 = load i64, i64* @contrast.ilat
%3084 = getelementptr inbounds double*, double** %3082, i64 %3083
%3085 = load double*, double** %3084
%3086 = load i64, i64* @contrast.ilon
%3087 = getelementptr inbounds double, double* %3085, i64 %3086
%3088 = load double, double* %3087
%3089 = call double @llvm.fmuladd.f64(double %3072, double %3081, double %3088)
store double %3089, double* %3087
br label %3090
3090: ; preds = %3065
%3091 = load i64, i64* @contrast.ilon
%3092 = add nsw i64 %3091, 1
store i64 %3092, i64* @contrast.ilon
br label %3060
3093: ; preds = %3060
%3094 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 0)
%3095 = load i64, i64* @contrast.ilat
%3096 = getelementptr inbounds double*, double** %3094, i64 %3095
%3097 = load double*, double** %3096
%3098 = getelementptr inbounds double, double* %3097, i64 0
%3099 = load double, double* %3098
%3100 = load double**, double*** @contrast.p
%3101 = load i64, i64* @contrast.ilat
%3102 = sub nsw i64 %3101, 1
%3103 = getelementptr inbounds double*, double** %3100, i64 %3102
%3104 = load double*, double** %3103
%3105 = load i32, i32* %3
%3106 = sub nsw i32 %3105, 1
%3107 = sext i32 %3106 to i64
%3108 = getelementptr inbounds double, double* %3104, i64 %3107
%3109 = load double, double* %3108
%3110 = load double**, double*** @contrast.r_new
%3111 = load i64, i64* @contrast.ilat
%3112 = getelementptr inbounds double*, double** %3110, i64 %3111
%3113 = load double*, double** %3112
%3114 = getelementptr inbounds double, double* %3113, i64 0
%3115 = load double, double* %3114
%3116 = call double @llvm.fmuladd.f64(double %3099, double %3109, double %3115)
store double %3116, double* %3114
br label %3117
3117: ; preds = %3093
%3118 = load i64, i64* @contrast.ilat
%3119 = add nsw i64 %3118, 1
store i64 %3119, i64* @contrast.ilat
br label %3054
3120: ; preds = %3054
store i64 1, i64* @contrast.ilat
br label %3121
3121: ; preds = %3160, %3120
%3122 = load i64, i64* @contrast.ilat
%3123 = load i32, i32* %2
%3124 = sext i32 %3123 to i64
%3125 = icmp slt i64 %3122, %3124
br i1 %3125, label %3126, label %3163
3126: ; preds = %3121
store i64 0, i64* @contrast.ilon
br label %3127
3127: ; preds = %3156, %3126
%3128 = load i64, i64* @contrast.ilon
%3129 = load i32, i32* %3
%3130 = sext i32 %3129 to i64
%3131 = icmp slt i64 %3128, %3130
br i1 %3131, label %3132, label %3159
3132: ; preds = %3127
%3133 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 1)
%3134 = load i64, i64* @contrast.ilat
%3135 = getelementptr inbounds double*, double** %3133, i64 %3134
%3136 = load double*, double** %3135
%3137 = load i64, i64* @contrast.ilon
%3138 = getelementptr inbounds double, double* %3136, i64 %3137
%3139 = load double, double* %3138
%3140 = load double**, double*** @contrast.p
%3141 = load i64, i64* @contrast.ilat
%3142 = sub nsw i64 %3141, 1
%3143 = getelementptr inbounds double*, double** %3140, i64 %3142
%3144 = load double*, double** %3143
%3145 = load i64, i64* @contrast.ilon
%3146 = getelementptr inbounds double, double* %3144, i64 %3145
%3147 = load double, double* %3146
%3148 = load double**, double*** @contrast.r_new
%3149 = load i64, i64* @contrast.ilat
%3150 = getelementptr inbounds double*, double** %3148, i64 %3149
%3151 = load double*, double** %3150
%3152 = load i64, i64* @contrast.ilon
%3153 = getelementptr inbounds double, double* %3151, i64 %3152
%3154 = load double, double* %3153
%3155 = call double @llvm.fmuladd.f64(double %3139, double %3147, double %3154)
store double %3155, double* %3153
br label %3156
3156: ; preds = %3132
%3157 = load i64, i64* @contrast.ilon
%3158 = add nsw i64 %3157, 1
store i64 %3158, i64* @contrast.ilon
br label %3127
3159: ; preds = %3127
br label %3160
3160: ; preds = %3159
%3161 = load i64, i64* @contrast.ilat
%3162 = add nsw i64 %3161, 1
store i64 %3162, i64* @contrast.ilat
br label %3121
3163: ; preds = %3121
store i64 1, i64* @contrast.ilat
br label %3164
3164: ; preds = %3231, %3163
%3165 = load i64, i64* @contrast.ilat
%3166 = load i32, i32* %2
%3167 = sext i32 %3166 to i64
%3168 = icmp slt i64 %3165, %3167
br i1 %3168, label %3169, label %3234
3169: ; preds = %3164
store i64 0, i64* @contrast.ilon
br label %3170
3170: ; preds = %3201, %3169
%3171 = load i64, i64* @contrast.ilon
%3172 = load i32, i32* %3
%3173 = sub nsw i32 %3172, 1
%3174 = sext i32 %3173 to i64
%3175 = icmp slt i64 %3171, %3174
br i1 %3175, label %3176, label %3204
3176: ; preds = %3170
%3177 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 2)
%3178 = load i64, i64* @contrast.ilat
%3179 = getelementptr inbounds double*, double** %3177, i64 %3178
%3180 = load double*, double** %3179
%3181 = load i64, i64* @contrast.ilon
%3182 = getelementptr inbounds double, double* %3180, i64 %3181
%3183 = load double, double* %3182
%3184 = load double**, double*** @contrast.p
%3185 = load i64, i64* @contrast.ilat
%3186 = sub nsw i64 %3185, 1
%3187 = getelementptr inbounds double*, double** %3184, i64 %3186
%3188 = load double*, double** %3187
%3189 = load i64, i64* @contrast.ilon
%3190 = add nsw i64 %3189, 1
%3191 = getelementptr inbounds double, double* %3188, i64 %3190
%3192 = load double, double* %3191
%3193 = load double**, double*** @contrast.r_new
%3194 = load i64, i64* @contrast.ilat
%3195 = getelementptr inbounds double*, double** %3193, i64 %3194
%3196 = load double*, double** %3195
%3197 = load i64, i64* @contrast.ilon
%3198 = getelementptr inbounds double, double* %3196, i64 %3197
%3199 = load double, double* %3198
%3200 = call double @llvm.fmuladd.f64(double %3183, double %3192, double %3199)
store double %3200, double* %3198
br label %3201
3201: ; preds = %3176
%3202 = load i64, i64* @contrast.ilon
%3203 = add nsw i64 %3202, 1
store i64 %3203, i64* @contrast.ilon
br label %3170
3204: ; preds = %3170
%3205 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 2)
%3206 = load i64, i64* @contrast.ilat
%3207 = getelementptr inbounds double*, double** %3205, i64 %3206
%3208 = load double*, double** %3207
%3209 = load i32, i32* %3
%3210 = sub nsw i32 %3209, 1
%3211 = sext i32 %3210 to i64
%3212 = getelementptr inbounds double, double* %3208, i64 %3211
%3213 = load double, double* %3212
%3214 = load double**, double*** @contrast.p
%3215 = load i64, i64* @contrast.ilat
%3216 = sub nsw i64 %3215, 1
%3217 = getelementptr inbounds double*, double** %3214, i64 %3216
%3218 = load double*, double** %3217
%3219 = getelementptr inbounds double, double* %3218, i64 0
%3220 = load double, double* %3219
%3221 = load double**, double*** @contrast.r_new
%3222 = load i64, i64* @contrast.ilat
%3223 = getelementptr inbounds double*, double** %3221, i64 %3222
%3224 = load double*, double** %3223
%3225 = load i32, i32* %3
%3226 = sub nsw i32 %3225, 1
%3227 = sext i32 %3226 to i64
%3228 = getelementptr inbounds double, double* %3224, i64 %3227
%3229 = load double, double* %3228
%3230 = call double @llvm.fmuladd.f64(double %3213, double %3220, double %3229)
store double %3230, double* %3228
br label %3231
3231: ; preds = %3204
%3232 = load i64, i64* @contrast.ilat
%3233 = add nsw i64 %3232, 1
store i64 %3233, i64* @contrast.ilat
br label %3164
3234: ; preds = %3164
store i64 0, i64* @contrast.ilat
br label %3235
3235: ; preds = %3296, %3234
%3236 = load i64, i64* @contrast.ilat
%3237 = load i32, i32* %2
%3238 = sext i32 %3237 to i64
%3239 = icmp slt i64 %3236, %3238
br i1 %3239, label %3240, label %3299
3240: ; preds = %3235
store i64 1, i64* @contrast.ilon
br label %3241
3241: ; preds = %3270, %3240
%3242 = load i64, i64* @contrast.ilon
%3243 = load i32, i32* %3
%3244 = sext i32 %3243 to i64
%3245 = icmp slt i64 %3242, %3244
br i1 %3245, label %3246, label %3273
3246: ; preds = %3241
%3247 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 3)
%3248 = load i64, i64* @contrast.ilat
%3249 = getelementptr inbounds double*, double** %3247, i64 %3248
%3250 = load double*, double** %3249
%3251 = load i64, i64* @contrast.ilon
%3252 = getelementptr inbounds double, double* %3250, i64 %3251
%3253 = load double, double* %3252
%3254 = load double**, double*** @contrast.p
%3255 = load i64, i64* @contrast.ilat
%3256 = getelementptr inbounds double*, double** %3254, i64 %3255
%3257 = load double*, double** %3256
%3258 = load i64, i64* @contrast.ilon
%3259 = sub nsw i64 %3258, 1
%3260 = getelementptr inbounds double, double* %3257, i64 %3259
%3261 = load double, double* %3260
%3262 = load double**, double*** @contrast.r_new
%3263 = load i64, i64* @contrast.ilat
%3264 = getelementptr inbounds double*, double** %3262, i64 %3263
%3265 = load double*, double** %3264
%3266 = load i64, i64* @contrast.ilon
%3267 = getelementptr inbounds double, double* %3265, i64 %3266
%3268 = load double, double* %3267
%3269 = call double @llvm.fmuladd.f64(double %3253, double %3261, double %3268)
store double %3269, double* %3267
br label %3270
3270: ; preds = %3246
%3271 = load i64, i64* @contrast.ilon
%3272 = add nsw i64 %3271, 1
store i64 %3272, i64* @contrast.ilon
br label %3241
3273: ; preds = %3241
%3274 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 3)
%3275 = load i64, i64* @contrast.ilat
%3276 = getelementptr inbounds double*, double** %3274, i64 %3275
%3277 = load double*, double** %3276
%3278 = getelementptr inbounds double, double* %3277, i64 0
%3279 = load double, double* %3278
%3280 = load double**, double*** @contrast.p
%3281 = load i64, i64* @contrast.ilat
%3282 = getelementptr inbounds double*, double** %3280, i64 %3281
%3283 = load double*, double** %3282
%3284 = load i32, i32* %3
%3285 = sub nsw i32 %3284, 1
%3286 = sext i32 %3285 to i64
%3287 = getelementptr inbounds double, double* %3283, i64 %3286
%3288 = load double, double* %3287
%3289 = load double**, double*** @contrast.r_new
%3290 = load i64, i64* @contrast.ilat
%3291 = getelementptr inbounds double*, double** %3289, i64 %3290
%3292 = load double*, double** %3291
%3293 = getelementptr inbounds double, double* %3292, i64 0
%3294 = load double, double* %3293
%3295 = call double @llvm.fmuladd.f64(double %3279, double %3288, double %3294)
store double %3295, double* %3293
br label %3296
3296: ; preds = %3273
%3297 = load i64, i64* @contrast.ilat
%3298 = add nsw i64 %3297, 1
store i64 %3298, i64* @contrast.ilat
br label %3235
3299: ; preds = %3235
store i64 0, i64* @contrast.ilat
br label %3300
3300: ; preds = %3365, %3299
%3301 = load i64, i64* @contrast.ilat
%3302 = load i32, i32* %2
%3303 = sext i32 %3302 to i64
%3304 = icmp slt i64 %3301, %3303
br i1 %3304, label %3305, label %3368
3305: ; preds = %3300
store i64 0, i64* @contrast.ilon
br label %3306
3306: ; preds = %3336, %3305
%3307 = load i64, i64* @contrast.ilon
%3308 = load i32, i32* %3
%3309 = sub nsw i32 %3308, 1
%3310 = sext i32 %3309 to i64
%3311 = icmp slt i64 %3307, %3310
br i1 %3311, label %3312, label %3339
3312: ; preds = %3306
%3313 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 5)
%3314 = load i64, i64* @contrast.ilat
%3315 = getelementptr inbounds double*, double** %3313, i64 %3314
%3316 = load double*, double** %3315
%3317 = load i64, i64* @contrast.ilon
%3318 = getelementptr inbounds double, double* %3316, i64 %3317
%3319 = load double, double* %3318
%3320 = load double**, double*** @contrast.p
%3321 = load i64, i64* @contrast.ilat
%3322 = getelementptr inbounds double*, double** %3320, i64 %3321
%3323 = load double*, double** %3322
%3324 = load i64, i64* @contrast.ilon
%3325 = add nsw i64 %3324, 1
%3326 = getelementptr inbounds double, double* %3323, i64 %3325
%3327 = load double, double* %3326
%3328 = load double**, double*** @contrast.r_new
%3329 = load i64, i64* @contrast.ilat
%3330 = getelementptr inbounds double*, double** %3328, i64 %3329
%3331 = load double*, double** %3330
%3332 = load i64, i64* @contrast.ilon
%3333 = getelementptr inbounds double, double* %3331, i64 %3332
%3334 = load double, double* %3333
%3335 = call double @llvm.fmuladd.f64(double %3319, double %3327, double %3334)
store double %3335, double* %3333
br label %3336
3336: ; preds = %3312
%3337 = load i64, i64* @contrast.ilon
%3338 = add nsw i64 %3337, 1
store i64 %3338, i64* @contrast.ilon
br label %3306
3339: ; preds = %3306
%3340 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 5)
%3341 = load i64, i64* @contrast.ilat
%3342 = getelementptr inbounds double*, double** %3340, i64 %3341
%3343 = load double*, double** %3342
%3344 = load i32, i32* %3
%3345 = sub nsw i32 %3344, 1
%3346 = sext i32 %3345 to i64
%3347 = getelementptr inbounds double, double* %3343, i64 %3346
%3348 = load double, double* %3347
%3349 = load double**, double*** @contrast.p
%3350 = load i64, i64* @contrast.ilat
%3351 = getelementptr inbounds double*, double** %3349, i64 %3350
%3352 = load double*, double** %3351
%3353 = getelementptr inbounds double, double* %3352, i64 0
%3354 = load double, double* %3353
%3355 = load double**, double*** @contrast.r_new
%3356 = load i64, i64* @contrast.ilat
%3357 = getelementptr inbounds double*, double** %3355, i64 %3356
%3358 = load double*, double** %3357
%3359 = load i32, i32* %3
%3360 = sub nsw i32 %3359, 1
%3361 = sext i32 %3360 to i64
%3362 = getelementptr inbounds double, double* %3358, i64 %3361
%3363 = load double, double* %3362
%3364 = call double @llvm.fmuladd.f64(double %3348, double %3354, double %3363)
store double %3364, double* %3362
br label %3365
3365: ; preds = %3339
%3366 = load i64, i64* @contrast.ilat
%3367 = add nsw i64 %3366, 1
store i64 %3367, i64* @contrast.ilat
br label %3300
3368: ; preds = %3300
store i64 0, i64* @contrast.ilat
br label %3369
3369: ; preds = %3433, %3368
%3370 = load i64, i64* @contrast.ilat
%3371 = load i32, i32* %2
%3372 = sub nsw i32 %3371, 1
%3373 = sext i32 %3372 to i64
%3374 = icmp slt i64 %3370, %3373
br i1 %3374, label %3375, label %3436
3375: ; preds = %3369
store i64 1, i64* @contrast.ilon
br label %3376
3376: ; preds = %3406, %3375
%3377 = load i64, i64* @contrast.ilon
%3378 = load i32, i32* %3
%3379 = sext i32 %3378 to i64
%3380 = icmp slt i64 %3377, %3379
br i1 %3380, label %3381, label %3409
3381: ; preds = %3376
%3382 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 6)
%3383 = load i64, i64* @contrast.ilat
%3384 = getelementptr inbounds double*, double** %3382, i64 %3383
%3385 = load double*, double** %3384
%3386 = load i64, i64* @contrast.ilon
%3387 = getelementptr inbounds double, double* %3385, i64 %3386
%3388 = load double, double* %3387
%3389 = load double**, double*** @contrast.p
%3390 = load i64, i64* @contrast.ilat
%3391 = add nsw i64 %3390, 1
%3392 = getelementptr inbounds double*, double** %3389, i64 %3391
%3393 = load double*, double** %3392
%3394 = load i64, i64* @contrast.ilon
%3395 = sub nsw i64 %3394, 1
%3396 = getelementptr inbounds double, double* %3393, i64 %3395
%3397 = load double, double* %3396
%3398 = load double**, double*** @contrast.r_new
%3399 = load i64, i64* @contrast.ilat
%3400 = getelementptr inbounds double*, double** %3398, i64 %3399
%3401 = load double*, double** %3400
%3402 = load i64, i64* @contrast.ilon
%3403 = getelementptr inbounds double, double* %3401, i64 %3402
%3404 = load double, double* %3403
%3405 = call double @llvm.fmuladd.f64(double %3388, double %3397, double %3404)
store double %3405, double* %3403
br label %3406
3406: ; preds = %3381
%3407 = load i64, i64* @contrast.ilon
%3408 = add nsw i64 %3407, 1
store i64 %3408, i64* @contrast.ilon
br label %3376
3409: ; preds = %3376
%3410 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 6)
%3411 = load i64, i64* @contrast.ilat
%3412 = getelementptr inbounds double*, double** %3410, i64 %3411
%3413 = load double*, double** %3412
%3414 = getelementptr inbounds double, double* %3413, i64 0
%3415 = load double, double* %3414
%3416 = load double**, double*** @contrast.p
%3417 = load i64, i64* @contrast.ilat
%3418 = add nsw i64 %3417, 1
%3419 = getelementptr inbounds double*, double** %3416, i64 %3418
%3420 = load double*, double** %3419
%3421 = load i32, i32* %3
%3422 = sub nsw i32 %3421, 1
%3423 = sext i32 %3422 to i64
%3424 = getelementptr inbounds double, double* %3420, i64 %3423
%3425 = load double, double* %3424
%3426 = load double**, double*** @contrast.r_new
%3427 = load i64, i64* @contrast.ilat
%3428 = getelementptr inbounds double*, double** %3426, i64 %3427
%3429 = load double*, double** %3428
%3430 = getelementptr inbounds double, double* %3429, i64 0
%3431 = load double, double* %3430
%3432 = call double @llvm.fmuladd.f64(double %3415, double %3425, double %3431)
store double %3432, double* %3430
br label %3433
3433: ; preds = %3409
%3434 = load i64, i64* @contrast.ilat
%3435 = add nsw i64 %3434, 1
store i64 %3435, i64* @contrast.ilat
br label %3369
3436: ; preds = %3369
store i64 0, i64* @contrast.ilat
br label %3437
3437: ; preds = %3477, %3436
%3438 = load i64, i64* @contrast.ilat
%3439 = load i32, i32* %2
%3440 = sub nsw i32 %3439, 1
%3441 = sext i32 %3440 to i64
%3442 = icmp slt i64 %3438, %3441
br i1 %3442, label %3443, label %3480
3443: ; preds = %3437
store i64 0, i64* @contrast.ilon
br label %3444
3444: ; preds = %3473, %3443
%3445 = load i64, i64* @contrast.ilon
%3446 = load i32, i32* %3
%3447 = sext i32 %3446 to i64
%3448 = icmp slt i64 %3445, %3447
br i1 %3448, label %3449, label %3476
3449: ; preds = %3444
%3450 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 7)
%3451 = load i64, i64* @contrast.ilat
%3452 = getelementptr inbounds double*, double** %3450, i64 %3451
%3453 = load double*, double** %3452
%3454 = load i64, i64* @contrast.ilon
%3455 = getelementptr inbounds double, double* %3453, i64 %3454
%3456 = load double, double* %3455
%3457 = load double**, double*** @contrast.p
%3458 = load i64, i64* @contrast.ilat
%3459 = add nsw i64 %3458, 1
%3460 = getelementptr inbounds double*, double** %3457, i64 %3459
%3461 = load double*, double** %3460
%3462 = load i64, i64* @contrast.ilon
%3463 = getelementptr inbounds double, double* %3461, i64 %3462
%3464 = load double, double* %3463
%3465 = load double**, double*** @contrast.r_new
%3466 = load i64, i64* @contrast.ilat
%3467 = getelementptr inbounds double*, double** %3465, i64 %3466
%3468 = load double*, double** %3467
%3469 = load i64, i64* @contrast.ilon
%3470 = getelementptr inbounds double, double* %3468, i64 %3469
%3471 = load double, double* %3470
%3472 = call double @llvm.fmuladd.f64(double %3456, double %3464, double %3471)
store double %3472, double* %3470
br label %3473
3473: ; preds = %3449
%3474 = load i64, i64* @contrast.ilon
%3475 = add nsw i64 %3474, 1
store i64 %3475, i64* @contrast.ilon
br label %3444
3476: ; preds = %3444
br label %3477
3477: ; preds = %3476
%3478 = load i64, i64* @contrast.ilat
%3479 = add nsw i64 %3478, 1
store i64 %3479, i64* @contrast.ilat
br label %3437
3480: ; preds = %3437
store i64 0, i64* @contrast.ilat
br label %3481
3481: ; preds = %3549, %3480
%3482 = load i64, i64* @contrast.ilat
%3483 = load i32, i32* %2
%3484 = sub nsw i32 %3483, 1
%3485 = sext i32 %3484 to i64
%3486 = icmp slt i64 %3482, %3485
br i1 %3486, label %3487, label %3552
3487: ; preds = %3481
store i64 0, i64* @contrast.ilon
br label %3488
3488: ; preds = %3519, %3487
%3489 = load i64, i64* @contrast.ilon
%3490 = load i32, i32* %3
%3491 = sub nsw i32 %3490, 1
%3492 = sext i32 %3491 to i64
%3493 = icmp slt i64 %3489, %3492
br i1 %3493, label %3494, label %3522
3494: ; preds = %3488
%3495 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 8)
%3496 = load i64, i64* @contrast.ilat
%3497 = getelementptr inbounds double*, double** %3495, i64 %3496
%3498 = load double*, double** %3497
%3499 = load i64, i64* @contrast.ilon
%3500 = getelementptr inbounds double, double* %3498, i64 %3499
%3501 = load double, double* %3500
%3502 = load double**, double*** @contrast.p
%3503 = load i64, i64* @contrast.ilat
%3504 = add nsw i64 %3503, 1
%3505 = getelementptr inbounds double*, double** %3502, i64 %3504
%3506 = load double*, double** %3505
%3507 = load i64, i64* @contrast.ilon
%3508 = add nsw i64 %3507, 1
%3509 = getelementptr inbounds double, double* %3506, i64 %3508
%3510 = load double, double* %3509
%3511 = load double**, double*** @contrast.r_new
%3512 = load i64, i64* @contrast.ilat
%3513 = getelementptr inbounds double*, double** %3511, i64 %3512
%3514 = load double*, double** %3513
%3515 = load i64, i64* @contrast.ilon
%3516 = getelementptr inbounds double, double* %3514, i64 %3515
%3517 = load double, double* %3516
%3518 = call double @llvm.fmuladd.f64(double %3501, double %3510, double %3517)
store double %3518, double* %3516
br label %3519
3519: ; preds = %3494
%3520 = load i64, i64* @contrast.ilon
%3521 = add nsw i64 %3520, 1
store i64 %3521, i64* @contrast.ilon
br label %3488
3522: ; preds = %3488
%3523 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 8)
%3524 = load i64, i64* @contrast.ilat
%3525 = getelementptr inbounds double*, double** %3523, i64 %3524
%3526 = load double*, double** %3525
%3527 = load i32, i32* %3
%3528 = sub nsw i32 %3527, 1
%3529 = sext i32 %3528 to i64
%3530 = getelementptr inbounds double, double* %3526, i64 %3529
%3531 = load double, double* %3530
%3532 = load double**, double*** @contrast.p
%3533 = load i64, i64* @contrast.ilat
%3534 = add nsw i64 %3533, 1
%3535 = getelementptr inbounds double*, double** %3532, i64 %3534
%3536 = load double*, double** %3535
%3537 = getelementptr inbounds double, double* %3536, i64 0
%3538 = load double, double* %3537
%3539 = load double**, double*** @contrast.r_new
%3540 = load i64, i64* @contrast.ilat
%3541 = getelementptr inbounds double*, double** %3539, i64 %3540
%3542 = load double*, double** %3541
%3543 = load i32, i32* %3
%3544 = sub nsw i32 %3543, 1
%3545 = sext i32 %3544 to i64
%3546 = getelementptr inbounds double, double* %3542, i64 %3545
%3547 = load double, double* %3546
%3548 = call double @llvm.fmuladd.f64(double %3531, double %3538, double %3547)
store double %3548, double* %3546
br label %3549
3549: ; preds = %3522
%3550 = load i64, i64* @contrast.ilat
%3551 = add nsw i64 %3550, 1
store i64 %3551, i64* @contrast.ilat
br label %3481
3552: ; preds = %3481
store double 0.000000e+00, double* @contrast.denom
store i64 0, i64* @contrast.ilat
br label %3553
3553: ; preds = %3585, %3552
%3554 = load i64, i64* @contrast.ilat
%3555 = load i32, i32* %2
%3556 = sext i32 %3555 to i64
%3557 = icmp slt i64 %3554, %3556
br i1 %3557, label %3558, label %3588
3558: ; preds = %3553
store i64 0, i64* @contrast.ilon
br label %3559
3559: ; preds = %3581, %3558
%3560 = load i64, i64* @contrast.ilon
%3561 = load i32, i32* %3
%3562 = sext i32 %3561 to i64
%3563 = icmp slt i64 %3560, %3562
br i1 %3563, label %3564, label %3584
3564: ; preds = %3559
%3565 = load double**, double*** @contrast.p_bar
%3566 = load i64, i64* @contrast.ilat
%3567 = getelementptr inbounds double*, double** %3565, i64 %3566
%3568 = load double*, double** %3567
%3569 = load i64, i64* @contrast.ilon
%3570 = getelementptr inbounds double, double* %3568, i64 %3569
%3571 = load double, double* %3570
%3572 = load double**, double*** @contrast.r_new
%3573 = load i64, i64* @contrast.ilat
%3574 = getelementptr inbounds double*, double** %3572, i64 %3573
%3575 = load double*, double** %3574
%3576 = load i64, i64* @contrast.ilon
%3577 = getelementptr inbounds double, double* %3575, i64 %3576
%3578 = load double, double* %3577
%3579 = load double, double* @contrast.denom
%3580 = call double @llvm.fmuladd.f64(double %3571, double %3578, double %3579)
store double %3580, double* @contrast.denom
br label %3581
3581: ; preds = %3564
%3582 = load i64, i64* @contrast.ilon
%3583 = add nsw i64 %3582, 1
store i64 %3583, i64* @contrast.ilon
br label %3559
3584: ; preds = %3559
br label %3585
3585: ; preds = %3584
%3586 = load i64, i64* @contrast.ilat
%3587 = add nsw i64 %3586, 1
store i64 %3587, i64* @contrast.ilat
br label %3553
3588: ; preds = %3553
%3589 = load double, double* @contrast.denom
%3590 = fcmp olt double %3589, 0.000000e+00
br i1 %3590, label %3595, label %3591
3591: ; preds = %3588
%3592 = load double, double* @contrast.denom
%3593 = fcmp olt double 0.000000e+00, %3592
br i1 %3593, label %3595, label %3594
3594: ; preds = %3591
br label %4466
3595: ; preds = %3591, %3588
%3596 = load double, double* @contrast.nom
%3597 = load double, double* @contrast.denom
%3598 = fdiv double %3596, %3597
store double %3598, double* @contrast.a
store i64 0, i64* @contrast.ilat
br label %3599
3599: ; preds = %3638, %3595
%3600 = load i64, i64* @contrast.ilat
%3601 = load i32, i32* %2
%3602 = sext i32 %3601 to i64
%3603 = icmp slt i64 %3600, %3602
br i1 %3603, label %3604, label %3641
3604: ; preds = %3599
store i64 0, i64* @contrast.ilon
br label %3605
3605: ; preds = %3634, %3604
%3606 = load i64, i64* @contrast.ilon
%3607 = load i32, i32* %3
%3608 = sext i32 %3607 to i64
%3609 = icmp slt i64 %3606, %3608
br i1 %3609, label %3610, label %3637
3610: ; preds = %3605
%3611 = load double**, double*** @contrast.r
%3612 = load i64, i64* @contrast.ilat
%3613 = getelementptr inbounds double*, double** %3611, i64 %3612
%3614 = load double*, double** %3613
%3615 = load i64, i64* @contrast.ilon
%3616 = getelementptr inbounds double, double* %3614, i64 %3615
%3617 = load double, double* %3616
%3618 = load double, double* @contrast.a
%3619 = load double**, double*** @contrast.r_new
%3620 = load i64, i64* @contrast.ilat
%3621 = getelementptr inbounds double*, double** %3619, i64 %3620
%3622 = load double*, double** %3621
%3623 = load i64, i64* @contrast.ilon
%3624 = getelementptr inbounds double, double* %3622, i64 %3623
%3625 = load double, double* %3624
%3626 = fneg double %3618
%3627 = call double @llvm.fmuladd.f64(double %3626, double %3625, double %3617)
%3628 = load double**, double*** @contrast.r_new
%3629 = load i64, i64* @contrast.ilat
%3630 = getelementptr inbounds double*, double** %3628, i64 %3629
%3631 = load double*, double** %3630
%3632 = load i64, i64* @contrast.ilon
%3633 = getelementptr inbounds double, double* %3631, i64 %3632
store double %3627, double* %3633
br label %3634
3634: ; preds = %3610
%3635 = load i64, i64* @contrast.ilon
%3636 = add nsw i64 %3635, 1
store i64 %3636, i64* @contrast.ilon
br label %3605
3637: ; preds = %3605
br label %3638
3638: ; preds = %3637
%3639 = load i64, i64* @contrast.ilat
%3640 = add nsw i64 %3639, 1
store i64 %3640, i64* @contrast.ilat
br label %3599
3641: ; preds = %3599
store i64 0, i64* @contrast.ilat
br label %3642
3642: ; preds = %3679, %3641
%3643 = load i64, i64* @contrast.ilat
%3644 = load i32, i32* %2
%3645 = sext i32 %3644 to i64
%3646 = icmp slt i64 %3643, %3645
br i1 %3646, label %3647, label %3682
3647: ; preds = %3642
store i64 0, i64* @contrast.ilon
br label %3648
3648: ; preds = %3675, %3647
%3649 = load i64, i64* @contrast.ilon
%3650 = load i32, i32* %3
%3651 = sext i32 %3650 to i64
%3652 = icmp slt i64 %3649, %3651
br i1 %3652, label %3653, label %3678
3653: ; preds = %3648
%3654 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 4)
%3655 = load i64, i64* @contrast.ilat
%3656 = getelementptr inbounds double*, double** %3654, i64 %3655
%3657 = load double*, double** %3656
%3658 = load i64, i64* @contrast.ilon
%3659 = getelementptr inbounds double, double* %3657, i64 %3658
%3660 = load double, double* %3659
%3661 = load double**, double*** @contrast.p_bar
%3662 = load i64, i64* @contrast.ilat
%3663 = getelementptr inbounds double*, double** %3661, i64 %3662
%3664 = load double*, double** %3663
%3665 = load i64, i64* @contrast.ilon
%3666 = getelementptr inbounds double, double* %3664, i64 %3665
%3667 = load double, double* %3666
%3668 = fmul double %3660, %3667
%3669 = load double**, double*** @contrast.r_bar_new
%3670 = load i64, i64* @contrast.ilat
%3671 = getelementptr inbounds double*, double** %3669, i64 %3670
%3672 = load double*, double** %3671
%3673 = load i64, i64* @contrast.ilon
%3674 = getelementptr inbounds double, double* %3672, i64 %3673
store double %3668, double* %3674
br label %3675
3675: ; preds = %3653
%3676 = load i64, i64* @contrast.ilon
%3677 = add nsw i64 %3676, 1
store i64 %3677, i64* @contrast.ilon
br label %3648
3678: ; preds = %3648
br label %3679
3679: ; preds = %3678
%3680 = load i64, i64* @contrast.ilat
%3681 = add nsw i64 %3680, 1
store i64 %3681, i64* @contrast.ilat
br label %3642
3682: ; preds = %3642
store i64 1, i64* @contrast.ilat
br label %3683
3683: ; preds = %3752, %3682
%3684 = load i64, i64* @contrast.ilat
%3685 = load i32, i32* %2
%3686 = sext i32 %3685 to i64
%3687 = icmp slt i64 %3684, %3686
br i1 %3687, label %3688, label %3755
3688: ; preds = %3683
store i64 1, i64* @contrast.ilon
br label %3689
3689: ; preds = %3721, %3688
%3690 = load i64, i64* @contrast.ilon
%3691 = load i32, i32* %3
%3692 = sext i32 %3691 to i64
%3693 = icmp slt i64 %3690, %3692
br i1 %3693, label %3694, label %3724
3694: ; preds = %3689
%3695 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 8)
%3696 = load i64, i64* @contrast.ilat
%3697 = sub nsw i64 %3696, 1
%3698 = getelementptr inbounds double*, double** %3695, i64 %3697
%3699 = load double*, double** %3698
%3700 = load i64, i64* @contrast.ilon
%3701 = sub nsw i64 %3700, 1
%3702 = getelementptr inbounds double, double* %3699, i64 %3701
%3703 = load double, double* %3702
%3704 = load double**, double*** @contrast.p_bar
%3705 = load i64, i64* @contrast.ilat
%3706 = sub nsw i64 %3705, 1
%3707 = getelementptr inbounds double*, double** %3704, i64 %3706
%3708 = load double*, double** %3707
%3709 = load i64, i64* @contrast.ilon
%3710 = sub nsw i64 %3709, 1
%3711 = getelementptr inbounds double, double* %3708, i64 %3710
%3712 = load double, double* %3711
%3713 = load double**, double*** @contrast.r_bar_new
%3714 = load i64, i64* @contrast.ilat
%3715 = getelementptr inbounds double*, double** %3713, i64 %3714
%3716 = load double*, double** %3715
%3717 = load i64, i64* @contrast.ilon
%3718 = getelementptr inbounds double, double* %3716, i64 %3717
%3719 = load double, double* %3718
%3720 = call double @llvm.fmuladd.f64(double %3703, double %3712, double %3719)
store double %3720, double* %3718
br label %3721
3721: ; preds = %3694
%3722 = load i64, i64* @contrast.ilon
%3723 = add nsw i64 %3722, 1
store i64 %3723, i64* @contrast.ilon
br label %3689
3724: ; preds = %3689
%3725 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 8)
%3726 = load i64, i64* @contrast.ilat
%3727 = sub nsw i64 %3726, 1
%3728 = getelementptr inbounds double*, double** %3725, i64 %3727
%3729 = load double*, double** %3728
%3730 = load i32, i32* %3
%3731 = sub nsw i32 %3730, 1
%3732 = sext i32 %3731 to i64
%3733 = getelementptr inbounds double, double* %3729, i64 %3732
%3734 = load double, double* %3733
%3735 = load double**, double*** @contrast.p_bar
%3736 = load i64, i64* @contrast.ilat
%3737 = sub nsw i64 %3736, 1
%3738 = getelementptr inbounds double*, double** %3735, i64 %3737
%3739 = load double*, double** %3738
%3740 = load i32, i32* %3
%3741 = sub nsw i32 %3740, 1
%3742 = sext i32 %3741 to i64
%3743 = getelementptr inbounds double, double* %3739, i64 %3742
%3744 = load double, double* %3743
%3745 = load double**, double*** @contrast.r_bar_new
%3746 = load i64, i64* @contrast.ilat
%3747 = getelementptr inbounds double*, double** %3745, i64 %3746
%3748 = load double*, double** %3747
%3749 = getelementptr inbounds double, double* %3748, i64 0
%3750 = load double, double* %3749
%3751 = call double @llvm.fmuladd.f64(double %3734, double %3744, double %3750)
store double %3751, double* %3749
br label %3752
3752: ; preds = %3724
%3753 = load i64, i64* @contrast.ilat
%3754 = add nsw i64 %3753, 1
store i64 %3754, i64* @contrast.ilat
br label %3683
3755: ; preds = %3683
store i64 1, i64* @contrast.ilat
br label %3756
3756: ; preds = %3796, %3755
%3757 = load i64, i64* @contrast.ilat
%3758 = load i32, i32* %2
%3759 = sext i32 %3758 to i64
%3760 = icmp slt i64 %3757, %3759
br i1 %3760, label %3761, label %3799
3761: ; preds = %3756
store i64 0, i64* @contrast.ilon
br label %3762
3762: ; preds = %3792, %3761
%3763 = load i64, i64* @contrast.ilon
%3764 = load i32, i32* %3
%3765 = sext i32 %3764 to i64
%3766 = icmp slt i64 %3763, %3765
br i1 %3766, label %3767, label %3795
3767: ; preds = %3762
%3768 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 7)
%3769 = load i64, i64* @contrast.ilat
%3770 = sub nsw i64 %3769, 1
%3771 = getelementptr inbounds double*, double** %3768, i64 %3770
%3772 = load double*, double** %3771
%3773 = load i64, i64* @contrast.ilon
%3774 = getelementptr inbounds double, double* %3772, i64 %3773
%3775 = load double, double* %3774
%3776 = load double**, double*** @contrast.p_bar
%3777 = load i64, i64* @contrast.ilat
%3778 = sub nsw i64 %3777, 1
%3779 = getelementptr inbounds double*, double** %3776, i64 %3778
%3780 = load double*, double** %3779
%3781 = load i64, i64* @contrast.ilon
%3782 = getelementptr inbounds double, double* %3780, i64 %3781
%3783 = load double, double* %3782
%3784 = load double**, double*** @contrast.r_bar_new
%3785 = load i64, i64* @contrast.ilat
%3786 = getelementptr inbounds double*, double** %3784, i64 %3785
%3787 = load double*, double** %3786
%3788 = load i64, i64* @contrast.ilon
%3789 = getelementptr inbounds double, double* %3787, i64 %3788
%3790 = load double, double* %3789
%3791 = call double @llvm.fmuladd.f64(double %3775, double %3783, double %3790)
store double %3791, double* %3789
br label %3792
3792: ; preds = %3767
%3793 = load i64, i64* @contrast.ilon
%3794 = add nsw i64 %3793, 1
store i64 %3794, i64* @contrast.ilon
br label %3762
3795: ; preds = %3762
br label %3796
3796: ; preds = %3795
%3797 = load i64, i64* @contrast.ilat
%3798 = add nsw i64 %3797, 1
store i64 %3798, i64* @contrast.ilat
br label %3756
3799: ; preds = %3756
store i64 1, i64* @contrast.ilat
br label %3800
3800: ; preds = %3867, %3799
%3801 = load i64, i64* @contrast.ilat
%3802 = load i32, i32* %2
%3803 = sext i32 %3802 to i64
%3804 = icmp slt i64 %3801, %3803
br i1 %3804, label %3805, label %3870
3805: ; preds = %3800
store i64 0, i64* @contrast.ilon
br label %3806
3806: ; preds = %3839, %3805
%3807 = load i64, i64* @contrast.ilon
%3808 = load i32, i32* %3
%3809 = sub nsw i32 %3808, 1
%3810 = sext i32 %3809 to i64
%3811 = icmp slt i64 %3807, %3810
br i1 %3811, label %3812, label %3842
3812: ; preds = %3806
%3813 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 6)
%3814 = load i64, i64* @contrast.ilat
%3815 = sub nsw i64 %3814, 1
%3816 = getelementptr inbounds double*, double** %3813, i64 %3815
%3817 = load double*, double** %3816
%3818 = load i64, i64* @contrast.ilon
%3819 = add nsw i64 %3818, 1
%3820 = getelementptr inbounds double, double* %3817, i64 %3819
%3821 = load double, double* %3820
%3822 = load double**, double*** @contrast.p_bar
%3823 = load i64, i64* @contrast.ilat
%3824 = sub nsw i64 %3823, 1
%3825 = getelementptr inbounds double*, double** %3822, i64 %3824
%3826 = load double*, double** %3825
%3827 = load i64, i64* @contrast.ilon
%3828 = add nsw i64 %3827, 1
%3829 = getelementptr inbounds double, double* %3826, i64 %3828
%3830 = load double, double* %3829
%3831 = load double**, double*** @contrast.r_bar_new
%3832 = load i64, i64* @contrast.ilat
%3833 = getelementptr inbounds double*, double** %3831, i64 %3832
%3834 = load double*, double** %3833
%3835 = load i64, i64* @contrast.ilon
%3836 = getelementptr inbounds double, double* %3834, i64 %3835
%3837 = load double, double* %3836
%3838 = call double @llvm.fmuladd.f64(double %3821, double %3830, double %3837)
store double %3838, double* %3836
br label %3839
3839: ; preds = %3812
%3840 = load i64, i64* @contrast.ilon
%3841 = add nsw i64 %3840, 1
store i64 %3841, i64* @contrast.ilon
br label %3806
3842: ; preds = %3806
%3843 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 6)
%3844 = load i64, i64* @contrast.ilat
%3845 = sub nsw i64 %3844, 1
%3846 = getelementptr inbounds double*, double** %3843, i64 %3845
%3847 = load double*, double** %3846
%3848 = getelementptr inbounds double, double* %3847, i64 0
%3849 = load double, double* %3848
%3850 = load double**, double*** @contrast.p_bar
%3851 = load i64, i64* @contrast.ilat
%3852 = sub nsw i64 %3851, 1
%3853 = getelementptr inbounds double*, double** %3850, i64 %3852
%3854 = load double*, double** %3853
%3855 = getelementptr inbounds double, double* %3854, i64 0
%3856 = load double, double* %3855
%3857 = load double**, double*** @contrast.r_bar_new
%3858 = load i64, i64* @contrast.ilat
%3859 = getelementptr inbounds double*, double** %3857, i64 %3858
%3860 = load double*, double** %3859
%3861 = load i32, i32* %3
%3862 = sub nsw i32 %3861, 1
%3863 = sext i32 %3862 to i64
%3864 = getelementptr inbounds double, double* %3860, i64 %3863
%3865 = load double, double* %3864
%3866 = call double @llvm.fmuladd.f64(double %3849, double %3856, double %3865)
store double %3866, double* %3864
br label %3867
3867: ; preds = %3842
%3868 = load i64, i64* @contrast.ilat
%3869 = add nsw i64 %3868, 1
store i64 %3869, i64* @contrast.ilat
br label %3800
3870: ; preds = %3800
store i64 0, i64* @contrast.ilat
br label %3871
3871: ; preds = %3936, %3870
%3872 = load i64, i64* @contrast.ilat
%3873 = load i32, i32* %2
%3874 = sext i32 %3873 to i64
%3875 = icmp slt i64 %3872, %3874
br i1 %3875, label %3876, label %3939
3876: ; preds = %3871
store i64 1, i64* @contrast.ilon
br label %3877
3877: ; preds = %3907, %3876
%3878 = load i64, i64* @contrast.ilon
%3879 = load i32, i32* %3
%3880 = sext i32 %3879 to i64
%3881 = icmp slt i64 %3878, %3880
br i1 %3881, label %3882, label %3910
3882: ; preds = %3877
%3883 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 5)
%3884 = load i64, i64* @contrast.ilat
%3885 = getelementptr inbounds double*, double** %3883, i64 %3884
%3886 = load double*, double** %3885
%3887 = load i64, i64* @contrast.ilon
%3888 = sub nsw i64 %3887, 1
%3889 = getelementptr inbounds double, double* %3886, i64 %3888
%3890 = load double, double* %3889
%3891 = load double**, double*** @contrast.p_bar
%3892 = load i64, i64* @contrast.ilat
%3893 = getelementptr inbounds double*, double** %3891, i64 %3892
%3894 = load double*, double** %3893
%3895 = load i64, i64* @contrast.ilon
%3896 = sub nsw i64 %3895, 1
%3897 = getelementptr inbounds double, double* %3894, i64 %3896
%3898 = load double, double* %3897
%3899 = load double**, double*** @contrast.r_bar_new
%3900 = load i64, i64* @contrast.ilat
%3901 = getelementptr inbounds double*, double** %3899, i64 %3900
%3902 = load double*, double** %3901
%3903 = load i64, i64* @contrast.ilon
%3904 = getelementptr inbounds double, double* %3902, i64 %3903
%3905 = load double, double* %3904
%3906 = call double @llvm.fmuladd.f64(double %3890, double %3898, double %3905)
store double %3906, double* %3904
br label %3907
3907: ; preds = %3882
%3908 = load i64, i64* @contrast.ilon
%3909 = add nsw i64 %3908, 1
store i64 %3909, i64* @contrast.ilon
br label %3877
3910: ; preds = %3877
%3911 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 5)
%3912 = load i64, i64* @contrast.ilat
%3913 = getelementptr inbounds double*, double** %3911, i64 %3912
%3914 = load double*, double** %3913
%3915 = load i32, i32* %3
%3916 = sub nsw i32 %3915, 1
%3917 = sext i32 %3916 to i64
%3918 = getelementptr inbounds double, double* %3914, i64 %3917
%3919 = load double, double* %3918
%3920 = load double**, double*** @contrast.p_bar
%3921 = load i64, i64* @contrast.ilat
%3922 = getelementptr inbounds double*, double** %3920, i64 %3921
%3923 = load double*, double** %3922
%3924 = load i32, i32* %3
%3925 = sub nsw i32 %3924, 1
%3926 = sext i32 %3925 to i64
%3927 = getelementptr inbounds double, double* %3923, i64 %3926
%3928 = load double, double* %3927
%3929 = load double**, double*** @contrast.r_bar_new
%3930 = load i64, i64* @contrast.ilat
%3931 = getelementptr inbounds double*, double** %3929, i64 %3930
%3932 = load double*, double** %3931
%3933 = getelementptr inbounds double, double* %3932, i64 0
%3934 = load double, double* %3933
%3935 = call double @llvm.fmuladd.f64(double %3919, double %3928, double %3934)
store double %3935, double* %3933
br label %3936
3936: ; preds = %3910
%3937 = load i64, i64* @contrast.ilat
%3938 = add nsw i64 %3937, 1
store i64 %3938, i64* @contrast.ilat
br label %3871
3939: ; preds = %3871
store i64 0, i64* @contrast.ilat
br label %3940
3940: ; preds = %4003, %3939
%3941 = load i64, i64* @contrast.ilat
%3942 = load i32, i32* %2
%3943 = sext i32 %3942 to i64
%3944 = icmp slt i64 %3941, %3943
br i1 %3944, label %3945, label %4006
3945: ; preds = %3940
store i64 0, i64* @contrast.ilon
br label %3946
3946: ; preds = %3977, %3945
%3947 = load i64, i64* @contrast.ilon
%3948 = load i32, i32* %3
%3949 = sub nsw i32 %3948, 1
%3950 = sext i32 %3949 to i64
%3951 = icmp slt i64 %3947, %3950
br i1 %3951, label %3952, label %3980
3952: ; preds = %3946
%3953 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 3)
%3954 = load i64, i64* @contrast.ilat
%3955 = getelementptr inbounds double*, double** %3953, i64 %3954
%3956 = load double*, double** %3955
%3957 = load i64, i64* @contrast.ilon
%3958 = add nsw i64 %3957, 1
%3959 = getelementptr inbounds double, double* %3956, i64 %3958
%3960 = load double, double* %3959
%3961 = load double**, double*** @contrast.p_bar
%3962 = load i64, i64* @contrast.ilat
%3963 = getelementptr inbounds double*, double** %3961, i64 %3962
%3964 = load double*, double** %3963
%3965 = load i64, i64* @contrast.ilon
%3966 = add nsw i64 %3965, 1
%3967 = getelementptr inbounds double, double* %3964, i64 %3966
%3968 = load double, double* %3967
%3969 = load double**, double*** @contrast.r_bar_new
%3970 = load i64, i64* @contrast.ilat
%3971 = getelementptr inbounds double*, double** %3969, i64 %3970
%3972 = load double*, double** %3971
%3973 = load i64, i64* @contrast.ilon
%3974 = getelementptr inbounds double, double* %3972, i64 %3973
%3975 = load double, double* %3974
%3976 = call double @llvm.fmuladd.f64(double %3960, double %3968, double %3975)
store double %3976, double* %3974
br label %3977
3977: ; preds = %3952
%3978 = load i64, i64* @contrast.ilon
%3979 = add nsw i64 %3978, 1
store i64 %3979, i64* @contrast.ilon
br label %3946
3980: ; preds = %3946
%3981 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 3)
%3982 = load i64, i64* @contrast.ilat
%3983 = getelementptr inbounds double*, double** %3981, i64 %3982
%3984 = load double*, double** %3983
%3985 = getelementptr inbounds double, double* %3984, i64 0
%3986 = load double, double* %3985
%3987 = load double**, double*** @contrast.p_bar
%3988 = load i64, i64* @contrast.ilat
%3989 = getelementptr inbounds double*, double** %3987, i64 %3988
%3990 = load double*, double** %3989
%3991 = getelementptr inbounds double, double* %3990, i64 0
%3992 = load double, double* %3991
%3993 = load double**, double*** @contrast.r_bar_new
%3994 = load i64, i64* @contrast.ilat
%3995 = getelementptr inbounds double*, double** %3993, i64 %3994
%3996 = load double*, double** %3995
%3997 = load i32, i32* %3
%3998 = sub nsw i32 %3997, 1
%3999 = sext i32 %3998 to i64
%4000 = getelementptr inbounds double, double* %3996, i64 %3999
%4001 = load double, double* %4000
%4002 = call double @llvm.fmuladd.f64(double %3986, double %3992, double %4001)
store double %4002, double* %4000
br label %4003
4003: ; preds = %3980
%4004 = load i64, i64* @contrast.ilat
%4005 = add nsw i64 %4004, 1
store i64 %4005, i64* @contrast.ilat
br label %3940
4006: ; preds = %3940
store i64 0, i64* @contrast.ilat
br label %4007
4007: ; preds = %4077, %4006
%4008 = load i64, i64* @contrast.ilat
%4009 = load i32, i32* %2
%4010 = sub nsw i32 %4009, 1
%4011 = sext i32 %4010 to i64
%4012 = icmp slt i64 %4008, %4011
br i1 %4012, label %4013, label %4080
4013: ; preds = %4007
store i64 1, i64* @contrast.ilon
br label %4014
4014: ; preds = %4046, %4013
%4015 = load i64, i64* @contrast.ilon
%4016 = load i32, i32* %3
%4017 = sext i32 %4016 to i64
%4018 = icmp slt i64 %4015, %4017
br i1 %4018, label %4019, label %4049
4019: ; preds = %4014
%4020 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 2)
%4021 = load i64, i64* @contrast.ilat
%4022 = add nsw i64 %4021, 1
%4023 = getelementptr inbounds double*, double** %4020, i64 %4022
%4024 = load double*, double** %4023
%4025 = load i64, i64* @contrast.ilon
%4026 = sub nsw i64 %4025, 1
%4027 = getelementptr inbounds double, double* %4024, i64 %4026
%4028 = load double, double* %4027
%4029 = load double**, double*** @contrast.p_bar
%4030 = load i64, i64* @contrast.ilat
%4031 = add nsw i64 %4030, 1
%4032 = getelementptr inbounds double*, double** %4029, i64 %4031
%4033 = load double*, double** %4032
%4034 = load i64, i64* @contrast.ilon
%4035 = sub nsw i64 %4034, 1
%4036 = getelementptr inbounds double, double* %4033, i64 %4035
%4037 = load double, double* %4036
%4038 = load double**, double*** @contrast.r_bar_new
%4039 = load i64, i64* @contrast.ilat
%4040 = getelementptr inbounds double*, double** %4038, i64 %4039
%4041 = load double*, double** %4040
%4042 = load i64, i64* @contrast.ilon
%4043 = getelementptr inbounds double, double* %4041, i64 %4042
%4044 = load double, double* %4043
%4045 = call double @llvm.fmuladd.f64(double %4028, double %4037, double %4044)
store double %4045, double* %4043
br label %4046
4046: ; preds = %4019
%4047 = load i64, i64* @contrast.ilon
%4048 = add nsw i64 %4047, 1
store i64 %4048, i64* @contrast.ilon
br label %4014
4049: ; preds = %4014
%4050 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 2)
%4051 = load i64, i64* @contrast.ilat
%4052 = add nsw i64 %4051, 1
%4053 = getelementptr inbounds double*, double** %4050, i64 %4052
%4054 = load double*, double** %4053
%4055 = load i32, i32* %3
%4056 = sub nsw i32 %4055, 1
%4057 = sext i32 %4056 to i64
%4058 = getelementptr inbounds double, double* %4054, i64 %4057
%4059 = load double, double* %4058
%4060 = load double**, double*** @contrast.p_bar
%4061 = load i64, i64* @contrast.ilat
%4062 = add nsw i64 %4061, 1
%4063 = getelementptr inbounds double*, double** %4060, i64 %4062
%4064 = load double*, double** %4063
%4065 = load i32, i32* %3
%4066 = sub nsw i32 %4065, 1
%4067 = sext i32 %4066 to i64
%4068 = getelementptr inbounds double, double* %4064, i64 %4067
%4069 = load double, double* %4068
%4070 = load double**, double*** @contrast.r_bar_new
%4071 = load i64, i64* @contrast.ilat
%4072 = getelementptr inbounds double*, double** %4070, i64 %4071
%4073 = load double*, double** %4072
%4074 = getelementptr inbounds double, double* %4073, i64 0
%4075 = load double, double* %4074
%4076 = call double @llvm.fmuladd.f64(double %4059, double %4069, double %4075)
store double %4076, double* %4074
br label %4077
4077: ; preds = %4049
%4078 = load i64, i64* @contrast.ilat
%4079 = add nsw i64 %4078, 1
store i64 %4079, i64* @contrast.ilat
br label %4007
4080: ; preds = %4007
store i64 0, i64* @contrast.ilat
br label %4081
4081: ; preds = %4122, %4080
%4082 = load i64, i64* @contrast.ilat
%4083 = load i32, i32* %2
%4084 = sub nsw i32 %4083, 1
%4085 = sext i32 %4084 to i64
%4086 = icmp slt i64 %4082, %4085
br i1 %4086, label %4087, label %4125
4087: ; preds = %4081
store i64 0, i64* @contrast.ilon
br label %4088
4088: ; preds = %4118, %4087
%4089 = load i64, i64* @contrast.ilon
%4090 = load i32, i32* %3
%4091 = sext i32 %4090 to i64
%4092 = icmp slt i64 %4089, %4091
br i1 %4092, label %4093, label %4121
4093: ; preds = %4088
%4094 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 1)
%4095 = load i64, i64* @contrast.ilat
%4096 = add nsw i64 %4095, 1
%4097 = getelementptr inbounds double*, double** %4094, i64 %4096
%4098 = load double*, double** %4097
%4099 = load i64, i64* @contrast.ilon
%4100 = getelementptr inbounds double, double* %4098, i64 %4099
%4101 = load double, double* %4100
%4102 = load double**, double*** @contrast.p_bar
%4103 = load i64, i64* @contrast.ilat
%4104 = add nsw i64 %4103, 1
%4105 = getelementptr inbounds double*, double** %4102, i64 %4104
%4106 = load double*, double** %4105
%4107 = load i64, i64* @contrast.ilon
%4108 = getelementptr inbounds double, double* %4106, i64 %4107
%4109 = load double, double* %4108
%4110 = load double**, double*** @contrast.r_bar_new
%4111 = load i64, i64* @contrast.ilat
%4112 = getelementptr inbounds double*, double** %4110, i64 %4111
%4113 = load double*, double** %4112
%4114 = load i64, i64* @contrast.ilon
%4115 = getelementptr inbounds double, double* %4113, i64 %4114
%4116 = load double, double* %4115
%4117 = call double @llvm.fmuladd.f64(double %4101, double %4109, double %4116)
store double %4117, double* %4115
br label %4118
4118: ; preds = %4093
%4119 = load i64, i64* @contrast.ilon
%4120 = add nsw i64 %4119, 1
store i64 %4120, i64* @contrast.ilon
br label %4088
4121: ; preds = %4088
br label %4122
4122: ; preds = %4121
%4123 = load i64, i64* @contrast.ilat
%4124 = add nsw i64 %4123, 1
store i64 %4124, i64* @contrast.ilat
br label %4081
4125: ; preds = %4081
store i64 0, i64* @contrast.ilat
br label %4126
4126: ; preds = %4194, %4125
%4127 = load i64, i64* @contrast.ilat
%4128 = load i32, i32* %2
%4129 = sub nsw i32 %4128, 1
%4130 = sext i32 %4129 to i64
%4131 = icmp slt i64 %4127, %4130
br i1 %4131, label %4132, label %4197
4132: ; preds = %4126
store i64 0, i64* @contrast.ilon
br label %4133
4133: ; preds = %4166, %4132
%4134 = load i64, i64* @contrast.ilon
%4135 = load i32, i32* %3
%4136 = sub nsw i32 %4135, 1
%4137 = sext i32 %4136 to i64
%4138 = icmp slt i64 %4134, %4137
br i1 %4138, label %4139, label %4169
4139: ; preds = %4133
%4140 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 0)
%4141 = load i64, i64* @contrast.ilat
%4142 = add nsw i64 %4141, 1
%4143 = getelementptr inbounds double*, double** %4140, i64 %4142
%4144 = load double*, double** %4143
%4145 = load i64, i64* @contrast.ilon
%4146 = add nsw i64 %4145, 1
%4147 = getelementptr inbounds double, double* %4144, i64 %4146
%4148 = load double, double* %4147
%4149 = load double**, double*** @contrast.p_bar
%4150 = load i64, i64* @contrast.ilat
%4151 = add nsw i64 %4150, 1
%4152 = getelementptr inbounds double*, double** %4149, i64 %4151
%4153 = load double*, double** %4152
%4154 = load i64, i64* @contrast.ilon
%4155 = add nsw i64 %4154, 1
%4156 = getelementptr inbounds double, double* %4153, i64 %4155
%4157 = load double, double* %4156
%4158 = load double**, double*** @contrast.r_bar_new
%4159 = load i64, i64* @contrast.ilat
%4160 = getelementptr inbounds double*, double** %4158, i64 %4159
%4161 = load double*, double** %4160
%4162 = load i64, i64* @contrast.ilon
%4163 = getelementptr inbounds double, double* %4161, i64 %4162
%4164 = load double, double* %4163
%4165 = call double @llvm.fmuladd.f64(double %4148, double %4157, double %4164)
store double %4165, double* %4163
br label %4166
4166: ; preds = %4139
%4167 = load i64, i64* @contrast.ilon
%4168 = add nsw i64 %4167, 1
store i64 %4168, i64* @contrast.ilon
br label %4133
4169: ; preds = %4133
%4170 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 0)
%4171 = load i64, i64* @contrast.ilat
%4172 = add nsw i64 %4171, 1
%4173 = getelementptr inbounds double*, double** %4170, i64 %4172
%4174 = load double*, double** %4173
%4175 = getelementptr inbounds double, double* %4174, i64 0
%4176 = load double, double* %4175
%4177 = load double**, double*** @contrast.p_bar
%4178 = load i64, i64* @contrast.ilat
%4179 = add nsw i64 %4178, 1
%4180 = getelementptr inbounds double*, double** %4177, i64 %4179
%4181 = load double*, double** %4180
%4182 = getelementptr inbounds double, double* %4181, i64 0
%4183 = load double, double* %4182
%4184 = load double**, double*** @contrast.r_bar_new
%4185 = load i64, i64* @contrast.ilat
%4186 = getelementptr inbounds double*, double** %4184, i64 %4185
%4187 = load double*, double** %4186
%4188 = load i32, i32* %3
%4189 = sub nsw i32 %4188, 1
%4190 = sext i32 %4189 to i64
%4191 = getelementptr inbounds double, double* %4187, i64 %4190
%4192 = load double, double* %4191
%4193 = call double @llvm.fmuladd.f64(double %4176, double %4183, double %4192)
store double %4193, double* %4191
br label %4194
4194: ; preds = %4169
%4195 = load i64, i64* @contrast.ilat
%4196 = add nsw i64 %4195, 1
store i64 %4196, i64* @contrast.ilat
br label %4126
4197: ; preds = %4126
store i64 0, i64* @contrast.ilat
br label %4198
4198: ; preds = %4237, %4197
%4199 = load i64, i64* @contrast.ilat
%4200 = load i32, i32* %2
%4201 = sext i32 %4200 to i64
%4202 = icmp slt i64 %4199, %4201
br i1 %4202, label %4203, label %4240
4203: ; preds = %4198
store i64 0, i64* @contrast.ilon
br label %4204
4204: ; preds = %4233, %4203
%4205 = load i64, i64* @contrast.ilon
%4206 = load i32, i32* %3
%4207 = sext i32 %4206 to i64
%4208 = icmp slt i64 %4205, %4207
br i1 %4208, label %4209, label %4236
4209: ; preds = %4204
%4210 = load double**, double*** @contrast.r_bar
%4211 = load i64, i64* @contrast.ilat
%4212 = getelementptr inbounds double*, double** %4210, i64 %4211
%4213 = load double*, double** %4212
%4214 = load i64, i64* @contrast.ilon
%4215 = getelementptr inbounds double, double* %4213, i64 %4214
%4216 = load double, double* %4215
%4217 = load double, double* @contrast.a
%4218 = load double**, double*** @contrast.r_bar_new
%4219 = load i64, i64* @contrast.ilat
%4220 = getelementptr inbounds double*, double** %4218, i64 %4219
%4221 = load double*, double** %4220
%4222 = load i64, i64* @contrast.ilon
%4223 = getelementptr inbounds double, double* %4221, i64 %4222
%4224 = load double, double* %4223
%4225 = fneg double %4217
%4226 = call double @llvm.fmuladd.f64(double %4225, double %4224, double %4216)
%4227 = load double**, double*** @contrast.r_bar_new
%4228 = load i64, i64* @contrast.ilat
%4229 = getelementptr inbounds double*, double** %4227, i64 %4228
%4230 = load double*, double** %4229
%4231 = load i64, i64* @contrast.ilon
%4232 = getelementptr inbounds double, double* %4230, i64 %4231
store double %4226, double* %4232
br label %4233
4233: ; preds = %4209
%4234 = load i64, i64* @contrast.ilon
%4235 = add nsw i64 %4234, 1
store i64 %4235, i64* @contrast.ilon
br label %4204
4236: ; preds = %4204
br label %4237
4237: ; preds = %4236
%4238 = load i64, i64* @contrast.ilat
%4239 = add nsw i64 %4238, 1
store i64 %4239, i64* @contrast.ilat
br label %4198
4240: ; preds = %4198
%4241 = load double, double* @contrast.nom
store double %4241, double* @contrast.denom
store double 0.000000e+00, double* @contrast.nom
store i64 0, i64* @contrast.ilat
br label %4242
4242: ; preds = %4274, %4240
%4243 = load i64, i64* @contrast.ilat
%4244 = load i32, i32* %2
%4245 = sext i32 %4244 to i64
%4246 = icmp slt i64 %4243, %4245
br i1 %4246, label %4247, label %4277
4247: ; preds = %4242
store i64 0, i64* @contrast.ilon
br label %4248
4248: ; preds = %4270, %4247
%4249 = load i64, i64* @contrast.ilon
%4250 = load i32, i32* %3
%4251 = sext i32 %4250 to i64
%4252 = icmp slt i64 %4249, %4251
br i1 %4252, label %4253, label %4273
4253: ; preds = %4248
%4254 = load double**, double*** @contrast.r_bar_new
%4255 = load i64, i64* @contrast.ilat
%4256 = getelementptr inbounds double*, double** %4254, i64 %4255
%4257 = load double*, double** %4256
%4258 = load i64, i64* @contrast.ilon
%4259 = getelementptr inbounds double, double* %4257, i64 %4258
%4260 = load double, double* %4259
%4261 = load double**, double*** @contrast.r_new
%4262 = load i64, i64* @contrast.ilat
%4263 = getelementptr inbounds double*, double** %4261, i64 %4262
%4264 = load double*, double** %4263
%4265 = load i64, i64* @contrast.ilon
%4266 = getelementptr inbounds double, double* %4264, i64 %4265
%4267 = load double, double* %4266
%4268 = load double, double* @contrast.nom
%4269 = call double @llvm.fmuladd.f64(double %4260, double %4267, double %4268)
store double %4269, double* @contrast.nom
br label %4270
4270: ; preds = %4253
%4271 = load i64, i64* @contrast.ilon
%4272 = add nsw i64 %4271, 1
store i64 %4272, i64* @contrast.ilon
br label %4248
4273: ; preds = %4248
br label %4274
4274: ; preds = %4273
%4275 = load i64, i64* @contrast.ilat
%4276 = add nsw i64 %4275, 1
store i64 %4276, i64* @contrast.ilat
br label %4242
4277: ; preds = %4242
%4278 = load double, double* @contrast.denom
%4279 = fcmp olt double %4278, 0.000000e+00
br i1 %4279, label %4284, label %4280
4280: ; preds = %4277
%4281 = load double, double* @contrast.denom
%4282 = fcmp olt double 0.000000e+00, %4281
br i1 %4282, label %4284, label %4283
4283: ; preds = %4280
br label %4466
4284: ; preds = %4280, %4277
%4285 = load double, double* @contrast.nom
%4286 = load double, double* @contrast.denom
%4287 = fdiv double %4285, %4286
store double %4287, double* @contrast.b
store i64 0, i64* @contrast.ilat
br label %4288
4288: ; preds = %4348, %4284
%4289 = load i64, i64* @contrast.ilat
%4290 = load i32, i32* %2
%4291 = sext i32 %4290 to i64
%4292 = icmp slt i64 %4289, %4291
br i1 %4292, label %4293, label %4351
4293: ; preds = %4288
store i64 0, i64* @contrast.ilon
br label %4294
4294: ; preds = %4344, %4293
%4295 = load i64, i64* @contrast.ilon
%4296 = load i32, i32* %3
%4297 = sext i32 %4296 to i64
%4298 = icmp slt i64 %4295, %4297
br i1 %4298, label %4299, label %4347
4299: ; preds = %4294
%4300 = load double**, double*** @contrast.r_new
%4301 = load i64, i64* @contrast.ilat
%4302 = getelementptr inbounds double*, double** %4300, i64 %4301
%4303 = load double*, double** %4302
%4304 = load i64, i64* @contrast.ilon
%4305 = getelementptr inbounds double, double* %4303, i64 %4304
%4306 = load double, double* %4305
%4307 = load double, double* @contrast.b
%4308 = load double**, double*** @contrast.p
%4309 = load i64, i64* @contrast.ilat
%4310 = getelementptr inbounds double*, double** %4308, i64 %4309
%4311 = load double*, double** %4310
%4312 = load i64, i64* @contrast.ilon
%4313 = getelementptr inbounds double, double* %4311, i64 %4312
%4314 = load double, double* %4313
%4315 = call double @llvm.fmuladd.f64(double %4307, double %4314, double %4306)
%4316 = load double**, double*** @contrast.p_new
%4317 = load i64, i64* @contrast.ilat
%4318 = getelementptr inbounds double*, double** %4316, i64 %4317
%4319 = load double*, double** %4318
%4320 = load i64, i64* @contrast.ilon
%4321 = getelementptr inbounds double, double* %4319, i64 %4320
store double %4315, double* %4321
%4322 = load double**, double*** @contrast.r_bar_new
%4323 = load i64, i64* @contrast.ilat
%4324 = getelementptr inbounds double*, double** %4322, i64 %4323
%4325 = load double*, double** %4324
%4326 = load i64, i64* @contrast.ilon
%4327 = getelementptr inbounds double, double* %4325, i64 %4326
%4328 = load double, double* %4327
%4329 = load double, double* @contrast.b
%4330 = load double**, double*** @contrast.p_bar
%4331 = load i64, i64* @contrast.ilat
%4332 = getelementptr inbounds double*, double** %4330, i64 %4331
%4333 = load double*, double** %4332
%4334 = load i64, i64* @contrast.ilon
%4335 = getelementptr inbounds double, double* %4333, i64 %4334
%4336 = load double, double* %4335
%4337 = call double @llvm.fmuladd.f64(double %4329, double %4336, double %4328)
%4338 = load double**, double*** @contrast.p_bar_new
%4339 = load i64, i64* @contrast.ilat
%4340 = getelementptr inbounds double*, double** %4338, i64 %4339
%4341 = load double*, double** %4340
%4342 = load i64, i64* @contrast.ilon
%4343 = getelementptr inbounds double, double* %4341, i64 %4342
store double %4337, double* %4343
br label %4344
4344: ; preds = %4299
%4345 = load i64, i64* @contrast.ilon
%4346 = add nsw i64 %4345, 1
store i64 %4346, i64* @contrast.ilon
br label %4294
4347: ; preds = %4294
br label %4348
4348: ; preds = %4347
%4349 = load i64, i64* @contrast.ilat
%4350 = add nsw i64 %4349, 1
store i64 %4350, i64* @contrast.ilat
br label %4288
4351: ; preds = %4288
store i64 0, i64* @contrast.ilat
br label %4352
4352: ; preds = %4447, %4351
%4353 = load i64, i64* @contrast.ilat
%4354 = load i32, i32* %2
%4355 = sext i32 %4354 to i64
%4356 = icmp slt i64 %4353, %4355
br i1 %4356, label %4357, label %4450
4357: ; preds = %4352
store i64 0, i64* @contrast.ilon
br label %4358
4358: ; preds = %4443, %4357
%4359 = load i64, i64* @contrast.ilon
%4360 = load i32, i32* %3
%4361 = sext i32 %4360 to i64
%4362 = icmp slt i64 %4359, %4361
br i1 %4362, label %4363, label %4446
4363: ; preds = %4358
%4364 = load double**, double*** @contrast.xout
%4365 = load i64, i64* @contrast.ilat
%4366 = getelementptr inbounds double*, double** %4364, i64 %4365
%4367 = load double*, double** %4366
%4368 = load i64, i64* @contrast.ilon
%4369 = getelementptr inbounds double, double* %4367, i64 %4368
%4370 = load double, double* %4369
%4371 = load double**, double*** @contrast.xout
%4372 = load i64, i64* @contrast.ilat
%4373 = getelementptr inbounds double*, double** %4371, i64 %4372
%4374 = load double*, double** %4373
%4375 = load i64, i64* @contrast.ilon
%4376 = getelementptr inbounds double, double* %4374, i64 %4375
%4377 = load double, double* %4376
%4378 = fcmp une double %4370, %4377
br i1 %4378, label %4383, label %4379
4379: ; preds = %4363
%4380 = load double, double* %7
%4381 = load double, double* %7
%4382 = fcmp une double %4380, %4381
br i1 %4382, label %4383, label %4405
4383: ; preds = %4379, %4363
%4384 = load double**, double*** @contrast.xout
%4385 = load i64, i64* @contrast.ilat
%4386 = getelementptr inbounds double*, double** %4384, i64 %4385
%4387 = load double*, double** %4386
%4388 = load i64, i64* @contrast.ilon
%4389 = getelementptr inbounds double, double* %4387, i64 %4388
%4390 = load double, double* %4389
%4391 = load double**, double*** @contrast.xout
%4392 = load i64, i64* @contrast.ilat
%4393 = getelementptr inbounds double*, double** %4391, i64 %4392
%4394 = load double*, double** %4393
%4395 = load i64, i64* @contrast.ilon
%4396 = getelementptr inbounds double, double* %4394, i64 %4395
%4397 = load double, double* %4396
%4398 = fcmp une double %4390, %4397
br i1 %4398, label %4399, label %4404
4399: ; preds = %4383
%4400 = load double, double* %7
%4401 = load double, double* %7
%4402 = fcmp une double %4400, %4401
br i1 %4402, label %4403, label %4404
4403: ; preds = %4399
br i1 true, label %4442, label %4425
4404: ; preds = %4399, %4383
br i1 false, label %4442, label %4425
4405: ; preds = %4379
%4406 = load double**, double*** @contrast.xout
%4407 = load i64, i64* @contrast.ilat
%4408 = getelementptr inbounds double*, double** %4406, i64 %4407
%4409 = load double*, double** %4408
%4410 = load i64, i64* @contrast.ilon
%4411 = getelementptr inbounds double, double* %4409, i64 %4410
%4412 = load double, double* %4411
%4413 = load double, double* %7
%4414 = fcmp olt double %4412, %4413
br i1 %4414, label %4425, label %4415
4415: ; preds = %4405
%4416 = load double, double* %7
%4417 = load double**, double*** @contrast.xout
%4418 = load i64, i64* @contrast.ilat
%4419 = getelementptr inbounds double*, double** %4417, i64 %4418
%4420 = load double*, double** %4419
%4421 = load i64, i64* @contrast.ilon
%4422 = getelementptr inbounds double, double* %4420, i64 %4421
%4423 = load double, double* %4422
%4424 = fcmp olt double %4416, %4423
br i1 %4424, label %4425, label %4442
4425: ; preds = %4415, %4405, %4404, %4403
%4426 = load double, double* @contrast.a
%4427 = load double**, double*** @contrast.p
%4428 = load i64, i64* @contrast.ilat
%4429 = getelementptr inbounds double*, double** %4427, i64 %4428
%4430 = load double*, double** %4429
%4431 = load i64, i64* @contrast.ilon
%4432 = getelementptr inbounds double, double* %4430, i64 %4431
%4433 = load double, double* %4432
%4434 = load double**, double*** @contrast.xout
%4435 = load i64, i64* @contrast.ilat
%4436 = getelementptr inbounds double*, double** %4434, i64 %4435
%4437 = load double*, double** %4436
%4438 = load i64, i64* @contrast.ilon
%4439 = getelementptr inbounds double, double* %4437, i64 %4438
%4440 = load double, double* %4439
%4441 = call double @llvm.fmuladd.f64(double %4426, double %4433, double %4440)
store double %4441, double* %4439
br label %4442
4442: ; preds = %4425, %4415, %4404, %4403
br label %4443
4443: ; preds = %4442
%4444 = load i64, i64* @contrast.ilon
%4445 = add nsw i64 %4444, 1
store i64 %4445, i64* @contrast.ilon
br label %4358
4446: ; preds = %4358
br label %4447
4447: ; preds = %4446
%4448 = load i64, i64* @contrast.ilat
%4449 = add nsw i64 %4448, 1
store i64 %4449, i64* @contrast.ilat
br label %4352
4450: ; preds = %4352
%4451 = load double**, double*** @contrast.r_new
store double** %4451, double*** @contrast.swap
%4452 = load double**, double*** @contrast.r
store double** %4452, double*** @contrast.r_new
%4453 = load double**, double*** @contrast.swap
store double** %4453, double*** @contrast.r
%4454 = load double**, double*** @contrast.r_bar_new
store double** %4454, double*** @contrast.swap
%4455 = load double**, double*** @contrast.r_bar
store double** %4455, double*** @contrast.r_bar_new
%4456 = load double**, double*** @contrast.swap
store double** %4456, double*** @contrast.r_bar
%4457 = load double**, double*** @contrast.p_new
store double** %4457, double*** @contrast.swap
%4458 = load double**, double*** @contrast.p
store double** %4458, double*** @contrast.p_new
%4459 = load double**, double*** @contrast.swap
store double** %4459, double*** @contrast.p
%4460 = load double**, double*** @contrast.p_bar_new
store double** %4460, double*** @contrast.swap
%4461 = load double**, double*** @contrast.p_bar
store double** %4461, double*** @contrast.p_bar_new
%4462 = load double**, double*** @contrast.swap
store double** %4462, double*** @contrast.p_bar
br label %4463
4463: ; preds = %4450
%4464 = load i32, i32* @contrast.iter
%4465 = add nsw i32 %4464, 1
store i32 %4465, i32* @contrast.iter
br label %2935
4466: ; preds = %4283, %3594, %2971
%4467 = load float, float* @contrast.iter_sum
%4468 = fpext float %4467 to double
%4469 = load i32, i32* @contrast.iter
%4470 = sitofp i32 %4469 to double
%4471 = call double @llvm.fmuladd.f64(double %4468, double 9.000000e-01, double %4470)
%4472 = fptrunc double %4471 to float
store float %4472, float* @contrast.iter_sum
%4473 = load float, float* @contrast.iter_n
%4474 = fpext float %4473 to double
%4475 = call double @llvm.fmuladd.f64(double %4474, double 9.000000e-01, double 1.000000e+00)
%4476 = fptrunc double %4475 to float
store float %4476, float* @contrast.iter_n
%4477 = load double*, double** @contrast.xin_array
%4478 = call i32 (i8*, i8*, i32, double*, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double*, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2020, double* %4477)
%4479 = load double**, double*** @contrast.xin
%4480 = call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2021, double** %4479)
%4481 = load double**, double*** @contrast.xout
%4482 = call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2022, double** %4481)
store i32 0, i32* %5
br label %4483
4483: ; preds = %4492, %4466
%4484 = load i32, i32* %5
%4485 = icmp slt i32 %4484, 17
br i1 %4485, label %4486, label %4495
4486: ; preds = %4483
%4487 = load i32, i32* %5
%4488 = sext i32 %4487 to i64
%4489 = getelementptr inbounds [17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 %4488
%4490 = load double**, double*** %4489
%4491 = call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %4490)
br label %4492
4492: ; preds = %4486
%4493 = load i32, i32* %5
%4494 = add nsw i32 %4493, 1
store i32 %4494, i32* %5
br label %4483
4495: ; preds = %4483
ret void
}

LLVM IR (-O2):
@contrast.xin_array = internal unnamed_addr global double* null
@contrast.xin = internal unnamed_addr global double** null
@contrast.xout = internal unnamed_addr global double** null
@contrast.xwork = internal unnamed_addr global [17 x double**] zeroinitializer
@contrast.r = internal unnamed_addr global double** null
@contrast.r_bar = internal unnamed_addr global double** null
@contrast.r_new = internal unnamed_addr global double** null
@contrast.r_bar_new = internal unnamed_addr global double** null
@contrast.p = internal unnamed_addr global double** null
@contrast.p_bar = internal unnamed_addr global double** null
@contrast.p_new = internal unnamed_addr global double** null
@contrast.p_bar_new = internal unnamed_addr global double** null
@contrast.iter_sum = internal unnamed_addr global float 0.000000e+00
@contrast.iter_n = internal unnamed_addr global float 0.000000e+00
@__func__.contrast = [9 x i8] c"contrast\00"
@.str = [132 x i8] c"/scratch/repos/new/home/jordi_armengol_estape/c-scraper/outputs/2022-01-22/02-19-57/repos/AZed/cdo/refs/heads/master/src/interpol.c\00"
define void @contrast() {
%1 = tail call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 1540, i64 32)
%2 = sext i32 %1 to i64
%3 = inttoptr i64 %2 to double*
store double* %3, double** @contrast.xin_array
%4 = tail call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 1541, i64 16)
%5 = sext i32 %4 to i64
%6 = inttoptr i64 %5 to double**
store double** %6, double*** @contrast.xin
%7 = getelementptr inbounds double*, double** %6, i64 1
%8 = load double*, double** %7
store double* %8, double** %6
%9 = load double*, double** @contrast.xin_array
%10 = load double**, double*** @contrast.xin
%11 = getelementptr inbounds double*, double** %10, i64 -1
%12 = insertelement <2 x double*> poison, double* %9, i64 0
%13 = shufflevector <2 x double*> %12, <2 x double*> poison, <2 x i32> zeroinitializer
%14 = getelementptr double, <2 x double*> %13, <2 x i64> <i64 1, i64 3>
%15 = bitcast double** %11 to <2 x double*>*
store <2 x double*> %14, <2 x double*>* %15
%16 = tail call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 1545, i64 0)
%17 = sext i32 %16 to i64
%18 = inttoptr i64 %17 to double**
store double** %18, double*** @contrast.xout
br label %19
19: ; preds = %0, %19
%20 = phi i64 [ 0, %0 ], [ %25, %19 ]
%21 = tail call i32 (i8*, i8*, i32, i64, ...) bitcast (i32 (...)* @Malloc to i32 (i8*, i8*, i32, i64, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 1550, i64 0)
%22 = sext i32 %21 to i64
%23 = inttoptr i64 %22 to double**
%24 = getelementptr inbounds [17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 %20
store double** %23, double*** %24
%25 = add nuw nsw i64 %20, 1
%26 = icmp eq i64 %25, 17
br i1 %26, label %27, label %19
27: ; preds = %19
%28 = load double**, double*** @contrast.xin
%29 = getelementptr inbounds double*, double** %28, i64 -1
%30 = load double*, double** %29
%31 = getelementptr inbounds double, double* %30, i64 -1
%32 = bitcast double* %31 to i8*
%33 = load double*, double** %28
%34 = getelementptr inbounds double, double* %33, i64 -1
%35 = bitcast double* %34 to i8*
%36 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 9)
store double** %36, double*** @contrast.r
%37 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 10)
store double** %37, double*** @contrast.r_bar
%38 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 11)
store double** %38, double*** @contrast.r_new
%39 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 12)
store double** %39, double*** @contrast.r_bar_new
%40 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 13)
store double** %40, double*** @contrast.p
%41 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 14)
store double** %41, double*** @contrast.p_bar
%42 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 15)
store double** %42, double*** @contrast.p_new
%43 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 16)
store double** %43, double*** @contrast.p_bar_new
%44 = load float, float* @contrast.iter_sum
%45 = fpext float %44 to double
%46 = tail call double @llvm.fmuladd.f64(double %45, double 9.000000e-01, double 1.000000e+00)
%47 = fptrunc double %46 to float
store float %47, float* @contrast.iter_sum
%48 = load float, float* @contrast.iter_n
%49 = fpext float %48 to double
%50 = tail call double @llvm.fmuladd.f64(double %49, double 9.000000e-01, double 1.000000e+00)
%51 = fptrunc double %50 to float
store float %51, float* @contrast.iter_n
%52 = load double*, double** @contrast.xin_array
%53 = tail call i32 (i8*, i8*, i32, double*, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double*, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2020, double* %52)
%54 = load double**, double*** @contrast.xin
%55 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2021, double** %54)
%56 = load double**, double*** @contrast.xout
%57 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2022, double** %56)
%58 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 0)
%59 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %58)
%60 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 1)
%61 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %60)
%62 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 2)
%63 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %62)
%64 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 3)
%65 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %64)
%66 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 4)
%67 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %66)
%68 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 5)
%69 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %68)
%70 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 6)
%71 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %70)
%72 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 7)
%73 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %72)
%74 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 8)
%75 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %74)
%76 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 9)
%77 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %76)
%78 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 10)
%79 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %78)
%80 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 11)
%81 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %80)
%82 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 12)
%83 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %82)
%84 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 13)
%85 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %84)
%86 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 14)
%87 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %86)
%88 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 15)
%89 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %88)
%90 = load double**, double*** getelementptr inbounds ([17 x double**], [17 x double**]* @contrast.xwork, i64 0, i64 16)
%91 = tail call i32 (i8*, i8*, i32, double**, ...) bitcast (i32 (...)* @Free to i32 (i8*, i8*, i32, double**, ...)*)(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @__func__.contrast, i64 0, i64 0), i8* getelementptr inbounds ([132 x i8], [132 x i8]* @.str, i64 0, i64 0), i32 2024, double** %90)
ret void
}