#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*/ exit(int);
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*/ mstpar(char *, char *, ...);
int /*<<< orphan*/ read_specfile(char *, float *, float *, int, int, int);
int /*<<< orphan*/ setpar(int, char **);
int /*<<< orphan*/ sprintf(char *, char *, ...);
double sqrt(float);
int /*<<< orphan*/ sscanf(char *, char *, ...);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ stdout;
main(int ac, char **av) {
  FILE *fpr, *fopfile();
  float *per, *sa1, *sa2, *res1, *res2, *avgr, v[8];
  int i, np2, np;
  float flo = 0.0;
  float fhi = 0.0;
  char statinfo[512], string[512];
  char eq[16], mag[16], stat[16], lon[16], lat[16];
  char seqno[16], vs30[16], cd[16], xc[16], yc[16], tmin[16], tmax[16];
  int sa_field = 6;
  int print_header = 0;
  int respect_format = 1;
  char datafile1[128], datafile2[128];
  char simfile1[128], simfile2[128];
  char comp1[128], comp2[128];
  float pga1 = -999.9;
  float pga2 = -999.9;
  float pgv1 = -999.9;
  float pgv2 = -999.9;
  simfile1[0] = '\0';
  simfile2[0] = '\0';
  setpar(ac, av);
  mstpar("datafile1", "s", datafile1);
  mstpar("datafile2", "s", datafile2);
  getpar("simfile1", "s", simfile1);
  getpar("simfile2", "s", simfile2);
  mstpar("comp1", "s", comp1);
  mstpar("comp2", "s", comp2);
  mstpar("eqname", "s", eq);
  mstpar("mag", "s", mag);
  mstpar("stat", "s", stat);
  mstpar("lon", "s", lon);
  mstpar("lat", "s", lat);
  mstpar("seqno", "s", seqno);
  mstpar("vs30", "s", vs30);
  mstpar("cd", "s", cd);
  mstpar("xcos", "s", xc);
  mstpar("ycos", "s", yc);
  getpar("flo", "f", &flo);
  getpar("fhi", "f", &fhi);
  getpar("print_header", "d", &print_header);
  getpar("sa_field", "d", &sa_field);
  getpar("pga1", "f", &pga1);
  getpar("pga2", "f", &pga2);
  getpar("pgv1", "f", &pgv1);
  getpar("pgv2", "f", &pgv2);
  getpar("respect_format", "d", &respect_format);
  if (respect_format == 0)
    mstpar("np", "d", &np);
  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);
  fpr = fopfile(datafile1, "r");
  read_specfile(datafile1, per, sa1, np, sa_field, respect_format);
  fgets(string, 512, fpr);
  fgets(string, 512, fpr);
  fgets(string, 512, fpr);
  fgets(string, 512, fpr);
  sscanf(string, "%d", &np);
  per = (float *)check_malloc(np * sizeof(float));
  sa1 = (float *)check_malloc(np * sizeof(float));
  sa2 = (float *)check_malloc(np * sizeof(float));
  res1 = (float *)check_malloc(np * sizeof(float));
  res2 = (float *)check_malloc(np * sizeof(float));
  avgr = (float *)check_malloc(np * sizeof(float));
  for (i = 0; i < np; i++) {
    fgets(string, 512, fpr);
    sscanf(string, "%f %f %f %f %f %f %f %f", &v[0], &v[1], &v[2], &v[3], &v[4],
           &v[5], &v[6], &v[7]);
    per[i] = v[1];
    sa1[i] = v[sa_field - 1];
  }
  fclose(fpr);
  fpr = fopfile(datafile2, "r");
  fgets(string, 512, fpr);
  fgets(string, 512, fpr);
  fgets(string, 512, fpr);
  fgets(string, 512, fpr);
  sscanf(string, "%d", &np2);
  if (np2 != np) {
    fprintf(stderr, "No. periods not equal, exiting...\n");
    exit(-1);
  }
  for (i = 0; i < np; i++) {
    fgets(string, 512, fpr);
    sscanf(string, "%f %f %f %f %f %f %f %f", &v[0], &v[1], &v[2], &v[3], &v[4],
           &v[5], &v[6], &v[7]);
    sa2[i] = v[sa_field - 1];
  }
  fclose(fpr);
  if (simfile1[0] == '\0' || simfile2[0] == '\0') {
    for (i = 0; i < np; i++) {
      res1[i] = sa1[i];
      res2[i] = sa2[i];
      avgr[i] = sqrt(res1[i] * res2[i]);
    }
  } else {
    fpr = fopfile(simfile1, "r");
    fgets(string, 512, fpr);
    fgets(string, 512, fpr);
    fgets(string, 512, fpr);
    fgets(string, 512, fpr);
    sscanf(string, "%d", &np2);
    if (np2 != np) {
      fprintf(stderr, "No. periods not equal, exiting...\n");
      exit(-1);
    }
    for (i = 0; i < np; i++) {
      fgets(string, 512, fpr);
      sscanf(string, "%f %f %f %f %f %f %f %f", &v[0], &v[1], &v[2], &v[3],
             &v[4], &v[5], &v[6], &v[7]);
      res1[i] = -99;
      if (v[sa_field - 1] != 0.0)
        res1[i] = log(sa1[i] / v[sa_field - 1]);
    }
    fclose(fpr);
    fpr = fopfile(simfile2, "r");
    fgets(string, 512, fpr);
    fgets(string, 512, fpr);
    fgets(string, 512, fpr);
    fgets(string, 512, fpr);
    sscanf(string, "%d", &np2);
    if (np2 != np) {
      fprintf(stderr, "No. periods not equal, exiting...\n");
      exit(-1);
    }
    for (i = 0; i < np; i++) {
      fgets(string, 512, fpr);
      sscanf(string, "%f %f %f %f %f %f %f %f", &v[0], &v[1], &v[2], &v[3],
             &v[4], &v[5], &v[6], &v[7]);
      res2[i] = -99;
      if (v[sa_field - 1] != 0.0)
        res2[i] = log(sa2[i] / v[sa_field - 1]);
      avgr[i] = 0.5 * (res1[i] + res2[i]);
    }
    fclose(fpr);
  }
  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", pga1);
  if (pgv1 >= 0.0)
    fprintf(stdout, "\t%.5e", pgv1);
  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", pga2);
  if (pgv2 >= 0.0)
    fprintf(stdout, "\t%.5e", pgv2);
  fprintf(stdout, "\n");
  fprintf(stdout, "%s", statinfo);
  fprintf(stdout, "\t%s", "avgh");
  for (i = 0; i < np; i++)
    fprintf(stdout, "\t%.5e", avgr[i]);
  if (pga1 >= 0.0)
    fprintf(stdout, "\t%.5e", sqrt(pga1 * pga2));
  if (pgv1 >= 0.0)
    fprintf(stdout, "\t%.5e", sqrt(pgv1 * pgv2));
  fprintf(stdout, "\n");
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x8c8,%rsp
movl   $0x0,-0x2c(%rbp)
mov    %edi,-0x30(%rbp)
mov    %rsi,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movl   $0x6,-0x574(%rbp)
movl   $0x0,-0x578(%rbp)
movl   $0x1,-0x57c(%rbp)
movss  0x1db2(%rip),%xmm0
movss  %xmm0,-0x884(%rbp)
ff
movss  0x1da2(%rip),%xmm0
movss  %xmm0,-0x888(%rbp)
ff
movss  0x1d92(%rip),%xmm0
movss  %xmm0,-0x88c(%rbp)
ff
movss  0x1d82(%rip),%xmm0
movss  %xmm0,-0x890(%rbp)
ff
movb   $0x0,-0x700(%rbp)
movb   $0x0,-0x780(%rbp)
mov    -0x30(%rbp),%edi
mov    -0x38(%rbp),%rsi
call   1030 <setpar@plt>
lea    -0x600(%rbp),%rdx
lea    0x1d6a(%rip),%rdi
lea    0x1e7c(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x680(%rbp),%rdx
lea    0x1d58(%rip),%rdi
lea    0x1e60(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x700(%rbp),%rdx
lea    0x1d46(%rip),%rdi
lea    0x1e44(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x780(%rbp),%rdx
lea    0x1d33(%rip),%rdi
lea    0x1e28(%rip),%rsi
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    -0x800(%rbp),%rdx
lea    0x1d20(%rip),%rdi
lea    0x1e0c(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x880(%rbp),%rdx
lea    0x1d0a(%rip),%rdi
lea    0x1df0(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x4c0(%rbp),%rdx
lea    0x1cf4(%rip),%rdi
lea    0x1dd4(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x4d0(%rbp),%rdx
lea    0x1cdf(%rip),%rdi
lea    0x1db8(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x4e0(%rbp),%rdx
lea    0x1cc7(%rip),%rdi
lea    0x1d9c(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x4f0(%rbp),%rdx
lea    0x1cb0(%rip),%rdi
lea    0x1d80(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x500(%rbp),%rdx
lea    0x1c98(%rip),%rdi
lea    0x1d64(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x510(%rbp),%rdx
lea    0x1c80(%rip),%rdi
lea    0x1d48(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x520(%rbp),%rdx
lea    0x1c6a(%rip),%rdi
lea    0x1d2c(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x530(%rbp),%rdx
lea    0x1c53(%rip),%rdi
lea    0x1d10(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x540(%rbp),%rdx
lea    0x1c3a(%rip),%rdi
lea    0x1cf4(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    -0x550(%rbp),%rdx
lea    0x1c23(%rip),%rdi
lea    0x1cd8(%rip),%rsi
mov    $0x0,%al
call   1040 <mstpar@plt>
lea    0x1c13(%rip),%rdi
lea    0x1c79(%rip),%rsi
lea    -0xa0(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1bfb(%rip),%rdi
lea    0x1c5d(%rip),%rsi
lea    -0xa4(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1be3(%rip),%rdi
lea    0x1c29(%rip),%rsi
lea    -0x578(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1bd4(%rip),%rdi
lea    0x1c0d(%rip),%rsi
lea    -0x574(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1bc1(%rip),%rdi
lea    0x1c09(%rip),%rsi
lea    -0x884(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1baa(%rip),%rdi
lea    0x1bed(%rip),%rsi
lea    -0x888(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1b93(%rip),%rdi
lea    0x1bd1(%rip),%rsi
lea    -0x88c(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1b7c(%rip),%rdi
lea    0x1bb5(%rip),%rsi
lea    -0x890(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
lea    0x1b65(%rip),%rdi
lea    0x1b81(%rip),%rsi
lea    -0x57c(%rbp),%rdx
mov    $0x0,%al
call   10b0 <getpar@plt>
cmpl   $0x0,-0x57c(%rbp)
jne    1585 <main+0x395>
lea    0x1b4b(%rip),%rdi
lea    0x1b58(%rip),%rsi
lea    -0x9c(%rbp),%rdx
mov    $0x0,%al
call   1040 <mstpar@plt>
mov    $0x0,%al
call   10c0 <endpar@plt>
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15d7 <main+0x3e7>
lea    -0x560(%rbp),%rdi
movss  -0xa4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1a48(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x1af3(%rip),%rsi
mov    $0x1,%al
call   10f0 <sprintf@plt>
jmp    15ec <main+0x3fc>
lea    -0x560(%rbp),%rdi
lea    0x1ade(%rip),%rsi
mov    $0x0,%al
call   10f0 <sprintf@plt>
movss  -0xa0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1637 <main+0x447>
lea    -0x570(%rbp),%rdi
movss  -0xa0(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x19e8(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x1a93(%rip),%rsi
mov    $0x1,%al
call   10f0 <sprintf@plt>
jmp    164c <main+0x45c>
lea    -0x570(%rbp),%rdi
lea    0x1a7f(%rip),%rsi
mov    $0x0,%al
call   10f0 <sprintf@plt>
lea    -0x2b0(%rbp),%rdi
lea    -0x4c0(%rbp),%rdx
lea    -0x4d0(%rbp),%rcx
lea    -0x4e0(%rbp),%r8
lea    -0x4f0(%rbp),%r9
lea    -0x500(%rbp),%r13
lea    -0x510(%rbp),%r12
lea    -0x520(%rbp),%r15
lea    -0x530(%rbp),%r14
lea    -0x540(%rbp),%rbx
lea    -0x550(%rbp),%r11
lea    -0x560(%rbp),%r10
lea    -0x570(%rbp),%rax
lea    0x1a61(%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   10f0 <sprintf@plt>
lea    -0x600(%rbp),%rdi
lea    0x19a3(%rip),%rsi
mov    $0x0,%al
call   1110 <fopfile@plt>
mov    %rax,-0x40(%rbp)
lea    -0x600(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x9c(%rbp),%ecx
mov    -0x574(%rbp),%r8d
mov    -0x57c(%rbp),%r9d
call   1060 <read_specfile@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
lea    0x194f(%rip),%rsi
lea    -0x9c(%rbp),%rdx
mov    $0x0,%al
call   10a0 <sscanf@plt>
movslq -0x9c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x9c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x9c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x9c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x9c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x9c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <check_malloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    190e <main+0x71e>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
lea    -0x90(%rbp),%rdx
lea    -0x90(%rbp),%rcx
add    $0x4,%rcx
lea    -0x90(%rbp),%r8
add    $0x8,%r8
lea    -0x90(%rbp),%r9
add    $0xc,%r9
lea    -0x90(%rbp),%rbx
add    $0x10,%rbx
lea    -0x90(%rbp),%r11
add    $0x14,%r11
lea    -0x90(%rbp),%r10
add    $0x18,%r10
lea    -0x90(%rbp),%rax
add    $0x1c,%rax
lea    0x182d(%rip),%rsi
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x0,%al
call   10a0 <sscanf@plt>
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x574(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    181b <main+0x62b>
mov    -0x40(%rbp),%rdi
call   1050 <fclose@plt>
lea    -0x680(%rbp),%rdi
lea    0x1768(%rip),%rsi
mov    $0x0,%al
call   1110 <fopfile@plt>
mov    %rax,-0x40(%rbp)
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
lea    0x173c(%rip),%rsi
lea    -0x98(%rbp),%rdx
mov    $0x0,%al
call   10a0 <sscanf@plt>
mov    -0x98(%rbp),%eax
cmp    -0x9c(%rbp),%eax
je     19d3 <main+0x7e3>
mov    0x3627(%rip),%rax
mov    (%rax),%edi
lea    0x1727(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    $0xffffffff,%edi
call   1100 <exit@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1ab8 <main+0x8c8>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
lea    -0x90(%rbp),%rdx
lea    -0x90(%rbp),%rcx
add    $0x4,%rcx
lea    -0x90(%rbp),%r8
add    $0x8,%r8
lea    -0x90(%rbp),%r9
add    $0xc,%r9
lea    -0x90(%rbp),%rbx
add    $0x10,%rbx
lea    -0x90(%rbp),%r11
add    $0x14,%r11
lea    -0x90(%rbp),%r10
add    $0x18,%r10
lea    -0x90(%rbp),%rax
add    $0x1c,%rax
lea    0x166b(%rip),%rsi
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x0,%al
call   10a0 <sscanf@plt>
mov    -0x574(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
mov    -0x58(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    19dd <main+0x7ed>
mov    -0x40(%rbp),%rdi
call   1050 <fclose@plt>
movsbl -0x700(%rbp),%eax
cmp    $0x0,%eax
je     1ae1 <main+0x8f1>
movsbl -0x780(%rbp),%eax
cmp    $0x0,%eax
jne    1b8f <main+0x99f>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1b8a <main+0x99a>
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
call   10e0 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1aeb <main+0x8fb>
jmp    1fe6 <main+0xdf6>
lea    -0x700(%rbp),%rdi
lea    0x14f0(%rip),%rsi
mov    $0x0,%al
call   1110 <fopfile@plt>
mov    %rax,-0x40(%rbp)
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
lea    0x14c4(%rip),%rsi
lea    -0x98(%rbp),%rdx
mov    $0x0,%al
call   10a0 <sscanf@plt>
mov    -0x98(%rbp),%eax
cmp    -0x9c(%rbp),%eax
je     1c4b <main+0xa5b>
mov    0x33af(%rip),%rax
mov    (%rax),%edi
lea    0x14af(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    $0xffffffff,%edi
call   1100 <exit@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1d92 <main+0xba2>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
lea    -0x90(%rbp),%rdx
lea    -0x90(%rbp),%rcx
add    $0x4,%rcx
lea    -0x90(%rbp),%r8
add    $0x8,%r8
lea    -0x90(%rbp),%r9
add    $0xc,%r9
lea    -0x90(%rbp),%rbx
add    $0x10,%rbx
lea    -0x90(%rbp),%r11
add    $0x14,%r11
lea    -0x90(%rbp),%r10
add    $0x18,%r10
lea    -0x90(%rbp),%rax
add    $0x1c,%rax
lea    0x13f3(%rip),%rsi
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x0,%al
call   10a0 <sscanf@plt>
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  0x12f9(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x574(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1d40 <main+0xb50>
jp     1d40 <main+0xb50>
jmp    1d79 <main+0xb89>
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x574(%rbp),%eax
sub    $0x1,%eax
cltq
divss  -0x90(%rbp,%rax,4),%xmm0
ff ff
call   10d0 <log@plt>
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1d7e <main+0xb8e>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1c55 <main+0xa65>
mov    -0x40(%rbp),%rdi
call   1050 <fclose@plt>
lea    -0x780(%rbp),%rdi
lea    0x12e4(%rip),%rsi
mov    $0x0,%al
call   1110 <fopfile@plt>
mov    %rax,-0x40(%rbp)
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
lea    0x12b8(%rip),%rsi
lea    -0x98(%rbp),%rdx
mov    $0x0,%al
call   10a0 <sscanf@plt>
mov    -0x98(%rbp),%eax
cmp    -0x9c(%rbp),%eax
je     1e57 <main+0xc67>
mov    0x31a3(%rip),%rax
mov    (%rax),%edi
lea    0x12a3(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    $0xffffffff,%edi
call   1100 <exit@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    1fdd <main+0xded>
lea    -0x4b0(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    $0x200,%esi
call   1070 <fgets@plt>
lea    -0x4b0(%rbp),%rdi
lea    -0x90(%rbp),%rdx
lea    -0x90(%rbp),%rcx
add    $0x4,%rcx
lea    -0x90(%rbp),%r8
add    $0x8,%r8
lea    -0x90(%rbp),%r9
add    $0xc,%r9
lea    -0x90(%rbp),%rbx
add    $0x10,%rbx
lea    -0x90(%rbp),%r11
add    $0x14,%r11
lea    -0x90(%rbp),%r10
add    $0x18,%r10
lea    -0x90(%rbp),%rax
add    $0x1c,%rax
lea    0x11e7(%rip),%rsi
mov    %rbx,(%rsp)
mov    %r11,0x8(%rsp)
mov    %r10,0x10(%rsp)
mov    %rax,0x18(%rsp)
mov    $0x0,%al
call   10a0 <sscanf@plt>
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  0x10ed(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x574(%rbp),%eax
sub    $0x1,%eax
cltq
movss  -0x90(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1f4c <main+0xd5c>
jp     1f4c <main+0xd5c>
jmp    1f85 <main+0xd95>
mov    -0x58(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x574(%rbp),%eax
sub    $0x1,%eax
cltq
divss  -0x90(%rbp,%rax,4),%xmm0
ff ff
call   10d0 <log@plt>
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x105f(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1e61 <main+0xc71>
mov    -0x40(%rbp),%rdi
call   1050 <fclose@plt>
cmpl   $0x0,-0x578(%rbp)
je     218d <main+0xf9d>
mov    0x2fde(%rip),%rax
mov    (%rax),%edi
lea    0x1109(%rip),%rsi
lea    0x1129(%rip),%rdx
lea    0x1125(%rip),%rcx
lea    0x103d(%rip),%r8
lea    0x103b(%rip),%r9
lea    0x1038(%rip),%rax
mov    %rax,-0x8a0(%rbp)
lea    0x1106(%rip),%r13
lea    0x110b(%rip),%r12
lea    0x1109(%rip),%r15
lea    0x110d(%rip),%r14
lea    0x110b(%rip),%rbx
lea    0x1109(%rip),%r11
lea    0x1108(%rip),%r10
lea    0x1107(%rip),%rax
mov    %rax,-0x898(%rbp)
mov    -0x8a0(%rbp),%rax
mov    %rax,(%rsp)
mov    -0x898(%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,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    2108 <main+0xf18>
mov    0x2f08(%rip),%rax
mov    (%rax),%edi
mov    -0x48(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x1084(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    20b7 <main+0xec7>
movss  -0x884(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     213f <main+0xf4f>
mov    0x2eb0(%rip),%rax
mov    (%rax),%edi
lea    0xffe(%rip),%rsi
lea    0x103f(%rip),%rdx
mov    $0x0,%al
call   1080 <fprintf@plt>
movss  -0x88c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2176 <main+0xf86>
mov    0x2e79(%rip),%rax
mov    (%rax),%edi
lea    0xfc7(%rip),%rsi
lea    0x100c(%rip),%rdx
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2e5b(%rip),%rax
mov    (%rax),%edi
lea    0xf84(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2e44(%rip),%rax
mov    (%rax),%edi
lea    -0x2b0(%rbp),%rdx
lea    0xf8c(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2e26(%rip),%rax
mov    (%rax),%edi
lea    -0x800(%rbp),%rdx
lea    0xf6d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    2224 <main+0x1034>
mov    0x2dec(%rip),%rax
mov    (%rax),%edi
mov    -0x60(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xf68(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    21d3 <main+0xfe3>
movss  -0x884(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2260 <main+0x1070>
mov    0x2d94(%rip),%rax
mov    (%rax),%edi
movss  -0x884(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xf18(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
movss  -0x88c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     229c <main+0x10ac>
mov    0x2d58(%rip),%rax
mov    (%rax),%edi
movss  -0x88c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xedc(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    0x2d35(%rip),%rax
mov    (%rax),%edi
lea    0xe5e(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2d1e(%rip),%rax
mov    (%rax),%edi
lea    -0x2b0(%rbp),%rdx
lea    0xe66(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2d00(%rip),%rax
mov    (%rax),%edi
lea    -0x880(%rbp),%rdx
lea    0xe47(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    234a <main+0x115a>
mov    0x2cc6(%rip),%rax
mov    (%rax),%edi
mov    -0x68(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe42(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    22f9 <main+0x1109>
movss  -0x888(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2386 <main+0x1196>
mov    0x2c6e(%rip),%rax
mov    (%rax),%edi
movss  -0x888(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xdf2(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
movss  -0x890(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     23c2 <main+0x11d2>
mov    0x2c32(%rip),%rax
mov    (%rax),%edi
movss  -0x890(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
lea    0xdb6(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    0x2c0f(%rip),%rax
mov    (%rax),%edi
lea    0xd38(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2bf8(%rip),%rax
mov    (%rax),%edi
lea    -0x2b0(%rbp),%rdx
lea    0xd40(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x2bda(%rip),%rax
mov    (%rax),%edi
lea    0xd28(%rip),%rsi
lea    0xd71(%rip),%rdx
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    2470 <main+0x1280>
mov    0x2ba0(%rip),%rax
mov    (%rax),%edi
mov    -0x70(%rbp),%rax
movslq -0x94(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd1c(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    241f <main+0x122f>
movss  -0x884(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     24c1 <main+0x12d1>
mov    0x2b48(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x8a4(%rbp)
movss  -0x884(%rbp),%xmm0
ff
mulss  -0x888(%rbp),%xmm0
ff
call   10e0 <sqrt@plt>
mov    -0x8a4(%rbp),%edi
lea    0xcb7(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
movss  -0x88c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     2512 <main+0x1322>
mov    0x2af7(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x8a8(%rbp)
movss  -0x88c(%rbp),%xmm0
ff
mulss  -0x890(%rbp),%xmm0
ff
call   10e0 <sqrt@plt>
mov    -0x8a8(%rbp),%edi
lea    0xc66(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    0x2abf(%rip),%rax
mov    (%rax),%edi
lea    0xbe8(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x2c(%rbp),%eax
add    $0x8c8,%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    $0x868,%rsp
movl   $0x0,0x64(%rsp)
movl   $0x0,0x60(%rsp)
movl   $0x6,0x10(%rsp)
movl   $0x0,0x5c(%rsp)
movl   $0x1,0x4c(%rsp)
movl   $0xc479f99a,0x1c(%rsp)
c4
movl   $0xc479f99a,0x48(%rsp)
c4
movl   $0xc479f99a,0x18(%rsp)
c4
movl   $0xc479f99a,0x44(%rsp)
c4
movb   $0x0,0x1e0(%rsp)
movb   $0x0,0x160(%rsp)
call   1030 <setpar@plt>
lea    0x1daf(%rip),%rdi
lea    0x1ec1(%rip),%r14
lea    0x3e0(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1d99(%rip),%rdi
lea    0x360(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1d8a(%rip),%rdi
lea    0x1e0(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1d7a(%rip),%rdi
lea    0x160(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1d6a(%rip),%rdi
lea    0x2e0(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1d57(%rip),%rdi
lea    0x260(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1d44(%rip),%rdi
lea    0x120(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1d32(%rip),%rdi
lea    0x110(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1d1d(%rip),%rdi
lea    0x100(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1d09(%rip),%rdi
lea    0xf0(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1cf4(%rip),%rdi
lea    0xe0(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1cdf(%rip),%rdi
lea    0xd0(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1ccc(%rip),%rdi
lea    0xc0(%rsp),%rdx
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1cb8(%rip),%rdi
lea    0x150(%rsp),%r13
mov    %r14,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1c9f(%rip),%rdi
lea    0x140(%rsp),%r15
mov    %r14,%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1c88(%rip),%rdi
lea    0x130(%rsp),%r12
mov    %r14,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1040 <mstpar@plt>
lea    0x1c71(%rip),%rdi
lea    0x1cd7(%rip),%rbx
lea    0x64(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c58(%rip),%rdi
lea    0x60(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c46(%rip),%rdi
lea    0x1c8c(%rip),%rbp
lea    0x5c(%rsp),%rdx
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c36(%rip),%rdi
lea    0x10(%rsp),%rdx
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c29(%rip),%rdi
lea    0x1c(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c18(%rip),%rdi
lea    0x48(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1c07(%rip),%rdi
lea    0x18(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1bf6(%rip),%rdi
lea    0x44(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
lea    0x1be5(%rip),%rdi
lea    0x4c(%rsp),%rdx
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <getpar@plt>
cmpl   $0x0,0x4c(%rsp)
jne    14f3 <main+0x303>
lea    0x1bd7(%rip),%rdi
lea    0x1be4(%rip),%rsi
lea    0xc(%rsp),%rdx
xor    %eax,%eax
call   1040 <mstpar@plt>
xor    %eax,%eax
call   10c0 <endpar@plt>
movss  0x60(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1533 <main+0x343>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0x1ae9(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x1b98(%rip),%rsi
lea    0xa0(%rsp),%rdi
mov    $0x1,%al
call   10f0 <sprintf@plt>
jmp    1550 <main+0x360>
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    1589 <main+0x399>
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0x1a93(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0x1b42(%rip),%rsi
lea    0x90(%rsp),%rdi
mov    $0x1,%al
call   10f0 <sprintf@plt>
jmp    15a5 <main+0x3b5>
movabs $0x39392e3939393939,%rax
2e 39 39
mov    %rax,0x90(%rsp)
movw   $0x39,0x98(%rsp)
lea    0x90(%rsp),%rbp
lea    0xa0(%rsp),%rbx
lea    0x1b4f(%rip),%rsi
lea    0x660(%rsp),%rdi
lea    0x120(%rsp),%rdx
lea    0x110(%rsp),%rcx
lea    0x100(%rsp),%r8
lea    0xf0(%rsp),%r9
mov    $0x0,%eax
push   %rbp
push   %rbx
push   %r12
push   %r15
push   %r13
lea    0xe8(%rsp),%rbp
push   %rbp
lea    0x100(%rsp),%rbp
push   %rbp
lea    0x118(%rsp),%rbp
push   %rbp
call   10f0 <sprintf@plt>
add    $0x40,%rsp
lea    0x1a6d(%rip),%rsi
lea    0x3e0(%rsp),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1110 <fopfile@plt>
mov    %rax,%rbp
mov    0xc(%rsp),%ecx
mov    0x10(%rsp),%r8d
mov    0x4c(%rsp),%r9d
mov    %rbx,%rdi
call   1060 <read_specfile@plt>
lea    0x460(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rbp,0x88(%rsp)
mov    %rbp,%rdx
call   1070 <fgets@plt>
lea    0x1a2c(%rip),%rsi
lea    0xc(%rsp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   10a0 <sscanf@plt>
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,%r13
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,%r15
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,0x78(%rsp)
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,0x50(%rsp)
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,0x70(%rsp)
mov    0xc(%rsp),%edi
shl    $0x2,%edi
call   1090 <check_malloc@plt>
mov    %rax,0x68(%rsp)
cmpl   $0x0,0xc(%rsp)
jle    17b0 <main+0x5c0>
lea    0x460(%rsp),%r14
lea    0x20(%rsp),%r12
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %r14,%rdi
mov    $0x200,%esi
mov    0x88(%rsp),%rdx
call   1070 <fgets@plt>
mov    %r14,%rdi
lea    0x197e(%rip),%rsi
mov    %r12,%rdx
lea    0x24(%rsp),%rcx
lea    0x28(%rsp),%r8
lea    0x2c(%rsp),%r9
xor    %eax,%eax
lea    0x3c(%rsp),%rbp
push   %rbp
lea    0x40(%rsp),%rbp
push   %rbp
lea    0x44(%rsp),%rbp
push   %rbp
lea    0x48(%rsp),%rbp
push   %rbp
call   10a0 <sscanf@plt>
add    $0x20,%rsp
movss  0x24(%rsp),%xmm0
movss  %xmm0,0x0(%r13,%rbx,4)
movslq 0x10(%rsp),%rax
movss  0x1c(%rsp,%rax,4),%xmm0
movss  %xmm0,(%r15,%rbx,4)
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1730 <main+0x540>
mov    %r15,0x80(%rsp)
mov    %r13,0xb8(%rsp)
mov    0x88(%rsp),%rdi
call   1050 <fclose@plt>
lea    0x18b5(%rip),%rsi
lea    0x360(%rsp),%rdi
xor    %eax,%eax
call   1110 <fopfile@plt>
mov    %rax,%r12
lea    0x460(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rax,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %r12,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %r12,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %r12,%rdx
call   1070 <fgets@plt>
lea    0x1895(%rip),%rsi
lea    0x14(%rsp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   10a0 <sscanf@plt>
mov    0x14(%rsp),%eax
cmp    0xc(%rsp),%eax
jne    2002 <main+0xe12>
test   %eax,%eax
mov    0x78(%rsp),%r14
jle    18de <main+0x6ee>
lea    0x460(%rsp),%rbx
lea    0x20(%rsp),%r15
xor    %r13d,%r13d
nop
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %r12,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
lea    0x1843(%rip),%rsi
mov    %r15,%rdx
lea    0x24(%rsp),%rcx
lea    0x28(%rsp),%r8
lea    0x2c(%rsp),%r9
xor    %eax,%eax
lea    0x3c(%rsp),%rbp
push   %rbp
lea    0x40(%rsp),%rbp
push   %rbp
lea    0x44(%rsp),%rbp
push   %rbp
lea    0x48(%rsp),%rbp
push   %rbp
call   10a0 <sscanf@plt>
add    $0x20,%rsp
movslq 0x10(%rsp),%rax
movss  0x1c(%rsp,%rax,4),%xmm0
movss  %xmm0,(%r14,%r13,4)
add    $0x1,%r13
movslq 0xc(%rsp),%rax
cmp    %rax,%r13
jl     1870 <main+0x680>
mov    %r12,%rdi
call   1050 <fclose@plt>
cmpb   $0x0,0x1e0(%rsp)
mov    0x70(%rsp),%r12
mov    0x50(%rsp),%r13
je     1a53 <main+0x863>
cmpb   $0x0,0x160(%rsp)
je     1a53 <main+0x863>
lea    0x1776(%rip),%rsi
lea    0x1e0(%rsp),%rdi
xor    %eax,%eax
call   1110 <fopfile@plt>
mov    %rax,%rbp
lea    0x460(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rax,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
lea    0x1756(%rip),%rsi
lea    0x14(%rsp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   10a0 <sscanf@plt>
mov    0x14(%rsp),%eax
cmp    0xc(%rsp),%eax
jne    2002 <main+0xe12>
test   %eax,%eax
jle    1ac2 <main+0x8d2>
lea    0x460(%rsp),%r15
lea    0x20(%rsp),%r14
xor    %r12d,%r12d
mov    0x50(%rsp),%r13
jmp    19c2 <main+0x7d2>
add    $0x1,%r12
movslq 0xc(%rsp),%rax
cmp    %rax,%r12
jge    1ac2 <main+0x8d2>
mov    %r15,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
mov    %r15,%rdi
lea    0x16f1(%rip),%rsi
mov    %r14,%rdx
lea    0x24(%rsp),%rcx
lea    0x28(%rsp),%r8
lea    0x2c(%rsp),%r9
xor    %eax,%eax
lea    0x3c(%rsp),%rbx
push   %rbx
lea    0x40(%rsp),%rbx
push   %rbx
lea    0x44(%rsp),%rbx
push   %rbx
lea    0x48(%rsp),%rbx
push   %rbx
call   10a0 <sscanf@plt>
add    $0x20,%rsp
movl   $0xc2c60000,0x0(%r13,%r12,4)
c6 c2
movslq 0x10(%rsp),%rax
movss  0x1c(%rsp,%rax,4),%xmm1
ucomiss 0x15e4(%rip),%xmm1
jne    1a30 <main+0x840>
jnp    19b0 <main+0x7c0>
mov    0x80(%rsp),%rax
movss  (%rax,%r12,4),%xmm0
divss  %xmm1,%xmm0
call   10d0 <log@plt>
movss  %xmm0,0x0(%r13,%r12,4)
jmp    19b0 <main+0x7c0>
cmpl   $0x0,0xc(%rsp)
mov    0x68(%rsp),%r15
mov    0x78(%rsp),%r14
mov    0x80(%rsp),%rbp
jle    1c50 <main+0xa60>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,0x0(%r13,%rbx,4)
movss  (%r14,%rbx,4),%xmm0
movss  %xmm0,(%r12,%rbx,4)
mulss  0x0(%r13,%rbx,4),%xmm0
call   10e0 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r15,%rbx,4)
add    $0x1,%rbx
movslq 0xc(%rsp),%rax
cmp    %rax,%rbx
jl     1a80 <main+0x890>
jmp    1c50 <main+0xa60>
mov    %rbp,%rdi
call   1050 <fclose@plt>
lea    0x15b8(%rip),%rsi
lea    0x160(%rsp),%rdi
xor    %eax,%eax
call   1110 <fopfile@plt>
mov    %rax,%rbp
lea    0x460(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rax,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
lea    0x1598(%rip),%rsi
lea    0x14(%rsp),%rdx
mov    %rbx,%rdi
xor    %eax,%eax
call   10a0 <sscanf@plt>
mov    0x14(%rsp),%eax
cmp    0xc(%rsp),%eax
jne    2002 <main+0xe12>
test   %eax,%eax
jle    1c39 <main+0xa49>
lea    0x3c(%rsp),%r12
lea    0x460(%rsp),%r15
lea    0x20(%rsp),%r14
xor    %r13d,%r13d
jmp    1ba0 <main+0x9b0>
xchg   %ax,%ax
mov    0x50(%rsp),%rax
addss  (%rax,%r13,4),%xmm0
mulss  0x1489(%rip),%xmm0
mov    0x68(%rsp),%rax
movss  %xmm0,(%rax,%r13,4)
add    $0x1,%r13
movslq 0xc(%rsp),%rax
cmp    %rax,%r13
jge    1c39 <main+0xa49>
mov    %r15,%rdi
mov    $0x200,%esi
mov    %rbp,%rdx
call   1070 <fgets@plt>
mov    %r15,%rdi
lea    0x1513(%rip),%rsi
mov    %r14,%rdx
lea    0x24(%rsp),%rcx
lea    0x28(%rsp),%r8
lea    0x2c(%rsp),%r9
xor    %eax,%eax
push   %r12
lea    0x40(%rsp),%rbx
push   %rbx
lea    0x44(%rsp),%rbx
push   %rbx
lea    0x48(%rsp),%rbx
push   %rbx
call   10a0 <sscanf@plt>
add    $0x20,%rsp
mov    0x70(%rsp),%rbx
movl   $0xc2c60000,(%rbx,%r13,4)
c2
movslq 0x10(%rsp),%rax
movss  0x1c(%rsp,%rax,4),%xmm1
ucomiss 0x1406(%rip),%xmm1
movss  0x13f6(%rip),%xmm0
jne    1c1a <main+0xa2a>
jnp    1b70 <main+0x980>
mov    0x78(%rsp),%rax
movss  (%rax,%r13,4),%xmm0
divss  %xmm1,%xmm0
call   10d0 <log@plt>
movss  %xmm0,(%rbx,%r13,4)
jmp    1b70 <main+0x980>
mov    %rbp,%rdi
call   1050 <fclose@plt>
mov    0x68(%rsp),%r15
mov    0x70(%rsp),%r12
mov    0x50(%rsp),%r13
cmpl   $0x0,0x5c(%rsp)
je     1d90 <main+0xba0>
mov    0x3376(%rip),%r14
mov    (%r14),%edi
sub    $0x8,%rsp
lea    0x14f8(%rip),%rbp
lea    0x14eb(%rip),%rbx
lea    0x14de(%rip),%r10
lea    0x14d2(%rip),%r11
lea    0x14c6(%rip),%r15
lea    0x14b4(%rip),%r12
lea    0x14a8(%rip),%r13
lea    0x1467(%rip),%rsi
lea    0x1487(%rip),%rdx
lea    0x1483(%rip),%rcx
lea    0x139b(%rip),%r8
lea    0x1399(%rip),%r9
xor    %eax,%eax
push   %rbp
push   %rbx
push   %r10
push   %r11
push   %r15
push   %r12
push   %r13
lea    0x1464(%rip),%rbp
push   %rbp
lea    0x1380(%rip),%rbp
push   %rbp
call   1080 <fprintf@plt>
add    $0x50,%rsp
cmpl   $0x0,0xc(%rsp)
mov    0xb8(%rsp),%rbx
jle    1d24 <main+0xb34>
xor    %ebp,%ebp
lea    0x1471(%rip),%r15
nopl   0x0(%rax)
mov    (%r14),%edi
movss  (%rbx,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r15,%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
add    $0x1,%rbp
movslq 0xc(%rsp),%rax
cmp    %rax,%rbp
jl     1d00 <main+0xb10>
movss  0x1c(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1d4d <main+0xb5d>
mov    (%r14),%edi
lea    0x13ef(%rip),%rsi
lea    0x1430(%rip),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x18(%rsp),%xmm0
ucomiss %xmm1,%xmm0
mov    0x68(%rsp),%r15
mov    0x70(%rsp),%r12
mov    0x50(%rsp),%r13
jb     1d7f <main+0xb8f>
mov    (%r14),%edi
lea    0x13ba(%rip),%rsi
lea    0x13ff(%rip),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x137d(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    0x3241(%rip),%r14
mov    (%r14),%edi
lea    0x138b(%rip),%rsi
lea    0x660(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x1371(%rip),%rsi
lea    0x2e0(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
cmpl   $0x0,0xc(%rsp)
jle    1e06 <main+0xc16>
xor    %ebp,%ebp
lea    0x1394(%rip),%rbx
nopl   0x0(%rax)
mov    (%r14),%edi
movss  0x0(%r13,%rbp,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbx,%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
add    $0x1,%rbp
movslq 0xc(%rsp),%rax
cmp    %rax,%rbp
jl     1de0 <main+0xbf0>
movss  0x1c(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1e2c <main+0xc3c>
cvtss2sd %xmm0,%xmm0
mov    (%r14),%edi
lea    0x134b(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x18(%rsp),%xmm0
ucomiss %xmm1,%xmm0
jb     1e4c <main+0xc5c>
cvtss2sd %xmm0,%xmm0
mov    (%r14),%edi
lea    0x1328(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x12b0(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x12c5(%rip),%rsi
lea    0x660(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x12ab(%rip),%rsi
lea    0x260(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
cmpl   $0x0,0xc(%rsp)
jle    1ec5 <main+0xcd5>
xor    %ebp,%ebp
lea    0x12ce(%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 0xc(%rsp),%rax
cmp    %rax,%rbp
jl     1ea0 <main+0xcb0>
movss  0x48(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1eeb <main+0xcfb>
cvtss2sd %xmm0,%xmm0
mov    (%r14),%edi
lea    0x128c(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x44(%rsp),%xmm0
ucomiss %xmm1,%xmm0
jb     1f0b <main+0xd1b>
cvtss2sd %xmm0,%xmm0
mov    (%r14),%edi
lea    0x1269(%rip),%rsi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x11f1(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x1206(%rip),%rsi
lea    0x660(%rsp),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x11ec(%rip),%rsi
lea    0x1235(%rip),%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
cmpl   $0x0,0xc(%rsp)
jle    1f85 <main+0xd95>
xor    %ebp,%ebp
lea    0x1210(%rip),%rbx
nopl   (%rax)
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 0xc(%rsp),%rax
cmp    %rax,%rbp
jl     1f60 <main+0xd70>
movss  0x1c(%rsp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1fb4 <main+0xdc4>
mov    (%r14),%ebx
mulss  0x48(%rsp),%xmm0
call   10e0 <sqrt@plt>
lea    0x11c5(%rip),%rsi
mov    %ebx,%edi
mov    $0x1,%al
call   1080 <fprintf@plt>
xorps  %xmm1,%xmm1
movss  0x18(%rsp),%xmm0
ucomiss %xmm1,%xmm0
jb     1fdd <main+0xded>
mov    (%r14),%ebx
mulss  0x44(%rsp),%xmm0
call   10e0 <sqrt@plt>
lea    0x1199(%rip),%rsi
mov    %ebx,%edi
mov    $0x1,%al
call   1080 <fprintf@plt>
mov    (%r14),%edi
lea    0x111f(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
xor    %eax,%eax
add    $0x868,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2fd7(%rip),%rax
mov    (%rax),%edi
lea    0x10d3(%rip),%rsi
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    $0xffffffff,%edi
call   1100 <exit@plt>

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

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