#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 */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ feof(int /*<<< orphan*/ *);
scalar_t__ fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int fscanf(int /*<<< orphan*/ *, char *, int *);
void *malloc(int);
int /*<<< orphan*/ ungetc(char, int /*<<< orphan*/ *);
int ****load_discrete4(char *fname, int *dim1, int **dim2, int ***dim3,
                       int ****dim4, int *max) {
  FILE *f;
  int ****x;
  char *s;
  int i, j, k, l, m, maxlen, v;
  char c;
  int *tmp;
  *max = 0;
  k = 0;
  f = fopen(fname, "r");
  while (!feof(f)) {
    c = (char)fgetc(f);
    if (c == '\n') {
      k++;
    }
  }
  fclose(f);
  *dim1 = k;
  *dim2 = malloc(*dim1 * sizeof(int));
  k = 0;
  i = 0;
  f = fopen(fname, "r");
  while (!feof(f)) {
    c = (char)fgetc(f);
    if (c == '\n') {
      (*dim2)[k] = i;
      k++;
      i = 0;
    } else {
      if (i == 0) {
        i = 1;
      }
      if (c == '\t') {
        i++;
      }
    }
  }
  fclose(f);
  *dim3 = malloc(*dim1 * sizeof(int *));
  for (k = 0; k < *dim1; k++) {
    (*dim3)[k] = malloc((*dim2)[k] * sizeof(int));
  }
  k = 0;
  i = 0;
  j = 0;
  f = fopen(fname, "r");
  while (!feof(f)) {
    c = (char)fgetc(f);
    if (c == '\n') {
      (*dim3)[k][i] = j;
      k++;
      i = 0;
      j = 0;
    } else if (c == '\t') {
      (*dim3)[k][i] = j;
      i++;
      j = 0;
    } else if (c == '#') {
      j++;
    } else if (j == 0) {
      j = 1;
    }
  }
  fclose(f);
  *dim4 = malloc(*dim1 * sizeof(int **));
  for (k = 0; k < *dim1; k++) {
    (*dim4)[k] = malloc((*dim2)[k] * sizeof(int *));
    for (i = 0; i < (*dim2)[k]; i++) {
      (*dim4)[k][i] = malloc((*dim3)[k][i] * sizeof(int));
    }
  }
  k = 0;
  i = 0;
  j = 0;
  l = 0;
  f = fopen(fname, "r");
  while (!feof(f)) {
    c = (char)fgetc(f);
    if (c == '\n') {
      (*dim4)[k][i][j] = l;
      k++;
      i = 0;
      j = 0;
      l = 0;
    } else if (c == '\t') {
      (*dim4)[k][i][j] = l;
      i++;
      j = 0;
      l = 0;
    } else if (c == '#') {
      (*dim4)[k][i][j] = l;
      j++;
      l = 0;
    } else if (c == ' ') {
      l++;
    } else if (l == 0) {
      l = 1;
    }
  }
  fclose(f);
  x = malloc(*dim1 * sizeof(int ***));
  for (k = 0; k < *dim1; k++) {
    x[k] = malloc((*dim2)[k] * sizeof(int **));
    for (i = 0; i < (*dim2)[k]; i++) {
      x[k][i] = malloc((*dim3)[k][i] * sizeof(int *));
      for (j = 0; j < (*dim3)[k][i]; j++) {
        x[k][i][j] = malloc((*dim4)[k][i][j] * sizeof(int));
      }
    }
  }
  f = fopen(fname, "r");
  k = 0;
  i = 0;
  j = 0;
  l = 0;
  while (!feof(f)) {
    c = (char)fgetc(f);
    if (c <= 0) {
      break;
    }
    if (c == ' ') {
    } else if (c == '\n') {
      k++;
      i = 0;
      j = 0;
      l = 0;
    } else if (c == '\t') {
      i++;
      j = 0;
      l = 0;
    } else if (c == '#') {
      j++;
      l = 0;
    } else {
      ungetc(c, f);
      m = fscanf(f, "%d", &v);
      x[k][i][j][l] = v;
      if (v > *max) {
        *max = v;
      }
      l++;
    }
  }
  fclose(f);
  return x;
}


