#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*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ Crossover_int_Kpoint(int **, double *, int, int, double *,
                                        double *, int, double, double *, int *,
                                        int *);
int /*<<< orphan*/ MH_Kpoint_int(int *, double *, int, double, int, double *,
                                 int *);
int /*<<< orphan*/ Mutation_int_Gibbs(int *, double *, int, double *, double *,
                                      int, double, int, int *);
int /*<<< orphan*/ Mutation_int_Kpoint(int *, double *, int, double *, double *,
                                       int, double, int, double *, int *);
double atof(char *);
int atoi(char *);
double cost(int *, int);
double *dvector(int, int);
double exp(double);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ fflush(int /*<<< orphan*/ *);
int /*<<< orphan*/ flags_usage();
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int /*<<< orphan*/ free_dvector(double *, int, int);
int /*<<< orphan*/ free_imatrix(int **, int, int, int, int);
int /*<<< orphan*/ free_ivector(int *, int, int);
int /*<<< orphan*/ get_data(char *, int *, int *, int *);
int **imatrix(int, int, int, int);
int /*<<< orphan*/ initialise_from_data(int *);
int integerrng(int, int);
int *ivector(int, int);
double pow(double, double);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ self_adj_desired_freq(double *, int, double);
int /*<<< orphan*/ self_adj_grid_points(double *, int, double, double);
int /*<<< orphan*/ self_adj_theta_norm(double *, double *, double *, int,
                                       double);
int /*<<< orphan*/ self_adj_theta_update(double *, int, double *, double *, int,
                                         double *, double, double *);
int /*<<< orphan*/ setseedrng(unsigned long);
int /*<<< orphan*/ snprintf(char *, int, char *, ...);
scalar_t__ strcmp(char *, char *);
scalar_t__ time(int /*<<< orphan*/ *);
double uniformrng();
int /*<<< orphan*/ update_best_value(int *, double *, int **, double *, int,
                                     int);
