#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_3comp(char *, float *, 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, *sa3, *res1, *res2, *res3, 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], comp3[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("comp3", "s", comp3);
  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));
  sa3 = (float *)check_malloc(np * sizeof(float));
  res1 = (float *)check_malloc(np * sizeof(float));
  res2 = (float *)check_malloc(np * sizeof(float));
  res3 = (float *)check_malloc(np * sizeof(float));
  if (bbp_format == 1)
    read_bbpfile_3comp(datafile1, per, sa1, sa2, sa3, 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];
      res3[i] = sa3[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_3comp(simfile1, per, res1, res2, res3, 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;
      if (res3[i] != 0.0)
        res3[i] = log(sa3[i] / res3[i]);
      else
        res3[i] = -99;
    }
    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", comp3);
  for (i = 0; i < np; i++)
    fprintf(stdout, "\t%.5e", res3[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    $0xde8,%rsp
movl   $0x0,-0x2c(%rbp)
mov    %edi,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
movl   $0x1,-0x804(%rbp)
movl   $0x7,-0x808(%rbp)
movl   $0x0,-0x80c(%rbp)
movl   $0x0,-0x810(%rbp)
movss  0x1da8(%rip),%xmm0
movss  %xmm0,-0xd94(%rbp)
ff
movss  0x1d98(%rip),%xmm0
movss  %xmm0,-0xd98(%rbp)
ff
movss  0x1d88(%rip),%xmm0
movss  %xmm0,-0xd9c(%rbp)
ff
movss  0x1d78(%rip),%xmm0
movss  %xmm0,-0xda0(%rbp)
ff
movss  0x1d68(%rip),%xmm0
movss  %xmm0,-0xda4(%rbp)
ff
movss  0x1d58(%rip),%xmm0
movss  %xmm0,-0xda8(%rbp)
ff
movss  0x1d48(%rip),%xmm0
movss  %xmm0,-0xdac(%rbp)
ff
movss  0x1d38(%rip),%xmm0
movss  %xmm0,-0xdb0(%rbp)
ff
movb   $0x0,-0x910(%rbp)
movb   $0x0,-0xa10(%rbp)
movb   $0x0,-0xb10(%rbp)
movb   $0x0,-0xc10(%rbp)
lea    -0x750(%rbp),%rdi
lea    0x1d1e(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x760(%rbp),%rdi
lea    0x1d09(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x770(%rbp),%rdi
lea    0x1cf4(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x780(%rbp),%rdi
lea    0x1cdf(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x790(%rbp),%rdi
lea    0x1cca(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x7a0(%rbp),%rdi
lea    0x1cb5(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x7b0(%rbp),%rdi
lea    0x1ca0(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x7c0(%rbp),%rdi
lea    0x1c8b(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x7d0(%rbp),%rdi
lea    0x1c76(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x7e0(%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    -0x910(%rbp),%rdx
lea    0x1c45(%rip),%rdi
lea    0x1d3f(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0xa10(%rbp),%rdx
lea    0x1c33(%rip),%rdi
lea    0x1d23(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0xb10(%rbp),%rdx
lea    0x1c21(%rip),%rdi
lea    0x1d07(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0xc10(%rbp),%rdx
lea    0x1c0e(%rip),%rdi
lea    0x1ceb(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0xc90(%rbp),%rdx
lea    0x1bfb(%rip),%rdi
lea    0x1ccf(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0xd10(%rbp),%rdx
lea    0x1be5(%rip),%rdi
lea    0x1cb3(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0xd90(%rbp),%rdx
lea    0x1bcf(%rip),%rdi
lea    0x1c97(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x750(%rbp),%rdx
lea    0x1bb9(%rip),%rdi
lea    0x1c7b(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x760(%rbp),%rdx
lea    0x1ba4(%rip),%rdi
lea    0x1c5f(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x770(%rbp),%rdx
lea    0x1b8c(%rip),%rdi
lea    0x1c43(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x780(%rbp),%rdx
lea    0x1b75(%rip),%rdi
lea    0x1c27(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x790(%rbp),%rdx
lea    0x1b5d(%rip),%rdi
lea    0x1c0b(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x7a0(%rbp),%rdx
lea    0x1b45(%rip),%rdi
lea    0x1bef(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x7b0(%rbp),%rdx
lea    0x1b2f(%rip),%rdi
lea    0x1bd3(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x7c0(%rbp),%rdx
lea    0x1b18(%rip),%rdi
lea    0x1bb7(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x7d0(%rbp),%rdx
lea    0x1aff(%rip),%rdi
lea    0x1b9b(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x7e0(%rbp),%rdx
lea    0x1ae8(%rip),%rdi
lea    0x1b7f(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1ad8(%rip),%rdi
lea    0x1b33(%rip),%rsi
lea    -0xc8(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1ac0(%rip),%rdi
lea    0x1b17(%rip),%rsi
lea    -0xcc(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1aa8(%rip),%rdi
lea    0x1b09(%rip),%rsi
lea    -0x810(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1a9d(%rip),%rdi
lea    0x1adf(%rip),%rsi
lea    -0xd94(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1a8a(%rip),%rdi
lea    0x1ac3(%rip),%rsi
lea    -0xd98(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1a77(%rip),%rdi
lea    0x1aa7(%rip),%rsi
lea    -0xd9c(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1a64(%rip),%rdi
lea    0x1a8b(%rip),%rsi
lea    -0xda0(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1a29(%rip),%rdi
lea    0x1a6f(%rip),%rsi
lea    -0xda4(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1a16(%rip),%rdi
lea    0x1a53(%rip),%rsi
lea    -0xda8(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1a03(%rip),%rdi
lea    0x1a37(%rip),%rsi
lea    -0xdac(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x19f0(%rip),%rdi
lea    0x1a1b(%rip),%rsi
lea    -0xdb0(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x19dd(%rip),%rdi
lea    0x1a0d(%rip),%rsi
lea    -0x80c(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
cmpl   $0x1,-0x80c(%rbp)
jne    170d <main+0x51d>
movl   $0x0,-0x804(%rbp)
lea    0x19b5(%rip),%rdi
lea    0x19da(%rip),%rsi
lea    -0x804(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
cmpl   $0x0,-0x804(%rbp)
jne    175f <main+0x56f>
cmpl   $0x0,-0x80c(%rbp)
jne    175f <main+0x56f>
lea    0x198e(%rip),%rdi
lea    0x19a4(%rip),%rsi
lea    -0xc4(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1975(%rip),%rdi
lea    0x1988(%rip),%rsi
lea    -0x808(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
mov    $0x0,%al
call   10c0 <endpar@plt>
movss  -0xcc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    17cd <main+0x5dd>
lea    -0x7f0(%rbp),%rdi
movss  -0xcc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1852(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x1923(%rip),%rsi
mov    $0x1,%al
call   1100 <sprintf@plt>
jmp    17e2 <main+0x5f2>
lea    -0x7f0(%rbp),%rdi
lea    0x190e(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
movss  -0xc8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    182d <main+0x63d>
lea    -0x800(%rbp),%rdi
movss  -0xc8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x17f2(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x18c3(%rip),%rsi
mov    $0x1,%al
call   1100 <sprintf@plt>
jmp    1842 <main+0x652>
lea    -0x800(%rbp),%rdi
lea    0x18af(%rip),%rsi
mov    $0x0,%al
call   1100 <sprintf@plt>
lea    -0x2d0(%rbp),%rdi
lea    -0x750(%rbp),%rdx
lea    -0x760(%rbp),%rcx
lea    -0x770(%rbp),%r8
lea    -0x780(%rbp),%r9
lea    -0x790(%rbp),%r13
lea    -0x7a0(%rbp),%r12
lea    -0x7b0(%rbp),%r15
lea    -0x7c0(%rbp),%r14
lea    -0x7d0(%rbp),%rbx
lea    -0x7e0(%rbp),%r11
lea    -0x7f0(%rbp),%r10
lea    -0x800(%rbp),%rax
lea    0x1858(%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,-0x804(%rbp)
je     1974 <main+0x784>
lea    -0x910(%rbp),%rdi
lea    0x17ab(%rip),%rsi
mov    $0x0,%al
call   1110 <fopfile@plt>
mov    %rax,-0x40(%rbp)
lea    -0x6d0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1070 <fgets@plt>
lea    -0x6d0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1070 <fgets@plt>
lea    -0x6d0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1070 <fgets@plt>
lea    -0x6d0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1070 <fgets@plt>
lea    -0x6d0(%rbp),%rdi
lea    0x179a(%rip),%rsi
lea    -0xc4(%rbp),%rdx
call   10a0 <sscanf@plt>
mov    -0x40(%rbp),%rdi
call   1050 <fclose@plt>
jmp    1a36 <main+0x846>
cmpl   $0x1,-0x80c(%rbp)
jne    1a31 <main+0x841>
lea    -0x910(%rbp),%rdi
lea    0x1709(%rip),%rsi
mov    $0x0,%al
call   1110 <fopfile@plt>
mov    %rax,-0x40(%rbp)
lea    -0x6d0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1070 <fgets@plt>
lea    -0x6d0(%rbp),%rdi
lea    0x173a(%rip),%rsi
mov    $0x1,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    19eb <main+0x7fb>
lea    -0x6d0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1070 <fgets@plt>
jmp    19af <main+0x7bf>
movl   $0x1,-0xc4(%rbp)
lea    -0x6d0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x400,%esi
call   1070 <fgets@plt>
cmp    $0x0,%rax
je     1a28 <main+0x838>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    19f5 <main+0x805>
mov    -0x40(%rbp),%rdi
call   1050 <fclose@plt>
jmp    1a36 <main+0x846>
movslq -0xc4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0xc4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0xc4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0xc4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0xc4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0xc4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0xc4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x78(%rbp)
cmpl   $0x1,-0x80c(%rbp)
jne    1b05 <main+0x915>
lea    -0x910(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0xc4(%rbp),%r9d
call   10d0 <read_bbpfile_3comp@plt>
jmp    1b55 <main+0x965>
lea    -0x910(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0xc4(%rbp),%ecx
mov    -0x808(%rbp),%r8d
mov    -0x804(%rbp),%r9d
call   1060 <read_specfile@plt>
lea    -0xa10(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0xc4(%rbp),%ecx
mov    -0x808(%rbp),%r8d
mov    -0x804(%rbp),%r9d
call   1060 <read_specfile@plt>
movsbl -0xb10(%rbp),%eax
cmp    $0x0,%eax
je     1b82 <main+0x992>
cmpl   $0x0,-0x80c(%rbp)
jne    1d15 <main+0xb25>
movsbl -0xc10(%rbp),%eax
cmp    $0x0,%eax
jne    1d15 <main+0xb25>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    1c12 <main+0xa22>
mov    -0x50(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1b8c <main+0x99c>
movss  -0xd94(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xd98(%rbp),%xmm0
ff
movss  %xmm0,-0xa8(%rbp)
ff
movss  0x13c6(%rip),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1c91 <main+0xaa1>
movss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1c91 <main+0xaa1>
movss  -0xa4(%rbp),%xmm0
ff
mulss  -0xa8(%rbp),%xmm0
ff
call   10f0 <sqrt@plt>
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xd9c(%rbp),%xmm0
ff
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xda0(%rbp),%xmm0
ff
movss  %xmm0,-0xb4(%rbp)
ff
movss  0x1347(%rip),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1d10 <main+0xb20>
movss  -0xb4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1d10 <main+0xb20>
movss  -0xb0(%rbp),%xmm0
ff
mulss  -0xb4(%rbp),%xmm0
ff
call   10f0 <sqrt@plt>
movss  %xmm0,-0xb8(%rbp)
ff
jmp    2131 <main+0xf41>
cmpl   $0x1,-0x80c(%rbp)
jne    1d4a <main+0xb5a>
lea    -0xb10(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
mov    -0x78(%rbp),%r8
mov    -0xc4(%rbp),%r9d
call   10d0 <read_bbpfile_3comp@plt>
jmp    1d9a <main+0xbaa>
lea    -0xb10(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x68(%rbp),%rdx
mov    -0xc4(%rbp),%ecx
mov    -0x808(%rbp),%r8d
mov    -0x804(%rbp),%r9d
call   1060 <read_specfile@plt>
lea    -0xc10(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x70(%rbp),%rdx
mov    -0xc4(%rbp),%ecx
mov    -0x808(%rbp),%r8d
mov    -0x804(%rbp),%r9d
call   1060 <read_specfile@plt>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    1f49 <main+0xd59>
mov    -0x68(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1de2 <main+0xbf2>
jp     1de2 <main+0xbf2>
jmp    1e1c <main+0xc2c>
mov    -0x50(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0xbc(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
call   10e0 <log@plt>
mov    -0x68(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1e34 <main+0xc44>
mov    -0x68(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  0x11d5(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1e60 <main+0xc70>
jp     1e60 <main+0xc70>
jmp    1e9a <main+0xcaa>
mov    -0x58(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
call   10e0 <log@plt>
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1eb2 <main+0xcc2>
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  0x1157(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ede <main+0xcee>
jp     1ede <main+0xcee>
jmp    1f18 <main+0xd28>
mov    -0x60(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
call   10e0 <log@plt>
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1f30 <main+0xd40>
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  0x10d9(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1f35 <main+0xd45>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1da4 <main+0xbb4>
movss  -0xd94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f9d <main+0xdad>
movss  -0xda4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1f9d <main+0xdad>
movss  -0xd94(%rbp),%xmm0
ff
divss  -0xda4(%rbp),%xmm0
ff
call   10e0 <log@plt>
movss  %xmm0,-0xa4(%rbp)
ff
jmp    1fad <main+0xdbd>
movss  0x105b(%rip),%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xd98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2001 <main+0xe11>
movss  -0xda8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2001 <main+0xe11>
movss  -0xd98(%rbp),%xmm0
ff
divss  -0xda8(%rbp),%xmm0
ff
call   10e0 <log@plt>
movss  %xmm0,-0xa8(%rbp)
ff
jmp    2011 <main+0xe21>
movss  0xff7(%rip),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
addss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xfe3(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xd9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2091 <main+0xea1>
movss  -0xdac(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2091 <main+0xea1>
movss  -0xd9c(%rbp),%xmm0
ff
divss  -0xdac(%rbp),%xmm0
ff
call   10e0 <log@plt>
movss  %xmm0,-0xb0(%rbp)
ff
jmp    20a1 <main+0xeb1>
movss  0xf67(%rip),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0xda0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    20f5 <main+0xf05>
movss  -0xdb0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    20f5 <main+0xf05>
movss  -0xda0(%rbp),%xmm0
ff
divss  -0xdb0(%rbp),%xmm0
ff
call   10e0 <log@plt>
movss  %xmm0,-0xb4(%rbp)
ff
jmp    2105 <main+0xf15>
movss  0xf03(%rip),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
addss  -0xb4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xeef(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
cmpl   $0x0,-0x810(%rbp)
je     22d8 <main+0x10e8>
mov    0x2e9b(%rip),%rax
mov    (%rax),%edi
lea    0xfab(%rip),%rsi
lea    0xfcb(%rip),%rdx
lea    0xfc7(%rip),%rcx
lea    0xefd(%rip),%r8
lea    0xefb(%rip),%r9
lea    0xef8(%rip),%rax
mov    %rax,-0xdc0(%rbp)
lea    0xfa8(%rip),%r13
lea    0xfad(%rip),%r12
lea    0xfab(%rip),%r15
lea    0xfaf(%rip),%r14
lea    0xfad(%rip),%rbx
lea    0xfab(%rip),%r11
lea    0xfaa(%rip),%r10
lea    0xfa9(%rip),%rax
mov    %rax,-0xdb8(%rbp)
mov    -0xdc0(%rbp),%rax
mov    %rax,(%rsp)
mov    -0xdb8(%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   1080 <fprintf@plt>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    2253 <main+0x1063>
mov    0x2dc5(%rip),%rax
mov    (%rax),%edi
mov    -0x48(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xf26(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    2202 <main+0x1012>
movss  -0xd94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     228a <main+0x109a>
mov    0x2d6d(%rip),%rax
mov    (%rax),%edi
lea    0xea0(%rip),%rsi
lea    0xee1(%rip),%rdx
mov    $0x0,%al
call   1080 <fprintf@plt>
movss  -0xd9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     22c1 <main+0x10d1>
mov    0x2d36(%rip),%rax
mov    (%rax),%edi
lea    0xe69(%rip),%rsi
lea    0xeae(%rip),%rdx
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2d18(%rip),%rax
mov    (%rax),%edi
lea    0xe9b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2d01(%rip),%rax
mov    (%rax),%edi
lea    -0x2d0(%rbp),%rdx
lea    0xe2e(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2ce3(%rip),%rax
mov    (%rax),%edi
lea    -0xc90(%rbp),%rdx
lea    0xe0f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    236f <main+0x117f>
mov    0x2ca9(%rip),%rax
mov    (%rax),%edi
mov    -0x68(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe0a(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    231e <main+0x112e>
movss  -0xd94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     23ab <main+0x11bb>
mov    0x2c51(%rip),%rax
mov    (%rax),%edi
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xdba(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
movss  -0xd9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     23e7 <main+0x11f7>
mov    0x2c15(%rip),%rax
mov    (%rax),%edi
movss  -0xb0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xd7e(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    0x2bf2(%rip),%rax
mov    (%rax),%edi
lea    0xd75(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2bdb(%rip),%rax
mov    (%rax),%edi
lea    -0x2d0(%rbp),%rdx
lea    0xd08(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2bbd(%rip),%rax
mov    (%rax),%edi
lea    -0xd10(%rbp),%rdx
lea    0xce9(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    2495 <main+0x12a5>
mov    0x2b83(%rip),%rax
mov    (%rax),%edi
mov    -0x70(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xce4(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    2444 <main+0x1254>
movss  -0xd98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     24d1 <main+0x12e1>
mov    0x2b2b(%rip),%rax
mov    (%rax),%edi
movss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xc94(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
movss  -0xda0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     250d <main+0x131d>
mov    0x2aef(%rip),%rax
mov    (%rax),%edi
movss  -0xb4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xc58(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    0x2acc(%rip),%rax
mov    (%rax),%edi
lea    0xc4f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2ab5(%rip),%rax
mov    (%rax),%edi
lea    -0x2d0(%rbp),%rdx
lea    0xbe2(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2a97(%rip),%rax
mov    (%rax),%edi
lea    -0xd90(%rbp),%rdx
lea    0xbc3(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
cmp    -0xc4(%rbp),%eax
jge    25bb <main+0x13cb>
mov    0x2a5d(%rip),%rax
mov    (%rax),%edi
mov    -0x78(%rbp),%rax
movslq -0xbc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xbbe(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    256a <main+0x137a>
movss  -0xd94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2610 <main+0x1420>
movss  -0xd98(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2610 <main+0x1420>
mov    0x29ec(%rip),%rax
mov    (%rax),%edi
movss  -0xac(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xb55(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
movss  -0xd9c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2665 <main+0x1475>
movss  -0xda0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2665 <main+0x1475>
mov    0x2997(%rip),%rax
mov    (%rax),%edi
movss  -0xb8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xb00(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    0x2974(%rip),%rax
mov    (%rax),%edi
lea    0xaf7(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
xor    %eax,%eax
add    $0xde8,%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    $0xd38,%rsp
movl   $0x0,0x64(%rsp)
movl   $0x0,0x60(%rsp)
movl   $0x1,0xc(%rsp)
movl   $0x7,0x30(%rsp)
movl   $0x0,0x1c(%rsp)
movl   $0x0,0x5c(%rsp)
movl   $0xc479f99a,0x18(%rsp)
c4
movl   $0xc479f99a,0x2c(%rsp)
c4
movl   $0xc479f99a,0x14(%rsp)
c4
movl   $0xc479f99a,0x28(%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,0x630(%rsp)
movb   $0x0,0x2b0(%rsp)
movb   $0x0,0x530(%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    0x1dc2(%rip),%r15
lea    0x1b0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1cb2(%rip),%rdi
lea    0x630(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1ca3(%rip),%rdi
lea    0x2b0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c93(%rip),%rdi
lea    0x530(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c83(%rip),%rdi
lea    0x4b0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c70(%rip),%rdi
lea    0x430(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c5d(%rip),%rdi
lea    0x3b0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c4a(%rip),%rdi
lea    0x130(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c38(%rip),%rdi
lea    0xe0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c23(%rip),%rdi
lea    0xd0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c0f(%rip),%rdi
lea    0xc0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1bfa(%rip),%rdi
lea    0x80(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1be5(%rip),%rdi
lea    0x70(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1bd5(%rip),%rdi
lea    0xb0(%rsp),%rdx
mov    %r15,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1bc1(%rip),%rdi
lea    0x120(%rsp),%r13
mov    %r15,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1ba8(%rip),%rdi
lea    0x110(%rsp),%r12
mov    %r15,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1b91(%rip),%rdi
lea    0x100(%rsp),%r14
mov    %r15,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1b7a(%rip),%rdi
lea    0x1bd5(%rip),%rbx
lea    0x64(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1b61(%rip),%rdi
lea    0x60(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1b4f(%rip),%rdi
lea    0x1bb0(%rip),%rbp
lea    0x5c(%rsp),%rdx
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1b43(%rip),%rdi
lea    0x18(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1b36(%rip),%rdi
lea    0x2c(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1b29(%rip),%rdi
lea    0x14(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1b1c(%rip),%rdi
lea    0x28(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1ae7(%rip),%rdi
lea    0x58(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1ada(%rip),%rdi
lea    0x54(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1acd(%rip),%rdi
lea    0x50(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1ac0(%rip),%rdi
lea    0x4c(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1ab3(%rip),%rdi
lea    0x1c(%rsp),%rdx
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
cmpl   $0x1,0x1c(%rsp)
jne    1629 <main+0x439>
movl   $0x0,0xc(%rsp)
lea    0x1a99(%rip),%rdi
lea    0x1abe(%rip),%rsi
lea    0xc(%rsp),%rdx
xor    %eax,%eax
call   10b0 <getpar@plt>
mov    0xc(%rsp),%eax
or     0x1c(%rsp),%eax
jne    1667 <main+0x477>
lea    0x1a84(%rip),%rdi
lea    0x1a9a(%rip),%rsi
lea    0x8(%rsp),%rdx
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1a6d(%rip),%rdi
lea    0x1a80(%rip),%rsi
lea    0x30(%rsp),%rdx
xor    %eax,%eax
call   10b0 <getpar@plt>
xor    %eax,%eax
call   10c0 <endpar@plt>
movss  0x60(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    16c1 <main+0x4d1>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0x195b(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x1a34(%rip),%rsi
lea    0xa0(%rsp),%rdi
mov    $0x1,%al
call   1100 <sprintf@plt>
jmp    16de <main+0x4ee>
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    1717 <main+0x527>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0x1905(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x19de(%rip),%rsi
lea    0x90(%rsp),%rdi
mov    $0x1,%al
call   1100 <sprintf@plt>
jmp    1733 <main+0x543>
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    0x19a5(%rip),%rsi
lea    0x730(%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   %r12
push   %r13
lea    0xd8(%rsp),%rbx
push   %rbx
push   %rbp
push   %r15
call   1100 <sprintf@plt>
add    $0x40,%rsp
cmpl   $0x0,0xc(%rsp)
je     194e <main+0x75e>
lea    0x18e3(%rip),%rsi
lea    0x1b0(%rsp),%rdi
xor    %eax,%eax
call   1110 <fopfile@plt>
mov    %rax,%rbx
lea    0x930(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rax,%rdx
call   1070 <fgets@plt>
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1070 <fgets@plt>
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1070 <fgets@plt>
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1070 <fgets@plt>
lea    0x18de(%rip),%rsi
lea    0x8(%rsp),%rdx
mov    %rbp,%rdi
call   10a0 <sscanf@plt>
mov    %rbx,%rdi
call   1050 <fclose@plt>
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,%rbx
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,%rbp
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,%r14
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,%r13
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,%r12
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,0x38(%rsp)
mov    0x8(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,%r15
cmpl   $0x1,0x1c(%rsp)
mov    0x8(%rsp),%eax
mov    %rbx,0x68(%rsp)
jne    18ce <main+0x6de>
lea    0x1b0(%rsp),%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %r14,%rcx
mov    %r13,%r8
mov    %eax,%r9d
call   10d0 <read_bbpfile_3comp@plt>
cmpb   $0x0,0x2b0(%rsp)
jne    1918 <main+0x728>
jmp    1932 <main+0x742>
mov    0x30(%rsp),%r8d
mov    0xc(%rsp),%r9d
lea    0x1b0(%rsp),%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    %eax,%ecx
call   1060 <read_specfile@plt>
mov    0x8(%rsp),%ecx
mov    0x30(%rsp),%r8d
mov    0xc(%rsp),%r9d
lea    0x630(%rsp),%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
call   1060 <read_specfile@plt>
cmpb   $0x0,0x2b0(%rsp)
je     1932 <main+0x742>
mov    0x1c(%rsp),%ecx
test   %ecx,%ecx
jne    1a3f <main+0x84f>
cmpb   $0x0,0x530(%rsp)
jne    1a3f <main+0x84f>
mov    0x8(%rsp),%eax
test   %eax,%eax
jle    1b12 <main+0x922>
cmp    $0x1,%eax
jne    1a7f <main+0x88f>
xor    %ecx,%ecx
jmp    1ae5 <main+0x8f5>
cmpl   $0x1,0x1c(%rsp)
jne    182b <main+0x63b>
lea    0x1738(%rip),%rsi
lea    0x1b0(%rsp),%rdi
xor    %eax,%eax
call   1110 <fopfile@plt>
mov    %rax,%rbx
lea    0x930(%rsp),%rbp
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rax,%rdx
call   1070 <fgets@plt>
lea    0x1766(%rip),%rsi
mov    %rbp,%rdi
mov    $0x1,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
jne    19e5 <main+0x7f5>
lea    0x930(%rsp),%rbp
lea    0x1745(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1070 <fgets@plt>
mov    %rbp,%rdi
mov    %r14,%rsi
mov    $0x1,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
je     19c0 <main+0x7d0>
movl   $0x1,0x8(%rsp)
lea    0x930(%rsp),%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1070 <fgets@plt>
test   %rax,%rax
je     1823 <main+0x633>
lea    0x930(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addl   $0x1,0x8(%rsp)
mov    %rbp,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1070 <fgets@plt>
test   %rax,%rax
jne    1a20 <main+0x830>
jmp    1823 <main+0x633>
mov    0x8(%rsp),%eax
cmp    $0x1,%ecx
jne    1bd0 <main+0x9e0>
lea    0x2b0(%rsp),%rdi
mov    0x68(%rsp),%rsi
mov    %r12,%rdx
mov    0x38(%rsp),%rcx
mov    %r15,%rbx
mov    %r15,%r8
mov    %eax,%r9d
call   10d0 <read_bbpfile_3comp@plt>
cmpl   $0x0,0x8(%rsp)
jg     1c25 <main+0xa35>
jmp    1ce1 <main+0xaf1>
mov    %eax,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
mov    0x38(%rsp),%rsi
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%r12,%rcx,4)
movss  (%r14,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rcx,4)
movss  0x0(%r13,%rcx,4),%xmm0
movss  %xmm0,(%r15,%rcx,4)
movss  0x4(%rbp,%rcx,4),%xmm0
movss  %xmm0,0x4(%r12,%rcx,4)
movss  0x4(%r14,%rcx,4),%xmm0
movss  %xmm0,0x4(%rsi,%rcx,4)
movss  0x4(%r13,%rcx,4),%xmm0
movss  %xmm0,0x4(%r15,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1a90 <main+0x8a0>
test   $0x1,%al
je     1b12 <main+0x922>
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%r12,%rcx,4)
movss  (%r14,%rcx,4),%xmm0
mov    0x38(%rsp),%rax
movss  %xmm0,(%rax,%rcx,4)
movss  0x0(%r13,%rcx,4),%xmm0
movss  %xmm0,(%r15,%rcx,4)
movss  0x18(%rsp),%xmm0
movss  0x2c(%rsp),%xmm5
xorps  %xmm6,%xmm6
movss  %xmm0,0x10(%rsp)
ucomiss %xmm6,%xmm0
movss  0x14da(%rip),%xmm3
movaps %xmm3,%xmm2
movss  %xmm5,0x44(%rsp)
jb     1b73 <main+0x983>
ucomiss %xmm6,%xmm5
movaps %xmm3,%xmm2
jb     1b73 <main+0x983>
movss  0x10(%rsp),%xmm0
mulss  %xmm5,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1b60 <main+0x970>
xorps  %xmm2,%xmm2
sqrtss %xmm0,%xmm2
jmp    1b73 <main+0x983>
call   10f0 <sqrt@plt>
xorps  %xmm6,%xmm6
movss  0x149c(%rip),%xmm3
movaps %xmm0,%xmm2
movss  0x14(%rsp),%xmm0
movss  0x28(%rsp),%xmm4
ucomiss %xmm6,%xmm0
movss  %xmm2,0x34(%rsp)
movss  %xmm4,0x48(%rsp)
movss  %xmm0,0x24(%rsp)
jb     1bb0 <main+0x9c0>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm4
jb     1bb0 <main+0x9c0>
mulss  %xmm4,%xmm0
ucomiss %xmm1,%xmm0
jb     1bc6 <main+0x9d6>
sqrtss %xmm0,%xmm0
jmp    1e0a <main+0xc1a>
movss  %xmm3,0x20(%rsp)
cmpl   $0x0,0x5c(%rsp)
jne    1e1b <main+0xc2b>
jmp    1f4a <main+0xd5a>
call   10f0 <sqrt@plt>
jmp    1e0a <main+0xc1a>
mov    %r15,%rbx
mov    0x30(%rsp),%r8d
mov    0xc(%rsp),%r9d
lea    0x2b0(%rsp),%rdi
mov    0x68(%rsp),%r15
mov    %r15,%rsi
mov    %r12,%rdx
mov    %eax,%ecx
call   1060 <read_specfile@plt>
mov    0x8(%rsp),%ecx
mov    0x30(%rsp),%r8d
mov    0xc(%rsp),%r9d
lea    0x530(%rsp),%rdi
mov    %r15,%rsi
mov    0x38(%rsp),%rdx
call   1060 <read_specfile@plt>
cmpl   $0x0,0x8(%rsp)
jle    1ce1 <main+0xaf1>
xor    %r15d,%r15d
jmp    1c48 <main+0xa58>
nopw   0x0(%rax,%rax,1)
movss  %xmm0,(%rbx,%r15,4)
add    $0x1,%r15
movslq 0x8(%rsp),%rax
cmp    %rax,%r15
jge    1ce1 <main+0xaf1>
movss  (%r12,%r15,4),%xmm1
ucomiss 0x13bf(%rip),%xmm1
movss  0x13ab(%rip),%xmm0
jne    1c61 <main+0xa71>
jnp    1c71 <main+0xa81>
movss  0x0(%rbp,%r15,4),%xmm0
divss  %xmm1,%xmm0
call   10e0 <log@plt>
movss  %xmm0,(%r12,%r15,4)
mov    0x38(%rsp),%rax
movss  (%rax,%r15,4),%xmm1
ucomiss 0x138b(%rip),%xmm1
movss  0x1377(%rip),%xmm0
jne    1c95 <main+0xaa5>
jnp    1ca4 <main+0xab4>
movss  (%r14,%r15,4),%xmm0
divss  %xmm1,%xmm0
call   10e0 <log@plt>
mov    0x38(%rsp),%rax
movss  %xmm0,(%rax,%r15,4)
movss  (%rbx,%r15,4),%xmm1
ucomiss 0x1358(%rip),%xmm1
movss  0x1344(%rip),%xmm0
jne    1ccc <main+0xadc>
jnp    1c30 <main+0xa40>
movss  0x0(%r13,%r15,4),%xmm0
divss  %xmm1,%xmm0
call   10e0 <log@plt>
jmp    1c30 <main+0xa40>
movss  0x18(%rsp),%xmm0
movss  0x131d(%rip),%xmm4
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm0
movss  %xmm4,0x10(%rsp)
jbe    1d28 <main+0xb38>
movss  0x58(%rsp),%xmm1
ucomiss %xmm2,%xmm1
movss  %xmm4,0x10(%rsp)
jbe    1d28 <main+0xb38>
divss  %xmm1,%xmm0
call   10e0 <log@plt>
xorps  %xmm2,%xmm2
movss  0x12ea(%rip),%xmm4
movss  %xmm0,0x10(%rsp)
movss  0x2c(%rsp),%xmm0
ucomiss %xmm2,%xmm0
movaps %xmm4,%xmm2
mov    %rbx,%r15
jbe    1d5e <main+0xb6e>
movss  0x54(%rsp),%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
movaps %xmm4,%xmm2
jbe    1d5e <main+0xb6e>
divss  %xmm1,%xmm0
call   10e0 <log@plt>
movss  0x12b1(%rip),%xmm4
movaps %xmm0,%xmm2
movss  0x14(%rsp),%xmm0
xorps  %xmm5,%xmm5
ucomiss %xmm5,%xmm0
movss  %xmm4,0x24(%rsp)
movss  %xmm2,0x44(%rsp)
jbe    1da9 <main+0xbb9>
movss  0x50(%rsp),%xmm1
ucomiss %xmm5,%xmm1
movss  %xmm4,0x24(%rsp)
jbe    1da9 <main+0xbb9>
divss  %xmm1,%xmm0
call   10e0 <log@plt>
xorps  %xmm5,%xmm5
movss  0x44(%rsp),%xmm2
movss  0x1269(%rip),%xmm4
movss  %xmm0,0x24(%rsp)
movss  0x10(%rsp),%xmm3
addss  %xmm2,%xmm3
movss  0x28(%rsp),%xmm0
ucomiss %xmm5,%xmm0
jbe    1de4 <main+0xbf4>
movss  0x4c(%rsp),%xmm1
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm1
jbe    1de4 <main+0xbf4>
divss  %xmm1,%xmm0
movss  %xmm3,0x34(%rsp)
call   10e0 <log@plt>
movss  0x34(%rsp),%xmm3
movaps %xmm0,%xmm4
mulss  0x1224(%rip),%xmm3
movss  %xmm3,0x34(%rsp)
movss  0x24(%rsp),%xmm0
movss  %xmm4,0x48(%rsp)
addss  %xmm4,%xmm0
mulss  0x1206(%rip),%xmm0
movss  %xmm0,0x20(%rsp)
cmpl   $0x0,0x5c(%rsp)
je     1f4a <main+0xd5a>
mov    %r15,0xf8(%rsp)
mov    0x31b6(%rip),%r14
mov    (%r14),%edi
sub    $0x8,%rsp
lea    0x1321(%rip),%rbp
lea    0x1314(%rip),%rbx
lea    0x1307(%rip),%r10
lea    0x12fb(%rip),%r11
lea    0x12ef(%rip),%r15
lea    0x12dd(%rip),%r13
lea    0x1297(%rip),%rsi
lea    0x12b7(%rip),%rdx
lea    0x12b3(%rip),%rcx
lea    0x11e9(%rip),%r8
lea    0x11e7(%rip),%r9
xor    %eax,%eax
push   %rbp
push   %rbx
push   %r10
push   %r11
push   %r15
push   %r13
lea    0x12a2(%rip),%rbp
push   %rbp
lea    0x128e(%rip),%rbp
push   %rbp
lea    0x11c8(%rip),%rbp
push   %rbp
call   1080 <fprintf@plt>
add    $0x50,%rsp
cmpl   $0x0,0x8(%rsp)
mov    0x68(%rsp),%rbp
jle    1ee5 <main+0xcf5>
xor    %ebx,%ebx
lea    0x129e(%rip),%r15
mov    (%r14),%edi
movss  0x0(%rbp,%rbx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
add    $0x1,%rbx
movslq 0x8(%rsp),%rax
cmp    %rax,%rbx
jl     1ec0 <main+0xcd0>
movss  0x18(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1f0e <main+0xd1e>
mov    (%r14),%edi
lea    0x121f(%rip),%rsi
lea    0x1260(%rip),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x14(%rsp),%xmm0
ucomiss %xmm1,%xmm0
mov    0xf8(%rsp),%r15
jb     1f39 <main+0xd49>
mov    (%r14),%edi
lea    0x11f1(%rip),%rsi
lea    0x1236(%rip),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x1229(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    0x308f(%rip),%r14
mov    (%r14),%edi
lea    0x11c2(%rip),%rsi
lea    0x730(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x11a8(%rip),%rsi
lea    0x4b0(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
cmpl   $0x0,0x8(%rsp)
jle    1fc5 <main+0xdd5>
xor    %ebx,%ebx
lea    0x11cb(%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   1080 <fprintf@plt>
add    $0x1,%rbx
movslq 0x8(%rsp),%rax
cmp    %rax,%rbx
jl     1fa0 <main+0xdb0>
movss  0x18(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1ff1 <main+0xe01>
mov    (%r14),%edi
movss  0x10(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x1177(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x14(%rsp),%xmm0
ucomiss %xmm1,%xmm0
mov    0x38(%rsp),%r12
jb     201c <main+0xe2c>
mov    (%r14),%edi
movss  0x24(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x1149(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x1146(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x10e6(%rip),%rsi
lea    0x730(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x10cc(%rip),%rsi
lea    0x430(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
cmpl   $0x0,0x8(%rsp)
jle    2095 <main+0xea5>
xor    %ebp,%ebp
lea    0x10ef(%rip),%rbx
nop
mov    (%r14),%edi
movss  (%r12,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jl     2070 <main+0xe80>
movss  0x2c(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     20c1 <main+0xed1>
mov    (%r14),%edi
movss  0x44(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x10a7(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x28(%rsp),%xmm0
ucomiss %xmm1,%xmm0
jb     20e7 <main+0xef7>
mov    (%r14),%edi
movss  0x48(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x107e(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x107b(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x101b(%rip),%rsi
lea    0x730(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x1001(%rip),%rsi
lea    0x3b0(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
cmpl   $0x0,0x8(%rsp)
jle    2165 <main+0xf75>
xor    %ebp,%ebp
lea    0x1024(%rip),%rbx
nopw   0x0(%rax,%rax,1)
mov    (%r14),%edi
movss  (%r15,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
add    $0x1,%rbp
movslq 0x8(%rsp),%rax
cmp    %rax,%rbp
jl     2140 <main+0xf50>
movss  0x18(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     219c <main+0xfac>
movss  0x2c(%rsp),%xmm0
ucomiss %xmm1,%xmm0
jb     219c <main+0xfac>
mov    (%r14),%edi
movss  0x34(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xfcc(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x14(%rsp),%xmm0
ucomiss %xmm1,%xmm0
jb     21d0 <main+0xfe0>
movss  0x28(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     21d0 <main+0xfe0>
mov    (%r14),%edi
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xf95(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0xf92(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
xor    %eax,%eax
add    $0xd38,%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 = [6 x i8] c"comp3\00"
@.str.9 = [7 x i8] c"eqname\00"
@.str.10 = [4 x i8] c"mag\00"
@.str.11 = [5 x i8] c"stat\00"
@.str.12 = [4 x i8] c"lon\00"
@.str.13 = [4 x i8] c"lat\00"
@.str.14 = [6 x i8] c"seqno\00"
@.str.15 = [5 x i8] c"vs30\00"
@.str.16 = [3 x i8] c"cd\00"
@.str.17 = [5 x i8] c"xcos\00"
@.str.18 = [5 x i8] c"ycos\00"
@.str.19 = [4 x i8] c"flo\00"
@.str.20 = [2 x i8] c"f\00"
@.str.21 = [4 x i8] c"fhi\00"
@.str.22 = [13 x i8] c"print_header\00"
@.str.23 = [2 x i8] c"d\00"
@.str.24 = [5 x i8] c"pga1\00"
@.str.25 = [5 x i8] c"pga2\00"
@.str.26 = [5 x i8] c"pgv1\00"
@.str.27 = [5 x i8] c"pgv2\00"
@.str.28 = [9 x i8] c"sim_pga1\00"
@.str.29 = [9 x i8] c"sim_pga2\00"
@.str.30 = [9 x i8] c"sim_pgv1\00"
@.str.31 = [9 x i8] c"sim_pgv2\00"
@.str.32 = [11 x i8] c"bbp_format\00"
@.str.33 = [15 x i8] c"respect_format\00"
@.str.34 = [3 x i8] c"np\00"
@.str.35 = [9 x i8] c"sa_field\00"
@.str.36 = [5 x i8] c"%.3f\00"
@.str.37 = [11 x i8] c"-99999.999\00"
@.str.38 = [10 x i8] c"99999.999\00"
@.str.39 = [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.40 = [2 x i8] c"r\00"
@.str.41 = [3 x i8] c"%d\00"
@.str.42 = [2 x i8] c"#\00"
@stdout = global i32 0
@.str.43 = [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.44 = [3 x i8] c"EQ\00"
@.str.45 = [4 x i8] c"Mag\00"
@.str.46 = [12 x i8] c"stat_seq_no\00"
@.str.47 = [5 x i8] c"Vs30\00"
@.str.48 = [11 x i8] c"close_dist\00"
@.str.49 = [5 x i8] c"Xcos\00"
@.str.50 = [5 x i8] c"Ycos\00"
@.str.51 = [6 x i8] c"T_min\00"
@.str.52 = [6 x i8] c"T_max\00"
@.str.53 = [5 x i8] c"comp\00"
@.str.54 = [6 x i8] c"\09%.5e\00"
@.str.55 = [4 x i8] c"\09%s\00"
@.str.56 = [4 x i8] c"pga\00"
@.str.57 = [4 x i8] c"pgv\00"
@.str.58 = [2 x i8] c"\0A\00"
@.str.59 = [3 x i8] c"%s\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 float*
%14 = alloca [8 x float]
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
%20 = alloca float
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca float
%25 = alloca float
%26 = alloca [512 x i8]
%27 = alloca [1024 x i8]
%28 = alloca [128 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 [16 x i8]
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca [256 x i8]
%45 = alloca [256 x i8]
%46 = alloca [256 x i8]
%47 = alloca [256 x i8]
%48 = alloca [128 x i8]
%49 = alloca [128 x i8]
%50 = alloca [128 x i8]
%51 = alloca float
%52 = alloca float
%53 = alloca float
%54 = alloca float
%55 = alloca float
%56 = alloca float
%57 = alloca float
%58 = alloca float
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store float 0.000000e+00, float* %24
store float 0.000000e+00, float* %25
store i32 1, i32* %40
store i32 7, i32* %41
store i32 0, i32* %42
store i32 0, i32* %43
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
store float 0xC08F3F3340000000, float* %57
store float 0xC08F3F3340000000, float* %58
%59 = getelementptr inbounds [256 x i8], [256 x i8]* %44, i64 0, i64 0
store i8 0, i8* %59
%60 = getelementptr inbounds [256 x i8], [256 x i8]* %45, i64 0, i64 0
store i8 0, i8* %60
%61 = getelementptr inbounds [256 x i8], [256 x i8]* %46, i64 0, i64 0
store i8 0, i8* %61
%62 = getelementptr inbounds [256 x i8], [256 x i8]* %47, i64 0, i64 0
store i8 0, i8* %62
%63 = getelementptr inbounds [128 x i8], [128 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 = getelementptr inbounds [16 x i8], [16 x i8]* %37, i64 0, i64 0
%82 = call i32 (i8*, i8*, ...) @sprintf(i8* %81, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%83 = load i32, i32* %4
%84 = load i8**, i8*** %5
%85 = call i32 @setpar(i32 %83, 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.1, 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 ([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* %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.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %90)
%92 = getelementptr inbounds [256 x i8], [256 x i8]* %47, i64 0, i64 0
%93 = 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* %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.6, 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]* %49, i64 0, i64 0
%97 = 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* %96)
%98 = getelementptr inbounds [128 x i8], [128 x i8]* %50, i64 0, i64 0
%99 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %98)
%100 = getelementptr inbounds [128 x i8], [128 x i8]* %28, i64 0, i64 0
%101 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, 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]* %29, i64 0, i64 0
%103 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, 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]* %30, i64 0, i64 0
%105 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, 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]* %31, i64 0, i64 0
%107 = 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* %106)
%108 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%109 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.13, 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]* %33, i64 0, i64 0
%111 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.14, 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]* %34, i64 0, i64 0
%113 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.15, 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]* %35, i64 0, i64 0
%115 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %114)
%116 = getelementptr inbounds [16 x i8], [16 x i8]* %36, i64 0, i64 0
%117 = 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* %116)
%118 = getelementptr inbounds [16 x i8], [16 x i8]* %37, i64 0, i64 0
%119 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %118)
%120 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.19, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), float* %24)
%121 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), float* %25)
%122 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0), i32* %43)
%123 = 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.20, i64 0, i64 0), float* %51)
%124 = 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.20, i64 0, i64 0), float* %52)
%125 = 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.20, i64 0, i64 0), float* %53)
%126 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.27, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), float* %54)
%127 = 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.20, i64 0, i64 0), float* %55)
%128 = 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.20, i64 0, i64 0), float* %56)
%129 = 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.20, i64 0, i64 0), float* %57)
%130 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.31, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), float* %58)
%131 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.32, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0), i32* %42)
%132 = load i32, i32* %42
%133 = icmp eq i32 %132, 1
br i1 %133, label %134, label %135
134: ; preds = %2
store i32 0, i32* %40
br label %135
135: ; preds = %134, %2
%136 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.33, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0), i32* %40)
%137 = load i32, i32* %40
%138 = icmp eq i32 %137, 0
br i1 %138, label %139, label %144
139: ; preds = %135
%140 = load i32, i32* %42
%141 = icmp eq i32 %140, 0
br i1 %141, label %142, label %144
142: ; preds = %139
%143 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.34, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0), i32* %23)
br label %144
144: ; preds = %142, %139, %135
%145 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.35, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0), i32* %41)
%146 = call i32 (...) @endpar()
%147 = load float, float* %25
%148 = fpext float %147 to double
%149 = fcmp ogt double %148, 0.000000e+00
br i1 %149, label %150, label %156
150: ; preds = %144
%151 = getelementptr inbounds [16 x i8], [16 x i8]* %38, i64 0, i64 0
%152 = load float, float* %25
%153 = fpext float %152 to double
%154 = fdiv double 1.000000e+00, %153
%155 = call i32 (i8*, i8*, ...) @sprintf(i8* %151, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.36, i64 0, i64 0), double %154)
br label %159
156: ; preds = %144
%157 = getelementptr inbounds [16 x i8], [16 x i8]* %38, i64 0, i64 0
%158 = call i32 (i8*, i8*, ...) @sprintf(i8* %157, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.37, i64 0, i64 0))
br label %159
159: ; preds = %156, %150
%160 = load float, float* %24
%161 = fpext float %160 to double
%162 = fcmp ogt double %161, 0.000000e+00
br i1 %162, label %163, label %169
163: ; preds = %159
%164 = getelementptr inbounds [16 x i8], [16 x i8]* %39, i64 0, i64 0
%165 = load float, float* %24
%166 = fpext float %165 to double
%167 = fdiv double 1.000000e+00, %166
%168 = call i32 (i8*, i8*, ...) @sprintf(i8* %164, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.36, i64 0, i64 0), double %167)
br label %172
169: ; preds = %159
%170 = getelementptr inbounds [16 x i8], [16 x i8]* %39, i64 0, i64 0
%171 = call i32 (i8*, i8*, ...) @sprintf(i8* %170, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.38, i64 0, i64 0))
br label %172
172: ; preds = %169, %163
%173 = getelementptr inbounds [512 x i8], [512 x i8]* %26, i64 0, i64 0
%174 = getelementptr inbounds [128 x i8], [128 x i8]* %28, i64 0, i64 0
%175 = getelementptr inbounds [16 x i8], [16 x i8]* %29, i64 0, i64 0
%176 = getelementptr inbounds [16 x i8], [16 x i8]* %30, i64 0, i64 0
%177 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 0
%178 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%179 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%180 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 0
%181 = getelementptr inbounds [16 x i8], [16 x i8]* %35, i64 0, i64 0
%182 = getelementptr inbounds [16 x i8], [16 x i8]* %36, i64 0, i64 0
%183 = getelementptr inbounds [16 x i8], [16 x i8]* %37, i64 0, i64 0
%184 = getelementptr inbounds [16 x i8], [16 x i8]* %38, i64 0, i64 0
%185 = getelementptr inbounds [16 x i8], [16 x i8]* %39, i64 0, i64 0
%186 = call i32 (i8*, i8*, ...) @sprintf(i8* %173, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.39, i64 0, i64 0), i8* %174, i8* %175, i8* %176, i8* %177, i8* %178, i8* %179, i8* %180, i8* %181, i8* %182, i8* %183, i8* %184, i8* %185)
%187 = load i32, i32* %40
%188 = icmp ne i32 %187, 0
br i1 %188, label %189, label %208
189: ; preds = %172
%190 = getelementptr inbounds [256 x i8], [256 x i8]* %44, i64 0, i64 0
%191 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %190, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.40, i64 0, i64 0))
store i32* %191, i32** %6
%192 = getelementptr inbounds [1024 x i8], [1024 x i8]* %27, i64 0, i64 0
%193 = load i32*, i32** %6
%194 = call i32* @fgets(i8* %192, i32 1024, i32* %193)
%195 = getelementptr inbounds [1024 x i8], [1024 x i8]* %27, i64 0, i64 0
%196 = load i32*, i32** %6
%197 = call i32* @fgets(i8* %195, i32 1024, i32* %196)
%198 = getelementptr inbounds [1024 x i8], [1024 x i8]* %27, i64 0, i64 0
%199 = load i32*, i32** %6
%200 = call i32* @fgets(i8* %198, i32 1024, i32* %199)
%201 = getelementptr inbounds [1024 x i8], [1024 x i8]* %27, i64 0, i64 0
%202 = load i32*, i32** %6
%203 = call i32* @fgets(i8* %201, i32 1024, i32* %202)
%204 = getelementptr inbounds [1024 x i8], [1024 x i8]* %27, i64 0, i64 0
%205 = call i32 @sscanf(i8* %204, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.41, i64 0, i64 0), i32* %23)
%206 = load i32*, i32** %6
%207 = call i32 @fclose(i32* %206)
br label %238
208: ; preds = %172
%209 = load i32, i32* %42
%210 = icmp eq i32 %209, 1
br i1 %210, label %211, label %237
211: ; preds = %208
%212 = getelementptr inbounds [256 x i8], [256 x i8]* %44, i64 0, i64 0
%213 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %212, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.40, i64 0, i64 0))
store i32* %213, i32** %6
%214 = getelementptr inbounds [1024 x i8], [1024 x i8]* %27, i64 0, i64 0
%215 = load i32*, i32** %6
%216 = call i32* @fgets(i8* %214, i32 1024, i32* %215)
br label %217
217: ; preds = %221, %211
%218 = getelementptr inbounds [1024 x i8], [1024 x i8]* %27, i64 0, i64 0
%219 = call i64 @strncmp(i8* %218, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0), i32 1)
%220 = icmp eq i64 %219, 0
br i1 %220, label %221, label %225
221: ; preds = %217
%222 = getelementptr inbounds [1024 x i8], [1024 x i8]* %27, i64 0, i64 0
%223 = load i32*, i32** %6
%224 = call i32* @fgets(i8* %222, i32 1024, i32* %223)
br label %217
225: ; preds = %217
store i32 1, i32* %23
br label %226
226: ; preds = %231, %225
%227 = getelementptr inbounds [1024 x i8], [1024 x i8]* %27, i64 0, i64 0
%228 = load i32*, i32** %6
%229 = call i32* @fgets(i8* %227, i32 1024, i32* %228)
%230 = icmp ne i32* %229, null
br i1 %230, label %231, label %234
231: ; preds = %226
%232 = load i32, i32* %23
%233 = add nsw i32 %232, 1
store i32 %233, i32* %23
br label %226
234: ; preds = %226
%235 = load i32*, i32** %6
%236 = call i32 @fclose(i32* %235)
br label %237
237: ; preds = %234, %208
br label %238
238: ; preds = %237, %189
%239 = load i32, i32* %23
%240 = sext i32 %239 to i64
%241 = mul i64 %240, 4
%242 = trunc i64 %241 to i32
%243 = call i64 @check_malloc(i32 %242)
%244 = inttoptr i64 %243 to float*
store float* %244, float** %7
%245 = load i32, i32* %23
%246 = sext i32 %245 to i64
%247 = mul i64 %246, 4
%248 = trunc i64 %247 to i32
%249 = call i64 @check_malloc(i32 %248)
%250 = inttoptr i64 %249 to float*
store float* %250, float** %8
%251 = load i32, i32* %23
%252 = sext i32 %251 to i64
%253 = mul i64 %252, 4
%254 = trunc i64 %253 to i32
%255 = call i64 @check_malloc(i32 %254)
%256 = inttoptr i64 %255 to float*
store float* %256, float** %9
%257 = load i32, i32* %23
%258 = sext i32 %257 to i64
%259 = mul i64 %258, 4
%260 = trunc i64 %259 to i32
%261 = call i64 @check_malloc(i32 %260)
%262 = inttoptr i64 %261 to float*
store float* %262, float** %10
%263 = load i32, i32* %23
%264 = sext i32 %263 to i64
%265 = mul i64 %264, 4
%266 = trunc i64 %265 to i32
%267 = call i64 @check_malloc(i32 %266)
%268 = inttoptr i64 %267 to float*
store float* %268, float** %11
%269 = load i32, i32* %23
%270 = sext i32 %269 to i64
%271 = mul i64 %270, 4
%272 = trunc i64 %271 to i32
%273 = call i64 @check_malloc(i32 %272)
%274 = inttoptr i64 %273 to float*
store float* %274, float** %12
%275 = load i32, i32* %23
%276 = sext i32 %275 to i64
%277 = mul i64 %276, 4
%278 = trunc i64 %277 to i32
%279 = call i64 @check_malloc(i32 %278)
%280 = inttoptr i64 %279 to float*
store float* %280, float** %13
%281 = load i32, i32* %42
%282 = icmp eq i32 %281, 1
br i1 %282, label %283, label %291
283: ; preds = %238
%284 = getelementptr inbounds [256 x i8], [256 x i8]* %44, i64 0, i64 0
%285 = load float*, float** %7
%286 = load float*, float** %8
%287 = load float*, float** %9
%288 = load float*, float** %10
%289 = load i32, i32* %23
%290 = call i32 @read_bbpfile_3comp(i8* %284, float* %285, float* %286, float* %287, float* %288, i32 %289)
br label %306
291: ; preds = %238
%292 = getelementptr inbounds [256 x i8], [256 x i8]* %44, i64 0, i64 0
%293 = load float*, float** %7
%294 = load float*, float** %8
%295 = load i32, i32* %23
%296 = load i32, i32* %41
%297 = load i32, i32* %40
%298 = call i32 @read_specfile(i8* %292, float* %293, float* %294, i32 %295, i32 %296, i32 %297)
%299 = getelementptr inbounds [256 x i8], [256 x i8]* %45, i64 0, i64 0
%300 = load float*, float** %7
%301 = load float*, float** %9
%302 = load i32, i32* %23
%303 = load i32, i32* %41
%304 = load i32, i32* %40
%305 = call i32 @read_specfile(i8* %299, float* %300, float* %301, i32 %302, i32 %303, i32 %304)
br label %306
306: ; preds = %291, %283
%307 = getelementptr inbounds [256 x i8], [256 x i8]* %46, i64 0, i64 0
%308 = load i8, i8* %307
%309 = sext i8 %308 to i32
%310 = icmp eq i32 %309, 0
br i1 %310, label %319, label %311
311: ; preds = %306
%312 = load i32, i32* %42
%313 = icmp eq i32 %312, 0
br i1 %313, label %314, label %386
314: ; preds = %311
%315 = getelementptr inbounds [256 x i8], [256 x i8]* %47, i64 0, i64 0
%316 = load i8, i8* %315
%317 = sext i8 %316 to i32
%318 = icmp eq i32 %317, 0
br i1 %318, label %319, label %386
319: ; preds = %314, %306
store i32 0, i32* %21
br label %320
320: ; preds = %352, %319
%321 = load i32, i32* %21
%322 = load i32, i32* %23
%323 = icmp slt i32 %321, %322
br i1 %323, label %324, label %355
324: ; preds = %320
%325 = load float*, float** %8
%326 = load i32, i32* %21
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds float, float* %325, i64 %327
%329 = load float, float* %328
%330 = load float*, float** %11
%331 = load i32, i32* %21
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float, float* %330, i64 %332
store float %329, float* %333
%334 = load float*, float** %9
%335 = load i32, i32* %21
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds float, float* %334, i64 %336
%338 = load float, float* %337
%339 = load float*, float** %12
%340 = load i32, i32* %21
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds float, float* %339, i64 %341
store float %338, float* %342
%343 = load float*, float** %10
%344 = load i32, i32* %21
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds float, float* %343, i64 %345
%347 = load float, float* %346
%348 = load float*, float** %13
%349 = load i32, i32* %21
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds float, float* %348, i64 %350
store float %347, float* %351
br label %352
352: ; preds = %324
%353 = load i32, i32* %21
%354 = add nsw i32 %353, 1
store i32 %354, i32* %21
br label %320
355: ; preds = %320
%356 = load float, float* %51
store float %356, float* %15
%357 = load float, float* %52
store float %357, float* %16
store float 0xC08F3F3340000000, float* %17
%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 %370
361: ; preds = %355
%362 = load float, float* %16
%363 = fpext float %362 to double
%364 = fcmp oge double %363, 0.000000e+00
br i1 %364, label %365, label %370
365: ; preds = %361
%366 = load float, float* %15
%367 = load float, float* %16
%368 = fmul float %366, %367
%369 = call float @sqrt(float %368)
store float %369, float* %17
br label %370
370: ; preds = %365, %361, %355
%371 = load float, float* %53
store float %371, float* %18
%372 = load float, float* %54
store float %372, float* %19
store float 0xC08F3F3340000000, float* %20
%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 %385
376: ; preds = %370
%377 = load float, float* %19
%378 = fpext float %377 to double
%379 = fcmp oge double %378, 0.000000e+00
br i1 %379, label %380, label %385
380: ; preds = %376
%381 = load float, float* %18
%382 = load float, float* %19
%383 = fmul float %381, %382
%384 = call float @sqrt(float %383)
store float %384, float* %20
br label %385
385: ; preds = %380, %376, %370
br label %580
386: ; preds = %314, %311
%387 = load i32, i32* %42
%388 = icmp eq i32 %387, 1
br i1 %388, label %389, label %397
389: ; preds = %386
%390 = getelementptr inbounds [256 x i8], [256 x i8]* %46, i64 0, i64 0
%391 = load float*, float** %7
%392 = load float*, float** %11
%393 = load float*, float** %12
%394 = load float*, float** %13
%395 = load i32, i32* %23
%396 = call i32 @read_bbpfile_3comp(i8* %390, float* %391, float* %392, float* %393, float* %394, i32 %395)
br label %412
397: ; preds = %386
%398 = getelementptr inbounds [256 x i8], [256 x i8]* %46, i64 0, i64 0
%399 = load float*, float** %7
%400 = load float*, float** %11
%401 = load i32, i32* %23
%402 = load i32, i32* %41
%403 = load i32, i32* %40
%404 = call i32 @read_specfile(i8* %398, float* %399, float* %400, i32 %401, i32 %402, i32 %403)
%405 = getelementptr inbounds [256 x i8], [256 x i8]* %47, i64 0, i64 0
%406 = load float*, float** %7
%407 = load float*, float** %12
%408 = load i32, i32* %23
%409 = load i32, i32* %41
%410 = load i32, i32* %40
%411 = call i32 @read_specfile(i8* %405, float* %406, float* %407, i32 %408, i32 %409, i32 %410)
br label %412
412: ; preds = %397, %389
store i32 0, i32* %21
br label %413
413: ; preds = %508, %412
%414 = load i32, i32* %21
%415 = load i32, i32* %23
%416 = icmp slt i32 %414, %415
br i1 %416, label %417, label %511
417: ; preds = %413
%418 = load float*, float** %11
%419 = load i32, i32* %21
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds float, float* %418, i64 %420
%422 = load float, float* %421
%423 = fpext float %422 to double
%424 = fcmp une double %423, 0.000000e+00
br i1 %424, label %425, label %442
425: ; preds = %417
%426 = load float*, float** %8
%427 = load i32, i32* %21
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds float, float* %426, i64 %428
%430 = load float, float* %429
%431 = load float*, float** %11
%432 = load i32, i32* %21
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds float, float* %431, i64 %433
%435 = load float, float* %434
%436 = fdiv float %430, %435
%437 = call float @log(float %436)
%438 = load float*, float** %11
%439 = load i32, i32* %21
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds float, float* %438, i64 %440
store float %437, float* %441
br label %447
442: ; preds = %417
%443 = load float*, float** %11
%444 = load i32, i32* %21
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds float, float* %443, i64 %445
store float -9.900000e+01, float* %446
br label %447
447: ; preds = %442, %425
%448 = load float*, float** %12
%449 = load i32, i32* %21
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds float, float* %448, i64 %450
%452 = load float, float* %451
%453 = fpext float %452 to double
%454 = fcmp une double %453, 0.000000e+00
br i1 %454, label %455, label %472
455: ; preds = %447
%456 = load float*, float** %9
%457 = load i32, i32* %21
%458 = sext i32 %457 to i64
%459 = getelementptr inbounds float, float* %456, i64 %458
%460 = load float, float* %459
%461 = load float*, float** %12
%462 = load i32, i32* %21
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds float, float* %461, i64 %463
%465 = load float, float* %464
%466 = fdiv float %460, %465
%467 = call float @log(float %466)
%468 = load float*, float** %12
%469 = load i32, i32* %21
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds float, float* %468, i64 %470
store float %467, float* %471
br label %477
472: ; preds = %447
%473 = load float*, float** %12
%474 = load i32, i32* %21
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds float, float* %473, i64 %475
store float -9.900000e+01, float* %476
br label %477
477: ; preds = %472, %455
%478 = load float*, float** %13
%479 = load i32, i32* %21
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds float, float* %478, i64 %480
%482 = load float, float* %481
%483 = fpext float %482 to double
%484 = fcmp une double %483, 0.000000e+00
br i1 %484, label %485, label %502
485: ; preds = %477
%486 = load float*, float** %10
%487 = load i32, i32* %21
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds float, float* %486, i64 %488
%490 = load float, float* %489
%491 = load float*, float** %13
%492 = load i32, i32* %21
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds float, float* %491, i64 %493
%495 = load float, float* %494
%496 = fdiv float %490, %495
%497 = call float @log(float %496)
%498 = load float*, float** %13
%499 = load i32, i32* %21
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds float, float* %498, i64 %500
store float %497, float* %501
br label %507
502: ; preds = %477
%503 = load float*, float** %13
%504 = load i32, i32* %21
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds float, float* %503, i64 %505
store float -9.900000e+01, float* %506
br label %507
507: ; preds = %502, %485
br label %508
508: ; preds = %507
%509 = load i32, i32* %21
%510 = add nsw i32 %509, 1
store i32 %510, i32* %21
br label %413
511: ; preds = %413
%512 = load float, float* %51
%513 = fpext float %512 to double
%514 = fcmp ogt double %513, 0.000000e+00
br i1 %514, label %515, label %524
515: ; preds = %511
%516 = load float, float* %55
%517 = fpext float %516 to double
%518 = fcmp ogt double %517, 0.000000e+00
br i1 %518, label %519, label %524
519: ; preds = %515
%520 = load float, float* %51
%521 = load float, float* %55
%522 = fdiv float %520, %521
%523 = call float @log(float %522)
store float %523, float* %15
br label %525
524: ; preds = %515, %511
store float 0xC08F3F3340000000, float* %15
br label %525
525: ; preds = %524, %519
%526 = load float, float* %52
%527 = fpext float %526 to double
%528 = fcmp ogt double %527, 0.000000e+00
br i1 %528, label %529, label %538
529: ; preds = %525
%530 = load float, float* %56
%531 = fpext float %530 to double
%532 = fcmp ogt double %531, 0.000000e+00
br i1 %532, label %533, label %538
533: ; preds = %529
%534 = load float, float* %52
%535 = load float, float* %56
%536 = fdiv float %534, %535
%537 = call float @log(float %536)
store float %537, float* %16
br label %539
538: ; preds = %529, %525
store float 0xC08F3F3340000000, float* %16
br label %539
539: ; preds = %538, %533
%540 = load float, float* %15
%541 = load float, float* %16
%542 = fadd float %540, %541
%543 = fpext float %542 to double
%544 = fmul double 5.000000e-01, %543
%545 = fptrunc double %544 to float
store float %545, float* %17
%546 = load float, float* %53
%547 = fpext float %546 to double
%548 = fcmp ogt double %547, 0.000000e+00
br i1 %548, label %549, label %558
549: ; preds = %539
%550 = load float, float* %57
%551 = fpext float %550 to double
%552 = fcmp ogt double %551, 0.000000e+00
br i1 %552, label %553, label %558
553: ; preds = %549
%554 = load float, float* %53
%555 = load float, float* %57
%556 = fdiv float %554, %555
%557 = call float @log(float %556)
store float %557, float* %18
br label %559
558: ; preds = %549, %539
store float 0xC08F3F3340000000, float* %18
br label %559
559: ; preds = %558, %553
%560 = load float, float* %54
%561 = fpext float %560 to double
%562 = fcmp ogt double %561, 0.000000e+00
br i1 %562, label %563, label %572
563: ; preds = %559
%564 = load float, float* %58
%565 = fpext float %564 to double
%566 = fcmp ogt double %565, 0.000000e+00
br i1 %566, label %567, label %572
567: ; preds = %563
%568 = load float, float* %54
%569 = load float, float* %58
%570 = fdiv float %568, %569
%571 = call float @log(float %570)
store float %571, float* %19
br label %573
572: ; preds = %563, %559
store float 0xC08F3F3340000000, float* %19
br label %573
573: ; preds = %572, %567
%574 = load float, float* %18
%575 = load float, float* %19
%576 = fadd float %574, %575
%577 = fpext float %576 to double
%578 = fmul double 5.000000e-01, %577
%579 = fptrunc double %578 to float
store float %579, float* %20
br label %580
580: ; preds = %573, %385
%581 = load i32, i32* %43
%582 = icmp ne i32 %581, 0
br i1 %582, label %583, label %619
583: ; preds = %580
%584 = load i32, i32* @stdout
%585 = call i32 (i32, i8*, ...) @fprintf(i32 %584, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.43, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.44, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.45, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 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 ([4 x i8], [4 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.46, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.47, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 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 ([5 x i8], [5 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 ([6 x i8], [6 x i8]* @.str.52, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.53, i64 0, i64 0))
store i32 0, i32* %21
br label %586
586: ; preds = %599, %583
%587 = load i32, i32* %21
%588 = load i32, i32* %23
%589 = icmp slt i32 %587, %588
br i1 %589, label %590, label %602
590: ; preds = %586
%591 = load i32, i32* @stdout
%592 = load float*, float** %7
%593 = load i32, i32* %21
%594 = sext i32 %593 to i64
%595 = getelementptr inbounds float, float* %592, i64 %594
%596 = load float, float* %595
%597 = fpext float %596 to double
%598 = call i32 (i32, i8*, ...) @fprintf(i32 %591, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %597)
br label %599
599: ; preds = %590
%600 = load i32, i32* %21
%601 = add nsw i32 %600, 1
store i32 %601, i32* %21
br label %586
602: ; preds = %586
%603 = load float, float* %51
%604 = fpext float %603 to double
%605 = fcmp oge double %604, 0.000000e+00
br i1 %605, label %606, label %609
606: ; preds = %602
%607 = load i32, i32* @stdout
%608 = call i32 (i32, i8*, ...) @fprintf(i32 %607, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.56, i64 0, i64 0))
br label %609
609: ; preds = %606, %602
%610 = load float, float* %53
%611 = fpext float %610 to double
%612 = fcmp oge double %611, 0.000000e+00
br i1 %612, label %613, label %616
613: ; preds = %609
%614 = load i32, i32* @stdout
%615 = call i32 (i32, i8*, ...) @fprintf(i32 %614, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.57, i64 0, i64 0))
br label %616
616: ; preds = %613, %609
%617 = load i32, i32* @stdout
%618 = call i32 (i32, i8*, ...) @fprintf(i32 %617, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.58, i64 0, i64 0))
br label %619
619: ; preds = %616, %580
%620 = load i32, i32* @stdout
%621 = getelementptr inbounds [512 x i8], [512 x i8]* %26, i64 0, i64 0
%622 = call i32 (i32, i8*, ...) @fprintf(i32 %620, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.59, i64 0, i64 0), i8* %621)
%623 = load i32, i32* @stdout
%624 = getelementptr inbounds [128 x i8], [128 x i8]* %48, i64 0, i64 0
%625 = call i32 (i32, i8*, ...) @fprintf(i32 %623, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0), i8* %624)
store i32 0, i32* %21
br label %626
626: ; preds = %639, %619
%627 = load i32, i32* %21
%628 = load i32, i32* %23
%629 = icmp slt i32 %627, %628
br i1 %629, label %630, label %642
630: ; preds = %626
%631 = load i32, i32* @stdout
%632 = load float*, float** %11
%633 = load i32, i32* %21
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds float, float* %632, i64 %634
%636 = load float, float* %635
%637 = fpext float %636 to double
%638 = call i32 (i32, i8*, ...) @fprintf(i32 %631, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %637)
br label %639
639: ; preds = %630
%640 = load i32, i32* %21
%641 = add nsw i32 %640, 1
store i32 %641, i32* %21
br label %626
642: ; preds = %626
%643 = load float, float* %51
%644 = fpext float %643 to double
%645 = fcmp oge double %644, 0.000000e+00
br i1 %645, label %646, label %651
646: ; preds = %642
%647 = load i32, i32* @stdout
%648 = load float, float* %15
%649 = fpext float %648 to double
%650 = call i32 (i32, i8*, ...) @fprintf(i32 %647, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %649)
br label %651
651: ; preds = %646, %642
%652 = load float, float* %53
%653 = fpext float %652 to double
%654 = fcmp oge double %653, 0.000000e+00
br i1 %654, label %655, label %660
655: ; preds = %651
%656 = load i32, i32* @stdout
%657 = load float, float* %18
%658 = fpext float %657 to double
%659 = call i32 (i32, i8*, ...) @fprintf(i32 %656, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %658)
br label %660
660: ; preds = %655, %651
%661 = load i32, i32* @stdout
%662 = call i32 (i32, i8*, ...) @fprintf(i32 %661, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.58, i64 0, i64 0))
%663 = load i32, i32* @stdout
%664 = getelementptr inbounds [512 x i8], [512 x i8]* %26, i64 0, i64 0
%665 = call i32 (i32, i8*, ...) @fprintf(i32 %663, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.59, i64 0, i64 0), i8* %664)
%666 = load i32, i32* @stdout
%667 = getelementptr inbounds [128 x i8], [128 x i8]* %49, i64 0, i64 0
%668 = call i32 (i32, i8*, ...) @fprintf(i32 %666, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0), i8* %667)
store i32 0, i32* %21
br label %669
669: ; preds = %682, %660
%670 = load i32, i32* %21
%671 = load i32, i32* %23
%672 = icmp slt i32 %670, %671
br i1 %672, label %673, label %685
673: ; preds = %669
%674 = load i32, i32* @stdout
%675 = load float*, float** %12
%676 = load i32, i32* %21
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds float, float* %675, i64 %677
%679 = load float, float* %678
%680 = fpext float %679 to double
%681 = call i32 (i32, i8*, ...) @fprintf(i32 %674, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %680)
br label %682
682: ; preds = %673
%683 = load i32, i32* %21
%684 = add nsw i32 %683, 1
store i32 %684, i32* %21
br label %669
685: ; preds = %669
%686 = load float, float* %52
%687 = fpext float %686 to double
%688 = fcmp oge double %687, 0.000000e+00
br i1 %688, label %689, label %694
689: ; preds = %685
%690 = load i32, i32* @stdout
%691 = load float, float* %16
%692 = fpext float %691 to double
%693 = call i32 (i32, i8*, ...) @fprintf(i32 %690, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %692)
br label %694
694: ; preds = %689, %685
%695 = load float, float* %54
%696 = fpext float %695 to double
%697 = fcmp oge double %696, 0.000000e+00
br i1 %697, label %698, label %703
698: ; preds = %694
%699 = load i32, i32* @stdout
%700 = load float, float* %19
%701 = fpext float %700 to double
%702 = call i32 (i32, i8*, ...) @fprintf(i32 %699, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %701)
br label %703
703: ; preds = %698, %694
%704 = load i32, i32* @stdout
%705 = call i32 (i32, i8*, ...) @fprintf(i32 %704, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.58, i64 0, i64 0))
%706 = load i32, i32* @stdout
%707 = getelementptr inbounds [512 x i8], [512 x i8]* %26, i64 0, i64 0
%708 = call i32 (i32, i8*, ...) @fprintf(i32 %706, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.59, i64 0, i64 0), i8* %707)
%709 = load i32, i32* @stdout
%710 = getelementptr inbounds [128 x i8], [128 x i8]* %50, i64 0, i64 0
%711 = call i32 (i32, i8*, ...) @fprintf(i32 %709, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0), i8* %710)
store i32 0, i32* %21
br label %712
712: ; preds = %725, %703
%713 = load i32, i32* %21
%714 = load i32, i32* %23
%715 = icmp slt i32 %713, %714
br i1 %715, label %716, label %728
716: ; preds = %712
%717 = load i32, i32* @stdout
%718 = load float*, float** %13
%719 = load i32, i32* %21
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds float, float* %718, i64 %720
%722 = load float, float* %721
%723 = fpext float %722 to double
%724 = call i32 (i32, i8*, ...) @fprintf(i32 %717, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %723)
br label %725
725: ; preds = %716
%726 = load i32, i32* %21
%727 = add nsw i32 %726, 1
store i32 %727, i32* %21
br label %712
728: ; preds = %712
%729 = load float, float* %51
%730 = fpext float %729 to double
%731 = fcmp oge double %730, 0.000000e+00
br i1 %731, label %732, label %741
732: ; preds = %728
%733 = load float, float* %52
%734 = fpext float %733 to double
%735 = fcmp oge double %734, 0.000000e+00
br i1 %735, label %736, label %741
736: ; preds = %732
%737 = load i32, i32* @stdout
%738 = load float, float* %17
%739 = fpext float %738 to double
%740 = call i32 (i32, i8*, ...) @fprintf(i32 %737, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %739)
br label %741
741: ; preds = %736, %732, %728
%742 = load float, float* %53
%743 = fpext float %742 to double
%744 = fcmp oge double %743, 0.000000e+00
br i1 %744, label %745, label %754
745: ; preds = %741
%746 = load float, float* %54
%747 = fpext float %746 to double
%748 = fcmp oge double %747, 0.000000e+00
br i1 %748, label %749, label %754
749: ; preds = %745
%750 = load i32, i32* @stdout
%751 = load float, float* %20
%752 = fpext float %751 to double
%753 = call i32 (i32, i8*, ...) @fprintf(i32 %750, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %752)
br label %754
754: ; preds = %749, %745, %741
%755 = load i32, i32* @stdout
%756 = call i32 (i32, i8*, ...) @fprintf(i32 %755, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.58, 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 = [6 x i8] c"comp3\00"
@.str.9 = [7 x i8] c"eqname\00"
@.str.10 = [4 x i8] c"mag\00"
@.str.11 = [5 x i8] c"stat\00"
@.str.12 = [4 x i8] c"lon\00"
@.str.13 = [4 x i8] c"lat\00"
@.str.14 = [6 x i8] c"seqno\00"
@.str.15 = [5 x i8] c"vs30\00"
@.str.16 = [3 x i8] c"cd\00"
@.str.17 = [5 x i8] c"xcos\00"
@.str.18 = [5 x i8] c"ycos\00"
@.str.19 = [4 x i8] c"flo\00"
@.str.20 = [2 x i8] c"f\00"
@.str.21 = [4 x i8] c"fhi\00"
@.str.22 = [13 x i8] c"print_header\00"
@.str.23 = [2 x i8] c"d\00"
@.str.24 = [5 x i8] c"pga1\00"
@.str.25 = [5 x i8] c"pga2\00"
@.str.26 = [5 x i8] c"pgv1\00"
@.str.27 = [5 x i8] c"pgv2\00"
@.str.28 = [9 x i8] c"sim_pga1\00"
@.str.29 = [9 x i8] c"sim_pga2\00"
@.str.30 = [9 x i8] c"sim_pgv1\00"
@.str.31 = [9 x i8] c"sim_pgv2\00"
@.str.32 = [11 x i8] c"bbp_format\00"
@.str.33 = [15 x i8] c"respect_format\00"
@.str.34 = [3 x i8] c"np\00"
@.str.35 = [9 x i8] c"sa_field\00"
@.str.36 = [5 x i8] c"%.3f\00"
@.str.37 = [11 x i8] c"-99999.999\00"
@.str.38 = [10 x i8] c"99999.999\00"
@.str.39 = [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.40 = [2 x i8] c"r\00"
@.str.41 = [3 x i8] c"%d\00"
@.str.42 = [2 x i8] c"#\00"
@stdout = global i32 0
@.str.43 = [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.44 = [3 x i8] c"EQ\00"
@.str.45 = [4 x i8] c"Mag\00"
@.str.46 = [12 x i8] c"stat_seq_no\00"
@.str.47 = [5 x i8] c"Vs30\00"
@.str.48 = [11 x i8] c"close_dist\00"
@.str.49 = [5 x i8] c"Xcos\00"
@.str.50 = [5 x i8] c"Ycos\00"
@.str.51 = [6 x i8] c"T_min\00"
@.str.52 = [6 x i8] c"T_max\00"
@.str.53 = [5 x i8] c"comp\00"
@.str.54 = [6 x i8] c"\09%.5e\00"
@.str.55 = [4 x i8] c"\09%s\00"
@.str.56 = [4 x i8] c"pga\00"
@.str.57 = [4 x i8] c"pgv\00"
@.str.58 = [2 x i8] c"\0A\00"
@.str.59 = [3 x i8] c"%s\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 [128 x i8]
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float
%37 = alloca float
%38 = alloca float
%39 = bitcast i32* %3 to i8*
%40 = bitcast float* %4 to i8*
store float 0.000000e+00, float* %4
%41 = bitcast float* %5 to i8*
store float 0.000000e+00, float* %5
%42 = getelementptr inbounds [512 x i8], [512 x i8]* %6, i64 0, i64 0
%43 = getelementptr inbounds [1024 x i8], [1024 x i8]* %7, i64 0, i64 0
%44 = getelementptr inbounds [128 x i8], [128 x i8]* %8, i64 0, i64 0
%45 = getelementptr inbounds [16 x i8], [16 x i8]* %9, i64 0, i64 0
%46 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%47 = getelementptr inbounds [16 x i8], [16 x i8]* %11, i64 0, i64 0
%48 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 0
%49 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%50 = getelementptr inbounds [16 x i8], [16 x i8]* %14, i64 0, i64 0
%51 = getelementptr inbounds [16 x i8], [16 x i8]* %15, i64 0, i64 0
%52 = getelementptr inbounds [16 x i8], [16 x i8]* %16, i64 0, i64 0
%53 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 0
%54 = getelementptr inbounds [16 x i8], [16 x i8]* %18, i64 0, i64 0
%55 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 0
%56 = bitcast i32* %20 to i8*
store i32 1, i32* %20
%57 = bitcast i32* %21 to i8*
store i32 7, i32* %21
%58 = bitcast i32* %22 to i8*
store i32 0, i32* %22
%59 = bitcast i32* %23 to i8*
store i32 0, i32* %23
%60 = getelementptr inbounds [256 x i8], [256 x i8]* %24, i64 0, i64 0
%61 = getelementptr inbounds [256 x i8], [256 x i8]* %25, i64 0, i64 0
%62 = getelementptr inbounds [256 x i8], [256 x i8]* %26, i64 0, i64 0
%63 = getelementptr inbounds [256 x i8], [256 x i8]* %27, i64 0, i64 0
%64 = getelementptr inbounds [128 x i8], [128 x i8]* %28, i64 0, i64 0
%65 = getelementptr inbounds [128 x i8], [128 x i8]* %29, i64 0, i64 0
%66 = getelementptr inbounds [128 x i8], [128 x i8]* %30, i64 0, i64 0
%67 = bitcast float* %31 to i8*
store float 0xC08F3F3340000000, float* %31
%68 = bitcast float* %32 to i8*
store float 0xC08F3F3340000000, float* %32
%69 = bitcast float* %33 to i8*
store float 0xC08F3F3340000000, float* %33
%70 = bitcast float* %34 to i8*
store float 0xC08F3F3340000000, float* %34
%71 = bitcast float* %35 to i8*
store float 0xC08F3F3340000000, float* %35
%72 = bitcast float* %36 to i8*
store float 0xC08F3F3340000000, float* %36
%73 = bitcast float* %37 to i8*
store float 0xC08F3F3340000000, float* %37
%74 = bitcast float* %38 to i8*
store float 0xC08F3F3340000000, float* %38
store i8 0, i8* %60
store i8 0, i8* %61
store i8 0, i8* %62
store i8 0, i8* %63
%75 = tail call i32 @setpar(i32 %0, i8** %1)
%76 = 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* %60)
%77 = 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* %61)
%78 = 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* %62)
%79 = 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* %63)
%80 = 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* %64)
%81 = 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* %65)
%82 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %66)
%83 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([7 x i8], [7 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)
%84 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 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)
%85 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 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)
%86 = 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)
%87 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 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)
%88 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([6 x i8], [6 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)
%89 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 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)
%90 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([3 x i8], [3 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)
%91 = 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)
%92 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* %53)
%93 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.19, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), float* %4)
%94 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.21, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), float* %5)
%95 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0), i32* %23)
%96 = 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.20, i64 0, i64 0), float* %31)
%97 = 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.20, i64 0, i64 0), float* %32)
%98 = 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.20, i64 0, i64 0), float* %33)
%99 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.27, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), float* %34)
%100 = 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.20, i64 0, i64 0), float* %35)
%101 = 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.20, i64 0, i64 0), float* %36)
%102 = 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.20, i64 0, i64 0), float* %37)
%103 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.31, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.20, i64 0, i64 0), float* %38)
%104 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.32, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0), i32* %22)
%105 = load i32, i32* %22
%106 = icmp eq i32 %105, 1
br i1 %106, label %107, label %108
107: ; preds = %2
store i32 0, i32* %20
br label %108
108: ; preds = %107, %2
%109 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.33, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0), i32* %20)
%110 = load i32, i32* %20
%111 = icmp eq i32 %110, 0
%112 = load i32, i32* %22
%113 = icmp eq i32 %112, 0
%114 = select i1 %111, i1 %113, i1 false
br i1 %114, label %115, label %117
115: ; preds = %108
%116 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.34, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0), i32* %3)
br label %117
117: ; preds = %115, %108
%118 = call i32 (i8*, i8*, ...) @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.35, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0), i32* %21)
%119 = call i32 (...) @endpar()
%120 = load float, float* %5
%121 = fcmp ogt float %120, 0.000000e+00
br i1 %121, label %122, label %126
122: ; preds = %117
%123 = fpext float %120 to double
%124 = fdiv double 1.000000e+00, %123
%125 = call i32 (i8*, i8*, ...) @sprintf(i8* %54, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.36, i64 0, i64 0), double %124)
br label %127
126: ; preds = %117
br label %127
127: ; preds = %126, %122
%128 = load float, float* %4
%129 = fcmp ogt float %128, 0.000000e+00
br i1 %129, label %130, label %134
130: ; preds = %127
%131 = fpext float %128 to double
%132 = fdiv double 1.000000e+00, %131
%133 = call i32 (i8*, i8*, ...) @sprintf(i8* %55, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.36, i64 0, i64 0), double %132)
br label %135
134: ; preds = %127
br label %135
135: ; preds = %134, %130
%136 = call i32 (i8*, i8*, ...) @sprintf(i8* %42, i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.39, i64 0, i64 0), i8* %44, i8* %45, i8* %46, i8* %47, i8* %48, i8* %49, i8* %50, i8* %51, i8* %52, i8* %53, i8* %54, i8* %55)
%137 = load i32, i32* %20
%138 = icmp eq i32 %137, 0
br i1 %138, label %146, label %139
139: ; preds = %135
%140 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %60, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.40, i64 0, i64 0))
%141 = call i32* @fgets(i8* %43, i32 1024, i32* %140)
%142 = call i32* @fgets(i8* %43, i32 1024, i32* %140)
%143 = call i32* @fgets(i8* %43, i32 1024, i32* %140)
%144 = call i32* @fgets(i8* %43, i32 1024, i32* %140)
%145 = call i32 @sscanf(i8* %43, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.41, i64 0, i64 0), i32* %3)
br label %166
146: ; preds = %135
%147 = load i32, i32* %22
%148 = icmp eq i32 %147, 1
br i1 %148, label %149, label %169
149: ; preds = %146
%150 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %60, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.40, i64 0, i64 0))
%151 = call i32* @fgets(i8* %43, i32 1024, i32* %150)
%152 = call i64 @strncmp(i8* %43, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0), i32 1)
%153 = icmp eq i64 %152, 0
br i1 %153, label %157, label %154
154: ; preds = %157, %149
store i32 1, i32* %3
%155 = call i32* @fgets(i8* %43, i32 1024, i32* %150)
%156 = icmp eq i32* %155, null
br i1 %156, label %166, label %161
157: ; preds = %149, %157
%158 = call i32* @fgets(i8* %43, i32 1024, i32* %150)
%159 = call i64 @strncmp(i8* %43, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0), i32 1)
%160 = icmp eq i64 %159, 0
br i1 %160, label %157, label %154
161: ; preds = %154, %161
%162 = load i32, i32* %3
%163 = add nsw i32 %162, 1
store i32 %163, i32* %3
%164 = call i32* @fgets(i8* %43, i32 1024, i32* %150)
%165 = icmp eq i32* %164, null
br i1 %165, label %166, label %161
166: ; preds = %161, %154, %139
%167 = phi i32* [ %140, %139 ], [ %150, %154 ], [ %150, %161 ]
%168 = call i32 @fclose(i32* %167)
br label %169
169: ; preds = %166, %146
%170 = load i32, i32* %3
%171 = shl i32 %170, 2
%172 = call i64 @check_malloc(i32 %171)
%173 = inttoptr i64 %172 to float*
%174 = load i32, i32* %3
%175 = shl i32 %174, 2
%176 = call i64 @check_malloc(i32 %175)
%177 = inttoptr i64 %176 to float*
%178 = load i32, i32* %3
%179 = shl i32 %178, 2
%180 = call i64 @check_malloc(i32 %179)
%181 = inttoptr i64 %180 to float*
%182 = load i32, i32* %3
%183 = shl i32 %182, 2
%184 = call i64 @check_malloc(i32 %183)
%185 = inttoptr i64 %184 to float*
%186 = load i32, i32* %3
%187 = shl i32 %186, 2
%188 = call i64 @check_malloc(i32 %187)
%189 = inttoptr i64 %188 to float*
%190 = load i32, i32* %3
%191 = shl i32 %190, 2
%192 = call i64 @check_malloc(i32 %191)
%193 = inttoptr i64 %192 to float*
%194 = load i32, i32* %3
%195 = shl i32 %194, 2
%196 = call i64 @check_malloc(i32 %195)
%197 = inttoptr i64 %196 to float*
%198 = load i32, i32* %22
%199 = icmp eq i32 %198, 1
%200 = load i32, i32* %3
br i1 %199, label %201, label %203
201: ; preds = %169
%202 = call i32 @read_bbpfile_3comp(i8* %60, float* %173, float* %177, float* %181, float* %185, i32 %200)
br label %211
203: ; preds = %169
%204 = load i32, i32* %21
%205 = load i32, i32* %20
%206 = call i32 @read_specfile(i8* %60, float* %173, float* %177, i32 %200, i32 %204, i32 %205)
%207 = load i32, i32* %3
%208 = load i32, i32* %21
%209 = load i32, i32* %20
%210 = call i32 @read_specfile(i8* %61, float* %173, float* %181, i32 %207, i32 %208, i32 %209)
br label %211
211: ; preds = %203, %201
%212 = load i8, i8* %62
%213 = icmp eq i8 %212, 0
br i1 %213, label %220, label %214
214: ; preds = %211
%215 = load i32, i32* %22
%216 = icmp eq i32 %215, 0
%217 = load i8, i8* %63
%218 = icmp eq i8 %217, 0
%219 = select i1 %216, i1 %218, i1 false
br i1 %219, label %220, label %286
220: ; preds = %214, %211
%221 = load i32, i32* %3
%222 = icmp sgt i32 %221, 0
br i1 %222, label %223, label %267
223: ; preds = %220
%224 = zext i32 %221 to i64
%225 = and i64 %224, 1
%226 = icmp eq i32 %221, 1
br i1 %226, label %254, label %227
227: ; preds = %223
%228 = and i64 %224, 4294967294
br label %229
229: ; preds = %229, %227
%230 = phi i64 [ 0, %227 ], [ %251, %229 ]
%231 = phi i64 [ 0, %227 ], [ %252, %229 ]
%232 = getelementptr inbounds float, float* %177, i64 %230
%233 = load float, float* %232
%234 = getelementptr inbounds float, float* %189, i64 %230
store float %233, float* %234
%235 = getelementptr inbounds float, float* %181, i64 %230
%236 = load float, float* %235
%237 = getelementptr inbounds float, float* %193, i64 %230
store float %236, float* %237
%238 = getelementptr inbounds float, float* %185, i64 %230
%239 = load float, float* %238
%240 = getelementptr inbounds float, float* %197, i64 %230
store float %239, float* %240
%241 = or i64 %230, 1
%242 = getelementptr inbounds float, float* %177, i64 %241
%243 = load float, float* %242
%244 = getelementptr inbounds float, float* %189, i64 %241
store float %243, float* %244
%245 = getelementptr inbounds float, float* %181, i64 %241
%246 = load float, float* %245
%247 = getelementptr inbounds float, float* %193, i64 %241
store float %246, float* %247
%248 = getelementptr inbounds float, float* %185, i64 %241
%249 = load float, float* %248
%250 = getelementptr inbounds float, float* %197, i64 %241
store float %249, float* %250
%251 = add nuw nsw i64 %230, 2
%252 = add i64 %231, 2
%253 = icmp eq i64 %252, %228
br i1 %253, label %254, label %229
254: ; preds = %229, %223
%255 = phi i64 [ 0, %223 ], [ %251, %229 ]
%256 = icmp eq i64 %225, 0
br i1 %256, label %267, label %257
257: ; preds = %254
%258 = getelementptr inbounds float, float* %177, i64 %255
%259 = load float, float* %258
%260 = getelementptr inbounds float, float* %189, i64 %255
store float %259, float* %260
%261 = getelementptr inbounds float, float* %181, i64 %255
%262 = load float, float* %261
%263 = getelementptr inbounds float, float* %193, i64 %255
store float %262, float* %263
%264 = getelementptr inbounds float, float* %185, i64 %255
%265 = load float, float* %264
%266 = getelementptr inbounds float, float* %197, i64 %255
store float %265, float* %266
br label %267
267: ; preds = %257, %254, %220
%268 = load float, float* %31
%269 = load float, float* %32
%270 = fcmp ult float %268, 0.000000e+00
%271 = fcmp ult float %269, 0.000000e+00
%272 = select i1 %270, i1 true, i1 %271
br i1 %272, label %276, label %273
273: ; preds = %267
%274 = fmul float %268, %269
%275 = call float @sqrt(float %274)
br label %276
276: ; preds = %273, %267
%277 = phi float [ %275, %273 ], [ 0xC08F3F3340000000, %267 ]
%278 = load float, float* %33
%279 = load float, float* %34
%280 = fcmp ult float %278, 0.000000e+00
%281 = fcmp ult float %279, 0.000000e+00
%282 = select i1 %280, i1 true, i1 %281
br i1 %282, label %383, label %283
283: ; preds = %276
%284 = fmul float %278, %279
%285 = call float @sqrt(float %284)
br label %383
286: ; preds = %214
%287 = icmp eq i32 %215, 1
%288 = load i32, i32* %3
br i1 %287, label %289, label %291
289: ; preds = %286
%290 = call i32 @read_bbpfile_3comp(i8* %62, float* %173, float* %189, float* %193, float* %197, i32 %288)
br label %299
291: ; preds = %286
%292 = load i32, i32* %21
%293 = load i32, i32* %20
%294 = call i32 @read_specfile(i8* %62, float* %173, float* %189, i32 %288, i32 %292, i32 %293)
%295 = load i32, i32* %3
%296 = load i32, i32* %21
%297 = load i32, i32* %20
%298 = call i32 @read_specfile(i8* %63, float* %173, float* %193, i32 %295, i32 %296, i32 %297)
br label %299
299: ; preds = %291, %289
%300 = load i32, i32* %3
%301 = icmp sgt i32 %300, 0
br i1 %301, label %302, label %338
302: ; preds = %299, %332
%303 = phi i64 [ %334, %332 ], [ 0, %299 ]
%304 = getelementptr inbounds float, float* %189, i64 %303
%305 = load float, float* %304
%306 = fcmp une float %305, 0.000000e+00
br i1 %306, label %307, label %312
307: ; preds = %302
%308 = getelementptr inbounds float, float* %177, i64 %303
%309 = load float, float* %308
%310 = fdiv float %309, %305
%311 = call float @log(float %310)
br label %312
312: ; preds = %302, %307
%313 = phi float [ %311, %307 ], [ -9.900000e+01, %302 ]
store float %313, float* %304
%314 = getelementptr inbounds float, float* %193, i64 %303
%315 = load float, float* %314
%316 = fcmp une float %315, 0.000000e+00
br i1 %316, label %317, label %322
317: ; preds = %312
%318 = getelementptr inbounds float, float* %181, i64 %303
%319 = load float, float* %318
%320 = fdiv float %319, %315
%321 = call float @log(float %320)
br label %322
322: ; preds = %312, %317
%323 = phi float [ %321, %317 ], [ -9.900000e+01, %312 ]
store float %323, float* %314
%324 = getelementptr inbounds float, float* %197, i64 %303
%325 = load float, float* %324
%326 = fcmp une float %325, 0.000000e+00
br i1 %326, label %327, label %332
327: ; preds = %322
%328 = getelementptr inbounds float, float* %185, i64 %303
%329 = load float, float* %328
%330 = fdiv float %329, %325
%331 = call float @log(float %330)
br label %332
332: ; preds = %322, %327
%333 = phi float [ %331, %327 ], [ -9.900000e+01, %322 ]
store float %333, float* %324
%334 = add nuw nsw i64 %303, 1
%335 = load i32, i32* %3
%336 = sext i32 %335 to i64
%337 = icmp slt i64 %334, %336
br i1 %337, label %302, label %338
338: ; preds = %332, %299
%339 = load float, float* %31
%340 = fcmp ogt float %339, 0.000000e+00
br i1 %340, label %341, label %347
341: ; preds = %338
%342 = load float, float* %35
%343 = fcmp ogt float %342, 0.000000e+00
br i1 %343, label %344, label %347
344: ; preds = %341
%345 = fdiv float %339, %342
%346 = call float @log(float %345)
br label %347
347: ; preds = %338, %341, %344
%348 = phi float [ %346, %344 ], [ 0xC08F3F3340000000, %341 ], [ 0xC08F3F3340000000, %338 ]
%349 = load float, float* %32
%350 = fcmp ogt float %349, 0.000000e+00
br i1 %350, label %351, label %357
351: ; preds = %347
%352 = load float, float* %36
%353 = fcmp ogt float %352, 0.000000e+00
br i1 %353, label %354, label %357
354: ; preds = %351
%355 = fdiv float %349, %352
%356 = call float @log(float %355)
br label %357
357: ; preds = %347, %351, %354
%358 = phi float [ %356, %354 ], [ 0xC08F3F3340000000, %351 ], [ 0xC08F3F3340000000, %347 ]
%359 = fadd float %348, %358
%360 = fmul float %359, 5.000000e-01
%361 = load float, float* %33
%362 = fcmp ogt float %361, 0.000000e+00
br i1 %362, label %363, label %369
363: ; preds = %357
%364 = load float, float* %37
%365 = fcmp ogt float %364, 0.000000e+00
br i1 %365, label %366, label %369
366: ; preds = %363
%367 = fdiv float %361, %364
%368 = call float @log(float %367)
br label %369
369: ; preds = %357, %363, %366
%370 = phi float [ %368, %366 ], [ 0xC08F3F3340000000, %363 ], [ 0xC08F3F3340000000, %357 ]
%371 = load float, float* %34
%372 = fcmp ogt float %371, 0.000000e+00
br i1 %372, label %373, label %379
373: ; preds = %369
%374 = load float, float* %38
%375 = fcmp ogt float %374, 0.000000e+00
br i1 %375, label %376, label %379
376: ; preds = %373
%377 = fdiv float %371, %374
%378 = call float @log(float %377)
br label %379
379: ; preds = %369, %373, %376
%380 = phi float [ %378, %376 ], [ 0xC08F3F3340000000, %373 ], [ 0xC08F3F3340000000, %369 ]
%381 = fadd float %370, %380
%382 = fmul float %381, 5.000000e-01
br label %383
383: ; preds = %276, %283, %379
%384 = phi float [ %268, %283 ], [ %268, %276 ], [ %348, %379 ]
%385 = phi float [ %269, %283 ], [ %269, %276 ], [ %358, %379 ]
%386 = phi float [ %277, %283 ], [ %277, %276 ], [ %360, %379 ]
%387 = phi float [ %278, %283 ], [ %278, %276 ], [ %370, %379 ]
%388 = phi float [ %279, %283 ], [ %279, %276 ], [ %380, %379 ]
%389 = phi float [ %285, %283 ], [ 0xC08F3F3340000000, %276 ], [ %382, %379 ]
%390 = load i32, i32* %23
%391 = icmp eq i32 %390, 0
br i1 %391, label %423, label %392
392: ; preds = %383
%393 = load i32, i32* @stdout
%394 = call i32 (i32, i8*, ...) @fprintf(i32 %393, i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.43, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.44, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.45, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 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 ([4 x i8], [4 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.46, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.47, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 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 ([5 x i8], [5 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 ([6 x i8], [6 x i8]* @.str.52, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.53, i64 0, i64 0))
%395 = load i32, i32* %3
%396 = icmp sgt i32 %395, 0
br i1 %396, label %397, label %408
397: ; preds = %392, %397
%398 = phi i64 [ %404, %397 ], [ 0, %392 ]
%399 = load i32, i32* @stdout
%400 = getelementptr inbounds float, float* %173, i64 %398
%401 = load float, float* %400
%402 = fpext float %401 to double
%403 = call i32 (i32, i8*, ...) @fprintf(i32 %399, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %402)
%404 = add nuw nsw i64 %398, 1
%405 = load i32, i32* %3
%406 = sext i32 %405 to i64
%407 = icmp slt i64 %404, %406
br i1 %407, label %397, label %408
408: ; preds = %397, %392
%409 = load float, float* %31
%410 = fcmp ult float %409, 0.000000e+00
br i1 %410, label %414, label %411
411: ; preds = %408
%412 = load i32, i32* @stdout
%413 = call i32 (i32, i8*, ...) @fprintf(i32 %412, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.56, i64 0, i64 0))
br label %414
414: ; preds = %411, %408
%415 = load float, float* %33
%416 = fcmp ult float %415, 0.000000e+00
br i1 %416, label %420, label %417
417: ; preds = %414
%418 = load i32, i32* @stdout
%419 = call i32 (i32, i8*, ...) @fprintf(i32 %418, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.57, i64 0, i64 0))
br label %420
420: ; preds = %417, %414
%421 = load i32, i32* @stdout
%422 = call i32 (i32, i8*, ...) @fprintf(i32 %421, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.58, i64 0, i64 0))
br label %423
423: ; preds = %420, %383
%424 = load i32, i32* @stdout
%425 = call i32 (i32, i8*, ...) @fprintf(i32 %424, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.59, i64 0, i64 0), i8* %42)
%426 = load i32, i32* @stdout
%427 = call i32 (i32, i8*, ...) @fprintf(i32 %426, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0), i8* %64)
%428 = load i32, i32* %3
%429 = icmp sgt i32 %428, 0
br i1 %429, label %430, label %441
430: ; preds = %423, %430
%431 = phi i64 [ %437, %430 ], [ 0, %423 ]
%432 = load i32, i32* @stdout
%433 = getelementptr inbounds float, float* %189, i64 %431
%434 = load float, float* %433
%435 = fpext float %434 to double
%436 = call i32 (i32, i8*, ...) @fprintf(i32 %432, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %435)
%437 = add nuw nsw i64 %431, 1
%438 = load i32, i32* %3
%439 = sext i32 %438 to i64
%440 = icmp slt i64 %437, %439
br i1 %440, label %430, label %441
441: ; preds = %430, %423
%442 = load float, float* %31
%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 %384 to double
%447 = call i32 (i32, i8*, ...) @fprintf(i32 %445, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %446)
br label %448
448: ; preds = %444, %441
%449 = load float, float* %33
%450 = fcmp ult float %449, 0.000000e+00
br i1 %450, label %455, label %451
451: ; preds = %448
%452 = load i32, i32* @stdout
%453 = fpext float %387 to double
%454 = call i32 (i32, i8*, ...) @fprintf(i32 %452, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %453)
br label %455
455: ; preds = %451, %448
%456 = load i32, i32* @stdout
%457 = call i32 (i32, i8*, ...) @fprintf(i32 %456, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.58, i64 0, i64 0))
%458 = load i32, i32* @stdout
%459 = call i32 (i32, i8*, ...) @fprintf(i32 %458, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.59, i64 0, i64 0), i8* %42)
%460 = load i32, i32* @stdout
%461 = call i32 (i32, i8*, ...) @fprintf(i32 %460, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0), i8* %65)
%462 = load i32, i32* %3
%463 = icmp sgt i32 %462, 0
br i1 %463, label %464, label %475
464: ; preds = %455, %464
%465 = phi i64 [ %471, %464 ], [ 0, %455 ]
%466 = load i32, i32* @stdout
%467 = getelementptr inbounds float, float* %193, i64 %465
%468 = load float, float* %467
%469 = fpext float %468 to double
%470 = call i32 (i32, i8*, ...) @fprintf(i32 %466, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %469)
%471 = add nuw nsw i64 %465, 1
%472 = load i32, i32* %3
%473 = sext i32 %472 to i64
%474 = icmp slt i64 %471, %473
br i1 %474, label %464, label %475
475: ; preds = %464, %455
%476 = load float, float* %32
%477 = fcmp ult float %476, 0.000000e+00
br i1 %477, label %482, label %478
478: ; preds = %475
%479 = load i32, i32* @stdout
%480 = fpext float %385 to double
%481 = call i32 (i32, i8*, ...) @fprintf(i32 %479, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %480)
br label %482
482: ; preds = %478, %475
%483 = load float, float* %34
%484 = fcmp ult float %483, 0.000000e+00
br i1 %484, label %489, label %485
485: ; preds = %482
%486 = load i32, i32* @stdout
%487 = fpext float %388 to double
%488 = call i32 (i32, i8*, ...) @fprintf(i32 %486, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %487)
br label %489
489: ; preds = %485, %482
%490 = load i32, i32* @stdout
%491 = call i32 (i32, i8*, ...) @fprintf(i32 %490, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.58, i64 0, i64 0))
%492 = load i32, i32* @stdout
%493 = call i32 (i32, i8*, ...) @fprintf(i32 %492, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.59, i64 0, i64 0), i8* %42)
%494 = load i32, i32* @stdout
%495 = call i32 (i32, i8*, ...) @fprintf(i32 %494, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i64 0, i64 0), i8* %66)
%496 = load i32, i32* %3
%497 = icmp sgt i32 %496, 0
br i1 %497, label %498, label %509
498: ; preds = %489, %498
%499 = phi i64 [ %505, %498 ], [ 0, %489 ]
%500 = load i32, i32* @stdout
%501 = getelementptr inbounds float, float* %197, i64 %499
%502 = load float, float* %501
%503 = fpext float %502 to double
%504 = call i32 (i32, i8*, ...) @fprintf(i32 %500, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %503)
%505 = add nuw nsw i64 %499, 1
%506 = load i32, i32* %3
%507 = sext i32 %506 to i64
%508 = icmp slt i64 %505, %507
br i1 %508, label %498, label %509
509: ; preds = %498, %489
%510 = load float, float* %31
%511 = fcmp ult float %510, 0.000000e+00
%512 = load float, float* %32
%513 = fcmp ult float %512, 0.000000e+00
%514 = select i1 %511, i1 true, i1 %513
br i1 %514, label %519, label %515
515: ; preds = %509
%516 = load i32, i32* @stdout
%517 = fpext float %386 to double
%518 = call i32 (i32, i8*, ...) @fprintf(i32 %516, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %517)
br label %519
519: ; preds = %515, %509
%520 = load float, float* %33
%521 = fcmp ult float %520, 0.000000e+00
%522 = load float, float* %34
%523 = fcmp ult float %522, 0.000000e+00
%524 = select i1 %521, i1 true, i1 %523
br i1 %524, label %529, label %525
525: ; preds = %519
%526 = load i32, i32* @stdout
%527 = fpext float %389 to double
%528 = call i32 (i32, i8*, ...) @fprintf(i32 %526, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), double %527)
br label %529
529: ; preds = %525, %519
%530 = load i32, i32* @stdout
%531 = call i32 (i32, i8*, ...) @fprintf(i32 %530, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.58, i64 0, i64 0))
ret i32 0
}