#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ buf;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
scalar_t__ fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *, ...);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ stderr;
scalar_t__ strtol(char *, char **, int);
int unifold_full(char *name) {
  int repl[1024][3];
  FILE *f;
  char buf[1024];
  unsigned in_low, in_high;
  unsigned out_low, out_high;
  int line = 0;
  int first = 0;
  int len = 0;
  int z;
  f = fopen(name, "r");
  if (!f) {
    fprintf(stderr, "couldn't open %s\n", name);
    return -1;
  }
  in_low = 0;
  out_low = 0;
  printf("\n");
  printf("struct interval fold_table[] = {\n");
  while (fgets(buf, sizeof(buf), f)) {
    int x, y, c;
    unsigned inval;
    char flag;
    unsigned outval[8];
    int outval_ptr;
    char *endp;
    ++line;
    for (outval_ptr = 0; outval_ptr != 8; ++outval_ptr)
      outval[outval_ptr] = 0;
    do {
      for (x = 0; buf[x] == ' ' || buf[x] == '\t'; ++x)
        ;
    } while (0);
    if (buf[x] == '\r' || buf[x] == '\n' || buf[x] == '#' || !buf[x])
      continue;
    do {
      for (y = x; buf[y] && buf[y] != '#' && buf[y] != ';' && buf[y] != ' ' &&
                  buf[y] != '\t' && buf[y] != '\n' && buf[y] != '\r';
           ++y)
        ;
      c = buf[y];
      buf[y] = 0;
    } while (0);
    inval = (unsigned int)strtol(buf + x, &endp, 16);
    if (endp != buf + y || endp == buf + x) {
      fprintf(stderr, "%s %d: invalid input character code\n", name, line);
      return -1;
    }
    do {
      buf[y] = (char)c;
      x = y;
      if (buf[x] == ';')
        ++x;
      while (buf[x] == ' ' || buf[x] == '\t')
        ++x;
    } while (0);
    do {
      for (y = x; buf[y] && buf[y] != '#' && buf[y] != ';' && buf[y] != ' ' &&
                  buf[y] != '\t' && buf[y] != '\n' && buf[y] != '\r';
           ++y)
        ;
      c = buf[y];
      buf[y] = 0;
    } while (0);
    if (!buf[x] && buf[x + 1]) {
      fprintf(stderr, "%s %d: bad flag character\n", name, line);
      return -1;
    }
    flag = buf[x];
    if (flag == 'T' || flag == 'S')
      continue;
    if (flag != 'F' && flag != 'C') {
      fprintf(stderr, "%s %d: unknown flag", name, line);
      return -1;
    }
    for (outval_ptr = 0;; ++outval_ptr) {
      do {
        buf[y] = (char)c;
        x = y;
        if (buf[x] == ';')
          ++x;
        while (buf[x] == ' ' || buf[x] == '\t')
          ++x;
      } while (0);
      do {
        for (y = x; buf[y] && buf[y] != '#' && buf[y] != ';' && buf[y] != ' ' &&
                    buf[y] != '\t' && buf[y] != '\n' && buf[y] != '\r';
             ++y)
          ;
        c = buf[y];
        buf[y] = 0;
      } while (0);
      if (!buf[x])
        break;
      outval[outval_ptr] = (unsigned int)strtol(buf + x, &endp, 16);
      if (endp != buf + y || endp == buf + x) {
        fprintf(stderr, "%s %d: invalid output character code\n", name, line);
        return -1;
      }
    }
    if (!outval_ptr || outval_ptr > 3) {
      fprintf(stderr, "%s %d: invalid output string\n", name, line);
      return -1;
    }
    if (outval_ptr == 1) {
      if (in_low == 0) {
        in_low = in_high = inval;
        out_low = out_high = outval[0];
      } else if (in_high + 1 == inval && out_high + 1 == outval[0]) {
        in_high = inval;
        out_high = outval[0];
      } else {
        do {
          if (first) {
            printf(",\n");
          } else {
            first = 1;
          }
        } while (0);
        printf("	{ 0x%x, 0x%x }", in_low, in_high);
        repl[len][0] = (int)out_low;
        repl[len][1] = 0;
        repl[len][2] = 0;
        ++len;
        in_low = in_high = inval;
        out_low = out_high = outval[0];
      }
    } else {
      if (in_low != 0) {
        do {
          if (first) {
            printf(",\n");
          } else {
            first = 1;
          }
        } while (0);
        printf("	{ 0x%x, 0x%x }", in_low, in_high);
        repl[len][0] = (int)out_low;
        repl[len][1] = 0;
        repl[len][2] = 0;
        ++len;
        in_low = 0;
      }
      do {
        if (first) {
          printf(",\n");
        } else {
          first = 1;
        }
      } while (0);
      printf("	{ 0x%x, 0x%x }", inval, inval);
      repl[len][0] = (int)outval[0];
      repl[len][1] = (int)outval[1];
      repl[len][2] = (int)outval[2];
      ++len;
    }
  }
  if (in_low != 0) {
    do {
      if (first) {
        printf(",\n");
      } else {
        first = 1;
      }
    } while (0);
    printf("	{ 0x%x, 0x%x }", in_low, in_high);
    repl[len][0] = (int)out_low;
    repl[len][1] = 0;
    repl[len][2] = 0;
    ++len;
  }
  do {
    if (first) {
      printf(",\n");
    } else {
      first = 1;
    }
  } while (0);
  printf("	{ 0x0, 0x0 }");
  printf("\n};\n");
  first = 0;
  printf("\nint fold_repl[][REPLLEN] = {\n");
  for (z = 0; z != len; ++z) {
    do {
      if (first) {
        printf(",\n");
      } else {
        first = 1;
      }
    } while (0);
    printf("	{ 0x%x, 0x%x, 0x%x }", repl[z][0], repl[z][1], repl[z][2]);
  }
  printf("\n};\n");
  fclose(f);
  return 0;
}


