#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*/ buf;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
double *malloc(int);
int /*<<< orphan*/ perror(char *);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sprintf(char *, char *, double);
int /*<<< orphan*/ strcat(char *, char *);
int strlen(char *);
double strtod(char *, int /*<<< orphan*/ *);
int main(int argc, char **argv) {
  int nx = 91, ny = 45, nz = 45;
  int i;
  double *longs_ref, *lats_ref, *p_ref, *ndepth_ref, *saar_ref, *delta_sa_ref;
  FILE *fin;
  char buf[256], b[64], *pC;
  longs_ref = malloc(nx * sizeof(double));
  lats_ref = malloc(ny * sizeof(double));
  p_ref = malloc(nz * sizeof(double));
  ndepth_ref = malloc(nx * ny * sizeof(double));
  saar_ref = malloc(nx * ny * nz * sizeof(double));
  delta_sa_ref = malloc(nx * ny * nz * sizeof(double));
  if ((fin = fopen("gsw_data_v3_0.dat", "r")) == NULL) {
    perror("gsw_data_v3_0.dat");
    exit(1);
  }
  for (i = 0; i < nx; i++) {
    if (fgets(buf, sizeof(buf), fin) == NULL)
      break;
    longs_ref[i] = strtod(buf, NULL);
  }
  for (i = 0; i < ny; i++) {
    if (fgets(buf, sizeof(buf), fin) == NULL)
      break;
    lats_ref[i] = strtod(buf, NULL);
  }
  for (i = 0; i < nz; i++) {
    if (fgets(buf, sizeof(buf), fin) == NULL)
      break;
    p_ref[i] = strtod(buf, NULL);
  }
  for (i = 0; i < nx * ny; i++) {
    if (fgets(buf, sizeof(buf), fin) == NULL)
      break;
    ndepth_ref[i] = strtod(buf, NULL);
  }
  for (i = 0; i < nx * ny * nz; i++) {
    if (fgets(buf, sizeof(buf), fin) == NULL)
      break;
    saar_ref[i] = strtod(buf, NULL);
  }
  for (i = 0; i < nx * ny * nz; i++) {
    if (fgets(buf, sizeof(buf), fin) == NULL)
      break;
    delta_sa_ref[i] = strtod(buf, NULL);
  }
  fclose(fin);
  printf("static int\tgsw_nx=%d, gsw_ny=%d, gsw_nz=%d;\n", nx, ny, nz);
  printf("static double\tlongs_ref[%d] = {\n", nx);
  buf[0] = '\0';
  for (i = 0; i < nx; i++) {
    sprintf(b, "%.17g", longs_ref[i]);
    if (i < (nx - 1))
      strcat(b, ",");
    if (strlen(buf) + strlen(b) > 110) {
      printf("\t%s\n", buf);
      buf[0] = '\0';
    }
    strcat(buf, b);
  }
  if (strlen(buf) != 0)
    printf("\t%s\n", buf);
  printf("\t};\n");
  printf("static double\tlats_ref[%d] = {\n", ny);
  buf[0] = '\0';
  for (i = 0; i < ny; i++) {
    sprintf(b, "%.17g", lats_ref[i]);
    if (i < (ny - 1))
      strcat(b, ",");
    if (strlen(buf) + strlen(b) > 110) {
      printf("\t%s\n", buf);
      buf[0] = '\0';
    }
    strcat(buf, b);
  }
  if (strlen(buf) != 0)
    printf("\t%s\n", buf);
  printf("\t};\n");
  printf("static double\tp_ref[%d] = {\n", nz);
  buf[0] = '\0';
  for (i = 0; i < nz; i++) {
    sprintf(b, "%.17g", p_ref[i]);
    if (i < (nz - 1))
      strcat(b, ",");
    if (strlen(buf) + strlen(b) > 110) {
      printf("\t%s\n", buf);
      buf[0] = '\0';
    }
    strcat(buf, b);
  }
  if (strlen(buf) != 0)
    printf("\t%s\n", buf);
  printf("\t};\n");
  printf("static double\tndepth_ref[%d] = {\n", nx * ny);
  buf[0] = '\0';
  for (i = 0; i < nx * ny; i++) {
    sprintf(b, "%.17g", ndepth_ref[i]);
    if (i < (nx * ny - 1))
      strcat(b, ",");
    if (strlen(buf) + strlen(b) > 110) {
      printf("\t%s\n", buf);
      buf[0] = '\0';
    }
    strcat(buf, b);
  }
  if (strlen(buf) != 0)
    printf("\t%s\n", buf);
  printf("\t};\n");
  printf("static double\tsaar_ref[%d] = {\n", nx * ny * nz);
  buf[0] = '\0';
  for (i = 0; i < nx * ny * nz; i++) {
    sprintf(b, "%.17g", saar_ref[i]);
    if (i < (nx * ny * nz - 1))
      strcat(b, ",");
    if (strlen(buf) + strlen(b) > 110) {
      printf("\t%s\n", buf);
      buf[0] = '\0';
    }
    strcat(buf, b);
  }
  if (strlen(buf) != 0)
    printf("\t%s\n", buf);
  printf("\t};\n");
  printf("static double\tdelta_sa_ref[%d] = {\n", nx * ny * nz);
  buf[0] = '\0';
  for (i = 0; i < nx * ny * nz; i++) {
    sprintf(b, "%.17g", delta_sa_ref[i]);
    if (i < (nx * ny * nz - 1))
      strcat(b, ",");
    if (strlen(buf) + strlen(b) > 110) {
      printf("\t%s\n", buf);
      buf[0] = '\0';
    }
    strcat(buf, b);
  }
  if (strlen(buf) != 0)
    printf("\t%s\n", buf);
  printf("\t};\n");
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x5b,-0x14(%rbp)
movl   $0x2d,-0x18(%rbp)
movl   $0x2d,-0x1c(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x28(%rbp)
movslq -0x18(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
imul   -0x1c(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x50(%rbp)
lea    0xd92(%rip),%rdi
lea    0xd9d(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x58(%rbp)
cmp    $0x0,%rax
jne    129e <main+0xee>
lea    0xd71(%rip),%rdi
call   10a0 <perror@plt>
mov    $0x1,%edi
call   10d0 <exit@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1300 <main+0x150>
lea    -0x160(%rbp),%rdi
mov    -0x58(%rbp),%rdx
mov    $0x100,%esi
call   1070 <fgets@plt>
cmp    $0x0,%rax
jne    12d5 <main+0x125>
jmp    1300 <main+0x150>
lea    -0x160(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtod@plt>
mov    -0x28(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12a5 <main+0xf5>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1362 <main+0x1b2>
lea    -0x160(%rbp),%rdi
mov    -0x58(%rbp),%rdx
mov    $0x100,%esi
call   1070 <fgets@plt>
cmp    $0x0,%rax
jne    1337 <main+0x187>
jmp    1362 <main+0x1b2>
lea    -0x160(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtod@plt>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1307 <main+0x157>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13c4 <main+0x214>
lea    -0x160(%rbp),%rdi
mov    -0x58(%rbp),%rdx
mov    $0x100,%esi
call   1070 <fgets@plt>
cmp    $0x0,%rax
jne    1399 <main+0x1e9>
jmp    13c4 <main+0x214>
lea    -0x160(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtod@plt>
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1369 <main+0x1b9>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    142c <main+0x27c>
lea    -0x160(%rbp),%rdi
mov    -0x58(%rbp),%rdx
mov    $0x100,%esi
call   1070 <fgets@plt>
cmp    $0x0,%rax
jne    1401 <main+0x251>
jmp    142c <main+0x27c>
lea    -0x160(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtod@plt>
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13cb <main+0x21b>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1498 <main+0x2e8>
lea    -0x160(%rbp),%rdi
mov    -0x58(%rbp),%rdx
mov    $0x100,%esi
call   1070 <fgets@plt>
cmp    $0x0,%rax
jne    146d <main+0x2bd>
jmp    1498 <main+0x2e8>
lea    -0x160(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtod@plt>
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1433 <main+0x283>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1504 <main+0x354>
lea    -0x160(%rbp),%rdi
mov    -0x58(%rbp),%rdx
mov    $0x100,%esi
call   1070 <fgets@plt>
cmp    $0x0,%rax
jne    14d9 <main+0x329>
jmp    1504 <main+0x354>
lea    -0x160(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1030 <strtod@plt>
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    149f <main+0x2ef>
mov    -0x58(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x1c(%rbp),%ecx
lea    0xaf7(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x14(%rbp),%esi
lea    0xb13(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1601 <main+0x451>
lea    -0x1a0(%rbp),%rdi
mov    -0x28(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0xaf8(%rip),%rsi
call   10c0 <sprintf@plt>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1593 <main+0x3e3>
lea    -0x1a0(%rbp),%rdi
lea    0xada(%rip),%rsi
call   10b0 <strcat@plt>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x1ac(%rbp)
lea    -0x1a0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x1ac(%rbp),%eax
add    %ecx,%eax
cmp    $0x6e,%eax
jle    15e0 <main+0x430>
lea    -0x160(%rbp),%rsi
lea    0xa98(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
lea    -0x160(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
call   10b0 <strcat@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1543 <main+0x393>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
je     162b <main+0x47b>
lea    -0x160(%rbp),%rsi
lea    0xa46(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xa3d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x18(%rbp),%esi
lea    0xa31(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1716 <main+0x566>
lea    -0x1a0(%rbp),%rdi
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x9e3(%rip),%rsi
call   10c0 <sprintf@plt>
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    16a8 <main+0x4f8>
lea    -0x1a0(%rbp),%rdi
lea    0x9c5(%rip),%rsi
call   10b0 <strcat@plt>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x1b0(%rbp)
lea    -0x1a0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x1b0(%rbp),%eax
add    %ecx,%eax
cmp    $0x6e,%eax
jle    16f5 <main+0x545>
lea    -0x160(%rbp),%rsi
lea    0x983(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
lea    -0x160(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
call   10b0 <strcat@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1658 <main+0x4a8>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
je     1740 <main+0x590>
lea    -0x160(%rbp),%rsi
lea    0x931(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x928(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x1c(%rbp),%esi
lea    0x93c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    182b <main+0x67b>
lea    -0x1a0(%rbp),%rdi
mov    -0x38(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x8ce(%rip),%rsi
call   10c0 <sprintf@plt>
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    17bd <main+0x60d>
lea    -0x1a0(%rbp),%rdi
lea    0x8b0(%rip),%rsi
call   10b0 <strcat@plt>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x1b4(%rbp)
lea    -0x1a0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x1b4(%rbp),%eax
add    %ecx,%eax
cmp    $0x6e,%eax
jle    180a <main+0x65a>
lea    -0x160(%rbp),%rsi
lea    0x86e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
lea    -0x160(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
call   10b0 <strcat@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    176d <main+0x5bd>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
je     1855 <main+0x6a5>
lea    -0x160(%rbp),%rsi
lea    0x81c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x813(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x14(%rbp),%esi
imul   -0x18(%rbp),%esi
lea    0x840(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    194e <main+0x79e>
lea    -0x1a0(%rbp),%rdi
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x7af(%rip),%rsi
call   10c0 <sprintf@plt>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    18e0 <main+0x730>
lea    -0x1a0(%rbp),%rdi
lea    0x78d(%rip),%rsi
call   10b0 <strcat@plt>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x1b8(%rbp)
lea    -0x1a0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x1b8(%rbp),%eax
add    %ecx,%eax
cmp    $0x6e,%eax
jle    192d <main+0x77d>
lea    -0x160(%rbp),%rsi
lea    0x74b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
lea    -0x160(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
call   10b0 <strcat@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1886 <main+0x6d6>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
je     1978 <main+0x7c8>
lea    -0x160(%rbp),%rsi
lea    0x6f9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x6f0(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x14(%rbp),%esi
imul   -0x18(%rbp),%esi
imul   -0x1c(%rbp),%esi
lea    0x73b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1a7d <main+0x8cd>
lea    -0x1a0(%rbp),%rdi
mov    -0x48(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x684(%rip),%rsi
call   10c0 <sprintf@plt>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1a0f <main+0x85f>
lea    -0x1a0(%rbp),%rdi
lea    0x65e(%rip),%rsi
call   10b0 <strcat@plt>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x1bc(%rbp)
lea    -0x1a0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x1bc(%rbp),%eax
add    %ecx,%eax
cmp    $0x6e,%eax
jle    1a5c <main+0x8ac>
lea    -0x160(%rbp),%rsi
lea    0x61c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
lea    -0x160(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
call   10b0 <strcat@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    19ad <main+0x7fd>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
je     1aa7 <main+0x8f7>
lea    -0x160(%rbp),%rsi
lea    0x5ca(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x5c1(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x14(%rbp),%esi
imul   -0x18(%rbp),%esi
imul   -0x1c(%rbp),%esi
lea    0x62c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1bac <main+0x9fc>
lea    -0x1a0(%rbp),%rdi
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x555(%rip),%rsi
call   10c0 <sprintf@plt>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1b3e <main+0x98e>
lea    -0x1a0(%rbp),%rdi
lea    0x52f(%rip),%rsi
call   10b0 <strcat@plt>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x1c0(%rbp)
lea    -0x1a0(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,%ecx
mov    -0x1c0(%rbp),%eax
add    %ecx,%eax
cmp    $0x6e,%eax
jle    1b8b <main+0x9db>
lea    -0x160(%rbp),%rsi
lea    0x4ed(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movb   $0x0,-0x160(%rbp)
lea    -0x160(%rbp),%rdi
lea    -0x1a0(%rbp),%rsi
call   10b0 <strcat@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1adc <main+0x92c>
lea    -0x160(%rbp),%rdi
call   1050 <strlen@plt>
cmp    $0x0,%eax
je     1bd6 <main+0xa26>
lea    -0x160(%rbp),%rsi
lea    0x49b(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x492(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
xor    %eax,%eax
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    $0x2d8,%edi
call   1090 <malloc@plt>
mov    %rax,%r12
mov    $0x168,%edi
call   1090 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    $0x168,%edi
call   1090 <malloc@plt>
mov    %rax,0x10(%rsp)
mov    $0x7ff8,%edi
call   1090 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    $0x167e98,%edi
call   1090 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    $0x167e98,%edi
call   1090 <malloc@plt>
mov    %rax,0x28(%rsp)
lea    0xdd0(%rip),%rdi
lea    0xddb(%rip),%rsi
call   10a0 <fopen@plt>
test   %rax,%rax
je     192d <main+0x76d>
mov    %rax,%r14
xor    %ebp,%ebp
lea    0x30(%rsp),%rbx
nop
mov    %rbx,%rdi
mov    $0x100,%esi
mov    %r14,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     127f <main+0xbf>
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <strtod@plt>
movsd  %xmm0,(%r12,%rbp,8)
add    $0x1,%rbp
cmp    $0x5b,%rbp
jne    1250 <main+0x90>
xor    %ebp,%ebp
lea    0x30(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    $0x100,%esi
mov    %r14,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     12c3 <main+0x103>
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <strtod@plt>
mov    0x8(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    $0x2d,%rbp
jne    1290 <main+0xd0>
xor    %ebp,%ebp
lea    0x30(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    $0x100,%esi
mov    %r14,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     1303 <main+0x143>
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <strtod@plt>
mov    0x10(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    $0x2d,%rbp
jne    12d0 <main+0x110>
xor    %ebp,%ebp
lea    0x30(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    $0x100,%esi
mov    %r14,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     1346 <main+0x186>
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <strtod@plt>
mov    0x18(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    $0xfff,%rbp
jne    1310 <main+0x150>
xor    %ebp,%ebp
lea    0x30(%rsp),%rbx
nopl   (%rax)
mov    %rbx,%rdi
mov    $0x100,%esi
mov    %r14,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     1386 <main+0x1c6>
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <strtod@plt>
mov    0x20(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    $0x2cfd3,%rbp
jne    1350 <main+0x190>
xor    %ebp,%ebp
lea    0x30(%rsp),%rbx
nopl   (%rax)
mov    %rbx,%rdi
mov    $0x100,%esi
mov    %r14,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     13c6 <main+0x206>
mov    %rbx,%rdi
xor    %esi,%esi
call   1040 <strtod@plt>
mov    0x28(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    $0x2cfd3,%rbp
jne    1390 <main+0x1d0>
mov    %r14,%rdi
call   1050 <fclose@plt>
lea    0xc3f(%rip),%rdi
mov    $0x5b,%esi
mov    $0x2d,%edx
mov    $0x2d,%ecx
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xc4f(%rip),%rdi
mov    $0x5b,%esi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
mov    $0xffffffffffffffa5,%r13
lea    0xc51(%rip),%r14
lea    0x130(%rsp),%rbp
lea    0x30(%rsp),%rbx
jmp    1430 <main+0x270>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   10c0 <strcat@plt>
inc    %r13
je     148d <main+0x2cd>
movsd  0x2d8(%r12,%r13,8),%xmm0
mov    %rbp,%rdi
mov    %r14,%rsi
call   10d0 <sprintf@plt>
cmp    $0xffffffffffffffff,%r13
je     145a <main+0x29a>
mov    %rbp,%rdi
lea    0xc13(%rip),%rsi
call   10c0 <strcat@plt>
mov    %rbx,%rdi
call   1060 <strlen@plt>
mov    %eax,%r15d
mov    %rbp,%rdi
call   1060 <strlen@plt>
add    %r15d,%eax
cmp    $0x6f,%eax
jl     1420 <main+0x260>
lea    0xbee(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
jmp    1420 <main+0x260>
lea    0x30(%rsp),%rdi
call   1060 <strlen@plt>
test   %eax,%eax
je     14ae <main+0x2ee>
lea    0xbc8(%rip),%rdi
lea    0x30(%rsp),%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xc5d(%rip),%rdi
call   1030 <puts@plt>
lea    0xbae(%rip),%rdi
mov    $0x2d,%esi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
mov    $0xffffffffffffffd3,%r12
lea    0xb82(%rip),%r14
lea    0x130(%rsp),%rbp
lea    0x30(%rsp),%r15
lea    0xb74(%rip),%r13
jmp    1510 <main+0x350>
cs nopw 0x0(%rax,%rax,1)
mov    %r15,%rdi
mov    %rbp,%rsi
call   10c0 <strcat@plt>
inc    %r12
je     156c <main+0x3ac>
mov    0x8(%rsp),%rax
movsd  0x168(%rax,%r12,8),%xmm0
mov    %rbp,%rdi
mov    %r14,%rsi
call   10d0 <sprintf@plt>
cmp    $0xffffffffffffffff,%r12
je     153b <main+0x37b>
mov    %rbp,%rdi
mov    %r13,%rsi
call   10c0 <strcat@plt>
mov    %r15,%rdi
call   1060 <strlen@plt>
mov    %eax,%ebx
mov    %rbp,%rdi
call   1060 <strlen@plt>
add    %ebx,%eax
cmp    $0x6f,%eax
jl     1500 <main+0x340>
lea    0xb0f(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
jmp    1500 <main+0x340>
lea    0x30(%rsp),%rdi
call   1060 <strlen@plt>
test   %eax,%eax
je     158d <main+0x3cd>
lea    0xae9(%rip),%rdi
lea    0x30(%rsp),%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xb7e(%rip),%rdi
call   1030 <puts@plt>
lea    0xaef(%rip),%rdi
mov    $0x2d,%esi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
mov    $0xffffffffffffffd3,%r15
lea    0xaa3(%rip),%r14
lea    0x130(%rsp),%rbp
lea    0x30(%rsp),%r13
lea    0xa95(%rip),%r12
jmp    15f0 <main+0x430>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rdi
mov    %rbp,%rsi
call   10c0 <strcat@plt>
inc    %r15
je     164c <main+0x48c>
mov    0x10(%rsp),%rax
movsd  0x168(%rax,%r15,8),%xmm0
mov    %rbp,%rdi
mov    %r14,%rsi
call   10d0 <sprintf@plt>
cmp    $0xffffffffffffffff,%r15
je     161b <main+0x45b>
mov    %rbp,%rdi
mov    %r12,%rsi
call   10c0 <strcat@plt>
mov    %r13,%rdi
call   1060 <strlen@plt>
mov    %eax,%ebx
mov    %rbp,%rdi
call   1060 <strlen@plt>
add    %ebx,%eax
cmp    $0x6f,%eax
jl     15e0 <main+0x420>
lea    0xa2f(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
jmp    15e0 <main+0x420>
lea    0x30(%rsp),%rdi
call   1060 <strlen@plt>
test   %eax,%eax
je     166d <main+0x4ad>
lea    0xa09(%rip),%rdi
lea    0x30(%rsp),%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xa9e(%rip),%rdi
call   1030 <puts@plt>
lea    0xa2c(%rip),%rdi
mov    $0xfff,%esi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
mov    $0xfffffffffffff001,%r15
lea    0x9c3(%rip),%r14
lea    0x130(%rsp),%rbp
lea    0x30(%rsp),%r13
lea    0x9b5(%rip),%r12
jmp    16d0 <main+0x510>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rdi
mov    %rbp,%rsi
call   10c0 <strcat@plt>
inc    %r15
je     172c <main+0x56c>
mov    0x18(%rsp),%rax
movsd  0x7ff8(%rax,%r15,8),%xmm0
mov    %rbp,%rdi
mov    %r14,%rsi
call   10d0 <sprintf@plt>
cmp    $0xffffffffffffffff,%r15
je     16fb <main+0x53b>
mov    %rbp,%rdi
mov    %r12,%rsi
call   10c0 <strcat@plt>
mov    %r13,%rdi
call   1060 <strlen@plt>
mov    %eax,%ebx
mov    %rbp,%rdi
call   1060 <strlen@plt>
add    %ebx,%eax
cmp    $0x6f,%eax
jl     16c0 <main+0x500>
lea    0x94f(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
jmp    16c0 <main+0x500>
lea    0x30(%rsp),%rdi
call   1060 <strlen@plt>
test   %eax,%eax
je     174d <main+0x58d>
lea    0x929(%rip),%rdi
lea    0x30(%rsp),%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x9be(%rip),%rdi
call   1030 <puts@plt>
lea    0x96e(%rip),%rdi
mov    $0x2cfd3,%esi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
mov    $0xfffffffffffd302d,%r15
lea    0x8e3(%rip),%r14
lea    0x130(%rsp),%rbp
lea    0x30(%rsp),%r13
lea    0x8d5(%rip),%r12
jmp    17b0 <main+0x5f0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rdi
mov    %rbp,%rsi
call   10c0 <strcat@plt>
inc    %r15
je     180c <main+0x64c>
mov    0x20(%rsp),%rax
movsd  0x167e98(%rax,%r15,8),%xmm0
mov    %rbp,%rdi
mov    %r14,%rsi
call   10d0 <sprintf@plt>
cmp    $0xffffffffffffffff,%r15
je     17db <main+0x61b>
mov    %rbp,%rdi
mov    %r12,%rsi
call   10c0 <strcat@plt>
mov    %r13,%rdi
call   1060 <strlen@plt>
mov    %eax,%ebx
mov    %rbp,%rdi
call   1060 <strlen@plt>
add    %ebx,%eax
cmp    $0x6f,%eax
jl     17a0 <main+0x5e0>
lea    0x86f(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
jmp    17a0 <main+0x5e0>
lea    0x30(%rsp),%rdi
call   1060 <strlen@plt>
test   %eax,%eax
je     182d <main+0x66d>
lea    0x849(%rip),%rdi
lea    0x30(%rsp),%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x8de(%rip),%rdi
call   1030 <puts@plt>
lea    0x8ae(%rip),%rdi
mov    $0x2cfd3,%esi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
mov    $0xfffffffffffd302d,%r15
lea    0x803(%rip),%r14
lea    0x130(%rsp),%rbp
lea    0x30(%rsp),%r13
lea    0x7f5(%rip),%r12
jmp    1890 <main+0x6d0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rdi
mov    %rbp,%rsi
call   10c0 <strcat@plt>
inc    %r15
je     18ec <main+0x72c>
mov    0x28(%rsp),%rax
movsd  0x167e98(%rax,%r15,8),%xmm0
mov    %rbp,%rdi
mov    %r14,%rsi
call   10d0 <sprintf@plt>
cmp    $0xffffffffffffffff,%r15
je     18bb <main+0x6fb>
mov    %rbp,%rdi
mov    %r12,%rsi
call   10c0 <strcat@plt>
mov    %r13,%rdi
call   1060 <strlen@plt>
mov    %eax,%ebx
mov    %rbp,%rdi
call   1060 <strlen@plt>
add    %ebx,%eax
cmp    $0x6f,%eax
jl     1880 <main+0x6c0>
lea    0x78f(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1070 <printf@plt>
movb   $0x0,0x30(%rsp)
jmp    1880 <main+0x6c0>
lea    0x30(%rsp),%rdi
call   1060 <strlen@plt>
test   %eax,%eax
je     190d <main+0x74d>
lea    0x769(%rip),%rdi
lea    0x30(%rsp),%rsi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0x7fe(%rip),%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x6cc(%rip),%rdi
call   10b0 <perror@plt>
mov    $0x1,%edi
call   10e0 <exit@plt>

LLVM IR (-O0):
@.str = [18 x i8] c"gsw_data_v3_0.dat\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [45 x i8] c"static int\09gsw_nx=%d, gsw_ny=%d, gsw_nz=%d;\0A\00"
@.str.3 = [33 x i8] c"static double\09longs_ref[%d] = {\0A\00"
@.str.4 = [6 x i8] c"%.17g\00"
@.str.5 = [2 x i8] c",\00"
@.str.6 = [5 x i8] c"\09%s\0A\00"
@.str.7 = [5 x i8] c"\09};\0A\00"
@.str.8 = [32 x i8] c"static double\09lats_ref[%d] = {\0A\00"
@.str.9 = [29 x i8] c"static double\09p_ref[%d] = {\0A\00"
@.str.10 = [34 x i8] c"static double\09ndepth_ref[%d] = {\0A\00"
@.str.11 = [32 x i8] c"static double\09saar_ref[%d] = {\0A\00"
@.str.12 = [36 x i8] c"static double\09delta_sa_ref[%d] = {\0A\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 i32
%9 = alloca i32
%10 = alloca double*
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca double*
%16 = alloca i32*
%17 = alloca [256 x i8]
%18 = alloca [64 x i8]
%19 = alloca i8*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 91, i32* %6
store i32 45, i32* %7
store i32 45, i32* %8
%20 = load i32, i32* %6
%21 = sext i32 %20 to i64
%22 = mul i64 %21, 8
%23 = trunc i64 %22 to i32
%24 = call double* @malloc(i32 %23)
store double* %24, double** %10
%25 = load i32, i32* %7
%26 = sext i32 %25 to i64
%27 = mul i64 %26, 8
%28 = trunc i64 %27 to i32
%29 = call double* @malloc(i32 %28)
store double* %29, double** %11
%30 = load i32, i32* %8
%31 = sext i32 %30 to i64
%32 = mul i64 %31, 8
%33 = trunc i64 %32 to i32
%34 = call double* @malloc(i32 %33)
store double* %34, double** %12
%35 = load i32, i32* %6
%36 = load i32, i32* %7
%37 = mul nsw i32 %35, %36
%38 = sext i32 %37 to i64
%39 = mul i64 %38, 8
%40 = trunc i64 %39 to i32
%41 = call double* @malloc(i32 %40)
store double* %41, double** %13
%42 = load i32, i32* %6
%43 = load i32, i32* %7
%44 = mul nsw i32 %42, %43
%45 = load i32, i32* %8
%46 = mul nsw i32 %44, %45
%47 = sext i32 %46 to i64
%48 = mul i64 %47, 8
%49 = trunc i64 %48 to i32
%50 = call double* @malloc(i32 %49)
store double* %50, double** %14
%51 = load i32, i32* %6
%52 = load i32, i32* %7
%53 = mul nsw i32 %51, %52
%54 = load i32, i32* %8
%55 = mul nsw i32 %53, %54
%56 = sext i32 %55 to i64
%57 = mul i64 %56, 8
%58 = trunc i64 %57 to i32
%59 = call double* @malloc(i32 %58)
store double* %59, double** %15
%60 = call i32* @fopen(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %60, i32** %16
%61 = icmp eq i32* %60, null
br i1 %61, label %62, label %65
62: ; preds = %2
%63 = call i32 @perror(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0))
%64 = call i32 @exit(i32 1)
unreachable
65: ; preds = %2
store i32 0, i32* %9
br label %66
66: ; preds = %83, %65
%67 = load i32, i32* %9
%68 = load i32, i32* %6
%69 = icmp slt i32 %67, %68
br i1 %69, label %70, label %86
70: ; preds = %66
%71 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%72 = load i32*, i32** %16
%73 = call i32* @fgets(i8* %71, i32 256, i32* %72)
%74 = icmp eq i32* %73, null
br i1 %74, label %75, label %76
75: ; preds = %70
br label %86
76: ; preds = %70
%77 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%78 = call double @strtod(i8* %77, i32* null)
%79 = load double*, double** %10
%80 = load i32, i32* %9
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
store double %78, double* %82
br label %83
83: ; preds = %76
%84 = load i32, i32* %9
%85 = add nsw i32 %84, 1
store i32 %85, i32* %9
br label %66
86: ; preds = %75, %66
store i32 0, i32* %9
br label %87
87: ; preds = %104, %86
%88 = load i32, i32* %9
%89 = load i32, i32* %7
%90 = icmp slt i32 %88, %89
br i1 %90, label %91, label %107
91: ; preds = %87
%92 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%93 = load i32*, i32** %16
%94 = call i32* @fgets(i8* %92, i32 256, i32* %93)
%95 = icmp eq i32* %94, null
br i1 %95, label %96, label %97
96: ; preds = %91
br label %107
97: ; preds = %91
%98 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%99 = call double @strtod(i8* %98, i32* null)
%100 = load double*, double** %11
%101 = load i32, i32* %9
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %100, i64 %102
store double %99, double* %103
br label %104
104: ; preds = %97
%105 = load i32, i32* %9
%106 = add nsw i32 %105, 1
store i32 %106, i32* %9
br label %87
107: ; preds = %96, %87
store i32 0, i32* %9
br label %108
108: ; preds = %125, %107
%109 = load i32, i32* %9
%110 = load i32, i32* %8
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %128
112: ; preds = %108
%113 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%114 = load i32*, i32** %16
%115 = call i32* @fgets(i8* %113, i32 256, i32* %114)
%116 = icmp eq i32* %115, null
br i1 %116, label %117, label %118
117: ; preds = %112
br label %128
118: ; preds = %112
%119 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%120 = call double @strtod(i8* %119, i32* null)
%121 = load double*, double** %12
%122 = load i32, i32* %9
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %121, i64 %123
store double %120, double* %124
br label %125
125: ; preds = %118
%126 = load i32, i32* %9
%127 = add nsw i32 %126, 1
store i32 %127, i32* %9
br label %108
128: ; preds = %117, %108
store i32 0, i32* %9
br label %129
129: ; preds = %148, %128
%130 = load i32, i32* %9
%131 = load i32, i32* %6
%132 = load i32, i32* %7
%133 = mul nsw i32 %131, %132
%134 = icmp slt i32 %130, %133
br i1 %134, label %135, label %151
135: ; preds = %129
%136 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%137 = load i32*, i32** %16
%138 = call i32* @fgets(i8* %136, i32 256, i32* %137)
%139 = icmp eq i32* %138, null
br i1 %139, label %140, label %141
140: ; preds = %135
br label %151
141: ; preds = %135
%142 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%143 = call double @strtod(i8* %142, i32* null)
%144 = load double*, double** %13
%145 = load i32, i32* %9
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds double, double* %144, i64 %146
store double %143, double* %147
br label %148
148: ; preds = %141
%149 = load i32, i32* %9
%150 = add nsw i32 %149, 1
store i32 %150, i32* %9
br label %129
151: ; preds = %140, %129
store i32 0, i32* %9
br label %152
152: ; preds = %173, %151
%153 = load i32, i32* %9
%154 = load i32, i32* %6
%155 = load i32, i32* %7
%156 = mul nsw i32 %154, %155
%157 = load i32, i32* %8
%158 = mul nsw i32 %156, %157
%159 = icmp slt i32 %153, %158
br i1 %159, label %160, label %176
160: ; preds = %152
%161 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%162 = load i32*, i32** %16
%163 = call i32* @fgets(i8* %161, i32 256, i32* %162)
%164 = icmp eq i32* %163, null
br i1 %164, label %165, label %166
165: ; preds = %160
br label %176
166: ; preds = %160
%167 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%168 = call double @strtod(i8* %167, i32* null)
%169 = load double*, double** %14
%170 = load i32, i32* %9
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %169, i64 %171
store double %168, double* %172
br label %173
173: ; preds = %166
%174 = load i32, i32* %9
%175 = add nsw i32 %174, 1
store i32 %175, i32* %9
br label %152
176: ; preds = %165, %152
store i32 0, i32* %9
br label %177
177: ; preds = %198, %176
%178 = load i32, i32* %9
%179 = load i32, i32* %6
%180 = load i32, i32* %7
%181 = mul nsw i32 %179, %180
%182 = load i32, i32* %8
%183 = mul nsw i32 %181, %182
%184 = icmp slt i32 %178, %183
br i1 %184, label %185, label %201
185: ; preds = %177
%186 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%187 = load i32*, i32** %16
%188 = call i32* @fgets(i8* %186, i32 256, i32* %187)
%189 = icmp eq i32* %188, null
br i1 %189, label %190, label %191
190: ; preds = %185
br label %201
191: ; preds = %185
%192 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%193 = call double @strtod(i8* %192, i32* null)
%194 = load double*, double** %15
%195 = load i32, i32* %9
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %194, i64 %196
store double %193, double* %197
br label %198
198: ; preds = %191
%199 = load i32, i32* %9
%200 = add nsw i32 %199, 1
store i32 %200, i32* %9
br label %177
201: ; preds = %190, %177
%202 = load i32*, i32** %16
%203 = call i32 @fclose(i32* %202)
%204 = load i32, i32* %6
%205 = load i32, i32* %7
%206 = load i32, i32* %8
%207 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.2, i64 0, i64 0), i32 %204, i32 %205, i32 %206)
%208 = load i32, i32* %6
%209 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0), i32 %208)
%210 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %210
store i32 0, i32* %9
br label %211
211: ; preds = %245, %201
%212 = load i32, i32* %9
%213 = load i32, i32* %6
%214 = icmp slt i32 %212, %213
br i1 %214, label %215, label %248
215: ; preds = %211
%216 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%217 = load double*, double** %10
%218 = load i32, i32* %9
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %217, i64 %219
%221 = load double, double* %220
%222 = call i32 @sprintf(i8* %216, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %221)
%223 = load i32, i32* %9
%224 = load i32, i32* %6
%225 = sub nsw i32 %224, 1
%226 = icmp slt i32 %223, %225
br i1 %226, label %227, label %230
227: ; preds = %215
%228 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%229 = call i32 @strcat(i8* %228, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %230
230: ; preds = %227, %215
%231 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%232 = call i32 @strlen(i8* %231)
%233 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%234 = call i32 @strlen(i8* %233)
%235 = add nsw i32 %232, %234
%236 = icmp sgt i32 %235, 110
br i1 %236, label %237, label %241
237: ; preds = %230
%238 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%239 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %238)
%240 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %240
br label %241
241: ; preds = %237, %230
%242 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%243 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%244 = call i32 @strcat(i8* %242, i8* %243)
br label %245
245: ; preds = %241
%246 = load i32, i32* %9
%247 = add nsw i32 %246, 1
store i32 %247, i32* %9
br label %211
248: ; preds = %211
%249 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%250 = call i32 @strlen(i8* %249)
%251 = icmp ne i32 %250, 0
br i1 %251, label %252, label %255
252: ; preds = %248
%253 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%254 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %253)
br label %255
255: ; preds = %252, %248
%256 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%257 = load i32, i32* %7
%258 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.8, i64 0, i64 0), i32 %257)
%259 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %259
store i32 0, i32* %9
br label %260
260: ; preds = %294, %255
%261 = load i32, i32* %9
%262 = load i32, i32* %7
%263 = icmp slt i32 %261, %262
br i1 %263, label %264, label %297
264: ; preds = %260
%265 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%266 = load double*, double** %11
%267 = load i32, i32* %9
%268 = sext i32 %267 to i64
%269 = getelementptr inbounds double, double* %266, i64 %268
%270 = load double, double* %269
%271 = call i32 @sprintf(i8* %265, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %270)
%272 = load i32, i32* %9
%273 = load i32, i32* %7
%274 = sub nsw i32 %273, 1
%275 = icmp slt i32 %272, %274
br i1 %275, label %276, label %279
276: ; preds = %264
%277 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%278 = call i32 @strcat(i8* %277, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %279
279: ; preds = %276, %264
%280 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%281 = call i32 @strlen(i8* %280)
%282 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%283 = call i32 @strlen(i8* %282)
%284 = add nsw i32 %281, %283
%285 = icmp sgt i32 %284, 110
br i1 %285, label %286, label %290
286: ; preds = %279
%287 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%288 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %287)
%289 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %289
br label %290
290: ; preds = %286, %279
%291 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%292 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%293 = call i32 @strcat(i8* %291, i8* %292)
br label %294
294: ; preds = %290
%295 = load i32, i32* %9
%296 = add nsw i32 %295, 1
store i32 %296, i32* %9
br label %260
297: ; preds = %260
%298 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%299 = call i32 @strlen(i8* %298)
%300 = icmp ne i32 %299, 0
br i1 %300, label %301, label %304
301: ; preds = %297
%302 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%303 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %302)
br label %304
304: ; preds = %301, %297
%305 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%306 = load i32, i32* %8
%307 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.9, i64 0, i64 0), i32 %306)
%308 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %308
store i32 0, i32* %9
br label %309
309: ; preds = %343, %304
%310 = load i32, i32* %9
%311 = load i32, i32* %8
%312 = icmp slt i32 %310, %311
br i1 %312, label %313, label %346
313: ; preds = %309
%314 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%315 = load double*, double** %12
%316 = load i32, i32* %9
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double, double* %315, i64 %317
%319 = load double, double* %318
%320 = call i32 @sprintf(i8* %314, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %319)
%321 = load i32, i32* %9
%322 = load i32, i32* %8
%323 = sub nsw i32 %322, 1
%324 = icmp slt i32 %321, %323
br i1 %324, label %325, label %328
325: ; preds = %313
%326 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%327 = call i32 @strcat(i8* %326, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %328
328: ; preds = %325, %313
%329 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%330 = call i32 @strlen(i8* %329)
%331 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%332 = call i32 @strlen(i8* %331)
%333 = add nsw i32 %330, %332
%334 = icmp sgt i32 %333, 110
br i1 %334, label %335, label %339
335: ; preds = %328
%336 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%337 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %336)
%338 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %338
br label %339
339: ; preds = %335, %328
%340 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%341 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%342 = call i32 @strcat(i8* %340, i8* %341)
br label %343
343: ; preds = %339
%344 = load i32, i32* %9
%345 = add nsw i32 %344, 1
store i32 %345, i32* %9
br label %309
346: ; preds = %309
%347 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%348 = call i32 @strlen(i8* %347)
%349 = icmp ne i32 %348, 0
br i1 %349, label %350, label %353
350: ; preds = %346
%351 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%352 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %351)
br label %353
353: ; preds = %350, %346
%354 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%355 = load i32, i32* %6
%356 = load i32, i32* %7
%357 = mul nsw i32 %355, %356
%358 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.10, i64 0, i64 0), i32 %357)
%359 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %359
store i32 0, i32* %9
br label %360
360: ; preds = %398, %353
%361 = load i32, i32* %9
%362 = load i32, i32* %6
%363 = load i32, i32* %7
%364 = mul nsw i32 %362, %363
%365 = icmp slt i32 %361, %364
br i1 %365, label %366, label %401
366: ; preds = %360
%367 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%368 = load double*, double** %13
%369 = load i32, i32* %9
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds double, double* %368, i64 %370
%372 = load double, double* %371
%373 = call i32 @sprintf(i8* %367, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %372)
%374 = load i32, i32* %9
%375 = load i32, i32* %6
%376 = load i32, i32* %7
%377 = mul nsw i32 %375, %376
%378 = sub nsw i32 %377, 1
%379 = icmp slt i32 %374, %378
br i1 %379, label %380, label %383
380: ; preds = %366
%381 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%382 = call i32 @strcat(i8* %381, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %383
383: ; preds = %380, %366
%384 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%385 = call i32 @strlen(i8* %384)
%386 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%387 = call i32 @strlen(i8* %386)
%388 = add nsw i32 %385, %387
%389 = icmp sgt i32 %388, 110
br i1 %389, label %390, label %394
390: ; preds = %383
%391 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%392 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %391)
%393 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %393
br label %394
394: ; preds = %390, %383
%395 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%396 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%397 = call i32 @strcat(i8* %395, i8* %396)
br label %398
398: ; preds = %394
%399 = load i32, i32* %9
%400 = add nsw i32 %399, 1
store i32 %400, i32* %9
br label %360
401: ; preds = %360
%402 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%403 = call i32 @strlen(i8* %402)
%404 = icmp ne i32 %403, 0
br i1 %404, label %405, label %408
405: ; preds = %401
%406 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%407 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %406)
br label %408
408: ; preds = %405, %401
%409 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%410 = load i32, i32* %6
%411 = load i32, i32* %7
%412 = mul nsw i32 %410, %411
%413 = load i32, i32* %8
%414 = mul nsw i32 %412, %413
%415 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.11, i64 0, i64 0), i32 %414)
%416 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %416
store i32 0, i32* %9
br label %417
417: ; preds = %459, %408
%418 = load i32, i32* %9
%419 = load i32, i32* %6
%420 = load i32, i32* %7
%421 = mul nsw i32 %419, %420
%422 = load i32, i32* %8
%423 = mul nsw i32 %421, %422
%424 = icmp slt i32 %418, %423
br i1 %424, label %425, label %462
425: ; preds = %417
%426 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%427 = load double*, double** %14
%428 = load i32, i32* %9
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds double, double* %427, i64 %429
%431 = load double, double* %430
%432 = call i32 @sprintf(i8* %426, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %431)
%433 = load i32, i32* %9
%434 = load i32, i32* %6
%435 = load i32, i32* %7
%436 = mul nsw i32 %434, %435
%437 = load i32, i32* %8
%438 = mul nsw i32 %436, %437
%439 = sub nsw i32 %438, 1
%440 = icmp slt i32 %433, %439
br i1 %440, label %441, label %444
441: ; preds = %425
%442 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%443 = call i32 @strcat(i8* %442, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %444
444: ; preds = %441, %425
%445 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%446 = call i32 @strlen(i8* %445)
%447 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%448 = call i32 @strlen(i8* %447)
%449 = add nsw i32 %446, %448
%450 = icmp sgt i32 %449, 110
br i1 %450, label %451, label %455
451: ; preds = %444
%452 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%453 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %452)
%454 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %454
br label %455
455: ; preds = %451, %444
%456 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%457 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%458 = call i32 @strcat(i8* %456, i8* %457)
br label %459
459: ; preds = %455
%460 = load i32, i32* %9
%461 = add nsw i32 %460, 1
store i32 %461, i32* %9
br label %417
462: ; preds = %417
%463 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%464 = call i32 @strlen(i8* %463)
%465 = icmp ne i32 %464, 0
br i1 %465, label %466, label %469
466: ; preds = %462
%467 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%468 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %467)
br label %469
469: ; preds = %466, %462
%470 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
%471 = load i32, i32* %6
%472 = load i32, i32* %7
%473 = mul nsw i32 %471, %472
%474 = load i32, i32* %8
%475 = mul nsw i32 %473, %474
%476 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.12, i64 0, i64 0), i32 %475)
%477 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %477
store i32 0, i32* %9
br label %478
478: ; preds = %520, %469
%479 = load i32, i32* %9
%480 = load i32, i32* %6
%481 = load i32, i32* %7
%482 = mul nsw i32 %480, %481
%483 = load i32, i32* %8
%484 = mul nsw i32 %482, %483
%485 = icmp slt i32 %479, %484
br i1 %485, label %486, label %523
486: ; preds = %478
%487 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%488 = load double*, double** %15
%489 = load i32, i32* %9
%490 = sext i32 %489 to i64
%491 = getelementptr inbounds double, double* %488, i64 %490
%492 = load double, double* %491
%493 = call i32 @sprintf(i8* %487, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %492)
%494 = load i32, i32* %9
%495 = load i32, i32* %6
%496 = load i32, i32* %7
%497 = mul nsw i32 %495, %496
%498 = load i32, i32* %8
%499 = mul nsw i32 %497, %498
%500 = sub nsw i32 %499, 1
%501 = icmp slt i32 %494, %500
br i1 %501, label %502, label %505
502: ; preds = %486
%503 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%504 = call i32 @strcat(i8* %503, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %505
505: ; preds = %502, %486
%506 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%507 = call i32 @strlen(i8* %506)
%508 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%509 = call i32 @strlen(i8* %508)
%510 = add nsw i32 %507, %509
%511 = icmp sgt i32 %510, 110
br i1 %511, label %512, label %516
512: ; preds = %505
%513 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%514 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %513)
%515 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
store i8 0, i8* %515
br label %516
516: ; preds = %512, %505
%517 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%518 = getelementptr inbounds [64 x i8], [64 x i8]* %18, i64 0, i64 0
%519 = call i32 @strcat(i8* %517, i8* %518)
br label %520
520: ; preds = %516
%521 = load i32, i32* %9
%522 = add nsw i32 %521, 1
store i32 %522, i32* %9
br label %478
523: ; preds = %478
%524 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%525 = call i32 @strlen(i8* %524)
%526 = icmp ne i32 %525, 0
br i1 %526, label %527, label %530
527: ; preds = %523
%528 = getelementptr inbounds [256 x i8], [256 x i8]* %17, i64 0, i64 0
%529 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %528)
br label %530
530: ; preds = %527, %523
%531 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.7, i64 0, i64 0))
ret i32 0
}

LLVM IR (-O2):
@.str = [18 x i8] c"gsw_data_v3_0.dat\00"
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [45 x i8] c"static int\09gsw_nx=%d, gsw_ny=%d, gsw_nz=%d;\0A\00"
@.str.3 = [33 x i8] c"static double\09longs_ref[%d] = {\0A\00"
@.str.4 = [6 x i8] c"%.17g\00"
@.str.5 = [2 x i8] c",\00"
@.str.6 = [5 x i8] c"\09%s\0A\00"
@.str.8 = [32 x i8] c"static double\09lats_ref[%d] = {\0A\00"
@.str.9 = [29 x i8] c"static double\09p_ref[%d] = {\0A\00"
@.str.10 = [34 x i8] c"static double\09ndepth_ref[%d] = {\0A\00"
@.str.11 = [32 x i8] c"static double\09saar_ref[%d] = {\0A\00"
@.str.12 = [36 x i8] c"static double\09delta_sa_ref[%d] = {\0A\00"
@str.17 = [4 x i8] c"\09};\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca [256 x i8]
%4 = alloca [64 x i8]
%5 = getelementptr inbounds [256 x i8], [256 x i8]* %3, i64 0, i64 0
%6 = getelementptr inbounds [64 x i8], [64 x i8]* %4, i64 0, i64 0
%7 = tail call double* @malloc(i32 728)
%8 = tail call double* @malloc(i32 360)
%9 = tail call double* @malloc(i32 360)
%10 = tail call double* @malloc(i32 32760)
%11 = tail call double* @malloc(i32 1474200)
%12 = tail call double* @malloc(i32 1474200)
%13 = tail call i32* @fopen(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%14 = icmp eq i32* %13, null
br i1 %14, label %15, label %18
15: ; preds = %2
%16 = tail call i32 @perror(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0))
%17 = tail call i32 @exit(i32 1)
unreachable
18: ; preds = %2, %22
%19 = phi i64 [ %25, %22 ], [ 0, %2 ]
%20 = call i32* @fgets(i8* %5, i32 256, i32* %13)
%21 = icmp eq i32* %20, null
br i1 %21, label %27, label %22
22: ; preds = %18
%23 = call double @strtod(i8* nocapture %5, i32* null)
%24 = getelementptr inbounds double, double* %7, i64 %19
store double %23, double* %24
%25 = add nuw nsw i64 %19, 1
%26 = icmp eq i64 %25, 91
br i1 %26, label %27, label %18
27: ; preds = %18, %22
br label %28
28: ; preds = %27, %32
%29 = phi i64 [ %35, %32 ], [ 0, %27 ]
%30 = call i32* @fgets(i8* %5, i32 256, i32* %13)
%31 = icmp eq i32* %30, null
br i1 %31, label %37, label %32
32: ; preds = %28
%33 = call double @strtod(i8* nocapture %5, i32* null)
%34 = getelementptr inbounds double, double* %8, i64 %29
store double %33, double* %34
%35 = add nuw nsw i64 %29, 1
%36 = icmp eq i64 %35, 45
br i1 %36, label %37, label %28
37: ; preds = %28, %32
br label %38
38: ; preds = %37, %42
%39 = phi i64 [ %45, %42 ], [ 0, %37 ]
%40 = call i32* @fgets(i8* %5, i32 256, i32* %13)
%41 = icmp eq i32* %40, null
br i1 %41, label %47, label %42
42: ; preds = %38
%43 = call double @strtod(i8* nocapture %5, i32* null)
%44 = getelementptr inbounds double, double* %9, i64 %39
store double %43, double* %44
%45 = add nuw nsw i64 %39, 1
%46 = icmp eq i64 %45, 45
br i1 %46, label %47, label %38
47: ; preds = %38, %42
br label %48
48: ; preds = %47, %52
%49 = phi i64 [ %55, %52 ], [ 0, %47 ]
%50 = call i32* @fgets(i8* %5, i32 256, i32* %13)
%51 = icmp eq i32* %50, null
br i1 %51, label %57, label %52
52: ; preds = %48
%53 = call double @strtod(i8* nocapture %5, i32* null)
%54 = getelementptr inbounds double, double* %10, i64 %49
store double %53, double* %54
%55 = add nuw nsw i64 %49, 1
%56 = icmp eq i64 %55, 4095
br i1 %56, label %57, label %48
57: ; preds = %48, %52
br label %58
58: ; preds = %57, %62
%59 = phi i64 [ %65, %62 ], [ 0, %57 ]
%60 = call i32* @fgets(i8* %5, i32 256, i32* %13)
%61 = icmp eq i32* %60, null
br i1 %61, label %67, label %62
62: ; preds = %58
%63 = call double @strtod(i8* nocapture %5, i32* null)
%64 = getelementptr inbounds double, double* %11, i64 %59
store double %63, double* %64
%65 = add nuw nsw i64 %59, 1
%66 = icmp eq i64 %65, 184275
br i1 %66, label %67, label %58
67: ; preds = %58, %62
br label %68
68: ; preds = %67, %72
%69 = phi i64 [ %75, %72 ], [ 0, %67 ]
%70 = call i32* @fgets(i8* %5, i32 256, i32* %13)
%71 = icmp eq i32* %70, null
br i1 %71, label %77, label %72
72: ; preds = %68
%73 = call double @strtod(i8* nocapture %5, i32* null)
%74 = getelementptr inbounds double, double* %12, i64 %69
store double %73, double* %74
%75 = add nuw nsw i64 %69, 1
%76 = icmp eq i64 %75, 184275
br i1 %76, label %77, label %68
77: ; preds = %68, %72
%78 = call i32 @fclose(i32* %13)
%79 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.2, i64 0, i64 0), i32 91, i32 45, i32 45)
%80 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0), i32 91)
store i8 0, i8* %5
br label %81
81: ; preds = %77, %96
%82 = phi i64 [ 0, %77 ], [ %98, %96 ]
%83 = getelementptr inbounds double, double* %7, i64 %82
%84 = load double, double* %83
%85 = call i32 @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %84)
%86 = icmp eq i64 %82, 90
br i1 %86, label %89, label %87
87: ; preds = %81
%88 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %89
89: ; preds = %87, %81
%90 = call i32 @strlen(i8* %5)
%91 = call i32 @strlen(i8* %6)
%92 = add nsw i32 %91, %90
%93 = icmp sgt i32 %92, 110
br i1 %93, label %94, label %96
94: ; preds = %89
%95 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
store i8 0, i8* %5
br label %96
96: ; preds = %94, %89
%97 = call i32 @strcat(i8* %5, i8* %6)
%98 = add nuw nsw i64 %82, 1
%99 = icmp eq i64 %98, 91
br i1 %99, label %100, label %81
100: ; preds = %96
%101 = call i32 @strlen(i8* %5)
%102 = icmp eq i32 %101, 0
br i1 %102, label %105, label %103
103: ; preds = %100
%104 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
br label %105
105: ; preds = %103, %100
%106 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.17, i64 0, i64 0))
%107 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.8, i64 0, i64 0), i32 45)
store i8 0, i8* %5
br label %108
108: ; preds = %105, %123
%109 = phi i64 [ 0, %105 ], [ %125, %123 ]
%110 = getelementptr inbounds double, double* %8, i64 %109
%111 = load double, double* %110
%112 = call i32 @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %111)
%113 = icmp eq i64 %109, 44
br i1 %113, label %116, label %114
114: ; preds = %108
%115 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %116
116: ; preds = %114, %108
%117 = call i32 @strlen(i8* %5)
%118 = call i32 @strlen(i8* %6)
%119 = add nsw i32 %118, %117
%120 = icmp sgt i32 %119, 110
br i1 %120, label %121, label %123
121: ; preds = %116
%122 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
store i8 0, i8* %5
br label %123
123: ; preds = %121, %116
%124 = call i32 @strcat(i8* %5, i8* %6)
%125 = add nuw nsw i64 %109, 1
%126 = icmp eq i64 %125, 45
br i1 %126, label %127, label %108
127: ; preds = %123
%128 = call i32 @strlen(i8* %5)
%129 = icmp eq i32 %128, 0
br i1 %129, label %132, label %130
130: ; preds = %127
%131 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
br label %132
132: ; preds = %130, %127
%133 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.17, i64 0, i64 0))
%134 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.9, i64 0, i64 0), i32 45)
store i8 0, i8* %5
br label %135
135: ; preds = %132, %150
%136 = phi i64 [ 0, %132 ], [ %152, %150 ]
%137 = getelementptr inbounds double, double* %9, i64 %136
%138 = load double, double* %137
%139 = call i32 @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %138)
%140 = icmp eq i64 %136, 44
br i1 %140, label %143, label %141
141: ; preds = %135
%142 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %143
143: ; preds = %141, %135
%144 = call i32 @strlen(i8* %5)
%145 = call i32 @strlen(i8* %6)
%146 = add nsw i32 %145, %144
%147 = icmp sgt i32 %146, 110
br i1 %147, label %148, label %150
148: ; preds = %143
%149 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
store i8 0, i8* %5
br label %150
150: ; preds = %148, %143
%151 = call i32 @strcat(i8* %5, i8* %6)
%152 = add nuw nsw i64 %136, 1
%153 = icmp eq i64 %152, 45
br i1 %153, label %154, label %135
154: ; preds = %150
%155 = call i32 @strlen(i8* %5)
%156 = icmp eq i32 %155, 0
br i1 %156, label %159, label %157
157: ; preds = %154
%158 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
br label %159
159: ; preds = %157, %154
%160 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.17, i64 0, i64 0))
%161 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @.str.10, i64 0, i64 0), i32 4095)
store i8 0, i8* %5
br label %162
162: ; preds = %159, %177
%163 = phi i64 [ 0, %159 ], [ %179, %177 ]
%164 = getelementptr inbounds double, double* %10, i64 %163
%165 = load double, double* %164
%166 = call i32 @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %165)
%167 = icmp eq i64 %163, 4094
br i1 %167, label %170, label %168
168: ; preds = %162
%169 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %170
170: ; preds = %168, %162
%171 = call i32 @strlen(i8* %5)
%172 = call i32 @strlen(i8* %6)
%173 = add nsw i32 %172, %171
%174 = icmp sgt i32 %173, 110
br i1 %174, label %175, label %177
175: ; preds = %170
%176 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
store i8 0, i8* %5
br label %177
177: ; preds = %175, %170
%178 = call i32 @strcat(i8* %5, i8* %6)
%179 = add nuw nsw i64 %163, 1
%180 = icmp eq i64 %179, 4095
br i1 %180, label %181, label %162
181: ; preds = %177
%182 = call i32 @strlen(i8* %5)
%183 = icmp eq i32 %182, 0
br i1 %183, label %186, label %184
184: ; preds = %181
%185 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
br label %186
186: ; preds = %184, %181
%187 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.17, i64 0, i64 0))
%188 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.11, i64 0, i64 0), i32 184275)
store i8 0, i8* %5
br label %189
189: ; preds = %186, %204
%190 = phi i64 [ 0, %186 ], [ %206, %204 ]
%191 = getelementptr inbounds double, double* %11, i64 %190
%192 = load double, double* %191
%193 = call i32 @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %192)
%194 = icmp eq i64 %190, 184274
br i1 %194, label %197, label %195
195: ; preds = %189
%196 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %197
197: ; preds = %195, %189
%198 = call i32 @strlen(i8* %5)
%199 = call i32 @strlen(i8* %6)
%200 = add nsw i32 %199, %198
%201 = icmp sgt i32 %200, 110
br i1 %201, label %202, label %204
202: ; preds = %197
%203 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
store i8 0, i8* %5
br label %204
204: ; preds = %202, %197
%205 = call i32 @strcat(i8* %5, i8* %6)
%206 = add nuw nsw i64 %190, 1
%207 = icmp eq i64 %206, 184275
br i1 %207, label %208, label %189
208: ; preds = %204
%209 = call i32 @strlen(i8* %5)
%210 = icmp eq i32 %209, 0
br i1 %210, label %213, label %211
211: ; preds = %208
%212 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
br label %213
213: ; preds = %211, %208
%214 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.17, i64 0, i64 0))
%215 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.12, i64 0, i64 0), i32 184275)
store i8 0, i8* %5
br label %216
216: ; preds = %213, %231
%217 = phi i64 [ 0, %213 ], [ %233, %231 ]
%218 = getelementptr inbounds double, double* %12, i64 %217
%219 = load double, double* %218
%220 = call i32 @sprintf(i8* %6, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), double %219)
%221 = icmp eq i64 %217, 184274
br i1 %221, label %224, label %222
222: ; preds = %216
%223 = call i32 @strcat(i8* %6, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
br label %224
224: ; preds = %222, %216
%225 = call i32 @strlen(i8* %5)
%226 = call i32 @strlen(i8* %6)
%227 = add nsw i32 %226, %225
%228 = icmp sgt i32 %227, 110
br i1 %228, label %229, label %231
229: ; preds = %224
%230 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
store i8 0, i8* %5
br label %231
231: ; preds = %229, %224
%232 = call i32 @strcat(i8* %5, i8* %6)
%233 = add nuw nsw i64 %217, 1
%234 = icmp eq i64 %233, 184275
br i1 %234, label %235, label %216
235: ; preds = %231
%236 = call i32 @strlen(i8* %5)
%237 = icmp eq i32 %236, 0
br i1 %237, label %240, label %238
238: ; preds = %235
%239 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i64 0, i64 0), i8* %5)
br label %240
240: ; preds = %238, %235
%241 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.17, i64 0, i64 0))
ret i32 0
}