#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ time_t;

/* Variables and functions */
int M_PI;
int cos(int);
double difftime(int /*<<< orphan*/, int /*<<< orphan*/);
size_t index_2d(int, int, int);
size_t index_3d(int, int, int, int, int);
size_t index_4d(int, int, int, int, int, int, int);
int /*<<< orphan*/ make_nucleon_2pt(double *, double *, double *, double *,
                                    int *, int *, double *, int *, int *,
                                    double *, double *, double *, double *,
                                    double *, int, int, int, int, int, int, int,
                                    int, int);
int /*<<< orphan*/
make_two_nucleon_2pt(double *, double *, double *, double *, double *, double *,
                     int *, int *, double *, int *, int *, double *, int *,
                     int *, double *, double *, double *, double *, double *,
                     double *, double *, double *, double *, double *, double *,
                     double *, double *, double *, int, int, int, int, int, int,
                     int, int, int, int, int, int, int, int);
void *malloc(int);
int /*<<< orphan*/ printf(char *, ...);
size_t prop_index(int, int, int, int, int, int, int, int, int, int, int, int,
                  int);
int sin(int);
int sqrt(int);
int /*<<< orphan*/ time(int /*<<< orphan*/ *);
int main() {
  int Vsrc = 256;
  int Vsnk = 256;
  int Nt = 1;
  int Nsrc = 4;
  int NsrcHex = 1;
  int Nsnk = 4;
  int NsnkHex = 1;
  int Nc = 3;
  int Ns = 2;
  int Nq = 3;
  int Nw = 9;
  int Nperms = 9;
  long mega = 1024 * 1024;
  printf("Array sizes\n");
  printf("Prop:\n");
  printf("	Max index size = %d ", Nq * Vsnk * Vsrc * Nc * Ns * Nc * Ns * Nt);
  printf("	Array size = %lu Mega bytes\n", Nq * Vsnk * Vsrc * Nc * Ns *
                                                    Nc * Ns * Nt * Nt *
                                                    sizeof(double) / mega);
  printf("Blocal:\n");
  printf("	Max index size = %d ", Vsnk * Nsrc * Nc * Ns * Nc * Ns * Nc * Ns);
  printf("	Array size = %lu Mega bytes\n",
         Vsnk * Nsrc * Nc * Ns * Nc * Ns * Nc * Ns * sizeof(double) / mega);
  printf("Q, O & P:\n");
  printf("	Max index size = %d ", Vsnk * Vsrc * Nc * Ns * Nc * Ns * Nc * Ns);
  printf("	Array size = %lu Mega bytes\n",
         Vsnk * Vsrc * Nc * Ns * Nc * Ns * Nc * Ns * sizeof(double) / mega);
  printf("Bsingle, Bdouble:\n");
  printf("	Max index size = %d ", Nc * Ns * Nc * Ns * Nc * Ns);
  printf("	Array size = %lu Mega bytes\n",
         Nc * Ns * Nc * Ns * Nc * Ns * sizeof(double) / mega);
  printf("%lu \n", 0xffffffffffffffffUL);
  printf("starting block main\n");
  time_t start, end;
  time(&start);
  double dif;
  int iCprime, iSprime, jCprime, jSprime, kCprime, kSprime, iC, iS, jC, jS, kC,
      kS, x, x1, x2, t, y, nB1, nB2, q, n, m, wnum, i, k, r, b;
  double mq = 1.0;
  double *B1_prop_re =
      malloc(Nq * Nt * Nc * Ns * Nc * Ns * Vsnk * Vsrc * sizeof(double));
  double *B1_prop_im =
      malloc(Nq * Nt * Nc * Ns * Nc * Ns * Vsnk * Vsrc * sizeof(double));
  double *B2_prop_re =
      malloc(Nq * Nt * Nc * Ns * Nc * Ns * Vsnk * Vsrc * sizeof(double));
  double *B2_prop_im =
      malloc(Nq * Nt * Nc * Ns * Nc * Ns * Vsnk * Vsrc * sizeof(double));
  for (q = 0; q < Nq; q++) {
    for (t = 0; t < Nt; t++) {
      for (iC = 0; iC < Nc; iC++) {
        for (iS = 0; iS < Ns; iS++) {
          for (jC = 0; jC < Nc; jC++) {
            for (jS = 0; jS < Ns; jS++) {
              for (y = 0; y < Vsrc; y++) {
                for (x = 0; x < Vsnk; x++) {
                  if ((jC == iC) && (jS == iS)) {
                    B1_prop_re[prop_index(q, t, jC, jS, iC, iS, y, x, Nc, Ns,
                                          Vsrc, Vsnk, Nt)] =
                        1 / mq * cos(2 * M_PI / 6);
                    B2_prop_re[prop_index(q, t, jC, jS, iC, iS, y, x, Nc, Ns,
                                          Vsrc, Vsnk, Nt)] =
                        1 / mq * cos(2 * M_PI / 6);
                    B1_prop_im[prop_index(q, t, jC, jS, iC, iS, y, x, Nc, Ns,
                                          Vsrc, Vsnk, Nt)] =
                        1 / mq * sin(2 * M_PI / 6);
                    B2_prop_im[prop_index(q, t, jC, jS, iC, iS, y, x, Nc, Ns,
                                          Vsrc, Vsnk, Nt)] =
                        1 / mq * sin(2 * M_PI / 6);
                  } else {
                    B1_prop_re[prop_index(q, t, jC, jS, iC, iS, y, x, Nc, Ns,
                                          Vsrc, Vsnk, Nt)] = 0;
                    B2_prop_re[prop_index(q, t, jC, jS, iC, iS, y, x, Nc, Ns,
                                          Vsrc, Vsnk, Nt)] = 0;
                    B1_prop_im[prop_index(q, t, jC, jS, iC, iS, y, x, Nc, Ns,
                                          Vsrc, Vsnk, Nt)] = 0;
                    B2_prop_im[prop_index(q, t, jC, jS, iC, iS, y, x, Nc, Ns,
                                          Vsrc, Vsnk, Nt)] = 0;
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  printf("built props\n");
  int B1_G1g_r1_color_weights[9][3] = {{0, 1, 2}, {0, 2, 1}, {1, 0, 2},
                                       {0, 1, 2}, {0, 2, 1}, {1, 0, 2},
                                       {1, 2, 0}, {2, 1, 0}, {2, 0, 1}};
  int B1_G1g_r1_spin_weights[9][3] = {{0, 1, 0}, {0, 1, 0}, {0, 1, 0},
                                      {1, 0, 0}, {1, 0, 0}, {1, 0, 0},
                                      {1, 0, 0}, {1, 0, 0}, {1, 0, 0}};
  double B1_G1g_r1_weights[9] = {-2 / sqrt(2), 2 / sqrt(2),  2 / sqrt(2),
                                 1 / sqrt(2),  -1 / sqrt(2), -1 / sqrt(2),
                                 1 / sqrt(2),  -1 / sqrt(2), 1 / sqrt(2)};
  int B1_G1g_r2_color_weights[9][3] = {{0, 1, 2}, {0, 2, 1}, {1, 0, 2},
                                       {1, 2, 0}, {2, 1, 0}, {2, 0, 1},
                                       {0, 1, 2}, {0, 2, 1}, {1, 0, 2}};
  int B1_G1g_r2_spin_weights[9][3] = {{0, 1, 1}, {0, 1, 1}, {0, 1, 1},
                                      {0, 1, 1}, {0, 1, 1}, {0, 1, 1},
                                      {1, 0, 1}, {1, 0, 1}, {1, 0, 1}};
  double B1_G1g_r2_weights[9] = {1 / sqrt(2),  -1 / sqrt(2), -1 / sqrt(2),
                                 1 / sqrt(2),  -1 / sqrt(2), 1 / sqrt(2),
                                 -2 / sqrt(2), 2 / sqrt(2),  2 / sqrt(2)};
  int *src_color_weights_r1 = malloc(Nw * Nq * sizeof(int));
  int *src_color_weights_r2 = malloc(Nw * Nq * sizeof(int));
  int *src_spin_weights_r1 = malloc(Nw * Nq * sizeof(int));
  int *src_spin_weights_r2 = malloc(Nw * Nq * sizeof(int));
  double src_weights_r1[Nw];
  double src_weights_r2[Nw];
  for (wnum = 0; wnum < Nw; wnum++) {
    for (q = 0; q < Nq; q++) {
      src_color_weights_r1[index_2d(wnum, q, Nq)] =
          B1_G1g_r1_color_weights[wnum][q];
      src_color_weights_r2[index_2d(wnum, q, Nq)] =
          B1_G1g_r2_color_weights[wnum][q];
      src_spin_weights_r1[index_2d(wnum, q, Nq)] =
          B1_G1g_r1_spin_weights[wnum][q];
      src_spin_weights_r2[index_2d(wnum, q, Nq)] =
          B1_G1g_r2_spin_weights[wnum][q];
    }
    src_weights_r1[wnum] = B1_G1g_r1_weights[wnum];
    src_weights_r2[wnum] = B1_G1g_r2_weights[wnum];
  }
  printf("built weights\n");
  int perms_array[36][6] = {
      {1, 2, 3, 4, 5, 6}, {1, 4, 3, 2, 5, 6}, {1, 6, 3, 2, 5, 4},
      {1, 2, 3, 6, 5, 4}, {1, 4, 3, 6, 5, 2}, {1, 6, 3, 4, 5, 2},
      {3, 2, 1, 4, 5, 6}, {3, 4, 1, 2, 5, 6}, {3, 6, 1, 2, 5, 4},
      {3, 2, 1, 6, 5, 4}, {3, 4, 1, 6, 5, 2}, {3, 6, 1, 4, 5, 2},
      {5, 2, 1, 4, 3, 6}, {5, 4, 1, 2, 3, 6}, {5, 6, 1, 2, 3, 4},
      {5, 2, 1, 6, 3, 4}, {5, 4, 1, 6, 3, 2}, {5, 6, 1, 4, 3, 2},
      {1, 2, 5, 4, 3, 6}, {1, 4, 5, 2, 3, 6}, {1, 6, 5, 2, 3, 4},
      {1, 2, 5, 6, 3, 4}, {1, 4, 5, 6, 3, 2}, {1, 6, 5, 4, 3, 2},
      {3, 2, 5, 4, 1, 6}, {3, 4, 5, 2, 1, 6}, {3, 6, 5, 2, 1, 4},
      {3, 2, 5, 6, 1, 4}, {3, 4, 5, 6, 1, 2}, {3, 6, 5, 4, 1, 2},
      {5, 2, 3, 4, 1, 6}, {5, 4, 3, 2, 1, 6}, {5, 6, 3, 2, 1, 4},
      {5, 2, 3, 6, 1, 4}, {5, 4, 3, 6, 1, 2}, {5, 6, 3, 4, 1, 2}};
  int sigs_array[36] = {1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1,
                        1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1,
                        1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1};
  int *perms = malloc(Nperms * 2 * Nq * sizeof(int));
  int sigs[Nperms];
  int permnum = 0;
  for (i = 0; i < 36; i++) {
    if (perms_array[i][0] > perms_array[i][2]) {
      continue;
    } else if (perms_array[i][3] > perms_array[i][5]) {
      continue;
    } else {
      for (q = 0; q < 2 * Nq; q++) {
        perms[index_2d(permnum, q, 2 * Nq)] = perms_array[i][q];
      }
      sigs[permnum] = sigs_array[i];
      permnum += 1;
    }
  }
  printf("read %d perms \n", permnum);
  double *src_psi_B1_re = malloc(Nsrc * Vsrc * sizeof(double));
  double *src_psi_B1_im = malloc(Nsrc * Vsrc * sizeof(double));
  double *src_psi_B2_re = malloc(Nsrc * Vsrc * sizeof(double));
  double *src_psi_B2_im = malloc(Nsrc * Vsrc * sizeof(double));
  for (k = 0; k < Nsrc; k++) {
    for (x = 0; x < Vsrc; x++) {
      src_psi_B1_re[index_2d(x, k, Nsrc)] = 1.0;
      src_psi_B1_im[index_2d(x, k, Nsrc)] = 0.0;
      src_psi_B2_re[index_2d(x, k, Nsrc)] = 1.0;
      src_psi_B2_im[index_2d(x, k, Nsrc)] = 0.0;
    }
  }
  double *snk_psi_B1_re = malloc(Nsnk * Vsnk * sizeof(double));
  double *snk_psi_B1_im = malloc(Nsnk * Vsnk * sizeof(double));
  double *snk_psi_B2_re = malloc(Nsnk * Vsnk * sizeof(double));
  double *snk_psi_B2_im = malloc(Nsnk * Vsnk * sizeof(double));
  for (k = 0; k < Nsnk; k++) {
    for (x = 0; x < Vsnk; x++) {
      snk_psi_B1_re[index_2d(x, k, Nsnk)] = 1.0;
      snk_psi_B1_im[index_2d(x, k, Nsnk)] = 0.0;
      snk_psi_B2_re[index_2d(x, k, Nsnk)] = 1.0;
      snk_psi_B2_im[index_2d(x, k, Nsnk)] = 0.0;
    }
  }
  double *hex_src_psi_re = malloc(NsrcHex * Vsrc * sizeof(double));
  double *hex_src_psi_im = malloc(NsrcHex * Vsrc * sizeof(double));
  double *hex_snk_psi_re = malloc(NsnkHex * Vsnk * sizeof(double));
  double *hex_snk_psi_im = malloc(NsnkHex * Vsnk * sizeof(double));
  for (k = 0; k < NsrcHex; k++) {
    for (y = 0; y < Vsrc; y++) {
      hex_src_psi_re[index_2d(y, k, NsrcHex)] = 1.0;
      hex_src_psi_im[index_2d(y, k, NsrcHex)] = 0.0;
    }
  }
  for (k = 0; k < NsnkHex; k++) {
    for (x = 0; x < Vsnk; x++) {
      hex_snk_psi_re[index_2d(x, k, NsnkHex)] = 1.0;
      hex_snk_psi_im[index_2d(x, k, NsnkHex)] = 0.0;
    }
  }
  double *snk_psi_re = malloc(Nsnk * Vsnk * Vsnk * sizeof(double));
  double *snk_psi_im = malloc(Nsnk * Vsnk * Vsnk * sizeof(double));
  for (k = 0; k < Nsnk; k++) {
    for (x = 0; x < Vsnk; x++) {
      for (y = 0; y < Vsnk; y++) {
        snk_psi_re[index_3d(x, y, k, Vsnk, Nsnk)] = 1.0;
        snk_psi_im[index_3d(x, y, k, Vsnk, Nsnk)] = 0.0;
      }
    }
  }
  printf("built wavefunctions\n");
  double *C_B1_re = malloc(2 * Nsrc * Nsnk * Nt * sizeof(double));
  double *C_B1_im = malloc(2 * Nsrc * Nsnk * Nt * sizeof(double));
  for (r = 0; r < 2; r++) {
    for (m = 0; m < Nsrc; m++) {
      for (n = 0; n < Nsnk; n++) {
        for (t = 0; t < Nt; t++) {
          C_B1_re[index_4d(r, m, n, t, Nsrc, Nsnk, Nt)] = 0.0;
          C_B1_im[index_4d(r, m, n, t, Nsrc, Nsnk, Nt)] = 0.0;
        }
      }
    }
  }
  make_nucleon_2pt(C_B1_re, C_B1_im, B1_prop_re, B1_prop_im,
                   src_color_weights_r1, src_spin_weights_r1, src_weights_r1,
                   src_color_weights_r2, src_spin_weights_r2, src_weights_r2,
                   src_psi_B1_re, src_psi_B1_im, snk_psi_B1_re, snk_psi_B1_im,
                   Nc, Ns, Vsrc, Vsnk, Nt, Nw, Nq, Nsrc, Nsnk);
  printf("B=1 results\n");
  for (m = 0; m < Nsrc; m++) {
    for (n = 0; n < Nsnk; n++) {
      for (t = 0; t < Nt; t++) {
        printf("C_B1_G1g_r1[%d,%d,%d] = %4.9f + (%4.9f)I\n", m, n, t,
               C_B1_re[index_4d(0, m, n, t, Nsrc, Nsnk, Nt)],
               C_B1_im[index_4d(0, m, n, t, Nsrc, Nsnk, Nt)]);
      }
      for (t = 0; t < Nt; t++) {
        printf("C_B1_G1g_r2[%d,%d,%d] = %4.9f + (%4.9f)I\n", m, n, t,
               C_B1_re[index_4d(1, m, n, t, Nsrc, Nsnk, Nt)],
               C_B1_im[index_4d(1, m, n, t, Nsrc, Nsnk, Nt)]);
      }
    }
  }
  double *C_re =
      malloc(4 * (Nsrc + NsrcHex) * (Nsnk + NsnkHex) * Nt * sizeof(double));
  double *C_im =
      malloc(4 * (Nsrc + NsrcHex) * (Nsnk + NsnkHex) * Nt * sizeof(double));
  for (b = 0; b < 4; b++) {
    for (m = 0; m < Nsrc + NsrcHex; m++) {
      for (n = 0; n < Nsnk + NsnkHex; n++) {
        for (t = 0; t < Nt; t++) {
          C_re[index_4d(b, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)] = 0.0;
          C_im[index_4d(b, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)] = 0.0;
        }
      }
    }
  }
  int space_symmetric = 0;
  int snk_entangled = 0;
  printf("starting \n");
  make_two_nucleon_2pt(
      C_re, C_im, B1_prop_re, B1_prop_im, B2_prop_re, B2_prop_im,
      src_color_weights_r1, src_spin_weights_r1, src_weights_r1,
      src_color_weights_r2, src_spin_weights_r2, src_weights_r2, perms, sigs,
      src_psi_B1_re, src_psi_B1_im, src_psi_B2_re, src_psi_B2_im, snk_psi_re,
      snk_psi_im, snk_psi_B1_re, snk_psi_B1_im, snk_psi_B2_re, snk_psi_B2_im,
      hex_src_psi_re, hex_src_psi_im, hex_snk_psi_re, hex_snk_psi_im,
      space_symmetric, snk_entangled, Nc, Ns, Vsrc, Vsnk, Nt, Nw, Nq, Nsrc,
      Nsnk, NsrcHex, NsnkHex, Nperms);
  printf("B=2 results\n");
  int *Vtab = malloc((Nsrc + NsrcHex) * (Nsnk + NsnkHex) * sizeof(int));
  for (m = 0; m < Nsrc; m++) {
    for (n = 0; n < Nsnk; n++) {
      Vtab[index_2d(m, n, Nsnk + NsnkHex)] = 1;
    }
  }
  for (m = 0; m < NsrcHex; m++) {
    for (n = 0; n < Nsnk; n++) {
      Vtab[index_2d(Nsrc + m, n, Nsnk + NsnkHex)] = 1;
    }
  }
  for (m = 0; m < Nsrc; m++) {
    for (n = 0; n < NsnkHex; n++) {
      Vtab[index_2d(m, Nsnk + n, Nsnk + NsnkHex)] = 1;
    }
  }
  for (m = 0; m < NsrcHex; m++) {
    for (n = 0; n < NsnkHex; n++) {
      Vtab[index_2d(Nsrc + m, Nsnk + n, Nsnk + NsnkHex)] = 1;
    }
  }
  for (m = 0; m < Nsrc + NsrcHex; m++) {
    for (n = 0; n < Nsnk + NsnkHex; n++) {
      for (t = 0; t < Nt; t++) {
        printf("C_B2_A1g[%d,%d,%d] = %4.9f + (%4.9f)I\n", m, n, t,
               C_re[index_4d(0, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)],
               C_im[index_4d(0, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)]);
      }
      for (t = 0; t < Nt; t++) {
        printf("C_B2_T1g_r1[%d,%d,%d] = %4.9f + (%4.9f)I\n", m, n, t,
               C_re[index_4d(1, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)],
               C_im[index_4d(1, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)]);
      }
      for (t = 0; t < Nt; t++) {
        printf("C_B2_T1g_r2[%d,%d,%d] = %4.9f + (%4.9f)I\n", m, n, t,
               C_re[index_4d(2, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)],
               C_im[index_4d(2, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)]);
      }
      for (t = 0; t < Nt; t++) {
        printf("C_B2_T1g_r3[%d,%d,%d] = %4.9f + (%4.9f)I\n", m, n, t,
               C_re[index_4d(3, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)],
               C_im[index_4d(3, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)]);
      }
    }
  }
  printf("B=2 ratios\n");
  for (m = 0; m < Nsrc + NsrcHex; m++) {
    for (n = 0; n < Nsnk + NsnkHex; n++) {
      for (t = 0; t < Nt; t++) {
        printf(
            "R_B2_A1g[%d,%d,%d] = %4.9f \n", m, n, t,
            Vtab[index_2d(m, n, Nsnk + NsnkHex)] *
                C_re[index_4d(0, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)] /
                (C_B1_re[index_4d(0, 0, 0, t, Nsrc, Nsnk, Nt)] *
                 C_B1_re[index_4d(1, 0, 0, t, Nsrc, Nsnk, Nt)]));
      }
      for (t = 0; t < Nt; t++) {
        printf(
            "R_B2_T1g_r1[%d,%d,%d] = %4.9f \n", m, n, t,
            Vtab[index_2d(m, n, Nsnk + NsnkHex)] *
                C_re[index_4d(1, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)] /
                (C_B1_re[index_4d(0, 0, 0, t, Nsrc, Nsnk, Nt)] *
                 C_B1_re[index_4d(1, 0, 0, t, Nsrc, Nsnk, Nt)]));
      }
      for (t = 0; t < Nt; t++) {
        printf(
            "R_B2_T1g_r2[%d,%d,%d] = %4.9f \n", m, n, t,
            Vtab[index_2d(m, n, Nsnk + NsnkHex)] *
                C_re[index_4d(2, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)] /
                (C_B1_re[index_4d(0, 0, 0, t, Nsrc, Nsnk, Nt)] *
                 C_B1_re[index_4d(1, 0, 0, t, Nsrc, Nsnk, Nt)]));
      }
      for (t = 0; t < Nt; t++) {
        printf(
            "R_B2_T1g_r3[%d,%d,%d] = %4.9f \n", m, n, t,
            Vtab[index_2d(m, n, Nsnk + NsnkHex)] *
                C_re[index_4d(3, m, n, t, Nsrc + NsrcHex, Nsnk + NsnkHex, Nt)] /
                (C_B1_re[index_4d(0, 0, 0, t, Nsrc, Nsnk, Nt)] *
                 C_B1_re[index_4d(1, 0, 0, t, Nsrc, Nsnk, Nt)]));
      }
    }
  }
  time(&end);
  dif = difftime(end, start);
  printf("total time %5.3f\n", dif);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xce8,%rsp
movl   $0x0,-0x2c(%rbp)
movl   $0x100,-0x30(%rbp)
movl   $0x100,-0x34(%rbp)
movl   $0x1,-0x38(%rbp)
movl   $0x4,-0x3c(%rbp)
movl   $0x1,-0x40(%rbp)
movl   $0x4,-0x44(%rbp)
movl   $0x1,-0x48(%rbp)
movl   $0x3,-0x4c(%rbp)
movl   $0x2,-0x50(%rbp)
movl   $0x3,-0x54(%rbp)
movl   $0x9,-0x58(%rbp)
movl   $0x9,-0x5c(%rbp)
movq   $0x100000,-0x68(%rbp)
lea    0x3daa(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x3da9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x54(%rbp),%esi
imul   -0x34(%rbp),%esi
imul   -0x30(%rbp),%esi
imul   -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
imul   -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
imul   -0x38(%rbp),%esi
lea    0x3d83(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x54(%rbp),%eax
imul   -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x68(%rbp)
mov    %rax,%rsi
lea    0x3d57(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x3d67(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x34(%rbp),%esi
imul   -0x3c(%rbp),%esi
imul   -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
imul   -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
imul   -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
lea    0x3d06(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x34(%rbp),%eax
imul   -0x3c(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
cltq
shl    $0x3,%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x68(%rbp)
mov    %rax,%rsi
lea    0x3cde(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x3cf7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x34(%rbp),%esi
imul   -0x30(%rbp),%esi
imul   -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
imul   -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
imul   -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
lea    0x3c8d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
cltq
shl    $0x3,%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x68(%rbp)
mov    %rax,%rsi
lea    0x3c65(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x3c89(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
imul   -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
imul   -0x4c(%rbp),%esi
imul   -0x50(%rbp),%esi
lea    0x3c1c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
cltq
shl    $0x3,%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x68(%rbp)
mov    %rax,%rsi
lea    0x3bfc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x3c33(%rip),%rdi
mov    $0xffffffffffffffff,%rsi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x3c24(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x6c(%rbp),%rdi
call   1090 <time@plt>
movsd  0x3b8f(%rip),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x54(%rbp),%eax
imul   -0x38(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0xf8(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x38(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x100(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x38(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x108(%rbp)
mov    -0x54(%rbp),%eax
imul   -0x38(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x4c(%rbp),%eax
imul   -0x50(%rbp),%eax
imul   -0x34(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x110(%rbp)
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1cd6 <main+0xaf6>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1cbd <main+0xadd>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1ca4 <main+0xac4>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1c8b <main+0xaab>
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1c72 <main+0xa92>
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x50(%rbp),%eax
jge    1c59 <main+0xa79>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1c40 <main+0xa60>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1c27 <main+0xa47>
mov    -0x9c(%rbp),%eax
cmp    -0x94(%rbp),%eax
jne    19c2 <main+0x7e2>
mov    -0xa0(%rbp),%eax
cmp    -0x98(%rbp),%eax
jne    19c2 <main+0x7e2>
movsd  0x39c7(%rip),%xmm0
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x8b8(%rbp)
ff
mov    0x5998(%rip),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    $0x6,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
call   10d0 <cos@plt>
movsd  -0x8b8(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x8b0(%rbp)
ff
mov    -0xf8(%rbp),%rax
mov    %rax,-0x8a8(%rbp)
mov    -0xc8(%rbp),%edi
mov    -0xb8(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x94(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0xbc(%rbp),%r12d
mov    -0xac(%rbp),%r15d
mov    -0x4c(%rbp),%r14d
mov    -0x50(%rbp),%ebx
mov    -0x30(%rbp),%r11d
mov    -0x34(%rbp),%r10d
mov    -0x38(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   10c0 <prop_index@plt>
movsd  -0x8b0(%rbp),%xmm0
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x8a8(%rbp),%rax
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x38e4(%rip),%xmm0
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x8a0(%rbp)
ff
mov    0x58b5(%rip),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    $0x6,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
call   10d0 <cos@plt>
movsd  -0x8a0(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x898(%rbp)
ff
mov    -0x108(%rbp),%rax
mov    %rax,-0x890(%rbp)
mov    -0xc8(%rbp),%edi
mov    -0xb8(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x94(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0xbc(%rbp),%r12d
mov    -0xac(%rbp),%r15d
mov    -0x4c(%rbp),%r14d
mov    -0x50(%rbp),%ebx
mov    -0x30(%rbp),%r11d
mov    -0x34(%rbp),%r10d
mov    -0x38(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   10c0 <prop_index@plt>
movsd  -0x898(%rbp),%xmm0
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x890(%rbp),%rax
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x3801(%rip),%xmm0
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x888(%rbp)
ff
mov    0x57d2(%rip),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    $0x6,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
call   1070 <sin@plt>
movsd  -0x888(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x880(%rbp)
ff
mov    -0x100(%rbp),%rax
mov    %rax,-0x878(%rbp)
mov    -0xc8(%rbp),%edi
mov    -0xb8(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x94(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0xbc(%rbp),%r12d
mov    -0xac(%rbp),%r15d
mov    -0x4c(%rbp),%r14d
mov    -0x50(%rbp),%ebx
mov    -0x30(%rbp),%r11d
mov    -0x34(%rbp),%r10d
mov    -0x38(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   10c0 <prop_index@plt>
movsd  -0x880(%rbp),%xmm0
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x878(%rbp),%rax
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x371e(%rip),%xmm0
divsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x870(%rbp)
ff
mov    0x56ef(%rip),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    $0x6,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
call   1070 <sin@plt>
movsd  -0x870(%rbp),%xmm0
ff
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x868(%rbp)
ff
mov    -0x110(%rbp),%rax
mov    %rax,-0x860(%rbp)
mov    -0xc8(%rbp),%edi
mov    -0xb8(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x94(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0xbc(%rbp),%r12d
mov    -0xac(%rbp),%r15d
mov    -0x4c(%rbp),%r14d
mov    -0x50(%rbp),%ebx
mov    -0x30(%rbp),%r11d
mov    -0x34(%rbp),%r10d
mov    -0x38(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   10c0 <prop_index@plt>
movsd  -0x868(%rbp),%xmm0
ff
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x860(%rbp),%rax
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c0e <main+0xa2e>
mov    -0xf8(%rbp),%rax
mov    %rax,-0x8d8(%rbp)
mov    -0xc8(%rbp),%edi
mov    -0xb8(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x94(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0xbc(%rbp),%r12d
mov    -0xac(%rbp),%r15d
mov    -0x4c(%rbp),%r14d
mov    -0x50(%rbp),%ebx
mov    -0x30(%rbp),%r11d
mov    -0x34(%rbp),%r10d
mov    -0x38(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   10c0 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x8d8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x108(%rbp),%rax
mov    %rax,-0x8d0(%rbp)
mov    -0xc8(%rbp),%edi
mov    -0xb8(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x94(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0xbc(%rbp),%r12d
mov    -0xac(%rbp),%r15d
mov    -0x4c(%rbp),%r14d
mov    -0x50(%rbp),%ebx
mov    -0x30(%rbp),%r11d
mov    -0x34(%rbp),%r10d
mov    -0x38(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   10c0 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x8d0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x100(%rbp),%rax
mov    %rax,-0x8c8(%rbp)
mov    -0xc8(%rbp),%edi
mov    -0xb8(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x94(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0xbc(%rbp),%r12d
mov    -0xac(%rbp),%r15d
mov    -0x4c(%rbp),%r14d
mov    -0x50(%rbp),%ebx
mov    -0x30(%rbp),%r11d
mov    -0x34(%rbp),%r10d
mov    -0x38(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   10c0 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x8c8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x110(%rbp),%rax
mov    %rax,-0x8c0(%rbp)
mov    -0xc8(%rbp),%edi
mov    -0xb8(%rbp),%esi
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%ecx
mov    -0x94(%rbp),%r8d
mov    -0x98(%rbp),%r9d
mov    -0xbc(%rbp),%r12d
mov    -0xac(%rbp),%r15d
mov    -0x4c(%rbp),%r14d
mov    -0x50(%rbp),%ebx
mov    -0x30(%rbp),%r11d
mov    -0x34(%rbp),%r10d
mov    -0x38(%rbp),%eax
sub    $0x40,%rsp
mov    %r12d,(%rsp)
mov    %r15d,0x8(%rsp)
mov    %r14d,0x10(%rsp)
mov    %ebx,0x18(%rsp)
mov    %r11d,0x20(%rsp)
mov    %r10d,0x28(%rsp)
mov    %eax,0x30(%rsp)
call   10c0 <prop_index@plt>
add    $0x40,%rsp
mov    %rax,%rcx
mov    -0x8c0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1c13 <main+0xa33>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    15fe <main+0x41e>
jmp    1c2c <main+0xa4c>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    15e5 <main+0x405>
jmp    1c45 <main+0xa65>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    15cc <main+0x3ec>
jmp    1c5e <main+0xa7e>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    15b3 <main+0x3d3>
jmp    1c77 <main+0xa97>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    159a <main+0x3ba>
jmp    1c90 <main+0xab0>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1581 <main+0x3a1>
jmp    1ca9 <main+0xac9>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1568 <main+0x388>
jmp    1cc2 <main+0xae2>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    154f <main+0x36f>
lea    0x33b5(%rip),%rdi
xor    %eax,%eax
mov    %eax,-0x8f0(%rbp)
call   1040 <printf@plt>
movups 0x35fb(%rip),%xmm0
movups %xmm0,-0x124(%rbp)
movaps 0x35e1(%rip),%xmm0
movaps %xmm0,-0x130(%rbp)
movaps 0x35c3(%rip),%xmm0
movaps %xmm0,-0x140(%rbp)
movaps 0x35a5(%rip),%xmm0
movaps %xmm0,-0x150(%rbp)
movaps 0x3587(%rip),%xmm0
movaps %xmm0,-0x160(%rbp)
movaps 0x3569(%rip),%xmm0
movaps %xmm0,-0x170(%rbp)
movaps 0x354b(%rip),%xmm0
movaps %xmm0,-0x180(%rbp)
movups 0x3609(%rip),%xmm0
movups %xmm0,-0x194(%rbp)
movaps 0x35ef(%rip),%xmm0
movaps %xmm0,-0x1a0(%rbp)
movaps 0x35d1(%rip),%xmm0
movaps %xmm0,-0x1b0(%rbp)
movaps 0x35b3(%rip),%xmm0
movaps %xmm0,-0x1c0(%rbp)
movaps 0x3595(%rip),%xmm0
movaps %xmm0,-0x1d0(%rbp)
movaps 0x3577(%rip),%xmm0
movaps %xmm0,-0x1e0(%rbp)
movaps 0x3559(%rip),%xmm0
movaps %xmm0,-0x1f0(%rbp)
mov    $0x2,%edi
mov    %edi,-0x8ec(%rbp)
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    %eax,%ecx
mov    $0xfffffffe,%eax
mov    %eax,-0x8f4(%rbp)
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    -0x8f0(%rbp),%edx
mov    %eax,%ecx
mov    %edi,%eax
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    -0x8f0(%rbp),%edx
mov    %eax,%ecx
mov    %edi,%eax
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    -0x8f0(%rbp),%edx
mov    %eax,%ecx
mov    $0x1,%eax
mov    %eax,-0x8f8(%rbp)
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    %eax,%ecx
mov    $0xffffffff,%eax
mov    %eax,-0x8fc(%rbp)
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    %eax,%ecx
mov    -0x8fc(%rbp),%eax
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    -0x8f0(%rbp),%edx
mov    %eax,%ecx
mov    -0x8f8(%rbp),%eax
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    %eax,%ecx
mov    -0x8fc(%rbp),%eax
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    -0x8f0(%rbp),%edx
mov    %eax,%ecx
mov    -0x8f8(%rbp),%eax
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movups 0x34ba(%rip),%xmm0
movups %xmm0,-0x254(%rbp)
movaps 0x34a0(%rip),%xmm0
movaps %xmm0,-0x260(%rbp)
movaps 0x3482(%rip),%xmm0
movaps %xmm0,-0x270(%rbp)
movaps 0x3464(%rip),%xmm0
movaps %xmm0,-0x280(%rbp)
movaps 0x3446(%rip),%xmm0
movaps %xmm0,-0x290(%rbp)
movaps 0x3428(%rip),%xmm0
movaps %xmm0,-0x2a0(%rbp)
movaps 0x340a(%rip),%xmm0
movaps %xmm0,-0x2b0(%rbp)
movups 0x34c8(%rip),%xmm0
movups %xmm0,-0x2c4(%rbp)
movaps 0x34ae(%rip),%xmm0
movaps %xmm0,-0x2d0(%rbp)
movaps 0x3490(%rip),%xmm0
movaps %xmm0,-0x2e0(%rbp)
movaps 0x3472(%rip),%xmm0
movaps %xmm0,-0x2f0(%rbp)
movaps 0x3454(%rip),%xmm0
movaps %xmm0,-0x300(%rbp)
movaps 0x3436(%rip),%xmm0
movaps %xmm0,-0x310(%rbp)
movaps 0x3418(%rip),%xmm0
movaps %xmm0,-0x320(%rbp)
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    -0x8f0(%rbp),%edx
mov    %eax,%ecx
mov    -0x8f8(%rbp),%eax
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x370(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    %eax,%ecx
mov    -0x8fc(%rbp),%eax
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x368(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    %eax,%ecx
mov    -0x8fc(%rbp),%eax
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x360(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    -0x8f0(%rbp),%edx
mov    %eax,%ecx
mov    -0x8f8(%rbp),%eax
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x358(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    %eax,%ecx
mov    -0x8fc(%rbp),%eax
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x350(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    -0x8f0(%rbp),%edx
mov    %eax,%ecx
mov    -0x8f8(%rbp),%eax
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x348(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    %eax,%ecx
mov    -0x8f4(%rbp),%eax
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x340(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8ec(%rbp),%edi
mov    -0x8f0(%rbp),%edx
mov    %eax,%ecx
mov    %edi,%eax
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x338(%rbp)
ff
call   10f0 <sqrt@plt>
mov    -0x8f0(%rbp),%edx
mov    %eax,%ecx
mov    -0x8ec(%rbp),%eax
idiv   %ecx
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x330(%rbp)
ff
mov    -0x58(%rbp),%edi
mov    -0x54(%rbp),%eax
imul   %eax,%edi
shl    $0x2,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x378(%rbp)
mov    -0x58(%rbp),%edi
mov    -0x54(%rbp),%eax
imul   %eax,%edi
shl    $0x2,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x380(%rbp)
mov    -0x58(%rbp),%edi
mov    -0x54(%rbp),%eax
imul   %eax,%edi
shl    $0x2,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x388(%rbp)
mov    -0x58(%rbp),%edi
mov    -0x54(%rbp),%eax
imul   %eax,%edi
shl    $0x2,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x390(%rbp)
mov    -0x58(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x398(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x8e8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x3a0(%rbp)
mov    -0x58(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x8e0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x3a8(%rbp)
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    23ce <main+0x11ee>
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    2374 <main+0x1194>
movslq -0xd4(%rbp),%rcx
lea    -0x180(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0xc8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x93c(%rbp)
mov    -0x378(%rbp),%rax
mov    %rax,-0x938(%rbp)
mov    -0xd4(%rbp),%edi
mov    -0xc8(%rbp),%esi
mov    -0x54(%rbp),%edx
call   10e0 <index_2d@plt>
mov    -0x93c(%rbp),%edx
mov    %rax,%rcx
mov    -0x938(%rbp),%rax
mov    %edx,(%rax,%rcx,4)
movslq -0xd4(%rbp),%rcx
lea    -0x2b0(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0xc8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x92c(%rbp)
mov    -0x380(%rbp),%rax
mov    %rax,-0x928(%rbp)
mov    -0xd4(%rbp),%edi
mov    -0xc8(%rbp),%esi
mov    -0x54(%rbp),%edx
call   10e0 <index_2d@plt>
mov    -0x92c(%rbp),%edx
mov    %rax,%rcx
mov    -0x928(%rbp),%rax
mov    %edx,(%rax,%rcx,4)
movslq -0xd4(%rbp),%rcx
lea    -0x1f0(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0xc8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x91c(%rbp)
mov    -0x388(%rbp),%rax
mov    %rax,-0x918(%rbp)
mov    -0xd4(%rbp),%edi
mov    -0xc8(%rbp),%esi
mov    -0x54(%rbp),%edx
call   10e0 <index_2d@plt>
mov    -0x91c(%rbp),%edx
mov    %rax,%rcx
mov    -0x918(%rbp),%rax
mov    %edx,(%rax,%rcx,4)
movslq -0xd4(%rbp),%rcx
lea    -0x320(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0xc8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x90c(%rbp)
mov    -0x390(%rbp),%rax
mov    %rax,-0x908(%rbp)
mov    -0xd4(%rbp),%edi
mov    -0xc8(%rbp),%esi
mov    -0x54(%rbp),%edx
call   10e0 <index_2d@plt>
mov    -0x90c(%rbp),%edx
mov    %rax,%rcx
mov    -0x908(%rbp),%rax
mov    %edx,(%rax,%rcx,4)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    21e9 <main+0x1009>
mov    -0x8e0(%rbp),%rax
mov    -0x8e8(%rbp),%rcx
movslq -0xd4(%rbp),%rdx
movsd  -0x240(%rbp,%rdx,8),%xmm0
ff ff
movslq -0xd4(%rbp),%rdx
movsd  %xmm0,(%rcx,%rdx,8)
movslq -0xd4(%rbp),%rcx
movsd  -0x370(%rbp,%rcx,8),%xmm0
ff ff
movslq -0xd4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    21d0 <main+0xff0>
lea    0x2cca(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x306d(%rip),%rsi
lea    -0x710(%rbp),%rdi
mov    $0x360,%edx
call   1080 <memcpy@plt>
lea    0x33b5(%rip),%rsi
lea    -0x7a0(%rbp),%rdi
mov    $0x90,%edx
call   1080 <memcpy@plt>
mov    -0x5c(%rbp),%edi
mov    -0x54(%rbp),%eax
imul   %eax,%edi
shl    $0x3,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x7a8(%rbp)
mov    -0x5c(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x948(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x7b0(%rbp)
movl   $0x0,-0x7b4(%rbp)
movl   $0x0,-0xd8(%rbp)
cmpl   $0x24,-0xd8(%rbp)
jge    25bb <main+0x13db>
movslq -0xd8(%rbp),%rcx
lea    -0x710(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
movslq -0xd8(%rbp),%rdx
lea    -0x710(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cmp    0x8(%rcx),%eax
jle    24a5 <main+0x12c5>
jmp    25a7 <main+0x13c7>
movslq -0xd8(%rbp),%rcx
lea    -0x710(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0xc(%rax),%eax
movslq -0xd8(%rbp),%rdx
lea    -0x710(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cmp    0x14(%rcx),%eax
jle    24e0 <main+0x1300>
jmp    25a7 <main+0x13c7>
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    256f <main+0x138f>
movslq -0xd8(%rbp),%rcx
lea    -0x710(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0xc8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x954(%rbp)
mov    -0x7a8(%rbp),%rax
mov    %rax,-0x950(%rbp)
mov    -0x7b4(%rbp),%edi
mov    -0xc8(%rbp),%esi
mov    -0x54(%rbp),%edx
shl    $0x1,%edx
call   10e0 <index_2d@plt>
mov    -0x954(%rbp),%edx
mov    %rax,%rcx
mov    -0x950(%rbp),%rax
mov    %edx,(%rax,%rcx,4)
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    24ea <main+0x130a>
mov    -0x948(%rbp),%rax
movslq -0xd8(%rbp),%rcx
mov    -0x7a0(%rbp,%rcx,4),%edx
movslq -0x7b4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x7b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7b4(%rbp)
jmp    25a2 <main+0x13c2>
jmp    25a7 <main+0x13c7>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    245e <main+0x127e>
mov    -0x7b4(%rbp),%esi
lea    0x2ae6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x3c(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x7c0(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x7c8(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x7d0(%rbp)
mov    -0x3c(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x7d8(%rbp)
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    2774 <main+0x1594>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    275b <main+0x157b>
mov    -0x7c0(%rbp),%rax
mov    %rax,-0x978(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x3c(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x978(%rbp),%rax
movsd  0x295f(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c8(%rbp),%rax
mov    %rax,-0x970(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x3c(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x970(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7d0(%rbp),%rax
mov    %rax,-0x968(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x3c(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x968(%rbp),%rax
movsd  0x28f2(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7d8(%rbp),%rax
mov    %rax,-0x960(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x3c(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x960(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    265e <main+0x147e>
jmp    2760 <main+0x1580>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    2645 <main+0x1465>
mov    -0x44(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x7e0(%rbp)
mov    -0x44(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x7e8(%rbp)
mov    -0x44(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x7f0(%rbp)
mov    -0x44(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x7f8(%rbp)
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    2919 <main+0x1739>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2900 <main+0x1720>
mov    -0x7e0(%rbp),%rax
mov    %rax,-0x998(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x44(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x998(%rbp),%rax
movsd  0x27ba(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7e8(%rbp),%rax
mov    %rax,-0x990(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x44(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x990(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7f0(%rbp),%rax
mov    %rax,-0x988(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x44(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x988(%rbp),%rax
movsd  0x274d(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7f8(%rbp),%rax
mov    %rax,-0x980(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x44(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x980(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    2803 <main+0x1623>
jmp    2905 <main+0x1725>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    27ea <main+0x160a>
mov    -0x40(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x800(%rbp)
mov    -0x40(%rbp),%eax
imul   -0x30(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x808(%rbp)
mov    -0x48(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x810(%rbp)
mov    -0x48(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x818(%rbp)
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    2a51 <main+0x1871>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    2a38 <main+0x1858>
mov    -0x800(%rbp),%rax
mov    %rax,-0x9a8(%rbp)
mov    -0xbc(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x40(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x9a8(%rbp),%rax
movsd  0x2615(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x808(%rbp),%rax
mov    %rax,-0x9a0(%rbp)
mov    -0xbc(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x40(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x9a0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    29a8 <main+0x17c8>
jmp    2a3d <main+0x185d>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    298f <main+0x17af>
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    2b1d <main+0x193d>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2b04 <main+0x1924>
mov    -0x810(%rbp),%rax
mov    %rax,-0x9b8(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x48(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x9b8(%rbp),%rax
movsd  0x2549(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x818(%rbp),%rax
mov    %rax,-0x9b0(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xdc(%rbp),%esi
mov    -0x48(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0x9b0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    2a74 <main+0x1894>
jmp    2b09 <main+0x1929>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    2a5b <main+0x187b>
mov    -0x44(%rbp),%eax
imul   -0x34(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x820(%rbp)
mov    -0x44(%rbp),%eax
imul   -0x34(%rbp),%eax
imul   -0x34(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x828(%rbp)
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    2c6d <main+0x1a8d>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2c54 <main+0x1a74>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    2c3b <main+0x1a5b>
mov    -0x820(%rbp),%rax
mov    %rax,-0x9c8(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xbc(%rbp),%esi
mov    -0xdc(%rbp),%edx
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%r8d
call   1030 <index_3d@plt>
mov    %rax,%rcx
mov    -0x9c8(%rbp),%rax
movsd  0x241c(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x828(%rbp),%rax
mov    %rax,-0x9c0(%rbp)
mov    -0xac(%rbp),%edi
mov    -0xbc(%rbp),%esi
mov    -0xdc(%rbp),%edx
mov    -0x34(%rbp),%ecx
mov    -0x44(%rbp),%r8d
call   1030 <index_3d@plt>
mov    %rax,%rcx
mov    -0x9c0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    2b97 <main+0x19b7>
jmp    2c40 <main+0x1a60>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    2b7e <main+0x199e>
jmp    2c59 <main+0x1a79>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    2b65 <main+0x1985>
lea    0x244a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
imul   -0x44(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x830(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
imul   -0x44(%rbp),%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x838(%rbp)
movl   $0x0,-0xe0(%rbp)
cmpl   $0x2,-0xe0(%rbp)
jge    2e26 <main+0x1c46>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    2e0d <main+0x1c2d>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    2df4 <main+0x1c14>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    2ddb <main+0x1bfb>
mov    -0x830(%rbp),%rax
mov    %rax,-0x9d8(%rbp)
mov    -0xe0(%rbp),%edi
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0x9d8(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x838(%rbp),%rax
mov    %rax,-0x9d0(%rbp)
mov    -0xe0(%rbp),%edi
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0x9d0(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    2d12 <main+0x1b32>
jmp    2de0 <main+0x1c00>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    2cf9 <main+0x1b19>
jmp    2df9 <main+0x1c19>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    2ce0 <main+0x1b00>
jmp    2e12 <main+0x1c32>
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    2cc9 <main+0x1ae9>
mov    -0x830(%rbp),%rdi
mov    -0x838(%rbp),%rsi
mov    -0xf8(%rbp),%rdx
mov    -0x100(%rbp),%rcx
mov    -0x378(%rbp),%r8
mov    -0x388(%rbp),%r9
mov    -0x380(%rbp),%rax
mov    %rax,-0xa10(%rbp)
mov    -0x390(%rbp),%rax
mov    %rax,-0xa08(%rbp)
mov    -0x7c0(%rbp),%rax
mov    %rax,-0xa00(%rbp)
mov    -0x7c8(%rbp),%rax
mov    %rax,-0x9f8(%rbp)
mov    -0x7e0(%rbp),%rax
mov    %rax,-0x9f0(%rbp)
mov    -0x7e8(%rbp),%rax
mov    %rax,-0x9e8(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x9e0(%rbp)
mov    -0x50(%rbp),%r13d
mov    -0x30(%rbp),%r12d
mov    -0x34(%rbp),%r15d
mov    -0x38(%rbp),%r14d
mov    -0x58(%rbp),%ebx
mov    -0x54(%rbp),%r11d
mov    -0x3c(%rbp),%r10d
mov    -0x44(%rbp),%eax
mov    %eax,-0x9dc(%rbp)
mov    -0x8e8(%rbp),%rax
sub    $0x90,%rsp
mov    %rax,(%rsp)
mov    -0xa10(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0xa08(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0x8e0(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0xa00(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x9f8(%rbp),%rax
mov    %rax,0x28(%rsp)
mov    -0x9f0(%rbp),%rax
mov    %rax,0x30(%rsp)
mov    -0x9e8(%rbp),%rax
mov    %rax,0x38(%rsp)
mov    -0x9e0(%rbp),%eax
mov    %eax,0x40(%rsp)
mov    -0x9dc(%rbp),%eax
mov    %r13d,0x48(%rsp)
mov    %r12d,0x50(%rsp)
mov    %r15d,0x58(%rsp)
mov    %r14d,0x60(%rsp)
mov    %ebx,0x68(%rsp)
mov    %r11d,0x70(%rsp)
mov    %r10d,0x78(%rsp)
mov    %eax,0x80(%rsp)
call   1060 <make_nucleon_2pt@plt>
add    $0x90,%rsp
lea    0x2150(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    3226 <main+0x2046>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    320d <main+0x202d>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    30d5 <main+0x1ef5>
mov    -0xd0(%rbp),%eax
mov    %eax,-0xa2c(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xa28(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xa24(%rbp)
mov    -0x830(%rbp),%rax
mov    %rax,-0xa38(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
xor    %edi,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xa38(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa20(%rbp)
ff
mov    -0x838(%rbp),%rax
mov    %rax,-0xa18(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
xor    %edi,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
mov    -0xa2c(%rbp),%esi
mov    -0xa28(%rbp),%edx
mov    -0xa24(%rbp),%ecx
movsd  -0xa20(%rbp),%xmm0
ff
add    $0x10,%rsp
mov    %rax,%rdi
mov    -0xa18(%rbp),%rax
movsd  (%rax,%rdi,8),%xmm1
lea    0x2026(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    2fc6 <main+0x1de6>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    31f4 <main+0x2014>
mov    -0xd0(%rbp),%eax
mov    %eax,-0xa54(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xa50(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xa4c(%rbp)
mov    -0x830(%rbp),%rax
mov    %rax,-0xa60(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x1,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xa60(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa48(%rbp)
ff
mov    -0x838(%rbp),%rax
mov    %rax,-0xa40(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x1,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
mov    -0xa54(%rbp),%esi
mov    -0xa50(%rbp),%edx
mov    -0xa4c(%rbp),%ecx
movsd  -0xa48(%rbp),%xmm0
ff
add    $0x10,%rsp
mov    %rax,%rdi
mov    -0xa40(%rbp),%rax
movsd  (%rax,%rdi,8),%xmm1
lea    0x1f31(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    30df <main+0x1eff>
jmp    31f9 <main+0x2019>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    2fad <main+0x1dcd>
jmp    3212 <main+0x2032>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    2f94 <main+0x1db4>
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
imul   %ecx,%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x840(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
shl    $0x2,%eax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
imul   %ecx,%eax
imul   -0x38(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x848(%rbp)
movl   $0x0,-0xe4(%rbp)
cmpl   $0x4,-0xe4(%rbp)
jge    33fb <main+0x221b>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jge    33e2 <main+0x2202>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
cmp    %ecx,%eax
jge    33c9 <main+0x21e9>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    33b0 <main+0x21d0>
mov    -0x840(%rbp),%rax
mov    %rax,-0xa70(%rbp)
mov    -0xe4(%rbp),%edi
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xa70(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x848(%rbp),%rax
mov    %rax,-0xa68(%rbp)
mov    -0xe4(%rbp),%edi
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xa68(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    32d7 <main+0x20f7>
jmp    33b5 <main+0x21d5>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    32b9 <main+0x20d9>
jmp    33ce <main+0x21ee>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    329b <main+0x20bb>
jmp    33e7 <main+0x2207>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    3284 <main+0x20a4>
movl   $0x0,-0x84c(%rbp)
movl   $0x0,-0x850(%rbp)
lea    0x1d1e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x840(%rbp),%rdi
mov    -0x848(%rbp),%rsi
mov    -0xf8(%rbp),%rdx
mov    -0x100(%rbp),%rcx
mov    -0x108(%rbp),%r8
mov    -0x110(%rbp),%r9
mov    -0x378(%rbp),%rax
mov    %rax,-0xb28(%rbp)
mov    -0x388(%rbp),%rax
mov    %rax,-0xb20(%rbp)
mov    -0x380(%rbp),%rax
mov    %rax,-0xb18(%rbp)
mov    -0x390(%rbp),%rax
mov    %rax,-0xb10(%rbp)
mov    -0x7a8(%rbp),%rax
mov    %rax,-0xb08(%rbp)
mov    -0x7c0(%rbp),%rax
mov    %rax,-0xb00(%rbp)
mov    -0x7c8(%rbp),%rax
mov    %rax,-0xaf8(%rbp)
mov    -0x7d0(%rbp),%rax
mov    %rax,-0xaf0(%rbp)
mov    -0x7d8(%rbp),%rax
mov    %rax,-0xae8(%rbp)
mov    -0x820(%rbp),%rax
mov    %rax,-0xae0(%rbp)
mov    -0x828(%rbp),%rax
mov    %rax,-0xad8(%rbp)
mov    -0x7e0(%rbp),%rax
mov    %rax,-0xad0(%rbp)
mov    -0x7e8(%rbp),%rax
mov    %rax,-0xac8(%rbp)
mov    -0x7f0(%rbp),%rax
mov    %rax,-0xac0(%rbp)
mov    -0x7f8(%rbp),%rax
mov    %rax,-0xab8(%rbp)
mov    -0x800(%rbp),%rax
mov    %rax,-0xab0(%rbp)
mov    -0x808(%rbp),%rax
mov    %rax,-0xaa8(%rbp)
mov    -0x810(%rbp),%rax
mov    %rax,-0xaa0(%rbp)
mov    -0x818(%rbp),%rax
mov    %rax,-0xa98(%rbp)
mov    -0x84c(%rbp),%eax
mov    %eax,-0xa8c(%rbp)
mov    -0x850(%rbp),%eax
mov    %eax,-0xa88(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0xa84(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0xa80(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0xa7c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0xa78(%rbp)
mov    -0x38(%rbp),%r13d
mov    -0x58(%rbp),%r12d
mov    -0x54(%rbp),%r15d
mov    -0x3c(%rbp),%r14d
mov    -0x44(%rbp),%ebx
mov    -0x40(%rbp),%r11d
mov    -0x48(%rbp),%r10d
mov    -0x5c(%rbp),%eax
mov    %eax,-0xa74(%rbp)
mov    -0xb28(%rbp),%rax
sub    $0x120,%rsp
mov    %rax,(%rsp)
mov    -0xb20(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0x8e8(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0xb18(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0xb10(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x8e0(%rbp),%rax
mov    %rax,0x28(%rsp)
mov    -0xb08(%rbp),%rax
mov    %rax,0x30(%rsp)
mov    -0x948(%rbp),%rax
mov    %rax,0x38(%rsp)
mov    -0xb00(%rbp),%rax
mov    %rax,0x40(%rsp)
mov    -0xaf8(%rbp),%rax
mov    %rax,0x48(%rsp)
mov    -0xaf0(%rbp),%rax
mov    %rax,0x50(%rsp)
mov    -0xae8(%rbp),%rax
mov    %rax,0x58(%rsp)
mov    -0xae0(%rbp),%rax
mov    %rax,0x60(%rsp)
mov    -0xad8(%rbp),%rax
mov    %rax,0x68(%rsp)
mov    -0xad0(%rbp),%rax
mov    %rax,0x70(%rsp)
mov    -0xac8(%rbp),%rax
mov    %rax,0x78(%rsp)
mov    -0xac0(%rbp),%rax
mov    %rax,0x80(%rsp)
mov    -0xab8(%rbp),%rax
mov    %rax,0x88(%rsp)
mov    -0xab0(%rbp),%rax
mov    %rax,0x90(%rsp)
mov    -0xaa8(%rbp),%rax
mov    %rax,0x98(%rsp)
mov    -0xaa0(%rbp),%rax
mov    %rax,0xa0(%rsp)
mov    -0xa98(%rbp),%rax
mov    %rax,0xa8(%rsp)
mov    -0xa8c(%rbp),%eax
mov    %eax,0xb0(%rsp)
mov    -0xa88(%rbp),%eax
mov    %eax,0xb8(%rsp)
mov    -0xa84(%rbp),%eax
mov    %eax,0xc0(%rsp)
mov    -0xa80(%rbp),%eax
mov    %eax,0xc8(%rsp)
mov    -0xa7c(%rbp),%eax
mov    %eax,0xd0(%rsp)
mov    -0xa78(%rbp),%eax
mov    %eax,0xd8(%rsp)
mov    -0xa74(%rbp),%eax
mov    %r13d,0xe0(%rsp)
mov    %r12d,0xe8(%rsp)
mov    %r15d,0xf0(%rsp)
mov    %r14d,0xf8(%rsp)
mov    %ebx,0x100(%rsp)
mov    %r11d,0x108(%rsp)
mov    %r10d,0x110(%rsp)
mov    %eax,0x118(%rsp)
call   1100 <make_two_nucleon_2pt@plt>
add    $0x120,%rsp
lea    0x19c9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
imul   %ecx,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x858(%rbp)
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    3835 <main+0x2655>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    381c <main+0x263c>
mov    -0x858(%rbp),%rax
mov    %rax,-0xb30(%rbp)
mov    -0xd0(%rbp),%edi
mov    -0xcc(%rbp),%esi
mov    -0x44(%rbp),%edx
add    -0x48(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0xb30(%rbp),%rax
movl   $0x1,(%rax,%rcx,4)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    37c3 <main+0x25e3>
jmp    3821 <main+0x2641>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    37aa <main+0x25ca>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    38cd <main+0x26ed>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    38b4 <main+0x26d4>
mov    -0x858(%rbp),%rax
mov    %rax,-0xb38(%rbp)
mov    -0x3c(%rbp),%edi
add    -0xd0(%rbp),%edi
mov    -0xcc(%rbp),%esi
mov    -0x44(%rbp),%edx
add    -0x48(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0xb38(%rbp),%rax
movl   $0x1,(%rax,%rcx,4)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    3858 <main+0x2678>
jmp    38b9 <main+0x26d9>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    383f <main+0x265f>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    3965 <main+0x2785>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    394c <main+0x276c>
mov    -0x858(%rbp),%rax
mov    %rax,-0xb40(%rbp)
mov    -0xd0(%rbp),%edi
mov    -0x44(%rbp),%esi
add    -0xcc(%rbp),%esi
mov    -0x44(%rbp),%edx
add    -0x48(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0xb40(%rbp),%rax
movl   $0x1,(%rax,%rcx,4)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    38f0 <main+0x2710>
jmp    3951 <main+0x2771>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    38d7 <main+0x26f7>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    3a00 <main+0x2820>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x48(%rbp),%eax
jge    39e7 <main+0x2807>
mov    -0x858(%rbp),%rax
mov    %rax,-0xb48(%rbp)
mov    -0x3c(%rbp),%edi
add    -0xd0(%rbp),%edi
mov    -0x44(%rbp),%esi
add    -0xcc(%rbp),%esi
mov    -0x44(%rbp),%edx
add    -0x48(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0xb48(%rbp),%rax
movl   $0x1,(%rax,%rcx,4)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    3988 <main+0x27a8>
jmp    39ec <main+0x280c>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    396f <main+0x278f>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jge    3f24 <main+0x2d44>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
cmp    %ecx,%eax
jge    3f0b <main+0x2d2b>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    3b65 <main+0x2985>
mov    -0xd0(%rbp),%eax
mov    %eax,-0xb64(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xb60(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xb5c(%rbp)
mov    -0x840(%rbp),%rax
mov    %rax,-0xb70(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
xor    %edi,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xb70(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb58(%rbp)
ff
mov    -0x848(%rbp),%rax
mov    %rax,-0xb50(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
xor    %edi,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
mov    -0xb64(%rbp),%esi
mov    -0xb60(%rbp),%edx
mov    -0xb5c(%rbp),%ecx
movsd  -0xb58(%rbp),%xmm0
ff
add    $0x10,%rsp
mov    %rax,%rdi
mov    -0xb50(%rbp),%rax
movsd  (%rax,%rdi,8),%xmm1
lea    0x1602(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    3a46 <main+0x2866>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    3c94 <main+0x2ab4>
mov    -0xd0(%rbp),%eax
mov    %eax,-0xb8c(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xb88(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xb84(%rbp)
mov    -0x840(%rbp),%rax
mov    %rax,-0xb98(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x1,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xb98(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb80(%rbp)
mov    -0x848(%rbp),%rax
mov    %rax,-0xb78(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x1,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
mov    -0xb8c(%rbp),%esi
mov    -0xb88(%rbp),%edx
mov    -0xb84(%rbp),%ecx
movsd  -0xb80(%rbp),%xmm0
ff
add    $0x10,%rsp
mov    %rax,%rdi
mov    -0xb78(%rbp),%rax
movsd  (%rax,%rdi,8),%xmm1
lea    0x14fa(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    3b6f <main+0x298f>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    3dc3 <main+0x2be3>
mov    -0xd0(%rbp),%eax
mov    %eax,-0xbb4(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xbb0(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xbac(%rbp)
mov    -0x840(%rbp),%rax
mov    %rax,-0xbc0(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x2,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xbc0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xba8(%rbp)
ff
mov    -0x848(%rbp),%rax
mov    %rax,-0xba0(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x2,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
mov    -0xbb4(%rbp),%esi
mov    -0xbb0(%rbp),%edx
mov    -0xbac(%rbp),%ecx
movsd  -0xba8(%rbp),%xmm0
ff
add    $0x10,%rsp
mov    %rax,%rdi
mov    -0xba0(%rbp),%rax
movsd  (%rax,%rdi,8),%xmm1
lea    0x13f5(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    3c9e <main+0x2abe>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    3ef2 <main+0x2d12>
mov    -0xd0(%rbp),%eax
mov    %eax,-0xbdc(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xbd8(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xbd4(%rbp)
mov    -0x840(%rbp),%rax
mov    %rax,-0xbe8(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x3,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xbe8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xbd0(%rbp)
ff
mov    -0x848(%rbp),%rax
mov    %rax,-0xbc8(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x3,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
mov    -0xbdc(%rbp),%esi
mov    -0xbd8(%rbp),%edx
mov    -0xbd4(%rbp),%ecx
movsd  -0xbd0(%rbp),%xmm0
ff
add    $0x10,%rsp
mov    %rax,%rdi
mov    -0xbc8(%rbp),%rax
movsd  (%rax,%rdi,8),%xmm1
lea    0x12f0(%rip),%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    3dcd <main+0x2bed>
jmp    3ef7 <main+0x2d17>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    3a28 <main+0x2848>
jmp    3f10 <main+0x2d30>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    3a0a <main+0x282a>
lea    0x12c6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xd0(%rbp)
mov    -0xd0(%rbp),%eax
mov    -0x3c(%rbp),%ecx
add    -0x40(%rbp),%ecx
cmp    %ecx,%eax
jge    4689 <main+0x34a9>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    -0x48(%rbp),%ecx
cmp    %ecx,%eax
jge    4670 <main+0x3490>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    4126 <main+0x2f46>
mov    -0xd0(%rbp),%eax
mov    %eax,-0xbfc(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xbf8(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xbf4(%rbp)
mov    -0x858(%rbp),%rax
mov    %rax,-0xc30(%rbp)
mov    -0xd0(%rbp),%edi
mov    -0xcc(%rbp),%esi
mov    -0x44(%rbp),%edx
add    -0x48(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0xc30(%rbp),%rax
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xc28(%rbp)
ff
mov    -0x840(%rbp),%rax
mov    %rax,-0xc20(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
xor    %edi,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
movsd  -0xc28(%rbp),%xmm0
ff
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xc20(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc08(%rbp)
ff
mov    -0x830(%rbp),%rax
mov    %rax,-0xc18(%rbp)
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
xor    %edx,%edx
sub    $0x10,%rsp
mov    %edx,%edi
mov    %edx,%esi
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xc18(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc10(%rbp)
ff
mov    -0x830(%rbp),%rax
mov    %rax,-0xbf0(%rbp)
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x1,%edi
xor    %edx,%edx
sub    $0x10,%rsp
mov    %edx,%esi
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
movsd  -0xc10(%rbp),%xmm1
ff
movsd  -0xc08(%rbp),%xmm0
ff
mov    -0xbfc(%rbp),%esi
mov    -0xbf8(%rbp),%edx
mov    -0xbf4(%rbp),%ecx
add    $0x10,%rsp
mov    %rax,%rdi
mov    -0xbf0(%rbp),%rax
mulsd  (%rax,%rdi,8),%xmm1
divsd  %xmm1,%xmm0
lea    0x10f2(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    3f78 <main+0x2d98>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    42e1 <main+0x3101>
mov    -0xd0(%rbp),%eax
mov    %eax,-0xc44(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xc40(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xc3c(%rbp)
mov    -0x858(%rbp),%rax
mov    %rax,-0xc78(%rbp)
mov    -0xd0(%rbp),%edi
mov    -0xcc(%rbp),%esi
mov    -0x44(%rbp),%edx
add    -0x48(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0xc78(%rbp),%rax
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xc70(%rbp)
ff
mov    -0x840(%rbp),%rax
mov    %rax,-0xc68(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x1,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
movsd  -0xc70(%rbp),%xmm0
ff
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xc68(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc50(%rbp)
ff
mov    -0x830(%rbp),%rax
mov    %rax,-0xc60(%rbp)
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
xor    %edx,%edx
sub    $0x10,%rsp
mov    %edx,%edi
mov    %edx,%esi
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xc60(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc58(%rbp)
ff
mov    -0x830(%rbp),%rax
mov    %rax,-0xc38(%rbp)
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x1,%edi
xor    %edx,%edx
sub    $0x10,%rsp
mov    %edx,%esi
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
movsd  -0xc58(%rbp),%xmm1
ff
movsd  -0xc50(%rbp),%xmm0
ff
mov    -0xc44(%rbp),%esi
mov    -0xc40(%rbp),%edx
mov    -0xc3c(%rbp),%ecx
add    $0x10,%rsp
mov    %rax,%rdi
mov    -0xc38(%rbp),%rax
mulsd  (%rax,%rdi,8),%xmm1
divsd  %xmm1,%xmm0
lea    0xf54(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    4130 <main+0x2f50>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    449c <main+0x32bc>
mov    -0xd0(%rbp),%eax
mov    %eax,-0xc8c(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xc88(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xc84(%rbp)
mov    -0x858(%rbp),%rax
mov    %rax,-0xcc0(%rbp)
mov    -0xd0(%rbp),%edi
mov    -0xcc(%rbp),%esi
mov    -0x44(%rbp),%edx
add    -0x48(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0xcc0(%rbp),%rax
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xcb8(%rbp)
ff
mov    -0x840(%rbp),%rax
mov    %rax,-0xcb0(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x2,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
movsd  -0xcb8(%rbp),%xmm0
ff
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xcb0(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc98(%rbp)
ff
mov    -0x830(%rbp),%rax
mov    %rax,-0xca8(%rbp)
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
xor    %edx,%edx
sub    $0x10,%rsp
mov    %edx,%edi
mov    %edx,%esi
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xca8(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xca0(%rbp)
ff
mov    -0x830(%rbp),%rax
mov    %rax,-0xc80(%rbp)
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x1,%edi
xor    %edx,%edx
sub    $0x10,%rsp
mov    %edx,%esi
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
movsd  -0xca0(%rbp),%xmm1
ff
movsd  -0xc98(%rbp),%xmm0
ff
mov    -0xc8c(%rbp),%esi
mov    -0xc88(%rbp),%edx
mov    -0xc84(%rbp),%ecx
add    $0x10,%rsp
mov    %rax,%rdi
mov    -0xc80(%rbp),%rax
mulsd  (%rax,%rdi,8),%xmm1
divsd  %xmm1,%xmm0
lea    0xdb9(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    42eb <main+0x310b>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    4657 <main+0x3477>
mov    -0xd0(%rbp),%eax
mov    %eax,-0xcd4(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0xcd0(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0xccc(%rbp)
mov    -0x858(%rbp),%rax
mov    %rax,-0xd08(%rbp)
mov    -0xd0(%rbp),%edi
mov    -0xcc(%rbp),%esi
mov    -0x44(%rbp),%edx
add    -0x48(%rbp),%edx
call   10e0 <index_2d@plt>
mov    %rax,%rcx
mov    -0xd08(%rbp),%rax
cvtsi2sdl (%rax,%rcx,4),%xmm0
movsd  %xmm0,-0xd00(%rbp)
ff
mov    -0x840(%rbp),%rax
mov    %rax,-0xcf8(%rbp)
mov    -0xd0(%rbp),%esi
mov    -0xcc(%rbp),%edx
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
add    -0x40(%rbp),%r8d
mov    -0x44(%rbp),%r9d
add    -0x48(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x3,%edi
sub    $0x10,%rsp
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
movsd  -0xd00(%rbp),%xmm0
ff
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xcf8(%rbp),%rax
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xce0(%rbp)
ff
mov    -0x830(%rbp),%rax
mov    %rax,-0xcf0(%rbp)
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
xor    %edx,%edx
sub    $0x10,%rsp
mov    %edx,%edi
mov    %edx,%esi
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
add    $0x10,%rsp
mov    %rax,%rcx
mov    -0xcf0(%rbp),%rax
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xce8(%rbp)
ff
mov    -0x830(%rbp),%rax
mov    %rax,-0xcc8(%rbp)
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%r8d
mov    -0x44(%rbp),%r9d
mov    -0x38(%rbp),%eax
mov    $0x1,%edi
xor    %edx,%edx
sub    $0x10,%rsp
mov    %edx,%esi
mov    %eax,(%rsp)
call   10a0 <index_4d@plt>
movsd  -0xce8(%rbp),%xmm1
ff
movsd  -0xce0(%rbp),%xmm0
ff
mov    -0xcd4(%rbp),%esi
mov    -0xcd0(%rbp),%edx
mov    -0xccc(%rbp),%ecx
add    $0x10,%rsp
mov    %rax,%rdi
mov    -0xcc8(%rbp),%rax
mulsd  (%rax,%rdi,8),%xmm1
divsd  %xmm1,%xmm0
lea    0xc1e(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    44a6 <main+0x32c6>
jmp    465c <main+0x347c>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    3f5a <main+0x2d7a>
jmp    4675 <main+0x3495>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    3f3c <main+0x2d5c>
lea    -0x70(%rbp),%rdi
call   1090 <time@plt>
mov    -0x70(%rbp),%edi
mov    -0x6c(%rbp),%esi
call   1050 <difftime@plt>
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
lea    0xbcc(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x398(%rbp),%rax
mov    %rax,%rsp
mov    -0x2c(%rbp),%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
lea    0x2fd7(%rip),%rdi
call   1030 <puts@plt>
lea    0x2fd7(%rip),%rdi
call   1030 <puts@plt>
lea    0x2ded(%rip),%r14
xor    %eax,%eax
mov    %rax,-0x50(%rbp)
mov    %r14,%rdi
mov    $0x6c0000,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x2de7(%rip),%r15
mov    $0x36,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x2f9f(%rip),%rdi
call   1030 <puts@plt>
mov    %r14,%rdi
mov    $0x36000,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x1,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x2f7d(%rip),%rdi
call   1030 <puts@plt>
mov    %r14,%rdi
mov    $0xd80000,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x6c,%esi
mov    %r15,%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x2f5d(%rip),%rdi
call   1030 <puts@plt>
mov    %r14,%rdi
mov    $0xd8,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r15,%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x2d74(%rip),%rdi
mov    $0xffffffffffffffff,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x2f33(%rip),%rdi
call   1030 <puts@plt>
lea    -0xc0(%rbp),%rdi
call   1090 <time@plt>
mov    $0x3600000,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x98(%rbp)
mov    $0x3600000,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x90(%rbp)
mov    $0x3600000,%edi
call   10b0 <malloc@plt>
mov    %rax,-0xb8(%rbp)
mov    $0x3600000,%edi
call   10b0 <malloc@plt>
mov    %rax,-0xf0(%rbp)
jmp    1344 <main+0x164>
nopl   0x0(%rax)
mov    -0x50(%rbp),%rax
add    $0x1,%eax
mov    %rax,-0x50(%rbp)
cmp    $0x3,%eax
je     1716 <main+0x536>
movl   $0x0,-0x40(%rbp)
jmp    135e <main+0x17e>
nopl   (%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
cmp    $0x3,%eax
je     1330 <main+0x150>
movl   $0x0,-0x38(%rbp)
mov    $0x1,%al
jmp    1382 <main+0x1a2>
nopl   0x0(%rax)
movl   $0x1,-0x38(%rbp)
testb  $0x1,-0x68(%rbp)
mov    $0x0,%eax
je     1350 <main+0x170>
mov    %eax,-0x68(%rbp)
movl   $0x0,-0x58(%rbp)
jmp    139e <main+0x1be>
xchg   %ax,%ax
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
cmp    $0x3,%eax
je     1370 <main+0x190>
xor    %ecx,%ecx
mov    $0x1,%al
jmp    13c0 <main+0x1e0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x1,%ecx
testb  $0x1,-0x70(%rbp)
mov    $0x0,%eax
je     1390 <main+0x1b0>
mov    %eax,-0x70(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x40(%rbp),%eax
mov    %ecx,-0x60(%rbp)
xor    -0x38(%rbp),%ecx
or     %eax,%ecx
sete   -0x78(%rbp)
xor    %eax,%eax
mov    %rax,-0x30(%rbp)
jmp    13f2 <main+0x212>
nopl   (%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%eax
mov    %rax,-0x30(%rbp)
cmp    $0x100,%eax
je     13b0 <main+0x1d0>
xor    %r13d,%r13d
jmp    1540 <main+0x360>
nopw   0x0(%rax,%rax,1)
sub    $0x8,%rsp
mov    -0x50(%rbp),%r15
mov    %r15d,%edi
xor    %esi,%esi
mov    -0x58(%rbp),%edx
mov    -0x60(%rbp),%ecx
mov    -0x40(%rbp),%r12d
mov    %r12d,%r8d
mov    %r12d,-0x40(%rbp)
mov    -0x38(%rbp),%ebx
mov    %ebx,%r9d
mov    %ebx,-0x38(%rbp)
push   $0x1
push   $0x100
push   $0x100
push   $0x2
push   $0x3
push   %r13
mov    -0x30(%rbp),%rax
push   %rax
call   10c0 <prop_index@plt>
add    $0x40,%rsp
mov    -0x98(%rbp),%rcx
movq   $0x0,(%rcx,%rax,8)
sub    $0x8,%rsp
mov    %r15d,%edi
mov    %r15,-0x50(%rbp)
xor    %esi,%esi
mov    -0x58(%rbp),%edx
mov    -0x60(%rbp),%r14d
mov    %r14d,%ecx
mov    %r12d,%r8d
mov    %ebx,%r9d
push   $0x1
push   $0x100
push   $0x100
push   $0x2
push   $0x3
push   %r13
mov    -0x30(%rbp),%rbx
push   %rbx
call   10c0 <prop_index@plt>
add    $0x40,%rsp
mov    -0xb8(%rbp),%rcx
movq   $0x0,(%rcx,%rax,8)
sub    $0x8,%rsp
mov    %r15d,%edi
xor    %esi,%esi
mov    -0x58(%rbp),%r12d
mov    %r12d,%edx
mov    %r14d,%ecx
mov    -0x40(%rbp),%r15d
mov    %r15d,%r8d
mov    -0x38(%rbp),%r14d
mov    %r14d,%r9d
push   $0x1
push   $0x100
push   $0x100
push   $0x2
push   $0x3
push   %r13
push   %rbx
call   10c0 <prop_index@plt>
add    $0x40,%rsp
mov    -0x90(%rbp),%rcx
movq   $0x0,(%rcx,%rax,8)
sub    $0x8,%rsp
mov    -0x50(%rbp),%rdi
xor    %esi,%esi
mov    %r12d,%edx
mov    -0x60(%rbp),%ecx
mov    %r15d,%r8d
mov    %r14d,%r9d
push   $0x1
push   $0x100
push   $0x100
push   $0x2
push   $0x3
push   %r13
push   %rbx
call   10c0 <prop_index@plt>
add    $0x40,%rsp
xorps  %xmm0,%xmm0
mov    -0xf0(%rbp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%r13d
cmp    $0x100,%r13d
je     13e0 <main+0x200>
cmpb   $0x0,-0x78(%rbp)
je     1400 <main+0x220>
mov    0x4a97(%rip),%rbx
movslq (%rbx),%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
call   10d0 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
sub    $0x8,%rsp
mov    -0x50(%rbp),%r14
mov    %r14d,%edi
xor    %esi,%esi
mov    -0x40(%rbp),%ebx
mov    %ebx,%edx
mov    -0x38(%rbp),%r15d
mov    %r15d,%ecx
mov    %ebx,%r8d
mov    %r15d,%r9d
push   $0x1
push   $0x100
push   $0x100
push   $0x2
push   $0x3
push   %r13
mov    -0x30(%rbp),%r12
push   %r12
call   10c0 <prop_index@plt>
add    $0x40,%rsp
mov    -0x98(%rbp),%rcx
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    0x4a17(%rip),%rax
movslq (%rax),%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
call   10d0 <cos@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
sub    $0x8,%rsp
mov    %r14d,%edi
xor    %esi,%esi
mov    %ebx,%edx
mov    %r15d,%ecx
mov    %ebx,%r8d
mov    %r15d,%r9d
push   $0x1
push   $0x100
push   $0x100
push   $0x2
push   $0x3
push   %r13
push   %r12
call   10c0 <prop_index@plt>
add    $0x40,%rsp
mov    -0xb8(%rbp),%rcx
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    0x49a6(%rip),%rax
movslq (%rax),%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
call   1080 <sin@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
sub    $0x8,%rsp
mov    %r14d,%edi
xor    %esi,%esi
mov    %ebx,%edx
mov    %r15d,%ecx
mov    %ebx,%r8d
mov    %r15d,%r9d
push   $0x1
push   $0x100
push   $0x100
push   $0x2
push   $0x3
push   %r13
push   %r12
call   10c0 <prop_index@plt>
add    $0x40,%rsp
mov    -0x90(%rbp),%rcx
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    0x4935(%rip),%rax
movslq (%rax),%rax
imul   $0x55555556,%rax,%rdi
mov    %rdi,%rax
shr    $0x3f,%rax
shr    $0x20,%rdi
add    %eax,%edi
call   1080 <sin@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
sub    $0x8,%rsp
mov    %r14d,%edi
xor    %esi,%esi
mov    %ebx,%edx
mov    %r15d,%ecx
mov    %ebx,%r8d
mov    %r15d,%r9d
push   $0x1
push   $0x100
push   $0x100
push   $0x2
push   $0x3
push   %r13
push   %r12
call   10c0 <prop_index@plt>
movsd  -0x48(%rbp),%xmm0
add    $0x40,%rsp
jmp    1523 <main+0x343>
lea    0x2aff(%rip),%rdi
call   1030 <puts@plt>
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0xfffffffe,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
xor    %r14d,%r14d
mov    $0x2,%eax
xor    %edx,%edx
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0x2,%eax
xor    %edx,%edx
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
lea    0x1(%rax),%ecx
cmp    $0x3,%ecx
cmovae %r14d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0xffffffff,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0xffffffff,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
lea    0x1(%rax),%ecx
cmp    $0x3,%ecx
cmovae %r14d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0xffffffff,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
lea    0x1(%rax),%ecx
cmp    $0x3,%ecx
cmovae %r14d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
lea    0x1(%rax),%ecx
cmp    $0x3,%ecx
cmovae %r14d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0xffffffff,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0xffffffff,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
lea    0x1(%rax),%ecx
cmp    $0x3,%ecx
cmovae %r14d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0xffffffff,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
lea    0x1(%rax),%ecx
cmp    $0x3,%ecx
cmovae %r14d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0xfffffffe,%eax
cltd
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0x2,%eax
xor    %edx,%edx
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    $0x2,%edi
call   10f0 <sqrt@plt>
mov    %eax,%ecx
mov    $0x2,%eax
xor    %edx,%edx
idiv   %ecx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    $0x6c,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    $0x6c,%edi
call   10b0 <malloc@plt>
mov    %rax,%r13
mov    $0x6c,%edi
call   10b0 <malloc@plt>
mov    %rax,%r12
mov    $0x6c,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    %rsp,-0x120(%rbp)
mov    %rsp,%rax
add    $0xffffffffffffffb0,%rax
mov    %rax,-0xa8(%rbp)
mov    %rax,%rsp
mov    %rsp,%rax
add    $0xffffffffffffffb0,%rax
mov    %rax,-0xa0(%rbp)
mov    %rax,%rsp
mov    $0x8,%ebx
mov    %r13,-0x48(%rbp)
mov    %r12,-0x70(%rbp)
nopl   0x0(%rax,%rax,1)
mov    %r14d,%edi
xor    %esi,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
lea    0x285a(%rip),%rdx
mov    -0x8(%rbx,%rdx,1),%ecx
mov    -0x4(%rbx,%rdx,1),%edx
mov    %edx,-0x30(%rbp)
mov    -0x78(%rbp),%rdx
mov    %ecx,(%rdx,%rax,4)
mov    %rdx,%r12
mov    %r14d,%edi
xor    %esi,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
lea    0x290f(%rip),%rdx
mov    -0x8(%rbx,%rdx,1),%ecx
mov    -0x4(%rbx,%rdx,1),%edx
mov    %edx,-0x38(%rbp)
mov    %ecx,0x0(%r13,%rax,4)
mov    %r14d,%edi
xor    %esi,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
lea    0x2879(%rip),%rdx
mov    -0x8(%rbx,%rdx,1),%ecx
mov    -0x4(%rbx,%rdx,1),%edx
mov    %edx,-0x40(%rbp)
mov    -0x70(%rbp),%rdx
mov    %ecx,(%rdx,%rax,4)
mov    %r14d,%edi
xor    %esi,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
lea    0x2931(%rip),%rdx
mov    -0x8(%rbx,%rdx,1),%ecx
mov    -0x4(%rbx,%rdx,1),%r15d
mov    -0x68(%rbp),%r13
mov    %ecx,0x0(%r13,%rax,4)
mov    %r14d,%edi
mov    $0x1,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
mov    -0x30(%rbp),%ecx
mov    %ecx,(%r12,%rax,4)
mov    %r14d,%edi
mov    $0x1,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
mov    -0x48(%rbp),%rcx
mov    -0x38(%rbp),%edx
mov    %edx,(%rcx,%rax,4)
mov    -0x70(%rbp),%r12
mov    %r14d,%edi
mov    $0x1,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
mov    -0x40(%rbp),%ecx
mov    %ecx,(%r12,%rax,4)
mov    %r14d,%edi
mov    $0x1,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
mov    %r15d,0x0(%r13,%rax,4)
mov    -0x48(%rbp),%r13
lea    0x275b(%rip),%rax
mov    (%rbx,%rax,1),%r15d
mov    %r14d,%edi
mov    $0x2,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
mov    -0x78(%rbp),%rcx
mov    %r15d,(%rcx,%rax,4)
lea    0x2816(%rip),%rax
mov    (%rbx,%rax,1),%r15d
mov    %r14d,%edi
mov    $0x2,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
mov    %r15d,0x0(%r13,%rax,4)
lea    0x2784(%rip),%rax
mov    (%rbx,%rax,1),%r15d
mov    %r14d,%edi
mov    $0x2,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
mov    %r15d,(%r12,%rax,4)
lea    0x2843(%rip),%rax
mov    (%rbx,%rax,1),%r15d
mov    %r14d,%edi
mov    $0x2,%esi
mov    $0x3,%edx
call   10e0 <index_2d@plt>
mov    -0x68(%rbp),%rcx
mov    %r15d,(%rcx,%rax,4)
movsd  -0x1c0(%rbp,%r14,8),%xmm0
fe ff ff
mov    -0xa8(%rbp),%rax
movsd  %xmm0,(%rax,%r14,8)
movsd  -0x170(%rbp,%r14,8),%xmm0
fe ff ff
mov    -0xa0(%rbp),%rax
movsd  %xmm0,(%rax,%r14,8)
add    $0x1,%r14
add    $0xc,%rbx
cmp    $0x9,%r14
jne    1a10 <main+0x830>
lea    0x2636(%rip),%rdi
call   1030 <puts@plt>
mov    $0xd8,%edi
call   10b0 <malloc@plt>
mov    %rax,-0xe8(%rbp)
mov    %rsp,%rax
add    $0xffffffffffffffd0,%rax
mov    %rax,-0xe0(%rbp)
mov    %rax,%rsp
xor    %r15d,%r15d
lea    0x2831(%rip),%rbx
xor    %esi,%esi
mov    -0xe8(%rbp),%r14
jmp    1c45 <main+0xa65>
xchg   %ax,%ax
add    $0x4,%r15
add    $0x18,%rbx
cmp    $0x90,%r15
je     1d1c <main+0xb3c>
mov    -0x14(%rbx),%r12d
mov    -0xc(%rbx),%r13d
cmp    %r13d,%r12d
jg     1c30 <main+0xa50>
mov    -0x8(%rbx),%ecx
mov    (%rbx),%eax
cmp    %eax,%ecx
jg     1c30 <main+0xa50>
mov    %esi,%edi
mov    %rsi,-0x30(%rbp)
xor    %esi,%esi
mov    $0x6,%edx
mov    %eax,-0x38(%rbp)
mov    %ecx,-0x40(%rbp)
call   10e0 <index_2d@plt>
mov    %r12d,(%r14,%rax,4)
mov    -0x10(%rbx),%r12d
mov    -0x30(%rbp),%rdi
mov    $0x1,%esi
mov    $0x6,%edx
call   10e0 <index_2d@plt>
mov    %r12d,(%r14,%rax,4)
mov    -0x30(%rbp),%rdi
mov    $0x2,%esi
mov    $0x6,%edx
call   10e0 <index_2d@plt>
mov    %r13d,(%r14,%rax,4)
mov    -0x30(%rbp),%rdi
mov    $0x3,%esi
mov    $0x6,%edx
call   10e0 <index_2d@plt>
mov    -0x40(%rbp),%ecx
mov    %ecx,(%r14,%rax,4)
mov    -0x4(%rbx),%r12d
mov    -0x30(%rbp),%rdi
mov    $0x4,%esi
mov    $0x6,%edx
call   10e0 <index_2d@plt>
mov    %r12d,(%r14,%rax,4)
mov    -0x30(%rbp),%rdi
mov    $0x5,%esi
mov    $0x6,%edx
call   10e0 <index_2d@plt>
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%ecx
mov    %ecx,(%r14,%rax,4)
lea    0x2a9d(%rip),%rax
mov    (%r15,%rax,1),%eax
movslq %esi,%rsi
mov    -0xe0(%rbp),%rcx
mov    %eax,(%rcx,%rsi,4)
add    $0x1,%esi
jmp    1c30 <main+0xa50>
lea    0x2317(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x2000,%edi
call   10b0 <malloc@plt>
mov    %rax,%r13
mov    $0x2000,%edi
call   10b0 <malloc@plt>
mov    %rax,%r12
mov    $0x2000,%edi
call   10b0 <malloc@plt>
mov    %rax,%r14
mov    $0x2000,%edi
call   10b0 <malloc@plt>
movabs $0x3ff0000000000000,%r15
mov    %rax,-0x38(%rbp)
nopl   0x0(%rax,%rax,1)
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,0x0(%r13,%rax,8)
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
movq   $0x0,(%r12,%rax,8)
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,(%r14,%rax,8)
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    -0x38(%rbp),%rcx
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    1d70 <main+0xb90>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,0x0(%r13,%rax,8)
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
movq   $0x0,(%r12,%rax,8)
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,(%r14,%rax,8)
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    -0x38(%rbp),%rcx
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    1de0 <main+0xc00>
xor    %ebx,%ebx
mov    %r13,-0x88(%rbp)
mov    -0x38(%rbp),%r13
nopl   0x0(%rax)
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    -0x88(%rbp),%rcx
mov    %r15,(%rcx,%rax,8)
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
movq   $0x0,(%r12,%rax,8)
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,(%r14,%rax,8)
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    -0x38(%rbp),%rcx
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    1e60 <main+0xc80>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    -0x88(%rbp),%rcx
mov    %r15,(%rcx,%rax,8)
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
movq   $0x0,(%r12,%rax,8)
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,(%r14,%rax,8)
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
movq   $0x0,0x0(%r13,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    1ee0 <main+0xd00>
mov    %r12,-0xd8(%rbp)
mov    %r14,-0x118(%rbp)
mov    $0x2000,%edi
call   10b0 <malloc@plt>
mov    %rax,%r13
mov    $0x2000,%edi
call   10b0 <malloc@plt>
mov    %rax,%r12
mov    $0x2000,%edi
call   10b0 <malloc@plt>
mov    %rax,%r14
mov    $0x2000,%edi
call   10b0 <malloc@plt>
xor    %ebx,%ebx
mov    %rax,-0x40(%rbp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,0x0(%r13,%rax,8)
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
movq   $0x0,(%r12,%rax,8)
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,(%r14,%rax,8)
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    -0x40(%rbp),%rcx
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    1fa0 <main+0xdc0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,0x0(%r13,%rax,8)
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
movq   $0x0,(%r12,%rax,8)
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,(%r14,%rax,8)
mov    %ebx,%edi
mov    $0x1,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    -0x40(%rbp),%rcx
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    2010 <main+0xe30>
xor    %ebx,%ebx
mov    %r13,-0x80(%rbp)
mov    -0x40(%rbp),%r13
cs nopw 0x0(%rax,%rax,1)
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    -0x80(%rbp),%rcx
mov    %r15,(%rcx,%rax,8)
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
movq   $0x0,(%r12,%rax,8)
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,(%r14,%rax,8)
mov    %ebx,%edi
mov    $0x2,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    -0x40(%rbp),%rcx
movq   $0x0,(%rcx,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    2090 <main+0xeb0>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    -0x80(%rbp),%rcx
mov    %r15,(%rcx,%rax,8)
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
movq   $0x0,(%r12,%rax,8)
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
mov    %r15,(%r14,%rax,8)
mov    %ebx,%edi
mov    $0x3,%esi
mov    $0x4,%edx
call   10e0 <index_2d@plt>
movq   $0x0,0x0(%r13,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    2110 <main+0xf30>
mov    %r14,-0x110(%rbp)
mov    %r12,-0xd0(%rbp)
mov    $0x800,%edi
call   10b0 <malloc@plt>
mov    %rax,%r14
mov    $0x800,%edi
call   10b0 <malloc@plt>
mov    %rax,%r12
mov    $0x800,%edi
call   10b0 <malloc@plt>
mov    %rax,%r13
mov    $0x800,%edi
call   10b0 <malloc@plt>
mov    %rax,-0xc8(%rbp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x1,%edx
call   10e0 <index_2d@plt>
mov    %r15,(%r14,%rax,8)
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x1,%edx
call   10e0 <index_2d@plt>
movq   $0x0,(%r12,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    21d0 <main+0xff0>
mov    %r12,-0x100(%rbp)
mov    %r14,-0x108(%rbp)
xor    %ebx,%ebx
mov    -0xc8(%rbp),%r14
nopw   0x0(%rax,%rax,1)
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x1,%edx
call   10e0 <index_2d@plt>
mov    %r15,0x0(%r13,%rax,8)
mov    %ebx,%edi
xor    %esi,%esi
mov    $0x1,%edx
call   10e0 <index_2d@plt>
movq   $0x0,(%r14,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    2220 <main+0x1040>
mov    %r13,-0xf8(%rbp)
mov    $0x200000,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    $0x200000,%edi
call   10b0 <malloc@plt>
xor    %r14d,%r14d
mov    -0x50(%rbp),%r12
nopw   0x0(%rax,%rax,1)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14d,%edi
mov    %ebx,%esi
xor    %edx,%edx
mov    $0x100,%ecx
mov    $0x4,%r8d
mov    %rax,%r13
call   1040 <index_3d@plt>
mov    %r15,(%r12,%rax,8)
mov    %r14d,%edi
mov    %ebx,%esi
xor    %edx,%edx
mov    $0x100,%ecx
mov    $0x4,%r8d
call   1040 <index_3d@plt>
movq   $0x0,0x0(%r13,%rax,8)
mov    %r13,%rax
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    2290 <main+0x10b0>
add    $0x1,%r14d
cmp    $0x100,%r14d
jne    2280 <main+0x10a0>
xor    %r14d,%r14d
mov    -0x50(%rbp),%r12
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    $0x100,%ecx
mov    $0x4,%r8d
call   1040 <index_3d@plt>
mov    %r15,(%r12,%rax,8)
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x1,%edx
mov    $0x100,%ecx
mov    $0x4,%r8d
call   1040 <index_3d@plt>
movq   $0x0,0x0(%r13,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    2300 <main+0x1120>
add    $0x1,%r14d
cmp    $0x100,%r14d
jne    22f0 <main+0x1110>
xor    %r14d,%r14d
mov    -0x50(%rbp),%r12
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x2,%edx
mov    $0x100,%ecx
mov    $0x4,%r8d
call   1040 <index_3d@plt>
mov    %r15,(%r12,%rax,8)
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x2,%edx
mov    $0x100,%ecx
mov    $0x4,%r8d
call   1040 <index_3d@plt>
movq   $0x0,0x0(%r13,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    2370 <main+0x1190>
add    $0x1,%r14d
cmp    $0x100,%r14d
jne    2360 <main+0x1180>
xor    %r14d,%r14d
mov    -0x50(%rbp),%r12
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x3,%edx
mov    $0x100,%ecx
mov    $0x4,%r8d
call   1040 <index_3d@plt>
mov    %r15,(%r12,%rax,8)
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x3,%edx
mov    $0x100,%ecx
mov    $0x4,%r8d
call   1040 <index_3d@plt>
movq   $0x0,0x0(%r13,%rax,8)
add    $0x1,%ebx
cmp    $0x100,%ebx
jne    23e0 <main+0x1200>
add    $0x1,%r14d
cmp    $0x100,%r14d
jne    23d0 <main+0x11f0>
lea    0x1df6(%rip),%rdi
call   1030 <puts@plt>
mov    $0x100,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x58(%rbp)
mov    $0x100,%edi
call   10b0 <malloc@plt>
mov    %rax,%r14
xor    %r12d,%r12d
mov    $0x1,%al
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,-0x30(%rbp)
xor    %ebx,%ebx
mov    -0x58(%rbp),%r15
nopl   0x0(%rax)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %ebx,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r15,%rax,8)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %ebx,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r14,%rax,8)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %ebx,%esi
mov    $0x1,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r15,%rax,8)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %ebx,%esi
mov    $0x1,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r14,%rax,8)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %ebx,%esi
mov    $0x2,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r15,%rax,8)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %ebx,%esi
mov    $0x2,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r14,%rax,8)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %ebx,%esi
mov    $0x3,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r15,%rax,8)
sub    $0x8,%rsp
mov    %r12d,%edi
mov    %ebx,%esi
mov    $0x3,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r14,%rax,8)
add    $0x1,%ebx
cmp    $0x4,%ebx
jne    2480 <main+0x12a0>
mov    $0x1,%r12d
xor    %r15d,%r15d
testb  $0x1,-0x30(%rbp)
mov    $0x0,%eax
jne    2470 <main+0x1290>
sub    $0x8,%rsp
mov    -0x58(%rbp),%rdi
mov    %r14,%rsi
mov    -0x98(%rbp),%rdx
mov    -0x90(%rbp),%rcx
mov    -0x78(%rbp),%r8
mov    -0x70(%rbp),%r9
push   $0x4
push   $0x4
push   $0x3
push   $0x9
push   $0x1
push   $0x100
push   $0x100
push   $0x2
push   $0x3
push   -0xd0(%rbp)
push   -0x80(%rbp)
push   -0xd8(%rbp)
push   -0x88(%rbp)
push   -0xa0(%rbp)
push   -0x68(%rbp)
push   -0x48(%rbp)
push   -0xa8(%rbp)
call   1070 <make_nucleon_2pt@plt>
add    $0x90,%rsp
lea    0x1bc1(%rip),%rdi
call   1030 <puts@plt>
mov    -0x58(%rbp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r15d,%esi
mov    %ebx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %r15d,%esi
mov    %ebx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  (%r14,%rax,8),%xmm1
lea    0x193a(%rip),%rdi
mov    %r15d,%esi
mov    %ebx,%edx
xor    %ecx,%ecx
movsd  -0x30(%rbp),%xmm0
mov    $0x2,%al
call   1050 <printf@plt>
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %r15d,%esi
mov    %ebx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %r15d,%esi
mov    %ebx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  (%r14,%rax,8),%xmm1
lea    0x18eb(%rip),%rdi
mov    %r15d,%esi
mov    %ebx,%edx
xor    %ecx,%ecx
movsd  -0x30(%rbp),%xmm0
mov    $0x2,%al
call   1050 <printf@plt>
add    $0x1,%ebx
cmp    $0x4,%ebx
jne    26b0 <main+0x14d0>
add    $0x1,%r15d
cmp    $0x4,%r15d
jne    26a0 <main+0x14c0>
mov    $0x320,%edi
call   10b0 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    $0x320,%edi
call   10b0 <malloc@plt>
mov    %rax,-0xb0(%rbp)
xor    %r14d,%r14d
mov    -0x60(%rbp),%r15
mov    -0xb0(%rbp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    %ebx,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r15,%rax,8)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    %ebx,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r12,%rax,8)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x1,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r15,%rax,8)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x1,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r12,%rax,8)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x2,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r15,%rax,8)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x2,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r12,%rax,8)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x3,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r15,%rax,8)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x3,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r12,%rax,8)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x4,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r15,%rax,8)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    %ebx,%esi
mov    $0x4,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movq   $0x0,(%r12,%rax,8)
add    $0x1,%ebx
cmp    $0x5,%ebx
jne    2800 <main+0x1620>
add    $0x1,%r14d
cmp    $0x4,%r14d
jne    27f0 <main+0x1610>
lea    0x1865(%rip),%rdi
call   1030 <puts@plt>
mov    -0x60(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0x98(%rbp),%rdx
mov    -0x90(%rbp),%rcx
mov    -0xb8(%rbp),%r8
mov    -0xf0(%rbp),%r9
push   $0x9
push   $0x1
push   $0x1
push   $0x4
push   $0x4
push   $0x3
push   $0x9
push   $0x1
push   $0x100
push   $0x100
push   $0x2
push   $0x3
push   $0x0
push   $0x0
push   -0xc8(%rbp)
push   -0xf8(%rbp)
push   -0x100(%rbp)
push   -0x108(%rbp)
push   -0x40(%rbp)
push   -0x110(%rbp)
push   -0xd0(%rbp)
push   -0x80(%rbp)
push   %r13
push   -0x50(%rbp)
push   -0x38(%rbp)
push   -0x118(%rbp)
push   -0xd8(%rbp)
push   -0x88(%rbp)
push   -0xe0(%rbp)
push   -0xe8(%rbp)
push   -0xa0(%rbp)
push   -0x68(%rbp)
push   -0x48(%rbp)
push   -0xa8(%rbp)
push   -0x70(%rbp)
push   -0x78(%rbp)
call   1100 <make_two_nucleon_2pt@plt>
add    $0x120,%rsp
lea    0x17a6(%rip),%rdi
call   1030 <puts@plt>
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,%r14
xor    %ebx,%ebx
xor    %edi,%edi
xor    %esi,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
xor    %edi,%edi
mov    $0x1,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
xor    %edi,%edi
mov    $0x2,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
xor    %edi,%edi
mov    $0x3,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x1,%edi
xor    %esi,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x1,%edi
mov    $0x1,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x1,%edi
mov    $0x2,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x2,%edi
xor    %esi,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x2,%edi
mov    $0x1,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x2,%edi
mov    $0x2,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x2,%edi
mov    $0x3,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x3,%edi
xor    %esi,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x3,%edi
mov    $0x1,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x3,%edi
mov    $0x2,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x3,%edi
mov    $0x3,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x4,%edi
xor    %esi,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x4,%edi
mov    $0x1,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x4,%edi
mov    $0x2,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x4,%edi
mov    $0x3,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
xor    %edi,%edi
mov    $0x4,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x1,%edi
mov    $0x4,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x2,%edi
mov    $0x4,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x3,%edi
mov    $0x4,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    $0x4,%edi
mov    $0x4,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
movl   $0x1,(%r14,%rax,4)
mov    -0x60(%rbp),%r13
mov    -0xb0(%rbp),%r15
nopw   0x0(%rax,%rax,1)
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  (%r15,%rax,8),%xmm1
lea    0x12ad(%rip),%rdi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
movsd  -0x30(%rbp),%xmm0
mov    $0x2,%al
call   1050 <printf@plt>
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  (%r15,%rax,8),%xmm1
lea    0x125a(%rip),%rdi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
movsd  -0x30(%rbp),%xmm0
mov    $0x2,%al
call   1050 <printf@plt>
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  (%r15,%rax,8),%xmm1
lea    0x120a(%rip),%rdi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
movsd  -0x30(%rbp),%xmm0
mov    $0x2,%al
call   1050 <printf@plt>
sub    $0x8,%rsp
mov    $0x3,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
mov    $0x3,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  (%r15,%rax,8),%xmm1
lea    0x11ba(%rip),%rdi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
movsd  -0x30(%rbp),%xmm0
mov    $0x2,%al
call   1050 <printf@plt>
add    $0x1,%r12d
cmp    $0x5,%r12d
jne    2d90 <main+0x1bb0>
add    $0x1,%ebx
cmp    $0x5,%ebx
jne    2d80 <main+0x1ba0>
lea    0x12d9(%rip),%rdi
call   1030 <puts@plt>
xor    %ebx,%ebx
mov    -0x58(%rbp),%r13
mov    -0x60(%rbp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebx,%edi
mov    %r12d,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
xorps  %xmm0,%xmm0
cvtsi2sdl (%r14,%rax,4),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
xor    %edi,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  -0x30(%rbp),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
sub    $0x8,%rsp
mov    $0x1,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  -0x38(%rbp),%xmm1
mulsd  0x0(%r13,%rax,8),%xmm1
movsd  -0x30(%rbp),%xmm0
divsd  %xmm1,%xmm0
lea    0x10c1(%rip),%rdi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
mov    %ebx,%edi
mov    %r12d,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
xorps  %xmm0,%xmm0
cvtsi2sdl (%r14,%rax,4),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
mov    $0x1,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  -0x30(%rbp),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
sub    $0x8,%rsp
mov    $0x1,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  -0x38(%rbp),%xmm1
mulsd  0x0(%r13,%rax,8),%xmm1
movsd  -0x30(%rbp),%xmm0
divsd  %xmm1,%xmm0
lea    0x100b(%rip),%rdi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
mov    %ebx,%edi
mov    %r12d,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
xorps  %xmm0,%xmm0
cvtsi2sdl (%r14,%rax,4),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
mov    $0x2,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  -0x30(%rbp),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
sub    $0x8,%rsp
mov    $0x1,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  -0x38(%rbp),%xmm1
mulsd  0x0(%r13,%rax,8),%xmm1
movsd  -0x30(%rbp),%xmm0
divsd  %xmm1,%xmm0
lea    0xf58(%rip),%rdi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
mov    %ebx,%edi
mov    %r12d,%esi
mov    $0x5,%edx
call   10e0 <index_2d@plt>
xorps  %xmm0,%xmm0
cvtsi2sdl (%r14,%rax,4),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
mov    $0x3,%edi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x5,%r8d
mov    $0x5,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  -0x30(%rbp),%xmm0
mulsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
sub    $0x8,%rsp
xor    %edi,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
sub    $0x8,%rsp
mov    $0x1,%edi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
mov    $0x4,%r8d
mov    $0x4,%r9d
push   $0x1
call   10a0 <index_4d@plt>
add    $0x10,%rsp
movsd  -0x38(%rbp),%xmm1
mulsd  0x0(%r13,%rax,8),%xmm1
movsd  -0x30(%rbp),%xmm0
divsd  %xmm1,%xmm0
lea    0xea5(%rip),%rdi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %ecx,%ecx
mov    $0x1,%al
call   1050 <printf@plt>
add    $0x1,%r12d
cmp    $0x5,%r12d
jne    2fc0 <main+0x1de0>
add    $0x1,%ebx
cmp    $0x5,%ebx
jne    2fb0 <main+0x1dd0>
lea    -0xbc(%rbp),%rdi
call   1090 <time@plt>
mov    -0xbc(%rbp),%edi
mov    -0xc0(%rbp),%esi
call   1060 <difftime@plt>
lea    0xe79(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0x120(%rbp),%rsp
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str.2 = [22 x i8] c"\09Max index size = %d \00"
@.str.3 = [30 x i8] c"\09Array size = %lu Mega bytes\0A\00"
@.str.7 = [6 x i8] c"%lu \0A\00"
@M_PI = global i32 0
@__const.main.B1_G1g_r1_color_weights = [9 x [3 x i32]] [[3 x i32] [i32 0, i32 1, i32 2], [3 x i32] [i32 0, i32 2, i32 1], [3 x i32] [i32 1, i32 0, i32 2], [3 x i32] [i32 0, i32 1, i32 2], [3 x i32] [i32 0, i32 2, i32 1], [3 x i32] [i32 1, i32 0, i32 2], [3 x i32] [i32 1, i32 2, i32 0], [3 x i32] [i32 2, i32 1, i32 0], [3 x i32] [i32 2, i32 0, i32 1]]
@__const.main.B1_G1g_r1_spin_weights = [9 x [3 x i32]] [[3 x i32] [i32 0, i32 1, i32 0], [3 x i32] [i32 0, i32 1, i32 0], [3 x i32] [i32 0, i32 1, i32 0], [3 x i32] [i32 1, i32 0, i32 0], [3 x i32] [i32 1, i32 0, i32 0], [3 x i32] [i32 1, i32 0, i32 0], [3 x i32] [i32 1, i32 0, i32 0], [3 x i32] [i32 1, i32 0, i32 0], [3 x i32] [i32 1, i32 0, i32 0]]
@__const.main.B1_G1g_r2_color_weights = [9 x [3 x i32]] [[3 x i32] [i32 0, i32 1, i32 2], [3 x i32] [i32 0, i32 2, i32 1], [3 x i32] [i32 1, i32 0, i32 2], [3 x i32] [i32 1, i32 2, i32 0], [3 x i32] [i32 2, i32 1, i32 0], [3 x i32] [i32 2, i32 0, i32 1], [3 x i32] [i32 0, i32 1, i32 2], [3 x i32] [i32 0, i32 2, i32 1], [3 x i32] [i32 1, i32 0, i32 2]]
@__const.main.B1_G1g_r2_spin_weights = [9 x [3 x i32]] [[3 x i32] [i32 0, i32 1, i32 1], [3 x i32] [i32 0, i32 1, i32 1], [3 x i32] [i32 0, i32 1, i32 1], [3 x i32] [i32 0, i32 1, i32 1], [3 x i32] [i32 0, i32 1, i32 1], [3 x i32] [i32 0, i32 1, i32 1], [3 x i32] [i32 1, i32 0, i32 1], [3 x i32] [i32 1, i32 0, i32 1], [3 x i32] [i32 1, i32 0, i32 1]]
@__const.main.perms_array = [36 x [6 x i32]] [[6 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5, i32 6], [6 x i32] [i32 1, i32 4, i32 3, i32 2, i32 5, i32 6], [6 x i32] [i32 1, i32 6, i32 3, i32 2, i32 5, i32 4], [6 x i32] [i32 1, i32 2, i32 3, i32 6, i32 5, i32 4], [6 x i32] [i32 1, i32 4, i32 3, i32 6, i32 5, i32 2], [6 x i32] [i32 1, i32 6, i32 3, i32 4, i32 5, i32 2], [6 x i32] [i32 3, i32 2, i32 1, i32 4, i32 5, i32 6], [6 x i32] [i32 3, i32 4, i32 1, i32 2, i32 5, i32 6], [6 x i32] [i32 3, i32 6, i32 1, i32 2, i32 5, i32 4], [6 x i32] [i32 3, i32 2, i32 1, i32 6, i32 5, i32 4], [6 x i32] [i32 3, i32 4, i32 1, i32 6, i32 5, i32 2], [6 x i32] [i32 3, i32 6, i32 1, i32 4, i32 5, i32 2], [6 x i32] [i32 5, i32 2, i32 1, i32 4, i32 3, i32 6], [6 x i32] [i32 5, i32 4, i32 1, i32 2, i32 3, i32 6], [6 x i32] [i32 5, i32 6, i32 1, i32 2, i32 3, i32 4], [6 x i32] [i32 5, i32 2, i32 1, i32 6, i32 3, i32 4], [6 x i32] [i32 5, i32 4, i32 1, i32 6, i32 3, i32 2], [6 x i32] [i32 5, i32 6, i32 1, i32 4, i32 3, i32 2], [6 x i32] [i32 1, i32 2, i32 5, i32 4, i32 3, i32 6], [6 x i32] [i32 1, i32 4, i32 5, i32 2, i32 3, i32 6], [6 x i32] [i32 1, i32 6, i32 5, i32 2, i32 3, i32 4], [6 x i32] [i32 1, i32 2, i32 5, i32 6, i32 3, i32 4], [6 x i32] [i32 1, i32 4, i32 5, i32 6, i32 3, i32 2], [6 x i32] [i32 1, i32 6, i32 5, i32 4, i32 3, i32 2], [6 x i32] [i32 3, i32 2, i32 5, i32 4, i32 1, i32 6], [6 x i32] [i32 3, i32 4, i32 5, i32 2, i32 1, i32 6], [6 x i32] [i32 3, i32 6, i32 5, i32 2, i32 1, i32 4], [6 x i32] [i32 3, i32 2, i32 5, i32 6, i32 1, i32 4], [6 x i32] [i32 3, i32 4, i32 5, i32 6, i32 1, i32 2], [6 x i32] [i32 3, i32 6, i32 5, i32 4, i32 1, i32 2], [6 x i32] [i32 5, i32 2, i32 3, i32 4, i32 1, i32 6], [6 x i32] [i32 5, i32 4, i32 3, i32 2, i32 1, i32 6], [6 x i32] [i32 5, i32 6, i32 3, i32 2, i32 1, i32 4], [6 x i32] [i32 5, i32 2, i32 3, i32 6, i32 1, i32 4], [6 x i32] [i32 5, i32 4, i32 3, i32 6, i32 1, i32 2], [6 x i32] [i32 5, i32 6, i32 3, i32 4, i32 1, i32 2]]
@__const.main.sigs_array = [36 x i32] [i32 1, i32 -1, i32 1, i32 -1, i32 1, i32 -1, i32 -1, i32 1, i32 -1, i32 1, i32 -1, i32 1, i32 1, i32 -1, i32 1, i32 -1, i32 1, i32 -1, i32 -1, i32 1, i32 -1, i32 1, i32 -1, i32 1, i32 1, i32 -1, i32 1, i32 -1, i32 1, i32 -1, i32 -1, i32 1, i32 -1, i32 1, i32 -1, i32 1]
@.str.11 = [16 x i8] c"read %d perms \0A\00"
@.str.14 = [42 x i8] c"C_B1_G1g_r1[%d,%d,%d] = %4.9f + (%4.9f)I\0A\00"
@.str.15 = [42 x i8] c"C_B1_G1g_r2[%d,%d,%d] = %4.9f + (%4.9f)I\0A\00"
@.str.18 = [39 x i8] c"C_B2_A1g[%d,%d,%d] = %4.9f + (%4.9f)I\0A\00"
@.str.19 = [42 x i8] c"C_B2_T1g_r1[%d,%d,%d] = %4.9f + (%4.9f)I\0A\00"
@.str.20 = [42 x i8] c"C_B2_T1g_r2[%d,%d,%d] = %4.9f + (%4.9f)I\0A\00"
@.str.21 = [42 x i8] c"C_B2_T1g_r3[%d,%d,%d] = %4.9f + (%4.9f)I\0A\00"
@.str.23 = [29 x i8] c"R_B2_A1g[%d,%d,%d] = %4.9f \0A\00"
@.str.24 = [32 x i8] c"R_B2_T1g_r1[%d,%d,%d] = %4.9f \0A\00"
@.str.25 = [32 x i8] c"R_B2_T1g_r2[%d,%d,%d] = %4.9f \0A\00"
@.str.26 = [32 x i8] c"R_B2_T1g_r3[%d,%d,%d] = %4.9f \0A\00"
@.str.27 = [18 x i8] c"total time %5.3f\0A\00"
@str = [12 x i8] c"Array sizes\00"
@str.28 = [6 x i8] c"Prop:\00"
@str.29 = [8 x i8] c"Blocal:\00"
@str.30 = [10 x i8] c"Q, O & P:\00"
@str.31 = [18 x i8] c"Bsingle, Bdouble:\00"
@str.32 = [20 x i8] c"starting block main\00"
@str.33 = [12 x i8] c"built props\00"
@str.34 = [14 x i8] c"built weights\00"
@str.35 = [20 x i8] c"built wavefunctions\00"
@str.36 = [12 x i8] c"B=1 results\00"
@str.37 = [10 x i8] c"starting \00"
@str.38 = [12 x i8] c"B=2 results\00"
@str.39 = [11 x i8] c"B=2 ratios\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca [9 x double]
%4 = alloca [9 x double]
%5 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str, i64 0, i64 0))
%6 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @str.28, i64 0, i64 0))
%7 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0), i32 7077888)
%8 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), i64 54)
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.29, i64 0, i64 0))
%10 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0), i32 221184)
%11 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), i64 1)
%12 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.30, i64 0, i64 0))
%13 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0), i32 14155776)
%14 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), i64 108)
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.31, i64 0, i64 0))
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0), i32 216)
%17 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), i64 0)
%18 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i64 -1)
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str.32, i64 0, i64 0))
%20 = bitcast i32* %1 to i8*
%21 = bitcast i32* %2 to i8*
%22 = call i32 @time(i32* %1)
%23 = call dereferenceable_or_null(56623104) i8* @malloc(i32 56623104)
%24 = bitcast i8* %23 to double*
%25 = call dereferenceable_or_null(56623104) i8* @malloc(i32 56623104)
%26 = bitcast i8* %25 to double*
%27 = call dereferenceable_or_null(56623104) i8* @malloc(i32 56623104)
%28 = bitcast i8* %27 to double*
%29 = call dereferenceable_or_null(56623104) i8* @malloc(i32 56623104)
%30 = bitcast i8* %29 to double*
br label %31
31: ; preds = %0, %99
%32 = phi i32 [ 0, %0 ], [ %100, %99 ]
br label %33
33: ; preds = %31, %96
%34 = phi i32 [ 0, %31 ], [ %97, %96 ]
br label %35
35: ; preds = %33, %95
%36 = phi i1 [ true, %33 ], [ false, %95 ]
%37 = phi i32 [ 0, %33 ], [ 1, %95 ]
br label %38
38: ; preds = %35, %92
%39 = phi i32 [ 0, %35 ], [ %93, %92 ]
%40 = icmp eq i32 %39, %34
br label %41
41: ; preds = %38, %91
%42 = phi i1 [ true, %38 ], [ false, %91 ]
%43 = phi i32 [ 0, %38 ], [ 1, %91 ]
%44 = icmp eq i32 %43, %37
%45 = and i1 %40, %44
br label %46
46: ; preds = %41, %88
%47 = phi i32 [ 0, %41 ], [ %89, %88 ]
br label %48
48: ; preds = %46, %82
%49 = phi i32 [ 0, %46 ], [ %86, %82 ]
br i1 %45, label %50, label %74
50: ; preds = %48
%51 = load i32, i32* @M_PI
%52 = sdiv i32 %51, 3
%53 = call i32 @cos(i32 %52)
%54 = sitofp i32 %53 to double
%55 = call i64 @prop_index(i32 %32, i32 0, i32 %34, i32 %37, i32 %34, i32 %37, i32 %47, i32 %49, i32 3, i32 2, i32 256, i32 256, i32 1)
%56 = getelementptr inbounds double, double* %24, i64 %55
store double %54, double* %56
%57 = load i32, i32* @M_PI
%58 = sdiv i32 %57, 3
%59 = call i32 @cos(i32 %58)
%60 = sitofp i32 %59 to double
%61 = call i64 @prop_index(i32 %32, i32 0, i32 %34, i32 %37, i32 %34, i32 %37, i32 %47, i32 %49, i32 3, i32 2, i32 256, i32 256, i32 1)
%62 = getelementptr inbounds double, double* %28, i64 %61
store double %60, double* %62
%63 = load i32, i32* @M_PI
%64 = sdiv i32 %63, 3
%65 = call i32 @sin(i32 %64)
%66 = sitofp i32 %65 to double
%67 = call i64 @prop_index(i32 %32, i32 0, i32 %34, i32 %37, i32 %34, i32 %37, i32 %47, i32 %49, i32 3, i32 2, i32 256, i32 256, i32 1)
%68 = getelementptr inbounds double, double* %26, i64 %67
store double %66, double* %68
%69 = load i32, i32* @M_PI
%70 = sdiv i32 %69, 3
%71 = call i32 @sin(i32 %70)
%72 = sitofp i32 %71 to double
%73 = call i64 @prop_index(i32 %32, i32 0, i32 %34, i32 %37, i32 %34, i32 %37, i32 %47, i32 %49, i32 3, i32 2, i32 256, i32 256, i32 1)
br label %82
74: ; preds = %48
%75 = call i64 @prop_index(i32 %32, i32 0, i32 %39, i32 %43, i32 %34, i32 %37, i32 %47, i32 %49, i32 3, i32 2, i32 256, i32 256, i32 1)
%76 = getelementptr inbounds double, double* %24, i64 %75
store double 0.000000e+00, double* %76
%77 = call i64 @prop_index(i32 %32, i32 0, i32 %39, i32 %43, i32 %34, i32 %37, i32 %47, i32 %49, i32 3, i32 2, i32 256, i32 256, i32 1)
%78 = getelementptr inbounds double, double* %28, i64 %77
store double 0.000000e+00, double* %78
%79 = call i64 @prop_index(i32 %32, i32 0, i32 %39, i32 %43, i32 %34, i32 %37, i32 %47, i32 %49, i32 3, i32 2, i32 256, i32 256, i32 1)
%80 = getelementptr inbounds double, double* %26, i64 %79
store double 0.000000e+00, double* %80
%81 = call i64 @prop_index(i32 %32, i32 0, i32 %39, i32 %43, i32 %34, i32 %37, i32 %47, i32 %49, i32 3, i32 2, i32 256, i32 256, i32 1)
br label %82
82: ; preds = %50, %74
%83 = phi i64 [ %73, %50 ], [ %81, %74 ]
%84 = phi double [ %72, %50 ], [ 0.000000e+00, %74 ]
%85 = getelementptr inbounds double, double* %30, i64 %83
store double %84, double* %85
%86 = add nuw nsw i32 %49, 1
%87 = icmp eq i32 %86, 256
br i1 %87, label %88, label %48
88: ; preds = %82
%89 = add nuw nsw i32 %47, 1
%90 = icmp eq i32 %89, 256
br i1 %90, label %91, label %46
91: ; preds = %88
br i1 %42, label %41, label %92
92: ; preds = %91
%93 = add nuw nsw i32 %39, 1
%94 = icmp eq i32 %93, 3
br i1 %94, label %95, label %38
95: ; preds = %92
br i1 %36, label %35, label %96
96: ; preds = %95
%97 = add nuw nsw i32 %34, 1
%98 = icmp eq i32 %97, 3
br i1 %98, label %99, label %33
99: ; preds = %96
%100 = add nuw nsw i32 %32, 1
%101 = icmp eq i32 %100, 3
br i1 %101, label %102, label %31
102: ; preds = %99
%103 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.33, i64 0, i64 0))
%104 = bitcast [9 x double]* %3 to i8*
%105 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 0
%106 = call i32 @sqrt(i32 2)
%107 = sdiv i32 -2, %106
%108 = sitofp i32 %107 to double
store double %108, double* %105
%109 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 1
%110 = call i32 @sqrt(i32 2)
%111 = sdiv i32 2, %110
%112 = sitofp i32 %111 to double
store double %112, double* %109
%113 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 2
%114 = call i32 @sqrt(i32 2)
%115 = sdiv i32 2, %114
%116 = sitofp i32 %115 to double
store double %116, double* %113
%117 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 3
%118 = call i32 @sqrt(i32 2)
%119 = add i32 %118, 1
%120 = icmp ult i32 %119, 3
%121 = select i1 %120, i32 %118, i32 0
%122 = sitofp i32 %121 to double
store double %122, double* %117
%123 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 4
%124 = call i32 @sqrt(i32 2)
%125 = sdiv i32 -1, %124
%126 = sitofp i32 %125 to double
store double %126, double* %123
%127 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 5
%128 = call i32 @sqrt(i32 2)
%129 = sdiv i32 -1, %128
%130 = sitofp i32 %129 to double
store double %130, double* %127
%131 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 6
%132 = call i32 @sqrt(i32 2)
%133 = add i32 %132, 1
%134 = icmp ult i32 %133, 3
%135 = select i1 %134, i32 %132, i32 0
%136 = sitofp i32 %135 to double
store double %136, double* %131
%137 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 7
%138 = call i32 @sqrt(i32 2)
%139 = sdiv i32 -1, %138
%140 = sitofp i32 %139 to double
store double %140, double* %137
%141 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 8
%142 = call i32 @sqrt(i32 2)
%143 = add i32 %142, 1
%144 = icmp ult i32 %143, 3
%145 = select i1 %144, i32 %142, i32 0
%146 = sitofp i32 %145 to double
store double %146, double* %141
%147 = bitcast [9 x double]* %4 to i8*
%148 = getelementptr inbounds [9 x double], [9 x double]* %4, i64 0, i64 0
%149 = call i32 @sqrt(i32 2)
%150 = add i32 %149, 1
%151 = icmp ult i32 %150, 3
%152 = select i1 %151, i32 %149, i32 0
%153 = sitofp i32 %152 to double
store double %153, double* %148
%154 = getelementptr inbounds [9 x double], [9 x double]* %4, i64 0, i64 1
%155 = call i32 @sqrt(i32 2)
%156 = sdiv i32 -1, %155
%157 = sitofp i32 %156 to double
store double %157, double* %154
%158 = getelementptr inbounds [9 x double], [9 x double]* %4, i64 0, i64 2
%159 = call i32 @sqrt(i32 2)
%160 = sdiv i32 -1, %159
%161 = sitofp i32 %160 to double
store double %161, double* %158
%162 = getelementptr inbounds [9 x double], [9 x double]* %4, i64 0, i64 3
%163 = call i32 @sqrt(i32 2)
%164 = add i32 %163, 1
%165 = icmp ult i32 %164, 3
%166 = select i1 %165, i32 %163, i32 0
%167 = sitofp i32 %166 to double
store double %167, double* %162
%168 = getelementptr inbounds [9 x double], [9 x double]* %4, i64 0, i64 4
%169 = call i32 @sqrt(i32 2)
%170 = sdiv i32 -1, %169
%171 = sitofp i32 %170 to double
store double %171, double* %168
%172 = getelementptr inbounds [9 x double], [9 x double]* %4, i64 0, i64 5
%173 = call i32 @sqrt(i32 2)
%174 = add i32 %173, 1
%175 = icmp ult i32 %174, 3
%176 = select i1 %175, i32 %173, i32 0
%177 = sitofp i32 %176 to double
store double %177, double* %172
%178 = getelementptr inbounds [9 x double], [9 x double]* %4, i64 0, i64 6
%179 = call i32 @sqrt(i32 2)
%180 = sdiv i32 -2, %179
%181 = sitofp i32 %180 to double
store double %181, double* %178
%182 = getelementptr inbounds [9 x double], [9 x double]* %4, i64 0, i64 7
%183 = call i32 @sqrt(i32 2)
%184 = sdiv i32 2, %183
%185 = sitofp i32 %184 to double
store double %185, double* %182
%186 = getelementptr inbounds [9 x double], [9 x double]* %4, i64 0, i64 8
%187 = call i32 @sqrt(i32 2)
%188 = sdiv i32 2, %187
%189 = sitofp i32 %188 to double
store double %189, double* %186
%190 = call dereferenceable_or_null(108) i8* @malloc(i32 108)
%191 = bitcast i8* %190 to i32*
%192 = call dereferenceable_or_null(108) i8* @malloc(i32 108)
%193 = bitcast i8* %192 to i32*
%194 = call dereferenceable_or_null(108) i8* @malloc(i32 108)
%195 = bitcast i8* %194 to i32*
%196 = call dereferenceable_or_null(108) i8* @malloc(i32 108)
%197 = bitcast i8* %196 to i32*
%198 = call i8* @llvm.stacksave()
%199 = alloca [9 x double]
%200 = alloca [9 x double]
%201 = getelementptr inbounds [9 x double], [9 x double]* %200, i64 0, i64 0
br label %202
202: ; preds = %102, %202
%203 = phi i64 [ 0, %102 ], [ %259, %202 ]
%204 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r1_color_weights, i64 0, i64 %203, i64 0
%205 = load i32, i32* %204
%206 = trunc i64 %203 to i32
%207 = call i64 @index_2d(i32 %206, i32 0, i32 3)
%208 = getelementptr inbounds i32, i32* %191, i64 %207
store i32 %205, i32* %208
%209 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r2_color_weights, i64 0, i64 %203, i64 0
%210 = load i32, i32* %209
%211 = call i64 @index_2d(i32 %206, i32 0, i32 3)
%212 = getelementptr inbounds i32, i32* %193, i64 %211
store i32 %210, i32* %212
%213 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r1_spin_weights, i64 0, i64 %203, i64 0
%214 = load i32, i32* %213
%215 = call i64 @index_2d(i32 %206, i32 0, i32 3)
%216 = getelementptr inbounds i32, i32* %195, i64 %215
store i32 %214, i32* %216
%217 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r2_spin_weights, i64 0, i64 %203, i64 0
%218 = load i32, i32* %217
%219 = call i64 @index_2d(i32 %206, i32 0, i32 3)
%220 = getelementptr inbounds i32, i32* %197, i64 %219
store i32 %218, i32* %220
%221 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r1_color_weights, i64 0, i64 %203, i64 1
%222 = load i32, i32* %221
%223 = call i64 @index_2d(i32 %206, i32 1, i32 3)
%224 = getelementptr inbounds i32, i32* %191, i64 %223
store i32 %222, i32* %224
%225 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r2_color_weights, i64 0, i64 %203, i64 1
%226 = load i32, i32* %225
%227 = call i64 @index_2d(i32 %206, i32 1, i32 3)
%228 = getelementptr inbounds i32, i32* %193, i64 %227
store i32 %226, i32* %228
%229 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r1_spin_weights, i64 0, i64 %203, i64 1
%230 = load i32, i32* %229
%231 = call i64 @index_2d(i32 %206, i32 1, i32 3)
%232 = getelementptr inbounds i32, i32* %195, i64 %231
store i32 %230, i32* %232
%233 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r2_spin_weights, i64 0, i64 %203, i64 1
%234 = load i32, i32* %233
%235 = call i64 @index_2d(i32 %206, i32 1, i32 3)
%236 = getelementptr inbounds i32, i32* %197, i64 %235
store i32 %234, i32* %236
%237 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r1_color_weights, i64 0, i64 %203, i64 2
%238 = load i32, i32* %237
%239 = call i64 @index_2d(i32 %206, i32 2, i32 3)
%240 = getelementptr inbounds i32, i32* %191, i64 %239
store i32 %238, i32* %240
%241 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r2_color_weights, i64 0, i64 %203, i64 2
%242 = load i32, i32* %241
%243 = call i64 @index_2d(i32 %206, i32 2, i32 3)
%244 = getelementptr inbounds i32, i32* %193, i64 %243
store i32 %242, i32* %244
%245 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r1_spin_weights, i64 0, i64 %203, i64 2
%246 = load i32, i32* %245
%247 = call i64 @index_2d(i32 %206, i32 2, i32 3)
%248 = getelementptr inbounds i32, i32* %195, i64 %247
store i32 %246, i32* %248
%249 = getelementptr inbounds [9 x [3 x i32]], [9 x [3 x i32]]* @__const.main.B1_G1g_r2_spin_weights, i64 0, i64 %203, i64 2
%250 = load i32, i32* %249
%251 = call i64 @index_2d(i32 %206, i32 2, i32 3)
%252 = getelementptr inbounds i32, i32* %197, i64 %251
store i32 %250, i32* %252
%253 = getelementptr inbounds [9 x double], [9 x double]* %3, i64 0, i64 %203
%254 = load double, double* %253
%255 = getelementptr inbounds [9 x double], [9 x double]* %199, i64 0, i64 %203
store double %254, double* %255
%256 = getelementptr inbounds [9 x double], [9 x double]* %4, i64 0, i64 %203
%257 = load double, double* %256
%258 = getelementptr inbounds [9 x double], [9 x double]* %200, i64 0, i64 %203
store double %257, double* %258
%259 = add nuw nsw i64 %203, 1
%260 = icmp eq i64 %259, 9
br i1 %260, label %261, label %202
261: ; preds = %202
%262 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @str.34, i64 0, i64 0))
%263 = call dereferenceable_or_null(216) i8* @malloc(i32 216)
%264 = bitcast i8* %263 to i32*
%265 = alloca [9 x i32]
br label %266
266: ; preds = %261, %302
%267 = phi i64 [ 0, %261 ], [ %304, %302 ]
%268 = phi i32 [ 0, %261 ], [ %303, %302 ]
%269 = getelementptr inbounds [36 x [6 x i32]], [36 x [6 x i32]]* @__const.main.perms_array, i64 0, i64 %267, i64 0
%270 = load i32, i32* %269
%271 = getelementptr inbounds [36 x [6 x i32]], [36 x [6 x i32]]* @__const.main.perms_array, i64 0, i64 %267, i64 2
%272 = load i32, i32* %271
%273 = icmp sgt i32 %270, %272
br i1 %273, label %302, label %274
274: ; preds = %266
%275 = getelementptr inbounds [36 x [6 x i32]], [36 x [6 x i32]]* @__const.main.perms_array, i64 0, i64 %267, i64 3
%276 = load i32, i32* %275
%277 = getelementptr inbounds [36 x [6 x i32]], [36 x [6 x i32]]* @__const.main.perms_array, i64 0, i64 %267, i64 5
%278 = load i32, i32* %277
%279 = icmp sgt i32 %276, %278
br i1 %279, label %302, label %280
280: ; preds = %274
%281 = call i64 @index_2d(i32 %268, i32 0, i32 6)
%282 = getelementptr inbounds i32, i32* %264, i64 %281
store i32 %270, i32* %282
%283 = getelementptr inbounds [36 x [6 x i32]], [36 x [6 x i32]]* @__const.main.perms_array, i64 0, i64 %267, i64 1
%284 = load i32, i32* %283
%285 = call i64 @index_2d(i32 %268, i32 1, i32 6)
%286 = getelementptr inbounds i32, i32* %264, i64 %285
store i32 %284, i32* %286
%287 = call i64 @index_2d(i32 %268, i32 2, i32 6)
%288 = getelementptr inbounds i32, i32* %264, i64 %287
store i32 %272, i32* %288
%289 = call i64 @index_2d(i32 %268, i32 3, i32 6)
%290 = getelementptr inbounds i32, i32* %264, i64 %289
store i32 %276, i32* %290
%291 = getelementptr inbounds [36 x [6 x i32]], [36 x [6 x i32]]* @__const.main.perms_array, i64 0, i64 %267, i64 4
%292 = load i32, i32* %291
%293 = call i64 @index_2d(i32 %268, i32 4, i32 6)
%294 = getelementptr inbounds i32, i32* %264, i64 %293
store i32 %292, i32* %294
%295 = call i64 @index_2d(i32 %268, i32 5, i32 6)
%296 = getelementptr inbounds i32, i32* %264, i64 %295
store i32 %278, i32* %296
%297 = getelementptr inbounds [36 x i32], [36 x i32]* @__const.main.sigs_array, i64 0, i64 %267
%298 = load i32, i32* %297
%299 = sext i32 %268 to i64
%300 = getelementptr inbounds [9 x i32], [9 x i32]* %265, i64 0, i64 %299
store i32 %298, i32* %300
%301 = add nsw i32 %268, 1
br label %302
302: ; preds = %274, %266, %280
%303 = phi i32 [ %268, %266 ], [ %268, %274 ], [ %301, %280 ]
%304 = add nuw nsw i64 %267, 1
%305 = icmp eq i64 %304, 36
br i1 %305, label %306, label %266
306: ; preds = %302
%307 = getelementptr inbounds [9 x double], [9 x double]* %199, i64 0, i64 0
%308 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.11, i64 0, i64 0), i32 %303)
%309 = call dereferenceable_or_null(8192) i8* @malloc(i32 8192)
%310 = bitcast i8* %309 to double*
%311 = call dereferenceable_or_null(8192) i8* @malloc(i32 8192)
%312 = bitcast i8* %311 to double*
%313 = call dereferenceable_or_null(8192) i8* @malloc(i32 8192)
%314 = bitcast i8* %313 to double*
%315 = call dereferenceable_or_null(8192) i8* @malloc(i32 8192)
%316 = bitcast i8* %315 to double*
br label %317
317: ; preds = %306, %317
%318 = phi i32 [ 0, %306 ], [ %327, %317 ]
%319 = call i64 @index_2d(i32 %318, i32 0, i32 4)
%320 = getelementptr inbounds double, double* %310, i64 %319
store double 1.000000e+00, double* %320
%321 = call i64 @index_2d(i32 %318, i32 0, i32 4)
%322 = getelementptr inbounds double, double* %312, i64 %321
store double 0.000000e+00, double* %322
%323 = call i64 @index_2d(i32 %318, i32 0, i32 4)
%324 = getelementptr inbounds double, double* %314, i64 %323
store double 1.000000e+00, double* %324
%325 = call i64 @index_2d(i32 %318, i32 0, i32 4)
%326 = getelementptr inbounds double, double* %316, i64 %325
store double 0.000000e+00, double* %326
%327 = add nuw nsw i32 %318, 1
%328 = icmp eq i32 %327, 256
br i1 %328, label %329, label %317
329: ; preds = %317, %329
%330 = phi i32 [ %339, %329 ], [ 0, %317 ]
%331 = call i64 @index_2d(i32 %330, i32 1, i32 4)
%332 = getelementptr inbounds double, double* %310, i64 %331
store double 1.000000e+00, double* %332
%333 = call i64 @index_2d(i32 %330, i32 1, i32 4)
%334 = getelementptr inbounds double, double* %312, i64 %333
store double 0.000000e+00, double* %334
%335 = call i64 @index_2d(i32 %330, i32 1, i32 4)
%336 = getelementptr inbounds double, double* %314, i64 %335
store double 1.000000e+00, double* %336
%337 = call i64 @index_2d(i32 %330, i32 1, i32 4)
%338 = getelementptr inbounds double, double* %316, i64 %337
store double 0.000000e+00, double* %338
%339 = add nuw nsw i32 %330, 1
%340 = icmp eq i32 %339, 256
br i1 %340, label %341, label %329
341: ; preds = %329, %341
%342 = phi i32 [ %351, %341 ], [ 0, %329 ]
%343 = call i64 @index_2d(i32 %342, i32 2, i32 4)
%344 = getelementptr inbounds double, double* %310, i64 %343
store double 1.000000e+00, double* %344
%345 = call i64 @index_2d(i32 %342, i32 2, i32 4)
%346 = getelementptr inbounds double, double* %312, i64 %345
store double 0.000000e+00, double* %346
%347 = call i64 @index_2d(i32 %342, i32 2, i32 4)
%348 = getelementptr inbounds double, double* %314, i64 %347
store double 1.000000e+00, double* %348
%349 = call i64 @index_2d(i32 %342, i32 2, i32 4)
%350 = getelementptr inbounds double, double* %316, i64 %349
store double 0.000000e+00, double* %350
%351 = add nuw nsw i32 %342, 1
%352 = icmp eq i32 %351, 256
br i1 %352, label %353, label %341
353: ; preds = %341, %353
%354 = phi i32 [ %363, %353 ], [ 0, %341 ]
%355 = call i64 @index_2d(i32 %354, i32 3, i32 4)
%356 = getelementptr inbounds double, double* %310, i64 %355
store double 1.000000e+00, double* %356
%357 = call i64 @index_2d(i32 %354, i32 3, i32 4)
%358 = getelementptr inbounds double, double* %312, i64 %357
store double 0.000000e+00, double* %358
%359 = call i64 @index_2d(i32 %354, i32 3, i32 4)
%360 = getelementptr inbounds double, double* %314, i64 %359
store double 1.000000e+00, double* %360
%361 = call i64 @index_2d(i32 %354, i32 3, i32 4)
%362 = getelementptr inbounds double, double* %316, i64 %361
store double 0.000000e+00, double* %362
%363 = add nuw nsw i32 %354, 1
%364 = icmp eq i32 %363, 256
br i1 %364, label %365, label %353
365: ; preds = %353
%366 = call dereferenceable_or_null(8192) i8* @malloc(i32 8192)
%367 = bitcast i8* %366 to double*
%368 = call dereferenceable_or_null(8192) i8* @malloc(i32 8192)
%369 = bitcast i8* %368 to double*
%370 = call dereferenceable_or_null(8192) i8* @malloc(i32 8192)
%371 = bitcast i8* %370 to double*
%372 = call dereferenceable_or_null(8192) i8* @malloc(i32 8192)
%373 = bitcast i8* %372 to double*
br label %374
374: ; preds = %365, %374
%375 = phi i32 [ 0, %365 ], [ %384, %374 ]
%376 = call i64 @index_2d(i32 %375, i32 0, i32 4)
%377 = getelementptr inbounds double, double* %367, i64 %376
store double 1.000000e+00, double* %377
%378 = call i64 @index_2d(i32 %375, i32 0, i32 4)
%379 = getelementptr inbounds double, double* %369, i64 %378
store double 0.000000e+00, double* %379
%380 = call i64 @index_2d(i32 %375, i32 0, i32 4)
%381 = getelementptr inbounds double, double* %371, i64 %380
store double 1.000000e+00, double* %381
%382 = call i64 @index_2d(i32 %375, i32 0, i32 4)
%383 = getelementptr inbounds double, double* %373, i64 %382
store double 0.000000e+00, double* %383
%384 = add nuw nsw i32 %375, 1
%385 = icmp eq i32 %384, 256
br i1 %385, label %386, label %374
386: ; preds = %374, %386
%387 = phi i32 [ %396, %386 ], [ 0, %374 ]
%388 = call i64 @index_2d(i32 %387, i32 1, i32 4)
%389 = getelementptr inbounds double, double* %367, i64 %388
store double 1.000000e+00, double* %389
%390 = call i64 @index_2d(i32 %387, i32 1, i32 4)
%391 = getelementptr inbounds double, double* %369, i64 %390
store double 0.000000e+00, double* %391
%392 = call i64 @index_2d(i32 %387, i32 1, i32 4)
%393 = getelementptr inbounds double, double* %371, i64 %392
store double 1.000000e+00, double* %393
%394 = call i64 @index_2d(i32 %387, i32 1, i32 4)
%395 = getelementptr inbounds double, double* %373, i64 %394
store double 0.000000e+00, double* %395
%396 = add nuw nsw i32 %387, 1
%397 = icmp eq i32 %396, 256
br i1 %397, label %398, label %386
398: ; preds = %386, %398
%399 = phi i32 [ %408, %398 ], [ 0, %386 ]
%400 = call i64 @index_2d(i32 %399, i32 2, i32 4)
%401 = getelementptr inbounds double, double* %367, i64 %400
store double 1.000000e+00, double* %401
%402 = call i64 @index_2d(i32 %399, i32 2, i32 4)
%403 = getelementptr inbounds double, double* %369, i64 %402
store double 0.000000e+00, double* %403
%404 = call i64 @index_2d(i32 %399, i32 2, i32 4)
%405 = getelementptr inbounds double, double* %371, i64 %404
store double 1.000000e+00, double* %405
%406 = call i64 @index_2d(i32 %399, i32 2, i32 4)
%407 = getelementptr inbounds double, double* %373, i64 %406
store double 0.000000e+00, double* %407
%408 = add nuw nsw i32 %399, 1
%409 = icmp eq i32 %408, 256
br i1 %409, label %410, label %398
410: ; preds = %398, %410
%411 = phi i32 [ %420, %410 ], [ 0, %398 ]
%412 = call i64 @index_2d(i32 %411, i32 3, i32 4)
%413 = getelementptr inbounds double, double* %367, i64 %412
store double 1.000000e+00, double* %413
%414 = call i64 @index_2d(i32 %411, i32 3, i32 4)
%415 = getelementptr inbounds double, double* %369, i64 %414
store double 0.000000e+00, double* %415
%416 = call i64 @index_2d(i32 %411, i32 3, i32 4)
%417 = getelementptr inbounds double, double* %371, i64 %416
store double 1.000000e+00, double* %417
%418 = call i64 @index_2d(i32 %411, i32 3, i32 4)
%419 = getelementptr inbounds double, double* %373, i64 %418
store double 0.000000e+00, double* %419
%420 = add nuw nsw i32 %411, 1
%421 = icmp eq i32 %420, 256
br i1 %421, label %422, label %410
422: ; preds = %410
%423 = call dereferenceable_or_null(2048) i8* @malloc(i32 2048)
%424 = bitcast i8* %423 to double*
%425 = call dereferenceable_or_null(2048) i8* @malloc(i32 2048)
%426 = bitcast i8* %425 to double*
%427 = call dereferenceable_or_null(2048) i8* @malloc(i32 2048)
%428 = call dereferenceable_or_null(2048) i8* @malloc(i32 2048)
br label %429
429: ; preds = %422, %429
%430 = phi i32 [ 0, %422 ], [ %435, %429 ]
%431 = call i64 @index_2d(i32 %430, i32 0, i32 1)
%432 = getelementptr inbounds double, double* %424, i64 %431
store double 1.000000e+00, double* %432
%433 = call i64 @index_2d(i32 %430, i32 0, i32 1)
%434 = getelementptr inbounds double, double* %426, i64 %433
store double 0.000000e+00, double* %434
%435 = add nuw nsw i32 %430, 1
%436 = icmp eq i32 %435, 256
br i1 %436, label %437, label %429
437: ; preds = %429
%438 = bitcast i8* %427 to double*
%439 = bitcast i8* %428 to double*
br label %440
440: ; preds = %437, %440
%441 = phi i32 [ %446, %440 ], [ 0, %437 ]
%442 = call i64 @index_2d(i32 %441, i32 0, i32 1)
%443 = getelementptr inbounds double, double* %438, i64 %442
store double 1.000000e+00, double* %443
%444 = call i64 @index_2d(i32 %441, i32 0, i32 1)
%445 = getelementptr inbounds double, double* %439, i64 %444
store double 0.000000e+00, double* %445
%446 = add nuw nsw i32 %441, 1
%447 = icmp eq i32 %446, 256
br i1 %447, label %448, label %440
448: ; preds = %440
%449 = call dereferenceable_or_null(2097152) i8* @malloc(i32 2097152)
%450 = bitcast i8* %449 to double*
%451 = call dereferenceable_or_null(2097152) i8* @malloc(i32 2097152)
%452 = bitcast i8* %451 to double*
br label %453
453: ; preds = %448, %463
%454 = phi i32 [ 0, %448 ], [ %464, %463 ]
br label %455
455: ; preds = %453, %455
%456 = phi i32 [ 0, %453 ], [ %461, %455 ]
%457 = call i64 @index_3d(i32 %454, i32 %456, i32 0, i32 256, i32 4)
%458 = getelementptr inbounds double, double* %450, i64 %457
store double 1.000000e+00, double* %458
%459 = call i64 @index_3d(i32 %454, i32 %456, i32 0, i32 256, i32 4)
%460 = getelementptr inbounds double, double* %452, i64 %459
store double 0.000000e+00, double* %460
%461 = add nuw nsw i32 %456, 1
%462 = icmp eq i32 %461, 256
br i1 %462, label %463, label %455
463: ; preds = %455
%464 = add nuw nsw i32 %454, 1
%465 = icmp eq i32 %464, 256
br i1 %465, label %466, label %453
466: ; preds = %463, %476
%467 = phi i32 [ %477, %476 ], [ 0, %463 ]
br label %468
468: ; preds = %468, %466
%469 = phi i32 [ 0, %466 ], [ %474, %468 ]
%470 = call i64 @index_3d(i32 %467, i32 %469, i32 1, i32 256, i32 4)
%471 = getelementptr inbounds double, double* %450, i64 %470
store double 1.000000e+00, double* %471
%472 = call i64 @index_3d(i32 %467, i32 %469, i32 1, i32 256, i32 4)
%473 = getelementptr inbounds double, double* %452, i64 %472
store double 0.000000e+00, double* %473
%474 = add nuw nsw i32 %469, 1
%475 = icmp eq i32 %474, 256
br i1 %475, label %476, label %468
476: ; preds = %468
%477 = add nuw nsw i32 %467, 1
%478 = icmp eq i32 %477, 256
br i1 %478, label %479, label %466
479: ; preds = %476, %489
%480 = phi i32 [ %490, %489 ], [ 0, %476 ]
br label %481
481: ; preds = %481, %479
%482 = phi i32 [ 0, %479 ], [ %487, %481 ]
%483 = call i64 @index_3d(i32 %480, i32 %482, i32 2, i32 256, i32 4)
%484 = getelementptr inbounds double, double* %450, i64 %483
store double 1.000000e+00, double* %484
%485 = call i64 @index_3d(i32 %480, i32 %482, i32 2, i32 256, i32 4)
%486 = getelementptr inbounds double, double* %452, i64 %485
store double 0.000000e+00, double* %486
%487 = add nuw nsw i32 %482, 1
%488 = icmp eq i32 %487, 256
br i1 %488, label %489, label %481
489: ; preds = %481
%490 = add nuw nsw i32 %480, 1
%491 = icmp eq i32 %490, 256
br i1 %491, label %492, label %479
492: ; preds = %489, %502
%493 = phi i32 [ %503, %502 ], [ 0, %489 ]
br label %494
494: ; preds = %494, %492
%495 = phi i32 [ 0, %492 ], [ %500, %494 ]
%496 = call i64 @index_3d(i32 %493, i32 %495, i32 3, i32 256, i32 4)
%497 = getelementptr inbounds double, double* %450, i64 %496
store double 1.000000e+00, double* %497
%498 = call i64 @index_3d(i32 %493, i32 %495, i32 3, i32 256, i32 4)
%499 = getelementptr inbounds double, double* %452, i64 %498
store double 0.000000e+00, double* %499
%500 = add nuw nsw i32 %495, 1
%501 = icmp eq i32 %500, 256
br i1 %501, label %502, label %494
502: ; preds = %494
%503 = add nuw nsw i32 %493, 1
%504 = icmp eq i32 %503, 256
br i1 %504, label %505, label %492
505: ; preds = %502
%506 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str.35, i64 0, i64 0))
%507 = call dereferenceable_or_null(256) i8* @malloc(i32 256)
%508 = bitcast i8* %507 to double*
%509 = call dereferenceable_or_null(256) i8* @malloc(i32 256)
%510 = bitcast i8* %509 to double*
br label %511
511: ; preds = %505, %534
%512 = phi i1 [ true, %505 ], [ false, %534 ]
%513 = phi i32 [ 0, %505 ], [ 1, %534 ]
br label %514
514: ; preds = %511, %514
%515 = phi i32 [ 0, %511 ], [ %532, %514 ]
%516 = call i64 @index_4d(i32 %513, i32 %515, i32 0, i32 0, i32 4, i32 4, i32 1)
%517 = getelementptr inbounds double, double* %508, i64 %516
store double 0.000000e+00, double* %517
%518 = call i64 @index_4d(i32 %513, i32 %515, i32 0, i32 0, i32 4, i32 4, i32 1)
%519 = getelementptr inbounds double, double* %510, i64 %518
store double 0.000000e+00, double* %519
%520 = call i64 @index_4d(i32 %513, i32 %515, i32 1, i32 0, i32 4, i32 4, i32 1)
%521 = getelementptr inbounds double, double* %508, i64 %520
store double 0.000000e+00, double* %521
%522 = call i64 @index_4d(i32 %513, i32 %515, i32 1, i32 0, i32 4, i32 4, i32 1)
%523 = getelementptr inbounds double, double* %510, i64 %522
store double 0.000000e+00, double* %523
%524 = call i64 @index_4d(i32 %513, i32 %515, i32 2, i32 0, i32 4, i32 4, i32 1)
%525 = getelementptr inbounds double, double* %508, i64 %524
store double 0.000000e+00, double* %525
%526 = call i64 @index_4d(i32 %513, i32 %515, i32 2, i32 0, i32 4, i32 4, i32 1)
%527 = getelementptr inbounds double, double* %510, i64 %526
store double 0.000000e+00, double* %527
%528 = call i64 @index_4d(i32 %513, i32 %515, i32 3, i32 0, i32 4, i32 4, i32 1)
%529 = getelementptr inbounds double, double* %508, i64 %528
store double 0.000000e+00, double* %529
%530 = call i64 @index_4d(i32 %513, i32 %515, i32 3, i32 0, i32 4, i32 4, i32 1)
%531 = getelementptr inbounds double, double* %510, i64 %530
store double 0.000000e+00, double* %531
%532 = add nuw nsw i32 %515, 1
%533 = icmp eq i32 %532, 4
br i1 %533, label %534, label %514
534: ; preds = %514
br i1 %512, label %511, label %535
535: ; preds = %534
%536 = call i32 @make_nucleon_2pt(double* %508, double* %510, double* %24, double* %26, i32* %191, i32* %195, double* %307, i32* %193, i32* %197, double* %201, double* %310, double* %312, double* %367, double* %369, i32 3, i32 2, i32 256, i32 256, i32 1, i32 9, i32 3, i32 4, i32 4)
%537 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.36, i64 0, i64 0))
br label %538
538: ; preds = %535, %558
%539 = phi i32 [ 0, %535 ], [ %559, %558 ]
br label %540
540: ; preds = %538, %540
%541 = phi i32 [ 0, %538 ], [ %556, %540 ]
%542 = call i64 @index_4d(i32 0, i32 %539, i32 %541, i32 0, i32 4, i32 4, i32 1)
%543 = getelementptr inbounds double, double* %508, i64 %542
%544 = load double, double* %543
%545 = call i64 @index_4d(i32 0, i32 %539, i32 %541, i32 0, i32 4, i32 4, i32 1)
%546 = getelementptr inbounds double, double* %510, i64 %545
%547 = load double, double* %546
%548 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.14, i64 0, i64 0), i32 %539, i32 %541, i32 0, double %544, double %547)
%549 = call i64 @index_4d(i32 1, i32 %539, i32 %541, i32 0, i32 4, i32 4, i32 1)
%550 = getelementptr inbounds double, double* %508, i64 %549
%551 = load double, double* %550
%552 = call i64 @index_4d(i32 1, i32 %539, i32 %541, i32 0, i32 4, i32 4, i32 1)
%553 = getelementptr inbounds double, double* %510, i64 %552
%554 = load double, double* %553
%555 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.15, i64 0, i64 0), i32 %539, i32 %541, i32 0, double %551, double %554)
%556 = add nuw nsw i32 %541, 1
%557 = icmp eq i32 %556, 4
br i1 %557, label %558, label %540
558: ; preds = %540
%559 = add nuw nsw i32 %539, 1
%560 = icmp eq i32 %559, 4
br i1 %560, label %561, label %538
561: ; preds = %558
%562 = call dereferenceable_or_null(800) i8* @malloc(i32 800)
%563 = bitcast i8* %562 to double*
%564 = call dereferenceable_or_null(800) i8* @malloc(i32 800)
%565 = bitcast i8* %564 to double*
br label %566
566: ; preds = %561, %592
%567 = phi i32 [ 0, %561 ], [ %593, %592 ]
br label %568
568: ; preds = %566, %568
%569 = phi i32 [ 0, %566 ], [ %590, %568 ]
%570 = call i64 @index_4d(i32 %567, i32 %569, i32 0, i32 0, i32 5, i32 5, i32 1)
%571 = getelementptr inbounds double, double* %563, i64 %570
store double 0.000000e+00, double* %571
%572 = call i64 @index_4d(i32 %567, i32 %569, i32 0, i32 0, i32 5, i32 5, i32 1)
%573 = getelementptr inbounds double, double* %565, i64 %572
store double 0.000000e+00, double* %573
%574 = call i64 @index_4d(i32 %567, i32 %569, i32 1, i32 0, i32 5, i32 5, i32 1)
%575 = getelementptr inbounds double, double* %563, i64 %574
store double 0.000000e+00, double* %575
%576 = call i64 @index_4d(i32 %567, i32 %569, i32 1, i32 0, i32 5, i32 5, i32 1)
%577 = getelementptr inbounds double, double* %565, i64 %576
store double 0.000000e+00, double* %577
%578 = call i64 @index_4d(i32 %567, i32 %569, i32 2, i32 0, i32 5, i32 5, i32 1)
%579 = getelementptr inbounds double, double* %563, i64 %578
store double 0.000000e+00, double* %579
%580 = call i64 @index_4d(i32 %567, i32 %569, i32 2, i32 0, i32 5, i32 5, i32 1)
%581 = getelementptr inbounds double, double* %565, i64 %580
store double 0.000000e+00, double* %581
%582 = call i64 @index_4d(i32 %567, i32 %569, i32 3, i32 0, i32 5, i32 5, i32 1)
%583 = getelementptr inbounds double, double* %563, i64 %582
store double 0.000000e+00, double* %583
%584 = call i64 @index_4d(i32 %567, i32 %569, i32 3, i32 0, i32 5, i32 5, i32 1)
%585 = getelementptr inbounds double, double* %565, i64 %584
store double 0.000000e+00, double* %585
%586 = call i64 @index_4d(i32 %567, i32 %569, i32 4, i32 0, i32 5, i32 5, i32 1)
%587 = getelementptr inbounds double, double* %563, i64 %586
store double 0.000000e+00, double* %587
%588 = call i64 @index_4d(i32 %567, i32 %569, i32 4, i32 0, i32 5, i32 5, i32 1)
%589 = getelementptr inbounds double, double* %565, i64 %588
store double 0.000000e+00, double* %589
%590 = add nuw nsw i32 %569, 1
%591 = icmp eq i32 %590, 5
br i1 %591, label %592, label %568
592: ; preds = %568
%593 = add nuw nsw i32 %567, 1
%594 = icmp eq i32 %593, 4
br i1 %594, label %595, label %566
595: ; preds = %592
%596 = getelementptr inbounds [9 x i32], [9 x i32]* %265, i64 0, i64 0
%597 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.37, i64 0, i64 0))
%598 = call i32 @make_two_nucleon_2pt(double* %563, double* %565, double* %24, double* %26, double* %28, double* %30, i32* %191, i32* %195, double* %307, i32* %193, i32* %197, double* %201, i32* %264, i32* %596, double* %310, double* %312, double* %314, double* %316, double* %450, double* %452, double* %367, double* %369, double* %371, double* %373, double* %424, double* %426, double* %438, double* %439, i32 0, i32 0, i32 3, i32 2, i32 256, i32 256, i32 1, i32 9, i32 3, i32 4, i32 4, i32 1, i32 1, i32 9)
%599 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.38, i64 0, i64 0))
%600 = call dereferenceable_or_null(100) i8* @malloc(i32 100)
%601 = bitcast i8* %600 to i32*
%602 = call i64 @index_2d(i32 0, i32 0, i32 5)
%603 = getelementptr inbounds i32, i32* %601, i64 %602
store i32 1, i32* %603
%604 = call i64 @index_2d(i32 0, i32 1, i32 5)
%605 = getelementptr inbounds i32, i32* %601, i64 %604
store i32 1, i32* %605
%606 = call i64 @index_2d(i32 0, i32 2, i32 5)
%607 = getelementptr inbounds i32, i32* %601, i64 %606
store i32 1, i32* %607
%608 = call i64 @index_2d(i32 0, i32 3, i32 5)
%609 = getelementptr inbounds i32, i32* %601, i64 %608
store i32 1, i32* %609
%610 = call i64 @index_2d(i32 1, i32 0, i32 5)
%611 = getelementptr inbounds i32, i32* %601, i64 %610
store i32 1, i32* %611
%612 = call i64 @index_2d(i32 1, i32 1, i32 5)
%613 = getelementptr inbounds i32, i32* %601, i64 %612
store i32 1, i32* %613
%614 = call i64 @index_2d(i32 1, i32 2, i32 5)
%615 = getelementptr inbounds i32, i32* %601, i64 %614
store i32 1, i32* %615
%616 = call i64 @index_2d(i32 1, i32 3, i32 5)
%617 = getelementptr inbounds i32, i32* %601, i64 %616
store i32 1, i32* %617
%618 = call i64 @index_2d(i32 2, i32 0, i32 5)
%619 = getelementptr inbounds i32, i32* %601, i64 %618
store i32 1, i32* %619
%620 = call i64 @index_2d(i32 2, i32 1, i32 5)
%621 = getelementptr inbounds i32, i32* %601, i64 %620
store i32 1, i32* %621
%622 = call i64 @index_2d(i32 2, i32 2, i32 5)
%623 = getelementptr inbounds i32, i32* %601, i64 %622
store i32 1, i32* %623
%624 = call i64 @index_2d(i32 2, i32 3, i32 5)
%625 = getelementptr inbounds i32, i32* %601, i64 %624
store i32 1, i32* %625
%626 = call i64 @index_2d(i32 3, i32 0, i32 5)
%627 = getelementptr inbounds i32, i32* %601, i64 %626
store i32 1, i32* %627
%628 = call i64 @index_2d(i32 3, i32 1, i32 5)
%629 = getelementptr inbounds i32, i32* %601, i64 %628
store i32 1, i32* %629
%630 = call i64 @index_2d(i32 3, i32 2, i32 5)
%631 = getelementptr inbounds i32, i32* %601, i64 %630
store i32 1, i32* %631
%632 = call i64 @index_2d(i32 3, i32 3, i32 5)
%633 = getelementptr inbounds i32, i32* %601, i64 %632
store i32 1, i32* %633
%634 = call i64 @index_2d(i32 4, i32 0, i32 5)
%635 = getelementptr inbounds i32, i32* %601, i64 %634
store i32 1, i32* %635
%636 = call i64 @index_2d(i32 4, i32 1, i32 5)
%637 = getelementptr inbounds i32, i32* %601, i64 %636
store i32 1, i32* %637
%638 = call i64 @index_2d(i32 4, i32 2, i32 5)
%639 = getelementptr inbounds i32, i32* %601, i64 %638
store i32 1, i32* %639
%640 = call i64 @index_2d(i32 4, i32 3, i32 5)
%641 = getelementptr inbounds i32, i32* %601, i64 %640
store i32 1, i32* %641
%642 = call i64 @index_2d(i32 0, i32 4, i32 5)
%643 = getelementptr inbounds i32, i32* %601, i64 %642
store i32 1, i32* %643
%644 = call i64 @index_2d(i32 1, i32 4, i32 5)
%645 = getelementptr inbounds i32, i32* %601, i64 %644
store i32 1, i32* %645
%646 = call i64 @index_2d(i32 2, i32 4, i32 5)
%647 = getelementptr inbounds i32, i32* %601, i64 %646
store i32 1, i32* %647
%648 = call i64 @index_2d(i32 3, i32 4, i32 5)
%649 = getelementptr inbounds i32, i32* %601, i64 %648
store i32 1, i32* %649
%650 = call i64 @index_2d(i32 4, i32 4, i32 5)
%651 = getelementptr inbounds i32, i32* %601, i64 %650
store i32 1, i32* %651
br label %652
652: ; preds = %595, %686
%653 = phi i32 [ 0, %595 ], [ %687, %686 ]
br label %654
654: ; preds = %652, %654
%655 = phi i32 [ 0, %652 ], [ %684, %654 ]
%656 = call i64 @index_4d(i32 0, i32 %653, i32 %655, i32 0, i32 5, i32 5, i32 1)
%657 = getelementptr inbounds double, double* %563, i64 %656
%658 = load double, double* %657
%659 = call i64 @index_4d(i32 0, i32 %653, i32 %655, i32 0, i32 5, i32 5, i32 1)
%660 = getelementptr inbounds double, double* %565, i64 %659
%661 = load double, double* %660
%662 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.18, i64 0, i64 0), i32 %653, i32 %655, i32 0, double %658, double %661)
%663 = call i64 @index_4d(i32 1, i32 %653, i32 %655, i32 0, i32 5, i32 5, i32 1)
%664 = getelementptr inbounds double, double* %563, i64 %663
%665 = load double, double* %664
%666 = call i64 @index_4d(i32 1, i32 %653, i32 %655, i32 0, i32 5, i32 5, i32 1)
%667 = getelementptr inbounds double, double* %565, i64 %666
%668 = load double, double* %667
%669 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.19, i64 0, i64 0), i32 %653, i32 %655, i32 0, double %665, double %668)
%670 = call i64 @index_4d(i32 2, i32 %653, i32 %655, i32 0, i32 5, i32 5, i32 1)
%671 = getelementptr inbounds double, double* %563, i64 %670
%672 = load double, double* %671
%673 = call i64 @index_4d(i32 2, i32 %653, i32 %655, i32 0, i32 5, i32 5, i32 1)
%674 = getelementptr inbounds double, double* %565, i64 %673
%675 = load double, double* %674
%676 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.20, i64 0, i64 0), i32 %653, i32 %655, i32 0, double %672, double %675)
%677 = call i64 @index_4d(i32 3, i32 %653, i32 %655, i32 0, i32 5, i32 5, i32 1)
%678 = getelementptr inbounds double, double* %563, i64 %677
%679 = load double, double* %678
%680 = call i64 @index_4d(i32 3, i32 %653, i32 %655, i32 0, i32 5, i32 5, i32 1)
%681 = getelementptr inbounds double, double* %565, i64 %680
%682 = load double, double* %681
%683 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @.str.21, i64 0, i64 0), i32 %653, i32 %655, i32 0, double %679, double %682)
%684 = add nuw nsw i32 %655, 1
%685 = icmp eq i32 %684, 5
br i1 %685, label %686, label %654
686: ; preds = %654
%687 = add nuw nsw i32 %653, 1
%688 = icmp eq i32 %687, 5
br i1 %688, label %689, label %652
689: ; preds = %686
%690 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.39, i64 0, i64 0))
br label %691
691: ; preds = %689, %765
%692 = phi i32 [ 0, %689 ], [ %766, %765 ]
br label %693
693: ; preds = %691, %693
%694 = phi i32 [ 0, %691 ], [ %763, %693 ]
%695 = call i64 @index_2d(i32 %692, i32 %694, i32 5)
%696 = getelementptr inbounds i32, i32* %601, i64 %695
%697 = load i32, i32* %696
%698 = sitofp i32 %697 to double
%699 = call i64 @index_4d(i32 0, i32 %692, i32 %694, i32 0, i32 5, i32 5, i32 1)
%700 = getelementptr inbounds double, double* %563, i64 %699
%701 = load double, double* %700
%702 = fmul double %701, %698
%703 = call i64 @index_4d(i32 0, i32 0, i32 0, i32 0, i32 4, i32 4, i32 1)
%704 = getelementptr inbounds double, double* %508, i64 %703
%705 = load double, double* %704
%706 = call i64 @index_4d(i32 1, i32 0, i32 0, i32 0, i32 4, i32 4, i32 1)
%707 = getelementptr inbounds double, double* %508, i64 %706
%708 = load double, double* %707
%709 = fmul double %705, %708
%710 = fdiv double %702, %709
%711 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.23, i64 0, i64 0), i32 %692, i32 %694, i32 0, double %710)
%712 = call i64 @index_2d(i32 %692, i32 %694, i32 5)
%713 = getelementptr inbounds i32, i32* %601, i64 %712
%714 = load i32, i32* %713
%715 = sitofp i32 %714 to double
%716 = call i64 @index_4d(i32 1, i32 %692, i32 %694, i32 0, i32 5, i32 5, i32 1)
%717 = getelementptr inbounds double, double* %563, i64 %716
%718 = load double, double* %717
%719 = fmul double %718, %715
%720 = call i64 @index_4d(i32 0, i32 0, i32 0, i32 0, i32 4, i32 4, i32 1)
%721 = getelementptr inbounds double, double* %508, i64 %720
%722 = load double, double* %721
%723 = call i64 @index_4d(i32 1, i32 0, i32 0, i32 0, i32 4, i32 4, i32 1)
%724 = getelementptr inbounds double, double* %508, i64 %723
%725 = load double, double* %724
%726 = fmul double %722, %725
%727 = fdiv double %719, %726
%728 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.24, i64 0, i64 0), i32 %692, i32 %694, i32 0, double %727)
%729 = call i64 @index_2d(i32 %692, i32 %694, i32 5)
%730 = getelementptr inbounds i32, i32* %601, i64 %729
%731 = load i32, i32* %730
%732 = sitofp i32 %731 to double
%733 = call i64 @index_4d(i32 2, i32 %692, i32 %694, i32 0, i32 5, i32 5, i32 1)
%734 = getelementptr inbounds double, double* %563, i64 %733
%735 = load double, double* %734
%736 = fmul double %735, %732
%737 = call i64 @index_4d(i32 0, i32 0, i32 0, i32 0, i32 4, i32 4, i32 1)
%738 = getelementptr inbounds double, double* %508, i64 %737
%739 = load double, double* %738
%740 = call i64 @index_4d(i32 1, i32 0, i32 0, i32 0, i32 4, i32 4, i32 1)
%741 = getelementptr inbounds double, double* %508, i64 %740
%742 = load double, double* %741
%743 = fmul double %739, %742
%744 = fdiv double %736, %743
%745 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.25, i64 0, i64 0), i32 %692, i32 %694, i32 0, double %744)
%746 = call i64 @index_2d(i32 %692, i32 %694, i32 5)
%747 = getelementptr inbounds i32, i32* %601, i64 %746
%748 = load i32, i32* %747
%749 = sitofp i32 %748 to double
%750 = call i64 @index_4d(i32 3, i32 %692, i32 %694, i32 0, i32 5, i32 5, i32 1)
%751 = getelementptr inbounds double, double* %563, i64 %750
%752 = load double, double* %751
%753 = fmul double %752, %749
%754 = call i64 @index_4d(i32 0, i32 0, i32 0, i32 0, i32 4, i32 4, i32 1)
%755 = getelementptr inbounds double, double* %508, i64 %754
%756 = load double, double* %755
%757 = call i64 @index_4d(i32 1, i32 0, i32 0, i32 0, i32 4, i32 4, i32 1)
%758 = getelementptr inbounds double, double* %508, i64 %757
%759 = load double, double* %758
%760 = fmul double %756, %759
%761 = fdiv double %753, %760
%762 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.26, i64 0, i64 0), i32 %692, i32 %694, i32 0, double %761)
%763 = add nuw nsw i32 %694, 1
%764 = icmp eq i32 %763, 5
br i1 %764, label %765, label %693
765: ; preds = %693
%766 = add nuw nsw i32 %692, 1
%767 = icmp eq i32 %766, 5
br i1 %767, label %768, label %691
768: ; preds = %765
%769 = call i32 @time(i32* %2)
%770 = load i32, i32* %2
%771 = load i32, i32* %1
%772 = call double @difftime(i32 %770, i32 %771)
%773 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.27, i64 0, i64 0), double %772)
ret i32 0
}