#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 *, float, ...);
char *getflt(float *, char *);
int /*<<< orphan*/ getpar(char *, char *, float *);
int /*<<< orphan*/ mstpar(char *, char *, ...);
int /*<<< orphan*/ setpar(int, char **);
char *skipval(int, char *);
int /*<<< orphan*/ sprintf(char *, char *, char *);
int /*<<< orphan*/ sscanf(char *, char *, float *, float *, float *, float *,
                          float *, float *, char *);
int /*<<< orphan*/ *stderr;
scalar_t__ strcmp(char *, char *);
scalar_t__ strncmp(char *, char *, int);
int /*<<< orphan*/ uncert(int, int *, float *, float *, int, float *, float *,
                          float *, float *, float *, float *, float *);
int main(int ac, char **av) {
  FILE *fpr, *fpw, *fopfile();
  float *per, *resid, vs30, cdst, xcos, ycos, *tmin, *tmax;
  float *bias, *sigma, *sigma0, *cl90m, *cl90p;
  int nstat, nper, *nval, nstat_read, i;
  float min_cdst = -1e+15;
  float max_cdst = 1e+15;
  float min_vs30 = -1e+15;
  float max_vs30 = 1e+15;
  float min_xcos = -1e+15;
  float max_xcos = 1e+15;
  float min_ycos = -1e+15;
  float max_ycos = 1e+15;
  char residfile[256], fileroot[256], comp[16], rdcomp[16];
  char *sptr, string[2048];
  setpar(ac, av);
  mstpar("residfile", "s", residfile);
  mstpar("fileroot", "s", fileroot);
  mstpar("comp", "s", comp);
  mstpar("nstat", "d", &nstat);
  mstpar("nper", "d", &nper);
  getpar("min_cdst", "f", &min_cdst);
  getpar("max_cdst", "f", &max_cdst);
  getpar("min_vs30", "f", &min_vs30);
  getpar("max_vs30", "f", &max_vs30);
  getpar("min_xcos", "f", &min_xcos);
  getpar("max_xcos", "f", &max_xcos);
  getpar("min_ycos", "f", &min_ycos);
  getpar("max_ycos", "f", &max_ycos);
  endpar();
  nval = (int *)check_malloc(nper * sizeof(float));
  tmin = (float *)check_malloc(nstat * sizeof(float));
  tmax = (float *)check_malloc(nstat * sizeof(float));
  per = (float *)check_malloc(nper * sizeof(float));
  bias = (float *)check_malloc(nper * sizeof(float));
  sigma = (float *)check_malloc(nper * sizeof(float));
  sigma0 = (float *)check_malloc(nper * sizeof(float));
  cl90m = (float *)check_malloc(nper * sizeof(float));
  cl90p = (float *)check_malloc(nper * sizeof(float));
  resid = (float *)check_malloc(nstat * nper * sizeof(float));
  fpr = fopfile(residfile, "r");
  fgets(string, 2048, fpr);
  while (strncmp(string, "#", 1) == 0)
    fgets(string, 2048, fpr);
  sptr = skipval(13, string);
  for (i = 0; i < nper; i++) {
    sptr = getflt(&per[i], sptr);
    nval[i] = 0;
  }
  nstat_read = 0;
  while (fgets(string, 2048, fpr) != NULL) {
    sscanf(string, "%*s %*f %*s %*f %*f %*d %f %f %f %f %f %f %s", &vs30, &cdst,
           &xcos, &ycos, &tmin[nstat_read], &tmax[nstat_read], rdcomp);
    if ((vs30 >= min_vs30 && vs30 <= max_vs30) &&
        (cdst >= min_cdst && cdst <= max_cdst) &&
        (xcos >= min_xcos && xcos <= max_xcos) &&
        (ycos >= min_ycos && ycos <= max_ycos) && (strcmp(rdcomp, comp) == 0)) {
      sptr = skipval(13, string);
      for (i = 0; i < nper; i++)
        sptr = getflt(&resid[i + nstat_read * nper], sptr);
      nstat_read++;
    }
    if (nstat_read > nstat) {
      fprintf(stderr, "(nstat_read= %d) > (nstat= %d), exiting...\n",
              nstat_read, nstat);
      exit(-1);
    }
  }
  fclose(fpr);
  fprintf(stderr, "nstat_read= %d\n", nstat_read);
  uncert(nstat_read, nval, tmin, tmax, nper, per, resid, bias, sigma, sigma0,
         cl90m, cl90p);
  sprintf(string, "%s.bias", fileroot);
  fpw = fopfile(string, "w");
  for (i = 0; i < nper; i++)
    fprintf(fpw, "%13.5e %13.5e\n", per[i], bias[i]);
  fclose(fpw);
  sprintf(string, "%s.sigma", fileroot);
  fpw = fopfile(string, "w");
  for (i = 0; i < nper; i++)
    fprintf(fpw, "%13.5e %13.5e\n", per[i], sigma[i]);
  fclose(fpw);
  sprintf(string, "%s.sigma0", fileroot);
  fpw = fopfile(string, "w");
  for (i = 0; i < nper; i++)
    fprintf(fpw, "%13.5e %13.5e\n", per[i], sigma0[i]);
  fclose(fpw);
  sprintf(string, "%s.m90", fileroot);
  fpw = fopfile(string, "w");
  for (i = 0; i < nper; i++)
    fprintf(fpw, "%13.5e %13.5e\n", per[i], cl90m[i]);
  fclose(fpw);
  sprintf(string, "%s.p90", fileroot);
  fpw = fopfile(string, "w");
  for (i = 0; i < nper; i++)
    fprintf(fpw, "%13.5e %13.5e\n", per[i], cl90p[i]);
  fclose(fpw);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0xb18,%rsp
movl   $0x0,-0x1c(%rbp)
mov    %edi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
movss  0xdce(%rip),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  0xdba(%rip),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  0xdae(%rip),%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
movss  0xd9a(%rip),%xmm0
movss  %xmm0,-0xb8(%rbp)
ff
movss  0xd8e(%rip),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
movss  0xd7a(%rip),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  0xd6e(%rip),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
movss  0xd5a(%rip),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
mov    -0x20(%rbp),%edi
mov    -0x28(%rbp),%rsi
call   1040 <setpar@plt>
lea    -0x1d0(%rbp),%rdx
lea    0xd40(%rip),%rdi
lea    0xdd5(%rip),%rsi
mov    $0x0,%al
call   1050 <mstpar@plt>
lea    -0x2d0(%rbp),%rdx
lea    0xd2e(%rip),%rdi
lea    0xdb9(%rip),%rsi
mov    $0x0,%al
call   1050 <mstpar@plt>
lea    -0x2e0(%rbp),%rdx
lea    0xd1b(%rip),%rdi
lea    0xd9d(%rip),%rsi
mov    $0x0,%al
call   1050 <mstpar@plt>
lea    0xd0b(%rip),%rdi
lea    0xd0a(%rip),%rsi
lea    -0x94(%rbp),%rdx
mov    $0x0,%al
call   1050 <mstpar@plt>
lea    0xcf7(%rip),%rdi
lea    0xcee(%rip),%rsi
lea    -0x98(%rbp),%rdx
mov    $0x0,%al
call   1050 <mstpar@plt>
lea    0xce0(%rip),%rdi
lea    0xce2(%rip),%rsi
lea    -0xac(%rbp),%rdx
call   10e0 <getpar@plt>
lea    0xcd1(%rip),%rdi
lea    0xcc8(%rip),%rsi
lea    -0xb0(%rbp),%rdx
call   10e0 <getpar@plt>
lea    0xcc0(%rip),%rdi
lea    0xcae(%rip),%rsi
lea    -0xb4(%rbp),%rdx
call   10e0 <getpar@plt>
lea    0xcaf(%rip),%rdi
lea    0xc94(%rip),%rsi
lea    -0xb8(%rbp),%rdx
call   10e0 <getpar@plt>
lea    0xc9e(%rip),%rdi
lea    0xc7a(%rip),%rsi
lea    -0xbc(%rbp),%rdx
call   10e0 <getpar@plt>
lea    0xc8d(%rip),%rdi
lea    0xc60(%rip),%rsi
lea    -0xc0(%rbp),%rdx
call   10e0 <getpar@plt>
lea    0xc7c(%rip),%rdi
lea    0xc46(%rip),%rsi
lea    -0xc4(%rbp),%rdx
call   10e0 <getpar@plt>
lea    0xc6b(%rip),%rdi
lea    0xc2c(%rip),%rsi
lea    -0xc8(%rbp),%rdx
call   10e0 <getpar@plt>
mov    $0x0,%al
call   1100 <endpar@plt>
movslq -0x98(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <check_malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0x94(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <check_malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x94(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <check_malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x98(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <check_malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0x98(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <check_malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0x98(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <check_malloc@plt>
mov    %rax,-0x78(%rbp)
movslq -0x98(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <check_malloc@plt>
mov    %rax,-0x80(%rbp)
movslq -0x98(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <check_malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x98(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <check_malloc@plt>
mov    %rax,-0x90(%rbp)
mov    -0x94(%rbp),%eax
imul   -0x98(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   10c0 <check_malloc@plt>
mov    %rax,-0x48(%rbp)
lea    -0x1d0(%rbp),%rdi
lea    0xb13(%rip),%rsi
mov    $0x0,%al
call   1130 <fopfile@plt>
mov    %rax,-0x30(%rbp)
lea    -0xb00(%rbp),%rdi
mov    -0x30(%rbp),%rdx
mov    $0x800,%esi
call   1070 <fgets@plt>
lea    -0xb00(%rbp),%rdi
lea    0xb31(%rip),%rsi
mov    $0x1,%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1574 <main+0x364>
lea    -0xb00(%rbp),%rdi
mov    -0x30(%rbp),%rdx
mov    $0x800,%esi
call   1070 <fgets@plt>
jmp    1538 <main+0x328>
lea    -0xb00(%rbp),%rsi
mov    $0xd,%edi
call   10f0 <skipval@plt>
mov    %rax,-0x2f8(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    15f6 <main+0x3e6>
mov    -0x40(%rbp),%rdi
movslq -0xa8(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x2f8(%rbp),%rsi
call   10b0 <getflt@plt>
mov    %rax,-0x2f8(%rbp)
mov    -0xa0(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1596 <main+0x386>
movl   $0x0,-0xa4(%rbp)
lea    -0xb00(%rbp),%rdi
mov    -0x30(%rbp),%rdx
mov    $0x800,%esi
call   1070 <fgets@plt>
cmp    $0x0,%rax
je     180b <main+0x5fb>
lea    -0xb00(%rbp),%rdi
mov    -0x60(%rbp),%r11
movslq -0xa4(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r11
mov    -0x68(%rbp),%r10
movslq -0xa4(%rbp),%rax
shl    $0x2,%rax
add    %rax,%r10
lea    -0x2f0(%rbp),%rax
lea    0xa21(%rip),%rsi
lea    -0x4c(%rbp),%rdx
lea    -0x50(%rbp),%rcx
lea    -0x54(%rbp),%r8
lea    -0x58(%rbp),%r9
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   10d0 <sscanf@plt>
movss  -0x4c(%rbp),%xmm0
ucomiss -0xb4(%rbp),%xmm0
jb     17c4 <main+0x5b4>
movss  -0x4c(%rbp),%xmm1
movss  -0xb8(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jb     17c4 <main+0x5b4>
movss  -0x50(%rbp),%xmm0
ucomiss -0xac(%rbp),%xmm0
jb     17c4 <main+0x5b4>
movss  -0x50(%rbp),%xmm1
movss  -0xb0(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jb     17c4 <main+0x5b4>
movss  -0x54(%rbp),%xmm0
ucomiss -0xbc(%rbp),%xmm0
jb     17c4 <main+0x5b4>
movss  -0x54(%rbp),%xmm1
movss  -0xc0(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jb     17c4 <main+0x5b4>
movss  -0x58(%rbp),%xmm0
ucomiss -0xc4(%rbp),%xmm0
jb     17c4 <main+0x5b4>
movss  -0x58(%rbp),%xmm1
movss  -0xc8(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jb     17c4 <main+0x5b4>
lea    -0x2f0(%rbp),%rdi
lea    -0x2e0(%rbp),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    17c4 <main+0x5b4>
lea    -0xb00(%rbp),%rsi
mov    $0xd,%edi
call   10f0 <skipval@plt>
mov    %rax,-0x2f8(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    17b5 <main+0x5a5>
mov    -0x48(%rbp),%rdi
mov    -0xa8(%rbp),%eax
mov    -0xa4(%rbp),%ecx
imul   -0x98(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x2f8(%rbp),%rsi
call   10b0 <getflt@plt>
mov    %rax,-0x2f8(%rbp)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    175a <main+0x54a>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x94(%rbp),%eax
jle    1806 <main+0x5f6>
mov    0x2803(%rip),%rax
mov    (%rax),%rdi
cvtsi2ssl -0xa4(%rbp),%xmm0
ff
mov    -0x94(%rbp),%edx
lea    0x8b1(%rip),%rsi
mov    $0x1,%al
call   10a0 <fprintf@plt>
mov    $0xffffffff,%edi
call   1120 <exit@plt>
jmp    1600 <main+0x3f0>
mov    -0x30(%rbp),%rdi
call   1060 <fclose@plt>
mov    0x27c5(%rip),%rax
mov    (%rax),%rdi
cvtsi2ssl -0xa4(%rbp),%xmm0
ff
lea    0x8a5(%rip),%rsi
mov    $0x1,%al
call   10a0 <fprintf@plt>
mov    -0xa4(%rbp),%edi
mov    -0xa0(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x68(%rbp),%rcx
mov    -0x98(%rbp),%r8d
mov    -0x40(%rbp),%r9
mov    -0x48(%rbp),%r15
mov    -0x70(%rbp),%r14
mov    -0x78(%rbp),%rbx
mov    -0x80(%rbp),%r11
mov    -0x88(%rbp),%r10
mov    -0x90(%rbp),%rax
mov    %r15,(%rsp)
mov    %r14,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1090 <uncert@plt>
lea    -0xb00(%rbp),%rdi
lea    -0x2d0(%rbp),%rdx
lea    0x839(%rip),%rsi
call   1110 <sprintf@plt>
lea    -0xb00(%rbp),%rdi
lea    0x82e(%rip),%rsi
mov    $0x0,%al
call   1130 <fopfile@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    192d <main+0x71d>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x7da(%rip),%rsi
mov    $0x2,%al
call   10a0 <fprintf@plt>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    18d1 <main+0x6c1>
mov    -0x38(%rbp),%rdi
call   1060 <fclose@plt>
lea    -0xb00(%rbp),%rdi
lea    -0x2d0(%rbp),%rdx
lea    0x7b0(%rip),%rsi
call   1110 <sprintf@plt>
lea    -0xb00(%rbp),%rdi
lea    0x78c(%rip),%rsi
mov    $0x0,%al
call   1130 <fopfile@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    19cf <main+0x7bf>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x738(%rip),%rsi
mov    $0x2,%al
call   10a0 <fprintf@plt>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1973 <main+0x763>
mov    -0x38(%rbp),%rdi
call   1060 <fclose@plt>
lea    -0xb00(%rbp),%rdi
lea    -0x2d0(%rbp),%rdx
lea    0x717(%rip),%rsi
call   1110 <sprintf@plt>
lea    -0xb00(%rbp),%rdi
lea    0x6ea(%rip),%rsi
mov    $0x0,%al
call   1130 <fopfile@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1a71 <main+0x861>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x696(%rip),%rsi
mov    $0x2,%al
call   10a0 <fprintf@plt>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1a15 <main+0x805>
mov    -0x38(%rbp),%rdi
call   1060 <fclose@plt>
lea    -0xb00(%rbp),%rdi
lea    -0x2d0(%rbp),%rdx
lea    0x67f(%rip),%rsi
call   1110 <sprintf@plt>
lea    -0xb00(%rbp),%rdi
lea    0x648(%rip),%rsi
mov    $0x0,%al
call   1130 <fopfile@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1b16 <main+0x906>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x88(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x5f1(%rip),%rsi
mov    $0x2,%al
call   10a0 <fprintf@plt>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1ab7 <main+0x8a7>
mov    -0x38(%rbp),%rdi
call   1060 <fclose@plt>
lea    -0xb00(%rbp),%rdi
lea    -0x2d0(%rbp),%rdx
lea    0x5e1(%rip),%rsi
call   1110 <sprintf@plt>
lea    -0xb00(%rbp),%rdi
lea    0x5a3(%rip),%rsi
mov    $0x0,%al
call   1130 <fopfile@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1bbb <main+0x9ab>
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x90(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0x54c(%rip),%rsi
mov    $0x2,%al
call   10a0 <fprintf@plt>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1b5c <main+0x94c>
mov    -0x38(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x1c(%rbp),%eax
add    $0xb18,%rsp
pop    %rbx
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    $0xaa8,%rsp
movl   $0xd8635fa9,0x24(%rsp)
d8
movl   $0x58635fa9,0x20(%rsp)
58
movl   $0xd8635fa9,0x1c(%rsp)
d8
movl   $0x58635fa9,0x18(%rsp)
58
movl   $0xd8635fa9,0x14(%rsp)
d8
movl   $0x58635fa9,0x10(%rsp)
58
movl   $0xd8635fa9,0xc(%rsp)
d8
movl   $0x58635fa9,0x8(%rsp)
58
call   1040 <setpar@plt>
lea    0xd93(%rip),%rdi
lea    0xe28(%rip),%rbx
lea    0x9a0(%rsp),%r13
mov    %rbx,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   1050 <mstpar@plt>
lea    0xd7a(%rip),%rdi
lea    0xa0(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <mstpar@plt>
lea    0xd6a(%rip),%rdi
lea    0x90(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <mstpar@plt>
lea    0xd56(%rip),%rdi
lea    0xd55(%rip),%rbx
lea    0x4(%rsp),%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <mstpar@plt>
lea    0xd41(%rip),%rdi
mov    %rsp,%rdx
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <mstpar@plt>
lea    0xd32(%rip),%rdi
lea    0xd34(%rip),%rbx
lea    0x24(%rsp),%rdx
mov    %rbx,%rsi
call   10e0 <getpar@plt>
lea    0xd22(%rip),%rdi
lea    0x20(%rsp),%rdx
mov    %rbx,%rsi
call   10e0 <getpar@plt>
lea    0xd17(%rip),%rdi
lea    0x1c(%rsp),%rdx
mov    %rbx,%rsi
call   10e0 <getpar@plt>
lea    0xd0c(%rip),%rdi
lea    0x18(%rsp),%rdx
mov    %rbx,%rsi
call   10e0 <getpar@plt>
lea    0xd01(%rip),%rdi
lea    0x14(%rsp),%rdx
mov    %rbx,%rsi
call   10e0 <getpar@plt>
lea    0xcf6(%rip),%rdi
lea    0x10(%rsp),%rdx
mov    %rbx,%rsi
call   10e0 <getpar@plt>
lea    0xceb(%rip),%rdi
lea    0xc(%rsp),%rdx
mov    %rbx,%rsi
call   10e0 <getpar@plt>
lea    0xce0(%rip),%rdi
lea    0x8(%rsp),%rdx
mov    %rbx,%rsi
call   10e0 <getpar@plt>
xor    %eax,%eax
call   1100 <endpar@plt>
mov    (%rsp),%edi
shl    $0x2,%edi
call   10c0 <check_malloc@plt>
mov    %rax,0x60(%rsp)
mov    0x4(%rsp),%edi
shl    $0x2,%edi
call   10c0 <check_malloc@plt>
mov    %rax,0x70(%rsp)
mov    0x4(%rsp),%edi
shl    $0x2,%edi
call   10c0 <check_malloc@plt>
mov    %rax,0x68(%rsp)
mov    (%rsp),%edi
shl    $0x2,%edi
call   10c0 <check_malloc@plt>
mov    %rax,%r12
mov    (%rsp),%edi
shl    $0x2,%edi
call   10c0 <check_malloc@plt>
mov    %rax,0x28(%rsp)
mov    (%rsp),%edi
shl    $0x2,%edi
call   10c0 <check_malloc@plt>
mov    %rax,0x78(%rsp)
mov    (%rsp),%edi
shl    $0x2,%edi
call   10c0 <check_malloc@plt>
mov    %rax,%r15
mov    (%rsp),%edi
shl    $0x2,%edi
call   10c0 <check_malloc@plt>
mov    %rax,0x50(%rsp)
mov    (%rsp),%edi
shl    $0x2,%edi
call   10c0 <check_malloc@plt>
mov    %rax,%r14
mov    0x4(%rsp),%edi
imul   (%rsp),%edi
shl    $0x2,%edi
call   10c0 <check_malloc@plt>
mov    %rax,0x40(%rsp)
lea    0xbe1(%rip),%rsi
mov    %r13,%rdi
xor    %eax,%eax
call   1130 <fopfile@plt>
mov    %rax,%r13
lea    0x1a0(%rsp),%rbx
mov    %rbx,%rdi
mov    $0x800,%esi
mov    %rax,%rdx
call   1070 <fgets@plt>
lea    0xc01(%rip),%rsi
mov    %rbx,%rdi
mov    $0x1,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
jne    14b5 <main+0x2a5>
lea    0x1a0(%rsp),%rbx
lea    0xbe0(%rip),%rbp
nop
mov    %rbx,%rdi
mov    $0x800,%esi
mov    %r13,%rdx
call   1070 <fgets@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    $0x1,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
je     1490 <main+0x280>
mov    %r15,0x48(%rsp)
mov    %r14,0x58(%rsp)
lea    0x1a0(%rsp),%rsi
mov    $0xd,%edi
call   10f0 <skipval@plt>
cmpl   $0x0,(%rsp)
mov    0x60(%rsp),%r14
jle    1514 <main+0x304>
xor    %ebp,%ebp
mov    %r12,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %rax,%rsi
call   10b0 <getflt@plt>
movl   $0x0,(%r14,%rbp,4)
add    $0x1,%rbp
movslq (%rsp),%rcx
add    $0x4,%rbx
cmp    %rcx,%rbp
jl     14f0 <main+0x2e0>
xor    %ebp,%ebp
lea    0x1a0(%rsp),%r14
lea    0x80(%rsp),%r15
mov    0x28(%rsp),%rbx
jmp    1541 <main+0x331>
nopl   (%rax)
mov    0x28(%rsp),%rbx
mov    0x4(%rsp),%edx
cmp    %edx,%ebp
jg     1986 <main+0x776>
mov    %r14,%rdi
mov    $0x800,%esi
mov    %r13,%rdx
call   1070 <fgets@plt>
test   %rax,%rax
je     1695 <main+0x485>
movslq %ebp,%rax
mov    0x70(%rsp),%rcx
lea    (%rcx,%rax,4),%rbx
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
sub    $0x8,%rsp
mov    %r14,%rdi
lea    0xaf4(%rip),%rsi
lea    0x44(%rsp),%rdx
lea    0x40(%rsp),%rcx
lea    0x3c(%rsp),%r8
lea    0x38(%rsp),%r9
push   %r15
push   %rax
push   %rbx
call   10d0 <sscanf@plt>
add    $0x20,%rsp
movss  0x3c(%rsp),%xmm0
ucomiss 0x1c(%rsp),%xmm0
jb     1530 <main+0x320>
movss  0x18(%rsp),%xmm1
ucomiss %xmm0,%xmm1
mov    0x28(%rsp),%rbx
jb     1535 <main+0x325>
movss  0x38(%rsp),%xmm0
ucomiss 0x24(%rsp),%xmm0
jb     1535 <main+0x325>
movss  0x20(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jb     1535 <main+0x325>
movss  0x34(%rsp),%xmm0
ucomiss 0x14(%rsp),%xmm0
jb     1535 <main+0x325>
movss  0x10(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jb     1535 <main+0x325>
movss  0x30(%rsp),%xmm0
ucomiss 0xc(%rsp),%xmm0
jb     1535 <main+0x325>
movss  0x8(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jb     1535 <main+0x325>
mov    %r15,%rdi
lea    0x90(%rsp),%rsi
call   1080 <strcmp@plt>
test   %rax,%rax
jne    1535 <main+0x325>
mov    $0xd,%edi
mov    %r14,%rsi
call   10f0 <skipval@plt>
mov    (%rsp),%ecx
test   %ecx,%ecx
mov    0x40(%rsp),%r15
jle    1680 <main+0x470>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
imul   %ebp,%ecx
movslq %ecx,%rcx
add    %rbx,%rcx
lea    (%r15,%rcx,4),%rdi
mov    %rax,%rsi
call   10b0 <getflt@plt>
mov    (%rsp),%ecx
add    $0x1,%rbx
cmp    %ecx,%ebx
jl     1660 <main+0x450>
add    $0x1,%ebp
mov    0x28(%rsp),%rbx
lea    0x80(%rsp),%r15
jmp    1535 <main+0x325>
mov    %r13,%rdi
call   1060 <fclose@plt>
mov    0x293c(%rip),%rax
mov    (%rax),%rdi
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
lea    0xa15(%rip),%rsi
mov    $0x1,%al
call   10a0 <fprintf@plt>
mov    (%rsp),%r8d
mov    %ebp,%edi
mov    0x60(%rsp),%rsi
mov    0x70(%rsp),%rdx
mov    0x68(%rsp),%rcx
mov    %r12,%r9
push   0x58(%rsp)
push   0x58(%rsp)
push   0x58(%rsp)
mov    0x90(%rsp),%r15
push   %r15
push   %rbx
push   0x68(%rsp)
call   1090 <uncert@plt>
add    $0x30,%rsp
lea    0x9db(%rip),%rsi
mov    %rbx,%r13
lea    0x1a0(%rsp),%rbx
lea    0xa0(%rsp),%rdx
mov    %rbx,%rdi
call   1110 <sprintf@plt>
lea    0x9c1(%rip),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1130 <fopfile@plt>
mov    %rax,%rbp
cmpl   $0x0,(%rsp)
jle    176b <main+0x55b>
xor    %ebx,%ebx
lea    0x9a7(%rip),%r14
nopl   (%rax)
movss  (%r12,%rbx,4),%xmm0
movss  0x0(%r13,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %rbp,%rdi
mov    %r14,%rsi
mov    $0x2,%al
call   10a0 <fprintf@plt>
add    $0x1,%rbx
movslq (%rsp),%rax
cmp    %rax,%rbx
jl     1740 <main+0x530>
mov    %rbp,%rdi
call   1060 <fclose@plt>
lea    0x979(%rip),%rsi
lea    0x1a0(%rsp),%rbx
lea    0xa0(%rsp),%rdx
mov    %rbx,%rdi
call   1110 <sprintf@plt>
lea    0x949(%rip),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1130 <fopfile@plt>
mov    %rax,%rbp
cmpl   $0x0,(%rsp)
jle    17ea <main+0x5da>
xor    %ebx,%ebx
lea    0x92f(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r12,%rbx,4),%xmm0
movss  (%r15,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %rbp,%rdi
mov    %r14,%rsi
mov    $0x2,%al
call   10a0 <fprintf@plt>
add    $0x1,%rbx
movslq (%rsp),%rax
cmp    %rax,%rbx
jl     17c0 <main+0x5b0>
mov    %rbp,%rdi
call   1060 <fclose@plt>
lea    0x903(%rip),%rsi
lea    0x1a0(%rsp),%rbx
lea    0xa0(%rsp),%rdx
mov    %rbx,%rdi
call   1110 <sprintf@plt>
lea    0x8ca(%rip),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1130 <fopfile@plt>
mov    %rax,%rbp
cmpl   $0x0,(%rsp)
mov    0x48(%rsp),%r15
jle    186a <main+0x65a>
xor    %ebx,%ebx
lea    0x8ab(%rip),%r14
nopl   0x0(%rax)
movss  (%r12,%rbx,4),%xmm0
movss  (%r15,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %rbp,%rdi
mov    %r14,%rsi
mov    $0x2,%al
call   10a0 <fprintf@plt>
add    $0x1,%rbx
movslq (%rsp),%rax
cmp    %rax,%rbx
jl     1840 <main+0x630>
mov    %rbp,%rdi
call   1060 <fclose@plt>
lea    0x88d(%rip),%rsi
lea    0x1a0(%rsp),%rbx
lea    0xa0(%rsp),%rdx
mov    %rbx,%rdi
call   1110 <sprintf@plt>
lea    0x84a(%rip),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1130 <fopfile@plt>
mov    %rax,%r15
cmpl   $0x0,(%rsp)
mov    0x50(%rsp),%rbp
jle    18ea <main+0x6da>
xor    %ebx,%ebx
lea    0x82b(%rip),%r14
nopl   0x0(%rax)
movss  (%r12,%rbx,4),%xmm0
movss  0x0(%rbp,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r15,%rdi
mov    %r14,%rsi
mov    $0x2,%al
call   10a0 <fprintf@plt>
add    $0x1,%rbx
movslq (%rsp),%rax
cmp    %rax,%rbx
jl     18c0 <main+0x6b0>
mov    %r15,%rdi
call   1060 <fclose@plt>
lea    0x814(%rip),%rsi
lea    0x1a0(%rsp),%rbx
lea    0xa0(%rsp),%rdx
mov    %rbx,%rdi
call   1110 <sprintf@plt>
lea    0x7ca(%rip),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1130 <fopfile@plt>
mov    %rax,%r15
cmpl   $0x0,(%rsp)
mov    0x58(%rsp),%rbp
jle    196a <main+0x75a>
xor    %ebx,%ebx
lea    0x7ab(%rip),%r14
nopl   0x0(%rax)
movss  (%r12,%rbx,4),%xmm0
movss  0x0(%rbp,%rbx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r15,%rdi
mov    %r14,%rsi
mov    $0x2,%al
call   10a0 <fprintf@plt>
add    $0x1,%rbx
movslq (%rsp),%rax
cmp    %rax,%rbx
jl     1940 <main+0x730>
mov    %r15,%rdi
call   1060 <fclose@plt>
xor    %eax,%eax
add    $0xaa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2653(%rip),%rax
mov    (%rax),%rdi
xorps  %xmm0,%xmm0
cvtsi2ss %ebp,%xmm0
lea    0x700(%rip),%rsi
mov    $0x1,%al
call   10a0 <fprintf@plt>
mov    $0xffffffff,%edi
call   1120 <exit@plt>

LLVM IR (-O0):
@.str = [10 x i8] c"residfile\00"
@.str.1 = [2 x i8] c"s\00"
@.str.2 = [9 x i8] c"fileroot\00"
@.str.3 = [5 x i8] c"comp\00"
@.str.4 = [6 x i8] c"nstat\00"
@.str.5 = [2 x i8] c"d\00"
@.str.6 = [5 x i8] c"nper\00"
@.str.7 = [9 x i8] c"min_cdst\00"
@.str.8 = [2 x i8] c"f\00"
@.str.9 = [9 x i8] c"max_cdst\00"
@.str.10 = [9 x i8] c"min_vs30\00"
@.str.11 = [9 x i8] c"max_vs30\00"
@.str.12 = [9 x i8] c"min_xcos\00"
@.str.13 = [9 x i8] c"max_xcos\00"
@.str.14 = [9 x i8] c"min_ycos\00"
@.str.15 = [9 x i8] c"max_ycos\00"
@.str.16 = [2 x i8] c"r\00"
@.str.17 = [2 x i8] c"#\00"
@.str.18 = [45 x i8] c"%*s %*f %*s %*f %*f %*d %f %f %f %f %f %f %s\00"
@stderr = global i32* null
@.str.19 = [44 x i8] c"(nstat_read= %d) > (nstat= %d), exiting...\0A\00"
@.str.20 = [16 x i8] c"nstat_read= %d\0A\00"
@.str.21 = [8 x i8] c"%s.bias\00"
@.str.22 = [2 x i8] c"w\00"
@.str.23 = [15 x i8] c"%13.5e %13.5e\0A\00"
@.str.24 = [9 x i8] c"%s.sigma\00"
@.str.25 = [10 x i8] c"%s.sigma0\00"
@.str.26 = [7 x i8] c"%s.m90\00"
@.str.27 = [7 x i8] c"%s.p90\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca float*
%9 = alloca float*
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float*
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%18 = alloca float*
%19 = alloca float*
%20 = alloca float*
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32*
%24 = alloca i32
%25 = alloca i32
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca [256 x i8]
%35 = alloca [256 x i8]
%36 = alloca [16 x i8]
%37 = alloca [16 x i8]
%38 = alloca i8*
%39 = alloca [2048 x i8]
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store float 0xC30C6BF520000000, float* %26
store float 0x430C6BF520000000, float* %27
store float 0xC30C6BF520000000, float* %28
store float 0x430C6BF520000000, float* %29
store float 0xC30C6BF520000000, float* %30
store float 0x430C6BF520000000, float* %31
store float 0xC30C6BF520000000, float* %32
store float 0x430C6BF520000000, float* %33
%40 = load i32, i32* %4
%41 = load i8**, i8*** %5
%42 = call i32 @setpar(i32 %40, i8** %41)
%43 = getelementptr inbounds [256 x i8], [256 x i8]* %34, i64 0, i64 0
%44 = 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* %43)
%45 = getelementptr inbounds [256 x i8], [256 x i8]* %35, i64 0, i64 0
%46 = call i32 (i8*, i8*, ...) @mstpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i8* %45)
%47 = getelementptr inbounds [16 x i8], [16 x i8]* %36, i64 0, i64 0
%48 = call i32 (i8*, i8*, ...) @mstpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i8* %47)
%49 = call i32 (i8*, i8*, ...) @mstpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32* %21)
%50 = call i32 (i8*, i8*, ...) @mstpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32* %22)
%51 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %26)
%52 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %27)
%53 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %28)
%54 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %29)
%55 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %30)
%56 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %31)
%57 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.14, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %32)
%58 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %33)
%59 = call i32 (...) @endpar()
%60 = load i32, i32* %22
%61 = sext i32 %60 to i64
%62 = mul i64 %61, 4
%63 = trunc i64 %62 to i32
%64 = call i64 @check_malloc(i32 %63)
%65 = inttoptr i64 %64 to i32*
store i32* %65, i32** %23
%66 = load i32, i32* %21
%67 = sext i32 %66 to i64
%68 = mul i64 %67, 4
%69 = trunc i64 %68 to i32
%70 = call i64 @check_malloc(i32 %69)
%71 = inttoptr i64 %70 to float*
store float* %71, float** %14
%72 = load i32, i32* %21
%73 = sext i32 %72 to i64
%74 = mul i64 %73, 4
%75 = trunc i64 %74 to i32
%76 = call i64 @check_malloc(i32 %75)
%77 = inttoptr i64 %76 to float*
store float* %77, float** %15
%78 = load i32, i32* %22
%79 = sext i32 %78 to i64
%80 = mul i64 %79, 4
%81 = trunc i64 %80 to i32
%82 = call i64 @check_malloc(i32 %81)
%83 = inttoptr i64 %82 to float*
store float* %83, float** %8
%84 = load i32, i32* %22
%85 = sext i32 %84 to i64
%86 = mul i64 %85, 4
%87 = trunc i64 %86 to i32
%88 = call i64 @check_malloc(i32 %87)
%89 = inttoptr i64 %88 to float*
store float* %89, float** %16
%90 = load i32, i32* %22
%91 = sext i32 %90 to i64
%92 = mul i64 %91, 4
%93 = trunc i64 %92 to i32
%94 = call i64 @check_malloc(i32 %93)
%95 = inttoptr i64 %94 to float*
store float* %95, float** %17
%96 = load i32, i32* %22
%97 = sext i32 %96 to i64
%98 = mul i64 %97, 4
%99 = trunc i64 %98 to i32
%100 = call i64 @check_malloc(i32 %99)
%101 = inttoptr i64 %100 to float*
store float* %101, float** %18
%102 = load i32, i32* %22
%103 = sext i32 %102 to i64
%104 = mul i64 %103, 4
%105 = trunc i64 %104 to i32
%106 = call i64 @check_malloc(i32 %105)
%107 = inttoptr i64 %106 to float*
store float* %107, float** %19
%108 = load i32, i32* %22
%109 = sext i32 %108 to i64
%110 = mul i64 %109, 4
%111 = trunc i64 %110 to i32
%112 = call i64 @check_malloc(i32 %111)
%113 = inttoptr i64 %112 to float*
store float* %113, float** %20
%114 = load i32, i32* %21
%115 = load i32, i32* %22
%116 = mul nsw i32 %114, %115
%117 = sext i32 %116 to i64
%118 = mul i64 %117, 4
%119 = trunc i64 %118 to i32
%120 = call i64 @check_malloc(i32 %119)
%121 = inttoptr i64 %120 to float*
store float* %121, float** %9
%122 = getelementptr inbounds [256 x i8], [256 x i8]* %34, i64 0, i64 0
%123 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %122, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0))
store i32* %123, i32** %6
%124 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%125 = load i32*, i32** %6
%126 = call i32* @fgets(i8* %124, i32 2048, i32* %125)
br label %127
127: ; preds = %131, %2
%128 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%129 = call i64 @strncmp(i8* %128, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i64 0, i64 0), i32 1)
%130 = icmp eq i64 %129, 0
br i1 %130, label %131, label %135
131: ; preds = %127
%132 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%133 = load i32*, i32** %6
%134 = call i32* @fgets(i8* %132, i32 2048, i32* %133)
br label %127
135: ; preds = %127
%136 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%137 = call i8* @skipval(i32 13, i8* %136)
store i8* %137, i8** %38
store i32 0, i32* %25
br label %138
138: ; preds = %153, %135
%139 = load i32, i32* %25
%140 = load i32, i32* %22
%141 = icmp slt i32 %139, %140
br i1 %141, label %142, label %156
142: ; preds = %138
%143 = load float*, float** %8
%144 = load i32, i32* %25
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds float, float* %143, i64 %145
%147 = load i8*, i8** %38
%148 = call i8* @getflt(float* %146, i8* %147)
store i8* %148, i8** %38
%149 = load i32*, i32** %23
%150 = load i32, i32* %25
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i32, i32* %149, i64 %151
store i32 0, i32* %152
br label %153
153: ; preds = %142
%154 = load i32, i32* %25
%155 = add nsw i32 %154, 1
store i32 %155, i32* %25
br label %138
156: ; preds = %138
store i32 0, i32* %24
br label %157
157: ; preds = %245, %156
%158 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%159 = load i32*, i32** %6
%160 = call i32* @fgets(i8* %158, i32 2048, i32* %159)
%161 = icmp ne i32* %160, null
br i1 %161, label %162, label %246
162: ; preds = %157
%163 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%164 = load float*, float** %14
%165 = load i32, i32* %24
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float, float* %164, i64 %166
%168 = load float*, float** %15
%169 = load i32, i32* %24
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds float, float* %168, i64 %170
%172 = getelementptr inbounds [16 x i8], [16 x i8]* %37, i64 0, i64 0
%173 = call i32 @sscanf(i8* %163, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.18, i64 0, i64 0), float* %10, float* %11, float* %12, float* %13, float* %167, float* %171, i8* %172)
%174 = load float, float* %10
%175 = load float, float* %28
%176 = fcmp oge float %174, %175
br i1 %176, label %177, label %234
177: ; preds = %162
%178 = load float, float* %10
%179 = load float, float* %29
%180 = fcmp ole float %178, %179
br i1 %180, label %181, label %234
181: ; preds = %177
%182 = load float, float* %11
%183 = load float, float* %26
%184 = fcmp oge float %182, %183
br i1 %184, label %185, label %234
185: ; preds = %181
%186 = load float, float* %11
%187 = load float, float* %27
%188 = fcmp ole float %186, %187
br i1 %188, label %189, label %234
189: ; preds = %185
%190 = load float, float* %12
%191 = load float, float* %30
%192 = fcmp oge float %190, %191
br i1 %192, label %193, label %234
193: ; preds = %189
%194 = load float, float* %12
%195 = load float, float* %31
%196 = fcmp ole float %194, %195
br i1 %196, label %197, label %234
197: ; preds = %193
%198 = load float, float* %13
%199 = load float, float* %32
%200 = fcmp oge float %198, %199
br i1 %200, label %201, label %234
201: ; preds = %197
%202 = load float, float* %13
%203 = load float, float* %33
%204 = fcmp ole float %202, %203
br i1 %204, label %205, label %234
205: ; preds = %201
%206 = getelementptr inbounds [16 x i8], [16 x i8]* %37, i64 0, i64 0
%207 = getelementptr inbounds [16 x i8], [16 x i8]* %36, i64 0, i64 0
%208 = call i64 @strcmp(i8* %206, i8* %207)
%209 = icmp eq i64 %208, 0
br i1 %209, label %210, label %234
210: ; preds = %205
%211 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%212 = call i8* @skipval(i32 13, i8* %211)
store i8* %212, i8** %38
store i32 0, i32* %25
br label %213
213: ; preds = %228, %210
%214 = load i32, i32* %25
%215 = load i32, i32* %22
%216 = icmp slt i32 %214, %215
br i1 %216, label %217, label %231
217: ; preds = %213
%218 = load float*, float** %9
%219 = load i32, i32* %25
%220 = load i32, i32* %24
%221 = load i32, i32* %22
%222 = mul nsw i32 %220, %221
%223 = add nsw i32 %219, %222
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds float, float* %218, i64 %224
%226 = load i8*, i8** %38
%227 = call i8* @getflt(float* %225, i8* %226)
store i8* %227, i8** %38
br label %228
228: ; preds = %217
%229 = load i32, i32* %25
%230 = add nsw i32 %229, 1
store i32 %230, i32* %25
br label %213
231: ; preds = %213
%232 = load i32, i32* %24
%233 = add nsw i32 %232, 1
store i32 %233, i32* %24
br label %234
234: ; preds = %231, %205, %201, %197, %193, %189, %185, %181, %177, %162
%235 = load i32, i32* %24
%236 = load i32, i32* %21
%237 = icmp sgt i32 %235, %236
br i1 %237, label %238, label %245
238: ; preds = %234
%239 = load i32*, i32** @stderr
%240 = load i32, i32* %24
%241 = sitofp i32 %240 to float
%242 = load i32, i32* %21
%243 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %239, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.19, i64 0, i64 0), float %241, i32 %242)
%244 = call i32 @exit(i32 -1)
unreachable
245: ; preds = %234
br label %157
246: ; preds = %157
%247 = load i32*, i32** %6
%248 = call i32 @fclose(i32* %247)
%249 = load i32*, i32** @stderr
%250 = load i32, i32* %24
%251 = sitofp i32 %250 to float
%252 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %249, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.20, i64 0, i64 0), float %251)
%253 = load i32, i32* %24
%254 = load i32*, i32** %23
%255 = load float*, float** %14
%256 = load float*, float** %15
%257 = load i32, i32* %22
%258 = load float*, float** %8
%259 = load float*, float** %9
%260 = load float*, float** %16
%261 = load float*, float** %17
%262 = load float*, float** %18
%263 = load float*, float** %19
%264 = load float*, float** %20
%265 = call i32 @uncert(i32 %253, i32* %254, float* %255, float* %256, i32 %257, float* %258, float* %259, float* %260, float* %261, float* %262, float* %263, float* %264)
%266 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%267 = getelementptr inbounds [256 x i8], [256 x i8]* %35, i64 0, i64 0
%268 = call i32 @sprintf(i8* %266, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.21, i64 0, i64 0), i8* %267)
%269 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%270 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %269, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
store i32* %270, i32** %7
store i32 0, i32* %25
br label %271
271: ; preds = %289, %246
%272 = load i32, i32* %25
%273 = load i32, i32* %22
%274 = icmp slt i32 %272, %273
br i1 %274, label %275, label %292
275: ; preds = %271
%276 = load i32*, i32** %7
%277 = load float*, float** %8
%278 = load i32, i32* %25
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds float, float* %277, i64 %279
%281 = load float, float* %280
%282 = load float*, float** %16
%283 = load i32, i32* %25
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds float, float* %282, i64 %284
%286 = load float, float* %285
%287 = fpext float %286 to double
%288 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %276, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), float %281, double %287)
br label %289
289: ; preds = %275
%290 = load i32, i32* %25
%291 = add nsw i32 %290, 1
store i32 %291, i32* %25
br label %271
292: ; preds = %271
%293 = load i32*, i32** %7
%294 = call i32 @fclose(i32* %293)
%295 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%296 = getelementptr inbounds [256 x i8], [256 x i8]* %35, i64 0, i64 0
%297 = call i32 @sprintf(i8* %295, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.24, i64 0, i64 0), i8* %296)
%298 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%299 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %298, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
store i32* %299, i32** %7
store i32 0, i32* %25
br label %300
300: ; preds = %318, %292
%301 = load i32, i32* %25
%302 = load i32, i32* %22
%303 = icmp slt i32 %301, %302
br i1 %303, label %304, label %321
304: ; preds = %300
%305 = load i32*, i32** %7
%306 = load float*, float** %8
%307 = load i32, i32* %25
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds float, float* %306, i64 %308
%310 = load float, float* %309
%311 = load float*, float** %17
%312 = load i32, i32* %25
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds float, float* %311, i64 %313
%315 = load float, float* %314
%316 = fpext float %315 to double
%317 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %305, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), float %310, double %316)
br label %318
318: ; preds = %304
%319 = load i32, i32* %25
%320 = add nsw i32 %319, 1
store i32 %320, i32* %25
br label %300
321: ; preds = %300
%322 = load i32*, i32** %7
%323 = call i32 @fclose(i32* %322)
%324 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%325 = getelementptr inbounds [256 x i8], [256 x i8]* %35, i64 0, i64 0
%326 = call i32 @sprintf(i8* %324, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.25, i64 0, i64 0), i8* %325)
%327 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%328 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %327, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
store i32* %328, i32** %7
store i32 0, i32* %25
br label %329
329: ; preds = %347, %321
%330 = load i32, i32* %25
%331 = load i32, i32* %22
%332 = icmp slt i32 %330, %331
br i1 %332, label %333, label %350
333: ; preds = %329
%334 = load i32*, i32** %7
%335 = load float*, float** %8
%336 = load i32, i32* %25
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float, float* %335, i64 %337
%339 = load float, float* %338
%340 = load float*, float** %18
%341 = load i32, i32* %25
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds float, float* %340, i64 %342
%344 = load float, float* %343
%345 = fpext float %344 to double
%346 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %334, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), float %339, double %345)
br label %347
347: ; preds = %333
%348 = load i32, i32* %25
%349 = add nsw i32 %348, 1
store i32 %349, i32* %25
br label %329
350: ; preds = %329
%351 = load i32*, i32** %7
%352 = call i32 @fclose(i32* %351)
%353 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%354 = getelementptr inbounds [256 x i8], [256 x i8]* %35, i64 0, i64 0
%355 = call i32 @sprintf(i8* %353, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.26, i64 0, i64 0), i8* %354)
%356 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%357 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %356, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
store i32* %357, i32** %7
store i32 0, i32* %25
br label %358
358: ; preds = %376, %350
%359 = load i32, i32* %25
%360 = load i32, i32* %22
%361 = icmp slt i32 %359, %360
br i1 %361, label %362, label %379
362: ; preds = %358
%363 = load i32*, i32** %7
%364 = load float*, float** %8
%365 = load i32, i32* %25
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds float, float* %364, i64 %366
%368 = load float, float* %367
%369 = load float*, float** %19
%370 = load i32, i32* %25
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds float, float* %369, i64 %371
%373 = load float, float* %372
%374 = fpext float %373 to double
%375 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %363, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), float %368, double %374)
br label %376
376: ; preds = %362
%377 = load i32, i32* %25
%378 = add nsw i32 %377, 1
store i32 %378, i32* %25
br label %358
379: ; preds = %358
%380 = load i32*, i32** %7
%381 = call i32 @fclose(i32* %380)
%382 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%383 = getelementptr inbounds [256 x i8], [256 x i8]* %35, i64 0, i64 0
%384 = call i32 @sprintf(i8* %382, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.27, i64 0, i64 0), i8* %383)
%385 = getelementptr inbounds [2048 x i8], [2048 x i8]* %39, i64 0, i64 0
%386 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %385, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
store i32* %386, i32** %7
store i32 0, i32* %25
br label %387
387: ; preds = %405, %379
%388 = load i32, i32* %25
%389 = load i32, i32* %22
%390 = icmp slt i32 %388, %389
br i1 %390, label %391, label %408
391: ; preds = %387
%392 = load i32*, i32** %7
%393 = load float*, float** %8
%394 = load i32, i32* %25
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds float, float* %393, i64 %395
%397 = load float, float* %396
%398 = load float*, float** %20
%399 = load i32, i32* %25
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds float, float* %398, i64 %400
%402 = load float, float* %401
%403 = fpext float %402 to double
%404 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %392, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), float %397, double %403)
br label %405
405: ; preds = %391
%406 = load i32, i32* %25
%407 = add nsw i32 %406, 1
store i32 %407, i32* %25
br label %387
408: ; preds = %387
%409 = load i32*, i32** %7
%410 = call i32 @fclose(i32* %409)
%411 = load i32, i32* %3
ret i32 %411
}

