#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 */
scalar_t__ check_malloc(int);
int /*<<< orphan*/ endpar();
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ getpar(char *, char *, ...);
float log(float);
int /*<<< orphan*/ read_bbpfile(char *, float *, float *, float *, int);
int /*<<< orphan*/ read_specfile(char *, float *, float *, int, int, int);
int /*<<< orphan*/ setpar(int, char **);
int /*<<< orphan*/ sprintf(char *, char *, ...);
float sqrt(float);
int /*<<< orphan*/ sscanf(char *, char *, int *);
int /*<<< orphan*/ stdout;
scalar_t__ strncmp(char *, char *, int);
int main(int ac, char **av) {
  FILE *fpr, *fopfile();
  float *per, *sa1, *sa2, *res1, *res2, *avgr, v[8];
  float rpga1, rpga2, avgpga, rpgv1, rpgv2, avgpgv;
  int i, np2, np;
  float flo = 0.0;
  float fhi = 0.0;
  char statinfo[512], str[1024];
  char eq[128], mag[16], stat[16], lon[16], lat[16];
  char seqno[16], vs30[16], cd[16], xc[16], yc[16], tmin[16], tmax[16];
  int respect_format = 1;
  int sa_field = 7;
  int bbp_format = 0;
  int print_header = 0;
  char datafile1[256], datafile2[256];
  char simfile1[256], simfile2[256];
  char comp1[128], comp2[128];
  float pga1 = -999.9;
  float pga2 = -999.9;
  float pgv1 = -999.9;
  float pgv2 = -999.9;
  float sim_pga1 = -999.9;
  float sim_pga2 = -999.9;
  float sim_pgv1 = -999.9;
  float sim_pgv2 = -999.9;
  datafile1[0] = '\0';
  datafile2[0] = '\0';
  simfile1[0] = '\0';
  simfile2[0] = '\0';
  sprintf(eq, "-999");
  sprintf(mag, "-999");
  sprintf(stat, "-999");
  sprintf(lon, "-999");
  sprintf(lat, "-999");
  sprintf(seqno, "-999");
  sprintf(vs30, "-999");
  sprintf(cd, "-999");
  sprintf(xc, "-999");
  sprintf(yc, "-999");
  setpar(ac, av);
  getpar("datafile1", "s", datafile1);
  getpar("datafile2", "s", datafile2);
  getpar("simfile1", "s", simfile1);
  getpar("simfile2", "s", simfile2);
  getpar("comp1", "s", comp1);
  getpar("comp2", "s", comp2);
  getpar("eqname", "s", eq);
  getpar("mag", "s", mag);
  getpar("stat", "s", stat);
  getpar("lon", "s", lon);
  getpar("lat", "s", lat);
  getpar("seqno", "s", seqno);
  getpar("vs30", "s", vs30);
  getpar("cd", "s", cd);
  getpar("xcos", "s", xc);
  getpar("ycos", "s", yc);
  getpar("flo", "f", &flo);
  getpar("fhi", "f", &fhi);
  getpar("print_header", "d", &print_header);
  getpar("pga1", "f", &pga1);
  getpar("pga2", "f", &pga2);
  getpar("pgv1", "f", &pgv1);
  getpar("pgv2", "f", &pgv2);
  getpar("sim_pga1", "f", &sim_pga1);
  getpar("sim_pga2", "f", &sim_pga2);
  getpar("sim_pgv1", "f", &sim_pgv1);
  getpar("sim_pgv2", "f", &sim_pgv2);
  getpar("bbp_format", "d", &bbp_format);
  if (bbp_format == 1)
    respect_format = 0;
  getpar("respect_format", "d", &respect_format);
  if (respect_format == 0 && bbp_format == 0)
    getpar("np", "d", &np);
  getpar("sa_field", "d", &sa_field);
  endpar();
  if (fhi > 0.0)
    sprintf(tmin, "%.3f", 1.0 / fhi);
  else
    sprintf(tmin, "-99999.999");
  if (flo > 0.0)
    sprintf(tmax, "%.3f", 1.0 / flo);
  else
    sprintf(tmax, "99999.999");
  sprintf(statinfo, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s", eq, mag,
          stat, lon, lat, seqno, vs30, cd, xc, yc, tmin, tmax);
  if (respect_format) {
    fpr = fopfile(datafile1, "r");
    fgets(str, 1024, fpr);
    fgets(str, 1024, fpr);
    fgets(str, 1024, fpr);
    fgets(str, 1024, fpr);
    sscanf(str, "%d", &np);
    fclose(fpr);
  } else if (bbp_format == 1) {
    fpr = fopfile(datafile1, "r");
    fgets(str, 1024, fpr);
    while (strncmp(str, "#", 1) == 0)
      fgets(str, 1024, fpr);
    np = 1;
    while (fgets(str, 1024, fpr) != NULL)
      np++;
    fclose(fpr);
  }
  per = (float *)check_malloc(np * sizeof(float));
  sa1 = (float *)check_malloc(np * sizeof(float));
  sa2 = (float *)check_malloc(np * sizeof(float));
  res1 = (float *)check_malloc(np * sizeof(float));
  res2 = (float *)check_malloc(np * sizeof(float));
  avgr = (float *)check_malloc(np * sizeof(float));
  if (bbp_format == 1)
    read_bbpfile(datafile1, per, sa1, sa2, np);
  else {
    read_specfile(datafile1, per, sa1, np, sa_field, respect_format);
    read_specfile(datafile2, per, sa2, np, sa_field, respect_format);
  }
  if (simfile1[0] == '\0' || (bbp_format == 0 && simfile2[0] == '\0')) {
    for (i = 0; i < np; i++) {
      res1[i] = sa1[i];
      res2[i] = sa2[i];
      avgr[i] = sqrt(res1[i] * res2[i]);
    }
    rpga1 = pga1;
    rpga2 = pga2;
    avgpga = -999.9;
    if (rpga1 >= 0.0 && rpga2 >= 0.0)
      avgpga = sqrt(rpga1 * rpga2);
    rpgv1 = pgv1;
    rpgv2 = pgv2;
    avgpgv = -999.9;
    if (rpgv1 >= 0.0 && rpgv2 >= 0.0)
      avgpgv = sqrt(rpgv1 * rpgv2);
  } else {
    if (bbp_format == 1)
      read_bbpfile(simfile1, per, res1, res2, np);
    else {
      read_specfile(simfile1, per, res1, np, sa_field, respect_format);
      read_specfile(simfile2, per, res2, np, sa_field, respect_format);
    }
    for (i = 0; i < np; i++) {
      if (res1[i] != 0.0)
        res1[i] = log(sa1[i] / res1[i]);
      else
        res1[i] = -99;
      if (res2[i] != 0.0)
        res2[i] = log(sa2[i] / res2[i]);
      else
        res2[i] = -99;
      avgr[i] = 0.5 * (res1[i] + res2[i]);
    }
    if (pga1 > 0.0 && sim_pga1 > 0.0)
      rpga1 = log(pga1 / sim_pga1);
    else
      rpga1 = -999.9;
    if (pga2 > 0.0 && sim_pga2 > 0.0)
      rpga2 = log(pga2 / sim_pga2);
    else
      rpga2 = -999.9;
    avgpga = 0.5 * (rpga1 + rpga2);
    if (pgv1 > 0.0 && sim_pgv1 > 0.0)
      rpgv1 = log(pgv1 / sim_pgv1);
    else
      rpgv1 = -999.9;
    if (pgv2 > 0.0 && sim_pgv2 > 0.0)
      rpgv2 = log(pgv2 / sim_pgv2);
    else
      rpgv2 = -999.9;
    avgpgv = 0.5 * (rpgv1 + rpgv2);
  }
  if (print_header) {
    fprintf(stdout, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t\%s", "EQ",
            "Mag", "stat", "lon", "lat", "stat_seq_no", "Vs30", "close_dist",
            "Xcos", "Ycos", "T_min", "T_max", "comp");
    for (i = 0; i < np; i++)
      fprintf(stdout, "\t%.5e", per[i]);
    if (pga1 >= 0.0)
      fprintf(stdout, "\t%s", "pga");
    if (pgv1 >= 0.0)
      fprintf(stdout, "\t%s", "pgv");
    fprintf(stdout, "\n");
  }
  fprintf(stdout, "%s", statinfo);
  fprintf(stdout, "\t%s", comp1);
  for (i = 0; i < np; i++)
    fprintf(stdout, "\t%.5e", res1[i]);
  if (pga1 >= 0.0)
    fprintf(stdout, "\t%.5e", rpga1);
  if (pgv1 >= 0.0)
    fprintf(stdout, "\t%.5e", rpgv1);
  fprintf(stdout, "\n");
  fprintf(stdout, "%s", statinfo);
  fprintf(stdout, "\t%s", comp2);
  for (i = 0; i < np; i++)
    fprintf(stdout, "\t%.5e", res2[i]);
  if (pga2 >= 0.0)
    fprintf(stdout, "\t%.5e", rpga2);
  if (pgv2 >= 0.0)
    fprintf(stdout, "\t%.5e", rpgv2);
  fprintf(stdout, "\n");
  fprintf(stdout, "%s", statinfo);
  fprintf(stdout, "\t%s", "avgh");
  for (i = 0; i < np; i++)
    fprintf(stdout, "\t%.5e", avgr[i]);
  if (pga1 >= 0.0 && pga2 >= 0.0)
    fprintf(stdout, "\t%.5e", avgpga);
  if (pgv1 >= 0.0 && pgv2 >= 0.0)
    fprintf(stdout, "\t%.5e", avgpgv);
  fprintf(stdout, "\n");
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd58,%rsp
movl   $0x0,-0x2c(%rbp)
mov    %edi,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movl   $0x1,-0x7f4(%rbp)
movl   $0x7,-0x7f8(%rbp)
movl   $0x0,-0x7fc(%rbp)
movl   $0x0,-0x800(%rbp)
movss  0x1da8(%rip),%xmm0
movss  %xmm0,-0xd04(%rbp)
ff
movss  0x1d98(%rip),%xmm0
movss  %xmm0,-0xd08(%rbp)
ff
movss  0x1d88(%rip),%xmm0
movss  %xmm0,-0xd0c(%rbp)
ff
movss  0x1d78(%rip),%xmm0
movss  %xmm0,-0xd10(%rbp)
ff
movss  0x1d68(%rip),%xmm0
movss  %xmm0,-0xd14(%rbp)
ff
movss  0x1d58(%rip),%xmm0
movss  %xmm0,-0xd18(%rbp)
ff
movss  0x1d48(%rip),%xmm0
movss  %xmm0,-0xd1c(%rbp)
ff
movss  0x1d38(%rip),%xmm0
movss  %xmm0,-0xd20(%rbp)
ff
movb   $0x0,-0x900(%rbp)
movb   $0x0,-0xa00(%rbp)
movb   $0x0,-0xb00(%rbp)
movb   $0x0,-0xc00(%rbp)
lea    -0x740(%rbp),%rdi
lea    0x1d1e(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x750(%rbp),%rdi
lea    0x1d09(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x760(%rbp),%rdi
lea    0x1cf4(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x770(%rbp),%rdi
lea    0x1cdf(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x780(%rbp),%rdi
lea    0x1cca(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x790(%rbp),%rdi
lea    0x1cb5(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x7a0(%rbp),%rdi
lea    0x1ca0(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x7b0(%rbp),%rdi
lea    0x1c8b(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x7c0(%rbp),%rdi
lea    0x1c76(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x7d0(%rbp),%rdi
lea    0x1c61(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
mov    -0x30(%rbp),%edi
mov    -0x38(%rbp),%rsi
call   1040 <setpar@plt>
lea    -0x900(%rbp),%rdx
lea    0x1c45(%rip),%rdi
lea    0x1d39(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0xa00(%rbp),%rdx
lea    0x1c33(%rip),%rdi
lea    0x1d1d(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0xb00(%rbp),%rdx
lea    0x1c21(%rip),%rdi
lea    0x1d01(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0xc00(%rbp),%rdx
lea    0x1c0e(%rip),%rdi
lea    0x1ce5(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0xc80(%rbp),%rdx
lea    0x1bfb(%rip),%rdi
lea    0x1cc9(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0xd00(%rbp),%rdx
lea    0x1be5(%rip),%rdi
lea    0x1cad(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0x740(%rbp),%rdx
lea    0x1bcf(%rip),%rdi
lea    0x1c91(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0x750(%rbp),%rdx
lea    0x1bba(%rip),%rdi
lea    0x1c75(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0x760(%rbp),%rdx
lea    0x1ba2(%rip),%rdi
lea    0x1c59(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0x770(%rbp),%rdx
lea    0x1b8b(%rip),%rdi
lea    0x1c3d(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0x780(%rbp),%rdx
lea    0x1b73(%rip),%rdi
lea    0x1c21(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0x790(%rbp),%rdx
lea    0x1b5b(%rip),%rdi
lea    0x1c05(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0x7a0(%rbp),%rdx
lea    0x1b45(%rip),%rdi
lea    0x1be9(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0x7b0(%rbp),%rdx
lea    0x1b2e(%rip),%rdi
lea    0x1bcd(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0x7c0(%rbp),%rdx
lea    0x1b15(%rip),%rdi
lea    0x1bb1(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    -0x7d0(%rbp),%rdx
lea    0x1afe(%rip),%rdi
lea    0x1b95(%rip),%rsi
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1aee(%rip),%rdi
lea    0x1b49(%rip),%rsi
lea    -0xb8(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1ad6(%rip),%rdi
lea    0x1b2d(%rip),%rsi
lea    -0xbc(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1abe(%rip),%rdi
lea    0x1b1f(%rip),%rsi
lea    -0x800(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1ab3(%rip),%rdi
lea    0x1af5(%rip),%rsi
lea    -0xd04(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1aa0(%rip),%rdi
lea    0x1ad9(%rip),%rsi
lea    -0xd08(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1a8d(%rip),%rdi
lea    0x1abd(%rip),%rsi
lea    -0xd0c(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1a7a(%rip),%rdi
lea    0x1aa1(%rip),%rsi
lea    -0xd10(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1a3f(%rip),%rdi
lea    0x1a85(%rip),%rsi
lea    -0xd14(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1a2c(%rip),%rdi
lea    0x1a69(%rip),%rsi
lea    -0xd18(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1a19(%rip),%rdi
lea    0x1a4d(%rip),%rsi
lea    -0xd1c(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x1a06(%rip),%rdi
lea    0x1a31(%rip),%rsi
lea    -0xd20(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x19f3(%rip),%rdi
lea    0x1a23(%rip),%rsi
lea    -0x7fc(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
cmpl   $0x1,-0x7fc(%rbp)
jne    16f1 <main+0x501>
movl   $0x0,-0x7f4(%rbp)
lea    0x19cb(%rip),%rdi
lea    0x19f0(%rip),%rsi
lea    -0x7f4(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
cmpl   $0x0,-0x7f4(%rbp)
jne    1743 <main+0x553>
cmpl   $0x0,-0x7fc(%rbp)
jne    1743 <main+0x553>
lea    0x19a4(%rip),%rdi
lea    0x19ba(%rip),%rsi
lea    -0xb4(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
lea    0x198b(%rip),%rdi
lea    0x199e(%rip),%rsi
lea    -0x7f8(%rbp),%rdx
mov    $0x0,%al
call   10c0 <getpar@plt>
mov    $0x0,%al
call   10d0 <endpar@plt>
movss  -0xbc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    17b1 <main+0x5c1>
lea    -0x7e0(%rbp),%rdi
movss  -0xbc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x186e(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x1939(%rip),%rsi
mov    $0x1,%al
call   1100 <sprintf@plt>
jmp    17c6 <main+0x5d6>
lea    -0x7e0(%rbp),%rdi
lea    0x1924(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
movss  -0xb8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1811 <main+0x621>
lea    -0x7f0(%rbp),%rdi
movss  -0xb8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x180e(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x18d9(%rip),%rsi
mov    $0x1,%al
call   1100 <sprintf@plt>
jmp    1826 <main+0x636>
lea    -0x7f0(%rbp),%rdi
lea    0x18c5(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x2c0(%rbp),%rdi
lea    -0x740(%rbp),%rdx
lea    -0x750(%rbp),%rcx
lea    -0x760(%rbp),%r8
lea    -0x770(%rbp),%r9
lea    -0x780(%rbp),%r13
lea    -0x790(%rbp),%r12
lea    -0x7a0(%rbp),%r15
lea    -0x7b0(%rbp),%r14
lea    -0x7c0(%rbp),%rbx
lea    -0x7d0(%rbp),%r11
lea    -0x7e0(%rbp),%r10
lea    -0x7f0(%rbp),%rax
lea    0x186e(%rip),%rsi
mov    %r13,(%rsp)
mov    %r12,0x8(%rsp)
mov    %r15,0x10(%rsp)
mov    %r14,0x18(%rsp)
mov    %rbx,0x20(%rsp)
mov    %r11,0x28(%rsp)
mov    %r10,0x30(%rsp)
mov    %rax,0x38(%rsp)
mov    $0x0,%al
call   1100 <sprintf@plt>
cmpl   $0x0,-0x7f4(%rbp)
je     1958 <main+0x768>
lea    -0x900(%rbp),%rdi
lea    0x17c1(%rip),%rsi
mov    $0x0,%al
call   1110 <fopfile@plt>
mov    %rax,-0x40(%rbp)
lea    -0x6c0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1080 <fgets@plt>
lea    -0x6c0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1080 <fgets@plt>
lea    -0x6c0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1080 <fgets@plt>
lea    -0x6c0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1080 <fgets@plt>
lea    -0x6c0(%rbp),%rdi
lea    0x17b0(%rip),%rsi
lea    -0xb4(%rbp),%rdx
call   10b0 <sscanf@plt>
mov    -0x40(%rbp),%rdi
call   1050 <fclose@plt>
jmp    1a1a <main+0x82a>
cmpl   $0x1,-0x7fc(%rbp)
jne    1a15 <main+0x825>
lea    -0x900(%rbp),%rdi
lea    0x171f(%rip),%rsi
mov    $0x0,%al
call   1110 <fopfile@plt>
mov    %rax,-0x40(%rbp)
lea    -0x6c0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1080 <fgets@plt>
lea    -0x6c0(%rbp),%rdi
lea    0x1750(%rip),%rsi
mov    $0x1,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    19cf <main+0x7df>
lea    -0x6c0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1080 <fgets@plt>
jmp    1993 <main+0x7a3>
movl   $0x1,-0xb4(%rbp)
lea    -0x6c0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1080 <fgets@plt>
cmp    $0x0,%rax
je     1a0c <main+0x81c>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    19d9 <main+0x7e9>
mov    -0x40(%rbp),%rdi
call   1050 <fclose@plt>
jmp    1a1a <main+0x82a>
movslq -0xb4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10a0 <check_malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0xb4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10a0 <check_malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0xb4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10a0 <check_malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0xb4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10a0 <check_malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0xb4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10a0 <check_malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0xb4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10a0 <check_malloc@plt>
mov    %rax,-0x70(%rbp)
cmpl   $0x1,-0x7fc(%rbp)
jne    1acf <main+0x8df>
lea    -0x900(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0xb4(%rbp),%r8d
call   1070 <read_bbpfile@plt>
jmp    1b1f <main+0x92f>
lea    -0x900(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0xb4(%rbp),%ecx
mov    -0x7f8(%rbp),%r8d
mov    -0x7f4(%rbp),%r9d
call   1060 <read_specfile@plt>
lea    -0xa00(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0xb4(%rbp),%ecx
mov    -0x7f8(%rbp),%r8d
mov    -0x7f4(%rbp),%r9d
call   1060 <read_specfile@plt>
movsbl -0xb00(%rbp),%eax
cmp    $0x0,%eax
je     1b4c <main+0x95c>
cmpl   $0x0,-0x7fc(%rbp)
jne    1cf4 <main+0xb04>
movsbl -0xc00(%rbp),%eax
cmp    $0x0,%eax
jne    1cf4 <main+0xb04>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    1bf1 <main+0xa01>
mov    -0x50(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0xac(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
call   10f0 <sqrt@plt>
mov    -0x70(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1b56 <main+0x966>
movss  -0xd04(%rbp),%xmm0
ff
movss  %xmm0,-0x94(%rbp)
movss  -0xd08(%rbp),%xmm0
ff
movss  %xmm0,-0x98(%rbp)
ff
movss  0x13e7(%rip),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1c70 <main+0xa80>
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1c70 <main+0xa80>
movss  -0x94(%rbp),%xmm0
ff
mulss  -0x98(%rbp),%xmm0
ff
call   10f0 <sqrt@plt>
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xd0c(%rbp),%xmm0
ff
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0xd10(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  0x1368(%rip),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1cef <main+0xaff>
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1cef <main+0xaff>
movss  -0xa0(%rbp),%xmm0
ff
mulss  -0xa4(%rbp),%xmm0
ff
call   10f0 <sqrt@plt>
movss  %xmm0,-0xa8(%rbp)
ff
jmp    20cd <main+0xedd>
cmpl   $0x1,-0x7fc(%rbp)
jne    1d25 <main+0xb35>
lea    -0xb00(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x68(%rbp),%rcx
mov    -0xb4(%rbp),%r8d
call   1070 <read_bbpfile@plt>
jmp    1d75 <main+0xb85>
lea    -0xb00(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0xb4(%rbp),%ecx
mov    -0x7f8(%rbp),%r8d
mov    -0x7f4(%rbp),%r9d
call   1060 <read_specfile@plt>
lea    -0xc00(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x68(%rbp),%rdx
mov    -0xb4(%rbp),%ecx
mov    -0x7f8(%rbp),%r8d
mov    -0x7f4(%rbp),%r9d
call   1060 <read_specfile@plt>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    1ee5 <main+0xcf5>
mov    -0x60(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1dbd <main+0xbcd>
jp     1dbd <main+0xbcd>
jmp    1df7 <main+0xc07>
mov    -0x50(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0xac(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
call   10e0 <log@plt>
mov    -0x60(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1e0f <main+0xc1f>
mov    -0x60(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  0x11fa(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1e3b <main+0xc4b>
jp     1e3b <main+0xc4b>
jmp    1e75 <main+0xc85>
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0xac(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
call   10e0 <log@plt>
mov    -0x68(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1e8d <main+0xc9d>
mov    -0x68(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  0x117c(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0xac(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1157(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x70(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1d7f <main+0xb8f>
movss  -0xd04(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f39 <main+0xd49>
movss  -0xd14(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f39 <main+0xd49>
movss  -0xd04(%rbp),%xmm0
ff
divss  -0xd14(%rbp),%xmm0
ff
call   10e0 <log@plt>
movss  %xmm0,-0x94(%rbp)
ff
jmp    1f49 <main+0xd59>
movss  0x10bf(%rip),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0xd08(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f9d <main+0xdad>
movss  -0xd18(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f9d <main+0xdad>
movss  -0xd08(%rbp),%xmm0
ff
divss  -0xd18(%rbp),%xmm0
ff
call   10e0 <log@plt>
movss  %xmm0,-0x98(%rbp)
ff
jmp    1fad <main+0xdbd>
movss  0x105b(%rip),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
addss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1047(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xd0c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    202d <main+0xe3d>
movss  -0xd1c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    202d <main+0xe3d>
movss  -0xd0c(%rbp),%xmm0
ff
divss  -0xd1c(%rbp),%xmm0
ff
call   10e0 <log@plt>
movss  %xmm0,-0xa0(%rbp)
ff
jmp    203d <main+0xe4d>
movss  0xfcb(%rip),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0xd10(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2091 <main+0xea1>
movss  -0xd20(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2091 <main+0xea1>
movss  -0xd10(%rbp),%xmm0
ff
divss  -0xd20(%rbp),%xmm0
ff
call   10e0 <log@plt>
movss  %xmm0,-0xa4(%rbp)
ff
jmp    20a1 <main+0xeb1>
movss  0xf67(%rip),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
addss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xf53(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
cmpl   $0x0,-0x800(%rbp)
je     2274 <main+0x1084>
mov    0x2eff(%rip),%rax
mov    (%rax),%edi
lea    0x1009(%rip),%rsi
lea    0x1029(%rip),%rdx
lea    0x1025(%rip),%rcx
lea    0xf5b(%rip),%r8
lea    0xf59(%rip),%r9
lea    0xf56(%rip),%rax
mov    %rax,-0xd30(%rbp)
lea    0x1006(%rip),%r13
lea    0x100b(%rip),%r12
lea    0x1009(%rip),%r15
lea    0x100d(%rip),%r14
lea    0x100b(%rip),%rbx
lea    0x1009(%rip),%r11
lea    0x1008(%rip),%r10
lea    0x1007(%rip),%rax
mov    %rax,-0xd28(%rbp)
mov    -0xd30(%rbp),%rax
mov    %rax,(%rsp)
mov    -0xd28(%rbp),%rax
mov    %r13,0x8(%rsp)
mov    %r12,0x10(%rsp)
mov    %r15,0x18(%rsp)
mov    %r14,0x20(%rsp)
mov    %rbx,0x28(%rsp)
mov    %r11,0x30(%rsp)
mov    %r10,0x38(%rsp)
mov    %rax,0x40(%rsp)
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    21ef <main+0xfff>
mov    0x2e29(%rip),%rax
mov    (%rax),%edi
mov    -0x48(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xf84(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    219e <main+0xfae>
movss  -0xd04(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2226 <main+0x1036>
mov    0x2dd1(%rip),%rax
mov    (%rax),%edi
lea    0xefe(%rip),%rsi
lea    0xf3f(%rip),%rdx
mov    $0x0,%al
call   1090 <fprintf@plt>
movss  -0xd0c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     225d <main+0x106d>
mov    0x2d9a(%rip),%rax
mov    (%rax),%edi
lea    0xec7(%rip),%rsi
lea    0xf0c(%rip),%rdx
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x2d7c(%rip),%rax
mov    (%rax),%edi
lea    0xef9(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x2d65(%rip),%rax
mov    (%rax),%edi
lea    -0x2c0(%rbp),%rdx
lea    0xe8c(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x2d47(%rip),%rax
mov    (%rax),%edi
lea    -0xc80(%rbp),%rdx
lea    0xe6d(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    230b <main+0x111b>
mov    0x2d0d(%rip),%rax
mov    (%rax),%edi
mov    -0x60(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe68(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    22ba <main+0x10ca>
movss  -0xd04(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2347 <main+0x1157>
mov    0x2cb5(%rip),%rax
mov    (%rax),%edi
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xe18(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
movss  -0xd0c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2383 <main+0x1193>
mov    0x2c79(%rip),%rax
mov    (%rax),%edi
movss  -0xa0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xddc(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    0x2c56(%rip),%rax
mov    (%rax),%edi
lea    0xdd3(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x2c3f(%rip),%rax
mov    (%rax),%edi
lea    -0x2c0(%rbp),%rdx
lea    0xd66(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x2c21(%rip),%rax
mov    (%rax),%edi
lea    -0xd00(%rbp),%rdx
lea    0xd47(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    2431 <main+0x1241>
mov    0x2be7(%rip),%rax
mov    (%rax),%edi
mov    -0x68(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd42(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    23e0 <main+0x11f0>
movss  -0xd08(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     246d <main+0x127d>
mov    0x2b8f(%rip),%rax
mov    (%rax),%edi
movss  -0x98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xcf2(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
movss  -0xd10(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     24a9 <main+0x12b9>
mov    0x2b53(%rip),%rax
mov    (%rax),%edi
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xcb6(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    0x2b30(%rip),%rax
mov    (%rax),%edi
lea    0xcad(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x2b19(%rip),%rax
mov    (%rax),%edi
lea    -0x2c0(%rbp),%rdx
lea    0xc40(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
mov    0x2afb(%rip),%rax
mov    (%rax),%edi
lea    0xc28(%rip),%rsi
lea    0xc73(%rip),%rdx
mov    $0x0,%al
call   1090 <fprintf@plt>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    2557 <main+0x1367>
mov    0x2ac1(%rip),%rax
mov    (%rax),%edi
mov    -0x70(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc1c(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    2506 <main+0x1316>
movss  -0xd04(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     25ac <main+0x13bc>
movss  -0xd08(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     25ac <main+0x13bc>
mov    0x2a50(%rip),%rax
mov    (%rax),%edi
movss  -0x9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xbb3(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
movss  -0xd0c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2601 <main+0x1411>
movss  -0xd10(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2601 <main+0x1411>
mov    0x29fb(%rip),%rax
mov    (%rax),%edi
movss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xb5e(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    0x29d8(%rip),%rax
mov    (%rax),%edi
lea    0xb55(%rip),%rsi
mov    $0x0,%al
call   1090 <fprintf@plt>
xor    %eax,%eax
add    $0xd58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xcb8,%rsp
movl   $0x0,0x64(%rsp)
movl   $0x0,0x60(%rsp)
movl   $0x1,0x10(%rsp)
movl   $0x7,0x34(%rsp)
movl   $0x0,0x20(%rsp)
movl   $0x0,0x5c(%rsp)
movl   $0xc479f99a,0x1c(%rsp)
c4
movl   $0xc479f99a,0x30(%rsp)
c4
movl   $0xc479f99a,0x18(%rsp)
c4
movl   $0xc479f99a,0x2c(%rsp)
c4
movl   $0xc479f99a,0x58(%rsp)
c4
movl   $0xc479f99a,0x54(%rsp)
c4
movl   $0xc479f99a,0x50(%rsp)
c4
movl   $0xc479f99a,0x4c(%rsp)
c4
movb   $0x0,0x1b0(%rsp)
movb   $0x0,0x5b0(%rsp)
movb   $0x0,0x2b0(%rsp)
movb   $0x0,0x4b0(%rsp)
movb   $0x0,0x134(%rsp)
movl   $0x3939392d,0x130(%rsp)
2d 39 39 39
movb   $0x0,0xe4(%rsp)
movl   $0x3939392d,0xe0(%rsp)
2d 39 39 39
movb   $0x0,0xd4(%rsp)
movl   $0x3939392d,0xd0(%rsp)
2d 39 39 39
movb   $0x0,0xc4(%rsp)
movl   $0x3939392d,0xc0(%rsp)
2d 39 39 39
movb   $0x0,0x84(%rsp)
movl   $0x3939392d,0x80(%rsp)
2d 39 39 39
movb   $0x0,0x74(%rsp)
movl   $0x3939392d,0x70(%rsp)
39
movb   $0x0,0xb4(%rsp)
movl   $0x3939392d,0xb0(%rsp)
2d 39 39 39
movb   $0x0,0x124(%rsp)
movl   $0x3939392d,0x120(%rsp)
2d 39 39 39
movb   $0x0,0x114(%rsp)
movl   $0x3939392d,0x110(%rsp)
2d 39 39 39
movb   $0x0,0x104(%rsp)
movl   $0x3939392d,0x100(%rsp)
2d 39 39 39
call   1040 <setpar@plt>
lea    0x1cc8(%rip),%rdi
lea    0x1dbc(%rip),%r15
lea    0x1b0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1cb2(%rip),%rdi
lea    0x5b0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1ca3(%rip),%rdi
lea    0x2b0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1c93(%rip),%rdi
lea    0x4b0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1c83(%rip),%rdi
lea    0x430(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1c70(%rip),%rdi
lea    0x3b0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1c5d(%rip),%rdi
lea    0x130(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1c4b(%rip),%rdi
lea    0xe0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1c36(%rip),%rdi
lea    0xd0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1c22(%rip),%rdi
lea    0xc0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1c0d(%rip),%rdi
lea    0x80(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1bf8(%rip),%rdi
lea    0x70(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1be8(%rip),%rdi
lea    0xb0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1bd4(%rip),%rdi
lea    0x120(%rsp),%r12
mov    %r15,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1bbb(%rip),%rdi
lea    0x110(%rsp),%r13
mov    %r15,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1ba4(%rip),%rdi
lea    0x100(%rsp),%r14
mov    %r15,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1b8d(%rip),%rdi
lea    0x1be8(%rip),%rbx
lea    0x64(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1b74(%rip),%rdi
lea    0x60(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1b62(%rip),%rdi
lea    0x1bc3(%rip),%rbp
lea    0x5c(%rsp),%rdx
mov    %rbp,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1b56(%rip),%rdi
lea    0x1c(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1b49(%rip),%rdi
lea    0x30(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1b3c(%rip),%rdi
lea    0x18(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1b2f(%rip),%rdi
lea    0x2c(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1afa(%rip),%rdi
lea    0x58(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1aed(%rip),%rdi
lea    0x54(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1ae0(%rip),%rdi
lea    0x50(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1ad3(%rip),%rdi
lea    0x4c(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1ac6(%rip),%rdi
lea    0x20(%rsp),%rdx
mov    %rbp,%rsi
xor    %eax,%eax
call   10c0 <getpar@plt>
cmpl   $0x1,0x20(%rsp)
jne    1610 <main+0x420>
movl   $0x0,0x10(%rsp)
lea    0x1aac(%rip),%rdi
lea    0x1ad1(%rip),%rsi
lea    0x10(%rsp),%rdx
xor    %eax,%eax
call   10c0 <getpar@plt>
mov    0x10(%rsp),%eax
or     0x20(%rsp),%eax
jne    164e <main+0x45e>
lea    0x1a97(%rip),%rdi
lea    0x1aad(%rip),%rsi
lea    0xc(%rsp),%rdx
xor    %eax,%eax
call   10c0 <getpar@plt>
lea    0x1a80(%rip),%rdi
lea    0x1a93(%rip),%rsi
lea    0x34(%rsp),%rdx
xor    %eax,%eax
call   10c0 <getpar@plt>
xor    %eax,%eax
call   10d0 <endpar@plt>
movss  0x60(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    16a8 <main+0x4b8>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0x1974(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x1a47(%rip),%rsi
lea    0xa0(%rsp),%rdi
mov    $0x1,%al
call   1100 <sprintf@plt>
jmp    16c5 <main+0x4d5>
movabs $0x392e39393939392d,%rax
39 2e 39
mov    %rax,0xa0(%rsp)
movl   $0x393939,0xa7(%rsp)
movss  0x64(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    16fe <main+0x50e>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0x191e(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x19f1(%rip),%rsi
lea    0x90(%rsp),%rdi
mov    $0x1,%al
call   1100 <sprintf@plt>
jmp    171a <main+0x52a>
movabs $0x39392e3939393939,%rax
2e 39 39
mov    %rax,0x90(%rsp)
movw   $0x39,0x98(%rsp)
lea    0x80(%rsp),%r15
lea    0x70(%rsp),%rbp
lea    0x90(%rsp),%r11
lea    0xa0(%rsp),%r10
lea    0x19b8(%rip),%rsi
lea    0x6b0(%rsp),%rdi
lea    0x130(%rsp),%rdx
lea    0xe0(%rsp),%rcx
lea    0xd0(%rsp),%r8
lea    0xc0(%rsp),%r9
mov    $0x0,%eax
push   %r11
push   %r10
push   %r14
push   %r13
push   %r12
lea    0xd8(%rsp),%rbx
push   %rbx
push   %rbp
push   %r15
call   1100 <sprintf@plt>
add    $0x40,%rsp
cmpl   $0x0,0x10(%rsp)
je     19c7 <main+0x7d7>
lea    0x18f6(%rip),%rsi
lea    0x1b0(%rsp),%rdi
xor    %eax,%eax
call   1110 <fopfile@plt>
mov    %rax,%rbx
lea    0x8b0(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rax,%rdx
call   1080 <fgets@plt>
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1080 <fgets@plt>
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1080 <fgets@plt>
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1080 <fgets@plt>
lea    0x18f1(%rip),%rsi
lea    0xc(%rsp),%rdx
mov    %rbp,%rdi
call   10b0 <sscanf@plt>
mov    %rbx,%rdi
call   1050 <fclose@plt>
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   10a0 <check_malloc@plt>
mov    %rax,%rbx
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   10a0 <check_malloc@plt>
mov    %rax,%r14
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   10a0 <check_malloc@plt>
mov    %rax,%r15
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   10a0 <check_malloc@plt>
mov    %rax,%r12
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   10a0 <check_malloc@plt>
mov    %rax,0x40(%rsp)
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   10a0 <check_malloc@plt>
mov    %rax,%r13
cmpl   $0x1,0x20(%rsp)
mov    0xc(%rsp),%eax
mov    %rbx,0x68(%rsp)
jne    18a3 <main+0x6b3>
lea    0x1b0(%rsp),%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %r15,%rcx
mov    %eax,%r8d
call   1070 <read_bbpfile@plt>
cmpb   $0x0,0x2b0(%rsp)
jne    18ed <main+0x6fd>
jmp    1907 <main+0x717>
mov    0x34(%rsp),%r8d
mov    0x10(%rsp),%r9d
lea    0x1b0(%rsp),%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    %eax,%ecx
call   1060 <read_specfile@plt>
mov    0xc(%rsp),%ecx
mov    0x34(%rsp),%r8d
mov    0x10(%rsp),%r9d
lea    0x5b0(%rsp),%rdi
mov    %rbx,%rsi
mov    %r15,%rdx
call   1060 <read_specfile@plt>
cmpb   $0x0,0x2b0(%rsp)
je     1907 <main+0x717>
mov    0x20(%rsp),%ecx
test   %ecx,%ecx
jne    1aaf <main+0x8bf>
cmpb   $0x0,0x4b0(%rsp)
jne    1aaf <main+0x8bf>
cmpl   $0x0,0xc(%rsp)
jle    196a <main+0x77a>
xor    %ebp,%ebp
xorps  %xmm1,%xmm1
jmp    193d <main+0x74d>
cs nopw 0x0(%rax,%rax,1)
nop
call   10f0 <sqrt@plt>
xorps  %xmm1,%xmm1
movss  %xmm0,0x0(%r13,%rbp,4)
add    $0x1,%rbp
movslq 0xc(%rsp),%rax
cmp    %rax,%rbp
jge    196a <main+0x77a>
movss  (%r14,%rbp,4),%xmm0
movss  %xmm0,(%r12,%rbp,4)
movss  (%r15,%rbp,4),%xmm0
mov    0x40(%rsp),%rax
movss  %xmm0,(%rax,%rbp,4)
mulss  (%r12,%rbp,4),%xmm0
ucomiss %xmm1,%xmm0
jb     1920 <main+0x730>
sqrtss %xmm0,%xmm0
jmp    1928 <main+0x738>
movss  0x1c(%rsp),%xmm0
movss  0x30(%rsp),%xmm5
xorps  %xmm6,%xmm6
movss  %xmm0,0x14(%rsp)
ucomiss %xmm6,%xmm0
movss  0x1686(%rip),%xmm3
movaps %xmm3,%xmm2
movss  %xmm5,0x3c(%rsp)
jb     1aff <main+0x90f>
ucomiss %xmm6,%xmm5
movaps %xmm3,%xmm2
jb     1aff <main+0x90f>
movss  0x14(%rsp),%xmm0
mulss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1aec <main+0x8fc>
xorps  %xmm2,%xmm2
sqrtss %xmm0,%xmm2
jmp    1aff <main+0x90f>
cmpl   $0x1,0x20(%rsp)
jne    1812 <main+0x622>
lea    0x16b9(%rip),%rsi
lea    0x1b0(%rsp),%rdi
xor    %eax,%eax
call   1110 <fopfile@plt>
mov    %rax,%rbx
lea    0x8b0(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rax,%rdx
call   1080 <fgets@plt>
lea    0x16e7(%rip),%rsi
mov    %rbp,%rdi
mov    $0x1,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
jne    1a55 <main+0x865>
lea    0x8b0(%rsp),%rbp
lea    0x16c6(%rip),%r14
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1080 <fgets@plt>
mov    %rbp,%rdi
mov    %r14,%rsi
mov    $0x1,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
je     1a30 <main+0x840>
movl   $0x1,0xc(%rsp)
lea    0x8b0(%rsp),%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     180a <main+0x61a>
lea    0x8b0(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addl   $0x1,0xc(%rsp)
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
jne    1a90 <main+0x8a0>
jmp    180a <main+0x61a>
mov    0xc(%rsp),%eax
mov    %r13,%rbx
cmp    $0x1,%ecx
jne    1b5c <main+0x96c>
lea    0x2b0(%rsp),%rdi
mov    0x68(%rsp),%rsi
mov    %r12,%rdx
mov    0x40(%rsp),%rcx
mov    %eax,%r8d
call   1070 <read_bbpfile@plt>
cmpl   $0x0,0xc(%rsp)
jg     1bae <main+0x9be>
jmp    1c4d <main+0xa5d>
call   10f0 <sqrt@plt>
xorps  %xmm6,%xmm6
movss  0x1514(%rip),%xmm3
movaps %xmm0,%xmm2
movss  0x18(%rsp),%xmm0
movss  0x2c(%rsp),%xmm4
ucomiss %xmm6,%xmm0
movss  %xmm2,0x38(%rsp)
movss  %xmm4,0x48(%rsp)
movss  %xmm0,0x28(%rsp)
jb     1b3c <main+0x94c>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm4
jb     1b3c <main+0x94c>
mulss  %xmm4,%xmm0
ucomiss %xmm1,%xmm0
jb     1b52 <main+0x962>
sqrtss %xmm0,%xmm0
jmp    1d76 <main+0xb86>
movss  %xmm3,0x24(%rsp)
cmpl   $0x0,0x5c(%rsp)
jne    1d87 <main+0xb97>
jmp    1eba <main+0xcca>
call   10f0 <sqrt@plt>
jmp    1d76 <main+0xb86>
mov    0x34(%rsp),%r8d
mov    0x10(%rsp),%r9d
lea    0x2b0(%rsp),%rdi
mov    0x68(%rsp),%rbp
mov    %rbp,%rsi
mov    %r12,%rdx
mov    %eax,%ecx
call   1060 <read_specfile@plt>
mov    0xc(%rsp),%ecx
mov    0x34(%rsp),%r8d
mov    0x10(%rsp),%r9d
lea    0x4b0(%rsp),%rdi
mov    %rbp,%rsi
mov    0x40(%rsp),%rdx
call   1060 <read_specfile@plt>
cmpl   $0x0,0xc(%rsp)
jle    1c4d <main+0xa5d>
xor    %r13d,%r13d
jmp    1bed <main+0x9fd>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x40(%rsp),%rax
movss  %xmm0,(%rax,%r13,4)
addss  (%r12,%r13,4),%xmm0
mulss  0x1433(%rip),%xmm0
movss  %xmm0,(%rbx,%r13,4)
add    $0x1,%r13
movslq 0xc(%rsp),%rax
cmp    %rax,%r13
jge    1c4d <main+0xa5d>
movss  (%r12,%r13,4),%xmm1
ucomiss 0x141a(%rip),%xmm1
movss  0x1406(%rip),%xmm0
jne    1c06 <main+0xa16>
jnp    1c15 <main+0xa25>
movss  (%r14,%r13,4),%xmm0
divss  %xmm1,%xmm0
call   10e0 <log@plt>
movss  %xmm0,(%r12,%r13,4)
mov    0x40(%rsp),%rax
movss  (%rax,%r13,4),%xmm1
ucomiss 0x13e7(%rip),%xmm1
movss  0x13d3(%rip),%xmm0
jne    1c39 <main+0xa49>
jnp    1bc0 <main+0x9d0>
movss  (%r15,%r13,4),%xmm0
divss  %xmm1,%xmm0
call   10e0 <log@plt>
jmp    1bc0 <main+0x9d0>
movss  0x1c(%rsp),%xmm0
movss  0x13b5(%rip),%xmm4
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm0
movss  %xmm4,0x14(%rsp)
jbe    1c94 <main+0xaa4>
movss  0x58(%rsp),%xmm1
ucomiss %xmm2,%xmm1
movss  %xmm4,0x14(%rsp)
jbe    1c94 <main+0xaa4>
divss  %xmm1,%xmm0
call   10e0 <log@plt>
xorps  %xmm2,%xmm2
movss  0x1382(%rip),%xmm4
movss  %xmm0,0x14(%rsp)
movss  0x30(%rsp),%xmm0
ucomiss %xmm2,%xmm0
movaps %xmm4,%xmm2
mov    %rbx,%r13
jbe    1cca <main+0xada>
movss  0x54(%rsp),%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
movaps %xmm4,%xmm2
jbe    1cca <main+0xada>
divss  %xmm1,%xmm0
call   10e0 <log@plt>
movss  0x1349(%rip),%xmm4
movaps %xmm0,%xmm2
movss  0x18(%rsp),%xmm0
xorps  %xmm5,%xmm5
ucomiss %xmm5,%xmm0
movss  %xmm4,0x28(%rsp)
movss  %xmm2,0x3c(%rsp)
jbe    1d15 <main+0xb25>
movss  0x50(%rsp),%xmm1
ucomiss %xmm5,%xmm1
movss  %xmm4,0x28(%rsp)
jbe    1d15 <main+0xb25>
divss  %xmm1,%xmm0
call   10e0 <log@plt>
xorps  %xmm5,%xmm5
movss  0x3c(%rsp),%xmm2
movss  0x1301(%rip),%xmm4
movss  %xmm0,0x28(%rsp)
movss  0x14(%rsp),%xmm3
addss  %xmm2,%xmm3
movss  0x2c(%rsp),%xmm0
ucomiss %xmm5,%xmm0
jbe    1d50 <main+0xb60>
movss  0x4c(%rsp),%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
jbe    1d50 <main+0xb60>
divss  %xmm1,%xmm0
movss  %xmm3,0x38(%rsp)
call   10e0 <log@plt>
movss  0x38(%rsp),%xmm3
movaps %xmm0,%xmm4
mulss  0x12b4(%rip),%xmm3
movss  %xmm3,0x38(%rsp)
movss  0x28(%rsp),%xmm0
movss  %xmm4,0x48(%rsp)
addss  %xmm4,%xmm0
mulss  0x1296(%rip),%xmm0
movss  %xmm0,0x24(%rsp)
cmpl   $0x0,0x5c(%rsp)
je     1eba <main+0xcca>
mov    %r13,0xf8(%rsp)
mov    0x324a(%rip),%r14
mov    (%r14),%edi
sub    $0x8,%rsp
lea    0x13af(%rip),%rbp
lea    0x13a2(%rip),%rbx
lea    0x1395(%rip),%r10
lea    0x1389(%rip),%r11
lea    0x137d(%rip),%r15
lea    0x136b(%rip),%r13
lea    0x1325(%rip),%rsi
lea    0x1345(%rip),%rdx
lea    0x1341(%rip),%rcx
lea    0x1277(%rip),%r8
lea    0x1275(%rip),%r9
xor    %eax,%eax
push   %rbp
push   %rbx
push   %r10
push   %r11
push   %r15
push   %r13
lea    0x1330(%rip),%rbp
push   %rbp
lea    0x131c(%rip),%rbp
push   %rbp
lea    0x1256(%rip),%rbp
push   %rbp
call   1090 <fprintf@plt>
add    $0x50,%rsp
cmpl   $0x0,0xc(%rsp)
mov    0x68(%rsp),%rbp
jle    1e55 <main+0xc65>
xor    %ebx,%ebx
lea    0x132c(%rip),%r15
nopl   0x0(%rax)
mov    (%r14),%edi
movss  0x0(%rbp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1e30 <main+0xc40>
movss  0x1c(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1e7e <main+0xc8e>
mov    (%r14),%edi
lea    0x12a9(%rip),%rsi
lea    0x12ea(%rip),%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x18(%rsp),%xmm0
ucomiss %xmm1,%xmm0
mov    0xf8(%rsp),%r13
jb     1ea9 <main+0xcb9>
mov    (%r14),%edi
lea    0x127b(%rip),%rsi
lea    0x12c0(%rip),%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x12b3(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    0x311f(%rip),%r14
mov    (%r14),%edi
lea    0x124c(%rip),%rsi
lea    0x6b0(%rsp),%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x1232(%rip),%rsi
lea    0x430(%rsp),%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
cmpl   $0x0,0xc(%rsp)
jle    1f35 <main+0xd45>
xor    %ebx,%ebx
lea    0x1255(%rip),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r14),%edi
movss  (%r12,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbp,%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1f10 <main+0xd20>
movss  0x1c(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1f61 <main+0xd71>
mov    (%r14),%edi
movss  0x14(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x1201(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x18(%rsp),%xmm0
ucomiss %xmm1,%xmm0
mov    0x40(%rsp),%r15
jb     1f8c <main+0xd9c>
mov    (%r14),%edi
movss  0x28(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x11d3(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x11d0(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x1170(%rip),%rsi
lea    0x6b0(%rsp),%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x1156(%rip),%rsi
lea    0x3b0(%rsp),%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
cmpl   $0x0,0xc(%rsp)
jle    2005 <main+0xe15>
xor    %ebp,%ebp
lea    0x1179(%rip),%rbx
nop
mov    (%r14),%edi
movss  (%r15,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
add    $0x1,%rbp
movslq 0xc(%rsp),%rax
cmp    %rax,%rbp
jl     1fe0 <main+0xdf0>
movss  0x30(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     2031 <main+0xe41>
mov    (%r14),%edi
movss  0x3c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x1131(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x2c(%rsp),%xmm0
ucomiss %xmm1,%xmm0
jb     2057 <main+0xe67>
mov    (%r14),%edi
movss  0x48(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x1108(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x1105(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x10a5(%rip),%rsi
lea    0x6b0(%rsp),%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x108b(%rip),%rsi
lea    0x10d6(%rip),%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
cmpl   $0x0,0xc(%rsp)
jle    20d6 <main+0xee6>
xor    %ebp,%ebp
lea    0x10af(%rip),%rbx
nopl   0x0(%rax)
mov    (%r14),%edi
movss  0x0(%r13,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
add    $0x1,%rbp
movslq 0xc(%rsp),%rax
cmp    %rax,%rbp
jl     20b0 <main+0xec0>
movss  0x1c(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     210d <main+0xf1d>
movss  0x30(%rsp),%xmm0
ucomiss %xmm1,%xmm0
jb     210d <main+0xf1d>
mov    (%r14),%edi
movss  0x38(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x1055(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x18(%rsp),%xmm0
ucomiss %xmm1,%xmm0
jb     2141 <main+0xf51>
movss  0x2c(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     2141 <main+0xf51>
mov    (%r14),%edi
movss  0x24(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x101e(%rip),%rsi
mov    $0x1,%al
call   1090 <fprintf@plt>
mov    (%r14),%edi
lea    0x101b(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
xor    %eax,%eax
add    $0xcb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [5 x i8] c"-999\00"
@.str.1 = [10 x i8] c"datafile1\00"
@.str.2 = [2 x i8] c"s\00"
@.str.3 = [10 x i8] c"datafile2\00"
@.str.4 = [9 x i8] c"simfile1\00"
@.str.5 = [9 x i8] c"simfile2\00"
@.str.6 = [6 x i8] c"comp1\00"
@.str.7 = [6 x i8] c"comp2\00"
@.str.8 = [7 x i8] c"eqname\00"
@.str.9 = [4 x i8] c"mag\00"
@.str.10 = [5 x i8] c"stat\00"
@.str.11 = [4 x i8] c"lon\00"
@.str.12 = [4 x i8] c"lat\00"
@.str.13 = [6 x i8] c"seqno\00"
@.str.14 = [5 x i8] c"vs30\00"
@.str.15 = [3 x i8] c"cd\00"
@.str.16 = [5 x i8] c"xcos\00"
@.str.17 = [5 x i8] c"ycos\00"
@.str.18 = [4 x i8] c"flo\00"
@.str.19 = [2 x i8] c"f\00"
@.str.20 = [4 x i8] c"fhi\00"
@.str.21 = [13 x i8] c"print_header\00"
@.str.22 = [2 x i8] c"d\00"
@.str.23 = [5 x i8] c"pga1\00"
@.str.24 = [5 x i8] c"pga2\00"
@.str.25 = [5 x i8] c"pgv1\00"
@.str.26 = [5 x i8] c"pgv2\00"
@.str.27 = [9 x i8] c"sim_pga1\00"
@.str.28 = [9 x i8] c"sim_pga2\00"
@.str.29 = [9 x i8] c"sim_pgv1\00"
@.str.30 = [9 x i8] c"sim_pgv2\00"
@.str.31 = [11 x i8] c"bbp_format\00"
@.str.32 = [15 x i8] c"respect_format\00"
@.str.33 = [3 x i8] c"np\00"
@.str.34 = [9 x i8] c"sa_field\00"
@.str.35 = [5 x i8] c"%.3f\00"
@.str.36 = [11 x i8] c"-99999.999\00"
@.str.37 = [10 x i8] c"99999.999\00"
@.str.38 = [36 x i8] c"%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\00"
@.str.39 = [2 x i8] c"r\00"
@.str.40 = [3 x i8] c"%d\00"
@.str.41 = [2 x i8] c"#\00"
@stdout = global i32 0
@.str.42 = [39 x i8] c"%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\00"
@.str.43 = [3 x i8] c"EQ\00"
@.str.44 = [4 x i8] c"Mag\00"
@.str.45 = [12 x i8] c"stat_seq_no\00"
@.str.46 = [5 x i8] c"Vs30\00"
@.str.47 = [11 x i8] c"close_dist\00"
@.str.48 = [5 x i8] c"Xcos\00"
@.str.49 = [5 x i8] c"Ycos\00"
@.str.50 = [6 x i8] c"T_min\00"
@.str.51 = [6 x i8] c"T_max\00"
@.str.52 = [5 x i8] c"comp\00"
@.str.53 = [6 x i8] c"\09%.5e\00"
@.str.54 = [4 x i8] c"\09%s\00"
@.str.55 = [4 x i8] c"pga\00"
@.str.56 = [4 x i8] c"pgv\00"
@.str.57 = [2 x i8] c"\0A\00"
@.str.58 = [3 x i8] c"%s\00"
@.str.59 = [5 x i8] c"avgh\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32*
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca float*
%12 = alloca float*
%13 = alloca [8 x float]
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca float
%24 = alloca float
%25 = alloca [512 x i8]
%26 = alloca [1024 x i8]
%27 = alloca [128 x i8]
%28 = alloca [16 x i8]
%29 = alloca [16 x i8]
%30 = alloca [16 x i8]
%31 = alloca [16 x i8]
%32 = alloca [16 x i8]
%33 = alloca [16 x i8]
%34 = alloca [16 x i8]
%35 = alloca [16 x i8]
%36 = alloca [16 x i8]
%37 = alloca [16 x i8]
%38 = alloca [16 x i8]
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca [256 x i8]
%44 = alloca [256 x i8]
%45 = alloca [256 x i8]
%46 = alloca [256 x i8]
%47 = alloca [128 x i8]
%48 = alloca [128 x i8]
%49 = alloca float
%50 = alloca float
%51 = alloca float
%52 = alloca float
%53 = alloca float
%54 = alloca float
%55 = alloca float
%56 = alloca float
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store float 0.000000e+00, float* %23
store float 0.000000e+00, float* %24
store i32 1, i32* %39
store i32 7, i32* %40
store i32 0, i32* %41
store i32 0, i32* %42
store float 0xC08F3F3340000000, float* %49
store float 0xC08F3F3340000000, float* %50
store float 0xC08F3F3340000000, float* %51
store float 0xC08F3F3340000000, float* %52
store float 0xC08F3F3340000000, float* %53
store float 0xC08F3F3340000000, float* %54
store float 0xC08F3F3340000000, float* %55
store float 0xC08F3F3340000000, float* %56
%57 = getelementptr inbounds [256 x i8], [256 x i8]* %43, i64 0, i64 0
store i8 0, i8* %57
%58 = getelementptr inbounds [256 x i8], [256 x i8]* %44, i64 0, i64 0
store i8 0, i8* %58
%59 = getelementptr inbounds [256 x i8], [256 x i8]* %45, i64 0, i64 0
store i8 0, i8* %59
%60 = getelementptr inbounds [256 x i8], [256 x i8]* %46, i64 0, i64 0
store i8 0, i8* %60
%61 = getelementptr inbounds [128 x i8], [128 x i8]* %27, i64 0, i64 0
%62 = call i32 (i8*, i8*, ...) @sprintf(i8* %61, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%63 = getelementptr inbounds [16 x i8], [16 x i8]* %28, i64 0, i64 0
%64 = call i32 (i8*, i8*, ...) @sprintf(i8* %63, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%65 = getelementptr inbounds [16 x i8], [16 x i8]* %29, i64 0, i64 0
%66 = call i32 (i8*, i8*, ...) @sprintf(i8* %65, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%67 = getelementptr inbounds [16 x i8], [16 x i8]* %30, i64 0, i64 0
%68 = call i32 (i8*, i8*, ...) @sprintf(i8* %67, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%69 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 0
%70 = call i32 (i8*, i8*, ...) @sprintf(i8* %69, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%71 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%72 = call i32 (i8*, i8*, ...) @sprintf(i8* %71, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%73 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%74 = call i32 (i8*, i8*, ...) @sprintf(i8* %73, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%75 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 0
%76 = call i32 (i8*, i8*, ...) @sprintf(i8* %75, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%77 = getelementptr inbounds [16 x i8], [16 x i8]* %35, i64 0, i64 0
%78 = call i32 (i8*, i8*, ...) @sprintf(i8* %77, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%79 = getelementptr inbounds [16 x i8], [16 x i8]* %36, i64 0, i64 0
%80 = call i32 (i8*, i8*, ...) @sprintf(i8* %79, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%81 = load i32, i32* %4
%82 = load i8**, i8*** %5
%83 = call i32 @setpar(i32 %81, i8** %82)
%84 = getelementptr inbounds [256 x i8], [256 x i8]* %43, i64 0, i64 0
%85 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %84)
%86 = getelementptr inbounds [256 x i8], [256 x i8]* %44, i64 0, i64 0
%87 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %86)
%88 = getelementptr inbounds [256 x i8], [256 x i8]* %45, i64 0, i64 0
%89 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %88)
%90 = getelementptr inbounds [256 x i8], [256 x i8]* %46, i64 0, i64 0
%91 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %90)
%92 = getelementptr inbounds [128 x i8], [128 x i8]* %47, i64 0, i64 0
%93 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %92)
%94 = getelementptr inbounds [128 x i8], [128 x i8]* %48, i64 0, i64 0
%95 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %94)
%96 = getelementptr inbounds [128 x i8], [128 x i8]* %27, i64 0, i64 0
%97 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %96)
%98 = getelementptr inbounds [16 x i8], [16 x i8]* %28, i64 0, i64 0
%99 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %98)
%100 = getelementptr inbounds [16 x i8], [16 x i8]* %29, i64 0, i64 0
%101 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %100)
%102 = getelementptr inbounds [16 x i8], [16 x i8]* %30, i64 0, i64 0
%103 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %102)
%104 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 0
%105 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %104)
%106 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%107 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %106)
%108 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%109 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %108)
%110 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 0
%111 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %110)
%112 = getelementptr inbounds [16 x i8], [16 x i8]* %35, i64 0, i64 0
%113 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %112)
%114 = getelementptr inbounds [16 x i8], [16 x i8]* %36, i64 0, i64 0
%115 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %114)
%116 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %23)
%117 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %24)
%118 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.21, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), i32* %42)
%119 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.23, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %49)
%120 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.24, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %50)
%121 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.25, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %51)
%122 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.26, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %52)
%123 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.27, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %53)
%124 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.28, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %54)
%125 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.29, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %55)
%126 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %56)
%127 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.31, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), i32* %41)
%128 = load i32, i32* %41
%129 = icmp eq i32 %128, 1
br i1 %129, label %130, label %131
130: ; preds = %2
store i32 0, i32* %39
br label %131
131: ; preds = %130, %2
%132 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.32, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), i32* %39)
%133 = load i32, i32* %39
%134 = icmp eq i32 %133, 0
br i1 %134, label %135, label %140
135: ; preds = %131
%136 = load i32, i32* %41
%137 = icmp eq i32 %136, 0
br i1 %137, label %138, label %140
138: ; preds = %135
%139 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.33, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), i32* %22)
br label %140
140: ; preds = %138, %135, %131
%141 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.34, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), i32* %40)
%142 = call i32 (...) @endpar()
%143 = load float, float* %24
%144 = fpext float %143 to double
%145 = fcmp ogt double %144, 0.000000e+00
br i1 %145, label %146, label %152
146: ; preds = %140
%147 = getelementptr inbounds [16 x i8], [16 x i8]* %37, i64 0, i64 0
%148 = load float, float* %24
%149 = fpext float %148 to double
%150 = fdiv double 1.000000e+00, %149
%151 = call i32 (i8*, i8*, ...) @sprintf(i8* %147, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.35, i64 0, i64 0), double %150)
br label %155
152: ; preds = %140
%153 = getelementptr inbounds [16 x i8], [16 x i8]* %37, i64 0, i64 0
%154 = call i32 (i8*, i8*, ...) @sprintf(i8* %153, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.36, i64 0, i64 0))
br label %155
155: ; preds = %152, %146
%156 = load float, float* %23
%157 = fpext float %156 to double
%158 = fcmp ogt double %157, 0.000000e+00
br i1 %158, label %159, label %165
159: ; preds = %155
%160 = getelementptr inbounds [16 x i8], [16 x i8]* %38, i64 0, i64 0
%161 = load float, float* %23
%162 = fpext float %161 to double
%163 = fdiv double 1.000000e+00, %162
%164 = call i32 (i8*, i8*, ...) @sprintf(i8* %160, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.35, i64 0, i64 0), double %163)
br label %168
165: ; preds = %155
%166 = getelementptr inbounds [16 x i8], [16 x i8]* %38, i64 0, i64 0
%167 = call i32 (i8*, i8*, ...) @sprintf(i8* %166, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.37, i64 0, i64 0))
br label %168
168: ; preds = %165, %159
%169 = getelementptr inbounds [512 x i8], [512 x i8]* %25, i64 0, i64 0
%170 = getelementptr inbounds [128 x i8], [128 x i8]* %27, i64 0, i64 0
%171 = getelementptr inbounds [16 x i8], [16 x i8]* %28, i64 0, i64 0
%172 = getelementptr inbounds [16 x i8], [16 x i8]* %29, i64 0, i64 0
%173 = getelementptr inbounds [16 x i8], [16 x i8]* %30, i64 0, i64 0
%174 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 0
%175 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%176 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%177 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 0
%178 = getelementptr inbounds [16 x i8], [16 x i8]* %35, i64 0, i64 0
%179 = getelementptr inbounds [16 x i8], [16 x i8]* %36, i64 0, i64 0
%180 = getelementptr inbounds [16 x i8], [16 x i8]* %37, i64 0, i64 0
%181 = getelementptr inbounds [16 x i8], [16 x i8]* %38, i64 0, i64 0
%182 = call i32 (i8*, i8*, ...) @sprintf(i8* %169, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.38, i64 0, i64 0), i8* %170, i8* %171, i8* %172, i8* %173, i8* %174, i8* %175, i8* %176, i8* %177, i8* %178, i8* %179, i8* %180, i8* %181)
%183 = load i32, i32* %39
%184 = icmp ne i32 %183, 0
br i1 %184, label %185, label %204
185: ; preds = %168
%186 = getelementptr inbounds [256 x i8], [256 x i8]* %43, i64 0, i64 0
%187 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %186, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.39, i64 0, i64 0))
store i32* %187, i32** %6
%188 = getelementptr inbounds [1024 x i8], [1024 x i8]* %26, i64 0, i64 0
%189 = load i32*, i32** %6
%190 = call i32* @fgets(i8* %188, i32 1024, i32* %189)
%191 = getelementptr inbounds [1024 x i8], [1024 x i8]* %26, i64 0, i64 0
%192 = load i32*, i32** %6
%193 = call i32* @fgets(i8* %191, i32 1024, i32* %192)
%194 = getelementptr inbounds [1024 x i8], [1024 x i8]* %26, i64 0, i64 0
%195 = load i32*, i32** %6
%196 = call i32* @fgets(i8* %194, i32 1024, i32* %195)
%197 = getelementptr inbounds [1024 x i8], [1024 x i8]* %26, i64 0, i64 0
%198 = load i32*, i32** %6
%199 = call i32* @fgets(i8* %197, i32 1024, i32* %198)
%200 = getelementptr inbounds [1024 x i8], [1024 x i8]* %26, i64 0, i64 0
%201 = call i32 @sscanf(i8* %200, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.40, i64 0, i64 0), i32* %22)
%202 = load i32*, i32** %6
%203 = call i32 @fclose(i32* %202)
br label %234
204: ; preds = %168
%205 = load i32, i32* %41
%206 = icmp eq i32 %205, 1
br i1 %206, label %207, label %233
207: ; preds = %204
%208 = getelementptr inbounds [256 x i8], [256 x i8]* %43, i64 0, i64 0
%209 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %208, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.39, i64 0, i64 0))
store i32* %209, i32** %6
%210 = getelementptr inbounds [1024 x i8], [1024 x i8]* %26, i64 0, i64 0
%211 = load i32*, i32** %6
%212 = call i32* @fgets(i8* %210, i32 1024, i32* %211)
br label %213
213: ; preds = %217, %207
%214 = getelementptr inbounds [1024 x i8], [1024 x i8]* %26, i64 0, i64 0
%215 = call i64 @strncmp(i8* %214, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.41, i64 0, i64 0), i32 1)
%216 = icmp eq i64 %215, 0
br i1 %216, label %217, label %221
217: ; preds = %213
%218 = getelementptr inbounds [1024 x i8], [1024 x i8]* %26, i64 0, i64 0
%219 = load i32*, i32** %6
%220 = call i32* @fgets(i8* %218, i32 1024, i32* %219)
br label %213
221: ; preds = %213
store i32 1, i32* %22
br label %222
222: ; preds = %227, %221
%223 = getelementptr inbounds [1024 x i8], [1024 x i8]* %26, i64 0, i64 0
%224 = load i32*, i32** %6
%225 = call i32* @fgets(i8* %223, i32 1024, i32* %224)
%226 = icmp ne i32* %225, null
br i1 %226, label %227, label %230
227: ; preds = %222
%228 = load i32, i32* %22
%229 = add nsw i32 %228, 1
store i32 %229, i32* %22
br label %222
230: ; preds = %222
%231 = load i32*, i32** %6
%232 = call i32 @fclose(i32* %231)
br label %233
233: ; preds = %230, %204
br label %234
234: ; preds = %233, %185
%235 = load i32, i32* %22
%236 = sext i32 %235 to i64
%237 = mul i64 %236, 4
%238 = trunc i64 %237 to i32
%239 = call i64 @check_malloc(i32 %238)
%240 = inttoptr i64 %239 to float*
store float* %240, float** %7
%241 = load i32, i32* %22
%242 = sext i32 %241 to i64
%243 = mul i64 %242, 4
%244 = trunc i64 %243 to i32
%245 = call i64 @check_malloc(i32 %244)
%246 = inttoptr i64 %245 to float*
store float* %246, float** %8
%247 = load i32, i32* %22
%248 = sext i32 %247 to i64
%249 = mul i64 %248, 4
%250 = trunc i64 %249 to i32
%251 = call i64 @check_malloc(i32 %250)
%252 = inttoptr i64 %251 to float*
store float* %252, float** %9
%253 = load i32, i32* %22
%254 = sext i32 %253 to i64
%255 = mul i64 %254, 4
%256 = trunc i64 %255 to i32
%257 = call i64 @check_malloc(i32 %256)
%258 = inttoptr i64 %257 to float*
store float* %258, float** %10
%259 = load i32, i32* %22
%260 = sext i32 %259 to i64
%261 = mul i64 %260, 4
%262 = trunc i64 %261 to i32
%263 = call i64 @check_malloc(i32 %262)
%264 = inttoptr i64 %263 to float*
store float* %264, float** %11
%265 = load i32, i32* %22
%266 = sext i32 %265 to i64
%267 = mul i64 %266, 4
%268 = trunc i64 %267 to i32
%269 = call i64 @check_malloc(i32 %268)
%270 = inttoptr i64 %269 to float*
store float* %270, float** %12
%271 = load i32, i32* %41
%272 = icmp eq i32 %271, 1
br i1 %272, label %273, label %280
273: ; preds = %234
%274 = getelementptr inbounds [256 x i8], [256 x i8]* %43, i64 0, i64 0
%275 = load float*, float** %7
%276 = load float*, float** %8
%277 = load float*, float** %9
%278 = load i32, i32* %22
%279 = call i32 @read_bbpfile(i8* %274, float* %275, float* %276, float* %277, i32 %278)
br label %295
280: ; preds = %234
%281 = getelementptr inbounds [256 x i8], [256 x i8]* %43, i64 0, i64 0
%282 = load float*, float** %7
%283 = load float*, float** %8
%284 = load i32, i32* %22
%285 = load i32, i32* %40
%286 = load i32, i32* %39
%287 = call i32 @read_specfile(i8* %281, float* %282, float* %283, i32 %284, i32 %285, i32 %286)
%288 = getelementptr inbounds [256 x i8], [256 x i8]* %44, i64 0, i64 0
%289 = load float*, float** %7
%290 = load float*, float** %9
%291 = load i32, i32* %22
%292 = load i32, i32* %40
%293 = load i32, i32* %39
%294 = call i32 @read_specfile(i8* %288, float* %289, float* %290, i32 %291, i32 %292, i32 %293)
br label %295
295: ; preds = %280, %273
%296 = getelementptr inbounds [256 x i8], [256 x i8]* %45, i64 0, i64 0
%297 = load i8, i8* %296
%298 = sext i8 %297 to i32
%299 = icmp eq i32 %298, 0
br i1 %299, label %308, label %300
300: ; preds = %295
%301 = load i32, i32* %41
%302 = icmp eq i32 %301, 0
br i1 %302, label %303, label %382
303: ; preds = %300
%304 = getelementptr inbounds [256 x i8], [256 x i8]* %46, i64 0, i64 0
%305 = load i8, i8* %304
%306 = sext i8 %305 to i32
%307 = icmp eq i32 %306, 0
br i1 %307, label %308, label %382
308: ; preds = %303, %295
store i32 0, i32* %20
br label %309
309: ; preds = %348, %308
%310 = load i32, i32* %20
%311 = load i32, i32* %22
%312 = icmp slt i32 %310, %311
br i1 %312, label %313, label %351
313: ; preds = %309
%314 = load float*, float** %8
%315 = load i32, i32* %20
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds float, float* %314, i64 %316
%318 = load float, float* %317
%319 = load float*, float** %10
%320 = load i32, i32* %20
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds float, float* %319, i64 %321
store float %318, float* %322
%323 = load float*, float** %9
%324 = load i32, i32* %20
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds float, float* %323, i64 %325
%327 = load float, float* %326
%328 = load float*, float** %11
%329 = load i32, i32* %20
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds float, float* %328, i64 %330
store float %327, float* %331
%332 = load float*, float** %10
%333 = load i32, i32* %20
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds float, float* %332, i64 %334
%336 = load float, float* %335
%337 = load float*, float** %11
%338 = load i32, i32* %20
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds float, float* %337, i64 %339
%341 = load float, float* %340
%342 = fmul float %336, %341
%343 = call float @sqrt(float %342)
%344 = load float*, float** %12
%345 = load i32, i32* %20
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds float, float* %344, i64 %346
store float %343, float* %347
br label %348
348: ; preds = %313
%349 = load i32, i32* %20
%350 = add nsw i32 %349, 1
store i32 %350, i32* %20
br label %309
351: ; preds = %309
%352 = load float, float* %49
store float %352, float* %14
%353 = load float, float* %50
store float %353, float* %15
store float 0xC08F3F3340000000, float* %16
%354 = load float, float* %14
%355 = fpext float %354 to double
%356 = fcmp oge double %355, 0.000000e+00
br i1 %356, label %357, label %366
357: ; preds = %351
%358 = load float, float* %15
%359 = fpext float %358 to double
%360 = fcmp oge double %359, 0.000000e+00
br i1 %360, label %361, label %366
361: ; preds = %357
%362 = load float, float* %14
%363 = load float, float* %15
%364 = fmul float %362, %363
%365 = call float @sqrt(float %364)
store float %365, float* %16
br label %366
366: ; preds = %361, %357, %351
%367 = load float, float* %51
store float %367, float* %17
%368 = load float, float* %52
store float %368, float* %18
store float 0xC08F3F3340000000, float* %19
%369 = load float, float* %17
%370 = fpext float %369 to double
%371 = fcmp oge double %370, 0.000000e+00
br i1 %371, label %372, label %381
372: ; preds = %366
%373 = load float, float* %18
%374 = fpext float %373 to double
%375 = fcmp oge double %374, 0.000000e+00
br i1 %375, label %376, label %381
376: ; preds = %372
%377 = load float, float* %17
%378 = load float, float* %18
%379 = fmul float %377, %378
%380 = call float @sqrt(float %379)
store float %380, float* %19
br label %381
381: ; preds = %376, %372, %366
br label %563
382: ; preds = %303, %300
%383 = load i32, i32* %41
%384 = icmp eq i32 %383, 1
br i1 %384, label %385, label %392
385: ; preds = %382
%386 = getelementptr inbounds [256 x i8], [256 x i8]* %45, i64 0, i64 0
%387 = load float*, float** %7
%388 = load float*, float** %10
%389 = load float*, float** %11
%390 = load i32, i32* %22
%391 = call i32 @read_bbpfile(i8* %386, float* %387, float* %388, float* %389, i32 %390)
br label %407
392: ; preds = %382
%393 = getelementptr inbounds [256 x i8], [256 x i8]* %45, i64 0, i64 0
%394 = load float*, float** %7
%395 = load float*, float** %10
%396 = load i32, i32* %22
%397 = load i32, i32* %40
%398 = load i32, i32* %39
%399 = call i32 @read_specfile(i8* %393, float* %394, float* %395, i32 %396, i32 %397, i32 %398)
%400 = getelementptr inbounds [256 x i8], [256 x i8]* %46, i64 0, i64 0
%401 = load float*, float** %7
%402 = load float*, float** %11
%403 = load i32, i32* %22
%404 = load i32, i32* %40
%405 = load i32, i32* %39
%406 = call i32 @read_specfile(i8* %400, float* %401, float* %402, i32 %403, i32 %404, i32 %405)
br label %407
407: ; preds = %392, %385
store i32 0, i32* %20
br label %408
408: ; preds = %491, %407
%409 = load i32, i32* %20
%410 = load i32, i32* %22
%411 = icmp slt i32 %409, %410
br i1 %411, label %412, label %494
412: ; preds = %408
%413 = load float*, float** %10
%414 = load i32, i32* %20
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds float, float* %413, i64 %415
%417 = load float, float* %416
%418 = fpext float %417 to double
%419 = fcmp une double %418, 0.000000e+00
br i1 %419, label %420, label %437
420: ; preds = %412
%421 = load float*, float** %8
%422 = load i32, i32* %20
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds float, float* %421, i64 %423
%425 = load float, float* %424
%426 = load float*, float** %10
%427 = load i32, i32* %20
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds float, float* %426, i64 %428
%430 = load float, float* %429
%431 = fdiv float %425, %430
%432 = call float @log(float %431)
%433 = load float*, float** %10
%434 = load i32, i32* %20
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds float, float* %433, i64 %435
store float %432, float* %436
br label %442
437: ; preds = %412
%438 = load float*, float** %10
%439 = load i32, i32* %20
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds float, float* %438, i64 %440
store float -9.900000e+01, float* %441
br label %442
442: ; preds = %437, %420
%443 = load float*, float** %11
%444 = load i32, i32* %20
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds float, float* %443, i64 %445
%447 = load float, float* %446
%448 = fpext float %447 to double
%449 = fcmp une double %448, 0.000000e+00
br i1 %449, label %450, label %467
450: ; preds = %442
%451 = load float*, float** %9
%452 = load i32, i32* %20
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds float, float* %451, i64 %453
%455 = load float, float* %454
%456 = load float*, float** %11
%457 = load i32, i32* %20
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds float, float* %456, i64 %458
%460 = load float, float* %459
%461 = fdiv float %455, %460
%462 = call float @log(float %461)
%463 = load float*, float** %11
%464 = load i32, i32* %20
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds float, float* %463, i64 %465
store float %462, float* %466
br label %472
467: ; preds = %442
%468 = load float*, float** %11
%469 = load i32, i32* %20
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds float, float* %468, i64 %470
store float -9.900000e+01, float* %471
br label %472
472: ; preds = %467, %450
%473 = load float*, float** %10
%474 = load i32, i32* %20
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds float, float* %473, i64 %475
%477 = load float, float* %476
%478 = load float*, float** %11
%479 = load i32, i32* %20
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds float, float* %478, i64 %480
%482 = load float, float* %481
%483 = fadd float %477, %482
%484 = fpext float %483 to double
%485 = fmul double 5.000000e-01, %484
%486 = fptrunc double %485 to float
%487 = load float*, float** %12
%488 = load i32, i32* %20
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds float, float* %487, i64 %489
store float %486, float* %490
br label %491
491: ; preds = %472
%492 = load i32, i32* %20
%493 = add nsw i32 %492, 1
store i32 %493, i32* %20
br label %408
494: ; preds = %408
%495 = load float, float* %49
%496 = fpext float %495 to double
%497 = fcmp ogt double %496, 0.000000e+00
br i1 %497, label %498, label %507
498: ; preds = %494
%499 = load float, float* %53
%500 = fpext float %499 to double
%501 = fcmp ogt double %500, 0.000000e+00
br i1 %501, label %502, label %507
502: ; preds = %498
%503 = load float, float* %49
%504 = load float, float* %53
%505 = fdiv float %503, %504
%506 = call float @log(float %505)
store float %506, float* %14
br label %508
507: ; preds = %498, %494
store float 0xC08F3F3340000000, float* %14
br label %508
508: ; preds = %507, %502
%509 = load float, float* %50
%510 = fpext float %509 to double
%511 = fcmp ogt double %510, 0.000000e+00
br i1 %511, label %512, label %521
512: ; preds = %508
%513 = load float, float* %54
%514 = fpext float %513 to double
%515 = fcmp ogt double %514, 0.000000e+00
br i1 %515, label %516, label %521
516: ; preds = %512
%517 = load float, float* %50
%518 = load float, float* %54
%519 = fdiv float %517, %518
%520 = call float @log(float %519)
store float %520, float* %15
br label %522
521: ; preds = %512, %508
store float 0xC08F3F3340000000, float* %15
br label %522
522: ; preds = %521, %516
%523 = load float, float* %14
%524 = load float, float* %15
%525 = fadd float %523, %524
%526 = fpext float %525 to double
%527 = fmul double 5.000000e-01, %526
%528 = fptrunc double %527 to float
store float %528, float* %16
%529 = load float, float* %51
%530 = fpext float %529 to double
%531 = fcmp ogt double %530, 0.000000e+00
br i1 %531, label %532, label %541
532: ; preds = %522
%533 = load float, float* %55
%534 = fpext float %533 to double
%535 = fcmp ogt double %534, 0.000000e+00
br i1 %535, label %536, label %541
536: ; preds = %532
%537 = load float, float* %51
%538 = load float, float* %55
%539 = fdiv float %537, %538
%540 = call float @log(float %539)
store float %540, float* %17
br label %542
541: ; preds = %532, %522
store float 0xC08F3F3340000000, float* %17
br label %542
542: ; preds = %541, %536
%543 = load float, float* %52
%544 = fpext float %543 to double
%545 = fcmp ogt double %544, 0.000000e+00
br i1 %545, label %546, label %555
546: ; preds = %542
%547 = load float, float* %56
%548 = fpext float %547 to double
%549 = fcmp ogt double %548, 0.000000e+00
br i1 %549, label %550, label %555
550: ; preds = %546
%551 = load float, float* %52
%552 = load float, float* %56
%553 = fdiv float %551, %552
%554 = call float @log(float %553)
store float %554, float* %18
br label %556
555: ; preds = %546, %542
store float 0xC08F3F3340000000, float* %18
br label %556
556: ; preds = %555, %550
%557 = load float, float* %17
%558 = load float, float* %18
%559 = fadd float %557, %558
%560 = fpext float %559 to double
%561 = fmul double 5.000000e-01, %560
%562 = fptrunc double %561 to float
store float %562, float* %19
br label %563
563: ; preds = %556, %381
%564 = load i32, i32* %42
%565 = icmp ne i32 %564, 0
br i1 %565, label %566, label %602
566: ; preds = %563
%567 = load i32, i32* @stdout
%568 = call i32 (i32, i8*, ...) @fprintf(i32 %567, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.42, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.43, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.44, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.45, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.47, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.48, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.49, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.50, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.51, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.52, i64 0, i64 0))
store i32 0, i32* %20
br label %569
569: ; preds = %582, %566
%570 = load i32, i32* %20
%571 = load i32, i32* %22
%572 = icmp slt i32 %570, %571
br i1 %572, label %573, label %585
573: ; preds = %569
%574 = load i32, i32* @stdout
%575 = load float*, float** %7
%576 = load i32, i32* %20
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds float, float* %575, i64 %577
%579 = load float, float* %578
%580 = fpext float %579 to double
%581 = call i32 (i32, i8*, ...) @fprintf(i32 %574, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %580)
br label %582
582: ; preds = %573
%583 = load i32, i32* %20
%584 = add nsw i32 %583, 1
store i32 %584, i32* %20
br label %569
585: ; preds = %569
%586 = load float, float* %49
%587 = fpext float %586 to double
%588 = fcmp oge double %587, 0.000000e+00
br i1 %588, label %589, label %592
589: ; preds = %585
%590 = load i32, i32* @stdout
%591 = call i32 (i32, i8*, ...) @fprintf(i32 %590, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0))
br label %592
592: ; preds = %589, %585
%593 = load float, float* %51
%594 = fpext float %593 to double
%595 = fcmp oge double %594, 0.000000e+00
br i1 %595, label %596, label %599
596: ; preds = %592
%597 = load i32, i32* @stdout
%598 = call i32 (i32, i8*, ...) @fprintf(i32 %597, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.56, i64 0, i64 0))
br label %599
599: ; preds = %596, %592
%600 = load i32, i32* @stdout
%601 = call i32 (i32, i8*, ...) @fprintf(i32 %600, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.57, i64 0, i64 0))
br label %602
602: ; preds = %599, %563
%603 = load i32, i32* @stdout
%604 = getelementptr inbounds [512 x i8], [512 x i8]* %25, i64 0, i64 0
%605 = call i32 (i32, i8*, ...) @fprintf(i32 %603, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.58, i64 0, i64 0), i8* %604)
%606 = load i32, i32* @stdout
%607 = getelementptr inbounds [128 x i8], [128 x i8]* %47, i64 0, i64 0
%608 = call i32 (i32, i8*, ...) @fprintf(i32 %606, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0), i8* %607)
store i32 0, i32* %20
br label %609
609: ; preds = %622, %602
%610 = load i32, i32* %20
%611 = load i32, i32* %22
%612 = icmp slt i32 %610, %611
br i1 %612, label %613, label %625
613: ; preds = %609
%614 = load i32, i32* @stdout
%615 = load float*, float** %10
%616 = load i32, i32* %20
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds float, float* %615, i64 %617
%619 = load float, float* %618
%620 = fpext float %619 to double
%621 = call i32 (i32, i8*, ...) @fprintf(i32 %614, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %620)
br label %622
622: ; preds = %613
%623 = load i32, i32* %20
%624 = add nsw i32 %623, 1
store i32 %624, i32* %20
br label %609
625: ; preds = %609
%626 = load float, float* %49
%627 = fpext float %626 to double
%628 = fcmp oge double %627, 0.000000e+00
br i1 %628, label %629, label %634
629: ; preds = %625
%630 = load i32, i32* @stdout
%631 = load float, float* %14
%632 = fpext float %631 to double
%633 = call i32 (i32, i8*, ...) @fprintf(i32 %630, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %632)
br label %634
634: ; preds = %629, %625
%635 = load float, float* %51
%636 = fpext float %635 to double
%637 = fcmp oge double %636, 0.000000e+00
br i1 %637, label %638, label %643
638: ; preds = %634
%639 = load i32, i32* @stdout
%640 = load float, float* %17
%641 = fpext float %640 to double
%642 = call i32 (i32, i8*, ...) @fprintf(i32 %639, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %641)
br label %643
643: ; preds = %638, %634
%644 = load i32, i32* @stdout
%645 = call i32 (i32, i8*, ...) @fprintf(i32 %644, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.57, i64 0, i64 0))
%646 = load i32, i32* @stdout
%647 = getelementptr inbounds [512 x i8], [512 x i8]* %25, i64 0, i64 0
%648 = call i32 (i32, i8*, ...) @fprintf(i32 %646, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.58, i64 0, i64 0), i8* %647)
%649 = load i32, i32* @stdout
%650 = getelementptr inbounds [128 x i8], [128 x i8]* %48, i64 0, i64 0
%651 = call i32 (i32, i8*, ...) @fprintf(i32 %649, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0), i8* %650)
store i32 0, i32* %20
br label %652
652: ; preds = %665, %643
%653 = load i32, i32* %20
%654 = load i32, i32* %22
%655 = icmp slt i32 %653, %654
br i1 %655, label %656, label %668
656: ; preds = %652
%657 = load i32, i32* @stdout
%658 = load float*, float** %11
%659 = load i32, i32* %20
%660 = sext i32 %659 to i64
%661 = getelementptr inbounds float, float* %658, i64 %660
%662 = load float, float* %661
%663 = fpext float %662 to double
%664 = call i32 (i32, i8*, ...) @fprintf(i32 %657, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %663)
br label %665
665: ; preds = %656
%666 = load i32, i32* %20
%667 = add nsw i32 %666, 1
store i32 %667, i32* %20
br label %652
668: ; preds = %652
%669 = load float, float* %50
%670 = fpext float %669 to double
%671 = fcmp oge double %670, 0.000000e+00
br i1 %671, label %672, label %677
672: ; preds = %668
%673 = load i32, i32* @stdout
%674 = load float, float* %15
%675 = fpext float %674 to double
%676 = call i32 (i32, i8*, ...) @fprintf(i32 %673, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %675)
br label %677
677: ; preds = %672, %668
%678 = load float, float* %52
%679 = fpext float %678 to double
%680 = fcmp oge double %679, 0.000000e+00
br i1 %680, label %681, label %686
681: ; preds = %677
%682 = load i32, i32* @stdout
%683 = load float, float* %18
%684 = fpext float %683 to double
%685 = call i32 (i32, i8*, ...) @fprintf(i32 %682, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %684)
br label %686
686: ; preds = %681, %677
%687 = load i32, i32* @stdout
%688 = call i32 (i32, i8*, ...) @fprintf(i32 %687, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.57, i64 0, i64 0))
%689 = load i32, i32* @stdout
%690 = getelementptr inbounds [512 x i8], [512 x i8]* %25, i64 0, i64 0
%691 = call i32 (i32, i8*, ...) @fprintf(i32 %689, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.58, i64 0, i64 0), i8* %690)
%692 = load i32, i32* @stdout
%693 = call i32 (i32, i8*, ...) @fprintf(i32 %692, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.59, i64 0, i64 0))
store i32 0, i32* %20
br label %694
694: ; preds = %707, %686
%695 = load i32, i32* %20
%696 = load i32, i32* %22
%697 = icmp slt i32 %695, %696
br i1 %697, label %698, label %710
698: ; preds = %694
%699 = load i32, i32* @stdout
%700 = load float*, float** %12
%701 = load i32, i32* %20
%702 = sext i32 %701 to i64
%703 = getelementptr inbounds float, float* %700, i64 %702
%704 = load float, float* %703
%705 = fpext float %704 to double
%706 = call i32 (i32, i8*, ...) @fprintf(i32 %699, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %705)
br label %707
707: ; preds = %698
%708 = load i32, i32* %20
%709 = add nsw i32 %708, 1
store i32 %709, i32* %20
br label %694
710: ; preds = %694
%711 = load float, float* %49
%712 = fpext float %711 to double
%713 = fcmp oge double %712, 0.000000e+00
br i1 %713, label %714, label %723
714: ; preds = %710
%715 = load float, float* %50
%716 = fpext float %715 to double
%717 = fcmp oge double %716, 0.000000e+00
br i1 %717, label %718, label %723
718: ; preds = %714
%719 = load i32, i32* @stdout
%720 = load float, float* %16
%721 = fpext float %720 to double
%722 = call i32 (i32, i8*, ...) @fprintf(i32 %719, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %721)
br label %723
723: ; preds = %718, %714, %710
%724 = load float, float* %51
%725 = fpext float %724 to double
%726 = fcmp oge double %725, 0.000000e+00
br i1 %726, label %727, label %736
727: ; preds = %723
%728 = load float, float* %52
%729 = fpext float %728 to double
%730 = fcmp oge double %729, 0.000000e+00
br i1 %730, label %731, label %736
731: ; preds = %727
%732 = load i32, i32* @stdout
%733 = load float, float* %19
%734 = fpext float %733 to double
%735 = call i32 (i32, i8*, ...) @fprintf(i32 %732, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %734)
br label %736
736: ; preds = %731, %727, %723
%737 = load i32, i32* @stdout
%738 = call i32 (i32, i8*, ...) @fprintf(i32 %737, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.57, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@.str = [5 x i8] c"-999\00"
@.str.1 = [10 x i8] c"datafile1\00"
@.str.2 = [2 x i8] c"s\00"
@.str.3 = [10 x i8] c"datafile2\00"
@.str.4 = [9 x i8] c"simfile1\00"
@.str.5 = [9 x i8] c"simfile2\00"
@.str.6 = [6 x i8] c"comp1\00"
@.str.7 = [6 x i8] c"comp2\00"
@.str.8 = [7 x i8] c"eqname\00"
@.str.9 = [4 x i8] c"mag\00"
@.str.10 = [5 x i8] c"stat\00"
@.str.11 = [4 x i8] c"lon\00"
@.str.12 = [4 x i8] c"lat\00"
@.str.13 = [6 x i8] c"seqno\00"
@.str.14 = [5 x i8] c"vs30\00"
@.str.15 = [3 x i8] c"cd\00"
@.str.16 = [5 x i8] c"xcos\00"
@.str.17 = [5 x i8] c"ycos\00"
@.str.18 = [4 x i8] c"flo\00"
@.str.19 = [2 x i8] c"f\00"
@.str.20 = [4 x i8] c"fhi\00"
@.str.21 = [13 x i8] c"print_header\00"
@.str.22 = [2 x i8] c"d\00"
@.str.23 = [5 x i8] c"pga1\00"
@.str.24 = [5 x i8] c"pga2\00"
@.str.25 = [5 x i8] c"pgv1\00"
@.str.26 = [5 x i8] c"pgv2\00"
@.str.27 = [9 x i8] c"sim_pga1\00"
@.str.28 = [9 x i8] c"sim_pga2\00"
@.str.29 = [9 x i8] c"sim_pgv1\00"
@.str.30 = [9 x i8] c"sim_pgv2\00"
@.str.31 = [11 x i8] c"bbp_format\00"
@.str.32 = [15 x i8] c"respect_format\00"
@.str.33 = [3 x i8] c"np\00"
@.str.34 = [9 x i8] c"sa_field\00"
@.str.35 = [5 x i8] c"%.3f\00"
@.str.36 = [11 x i8] c"-99999.999\00"
@.str.37 = [10 x i8] c"99999.999\00"
@.str.38 = [36 x i8] c"%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\00"
@.str.39 = [2 x i8] c"r\00"
@.str.40 = [3 x i8] c"%d\00"
@.str.41 = [2 x i8] c"#\00"
@stdout = global i32 0
@.str.42 = [39 x i8] c"%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\09%s\00"
@.str.43 = [3 x i8] c"EQ\00"
@.str.44 = [4 x i8] c"Mag\00"
@.str.45 = [12 x i8] c"stat_seq_no\00"
@.str.46 = [5 x i8] c"Vs30\00"
@.str.47 = [11 x i8] c"close_dist\00"
@.str.48 = [5 x i8] c"Xcos\00"
@.str.49 = [5 x i8] c"Ycos\00"
@.str.50 = [6 x i8] c"T_min\00"
@.str.51 = [6 x i8] c"T_max\00"
@.str.52 = [5 x i8] c"comp\00"
@.str.53 = [6 x i8] c"\09%.5e\00"
@.str.54 = [4 x i8] c"\09%s\00"
@.str.55 = [4 x i8] c"pga\00"
@.str.56 = [4 x i8] c"pgv\00"
@.str.57 = [2 x i8] c"\0A\00"
@.str.58 = [3 x i8] c"%s\00"
@.str.59 = [5 x i8] c"avgh\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca float
%5 = alloca float
%6 = alloca [512 x i8]
%7 = alloca [1024 x i8]
%8 = alloca [128 x i8]
%9 = alloca [16 x i8]
%10 = alloca [16 x i8]
%11 = alloca [16 x i8]
%12 = alloca [16 x i8]
%13 = alloca [16 x i8]
%14 = alloca [16 x i8]
%15 = alloca [16 x i8]
%16 = alloca [16 x i8]
%17 = alloca [16 x i8]
%18 = alloca [16 x i8]
%19 = alloca [16 x i8]
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca [256 x i8]
%25 = alloca [256 x i8]
%26 = alloca [256 x i8]
%27 = alloca [256 x i8]
%28 = alloca [128 x i8]
%29 = alloca [128 x i8]
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = bitcast i32* %3 to i8*
%39 = bitcast float* %4 to i8*
store float 0.000000e+00, float* %4
%40 = bitcast float* %5 to i8*
store float 0.000000e+00, float* %5
%41 = getelementptr inbounds [512 x i8], [512 x i8]* %6, i64 0, i64 0
%42 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 0
%43 = getelementptr inbounds [128 x i8], [128 x i8]* %8, i64 0, i64 0
%44 = getelementptr inbounds [16 x i8], [16 x i8]* %9, i64 0, i64 0
%45 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%46 = getelementptr inbounds [16 x i8], [16 x i8]* %11, i64 0, i64 0
%47 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 0
%48 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%49 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%50 = getelementptr inbounds [16 x i8], [16 x i8]* %15, i64 0, i64 0
%51 = getelementptr inbounds [16 x i8], [16 x i8]* %16, i64 0, i64 0
%52 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 0
%53 = getelementptr inbounds [16 x i8], [16 x i8]* %18, i64 0, i64 0
%54 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 0
%55 = bitcast i32* %20 to i8*
store i32 1, i32* %20
%56 = bitcast i32* %21 to i8*
store i32 7, i32* %21
%57 = bitcast i32* %22 to i8*
store i32 0, i32* %22
%58 = bitcast i32* %23 to i8*
store i32 0, i32* %23
%59 = getelementptr inbounds [256 x i8], [256 x i8]* %24, i64 0, i64 0
%60 = getelementptr inbounds [256 x i8], [256 x i8]* %25, i64 0, i64 0
%61 = getelementptr inbounds [256 x i8], [256 x i8]* %26, i64 0, i64 0
%62 = getelementptr inbounds [256 x i8], [256 x i8]* %27, i64 0, i64 0
%63 = getelementptr inbounds [128 x i8], [128 x i8]* %28, i64 0, i64 0
%64 = getelementptr inbounds [128 x i8], [128 x i8]* %29, i64 0, i64 0
%65 = bitcast float* %30 to i8*
store float 0xC08F3F3340000000, float* %30
%66 = bitcast float* %31 to i8*
store float 0xC08F3F3340000000, float* %31
%67 = bitcast float* %32 to i8*
store float 0xC08F3F3340000000, float* %32
%68 = bitcast float* %33 to i8*
store float 0xC08F3F3340000000, float* %33
%69 = bitcast float* %34 to i8*
store float 0xC08F3F3340000000, float* %34
%70 = bitcast float* %35 to i8*
store float 0xC08F3F3340000000, float* %35
%71 = bitcast float* %36 to i8*
store float 0xC08F3F3340000000, float* %36
%72 = bitcast float* %37 to i8*
store float 0xC08F3F3340000000, float* %37
store i8 0, i8* %59
store i8 0, i8* %60
store i8 0, i8* %61
store i8 0, i8* %62
%73 = tail call i32 @setpar(i32 %0, i8** %1)
%74 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %59)
%75 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %60)
%76 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %61)
%77 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %62)
%78 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %63)
%79 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %64)
%80 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %43)
%81 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %44)
%82 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %45)
%83 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %46)
%84 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %47)
%85 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %48)
%86 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %49)
%87 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %50)
%88 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %51)
%89 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %52)
%90 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %4)
%91 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %5)
%92 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.21, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), i32* %23)
%93 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.23, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %30)
%94 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.24, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %31)
%95 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.25, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %32)
%96 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.26, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %33)
%97 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.27, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %34)
%98 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.28, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %35)
%99 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.29, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %36)
%100 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.19, i64 0, i64 0), float* %37)
%101 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.31, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), i32* %22)
%102 = load i32, i32* %22
%103 = icmp eq i32 %102, 1
br i1 %103, label %104, label %105
104: ; preds = %2
store i32 0, i32* %20
br label %105
105: ; preds = %104, %2
%106 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.32, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), i32* %20)
%107 = load i32, i32* %20
%108 = icmp eq i32 %107, 0
%109 = load i32, i32* %22
%110 = icmp eq i32 %109, 0
%111 = select i1 %108, i1 %110, i1 false
br i1 %111, label %112, label %114
112: ; preds = %105
%113 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.33, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), i32* %3)
br label %114
114: ; preds = %112, %105
%115 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.34, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0), i32* %21)
%116 = call i32 (...) @endpar()
%117 = load float, float* %5
%118 = fcmp ogt float %117, 0.000000e+00
br i1 %118, label %119, label %123
119: ; preds = %114
%120 = fpext float %117 to double
%121 = fdiv double 1.000000e+00, %120
%122 = call i32 (i8*, i8*, ...) @sprintf(i8* %53, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.35, i64 0, i64 0), double %121)
br label %124
123: ; preds = %114
br label %124
124: ; preds = %123, %119
%125 = load float, float* %4
%126 = fcmp ogt float %125, 0.000000e+00
br i1 %126, label %127, label %131
127: ; preds = %124
%128 = fpext float %125 to double
%129 = fdiv double 1.000000e+00, %128
%130 = call i32 (i8*, i8*, ...) @sprintf(i8* %54, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.35, i64 0, i64 0), double %129)
br label %132
131: ; preds = %124
br label %132
132: ; preds = %131, %127
%133 = call i32 (i8*, i8*, ...) @sprintf(i8* %41, i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.38, i64 0, i64 0), i8* %43, i8* %44, i8* %45, i8* %46, i8* %47, i8* %48, i8* %49, i8* %50, i8* %51, i8* %52, i8* %53, i8* %54)
%134 = load i32, i32* %20
%135 = icmp eq i32 %134, 0
br i1 %135, label %143, label %136
136: ; preds = %132
%137 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %59, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.39, i64 0, i64 0))
%138 = call i32* @fgets(i8* %42, i32 1024, i32* %137)
%139 = call i32* @fgets(i8* %42, i32 1024, i32* %137)
%140 = call i32* @fgets(i8* %42, i32 1024, i32* %137)
%141 = call i32* @fgets(i8* %42, i32 1024, i32* %137)
%142 = call i32 @sscanf(i8* %42, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.40, i64 0, i64 0), i32* %3)
br label %163
143: ; preds = %132
%144 = load i32, i32* %22
%145 = icmp eq i32 %144, 1
br i1 %145, label %146, label %166
146: ; preds = %143
%147 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %59, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.39, i64 0, i64 0))
%148 = call i32* @fgets(i8* %42, i32 1024, i32* %147)
%149 = call i64 @strncmp(i8* %42, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.41, i64 0, i64 0), i32 1)
%150 = icmp eq i64 %149, 0
br i1 %150, label %154, label %151
151: ; preds = %154, %146
store i32 1, i32* %3
%152 = call i32* @fgets(i8* %42, i32 1024, i32* %147)
%153 = icmp eq i32* %152, null
br i1 %153, label %163, label %158
154: ; preds = %146, %154
%155 = call i32* @fgets(i8* %42, i32 1024, i32* %147)
%156 = call i64 @strncmp(i8* %42, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.41, i64 0, i64 0), i32 1)
%157 = icmp eq i64 %156, 0
br i1 %157, label %154, label %151
158: ; preds = %151, %158
%159 = load i32, i32* %3
%160 = add nsw i32 %159, 1
store i32 %160, i32* %3
%161 = call i32* @fgets(i8* %42, i32 1024, i32* %147)
%162 = icmp eq i32* %161, null
br i1 %162, label %163, label %158
163: ; preds = %158, %151, %136
%164 = phi i32* [ %137, %136 ], [ %147, %151 ], [ %147, %158 ]
%165 = call i32 @fclose(i32* %164)
br label %166
166: ; preds = %163, %143
%167 = load i32, i32* %3
%168 = shl i32 %167, 2
%169 = call i64 @check_malloc(i32 %168)
%170 = inttoptr i64 %169 to float*
%171 = load i32, i32* %3
%172 = shl i32 %171, 2
%173 = call i64 @check_malloc(i32 %172)
%174 = inttoptr i64 %173 to float*
%175 = load i32, i32* %3
%176 = shl i32 %175, 2
%177 = call i64 @check_malloc(i32 %176)
%178 = inttoptr i64 %177 to float*
%179 = load i32, i32* %3
%180 = shl i32 %179, 2
%181 = call i64 @check_malloc(i32 %180)
%182 = inttoptr i64 %181 to float*
%183 = load i32, i32* %3
%184 = shl i32 %183, 2
%185 = call i64 @check_malloc(i32 %184)
%186 = inttoptr i64 %185 to float*
%187 = load i32, i32* %3
%188 = shl i32 %187, 2
%189 = call i64 @check_malloc(i32 %188)
%190 = inttoptr i64 %189 to float*
%191 = load i32, i32* %22
%192 = icmp eq i32 %191, 1
%193 = load i32, i32* %3
br i1 %192, label %194, label %196
194: ; preds = %166
%195 = call i32 @read_bbpfile(i8* %59, float* %170, float* %174, float* %178, i32 %193)
br label %204
196: ; preds = %166
%197 = load i32, i32* %21
%198 = load i32, i32* %20
%199 = call i32 @read_specfile(i8* %59, float* %170, float* %174, i32 %193, i32 %197, i32 %198)
%200 = load i32, i32* %3
%201 = load i32, i32* %21
%202 = load i32, i32* %20
%203 = call i32 @read_specfile(i8* %60, float* %170, float* %178, i32 %200, i32 %201, i32 %202)
br label %204
204: ; preds = %196, %194
%205 = load i8, i8* %61
%206 = icmp eq i8 %205, 0
br i1 %206, label %213, label %207
207: ; preds = %204
%208 = load i32, i32* %22
%209 = icmp eq i32 %208, 0
%210 = load i8, i8* %62
%211 = icmp eq i8 %210, 0
%212 = select i1 %209, i1 %211, i1 false
br i1 %212, label %213, label %251
213: ; preds = %207, %204
%214 = load i32, i32* %3
%215 = icmp sgt i32 %214, 0
br i1 %215, label %216, label %232
216: ; preds = %213, %216
%217 = phi i64 [ %228, %216 ], [ 0, %213 ]
%218 = getelementptr inbounds float, float* %174, i64 %217
%219 = load float, float* %218
%220 = getelementptr inbounds float, float* %182, i64 %217
store float %219, float* %220
%221 = getelementptr inbounds float, float* %178, i64 %217
%222 = load float, float* %221
%223 = getelementptr inbounds float, float* %186, i64 %217
store float %222, float* %223
%224 = load float, float* %220
%225 = fmul float %222, %224
%226 = call float @sqrt(float %225)
%227 = getelementptr inbounds float, float* %190, i64 %217
store float %226, float* %227
%228 = add nuw nsw i64 %217, 1
%229 = load i32, i32* %3
%230 = sext i32 %229 to i64
%231 = icmp slt i64 %228, %230
br i1 %231, label %216, label %232
232: ; preds = %216, %213
%233 = load float, float* %30
%234 = load float, float* %31
%235 = fcmp ult float %233, 0.000000e+00
%236 = fcmp ult float %234, 0.000000e+00
%237 = select i1 %235, i1 true, i1 %236
br i1 %237, label %241, label %238
238: ; preds = %232
%239 = fmul float %233, %234
%240 = call float @sqrt(float %239)
br label %241
241: ; preds = %238, %232
%242 = phi float [ %240, %238 ], [ 0xC08F3F3340000000, %232 ]
%243 = load float, float* %32
%244 = load float, float* %33
%245 = fcmp ult float %243, 0.000000e+00
%246 = fcmp ult float %244, 0.000000e+00
%247 = select i1 %245, i1 true, i1 %246
br i1 %247, label %342, label %248
248: ; preds = %241
%249 = fmul float %243, %244
%250 = call float @sqrt(float %249)
br label %342
251: ; preds = %207
%252 = icmp eq i32 %208, 1
%253 = load i32, i32* %3
br i1 %252, label %254, label %256
254: ; preds = %251
%255 = call i32 @read_bbpfile(i8* %61, float* %170, float* %182, float* %186, i32 %253)
br label %264
256: ; preds = %251
%257 = load i32, i32* %21
%258 = load i32, i32* %20
%259 = call i32 @read_specfile(i8* %61, float* %170, float* %182, i32 %253, i32 %257, i32 %258)
%260 = load i32, i32* %3
%261 = load i32, i32* %21
%262 = load i32, i32* %20
%263 = call i32 @read_specfile(i8* %62, float* %170, float* %186, i32 %260, i32 %261, i32 %262)
br label %264
264: ; preds = %256, %254
%265 = load i32, i32* %3
%266 = icmp sgt i32 %265, 0
br i1 %266, label %267, label %297
267: ; preds = %264, %287
%268 = phi i64 [ %293, %287 ], [ 0, %264 ]
%269 = getelementptr inbounds float, float* %182, i64 %268
%270 = load float, float* %269
%271 = fcmp une float %270, 0.000000e+00
br i1 %271, label %272, label %277
272: ; preds = %267
%273 = getelementptr inbounds float, float* %174, i64 %268
%274 = load float, float* %273
%275 = fdiv float %274, %270
%276 = call float @log(float %275)
br label %277
277: ; preds = %267, %272
%278 = phi float [ %276, %272 ], [ -9.900000e+01, %267 ]
store float %278, float* %269
%279 = getelementptr inbounds float, float* %186, i64 %268
%280 = load float, float* %279
%281 = fcmp une float %280, 0.000000e+00
br i1 %281, label %282, label %287
282: ; preds = %277
%283 = getelementptr inbounds float, float* %178, i64 %268
%284 = load float, float* %283
%285 = fdiv float %284, %280
%286 = call float @log(float %285)
br label %287
287: ; preds = %277, %282
%288 = phi float [ %286, %282 ], [ -9.900000e+01, %277 ]
store float %288, float* %279
%289 = load float, float* %269
%290 = fadd float %288, %289
%291 = fmul float %290, 5.000000e-01
%292 = getelementptr inbounds float, float* %190, i64 %268
store float %291, float* %292
%293 = add nuw nsw i64 %268, 1
%294 = load i32, i32* %3
%295 = sext i32 %294 to i64
%296 = icmp slt i64 %293, %295
br i1 %296, label %267, label %297
297: ; preds = %287, %264
%298 = load float, float* %30
%299 = fcmp ogt float %298, 0.000000e+00
br i1 %299, label %300, label %306
300: ; preds = %297
%301 = load float, float* %34
%302 = fcmp ogt float %301, 0.000000e+00
br i1 %302, label %303, label %306
303: ; preds = %300
%304 = fdiv float %298, %301
%305 = call float @log(float %304)
br label %306
306: ; preds = %297, %300, %303
%307 = phi float [ %305, %303 ], [ 0xC08F3F3340000000, %300 ], [ 0xC08F3F3340000000, %297 ]
%308 = load float, float* %31
%309 = fcmp ogt float %308, 0.000000e+00
br i1 %309, label %310, label %316
310: ; preds = %306
%311 = load float, float* %35
%312 = fcmp ogt float %311, 0.000000e+00
br i1 %312, label %313, label %316
313: ; preds = %310
%314 = fdiv float %308, %311
%315 = call float @log(float %314)
br label %316
316: ; preds = %306, %310, %313
%317 = phi float [ %315, %313 ], [ 0xC08F3F3340000000, %310 ], [ 0xC08F3F3340000000, %306 ]
%318 = fadd float %307, %317
%319 = fmul float %318, 5.000000e-01
%320 = load float, float* %32
%321 = fcmp ogt float %320, 0.000000e+00
br i1 %321, label %322, label %328
322: ; preds = %316
%323 = load float, float* %36
%324 = fcmp ogt float %323, 0.000000e+00
br i1 %324, label %325, label %328
325: ; preds = %322
%326 = fdiv float %320, %323
%327 = call float @log(float %326)
br label %328
328: ; preds = %316, %322, %325
%329 = phi float [ %327, %325 ], [ 0xC08F3F3340000000, %322 ], [ 0xC08F3F3340000000, %316 ]
%330 = load float, float* %33
%331 = fcmp ogt float %330, 0.000000e+00
br i1 %331, label %332, label %338
332: ; preds = %328
%333 = load float, float* %37
%334 = fcmp ogt float %333, 0.000000e+00
br i1 %334, label %335, label %338
335: ; preds = %332
%336 = fdiv float %330, %333
%337 = call float @log(float %336)
br label %338
338: ; preds = %328, %332, %335
%339 = phi float [ %337, %335 ], [ 0xC08F3F3340000000, %332 ], [ 0xC08F3F3340000000, %328 ]
%340 = fadd float %329, %339
%341 = fmul float %340, 5.000000e-01
br label %342
342: ; preds = %241, %248, %338
%343 = phi float [ %233, %248 ], [ %233, %241 ], [ %307, %338 ]
%344 = phi float [ %234, %248 ], [ %234, %241 ], [ %317, %338 ]
%345 = phi float [ %242, %248 ], [ %242, %241 ], [ %319, %338 ]
%346 = phi float [ %243, %248 ], [ %243, %241 ], [ %329, %338 ]
%347 = phi float [ %244, %248 ], [ %244, %241 ], [ %339, %338 ]
%348 = phi float [ %250, %248 ], [ 0xC08F3F3340000000, %241 ], [ %341, %338 ]
%349 = load i32, i32* %23
%350 = icmp eq i32 %349, 0
br i1 %350, label %382, label %351
351: ; preds = %342
%352 = load i32, i32* @stdout
%353 = call i32 (i32, i8*, ...) @fprintf(i32 %352, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.42, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.43, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.44, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.45, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.47, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.48, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.49, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.50, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.51, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.52, i64 0, i64 0))
%354 = load i32, i32* %3
%355 = icmp sgt i32 %354, 0
br i1 %355, label %356, label %367
356: ; preds = %351, %356
%357 = phi i64 [ %363, %356 ], [ 0, %351 ]
%358 = load i32, i32* @stdout
%359 = getelementptr inbounds float, float* %170, i64 %357
%360 = load float, float* %359
%361 = fpext float %360 to double
%362 = call i32 (i32, i8*, ...) @fprintf(i32 %358, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %361)
%363 = add nuw nsw i64 %357, 1
%364 = load i32, i32* %3
%365 = sext i32 %364 to i64
%366 = icmp slt i64 %363, %365
br i1 %366, label %356, label %367
367: ; preds = %356, %351
%368 = load float, float* %30
%369 = fcmp ult float %368, 0.000000e+00
br i1 %369, label %373, label %370
370: ; preds = %367
%371 = load i32, i32* @stdout
%372 = call i32 (i32, i8*, ...) @fprintf(i32 %371, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0))
br label %373
373: ; preds = %370, %367
%374 = load float, float* %32
%375 = fcmp ult float %374, 0.000000e+00
br i1 %375, label %379, label %376
376: ; preds = %373
%377 = load i32, i32* @stdout
%378 = call i32 (i32, i8*, ...) @fprintf(i32 %377, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.56, i64 0, i64 0))
br label %379
379: ; preds = %376, %373
%380 = load i32, i32* @stdout
%381 = call i32 (i32, i8*, ...) @fprintf(i32 %380, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.57, i64 0, i64 0))
br label %382
382: ; preds = %379, %342
%383 = load i32, i32* @stdout
%384 = call i32 (i32, i8*, ...) @fprintf(i32 %383, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.58, i64 0, i64 0), i8* %41)
%385 = load i32, i32* @stdout
%386 = call i32 (i32, i8*, ...) @fprintf(i32 %385, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0), i8* %63)
%387 = load i32, i32* %3
%388 = icmp sgt i32 %387, 0
br i1 %388, label %389, label %400
389: ; preds = %382, %389
%390 = phi i64 [ %396, %389 ], [ 0, %382 ]
%391 = load i32, i32* @stdout
%392 = getelementptr inbounds float, float* %182, i64 %390
%393 = load float, float* %392
%394 = fpext float %393 to double
%395 = call i32 (i32, i8*, ...) @fprintf(i32 %391, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %394)
%396 = add nuw nsw i64 %390, 1
%397 = load i32, i32* %3
%398 = sext i32 %397 to i64
%399 = icmp slt i64 %396, %398
br i1 %399, label %389, label %400
400: ; preds = %389, %382
%401 = load float, float* %30
%402 = fcmp ult float %401, 0.000000e+00
br i1 %402, label %407, label %403
403: ; preds = %400
%404 = load i32, i32* @stdout
%405 = fpext float %343 to double
%406 = call i32 (i32, i8*, ...) @fprintf(i32 %404, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %405)
br label %407
407: ; preds = %403, %400
%408 = load float, float* %32
%409 = fcmp ult float %408, 0.000000e+00
br i1 %409, label %414, label %410
410: ; preds = %407
%411 = load i32, i32* @stdout
%412 = fpext float %346 to double
%413 = call i32 (i32, i8*, ...) @fprintf(i32 %411, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %412)
br label %414
414: ; preds = %410, %407
%415 = load i32, i32* @stdout
%416 = call i32 (i32, i8*, ...) @fprintf(i32 %415, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.57, i64 0, i64 0))
%417 = load i32, i32* @stdout
%418 = call i32 (i32, i8*, ...) @fprintf(i32 %417, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.58, i64 0, i64 0), i8* %41)
%419 = load i32, i32* @stdout
%420 = call i32 (i32, i8*, ...) @fprintf(i32 %419, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0), i8* %64)
%421 = load i32, i32* %3
%422 = icmp sgt i32 %421, 0
br i1 %422, label %423, label %434
423: ; preds = %414, %423
%424 = phi i64 [ %430, %423 ], [ 0, %414 ]
%425 = load i32, i32* @stdout
%426 = getelementptr inbounds float, float* %186, i64 %424
%427 = load float, float* %426
%428 = fpext float %427 to double
%429 = call i32 (i32, i8*, ...) @fprintf(i32 %425, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %428)
%430 = add nuw nsw i64 %424, 1
%431 = load i32, i32* %3
%432 = sext i32 %431 to i64
%433 = icmp slt i64 %430, %432
br i1 %433, label %423, label %434
434: ; preds = %423, %414
%435 = load float, float* %31
%436 = fcmp ult float %435, 0.000000e+00
br i1 %436, label %441, label %437
437: ; preds = %434
%438 = load i32, i32* @stdout
%439 = fpext float %344 to double
%440 = call i32 (i32, i8*, ...) @fprintf(i32 %438, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %439)
br label %441
441: ; preds = %437, %434
%442 = load float, float* %33
%443 = fcmp ult float %442, 0.000000e+00
br i1 %443, label %448, label %444
444: ; preds = %441
%445 = load i32, i32* @stdout
%446 = fpext float %347 to double
%447 = call i32 (i32, i8*, ...) @fprintf(i32 %445, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %446)
br label %448
448: ; preds = %444, %441
%449 = load i32, i32* @stdout
%450 = call i32 (i32, i8*, ...) @fprintf(i32 %449, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.57, i64 0, i64 0))
%451 = load i32, i32* @stdout
%452 = call i32 (i32, i8*, ...) @fprintf(i32 %451, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.58, i64 0, i64 0), i8* %41)
%453 = load i32, i32* @stdout
%454 = call i32 (i32, i8*, ...) @fprintf(i32 %453, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.59, i64 0, i64 0))
%455 = load i32, i32* %3
%456 = icmp sgt i32 %455, 0
br i1 %456, label %457, label %468
457: ; preds = %448, %457
%458 = phi i64 [ %464, %457 ], [ 0, %448 ]
%459 = load i32, i32* @stdout
%460 = getelementptr inbounds float, float* %190, i64 %458
%461 = load float, float* %460
%462 = fpext float %461 to double
%463 = call i32 (i32, i8*, ...) @fprintf(i32 %459, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %462)
%464 = add nuw nsw i64 %458, 1
%465 = load i32, i32* %3
%466 = sext i32 %465 to i64
%467 = icmp slt i64 %464, %466
br i1 %467, label %457, label %468
468: ; preds = %457, %448
%469 = load float, float* %30
%470 = fcmp ult float %469, 0.000000e+00
%471 = load float, float* %31
%472 = fcmp ult float %471, 0.000000e+00
%473 = select i1 %470, i1 true, i1 %472
br i1 %473, label %478, label %474
474: ; preds = %468
%475 = load i32, i32* @stdout
%476 = fpext float %345 to double
%477 = call i32 (i32, i8*, ...) @fprintf(i32 %475, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %476)
br label %478
478: ; preds = %474, %468
%479 = load float, float* %32
%480 = fcmp ult float %479, 0.000000e+00
%481 = load float, float* %33
%482 = fcmp ult float %481, 0.000000e+00
%483 = select i1 %480, i1 true, i1 %482
br i1 %483, label %488, label %484
484: ; preds = %478
%485 = load i32, i32* @stdout
%486 = fpext float %348 to double
%487 = call i32 (i32, i8*, ...) @fprintf(i32 %485, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.53, i64 0, i64 0), double %486)
br label %488
488: ; preds = %484, %478
%489 = load i32, i32* @stdout
%490 = call i32 (i32, i8*, ...) @fprintf(i32 %489, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.57, i64 0, i64 0))
ret i32 0
}