x86 assembly (clang, -O0):
<unifold_full>:
push   %rbp
mov    %rsp,%rbp
sub    $0x34a0,%rsp
mov    %rdi,-0x10(%rbp)
movl   $0x0,-0x3434(%rbp)
movl   $0x0,-0x3438(%rbp)
movl   $0x0,-0x343c(%rbp)
mov    -0x10(%rbp),%rdi
lea    0x1e68(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x3018(%rbp)
cmpq   $0x0,-0x3018(%rbp)
jne    11d9 <unifold_full+0x79>
mov    0x3e27(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rdx
lea    0x1e3c(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    200b <unifold_full+0xeab>
movl   $0x0,-0x3424(%rbp)
movl   $0x0,-0x342c(%rbp)
lea    0x1edb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1e12(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x3420(%rbp),%rdi
mov    -0x3018(%rbp),%rdx
mov    $0x400,%esi
call   1050 <fgets@plt>
cmp    $0x0,%rax
je     1e0a <unifold_full+0xcaa>
mov    -0x3434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3434(%rbp)
movl   $0x0,-0x3484(%rbp)
cmpl   $0x8,-0x3484(%rbp)
je     1277 <unifold_full+0x117>
movslq -0x3484(%rbp),%rax
movl   $0x0,-0x3480(%rbp,%rax,4)
mov    -0x3484(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3484(%rbp)
jmp    1244 <unifold_full+0xe4>
jmp    127c <unifold_full+0x11c>
movl   $0x0,-0x3444(%rbp)
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
mov    $0x1,%al
cmp    $0x20,%ecx
mov    %al,-0x3491(%rbp)
je     12c1 <unifold_full+0x161>
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0x9,%eax
sete   %al
mov    %al,-0x3491(%rbp)
mov    -0x3491(%rbp),%al
test   $0x1,%al
jne    12d4 <unifold_full+0x174>
jmp    12ed <unifold_full+0x18d>
jmp    12d9 <unifold_full+0x179>
mov    -0x3444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3444(%rbp)
jmp    1286 <unifold_full+0x126>
jmp    12f2 <unifold_full+0x192>
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
cmp    $0xd,%eax
je     134f <unifold_full+0x1ef>
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0xa,%eax
je     134f <unifold_full+0x1ef>
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0x23,%eax
je     134f <unifold_full+0x1ef>
movslq -0x3444(%rbp),%rax
cmpb   $0x0,-0x3420(%rbp,%rax,1)
jne    1354 <unifold_full+0x1f4>
jmp    1209 <unifold_full+0xa9>
jmp    1359 <unifold_full+0x1f9>
mov    -0x3444(%rbp),%eax
mov    %eax,-0x3448(%rbp)
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x3492(%rbp)
je     1440 <unifold_full+0x2e0>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x23,%ecx
mov    %al,-0x3492(%rbp)
je     1440 <unifold_full+0x2e0>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x3b,%ecx
mov    %al,-0x3492(%rbp)
je     1440 <unifold_full+0x2e0>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x3492(%rbp)
je     1440 <unifold_full+0x2e0>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x9,%ecx
mov    %al,-0x3492(%rbp)
je     1440 <unifold_full+0x2e0>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x3492(%rbp)
je     1440 <unifold_full+0x2e0>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0xd,%eax
setne  %al
mov    %al,-0x3492(%rbp)
mov    -0x3492(%rbp),%al
test   $0x1,%al
jne    1453 <unifold_full+0x2f3>
jmp    146c <unifold_full+0x30c>
jmp    1458 <unifold_full+0x2f8>
mov    -0x3448(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3448(%rbp)
jmp    1365 <unifold_full+0x205>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
mov    %eax,-0x344c(%rbp)
movslq -0x3448(%rbp),%rax
movb   $0x0,-0x3420(%rbp,%rax,1)
lea    -0x3420(%rbp),%rdi
movslq -0x3444(%rbp),%rax
add    %rax,%rdi
lea    -0x3490(%rbp),%rsi
mov    $0x10,%edx
call   1070 <strtol@plt>
mov    %eax,-0x3450(%rbp)
mov    -0x3490(%rbp),%rax
lea    -0x3420(%rbp),%rcx
movslq -0x3448(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jne    14fa <unifold_full+0x39a>
mov    -0x3490(%rbp),%rax
lea    -0x3420(%rbp),%rcx
movslq -0x3444(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jne    1527 <unifold_full+0x3c7>
mov    0x3adf(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rdx
mov    -0x3434(%rbp),%ecx
lea    0x1b22(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    200b <unifold_full+0xeab>
jmp    152c <unifold_full+0x3cc>
mov    -0x344c(%rbp),%eax
mov    %al,%cl
movslq -0x3448(%rbp),%rax
mov    %cl,-0x3420(%rbp,%rax,1)
mov    -0x3448(%rbp),%eax
mov    %eax,-0x3444(%rbp)
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0x3b,%eax
jne    1575 <unifold_full+0x415>
mov    -0x3444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3444(%rbp)
jmp    157a <unifold_full+0x41a>
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
mov    $0x1,%al
cmp    $0x20,%ecx
mov    %al,-0x3493(%rbp)
je     15b5 <unifold_full+0x455>
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0x9,%eax
sete   %al
mov    %al,-0x3493(%rbp)
mov    -0x3493(%rbp),%al
test   $0x1,%al
jne    15c8 <unifold_full+0x468>
jmp    15dc <unifold_full+0x47c>
mov    -0x3444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3444(%rbp)
jmp    157a <unifold_full+0x41a>
jmp    15e1 <unifold_full+0x481>
jmp    15e6 <unifold_full+0x486>
mov    -0x3444(%rbp),%eax
mov    %eax,-0x3448(%rbp)
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x3494(%rbp)
je     16cd <unifold_full+0x56d>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x23,%ecx
mov    %al,-0x3494(%rbp)
je     16cd <unifold_full+0x56d>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x3b,%ecx
mov    %al,-0x3494(%rbp)
je     16cd <unifold_full+0x56d>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x3494(%rbp)
je     16cd <unifold_full+0x56d>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x9,%ecx
mov    %al,-0x3494(%rbp)
je     16cd <unifold_full+0x56d>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x3494(%rbp)
je     16cd <unifold_full+0x56d>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0xd,%eax
setne  %al
mov    %al,-0x3494(%rbp)
mov    -0x3494(%rbp),%al
test   $0x1,%al
jne    16e0 <unifold_full+0x580>
jmp    16f9 <unifold_full+0x599>
jmp    16e5 <unifold_full+0x585>
mov    -0x3448(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3448(%rbp)
jmp    15f2 <unifold_full+0x492>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
mov    %eax,-0x344c(%rbp)
movslq -0x3448(%rbp),%rax
movb   $0x0,-0x3420(%rbp,%rax,1)
movslq -0x3444(%rbp),%rax
cmpb   $0x0,-0x3420(%rbp,%rax,1)
jne    177b <unifold_full+0x61b>
mov    -0x3444(%rbp),%eax
add    $0x1,%eax
cltq
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     177b <unifold_full+0x61b>
mov    0x388b(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rdx
mov    -0x3434(%rbp),%ecx
lea    0x18f3(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    200b <unifold_full+0xeab>
movslq -0x3444(%rbp),%rax
mov    -0x3420(%rbp,%rax,1),%al
mov    %al,-0x3451(%rbp)
movsbl -0x3451(%rbp),%eax
cmp    $0x54,%eax
je     17af <unifold_full+0x64f>
movsbl -0x3451(%rbp),%eax
cmp    $0x53,%eax
jne    17b4 <unifold_full+0x654>
jmp    1209 <unifold_full+0xa9>
movsbl -0x3451(%rbp),%eax
cmp    $0x46,%eax
je     1801 <unifold_full+0x6a1>
movsbl -0x3451(%rbp),%eax
cmp    $0x43,%eax
je     1801 <unifold_full+0x6a1>
mov    0x3805(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rdx
mov    -0x3434(%rbp),%ecx
lea    0x1888(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    200b <unifold_full+0xeab>
movl   $0x0,-0x3484(%rbp)
jmp    1810 <unifold_full+0x6b0>
mov    -0x344c(%rbp),%eax
mov    %al,%cl
movslq -0x3448(%rbp),%rax
mov    %cl,-0x3420(%rbp,%rax,1)
mov    -0x3448(%rbp),%eax
mov    %eax,-0x3444(%rbp)
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0x3b,%eax
jne    1859 <unifold_full+0x6f9>
mov    -0x3444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3444(%rbp)
jmp    185e <unifold_full+0x6fe>
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
mov    $0x1,%al
cmp    $0x20,%ecx
mov    %al,-0x3495(%rbp)
je     1899 <unifold_full+0x739>
movslq -0x3444(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0x9,%eax
sete   %al
mov    %al,-0x3495(%rbp)
mov    -0x3495(%rbp),%al
test   $0x1,%al
jne    18ac <unifold_full+0x74c>
jmp    18c0 <unifold_full+0x760>
mov    -0x3444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3444(%rbp)
jmp    185e <unifold_full+0x6fe>
jmp    18c5 <unifold_full+0x765>
jmp    18ca <unifold_full+0x76a>
mov    -0x3444(%rbp),%eax
mov    %eax,-0x3448(%rbp)
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x3496(%rbp)
je     19b1 <unifold_full+0x851>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x23,%ecx
mov    %al,-0x3496(%rbp)
je     19b1 <unifold_full+0x851>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x3b,%ecx
mov    %al,-0x3496(%rbp)
je     19b1 <unifold_full+0x851>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x20,%ecx
mov    %al,-0x3496(%rbp)
je     19b1 <unifold_full+0x851>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0x9,%ecx
mov    %al,-0x3496(%rbp)
je     19b1 <unifold_full+0x851>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%ecx
ff
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x3496(%rbp)
je     19b1 <unifold_full+0x851>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
cmp    $0xd,%eax
setne  %al
mov    %al,-0x3496(%rbp)
mov    -0x3496(%rbp),%al
test   $0x1,%al
jne    19c4 <unifold_full+0x864>
jmp    19dd <unifold_full+0x87d>
jmp    19c9 <unifold_full+0x869>
mov    -0x3448(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3448(%rbp)
jmp    18d6 <unifold_full+0x776>
movslq -0x3448(%rbp),%rax
movsbl -0x3420(%rbp,%rax,1),%eax
ff
mov    %eax,-0x344c(%rbp)
movslq -0x3448(%rbp),%rax
movb   $0x0,-0x3420(%rbp,%rax,1)
movslq -0x3444(%rbp),%rax
cmpb   $0x0,-0x3420(%rbp,%rax,1)
jne    1a1b <unifold_full+0x8bb>
jmp    1ad5 <unifold_full+0x975>
lea    -0x3420(%rbp),%rdi
movslq -0x3444(%rbp),%rax
add    %rax,%rdi
lea    -0x3490(%rbp),%rsi
mov    $0x10,%edx
call   1070 <strtol@plt>
mov    %eax,%ecx
movslq -0x3484(%rbp),%rax
mov    %ecx,-0x3480(%rbp,%rax,4)
mov    -0x3490(%rbp),%rax
lea    -0x3420(%rbp),%rcx
movslq -0x3448(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jne    1a8f <unifold_full+0x92f>
mov    -0x3490(%rbp),%rax
lea    -0x3420(%rbp),%rcx
movslq -0x3444(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jne    1abc <unifold_full+0x95c>
mov    0x354a(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rdx
mov    -0x3434(%rbp),%ecx
lea    0x15e1(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    200b <unifold_full+0xeab>
jmp    1ac1 <unifold_full+0x961>
mov    -0x3484(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3484(%rbp)
jmp    180b <unifold_full+0x6ab>
cmpl   $0x0,-0x3484(%rbp)
je     1aef <unifold_full+0x98f>
cmpl   $0x3,-0x3484(%rbp)
jle    1b1c <unifold_full+0x9bc>
mov    0x34ea(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rdx
mov    -0x3434(%rbp),%ecx
lea    0x15a7(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    200b <unifold_full+0xeab>
cmpl   $0x1,-0x3484(%rbp)
jne    1c86 <unifold_full+0xb26>
cmpl   $0x0,-0x3424(%rbp)
jne    1b5f <unifold_full+0x9ff>
mov    -0x3450(%rbp),%eax
mov    %eax,-0x3428(%rbp)
mov    %eax,-0x3424(%rbp)
mov    -0x3480(%rbp),%eax
mov    %eax,-0x3430(%rbp)
mov    %eax,-0x342c(%rbp)
jmp    1c81 <unifold_full+0xb21>
mov    -0x3428(%rbp),%eax
add    $0x1,%eax
cmp    -0x3450(%rbp),%eax
jne    1ba6 <unifold_full+0xa46>
mov    -0x3430(%rbp),%eax
add    $0x1,%eax
cmp    -0x3480(%rbp),%eax
jne    1ba6 <unifold_full+0xa46>
mov    -0x3450(%rbp),%eax
mov    %eax,-0x3428(%rbp)
mov    -0x3480(%rbp),%eax
mov    %eax,-0x3430(%rbp)
jmp    1c7c <unifold_full+0xb1c>
jmp    1bab <unifold_full+0xa4b>
cmpl   $0x0,-0x3438(%rbp)
je     1bcb <unifold_full+0xa6b>
lea    0x150f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1bd5 <unifold_full+0xa75>
movl   $0x1,-0x3438(%rbp)
jmp    1bda <unifold_full+0xa7a>
mov    -0x3424(%rbp),%esi
mov    -0x3428(%rbp),%edx
lea    0x14e4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x342c(%rbp),%ecx
movslq -0x343c(%rbp),%rdx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
movslq -0x343c(%rbp),%rcx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movl   $0x0,0x4(%rax)
movslq -0x343c(%rbp),%rcx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movl   $0x0,0x8(%rax)
mov    -0x343c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x343c(%rbp)
mov    -0x3450(%rbp),%eax
mov    %eax,-0x3428(%rbp)
mov    %eax,-0x3424(%rbp)
mov    -0x3480(%rbp),%eax
mov    %eax,-0x3430(%rbp)
mov    %eax,-0x342c(%rbp)
jmp    1c81 <unifold_full+0xb21>
jmp    1e05 <unifold_full+0xca5>
cmpl   $0x0,-0x3424(%rbp)
je     1d4f <unifold_full+0xbef>
jmp    1c98 <unifold_full+0xb38>
cmpl   $0x0,-0x3438(%rbp)
je     1cb8 <unifold_full+0xb58>
lea    0x1422(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1cc2 <unifold_full+0xb62>
movl   $0x1,-0x3438(%rbp)
jmp    1cc7 <unifold_full+0xb67>
mov    -0x3424(%rbp),%esi
mov    -0x3428(%rbp),%edx
lea    0x13f7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x342c(%rbp),%ecx
movslq -0x343c(%rbp),%rdx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
movslq -0x343c(%rbp),%rcx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movl   $0x0,0x4(%rax)
movslq -0x343c(%rbp),%rcx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movl   $0x0,0x8(%rax)
mov    -0x343c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x343c(%rbp)
movl   $0x0,-0x3424(%rbp)
jmp    1d54 <unifold_full+0xbf4>
cmpl   $0x0,-0x3438(%rbp)
je     1d74 <unifold_full+0xc14>
lea    0x1366(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1d7e <unifold_full+0xc1e>
movl   $0x1,-0x3438(%rbp)
jmp    1d83 <unifold_full+0xc23>
mov    -0x3450(%rbp),%esi
mov    -0x3450(%rbp),%edx
lea    0x133b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x3480(%rbp),%ecx
movslq -0x343c(%rbp),%rdx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x347c(%rbp),%ecx
movslq -0x343c(%rbp),%rdx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
mov    -0x3478(%rbp),%ecx
movslq -0x343c(%rbp),%rdx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x343c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x343c(%rbp)
jmp    1209 <unifold_full+0xa9>
cmpl   $0x0,-0x3424(%rbp)
je     1ec9 <unifold_full+0xd69>
jmp    1e1c <unifold_full+0xcbc>
cmpl   $0x0,-0x3438(%rbp)
je     1e3c <unifold_full+0xcdc>
lea    0x129e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1e46 <unifold_full+0xce6>
movl   $0x1,-0x3438(%rbp)
jmp    1e4b <unifold_full+0xceb>
mov    -0x3424(%rbp),%esi
mov    -0x3428(%rbp),%edx
lea    0x1273(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x342c(%rbp),%ecx
movslq -0x343c(%rbp),%rdx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
movslq -0x343c(%rbp),%rcx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movl   $0x0,0x4(%rax)
movslq -0x343c(%rbp),%rcx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movl   $0x0,0x8(%rax)
mov    -0x343c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x343c(%rbp)
jmp    1ece <unifold_full+0xd6e>
cmpl   $0x0,-0x3438(%rbp)
je     1eee <unifold_full+0xd8e>
lea    0x11ec(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1ef8 <unifold_full+0xd98>
movl   $0x1,-0x3438(%rbp)
jmp    1efd <unifold_full+0xd9d>
lea    0x11dd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x11dd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x3438(%rbp)
lea    0x11ca(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x3440(%rbp)
mov    -0x3440(%rbp),%eax
cmp    -0x343c(%rbp),%eax
je     1fea <unifold_full+0xe8a>
jmp    1f52 <unifold_full+0xdf2>
cmpl   $0x0,-0x3438(%rbp)
je     1f72 <unifold_full+0xe12>
lea    0x1168(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1f7c <unifold_full+0xe1c>
movl   $0x1,-0x3438(%rbp)
jmp    1f81 <unifold_full+0xe21>
movslq -0x3440(%rbp),%rcx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%esi
movslq -0x3440(%rbp),%rcx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%edx
movslq -0x3440(%rbp),%rcx
lea    -0x3010(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%ecx
lea    0x1144(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x3440(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3440(%rbp)
jmp    1f3b <unifold_full+0xddb>
lea    0x10fe(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x3018(%rbp),%rdi
call   1030 <fclose@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x34a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<unifold_full>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3478,%rsp
mov    %rdi,%rbp
lea    0xe65(%rip),%rsi
call   10a0 <fopen@plt>
test   %rax,%rax
je     16c2 <unifold_full+0x542>
mov    %rax,%rbx
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xf23(%rip),%rdi
call   1040 <puts@plt>
lea    0x70(%rsp),%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1070 <fgets@plt>
test   %rax,%rax
mov    %rbx,0x38(%rsp)
je     16e7 <unifold_full+0x567>
mov    %rbp,0x20(%rsp)
movabs $0x100000000,%r15
lea    0x70(%rsp),%r14
movabs $0x100000200,%rbp
movabs $0x800002401,%r12
movl   $0x0,0xc(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
movl   $0x0,0x10(%rsp)
xor    %r13d,%r13d
movl   $0x0,0x14(%rsp)
mov    %rax,0x28(%rsp)
jmp    125f <unifold_full+0xdf>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
bt     %rcx,%r12
jae    12a0 <unifold_full+0x120>
mov    %r14,%rdi
mov    $0x400,%esi
mov    %rbx,%rdx
call   1070 <fgets@plt>
test   %rax,%rax
je     171d <unifold_full+0x59d>
xorps  %xmm0,%xmm0
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x60(%rsp)
add    $0x1,%r13d
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x70(%rsp,%rax,1),%ecx
cmp    $0x23,%rcx
ja     12a0 <unifold_full+0x120>
bt     %rcx,%rbp
jae    1240 <unifold_full+0xc0>
add    $0x1,%rax
jmp    1280 <unifold_full+0x100>
nopw   0x0(%rax,%rax,1)
mov    %eax,%ebp
lea    (%rsp,%rbp,1),%r14
add    $0x70,%r14
movabs $0x800000900002601,%rax
jmp    12c4 <unifold_full+0x144>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
movzbl 0x70(%rsp,%rbp,1),%ebx
cmp    $0x3b,%rbx
ja     12c0 <unifold_full+0x140>
bt     %rbx,%rax
jae    12c0 <unifold_full+0x140>
mov    %ebp,%eax
lea    (%rsp,%rax,1),%r12
add    $0x70,%r12
movb   $0x0,0x70(%rsp,%rax,1)
mov    %r14,%rdi
lea    0x48(%rsp),%rsi
mov    $0x10,%edx
call   1090 <strtol@plt>
mov    %rax,0x40(%rsp)
mov    0x48(%rsp),%rax
cmp    %r12,%rax
jne    1850 <unifold_full+0x6d0>
cmp    %r14,%rax
je     1850 <unifold_full+0x6d0>
mov    %bl,(%r12)
xor    %eax,%eax
cmp    $0x3b,%bl
sete   %al
add    %ebp,%eax
jmp    1334 <unifold_full+0x1b4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
movzbl 0x70(%rsp,%rax,1),%ecx
cmp    $0x9,%cl
je     1330 <unifold_full+0x1b0>
cmp    $0x20,%cl
je     1330 <unifold_full+0x1b0>
mov    %eax,%ecx
mov    %rcx,%rbx
jmp    1354 <unifold_full+0x1d4>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
movzbl 0x70(%rsp,%rbx,1),%r12d
cmp    $0x3b,%r12
ja     1350 <unifold_full+0x1d0>
movabs $0x800000900002601,%rdx
bt     %r12,%rdx
jae    1350 <unifold_full+0x1d0>
mov    %ebx,%edx
movb   $0x0,0x70(%rsp,%rdx,1)
mov    0x70(%rsp,%rcx,1),%cl
test   %cl,%cl
je     1861 <unifold_full+0x6e1>
lea    -0x53(%rcx),%eax
cmp    $0x2,%al
jae    13ad <unifold_full+0x22d>
mov    0x38(%rsp),%rbx
lea    0x70(%rsp),%r14
movabs $0x100000200,%rbp
movabs $0x800002401,%r12
jmp    1246 <unifold_full+0xc6>
cmp    $0x46,%cl
je     13bb <unifold_full+0x23b>
cmp    $0x43,%cl
jne    1874 <unifold_full+0x6f4>
mov    %r13d,0x34(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movabs $0x800000900002601,%rcx
movslq %ebx,%rax
mov    %r12b,0x70(%rsp,%rax,1)
xor    %eax,%eax
cmp    $0x3b,%r12b
sete   %al
add    %rbx,%rax
mov    %rax,%rbx
shl    $0x20,%rbx
cltq
lea    (%rsp,%rax,1),%r14
add    $0x70,%r14
jmp    1417 <unifold_full+0x297>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
add    %r15,%rbx
movzbl (%r14),%eax
cmp    $0x9,%al
je     1410 <unifold_full+0x290>
cmp    $0x20,%al
je     1410 <unifold_full+0x290>
sar    $0x20,%rbx
jmp    1434 <unifold_full+0x2b4>
nopl   0x0(%rax)
add    $0x1,%rbx
movzbl 0x70(%rsp,%rbx,1),%r12d
cmp    $0x3b,%r12
ja     1430 <unifold_full+0x2b0>
bt     %r12,%rcx
jae    1430 <unifold_full+0x2b0>
movb   $0x0,0x70(%rsp,%rbx,1)
cmpb   $0x0,(%r14)
je     148f <unifold_full+0x30f>
lea    (%rsp,%rbx,1),%r13
add    $0x70,%r13
mov    %r14,%rdi
lea    0x48(%rsp),%rsi
mov    $0x10,%edx
call   1090 <strtol@plt>
mov    %eax,0x50(%rsp,%rbp,4)
mov    0x48(%rsp),%rax
cmp    %rax,%r13
jne    16ee <unifold_full+0x56e>
cmp    %rax,%r14
je     16ee <unifold_full+0x56e>
add    $0x1,%rbp
jmp    13d0 <unifold_full+0x250>
lea    -0x4(%rbp),%eax
cmp    $0xfffffffd,%eax
mov    0x34(%rsp),%r13d
jb     187d <unifold_full+0x6fd>
cmp    $0x1,%ebp
jne    14fc <unifold_full+0x37c>
cmpl   $0x0,0xc(%rsp)
je     155b <unifold_full+0x3db>
mov    0x28(%rsp),%rdx
lea    0x1(%rdx),%eax
cmp    0x40(%rsp),%eax
mov    0x38(%rsp),%rbx
lea    0x70(%rsp),%r14
movabs $0x100000200,%rbp
movabs $0x800002401,%r12
jne    153a <unifold_full+0x3ba>
mov    0x30(%rsp),%eax
add    $0x1,%eax
mov    %eax,0x30(%rsp)
cmp    0x50(%rsp),%eax
jne    153a <unifold_full+0x3ba>
mov    0x40(%rsp),%rax
mov    %rax,0x28(%rsp)
jmp    1246 <unifold_full+0xc6>
cmpl   $0x0,0xc(%rsp)
je     157e <unifold_full+0x3fe>
cmpl   $0x0,0x10(%rsp)
mov    0x38(%rsp),%rbx
lea    0x70(%rsp),%r14
movabs $0x100000200,%rbp
movabs $0x800002401,%r12
je     15ad <unifold_full+0x42d>
lea    0xbf0(%rip),%rdi
call   1040 <puts@plt>
jmp    15b5 <unifold_full+0x435>
cmpl   $0x0,0x10(%rsp)
je     165a <unifold_full+0x4da>
lea    0xbd7(%rip),%rdi
call   1040 <puts@plt>
mov    0x28(%rsp),%rdx
jmp    1662 <unifold_full+0x4e2>
mov    0x50(%rsp),%eax
mov    0x40(%rsp),%rdx
mov    %edx,%ecx
mov    %rcx,0x28(%rsp)
mov    %eax,0x14(%rsp)
mov    %eax,0x30(%rsp)
mov    %edx,%eax
mov    %edx,0xc(%rsp)
jmp    138a <unifold_full+0x20a>
cmpl   $0x0,0x10(%rsp)
mov    0x38(%rsp),%rbx
lea    0x70(%rsp),%r14
movabs $0x100000200,%rbp
movabs $0x800002401,%r12
jne    15f7 <unifold_full+0x477>
movl   $0x1,0x10(%rsp)
jmp    1603 <unifold_full+0x483>
movl   $0x1,0x10(%rsp)
lea    0xaf0(%rip),%rdi
mov    0xc(%rsp),%esi
mov    0x28(%rsp),%rdx
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x18(%rsp),%rcx
movslq %ecx,%rcx
lea    (%rcx,%rcx,2),%rax
mov    0x14(%rsp),%edx
mov    %edx,0x470(%rsp,%rax,4)
movq   $0x0,0x474(%rsp,%rax,4)
add    $0x1,%ecx
mov    %rcx,0x18(%rsp)
lea    0xb25(%rip),%rdi
call   1040 <puts@plt>
movl   $0x0,0xc(%rsp)
lea    0xa9a(%rip),%rdi
mov    0x40(%rsp),%rdx
mov    %edx,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x50(%rsp),%eax
mov    0x18(%rsp),%rdx
movslq %edx,%rdx
lea    (%rdx,%rdx,2),%rcx
mov    %eax,0x470(%rsp,%rcx,4)
mov    0x54(%rsp),%eax
mov    %eax,0x474(%rsp,%rcx,4)
mov    0x58(%rsp),%eax
mov    %eax,0x478(%rsp,%rcx,4)
add    $0x1,%edx
mov    %rdx,0x18(%rsp)
jmp    1246 <unifold_full+0xc6>
movl   $0x1,0x10(%rsp)
lea    0xa43(%rip),%rdi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x18(%rsp),%rcx
movslq %ecx,%rax
lea    (%rax,%rax,2),%rax
mov    0x14(%rsp),%edx
mov    %edx,0x470(%rsp,%rax,4)
movq   $0x0,0x474(%rsp,%rax,4)
add    $0x1,%ecx
mov    %rcx,0x18(%rsp)
mov    0x50(%rsp),%eax
mov    0x40(%rsp),%rdx
mov    %edx,%ecx
mov    %rcx,0x28(%rsp)
mov    %eax,0x14(%rsp)
mov    %eax,0x30(%rsp)
mov    %edx,%eax
mov    %edx,0xc(%rsp)
jmp    1246 <unifold_full+0xc6>
mov    0x2917(%rip),%rax
mov    (%rax),%edi
lea    0x930(%rip),%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    $0xffffffff,%r14d
jmp    183b <unifold_full+0x6bb>
xor    %ebx,%ebx
jmp    178e <unifold_full+0x60e>
lea    0x973(%rip),%rsi
mov    0x20(%rsp),%rdx
mov    0x34(%rsp),%r13d
mov    0x28da(%rip),%rax
mov    (%rax),%edi
mov    %r13d,%ecx
xor    %eax,%eax
call   1080 <fprintf@plt>
mov    $0xffffffff,%r14d
jmp    183b <unifold_full+0x6bb>
cmpl   $0x0,0xc(%rsp)
je     1776 <unifold_full+0x5f6>
cmpl   $0x0,0x10(%rsp)
mov    0x18(%rsp),%rbx
je     173c <unifold_full+0x5bc>
lea    0x9ec(%rip),%rdi
call   1040 <puts@plt>
lea    0x969(%rip),%rdi
mov    0xc(%rsp),%esi
mov    0x28(%rsp),%rdx
xor    %eax,%eax
call   1060 <printf@plt>
movslq %ebx,%rbx
lea    (%rbx,%rbx,2),%rax
mov    0x14(%rsp),%ecx
mov    %ecx,0x470(%rsp,%rax,4)
movq   $0x0,0x474(%rsp,%rax,4)
add    $0x1,%ebx
jmp    1782 <unifold_full+0x602>
cmpl   $0x0,0x10(%rsp)
mov    0x18(%rsp),%rbx
je     178e <unifold_full+0x60e>
lea    0x99a(%rip),%rdi
call   1040 <puts@plt>
lea    0x927(%rip),%rdi
xor    %r14d,%r14d
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x979(%rip),%rdi
call   1040 <puts@plt>
lea    0x94f(%rip),%rdi
call   1040 <puts@plt>
test   %ebx,%ebx
je     1825 <unifold_full+0x6a5>
mov    0x470(%rsp),%esi
mov    0x474(%rsp),%edx
mov    0x478(%rsp),%ecx
lea    0x8f3(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    $0x1,%ebx
je     1825 <unifold_full+0x6a5>
mov    %ebx,%ebx
lea    0x484(%rsp),%rbp
add    $0xffffffffffffffff,%rbx
lea    0x92b(%rip),%r15
lea    0x8cb(%rip),%r12
nop
mov    %r15,%rdi
call   1040 <puts@plt>
mov    -0x8(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    0x0(%rbp),%ecx
mov    %r12,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0xc,%rbp
add    $0xffffffffffffffff,%rbx
jne    1800 <unifold_full+0x680>
lea    0x8f3(%rip),%rdi
call   1040 <puts@plt>
mov    0x38(%rsp),%rdi
call   1050 <fclose@plt>
mov    %r14d,%eax
add    $0x3478,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x20(%rsp),%rdx
lea    0x7b8(%rip),%rsi
jmp    16ff <unifold_full+0x57f>
add    $0x1,%eax
cmpb   $0x0,0x70(%rsp,%rax,1)
je     1874 <unifold_full+0x6f4>
lea    0x7c7(%rip),%rsi
jmp    1884 <unifold_full+0x704>
lea    0x7d9(%rip),%rsi
jmp    1884 <unifold_full+0x704>
lea    0x80a(%rip),%rsi
mov    0x20(%rsp),%rdx
jmp    16ff <unifold_full+0x57f>

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

LLVM IR (-O2):
@.str = [2 x i8] c"r\00"
@stderr = global i32 0
@.str.1 = [18 x i8] c"couldn't open %s\0A\00"
@.str.4 = [37 x i8] c"%s %d: invalid input character code\0A\00"
@.str.5 = [27 x i8] c"%s %d: bad flag character\0A\00"
@.str.6 = [20 x i8] c"%s %d: unknown flag\00"
@.str.7 = [38 x i8] c"%s %d: invalid output character code\0A\00"
@.str.8 = [30 x i8] c"%s %d: invalid output string\0A\00"
@.str.10 = [16 x i8] c"\09{ 0x%x, 0x%x }\00"
@.str.11 = [14 x i8] c"\09{ 0x0, 0x0 }\00"
@.str.14 = [22 x i8] c"\09{ 0x%x, 0x%x, 0x%x }\00"
@str = [33 x i8] c"struct interval fold_table[] = {\00"
@str.16 = [30 x i8] c"\0Aint fold_repl[][REPLLEN] = {\00"
@str.17 = [4 x i8] c"\0A};\00"
@str.23 = [2 x i8] c",\00"
define i32 @unifold_full(i8* %0) {
%2 = alloca [1024 x [3 x i32]]
%3 = alloca [1024 x i8]
%4 = alloca [8 x i32]
%5 = bitcast [8 x i32]* %4 to i8*
%6 = alloca i8*
%7 = bitcast [1024 x [3 x i32]]* %2 to i8*
%8 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 0
%9 = tail call i32* @fopen(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%10 = icmp eq i32* %9, null
br i1 %10, label %11, label %14
11: ; preds = %1
%12 = load i32, i32* @stderr
%13 = tail call i32 (i32, i8*, i8*, ...) @fprintf(i32 %12, i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i8* %0)
br label %257
14: ; preds = %1
%15 = tail call i32 @putchar(i32 10)
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str, i64 0, i64 0))
%17 = call i64 @fgets(i8* %8, i32 1024, i32* %9)
%18 = icmp eq i64 %17, 0
br i1 %18, label %226, label %19
19: ; preds = %14
%20 = bitcast i8** %6 to i8*
%21 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 0
%22 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 1
%23 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 2
br label %24
24: ; preds = %19, %200
%25 = phi i32 [ 0, %19 ], [ %206, %200 ]
%26 = phi i32 [ 0, %19 ], [ %205, %200 ]
%27 = phi i32 [ 0, %19 ], [ %204, %200 ]
%28 = phi i32 [ 0, %19 ], [ %32, %200 ]
%29 = phi i32 [ undef, %19 ], [ %203, %200 ]
%30 = phi i32 [ 0, %19 ], [ %202, %200 ]
%31 = phi i32 [ undef, %19 ], [ %201, %200 ]
%32 = add nuw nsw i32 %28, 1
br label %33
33: ; preds = %24, %40
%34 = phi i64 [ 0, %24 ], [ %41, %40 ]
%35 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %34
%36 = load i8, i8* %35
switch i8 %36, label %37 [
i8 32, label %40
i8 9, label %40
i8 13, label %200
i8 10, label %200
i8 35, label %200
i8 0, label %200
]
37: ; preds = %33
%38 = and i64 %34, 4294967295
%39 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %38
br label %42
40: ; preds = %33, %33
%41 = add nuw i64 %34, 1
br label %33
42: ; preds = %37, %46
%43 = phi i64 [ %38, %37 ], [ %47, %46 ]
%44 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %43
%45 = load i8, i8* %44
switch i8 %45, label %46 [
i8 0, label %48
i8 35, label %48
i8 59, label %48
i8 32, label %48
i8 9, label %48
i8 10, label %48
i8 13, label %48
]
46: ; preds = %42
%47 = add nuw i64 %43, 1
br label %42
48: ; preds = %42, %42, %42, %42, %42, %42, %42
%49 = and i64 %43, 4294967295
%50 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %49
store i8 0, i8* %50
%51 = call i64 @strtol(i8* %39, i8** %6, i32 16)
%52 = trunc i64 %51 to i32
%53 = load i8*, i8** %6
%54 = icmp ne i8* %53, %50
%55 = icmp eq i8* %53, %39
%56 = or i1 %54, %55
br i1 %56, label %196, label %57
57: ; preds = %48
store i8 %45, i8* %50
%58 = icmp eq i8 %45, 59
%59 = zext i1 %58 to i64
%60 = add i64 %43, %59
%61 = and i64 %60, 4294967295
br label %62
62: ; preds = %69, %57
%63 = phi i64 [ %70, %69 ], [ %61, %57 ]
%64 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %63
%65 = load i8, i8* %64
switch i8 %65, label %66 [
i8 32, label %69
i8 9, label %69
]
66: ; preds = %62
%67 = and i64 %63, 4294967295
%68 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %67
br label %71
69: ; preds = %62, %62
%70 = add nuw i64 %63, 1
br label %62
71: ; preds = %66, %75
%72 = phi i64 [ %67, %66 ], [ %76, %75 ]
%73 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %72
%74 = load i8, i8* %73
switch i8 %74, label %75 [
i8 0, label %77
i8 35, label %77
i8 59, label %77
i8 32, label %77
i8 9, label %77
i8 10, label %77
i8 13, label %77
]
75: ; preds = %71
%76 = add nuw i64 %72, 1
br label %71
77: ; preds = %71, %71, %71, %71, %71, %71, %71
%78 = and i64 %72, 4294967295
%79 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %78
store i8 0, i8* %79
%80 = load i8, i8* %68
%81 = icmp eq i8 %80, 0
br i1 %81, label %82, label %88
82: ; preds = %77
%83 = add i64 %63, 1
%84 = and i64 %83, 4294967295
%85 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %84
%86 = load i8, i8* %85
%87 = icmp eq i8 %86, 0
br i1 %87, label %93, label %196
88: ; preds = %77
%89 = add i8 %80, -83
%90 = icmp ult i8 %89, 2
br i1 %90, label %200, label %91
91: ; preds = %88
switch i8 %80, label %93 [
i8 70, label %92
i8 67, label %92
]
92: ; preds = %91, %91
br label %94
93: ; preds = %91, %82
br label %196
94: ; preds = %92, %134
%95 = phi i64 [ %135, %134 ], [ 0, %92 ]
%96 = phi i64 [ %117, %134 ], [ %72, %92 ]
%97 = phi i8 [ %119, %134 ], [ %74, %92 ]
%98 = shl i64 %96, 32
%99 = ashr exact i64 %98, 32
%100 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %99
store i8 %97, i8* %100
%101 = icmp eq i8 %97, 59
%102 = zext i1 %101 to i64
%103 = add i64 %96, %102
%104 = shl i64 %103, 32
%105 = ashr exact i64 %104, 32
br label %106
106: ; preds = %114, %94
%107 = phi i64 [ %115, %114 ], [ %105, %94 ]
%108 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %107
%109 = load i8, i8* %108
switch i8 %109, label %110 [
i8 32, label %114
i8 9, label %114
]
110: ; preds = %106
%111 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %107
%112 = shl i64 %107, 32
%113 = ashr exact i64 %112, 32
br label %116
114: ; preds = %106, %106
%115 = add i64 %107, 1
br label %106
116: ; preds = %110, %120
%117 = phi i64 [ %113, %110 ], [ %121, %120 ]
%118 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %117
%119 = load i8, i8* %118
switch i8 %119, label %120 [
i8 0, label %122
i8 35, label %122
i8 59, label %122
i8 32, label %122
i8 9, label %122
i8 10, label %122
i8 13, label %122
]
120: ; preds = %116
%121 = add i64 %117, 1
br label %116
122: ; preds = %116, %116, %116, %116, %116, %116, %116
%123 = getelementptr inbounds [1024 x i8], [1024 x i8]* %3, i64 0, i64 %117
store i8 0, i8* %123
%124 = load i8, i8* %111
%125 = icmp eq i8 %124, 0
br i1 %125, label %136, label %126
126: ; preds = %122
%127 = call i64 @strtol(i8* %111, i8** %6, i32 16)
%128 = trunc i64 %127 to i32
%129 = getelementptr inbounds [8 x i32], [8 x i32]* %4, i64 0, i64 %95
store i32 %128, i32* %129
%130 = load i8*, i8** %6
%131 = icmp ne i8* %130, %123
%132 = icmp eq i8* %130, %111
%133 = or i1 %131, %132
br i1 %133, label %196, label %134
134: ; preds = %126
%135 = add nuw i64 %95, 1
br label %94
136: ; preds = %122
%137 = trunc i64 %95 to i32
%138 = add nsw i32 %137, -4
%139 = icmp ult i32 %138, -3
br i1 %139, label %196, label %140
140: ; preds = %136
%141 = icmp eq i32 %137, 1
%142 = icmp eq i32 %25, 0
br i1 %141, label %143, label %166
143: ; preds = %140
br i1 %142, label %144, label %146
144: ; preds = %143
%145 = load i32, i32* %21
br label %200
146: ; preds = %143
%147 = add i32 %31, 1
%148 = icmp eq i32 %147, %52
br i1 %148, label %149, label %153
149: ; preds = %146
%150 = add i32 %29, 1
%151 = load i32, i32* %21
%152 = icmp eq i32 %150, %151
br i1 %152, label %200, label %153
153: ; preds = %146, %149
%154 = icmp eq i32 %27, 0
br i1 %154, label %157, label %155
155: ; preds = %153
%156 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.23, i64 0, i64 0))
br label %157
157: ; preds = %153, %155
%158 = phi i32 [ %27, %155 ], [ 1, %153 ]
%159 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.10, i64 0, i64 0), i32 %25, i32 %31)
%160 = sext i32 %26 to i64
%161 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %160, i64 0
store i32 %30, i32* %161
%162 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %160, i64 1
store i32 0, i32* %162
%163 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %160, i64 2
store i32 0, i32* %163
%164 = add nsw i32 %26, 1
%165 = load i32, i32* %21
br label %200
166: ; preds = %140
%167 = icmp eq i32 %27, 0
br i1 %142, label %179, label %168
168: ; preds = %166
br i1 %167, label %171, label %169
169: ; preds = %168
%170 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.23, i64 0, i64 0))
br label %171
171: ; preds = %169, %168
%172 = phi i32 [ %27, %169 ], [ 1, %168 ]
%173 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.10, i64 0, i64 0), i32 %25, i32 %31)
%174 = sext i32 %26 to i64
%175 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %174, i64 0
store i32 %30, i32* %175
%176 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %174, i64 1
store i32 0, i32* %176
%177 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %174, i64 2
store i32 0, i32* %177
%178 = add nsw i32 %26, 1
br label %180
179: ; preds = %166
br i1 %167, label %184, label %180
180: ; preds = %171, %179
%181 = phi i32 [ %178, %171 ], [ %26, %179 ]
%182 = phi i32 [ %172, %171 ], [ %27, %179 ]
%183 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.23, i64 0, i64 0))
br label %184
184: ; preds = %179, %180
%185 = phi i32 [ %181, %180 ], [ %26, %179 ]
%186 = phi i32 [ %182, %180 ], [ 1, %179 ]
%187 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.10, i64 0, i64 0), i32 %52, i32 %52)
%188 = load i32, i32* %21
%189 = sext i32 %185 to i64
%190 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %189, i64 0
store i32 %188, i32* %190
%191 = load i32, i32* %22
%192 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %189, i64 1
store i32 %191, i32* %192
%193 = load i32, i32* %23
%194 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %189, i64 2
store i32 %193, i32* %194
%195 = add nsw i32 %185, 1
br label %200
196: ; preds = %136, %48, %126, %82, %93
%197 = phi i8* [ getelementptr inbounds ([20 x i8], [20 x i8]* @.str.6, i64 0, i64 0), %93 ], [ getelementptr inbounds ([27 x i8], [27 x i8]* @.str.5, i64 0, i64 0), %82 ], [ getelementptr inbounds ([38 x i8], [38 x i8]* @.str.7, i64 0, i64 0), %126 ], [ getelementptr inbounds ([30 x i8], [30 x i8]* @.str.8, i64 0, i64 0), %136 ], [ getelementptr inbounds ([37 x i8], [37 x i8]* @.str.4, i64 0, i64 0), %48 ]
%198 = load i32, i32* @stderr
%199 = call i32 (i32, i8*, i8*, ...) @fprintf(i32 %198, i8* %197, i8* %0, i32 %32)
br label %257
200: ; preds = %33, %33, %33, %33, %184, %157, %144, %149, %88
%201 = phi i32 [ %31, %88 ], [ %52, %144 ], [ %52, %157 ], [ %31, %184 ], [ %52, %149 ], [ %31, %33 ], [ %31, %33 ], [ %31, %33 ], [ %31, %33 ]
%202 = phi i32 [ %30, %88 ], [ %145, %144 ], [ %165, %157 ], [ %30, %184 ], [ %30, %149 ], [ %30, %33 ], [ %30, %33 ], [ %30, %33 ], [ %30, %33 ]
%203 = phi i32 [ %29, %88 ], [ %145, %144 ], [ %165, %157 ], [ %29, %184 ], [ %150, %149 ], [ %29, %33 ], [ %29, %33 ], [ %29, %33 ], [ %29, %33 ]
%204 = phi i32 [ %27, %88 ], [ %27, %144 ], [ %158, %157 ], [ %186, %184 ], [ %27, %149 ], [ %27, %33 ], [ %27, %33 ], [ %27, %33 ], [ %27, %33 ]
%205 = phi i32 [ %26, %88 ], [ %26, %144 ], [ %164, %157 ], [ %195, %184 ], [ %26, %149 ], [ %26, %33 ], [ %26, %33 ], [ %26, %33 ], [ %26, %33 ]
%206 = phi i32 [ %25, %88 ], [ %52, %144 ], [ %52, %157 ], [ 0, %184 ], [ %25, %149 ], [ %25, %33 ], [ %25, %33 ], [ %25, %33 ], [ %25, %33 ]
%207 = call i64 @fgets(i8* %8, i32 1024, i32* %9)
%208 = icmp eq i64 %207, 0
br i1 %208, label %209, label %24
209: ; preds = %200
%210 = icmp eq i32 %206, 0
%211 = icmp eq i32 %204, 0
br i1 %210, label %222, label %212
212: ; preds = %209
br i1 %211, label %215, label %213
213: ; preds = %212
%214 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.23, i64 0, i64 0))
br label %215
215: ; preds = %213, %212
%216 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.10, i64 0, i64 0), i32 %206, i32 %201)
%217 = sext i32 %205 to i64
%218 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %217, i64 0
store i32 %202, i32* %218
%219 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %217, i64 1
store i32 0, i32* %219
%220 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %217, i64 2
store i32 0, i32* %220
%221 = add nsw i32 %205, 1
br label %223
222: ; preds = %209
br i1 %211, label %226, label %223
223: ; preds = %215, %222
%224 = phi i32 [ %221, %215 ], [ %205, %222 ]
%225 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.23, i64 0, i64 0))
br label %226
226: ; preds = %14, %222, %223
%227 = phi i32 [ %205, %222 ], [ %224, %223 ], [ 0, %14 ]
%228 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.11, i64 0, i64 0))
%229 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.17, i64 0, i64 0))
%230 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str.16, i64 0, i64 0))
%231 = icmp eq i32 %227, 0
br i1 %231, label %254, label %232
232: ; preds = %226
%233 = zext i32 %227 to i64
%234 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 0, i64 0
%235 = load i32, i32* %234
%236 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 0, i64 1
%237 = load i32, i32* %236
%238 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 0, i64 2
%239 = load i32, i32* %238
%240 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0), i32 %235, i32 %237, i32 %239)
%241 = icmp eq i32 %227, 1
br i1 %241, label %254, label %242
242: ; preds = %232, %242
%243 = phi i64 [ %252, %242 ], [ 1, %232 ]
%244 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.23, i64 0, i64 0))
%245 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %243, i64 0
%246 = load i32, i32* %245
%247 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %243, i64 1
%248 = load i32, i32* %247
%249 = getelementptr inbounds [1024 x [3 x i32]], [1024 x [3 x i32]]* %2, i64 0, i64 %243, i64 2
%250 = load i32, i32* %249
%251 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0), i32 %246, i32 %248, i32 %250)
%252 = add nuw nsw i64 %243, 1
%253 = icmp eq i64 %252, %233
br i1 %253, label %254, label %242
254: ; preds = %242, %232, %226
%255 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.17, i64 0, i64 0))
%256 = call i32 @fclose(i32* %9)
br label %257
257: ; preds = %196, %254, %11
%258 = phi i32 [ 0, %254 ], [ -1, %11 ], [ -1, %196 ]
ret i32 %258
}