LLVM IR (-O2):
@.str = [10 x i8] c"residfile\00"
@.str.1 = [2 x i8] c"s\00"
@.str.2 = [9 x i8] c"fileroot\00"
@.str.3 = [5 x i8] c"comp\00"
@.str.4 = [6 x i8] c"nstat\00"
@.str.5 = [2 x i8] c"d\00"
@.str.6 = [5 x i8] c"nper\00"
@.str.7 = [9 x i8] c"min_cdst\00"
@.str.8 = [2 x i8] c"f\00"
@.str.9 = [9 x i8] c"max_cdst\00"
@.str.10 = [9 x i8] c"min_vs30\00"
@.str.11 = [9 x i8] c"max_vs30\00"
@.str.12 = [9 x i8] c"min_xcos\00"
@.str.13 = [9 x i8] c"max_xcos\00"
@.str.14 = [9 x i8] c"min_ycos\00"
@.str.15 = [9 x i8] c"max_ycos\00"
@.str.16 = [2 x i8] c"r\00"
@.str.17 = [2 x i8] c"#\00"
@.str.18 = [45 x i8] c"%*s %*f %*s %*f %*f %*d %f %f %f %f %f %f %s\00"
@stderr = global i32* null
@.str.19 = [44 x i8] c"(nstat_read= %d) > (nstat= %d), exiting...\0A\00"
@.str.20 = [16 x i8] c"nstat_read= %d\0A\00"
@.str.21 = [8 x i8] c"%s.bias\00"
@.str.22 = [2 x i8] c"w\00"
@.str.23 = [15 x i8] c"%13.5e %13.5e\0A\00"
@.str.24 = [9 x i8] c"%s.sigma\00"
@.str.25 = [10 x i8] c"%s.sigma0\00"
@.str.26 = [7 x i8] c"%s.m90\00"
@.str.27 = [7 x i8] c"%s.p90\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca float
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca i32
%8 = alloca i32
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca [256 x i8]
%18 = alloca [256 x i8]
%19 = alloca [16 x i8]
%20 = alloca [16 x i8]
%21 = alloca [2048 x i8]
%22 = bitcast float* %3 to i8*
%23 = bitcast float* %4 to i8*
%24 = bitcast float* %5 to i8*
%25 = bitcast float* %6 to i8*
%26 = bitcast i32* %7 to i8*
%27 = bitcast i32* %8 to i8*
%28 = bitcast float* %9 to i8*
store float 0xC30C6BF520000000, float* %9
%29 = bitcast float* %10 to i8*
store float 0x430C6BF520000000, float* %10
%30 = bitcast float* %11 to i8*
store float 0xC30C6BF520000000, float* %11
%31 = bitcast float* %12 to i8*
store float 0x430C6BF520000000, float* %12
%32 = bitcast float* %13 to i8*
store float 0xC30C6BF520000000, float* %13
%33 = bitcast float* %14 to i8*
store float 0x430C6BF520000000, float* %14
%34 = bitcast float* %15 to i8*
store float 0xC30C6BF520000000, float* %15
%35 = bitcast float* %16 to i8*
store float 0x430C6BF520000000, float* %16
%36 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%37 = getelementptr inbounds [256 x i8], [256 x i8]* %18, i64 0, i64 0
%38 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 0
%39 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 0
%40 = getelementptr inbounds [2048 x i8], [2048 x i8]* %21, i64 0, i64 0
%41 = tail call i32 @setpar(i32 %0, i8** %1)
%42 = 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* %36)
%43 = call i32 (i8*, i8*, ...) @mstpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i8* %37)
%44 = call i32 (i8*, i8*, ...) @mstpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i8* %38)
%45 = call i32 (i8*, i8*, ...) @mstpar(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32* %7)
%46 = call i32 (i8*, i8*, ...) @mstpar(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32* %8)
%47 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.7, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %9)
%48 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.9, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %10)
%49 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.10, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %11)
%50 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.11, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %12)
%51 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.12, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %13)
%52 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %14)
%53 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.14, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %15)
%54 = call i32 @getpar(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.8, i64 0, i64 0), float* %16)
%55 = call i32 (...) @endpar()
%56 = load i32, i32* %8
%57 = shl i32 %56, 2
%58 = call i64 @check_malloc(i32 %57)
%59 = inttoptr i64 %58 to i32*
%60 = load i32, i32* %7
%61 = shl i32 %60, 2
%62 = call i64 @check_malloc(i32 %61)
%63 = inttoptr i64 %62 to float*
%64 = load i32, i32* %7
%65 = shl i32 %64, 2
%66 = call i64 @check_malloc(i32 %65)
%67 = inttoptr i64 %66 to float*
%68 = load i32, i32* %8
%69 = shl i32 %68, 2
%70 = call i64 @check_malloc(i32 %69)
%71 = inttoptr i64 %70 to float*
%72 = load i32, i32* %8
%73 = shl i32 %72, 2
%74 = call i64 @check_malloc(i32 %73)
%75 = inttoptr i64 %74 to float*
%76 = load i32, i32* %8
%77 = shl i32 %76, 2
%78 = call i64 @check_malloc(i32 %77)
%79 = inttoptr i64 %78 to float*
%80 = load i32, i32* %8
%81 = shl i32 %80, 2
%82 = call i64 @check_malloc(i32 %81)
%83 = inttoptr i64 %82 to float*
%84 = load i32, i32* %8
%85 = shl i32 %84, 2
%86 = call i64 @check_malloc(i32 %85)
%87 = inttoptr i64 %86 to float*
%88 = load i32, i32* %8
%89 = shl i32 %88, 2
%90 = call i64 @check_malloc(i32 %89)
%91 = inttoptr i64 %90 to float*
%92 = load i32, i32* %7
%93 = load i32, i32* %8
%94 = shl i32 %92, 2
%95 = mul i32 %94, %93
%96 = call i64 @check_malloc(i32 %95)
%97 = inttoptr i64 %96 to float*
%98 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %36, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0))
%99 = call i32* @fgets(i8* %40, i32 2048, i32* %98)
%100 = call i64 @strncmp(i8* %40, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i64 0, i64 0), i32 1)
%101 = icmp eq i64 %100, 0
br i1 %101, label %102, label %106
102: ; preds = %2, %102
%103 = call i32* @fgets(i8* %40, i32 2048, i32* %98)
%104 = call i64 @strncmp(i8* %40, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i64 0, i64 0), i32 1)
%105 = icmp eq i64 %104, 0
br i1 %105, label %102, label %106
106: ; preds = %102, %2
%107 = call i8* @skipval(i32 13, i8* %40)
%108 = load i32, i32* %8
%109 = icmp sgt i32 %108, 0
br i1 %109, label %110, label %120
110: ; preds = %106, %110
%111 = phi i64 [ %116, %110 ], [ 0, %106 ]
%112 = phi i8* [ %114, %110 ], [ %107, %106 ]
%113 = getelementptr inbounds float, float* %71, i64 %111
%114 = call i8* @getflt(float* %113, i8* %112)
%115 = getelementptr inbounds i32, i32* %59, i64 %111
store i32 0, i32* %115
%116 = add nuw nsw i64 %111, 1
%117 = load i32, i32* %8
%118 = sext i32 %117 to i64
%119 = icmp slt i64 %116, %118
br i1 %119, label %110, label %120
120: ; preds = %110, %106
br label %121
121: ; preds = %120, %178
%122 = phi i32 [ %179, %178 ], [ 0, %120 ]
%123 = call i32* @fgets(i8* %40, i32 2048, i32* %98)
%124 = icmp eq i32* %123, null
br i1 %124, label %187, label %125
125: ; preds = %121
%126 = sext i32 %122 to i64
%127 = getelementptr inbounds float, float* %63, i64 %126
%128 = getelementptr inbounds float, float* %67, i64 %126
%129 = call i32 @sscanf(i8* %40, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.18, i64 0, i64 0), float* %3, float* %4, float* %5, float* %6, float* %127, float* %128, i8* %39)
%130 = load float, float* %3
%131 = load float, float* %11
%132 = fcmp ult float %130, %131
%133 = load float, float* %12
%134 = fcmp ugt float %130, %133
%135 = select i1 %132, i1 true, i1 %134
br i1 %135, label %178, label %136
136: ; preds = %125
%137 = load float, float* %4
%138 = load float, float* %9
%139 = fcmp ult float %137, %138
%140 = load float, float* %10
%141 = fcmp ugt float %137, %140
%142 = select i1 %139, i1 true, i1 %141
br i1 %142, label %178, label %143
143: ; preds = %136
%144 = load float, float* %5
%145 = load float, float* %13
%146 = fcmp ult float %144, %145
%147 = load float, float* %14
%148 = fcmp ugt float %144, %147
%149 = select i1 %146, i1 true, i1 %148
br i1 %149, label %178, label %150
150: ; preds = %143
%151 = load float, float* %6
%152 = load float, float* %15
%153 = fcmp ult float %151, %152
%154 = load float, float* %16
%155 = fcmp ugt float %151, %154
%156 = select i1 %153, i1 true, i1 %155
br i1 %156, label %178, label %157
157: ; preds = %150
%158 = call i64 @strcmp(i8* %39, i8* %38)
%159 = icmp eq i64 %158, 0
br i1 %159, label %160, label %178
160: ; preds = %157
%161 = call i8* @skipval(i32 13, i8* %40)
%162 = load i32, i32* %8
%163 = icmp sgt i32 %162, 0
br i1 %163, label %164, label %176
164: ; preds = %160, %164
%165 = phi i32 [ %174, %164 ], [ %162, %160 ]
%166 = phi i8* [ %172, %164 ], [ %161, %160 ]
%167 = phi i32 [ %173, %164 ], [ 0, %160 ]
%168 = mul nsw i32 %165, %122
%169 = add nsw i32 %168, %167
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds float, float* %97, i64 %170
%172 = call i8* @getflt(float* %171, i8* %166)
%173 = add nuw nsw i32 %167, 1
%174 = load i32, i32* %8
%175 = icmp slt i32 %173, %174
br i1 %175, label %164, label %176
176: ; preds = %164, %160
%177 = add nsw i32 %122, 1
br label %178
178: ; preds = %176, %157, %150, %143, %136, %125
%179 = phi i32 [ %177, %176 ], [ %122, %157 ], [ %122, %150 ], [ %122, %143 ], [ %122, %136 ], [ %122, %125 ]
%180 = load i32, i32* %7
%181 = icmp sgt i32 %179, %180
br i1 %181, label %182, label %121
182: ; preds = %178
%183 = load i32*, i32** @stderr
%184 = sitofp i32 %179 to float
%185 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %183, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.19, i64 0, i64 0), float %184, i32 %180)
%186 = call i32 @exit(i32 -1)
unreachable
187: ; preds = %121
%188 = call i32 @fclose(i32* %98)
%189 = load i32*, i32** @stderr
%190 = sitofp i32 %122 to float
%191 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %189, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.20, i64 0, i64 0), float %190)
%192 = load i32, i32* %8
%193 = call i32 @uncert(i32 %122, i32* %59, float* %63, float* %67, i32 %192, float* %71, float* %97, float* %75, float* %79, float* %83, float* %87, float* %91)
%194 = call i32 @sprintf(i8* %40, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.21, i64 0, i64 0), i8* %37)
%195 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %40, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
%196 = load i32, i32* %8
%197 = icmp sgt i32 %196, 0
br i1 %197, label %198, label %210
198: ; preds = %187, %198
%199 = phi i64 [ %206, %198 ], [ 0, %187 ]
%200 = getelementptr inbounds float, float* %71, i64 %199
%201 = load float, float* %200
%202 = getelementptr inbounds float, float* %75, i64 %199
%203 = load float, float* %202
%204 = fpext float %203 to double
%205 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %195, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), float %201, double %204)
%206 = add nuw nsw i64 %199, 1
%207 = load i32, i32* %8
%208 = sext i32 %207 to i64
%209 = icmp slt i64 %206, %208
br i1 %209, label %198, label %210
210: ; preds = %198, %187
%211 = call i32 @fclose(i32* %195)
%212 = call i32 @sprintf(i8* %40, i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.24, i64 0, i64 0), i8* %37)
%213 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %40, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
%214 = load i32, i32* %8
%215 = icmp sgt i32 %214, 0
br i1 %215, label %216, label %228
216: ; preds = %210, %216
%217 = phi i64 [ %224, %216 ], [ 0, %210 ]
%218 = getelementptr inbounds float, float* %71, i64 %217
%219 = load float, float* %218
%220 = getelementptr inbounds float, float* %79, i64 %217
%221 = load float, float* %220
%222 = fpext float %221 to double
%223 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %213, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), float %219, double %222)
%224 = add nuw nsw i64 %217, 1
%225 = load i32, i32* %8
%226 = sext i32 %225 to i64
%227 = icmp slt i64 %224, %226
br i1 %227, label %216, label %228
228: ; preds = %216, %210
%229 = call i32 @fclose(i32* %213)
%230 = call i32 @sprintf(i8* %40, i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.25, i64 0, i64 0), i8* %37)
%231 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %40, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
%232 = load i32, i32* %8
%233 = icmp sgt i32 %232, 0
br i1 %233, label %234, label %246
234: ; preds = %228, %234
%235 = phi i64 [ %242, %234 ], [ 0, %228 ]
%236 = getelementptr inbounds float, float* %71, i64 %235
%237 = load float, float* %236
%238 = getelementptr inbounds float, float* %83, i64 %235
%239 = load float, float* %238
%240 = fpext float %239 to double
%241 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %231, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), float %237, double %240)
%242 = add nuw nsw i64 %235, 1
%243 = load i32, i32* %8
%244 = sext i32 %243 to i64
%245 = icmp slt i64 %242, %244
br i1 %245, label %234, label %246
246: ; preds = %234, %228
%247 = call i32 @fclose(i32* %231)
%248 = call i32 @sprintf(i8* %40, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.26, i64 0, i64 0), i8* %37)
%249 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %40, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
%250 = load i32, i32* %8
%251 = icmp sgt i32 %250, 0
br i1 %251, label %252, label %264
252: ; preds = %246, %252
%253 = phi i64 [ %260, %252 ], [ 0, %246 ]
%254 = getelementptr inbounds float, float* %71, i64 %253
%255 = load float, float* %254
%256 = getelementptr inbounds float, float* %87, i64 %253
%257 = load float, float* %256
%258 = fpext float %257 to double
%259 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %249, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), float %255, double %258)
%260 = add nuw nsw i64 %253, 1
%261 = load i32, i32* %8
%262 = sext i32 %261 to i64
%263 = icmp slt i64 %260, %262
br i1 %263, label %252, label %264
264: ; preds = %252, %246
%265 = call i32 @fclose(i32* %249)
%266 = call i32 @sprintf(i8* %40, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.27, i64 0, i64 0), i8* %37)
%267 = call i32* (i8*, i8*, ...) bitcast (i32* (...)* @fopfile to i32* (i8*, i8*, ...)*)(i8* %40, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.22, i64 0, i64 0))
%268 = load i32, i32* %8
%269 = icmp sgt i32 %268, 0
br i1 %269, label %270, label %282
270: ; preds = %264, %270
%271 = phi i64 [ %278, %270 ], [ 0, %264 ]
%272 = getelementptr inbounds float, float* %71, i64 %271
%273 = load float, float* %272
%274 = getelementptr inbounds float, float* %91, i64 %271
%275 = load float, float* %274
%276 = fpext float %275 to double
%277 = call i32 (i32*, i8*, float, ...) @fprintf(i32* %267, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.23, i64 0, i64 0), float %273, double %276)
%278 = add nuw nsw i64 %271, 1
%279 = load i32, i32* %8
%280 = sext i32 %279 to i64
%281 = icmp slt i64 %278, %280
br i1 %281, label %270, label %282
282: ; preds = %270, %264
%283 = call i32 @fclose(i32* %267)
ret i32 0
}