#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 */
char EOF;
double NAN;
int /*<<< orphan*/ SEEK_CUR;
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ fseek(int /*<<< orphan*/ *, int, int /*<<< orphan*/);
char getc(int /*<<< orphan*/ *);
int /*<<< orphan*/ rewind(int /*<<< orphan*/ *);
int /*<<< orphan*/ sprintf(char *, char *, char *);
int /*<<< orphan*/ stderr;
scalar_t__ strcasecmp(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
double strtod(char *, char **);
double ***importmelts(const int allwdRws, const int allwdClmns, char prefix[],
                      double ***importedMelts, double **rawMatrix, int *rows,
                      int *columns, char **names, char ***elements,
                      int *minerals) {
  FILE *fp;
  char filePath[50];
  sprintf(filePath, "%sPhase_main_tbl.txt", prefix);
  fp = fopen(filePath, "r");
  char c, teststr[8];
  int a, numMinerals = 0, numColumns = 0, maxColumns = 0, numChars = 0,
         maxChars = 0, numRows = 0;
  for (c = getc(fp); c != EOF; c = getc(fp)) {
    numChars++;
    if (c == ' ') {
      numColumns++;
    }
    if (c == '\n') {
      numRows++;
      fseek(fp, -2, SEEK_CUR);
      if (getc(fp) != ' ') {
        numColumns++;
      }
      fseek(fp, +1, SEEK_CUR);
      if (numChars > maxChars) {
        maxChars = numChars;
      }
      if (numColumns > maxColumns) {
        maxColumns = numColumns;
      }
      numChars = 0;
      numColumns = 0;
      c = getc(fp);
      if (c == 'P') {
        for (a = 0; a < 7; a++) {
          teststr[a] = getc(fp);
        }
        teststr[7] = '\0';
        fseek(fp, -7, SEEK_CUR);
        if (strcasecmp(teststr, "ressure") == 0) {
          numMinerals++;
        }
      }
      if (c != EOF) {
        fseek(fp, -1, SEEK_CUR);
      }
    }
  }
  fseek(fp, -1, SEEK_CUR);
  if (getc(fp) != '\n') {
    numRows++;
  }
  if (numRows > (allwdRws * (*minerals))) {
    fprintf(stderr, "%s : Too many melts rows\n", prefix);
    *minerals = 0;
    return NULL;
  }
  if (maxColumns > allwdClmns) {
    fprintf(stderr, "%s : Too many melts columns\n", prefix);
    *minerals = 0;
    return NULL;
  }
  int mineral = 0, i = 0, j = 0, k, i_last, field[maxColumns + 2];
  char str[maxChars + 2], str_last[maxChars + 2];
  char *endp;
  rewind(fp);
  while (fgets(str, maxChars + 2, fp) != NULL) {
    field[0] = 0;
    for (k = 1; k < maxColumns + 2; k++) {
      field[k] = maxChars + 1;
    }
    for (k = 0, numColumns = 0; str[k] != '\0'; k++) {
      if (str[k] == ' ') {
        str[k] = '\0';
        field[numColumns + 1] = k + 1;
        numColumns++;
      } else if (str[k] == '\n') {
        str[k] = '\0';
        if (k > 0) {
          if (str[k - 1] != '\0') {
            numColumns++;
          }
        }
      }
    }
    for (j = 0; j < maxColumns; j++) {
      rawMatrix[i][j] = strtod(&str[field[j]], &endp);
      if (endp == &str[field[j]]) {
        rawMatrix[i][j] = NAN;
      }
    }
    if (strcasecmp(&str[0], "pressure") == 0) {
      importedMelts[mineral] = &rawMatrix[i + 1];
      strcpy(names[mineral], str_last);
      for (k = 0; k < numColumns; k++) {
        strcpy(elements[mineral][k], &str[field[k]]);
      }
      columns[mineral] = numColumns;
      if (mineral > 0) {
        rows[mineral - 1] = i - i_last - 3;
      }
      mineral++;
      if (mineral > *minerals) {
        fprintf(stderr, "%s : Too many minerals\n", prefix);
        break;
      }
      i_last = i;
    }
    strcpy(str_last, str);
    i++;
  }
  fclose(fp);
  rows[mineral - 1] = i - i_last - 1;
  *minerals = mineral;
  return importedMelts;
}


x86 assembly (clang, -O0):
<importmelts>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0xc(%rbp)
mov    %esi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
lea    -0x70(%rbp),%rdi
mov    -0x18(%rbp),%rdx
lea    0xe10(%rip),%rsi
call   10c0 <sprintf@plt>
lea    -0x70(%rbp),%rdi
lea    0xe15(%rip),%rsi
call   10b0 <fopen@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
movl   $0x0,-0x90(%rbp)
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0x98(%rbp)
mov    -0x38(%rbp),%rdi
call   10d0 <getc@plt>
mov    %al,-0x71(%rbp)
movsbl -0x71(%rbp),%eax
mov    0x2d7c(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     142c <importmelts+0x27c>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
movsbl -0x71(%rbp),%eax
cmp    $0x20,%eax
jne    1292 <importmelts+0xe2>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
movsbl -0x71(%rbp),%eax
cmp    $0xa,%eax
jne    1416 <importmelts+0x266>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x38(%rbp),%rdi
mov    0x2d27(%rip),%rax
mov    (%rax),%edx
mov    $0xfffffffe,%esi
call   10a0 <fseek@plt>
mov    -0x38(%rbp),%rdi
call   10d0 <getc@plt>
movsbl %al,%eax
cmp    $0x20,%eax
je     12e9 <importmelts+0x139>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x38(%rbp),%rdi
mov    0x2cec(%rip),%rax
mov    (%rax),%edx
mov    $0x1,%esi
call   10a0 <fseek@plt>
mov    -0x90(%rbp),%eax
cmp    -0x94(%rbp),%eax
jle    131e <importmelts+0x16e>
mov    -0x90(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jle    133c <importmelts+0x18c>
mov    -0x88(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x90(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x38(%rbp),%rdi
call   10d0 <getc@plt>
mov    %al,-0x71(%rbp)
movsbl -0x71(%rbp),%eax
cmp    $0x50,%eax
jne    13e4 <importmelts+0x234>
movl   $0x0,-0x80(%rbp)
cmpl   $0x7,-0x80(%rbp)
jge    139b <importmelts+0x1eb>
mov    -0x38(%rbp),%rdi
call   10d0 <getc@plt>
mov    %al,%cl
movslq -0x80(%rbp),%rax
mov    %cl,-0x79(%rbp,%rax,1)
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1370 <importmelts+0x1c0>
movb   $0x0,-0x72(%rbp)
mov    -0x38(%rbp),%rdi
mov    0x2c36(%rip),%rax
mov    (%rax),%edx
mov    $0xfffffff9,%esi
call   10a0 <fseek@plt>
lea    -0x79(%rbp),%rdi
lea    0xc8e(%rip),%rsi
call   1030 <strcasecmp@plt>
cmp    $0x0,%rax
jne    13df <importmelts+0x22f>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    13e4 <importmelts+0x234>
movsbl -0x71(%rbp),%eax
mov    0x2be9(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     1411 <importmelts+0x261>
mov    -0x38(%rbp),%rdi
mov    0x2bdb(%rip),%rax
mov    (%rax),%edx
mov    $0xffffffff,%esi
call   10a0 <fseek@plt>
jmp    1416 <importmelts+0x266>
jmp    141b <importmelts+0x26b>
mov    -0x38(%rbp),%rdi
call   10d0 <getc@plt>
mov    %al,-0x71(%rbp)
jmp    1251 <importmelts+0xa1>
mov    -0x38(%rbp),%rdi
mov    0x2ba9(%rip),%rax
mov    (%rax),%edx
mov    $0xffffffff,%esi
call   10a0 <fseek@plt>
mov    -0x38(%rbp),%rdi
call   10d0 <getc@plt>
movsbl %al,%eax
cmp    $0xa,%eax
je     1467 <importmelts+0x2b7>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0xc(%rbp),%ecx
mov    0x28(%rbp),%rdx
imul   (%rdx),%ecx
cmp    %ecx,%eax
jle    14af <importmelts+0x2ff>
mov    0x2b42(%rip),%rax
mov    (%rax),%edi
mov    -0x18(%rbp),%rdx
lea    0xb84(%rip),%rsi
call   1090 <fprintf@plt>
mov    0x28(%rbp),%rax
movl   $0x0,(%rax)
movq   $0x0,-0x8(%rbp)
jmp    19d0 <importmelts+0x820>
mov    -0x8c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    14ee <importmelts+0x33e>
mov    0x2b03(%rip),%rax
mov    (%rax),%edi
mov    -0x18(%rbp),%rdx
lea    0xb5f(%rip),%rsi
call   1090 <fprintf@plt>
mov    0x28(%rbp),%rax
movl   $0x0,(%rax)
movq   $0x0,-0x8(%rbp)
jmp    19d0 <importmelts+0x820>
movl   $0x0,-0x9c(%rbp)
movl   $0x0,-0xa0(%rbp)
movl   $0x0,-0xa4(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x2,%eax
mov    %rsp,%rcx
mov    %rcx,-0xb8(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xf0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xc0(%rbp)
mov    -0x94(%rbp),%eax
add    $0x2,%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xe8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xc8(%rbp)
mov    -0x94(%rbp),%eax
add    $0x2,%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xe0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0xd0(%rbp)
mov    -0x38(%rbp),%rdi
call   1070 <rewind@plt>
mov    -0xe8(%rbp),%rdi
mov    -0x94(%rbp),%esi
add    $0x2,%esi
mov    -0x38(%rbp),%rdx
call   1080 <fgets@plt>
cmp    $0x0,%rax
je     1987 <importmelts+0x7d7>
mov    -0xf0(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
mov    -0x8c(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    1620 <importmelts+0x470>
mov    -0xf0(%rbp),%rax
mov    -0x94(%rbp),%edx
add    $0x1,%edx
movslq -0xa8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    15db <importmelts+0x42b>
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0xe8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1740 <importmelts+0x590>
mov    -0xe8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    16af <importmelts+0x4ff>
mov    -0xf0(%rbp),%rax
mov    -0xe8(%rbp),%rcx
movslq -0xa8(%rbp),%rdx
movb   $0x0,(%rcx,%rdx,1)
mov    -0xa8(%rbp),%edx
add    $0x1,%edx
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1727 <importmelts+0x577>
mov    -0xe8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
jne    1722 <importmelts+0x572>
mov    -0xe8(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
cmpl   $0x0,-0xa8(%rbp)
jle    171d <importmelts+0x56d>
mov    -0xe8(%rbp),%rax
mov    -0xa8(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1718 <importmelts+0x568>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    171d <importmelts+0x56d>
jmp    1722 <importmelts+0x572>
jmp    1727 <importmelts+0x577>
jmp    172c <importmelts+0x57c>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1634 <importmelts+0x484>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x8c(%rbp),%eax
jge    180a <importmelts+0x65a>
mov    -0xe8(%rbp),%rdi
mov    -0xf0(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
add    %rax,%rdi
lea    -0xd8(%rbp),%rsi
call   1050 <strtod@plt>
mov    -0xf0(%rbp),%rdx
mov    -0xe8(%rbp),%rcx
mov    -0x28(%rbp),%rax
movslq -0xa0(%rbp),%rsi
mov    (%rax,%rsi,8),%rax
movslq -0xa4(%rbp),%rsi
movsd  %xmm0,(%rax,%rsi,8)
mov    -0xd8(%rbp),%rax
movslq -0xa4(%rbp),%rsi
movslq (%rdx,%rsi,4),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jne    17f1 <importmelts+0x641>
mov    0x2826(%rip),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    17f6 <importmelts+0x646>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    174a <importmelts+0x59a>
mov    -0xe8(%rbp),%rdi
lea    0x836(%rip),%rsi
call   1030 <strcasecmp@plt>
cmp    $0x0,%rax
jne    1960 <importmelts+0x7b0>
mov    -0xe0(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1040 <strcpy@plt>
movl   $0x0,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x88(%rbp),%eax
jge    18d2 <importmelts+0x722>
mov    -0xe8(%rbp),%rsi
mov    -0xf0(%rbp),%rax
mov    0x20(%rbp),%rcx
movslq -0x9c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0xa8(%rbp),%rdx
mov    (%rcx,%rdx,8),%rdi
movslq -0xa8(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
add    %rax,%rsi
call   1040 <strcpy@plt>
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1871 <importmelts+0x6c1>
mov    -0x88(%rbp),%edx
mov    0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x9c(%rbp)
jle    1915 <importmelts+0x765>
mov    -0xa0(%rbp),%edx
sub    -0xac(%rbp),%edx
sub    $0x3,%edx
mov    -0x30(%rbp),%rax
mov    -0x9c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    0x28(%rbp),%rcx
cmp    (%rcx),%eax
jle    1954 <importmelts+0x7a4>
mov    0x268b(%rip),%rax
mov    (%rax),%edi
mov    -0x18(%rbp),%rdx
lea    0x70d(%rip),%rsi
call   1090 <fprintf@plt>
jmp    1987 <importmelts+0x7d7>
mov    -0xa0(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xe8(%rbp),%rsi
mov    -0xe0(%rbp),%rdi
call   1040 <strcpy@plt>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    15a1 <importmelts+0x3f1>
mov    -0x38(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0xa0(%rbp),%edx
sub    -0xac(%rbp),%edx
sub    $0x1,%edx
mov    -0x30(%rbp),%rax
mov    -0x9c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x9c(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,%rsp
mov    -0x8(%rbp),%rax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<importmelts>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r9,-0x80(%rbp)
mov    %r8,-0xa8(%rbp)
mov    %rcx,-0x88(%rbp)
mov    %esi,-0x68(%rbp)
mov    %edi,-0x58(%rbp)
lea    0xe1d(%rip),%rsi
lea    -0x140(%rbp),%rbx
mov    %rbx,%rdi
mov    %rdx,-0x60(%rbp)
call   10c0 <sprintf@plt>
lea    0xe18(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <fopen@plt>
mov    %rax,-0x38(%rbp)
mov    %rax,%rdi
call   10d0 <getc@plt>
mov    0x2dc0(%rip),%rcx
xor    %ebx,%ebx
mov    $0x0,%edx
movl   $0x0,-0x30(%rbp)
cmp    (%rcx),%al
jne    1284 <importmelts+0xd4>
mov    %rdx,%r14
mov    %rbx,-0x50(%rbp)
mov    0x2da8(%rip),%rax
mov    (%rax),%edx
mov    -0x38(%rbp),%rbx
mov    %rbx,%rdi
mov    $0xffffffff,%esi
call   10a0 <fseek@plt>
mov    %rbx,%rdi
call   10d0 <getc@plt>
xor    %ecx,%ecx
cmp    $0xa,%al
setne  %cl
add    -0x30(%rbp),%ecx
mov    0x28(%rbp),%rbx
mov    -0x58(%rbp),%eax
imul   (%rbx),%eax
cmp    %eax,%ecx
jle    13d7 <importmelts+0x227>
mov    0x2d52(%rip),%rax
mov    (%rax),%edi
lea    0xd98(%rip),%rsi
jmp    13f0 <importmelts+0x240>
movl   $0x0,-0x30(%rbp)
xor    %r13d,%r13d
xor    %r14d,%r14d
xor    %r12d,%r12d
xor    %r15d,%r15d
jmp    12c4 <importmelts+0x114>
nopl   0x0(%rax)
mov    %r12d,%ebx
mov    %esi,%r14d
mov    -0x38(%rbp),%rdi
call   10d0 <getc@plt>
mov    %r13,%rdx
mov    %ebx,%r12d
mov    0x2d1c(%rip),%rcx
cmp    (%rcx),%al
je     122a <importmelts+0x7a>
mov    %r15d,%ecx
lea    0x1(%r14),%esi
xor    %r15d,%r15d
cmp    $0x20,%al
sete   %r15b
add    %ecx,%r15d
cmp    $0xa,%al
jne    12a0 <importmelts+0xf0>
mov    0x2cfe(%rip),%rax
mov    %r14,-0x70(%rbp)
mov    (%rax),%edx
mov    %rsi,%rbx
mov    -0x38(%rbp),%r14
mov    %r14,%rdi
mov    $0xfffffffe,%esi
call   10a0 <fseek@plt>
mov    %r14,%rdi
call   10d0 <getc@plt>
xor    %ecx,%ecx
cmp    $0x20,%al
setne  %cl
add    %ecx,%r15d
mov    0x2ccb(%rip),%rax
mov    (%rax),%edx
mov    %r14,%rdi
mov    $0x1,%esi
call   10a0 <fseek@plt>
cmp    %r13d,-0x70(%rbp)
cmovl  %r13d,%ebx
mov    %rbx,%r13
cmp    %r12d,%r15d
mov    %r15d,%ebx
cmovle %r12d,%ebx
mov    %r14,%rdi
call   10d0 <getc@plt>
mov    %eax,%r14d
cmp    $0x50,%al
jne    13a0 <importmelts+0x1f0>
mov    %rbx,%r15
mov    -0x38(%rbp),%rbx
mov    %rbx,%rdi
call   10d0 <getc@plt>
mov    %rbx,%rdi
call   10d0 <getc@plt>
mov    %rbx,%rdi
call   10d0 <getc@plt>
mov    %rbx,%rdi
call   10d0 <getc@plt>
mov    %rbx,%rdi
call   10d0 <getc@plt>
mov    %rbx,%rdi
call   10d0 <getc@plt>
mov    %rbx,%rdi
call   10d0 <getc@plt>
mov    0x2c52(%rip),%rax
mov    (%rax),%edx
mov    %rbx,%rdi
mov    %r15,%rbx
mov    $0xfffffff9,%esi
call   10a0 <fseek@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
xor    %r15d,%r15d
mov    0x2c28(%rip),%rcx
cmp    (%rcx),%r14b
mov    %eax,-0x30(%rbp)
je     13cf <importmelts+0x21f>
mov    0x2c21(%rip),%rax
mov    (%rax),%edx
mov    -0x38(%rbp),%rdi
mov    $0xffffffff,%esi
call   10a0 <fseek@plt>
xor    %r14d,%r14d
jmp    12a6 <importmelts+0xf6>
mov    -0x50(%rbp),%rax
cmp    -0x68(%rbp),%eax
jle    1406 <importmelts+0x256>
mov    0x2be1(%rip),%rax
mov    (%rax),%edi
lea    0xc41(%rip),%rsi
mov    -0x60(%rbp),%rdx
call   1090 <fprintf@plt>
movl   $0x0,(%rbx)
xor    %eax,%eax
jmp    1874 <importmelts+0x6c4>
mov    %rsp,-0xb0(%rbp)
add    $0x2,%eax
mov    %rsp,%r13
mov    %rax,-0x30(%rbp)
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r13
mov    %r13,%rsp
lea    0x2(%r14),%r12d
mov    %rsp,%r15
lea    0xf(%r12),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0xa0(%rbp)
mov    %rcx,%rsp
mov    -0x38(%rbp),%rbx
mov    %rbx,%rdi
call   1070 <rewind@plt>
mov    %r15,%rdi
mov    %r12,-0xe8(%rbp)
mov    %r12d,%esi
mov    %rbx,%rdx
call   1080 <fgets@plt>
test   %rax,%rax
je     1822 <importmelts+0x672>
add    $0x1,%r14d
mov    -0x30(%rbp),%rax
cmp    $0x3,%eax
mov    $0x2,%esi
cmovge %eax,%esi
mov    -0x50(%rbp),%eax
mov    %rax,-0x70(%rbp)
lea    -0x1(%rsi),%rax
lea    -0x9(%rsi),%rcx
mov    %rcx,-0xd0(%rbp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rax,-0x90(%rbp)
and    $0xfffffffffffffff8,%rax
mov    %rax,-0xc8(%rbp)
add    $0x1,%rax
mov    %rax,-0xc0(%rbp)
movd   %r14d,%xmm0
pshufd $0x0,%xmm0,%xmm0
mov    %ecx,%eax
and    $0x3,%eax
mov    %rax,-0x78(%rbp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0xb8(%rbp)
xor    %edi,%edi
xor    %eax,%eax
mov    %rax,-0x48(%rbp)
mov    %r14,%rbx
mov    %r14,-0x98(%rbp)
mov    %rsi,-0xe0(%rbp)
movdqa %xmm0,-0x100(%rbp)
ff
jmp    1574 <importmelts+0x3c4>
nopl   0x0(%rax,%rax,1)
mov    %r15,%rdi
lea    0xb34(%rip),%rsi
call   1030 <strcasecmp@plt>
mov    -0x30(%rbp),%rcx
lea    0x1(%rcx),%r14
test   %rax,%rax
je     15b0 <importmelts+0x400>
mov    -0x98(%rbp),%rbx
mov    -0xa0(%rbp),%rdi
mov    %r15,%rsi
call   1040 <strcpy@plt>
mov    %r15,%rdi
mov    -0xe8(%rbp),%rsi
mov    -0x38(%rbp),%rdx
call   1080 <fgets@plt>
mov    %r14,%rdi
test   %rax,%rax
mov    -0xe0(%rbp),%rsi
movdqa -0x100(%rbp),%xmm0
ff
je     1816 <importmelts+0x666>
movl   $0x0,0x0(%r13)
cmpl   $0x0,-0x50(%rbp)
js     172e <importmelts+0x57e>
mov    $0x1,%eax
cmpq   $0x8,-0x90(%rbp)
08
jb     1720 <importmelts+0x570>
cmpq   $0x18,-0xd0(%rbp)
18
jae    167c <importmelts+0x4cc>
xor    %eax,%eax
jmp    16d2 <importmelts+0x522>
xchg   %ax,%ax
mov    -0xa8(%rbp),%rax
mov    %r14,-0xd8(%rbp)
lea    (%rax,%r14,8),%rax
movslq -0x48(%rbp),%rdx
mov    -0x88(%rbp),%rcx
mov    %rax,(%rcx,%rdx,8)
mov    0x18(%rbp),%rax
mov    %rdx,-0x58(%rbp)
mov    (%rax,%rdx,8),%rdi
mov    -0xa0(%rbp),%rsi
call   1040 <strcpy@plt>
test   %r12d,%r12d
mov    0x20(%rbp),%rbx
jle    1623 <importmelts+0x473>
mov    %r12d,%eax
mov    %rax,-0x68(%rbp)
xor    %r14d,%r14d
nopl   0x0(%rax)
mov    -0x58(%rbp),%rax
mov    (%rbx,%rax,8),%rax
mov    (%rax,%r14,8),%rdi
movslq 0x0(%r13,%r14,4),%rsi
add    %r15,%rsi
call   1040 <strcpy@plt>
add    $0x1,%r14
cmp    %r14,-0x68(%rbp)
jne    1600 <importmelts+0x450>
mov    0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    %r12d,(%rax,%rcx,4)
test   %ecx,%ecx
mov    -0x30(%rbp),%rsi
mov    -0x48(%rbp),%rdi
jle    164d <importmelts+0x49d>
mov    %esi,%eax
sub    -0x3c(%rbp),%eax
add    $0xfffffffd,%eax
lea    -0x1(%rdi),%ecx
mov    -0x80(%rbp),%rdx
mov    %eax,(%rdx,%rcx,4)
lea    0x1(%rdi),%r14d
mov    0x28(%rbp),%rax
cmp    (%rax),%edi
mov    -0x98(%rbp),%rbx
jge    1829 <importmelts+0x679>
mov    %r14d,%eax
mov    %rax,-0x48(%rbp)
mov    %esi,%eax
mov    %esi,-0x3c(%rbp)
mov    -0xd8(%rbp),%r14
jmp    1537 <importmelts+0x387>
mov    -0xb8(%rbp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movdqu %xmm0,0x4(%r13,%rax,4)
movdqu %xmm0,0x14(%r13,%rax,4)
movdqu %xmm0,0x24(%r13,%rax,4)
movdqu %xmm0,0x34(%r13,%rax,4)
movdqu %xmm0,0x44(%r13,%rax,4)
movdqu %xmm0,0x54(%r13,%rax,4)
movdqu %xmm0,0x64(%r13,%rax,4)
movdqu %xmm0,0x74(%r13,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%rcx
jne    1690 <importmelts+0x4e0>
cmpq   $0x0,-0x78(%rbp)
je     1704 <importmelts+0x554>
mov    -0x78(%rbp),%rcx
nopl   (%rax)
lea    0x0(,%rax,4),%rdx
or     $0x4,%rdx
movdqu %xmm0,0x0(%r13,%rdx,1)
movdqu %xmm0,0x10(%r13,%rdx,1)
add    $0x8,%rax
add    $0xffffffffffffffff,%rcx
jne    16e0 <importmelts+0x530>
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rcx
cmp    %rcx,-0x90(%rbp)
je     172e <importmelts+0x57e>
nopl   0x0(%rax,%rax,1)
mov    %ebx,0x0(%r13,%rax,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1720 <importmelts+0x570>
xor    %eax,%eax
xor    %r12d,%r12d
jmp    1748 <importmelts+0x598>
cs nopw 0x0(%rax,%rax,1)
nop
test   %cl,%cl
je     17a0 <importmelts+0x5f0>
add    $0x1,%rax
movzbl (%r15,%rax,1),%ecx
cmp    $0xa,%cl
je     1780 <importmelts+0x5d0>
cmp    $0x20,%cl
jne    1740 <importmelts+0x590>
movb   $0x0,(%r15,%rax,1)
movslq %r12d,%rcx
add    $0x1,%r12d
lea    0x1(%rax),%edx
mov    %edx,0x4(%r13,%rcx,4)
add    $0x1,%rax
jmp    1748 <importmelts+0x598>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movb   $0x0,(%r15,%rax,1)
test   %rax,%rax
je     1744 <importmelts+0x594>
lea    -0x1(%rax),%ecx
cmpb   $0x1,(%r15,%rcx,1)
sbb    $0xffffffff,%r12d
jmp    1744 <importmelts+0x594>
nopl   0x0(%rax,%rax,1)
mov    %rdi,-0x30(%rbp)
cmpl   $0x0,-0x50(%rbp)
jle    1510 <importmelts+0x360>
xor    %r14d,%r14d
jmp    17ce <importmelts+0x61e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
cmp    %r14,-0x70(%rbp)
je     1510 <importmelts+0x360>
movslq 0x0(%r13,%r14,4),%rbx
add    %r15,%rbx
mov    %rbx,%rdi
lea    -0xf0(%rbp),%rsi
call   1050 <strtod@plt>
mov    -0xa8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movq   %xmm0,(%rax,%r14,8)
cmp    %rbx,-0xf0(%rbp)
jne    17c0 <importmelts+0x610>
mov    0x27ee(%rip),%rcx
movq   (%rcx),%xmm0
movq   %xmm0,(%rax,%r14,8)
jmp    17c0 <importmelts+0x610>
mov    %r14d,%ebx
mov    -0x48(%rbp),%rax
mov    %eax,%r14d
jmp    1845 <importmelts+0x695>
xor    %ebx,%ebx
xor    %r14d,%r14d
jmp    1845 <importmelts+0x695>
mov    0x2798(%rip),%rax
mov    %rsi,%rbx
mov    (%rax),%edi
lea    0x81b(%rip),%rsi
mov    -0x60(%rbp),%rdx
call   1090 <fprintf@plt>
mov    -0x38(%rbp),%rdi
call   1060 <fclose@plt>
mov    -0x3c(%rbp),%edx
not    %edx
add    %ebx,%edx
movslq %r14d,%rax
mov    -0x80(%rbp),%rcx
mov    %edx,-0x4(%rcx,%rax,4)
mov    0x28(%rbp),%rcx
mov    %eax,(%rcx)
mov    -0xb0(%rbp),%rsp
mov    -0x88(%rbp),%rax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [21 x i8] c"%sPhase_main_tbl.txt\00"
@.str.1 = [2 x i8] c"r\00"
@EOF = global i8 0
@SEEK_CUR = global i32 0
@stderr = global i32 0
@.str.3 = [26 x i8] c"%s : Too many melts rows\0A\00"
@.str.4 = [29 x i8] c"%s : Too many melts columns\0A\00"
@NAN = global double 0.000000e+00
@.str.5 = [9 x i8] c"pressure\00"
@.str.6 = [24 x i8] c"%s : Too many minerals\0A\00"
define double*** @importmelts(i32 %0, i32 %1, i8* %2, double*** writeonly %3, double** %4, i32* nocapture writeonly %5, i32* nocapture writeonly %6, i8** nocapture %7, i8*** nocapture %8, i32* nocapture %9) {
%11 = alloca [50 x i8]
%12 = alloca i8*
%13 = getelementptr inbounds [50 x i8], [50 x i8]* %11, i64 0, i64 0
%14 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0), i8* %2)
%15 = call i32* @fopen(i8* %13, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%16 = tail call signext i8 @getc(i32* %15)
%17 = load i8, i8* @EOF
%18 = icmp eq i8 %16, %17
br i1 %18, label %72, label %19
19: ; preds = %10, %63
%20 = phi i8 [ %69, %63 ], [ %16, %10 ]
%21 = phi i32 [ %68, %63 ], [ 0, %10 ]
%22 = phi i32 [ %67, %63 ], [ 0, %10 ]
%23 = phi i32 [ %66, %63 ], [ 0, %10 ]
%24 = phi i32 [ %65, %63 ], [ 0, %10 ]
%25 = phi i32 [ %64, %63 ], [ 0, %10 ]
%26 = add nsw i32 %23, 1
%27 = icmp eq i8 %20, 32
%28 = zext i1 %27 to i32
%29 = add nsw i32 %25, %28
%30 = icmp eq i8 %20, 10
br i1 %30, label %31, label %63
31: ; preds = %19
%32 = add nsw i32 %21, 1
%33 = load i32, i32* @SEEK_CUR
%34 = tail call i32 @fseek(i32* %15, i32 -2, i32 %33)
%35 = tail call signext i8 @getc(i32* %15)
%36 = icmp ne i8 %35, 32
%37 = zext i1 %36 to i32
%38 = add nsw i32 %29, %37
%39 = load i32, i32* @SEEK_CUR
%40 = tail call i32 @fseek(i32* %15, i32 1, i32 %39)
%41 = icmp slt i32 %23, %22
%42 = select i1 %41, i32 %22, i32 %26
%43 = icmp sgt i32 %38, %24
%44 = select i1 %43, i32 %38, i32 %24
%45 = tail call signext i8 @getc(i32* %15)
%46 = icmp eq i8 %45, 80
br i1 %46, label %47, label %57
47: ; preds = %31
%48 = tail call signext i8 @getc(i32* %15)
%49 = tail call signext i8 @getc(i32* %15)
%50 = tail call signext i8 @getc(i32* %15)
%51 = tail call signext i8 @getc(i32* %15)
%52 = tail call signext i8 @getc(i32* %15)
%53 = tail call signext i8 @getc(i32* %15)
%54 = tail call signext i8 @getc(i32* %15)
%55 = load i32, i32* @SEEK_CUR
%56 = tail call i32 @fseek(i32* %15, i32 -7, i32 %55)
br label %57
57: ; preds = %47, %31
%58 = load i8, i8* @EOF
%59 = icmp eq i8 %45, %58
br i1 %59, label %63, label %60
60: ; preds = %57
%61 = load i32, i32* @SEEK_CUR
%62 = tail call i32 @fseek(i32* %15, i32 -1, i32 %61)
br label %63
63: ; preds = %19, %60, %57
%64 = phi i32 [ 0, %60 ], [ 0, %57 ], [ %29, %19 ]
%65 = phi i32 [ %44, %60 ], [ %44, %57 ], [ %24, %19 ]
%66 = phi i32 [ 0, %60 ], [ 0, %57 ], [ %26, %19 ]
%67 = phi i32 [ %42, %60 ], [ %42, %57 ], [ %22, %19 ]
%68 = phi i32 [ %32, %60 ], [ %32, %57 ], [ %21, %19 ]
%69 = tail call signext i8 @getc(i32* %15)
%70 = load i8, i8* @EOF
%71 = icmp eq i8 %69, %70
br i1 %71, label %72, label %19
72: ; preds = %63, %10
%73 = phi i32 [ 0, %10 ], [ %65, %63 ]
%74 = phi i32 [ 0, %10 ], [ %67, %63 ]
%75 = phi i32 [ 0, %10 ], [ %68, %63 ]
%76 = load i32, i32* @SEEK_CUR
%77 = tail call i32 @fseek(i32* %15, i32 -1, i32 %76)
%78 = tail call signext i8 @getc(i32* %15)
%79 = icmp ne i8 %78, 10
%80 = zext i1 %79 to i32
%81 = add nsw i32 %75, %80
%82 = load i32, i32* %9
%83 = mul nsw i32 %82, %0
%84 = icmp sgt i32 %81, %83
br i1 %84, label %85, label %88
85: ; preds = %72
%86 = load i32, i32* @stderr
%87 = tail call i32 @fprintf(i32 %86, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.3, i64 0, i64 0), i8* %2)
store i32 0, i32* %9
br label %290
88: ; preds = %72
%89 = icmp sgt i32 %73, %1
br i1 %89, label %90, label %93
90: ; preds = %88
%91 = load i32, i32* @stderr
%92 = tail call i32 @fprintf(i32 %91, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.4, i64 0, i64 0), i8* %2)
store i32 0, i32* %9
br label %290
93: ; preds = %88
%94 = add i32 %73, 2
%95 = zext i32 %94 to i64
%96 = tail call i8* @llvm.stacksave()
%97 = alloca i32, i64 %95
%98 = add nsw i32 %74, 2
%99 = zext i32 %98 to i64
%100 = alloca i8, i64 %99
%101 = alloca i8, i64 %99
%102 = bitcast i8** %12 to i8*
%103 = tail call i32 @rewind(i32* %15)
%104 = call i32* @fgets(i8* %100, i32 %98, i32* %15)
%105 = icmp eq i32* %104, null
br i1 %105, label %280, label %106
106: ; preds = %93
%107 = icmp sgt i32 %73, -1
%108 = add nsw i32 %74, 1
%109 = icmp sgt i32 %73, 0
%110 = call i32 @llvm.smax.i32(i32 %94, i32 2)
%111 = zext i32 %110 to i64
%112 = zext i32 %73 to i64
%113 = add nsw i64 %111, -1
%114 = add nsw i64 %111, -9
%115 = lshr i64 %114, 3
%116 = add nuw nsw i64 %115, 1
%117 = icmp ult i64 %113, 8
%118 = and i64 %113, -8
%119 = or i64 %118, 1
%120 = insertelement <4 x i32> poison, i32 %108, i64 0
%121 = shufflevector <4 x i32> %120, <4 x i32> poison, <4 x i32> zeroinitializer
%122 = insertelement <4 x i32> poison, i32 %108, i64 0
%123 = shufflevector <4 x i32> %122, <4 x i32> poison, <4 x i32> zeroinitializer
%124 = and i64 %116, 3
%125 = icmp ult i64 %114, 24
%126 = and i64 %116, 4611686018427387900
%127 = icmp eq i64 %124, 0
%128 = icmp eq i64 %113, %118
br label %129
129: ; preds = %106, %272
%130 = phi i64 [ 0, %106 ], [ %229, %272 ]
%131 = phi i32 [ undef, %106 ], [ %274, %272 ]
%132 = phi i32 [ 0, %106 ], [ %273, %272 ]
store i32 0, i32* %97
br i1 %107, label %133, label %182
133: ; preds = %129
br i1 %117, label %175, label %134
134: ; preds = %133
br i1 %125, label %161, label %135
135: ; preds = %134, %135
%136 = phi i64 [ %158, %135 ], [ 0, %134 ]
%137 = phi i64 [ %159, %135 ], [ 0, %134 ]
%138 = or i64 %136, 1
%139 = getelementptr inbounds i32, i32* %97, i64 %138
%140 = bitcast i32* %139 to <4 x i32>*
store <4 x i32> %121, <4 x i32>* %140
%141 = getelementptr inbounds i32, i32* %139, i64 4
%142 = bitcast i32* %141 to <4 x i32>*
store <4 x i32> %123, <4 x i32>* %142
%143 = or i64 %136, 9
%144 = getelementptr inbounds i32, i32* %97, i64 %143
%145 = bitcast i32* %144 to <4 x i32>*
store <4 x i32> %121, <4 x i32>* %145
%146 = getelementptr inbounds i32, i32* %144, i64 4
%147 = bitcast i32* %146 to <4 x i32>*
store <4 x i32> %123, <4 x i32>* %147
%148 = or i64 %136, 17
%149 = getelementptr inbounds i32, i32* %97, i64 %148
%150 = bitcast i32* %149 to <4 x i32>*
store <4 x i32> %121, <4 x i32>* %150
%151 = getelementptr inbounds i32, i32* %149, i64 4
%152 = bitcast i32* %151 to <4 x i32>*
store <4 x i32> %123, <4 x i32>* %152
%153 = or i64 %136, 25
%154 = getelementptr inbounds i32, i32* %97, i64 %153
%155 = bitcast i32* %154 to <4 x i32>*
store <4 x i32> %121, <4 x i32>* %155
%156 = getelementptr inbounds i32, i32* %154, i64 4
%157 = bitcast i32* %156 to <4 x i32>*
store <4 x i32> %123, <4 x i32>* %157
%158 = add nuw i64 %136, 32
%159 = add i64 %137, 4
%160 = icmp eq i64 %159, %126
br i1 %160, label %161, label %135
161: ; preds = %135, %134
%162 = phi i64 [ 0, %134 ], [ %158, %135 ]
br i1 %127, label %174, label %163
163: ; preds = %161, %163
%164 = phi i64 [ %171, %163 ], [ %162, %161 ]
%165 = phi i64 [ %172, %163 ], [ 0, %161 ]
%166 = or i64 %164, 1
%167 = getelementptr inbounds i32, i32* %97, i64 %166
%168 = bitcast i32* %167 to <4 x i32>*
store <4 x i32> %121, <4 x i32>* %168
%169 = getelementptr inbounds i32, i32* %167, i64 4
%170 = bitcast i32* %169 to <4 x i32>*
store <4 x i32> %123, <4 x i32>* %170
%171 = add nuw i64 %164, 8
%172 = add i64 %165, 1
%173 = icmp eq i64 %172, %124
br i1 %173, label %174, label %163
174: ; preds = %163, %161
br i1 %128, label %182, label %175
175: ; preds = %133, %174
%176 = phi i64 [ 1, %133 ], [ %119, %174 ]
br label %177
177: ; preds = %175, %177
%178 = phi i64 [ %180, %177 ], [ %176, %175 ]
%179 = getelementptr inbounds i32, i32* %97, i64 %178
store i32 %108, i32* %179
%180 = add nuw nsw i64 %178, 1
%181 = icmp eq i64 %180, %111
br i1 %181, label %182, label %177
182: ; preds = %177, %174, %129
br label %183
183: ; preds = %182, %207
%184 = phi i64 [ %209, %207 ], [ 0, %182 ]
%185 = phi i32 [ %208, %207 ], [ 0, %182 ]
%186 = getelementptr inbounds i8, i8* %100, i64 %184
%187 = load i8, i8* %186
switch i8 %187, label %207 [
i8 0, label %188
i8 32, label %191
i8 10, label %197
]
188: ; preds = %183
br i1 %109, label %189, label %226
189: ; preds = %188
%190 = getelementptr inbounds double*, double** %4, i64 %130
br label %210
191: ; preds = %183
store i8 0, i8* %186
%192 = add nsw i32 %185, 1
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i32, i32* %97, i64 %193
%195 = trunc i64 %184 to i32
%196 = add i32 %195, 1
store i32 %196, i32* %194
br label %207
197: ; preds = %183
store i8 0, i8* %186
%198 = icmp eq i64 %184, 0
br i1 %198, label %207, label %199
199: ; preds = %197
%200 = add i64 %184, 4294967295
%201 = and i64 %200, 4294967295
%202 = getelementptr inbounds i8, i8* %100, i64 %201
%203 = load i8, i8* %202
%204 = icmp ne i8 %203, 0
%205 = zext i1 %204 to i32
%206 = add nsw i32 %185, %205
br label %207
207: ; preds = %199, %183, %191, %197
%208 = phi i32 [ %192, %191 ], [ %185, %197 ], [ %185, %183 ], [ %206, %199 ]
%209 = add nuw i64 %184, 1
br label %183
210: ; preds = %189, %223
%211 = phi i64 [ 0, %189 ], [ %224, %223 ]
%212 = getelementptr inbounds i32, i32* %97, i64 %211
%213 = load i32, i32* %212
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i8, i8* %100, i64 %214
%216 = call double @strtod(i8* %215, i8** %12)
%217 = load double*, double** %190
%218 = getelementptr inbounds double, double* %217, i64 %211
store double %216, double* %218
%219 = load i8*, i8** %12
%220 = icmp eq i8* %219, %215
br i1 %220, label %221, label %223
221: ; preds = %210
%222 = load double, double* @NAN
store double %222, double* %218
br label %223
223: ; preds = %210, %221
%224 = add nuw nsw i64 %211, 1
%225 = icmp eq i64 %224, %112
br i1 %225, label %226, label %210
226: ; preds = %223, %188
%227 = call i64 @strcasecmp(i8* %100, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
%228 = icmp eq i64 %227, 0
%229 = add nuw i64 %130, 1
br i1 %228, label %230, label %272
230: ; preds = %226
%231 = getelementptr inbounds double*, double** %4, i64 %229
%232 = sext i32 %132 to i64
%233 = getelementptr inbounds double**, double*** %3, i64 %232
store double** %231, double*** %233
%234 = getelementptr inbounds i8*, i8** %7, i64 %232
%235 = load i8*, i8** %234
%236 = call i32 @strcpy(i8* %235, i8* %101)
%237 = icmp sgt i32 %185, 0
br i1 %237, label %238, label %253
238: ; preds = %230
%239 = getelementptr inbounds i8**, i8*** %8, i64 %232
%240 = zext i32 %185 to i64
br label %241
241: ; preds = %238, %241
%242 = phi i64 [ 0, %238 ], [ %251, %241 ]
%243 = load i8**, i8*** %239
%244 = getelementptr inbounds i8*, i8** %243, i64 %242
%245 = load i8*, i8** %244
%246 = getelementptr inbounds i32, i32* %97, i64 %242
%247 = load i32, i32* %246
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i8, i8* %100, i64 %248
%250 = call i32 @strcpy(i8* %245, i8* %249)
%251 = add nuw nsw i64 %242, 1
%252 = icmp eq i64 %251, %240
br i1 %252, label %253, label %241
253: ; preds = %241, %230
%254 = getelementptr inbounds i32, i32* %6, i64 %232
store i32 %185, i32* %254
%255 = icmp sgt i32 %132, 0
br i1 %255, label %256, label %263
256: ; preds = %253
%257 = trunc i64 %130 to i32
%258 = add i32 %257, -3
%259 = sub i32 %258, %131
%260 = add nsw i32 %132, -1
%261 = zext i32 %260 to i64
%262 = getelementptr inbounds i32, i32* %5, i64 %261
store i32 %259, i32* %262
br label %263
263: ; preds = %256, %253
%264 = add nsw i32 %132, 1
%265 = load i32, i32* %9
%266 = icmp slt i32 %132, %265
%267 = trunc i64 %130 to i32
br i1 %266, label %272, label %268
268: ; preds = %263
%269 = trunc i64 %130 to i32
%270 = load i32, i32* @stderr
%271 = call i32 @fprintf(i32 %270, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.6, i64 0, i64 0), i8* %2)
br label %280
272: ; preds = %226, %263
%273 = phi i32 [ %264, %263 ], [ %132, %226 ]
%274 = phi i32 [ %267, %263 ], [ %131, %226 ]
%275 = call i32 @strcpy(i8* %101, i8* %100)
%276 = call i32* @fgets(i8* %100, i32 %98, i32* %15)
%277 = icmp eq i32* %276, null
br i1 %277, label %278, label %129
278: ; preds = %272
%279 = trunc i64 %229 to i32
br label %280
280: ; preds = %278, %93, %268
%281 = phi i32 [ %269, %268 ], [ 0, %93 ], [ %279, %278 ]
%282 = phi i32 [ %131, %268 ], [ undef, %93 ], [ %274, %278 ]
%283 = phi i32 [ %264, %268 ], [ 0, %93 ], [ %273, %278 ]
%284 = call i32 @fclose(i32* %15)
%285 = xor i32 %282, -1
%286 = add i32 %281, %285
%287 = add nsw i32 %283, -1
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds i32, i32* %5, i64 %288
store i32 %286, i32* %289
store i32 %283, i32* %9
br label %290
290: ; preds = %280, %90, %85
%291 = phi double*** [ null, %85 ], [ null, %90 ], [ %3, %280 ]
ret double*** %291
}