x86 assembly (clang, -O0):
<load_discrete4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x54(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xe54(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
call   1060 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    11d3 <load_discrete4+0x63>
jmp    11fa <load_discrete4+0x8a>
mov    -0x38(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %al,-0x65(%rbp)
movsbl -0x65(%rbp),%eax
cmp    $0xa,%eax
jne    11f5 <load_discrete4+0x85>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11b5 <load_discrete4+0x45>
mov    -0x38(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x54(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
movslq (%rax),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xdbf(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
call   1060 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1268 <load_discrete4+0xf8>
jmp    12d8 <load_discrete4+0x168>
mov    -0x38(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %al,-0x65(%rbp)
movsbl -0x65(%rbp),%eax
cmp    $0xa,%eax
jne    12a7 <load_discrete4+0x137>
mov    -0x4c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
jmp    12d3 <load_discrete4+0x163>
cmpl   $0x0,-0x4c(%rbp)
jne    12b8 <load_discrete4+0x148>
movl   $0x1,-0x4c(%rbp)
movsbl -0x65(%rbp),%eax
cmp    $0x9,%eax
jne    12ce <load_discrete4+0x15e>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12d3 <load_discrete4+0x163>
jmp    124a <load_discrete4+0xda>
mov    -0x38(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x10(%rbp),%rax
movslq (%rax),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    134d <load_discrete4+0x1dd>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1304 <load_discrete4+0x194>
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xc93(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
call   1060 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1394 <load_discrete4+0x224>
jmp    145d <load_discrete4+0x2ed>
mov    -0x38(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %al,-0x65(%rbp)
movsbl -0x65(%rbp),%eax
cmp    $0xa,%eax
jne    13e2 <load_discrete4+0x272>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
jmp    1458 <load_discrete4+0x2e8>
movsbl -0x65(%rbp),%eax
cmp    $0x9,%eax
jne    141d <load_discrete4+0x2ad>
mov    -0x50(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
jmp    1453 <load_discrete4+0x2e3>
movsbl -0x65(%rbp),%eax
cmp    $0x23,%eax
jne    1438 <load_discrete4+0x2c8>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    144e <load_discrete4+0x2de>
cmpl   $0x0,-0x50(%rbp)
jne    1449 <load_discrete4+0x2d9>
movl   $0x1,-0x50(%rbp)
jmp    144e <load_discrete4+0x2de>
jmp    1453 <load_discrete4+0x2e3>
jmp    1458 <load_discrete4+0x2e8>
jmp    1376 <load_discrete4+0x206>
mov    -0x38(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x10(%rbp),%rax
movslq (%rax),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    153f <load_discrete4+0x3cf>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
movslq -0x54(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    152c <load_discrete4+0x3bc>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    14cb <load_discrete4+0x35b>
jmp    1531 <load_discrete4+0x3c1>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1489 <load_discrete4+0x319>
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
lea    0xa9a(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
call   1060 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    158d <load_discrete4+0x41d>
jmp    16bc <load_discrete4+0x54c>
mov    -0x38(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %al,-0x65(%rbp)
movsbl -0x65(%rbp),%eax
cmp    $0xa,%eax
jne    15ea <load_discrete4+0x47a>
mov    -0x58(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
jmp    16b7 <load_discrete4+0x547>
movsbl -0x65(%rbp),%eax
cmp    $0x9,%eax
jne    1634 <load_discrete4+0x4c4>
mov    -0x58(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
jmp    16b2 <load_discrete4+0x542>
movsbl -0x65(%rbp),%eax
cmp    $0x23,%eax
jne    1677 <load_discrete4+0x507>
mov    -0x58(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
jmp    16ad <load_discrete4+0x53d>
movsbl -0x65(%rbp),%eax
cmp    $0x20,%eax
jne    1692 <load_discrete4+0x522>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    16a8 <load_discrete4+0x538>
cmpl   $0x0,-0x58(%rbp)
jne    16a3 <load_discrete4+0x533>
movl   $0x1,-0x58(%rbp)
jmp    16a8 <load_discrete4+0x538>
jmp    16ad <load_discrete4+0x53d>
jmp    16b2 <load_discrete4+0x542>
jmp    16b7 <load_discrete4+0x547>
jmp    156f <load_discrete4+0x3ff>
mov    -0x38(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x10(%rbp),%rax
movslq (%rax),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1814 <load_discrete4+0x6a4>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
movslq -0x54(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1801 <load_discrete4+0x691>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%rcx
movslq -0x54(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x4c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    17ee <load_discrete4+0x67e>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1778 <load_discrete4+0x608>
jmp    17f3 <load_discrete4+0x683>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1721 <load_discrete4+0x5b1>
jmp    1806 <load_discrete4+0x696>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    16e2 <load_discrete4+0x572>
mov    -0x8(%rbp),%rdi
lea    0x7e1(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x38(%rbp),%rdi
call   1060 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1862 <load_discrete4+0x6f2>
jmp    198e <load_discrete4+0x81e>
mov    -0x38(%rbp),%rdi
call   1050 <fgetc@plt>
mov    %al,-0x65(%rbp)
movsbl -0x65(%rbp),%eax
cmp    $0x0,%eax
jg     1880 <load_discrete4+0x710>
jmp    198e <load_discrete4+0x81e>
movsbl -0x65(%rbp),%eax
cmp    $0x20,%eax
jne    1892 <load_discrete4+0x722>
jmp    1989 <load_discrete4+0x819>
movsbl -0x65(%rbp),%eax
cmp    $0xa,%eax
jne    18c2 <load_discrete4+0x752>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
jmp    1984 <load_discrete4+0x814>
movsbl -0x65(%rbp),%eax
cmp    $0x9,%eax
jne    18eb <load_discrete4+0x77b>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
jmp    197f <load_discrete4+0x80f>
movsbl -0x65(%rbp),%eax
cmp    $0x23,%eax
jne    190d <load_discrete4+0x79d>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x58(%rbp)
jmp    197a <load_discrete4+0x80a>
mov    -0x65(%rbp),%al
mov    -0x38(%rbp),%rsi
movsbl %al,%edi
call   1080 <ungetc@plt>
mov    -0x38(%rbp),%rdi
lea    0x6db(%rip),%rsi
lea    -0x64(%rbp),%rdx
call   1040 <fscanf@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x64(%rbp),%edx
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
mov    -0x30(%rbp),%rcx
cmp    (%rcx),%eax
jle    1971 <load_discrete4+0x801>
mov    -0x64(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    197f <load_discrete4+0x80f>
jmp    1984 <load_discrete4+0x814>
jmp    1989 <load_discrete4+0x819>
jmp    1844 <load_discrete4+0x6d4>
mov    -0x38(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x40(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<load_discrete4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8,%r15
mov    %rcx,0x30(%rsp)
mov    %rdx,%r13
mov    %rsi,0x18(%rsp)
mov    %r9,0x38(%rsp)
movl   $0x0,(%r9)
lea    0xecb(%rip),%rsi
mov    %rdi,0x28(%rsp)
call   1090 <fopen@plt>
mov    %rax,%r14
mov    %rax,%rdi
call   1060 <feof@plt>
xor    %ebp,%ebp
test   %eax,%eax
jne    11dd <load_discrete4+0x6d>
xor    %ebp,%ebp
xchg   %ax,%ax
mov    %r14,%rdi
call   1050 <fgetc@plt>
xor    %ecx,%ecx
cmp    $0xa,%al
sete   %cl
add    %ecx,%ebp
mov    %r14,%rdi
call   1060 <feof@plt>
test   %eax,%eax
je     11c0 <load_discrete4+0x50>
mov    %r14,%rdi
call   1030 <fclose@plt>
mov    0x18(%rsp),%rax
mov    %ebp,(%rax)
shl    $0x2,%ebp
mov    %ebp,%edi
call   1070 <malloc@plt>
mov    %rax,0x0(%r13)
lea    0xe6b(%rip),%rsi
mov    0x28(%rsp),%rdi
call   1090 <fopen@plt>
mov    %rax,%r12
mov    %rax,%rdi
call   1060 <feof@plt>
test   %eax,%eax
je     14dd <load_discrete4+0x36d>
mov    %r12,%rdi
call   1030 <fclose@plt>
mov    0x18(%rsp),%rax
mov    (%rax),%r14d
lea    0x0(,%r14,8),%edi
call   1070 <malloc@plt>
mov    0x30(%rsp),%r12
mov    %rax,(%r12)
test   %r14d,%r14d
jle    1290 <load_discrete4+0x120>
mov    %rax,%rbp
mov    0x0(%r13),%rax
mov    (%rax),%edi
shl    $0x2,%edi
call   1070 <malloc@plt>
mov    %rax,0x0(%rbp)
cmp    $0x1,%r14d
je     1290 <load_discrete4+0x120>
mov    $0x1,%ebp
nopl   0x0(%rax)
mov    (%r12),%rbx
mov    0x0(%r13),%rax
mov    (%rax,%rbp,4),%edi
shl    $0x2,%edi
call   1070 <malloc@plt>
mov    %rax,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1270 <load_discrete4+0x100>
mov    %r13,0x40(%rsp)
lea    0xdd0(%rip),%rsi
mov    0x28(%rsp),%rdi
call   1090 <fopen@plt>
mov    %rax,%rbp
mov    %rax,%rdi
call   1060 <feof@plt>
test   %eax,%eax
je     1535 <load_discrete4+0x3c5>
mov    %rbp,%rdi
call   1030 <fclose@plt>
mov    0x18(%rsp),%rax
mov    (%rax),%r14d
lea    0x0(,%r14,8),%edi
call   1070 <malloc@plt>
mov    %rax,(%r15)
test   %r14d,%r14d
mov    0x40(%rsp),%r13
jle    134d <load_discrete4+0x1dd>
mov    %rax,%rbp
mov    0x0(%r13),%rax
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    (%rax,%rbx,4),%edi
shl    $0x3,%edi
call   1070 <malloc@plt>
mov    %rax,0x0(%rbp,%rbx,8)
mov    0x0(%r13),%rax
cmpl   $0x0,(%rax,%rbx,4)
jle    133f <load_discrete4+0x1cf>
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    (%r12),%rax
mov    (%rax,%rbx,8),%rax
mov    (%rax,%rbp,4),%edi
shl    $0x2,%edi
call   1070 <malloc@plt>
mov    (%r15),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %rax,(%rcx,%rbp,8)
add    $0x1,%rbp
mov    0x0(%r13),%rax
movslq (%rax,%rbx,4),%rcx
cmp    %rcx,%rbp
jl     1310 <load_discrete4+0x1a0>
add    $0x1,%rbx
cmp    %r14,%rbx
je     134d <load_discrete4+0x1dd>
mov    (%r15),%rbp
jmp    12f0 <load_discrete4+0x180>
lea    0xd18(%rip),%rsi
mov    0x28(%rsp),%rdi
call   1090 <fopen@plt>
mov    %rax,%r14
mov    %rax,%rdi
call   1060 <feof@plt>
test   %eax,%eax
je     15c6 <load_discrete4+0x456>
mov    %r15,0x10(%rsp)
mov    %r14,%rdi
call   1030 <fclose@plt>
mov    0x18(%rsp),%rax
mov    (%rax),%ebx
lea    0x0(,%rbx,8),%edi
call   1070 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %rbx,0x18(%rsp)
test   %ebx,%ebx
jle    149d <load_discrete4+0x32d>
mov    0x0(%r13),%r15
xor    %r14d,%r14d
jmp    13c4 <load_discrete4+0x254>
nopl   0x0(%rax)
add    $0x1,%r14
cmp    0x18(%rsp),%r14
mov    0x30(%rsp),%r12
je     149d <load_discrete4+0x32d>
mov    (%r15,%r14,4),%ebx
lea    0x0(,%rbx,8),%edi
call   1070 <malloc@plt>
mov    %rax,%rbp
mov    0x8(%rsp),%rax
mov    %rbp,(%rax,%r14,8)
test   %ebx,%ebx
jle    13b0 <load_discrete4+0x240>
mov    (%r12),%r12
xor    %r13d,%r13d
jmp    1405 <load_discrete4+0x295>
nopl   (%rax)
mov    0x40(%rsp),%rax
mov    (%rax),%r15
add    $0x1,%r13
movslq (%r15,%r14,4),%rax
cmp    %rax,%r13
jge    13b0 <load_discrete4+0x240>
mov    (%r12,%r14,8),%rax
mov    (%rax,%r13,4),%edi
shl    $0x3,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    %rax,0x0(%rbp,%r13,8)
mov    (%r12,%r14,8),%rax
cmpl   $0x0,(%rax,%r13,4)
jle    13f8 <load_discrete4+0x288>
mov    0x10(%rsp),%rax
mov    (%rax),%rax
mov    (%rax,%r14,8),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax),%edi
shl    $0x2,%edi
call   1070 <malloc@plt>
mov    %rax,(%rbx)
mov    0x30(%rsp),%r15
mov    (%r15),%r12
mov    (%r12,%r14,8),%rax
cmpl   $0x2,(%rax,%r13,4)
jl     13f0 <load_discrete4+0x280>
mov    $0x1,%ebx
nopl   (%rax)
mov    0x0(%rbp,%r13,8),%r12
mov    0x10(%rsp),%rax
mov    (%rax),%rax
mov    (%rax,%r14,8),%rax
mov    (%rax,%r13,8),%rax
mov    (%rax,%rbx,4),%edi
shl    $0x2,%edi
call   1070 <malloc@plt>
mov    %rax,(%r12,%rbx,8)
add    $0x1,%rbx
mov    (%r15),%r12
mov    (%r12,%r14,8),%rax
movslq (%rax,%r13,4),%rax
cmp    %rax,%rbx
jl     1460 <load_discrete4+0x2f0>
jmp    13f0 <load_discrete4+0x280>
lea    0xbc8(%rip),%rsi
mov    0x28(%rsp),%rdi
call   1090 <fopen@plt>
mov    %rax,%rbx
mov    %rax,%rdi
call   1060 <feof@plt>
test   %eax,%eax
je     16d8 <load_discrete4+0x568>
mov    %rbx,%rdi
call   1030 <fclose@plt>
mov    0x8(%rsp),%rax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
mov    $0x1,%r14d
xor    %ebx,%ebx
jmp    1512 <load_discrete4+0x3a2>
nopl   0x0(%rax)
test   %ebp,%ebp
cmove  %r14d,%ebp
xor    %ecx,%ecx
cmp    $0x9000000,%eax
sete   %cl
add    %ecx,%ebp
mov    %r12,%rdi
call   1060 <feof@plt>
test   %eax,%eax
jne    121e <load_discrete4+0xae>
mov    %r12,%rdi
call   1050 <fgetc@plt>
shl    $0x18,%eax
cmp    $0xa000000,%eax
jne    14f0 <load_discrete4+0x380>
mov    0x0(%r13),%rax
movslq %ebx,%rbx
mov    %ebp,(%rax,%rbx,4)
add    $0x1,%ebx
xor    %ebp,%ebp
jmp    1502 <load_discrete4+0x392>
xor    %ebx,%ebx
xor    %r14d,%r14d
xor    %r13d,%r13d
jmp    155c <load_discrete4+0x3ec>
nop
test   %r14d,%r14d
mov    $0x1,%eax
cmove  %eax,%r14d
mov    %rbp,%rdi
call   1060 <feof@plt>
test   %eax,%eax
jne    12b9 <load_discrete4+0x149>
mov    %rbp,%rdi
call   1050 <fgetc@plt>
shl    $0x18,%eax
cmp    $0x9000000,%eax
je     15a0 <load_discrete4+0x430>
cmp    $0x23000000,%eax
je     15c0 <load_discrete4+0x450>
cmp    $0xa000000,%eax
jne    1540 <load_discrete4+0x3d0>
mov    (%r12),%rax
movslq %r13d,%rcx
mov    (%rax,%rcx,8),%rax
movslq %ebx,%rcx
mov    %r14d,(%rax,%rcx,4)
add    $0x1,%r13d
xor    %r14d,%r14d
xor    %ebx,%ebx
jmp    154c <load_discrete4+0x3dc>
nopl   0x0(%rax)
mov    (%r12),%rax
movslq %r13d,%rcx
mov    (%rax,%rcx,8),%rax
movslq %ebx,%rbx
mov    %r14d,(%rax,%rbx,4)
add    $0x1,%ebx
xor    %r14d,%r14d
jmp    154c <load_discrete4+0x3dc>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r14d
jmp    154c <load_discrete4+0x3dc>
movl   $0x0,0x10(%rsp)
xor    %ebp,%ebp
xor    %ebx,%ebx
movl   $0x0,0x8(%rsp)
jmp    1600 <load_discrete4+0x490>
nopl   0x0(%rax)
test   %ebx,%ebx
mov    $0x1,%eax
cmove  %eax,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
call   1060 <feof@plt>
test   %eax,%eax
jne    1371 <load_discrete4+0x201>
mov    %r14,%rdi
call   1050 <fgetc@plt>
shl    $0x18,%eax
cmp    $0x1fffffff,%eax
jg     1660 <load_discrete4+0x4f0>
cmp    $0x9000000,%eax
je     16a0 <load_discrete4+0x530>
cmp    $0xa000000,%eax
jne    15e0 <load_discrete4+0x470>
mov    (%r15),%rax
mov    0x8(%rsp),%edx
movslq %edx,%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x10(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
movslq %ebp,%rcx
mov    %ebx,(%rax,%rcx,4)
add    $0x1,%edx
mov    %edx,0x8(%rsp)
xor    %ebx,%ebx
xor    %ebp,%ebp
movl   $0x0,0x10(%rsp)
jmp    15f0 <load_discrete4+0x480>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x20000000,%eax
je     16d0 <load_discrete4+0x560>
cmp    $0x23000000,%eax
jne    15e0 <load_discrete4+0x470>
mov    (%r15),%rax
movslq 0x8(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
movslq 0x10(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
movslq %ebp,%rbp
mov    %ebx,(%rax,%rbp,4)
add    $0x1,%ebp
xor    %ebx,%ebx
jmp    15f0 <load_discrete4+0x480>
nopw   0x0(%rax,%rax,1)
mov    (%r15),%rax
movslq 0x8(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x10(%rsp),%edx
movslq %edx,%rcx
mov    (%rax,%rcx,8),%rax
movslq %ebp,%rcx
mov    %ebx,(%rax,%rcx,4)
add    $0x1,%edx
mov    %edx,0x10(%rsp)
xor    %ebx,%ebx
xor    %ebp,%ebp
jmp    15f0 <load_discrete4+0x480>
nopl   (%rax)
add    $0x1,%ebx
jmp    15f0 <load_discrete4+0x480>
xor    %r13d,%r13d
lea    0x91e(%rip),%rbp
xor    %r15d,%r15d
xor    %r14d,%r14d
xor    %r12d,%r12d
jmp    1710 <load_discrete4+0x5a0>
add    $0x1,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
call   1060 <feof@plt>
test   %eax,%eax
jne    14c1 <load_discrete4+0x351>
mov    %rbx,%rdi
call   1050 <fgetc@plt>
test   %al,%al
jle    14c1 <load_discrete4+0x351>
lea    -0x9(%rax),%ecx
cmp    $0x1a,%cl
ja     1750 <load_discrete4+0x5e0>
movzbl %cl,%ecx
movslq 0x0(%rbp,%rcx,4),%rcx
add    %rbp,%rcx
jmp    *%rcx
add    $0x1,%r13d
xor    %r14d,%r14d
xor    %r15d,%r15d
jmp    1700 <load_discrete4+0x590>
add    $0x1,%r12d
xor    %r14d,%r14d
xor    %r15d,%r15d
xor    %r13d,%r13d
jmp    1700 <load_discrete4+0x590>
movsbl %al,%edi
mov    %rbx,%rsi
call   1080 <ungetc@plt>
mov    %rbx,%rdi
lea    0x909(%rip),%rsi
lea    0x24(%rsp),%rdx
call   1040 <fscanf@plt>
mov    0x24(%rsp),%eax
movslq %r12d,%rcx
mov    0x8(%rsp),%rdx
mov    (%rdx,%rcx,8),%rcx
movslq %r13d,%rdx
mov    (%rcx,%rdx,8),%rcx
movslq %r15d,%rdx
mov    (%rcx,%rdx,8),%rcx
movslq %r14d,%rdx
mov    %eax,(%rcx,%rdx,4)
mov    0x24(%rsp),%eax
mov    0x38(%rsp),%rcx
cmp    (%rcx),%eax
jle    16ed <load_discrete4+0x57d>
mov    0x38(%rsp),%rcx
mov    %eax,(%rcx)
jmp    16ed <load_discrete4+0x57d>
add    $0x1,%r15d
xor    %r14d,%r14d
jmp    1700 <load_discrete4+0x590>

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

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