int main(int argc, char *argv[]) {
  double sumv;
  double avev;
  double minv;
  double maxv;
  double un;
  int N_empty;
  int lab_mcmc;
  int i;
  int j;
  int pop;
  int iter;
  int Rep;
  int N_sample;
  int N_thinning;
  int N_dimension;
  int N_population;
  int N_iteration;
  int Nrow;
  int Ncol;
  double *freq_ref;
  double *freq_est;
  double freq_zeta;
  double *theta;
  double theta_norm_const;
  double *grid_points;
  int grid_size;
  double grid_high;
  double grid_low;
  double gain;
  double gain_pow;
  int gain_warmup;
  double gain_high;
  double temp_saa;
  double temp_saa_pow;
  int temp_saa_warmup;
  double temp_saa_high;
  double temp_saa_low;
  double temp_seed;
  double temp_refine;
  double *fx;
  int **x;
  double fz_best;
  int *z_best;
  double accpr;
  double exp_accpr_mhseed;
  double exp_accpr_mh0;
  double exp_accpr_mh1;
  double exp_accpr_mh2;
  double exp_accpr_co1;
  double exp_accpr_mhrefine;
  int n_mhseed;
  int n_mh0;
  int n_mh1;
  int n_mh2;
  int n_co1;
  int n_mhrefine;
  int *workvec1;
  int *workvec2;
  double *workvec3;
  FILE *ins_hist = NULL;
  FILE *ins_fz_best_trace = NULL;
  FILE *ins_fz_best = NULL;
  FILE *ins_fz_better = NULL;
  char file_name[50];
  char datapath[50];
  printf("\n INITIALIZE THE RNG \n");
  setseedrng((unsigned long)time(NULL));
  for (i = 1; i <= 10; i++)
    un = uniformrng();
  printf("\n SET ALGORITHMIC SETTINGS \n");
  snprintf(datapath, sizeof datapath, "./FPphotomicro_240x320_bw.dat");
  N_population = 5;
  N_iteration = 500000;
  Rep = 1;
  N_sample = 5000;
  N_thinning = N_iteration / N_sample;
  gain_warmup = 5000;
  gain_pow = 0.55;
  gain_high = 1.0;
  temp_saa_warmup = 5000;
  temp_saa_pow = 0.5;
  temp_saa_high = 1.0;
  temp_saa_low = pow(10.0, -3.0);
  temp_seed = 100.0;
  temp_refine = 0.0001;
  freq_zeta = 0.1;
  grid_low = -971500.5;
  grid_high = -826315.5;
  grid_size = 200;
  theta_norm_const = 100.0;
  for (i = 1; i < argc; i++) {
    if (strcmp("-ID", argv[i]) == 0)
      Rep = atoi(argv[++i]);
    else if (strcmp("-Data", argv[i]) == 0)
      snprintf(datapath, sizeof datapath, argv[++i]);
    else if (strcmp("-Niter", argv[i]) == 0) {
      N_iteration = atoi(argv[++i]);
      N_thinning = N_iteration / N_sample;
    } else if (strcmp("-Npop", argv[i]) == 0)
      N_population = atoi(argv[++i]);
    else if (strcmp("-Nsam", argv[i]) == 0) {
      N_sample = atoi(argv[++i]);
      if (N_sample == 0)
        N_thinning = N_iteration / 1;
      else
        N_thinning = N_iteration / N_sample;
    } else if (strcmp("-Gwarm", argv[i]) == 0)
      gain_warmup = atoi(argv[++i]);
    else if (strcmp("-Ghigh", argv[i]) == 0)
      gain_high = atof(argv[++i]);
    else if (strcmp("-Gpow", argv[i]) == 0)
      gain_pow = atof(argv[++i]);
    else if (strcmp("-Hlow", argv[i]) == 0)
      grid_low = atof(argv[++i]);
    else if (strcmp("-Hhigh", argv[i]) == 0)
      grid_high = atof(argv[++i]);
    else if (strcmp("-Hsize", argv[i]) == 0)
      grid_size = atoi(argv[++i]);
    else if (strcmp("-Hzeta", argv[i]) == 0)
      freq_zeta = atof(argv[++i]);
    else if (strcmp("-Hconst", argv[i]) == 0)
      theta_norm_const = atof(argv[++i]);
    else if (strcmp("-Twarm", argv[i]) == 0)
      temp_saa_warmup = atoi(argv[++i]);
    else if (strcmp("-Tlow", argv[i]) == 0)
      temp_saa_low = atof(argv[++i]);
    else if (strcmp("-Thigh", argv[i]) == 0)
      temp_saa_high = atof(argv[++i]);
    else if (strcmp("-Tpow", argv[i]) == 0)
      temp_saa_pow = atof(argv[++i]);
    else if (strcmp("-flags", argv[i]) == 0)
      flags_usage();
  }
  printf("\n PRINT INPUTS OF THE ALGORITHM \n");
  printf("Rep: \t\t %d \n", Rep);
  printf("N_iteration: \t\t %d \n", N_iteration);
  printf("N_population: \t\t %d \n", N_population);
  printf("N_sample: \t\t %d \n", N_sample);
  printf("N_thinning: \t\t %d \n", N_thinning);
  printf("gain_warmup: \t\t %d \n", gain_warmup);
  printf("gain_high: \t\t %f \n", gain_high);
  printf("gain_pow: \t\t %f \n", gain_pow);
  printf("grid_low: \t\t %f \n", grid_low);
  printf("grid_high: \t\t %f \n", grid_high);
  printf("grid_size: \t\t %d \n", grid_size);
  printf("freq_zeta: \t\t %f \n", freq_zeta);
  printf("theta_norm_const: \t %f \n", theta_norm_const);
  printf("temp_saa_warmup: \t %d \n", temp_saa_warmup);
  printf("temp_saa_low: \t\t %f \n", temp_saa_low);
  printf("temp_saa_high: \t\t %f \n", temp_saa_high);
  printf("temp_saa_pow: \t\t %f \n", temp_saa_pow);
  printf("temp_seed: \t\t %f \n", temp_seed);
  printf("temp_refine: \t\t %f \n", temp_refine);
  printf("\n");
  printf("\n GET DATA\n");
  get_data(datapath, &N_dimension, &Nrow, &Ncol);
  printf("\n OPEN FILES\n");
  snprintf(file_name, sizeof file_name, "./output_files/hist-n=%d-r=%d",
           N_population, Rep);
  ins_hist = fopen(file_name, "w");
  snprintf(file_name, sizeof file_name,
           "./output_files/fz_best_trace-n=%d-r=%d", N_population, Rep);
  ins_fz_best_trace = fopen(file_name, "w");
  snprintf(file_name, sizeof file_name, "./output_files/fz_best-n=%d-r=%d",
           N_population, Rep);
  ins_fz_best = fopen(file_name, "w");
  snprintf(file_name, sizeof file_name, "./output_files/fz_better-n=%d-r=%d",
           N_population, Rep);
  ins_fz_better = fopen(file_name, "w");
  printf("\n ALLOCATE SPACE FOR THE ARRAYS \n");
  grid_points = dvector(1, grid_size);
  freq_ref = dvector(1, grid_size + 1);
  theta = dvector(1, grid_size + 1);
  freq_est = dvector(1, grid_size + 1);
  x = imatrix(1, N_population, 1, N_dimension);
  fx = dvector(1, N_population);
  z_best = ivector(1, N_dimension);
  workvec1 = ivector(1, N_dimension);
  workvec2 = ivector(1, N_dimension);
  workvec3 = dvector(1, grid_size + 1);
  printf("\n INITIALIZE THE POPULATION \n");
  for (pop = 1; pop <= N_population; pop++) {
    initialise_from_data(x[pop]);
    fx[pop] = cost(x[pop], N_dimension);
  }
  exp_accpr_mhseed = 0.0;
  n_mhseed = 0;
  printf("\n INITIALIZE BEST VALUES \n");
  j = 1;
  fz_best = fx[1];
  for (pop = 2; pop <= N_population; pop++)
    if (fx[pop] < fz_best) {
      j = pop;
      fz_best = fx[j];
    }
  for (i = 1; i <= N_dimension; i++)
    z_best[i] = x[j][i];
  printf("%f \n", fz_best);
  for (i = 1; i <= Nrow; i++) {
    for (j = 1; j <= Ncol; j++) {
      if (z_best[(i - 1) * Ncol + j] == 1)
        printf(" ");
      if (z_best[(i - 1) * Ncol + j] == 0)
        printf("X");
    }
    printf("\n");
  }
  printf("\n");
  printf("\n INITIALIZE THE SELF-ADJUSTING MECHANISM \n");
  printf("\n INITIALIZE THE REFERENCE FREQUENCE \n");
  self_adj_desired_freq(freq_ref, grid_size, freq_zeta);
  printf("\n INITIALIZE EMPIRICAL FREQUENCE \n");
  for (i = 1; i <= grid_size + 1; i++)
    freq_est[i] = 0.0;
  printf("\n INITIALIZE GRID POINTSE \n");
  self_adj_grid_points(grid_points, grid_size, grid_low, grid_high);
  printf("\n INITIALIZE THETA \n");
  for (i = 1; i <= grid_size + 1; i++)
    theta[i] = 0.0;
  if (grid_size < 500) {
    printf("\n PRINT INITIAL SETTINGS OF "
           "THE SELF-ADJUSTMENT PROSEDURE \n");
    for (i = 1; i <= grid_size; i++)
      printf("%d \t %f \t %f \t %f \t %f \t %f \n", i, grid_points[i], theta[i],
             exp(theta[i]), freq_ref[i], freq_est[i]);
    i = grid_size + 1;
    printf("%d \t %f \t %f \t %f \t %f \t %f \n", i, 0.0, theta[i],
           exp(theta[i]), freq_ref[i], freq_est[i]);
  }
  printf("\n INITIALIZE THE COUNTERS \n");
  exp_accpr_mh0 = 0.0;
  n_mh0 = 0;
  exp_accpr_mh1 = 0.0;
  n_mh1 = 0;
  exp_accpr_mh2 = 0.0;
  n_mh2 = 0;
  exp_accpr_co1 = 0.0;
  n_co1 = 0;
  printf("\n PERFORM PISAA ITERATIONS \n");
  for (iter = 1; iter <= N_iteration; iter++) {
    if (iter <= temp_saa_warmup)
      temp_saa = temp_saa_high + temp_saa_low;
    else {
      temp_saa = temp_saa_warmup / ((double)iter);
      temp_saa = temp_saa_high * pow(temp_saa, temp_saa_pow) + temp_saa_low;
    }
    if (N_population == 1)
      lab_mcmc = integerrng(1, 2);
    else
      lab_mcmc = integerrng(1, 3);
    switch (lab_mcmc) {
    case 0:
      sumv = 0.0;
      for (pop = 1; pop <= N_population; pop++) {
        MH_Kpoint_int(x[pop], &fx[pop], N_dimension, temp_saa, 5, &accpr,
                      workvec1);
        sumv += accpr;
      }
      accpr = sumv / pop;
      exp_accpr_mh0 += accpr;
      n_mh0++;
      break;
    case 1:
      sumv = 0.0;
      for (pop = 1; pop <= N_population; pop++) {
        Mutation_int_Kpoint(x[pop], &fx[pop], N_dimension, theta, grid_points,
                            grid_size, temp_saa, 2, &accpr, workvec1);
        sumv += accpr;
      }
      accpr = sumv / pop;
      exp_accpr_mh1 += accpr;
      n_mh1++;
      break;
    case 2:
      for (pop = 1; pop <= N_population; pop++) {
        Mutation_int_Gibbs(
            x[pop], &fx[pop], N_dimension, theta, grid_points, grid_size,
            temp_saa,
            (((5) > ((((25) < (N_population)) ? (25) : (N_population))))
                 ? (5)
                 : ((((25) < (N_population)) ? (25) : (N_population)))),
            workvec1);
      }
      exp_accpr_mh2 += 1.0;
      n_mh2++;
      break;
    case 3:
      Crossover_int_Kpoint(x, fx, N_dimension, N_population, theta, grid_points,
                           grid_size, temp_saa, &accpr, workvec1, workvec2);
      exp_accpr_co1 += accpr;
      n_co1++;
      break;
    default:
      break;
    }
    if (iter <= gain_warmup)
      gain = gain_high;
    else {
      gain = gain_warmup / ((double)iter);
      gain = gain_high * pow(gain, gain_pow);
    }
    self_adj_theta_update(fx, N_population, theta, grid_points, grid_size,
                          freq_ref, gain, workvec3);
    for (i = 1; i <= grid_size + 1; i++)
      freq_est[i] += workvec3[i];
    update_best_value(z_best, &fz_best, x, fx, N_dimension, N_population);
    if (iter > 0 && iter % N_thinning == 0 && N_sample > 0)
      printf("iter=%d gain=%f temp_saa=%f min=%f \n", iter, gain, temp_saa,
             fz_best);
    if (ins_fz_best_trace != NULL)
      if (iter > 0 && iter % N_thinning == 0 && N_sample > 0) {
        fprintf(ins_fz_best_trace, "%d %f \n", iter, fz_best);
        fflush(ins_fz_best_trace);
      }
  }
  printf("\n THETA-NORMALIZATION STEP \n");
  for (i = 1; i <= grid_size + 1; i++)
    freq_est[i] /= N_iteration;
  self_adj_theta_norm(theta, freq_ref, freq_est, grid_size, theta_norm_const);
  if (ins_hist != NULL) {
    for (i = 1; i <= grid_size; i++)
      fprintf(ins_hist, "%d %f %f %f %f %f \n", i, grid_points[i], theta[i],
              exp(theta[i]), freq_ref[i], freq_est[i]);
    i = grid_size + 1;
    fprintf(ins_hist, "%d %f %f %f %f %f \n", i, 0.0, theta[i], exp(theta[i]),
            freq_ref[i], freq_est[i]);
    fflush(ins_hist);
  }
  printf("\n RECORD BEST VALUES \n");
  if (ins_fz_best != NULL) {
    fprintf(ins_fz_best, "%f \n", fz_best);
    for (i = 1; i <= Nrow; i++) {
      for (j = 1; j <= Ncol; j++)
        fprintf(ins_fz_best, "%d ", z_best[(i - 1) * Ncol + j]);
      fprintf(ins_fz_best, "\n");
    }
    fprintf(ins_fz_best, "\n");
    fprintf(ins_fz_best, "\n");
    fflush(ins_fz_best);
  }
  printf("\n RECORD BETTER VALUES \n");
  if (ins_fz_better != NULL) {
    maxv = fz_best;
    for (i = 1; i <= N_dimension; i++)
      workvec1[i] = z_best[i];
    exp_accpr_mhrefine = 0.0;
    n_mhrefine = 0;
    for (i = 1; i <= 10000; i++) {
      MH_Kpoint_int(workvec1, &maxv, N_dimension, temp_refine, 5, &accpr,
                    workvec2);
      exp_accpr_mhrefine += accpr;
      n_mhrefine++;
    }
    exp_accpr_mhrefine /= n_mhrefine;
    fprintf(ins_fz_better, "%f \n", maxv);
    for (i = 1; i <= Nrow; i++) {
      for (j = 1; j <= Ncol; j++)
        fprintf(ins_fz_better, "%d ", workvec1[(i - 1) * Ncol + j]);
      fprintf(ins_fz_better, "\n");
    }
    fprintf(ins_fz_better, "\n");
    fprintf(ins_fz_better, "\n");
    fflush(ins_fz_better);
  }
  printf("\n SUMMARY \n");
  printf("\n ...Result \n");
  printf("fz_best : %f\n", fz_best);
  printf("z_best  : \n");
  for (i = 1; i <= Nrow; i++) {
    for (j = 1; j <= Ncol; j++) {
      if (z_best[(i - 1) * Ncol + j] == 1)
        printf(" ");
      if (z_best[(i - 1) * Ncol + j] == 0)
        printf("X");
    }
    printf("\n");
  }
  printf("\n");
  printf("fz_better : %f\n", maxv);
  printf("z_better  : \n");
  for (i = 1; i <= Nrow; i++) {
    for (j = 1; j <= Ncol; j++) {
      if (workvec1[(i - 1) * Ncol + j] == 1)
        printf(" ");
      if (workvec1[(i - 1) * Ncol + j] == 0)
        printf("X");
    }
    printf("\n");
  }
  printf("\n");
  printf("\n ...Acceptance ratios \n");
  exp_accpr_mh0 /= n_mh0;
  exp_accpr_mh1 /= n_mh1;
  exp_accpr_mh2 /= n_mh2;
  exp_accpr_co1 /= n_co1;
  printf("mhs rate=%f \n", exp_accpr_mhseed);
  printf("mh0 rate=%f \n", exp_accpr_mh0);
  printf("mh1 rate=%f \n", exp_accpr_mh1);
  printf("mh2 rate=%f \n", exp_accpr_mh2);
  printf("co1 rate=%f \n", exp_accpr_co1);
  printf("mhr rate=%f \n", exp_accpr_mhrefine);
  printf("\n CLOSE FILES \n");
  if (ins_hist != NULL)
    fclose(ins_hist);
  if (ins_fz_best_trace != NULL)
    fclose(ins_fz_best_trace);
  if (ins_fz_best != NULL)
    fclose(ins_fz_best);
  if (ins_fz_better != NULL)
    fclose(ins_fz_better);
  printf("\n FREE SPACE \n");
  free_dvector(grid_points, 1, grid_size);
  free_dvector(freq_ref, 1, grid_size + 1);
  free_dvector(freq_est, 1, grid_size + 1);
  free_dvector(theta, 1, grid_size + 1);
  free_dvector(fx, 1, N_population);
  free_imatrix(x, 1, N_population, 1, N_dimension);
  free_ivector(z_best, 1, N_dimension);
  free_ivector(workvec1, 1, N_dimension);
  free_ivector(workvec2, 1, N_dimension);
  free_dvector(workvec3, 1, grid_size + 1);
  printf("\n\n\n OKAY \n");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
sub    $0x318,%rsp
movl   $0x0,-0xc(%rbp)
mov    %edi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movq   $0x0,-0x1a8(%rbp)
movq   $0x0,-0x1b0(%rbp)
movq   $0x0,-0x1b8(%rbp)
movq   $0x0,-0x1c0(%rbp)
lea    0x2cf3(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
xor    %eax,%eax
mov    %eax,%edi
call   1100 <time@plt>
mov    %rax,%rdi
call   11f0 <setseedrng@plt>
movl   $0x1,-0x4c(%rbp)
cmpl   $0xa,-0x4c(%rbp)
jg     13b0 <main+0x90>
mov    $0x0,%al
call   1060 <uniformrng@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    138c <main+0x6c>
lea    0x2cc0(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    -0x240(%rbp),%rdi
mov    $0x32,%esi
lea    0x2cc3(%rip),%rdx
mov    $0x0,%al
call   10a0 <snprintf@plt>
movl   $0x5,-0x6c(%rbp)
movl   $0x7a120,-0x70(%rbp)
movl   $0x1,-0x5c(%rbp)
movl   $0x1388,-0x60(%rbp)
mov    -0x70(%rbp),%eax
cltd
idivl  -0x60(%rbp)
mov    %eax,-0x64(%rbp)
movl   $0x1388,-0xd4(%rbp)
movsd  0x2c38(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0x2c18(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movl   $0x1388,-0xf4(%rbp)
movsd  0x2c06(%rip),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  0x2bee(%rip),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  0x2bce(%rip),%xmm0
movsd  0x2bce(%rip),%xmm1
call   11c0 <pow@plt>
movsd  %xmm0,-0x108(%rbp)
ff
movsd  0x2b89(%rip),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  0x2b99(%rip),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  0x2b81(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x2b69(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x2b51(%rip),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0xc8,-0xac(%rbp)
movsd  0x2b2f(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a62 <main+0x742>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2bb3(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    152f <main+0x20f>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   11e0 <atoi@plt>
mov    %eax,-0x5c(%rbp)
jmp    1a4f <main+0x72f>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2b74(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    157d <main+0x25d>
lea    -0x240(%rbp),%rdi
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    $0x32,%esi
mov    $0x0,%al
call   10a0 <snprintf@plt>
jmp    1a4a <main+0x72a>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2b2c(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    15ca <main+0x2aa>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   11e0 <atoi@plt>
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cltd
idivl  -0x60(%rbp)
mov    %eax,-0x64(%rbp)
jmp    1a45 <main+0x725>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2ae6(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    160d <main+0x2ed>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   11e0 <atoi@plt>
mov    %eax,-0x6c(%rbp)
jmp    1a40 <main+0x720>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2aa9(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    1677 <main+0x357>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   11e0 <atoi@plt>
mov    %eax,-0x60(%rbp)
cmpl   $0x0,-0x60(%rbp)
jne    1668 <main+0x348>
mov    -0x70(%rbp),%eax
mov    $0x1,%ecx
cltd
idiv   %ecx
mov    %eax,-0x64(%rbp)
jmp    1672 <main+0x352>
mov    -0x70(%rbp),%eax
cltd
idivl  -0x60(%rbp)
mov    %eax,-0x64(%rbp)
jmp    1a3b <main+0x71b>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2a45(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    16bd <main+0x39d>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   11e0 <atoi@plt>
mov    %eax,-0xd4(%rbp)
jmp    1a36 <main+0x716>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2a06(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    1705 <main+0x3e5>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1a31 <main+0x711>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x29c5(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    174d <main+0x42d>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
jmp    1a2c <main+0x70c>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2983(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    1795 <main+0x475>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    1a27 <main+0x707>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2941(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    17dd <main+0x4bd>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1a22 <main+0x702>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2900(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    1823 <main+0x503>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   11e0 <atoi@plt>
mov    %eax,-0xac(%rbp)
jmp    1a1d <main+0x6fd>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x28c1(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    186b <main+0x54b>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1a18 <main+0x6f8>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2880(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    18b3 <main+0x593>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1a13 <main+0x6f3>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2840(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    18f9 <main+0x5d9>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   11e0 <atoi@plt>
mov    %eax,-0xf4(%rbp)
jmp    1a0e <main+0x6ee>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x2801(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    1941 <main+0x621>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x108(%rbp)
ff
jmp    1a09 <main+0x6e9>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x27bf(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    1989 <main+0x669>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0x100(%rbp)
ff
jmp    1a04 <main+0x6e4>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x277e(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    19d1 <main+0x6b1>
mov    -0x18(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1050 <atof@plt>
movsd  %xmm0,-0xf0(%rbp)
ff
jmp    19ff <main+0x6df>
mov    -0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0x273c(%rip),%rdi
call   10d0 <strcmp@plt>
cmp    $0x0,%rax
jne    19fa <main+0x6da>
mov    $0x0,%al
call   1040 <flags_usage@plt>
jmp    19ff <main+0x6df>
jmp    1a04 <main+0x6e4>
jmp    1a09 <main+0x6e9>
jmp    1a0e <main+0x6ee>
jmp    1a13 <main+0x6f3>
jmp    1a18 <main+0x6f8>
jmp    1a1d <main+0x6fd>
jmp    1a22 <main+0x702>
jmp    1a27 <main+0x707>
jmp    1a2c <main+0x70c>
jmp    1a31 <main+0x711>
jmp    1a36 <main+0x716>
jmp    1a3b <main+0x71b>
jmp    1a40 <main+0x720>
jmp    1a45 <main+0x725>
jmp    1a4a <main+0x72a>
jmp    1a4f <main+0x72f>
jmp    1a54 <main+0x734>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14e0 <main+0x1c0>
lea    0x26be(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x5c(%rbp),%esi
lea    0x26cf(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x70(%rbp),%esi
lea    0x26cb(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x6c(%rbp),%esi
lea    0x26cf(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x60(%rbp),%esi
lea    0x26d4(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x64(%rbp),%esi
lea    0x26d5(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0xd4(%rbp),%esi
lea    0x26d5(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movsd  -0xe0(%rbp),%xmm0
ff
lea    0x26d4(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0xd0(%rbp),%xmm0
ff
lea    0x26d1(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0xc0(%rbp),%xmm0
ff
lea    0x26cd(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0xb8(%rbp),%xmm0
ff
lea    0x26c9(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    -0xac(%rbp),%esi
lea    0x26c8(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movsd  -0x90(%rbp),%xmm0
ff
lea    0x26c5(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0xa0(%rbp),%xmm0
ff
lea    0x26c2(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    -0xf4(%rbp),%esi
lea    0x26c7(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movsd  -0x108(%rbp),%xmm0
ff
lea    0x26c9(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0x100(%rbp),%xmm0
ff
lea    0x26c9(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0xf0(%rbp),%xmm0
ff
lea    0x26ca(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0x110(%rbp),%xmm0
ff
lea    0x26ca(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0x118(%rbp),%xmm0
ff
lea    0x26c7(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
lea    0x29ea(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0x26c0(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    -0x240(%rbp),%rdi
lea    -0x68(%rbp),%rsi
lea    -0x74(%rbp),%rdx
lea    -0x78(%rbp),%rcx
call   1230 <get_data@plt>
lea    0x26a6(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    -0x200(%rbp),%rdi
mov    -0x6c(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    $0x32,%esi
lea    0x2693(%rip),%rdx
mov    $0x0,%al
call   10a0 <snprintf@plt>
lea    -0x200(%rbp),%rdi
lea    0x2483(%rip),%rsi
call   11b0 <fopen@plt>
mov    %rax,-0x1a8(%rbp)
lea    -0x200(%rbp),%rdi
mov    -0x6c(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    $0x32,%esi
lea    0x2676(%rip),%rdx
mov    $0x0,%al
call   10a0 <snprintf@plt>
lea    -0x200(%rbp),%rdi
lea    0x2448(%rip),%rsi
call   11b0 <fopen@plt>
mov    %rax,-0x1b0(%rbp)
lea    -0x200(%rbp),%rdi
mov    -0x6c(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    $0x32,%esi
lea    0x2662(%rip),%rdx
mov    $0x0,%al
call   10a0 <snprintf@plt>
lea    -0x200(%rbp),%rdi
lea    0x240d(%rip),%rsi
call   11b0 <fopen@plt>
mov    %rax,-0x1b8(%rbp)
lea    -0x200(%rbp),%rdi
mov    -0x6c(%rbp),%ecx
mov    -0x5c(%rbp),%r8d
mov    $0x32,%esi
lea    0x2648(%rip),%rdx
mov    $0x0,%al
call   10a0 <snprintf@plt>
lea    -0x200(%rbp),%rdi
lea    0x23d2(%rip),%rsi
call   11b0 <fopen@plt>
mov    %rax,-0x1c0(%rbp)
lea    0x2643(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0xac(%rbp),%esi
mov    $0x1,%edi
call   1150 <dvector@plt>
mov    %rax,-0xa8(%rbp)
mov    -0xac(%rbp),%esi
add    $0x1,%esi
mov    $0x1,%edi
call   1150 <dvector@plt>
mov    %rax,-0x80(%rbp)
mov    -0xac(%rbp),%esi
add    $0x1,%esi
mov    $0x1,%edi
call   1150 <dvector@plt>
mov    %rax,-0x98(%rbp)
mov    -0xac(%rbp),%esi
add    $0x1,%esi
mov    $0x1,%edi
call   1150 <dvector@plt>
mov    %rax,-0x88(%rbp)
mov    -0x6c(%rbp),%esi
mov    -0x68(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1030 <imatrix@plt>
mov    %rax,-0x128(%rbp)
mov    -0x6c(%rbp),%esi
mov    $0x1,%edi
call   1150 <dvector@plt>
mov    %rax,-0x120(%rbp)
mov    -0x68(%rbp),%esi
mov    $0x1,%edi
call   11a0 <ivector@plt>
mov    %rax,-0x138(%rbp)
mov    -0x68(%rbp),%esi
mov    $0x1,%edi
call   11a0 <ivector@plt>
mov    %rax,-0x190(%rbp)
mov    -0x68(%rbp),%esi
mov    $0x1,%edi
call   11a0 <ivector@plt>
mov    %rax,-0x198(%rbp)
mov    -0xac(%rbp),%esi
add    $0x1,%esi
mov    $0x1,%edi
call   1150 <dvector@plt>
mov    %rax,-0x1a0(%rbp)
lea    0x2572(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     1e7e <main+0xb5e>
mov    -0x128(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   11d0 <initialise_from_data@plt>
mov    -0x128(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x68(%rbp),%esi
call   1090 <cost@plt>
mov    -0x120(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1e29 <main+0xb09>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movl   $0x0,-0x174(%rbp)
lea    0x2511(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x1,-0x50(%rbp)
mov    -0x120(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movl   $0x2,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     1f22 <main+0xc02>
mov    -0x120(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x130(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1f0f <main+0xbef>
mov    -0x54(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x120(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
jmp    1f14 <main+0xbf4>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1ec3 <main+0xba3>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jg     1f67 <main+0xc47>
mov    -0x128(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x138(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1f29 <main+0xc09>
movsd  -0x130(%rbp),%xmm0
ff
lea    0x22b1(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     2030 <main+0xd10>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     2014 <main+0xcf4>
mov    -0x138(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x78(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    1fd2 <main+0xcb2>
lea    0x25ae(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x138(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x78(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    2001 <main+0xce1>
lea    0x23cc(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    2006 <main+0xce6>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1f97 <main+0xc77>
lea    0x25c9(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1f84 <main+0xc64>
lea    0x25ad(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0x2383(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0x23a1(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x80(%rbp),%rdi
mov    -0xac(%rbp),%esi
movsd  -0x90(%rbp),%xmm0
ff
call   1200 <self_adj_desired_freq@plt>
lea    0x23a3(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0xac(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     20bb <main+0xd9b>
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2086 <main+0xd66>
lea    0x237c(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0xa8(%rbp),%rdi
mov    -0xac(%rbp),%esi
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm1
ff
call   1180 <self_adj_grid_points@plt>
lea    0x2368(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0xac(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     2135 <main+0xe15>
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2100 <main+0xde0>
cmpl   $0x1f4,-0xac(%rbp)
jge    228a <main+0xf6a>
lea    0x2323(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xac(%rbp),%eax
jg     2209 <main+0xee9>
mov    -0x4c(%rbp),%eax
mov    %eax,-0x254(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x248(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x250(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1140 <exp@plt>
mov    -0x254(%rbp),%esi
movsd  -0x250(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x248(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
lea    0x22b7(%rip),%rdi
mov    $0x5,%al
call   1080 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    215a <main+0xe3a>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x264(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x260(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1140 <exp@plt>
mov    -0x264(%rbp),%esi
movsd  -0x260(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
lea    0x222b(%rip),%rdi
xorps  %xmm0,%xmm0
mov    $0x5,%al
call   1080 <printf@plt>
lea    0x2238(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movl   $0x0,-0x178(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movl   $0x0,-0x17c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movl   $0x0,-0x180(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movl   $0x0,-0x184(%rbp)
lea    0x21f2(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x70(%rbp),%eax
jg     299d <main+0x167d>
mov    -0x58(%rbp),%eax
cmp    -0xf4(%rbp),%eax
jg     2339 <main+0x1019>
movsd  -0x100(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    239a <main+0x107a>
cvtsi2sdl -0xf4(%rbp),%xmm0
ff
cvtsi2sdl -0x58(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x270(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm1
ff
call   11c0 <pow@plt>
movaps %xmm0,%xmm2
movsd  -0x270(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
cmpl   $0x1,-0x6c(%rbp)
jne    23bb <main+0x109b>
mov    $0x1,%edi
mov    $0x2,%esi
call   1130 <integerrng@plt>
mov    %eax,-0x48(%rbp)
jmp    23cd <main+0x10ad>
mov    $0x1,%edi
mov    $0x3,%esi
call   1130 <integerrng@plt>
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %rax,-0x278(%rbp)
sub    $0x3,%rax
ja     27aa <main+0x148a>
mov    -0x278(%rbp),%rax
lea    0x1c61(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     2477 <main+0x1157>
mov    -0x128(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x120(%rbp),%rsi
movslq -0x54(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x68(%rbp),%edx
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x190(%rbp),%r9
mov    $0x5,%ecx
lea    -0x140(%rbp),%r8
call   1110 <MH_Kpoint_int@plt>
movsd  -0x140(%rbp),%xmm0
ff
addsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    2407 <main+0x10e7>
movsd  -0x20(%rbp),%xmm0
cvtsi2sdl -0x54(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
addsd  -0x150(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x178(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x178(%rbp)
jmp    27af <main+0x148f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     2559 <main+0x1239>
mov    -0x128(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x120(%rbp),%rsi
movslq -0x54(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x68(%rbp),%edx
mov    -0x98(%rbp),%rcx
mov    -0xa8(%rbp),%r8
mov    -0xac(%rbp),%r9d
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x190(%rbp),%rax
lea    -0x140(%rbp),%r10
movl   $0x2,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1240 <Mutation_int_Kpoint@plt>
movsd  -0x140(%rbp),%xmm0
ff
addsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    24c8 <main+0x11a8>
movsd  -0x20(%rbp),%xmm0
cvtsi2sdl -0x54(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
addsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x17c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x17c(%rbp)
jmp    27af <main+0x148f>
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jg     26f6 <main+0x13d6>
mov    -0x128(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x2b0(%rbp)
mov    -0x120(%rbp),%rax
movslq -0x54(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x2a8(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x29c(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0x298(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,-0x290(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,-0x284(%rbp)
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x280(%rbp)
ff
mov    $0x19,%eax
cmp    -0x6c(%rbp),%eax
jge    263c <main+0x131c>
mov    $0x19,%eax
mov    %eax,-0x2b4(%rbp)
jmp    2645 <main+0x1325>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x2b4(%rbp)
mov    -0x2b4(%rbp),%ecx
mov    $0x5,%eax
cmp    %ecx,%eax
jle    2668 <main+0x1348>
mov    $0x5,%eax
mov    %eax,-0x2b8(%rbp)
jmp    269b <main+0x137b>
mov    $0x19,%eax
cmp    -0x6c(%rbp),%eax
jge    2686 <main+0x1366>
mov    $0x19,%eax
mov    %eax,-0x2bc(%rbp)
jmp    268f <main+0x136f>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x2bc(%rbp)
mov    -0x2bc(%rbp),%eax
mov    %eax,-0x2b8(%rbp)
movsd  -0x280(%rbp),%xmm0
ff
mov    -0x284(%rbp),%r9d
mov    -0x290(%rbp),%r8
mov    -0x298(%rbp),%rcx
mov    -0x29c(%rbp),%edx
mov    -0x2a8(%rbp),%rsi
mov    -0x2b0(%rbp),%rdi
mov    -0x2b8(%rbp),%r10d
mov    -0x190(%rbp),%rax
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
call   1210 <Mutation_int_Gibbs@plt>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    25a2 <main+0x1282>
movsd  0x193a(%rip),%xmm0
addsd  -0x160(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x180(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x180(%rbp)
jmp    27af <main+0x148f>
mov    -0x128(%rbp),%rdi
mov    -0x120(%rbp),%rsi
mov    -0x68(%rbp),%edx
mov    -0x6c(%rbp),%ecx
mov    -0x98(%rbp),%r8
mov    -0xa8(%rbp),%r9
mov    -0xac(%rbp),%ebx
movsd  -0xe8(%rbp),%xmm0
ff
mov    -0x190(%rbp),%r10
mov    -0x198(%rbp),%rax
lea    -0x140(%rbp),%r11
mov    %ebx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
call   10b0 <Crossover_int_Kpoint@plt>
movsd  -0x140(%rbp),%xmm0
ff
addsd  -0x168(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
mov    -0x184(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x184(%rbp)
jmp    27af <main+0x148f>
jmp    27af <main+0x148f>
mov    -0x58(%rbp),%eax
cmp    -0xd4(%rbp),%eax
jg     27d3 <main+0x14b3>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    2828 <main+0x1508>
cvtsi2sdl -0xd4(%rbp),%xmm0
ff
cvtsi2sdl -0x58(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2c8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
call   11c0 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x2c8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x120(%rbp),%rdi
mov    -0x6c(%rbp),%esi
mov    -0x98(%rbp),%rdx
mov    -0xa8(%rbp),%rcx
mov    -0xac(%rbp),%r8d
mov    -0x80(%rbp),%r9
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x1a0(%rbp),%rax
mov    %rax,(%rsp)
call   1160 <self_adj_theta_update@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0xac(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     28b1 <main+0x1591>
mov    -0x1a0(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    286a <main+0x154a>
mov    -0x138(%rbp),%rdi
mov    -0x128(%rbp),%rdx
mov    -0x120(%rbp),%rcx
mov    -0x68(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
lea    -0x130(%rbp),%rsi
call   10c0 <update_best_value@plt>
cmpl   $0x0,-0x58(%rbp)
jle    2927 <main+0x1607>
mov    -0x58(%rbp),%eax
cltd
idivl  -0x64(%rbp)
cmp    $0x0,%edx
jne    2927 <main+0x1607>
cmpl   $0x0,-0x60(%rbp)
jle    2927 <main+0x1607>
mov    -0x58(%rbp),%esi
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm1
ff
movsd  -0x130(%rbp),%xmm2
ff
lea    0x1be2(%rip),%rdi
mov    $0x3,%al
call   1080 <printf@plt>
cmpq   $0x0,-0x1b0(%rbp)
je     298a <main+0x166a>
cmpl   $0x0,-0x58(%rbp)
jle    2985 <main+0x1665>
mov    -0x58(%rbp),%eax
cltd
idivl  -0x64(%rbp)
cmp    $0x0,%edx
jne    2985 <main+0x1665>
cmpl   $0x0,-0x60(%rbp)
jle    2985 <main+0x1665>
mov    -0x1b0(%rbp),%rdi
mov    -0x58(%rbp),%edx
movsd  -0x130(%rbp),%xmm0
ff
lea    0x1bb5(%rip),%rsi
mov    $0x1,%al
call   10e0 <fprintf@plt>
mov    -0x1b0(%rbp),%rdi
call   1120 <fflush@plt>
jmp    298a <main+0x166a>
jmp    298f <main+0x166f>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    2301 <main+0xfe1>
lea    0x1b8b(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0xac(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     29f2 <main+0x16d2>
cvtsi2sdl -0x70(%rbp),%xmm1
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    29b2 <main+0x1692>
mov    -0x98(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x88(%rbp),%rdx
mov    -0xac(%rbp),%ecx
movsd  -0xa0(%rbp),%xmm0
ff
call   1220 <self_adj_theta_norm@plt>
cmpq   $0x0,-0x1a8(%rbp)
je     2b92 <main+0x1872>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0xac(%rbp),%eax
jg     2af0 <main+0x17d0>
mov    -0x1a8(%rbp),%rax
mov    %rax,-0x2e8(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x2dc(%rbp)
mov    -0xa8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2d0(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2d8(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1140 <exp@plt>
mov    -0x2e8(%rbp),%rdi
mov    -0x2dc(%rbp),%edx
movsd  -0x2d8(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movsd  -0x2d0(%rbp),%xmm0
ff
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
lea    0x1a71(%rip),%rsi
mov    $0x5,%al
call   10e0 <fprintf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2a2c <main+0x170c>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x1a8(%rbp),%rax
mov    %rax,-0x300(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x2f4(%rbp)
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x2f0(%rbp)
ff
mov    -0x98(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1140 <exp@plt>
mov    -0x300(%rbp),%rdi
mov    -0x2f4(%rbp),%edx
movsd  -0x2f0(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
mov    -0x80(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x88(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
lea    0x19d0(%rip),%rsi
xorps  %xmm0,%xmm0
mov    $0x5,%al
call   10e0 <fprintf@plt>
mov    -0x1a8(%rbp),%rdi
call   1120 <fflush@plt>
lea    0x19c7(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpq   $0x0,-0x1b8(%rbp)
je     2c87 <main+0x1967>
mov    -0x1b8(%rbp),%rdi
movsd  -0x130(%rbp),%xmm0
ff
lea    0x1663(%rip),%rsi
mov    $0x1,%al
call   10e0 <fprintf@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     2c51 <main+0x1931>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     2c2e <main+0x190e>
mov    -0x1b8(%rbp),%rdi
mov    -0x138(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x78(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0x195e(%rip),%rsi
mov    $0x0,%al
call   10e0 <fprintf@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2be5 <main+0x18c5>
mov    -0x1b8(%rbp),%rdi
lea    0x19a8(%rip),%rsi
mov    $0x0,%al
call   10e0 <fprintf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2bd2 <main+0x18b2>
mov    -0x1b8(%rbp),%rdi
lea    0x1985(%rip),%rsi
mov    $0x0,%al
call   10e0 <fprintf@plt>
mov    -0x1b8(%rbp),%rdi
lea    0x1970(%rip),%rsi
mov    $0x0,%al
call   10e0 <fprintf@plt>
mov    -0x1b8(%rbp),%rdi
call   1120 <fflush@plt>
lea    0x18ed(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpq   $0x0,-0x1c0(%rbp)
je     2e6b <main+0x1b4b>
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x38(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jg     2ced <main+0x19cd>
mov    -0x138(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x190(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2cb7 <main+0x1997>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movl   $0x0,-0x188(%rbp)
movl   $0x1,-0x4c(%rbp)
cmpl   $0x2710,-0x4c(%rbp)
jg     2d79 <main+0x1a59>
mov    -0x190(%rbp),%rdi
mov    -0x68(%rbp),%edx
movsd  -0x118(%rbp),%xmm0
ff
mov    -0x198(%rbp),%r9
lea    -0x38(%rbp),%rsi
mov    $0x5,%ecx
lea    -0x140(%rbp),%r8
call   1110 <MH_Kpoint_int@plt>
movsd  -0x140(%rbp),%xmm0
ff
addsd  -0x170(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x188(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x188(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2d09 <main+0x19e9>
cvtsi2sdl -0x188(%rbp),%xmm1
ff
movsd  -0x170(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
mov    -0x1c0(%rbp),%rdi
movsd  -0x38(%rbp),%xmm0
lea    0x147f(%rip),%rsi
mov    $0x1,%al
call   10e0 <fprintf@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     2e35 <main+0x1b15>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     2e12 <main+0x1af2>
mov    -0x1c0(%rbp),%rdi
mov    -0x190(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x78(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0x177a(%rip),%rsi
mov    $0x0,%al
call   10e0 <fprintf@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2dc9 <main+0x1aa9>
mov    -0x1c0(%rbp),%rdi
lea    0x17c4(%rip),%rsi
mov    $0x0,%al
call   10e0 <fprintf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2db6 <main+0x1a96>
mov    -0x1c0(%rbp),%rdi
lea    0x17a1(%rip),%rsi
mov    $0x0,%al
call   10e0 <fprintf@plt>
mov    -0x1c0(%rbp),%rdi
lea    0x178c(%rip),%rsi
mov    $0x0,%al
call   10e0 <fprintf@plt>
mov    -0x1c0(%rbp),%rdi
call   1120 <fflush@plt>
lea    0x1722(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0x1720(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movsd  -0x130(%rbp),%xmm0
ff
lea    0x1718(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
lea    0x1718(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     2f5e <main+0x1c3e>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     2f42 <main+0x1c22>
mov    -0x138(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x78(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    2f00 <main+0x1be0>
lea    0x1680(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x138(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x78(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    2f2f <main+0x1c0f>
lea    0x149e(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    2f34 <main+0x1c14>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2ec5 <main+0x1ba5>
lea    0x169b(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2eb2 <main+0x1b92>
lea    0x167f(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movsd  -0x38(%rbp),%xmm0
lea    0x1650(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
lea    0x1652(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x74(%rbp),%eax
jg     3040 <main+0x1d20>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x78(%rbp),%eax
jg     3024 <main+0x1d04>
mov    -0x190(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x78(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    2fe2 <main+0x1cc2>
lea    0x159e(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x190(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x78(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    3011 <main+0x1cf1>
lea    0x13bc(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
jmp    3016 <main+0x1cf6>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    2fa7 <main+0x1c87>
lea    0x15b9(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    2f94 <main+0x1c74>
lea    0x159d(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
lea    0x1591(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cvtsi2sdl -0x178(%rbp),%xmm1
ff
movsd  -0x150(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
cvtsi2sdl -0x17c(%rbp),%xmm1
ff
movsd  -0x158(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
cvtsi2sdl -0x180(%rbp),%xmm1
ff
movsd  -0x160(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
cvtsi2sdl -0x184(%rbp),%xmm1
ff
movsd  -0x168(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
lea    0x1524(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0x150(%rbp),%xmm0
ff
lea    0x151c(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0x158(%rbp),%xmm0
ff
lea    0x1514(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0x160(%rbp),%xmm0
ff
lea    0x150c(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0x168(%rbp),%xmm0
ff
lea    0x1504(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
movsd  -0x170(%rbp),%xmm0
ff
lea    0x14fc(%rip),%rdi
mov    $0x1,%al
call   1080 <printf@plt>
lea    0x14fc(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
cmpq   $0x0,-0x1a8(%rbp)
je     3178 <main+0x1e58>
mov    -0x1a8(%rbp),%rdi
call   1070 <fclose@plt>
cmpq   $0x0,-0x1b0(%rbp)
je     3192 <main+0x1e72>
mov    -0x1b0(%rbp),%rdi
call   1070 <fclose@plt>
cmpq   $0x0,-0x1b8(%rbp)
je     31ac <main+0x1e8c>
mov    -0x1b8(%rbp),%rdi
call   1070 <fclose@plt>
cmpq   $0x0,-0x1c0(%rbp)
je     31c6 <main+0x1ea6>
mov    -0x1c0(%rbp),%rdi
call   1070 <fclose@plt>
lea    0x1496(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
mov    -0xa8(%rbp),%rdi
mov    -0xac(%rbp),%edx
mov    $0x1,%esi
call   1190 <free_dvector@plt>
mov    -0x80(%rbp),%rdi
mov    -0xac(%rbp),%edx
add    $0x1,%edx
mov    $0x1,%esi
call   1190 <free_dvector@plt>
mov    -0x88(%rbp),%rdi
mov    -0xac(%rbp),%edx
add    $0x1,%edx
mov    $0x1,%esi
call   1190 <free_dvector@plt>
mov    -0x98(%rbp),%rdi
mov    -0xac(%rbp),%edx
add    $0x1,%edx
mov    $0x1,%esi
call   1190 <free_dvector@plt>
mov    -0x120(%rbp),%rdi
mov    -0x6c(%rbp),%edx
mov    $0x1,%esi
call   1190 <free_dvector@plt>
mov    -0x128(%rbp),%rdi
mov    -0x6c(%rbp),%edx
mov    -0x68(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   10f0 <free_imatrix@plt>
mov    -0x138(%rbp),%rdi
mov    -0x68(%rbp),%edx
mov    $0x1,%esi
call   1170 <free_ivector@plt>
mov    -0x190(%rbp),%rdi
mov    -0x68(%rbp),%edx
mov    $0x1,%esi
call   1170 <free_ivector@plt>
mov    -0x198(%rbp),%rdi
mov    -0x68(%rbp),%edx
mov    $0x1,%esi
call   1170 <free_ivector@plt>
mov    -0x1a0(%rbp),%rdi
mov    -0xac(%rbp),%edx
add    $0x1,%edx
mov    $0x1,%esi
call   1190 <free_dvector@plt>
lea    0x13b1(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
xor    %eax,%eax
add    $0x318,%rsp
pop    %rbx
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x248,%rsp
mov    %rsi,%rbp
mov    %edi,%ebx
lea    0x3053(%rip),%rdi
call   1060 <puts@plt>
xor    %edi,%edi
call   1140 <time@plt>
mov    %rax,%rdi
call   1230 <setseedrng@plt>
xor    %eax,%eax
call   1080 <uniformrng@plt>
xor    %eax,%eax
call   1080 <uniformrng@plt>
xor    %eax,%eax
call   1080 <uniformrng@plt>
xor    %eax,%eax
call   1080 <uniformrng@plt>
xor    %eax,%eax
call   1080 <uniformrng@plt>
xor    %eax,%eax
call   1080 <uniformrng@plt>
xor    %eax,%eax
call   1080 <uniformrng@plt>
xor    %eax,%eax
call   1080 <uniformrng@plt>
xor    %eax,%eax
call   1080 <uniformrng@plt>
xor    %eax,%eax
call   1080 <uniformrng@plt>
lea    0x3008(%rip),%rdi
call   1060 <puts@plt>
lea    0x2c76(%rip),%rdx
lea    0x1d0(%rsp),%rdi
mov    $0x32,%esi
xor    %eax,%eax
call   10c0 <snprintf@plt>
cmp    $0x2,%ebx
jl     18d6 <main+0x576>
movsd  0x2c29(%rip),%xmm0
movsd  %xmm0,0x90(%rsp)
movsd  0x2c10(%rip),%xmm0
movsd  %xmm0,0x108(%rsp)
movl   $0x7a120,0x34(%rsp)
mov    $0xc8,%eax
mov    %rax,0x88(%rsp)
movsd  0x2be2(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
movsd  0x2bcc(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x2bb6(%rip),%xmm0
movsd  %xmm0,0x128(%rsp)
movsd  0x2b95(%rip),%xmm0
movsd  %xmm0,0x120(%rsp)
movsd  0x2b8c(%rip),%xmm1
movsd  0x2b74(%rip),%xmm0
movsd  %xmm0,0xf0(%rsp)
mov    $0x5,%eax
mov    %rax,0x20(%rsp)
movl   $0x64,0x44(%rsp)
movl   $0x1388,0x40(%rsp)
mov    $0x1,%r13d
lea    0x2bc2(%rip),%r15
movsd  %xmm1,0xe8(%rsp)
movsd  %xmm1,0x100(%rsp)
mov    $0x1,%r14d
movl   $0x1388,0x58(%rsp)
movl   $0x1388,0x5c(%rsp)
jmp    150f <main+0x1af>
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1220 <atoi@plt>
mov    %eax,%r14d
add    $0x1,%r13d
cmp    %ebx,%r13d
jge    19a6 <main+0x646>
movslq %r13d,%r12
mov    0x0(%rbp,%r12,8),%rsi
mov    %r15,%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     14f0 <main+0x190>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2b52(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     16f0 <main+0x390>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2b3e(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     1713 <main+0x3b3>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2b2b(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     1734 <main+0x3d4>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2b17(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     174d <main+0x3ed>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2b03(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     1776 <main+0x416>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2af0(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     178e <main+0x42e>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2add(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     17c0 <main+0x460>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2ac9(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     17dd <main+0x47d>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2ab5(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     17f7 <main+0x497>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2aa2(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     1811 <main+0x4b1>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2a8f(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     182d <main+0x4cd>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2a7c(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     184a <main+0x4ea>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2a6a(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     1867 <main+0x507>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2a57(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     187f <main+0x51f>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2a43(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     189c <main+0x53c>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2a30(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
je     18b9 <main+0x559>
mov    0x0(%rbp,%r12,8),%rsi
lea    0x2a1c(%rip),%rdi
call   1110 <strcmp@plt>
test   %rax,%rax
jne    1502 <main+0x1a2>
xor    %eax,%eax
call   1050 <flags_usage@plt>
jmp    1502 <main+0x1a2>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdx
lea    0x1d0(%rsp),%rdi
mov    $0x32,%esi
xor    %eax,%eax
call   10c0 <snprintf@plt>
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1220 <atoi@plt>
mov    %eax,0x34(%rsp)
cltd
idivl  0x40(%rsp)
mov    %eax,0x44(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1220 <atoi@plt>
mov    %rax,0x20(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1220 <atoi@plt>
test   %eax,%eax
je     17ab <main+0x44b>
mov    %eax,%ecx
mov    0x34(%rsp),%eax
cltd
mov    %ecx,0x40(%rsp)
idiv   %ecx
mov    %eax,0x44(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1220 <atoi@plt>
mov    %eax,0x5c(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1070 <atof@plt>
movsd  %xmm0,0x100(%rsp)
jmp    1502 <main+0x1a2>
movl   $0x0,0x40(%rsp)
mov    0x34(%rsp),%eax
mov    %eax,0x44(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1070 <atof@plt>
movsd  %xmm0,0x128(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1070 <atof@plt>
movsd  %xmm0,0x10(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1070 <atof@plt>
movsd  %xmm0,0x28(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1220 <atoi@plt>
mov    %rax,0x88(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1070 <atof@plt>
movsd  %xmm0,0x90(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1070 <atof@plt>
movsd  %xmm0,0x108(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1220 <atoi@plt>
mov    %eax,0x58(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1070 <atof@plt>
movsd  %xmm0,0xf0(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1070 <atof@plt>
movsd  %xmm0,0xe8(%rsp)
jmp    1502 <main+0x1a2>
lea    0x1(%r12),%r13d
mov    0x8(%rbp,%r12,8),%rdi
call   1070 <atof@plt>
movsd  %xmm0,0x120(%rsp)
jmp    1502 <main+0x1a2>
mov    $0x1,%r14d
movl   $0x64,0x44(%rsp)
mov    $0x5,%eax
mov    %rax,0x20(%rsp)
movsd  0x270a(%rip),%xmm0
movsd  %xmm0,0xf0(%rsp)
movsd  0x2701(%rip),%xmm0
movsd  %xmm0,0x120(%rsp)
movsd  0x26f8(%rip),%xmm1
movl   $0x1388,0x5c(%rsp)
movsd  0x26f0(%rip),%xmm0
movsd  %xmm0,0x128(%rsp)
movsd  0x26e7(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x26e1(%rip),%xmm0
movsd  %xmm0,0x28(%rsp)
mov    $0xc8,%eax
mov    %rax,0x88(%rsp)
movl   $0x7a120,0x34(%rsp)
movsd  0x26c6(%rip),%xmm0
movsd  %xmm0,0x108(%rsp)
movsd  0x26bd(%rip),%xmm0
movsd  %xmm0,0x90(%rsp)
movl   $0x1388,0x58(%rsp)
movsd  %xmm1,0x100(%rsp)
movsd  %xmm1,0xe8(%rsp)
movl   $0x1388,0x40(%rsp)
lea    0x2a55(%rip),%rdi
call   1060 <puts@plt>
lea    0x273a(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0x2736(%rip),%rdi
mov    0x34(%rsp),%esi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0x2739(%rip),%rdi
mov    0x20(%rsp),%r12
mov    %r12d,%esi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0x2739(%rip),%rdi
mov    0x40(%rsp),%esi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0x2739(%rip),%rdi
mov    0x44(%rsp),%esi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0x273b(%rip),%rdi
mov    0x5c(%rsp),%esi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0x273e(%rip),%rdi
movsd  0x100(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x273a(%rip),%rdi
movsd  0x128(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x2735(%rip),%rdi
movsd  0x10(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x2733(%rip),%rdi
movsd  0x28(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x2732(%rip),%rdi
mov    0x88(%rsp),%r13
mov    %r13d,%esi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0x272c(%rip),%rdi
movsd  0x90(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x2728(%rip),%rdi
movsd  0x108(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x272a(%rip),%rdi
mov    0x58(%rsp),%esi
xor    %eax,%eax
call   10a0 <printf@plt>
lea    0x2730(%rip),%rdi
movsd  0xf0(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x272f(%rip),%rdi
movsd  0xe8(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x272f(%rip),%rdi
movsd  0x120(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x272e(%rip),%rdi
movsd  0x250c(%rip),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x272b(%rip),%rdi
movsd  0x2506(%rip),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x28d1(%rip),%rdi
call   1060 <puts@plt>
lea    0x1d0(%rsp),%rdi
lea    0xc(%rsp),%rsi
lea    0x1c(%rsp),%rdx
lea    0x18(%rsp),%rcx
call   1270 <get_data@plt>
lea    0x28b4(%rip),%rdi
call   1060 <puts@plt>
lea    0x26ec(%rip),%rdx
lea    0x210(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x32,%esi
mov    %r12d,%ecx
mov    %r14d,%r8d
xor    %eax,%eax
call   10c0 <snprintf@plt>
lea    0x2509(%rip),%rbp
mov    %rbx,%rdi
mov    %rbp,%rsi
call   11f0 <fopen@plt>
mov    %rax,0x138(%rsp)
lea    0x26cc(%rip),%rdx
mov    %rbx,%rdi
mov    $0x32,%esi
mov    %r12d,%ecx
mov    %r14d,%r8d
xor    %eax,%eax
call   10c0 <snprintf@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   11f0 <fopen@plt>
mov    %rax,0x148(%rsp)
lea    0x26c4(%rip),%rdx
mov    %rbx,%rdi
mov    $0x32,%esi
mov    %r12d,%ecx
mov    %r14d,%r8d
xor    %eax,%eax
call   10c0 <snprintf@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   11f0 <fopen@plt>
mov    %rax,0x130(%rsp)
lea    0x26b6(%rip),%rdx
mov    %rbx,%rdi
mov    $0x32,%esi
mov    %r12d,%ecx
mov    %r14d,%r8d
xor    %eax,%eax
call   10c0 <snprintf@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   11f0 <fopen@plt>
mov    %rax,0xf8(%rsp)
lea    0x27ea(%rip),%rdi
call   1060 <puts@plt>
mov    $0x1,%edi
mov    %r13d,%esi
call   1190 <dvector@plt>
mov    %rax,0x80(%rsp)
lea    0x1(%r13),%ebx
mov    $0x1,%edi
mov    %ebx,%esi
call   1190 <dvector@plt>
mov    %rax,0x78(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
call   1190 <dvector@plt>
mov    %rax,0xb8(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
call   1190 <dvector@plt>
mov    %rax,0xb0(%rsp)
mov    0xc(%rsp),%ecx
mov    $0x1,%edi
mov    %r12d,%esi
mov    $0x1,%edx
call   1040 <imatrix@plt>
mov    %rax,%rbp
mov    $0x1,%edi
mov    %r12d,%esi
call   1190 <dvector@plt>
mov    %rax,%r15
mov    0xc(%rsp),%esi
mov    $0x1,%edi
call   11e0 <ivector@plt>
mov    %rax,%r14
mov    0xc(%rsp),%esi
mov    $0x1,%edi
call   11e0 <ivector@plt>
mov    %rax,0x68(%rsp)
mov    0xc(%rsp),%esi
mov    $0x1,%edi
call   11e0 <ivector@plt>
mov    %rax,0x140(%rsp)
mov    $0x1,%edi
mov    %ebx,0x38(%rsp)
mov    %ebx,%esi
call   1190 <dvector@plt>
mov    %rax,0xe0(%rsp)
lea    0x2732(%rip),%rdi
call   1060 <puts@plt>
test   %r12d,%r12d
mov    %rbp,%r12
jle    1d75 <main+0xa15>
mov    0x20(%rsp),%rax
lea    0x1(%rax),%ebx
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r12,%rbp,8),%rdi
call   1210 <initialise_from_data@plt>
mov    (%r12,%rbp,8),%rdi
mov    0xc(%rsp),%esi
call   10b0 <cost@plt>
movsd  %xmm0,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1d50 <main+0x9f0>
lea    0x26fd(%rip),%rdi
call   1060 <puts@plt>
movsd  0x8(%r15),%xmm0
movsd  %xmm0,0x48(%rsp)
mov    0x20(%rsp),%rax
cmp    $0x2,%eax
jge    1d9e <main+0xa3e>
mov    $0x1,%ebp
jmp    1dca <main+0xa6a>
mov    %eax,%ecx
lea    -0x1(%rcx),%rdx
add    $0xfffffffffffffffe,%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    333e <main+0x1fde>
mov    $0x1,%ebp
mov    $0x2,%ecx
test   %rax,%rax
jne    1ede <main+0xb7e>
mov    %r15,0x98(%rsp)
cmpl   $0x0,0xc(%rsp)
jle    1e07 <main+0xaa7>
movslq %ebp,%rax
mov    (%r12,%rax,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x4(%rax,%rcx,4),%edx
mov    %edx,0x4(%r14,%rcx,4)
movslq 0xc(%rsp),%rdx
add    $0x1,%rcx
cmp    %rdx,%rcx
jl     1df0 <main+0xa90>
mov    %r12,0xc0(%rsp)
lea    0x23bb(%rip),%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
cmpl   $0x0,0x1c(%rsp)
jle    1ef8 <main+0xb98>
mov    $0x1,%r15d
xor    %ebp,%ebp
jmp    1e5f <main+0xaff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%r15),%eax
add    $0x1,%ebp
cmp    0x1c(%rsp),%r15d
mov    %eax,%r15d
jge    1ef8 <main+0xb98>
mov    0x18(%rsp),%eax
test   %eax,%eax
jle    1e40 <main+0xae0>
mov    $0x1,%r12d
xor    %ebx,%ebx
jmp    1e92 <main+0xb32>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,(%r14,%rcx,4)
je     1ec0 <main+0xb60>
add    $0x1,%r12
add    $0x1,%ebx
cmp    %eax,%ebx
jge    1e40 <main+0xae0>
mov    %ebp,%ecx
imul   %eax,%ecx
movslq %ecx,%rcx
add    %r12,%rcx
cmpl   $0x1,(%r14,%rcx,4)
jne    1e80 <main+0xb20>
mov    $0x20,%edi
call   1030 <putchar@plt>
mov    0x18(%rsp),%eax
mov    %ebp,%ecx
imul   %eax,%ecx
add    %r12d,%ecx
movslq %ecx,%rcx
jmp    1e80 <main+0xb20>
nop
mov    $0x58,%edi
call   1030 <putchar@plt>
mov    0x18(%rsp),%eax
jmp    1e87 <main+0xb27>
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
je     1dca <main+0xa6a>
movsd  (%r15,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ed0 <main+0xb70>
movsd  %xmm1,0x48(%rsp)
movapd %xmm1,%xmm0
mov    %ecx,%ebp
jmp    1ed0 <main+0xb70>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x258a(%rip),%rdi
call   1060 <puts@plt>
lea    0x25a9(%rip),%rdi
call   1060 <puts@plt>
mov    0x78(%rsp),%r15
mov    %r15,%rdi
mov    0x88(%rsp),%rbx
mov    %ebx,%esi
movsd  0x90(%rsp),%xmm0
call   1240 <self_adj_desired_freq@plt>
lea    0x25a3(%rip),%rdi
call   1060 <puts@plt>
mov    0x38(%rsp),%r13d
movslq %r13d,%rax
mov    %rax,0x160(%rsp)
test   %ebx,%ebx
mov    %rbx,0x88(%rsp)
js     206b <main+0xd0b>
mov    0xb0(%rsp),%rax
lea    0x8(%rax),%rdi
cmp    $0x2,%r13d
mov    $0x1,%ebp
cmovge %r13d,%ebp
shl    $0x3,%rbp
xor    %esi,%esi
mov    %rbp,%rdx
call   10d0 <memset@plt>
lea    0x2572(%rip),%rdi
call   1060 <puts@plt>
mov    0x80(%rsp),%rdi
mov    %ebx,%esi
movsd  0x10(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
call   11c0 <self_adj_grid_points@plt>
lea    0x2566(%rip),%rdi
call   1060 <puts@plt>
mov    0xb8(%rsp),%r12
mov    %r12,%rdi
add    $0x8,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   10d0 <memset@plt>
cmp    $0x1f4,%ebx
jae    210a <main+0xdaa>
lea    0x2639(%rip),%rdi
call   1060 <puts@plt>
test   %ebx,%ebx
mov    0x80(%rsp),%r13
je     20b2 <main+0xd52>
mov    0x38(%rsp),%ebx
mov    $0x1,%ebp
nopw   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbp,8),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  (%r12,%rbp,8),%xmm0
movsd  %xmm0,0x28(%rsp)
call   1180 <exp@plt>
movaps %xmm0,%xmm2
movsd  (%r15,%rbp,8),%xmm3
mov    0xb0(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm4
lea    0x22b0(%rip),%rdi
mov    %ebp,%esi
movsd  0x10(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
mov    $0x5,%al
call   10a0 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    2010 <main+0xcb0>
jmp    20b2 <main+0xd52>
lea    0x2494(%rip),%rdi
call   1060 <puts@plt>
mov    0x80(%rsp),%rdi
mov    %ebx,%esi
movsd  0x10(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
call   11c0 <self_adj_grid_points@plt>
lea    0x2488(%rip),%rdi
call   1060 <puts@plt>
lea    0x2580(%rip),%rdi
call   1060 <puts@plt>
mov    0xb8(%rsp),%r12
mov    0x160(%rsp),%rbx
movsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,0x10(%rsp)
call   1180 <exp@plt>
movapd %xmm0,%xmm2
movsd  (%r15,%rbx,8),%xmm3
mov    0xb0(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm4
lea    0x2212(%rip),%rdi
xorpd  %xmm0,%xmm0
mov    0x38(%rsp),%r13d
mov    %r13d,%esi
movsd  0x10(%rsp),%xmm1
mov    $0x5,%al
call   10a0 <printf@plt>
mov    0x88(%rsp),%rbx
lea    0x2424(%rip),%rdi
call   1060 <puts@plt>
lea    0x2433(%rip),%rdi
call   1060 <puts@plt>
cmpl   $0x0,0x34(%rsp)
mov    %r14,0x118(%rsp)
jle    2a0e <main+0x16ae>
movsd  0xe8(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl 0x58(%rsp),%xmm1
movsd  %xmm1,0x1b8(%rsp)
addsd  0xf0(%rsp),%xmm0
movsd  %xmm0,0x1c8(%rsp)
xor    %r11d,%r11d
mov    0x20(%rsp),%rdx
cmp    $0x1,%edx
sete   %r11b
cmp    $0x19,%edx
mov    $0x19,%ecx
cmovl  %edx,%ecx
cmp    $0x6,%ecx
mov    $0x5,%eax
cmovl  %eax,%ecx
mov    %rcx,0x180(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x5c(%rsp),%xmm0
movsd  %xmm0,0x1b0(%rsp)
mov    %rdx,0x20(%rsp)
lea    0x1(%rdx),%r9d
cmp    $0x2,%r13d
mov    $0x1,%edx
mov    $0x1,%eax
cmovge %r13d,%eax
lea    0x1(%rax),%rcx
mov    %rcx,0x1a8(%rsp)
mov    0xb0(%rsp),%r13
lea    0x8(,%rax,8),%r8
add    %r13,%r8
mov    %r13,%rcx
add    $0x8,%rcx
mov    0xe0(%rsp),%rbp
lea    0x8(,%rax,8),%r10
add    %rbp,%r10
mov    %rbp,%rsi
add    $0x8,%rsi
lea    -0x4(%rax),%rdi
mov    %rdi,0x1a0(%rsp)
shr    $0x2,%rdi
add    $0x1,%rdi
xor    $0x3,%r11d
mov    %r11d,0x15c(%rsp)
cmp    %r10,%rcx
setb   %r10b
cmp    %r8,%rsi
setb   %cl
and    %r10b,%cl
mov    %cl,0x3f(%rsp)
mov    %rax,0x1c0(%rsp)
and    $0x7ffffffc,%eax
mov    %rax,0x190(%rsp)
add    $0x1,%rax
mov    %rax,0x188(%rsp)
mov    %rdi,%rax
mov    %rdi,0x198(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x178(%rsp)
mov    %r9,0x168(%rsp)
lea    0x0(,%r9,8),%rax
mov    %rax,0x90(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xd8(%rsp)
xor    %eax,%eax
mov    %rax,0x110(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xd0(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xa8(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xa0(%rsp)
movl   $0x0,0xcc(%rsp)
movl   $0x0,0x50(%rsp)
movl   $0x0,0x54(%rsp)
jmp    22ef <main+0xf8f>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rcx),%eax
cmp    0x34(%rsp),%ecx
mov    %eax,%edx
je     2a6f <main+0x170f>
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
movsd  %xmm0,0x170(%rsp)
movsd  0x1c8(%rsp),%xmm0
mov    %rdx,0x60(%rsp)
cmp    0x58(%rsp),%edx
jle    2345 <main+0xfe5>
movsd  0x1b8(%rsp),%xmm0
divsd  0x170(%rsp),%xmm0
movsd  0x120(%rsp),%xmm1
call   1200 <pow@plt>
mulsd  0xe8(%rsp),%xmm0
addsd  0xf0(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0x1,%edi
mov    0x15c(%rsp),%esi
call   1170 <integerrng@plt>
cmp    $0x3,%eax
ja     2440 <main+0x10e0>
mov    %eax,%eax
lea    0x1ce2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0x20(%rsp),%rsi
xorpd  %xmm2,%xmm2
test   %esi,%esi
jle    26a1 <main+0x1341>
mov    $0x8,%ebx
mov    0x68(%rsp),%r15
mov    0x98(%rsp),%rbp
mov    0x90(%rsp),%r12
mov    0xc0(%rsp),%r14
nopw   0x0(%rax,%rax,1)
movsd  %xmm2,0x28(%rsp)
mov    (%r14,%rbx,1),%rdi
lea    (%rbx,%rbp,1),%rsi
mov    0xc(%rsp),%edx
movsd  0x10(%rsp),%xmm0
mov    $0x5,%ecx
lea    0x70(%rsp),%r8
mov    %r15,%r9
call   1150 <MH_Kpoint_int@plt>
movsd  0x28(%rsp),%xmm2
addsd  0x70(%rsp),%xmm2
add    $0x8,%rbx
cmp    %rbx,%r12
jne    23b0 <main+0x1050>
mov    0x168(%rsp),%rax
mov    0x20(%rsp),%rsi
mov    0xb8(%rsp),%r12
mov    0xe0(%rsp),%rbp
movsd  0xa0(%rsp),%xmm1
mov    0x54(%rsp),%ecx
mov    0x78(%rsp),%r15
mov    0x88(%rsp),%rbx
mov    0x60(%rsp),%rdx
mov    0x118(%rsp),%r14
jmp    26b8 <main+0x1358>
nopl   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rdx
mov    0x20(%rsp),%rsi
jmp    2720 <main+0x13c0>
nop
mov    0x20(%rsp),%rsi
xorpd  %xmm2,%xmm2
test   %esi,%esi
jle    26df <main+0x137f>
mov    %rbx,%r13
mov    $0x8,%ebx
mov    0x68(%rsp),%rbp
mov    0x98(%rsp),%r12
mov    0x90(%rsp),%r15
mov    0xc0(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm2,0x28(%rsp)
mov    (%r14,%rbx,1),%rdi
lea    (%r12,%rbx,1),%rsi
mov    0xc(%rsp),%edx
sub    $0x8,%rsp
mov    0xc0(%rsp),%rcx
mov    0x88(%rsp),%r8
mov    %r13d,%r9d
movsd  0x18(%rsp),%xmm0
push   %rbp
lea    0x80(%rsp),%rax
push   %rax
push   $0x2
call   1280 <Mutation_int_Kpoint@plt>
movsd  0x48(%rsp),%xmm2
add    $0x20,%rsp
addsd  0x70(%rsp),%xmm2
add    $0x8,%rbx
cmp    %rbx,%r15
jne    2490 <main+0x1130>
mov    0x168(%rsp),%rax
mov    0x20(%rsp),%rsi
mov    0xb8(%rsp),%r12
mov    0x78(%rsp),%r15
mov    0x118(%rsp),%r14
mov    0xe0(%rsp),%rbp
movsd  0xa8(%rsp),%xmm1
mov    0x50(%rsp),%ecx
mov    %r13,%rbx
mov    0xb0(%rsp),%r13
jmp    26f1 <main+0x1391>
cmpl   $0x0,0x20(%rsp)
mov    0x80(%rsp),%r15
mov    0xc0(%rsp),%rsi
mov    %rbx,%r9
mov    %r12,%rbp
mov    0x68(%rsp),%r14
mov    0x98(%rsp),%rdx
mov    0x180(%rsp),%r13
jle    25bc <main+0x125c>
mov    $0x8,%ebx
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rbx,1),%rdi
lea    (%rdx,%rbx,1),%rsi
mov    0xc(%rsp),%edx
mov    %rbp,%rcx
mov    %r15,%r8
mov    %r9,%r12
movsd  0x10(%rsp),%xmm0
push   %r14
push   %r13
call   1250 <Mutation_int_Gibbs@plt>
mov    0xa0(%rsp),%rdi
mov    0xa8(%rsp),%rdx
mov    0xd0(%rsp),%rsi
mov    %r12,%r9
add    $0x10,%rsp
add    $0x8,%rbx
cmp    %rbx,%rdi
jne    2570 <main+0x1210>
movsd  0xd0(%rsp),%xmm0
addsd  0x1a43(%rip),%xmm0
movsd  %xmm0,0xd0(%rsp)
addl   $0x1,0xcc(%rsp)
01
mov    0x20(%rsp),%rsi
mov    %rbp,%r12
mov    0x78(%rsp),%r15
mov    0x118(%rsp),%r14
mov    0xe0(%rsp),%rbp
mov    0xb0(%rsp),%r13
mov    %r9,%rbx
jmp    2697 <main+0x1337>
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%edx
mov    0xc0(%rsp),%rdi
mov    0x98(%rsp),%rsi
mov    %r12,%r15
mov    0x20(%rsp),%r12
mov    %r12d,%ecx
mov    %r15,%r8
mov    0x80(%rsp),%r9
movsd  0x10(%rsp),%xmm0
push   0x140(%rsp)
push   0x70(%rsp)
lea    0x80(%rsp),%rax
push   %rax
push   %rbx
call   10e0 <Crossover_int_Kpoint@plt>
mov    %r12,%rsi
mov    %r15,%r12
mov    0x98(%rsp),%r15
add    $0x20,%rsp
movsd  0xd8(%rsp),%xmm0
addsd  0x70(%rsp),%xmm0
movsd  %xmm0,0xd8(%rsp)
mov    0x110(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x110(%rsp)
mov    0x60(%rsp),%rdx
jmp    2720 <main+0x13c0>
mov    $0x1,%eax
movsd  0xa0(%rsp),%xmm1
mov    0x54(%rsp),%ecx
mov    0x60(%rsp),%rdx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
divsd  %xmm0,%xmm2
movsd  %xmm2,0x70(%rsp)
addsd  %xmm2,%xmm1
movsd  %xmm1,0xa0(%rsp)
add    $0x1,%ecx
mov    %ecx,0x54(%rsp)
jmp    2720 <main+0x13c0>
mov    $0x1,%eax
movsd  0xa8(%rsp),%xmm1
mov    0x50(%rsp),%ecx
mov    0x60(%rsp),%rdx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
divsd  %xmm0,%xmm2
movsd  %xmm2,0x70(%rsp)
addsd  %xmm2,%xmm1
movsd  %xmm1,0xa8(%rsp)
add    $0x1,%ecx
mov    %ecx,0x50(%rsp)
nopl   0x0(%rax,%rax,1)
movsd  0x100(%rsp),%xmm0
cmp    0x5c(%rsp),%edx
jle    276f <main+0x140f>
movsd  0x1b0(%rsp),%xmm0
divsd  0x170(%rsp),%xmm0
movsd  0x128(%rsp),%xmm1
mov    %r12,%r15
mov    %rbx,%r12
mov    %rsi,%rbx
call   1200 <pow@plt>
mov    %rbx,%rsi
mov    %r12,%rbx
mov    %r15,%r12
mov    0x78(%rsp),%r15
mulsd  0x100(%rsp),%xmm0
sub    $0x8,%rsp
mov    0xa0(%rsp),%rdi
mov    %r12,%rdx
mov    0x88(%rsp),%rcx
mov    %ebx,%r8d
mov    %r15,%r9
movsd  %xmm0,0x30(%rsp)
push   %rbp
call   11a0 <self_adj_theta_update@plt>
add    $0x10,%rsp
test   %ebx,%ebx
mov    0x1c0(%rsp),%rsi
mov    0xc0(%rsp),%rdx
js     2959 <main+0x15f9>
cmp    $0x4,%esi
setb   %al
or     0x3f(%rsp),%al
mov    $0x1,%eax
jne    28b2 <main+0x1552>
cmpq   $0x4,0x1a0(%rsp)
jae    27db <main+0x147b>
xor    %eax,%eax
jmp    285a <main+0x14fa>
mov    0x178(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movupd 0x8(%rbp,%rax,8),%xmm0
movupd 0x18(%rbp,%rax,8),%xmm1
movupd 0x8(%r13,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x18(%r13,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x28(%r13,%rax,8),%xmm1
movupd 0x38(%r13,%rax,8),%xmm3
movupd %xmm2,0x8(%r13,%rax,8)
movupd %xmm0,0x18(%r13,%rax,8)
movupd 0x28(%rbp,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd 0x38(%rbp,%rax,8),%xmm1
addpd  %xmm3,%xmm1
movupd %xmm0,0x28(%r13,%rax,8)
movupd %xmm1,0x38(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    27f0 <main+0x1490>
testb  $0x1,0x198(%rsp)
01
je     289c <main+0x153c>
shl    $0x3,%rax
or     $0x8,%rax
movupd 0x0(%rbp,%rax,1),%xmm0
movupd 0x10(%rbp,%rax,1),%xmm1
movupd 0x0(%r13,%rax,1),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%r13,%rax,1),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x0(%r13,%rax,1)
movupd %xmm0,0x10(%r13,%rax,1)
mov    0x188(%rsp),%rax
cmp    0x190(%rsp),%rsi
je     2959 <main+0x15f9>
mov    %rbx,%r9
mov    0x1a8(%rsp),%rdi
mov    %edi,%ebx
sub    %eax,%ebx
mov    %rax,%rcx
not    %rcx
add    %rdi,%rcx
and    $0x3,%rbx
je     28ee <main+0x158e>
movsd  0x0(%rbp,%rax,8),%xmm0
addsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    28d0 <main+0x1570>
cmp    $0x3,%rcx
mov    %r9,%rbx
jb     2959 <main+0x15f9>
add    $0xffffffffffffffff,%rax
nopl   0x0(%rax,%rax,1)
movsd  0x8(%rbp,%rax,8),%xmm0
addsd  0x8(%r13,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
movsd  0x10(%rbp,%rax,8),%xmm0
addsd  0x10(%r13,%rax,8),%xmm0
movsd  %xmm0,0x10(%r13,%rax,8)
movsd  0x18(%rbp,%rax,8),%xmm0
addsd  0x18(%r13,%rax,8),%xmm0
movsd  %xmm0,0x18(%r13,%rax,8)
movsd  0x20(%rbp,%rax,8),%xmm0
addsd  0x20(%r13,%rax,8),%xmm0
movsd  %xmm0,0x20(%r13,%rax,8)
add    $0x4,%rax
cmp    %rax,%rsi
jne    2900 <main+0x15a0>
mov    0xc(%rsp),%r8d
mov    %r14,%rdi
lea    0x48(%rsp),%rsi
mov    0x98(%rsp),%rcx
mov    0x20(%rsp),%r9
call   1100 <update_best_value@plt>
mov    0x60(%rsp),%rcx
mov    %ecx,%eax
cltd
idivl  0x44(%rsp)
test   %edx,%edx
jne    22e0 <main+0xf80>
cmpl   $0x0,0x40(%rsp)
jle    22e0 <main+0xf80>
movsd  0x48(%rsp),%xmm2
lea    0x1975(%rip),%rdi
mov    %ecx,%esi
movsd  0x28(%rsp),%xmm0
movsd  0x10(%rsp),%xmm1
mov    $0x3,%al
call   10a0 <printf@plt>
mov    0x60(%rsp),%rcx
cmpq   $0x0,0x148(%rsp)
je     22e0 <main+0xf80>
movsd  0x48(%rsp),%xmm0
mov    %rbx,%r12
mov    0x148(%rsp),%rbx
mov    %rbx,%rdi
lea    0x1956(%rip),%rsi
mov    %ecx,%edx
mov    $0x1,%al
call   1120 <fprintf@plt>
mov    %rbx,%rdi
mov    %r12,%rbx
mov    0xb8(%rsp),%r12
call   1160 <fflush@plt>
mov    0x60(%rsp),%rcx
jmp    22e0 <main+0xf80>
movl   $0x0,0x54(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xa0(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xa8(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xd0(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0xd8(%rsp)
movl   $0x0,0x50(%rsp)
movl   $0x0,0xcc(%rsp)
xor    %eax,%eax
mov    %rax,0x110(%rsp)
mov    0xb0(%rsp),%r13
lea    0x1af6(%rip),%rdi
call   1060 <puts@plt>
test   %ebx,%ebx
mov    0x38(%rsp),%ebp
js     2b5b <main+0x17fb>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x34(%rsp),%xmm0
cmp    $0x2,%ebp
mov    $0x1,%eax
cmovge %ebp,%eax
mov    $0x1,%ecx
cmp    $0x2,%eax
jb     2b3a <main+0x17da>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rcx),%rdx
mov    %rdx,%rsi
shr    %rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     33e4 <main+0x2084>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movupd 0x8(%r13,%rdx,8),%xmm2
movupd 0x18(%r13,%rdx,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,0x8(%r13,%rdx,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x18(%r13,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rdi
jne    2ae0 <main+0x1780>
test   $0x1,%sil
je     2b2e <main+0x17ce>
shl    $0x3,%rdx
or     $0x8,%rdx
movupd 0x0(%r13,%rdx,1),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,0x0(%r13,%rdx,1)
cmp    %rcx,%rax
je     2b5b <main+0x17fb>
mov    %rax,%rcx
or     $0x1,%rcx
add    $0x1,%rax
xchg   %ax,%ax
movsd  0x0(%r13,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2b40 <main+0x17e0>
mov    %r12,%rdi
mov    %r15,%rsi
mov    %r13,%rdx
mov    %ebx,%ecx
movsd  0x108(%rsp),%xmm0
call   1260 <self_adj_theta_norm@plt>
cmpq   $0x0,0x138(%rsp)
je     2c5a <main+0x18fa>
test   %ebx,%ebx
mov    %r12,%rbx
mov    0x80(%rsp),%r12
jle    2bfe <main+0x189e>
mov    0x38(%rsp),%r15d
mov    $0x1,%ebp
nopl   0x0(%rax)
movsd  (%r12,%rbp,8),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,0x28(%rsp)
call   1180 <exp@plt>
movapd %xmm0,%xmm2
mov    0x78(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm3
movsd  0x0(%r13,%rbp,8),%xmm4
mov    0x138(%rsp),%rdi
lea    0x1766(%rip),%rsi
mov    %ebp,%edx
movsd  0x10(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
mov    $0x5,%al
call   1120 <fprintf@plt>
add    $0x1,%rbp
cmp    %rbp,%r15
jne    2ba0 <main+0x1840>
mov    0x160(%rsp),%rbp
movsd  (%rbx,%rbp,8),%xmm0
movsd  %xmm0,0x10(%rsp)
call   1180 <exp@plt>
movapd %xmm0,%xmm2
mov    0x78(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm3
movsd  0x0(%r13,%rbp,8),%xmm4
lea    0x1714(%rip),%rsi
xorpd  %xmm0,%xmm0
mov    0x138(%rsp),%rbx
mov    %rbx,%rdi
mov    0x38(%rsp),%edx
movsd  0x10(%rsp),%xmm1
mov    $0x5,%al
call   1120 <fprintf@plt>
mov    %rbx,%rdi
call   1160 <fflush@plt>
lea    0x1927(%rip),%rdi
call   1060 <puts@plt>
mov    0x130(%rsp),%rdi
test   %rdi,%rdi
je     2d32 <main+0x19d2>
movsd  0x48(%rsp),%xmm0
lea    0x154d(%rip),%rsi
mov    $0x1,%al
call   1120 <fprintf@plt>
cmpl   $0x0,0x1c(%rsp)
jle    2d08 <main+0x19a8>
mov    $0x1,%eax
lea    0x16bc(%rip),%r12
xor    %ebx,%ebx
mov    0x130(%rsp),%r15
jmp    2cce <main+0x196e>
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
mov    %r15,%rsi
call   10f0 <fputc@plt>
mov    0x10(%rsp),%rcx
lea    0x1(%rcx),%eax
add    $0x1,%ebx
cmp    0x1c(%rsp),%ecx
jge    2d08 <main+0x19a8>
mov    %rax,0x10(%rsp)
mov    0x18(%rsp),%eax
test   %eax,%eax
jle    2cb0 <main+0x1950>
xor    %ebp,%ebp
nopl   (%rax)
imul   %ebx,%eax
cltq
add    %rbp,%rax
mov    0x4(%r14,%rax,4),%edx
mov    %r15,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1120 <fprintf@plt>
mov    0x18(%rsp),%eax
add    $0x1,%rbp
cmp    %eax,%ebp
jl     2ce0 <main+0x1980>
jmp    2cb0 <main+0x1950>
mov    $0xa,%edi
mov    0x130(%rsp),%rbx
mov    %rbx,%rsi
call   10f0 <fputc@plt>
mov    $0xa,%edi
mov    %rbx,%rsi
call   10f0 <fputc@plt>
mov    %rbx,%rdi
call   1160 <fflush@plt>
lea    0x1865(%rip),%rdi
call   1060 <puts@plt>
cmpq   $0x0,0xf8(%rsp)
je     2f00 <main+0x1ba0>
movsd  0x48(%rsp),%xmm0
movsd  %xmm0,0x150(%rsp)
mov    0xc(%rsp),%edx
test   %edx,%edx
mov    0x68(%rsp),%rdi
jle    2d87 <main+0x1a27>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    0x4(%r14,%rax,4),%ecx
mov    %ecx,0x4(%rdi,%rax,4)
movslq 0xc(%rsp),%rdx
add    $0x1,%rax
cmp    %rdx,%rax
jl     2d70 <main+0x1a10>
lea    0x150(%rsp),%r12
movsd  0x12a9(%rip),%xmm0
lea    0x70(%rsp),%r15
mov    %r12,%rsi
mov    $0x5,%ecx
mov    %r15,%r8
mov    %rdi,%r14
mov    0x140(%rsp),%rbp
mov    %rbp,%r9
call   1150 <MH_Kpoint_int@plt>
xorpd  %xmm0,%xmm0
addsd  0x70(%rsp),%xmm0
mov    $0x270f,%ebx
nopl   0x0(%rax)
movsd  %xmm0,0x10(%rsp)
mov    0xc(%rsp),%edx
mov    %r14,%rdi
mov    %r12,%rsi
movsd  0x1258(%rip),%xmm0
mov    $0x5,%ecx
mov    %r15,%r8
mov    %rbp,%r9
call   1150 <MH_Kpoint_int@plt>
movsd  0x10(%rsp),%xmm0
addsd  0x70(%rsp),%xmm0
add    $0xffffffff,%ebx
jne    2dd0 <main+0x1a70>
movsd  %xmm0,0x10(%rsp)
movsd  0x150(%rsp),%xmm0
lea    0x13b2(%rip),%rsi
mov    0xf8(%rsp),%rdi
mov    $0x1,%al
call   1120 <fprintf@plt>
cmpl   $0x0,0x1c(%rsp)
jle    2eb8 <main+0x1b58>
mov    $0x1,%eax
lea    0x1515(%rip),%r12
xor    %ebx,%ebx
mov    0xf8(%rsp),%r15
mov    0x68(%rsp),%r14
jmp    2e7e <main+0x1b1e>
cs nopw 0x0(%rax,%rax,1)
mov    $0xa,%edi
mov    %r15,%rsi
call   10f0 <fputc@plt>
mov    0x28(%rsp),%rcx
lea    0x1(%rcx),%eax
add    $0x1,%ebx
cmp    0x1c(%rsp),%ecx
jge    2eb8 <main+0x1b58>
mov    %rax,0x28(%rsp)
mov    0x18(%rsp),%eax
test   %eax,%eax
jle    2e60 <main+0x1b00>
xor    %ebp,%ebp
nopl   (%rax)
imul   %ebx,%eax
cltq
add    %rbp,%rax
mov    0x4(%r14,%rax,4),%edx
mov    %r15,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1120 <fprintf@plt>
mov    0x18(%rsp),%eax
add    $0x1,%rbp
cmp    %eax,%ebp
jl     2e90 <main+0x1b30>
jmp    2e60 <main+0x1b00>
movsd  0x10(%rsp),%xmm0
divsd  0x1182(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
mov    $0xa,%edi
mov    0xf8(%rsp),%rbx
mov    %rbx,%rsi
call   10f0 <fputc@plt>
mov    $0xa,%edi
mov    %rbx,%rsi
call   10f0 <fputc@plt>
mov    %rbx,%rdi
call   1160 <fflush@plt>
mov    0x118(%rsp),%r14
jmp    2f00 <main+0x1ba0>
lea    0x16af(%rip),%rdi
call   1060 <puts@plt>
lea    0x16ae(%rip),%rdi
call   1060 <puts@plt>
movsd  0x48(%rsp),%xmm0
lea    0x1439(%rip),%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x169b(%rip),%rdi
call   1060 <puts@plt>
cmpl   $0x0,0x1c(%rsp)
jle    2fd0 <main+0x1c70>
mov    $0x1,%r15d
xor    %r12d,%r12d
jmp    2f6c <main+0x1c0c>
xchg   %ax,%ax
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%r15),%eax
add    $0x1,%r12d
cmp    0x1c(%rsp),%r15d
mov    %eax,%r15d
jge    2fd0 <main+0x1c70>
mov    0x18(%rsp),%eax
test   %eax,%eax
jle    2f50 <main+0x1bf0>
mov    $0x1,%ebx
xor    %ebp,%ebp
jmp    2f92 <main+0x1c32>
nopl   (%rax)
cmpl   $0x0,(%r14,%rcx,4)
je     2fc0 <main+0x1c60>
add    $0x1,%rbx
add    $0x1,%ebp
cmp    %eax,%ebp
jge    2f50 <main+0x1bf0>
mov    %r12d,%ecx
imul   %eax,%ecx
movslq %ecx,%rcx
add    %rbx,%rcx
cmpl   $0x1,(%r14,%rcx,4)
jne    2f80 <main+0x1c20>
mov    $0x20,%edi
call   1030 <putchar@plt>
mov    0x18(%rsp),%eax
mov    %r12d,%ecx
imul   %eax,%ecx
add    %ebx,%ecx
movslq %ecx,%rcx
jmp    2f80 <main+0x1c20>
mov    $0x58,%edi
call   1030 <putchar@plt>
mov    0x18(%rsp),%eax
jmp    2f87 <main+0x1c27>
mov    $0xa,%edi
call   1030 <putchar@plt>
movsd  0x150(%rsp),%xmm0
lea    0x1382(%rip),%rdi
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x15e1(%rip),%rdi
call   1060 <puts@plt>
cmpl   $0x0,0x1c(%rsp)
jle    30c5 <main+0x1d65>
mov    $0x1,%r15d
xor    %r12d,%r12d
jmp    3040 <main+0x1ce0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1(%r15),%eax
add    $0x1,%r12d
cmp    0x1c(%rsp),%r15d
mov    %eax,%r15d
jge    30c5 <main+0x1d65>
mov    0x18(%rsp),%eax
test   %eax,%eax
mov    0x68(%rsp),%rdx
jle    3020 <main+0x1cc0>
mov    $0x1,%ebx
xor    %ebp,%ebp
jmp    3071 <main+0x1d11>
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x0,(%rdx,%rcx,4)
je     30b0 <main+0x1d50>
add    $0x1,%rbx
add    $0x1,%ebp
cmp    %eax,%ebp
jge    3020 <main+0x1cc0>
mov    %r12d,%ecx
imul   %eax,%ecx
movslq %ecx,%rcx
add    %rbx,%rcx
cmpl   $0x1,(%rdx,%rcx,4)
jne    3060 <main+0x1d00>
mov    $0x20,%edi
call   1030 <putchar@plt>
mov    0x68(%rsp),%rdx
mov    0x18(%rsp),%eax
mov    %r12d,%ecx
imul   %eax,%ecx
add    %ebx,%ecx
movslq %ecx,%rcx
jmp    3060 <main+0x1d00>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x58,%edi
call   1030 <putchar@plt>
mov    0x68(%rsp),%rdx
mov    0x18(%rsp),%eax
jmp    3066 <main+0x1d06>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x1510(%rip),%rdi
call   1060 <puts@plt>
xorps  %xmm0,%xmm0
cvtsi2sdl 0x54(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sdl 0x50(%rsp),%xmm1
movsd  0xa0(%rsp),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0xa0(%rsp)
movsd  0xa8(%rsp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0xa8(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0xcc(%rsp),%xmm0
movsd  0xd0(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xd0(%rsp)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x110(%rsp),%xmm0
movsd  0xd8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0xd8(%rsp)
lea    0x1218(%rip),%rdi
xorpd  %xmm0,%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x1214(%rip),%rdi
movsd  0xa0(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x120b(%rip),%rdi
movsd  0xa8(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x1202(%rip),%rdi
movsd  0xd0(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x11f9(%rip),%rdi
movsd  0xd8(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x11f0(%rip),%rdi
movsd  0x10(%rsp),%xmm0
mov    $0x1,%al
call   10a0 <printf@plt>
lea    0x1418(%rip),%rdi
call   1060 <puts@plt>
mov    0x138(%rsp),%rdi
test   %rdi,%rdi
je     31fd <main+0x1e9d>
call   1090 <fclose@plt>
mov    0x148(%rsp),%rdi
test   %rdi,%rdi
mov    0x20(%rsp),%r15
mov    0x88(%rsp),%r12
mov    0x38(%rsp),%ebx
mov    0x130(%rsp),%rbp
je     3228 <main+0x1ec8>
call   1090 <fclose@plt>
test   %rbp,%rbp
je     3235 <main+0x1ed5>
mov    %rbp,%rdi
call   1090 <fclose@plt>
mov    0xf8(%rsp),%rdi
test   %rdi,%rdi
je     3247 <main+0x1ee7>
call   1090 <fclose@plt>
lea    0x13bf(%rip),%rdi
call   1060 <puts@plt>
mov    0x80(%rsp),%rdi
mov    $0x1,%esi
mov    %r12d,%edx
call   11d0 <free_dvector@plt>
mov    0x78(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   11d0 <free_dvector@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   11d0 <free_dvector@plt>
mov    0xb8(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   11d0 <free_dvector@plt>
mov    0x98(%rsp),%rdi
mov    $0x1,%esi
mov    %r15d,%edx
call   11d0 <free_dvector@plt>
mov    0xc(%rsp),%r8d
mov    0xc0(%rsp),%rdi
mov    $0x1,%esi
mov    %r15d,%edx
mov    $0x1,%ecx
call   1130 <free_imatrix@plt>
mov    0xc(%rsp),%edx
mov    %r14,%rdi
mov    $0x1,%esi
call   11b0 <free_ivector@plt>
mov    0xc(%rsp),%edx
mov    0x68(%rsp),%rdi
mov    $0x1,%esi
call   11b0 <free_ivector@plt>
mov    0xc(%rsp),%edx
mov    0x140(%rsp),%rdi
mov    $0x1,%esi
call   11b0 <free_ivector@plt>
mov    0xe0(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   11d0 <free_dvector@plt>
lea    0x12f6(%rip),%rdi
call   1060 <puts@plt>
xor    %eax,%eax
add    $0x248,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffffffffffc,%rdx
neg    %rdx
mov    $0x1,%ebp
mov    $0x2,%ecx
mov    $0x5,%esi
jmp    3379 <main+0x2019>
cs nopw 0x0(%rax,%rax,1)
add    $0x4,%esi
lea    (%rdx,%rcx,1),%rdi
add    $0x4,%rdi
add    $0x4,%rcx
cmp    $0x2,%rdi
je     1dc1 <main+0xa61>
movsd  (%r15,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    3392 <main+0x2032>
movsd  %xmm1,0x48(%rsp)
lea    -0x3(%rsi),%ebp
movapd %xmm1,%xmm0
movsd  0x8(%r15,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    33ac <main+0x204c>
movsd  %xmm1,0x48(%rsp)
lea    -0x2(%rsi),%ebp
movapd %xmm1,%xmm0
movsd  0x10(%r15,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    33c6 <main+0x2066>
movsd  %xmm1,0x48(%rsp)
lea    -0x1(%rsi),%ebp
movapd %xmm1,%xmm0
movsd  0x18(%r15,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    3360 <main+0x2000>
movsd  %xmm1,0x48(%rsp)
movapd %xmm1,%xmm0
mov    %esi,%ebp
jmp    3360 <main+0x2000>
xor    %edx,%edx
test   $0x1,%sil
jne    2b14 <main+0x17b4>
jmp    2b2e <main+0x17ce>

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

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