#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 EOF;
int /*<<< orphan*/ abort();
int /*<<< orphan*/ exit(int);
scalar_t__ fclose(int /*<<< orphan*/ *);
scalar_t__ ferror(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int getc(int /*<<< orphan*/);
char *malloc(int);
int scanf(char *, int *);
int /*<<< orphan*/ sprintf(char *, char *, int, ...);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ stdin;
int /*<<< orphan*/ strcat(char *, char const *);
int /*<<< orphan*/ strcpy(char *, char const *);
int strlen(char const *);
int /*<<< orphan*/ ungetc(int, int /*<<< orphan*/);
int main(int argc, char *argv[]) {
  const char *charsetname;
  const char *c_charsetname;
  const char *filename;
  const char *directory;
  int charset2uni[0x100];
  if (argc != 3 && argc != 4 && argc != 5)
    exit(1);
  charsetname = argv[1];
  c_charsetname = argv[2];
  if (argc > 3) {
    filename = argv[3];
  } else {
    char *s = (char *)malloc(strlen(c_charsetname) + strlen(".h") + 1);
    strcpy(s, c_charsetname);
    strcat(s, ".h");
    filename = s;
  }
  directory = (argc > 4 ? argv[4] : "");
  fprintf(stderr, "Creating %s%s\n", directory, filename);
  {
    int i, c;
    c = getc(stdin);
    ungetc(c, stdin);
    if (c == '#') {
      for (i = 0; i < 0x100; i++)
        charset2uni[i] = 0xfffd;
      for (;;) {
        c = getc(stdin);
        if (c == EOF)
          break;
        if (c == '\n' || c == ' ' || c == '\t')
          continue;
        if (c == '#') {
          do {
            c = getc(stdin);
          } while (!(c == EOF || c == '\n'));
          continue;
        }
        ungetc(c, stdin);
        if (scanf("0x%x", &i) != 1 || !(i >= 0 && i < 0x100))
          exit(1);
        do {
          c = getc(stdin);
        } while (c == ' ' || c == '\t');
        if (c != EOF)
          ungetc(c, stdin);
        if (c == '\n' || c == '#')
          continue;
        if (scanf("0x%x", &charset2uni[i]) != 1)
          exit(1);
      }
    } else {
      for (i = 0; i < 0x100; i++) {
        if (scanf("%x", &charset2uni[i]) != 1)
          exit(1);
        if (charset2uni[i] < 0 || charset2uni[i] == 0xffff)
          charset2uni[i] = 0xfffd;
      }
      if (scanf("%x", &i) != EOF)
        exit(1);
    }
  }
  {
    FILE *f;
    {
      char *fname = malloc(strlen(directory) + strlen(filename) + 1);
      strcpy(fname, directory);
      strcat(fname, filename);
      f = fopen(fname, "w");
      if (f == NULL)
        exit(1);
    }
    fprintf(f, "\n");
    fprintf(f, "/*\n");
    fprintf(f, " * %s\n", charsetname);
    fprintf(f, " */\n");
    fprintf(f, "\n");
    {
      int i, i1, i2, i3;
      int line[16];
      int tableno;
      struct {
        int minline;
        int maxline;
      } tables[16];
      bool some_invalid;
      bool final_ret_reached;
      for (i1 = 0; i1 < 16; i1++) {
        bool all_invalid = true;
        bool all_identity = true;
        for (i2 = 0; i2 < 16; i2++) {
          i = 16 * i1 + i2;
          if (charset2uni[i] != 0xfffd)
            all_invalid = false;
          if (charset2uni[i] != i)
            all_identity = false;
        }
        if (all_invalid)
          line[i1] = -2;
        else if (all_identity)
          line[i1] = -1;
        else
          line[i1] = 0;
      }
      tableno = 0;
      for (i1 = 0; i1 < 16; i1++) {
        if (line[i1] >= 0) {
          if (i1 > 0 && tableno > 0 && line[i1 - 1] == tableno - 1) {
            line[i1] = tableno - 1;
            tables[tableno - 1].maxline = i1;
          } else {
            tableno++;
            line[i1] = tableno - 1;
            tables[tableno - 1].minline = tables[tableno - 1].maxline = i1;
          }
        }
      }
      some_invalid = false;
      for (i = 0; i < 0x100; i++)
        if (charset2uni[i] == 0xfffd)
          some_invalid = true;
      if (tableno > 0) {
        int t;
        for (t = 0; t < tableno; t++) {
          fprintf(f, "static const unsigned short %s_2uni", c_charsetname);
          if (tableno > 1)
            fprintf(f, "_%d", t + 1);
          fprintf(f, "[%d] = {\n",
                  16 * (tables[t].maxline - tables[t].minline + 1));
          for (i1 = tables[t].minline; i1 <= tables[t].maxline; i1++) {
            fprintf(f, "  /* 0x%02x */\n", 16 * i1);
            for (i2 = 0; i2 < 2; i2++) {
              fprintf(f, " ");
              for (i3 = 0; i3 < 8; i3++) {
                i = 16 * i1 + 8 * i2 + i3;
                fprintf(f, " 0x%04x,", charset2uni[i]);
              }
              fprintf(f, "\n");
            }
          }
          fprintf(f, "};\n");
        }
        fprintf(f, "\n");
      }
      final_ret_reached = false;
      fprintf(f,
              "static int\n%s_mbtowc (conv_t conv, ucs4_t *pwc, const unsigned "
              "char *s, int n)\n",
              c_charsetname);
      fprintf(f, "{\n");
      fprintf(f, "  unsigned char c = *s;\n");
      if (some_invalid) {
        for (i1 = 0; i1 < 16;) {
          int t = line[i1];
          const char *indent;
          for (i2 = i1; i2 < 16 && line[i2] == t; i2++)
            ;
          indent = (i1 == 0 && i2 == 16 ? "  " : "    ");
          if (i1 == 0) {
            if (i2 == 16) {
            } else {
              fprintf(f, "  if (c < 0x%02x) {\n", 16 * i2);
            }
          } else {
            if (i2 == 16) {
              fprintf(f, "  else {\n");
            } else {
              fprintf(f, "  else if (c < 0x%02x) {\n", 16 * i2);
            }
          }
          if (t == -2) {
            final_ret_reached = true;
          } else if (t == -1) {
            fprintf(f, "%s*pwc = (ucs4_t) c;\n", indent);
            fprintf(f, "%sreturn 1;\n", indent);
          } else {
            fprintf(f, "%s", indent);
            some_invalid = false;
            for (i = 16 * i1; i < 16 * i2; i++)
              if (charset2uni[i] == 0xfffd)
                some_invalid = true;
            if (some_invalid)
              fprintf(f, "unsigned short wc = ");
            else
              fprintf(f, "*pwc = (ucs4_t) ");
            fprintf(f, "%s_2uni", c_charsetname);
            if (tableno > 1)
              fprintf(f, "_%d", t + 1);
            fprintf(f, "[c");
            if (tables[t].minline > 0)
              fprintf(f, "-0x%02x", 16 * tables[t].minline);
            fprintf(f, "];\n");
            if (some_invalid) {
              fprintf(f, "%sif (wc != 0xfffd) {\n", indent);
              fprintf(f, "%s  *pwc = (ucs4_t) wc;\n", indent);
              fprintf(f, "%s  return 1;\n", indent);
              fprintf(f, "%s}\n", indent);
              final_ret_reached = true;
            } else {
              fprintf(f, "%sreturn 1;\n", indent);
            }
          }
          if (!(i1 == 0 && i2 == 16))
            fprintf(f, "  }\n");
          i1 = i2;
        }
        if (final_ret_reached)
          fprintf(f, "  return RET_ILSEQ;\n");
      } else {
        for (i1 = 0; i1 < 16;) {
          int t = line[i1];
          for (i2 = i1; i2 < 16 && line[i2] == t; i2++)
            ;
          if (i1 == 0) {
            if (i2 == 16) {
              fprintf(f, "  ");
            } else {
              fprintf(f, "  if (c < 0x%02x)\n    ", 16 * i2);
            }
          } else {
            if (i2 == 16) {
              fprintf(f, "  else\n    ");
            } else {
              fprintf(f, "  else if (c < 0x%02x)\n    ", 16 * i2);
            }
          }
          if (t == -1)
            fprintf(f, "*pwc = (ucs4_t) c;\n");
          else {
            fprintf(f, "*pwc = (ucs4_t) %s_2uni", c_charsetname);
            if (tableno > 1)
              fprintf(f, "_%d", t + 1);
            fprintf(f, "[c");
            if (tables[t].minline > 0)
              fprintf(f, "-0x%02x", 16 * tables[t].minline);
            fprintf(f, "];\n");
          }
          i1 = i2;
        }
        fprintf(f, "  return 1;\n");
      }
      fprintf(f, "}\n");
    }
    fprintf(f, "\n");
    {
      int uni2charset[0x10000];
      bool pages[0x100];
      int line[0x2000];
      int tableno;
      struct {
        int minline;
        int maxline;
        int usecount;
        const char *suffix;
      } tables[0x2000];
      bool need_c;
      bool fix_0000;
      int i, j, p, j1, j2, t;
      for (j = 0; j < 0x10000; j++)
        uni2charset[j] = 0;
      for (p = 0; p < 0x100; p++)
        pages[p] = false;
      for (i = 0; i < 0x100; i++) {
        j = charset2uni[i];
        if (j != 0xfffd) {
          uni2charset[j] = i;
          pages[j >> 8] = true;
        }
      }
      for (j1 = 0; j1 < 0x2000; j1++) {
        bool all_invalid = true;
        bool all_identity = true;
        for (j2 = 0; j2 < 8; j2++) {
          j = 8 * j1 + j2;
          if (uni2charset[j] != 0)
            all_invalid = false;
          if (uni2charset[j] != j)
            all_identity = false;
        }
        if (all_invalid)
          line[j1] = -2;
        else if (all_identity)
          line[j1] = -1;
        else
          line[j1] = 0;
      }
      tableno = 0;
      for (j1 = 0; j1 < 0x2000; j1++) {
        if (line[j1] >= 0) {
          if (tableno > 0 &&
              ((j1 > 0 && line[j1 - 1] == tableno - 1) ||
               ((tables[tableno - 1].maxline >> 5) == (j1 >> 5) &&
                j1 - tables[tableno - 1].maxline <= 8))) {
            line[j1] = tableno - 1;
            tables[tableno - 1].maxline = j1;
          } else {
            tableno++;
            line[j1] = tableno - 1;
            tables[tableno - 1].minline = tables[tableno - 1].maxline = j1;
          }
        }
      }
      for (t = 0; t < tableno; t++) {
        tables[t].usecount = 0;
        j1 = 8 * tables[t].minline;
        j2 = 8 * (tables[t].maxline + 1);
        for (j = j1; j < j2; j++)
          if (uni2charset[j] != 0)
            tables[t].usecount++;
      }
      for (t = 0, p = -1, i = 0; t < tableno; t++) {
        if (tables[t].usecount > 1) {
          char *s;
          if (p == tables[t].minline >> 5) {
            s = (char *)malloc(5 + 1);
            sprintf(s, "%02x_%d", p, ++i);
          } else {
            p = tables[t].minline >> 5;
            s = (char *)malloc(2 + 1);
            sprintf(s, "%02x", p);
          }
          tables[t].suffix = s;
        } else
          tables[t].suffix = NULL;
      }
      {
        p = -1;
        for (t = 0; t < tableno; t++)
          if (tables[t].usecount > 1) {
            p = 0;
            fprintf(f, "static const unsigned char %s_page%s[%d] = {\n",
                    c_charsetname, tables[t].suffix,
                    8 * (tables[t].maxline - tables[t].minline + 1));
            for (j1 = tables[t].minline; j1 <= tables[t].maxline; j1++) {
              if ((j1 % 0x20) == 0 && j1 > tables[t].minline)
                fprintf(f, "  /* 0x%04x */\n", 8 * j1);
              fprintf(f, " ");
              for (j2 = 0; j2 < 8; j2++) {
                j = 8 * j1 + j2;
                fprintf(f, " 0x%02x,", uni2charset[j]);
              }
              fprintf(f, " /* 0x%02x-0x%02x */\n", 8 * (j1 % 0x20),
                      8 * (j1 % 0x20) + 7);
            }
            fprintf(f, "};\n");
          }
        if (p >= 0)
          fprintf(f, "\n");
      }
      need_c = false;
      for (j1 = 0; j1 < 0x2000;) {
        t = line[j1];
        for (j2 = j1; j2 < 0x2000 && line[j2] == t; j2++)
          ;
        if (t >= 0)
          j2 = tables[t].maxline + 1;
        if (!(t == -2 || (t == -1 && j1 == 0)))
          need_c = true;
        j1 = j2;
      }
      fix_0000 = false;
      fprintf(f,
              "static int\n%s_wctomb (conv_t conv, unsigned char *r, ucs4_t "
              "wc, int n)\n",
              c_charsetname);
      fprintf(f, "{\n");
      if (need_c)
        fprintf(f, "  unsigned char c = 0;\n");
      for (j1 = 0; j1 < 0x2000;) {
        t = line[j1];
        for (j2 = j1; j2 < 0x2000 && line[j2] == t; j2++)
          ;
        if (t >= 0) {
          if (j1 != tables[t].minline)
            abort();
          if (j2 > tables[t].maxline + 1)
            abort();
          j2 = tables[t].maxline + 1;
        }
        if (t == -2) {
        } else {
          if (j1 == 0)
            fprintf(f, "  ");
          else
            fprintf(f, "  else ");
          if (t >= 0 && tables[t].usecount == 0)
            abort();
          if (t >= 0 && tables[t].usecount == 1) {
            if (j2 != j1 + 1)
              abort();
            for (j = 8 * j1; j < 8 * j2; j++)
              if (uni2charset[j] != 0) {
                fprintf(f, "if (wc == 0x%04x)\n    c = 0x%02x;\n", j,
                        uni2charset[j]);
                break;
              }
          } else {
            if (j1 == 0) {
              fprintf(f, "if (wc < 0x%04x)", 8 * j2);
            } else {
              fprintf(f, "if (wc >= 0x%04x && wc < 0x%04x)", 8 * j1, 8 * j2);
            }
            if (t == -1) {
              if (j1 == 0)
                fprintf(f, " {\n    *r = wc;\n    return 1;\n  }\n");
              else
                fprintf(f, "\n    c = wc;\n");
            } else {
              fprintf(f, "\n    c = %s_page%s[wc", c_charsetname,
                      tables[t].suffix);
              if (tables[t].minline > 0)
                fprintf(f, "-0x%04x", 8 * j1);
              fprintf(f, "];\n");
              if (j1 == 0 && uni2charset[0] == 0)
                fix_0000 = true;
            }
          }
        }
        j1 = j2;
      }
      if (need_c) {
        if (fix_0000)
          fprintf(f, "  if (c != 0 || wc == 0) {\n");
        else
          fprintf(f, "  if (c != 0) {\n");
        fprintf(f, "    *r = c;\n");
        fprintf(f, "    return 1;\n");
        fprintf(f, "  }\n");
      }
      fprintf(f, "  return RET_ILSEQ;\n");
      fprintf(f, "}\n");
    }
    if (ferror(f) || fclose(f))
      exit(1);
  }
  exit(0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x789d0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x3,-0x8(%rbp)
je     1221 <main+0x41>
cmpl   $0x4,-0x8(%rbp)
je     1221 <main+0x41>
cmpl   $0x5,-0x8(%rbp)
je     1221 <main+0x41>
mov    $0x1,%edi
call   10f0 <exit@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x20(%rbp)
cmpl   $0x3,-0x8(%rbp)
jle    1254 <main+0x74>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x28(%rbp)
jmp    12b4 <main+0xd4>
mov    -0x20(%rbp),%rdi
call   1070 <strlen@plt>
mov    %eax,-0x789a4(%rbp)
lea    0x2d96(%rip),%rdi
call   1070 <strlen@plt>
mov    -0x789a4(%rbp),%edi
add    %eax,%edi
add    $0x1,%edi
call   1090 <malloc@plt>
mov    %rax,-0x438(%rbp)
mov    -0x438(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1040 <strcpy@plt>
mov    -0x438(%rbp),%rdi
lea    0x2d5c(%rip),%rsi
call   10d0 <strcat@plt>
mov    -0x438(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpl   $0x4,-0x8(%rbp)
jle    12d2 <main+0xf2>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    %rax,-0x789b0(%rbp)
jmp    12e5 <main+0x105>
lea    0x2fe5(%rip),%rax
mov    %rax,-0x789b0(%rbp)
jmp    12e5 <main+0x105>
mov    -0x789b0(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    0x4cd9(%rip),%rax
movslq (%rax),%rdi
mov    -0x30(%rbp),%rdx
mov    -0x28(%rbp),%rcx
lea    0x2cfa(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    0x4cd1(%rip),%rax
mov    (%rax),%edi
call   1100 <getc@plt>
mov    %eax,-0x440(%rbp)
mov    -0x440(%rbp),%edi
mov    0x4cb7(%rip),%rax
mov    (%rax),%esi
call   10a0 <ungetc@plt>
cmpl   $0x23,-0x440(%rbp)
jne    1575 <main+0x395>
movl   $0x0,-0x43c(%rbp)
cmpl   $0x100,-0x43c(%rbp)
jge    1385 <main+0x1a5>
movslq -0x43c(%rbp),%rax
movl   $0xfffd,-0x430(%rbp,%rax,4)
mov    -0x43c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x43c(%rbp)
jmp    134f <main+0x16f>
jmp    138a <main+0x1aa>
mov    0x4c57(%rip),%rax
mov    (%rax),%edi
call   1100 <getc@plt>
mov    %eax,-0x440(%rbp)
mov    -0x440(%rbp),%eax
mov    0x4c35(%rip),%rcx
cmp    (%rcx),%eax
jne    13b8 <main+0x1d8>
jmp    1570 <main+0x390>
cmpl   $0xa,-0x440(%rbp)
je     13df <main+0x1ff>
cmpl   $0x20,-0x440(%rbp)
je     13df <main+0x1ff>
cmpl   $0x9,-0x440(%rbp)
jne    13e4 <main+0x204>
jmp    138a <main+0x1aa>
cmpl   $0x23,-0x440(%rbp)
jne    144c <main+0x26c>
jmp    13f6 <main+0x216>
mov    0x4beb(%rip),%rax
mov    (%rax),%edi
call   1100 <getc@plt>
mov    %eax,-0x440(%rbp)
mov    -0x440(%rbp),%ecx
mov    $0x1,%al
mov    0x4bc7(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0x789b1(%rbp)
je     1437 <main+0x257>
cmpl   $0xa,-0x440(%rbp)
sete   %al
mov    %al,-0x789b1(%rbp)
mov    -0x789b1(%rbp),%al
xor    $0xff,%al
test   $0x1,%al
jne    13f6 <main+0x216>
jmp    138a <main+0x1aa>
mov    -0x440(%rbp),%edi
mov    0x4b8f(%rip),%rax
mov    (%rax),%esi
call   10a0 <ungetc@plt>
lea    0x2bab(%rip),%rdi
lea    -0x43c(%rbp),%rsi
call   10b0 <scanf@plt>
cmp    $0x1,%eax
jne    1499 <main+0x2b9>
cmpl   $0x0,-0x43c(%rbp)
jl     1499 <main+0x2b9>
cmpl   $0x100,-0x43c(%rbp)
jl     14a3 <main+0x2c3>
mov    $0x1,%edi
call   10f0 <exit@plt>
jmp    14a8 <main+0x2c8>
mov    0x4b39(%rip),%rax
mov    (%rax),%edi
call   1100 <getc@plt>
mov    %eax,-0x440(%rbp)
mov    $0x1,%al
cmpl   $0x20,-0x440(%rbp)
mov    %al,-0x789b2(%rbp)
je     14e1 <main+0x301>
cmpl   $0x9,-0x440(%rbp)
sete   %al
mov    %al,-0x789b2(%rbp)
mov    -0x789b2(%rbp),%al
test   $0x1,%al
jne    14a8 <main+0x2c8>
mov    -0x440(%rbp),%eax
mov    0x4ae4(%rip),%rcx
cmp    (%rcx),%eax
je     1518 <main+0x338>
mov    -0x440(%rbp),%edi
mov    0x4ad7(%rip),%rax
mov    (%rax),%esi
call   10a0 <ungetc@plt>
cmpl   $0xa,-0x440(%rbp)
je     1532 <main+0x352>
cmpl   $0x23,-0x440(%rbp)
jne    1537 <main+0x357>
jmp    138a <main+0x1aa>
movslq -0x43c(%rbp),%rax
lea    -0x430(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0x2abf(%rip),%rdi
call   10b0 <scanf@plt>
cmp    $0x1,%eax
je     156b <main+0x38b>
mov    $0x1,%edi
call   10f0 <exit@plt>
jmp    138a <main+0x1aa>
jmp    164c <main+0x46c>
movl   $0x0,-0x43c(%rbp)
cmpl   $0x100,-0x43c(%rbp)
jge    161b <main+0x43b>
movslq -0x43c(%rbp),%rax
lea    -0x430(%rbp),%rsi
shl    $0x2,%rax
add    %rax,%rsi
lea    0x2a69(%rip),%rdi
call   10b0 <scanf@plt>
cmp    $0x1,%eax
je     15c3 <main+0x3e3>
mov    $0x1,%edi
call   10f0 <exit@plt>
movslq -0x43c(%rbp),%rax
cmpl   $0x0,-0x430(%rbp,%rax,4)
jl     15f0 <main+0x410>
movslq -0x43c(%rbp),%rax
cmpl   $0xffff,-0x430(%rbp,%rax,4)
jne    1602 <main+0x422>
movslq -0x43c(%rbp),%rax
movl   $0xfffd,-0x430(%rbp,%rax,4)
jmp    1607 <main+0x427>
mov    -0x43c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x43c(%rbp)
jmp    157f <main+0x39f>
lea    0x29f2(%rip),%rdi
lea    -0x43c(%rbp),%rsi
call   10b0 <scanf@plt>
mov    0x49ab(%rip),%rcx
cmp    (%rcx),%eax
je     1647 <main+0x467>
mov    $0x1,%edi
call   10f0 <exit@plt>
jmp    164c <main+0x46c>
mov    -0x30(%rbp),%rdi
call   1070 <strlen@plt>
mov    %eax,-0x789b8(%rbp)
mov    -0x28(%rbp),%rdi
call   1070 <strlen@plt>
mov    -0x789b8(%rbp),%edi
add    %eax,%edi
add    $0x1,%edi
call   1090 <malloc@plt>
mov    %rax,-0x450(%rbp)
mov    -0x450(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   1040 <strcpy@plt>
mov    -0x450(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   10d0 <strcat@plt>
mov    -0x450(%rbp),%rdi
lea    0x296e(%rip),%rsi
call   10c0 <fopen@plt>
mov    %rax,-0x448(%rbp)
cmpq   $0x0,-0x448(%rbp)
jne    16cd <main+0x4ed>
mov    $0x1,%edi
call   10f0 <exit@plt>
mov    -0x448(%rbp),%rdi
lea    0x2be2(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2929(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x18(%rbp),%rdx
lea    0x2914(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2935(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2b8a(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x458(%rbp)
cmpl   $0x10,-0x458(%rbp)
jge    1868 <main+0x688>
movl   $0x1,-0x53c(%rbp)
movl   $0x1,-0x540(%rbp)
movl   $0x0,-0x45c(%rbp)
cmpl   $0x10,-0x45c(%rbp)
jge    17f0 <main+0x610>
mov    -0x458(%rbp),%eax
shl    $0x4,%eax
add    -0x45c(%rbp),%eax
mov    %eax,-0x454(%rbp)
movslq -0x454(%rbp),%rax
cmpl   $0xfffd,-0x430(%rbp,%rax,4)
je     17b3 <main+0x5d3>
movl   $0x0,-0x53c(%rbp)
movslq -0x454(%rbp),%rax
mov    -0x430(%rbp,%rax,4),%eax
cmp    -0x454(%rbp),%eax
je     17d7 <main+0x5f7>
movl   $0x0,-0x540(%rbp)
jmp    17dc <main+0x5fc>
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    176f <main+0x58f>
cmpl   $0x0,-0x53c(%rbp)
je     1814 <main+0x634>
movslq -0x458(%rbp),%rax
movl   $0xfffffffe,-0x4a0(%rbp,%rax,4)
fe ff ff ff
jmp    184f <main+0x66f>
cmpl   $0x0,-0x540(%rbp)
je     1838 <main+0x658>
movslq -0x458(%rbp),%rax
movl   $0xffffffff,-0x4a0(%rbp,%rax,4)
ff ff ff ff
jmp    184a <main+0x66a>
movslq -0x458(%rbp),%rax
movl   $0x0,-0x4a0(%rbp,%rax,4)
jmp    184f <main+0x66f>
jmp    1854 <main+0x674>
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    1744 <main+0x564>
movl   $0x0,-0x4a4(%rbp)
movl   $0x0,-0x458(%rbp)
cmpl   $0x10,-0x458(%rbp)
jge    197d <main+0x79d>
movslq -0x458(%rbp),%rax
cmpl   $0x0,-0x4a0(%rbp,%rax,4)
jl     1964 <main+0x784>
cmpl   $0x0,-0x458(%rbp)
jle    190f <main+0x72f>
cmpl   $0x0,-0x4a4(%rbp)
jle    190f <main+0x72f>
mov    -0x458(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x4a0(%rbp,%rax,4),%eax
mov    -0x4a4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    190f <main+0x72f>
mov    -0x4a4(%rbp),%ecx
sub    $0x1,%ecx
movslq -0x458(%rbp),%rax
mov    %ecx,-0x4a0(%rbp,%rax,4)
mov    -0x458(%rbp),%ecx
mov    -0x4a4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x52c(%rbp,%rax,8)
jmp    195f <main+0x77f>
mov    -0x4a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4a4(%rbp)
mov    -0x4a4(%rbp),%ecx
sub    $0x1,%ecx
movslq -0x458(%rbp),%rax
mov    %ecx,-0x4a0(%rbp,%rax,4)
mov    -0x458(%rbp),%ecx
mov    -0x4a4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x52c(%rbp,%rax,8)
mov    -0x4a4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x530(%rbp,%rax,8)
jmp    1964 <main+0x784>
jmp    1969 <main+0x789>
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    187c <main+0x69c>
movl   $0x0,-0x534(%rbp)
movl   $0x0,-0x454(%rbp)
cmpl   $0x100,-0x454(%rbp)
jge    19dc <main+0x7fc>
movslq -0x454(%rbp),%rax
cmpl   $0xfffd,-0x430(%rbp,%rax,4)
jne    19c3 <main+0x7e3>
movl   $0x1,-0x534(%rbp)
jmp    19c8 <main+0x7e8>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    1991 <main+0x7b1>
cmpl   $0x0,-0x4a4(%rbp)
jle    1be6 <main+0xa06>
movl   $0x0,-0x544(%rbp)
mov    -0x544(%rbp),%eax
cmp    -0x4a4(%rbp),%eax
jge    1bd1 <main+0x9f1>
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x260d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x1,-0x4a4(%rbp)
jle    1a49 <main+0x869>
mov    -0x448(%rbp),%rdi
mov    -0x544(%rbp),%edx
add    $0x1,%edx
lea    0x27d4(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
movslq -0x544(%rbp),%rax
mov    -0x52c(%rbp,%rax,8),%edx
movslq -0x544(%rbp),%rax
sub    -0x530(%rbp,%rax,8),%edx
add    $0x1,%edx
shl    $0x4,%edx
lea    0x27c5(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movslq -0x544(%rbp),%rax
mov    -0x530(%rbp,%rax,8),%eax
mov    %eax,-0x458(%rbp)
mov    -0x458(%rbp),%eax
movslq -0x544(%rbp),%rcx
cmp    -0x52c(%rbp,%rcx,8),%eax
jg     1ba8 <main+0x9c8>
mov    -0x448(%rbp),%rdi
mov    -0x458(%rbp),%edx
shl    $0x4,%edx
lea    0x2583(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x45c(%rbp)
cmpl   $0x2,-0x45c(%rbp)
jge    1b8f <main+0x9af>
mov    -0x448(%rbp),%rdi
lea    0x26df(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x460(%rbp)
cmpl   $0x8,-0x460(%rbp)
jge    1b66 <main+0x986>
mov    -0x458(%rbp),%eax
shl    $0x4,%eax
mov    -0x45c(%rbp),%ecx
shl    $0x3,%ecx
add    %ecx,%eax
add    -0x460(%rbp),%eax
mov    %eax,-0x454(%rbp)
mov    -0x448(%rbp),%rdi
movslq -0x454(%rbp),%rax
mov    -0x430(%rbp,%rax,4),%edx
lea    0x250d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x460(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x460(%rbp)
jmp    1b02 <main+0x922>
mov    -0x448(%rbp),%rdi
lea    0x2749(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    1ad6 <main+0x8f6>
jmp    1b94 <main+0x9b4>
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    1a94 <main+0x8b4>
mov    -0x448(%rbp),%rdi
lea    0x24ab(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x544(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x544(%rbp)
jmp    19f3 <main+0x813>
mov    -0x448(%rbp),%rdi
lea    0x26de(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x538(%rbp)
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x2463(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2796(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2489(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x534(%rbp)
je     2093 <main+0xeb3>
movl   $0x0,-0x458(%rbp)
cmpl   $0x10,-0x458(%rbp)
jge    206c <main+0xe8c>
movslq -0x458(%rbp),%rax
mov    -0x4a0(%rbp,%rax,4),%eax
mov    %eax,-0x548(%rbp)
mov    -0x458(%rbp),%eax
mov    %eax,-0x45c(%rbp)
xor    %eax,%eax
cmpl   $0x10,-0x45c(%rbp)
mov    %al,-0x789b9(%rbp)
jge    1ca9 <main+0xac9>
movslq -0x45c(%rbp),%rax
mov    -0x4a0(%rbp,%rax,4),%eax
cmp    -0x548(%rbp),%eax
sete   %al
mov    %al,-0x789b9(%rbp)
mov    -0x789b9(%rbp),%al
test   $0x1,%al
jne    1cbc <main+0xadc>
jmp    1cd5 <main+0xaf5>
jmp    1cc1 <main+0xae1>
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    1c77 <main+0xa97>
xor    %eax,%eax
cmpl   $0x0,-0x458(%rbp)
mov    %al,-0x789ba(%rbp)
jne    1cfa <main+0xb1a>
cmpl   $0x10,-0x45c(%rbp)
sete   %al
mov    %al,-0x789ba(%rbp)
mov    -0x789ba(%rbp),%dl
lea    0x24c6(%rip),%rax
lea    0x24c1(%rip),%rcx
test   $0x1,%dl
cmovne %rcx,%rax
mov    %rax,-0x550(%rbp)
cmpl   $0x0,-0x458(%rbp)
jne    1d5e <main+0xb7e>
cmpl   $0x10,-0x45c(%rbp)
jne    1d3b <main+0xb5b>
jmp    1d59 <main+0xb79>
mov    -0x448(%rbp),%rdi
mov    -0x45c(%rbp),%edx
shl    $0x4,%edx
lea    0x237c(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1da8 <main+0xbc8>
cmpl   $0x10,-0x45c(%rbp)
jne    1d85 <main+0xba5>
mov    -0x448(%rbp),%rdi
lea    0x236a(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1da3 <main+0xbc3>
mov    -0x448(%rbp),%rdi
mov    -0x45c(%rbp),%edx
shl    $0x4,%edx
lea    0x2351(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1da8 <main+0xbc8>
cmpl   $0xfffffffe,-0x548(%rbp)
jne    1dc4 <main+0xbe4>
movl   $0x1,-0x538(%rbp)
jmp    202c <main+0xe4c>
cmpl   $0xffffffff,-0x548(%rbp)
jne    1e0e <main+0xc2e>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x2321(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x231b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2027 <main+0xe47>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x2307(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x534(%rbp)
mov    -0x458(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x454(%rbp)
mov    -0x454(%rbp),%eax
mov    -0x45c(%rbp),%ecx
shl    $0x4,%ecx
cmp    %ecx,%eax
jge    1e95 <main+0xcb5>
movslq -0x454(%rbp),%rax
cmpl   $0xfffd,-0x430(%rbp,%rax,4)
jne    1e7c <main+0xc9c>
movl   $0x1,-0x534(%rbp)
jmp    1e81 <main+0xca1>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    1e43 <main+0xc63>
cmpl   $0x0,-0x534(%rbp)
je     1ebc <main+0xcdc>
mov    -0x448(%rbp),%rdi
lea    0x227d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1ed1 <main+0xcf1>
mov    -0x448(%rbp),%rdi
lea    0x2278(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x2327(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x1,-0x4a4(%rbp)
jle    1f15 <main+0xd35>
mov    -0x448(%rbp),%rdi
mov    -0x548(%rbp),%edx
add    $0x1,%edx
lea    0x2308(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2230(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movslq -0x548(%rbp),%rax
cmpl   $0x0,-0x530(%rbp,%rax,8)
jle    1f65 <main+0xd85>
mov    -0x448(%rbp),%rdi
movslq -0x548(%rbp),%rax
mov    -0x530(%rbp,%rax,8),%edx
shl    $0x4,%edx
lea    0x21f8(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x21eb(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x534(%rbp)
je     2006 <main+0xe26>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x21c6(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x21c1(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x21be(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x21b1(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x538(%rbp)
jmp    2022 <main+0xe42>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x2102(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2027 <main+0xe47>
jmp    202c <main+0xe4c>
cmpl   $0x0,-0x458(%rbp)
jne    2046 <main+0xe66>
cmpl   $0x10,-0x45c(%rbp)
je     205b <main+0xe7b>
mov    -0x448(%rbp),%rdi
lea    0x22fe(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x45c(%rbp),%eax
mov    %eax,-0x458(%rbp)
jmp    1c4a <main+0xa6a>
cmpl   $0x0,-0x538(%rbp)
je     208e <main+0xeae>
mov    -0x448(%rbp),%rdi
lea    0x211f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    22bf <main+0x10df>
movl   $0x0,-0x458(%rbp)
cmpl   $0x10,-0x458(%rbp)
jge    22aa <main+0x10ca>
movslq -0x458(%rbp),%rax
mov    -0x4a0(%rbp,%rax,4),%eax
mov    %eax,-0x554(%rbp)
mov    -0x458(%rbp),%eax
mov    %eax,-0x45c(%rbp)
xor    %eax,%eax
cmpl   $0x10,-0x45c(%rbp)
mov    %al,-0x789bb(%rbp)
jge    20fc <main+0xf1c>
movslq -0x45c(%rbp),%rax
mov    -0x4a0(%rbp,%rax,4),%eax
cmp    -0x554(%rbp),%eax
sete   %al
mov    %al,-0x789bb(%rbp)
mov    -0x789bb(%rbp),%al
test   $0x1,%al
jne    210f <main+0xf2f>
jmp    2128 <main+0xf48>
jmp    2114 <main+0xf34>
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    20ca <main+0xeea>
cmpl   $0x0,-0x458(%rbp)
jne    217f <main+0xf9f>
cmpl   $0x10,-0x45c(%rbp)
jne    215c <main+0xf7c>
mov    -0x448(%rbp),%rdi
lea    0x207f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    217a <main+0xf9a>
mov    -0x448(%rbp),%rdi
mov    -0x45c(%rbp),%edx
shl    $0x4,%edx
lea    0x2048(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    21c9 <main+0xfe9>
cmpl   $0x10,-0x45c(%rbp)
jne    21a6 <main+0xfc6>
mov    -0x448(%rbp),%rdi
lea    0x2038(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    21c4 <main+0xfe4>
mov    -0x448(%rbp),%rdi
mov    -0x45c(%rbp),%edx
shl    $0x4,%edx
lea    0x2021(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    21c9 <main+0xfe9>
cmpl   $0xffffffff,-0x554(%rbp)
jne    21f0 <main+0x1010>
mov    -0x448(%rbp),%rdi
lea    0x1f25(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2299 <main+0x10b9>
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x1ff8(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x1,-0x4a4(%rbp)
jle    2234 <main+0x1054>
mov    -0x448(%rbp),%rdi
mov    -0x554(%rbp),%edx
add    $0x1,%edx
lea    0x1fe9(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x1f11(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movslq -0x554(%rbp),%rax
cmpl   $0x0,-0x530(%rbp,%rax,8)
jle    2284 <main+0x10a4>
mov    -0x448(%rbp),%rdi
movslq -0x554(%rbp),%rax
mov    -0x530(%rbp,%rax,8),%edx
shl    $0x4,%edx
lea    0x1ed9(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x1ecc(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x45c(%rbp),%eax
mov    %eax,-0x458(%rbp)
jmp    209d <main+0xebd>
mov    -0x448(%rbp),%rdi
lea    0x2107(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2087(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x1fdb(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x78980(%rbp)
cmpl   $0x10000,-0x78980(%rbp)
jge    2329 <main+0x1149>
movslq -0x78980(%rbp),%rax
movl   $0x0,-0x40560(%rbp,%rax,4)
mov    -0x78980(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78980(%rbp)
jmp    22f3 <main+0x1113>
movl   $0x0,-0x78984(%rbp)
cmpl   $0x100,-0x78984(%rbp)
jge    2369 <main+0x1189>
movslq -0x78984(%rbp),%rax
movl   $0x0,-0x40960(%rbp,%rax,4)
mov    -0x78984(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78984(%rbp)
jmp    2333 <main+0x1153>
movl   $0x0,-0x7897c(%rbp)
cmpl   $0x100,-0x7897c(%rbp)
jge    23ea <main+0x120a>
movslq -0x7897c(%rbp),%rax
mov    -0x430(%rbp,%rax,4),%eax
mov    %eax,-0x78980(%rbp)
cmpl   $0xfffd,-0x78980(%rbp)
je     23d1 <main+0x11f1>
mov    -0x7897c(%rbp),%ecx
movslq -0x78980(%rbp),%rax
mov    %ecx,-0x40560(%rbp,%rax,4)
mov    -0x78980(%rbp),%eax
sar    $0x8,%eax
cltq
movl   $0x1,-0x40960(%rbp,%rax,4)
jmp    23d6 <main+0x11f6>
mov    -0x7897c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7897c(%rbp)
jmp    2373 <main+0x1193>
movl   $0x0,-0x78988(%rbp)
cmpl   $0x2000,-0x78988(%rbp)
jge    2518 <main+0x1338>
movl   $0x1,-0x78994(%rbp)
movl   $0x1,-0x78998(%rbp)
movl   $0x0,-0x7898c(%rbp)
cmpl   $0x8,-0x7898c(%rbp)
jge    24a0 <main+0x12c0>
mov    -0x78988(%rbp),%eax
shl    $0x3,%eax
add    -0x7898c(%rbp),%eax
mov    %eax,-0x78980(%rbp)
movslq -0x78980(%rbp),%rax
cmpl   $0x0,-0x40560(%rbp,%rax,4)
je     2463 <main+0x1283>
movl   $0x0,-0x78994(%rbp)
movslq -0x78980(%rbp),%rax
mov    -0x40560(%rbp,%rax,4),%eax
cmp    -0x78980(%rbp),%eax
je     2487 <main+0x12a7>
movl   $0x0,-0x78998(%rbp)
jmp    248c <main+0x12ac>
mov    -0x7898c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7898c(%rbp)
jmp    2422 <main+0x1242>
cmpl   $0x0,-0x78994(%rbp)
je     24c4 <main+0x12e4>
movslq -0x78988(%rbp),%rax
movl   $0xfffffffe,-0x48960(%rbp,%rax,4)
fe ff ff ff
jmp    24ff <main+0x131f>
cmpl   $0x0,-0x78998(%rbp)
je     24e8 <main+0x1308>
movslq -0x78988(%rbp),%rax
movl   $0xffffffff,-0x48960(%rbp,%rax,4)
ff ff ff ff
jmp    24fa <main+0x131a>
movslq -0x78988(%rbp),%rax
movl   $0x0,-0x48960(%rbp,%rax,4)
jmp    24ff <main+0x131f>
jmp    2504 <main+0x1324>
mov    -0x78988(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78988(%rbp)
jmp    23f4 <main+0x1214>
movl   $0x0,-0x48964(%rbp)
movl   $0x0,-0x78988(%rbp)
cmpl   $0x2000,-0x78988(%rbp)
jge    26ad <main+0x14cd>
movslq -0x78988(%rbp),%rax
cmpl   $0x0,-0x48960(%rbp,%rax,4)
jl     2694 <main+0x14b4>
cmpl   $0x0,-0x48964(%rbp)
jle    262a <main+0x144a>
cmpl   $0x0,-0x78988(%rbp)
jle    258e <main+0x13ae>
mov    -0x78988(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x48960(%rbp,%rax,4),%eax
mov    -0x48964(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     25eb <main+0x140b>
mov    -0x48964(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
sar    $0x5,%eax
mov    -0x78988(%rbp),%ecx
sar    $0x5,%ecx
cmp    %ecx,%eax
jne    262a <main+0x144a>
mov    -0x78988(%rbp),%eax
mov    -0x48964(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x78970(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
sub    0x4(%rcx),%eax
cmp    $0x8,%eax
jg     262a <main+0x144a>
mov    -0x48964(%rbp),%ecx
sub    $0x1,%ecx
movslq -0x78988(%rbp),%rax
mov    %ecx,-0x48960(%rbp,%rax,4)
mov    -0x78988(%rbp),%ecx
mov    -0x48964(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
jmp    268f <main+0x14af>
mov    -0x48964(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48964(%rbp)
mov    -0x48964(%rbp),%ecx
sub    $0x1,%ecx
movslq -0x78988(%rbp),%rax
mov    %ecx,-0x48960(%rbp,%rax,4)
mov    -0x78988(%rbp),%ecx
mov    -0x48964(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
mov    -0x48964(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
jmp    2694 <main+0x14b4>
jmp    2699 <main+0x14b9>
mov    -0x78988(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78988(%rbp)
jmp    252c <main+0x134c>
movl   $0x0,-0x78990(%rbp)
mov    -0x78990(%rbp),%eax
cmp    -0x48964(%rbp),%eax
jge    27ac <main+0x15cc>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movl   $0x0,0x8(%rax)
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
shl    $0x3,%eax
mov    %eax,-0x78988(%rbp)
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
add    $0x1,%eax
shl    $0x3,%eax
mov    %eax,-0x7898c(%rbp)
mov    -0x78988(%rbp),%eax
mov    %eax,-0x78980(%rbp)
mov    -0x78980(%rbp),%eax
cmp    -0x7898c(%rbp),%eax
jge    2793 <main+0x15b3>
movslq -0x78980(%rbp),%rax
cmpl   $0x0,-0x40560(%rbp,%rax,4)
je     277a <main+0x159a>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x8(%rax)
jmp    277f <main+0x159f>
mov    -0x78980(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78980(%rbp)
jmp    2735 <main+0x1555>
jmp    2798 <main+0x15b8>
mov    -0x78990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78990(%rbp)
jmp    26b7 <main+0x14d7>
movl   $0x0,-0x78990(%rbp)
movl   $0xffffffff,-0x78984(%rbp)
ff ff ff
movl   $0x0,-0x7897c(%rbp)
mov    -0x78990(%rbp),%eax
cmp    -0x48964(%rbp),%eax
jge    290a <main+0x172a>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1,0x8(%rax)
jle    28d4 <main+0x16f4>
mov    -0x78984(%rbp),%eax
movslq -0x78990(%rbp),%rdx
lea    -0x78970(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
mov    (%rcx),%ecx
sar    $0x5,%ecx
cmp    %ecx,%eax
jne    2863 <main+0x1683>
mov    $0x6,%edi
call   1090 <malloc@plt>
mov    %rax,-0x789a0(%rbp)
mov    -0x789a0(%rbp),%rdi
mov    -0x78984(%rbp),%edx
mov    -0x7897c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x7897c(%rbp)
lea    0x19bb(%rip),%rsi
mov    $0x0,%al
call   10e0 <sprintf@plt>
jmp    28af <main+0x16cf>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
sar    $0x5,%eax
mov    %eax,-0x78984(%rbp)
mov    $0x3,%edi
call   1090 <malloc@plt>
mov    %rax,-0x789a0(%rbp)
mov    -0x789a0(%rbp),%rdi
mov    -0x78984(%rbp),%edx
lea    0x18b1(%rip),%rsi
mov    $0x0,%al
call   10e0 <sprintf@plt>
mov    -0x789a0(%rbp),%rcx
movslq -0x78990(%rbp),%rdx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x10(%rax)
jmp    28f1 <main+0x1711>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movq   $0x0,0x10(%rax)
jmp    28f6 <main+0x1716>
mov    -0x78990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78990(%rbp)
jmp    27ca <main+0x15ea>
movl   $0xffffffff,-0x78984(%rbp)
ff ff ff
movl   $0x0,-0x78990(%rbp)
mov    -0x78990(%rbp),%eax
cmp    -0x48964(%rbp),%eax
jge    2b5f <main+0x197f>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1,0x8(%rax)
jle    2b46 <main+0x1966>
movl   $0x0,-0x78984(%rbp)
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x10(%rax),%rcx
movslq -0x78990(%rbp),%rsi
lea    -0x78970(%rbp),%rax
imul   $0x18,%rsi,%rsi
add    %rsi,%rax
mov    0x4(%rax),%r8d
movslq -0x78990(%rbp),%rsi
lea    -0x78970(%rbp),%rax
imul   $0x18,%rsi,%rsi
add    %rsi,%rax
sub    (%rax),%r8d
add    $0x1,%r8d
shl    $0x3,%r8d
lea    0x185d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
mov    %eax,-0x78988(%rbp)
mov    -0x78988(%rbp),%eax
movslq -0x78990(%rbp),%rdx
lea    -0x78970(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cmp    0x4(%rcx),%eax
jg     2b31 <main+0x1951>
mov    -0x78988(%rbp),%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    2a5d <main+0x187d>
mov    -0x78988(%rbp),%eax
movslq -0x78990(%rbp),%rdx
lea    -0x78970(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
jle    2a5d <main+0x187d>
mov    -0x448(%rbp),%rdi
mov    -0x78988(%rbp),%edx
shl    $0x3,%edx
lea    0x17f2(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x1765(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x7898c(%rbp)
cmpl   $0x8,-0x7898c(%rbp)
jge    2ad5 <main+0x18f5>
mov    -0x78988(%rbp),%eax
shl    $0x3,%eax
add    -0x7898c(%rbp),%eax
mov    %eax,-0x78980(%rbp)
mov    -0x448(%rbp),%rdi
movslq -0x78980(%rbp),%rax
mov    -0x40560(%rbp,%rax,4),%edx
lea    0x179e(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x7898c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7898c(%rbp)
jmp    2a7c <main+0x189c>
mov    -0x448(%rbp),%rdi
mov    -0x78988(%rbp),%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
shl    $0x3,%edx
mov    %edx,-0x789c0(%rbp)
mov    -0x78988(%rbp),%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
mov    -0x789c0(%rbp),%edx
shl    $0x3,%ecx
add    $0x7,%ecx
lea    0x174b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x78988(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78988(%rbp)
jmp    29e1 <main+0x1801>
mov    -0x448(%rbp),%rdi
lea    0x1522(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2b4b <main+0x196b>
mov    -0x78990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78990(%rbp)
jmp    291e <main+0x173e>
cmpl   $0x0,-0x78984(%rbp)
jl     2b81 <main+0x19a1>
mov    -0x448(%rbp),%rdi
lea    0x1743(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x78974(%rbp)
movl   $0x0,-0x78988(%rbp)
cmpl   $0x2000,-0x78988(%rbp)
jge    2c96 <main+0x1ab6>
movslq -0x78988(%rbp),%rax
mov    -0x48960(%rbp,%rax,4),%eax
mov    %eax,-0x78990(%rbp)
mov    -0x78988(%rbp),%eax
mov    %eax,-0x7898c(%rbp)
xor    %eax,%eax
cmpl   $0x2000,-0x7898c(%rbp)
mov    %al,-0x789c1(%rbp)
jge    2bfa <main+0x1a1a>
movslq -0x7898c(%rbp),%rax
mov    -0x48960(%rbp,%rax,4),%eax
cmp    -0x78990(%rbp),%eax
sete   %al
mov    %al,-0x789c1(%rbp)
mov    -0x789c1(%rbp),%al
test   $0x1,%al
jne    2c0d <main+0x1a2d>
jmp    2c26 <main+0x1a46>
jmp    2c12 <main+0x1a32>
mov    -0x7898c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7898c(%rbp)
jmp    2bc5 <main+0x19e5>
cmpl   $0x0,-0x78990(%rbp)
jl     2c54 <main+0x1a74>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
add    $0x1,%eax
mov    %eax,-0x7898c(%rbp)
cmpl   $0xfffffffe,-0x78990(%rbp)
je     2c85 <main+0x1aa5>
cmpl   $0xffffffff,-0x78990(%rbp)
jne    2c7b <main+0x1a9b>
cmpl   $0x0,-0x78988(%rbp)
je     2c85 <main+0x1aa5>
movl   $0x1,-0x78974(%rbp)
mov    -0x7898c(%rbp),%eax
mov    %eax,-0x78988(%rbp)
jmp    2b95 <main+0x19b5>
movl   $0x0,-0x78978(%rbp)
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x15c5(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x16e6(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x78974(%rbp)
je     2cf0 <main+0x1b10>
mov    -0x448(%rbp),%rdi
lea    0x15d6(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x78988(%rbp)
cmpl   $0x2000,-0x78988(%rbp)
jge    30d1 <main+0x1ef1>
movslq -0x78988(%rbp),%rax
mov    -0x48960(%rbp,%rax,4),%eax
mov    %eax,-0x78990(%rbp)
mov    -0x78988(%rbp),%eax
mov    %eax,-0x7898c(%rbp)
xor    %eax,%eax
cmpl   $0x2000,-0x7898c(%rbp)
mov    %al,-0x789c2(%rbp)
jge    2d5f <main+0x1b7f>
movslq -0x7898c(%rbp),%rax
mov    -0x48960(%rbp,%rax,4),%eax
cmp    -0x78990(%rbp),%eax
sete   %al
mov    %al,-0x789c2(%rbp)
mov    -0x789c2(%rbp),%al
test   $0x1,%al
jne    2d72 <main+0x1b92>
jmp    2d8b <main+0x1bab>
jmp    2d77 <main+0x1b97>
mov    -0x7898c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7898c(%rbp)
jmp    2d2a <main+0x1b4a>
cmpl   $0x0,-0x78990(%rbp)
jl     2e13 <main+0x1c33>
mov    -0x78988(%rbp),%eax
movslq -0x78990(%rbp),%rdx
lea    -0x78970(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
je     2dc2 <main+0x1be2>
mov    $0x0,%al
call   1030 <abort@plt>
mov    -0x7898c(%rbp),%eax
movslq -0x78990(%rbp),%rdx
lea    -0x78970(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    2df2 <main+0x1c12>
mov    $0x0,%al
call   1030 <abort@plt>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
add    $0x1,%eax
mov    %eax,-0x7898c(%rbp)
cmpl   $0xfffffffe,-0x78990(%rbp)
jne    2e25 <main+0x1c45>
jmp    30c0 <main+0x1ee0>
cmpl   $0x0,-0x78988(%rbp)
jne    2e4c <main+0x1c6c>
mov    -0x448(%rbp),%rdi
lea    0x138f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2e61 <main+0x1c81>
mov    -0x448(%rbp),%rdi
lea    0x147d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x78990(%rbp)
jl     2e94 <main+0x1cb4>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,0x8(%rax)
jne    2e94 <main+0x1cb4>
mov    $0x0,%al
call   1030 <abort@plt>
cmpl   $0x0,-0x78990(%rbp)
jl     2f65 <main+0x1d85>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1,0x8(%rax)
jne    2f65 <main+0x1d85>
mov    -0x7898c(%rbp),%eax
mov    -0x78988(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
je     2ede <main+0x1cfe>
mov    $0x0,%al
call   1030 <abort@plt>
mov    -0x78988(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x78980(%rbp)
mov    -0x78980(%rbp),%eax
mov    -0x7898c(%rbp),%ecx
shl    $0x3,%ecx
cmp    %ecx,%eax
jge    2f60 <main+0x1d80>
movslq -0x78980(%rbp),%rax
cmpl   $0x0,-0x40560(%rbp,%rax,4)
je     2f47 <main+0x1d67>
mov    -0x448(%rbp),%rdi
mov    -0x78980(%rbp),%edx
movslq -0x78980(%rbp),%rax
mov    -0x40560(%rbp,%rax,4),%ecx
lea    0x13a4(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2f60 <main+0x1d80>
jmp    2f4c <main+0x1d6c>
mov    -0x78980(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78980(%rbp)
jmp    2eed <main+0x1d0d>
jmp    30bb <main+0x1edb>
cmpl   $0x0,-0x78988(%rbp)
jne    2f95 <main+0x1db5>
mov    -0x448(%rbp),%rdi
mov    -0x7898c(%rbp),%edx
shl    $0x3,%edx
lea    0x1379(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2fbc <main+0x1ddc>
mov    -0x448(%rbp),%rdi
mov    -0x78988(%rbp),%edx
shl    $0x3,%edx
mov    -0x7898c(%rbp),%ecx
shl    $0x3,%ecx
lea    0x135e(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0xffffffff,-0x78990(%rbp)
jne    300a <main+0x1e2a>
cmpl   $0x0,-0x78988(%rbp)
jne    2ff0 <main+0x1e10>
mov    -0x448(%rbp),%rdi
lea    0x1350(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    3005 <main+0x1e25>
mov    -0x448(%rbp),%rdi
lea    0x1359(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    30b6 <main+0x1ed6>
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x10(%rax),%rcx
lea    0x1330(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,(%rax)
jle    3078 <main+0x1e98>
mov    -0x448(%rbp),%rdi
mov    -0x78988(%rbp),%edx
shl    $0x3,%edx
lea    0x130a(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x10d8(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x78988(%rbp)
jne    30b1 <main+0x1ed1>
cmpl   $0x0,-0x40560(%rbp)
jne    30b1 <main+0x1ed1>
movl   $0x1,-0x78978(%rbp)
jmp    30b6 <main+0x1ed6>
jmp    30bb <main+0x1edb>
jmp    30c0 <main+0x1ee0>
mov    -0x7898c(%rbp),%eax
mov    %eax,-0x78988(%rbp)
jmp    2cfa <main+0x1b1a>
cmpl   $0x0,-0x78974(%rbp)
je     3159 <main+0x1f79>
cmpl   $0x0,-0x78978(%rbp)
je     3105 <main+0x1f25>
mov    -0x448(%rbp),%rdi
lea    0x128a(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    311a <main+0x1f3a>
mov    -0x448(%rbp),%rdi
lea    0x128c(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x1288(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x1280(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x1200(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x103f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x11d8(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
call   1050 <ferror@plt>
cmp    $0x0,%rax
jne    31af <main+0x1fcf>
mov    -0x448(%rbp),%rdi
call   1060 <fclose@plt>
cmp    $0x0,%rax
je     31b9 <main+0x1fd9>
mov    $0x1,%edi
call   10f0 <exit@plt>
xor    %edi,%edi
call   10f0 <exit@plt>

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78438,%rsp
lea    -0x6(%rdi),%eax
cmp    $0xfffffffc,%eax
jbe    1732 <main+0x512>
mov    0x8(%rsi),%rax
mov    %rax,0x10(%rsp)
mov    0x10(%rsi),%rbp
cmp    $0x3,%edi
mov    %rbp,0x20(%rsp)
jbe    1266 <main+0x46>
mov    0x18(%rsi),%r12
cmp    $0x4,%edi
jne    12ac <main+0x8c>
lea    0x2067(%rip),%r14
jmp    12b0 <main+0x90>
mov    %rbp,%rdi
call   1070 <strlen@plt>
mov    %eax,%ebx
lea    0x1d99(%rip),%r14
mov    %r14,%rdi
call   1070 <strlen@plt>
lea    (%rbx,%rax,1),%edi
add    $0x1,%edi
call   10c0 <malloc@plt>
mov    %rax,%r12
mov    %rax,%rdi
mov    %rbp,%rsi
call   1040 <strcpy@plt>
mov    %r12,%rdi
mov    %r14,%rsi
call   1100 <strcat@plt>
lea    0x2021(%rip),%r14
jmp    12b0 <main+0x90>
mov    0x20(%rsi),%r14
mov    0x3d19(%rip),%rax
movslq (%rax),%rdi
lea    0x1d52(%rip),%rsi
xor    %ebp,%ebp
mov    %r14,%rdx
mov    %r12,%rcx
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    0x3d11(%rip),%r15
mov    (%r15),%edi
call   1140 <getc@plt>
mov    %eax,%ebx
mov    (%r15),%esi
mov    %eax,%edi
call   10d0 <ungetc@plt>
cmp    $0x23,%ebx
jne    165b <main+0x43b>
mov    %r14,0x8(%rsp)
movdqa 0x1cff(%rip),%xmm0
movdqa %xmm0,0x30(%rsp)
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x50(%rsp)
movdqa %xmm0,0x60(%rsp)
movdqa %xmm0,0x70(%rsp)
movdqa %xmm0,0x80(%rsp)
movdqa %xmm0,0x90(%rsp)
movdqa %xmm0,0xa0(%rsp)
movdqa %xmm0,0xb0(%rsp)
movdqa %xmm0,0xc0(%rsp)
movdqa %xmm0,0xd0(%rsp)
movdqa %xmm0,0xe0(%rsp)
movdqa %xmm0,0xf0(%rsp)
movdqa %xmm0,0x100(%rsp)
movdqa %xmm0,0x110(%rsp)
movdqa %xmm0,0x120(%rsp)
movdqa %xmm0,0x130(%rsp)
movdqa %xmm0,0x140(%rsp)
movdqa %xmm0,0x150(%rsp)
movdqa %xmm0,0x160(%rsp)
movdqa %xmm0,0x170(%rsp)
movdqa %xmm0,0x180(%rsp)
movdqa %xmm0,0x190(%rsp)
movdqa %xmm0,0x1a0(%rsp)
movdqa %xmm0,0x1b0(%rsp)
movdqa %xmm0,0x1c0(%rsp)
movdqa %xmm0,0x1d0(%rsp)
movdqa %xmm0,0x1e0(%rsp)
movdqa %xmm0,0x1f0(%rsp)
movdqa %xmm0,0x200(%rsp)
movdqa %xmm0,0x210(%rsp)
movdqa %xmm0,0x220(%rsp)
movdqa %xmm0,0x230(%rsp)
movdqa %xmm0,0x240(%rsp)
movdqa %xmm0,0x250(%rsp)
movdqa %xmm0,0x260(%rsp)
movdqa %xmm0,0x270(%rsp)
movdqa %xmm0,0x280(%rsp)
movdqa %xmm0,0x290(%rsp)
movdqa %xmm0,0x2a0(%rsp)
movdqa %xmm0,0x2b0(%rsp)
movdqa %xmm0,0x2c0(%rsp)
movdqa %xmm0,0x2d0(%rsp)
movdqa %xmm0,0x2e0(%rsp)
movdqa %xmm0,0x2f0(%rsp)
movdqa %xmm0,0x300(%rsp)
movdqa %xmm0,0x310(%rsp)
movdqa %xmm0,0x320(%rsp)
movdqa %xmm0,0x330(%rsp)
movdqa %xmm0,0x340(%rsp)
movdqa %xmm0,0x350(%rsp)
movdqa %xmm0,0x360(%rsp)
movdqa %xmm0,0x370(%rsp)
movdqa %xmm0,0x380(%rsp)
movdqa %xmm0,0x390(%rsp)
movdqa %xmm0,0x3a0(%rsp)
movdqa %xmm0,0x3b0(%rsp)
movdqa %xmm0,0x3c0(%rsp)
movdqa %xmm0,0x3d0(%rsp)
movdqa %xmm0,0x3e0(%rsp)
movdqa %xmm0,0x3f0(%rsp)
movdqa %xmm0,0x400(%rsp)
movdqa %xmm0,0x410(%rsp)
movdqa %xmm0,0x420(%rsp)
movl   $0x100,0x38430(%rsp)
mov    (%r15),%edi
call   1140 <getc@plt>
mov    0x3a94(%rip),%r14
cmp    (%r14),%eax
je     16e3 <main+0x4c3>
lea    0x1ac6(%rip),%rbp
lea    0x38430(%rsp),%r13
jmp    1581 <main+0x361>
cs nopw 0x0(%rax,%rax,1)
mov    (%r15),%edi
call   1140 <getc@plt>
cmp    (%r14),%eax
je     16e3 <main+0x4c3>
lea    -0x9(%rax),%ecx
cmp    $0x2,%ecx
jb     1570 <main+0x350>
cmp    $0x20,%eax
je     1570 <main+0x350>
cmp    $0x23,%eax
jne    15c0 <main+0x3a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15),%edi
call   1140 <getc@plt>
cmp    $0xa,%eax
je     1570 <main+0x350>
cmp    (%r14),%eax
jne    15a0 <main+0x380>
jmp    1570 <main+0x350>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r15),%esi
mov    %eax,%edi
call   10d0 <ungetc@plt>
mov    %rbp,%rdi
mov    %r13,%rsi
call   10e0 <scanf@plt>
cmp    $0x1,%eax
jne    1732 <main+0x512>
mov    0x38430(%rsp),%eax
test   %eax,%eax
js     1732 <main+0x512>
cmp    $0xff,%eax
jg     1732 <main+0x512>
nopl   0x0(%rax,%rax,1)
mov    (%r15),%edi
call   1140 <getc@plt>
cmp    $0x9,%eax
je     1600 <main+0x3e0>
mov    %eax,%ebx
cmp    $0x20,%eax
je     1600 <main+0x3e0>
cmp    (%r14),%ebx
je     1623 <main+0x403>
mov    (%r15),%esi
mov    %ebx,%edi
call   10d0 <ungetc@plt>
cmp    $0xa,%ebx
je     1570 <main+0x350>
cmp    $0x23,%ebx
je     1570 <main+0x350>
movslq 0x38430(%rsp),%rax
lea    (%rsp,%rax,4),%rsi
add    $0x30,%rsi
mov    %rbp,%rdi
call   10e0 <scanf@plt>
cmp    $0x1,%eax
je     1570 <main+0x350>
jmp    1732 <main+0x512>
movl   $0x0,0x38430(%rsp)
lea    0x19b7(%rip),%rbx
jmp    1689 <main+0x469>
nop
movl   $0xfffd,0x30(%rsp,%rax,4)
lea    0x1(%rax),%ebp
mov    %ebp,0x38430(%rsp)
cmp    $0xff,%eax
jge    16bf <main+0x49f>
movslq %ebp,%rax
lea    (%rsp,%rax,4),%rsi
add    $0x30,%rsi
mov    %rbx,%rdi
call   10e0 <scanf@plt>
cmp    $0x1,%eax
jne    1732 <main+0x512>
movslq 0x38430(%rsp),%rax
mov    0x30(%rsp,%rax,4),%ecx
test   %ecx,%ecx
js     1670 <main+0x450>
cmp    $0xffff,%ecx
jne    1678 <main+0x458>
jmp    1670 <main+0x450>
mov    %r14,0x8(%rsp)
lea    0x1959(%rip),%rdi
lea    0x38430(%rsp),%rsi
call   10e0 <scanf@plt>
mov    0x3901(%rip),%rcx
cmp    (%rcx),%eax
jne    1732 <main+0x512>
mov    0x8(%rsp),%rbp
mov    %rbp,%rdi
call   1070 <strlen@plt>
mov    %eax,%ebx
mov    %r12,%rdi
call   1070 <strlen@plt>
lea    (%rbx,%rax,1),%edi
add    $0x1,%edi
call   10c0 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
mov    %rbp,%rsi
call   1040 <strcpy@plt>
mov    %rbx,%rdi
mov    %r12,%rsi
call   1100 <strcat@plt>
lea    0x1902(%rip),%rsi
mov    %rbx,%rdi
call   10f0 <fopen@plt>
test   %rax,%rax
jne    173c <main+0x51c>
mov    $0x1,%edi
call   1120 <exit@plt>
mov    %rax,%rbx
mov    $0xa,%edi
mov    %rax,%rsi
call   10a0 <fputc@plt>
lea    0x18d6(%rip),%rdi
mov    $0x3,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x18c1(%rip),%rsi
mov    %rbx,%rdi
mov    0x10(%rsp),%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
lea    0x18e1(%rip),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    $0xa,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
lea    0x8430(%rsp),%rax
mov    $0xf,%ecx
movdqa 0x1849(%rip),%xmm8
pcmpeqd %xmm0,%xmm0
mov    0x20(%rsp),%r15
jmp    17eb <main+0x5cb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0xfffffffe,(%rax)
add    $0x4,%rax
add    $0x10,%rcx
cmp    $0x10f,%rcx
je     199b <main+0x77b>
movdqa -0xc(%rsp,%rcx,4),%xmm1
movdqa 0x4(%rsp,%rcx,4),%xmm2
movdqa 0x14(%rsp,%rcx,4),%xmm3
movdqa 0x24(%rsp,%rcx,4),%xmm4
movdqa %xmm4,%xmm5
pcmpeqd %xmm8,%xmm5
pxor   %xmm0,%xmm5
movdqa %xmm3,%xmm6
pcmpeqd %xmm8,%xmm6
pxor   %xmm0,%xmm6
packssdw %xmm5,%xmm6
movdqa %xmm2,%xmm5
pcmpeqd %xmm8,%xmm5
pxor   %xmm0,%xmm5
movdqa %xmm1,%xmm7
pcmpeqd %xmm8,%xmm7
pxor   %xmm0,%xmm7
packssdw %xmm5,%xmm7
packsswb %xmm6,%xmm7
pmovmskb %xmm7,%edx
test   %edx,%edx
je     17d0 <main+0x5b0>
pshufd $0xff,%xmm4,%xmm5
movd   %xmm5,%edx
cmp    %rdx,%rcx
jne    1990 <main+0x770>
lea    -0x1(%rcx),%rdx
pshufd $0xee,%xmm4,%xmm5
movd   %xmm5,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0x2(%rcx),%rdx
pshufd $0x55,%xmm4,%xmm5
movd   %xmm5,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0x3(%rcx),%rdx
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0x4(%rcx),%rdx
pshufd $0xff,%xmm3,%xmm4
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0x5(%rcx),%rdx
pshufd $0xee,%xmm3,%xmm4
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0x6(%rcx),%rdx
pshufd $0x55,%xmm3,%xmm4
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0x7(%rcx),%rdx
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0x8(%rcx),%rdx
pshufd $0xff,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0x9(%rcx),%rdx
pshufd $0xee,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0xa(%rcx),%rdx
pshufd $0x55,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0xb(%rcx),%rdx
movd   %xmm2,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0xc(%rcx),%rdx
pshufd $0xff,%xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0xd(%rcx),%rdx
pshufd $0xee,%xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0xe(%rcx),%rdx
pshufd $0x55,%xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
lea    -0xf(%rcx),%rdx
movd   %xmm1,%esi
cmp    %rsi,%rdx
jne    1990 <main+0x770>
movl   $0xffffffff,(%rax)
jmp    17d6 <main+0x5b6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rax)
jmp    17d6 <main+0x5b6>
xor    %eax,%eax
xor    %r12d,%r12d
jmp    19db <main+0x7bb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12d,0x8430(%rsp,%rax,4)
movslq %r12d,%rcx
lea    0x1(%r12),%edx
mov    %eax,0x38434(%rsp,%rcx,8)
mov    %eax,0x38430(%rsp,%rcx,8)
mov    %edx,%r12d
add    $0x1,%rax
cmp    $0x10,%rax
je     1a12 <main+0x7f2>
cmpl   $0x0,0x8430(%rsp,%rax,4)
js     19d1 <main+0x7b1>
test   %rax,%rax
je     19b0 <main+0x790>
test   %r12d,%r12d
jle    19b0 <main+0x790>
lea    -0x1(%rax),%ecx
mov    0x8430(%rsp,%rcx,4),%ecx
lea    -0x1(%r12),%edx
cmp    %edx,%ecx
jne    19b0 <main+0x790>
mov    %ecx,0x8430(%rsp,%rax,4)
mov    %eax,0x38434(%rsp,%rcx,8)
jmp    19d1 <main+0x7b1>
pxor   %xmm0,%xmm0
xor    %eax,%eax
pxor   %xmm1,%xmm1
mov    %r12,0x10(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa 0x30(%rsp,%rax,4),%xmm2
pcmpeqd %xmm8,%xmm2
movdqa 0x40(%rsp,%rax,4),%xmm3
pcmpeqd %xmm8,%xmm3
movdqa 0x50(%rsp,%rax,4),%xmm4
pcmpeqd %xmm8,%xmm4
por    %xmm2,%xmm4
movdqa 0x60(%rsp,%rax,4),%xmm2
pcmpeqd %xmm8,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm3
pandn  %xmm0,%xmm3
movdqa %xmm3,%xmm0
psubd  %xmm4,%xmm0
movdqa %xmm2,%xmm3
pandn  %xmm1,%xmm3
movdqa %xmm3,%xmm1
psubd  %xmm2,%xmm1
add    $0x10,%rax
cmp    $0x100,%rax
jne    1a30 <main+0x810>
pxor   %xmm2,%xmm2
movdqa %xmm0,%xmm3
pcmpeqd %xmm2,%xmm3
pand   %xmm3,%xmm1
pandn  %xmm0,%xmm3
por    %xmm1,%xmm3
pcmpeqd %xmm2,%xmm3
movmskps %xmm3,%r14d
xor    $0xf,%r14d
test   %r12d,%r12d
jle    1d7b <main+0xb5b>
mov    %r14d,0x1c(%rsp)
mov    %r12d,%eax
mov    %rax,0x28(%rsp)
lea    0x1597(%rip),%r14
xor    %ebp,%ebp
jmp    1b17 <main+0x8f7>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x3,%esi
mov    $0x1,%edx
lea    0x1580(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    0x8(%rsp),%rbp
add    $0x1,%rbp
cmp    0x28(%rsp),%rbp
mov    0x20(%rsp),%r15
mov    0x10(%rsp),%r12
je     1d69 <main+0xb49>
mov    %rbx,%rdi
lea    0x1513(%rip),%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0x1,%r12d
je     1b45 <main+0x925>
lea    0x1(%rbp),%edx
mov    %rbx,%rdi
lea    0x16e5(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    0x38430(%rsp,%rbp,8),%r15d
mov    %rbp,0x8(%rsp)
mov    0x38434(%rsp,%rbp,8),%r12d
mov    %r12d,%edx
sub    %r15d,%edx
shl    $0x4,%edx
add    $0x10,%edx
mov    %rbx,%rdi
lea    0x16db(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
sub    %r15d,%r12d
lea    0x14d7(%rip),%r13
jl     1ae0 <main+0x8c0>
shl    $0x4,%r15d
add    $0x1,%r12d
nop
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r15d,%edx
xor    %eax,%eax
call   10b0 <fprintf@plt>
movslq %r15d,%r15
mov    $0x20,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
lea    0x0(,%r15,4),%rbp
mov    0x30(%rsp,%r15,4),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x4,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x8,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0xc,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x10,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x14,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x18,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x1c,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0xa,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
mov    $0x20,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
mov    %rbp,%rax
or     $0x20,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x24,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x28,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x2c,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x30,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x34,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbp,%rax
or     $0x38,%rax
mov    0x30(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
or     $0x3c,%rbp
mov    0x30(%rsp,%rbp,1),%edx
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0xa,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
add    $0x10,%r15d
add    $0xffffffff,%r12d
jne    1b90 <main+0x970>
jmp    1ae0 <main+0x8c0>
mov    $0xa,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
mov    0x1c(%rsp),%r14d
lea    0x12f3(%rip),%rsi
mov    %rbx,%rdi
mov    %r15,%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
lea    0x1624(%rip),%rdi
mov    $0x2,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x1316(%rip),%rdi
mov    $0x18,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
test   %r14b,%r14b
jne    1f44 <main+0xd24>
lea    0x8434(%rsp),%rbp
lea    0x1387(%rip),%r14
lea    0x138b(%rip),%r13
xor    %r15d,%r15d
jmp    1e13 <main+0xbf3>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x13,%esi
mov    $0x1,%edx
lea    0x1318(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
cmp    $0x10,%r15d
jge    2292 <main+0x1072>
mov    %r15d,%eax
movslq %r15d,%rdx
movslq 0x8430(%rsp,%rdx,4),%r12
lea    0x0(,%rdx,4),%rcx
add    %rbp,%rcx
mov    $0xf,%esi
sub    %rdx,%rsi
shl    $0x4,%edx
xor    %edi,%edi
nopl   0x0(%rax)
cmp    %rdi,%rsi
je     1e70 <main+0xc50>
lea    0x1(%rdi),%r15
add    $0x10,%edx
cmp    %r12d,(%rcx,%rdi,4)
mov    %r15,%rdi
je     1e40 <main+0xc20>
add    %rax,%r15
mov    %rbx,%rdi
test   %rax,%rax
je     1eb2 <main+0xc92>
lea    0x1384(%rip),%rsi
jmp    1eb9 <main+0xc99>
nopl   0x0(%rax)
test   %rax,%rax
je     1e88 <main+0xc68>
mov    $0xb,%esi
mov    $0x1,%edx
lea    0x1359(%rip),%rdi
jmp    1e99 <main+0xc79>
mov    $0x2,%esi
mov    $0x1,%edx
lea    0x1343(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    $0x10,%r15d
cmp    $0xffffffff,%r12d
jne    1eca <main+0xcaa>
jmp    1df0 <main+0xbd0>
lea    0x130f(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0xffffffff,%r12d
je     1df0 <main+0xbd0>
mov    %rbx,%rdi
lea    0x1333(%rip),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmpl   $0x2,0x10(%rsp)
jl     1efd <main+0xcdd>
lea    0x1(%r12),%edx
mov    %rbx,%rdi
lea    0x132d(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0x2,%esi
mov    $0x1,%edx
mov    %r14,%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    0x38430(%rsp,%r12,8),%edx
test   %edx,%edx
jle    1f32 <main+0xd12>
shl    $0x4,%edx
mov    %rbx,%rdi
lea    0x1238(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0x3,%esi
mov    $0x1,%edx
mov    %r13,%rdi
jmp    1e01 <main+0xbe1>
movl   $0x0,0x8(%rsp)
xor    %r15d,%r15d
nop
mov    %r15d,%r12d
movslq %r15d,%rdx
movslq 0x8430(%rsp,%rdx,4),%rbp
lea    0x8434(%rsp),%rax
lea    (%rax,%rdx,4),%rax
mov    $0xf,%ecx
sub    %rdx,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %rdx,%rcx
je     1fa0 <main+0xd80>
lea    0x1(%rdx),%r15
cmp    %ebp,(%rax,%rdx,4)
mov    %r15,%rdx
je     1f80 <main+0xd60>
add    %r12d,%r15d
jmp    1fa6 <main+0xd86>
cs nopw 0x0(%rax,%rax,1)
mov    $0x10,%r15d
mov    %r15d,%eax
xor    $0x10,%eax
or     %r12d,%eax
sete   %r14b
lea    0x1220(%rip),%r13
lea    0x121b(%rip),%rax
cmove  %rax,%r13
test   %r12,%r12
je     1ff0 <main+0xdd0>
cmp    $0x10,%r15d
jne    2010 <main+0xdf0>
mov    $0x9,%esi
mov    $0x1,%edx
lea    0x1112(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
jmp    2027 <main+0xe07>
nopl   0x0(%rax,%rax,1)
cmp    $0x10,%r15d
je     2027 <main+0xe07>
mov    %r15d,%edx
shl    $0x4,%edx
mov    %rbx,%rdi
lea    0x10d8(%rip),%rsi
jmp    2020 <main+0xe00>
nopl   0x0(%rax,%rax,1)
mov    %r15d,%edx
shl    $0x4,%edx
mov    %rbx,%rdi
lea    0x10dd(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0xfffffffe,%ebp
je     2050 <main+0xe30>
cmp    $0xffffffff,%ebp
jne    2060 <main+0xe40>
lea    0x10df(%rip),%rsi
lea    0x10ee(%rip),%rbp
jmp    2238 <main+0x1018>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x1,0x8(%rsp)
jmp    2255 <main+0x1035>
nopl   (%rax)
mov    %r13,%rdi
mov    %rbx,%rsi
call   1080 <fputs@plt>
shl    $0x4,%r12d
mov    %r15d,%ecx
shl    $0x4,%ecx
cmp    %ecx,%r12d
jge    2150 <main+0xf30>
movslq %r12d,%rax
movslq %ecx,%rcx
cmp    %rax,%rcx
je     2106 <main+0xee6>
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
movdqa 0xf63(%rip),%xmm5
nopl   (%rax)
movdqa 0x30(%rsp,%rax,4),%xmm2
pcmpeqd %xmm5,%xmm2
movdqa 0x40(%rsp,%rax,4),%xmm3
pcmpeqd %xmm5,%xmm3
movdqa %xmm2,%xmm4
pandn  %xmm0,%xmm4
movdqa %xmm4,%xmm0
psubd  %xmm2,%xmm0
movdqa %xmm3,%xmm2
pandn  %xmm1,%xmm2
movdqa %xmm2,%xmm1
psubd  %xmm3,%xmm1
add    $0x8,%rax
cmp    %rax,%rcx
jne    20a0 <main+0xe80>
movdqa %xmm0,%xmm2
pxor   %xmm3,%xmm3
pcmpeqd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
pcmpeqd %xmm3,%xmm2
movmskps %xmm2,%eax
xor    %edx,%edx
cmp    $0xf,%eax
setne  %dl
jmp    2124 <main+0xf04>
xor    %edx,%edx
mov    $0x1,%esi
nopl   (%rax)
cmpl   $0xfffd,0x30(%rsp,%rax,4)
cmove  %esi,%edx
add    $0x1,%rax
cmp    %rax,%rcx
jne    2110 <main+0xef0>
test   %edx,%edx
je     2150 <main+0xf30>
mov    $0x14,%esi
mov    $0x1,%edx
lea    0x1001(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
xor    %r12d,%r12d
jmp    216c <main+0xf4c>
cs nopw 0x0(%rax,%rax,1)
mov    $0x10,%esi
mov    $0x1,%edx
lea    0xfee(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    $0x1,%r12b
mov    %rbx,%rdi
lea    0x10a1(%rip),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmpl   $0x2,0x10(%rsp)
jl     219d <main+0xf7d>
lea    0x1(%rbp),%edx
mov    %rbx,%rdi
lea    0x108d(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0x2,%esi
mov    $0x1,%edx
lea    0xfb2(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    0x38430(%rsp,%rbp,8),%edx
test   %edx,%edx
jle    21d5 <main+0xfb5>
shl    $0x4,%edx
mov    %rbx,%rdi
lea    0xf95(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0x3,%esi
mov    $0x1,%edx
lea    0xf85(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0xf38(%rip),%rbp
test   %r12b,%r12b
jne    2245 <main+0x1025>
mov    %rbx,%rdi
lea    0xf6b(%rip),%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbx,%rdi
lea    0xf6e(%rip),%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
movl   $0x1,0x8(%rsp)
lea    0xf6e(%rip),%rsi
lea    0xf76(%rip),%rbp
mov    %rbx,%rdi
mov    %r13,%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
test   %r14b,%r14b
jne    227d <main+0x105d>
mov    $0x4,%esi
mov    $0x1,%edx
lea    0x10f4(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
cmp    $0x10,%r15d
jl     1f50 <main+0xd30>
cmpl   $0x0,0x8(%rsp)
je     22ab <main+0x108b>
lea    0xf28(%rip),%rdi
mov    $0x14,%esi
jmp    229e <main+0x107e>
lea    0x1133(%rip),%rdi
mov    $0xc,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x10af(%rip),%rdi
mov    $0x2,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    $0xa,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
lea    0x38430(%rsp),%rdi
xor    %ebp,%ebp
mov    $0x40000,%edx
xor    %esi,%esi
call   1090 <memset@plt>
jmp    22fd <main+0x10dd>
nopl   0x0(%rax)
add    $0x2,%rbp
cmp    $0x100,%rbp
je     232a <main+0x110a>
movslq 0x30(%rsp,%rbp,4),%rax
cmp    $0xfffd,%rax
je     2311 <main+0x10f1>
mov    %ebp,0x38430(%rsp,%rax,4)
movslq 0x34(%rsp,%rbp,4),%rax
cmp    $0xfffd,%rax
je     22f0 <main+0x10d0>
lea    0x1(%rbp),%ecx
mov    %ecx,0x38430(%rsp,%rax,4)
jmp    22f0 <main+0x10d0>
lea    0x430(%rsp),%rax
mov    $0x7,%ecx
pxor   %xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
jmp    236b <main+0x114b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movl   $0xfffffffe,(%rax)
add    $0x4,%rax
add    $0x8,%rcx
cmp    $0x10007,%rcx
je     244b <main+0x122b>
movdqa 0x38414(%rsp,%rcx,4),%xmm2
movdqa 0x38424(%rsp,%rcx,4),%xmm3
movdqa %xmm3,%xmm4
pcmpeqd %xmm0,%xmm4
pxor   %xmm1,%xmm4
movdqa %xmm2,%xmm5
pcmpeqd %xmm0,%xmm5
pxor   %xmm1,%xmm5
packssdw %xmm4,%xmm5
pmovmskb %xmm5,%edx
test   %edx,%edx
je     2350 <main+0x1130>
pshufd $0xff,%xmm3,%xmm4
movd   %xmm4,%edx
cmp    %rdx,%rcx
jne    2440 <main+0x1220>
lea    -0x1(%rcx),%rdx
pshufd $0xee,%xmm3,%xmm4
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    2440 <main+0x1220>
lea    -0x2(%rcx),%rdx
pshufd $0x55,%xmm3,%xmm4
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    2440 <main+0x1220>
lea    -0x3(%rcx),%rdx
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    2440 <main+0x1220>
lea    -0x4(%rcx),%rdx
pshufd $0xff,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    2440 <main+0x1220>
lea    -0x5(%rcx),%rdx
pshufd $0xee,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    2440 <main+0x1220>
lea    -0x6(%rcx),%rdx
pshufd $0x55,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    2440 <main+0x1220>
lea    -0x7(%rcx),%rdx
movd   %xmm2,%esi
cmp    %rsi,%rdx
jne    2440 <main+0x1220>
movl   $0xffffffff,(%rax)
jmp    2356 <main+0x1136>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rax)
jmp    2356 <main+0x1136>
mov    0x430(%rsp),%ebp
xor    %r12d,%r12d
test   %ebp,%ebp
js     2478 <main+0x1258>
movl   $0x0,0x430(%rsp)
movq   $0x0,0x8430(%rsp)
mov    $0x1,%r12d
xor    %ebp,%ebp
mov    $0x1,%eax
jmp    24b1 <main+0x1291>
nop
mov    %r12d,0x430(%rsp,%rax,4)
movslq %r12d,%rcx
lea    0x1(%r12),%edx
lea    (%rcx,%rcx,2),%rcx
mov    %eax,0x8434(%rsp,%rcx,8)
mov    %eax,0x8430(%rsp,%rcx,8)
mov    %edx,%r12d
add    $0x1,%rax
cmp    $0x2000,%rax
je     2504 <main+0x12e4>
cmpl   $0x0,0x430(%rsp,%rax,4)
js     24a5 <main+0x1285>
test   %r12d,%r12d
jle    2480 <main+0x1260>
lea    -0x1(%r12),%ecx
cmp    %ecx,0x42c(%rsp,%rax,4)
je     24f0 <main+0x12d0>
lea    (%rcx,%rcx,2),%rdx
mov    0x8434(%rsp,%rdx,8),%edx
mov    %edx,%esi
sar    $0x5,%esi
mov    %eax,%edi
shr    $0x5,%edi
cmp    %edi,%esi
jne    2480 <main+0x1260>
mov    %eax,%esi
sub    %edx,%esi
cmp    $0x8,%esi
jg     2480 <main+0x1260>
mov    %ecx,0x430(%rsp,%rax,4)
lea    (%rcx,%rcx,2),%rcx
mov    %eax,0x8434(%rsp,%rcx,8)
jmp    24a5 <main+0x1285>
mov    %ebp,0x1c(%rsp)
test   %r12d,%r12d
jle    28a5 <main+0x1685>
mov    %r12d,%ebp
xor    %eax,%eax
jmp    2529 <main+0x1309>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rbp,%rax
je     2599 <main+0x1379>
lea    (%rax,%rax,2),%rcx
movl   $0x0,0x8438(%rsp,%rcx,8)
mov    0x8430(%rsp,%rcx,8),%edx
mov    0x8434(%rsp,%rcx,8),%esi
shl    $0x3,%edx
lea    0x8(,%rsi,8),%esi
cmp    %esi,%edx
jge    2520 <main+0x1300>
lea    (%rsp,%rcx,8),%rcx
add    $0x8438,%rcx
movslq %edx,%rdx
movslq %esi,%rsi
xor    %edi,%edi
jmp    2579 <main+0x1359>
nopl   0x0(%rax)
add    $0x2,%rdx
cmp    %rdx,%rsi
je     2520 <main+0x1300>
cmpl   $0x0,0x38430(%rsp,%rdx,4)
je     2588 <main+0x1368>
add    $0x1,%edi
mov    %edi,(%rcx)
cmpl   $0x0,0x38434(%rsp,%rdx,4)
je     2570 <main+0x1350>
add    $0x1,%edi
mov    %edi,(%rcx)
jmp    2570 <main+0x1350>
test   %r12d,%r12d
jle    28a5 <main+0x1685>
mov    %rbp,0x28(%rsp)
lea    0x0(,%rbp,8),%rax
lea    (%rax,%rax,2),%r15
mov    $0xffffffff,%eax
xor    %r14d,%r14d
movl   $0x0,0x8(%rsp)
jmp    25e3 <main+0x13c3>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ebp,%ebp
mov    %rbp,0x8440(%rsp,%r14,1)
add    $0x18,%r14
cmp    %r14,%r15
je     2659 <main+0x1439>
cmpl   $0x2,0x8438(%rsp,%r14,1)
jl     25d0 <main+0x13b0>
mov    0x8430(%rsp,%r14,1),%r13d
sar    $0x5,%r13d
cmp    %r13d,%eax
jne    2630 <main+0x1410>
mov    $0x6,%edi
mov    %eax,%r13d
call   10c0 <malloc@plt>
mov    %rax,%rbp
mov    0x8(%rsp),%ecx
add    $0x1,%ecx
mov    %rax,%rdi
lea    0xbff(%rip),%rsi
mov    %r13d,%edx
mov    %ecx,0x8(%rsp)
xor    %eax,%eax
call   1110 <sprintf@plt>
jmp    2651 <main+0x1431>
mov    $0x3,%edi
call   10c0 <malloc@plt>
mov    %rax,%rbp
mov    %rax,%rdi
lea    0xb1f(%rip),%rsi
mov    %r13d,%edx
xor    %eax,%eax
call   1110 <sprintf@plt>
mov    %r13d,%eax
jmp    25d2 <main+0x13b2>
test   %r12d,%r12d
mov    0x28(%rsp),%rsi
jle    28a5 <main+0x1685>
mov    $0xffffffff,%eax
lea    0xbf2(%rip),%rbp
xor    %ecx,%ecx
mov    0x20(%rsp),%rdx
jmp    26b7 <main+0x1497>
nopl   0x0(%rax)
mov    $0x3,%esi
mov    $0x1,%edx
lea    0x9e0(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
xor    %eax,%eax
mov    0x20(%rsp),%rdx
mov    0x28(%rsp),%rsi
mov    0x10(%rsp),%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
je     2894 <main+0x1674>
lea    (%rcx,%rcx,2),%r14
cmpl   $0x2,0x8438(%rsp,%r14,8)
jl     26aa <main+0x148a>
mov    %rcx,0x10(%rsp)
mov    0x8440(%rsp,%r14,8),%rcx
mov    0x8434(%rsp,%r14,8),%eax
movslq 0x8430(%rsp,%r14,8),%r13
sub    %r13d,%eax
lea    0x8(,%rax,8),%r8d
mov    %rbx,%rdi
lea    0xb2f(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    0x8434(%rsp,%r14,8),%r13d
jg     2680 <main+0x1460>
lea    (%rsp,%r14,8),%rax
add    $0x8430,%rax
mov    %rax,0x8(%rsp)
lea    0x0(,%r13,8),%r14d
jmp    2850 <main+0x1630>
nopl   0x0(%rax)
mov    $0x20,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
movslq %r14d,%r15
mov    0x38430(%rsp,%r15,4),%edx
shl    $0x2,%r15
mov    %rbx,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %r15,%rax
or     $0x4,%rax
mov    0x38430(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %r15,%rax
or     $0x8,%rax
mov    0x38430(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %r15,%rax
or     $0xc,%rax
mov    0x38430(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %r15,%rax
or     $0x10,%rax
mov    0x38430(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %r15,%rax
or     $0x14,%rax
mov    0x38430(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %r15,%rax
or     $0x18,%rax
mov    0x38430(%rsp,%rax,1),%edx
mov    %rbx,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
or     $0x1c,%r15
mov    0x38430(%rsp,%r15,1),%edx
mov    %rbx,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %r12d,%edx
shl    $0x3,%edx
lea    0x7(,%r12,8),%ecx
mov    %rbx,%rdi
lea    0xa42(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
lea    0x1(%r13),%rax
mov    0x8(%rsp),%rcx
movslq 0x4(%rcx),%rcx
add    $0x8,%r14d
cmp    %rcx,%r13
mov    %rax,%r13
jge    2680 <main+0x1460>
lea    0x1f(%r13),%eax
test   %r13d,%r13d
cmovns %r13d,%eax
and    $0xffffffe0,%eax
mov    %r13d,%r12d
sub    %eax,%r12d
jne    2730 <main+0x1510>
mov    0x8(%rsp),%rax
movslq (%rax),%rax
cmp    %rax,%r13
jle    2730 <main+0x1510>
mov    %rbx,%rdi
lea    0x9d0(%rip),%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   10b0 <fprintf@plt>
jmp    2730 <main+0x1510>
test   %eax,%eax
js     28a5 <main+0x1685>
mov    $0xa,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
xor    %ebp,%ebp
lea    0x434(%rsp),%r15
mov    0x1c(%rsp),%eax
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
mov    %ebp,%edx
movslq %ebp,%rcx
lea    (%r15,%rcx,4),%rsi
mov    $0x1fff,%edi
sub    %rcx,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %rcx,%rdi
je     2900 <main+0x16e0>
lea    0x1(%rcx),%rbp
cmp    %eax,(%rsi,%rcx,4)
mov    %rbp,%rcx
je     28e0 <main+0x16c0>
add    %edx,%ebp
test   %eax,%eax
jns    2909 <main+0x16e9>
jmp    2919 <main+0x16f9>
nopl   0x0(%rax)
mov    $0x2000,%ebp
test   %eax,%eax
js     2919 <main+0x16f9>
mov    %eax,%ecx
lea    (%rcx,%rcx,2),%rcx
mov    0x8434(%rsp,%rcx,8),%ebp
add    $0x1,%ebp
mov    %eax,%ecx
not    %ecx
or     %ecx,%edx
mov    $0x1,%ecx
cmove  %r12d,%ecx
cmp    $0xfffffffe,%eax
cmovne %ecx,%r12d
cmp    $0x1fff,%ebp
jg     2946 <main+0x1726>
movslq %ebp,%rax
mov    0x430(%rsp,%rax,4),%eax
jmp    28c0 <main+0x16a0>
lea    0x937(%rip),%rsi
mov    %rbx,%rdi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
lea    0xa57(%rip),%rdi
mov    $0x2,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
test   %r12d,%r12d
je     2993 <main+0x1773>
lea    0x94b(%rip),%rdi
mov    $0x17,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    0x38430(%rsp),%eax
mov    %eax,0x10(%rsp)
xor    %r14d,%r14d
movl   $0x0,0x8(%rsp)
mov    0x1c(%rsp),%ebp
nopl   (%rax)
mov    %r14d,%r13d
movslq %r14d,%rdx
lea    (%r15,%rdx,4),%rax
mov    $0x1fff,%ecx
sub    %rdx,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %rdx,%rcx
je     29f0 <main+0x17d0>
lea    0x1(%rdx),%r14
cmp    %ebp,(%rax,%rdx,4)
mov    %r14,%rdx
je     29d0 <main+0x17b0>
add    %r13d,%r14d
jmp    29f6 <main+0x17d6>
cs nopw 0x0(%rax,%rax,1)
mov    $0x2000,%r14d
mov    %ebp,%r15d
test   %ebp,%ebp
js     2a30 <main+0x1810>
lea    (%r15,%r15,2),%rax
cmp    0x8430(%rsp,%rax,8),%r13d
jne    2cb4 <main+0x1a94>
mov    0x8434(%rsp,%rax,8),%eax
add    $0x1,%eax
cmp    %eax,%r14d
mov    %eax,%r14d
jle    2a39 <main+0x1819>
jmp    2cb4 <main+0x1a94>
cs nopw 0x0(%rax,%rax,1)
cmp    $0xfffffffe,%ebp
je     2b70 <main+0x1950>
test   %r13,%r13
je     2a60 <main+0x1840>
mov    $0x7,%esi
mov    $0x1,%edx
lea    0x895(%rip),%rdi
jmp    2a71 <main+0x1851>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x2,%esi
mov    $0x1,%edx
lea    0x76b(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
test   %ebp,%ebp
js     2a95 <main+0x1875>
lea    (%r15,%r15,2),%rax
mov    0x8438(%rsp,%rax,8),%eax
cmp    $0x1,%eax
je     2af0 <main+0x18d0>
test   %eax,%eax
je     2cb4 <main+0x1a94>
test   %r13,%r13
je     2b90 <main+0x1970>
lea    0x0(,%r13,8),%edx
lea    0x0(,%r14,8),%ecx
mov    %rbx,%rdi
lea    0x868(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0xffffffff,%ebp
lea    0x434(%rsp),%r15
jne    2bba <main+0x199a>
mov    $0xd,%esi
mov    $0x1,%edx
lea    0x883(%rip),%rdi
jmp    2c4c <main+0x1a2c>
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%r13),%eax
cmp    %eax,%r14d
jne    2cb4 <main+0x1a94>
shl    $0x3,%r13d
lea    0x0(,%r14,8),%eax
cmp    %eax,%r13d
jge    2b70 <main+0x1950>
movslq %r13d,%rdx
add    $0x1,%rdx
sub    %r13d,%eax
lea    0x434(%rsp),%r15
mov    0x3842c(%rsp,%rdx,4),%ecx
test   %ecx,%ecx
jne    2c6c <main+0x1a4c>
mov    0x38430(%rsp,%rdx,4),%ecx
test   %ecx,%ecx
jne    2c7c <main+0x1a5c>
mov    0x38434(%rsp,%rdx,4),%ecx
test   %ecx,%ecx
jne    2c72 <main+0x1a52>
mov    0x38438(%rsp,%rdx,4),%ecx
test   %ecx,%ecx
jne    2c78 <main+0x1a58>
add    $0x4,%rdx
add    $0xfffffffc,%eax
jne    2b20 <main+0x1900>
jmp    2c54 <main+0x1a34>
nopw   0x0(%rax,%rax,1)
lea    0x434(%rsp),%r15
cmp    $0x1fff,%r14d
jle    2c5d <main+0x1a3d>
jmp    2c96 <main+0x1a76>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%r14,8),%edx
mov    %rbx,%rdi
lea    0x76d(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0xffffffff,%ebp
lea    0x434(%rsp),%r15
je     2c3b <main+0x1a1b>
movslq %ebp,%rax
lea    (%rax,%rax,2),%rbp
mov    0x8440(%rsp,%rbp,8),%rcx
mov    %rbx,%rdi
lea    0x79f(%rip),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmpl   $0x0,0x8430(%rsp,%rbp,8)
jle    2c02 <main+0x19e2>
lea    0x0(,%r13,8),%edx
mov    %rbx,%rdi
lea    0x78d(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0x3,%esi
mov    $0x1,%edx
lea    0x558(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
or     0x10(%rsp),%r13d
mov    $0x1,%eax
mov    0x8(%rsp),%ecx
cmove  %eax,%ecx
mov    %ecx,0x8(%rsp)
cmp    $0x1fff,%r14d
jle    2c5d <main+0x1a3d>
jmp    2c96 <main+0x1a76>
mov    $0x22,%esi
mov    $0x1,%edx
lea    0x6f5(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
cmp    $0x1fff,%r14d
jg     2c96 <main+0x1a76>
movslq %r14d,%rax
mov    0x430(%rsp,%rax,4),%ebp
jmp    29b0 <main+0x1790>
add    $0xffffffffffffffff,%rdx
jmp    2c7c <main+0x1a5c>
add    $0x1,%rdx
jmp    2c7c <main+0x1a5c>
add    $0x2,%rdx
mov    %rbx,%rdi
lea    0x666(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0x1fff,%r14d
jle    2c5d <main+0x1a3d>
test   %r12d,%r12d
je     2d1f <main+0x1aff>
cmpl   $0x0,0x8(%rsp)
jne    2cbb <main+0x1a9b>
lea    0x6ff(%rip),%rdi
mov    $0x10,%esi
jmp    2cc7 <main+0x1aa7>
xor    %eax,%eax
call   1030 <abort@plt>
lea    0x6ce(%rip),%rdi
mov    $0x1b,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x6e2(%rip),%rdi
mov    $0xc,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x6d6(%rip),%rdi
mov    $0xe,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x652(%rip),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x48d(%rip),%rdi
mov    $0x14,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x622(%rip),%rdi
mov    $0x2,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    %rbx,%rdi
call   1050 <ferror@plt>
test   %rax,%rax
jne    1732 <main+0x512>
mov    %rbx,%rdi
call   1060 <fclose@plt>
test   %rax,%rax
jne    1732 <main+0x512>
xor    %edi,%edi
call   1120 <exit@plt>

LLVM IR (-O0):
%struct.anon = type { i32, i32 }
%struct.anon.0 = type { i32, i32, i32, i8* }
@.str = [3 x i8] c".h\00"
@.str.1 = [1 x i8] zeroinitializer
@stderr = global i32 0
@.str.2 = [15 x i8] c"Creating %s%s\0A\00"
@stdin = global i32 0
@EOF = global i32 0
@.str.3 = [5 x i8] c"0x%x\00"
@.str.4 = [3 x i8] c"%x\00"
@.str.5 = [2 x i8] c"w\00"
@.str.6 = [2 x i8] c"\0A\00"
@.str.7 = [4 x i8] c"/*\0A\00"
@.str.8 = [7 x i8] c" * %s\0A\00"
@.str.9 = [5 x i8] c" */\0A\00"
@.str.10 = [36 x i8] c"static const unsigned short %s_2uni\00"
@.str.11 = [4 x i8] c"_%d\00"
@.str.12 = [10 x i8] c"[%d] = {\0A\00"
@.str.13 = [16 x i8] c" /* 0x%02x */\0A\00"
@.str.14 = [2 x i8] c" \00"
@.str.15 = [9 x i8] c" 0x%04x,\00"
@.str.16 = [4 x i8] c"};\0A\00"
@.str.17 = [80 x i8] c"static int\0A%s_mbtowc (conv_t conv, ucs4_t *pwc, const unsigned char *s, int n)\0A\00"
@.str.18 = [3 x i8] c"{\0A\00"
@.str.19 = [25 x i8] c" unsigned char c = *s;\0A\00"
@.str.20 = [3 x i8] c" \00"
@.str.21 = [5 x i8] c" \00"
@.str.22 = [21 x i8] c" if (c < 0x%02x) {\0A\00"
@.str.23 = [10 x i8] c" else {\0A\00"
@.str.24 = [26 x i8] c" else if (c < 0x%02x) {\0A\00"
@.str.25 = [22 x i8] c"%s*pwc = (ucs4_t) c;\0A\00"
@.str.26 = [13 x i8] c"%sreturn 1;\0A\00"
@.str.27 = [3 x i8] c"%s\00"
@.str.28 = [21 x i8] c"unsigned short wc = \00"
@.str.29 = [17 x i8] c"*pwc = (ucs4_t) \00"
@.str.30 = [8 x i8] c"%s_2uni\00"
@.str.31 = [3 x i8] c"[c\00"
@.str.32 = [8 x i8] c"-0x%02x\00"
@.str.33 = [4 x i8] c"];\0A\00"
@.str.34 = [23 x i8] c"%sif (wc != 0xfffd) {\0A\00"
@.str.35 = [25 x i8] c"%s *pwc = (ucs4_t) wc;\0A\00"
@.str.36 = [15 x i8] c"%s return 1;\0A\00"
@.str.37 = [5 x i8] c"%s}\0A\00"
@.str.38 = [5 x i8] c" }\0A\00"
@.str.39 = [21 x i8] c" return RET_ILSEQ;\0A\00"
@.str.40 = [23 x i8] c" if (c < 0x%02x)\0A \00"
@.str.41 = [12 x i8] c" else\0A \00"
@.str.42 = [28 x i8] c" else if (c < 0x%02x)\0A \00"
@.str.43 = [20 x i8] c"*pwc = (ucs4_t) c;\0A\00"
@.str.44 = [24 x i8] c"*pwc = (ucs4_t) %s_2uni\00"
@.str.45 = [13 x i8] c" return 1;\0A\00"
@.str.46 = [3 x i8] c"}\0A\00"
@.str.47 = [8 x i8] c"%02x_%d\00"
@.str.48 = [5 x i8] c"%02x\00"
@.str.49 = [46 x i8] c"static const unsigned char %s_page%s[%d] = {\0A\00"
@.str.50 = [16 x i8] c" /* 0x%04x */\0A\00"
@.str.51 = [9 x i8] c" 0x%02x,\00"
@.str.52 = [22 x i8] c" /* 0x%02x-0x%02x */\0A\00"
@.str.53 = [72 x i8] c"static int\0A%s_wctomb (conv_t conv, unsigned char *r, ucs4_t wc, int n)\0A\00"
@.str.54 = [24 x i8] c" unsigned char c = 0;\0A\00"
@.str.55 = [8 x i8] c" else \00"
@.str.56 = [35 x i8] c"if (wc == 0x%04x)\0A c = 0x%02x;\0A\00"
@.str.57 = [17 x i8] c"if (wc < 0x%04x)\00"
@.str.58 = [33 x i8] c"if (wc >= 0x%04x && wc < 0x%04x)\00"
@.str.59 = [35 x i8] c" {\0A *r = wc;\0A return 1;\0A }\0A\00"
@.str.60 = [14 x i8] c"\0A c = wc;\0A\00"
@.str.61 = [22 x i8] c"\0A c = %s_page%s[wc\00"
@.str.62 = [8 x i8] c"-0x%04x\00"
@.str.63 = [28 x i8] c" if (c != 0 || wc == 0) {\0A\00"
@.str.64 = [17 x i8] c" if (c != 0) {\0A\00"
@.str.65 = [13 x i8] c" *r = c;\0A\00"
@.str.66 = [15 x i8] c" return 1;\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca [256 x i32]
%11 = alloca i8*
%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 [16 x i32]
%21 = alloca i32
%22 = alloca [16 x %struct.anon]
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i8*
%30 = alloca i32
%31 = alloca [65536 x i32]
%32 = alloca [256 x i32]
%33 = alloca [8192 x i32]
%34 = alloca i32
%35 = alloca [8192 x %struct.anon.0]
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i8*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%47 = load i32, i32* %4
%48 = icmp ne i32 %47, 3
br i1 %48, label %49, label %57
49: ; preds = %2
%50 = load i32, i32* %4
%51 = icmp ne i32 %50, 4
br i1 %51, label %52, label %57
52: ; preds = %49
%53 = load i32, i32* %4
%54 = icmp ne i32 %53, 5
br i1 %54, label %55, label %57
55: ; preds = %52
%56 = call i32 @exit(i32 1)
unreachable
57: ; preds = %52, %49, %2
%58 = load i8**, i8*** %5
%59 = getelementptr inbounds i8*, i8** %58, i64 1
%60 = load i8*, i8** %59
store i8* %60, i8** %6
%61 = load i8**, i8*** %5
%62 = getelementptr inbounds i8*, i8** %61, i64 2
%63 = load i8*, i8** %62
store i8* %63, i8** %7
%64 = load i32, i32* %4
%65 = icmp sgt i32 %64, 3
br i1 %65, label %66, label %70
66: ; preds = %57
%67 = load i8**, i8*** %5
%68 = getelementptr inbounds i8*, i8** %67, i64 3
%69 = load i8*, i8** %68
store i8* %69, i8** %8
br label %83
70: ; preds = %57
%71 = load i8*, i8** %7
%72 = call i32 @strlen(i8* %71)
%73 = call i32 @strlen(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%74 = add nsw i32 %72, %73
%75 = add nsw i32 %74, 1
%76 = call i8* @malloc(i32 %75)
store i8* %76, i8** %11
%77 = load i8*, i8** %11
%78 = load i8*, i8** %7
%79 = call i32 @strcpy(i8* %77, i8* %78)
%80 = load i8*, i8** %11
%81 = call i32 @strcat(i8* %80, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%82 = load i8*, i8** %11
store i8* %82, i8** %8
br label %83
83: ; preds = %70, %66
%84 = load i32, i32* %4
%85 = icmp sgt i32 %84, 4
br i1 %85, label %86, label %90
86: ; preds = %83
%87 = load i8**, i8*** %5
%88 = getelementptr inbounds i8*, i8** %87, i64 4
%89 = load i8*, i8** %88
br label %91
90: ; preds = %83
br label %91
91: ; preds = %90, %86
%92 = phi i8* [ %89, %86 ], [ getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0), %90 ]
store i8* %92, i8** %9
%93 = load i32, i32* @stderr
%94 = sext i32 %93 to i64
%95 = inttoptr i64 %94 to i32*
%96 = load i8*, i8** %9
%97 = load i8*, i8** %8
%98 = call i32 (i32*, i8*, ...) @fprintf(i32* %95, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i8* %96, i8* %97)
%99 = load i32, i32* @stdin
%100 = call i32 @getc(i32 %99)
store i32 %100, i32* %13
%101 = load i32, i32* %13
%102 = load i32, i32* @stdin
%103 = call i32 @ungetc(i32 %101, i32 %102)
%104 = load i32, i32* %13
%105 = icmp eq i32 %104, 35
br i1 %105, label %106, label %204
106: ; preds = %91
store i32 0, i32* %12
br label %107
107: ; preds = %114, %106
%108 = load i32, i32* %12
%109 = icmp slt i32 %108, 256
br i1 %109, label %110, label %117
110: ; preds = %107
%111 = load i32, i32* %12
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %112
store i32 65533, i32* %113
br label %114
114: ; preds = %110
%115 = load i32, i32* %12
%116 = add nsw i32 %115, 1
store i32 %116, i32* %12
br label %107
117: ; preds = %107
br label %118
118: ; preds = %202, %193, %152, %134, %117
%119 = load i32, i32* @stdin
%120 = call i32 @getc(i32 %119)
store i32 %120, i32* %13
%121 = load i32, i32* %13
%122 = load i32, i32* @EOF
%123 = icmp eq i32 %121, %122
br i1 %123, label %124, label %125
124: ; preds = %118
br label %203
125: ; preds = %118
%126 = load i32, i32* %13
%127 = icmp eq i32 %126, 10
br i1 %127, label %134, label %128
128: ; preds = %125
%129 = load i32, i32* %13
%130 = icmp eq i32 %129, 32
br i1 %130, label %134, label %131
131: ; preds = %128
%132 = load i32, i32* %13
%133 = icmp eq i32 %132, 9
br i1 %133, label %134, label %135
134: ; preds = %131, %128, %125
br label %118
135: ; preds = %131
%136 = load i32, i32* %13
%137 = icmp eq i32 %136, 35
br i1 %137, label %138, label %153
138: ; preds = %135
br label %139
139: ; preds = %149, %138
%140 = load i32, i32* @stdin
%141 = call i32 @getc(i32 %140)
store i32 %141, i32* %13
br label %142
142: ; preds = %139
%143 = load i32, i32* %13
%144 = load i32, i32* @EOF
%145 = icmp eq i32 %143, %144
br i1 %145, label %149, label %146
146: ; preds = %142
%147 = load i32, i32* %13
%148 = icmp eq i32 %147, 10
br label %149
149: ; preds = %146, %142
%150 = phi i1 [ true, %142 ], [ %148, %146 ]
%151 = xor i1 %150, true
br i1 %151, label %139, label %152
152: ; preds = %149
br label %118
153: ; preds = %135
%154 = load i32, i32* %13
%155 = load i32, i32* @stdin
%156 = call i32 @ungetc(i32 %154, i32 %155)
%157 = call i32 @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32* %12)
%158 = icmp ne i32 %157, 1
br i1 %158, label %165, label %159
159: ; preds = %153
%160 = load i32, i32* %12
%161 = icmp sge i32 %160, 0
br i1 %161, label %162, label %165
162: ; preds = %159
%163 = load i32, i32* %12
%164 = icmp slt i32 %163, 256
br i1 %164, label %167, label %165
165: ; preds = %162, %159, %153
%166 = call i32 @exit(i32 1)
unreachable
167: ; preds = %162
br label %168
168: ; preds = %177, %167
%169 = load i32, i32* @stdin
%170 = call i32 @getc(i32 %169)
store i32 %170, i32* %13
br label %171
171: ; preds = %168
%172 = load i32, i32* %13
%173 = icmp eq i32 %172, 32
br i1 %173, label %177, label %174
174: ; preds = %171
%175 = load i32, i32* %13
%176 = icmp eq i32 %175, 9
br label %177
177: ; preds = %174, %171
%178 = phi i1 [ true, %171 ], [ %176, %174 ]
br i1 %178, label %168, label %179
179: ; preds = %177
%180 = load i32, i32* %13
%181 = load i32, i32* @EOF
%182 = icmp ne i32 %180, %181
br i1 %182, label %183, label %187
183: ; preds = %179
%184 = load i32, i32* %13
%185 = load i32, i32* @stdin
%186 = call i32 @ungetc(i32 %184, i32 %185)
br label %187
187: ; preds = %183, %179
%188 = load i32, i32* %13
%189 = icmp eq i32 %188, 10
br i1 %189, label %193, label %190
190: ; preds = %187
%191 = load i32, i32* %13
%192 = icmp eq i32 %191, 35
br i1 %192, label %193, label %194
193: ; preds = %190, %187
br label %118
194: ; preds = %190
%195 = load i32, i32* %12
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %196
%198 = call i32 @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32* %197)
%199 = icmp ne i32 %198, 1
br i1 %199, label %200, label %202
200: ; preds = %194
%201 = call i32 @exit(i32 1)
unreachable
202: ; preds = %194
br label %118
203: ; preds = %124
br label %243
204: ; preds = %91
store i32 0, i32* %12
br label %205
205: ; preds = %233, %204
%206 = load i32, i32* %12
%207 = icmp slt i32 %206, 256
br i1 %207, label %208, label %236
208: ; preds = %205
%209 = load i32, i32* %12
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %210
%212 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %211)
%213 = icmp ne i32 %212, 1
br i1 %213, label %214, label %216
214: ; preds = %208
%215 = call i32 @exit(i32 1)
unreachable
216: ; preds = %208
%217 = load i32, i32* %12
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %218
%220 = load i32, i32* %219
%221 = icmp slt i32 %220, 0
br i1 %221, label %228, label %222
222: ; preds = %216
%223 = load i32, i32* %12
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %224
%226 = load i32, i32* %225
%227 = icmp eq i32 %226, 65535
br i1 %227, label %228, label %232
228: ; preds = %222, %216
%229 = load i32, i32* %12
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %230
store i32 65533, i32* %231
br label %232
232: ; preds = %228, %222
br label %233
233: ; preds = %232
%234 = load i32, i32* %12
%235 = add nsw i32 %234, 1
store i32 %235, i32* %12
br label %205
236: ; preds = %205
%237 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %12)
%238 = load i32, i32* @EOF
%239 = icmp ne i32 %237, %238
br i1 %239, label %240, label %242
240: ; preds = %236
%241 = call i32 @exit(i32 1)
unreachable
242: ; preds = %236
br label %243
243: ; preds = %242, %203
%244 = load i8*, i8** %9
%245 = call i32 @strlen(i8* %244)
%246 = load i8*, i8** %8
%247 = call i32 @strlen(i8* %246)
%248 = add nsw i32 %245, %247
%249 = add nsw i32 %248, 1
%250 = call i8* @malloc(i32 %249)
store i8* %250, i8** %15
%251 = load i8*, i8** %15
%252 = load i8*, i8** %9
%253 = call i32 @strcpy(i8* %251, i8* %252)
%254 = load i8*, i8** %15
%255 = load i8*, i8** %8
%256 = call i32 @strcat(i8* %254, i8* %255)
%257 = load i8*, i8** %15
%258 = call i32* @fopen(i8* %257, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i32* %258, i32** %14
%259 = load i32*, i32** %14
%260 = icmp eq i32* %259, null
br i1 %260, label %261, label %263
261: ; preds = %243
%262 = call i32 @exit(i32 1)
unreachable
263: ; preds = %243
%264 = load i32*, i32** %14
%265 = call i32 (i32*, i8*, ...) @fprintf(i32* %264, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
%266 = load i32*, i32** %14
%267 = call i32 (i32*, i8*, ...) @fprintf(i32* %266, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%268 = load i32*, i32** %14
%269 = load i8*, i8** %6
%270 = call i32 (i32*, i8*, ...) @fprintf(i32* %268, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0), i8* %269)
%271 = load i32*, i32** %14
%272 = call i32 (i32*, i8*, ...) @fprintf(i32* %271, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0))
%273 = load i32*, i32** %14
%274 = call i32 (i32*, i8*, ...) @fprintf(i32* %273, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %17
br label %275
275: ; preds = %325, %263
%276 = load i32, i32* %17
%277 = icmp slt i32 %276, 16
br i1 %277, label %278, label %328
278: ; preds = %275
store i32 1, i32* %25
store i32 1, i32* %26
store i32 0, i32* %18
br label %279
279: ; preds = %302, %278
%280 = load i32, i32* %18
%281 = icmp slt i32 %280, 16
br i1 %281, label %282, label %305
282: ; preds = %279
%283 = load i32, i32* %17
%284 = mul nsw i32 16, %283
%285 = load i32, i32* %18
%286 = add nsw i32 %284, %285
store i32 %286, i32* %16
%287 = load i32, i32* %16
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %288
%290 = load i32, i32* %289
%291 = icmp ne i32 %290, 65533
br i1 %291, label %292, label %293
292: ; preds = %282
store i32 0, i32* %25
br label %293
293: ; preds = %292, %282
%294 = load i32, i32* %16
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %295
%297 = load i32, i32* %296
%298 = load i32, i32* %16
%299 = icmp ne i32 %297, %298
br i1 %299, label %300, label %301
300: ; preds = %293
store i32 0, i32* %26
br label %301
301: ; preds = %300, %293
br label %302
302: ; preds = %301
%303 = load i32, i32* %18
%304 = add nsw i32 %303, 1
store i32 %304, i32* %18
br label %279
305: ; preds = %279
%306 = load i32, i32* %25
%307 = icmp ne i32 %306, 0
br i1 %307, label %308, label %312
308: ; preds = %305
%309 = load i32, i32* %17
%310 = sext i32 %309 to i64
%311 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %310
store i32 -2, i32* %311
br label %324
312: ; preds = %305
%313 = load i32, i32* %26
%314 = icmp ne i32 %313, 0
br i1 %314, label %315, label %319
315: ; preds = %312
%316 = load i32, i32* %17
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %317
store i32 -1, i32* %318
br label %323
319: ; preds = %312
%320 = load i32, i32* %17
%321 = sext i32 %320 to i64
%322 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %321
store i32 0, i32* %322
br label %323
323: ; preds = %319, %315
br label %324
324: ; preds = %323, %308
br label %325
325: ; preds = %324
%326 = load i32, i32* %17
%327 = add nsw i32 %326, 1
store i32 %327, i32* %17
br label %275
328: ; preds = %275
store i32 0, i32* %21
store i32 0, i32* %17
br label %329
329: ; preds = %386, %328
%330 = load i32, i32* %17
%331 = icmp slt i32 %330, 16
br i1 %331, label %332, label %389
332: ; preds = %329
%333 = load i32, i32* %17
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %334
%336 = load i32, i32* %335
%337 = icmp sge i32 %336, 0
br i1 %337, label %338, label %385
338: ; preds = %332
%339 = load i32, i32* %17
%340 = icmp sgt i32 %339, 0
br i1 %340, label %341, label %365
341: ; preds = %338
%342 = load i32, i32* %21
%343 = icmp sgt i32 %342, 0
br i1 %343, label %344, label %365
344: ; preds = %341
%345 = load i32, i32* %17
%346 = sub nsw i32 %345, 1
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %347
%349 = load i32, i32* %348
%350 = load i32, i32* %21
%351 = sub nsw i32 %350, 1
%352 = icmp eq i32 %349, %351
br i1 %352, label %353, label %365
353: ; preds = %344
%354 = load i32, i32* %21
%355 = sub nsw i32 %354, 1
%356 = load i32, i32* %17
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %357
store i32 %355, i32* %358
%359 = load i32, i32* %17
%360 = load i32, i32* %21
%361 = sub nsw i32 %360, 1
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %362
%364 = getelementptr inbounds %struct.anon, %struct.anon* %363, i32 0, i32 1
store i32 %359, i32* %364
br label %384
365: ; preds = %344, %341, %338
%366 = load i32, i32* %21
%367 = add nsw i32 %366, 1
store i32 %367, i32* %21
%368 = load i32, i32* %21
%369 = sub nsw i32 %368, 1
%370 = load i32, i32* %17
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %371
store i32 %369, i32* %372
%373 = load i32, i32* %17
%374 = load i32, i32* %21
%375 = sub nsw i32 %374, 1
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %376
%378 = getelementptr inbounds %struct.anon, %struct.anon* %377, i32 0, i32 1
store i32 %373, i32* %378
%379 = load i32, i32* %21
%380 = sub nsw i32 %379, 1
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %381
%383 = getelementptr inbounds %struct.anon, %struct.anon* %382, i32 0, i32 0
store i32 %373, i32* %383
br label %384
384: ; preds = %365, %353
br label %385
385: ; preds = %384, %332
br label %386
386: ; preds = %385
%387 = load i32, i32* %17
%388 = add nsw i32 %387, 1
store i32 %388, i32* %17
br label %329
389: ; preds = %329
store i32 0, i32* %23
store i32 0, i32* %16
br label %390
390: ; preds = %401, %389
%391 = load i32, i32* %16
%392 = icmp slt i32 %391, 256
br i1 %392, label %393, label %404
393: ; preds = %390
%394 = load i32, i32* %16
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %395
%397 = load i32, i32* %396
%398 = icmp eq i32 %397, 65533
br i1 %398, label %399, label %400
399: ; preds = %393
store i32 1, i32* %23
br label %400
400: ; preds = %399, %393
br label %401
401: ; preds = %400
%402 = load i32, i32* %16
%403 = add nsw i32 %402, 1
store i32 %403, i32* %16
br label %390
404: ; preds = %390
%405 = load i32, i32* %21
%406 = icmp sgt i32 %405, 0
br i1 %406, label %407, label %502
407: ; preds = %404
store i32 0, i32* %27
br label %408
408: ; preds = %496, %407
%409 = load i32, i32* %27
%410 = load i32, i32* %21
%411 = icmp slt i32 %409, %410
br i1 %411, label %412, label %499
412: ; preds = %408
%413 = load i32*, i32** %14
%414 = load i8*, i8** %7
%415 = call i32 (i32*, i8*, ...) @fprintf(i32* %413, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.10, i64 0, i64 0), i8* %414)
%416 = load i32, i32* %21
%417 = icmp sgt i32 %416, 1
br i1 %417, label %418, label %423
418: ; preds = %412
%419 = load i32*, i32** %14
%420 = load i32, i32* %27
%421 = add nsw i32 %420, 1
%422 = call i32 (i32*, i8*, ...) @fprintf(i32* %419, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i32 %421)
br label %423
423: ; preds = %418, %412
%424 = load i32*, i32** %14
%425 = load i32, i32* %27
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %426
%428 = getelementptr inbounds %struct.anon, %struct.anon* %427, i32 0, i32 1
%429 = load i32, i32* %428
%430 = load i32, i32* %27
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %431
%433 = getelementptr inbounds %struct.anon, %struct.anon* %432, i32 0, i32 0
%434 = load i32, i32* %433
%435 = sub nsw i32 %429, %434
%436 = add nsw i32 %435, 1
%437 = mul nsw i32 16, %436
%438 = call i32 (i32*, i8*, ...) @fprintf(i32* %424, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0), i32 %437)
%439 = load i32, i32* %27
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %440
%442 = getelementptr inbounds %struct.anon, %struct.anon* %441, i32 0, i32 0
%443 = load i32, i32* %442
store i32 %443, i32* %17
br label %444
444: ; preds = %490, %423
%445 = load i32, i32* %17
%446 = load i32, i32* %27
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %447
%449 = getelementptr inbounds %struct.anon, %struct.anon* %448, i32 0, i32 1
%450 = load i32, i32* %449
%451 = icmp sle i32 %445, %450
br i1 %451, label %452, label %493
452: ; preds = %444
%453 = load i32*, i32** %14
%454 = load i32, i32* %17
%455 = mul nsw i32 16, %454
%456 = call i32 (i32*, i8*, ...) @fprintf(i32* %453, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.13, i64 0, i64 0), i32 %455)
store i32 0, i32* %18
br label %457
457: ; preds = %486, %452
%458 = load i32, i32* %18
%459 = icmp slt i32 %458, 2
br i1 %459, label %460, label %489
460: ; preds = %457
%461 = load i32*, i32** %14
%462 = call i32 (i32*, i8*, ...) @fprintf(i32* %461, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
store i32 0, i32* %19
br label %463
463: ; preds = %480, %460
%464 = load i32, i32* %19
%465 = icmp slt i32 %464, 8
br i1 %465, label %466, label %483
466: ; preds = %463
%467 = load i32, i32* %17
%468 = mul nsw i32 16, %467
%469 = load i32, i32* %18
%470 = mul nsw i32 8, %469
%471 = add nsw i32 %468, %470
%472 = load i32, i32* %19
%473 = add nsw i32 %471, %472
store i32 %473, i32* %16
%474 = load i32*, i32** %14
%475 = load i32, i32* %16
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %476
%478 = load i32, i32* %477
%479 = call i32 (i32*, i8*, ...) @fprintf(i32* %474, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %478)
br label %480
480: ; preds = %466
%481 = load i32, i32* %19
%482 = add nsw i32 %481, 1
store i32 %482, i32* %19
br label %463
483: ; preds = %463
%484 = load i32*, i32** %14
%485 = call i32 (i32*, i8*, ...) @fprintf(i32* %484, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %486
486: ; preds = %483
%487 = load i32, i32* %18
%488 = add nsw i32 %487, 1
store i32 %488, i32* %18
br label %457
489: ; preds = %457
br label %490
490: ; preds = %489
%491 = load i32, i32* %17
%492 = add nsw i32 %491, 1
store i32 %492, i32* %17
br label %444
493: ; preds = %444
%494 = load i32*, i32** %14
%495 = call i32 (i32*, i8*, ...) @fprintf(i32* %494, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.16, i64 0, i64 0))
br label %496
496: ; preds = %493
%497 = load i32, i32* %27
%498 = add nsw i32 %497, 1
store i32 %498, i32* %27
br label %408
499: ; preds = %408
%500 = load i32*, i32** %14
%501 = call i32 (i32*, i8*, ...) @fprintf(i32* %500, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %502
502: ; preds = %499, %404
store i32 0, i32* %24
%503 = load i32*, i32** %14
%504 = load i8*, i8** %7
%505 = call i32 (i32*, i8*, ...) @fprintf(i32* %503, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.17, i64 0, i64 0), i8* %504)
%506 = load i32*, i32** %14
%507 = call i32 (i32*, i8*, ...) @fprintf(i32* %506, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.18, i64 0, i64 0))
%508 = load i32*, i32** %14
%509 = call i32 (i32*, i8*, ...) @fprintf(i32* %508, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.19, i64 0, i64 0))
%510 = load i32, i32* %23
%511 = icmp ne i32 %510, 0
br i1 %511, label %512, label %688
512: ; preds = %502
store i32 0, i32* %17
br label %513
513: ; preds = %679, %512
%514 = load i32, i32* %17
%515 = icmp slt i32 %514, 16
br i1 %515, label %516, label %681
516: ; preds = %513
%517 = load i32, i32* %17
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %518
%520 = load i32, i32* %519
store i32 %520, i32* %28
%521 = load i32, i32* %17
store i32 %521, i32* %18
br label %522
522: ; preds = %535, %516
%523 = load i32, i32* %18
%524 = icmp slt i32 %523, 16
br i1 %524, label %525, label %532
525: ; preds = %522
%526 = load i32, i32* %18
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %527
%529 = load i32, i32* %528
%530 = load i32, i32* %28
%531 = icmp eq i32 %529, %530
br label %532
532: ; preds = %525, %522
%533 = phi i1 [ false, %522 ], [ %531, %525 ]
br i1 %533, label %534, label %538
534: ; preds = %532
br label %535
535: ; preds = %534
%536 = load i32, i32* %18
%537 = add nsw i32 %536, 1
store i32 %537, i32* %18
br label %522
538: ; preds = %532
%539 = load i32, i32* %17
%540 = icmp eq i32 %539, 0
br i1 %540, label %541, label %544
541: ; preds = %538
%542 = load i32, i32* %18
%543 = icmp eq i32 %542, 16
br label %544
544: ; preds = %541, %538
%545 = phi i1 [ false, %538 ], [ %543, %541 ]
%546 = zext i1 %545 to i64
%547 = select i1 %545, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.21, i64 0, i64 0)
store i8* %547, i8** %29
%548 = load i32, i32* %17
%549 = icmp eq i32 %548, 0
br i1 %549, label %550, label %560
550: ; preds = %544
%551 = load i32, i32* %18
%552 = icmp eq i32 %551, 16
br i1 %552, label %553, label %554
553: ; preds = %550
br label %559
554: ; preds = %550
%555 = load i32*, i32** %14
%556 = load i32, i32* %18
%557 = mul nsw i32 16, %556
%558 = call i32 (i32*, i8*, ...) @fprintf(i32* %555, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.22, i64 0, i64 0), i32 %557)
br label %559
559: ; preds = %554, %553
br label %572
560: ; preds = %544
%561 = load i32, i32* %18
%562 = icmp eq i32 %561, 16
br i1 %562, label %563, label %566
563: ; preds = %560
%564 = load i32*, i32** %14
%565 = call i32 (i32*, i8*, ...) @fprintf(i32* %564, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.23, i64 0, i64 0))
br label %571
566: ; preds = %560
%567 = load i32*, i32** %14
%568 = load i32, i32* %18
%569 = mul nsw i32 16, %568
%570 = call i32 (i32*, i8*, ...) @fprintf(i32* %567, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.24, i64 0, i64 0), i32 %569)
br label %571
571: ; preds = %566, %563
br label %572
572: ; preds = %571, %559
%573 = load i32, i32* %28
%574 = icmp eq i32 %573, -2
br i1 %574, label %575, label %576
575: ; preds = %572
store i32 1, i32* %24
br label %670
576: ; preds = %572
%577 = load i32, i32* %28
%578 = icmp eq i32 %577, -1
br i1 %578, label %579, label %586
579: ; preds = %576
%580 = load i32*, i32** %14
%581 = load i8*, i8** %29
%582 = call i32 (i32*, i8*, ...) @fprintf(i32* %580, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.25, i64 0, i64 0), i8* %581)
%583 = load i32*, i32** %14
%584 = load i8*, i8** %29
%585 = call i32 (i32*, i8*, ...) @fprintf(i32* %583, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.26, i64 0, i64 0), i8* %584)
br label %669
586: ; preds = %576
%587 = load i32*, i32** %14
%588 = load i8*, i8** %29
%589 = call i32 (i32*, i8*, ...) @fprintf(i32* %587, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.27, i64 0, i64 0), i8* %588)
store i32 0, i32* %23
%590 = load i32, i32* %17
%591 = mul nsw i32 16, %590
store i32 %591, i32* %16
br label %592
592: ; preds = %605, %586
%593 = load i32, i32* %16
%594 = load i32, i32* %18
%595 = mul nsw i32 16, %594
%596 = icmp slt i32 %593, %595
br i1 %596, label %597, label %608
597: ; preds = %592
%598 = load i32, i32* %16
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %599
%601 = load i32, i32* %600
%602 = icmp eq i32 %601, 65533
br i1 %602, label %603, label %604
603: ; preds = %597
store i32 1, i32* %23
br label %604
604: ; preds = %603, %597
br label %605
605: ; preds = %604
%606 = load i32, i32* %16
%607 = add nsw i32 %606, 1
store i32 %607, i32* %16
br label %592
608: ; preds = %592
%609 = load i32, i32* %23
%610 = icmp ne i32 %609, 0
br i1 %610, label %611, label %614
611: ; preds = %608
%612 = load i32*, i32** %14
%613 = call i32 (i32*, i8*, ...) @fprintf(i32* %612, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.28, i64 0, i64 0))
br label %617
614: ; preds = %608
%615 = load i32*, i32** %14
%616 = call i32 (i32*, i8*, ...) @fprintf(i32* %615, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.29, i64 0, i64 0))
br label %617
617: ; preds = %614, %611
%618 = load i32*, i32** %14
%619 = load i8*, i8** %7
%620 = call i32 (i32*, i8*, ...) @fprintf(i32* %618, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8* %619)
%621 = load i32, i32* %21
%622 = icmp sgt i32 %621, 1
br i1 %622, label %623, label %628
623: ; preds = %617
%624 = load i32*, i32** %14
%625 = load i32, i32* %28
%626 = add nsw i32 %625, 1
%627 = call i32 (i32*, i8*, ...) @fprintf(i32* %624, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i32 %626)
br label %628
628: ; preds = %623, %617
%629 = load i32*, i32** %14
%630 = call i32 (i32*, i8*, ...) @fprintf(i32* %629, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.31, i64 0, i64 0))
%631 = load i32, i32* %28
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %632
%634 = getelementptr inbounds %struct.anon, %struct.anon* %633, i32 0, i32 0
%635 = load i32, i32* %634
%636 = icmp sgt i32 %635, 0
br i1 %636, label %637, label %646
637: ; preds = %628
%638 = load i32*, i32** %14
%639 = load i32, i32* %28
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %640
%642 = getelementptr inbounds %struct.anon, %struct.anon* %641, i32 0, i32 0
%643 = load i32, i32* %642
%644 = mul nsw i32 16, %643
%645 = call i32 (i32*, i8*, ...) @fprintf(i32* %638, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.32, i64 0, i64 0), i32 %644)
br label %646
646: ; preds = %637, %628
%647 = load i32*, i32** %14
%648 = call i32 (i32*, i8*, ...) @fprintf(i32* %647, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.33, i64 0, i64 0))
%649 = load i32, i32* %23
%650 = icmp ne i32 %649, 0
br i1 %650, label %651, label %664
651: ; preds = %646
%652 = load i32*, i32** %14
%653 = load i8*, i8** %29
%654 = call i32 (i32*, i8*, ...) @fprintf(i32* %652, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.34, i64 0, i64 0), i8* %653)
%655 = load i32*, i32** %14
%656 = load i8*, i8** %29
%657 = call i32 (i32*, i8*, ...) @fprintf(i32* %655, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.35, i64 0, i64 0), i8* %656)
%658 = load i32*, i32** %14
%659 = load i8*, i8** %29
%660 = call i32 (i32*, i8*, ...) @fprintf(i32* %658, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.36, i64 0, i64 0), i8* %659)
%661 = load i32*, i32** %14
%662 = load i8*, i8** %29
%663 = call i32 (i32*, i8*, ...) @fprintf(i32* %661, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.37, i64 0, i64 0), i8* %662)
store i32 1, i32* %24
br label %668
664: ; preds = %646
%665 = load i32*, i32** %14
%666 = load i8*, i8** %29
%667 = call i32 (i32*, i8*, ...) @fprintf(i32* %665, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.26, i64 0, i64 0), i8* %666)
br label %668
668: ; preds = %664, %651
br label %669
669: ; preds = %668, %579
br label %670
670: ; preds = %669, %575
%671 = load i32, i32* %17
%672 = icmp eq i32 %671, 0
br i1 %672, label %673, label %676
673: ; preds = %670
%674 = load i32, i32* %18
%675 = icmp eq i32 %674, 16
br i1 %675, label %679, label %676
676: ; preds = %673, %670
%677 = load i32*, i32** %14
%678 = call i32 (i32*, i8*, ...) @fprintf(i32* %677, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.38, i64 0, i64 0))
br label %679
679: ; preds = %676, %673
%680 = load i32, i32* %18
store i32 %680, i32* %17
br label %513
681: ; preds = %513
%682 = load i32, i32* %24
%683 = icmp ne i32 %682, 0
br i1 %683, label %684, label %687
684: ; preds = %681
%685 = load i32*, i32** %14
%686 = call i32 (i32*, i8*, ...) @fprintf(i32* %685, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.39, i64 0, i64 0))
br label %687
687: ; preds = %684, %681
br label %784
688: ; preds = %502
store i32 0, i32* %17
br label %689
689: ; preds = %779, %688
%690 = load i32, i32* %17
%691 = icmp slt i32 %690, 16
br i1 %691, label %692, label %781
692: ; preds = %689
%693 = load i32, i32* %17
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %694
%696 = load i32, i32* %695
store i32 %696, i32* %30
%697 = load i32, i32* %17
store i32 %697, i32* %18
br label %698
698: ; preds = %711, %692
%699 = load i32, i32* %18
%700 = icmp slt i32 %699, 16
br i1 %700, label %701, label %708
701: ; preds = %698
%702 = load i32, i32* %18
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %703
%705 = load i32, i32* %704
%706 = load i32, i32* %30
%707 = icmp eq i32 %705, %706
br label %708
708: ; preds = %701, %698
%709 = phi i1 [ false, %698 ], [ %707, %701 ]
br i1 %709, label %710, label %714
710: ; preds = %708
br label %711
711: ; preds = %710
%712 = load i32, i32* %18
%713 = add nsw i32 %712, 1
store i32 %713, i32* %18
br label %698
714: ; preds = %708
%715 = load i32, i32* %17
%716 = icmp eq i32 %715, 0
br i1 %716, label %717, label %729
717: ; preds = %714
%718 = load i32, i32* %18
%719 = icmp eq i32 %718, 16
br i1 %719, label %720, label %723
720: ; preds = %717
%721 = load i32*, i32** %14
%722 = call i32 (i32*, i8*, ...) @fprintf(i32* %721, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0))
br label %728
723: ; preds = %717
%724 = load i32*, i32** %14
%725 = load i32, i32* %18
%726 = mul nsw i32 16, %725
%727 = call i32 (i32*, i8*, ...) @fprintf(i32* %724, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.40, i64 0, i64 0), i32 %726)
br label %728
728: ; preds = %723, %720
br label %741
729: ; preds = %714
%730 = load i32, i32* %18
%731 = icmp eq i32 %730, 16
br i1 %731, label %732, label %735
732: ; preds = %729
%733 = load i32*, i32** %14
%734 = call i32 (i32*, i8*, ...) @fprintf(i32* %733, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.41, i64 0, i64 0))
br label %740
735: ; preds = %729
%736 = load i32*, i32** %14
%737 = load i32, i32* %18
%738 = mul nsw i32 16, %737
%739 = call i32 (i32*, i8*, ...) @fprintf(i32* %736, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.42, i64 0, i64 0), i32 %738)
br label %740
740: ; preds = %735, %732
br label %741
741: ; preds = %740, %728
%742 = load i32, i32* %30
%743 = icmp eq i32 %742, -1
br i1 %743, label %744, label %747
744: ; preds = %741
%745 = load i32*, i32** %14
%746 = call i32 (i32*, i8*, ...) @fprintf(i32* %745, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.43, i64 0, i64 0))
br label %779
747: ; preds = %741
%748 = load i32*, i32** %14
%749 = load i8*, i8** %7
%750 = call i32 (i32*, i8*, ...) @fprintf(i32* %748, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.44, i64 0, i64 0), i8* %749)
%751 = load i32, i32* %21
%752 = icmp sgt i32 %751, 1
br i1 %752, label %753, label %758
753: ; preds = %747
%754 = load i32*, i32** %14
%755 = load i32, i32* %30
%756 = add nsw i32 %755, 1
%757 = call i32 (i32*, i8*, ...) @fprintf(i32* %754, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i32 %756)
br label %758
758: ; preds = %753, %747
%759 = load i32*, i32** %14
%760 = call i32 (i32*, i8*, ...) @fprintf(i32* %759, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.31, i64 0, i64 0))
%761 = load i32, i32* %30
%762 = sext i32 %761 to i64
%763 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %762
%764 = getelementptr inbounds %struct.anon, %struct.anon* %763, i32 0, i32 0
%765 = load i32, i32* %764
%766 = icmp sgt i32 %765, 0
br i1 %766, label %767, label %776
767: ; preds = %758
%768 = load i32*, i32** %14
%769 = load i32, i32* %30
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %770
%772 = getelementptr inbounds %struct.anon, %struct.anon* %771, i32 0, i32 0
%773 = load i32, i32* %772
%774 = mul nsw i32 16, %773
%775 = call i32 (i32*, i8*, ...) @fprintf(i32* %768, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.32, i64 0, i64 0), i32 %774)
br label %776
776: ; preds = %767, %758
%777 = load i32*, i32** %14
%778 = call i32 (i32*, i8*, ...) @fprintf(i32* %777, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.33, i64 0, i64 0))
br label %779
779: ; preds = %776, %744
%780 = load i32, i32* %18
store i32 %780, i32* %17
br label %689
781: ; preds = %689
%782 = load i32*, i32** %14
%783 = call i32 (i32*, i8*, ...) @fprintf(i32* %782, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.45, i64 0, i64 0))
br label %784
784: ; preds = %781, %687
%785 = load i32*, i32** %14
%786 = call i32 (i32*, i8*, ...) @fprintf(i32* %785, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.46, i64 0, i64 0))
%787 = load i32*, i32** %14
%788 = call i32 (i32*, i8*, ...) @fprintf(i32* %787, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
store i32 0, i32* %39
br label %789
789: ; preds = %796, %784
%790 = load i32, i32* %39
%791 = icmp slt i32 %790, 65536
br i1 %791, label %792, label %799
792: ; preds = %789
%793 = load i32, i32* %39
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %794
store i32 0, i32* %795
br label %796
796: ; preds = %792
%797 = load i32, i32* %39
%798 = add nsw i32 %797, 1
store i32 %798, i32* %39
br label %789
799: ; preds = %789
store i32 0, i32* %40
br label %800
800: ; preds = %807, %799
%801 = load i32, i32* %40
%802 = icmp slt i32 %801, 256
br i1 %802, label %803, label %810
803: ; preds = %800
%804 = load i32, i32* %40
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds [256 x i32], [256 x i32]* %32, i64 0, i64 %805
store i32 0, i32* %806
br label %807
807: ; preds = %803
%808 = load i32, i32* %40
%809 = add nsw i32 %808, 1
store i32 %809, i32* %40
br label %800
810: ; preds = %800
store i32 0, i32* %38
br label %811
811: ; preds = %831, %810
%812 = load i32, i32* %38
%813 = icmp slt i32 %812, 256
br i1 %813, label %814, label %834
814: ; preds = %811
%815 = load i32, i32* %38
%816 = sext i32 %815 to i64
%817 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %816
%818 = load i32, i32* %817
store i32 %818, i32* %39
%819 = load i32, i32* %39
%820 = icmp ne i32 %819, 65533
br i1 %820, label %821, label %830
821: ; preds = %814
%822 = load i32, i32* %38
%823 = load i32, i32* %39
%824 = sext i32 %823 to i64
%825 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %824
store i32 %822, i32* %825
%826 = load i32, i32* %39
%827 = ashr i32 %826, 8
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds [256 x i32], [256 x i32]* %32, i64 0, i64 %828
store i32 1, i32* %829
br label %830
830: ; preds = %821, %814
br label %831
831: ; preds = %830
%832 = load i32, i32* %38
%833 = add nsw i32 %832, 1
store i32 %833, i32* %38
br label %811
834: ; preds = %811
store i32 0, i32* %41
br label %835
835: ; preds = %885, %834
%836 = load i32, i32* %41
%837 = icmp slt i32 %836, 8192
br i1 %837, label %838, label %888
838: ; preds = %835
store i32 1, i32* %44
store i32 1, i32* %45
store i32 0, i32* %42
br label %839
839: ; preds = %862, %838
%840 = load i32, i32* %42
%841 = icmp slt i32 %840, 8
br i1 %841, label %842, label %865
842: ; preds = %839
%843 = load i32, i32* %41
%844 = mul nsw i32 8, %843
%845 = load i32, i32* %42
%846 = add nsw i32 %844, %845
store i32 %846, i32* %39
%847 = load i32, i32* %39
%848 = sext i32 %847 to i64
%849 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %848
%850 = load i32, i32* %849
%851 = icmp ne i32 %850, 0
br i1 %851, label %852, label %853
852: ; preds = %842
store i32 0, i32* %44
br label %853
853: ; preds = %852, %842
%854 = load i32, i32* %39
%855 = sext i32 %854 to i64
%856 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %855
%857 = load i32, i32* %856
%858 = load i32, i32* %39
%859 = icmp ne i32 %857, %858
br i1 %859, label %860, label %861
860: ; preds = %853
store i32 0, i32* %45
br label %861
861: ; preds = %860, %853
br label %862
862: ; preds = %861
%863 = load i32, i32* %42
%864 = add nsw i32 %863, 1
store i32 %864, i32* %42
br label %839
865: ; preds = %839
%866 = load i32, i32* %44
%867 = icmp ne i32 %866, 0
br i1 %867, label %868, label %872
868: ; preds = %865
%869 = load i32, i32* %41
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %870
store i32 -2, i32* %871
br label %884
872: ; preds = %865
%873 = load i32, i32* %45
%874 = icmp ne i32 %873, 0
br i1 %874, label %875, label %879
875: ; preds = %872
%876 = load i32, i32* %41
%877 = sext i32 %876 to i64
%878 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %877
store i32 -1, i32* %878
br label %883
879: ; preds = %872
%880 = load i32, i32* %41
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %881
store i32 0, i32* %882
br label %883
883: ; preds = %879, %875
br label %884
884: ; preds = %883, %868
br label %885
885: ; preds = %884
%886 = load i32, i32* %41
%887 = add nsw i32 %886, 1
store i32 %887, i32* %41
br label %835
888: ; preds = %835
store i32 0, i32* %34
store i32 0, i32* %41
br label %889
889: ; preds = %967, %888
%890 = load i32, i32* %41
%891 = icmp slt i32 %890, 8192
br i1 %891, label %892, label %970
892: ; preds = %889
%893 = load i32, i32* %41
%894 = sext i32 %893 to i64
%895 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %894
%896 = load i32, i32* %895
%897 = icmp sge i32 %896, 0
br i1 %897, label %898, label %966
898: ; preds = %892
%899 = load i32, i32* %34
%900 = icmp sgt i32 %899, 0
br i1 %900, label %901, label %946
901: ; preds = %898
%902 = load i32, i32* %41
%903 = icmp sgt i32 %902, 0
br i1 %903, label %904, label %913
904: ; preds = %901
%905 = load i32, i32* %41
%906 = sub nsw i32 %905, 1
%907 = sext i32 %906 to i64
%908 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %907
%909 = load i32, i32* %908
%910 = load i32, i32* %34
%911 = sub nsw i32 %910, 1
%912 = icmp eq i32 %909, %911
br i1 %912, label %934, label %913
913: ; preds = %904, %901
%914 = load i32, i32* %34
%915 = sub nsw i32 %914, 1
%916 = sext i32 %915 to i64
%917 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %916
%918 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %917, i32 0, i32 1
%919 = load i32, i32* %918
%920 = ashr i32 %919, 5
%921 = load i32, i32* %41
%922 = ashr i32 %921, 5
%923 = icmp eq i32 %920, %922
br i1 %923, label %924, label %946
924: ; preds = %913
%925 = load i32, i32* %41
%926 = load i32, i32* %34
%927 = sub nsw i32 %926, 1
%928 = sext i32 %927 to i64
%929 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %928
%930 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %929, i32 0, i32 1
%931 = load i32, i32* %930
%932 = sub nsw i32 %925, %931
%933 = icmp sle i32 %932, 8
br i1 %933, label %934, label %946
934: ; preds = %924, %904
%935 = load i32, i32* %34
%936 = sub nsw i32 %935, 1
%937 = load i32, i32* %41
%938 = sext i32 %937 to i64
%939 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %938
store i32 %936, i32* %939
%940 = load i32, i32* %41
%941 = load i32, i32* %34
%942 = sub nsw i32 %941, 1
%943 = sext i32 %942 to i64
%944 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %943
%945 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %944, i32 0, i32 1
store i32 %940, i32* %945
br label %965
946: ; preds = %924, %913, %898
%947 = load i32, i32* %34
%948 = add nsw i32 %947, 1
store i32 %948, i32* %34
%949 = load i32, i32* %34
%950 = sub nsw i32 %949, 1
%951 = load i32, i32* %41
%952 = sext i32 %951 to i64
%953 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %952
store i32 %950, i32* %953
%954 = load i32, i32* %41
%955 = load i32, i32* %34
%956 = sub nsw i32 %955, 1
%957 = sext i32 %956 to i64
%958 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %957
%959 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %958, i32 0, i32 1
store i32 %954, i32* %959
%960 = load i32, i32* %34
%961 = sub nsw i32 %960, 1
%962 = sext i32 %961 to i64
%963 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %962
%964 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %963, i32 0, i32 0
store i32 %954, i32* %964
br label %965
965: ; preds = %946, %934
br label %966
966: ; preds = %965, %892
br label %967
967: ; preds = %966
%968 = load i32, i32* %41
%969 = add nsw i32 %968, 1
store i32 %969, i32* %41
br label %889
970: ; preds = %889
store i32 0, i32* %43
br label %971
971: ; preds = %1016, %970
%972 = load i32, i32* %43
%973 = load i32, i32* %34
%974 = icmp slt i32 %972, %973
br i1 %974, label %975, label %1019
975: ; preds = %971
%976 = load i32, i32* %43
%977 = sext i32 %976 to i64
%978 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %977
%979 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %978, i32 0, i32 2
store i32 0, i32* %979
%980 = load i32, i32* %43
%981 = sext i32 %980 to i64
%982 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %981
%983 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %982, i32 0, i32 0
%984 = load i32, i32* %983
%985 = mul nsw i32 8, %984
store i32 %985, i32* %41
%986 = load i32, i32* %43
%987 = sext i32 %986 to i64
%988 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %987
%989 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %988, i32 0, i32 1
%990 = load i32, i32* %989
%991 = add nsw i32 %990, 1
%992 = mul nsw i32 8, %991
store i32 %992, i32* %42
%993 = load i32, i32* %41
store i32 %993, i32* %39
br label %994
994: ; preds = %1012, %975
%995 = load i32, i32* %39
%996 = load i32, i32* %42
%997 = icmp slt i32 %995, %996
br i1 %997, label %998, label %1015
998: ; preds = %994
%999 = load i32, i32* %39
%1000 = sext i32 %999 to i64
%1001 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %1000
%1002 = load i32, i32* %1001
%1003 = icmp ne i32 %1002, 0
br i1 %1003, label %1004, label %1011
1004: ; preds = %998
%1005 = load i32, i32* %43
%1006 = sext i32 %1005 to i64
%1007 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1006
%1008 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1007, i32 0, i32 2
%1009 = load i32, i32* %1008
%1010 = add nsw i32 %1009, 1
store i32 %1010, i32* %1008
br label %1011
1011: ; preds = %1004, %998
br label %1012
1012: ; preds = %1011
%1013 = load i32, i32* %39
%1014 = add nsw i32 %1013, 1
store i32 %1014, i32* %39
br label %994
1015: ; preds = %994
br label %1016
1016: ; preds = %1015
%1017 = load i32, i32* %43
%1018 = add nsw i32 %1017, 1
store i32 %1018, i32* %43
br label %971
1019: ; preds = %971
store i32 0, i32* %43
store i32 -1, i32* %40
store i32 0, i32* %38
br label %1020
1020: ; preds = %1070, %1019
%1021 = load i32, i32* %43
%1022 = load i32, i32* %34
%1023 = icmp slt i32 %1021, %1022
br i1 %1023, label %1024, label %1073
1024: ; preds = %1020
%1025 = load i32, i32* %43
%1026 = sext i32 %1025 to i64
%1027 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1026
%1028 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1027, i32 0, i32 2
%1029 = load i32, i32* %1028
%1030 = icmp sgt i32 %1029, 1
br i1 %1030, label %1031, label %1064
1031: ; preds = %1024
%1032 = load i32, i32* %40
%1033 = load i32, i32* %43
%1034 = sext i32 %1033 to i64
%1035 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1034
%1036 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1035, i32 0, i32 0
%1037 = load i32, i32* %1036
%1038 = ashr i32 %1037, 5
%1039 = icmp eq i32 %1032, %1038
br i1 %1039, label %1040, label %1047
1040: ; preds = %1031
%1041 = call i8* @malloc(i32 6)
store i8* %1041, i8** %46
%1042 = load i8*, i8** %46
%1043 = load i32, i32* %40
%1044 = load i32, i32* %38
%1045 = add nsw i32 %1044, 1
store i32 %1045, i32* %38
%1046 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* %1042, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i32 %1043, i32 %1045)
br label %1058
1047: ; preds = %1031
%1048 = load i32, i32* %43
%1049 = sext i32 %1048 to i64
%1050 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1049
%1051 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1050, i32 0, i32 0
%1052 = load i32, i32* %1051
%1053 = ashr i32 %1052, 5
store i32 %1053, i32* %40
%1054 = call i8* @malloc(i32 3)
store i8* %1054, i8** %46
%1055 = load i8*, i8** %46
%1056 = load i32, i32* %40
%1057 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* %1055, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.48, i64 0, i64 0), i32 %1056)
br label %1058
1058: ; preds = %1047, %1040
%1059 = load i8*, i8** %46
%1060 = load i32, i32* %43
%1061 = sext i32 %1060 to i64
%1062 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1061
%1063 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1062, i32 0, i32 3
store i8* %1059, i8** %1063
br label %1069
1064: ; preds = %1024
%1065 = load i32, i32* %43
%1066 = sext i32 %1065 to i64
%1067 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1066
%1068 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1067, i32 0, i32 3
store i8* null, i8** %1068
br label %1069
1069: ; preds = %1064, %1058
br label %1070
1070: ; preds = %1069
%1071 = load i32, i32* %43
%1072 = add nsw i32 %1071, 1
store i32 %1072, i32* %43
br label %1020
1073: ; preds = %1020
store i32 -1, i32* %40
store i32 0, i32* %43
br label %1074
1074: ; preds = %1174, %1073
%1075 = load i32, i32* %43
%1076 = load i32, i32* %34
%1077 = icmp slt i32 %1075, %1076
br i1 %1077, label %1078, label %1177
1078: ; preds = %1074
%1079 = load i32, i32* %43
%1080 = sext i32 %1079 to i64
%1081 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1080
%1082 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1081, i32 0, i32 2
%1083 = load i32, i32* %1082
%1084 = icmp sgt i32 %1083, 1
br i1 %1084, label %1085, label %1173
1085: ; preds = %1078
store i32 0, i32* %40
%1086 = load i32*, i32** %14
%1087 = load i8*, i8** %7
%1088 = load i32, i32* %43
%1089 = sext i32 %1088 to i64
%1090 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1089
%1091 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1090, i32 0, i32 3
%1092 = load i8*, i8** %1091
%1093 = load i32, i32* %43
%1094 = sext i32 %1093 to i64
%1095 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1094
%1096 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1095, i32 0, i32 1
%1097 = load i32, i32* %1096
%1098 = load i32, i32* %43
%1099 = sext i32 %1098 to i64
%1100 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1099
%1101 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1100, i32 0, i32 0
%1102 = load i32, i32* %1101
%1103 = sub nsw i32 %1097, %1102
%1104 = add nsw i32 %1103, 1
%1105 = mul nsw i32 8, %1104
%1106 = call i32 (i32*, i8*, ...) @fprintf(i32* %1086, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.49, i64 0, i64 0), i8* %1087, i8* %1092, i32 %1105)
%1107 = load i32, i32* %43
%1108 = sext i32 %1107 to i64
%1109 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1108
%1110 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1109, i32 0, i32 0
%1111 = load i32, i32* %1110
store i32 %1111, i32* %41
br label %1112
1112: ; preds = %1167, %1085
%1113 = load i32, i32* %41
%1114 = load i32, i32* %43
%1115 = sext i32 %1114 to i64
%1116 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1115
%1117 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1116, i32 0, i32 1
%1118 = load i32, i32* %1117
%1119 = icmp sle i32 %1113, %1118
br i1 %1119, label %1120, label %1170
1120: ; preds = %1112
%1121 = load i32, i32* %41
%1122 = srem i32 %1121, 32
%1123 = icmp eq i32 %1122, 0
br i1 %1123, label %1124, label %1137
1124: ; preds = %1120
%1125 = load i32, i32* %41
%1126 = load i32, i32* %43
%1127 = sext i32 %1126 to i64
%1128 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1127
%1129 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1128, i32 0, i32 0
%1130 = load i32, i32* %1129
%1131 = icmp sgt i32 %1125, %1130
br i1 %1131, label %1132, label %1137
1132: ; preds = %1124
%1133 = load i32*, i32** %14
%1134 = load i32, i32* %41
%1135 = mul nsw i32 8, %1134
%1136 = call i32 (i32*, i8*, ...) @fprintf(i32* %1133, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.50, i64 0, i64 0), i32 %1135)
br label %1137
1137: ; preds = %1132, %1124, %1120
%1138 = load i32*, i32** %14
%1139 = call i32 (i32*, i8*, ...) @fprintf(i32* %1138, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.14, i64 0, i64 0))
store i32 0, i32* %42
br label %1140
1140: ; preds = %1154, %1137
%1141 = load i32, i32* %42
%1142 = icmp slt i32 %1141, 8
br i1 %1142, label %1143, label %1157
1143: ; preds = %1140
%1144 = load i32, i32* %41
%1145 = mul nsw i32 8, %1144
%1146 = load i32, i32* %42
%1147 = add nsw i32 %1145, %1146
store i32 %1147, i32* %39
%1148 = load i32*, i32** %14
%1149 = load i32, i32* %39
%1150 = sext i32 %1149 to i64
%1151 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %1150
%1152 = load i32, i32* %1151
%1153 = call i32 (i32*, i8*, ...) @fprintf(i32* %1148, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.51, i64 0, i64 0), i32 %1152)
br label %1154
1154: ; preds = %1143
%1155 = load i32, i32* %42
%1156 = add nsw i32 %1155, 1
store i32 %1156, i32* %42
br label %1140
1157: ; preds = %1140
%1158 = load i32*, i32** %14
%1159 = load i32, i32* %41
%1160 = srem i32 %1159, 32
%1161 = mul nsw i32 8, %1160
%1162 = load i32, i32* %41
%1163 = srem i32 %1162, 32
%1164 = mul nsw i32 8, %1163
%1165 = add nsw i32 %1164, 7
%1166 = call i32 (i32*, i8*, ...) @fprintf(i32* %1158, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.52, i64 0, i64 0), i32 %1161, i32 %1165)
br label %1167
1167: ; preds = %1157
%1168 = load i32, i32* %41
%1169 = add nsw i32 %1168, 1
store i32 %1169, i32* %41
br label %1112
1170: ; preds = %1112
%1171 = load i32*, i32** %14
%1172 = call i32 (i32*, i8*, ...) @fprintf(i32* %1171, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.16, i64 0, i64 0))
br label %1173
1173: ; preds = %1170, %1078
br label %1174
1174: ; preds = %1173
%1175 = load i32, i32* %43
%1176 = add nsw i32 %1175, 1
store i32 %1176, i32* %43
br label %1074
1177: ; preds = %1074
%1178 = load i32, i32* %40
%1179 = icmp sge i32 %1178, 0
br i1 %1179, label %1180, label %1183
1180: ; preds = %1177
%1181 = load i32*, i32** %14
%1182 = call i32 (i32*, i8*, ...) @fprintf(i32* %1181, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.6, i64 0, i64 0))
br label %1183
1183: ; preds = %1180, %1177
store i32 0, i32* %36
store i32 0, i32* %41
br label %1184
1184: ; preds = %1229, %1183
%1185 = load i32, i32* %41
%1186 = icmp slt i32 %1185, 8192
br i1 %1186, label %1187, label %1231
1187: ; preds = %1184
%1188 = load i32, i32* %41
%1189 = sext i32 %1188 to i64
%1190 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %1189
%1191 = load i32, i32* %1190
store i32 %1191, i32* %43
%1192 = load i32, i32* %41
store i32 %1192, i32* %42
br label %1193
1193: ; preds = %1206, %1187
%1194 = load i32, i32* %42
%1195 = icmp slt i32 %1194, 8192
br i1 %1195, label %1196, label %1203
1196: ; preds = %1193
%1197 = load i32, i32* %42
%1198 = sext i32 %1197 to i64
%1199 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %1198
%1200 = load i32, i32* %1199
%1201 = load i32, i32* %43
%1202 = icmp eq i32 %1200, %1201
br label %1203
1203: ; preds = %1196, %1193
%1204 = phi i1 [ false, %1193 ], [ %1202, %1196 ]
br i1 %1204, label %1205, label %1209
1205: ; preds = %1203
br label %1206
1206: ; preds = %1205
%1207 = load i32, i32* %42
%1208 = add nsw i32 %1207, 1
store i32 %1208, i32* %42
br label %1193
1209: ; preds = %1203
%1210 = load i32, i32* %43
%1211 = icmp sge i32 %1210, 0
br i1 %1211, label %1212, label %1219
1212: ; preds = %1209
%1213 = load i32, i32* %43
%1214 = sext i32 %1213 to i64
%1215 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1214
%1216 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1215, i32 0, i32 1
%1217 = load i32, i32* %1216
%1218 = add nsw i32 %1217, 1
store i32 %1218, i32* %42
br label %1219
1219: ; preds = %1212, %1209
%1220 = load i32, i32* %43
%1221 = icmp eq i32 %1220, -2
br i1 %1221, label %1229, label %1222
1222: ; preds = %1219
%1223 = load i32, i32* %43
%1224 = icmp eq i32 %1223, -1
br i1 %1224, label %1225, label %1228
1225: ; preds = %1222
%1226 = load i32, i32* %41
%1227 = icmp eq i32 %1226, 0
br i1 %1227, label %1229, label %1228
1228: ; preds = %1225, %1222
store i32 1, i32* %36
br label %1229
1229: ; preds = %1228, %1225, %1219
%1230 = load i32, i32* %42
store i32 %1230, i32* %41
br label %1184
1231: ; preds = %1184
store i32 0, i32* %37
%1232 = load i32*, i32** %14
%1233 = load i8*, i8** %7
%1234 = call i32 (i32*, i8*, ...) @fprintf(i32* %1232, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.53, i64 0, i64 0), i8* %1233)
%1235 = load i32*, i32** %14
%1236 = call i32 (i32*, i8*, ...) @fprintf(i32* %1235, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.18, i64 0, i64 0))
%1237 = load i32, i32* %36
%1238 = icmp ne i32 %1237, 0
br i1 %1238, label %1239, label %1242
1239: ; preds = %1231
%1240 = load i32*, i32** %14
%1241 = call i32 (i32*, i8*, ...) @fprintf(i32* %1240, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.54, i64 0, i64 0))
br label %1242
1242: ; preds = %1239, %1231
store i32 0, i32* %41
br label %1243
1243: ; preds = %1429, %1242
%1244 = load i32, i32* %41
%1245 = icmp slt i32 %1244, 8192
br i1 %1245, label %1246, label %1431
1246: ; preds = %1243
%1247 = load i32, i32* %41
%1248 = sext i32 %1247 to i64
%1249 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %1248
%1250 = load i32, i32* %1249
store i32 %1250, i32* %43
%1251 = load i32, i32* %41
store i32 %1251, i32* %42
br label %1252
1252: ; preds = %1265, %1246
%1253 = load i32, i32* %42
%1254 = icmp slt i32 %1253, 8192
br i1 %1254, label %1255, label %1262
1255: ; preds = %1252
%1256 = load i32, i32* %42
%1257 = sext i32 %1256 to i64
%1258 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %1257
%1259 = load i32, i32* %1258
%1260 = load i32, i32* %43
%1261 = icmp eq i32 %1259, %1260
br label %1262
1262: ; preds = %1255, %1252
%1263 = phi i1 [ false, %1252 ], [ %1261, %1255 ]
br i1 %1263, label %1264, label %1268
1264: ; preds = %1262
br label %1265
1265: ; preds = %1264
%1266 = load i32, i32* %42
%1267 = add nsw i32 %1266, 1
store i32 %1267, i32* %42
br label %1252
1268: ; preds = %1262
%1269 = load i32, i32* %43
%1270 = icmp sge i32 %1269, 0
br i1 %1270, label %1271, label %1299
1271: ; preds = %1268
%1272 = load i32, i32* %41
%1273 = load i32, i32* %43
%1274 = sext i32 %1273 to i64
%1275 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1274
%1276 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1275, i32 0, i32 0
%1277 = load i32, i32* %1276
%1278 = icmp ne i32 %1272, %1277
br i1 %1278, label %1279, label %1281
1279: ; preds = %1271
%1280 = call i32 (...) @abort()
unreachable
1281: ; preds = %1271
%1282 = load i32, i32* %42
%1283 = load i32, i32* %43
%1284 = sext i32 %1283 to i64
%1285 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1284
%1286 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1285, i32 0, i32 1
%1287 = load i32, i32* %1286
%1288 = add nsw i32 %1287, 1
%1289 = icmp sgt i32 %1282, %1288
br i1 %1289, label %1290, label %1292
1290: ; preds = %1281
%1291 = call i32 (...) @abort()
unreachable
1292: ; preds = %1281
%1293 = load i32, i32* %43
%1294 = sext i32 %1293 to i64
%1295 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1294
%1296 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1295, i32 0, i32 1
%1297 = load i32, i32* %1296
%1298 = add nsw i32 %1297, 1
store i32 %1298, i32* %42
br label %1299
1299: ; preds = %1292, %1268
%1300 = load i32, i32* %43
%1301 = icmp eq i32 %1300, -2
br i1 %1301, label %1302, label %1303
1302: ; preds = %1299
br label %1429
1303: ; preds = %1299
%1304 = load i32, i32* %41
%1305 = icmp eq i32 %1304, 0
br i1 %1305, label %1306, label %1309
1306: ; preds = %1303
%1307 = load i32*, i32** %14
%1308 = call i32 (i32*, i8*, ...) @fprintf(i32* %1307, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0))
br label %1312
1309: ; preds = %1303
%1310 = load i32*, i32** %14
%1311 = call i32 (i32*, i8*, ...) @fprintf(i32* %1310, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.55, i64 0, i64 0))
br label %1312
1312: ; preds = %1309, %1306
%1313 = load i32, i32* %43
%1314 = icmp sge i32 %1313, 0
br i1 %1314, label %1315, label %1324
1315: ; preds = %1312
%1316 = load i32, i32* %43
%1317 = sext i32 %1316 to i64
%1318 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1317
%1319 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1318, i32 0, i32 2
%1320 = load i32, i32* %1319
%1321 = icmp eq i32 %1320, 0
br i1 %1321, label %1322, label %1324
1322: ; preds = %1315
%1323 = call i32 (...) @abort()
unreachable
1324: ; preds = %1315, %1312
%1325 = load i32, i32* %43
%1326 = icmp sge i32 %1325, 0
br i1 %1326, label %1327, label %1368
1327: ; preds = %1324
%1328 = load i32, i32* %43
%1329 = sext i32 %1328 to i64
%1330 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1329
%1331 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1330, i32 0, i32 2
%1332 = load i32, i32* %1331
%1333 = icmp eq i32 %1332, 1
br i1 %1333, label %1334, label %1368
1334: ; preds = %1327
%1335 = load i32, i32* %42
%1336 = load i32, i32* %41
%1337 = add nsw i32 %1336, 1
%1338 = icmp ne i32 %1335, %1337
br i1 %1338, label %1339, label %1341
1339: ; preds = %1334
%1340 = call i32 (...) @abort()
unreachable
1341: ; preds = %1334
%1342 = load i32, i32* %41
%1343 = mul nsw i32 8, %1342
store i32 %1343, i32* %39
br label %1344
1344: ; preds = %1364, %1341
%1345 = load i32, i32* %39
%1346 = load i32, i32* %42
%1347 = mul nsw i32 8, %1346
%1348 = icmp slt i32 %1345, %1347
br i1 %1348, label %1349, label %1367
1349: ; preds = %1344
%1350 = load i32, i32* %39
%1351 = sext i32 %1350 to i64
%1352 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %1351
%1353 = load i32, i32* %1352
%1354 = icmp ne i32 %1353, 0
br i1 %1354, label %1355, label %1363
1355: ; preds = %1349
%1356 = load i32*, i32** %14
%1357 = load i32, i32* %39
%1358 = load i32, i32* %39
%1359 = sext i32 %1358 to i64
%1360 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %1359
%1361 = load i32, i32* %1360
%1362 = call i32 (i32*, i8*, ...) @fprintf(i32* %1356, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.56, i64 0, i64 0), i32 %1357, i32 %1361)
br label %1367
1363: ; preds = %1349
br label %1364
1364: ; preds = %1363
%1365 = load i32, i32* %39
%1366 = add nsw i32 %1365, 1
store i32 %1366, i32* %39
br label %1344
1367: ; preds = %1355, %1344
br label %1428
1368: ; preds = %1327, %1324
%1369 = load i32, i32* %41
%1370 = icmp eq i32 %1369, 0
br i1 %1370, label %1371, label %1376
1371: ; preds = %1368
%1372 = load i32*, i32** %14
%1373 = load i32, i32* %42
%1374 = mul nsw i32 8, %1373
%1375 = call i32 (i32*, i8*, ...) @fprintf(i32* %1372, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.57, i64 0, i64 0), i32 %1374)
br label %1383
1376: ; preds = %1368
%1377 = load i32*, i32** %14
%1378 = load i32, i32* %41
%1379 = mul nsw i32 8, %1378
%1380 = load i32, i32* %42
%1381 = mul nsw i32 8, %1380
%1382 = call i32 (i32*, i8*, ...) @fprintf(i32* %1377, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.58, i64 0, i64 0), i32 %1379, i32 %1381)
br label %1383
1383: ; preds = %1376, %1371
%1384 = load i32, i32* %43
%1385 = icmp eq i32 %1384, -1
br i1 %1385, label %1386, label %1396
1386: ; preds = %1383
%1387 = load i32, i32* %41
%1388 = icmp eq i32 %1387, 0
br i1 %1388, label %1389, label %1392
1389: ; preds = %1386
%1390 = load i32*, i32** %14
%1391 = call i32 (i32*, i8*, ...) @fprintf(i32* %1390, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.59, i64 0, i64 0))
br label %1395
1392: ; preds = %1386
%1393 = load i32*, i32** %14
%1394 = call i32 (i32*, i8*, ...) @fprintf(i32* %1393, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.60, i64 0, i64 0))
br label %1395
1395: ; preds = %1392, %1389
br label %1427
1396: ; preds = %1383
%1397 = load i32*, i32** %14
%1398 = load i8*, i8** %7
%1399 = load i32, i32* %43
%1400 = sext i32 %1399 to i64
%1401 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1400
%1402 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1401, i32 0, i32 3
%1403 = load i8*, i8** %1402
%1404 = call i32 (i32*, i8*, ...) @fprintf(i32* %1397, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.61, i64 0, i64 0), i8* %1398, i8* %1403)
%1405 = load i32, i32* %43
%1406 = sext i32 %1405 to i64
%1407 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1406
%1408 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1407, i32 0, i32 0
%1409 = load i32, i32* %1408
%1410 = icmp sgt i32 %1409, 0
br i1 %1410, label %1411, label %1416
1411: ; preds = %1396
%1412 = load i32*, i32** %14
%1413 = load i32, i32* %41
%1414 = mul nsw i32 8, %1413
%1415 = call i32 (i32*, i8*, ...) @fprintf(i32* %1412, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.62, i64 0, i64 0), i32 %1414)
br label %1416
1416: ; preds = %1411, %1396
%1417 = load i32*, i32** %14
%1418 = call i32 (i32*, i8*, ...) @fprintf(i32* %1417, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.33, i64 0, i64 0))
%1419 = load i32, i32* %41
%1420 = icmp eq i32 %1419, 0
br i1 %1420, label %1421, label %1426
1421: ; preds = %1416
%1422 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 0
%1423 = load i32, i32* %1422
%1424 = icmp eq i32 %1423, 0
br i1 %1424, label %1425, label %1426
1425: ; preds = %1421
store i32 1, i32* %37
br label %1426
1426: ; preds = %1425, %1421, %1416
br label %1427
1427: ; preds = %1426, %1395
br label %1428
1428: ; preds = %1427, %1367
br label %1429
1429: ; preds = %1428, %1302
%1430 = load i32, i32* %42
store i32 %1430, i32* %41
br label %1243
1431: ; preds = %1243
%1432 = load i32, i32* %36
%1433 = icmp ne i32 %1432, 0
br i1 %1433, label %1434, label %1450
1434: ; preds = %1431
%1435 = load i32, i32* %37
%1436 = icmp ne i32 %1435, 0
br i1 %1436, label %1437, label %1440
1437: ; preds = %1434
%1438 = load i32*, i32** %14
%1439 = call i32 (i32*, i8*, ...) @fprintf(i32* %1438, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.63, i64 0, i64 0))
br label %1443
1440: ; preds = %1434
%1441 = load i32*, i32** %14
%1442 = call i32 (i32*, i8*, ...) @fprintf(i32* %1441, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.64, i64 0, i64 0))
br label %1443
1443: ; preds = %1440, %1437
%1444 = load i32*, i32** %14
%1445 = call i32 (i32*, i8*, ...) @fprintf(i32* %1444, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.65, i64 0, i64 0))
%1446 = load i32*, i32** %14
%1447 = call i32 (i32*, i8*, ...) @fprintf(i32* %1446, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.66, i64 0, i64 0))
%1448 = load i32*, i32** %14
%1449 = call i32 (i32*, i8*, ...) @fprintf(i32* %1448, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.38, i64 0, i64 0))
br label %1450
1450: ; preds = %1443, %1431
%1451 = load i32*, i32** %14
%1452 = call i32 (i32*, i8*, ...) @fprintf(i32* %1451, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.39, i64 0, i64 0))
%1453 = load i32*, i32** %14
%1454 = call i32 (i32*, i8*, ...) @fprintf(i32* %1453, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.46, i64 0, i64 0))
%1455 = load i32*, i32** %14
%1456 = call i64 @ferror(i32* %1455)
%1457 = icmp ne i64 %1456, 0
br i1 %1457, label %1462, label %1458
1458: ; preds = %1450
%1459 = load i32*, i32** %14
%1460 = call i64 @fclose(i32* %1459)
%1461 = icmp ne i64 %1460, 0
br i1 %1461, label %1462, label %1464
1462: ; preds = %1458, %1450
%1463 = call i32 @exit(i32 1)
unreachable
1464: ; preds = %1458
%1465 = call i32 @exit(i32 0)
unreachable
}

LLVM IR (-O2):
%struct.anon = type { i32, i32 }
%struct.anon.0 = type { i32, i32, i32, i8* }
@.str = [3 x i8] c".h\00"
@.str.1 = [1 x i8] zeroinitializer
@stderr = global i32 0
@.str.2 = [15 x i8] c"Creating %s%s\0A\00"
@stdin = global i32 0
@EOF = global i32 0
@.str.3 = [5 x i8] c"0x%x\00"
@.str.4 = [3 x i8] c"%x\00"
@.str.5 = [2 x i8] c"w\00"
@.str.7 = [4 x i8] c"/*\0A\00"
@.str.8 = [7 x i8] c" * %s\0A\00"
@.str.9 = [5 x i8] c" */\0A\00"
@.str.10 = [36 x i8] c"static const unsigned short %s_2uni\00"
@.str.11 = [4 x i8] c"_%d\00"
@.str.12 = [10 x i8] c"[%d] = {\0A\00"
@.str.13 = [16 x i8] c" /* 0x%02x */\0A\00"
@.str.15 = [9 x i8] c" 0x%04x,\00"
@.str.16 = [4 x i8] c"};\0A\00"
@.str.17 = [80 x i8] c"static int\0A%s_mbtowc (conv_t conv, ucs4_t *pwc, const unsigned char *s, int n)\0A\00"
@.str.18 = [3 x i8] c"{\0A\00"
@.str.19 = [25 x i8] c" unsigned char c = *s;\0A\00"
@.str.20 = [3 x i8] c" \00"
@.str.21 = [5 x i8] c" \00"
@.str.22 = [21 x i8] c" if (c < 0x%02x) {\0A\00"
@.str.23 = [10 x i8] c" else {\0A\00"
@.str.24 = [26 x i8] c" else if (c < 0x%02x) {\0A\00"
@.str.25 = [22 x i8] c"%s*pwc = (ucs4_t) c;\0A\00"
@.str.26 = [13 x i8] c"%sreturn 1;\0A\00"
@.str.28 = [21 x i8] c"unsigned short wc = \00"
@.str.29 = [17 x i8] c"*pwc = (ucs4_t) \00"
@.str.30 = [8 x i8] c"%s_2uni\00"
@.str.31 = [3 x i8] c"[c\00"
@.str.32 = [8 x i8] c"-0x%02x\00"
@.str.33 = [4 x i8] c"];\0A\00"
@.str.34 = [23 x i8] c"%sif (wc != 0xfffd) {\0A\00"
@.str.35 = [25 x i8] c"%s *pwc = (ucs4_t) wc;\0A\00"
@.str.36 = [15 x i8] c"%s return 1;\0A\00"
@.str.37 = [5 x i8] c"%s}\0A\00"
@.str.38 = [5 x i8] c" }\0A\00"
@.str.39 = [21 x i8] c" return RET_ILSEQ;\0A\00"
@.str.40 = [23 x i8] c" if (c < 0x%02x)\0A \00"
@.str.41 = [12 x i8] c" else\0A \00"
@.str.42 = [28 x i8] c" else if (c < 0x%02x)\0A \00"
@.str.43 = [20 x i8] c"*pwc = (ucs4_t) c;\0A\00"
@.str.44 = [24 x i8] c"*pwc = (ucs4_t) %s_2uni\00"
@.str.45 = [13 x i8] c" return 1;\0A\00"
@.str.46 = [3 x i8] c"}\0A\00"
@.str.47 = [8 x i8] c"%02x_%d\00"
@.str.48 = [5 x i8] c"%02x\00"
@.str.49 = [46 x i8] c"static const unsigned char %s_page%s[%d] = {\0A\00"
@.str.50 = [16 x i8] c" /* 0x%04x */\0A\00"
@.str.51 = [9 x i8] c" 0x%02x,\00"
@.str.52 = [22 x i8] c" /* 0x%02x-0x%02x */\0A\00"
@.str.53 = [72 x i8] c"static int\0A%s_wctomb (conv_t conv, unsigned char *r, ucs4_t wc, int n)\0A\00"
@.str.54 = [24 x i8] c" unsigned char c = 0;\0A\00"
@.str.55 = [8 x i8] c" else \00"
@.str.56 = [35 x i8] c"if (wc == 0x%04x)\0A c = 0x%02x;\0A\00"
@.str.57 = [17 x i8] c"if (wc < 0x%04x)\00"
@.str.58 = [33 x i8] c"if (wc >= 0x%04x && wc < 0x%04x)\00"
@.str.59 = [35 x i8] c" {\0A *r = wc;\0A return 1;\0A }\0A\00"
@.str.60 = [14 x i8] c"\0A c = wc;\0A\00"
@.str.61 = [22 x i8] c"\0A c = %s_page%s[wc\00"
@.str.62 = [8 x i8] c"-0x%04x\00"
@.str.63 = [28 x i8] c" if (c != 0 || wc == 0) {\0A\00"
@.str.64 = [17 x i8] c" if (c != 0) {\0A\00"
@.str.65 = [13 x i8] c" *r = c;\0A\00"
@.str.66 = [15 x i8] c" return 1;\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [256 x i32]
%4 = alloca i32
%5 = alloca [16 x i32]
%6 = alloca [16 x %struct.anon]
%7 = alloca [65536 x i32]
%8 = bitcast [65536 x i32]* %7 to i8*
%9 = alloca [8192 x i32]
%10 = alloca [8192 x %struct.anon.0]
%11 = bitcast [256 x i32]* %3 to i8*
%12 = add i32 %0, -6
%13 = icmp ult i32 %12, -3
br i1 %13, label %14, label %16
14: ; preds = %2
%15 = tail call i32 @exit(i32 1)
unreachable
16: ; preds = %2
%17 = getelementptr inbounds i8*, i8** %1, i64 1
%18 = load i8*, i8** %17
%19 = getelementptr inbounds i8*, i8** %1, i64 2
%20 = load i8*, i8** %19
%21 = icmp ugt i32 %0, 3
br i1 %21, label %30, label %22
22: ; preds = %16
%23 = tail call i32 @strlen(i8* %20)
%24 = tail call i32 @strlen(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%25 = add i32 %23, 1
%26 = add i32 %25, %24
%27 = tail call i8* @malloc(i32 %26)
%28 = tail call i32 @strcpy(i8* %27, i8* %20)
%29 = tail call i32 @strcat(i8* %27, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
br label %37
30: ; preds = %16
%31 = getelementptr inbounds i8*, i8** %1, i64 3
%32 = load i8*, i8** %31
%33 = icmp eq i32 %0, 4
br i1 %33, label %37, label %34
34: ; preds = %30
%35 = getelementptr inbounds i8*, i8** %1, i64 4
%36 = load i8*, i8** %35
br label %37
37: ; preds = %22, %30, %34
%38 = phi i8* [ %32, %34 ], [ %32, %30 ], [ %27, %22 ]
%39 = phi i8* [ %36, %34 ], [ getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0), %30 ], [ getelementptr inbounds ([1 x i8], [1 x i8]* @.str.1, i64 0, i64 0), %22 ]
%40 = load i32, i32* @stderr
%41 = sext i32 %40 to i64
%42 = inttoptr i64 %41 to i32*
%43 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i8* %39, i8* %38)
%44 = bitcast i32* %4 to i8*
%45 = load i32, i32* @stdin
%46 = tail call i32 @getc(i32 %45)
%47 = load i32, i32* @stdin
%48 = tail call i32 @ungetc(i32 %46, i32 %47)
%49 = icmp eq i32 %46, 35
br i1 %49, label %50, label %182
50: ; preds = %37
%51 = bitcast [256 x i32]* %3 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %51
%52 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 4
%53 = bitcast i32* %52 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %53
%54 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 8
%55 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %55
%56 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 12
%57 = bitcast i32* %56 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %57
%58 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 16
%59 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %59
%60 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 20
%61 = bitcast i32* %60 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %61
%62 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 24
%63 = bitcast i32* %62 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %63
%64 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 28
%65 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %65
%66 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 32
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %67
%68 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 36
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %69
%70 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 40
%71 = bitcast i32* %70 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %71
%72 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 44
%73 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %73
%74 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 48
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %75
%76 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 52
%77 = bitcast i32* %76 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %77
%78 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 56
%79 = bitcast i32* %78 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %79
%80 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 60
%81 = bitcast i32* %80 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %81
%82 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 64
%83 = bitcast i32* %82 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %83
%84 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 68
%85 = bitcast i32* %84 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %85
%86 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 72
%87 = bitcast i32* %86 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %87
%88 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 76
%89 = bitcast i32* %88 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %89
%90 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 80
%91 = bitcast i32* %90 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %91
%92 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 84
%93 = bitcast i32* %92 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %93
%94 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 88
%95 = bitcast i32* %94 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %95
%96 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 92
%97 = bitcast i32* %96 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %97
%98 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 96
%99 = bitcast i32* %98 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %99
%100 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 100
%101 = bitcast i32* %100 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %101
%102 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 104
%103 = bitcast i32* %102 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %103
%104 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 108
%105 = bitcast i32* %104 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %105
%106 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 112
%107 = bitcast i32* %106 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %107
%108 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 116
%109 = bitcast i32* %108 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %109
%110 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 120
%111 = bitcast i32* %110 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %111
%112 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 124
%113 = bitcast i32* %112 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %113
%114 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 128
%115 = bitcast i32* %114 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %115
%116 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 132
%117 = bitcast i32* %116 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %117
%118 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 136
%119 = bitcast i32* %118 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %119
%120 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 140
%121 = bitcast i32* %120 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %121
%122 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 144
%123 = bitcast i32* %122 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %123
%124 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 148
%125 = bitcast i32* %124 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %125
%126 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 152
%127 = bitcast i32* %126 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %127
%128 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 156
%129 = bitcast i32* %128 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %129
%130 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 160
%131 = bitcast i32* %130 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %131
%132 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 164
%133 = bitcast i32* %132 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %133
%134 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 168
%135 = bitcast i32* %134 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %135
%136 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 172
%137 = bitcast i32* %136 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %137
%138 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 176
%139 = bitcast i32* %138 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %139
%140 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 180
%141 = bitcast i32* %140 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %141
%142 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 184
%143 = bitcast i32* %142 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %143
%144 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 188
%145 = bitcast i32* %144 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %145
%146 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 192
%147 = bitcast i32* %146 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %147
%148 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 196
%149 = bitcast i32* %148 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %149
%150 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 200
%151 = bitcast i32* %150 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %151
%152 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 204
%153 = bitcast i32* %152 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %153
%154 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 208
%155 = bitcast i32* %154 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %155
%156 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 212
%157 = bitcast i32* %156 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %157
%158 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 216
%159 = bitcast i32* %158 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %159
%160 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 220
%161 = bitcast i32* %160 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %161
%162 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 224
%163 = bitcast i32* %162 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %163
%164 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 228
%165 = bitcast i32* %164 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %165
%166 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 232
%167 = bitcast i32* %166 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %167
%168 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 236
%169 = bitcast i32* %168 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %169
%170 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 240
%171 = bitcast i32* %170 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %171
%172 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 244
%173 = bitcast i32* %172 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %173
%174 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 248
%175 = bitcast i32* %174 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %175
%176 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 252
%177 = bitcast i32* %176 to <4 x i32>*
store <4 x i32> <i32 65533, i32 65533, i32 65533, i32 65533>, <4 x i32>* %177
store i32 256, i32* %4
%178 = load i32, i32* @stdin
%179 = call i32 @getc(i32 %178)
%180 = load i32, i32* @EOF
%181 = icmp eq i32 %179, %180
br i1 %181, label %254, label %183
182: ; preds = %37
store i32 0, i32* %4
br label %228
183: ; preds = %50, %221
%184 = phi i32 [ %223, %221 ], [ %179, %50 ]
switch i32 %184, label %192 [
i32 32, label %221
i32 10, label %221
i32 9, label %221
i32 35, label %185
]
185: ; preds = %183, %185
%186 = load i32, i32* @stdin
%187 = call i32 @getc(i32 %186)
%188 = load i32, i32* @EOF
%189 = icmp ne i32 %187, %188
%190 = icmp ne i32 %187, 10
%191 = and i1 %190, %189
br i1 %191, label %185, label %221
192: ; preds = %183
%193 = load i32, i32* @stdin
%194 = call i32 @ungetc(i32 %184, i32 %193)
%195 = call i32 @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32* %4)
%196 = icmp eq i32 %195, 1
%197 = load i32, i32* %4
%198 = icmp sgt i32 %197, -1
%199 = select i1 %196, i1 %198, i1 false
%200 = icmp slt i32 %197, 256
%201 = select i1 %199, i1 %200, i1 false
br i1 %201, label %204, label %202
202: ; preds = %192
%203 = call i32 @exit(i32 1)
unreachable
204: ; preds = %192, %207
%205 = load i32, i32* @stdin
%206 = call i32 @getc(i32 %205)
switch i32 %206, label %208 [
i32 32, label %207
i32 9, label %207
]
207: ; preds = %204, %204
br label %204
208: ; preds = %204
%209 = load i32, i32* @EOF
%210 = icmp eq i32 %206, %209
br i1 %210, label %214, label %211
211: ; preds = %208
%212 = load i32, i32* @stdin
%213 = call i32 @ungetc(i32 %206, i32 %212)
br label %214
214: ; preds = %211, %208
switch i32 %206, label %215 [
i32 35, label %221
i32 10, label %221
]
215: ; preds = %214
%216 = load i32, i32* %4
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %217
%219 = call i32 @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i32* %218)
%220 = icmp eq i32 %219, 1
br i1 %220, label %221, label %226
221: ; preds = %185, %215, %183, %183, %183, %214, %214
%222 = load i32, i32* @stdin
%223 = call i32 @getc(i32 %222)
%224 = load i32, i32* @EOF
%225 = icmp eq i32 %223, %224
br i1 %225, label %254, label %183
226: ; preds = %215
%227 = call i32 @exit(i32 1)
unreachable
228: ; preds = %182, %245
%229 = phi i32 [ 0, %182 ], [ %246, %245 ]
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %230
%232 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %231)
%233 = icmp eq i32 %232, 1
br i1 %233, label %236, label %234
234: ; preds = %228
%235 = call i32 @exit(i32 1)
unreachable
236: ; preds = %228
%237 = load i32, i32* %4
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %238
%240 = load i32, i32* %239
%241 = icmp slt i32 %240, 0
%242 = icmp eq i32 %240, 65535
%243 = or i1 %241, %242
br i1 %243, label %244, label %245
244: ; preds = %236
store i32 65533, i32* %239
br label %245
245: ; preds = %236, %244
%246 = add nsw i32 %237, 1
store i32 %246, i32* %4
%247 = icmp slt i32 %237, 255
br i1 %247, label %228, label %248
248: ; preds = %245
%249 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.4, i64 0, i64 0), i32* %4)
%250 = load i32, i32* @EOF
%251 = icmp eq i32 %249, %250
br i1 %251, label %254, label %252
252: ; preds = %248
%253 = call i32 @exit(i32 1)
unreachable
254: ; preds = %221, %50, %248
%255 = call i32 @strlen(i8* %39)
%256 = call i32 @strlen(i8* %38)
%257 = add i32 %255, 1
%258 = add i32 %257, %256
%259 = call i8* @malloc(i32 %258)
%260 = call i32 @strcpy(i8* %259, i8* %39)
%261 = call i32 @strcat(i8* %259, i8* %38)
%262 = call i32* @fopen(i8* %259, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%263 = icmp eq i32* %262, null
br i1 %263, label %264, label %266
264: ; preds = %254
%265 = call i32 @exit(i32 1)
unreachable
266: ; preds = %254
%267 = call i32 @fputc(i32 10, i32* %262)
%268 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i64 3, i64 1, i32* %262)
%269 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.8, i64 0, i64 0), i8* %18)
%270 = call i64 @fwrite(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.9, i64 0, i64 0), i64 4, i64 1, i32* %262)
%271 = call i32 @fputc(i32 10, i32* %262)
%272 = bitcast [16 x i32]* %5 to i8*
%273 = bitcast [16 x %struct.anon]* %6 to i8*
br label %274
274: ; preds = %266, %368
%275 = phi i64 [ 0, %266 ], [ %369, %368 ]
%276 = shl nsw i64 %275, 4
%277 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %276
%278 = bitcast i32* %277 to <16 x i32>*
%279 = load <16 x i32>, <16 x i32>* %278
%280 = freeze <16 x i32> %279
%281 = icmp ne <16 x i32> %280, <i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533, i32 65533>
%282 = bitcast <16 x i1> %281 to i16
%283 = icmp eq i16 %282, 0
br i1 %283, label %284, label %286
284: ; preds = %274
%285 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %275
store i32 -2, i32* %285
br label %368
286: ; preds = %274
%287 = or i64 %276, 15
%288 = or i64 %276, 14
%289 = or i64 %276, 13
%290 = or i64 %276, 12
%291 = or i64 %276, 11
%292 = or i64 %276, 10
%293 = or i64 %276, 9
%294 = or i64 %276, 8
%295 = or i64 %276, 7
%296 = or i64 %276, 6
%297 = or i64 %276, 5
%298 = or i64 %276, 4
%299 = or i64 %276, 3
%300 = or i64 %276, 2
%301 = or i64 %276, 1
%302 = extractelement <16 x i32> %280, i64 15
%303 = zext i32 %302 to i64
%304 = icmp ne i64 %287, %303
%305 = extractelement <16 x i32> %280, i64 0
%306 = zext i32 %305 to i64
%307 = icmp ne i64 %276, %306
%308 = extractelement <16 x i32> %280, i64 1
%309 = zext i32 %308 to i64
%310 = icmp ne i64 %301, %309
%311 = extractelement <16 x i32> %280, i64 2
%312 = zext i32 %311 to i64
%313 = icmp ne i64 %300, %312
%314 = extractelement <16 x i32> %280, i64 3
%315 = zext i32 %314 to i64
%316 = icmp ne i64 %299, %315
%317 = extractelement <16 x i32> %280, i64 4
%318 = zext i32 %317 to i64
%319 = icmp ne i64 %298, %318
%320 = extractelement <16 x i32> %280, i64 5
%321 = zext i32 %320 to i64
%322 = icmp ne i64 %297, %321
%323 = extractelement <16 x i32> %280, i64 6
%324 = zext i32 %323 to i64
%325 = icmp ne i64 %296, %324
%326 = extractelement <16 x i32> %280, i64 7
%327 = zext i32 %326 to i64
%328 = icmp ne i64 %295, %327
%329 = extractelement <16 x i32> %280, i64 8
%330 = zext i32 %329 to i64
%331 = icmp ne i64 %294, %330
%332 = extractelement <16 x i32> %280, i64 9
%333 = zext i32 %332 to i64
%334 = icmp ne i64 %293, %333
%335 = extractelement <16 x i32> %280, i64 10
%336 = zext i32 %335 to i64
%337 = icmp ne i64 %292, %336
%338 = extractelement <16 x i32> %280, i64 11
%339 = zext i32 %338 to i64
%340 = icmp ne i64 %291, %339
%341 = extractelement <16 x i32> %280, i64 12
%342 = zext i32 %341 to i64
%343 = icmp ne i64 %290, %342
%344 = extractelement <16 x i32> %280, i64 13
%345 = zext i32 %344 to i64
%346 = icmp ne i64 %289, %345
%347 = extractelement <16 x i32> %280, i64 14
%348 = zext i32 %347 to i64
%349 = icmp ne i64 %288, %348
%350 = or i1 %304, %349
%351 = select i1 %350, i1 true, i1 %346
%352 = select i1 %351, i1 true, i1 %343
%353 = select i1 %352, i1 true, i1 %340
%354 = select i1 %353, i1 true, i1 %337
%355 = select i1 %354, i1 true, i1 %334
%356 = select i1 %355, i1 true, i1 %331
%357 = select i1 %356, i1 true, i1 %328
%358 = select i1 %357, i1 true, i1 %325
%359 = select i1 %358, i1 true, i1 %322
%360 = select i1 %359, i1 true, i1 %319
%361 = select i1 %360, i1 true, i1 %316
%362 = select i1 %361, i1 true, i1 %313
%363 = select i1 %362, i1 true, i1 %310
%364 = select i1 %363, i1 true, i1 %307
%365 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %275
br i1 %364, label %367, label %366
366: ; preds = %286
store i32 -1, i32* %365
br label %368
367: ; preds = %286
store i32 0, i32* %365
br label %368
368: ; preds = %366, %367, %284
%369 = add nuw nsw i64 %275, 1
%370 = icmp eq i64 %369, 16
br i1 %370, label %405, label %274
371: ; preds = %432, %371
%372 = phi i64 [ %396, %371 ], [ 0, %432 ]
%373 = phi <4 x i32> [ %393, %371 ], [ zeroinitializer, %432 ]
%374 = phi <4 x i32> [ %395, %371 ], [ zeroinitializer, %432 ]
%375 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %372
%376 = bitcast i32* %375 to <4 x i32>*
%377 = load <4 x i32>, <4 x i32>* %376
%378 = getelementptr inbounds i32, i32* %375, i64 4
%379 = bitcast i32* %378 to <4 x i32>*
%380 = load <4 x i32>, <4 x i32>* %379
%381 = icmp eq <4 x i32> %377, <i32 65533, i32 65533, i32 65533, i32 65533>
%382 = icmp eq <4 x i32> %380, <i32 65533, i32 65533, i32 65533, i32 65533>
%383 = or i64 %372, 8
%384 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %383
%385 = bitcast i32* %384 to <4 x i32>*
%386 = load <4 x i32>, <4 x i32>* %385
%387 = getelementptr inbounds i32, i32* %384, i64 4
%388 = bitcast i32* %387 to <4 x i32>*
%389 = load <4 x i32>, <4 x i32>* %388
%390 = icmp eq <4 x i32> %386, <i32 65533, i32 65533, i32 65533, i32 65533>
%391 = icmp eq <4 x i32> %389, <i32 65533, i32 65533, i32 65533, i32 65533>
%392 = select <4 x i1> %390, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %381
%393 = select <4 x i1> %392, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> %373
%394 = select <4 x i1> %391, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %382
%395 = select <4 x i1> %394, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> %374
%396 = add nuw nsw i64 %372, 16
%397 = icmp eq i64 %396, 256
br i1 %397, label %398, label %371
398: ; preds = %371
%399 = icmp eq <4 x i32> %393, zeroinitializer
%400 = select <4 x i1> %399, <4 x i32> %395, <4 x i32> %393
%401 = icmp ne <4 x i32> %400, zeroinitializer
%402 = bitcast <4 x i1> %401 to i4
%403 = icmp eq i4 %402, 0
%404 = icmp sgt i32 %433, 0
br i1 %404, label %436, label %541
405: ; preds = %368, %432
%406 = phi i64 [ %434, %432 ], [ 0, %368 ]
%407 = phi i32 [ %433, %432 ], [ 0, %368 ]
%408 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %406
%409 = load i32, i32* %408
%410 = icmp sgt i32 %409, -1
br i1 %410, label %411, label %432
411: ; preds = %405
%412 = icmp ne i64 %406, 0
%413 = icmp sgt i32 %407, 0
%414 = select i1 %412, i1 %413, i1 false
br i1 %414, label %415, label %426
415: ; preds = %411
%416 = add nuw i64 %406, 4294967295
%417 = and i64 %416, 4294967295
%418 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %417
%419 = load i32, i32* %418
%420 = add nsw i32 %407, -1
%421 = icmp eq i32 %419, %420
br i1 %421, label %422, label %426
422: ; preds = %415
store i32 %419, i32* %408
%423 = zext i32 %419 to i64
%424 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %423, i32 1
%425 = trunc i64 %406 to i32
store i32 %425, i32* %424
br label %432
426: ; preds = %415, %411
%427 = add nsw i32 %407, 1
store i32 %407, i32* %408
%428 = sext i32 %407 to i64
%429 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %428, i32 1
%430 = trunc i64 %406 to i32
store i32 %430, i32* %429
%431 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %428, i32 0
store i32 %430, i32* %431
br label %432
432: ; preds = %405, %426, %422
%433 = phi i32 [ %407, %422 ], [ %427, %426 ], [ %407, %405 ]
%434 = add nuw nsw i64 %406, 1
%435 = icmp eq i64 %434, 16
br i1 %435, label %371, label %405
436: ; preds = %398
%437 = icmp eq i32 %433, 1
%438 = zext i32 %433 to i64
br label %439
439: ; preds = %436, %535
%440 = phi i64 [ 0, %436 ], [ %537, %535 ]
%441 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.10, i64 0, i64 0), i8* %20)
br i1 %437, label %446, label %442
442: ; preds = %439
%443 = trunc i64 %440 to i32
%444 = add i32 %443, 1
%445 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i32 %444)
br label %446
446: ; preds = %442, %439
%447 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %440, i32 1
%448 = load i32, i32* %447
%449 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %440, i32 0
%450 = load i32, i32* %449
%451 = sub nsw i32 %448, %450
%452 = shl i32 %451, 4
%453 = add i32 %452, 16
%454 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0), i32 %453)
%455 = icmp slt i32 %448, %450
br i1 %455, label %535, label %456
456: ; preds = %446
%457 = zext i32 %450 to i64
%458 = add i32 %448, 1
br label %459
459: ; preds = %456, %459
%460 = phi i64 [ %457, %456 ], [ %532, %459 ]
%461 = trunc i64 %460 to i32
%462 = shl nsw i32 %461, 4
%463 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.13, i64 0, i64 0), i32 %462)
%464 = sext i32 %462 to i64
%465 = call i32 @fputc(i32 32, i32* %262)
%466 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %464
%467 = load i32, i32* %466
%468 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %467)
%469 = or i64 %464, 1
%470 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %469
%471 = load i32, i32* %470
%472 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %471)
%473 = or i64 %464, 2
%474 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %473
%475 = load i32, i32* %474
%476 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %475)
%477 = or i64 %464, 3
%478 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %477
%479 = load i32, i32* %478
%480 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %479)
%481 = or i64 %464, 4
%482 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %481
%483 = load i32, i32* %482
%484 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %483)
%485 = or i64 %464, 5
%486 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %485
%487 = load i32, i32* %486
%488 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %487)
%489 = or i64 %464, 6
%490 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %489
%491 = load i32, i32* %490
%492 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %491)
%493 = or i64 %464, 7
%494 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %493
%495 = load i32, i32* %494
%496 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %495)
%497 = call i32 @fputc(i32 10, i32* %262)
%498 = call i32 @fputc(i32 32, i32* %262)
%499 = or i64 %464, 8
%500 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %499
%501 = load i32, i32* %500
%502 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %501)
%503 = or i64 %464, 9
%504 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %503
%505 = load i32, i32* %504
%506 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %505)
%507 = or i64 %464, 10
%508 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %507
%509 = load i32, i32* %508
%510 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %509)
%511 = or i64 %464, 11
%512 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %511
%513 = load i32, i32* %512
%514 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %513)
%515 = or i64 %464, 12
%516 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %515
%517 = load i32, i32* %516
%518 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %517)
%519 = or i64 %464, 13
%520 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %519
%521 = load i32, i32* %520
%522 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %521)
%523 = or i64 %464, 14
%524 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %523
%525 = load i32, i32* %524
%526 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %525)
%527 = or i64 %464, 15
%528 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %527
%529 = load i32, i32* %528
%530 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.15, i64 0, i64 0), i32 %529)
%531 = call i32 @fputc(i32 10, i32* %262)
%532 = add i64 %460, 1
%533 = trunc i64 %532 to i32
%534 = icmp eq i32 %458, %533
br i1 %534, label %535, label %459
535: ; preds = %459, %446
%536 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.16, i64 0, i64 0), i64 3, i64 1, i32* %262)
%537 = add nuw nsw i64 %440, 1
%538 = icmp eq i64 %537, %438
br i1 %538, label %539, label %439
539: ; preds = %535
%540 = call i32 @fputc(i32 10, i32* %262)
br label %541
541: ; preds = %539, %398
%542 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.17, i64 0, i64 0), i8* %20)
%543 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.18, i64 0, i64 0), i64 2, i64 1, i32* %262)
%544 = call i64 @fwrite(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.19, i64 0, i64 0), i64 24, i64 1, i32* %262)
%545 = icmp sgt i32 %433, 1
br i1 %403, label %667, label %546
546: ; preds = %541, %660
%547 = phi i32 [ %659, %660 ], [ 0, %541 ]
%548 = phi i32 [ %563, %660 ], [ 0, %541 ]
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %549
%551 = load i32, i32* %550
br label %552
552: ; preds = %546, %556
%553 = phi i64 [ %549, %546 ], [ %554, %556 ]
%554 = add nsw i64 %553, 1
%555 = icmp eq i64 %554, 16
br i1 %555, label %562, label %556
556: ; preds = %552
%557 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %554
%558 = load i32, i32* %557
%559 = icmp eq i32 %558, %551
br i1 %559, label %552, label %560
560: ; preds = %556
%561 = trunc i64 %554 to i32
br label %562
562: ; preds = %552, %560
%563 = phi i32 [ %561, %560 ], [ 16, %552 ]
%564 = icmp eq i32 %548, 0
%565 = icmp eq i32 %563, 16
%566 = select i1 %564, i1 %565, i1 false
%567 = select i1 %566, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.21, i64 0, i64 0)
br i1 %564, label %568, label %572
568: ; preds = %562
br i1 %565, label %578, label %569
569: ; preds = %568
%570 = shl nsw i32 %563, 4
%571 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.22, i64 0, i64 0), i32 %570)
br label %578
572: ; preds = %562
br i1 %565, label %573, label %575
573: ; preds = %572
%574 = call i64 @fwrite(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.23, i64 0, i64 0), i64 9, i64 1, i32* %262)
br label %578
575: ; preds = %572
%576 = shl nsw i32 %563, 4
%577 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.24, i64 0, i64 0), i32 %576)
br label %578
578: ; preds = %573, %575, %569, %568
switch i32 %551, label %579 [
i32 -2, label %658
i32 -1, label %649
]
579: ; preds = %578
%580 = call i32 @fputs(i8* %567, i32* %262)
%581 = shl i32 %548, 4
%582 = shl i32 %563, 4
%583 = icmp slt i32 %581, %582
br i1 %583, label %584, label %627
584: ; preds = %579
%585 = sext i32 %581 to i64
%586 = sext i32 %582 to i64
%587 = sub nsw i64 %586, %585
%588 = icmp eq i64 %587, 0
br i1 %588, label %613, label %589
589: ; preds = %584, %589
%590 = phi i64 [ %604, %589 ], [ 0, %584 ]
%591 = phi <4 x i32> [ %602, %589 ], [ zeroinitializer, %584 ]
%592 = phi <4 x i32> [ %603, %589 ], [ zeroinitializer, %584 ]
%593 = add i64 %590, %585
%594 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %593
%595 = bitcast i32* %594 to <4 x i32>*
%596 = load <4 x i32>, <4 x i32>* %595
%597 = getelementptr inbounds i32, i32* %594, i64 4
%598 = bitcast i32* %597 to <4 x i32>*
%599 = load <4 x i32>, <4 x i32>* %598
%600 = icmp eq <4 x i32> %596, <i32 65533, i32 65533, i32 65533, i32 65533>
%601 = icmp eq <4 x i32> %599, <i32 65533, i32 65533, i32 65533, i32 65533>
%602 = select <4 x i1> %600, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> %591
%603 = select <4 x i1> %601, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> %592
%604 = add nuw i64 %590, 8
%605 = icmp eq i64 %604, %587
br i1 %605, label %606, label %589
606: ; preds = %589
%607 = icmp eq <4 x i32> %602, zeroinitializer
%608 = select <4 x i1> %607, <4 x i32> %603, <4 x i32> %602
%609 = icmp ne <4 x i32> %608, zeroinitializer
%610 = bitcast <4 x i1> %609 to i4
%611 = icmp ne i4 %610, 0
%612 = zext i1 %611 to i32
br label %622
613: ; preds = %584, %613
%614 = phi i64 [ %620, %613 ], [ %585, %584 ]
%615 = phi i32 [ %619, %613 ], [ 0, %584 ]
%616 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %614
%617 = load i32, i32* %616
%618 = icmp eq i32 %617, 65533
%619 = select i1 %618, i32 1, i32 %615
%620 = add nsw i64 %614, 1
%621 = icmp eq i64 %620, %586
br i1 %621, label %622, label %613
622: ; preds = %613, %606
%623 = phi i32 [ %612, %606 ], [ %619, %613 ]
%624 = icmp eq i32 %623, 0
br i1 %624, label %627, label %625
625: ; preds = %622
%626 = call i64 @fwrite(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.28, i64 0, i64 0), i64 20, i64 1, i32* %262)
br label %629
627: ; preds = %579, %622
%628 = call i64 @fwrite(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.29, i64 0, i64 0), i64 16, i64 1, i32* %262)
br label %629
629: ; preds = %627, %625
%630 = phi i1 [ true, %627 ], [ false, %625 ]
%631 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8* %20)
br i1 %545, label %632, label %635
632: ; preds = %629
%633 = add nsw i32 %551, 1
%634 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i32 %633)
br label %635
635: ; preds = %632, %629
%636 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.31, i64 0, i64 0), i64 2, i64 1, i32* %262)
%637 = sext i32 %551 to i64
%638 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %637, i32 0
%639 = load i32, i32* %638
%640 = icmp sgt i32 %639, 0
br i1 %640, label %641, label %644
641: ; preds = %635
%642 = shl nsw i32 %639, 4
%643 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.32, i64 0, i64 0), i32 %642)
br label %644
644: ; preds = %641, %635
%645 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.33, i64 0, i64 0), i64 3, i64 1, i32* %262)
br i1 %630, label %654, label %646
646: ; preds = %644
%647 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.34, i64 0, i64 0), i8* %567)
%648 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.35, i64 0, i64 0), i8* %567)
br label %649
649: ; preds = %578, %646
%650 = phi i8* [ getelementptr inbounds ([15 x i8], [15 x i8]* @.str.36, i64 0, i64 0), %646 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.25, i64 0, i64 0), %578 ]
%651 = phi i8* [ getelementptr inbounds ([5 x i8], [5 x i8]* @.str.37, i64 0, i64 0), %646 ], [ getelementptr inbounds ([13 x i8], [13 x i8]* @.str.26, i64 0, i64 0), %578 ]
%652 = phi i32 [ 1, %646 ], [ %547, %578 ]
%653 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* %650, i8* %567)
br label %654
654: ; preds = %649, %644
%655 = phi i8* [ getelementptr inbounds ([13 x i8], [13 x i8]* @.str.26, i64 0, i64 0), %644 ], [ %651, %649 ]
%656 = phi i32 [ %547, %644 ], [ %652, %649 ]
%657 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* %655, i8* %567)
br label %658
658: ; preds = %654, %578
%659 = phi i32 [ 1, %578 ], [ %656, %654 ]
br i1 %566, label %663, label %660
660: ; preds = %658
%661 = call i64 @fwrite(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.38, i64 0, i64 0), i64 4, i64 1, i32* %262)
%662 = icmp slt i32 %563, 16
br i1 %662, label %546, label %663
663: ; preds = %658, %660
%664 = icmp eq i32 %659, 0
br i1 %664, label %719, label %665
665: ; preds = %663
%666 = call i64 @fwrite(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.39, i64 0, i64 0), i64 20, i64 1, i32* %262)
br label %719
667: ; preds = %541, %715
%668 = phi i32 [ %695, %715 ], [ 0, %541 ]
%669 = sext i32 %668 to i64
%670 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %669
%671 = load i32, i32* %670
br label %672
672: ; preds = %667, %676
%673 = phi i64 [ %669, %667 ], [ %674, %676 ]
%674 = add nsw i64 %673, 1
%675 = icmp eq i64 %674, 16
br i1 %675, label %684, label %676
676: ; preds = %672
%677 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %674
%678 = load i32, i32* %677
%679 = icmp eq i32 %678, %671
br i1 %679, label %672, label %680
680: ; preds = %676
%681 = trunc i64 %674 to i32
%682 = icmp eq i32 %668, 0
%683 = shl nsw i32 %681, 4
br i1 %682, label %688, label %692
684: ; preds = %672
%685 = icmp eq i32 %668, 0
br i1 %685, label %686, label %690
686: ; preds = %684
%687 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0), i64 2, i64 1, i32* %262)
br label %694
688: ; preds = %680
%689 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.40, i64 0, i64 0), i32 %683)
br label %694
690: ; preds = %684
%691 = call i64 @fwrite(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.41, i64 0, i64 0), i64 11, i64 1, i32* %262)
br label %694
692: ; preds = %680
%693 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.42, i64 0, i64 0), i32 %683)
br label %694
694: ; preds = %690, %692, %686, %688
%695 = phi i32 [ 16, %690 ], [ %681, %692 ], [ 16, %686 ], [ %681, %688 ]
%696 = icmp eq i32 %671, -1
br i1 %696, label %697, label %699
697: ; preds = %694
%698 = call i64 @fwrite(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.43, i64 0, i64 0), i64 19, i64 1, i32* %262)
br label %715
699: ; preds = %694
%700 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.44, i64 0, i64 0), i8* %20)
br i1 %545, label %701, label %704
701: ; preds = %699
%702 = add nuw nsw i32 %671, 1
%703 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i32 %702)
br label %704
704: ; preds = %701, %699
%705 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.31, i64 0, i64 0), i64 2, i64 1, i32* %262)
%706 = sext i32 %671 to i64
%707 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %706, i32 0
%708 = load i32, i32* %707
%709 = icmp sgt i32 %708, 0
br i1 %709, label %710, label %713
710: ; preds = %704
%711 = shl nsw i32 %708, 4
%712 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.32, i64 0, i64 0), i32 %711)
br label %713
713: ; preds = %710, %704
%714 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.33, i64 0, i64 0), i64 3, i64 1, i32* %262)
br label %715
715: ; preds = %713, %697
%716 = icmp slt i32 %695, 16
br i1 %716, label %667, label %717
717: ; preds = %715
%718 = call i64 @fwrite(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.45, i64 0, i64 0), i64 12, i64 1, i32* %262)
br label %719
719: ; preds = %663, %665, %717
%720 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.46, i64 0, i64 0), i64 2, i64 1, i32* %262)
%721 = call i32 @fputc(i32 10, i32* %262)
%722 = bitcast [8192 x i32]* %9 to i8*
%723 = bitcast [8192 x %struct.anon.0]* %10 to i8*
br label %724
724: ; preds = %742, %719
%725 = phi i64 [ 0, %719 ], [ %743, %742 ]
%726 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %725
%727 = load i32, i32* %726
%728 = icmp eq i32 %727, 65533
br i1 %728, label %733, label %729
729: ; preds = %724
%730 = sext i32 %727 to i64
%731 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %730
%732 = trunc i64 %725 to i32
store i32 %732, i32* %731
br label %733
733: ; preds = %724, %729
%734 = or i64 %725, 1
%735 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %734
%736 = load i32, i32* %735
%737 = icmp eq i32 %736, 65533
br i1 %737, label %742, label %738
738: ; preds = %733
%739 = sext i32 %736 to i64
%740 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %739
%741 = trunc i64 %734 to i32
store i32 %741, i32* %740
br label %742
742: ; preds = %738, %733
%743 = add nuw nsw i64 %725, 2
%744 = icmp eq i64 %743, 256
br i1 %744, label %745, label %724
745: ; preds = %742, %799
%746 = phi i64 [ %800, %799 ], [ 0, %742 ]
%747 = shl nsw i64 %746, 3
%748 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %747
%749 = bitcast i32* %748 to <8 x i32>*
%750 = load <8 x i32>, <8 x i32>* %749
%751 = freeze <8 x i32> %750
%752 = icmp ne <8 x i32> %751, zeroinitializer
%753 = bitcast <8 x i1> %752 to i8
%754 = icmp eq i8 %753, 0
br i1 %754, label %755, label %757
755: ; preds = %745
%756 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %746
store i32 -2, i32* %756
br label %799
757: ; preds = %745
%758 = or i64 %747, 7
%759 = or i64 %747, 6
%760 = or i64 %747, 5
%761 = or i64 %747, 4
%762 = or i64 %747, 3
%763 = or i64 %747, 2
%764 = or i64 %747, 1
%765 = extractelement <8 x i32> %751, i64 7
%766 = zext i32 %765 to i64
%767 = icmp ne i64 %758, %766
%768 = extractelement <8 x i32> %751, i64 0
%769 = zext i32 %768 to i64
%770 = icmp ne i64 %747, %769
%771 = extractelement <8 x i32> %751, i64 1
%772 = zext i32 %771 to i64
%773 = icmp ne i64 %764, %772
%774 = extractelement <8 x i32> %751, i64 2
%775 = zext i32 %774 to i64
%776 = icmp ne i64 %763, %775
%777 = extractelement <8 x i32> %751, i64 3
%778 = zext i32 %777 to i64
%779 = icmp ne i64 %762, %778
%780 = extractelement <8 x i32> %751, i64 4
%781 = zext i32 %780 to i64
%782 = icmp ne i64 %761, %781
%783 = extractelement <8 x i32> %751, i64 5
%784 = zext i32 %783 to i64
%785 = icmp ne i64 %760, %784
%786 = extractelement <8 x i32> %751, i64 6
%787 = zext i32 %786 to i64
%788 = icmp ne i64 %759, %787
%789 = or i1 %767, %788
%790 = select i1 %789, i1 true, i1 %785
%791 = select i1 %790, i1 true, i1 %782
%792 = select i1 %791, i1 true, i1 %779
%793 = select i1 %792, i1 true, i1 %776
%794 = select i1 %793, i1 true, i1 %773
%795 = select i1 %794, i1 true, i1 %770
%796 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %746
br i1 %795, label %798, label %797
797: ; preds = %757
store i32 -1, i32* %796
br label %799
798: ; preds = %757
store i32 0, i32* %796
br label %799
799: ; preds = %797, %798, %755
%800 = add nuw nsw i64 %746, 1
%801 = icmp eq i64 %800, 8192
br i1 %801, label %802, label %745
802: ; preds = %799
%803 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 0
%804 = load i32, i32* %803
%805 = icmp sgt i32 %804, -1
br i1 %805, label %806, label %809
806: ; preds = %802
store i32 0, i32* %803
%807 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 0, i32 1
store i32 0, i32* %807
%808 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 0, i32 0
store i32 0, i32* %808
br label %809
809: ; preds = %802, %806
%810 = phi i32 [ 0, %806 ], [ %804, %802 ]
%811 = phi i32 [ 1, %806 ], [ 0, %802 ]
br label %816
812: ; preds = %855
%813 = icmp sgt i32 %856, 0
br i1 %813, label %814, label %1013
814: ; preds = %812
%815 = zext i32 %856 to i64
br label %862
816: ; preds = %809, %855
%817 = phi i64 [ 1, %809 ], [ %857, %855 ]
%818 = phi i32 [ %811, %809 ], [ %856, %855 ]
%819 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %817
%820 = load i32, i32* %819
%821 = icmp sgt i32 %820, -1
br i1 %821, label %822, label %855
822: ; preds = %816
%823 = icmp sgt i32 %818, 0
br i1 %823, label %826, label %824
824: ; preds = %822
%825 = trunc i64 %817 to i32
br label %849
826: ; preds = %822
%827 = add nuw i64 %817, 4294967295
%828 = and i64 %827, 4294967295
%829 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %828
%830 = load i32, i32* %829
%831 = add nsw i32 %818, -1
%832 = icmp eq i32 %830, %831
%833 = zext i32 %831 to i64
br i1 %832, label %834, label %836
834: ; preds = %826
%835 = trunc i64 %817 to i32
br label %846
836: ; preds = %826
%837 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %833, i32 1
%838 = load i32, i32* %837
%839 = ashr i32 %838, 5
%840 = trunc i64 %817 to i32
%841 = lshr i32 %840, 5
%842 = icmp eq i32 %839, %841
%843 = sub nsw i32 %840, %838
%844 = icmp slt i32 %843, 9
%845 = select i1 %842, i1 %844, i1 false
br i1 %845, label %846, label %849
846: ; preds = %834, %836
%847 = phi i32 [ %835, %834 ], [ %840, %836 ]
store i32 %831, i32* %819
%848 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %833, i32 1
store i32 %847, i32* %848
br label %855
849: ; preds = %824, %836
%850 = phi i32 [ %825, %824 ], [ %840, %836 ]
%851 = add nsw i32 %818, 1
store i32 %818, i32* %819
%852 = sext i32 %818 to i64
%853 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %852, i32 1
store i32 %850, i32* %853
%854 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %852, i32 0
store i32 %850, i32* %854
br label %855
855: ; preds = %816, %849, %846
%856 = phi i32 [ %818, %846 ], [ %851, %849 ], [ %818, %816 ]
%857 = add nuw nsw i64 %817, 1
%858 = icmp eq i64 %857, 8192
br i1 %858, label %812, label %816
859: ; preds = %896
br i1 %813, label %860, label %1013
860: ; preds = %859
%861 = zext i32 %856 to i64
br label %902
862: ; preds = %814, %896
%863 = phi i64 [ 0, %814 ], [ %897, %896 ]
%864 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %863, i32 2
store i32 0, i32* %864
%865 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %863, i32 0
%866 = load i32, i32* %865
%867 = shl i32 %866, 3
%868 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %863, i32 1
%869 = load i32, i32* %868
%870 = shl i32 %869, 3
%871 = add i32 %870, 8
%872 = icmp slt i32 %867, %871
br i1 %872, label %873, label %896
873: ; preds = %862
%874 = sext i32 %867 to i64
%875 = sext i32 %871 to i64
br label %876
876: ; preds = %892, %873
%877 = phi i32 [ 0, %873 ], [ %893, %892 ]
%878 = phi i64 [ %874, %873 ], [ %894, %892 ]
%879 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %878
%880 = load i32, i32* %879
%881 = icmp eq i32 %880, 0
br i1 %881, label %884, label %882
882: ; preds = %876
%883 = add nsw i32 %877, 1
store i32 %883, i32* %864
br label %884
884: ; preds = %876, %882
%885 = phi i32 [ %877, %876 ], [ %883, %882 ]
%886 = or i64 %878, 1
%887 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %886
%888 = load i32, i32* %887
%889 = icmp eq i32 %888, 0
br i1 %889, label %892, label %890
890: ; preds = %884
%891 = add nsw i32 %885, 1
store i32 %891, i32* %864
br label %892
892: ; preds = %890, %884
%893 = phi i32 [ %885, %884 ], [ %891, %890 ]
%894 = add nsw i64 %878, 2
%895 = icmp eq i64 %894, %875
br i1 %895, label %896, label %876
896: ; preds = %892, %862
%897 = add nuw nsw i64 %863, 1
%898 = icmp eq i64 %897, %815
br i1 %898, label %859, label %862
899: ; preds = %921
br i1 %813, label %900, label %1013
900: ; preds = %899
%901 = zext i32 %856 to i64
br label %928
902: ; preds = %860, %921
%903 = phi i64 [ 0, %860 ], [ %926, %921 ]
%904 = phi i32 [ -1, %860 ], [ %924, %921 ]
%905 = phi i32 [ 0, %860 ], [ %923, %921 ]
%906 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %903, i32 2
%907 = load i32, i32* %906
%908 = icmp sgt i32 %907, 1
br i1 %908, label %909, label %921
909: ; preds = %902
%910 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %903, i32 0
%911 = load i32, i32* %910
%912 = ashr i32 %911, 5
%913 = icmp eq i32 %904, %912
br i1 %913, label %914, label %918
914: ; preds = %909
%915 = call dereferenceable_or_null(6) i8* @malloc(i32 6)
%916 = add nsw i32 %905, 1
%917 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* dereferenceable(1) %915, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i32 %904, i32 %916)
br label %921
918: ; preds = %909
%919 = call dereferenceable_or_null(3) i8* @malloc(i32 3)
%920 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* dereferenceable(1) %919, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.48, i64 0, i64 0), i32 %912)
br label %921
921: ; preds = %902, %914, %918
%922 = phi i8* [ %915, %914 ], [ %919, %918 ], [ null, %902 ]
%923 = phi i32 [ %916, %914 ], [ %905, %918 ], [ %905, %902 ]
%924 = phi i32 [ %904, %914 ], [ %912, %918 ], [ %904, %902 ]
%925 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %903, i32 3
store i8* %922, i8** %925
%926 = add nuw nsw i64 %903, 1
%927 = icmp eq i64 %926, %861
br i1 %927, label %899, label %902
928: ; preds = %900, %1005
%929 = phi i64 [ 0, %900 ], [ %1007, %1005 ]
%930 = phi i32 [ -1, %900 ], [ %1006, %1005 ]
%931 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %929, i32 2
%932 = load i32, i32* %931
%933 = icmp sgt i32 %932, 1
br i1 %933, label %934, label %1005
934: ; preds = %928
%935 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %929, i32 3
%936 = load i8*, i8** %935
%937 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %929, i32 1
%938 = load i32, i32* %937
%939 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %929, i32 0
%940 = load i32, i32* %939
%941 = sub nsw i32 %938, %940
%942 = shl i32 %941, 3
%943 = add i32 %942, 8
%944 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.49, i64 0, i64 0), i8* %20, i8* %936, i32 %943)
%945 = load i32, i32* %937
%946 = icmp sgt i32 %940, %945
br i1 %946, label %1003, label %947
947: ; preds = %934
%948 = sext i32 %940 to i64
br label %949
949: ; preds = %947, %961
%950 = phi i64 [ %948, %947 ], [ %999, %961 ]
%951 = trunc i64 %950 to i32
%952 = srem i32 %951, 32
%953 = icmp eq i32 %952, 0
br i1 %953, label %954, label %961
954: ; preds = %949
%955 = load i32, i32* %939
%956 = sext i32 %955 to i64
%957 = icmp sgt i64 %950, %956
br i1 %957, label %958, label %961
958: ; preds = %954
%959 = shl nsw i32 %951, 3
%960 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.50, i64 0, i64 0), i32 %959)
br label %961
961: ; preds = %958, %954, %949
%962 = call i32 @fputc(i32 32, i32* %262)
%963 = shl nsw i32 %951, 3
%964 = sext i32 %963 to i64
%965 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %964
%966 = load i32, i32* %965
%967 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.51, i64 0, i64 0), i32 %966)
%968 = or i64 %964, 1
%969 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %968
%970 = load i32, i32* %969
%971 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.51, i64 0, i64 0), i32 %970)
%972 = or i64 %964, 2
%973 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %972
%974 = load i32, i32* %973
%975 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.51, i64 0, i64 0), i32 %974)
%976 = or i64 %964, 3
%977 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %976
%978 = load i32, i32* %977
%979 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.51, i64 0, i64 0), i32 %978)
%980 = or i64 %964, 4
%981 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %980
%982 = load i32, i32* %981
%983 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.51, i64 0, i64 0), i32 %982)
%984 = or i64 %964, 5
%985 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %984
%986 = load i32, i32* %985
%987 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.51, i64 0, i64 0), i32 %986)
%988 = or i64 %964, 6
%989 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %988
%990 = load i32, i32* %989
%991 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.51, i64 0, i64 0), i32 %990)
%992 = or i64 %964, 7
%993 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %992
%994 = load i32, i32* %993
%995 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.51, i64 0, i64 0), i32 %994)
%996 = shl nsw i32 %952, 3
%997 = or i32 %996, 7
%998 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.52, i64 0, i64 0), i32 %996, i32 %997)
%999 = add nsw i64 %950, 1
%1000 = load i32, i32* %937
%1001 = sext i32 %1000 to i64
%1002 = icmp slt i64 %950, %1001
br i1 %1002, label %949, label %1003
1003: ; preds = %961, %934
%1004 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.16, i64 0, i64 0), i64 3, i64 1, i32* %262)
br label %1005
1005: ; preds = %928, %1003
%1006 = phi i32 [ 0, %1003 ], [ %930, %928 ]
%1007 = add nuw nsw i64 %929, 1
%1008 = icmp eq i64 %1007, %901
br i1 %1008, label %1009, label %928
1009: ; preds = %1005
%1010 = icmp sgt i32 %1006, -1
br i1 %1010, label %1011, label %1013
1011: ; preds = %1009
%1012 = call i32 @fputc(i32 10, i32* %262)
br label %1013
1013: ; preds = %812, %859, %899, %1011, %1009
br label %1014
1014: ; preds = %1013, %1046
%1015 = phi i32 [ %1049, %1046 ], [ %810, %1013 ]
%1016 = phi i32 [ %1038, %1046 ], [ 0, %1013 ]
%1017 = phi i32 [ %1044, %1046 ], [ 0, %1013 ]
%1018 = sext i32 %1016 to i64
br label %1019
1019: ; preds = %1014, %1023
%1020 = phi i64 [ %1018, %1014 ], [ %1021, %1023 ]
%1021 = add nsw i64 %1020, 1
%1022 = icmp eq i64 %1021, 8192
br i1 %1022, label %1029, label %1023
1023: ; preds = %1019
%1024 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %1021
%1025 = load i32, i32* %1024
%1026 = icmp eq i32 %1025, %1015
br i1 %1026, label %1019, label %1027
1027: ; preds = %1023
%1028 = trunc i64 %1021 to i32
br label %1029
1029: ; preds = %1019, %1027
%1030 = phi i32 [ %1028, %1027 ], [ 8192, %1019 ]
%1031 = icmp sgt i32 %1015, -1
br i1 %1031, label %1032, label %1037
1032: ; preds = %1029
%1033 = zext i32 %1015 to i64
%1034 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1033, i32 1
%1035 = load i32, i32* %1034
%1036 = add nsw i32 %1035, 1
br label %1037
1037: ; preds = %1032, %1029
%1038 = phi i32 [ %1036, %1032 ], [ %1030, %1029 ]
%1039 = icmp eq i32 %1015, -2
%1040 = icmp eq i32 %1015, -1
%1041 = icmp eq i32 %1016, 0
%1042 = select i1 %1040, i1 %1041, i1 false
%1043 = select i1 %1039, i1 true, i1 %1042
%1044 = select i1 %1043, i32 %1017, i32 1
%1045 = icmp slt i32 %1038, 8192
br i1 %1045, label %1046, label %1050
1046: ; preds = %1037
%1047 = sext i32 %1038 to i64
%1048 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %1047
%1049 = load i32, i32* %1048
br label %1014
1050: ; preds = %1037
%1051 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.53, i64 0, i64 0), i8* %20)
%1052 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.18, i64 0, i64 0), i64 2, i64 1, i32* %262)
%1053 = icmp eq i32 %1044, 0
br i1 %1053, label %1056, label %1054
1054: ; preds = %1050
%1055 = call i64 @fwrite(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.54, i64 0, i64 0), i64 23, i64 1, i32* %262)
br label %1056
1056: ; preds = %1054, %1050
%1057 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 0
%1058 = load i32, i32* %1057
%1059 = icmp eq i32 %1058, 0
br label %1060
1060: ; preds = %1056, %1181
%1061 = phi i32 [ %810, %1056 ], [ %1184, %1181 ]
%1062 = phi i32 [ 0, %1056 ], [ %1178, %1181 ]
%1063 = phi i32 [ 0, %1056 ], [ %1179, %1181 ]
%1064 = sext i32 %1062 to i64
br label %1065
1065: ; preds = %1060, %1069
%1066 = phi i64 [ %1064, %1060 ], [ %1067, %1069 ]
%1067 = add nsw i64 %1066, 1
%1068 = icmp eq i64 %1067, 8192
br i1 %1068, label %1075, label %1069
1069: ; preds = %1065
%1070 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %1067
%1071 = load i32, i32* %1070
%1072 = icmp eq i32 %1071, %1061
br i1 %1072, label %1065, label %1073
1073: ; preds = %1069
%1074 = trunc i64 %1067 to i32
br label %1075
1075: ; preds = %1065, %1073
%1076 = phi i32 [ %1074, %1073 ], [ 8192, %1065 ]
%1077 = icmp sgt i32 %1061, -1
br i1 %1077, label %1078, label %1092
1078: ; preds = %1075
%1079 = zext i32 %1061 to i64
%1080 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1079, i32 0
%1081 = load i32, i32* %1080
%1082 = icmp eq i32 %1062, %1081
br i1 %1082, label %1085, label %1083
1083: ; preds = %1078
%1084 = call i32 (...) @abort()
unreachable
1085: ; preds = %1078
%1086 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1079, i32 1
%1087 = load i32, i32* %1086
%1088 = add nsw i32 %1087, 1
%1089 = icmp sgt i32 %1076, %1088
br i1 %1089, label %1090, label %1094
1090: ; preds = %1085
%1091 = call i32 (...) @abort()
unreachable
1092: ; preds = %1075
%1093 = icmp eq i32 %1061, -2
br i1 %1093, label %1177, label %1094
1094: ; preds = %1085, %1092
%1095 = phi i32 [ %1076, %1092 ], [ %1088, %1085 ]
%1096 = icmp eq i32 %1062, 0
br i1 %1096, label %1097, label %1099
1097: ; preds = %1094
%1098 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.20, i64 0, i64 0), i64 2, i64 1, i32* %262)
br label %1101
1099: ; preds = %1094
%1100 = call i64 @fwrite(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.55, i64 0, i64 0), i64 7, i64 1, i32* %262)
br label %1101
1101: ; preds = %1099, %1097
br i1 %1077, label %1102, label %1148
1102: ; preds = %1101
%1103 = zext i32 %1061 to i64
%1104 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1103, i32 2
%1105 = load i32, i32* %1104
switch i32 %1105, label %1148 [
i32 0, label %1106
i32 1, label %1108
]
1106: ; preds = %1102
%1107 = call i32 (...) @abort()
unreachable
1108: ; preds = %1102
%1109 = add nsw i32 %1062, 1
%1110 = icmp eq i32 %1095, %1109
br i1 %1110, label %1113, label %1111
1111: ; preds = %1108
%1112 = call i32 (...) @abort()
unreachable
1113: ; preds = %1108
%1114 = shl i32 %1062, 3
%1115 = shl i32 %1095, 3
%1116 = icmp slt i32 %1114, %1115
br i1 %1116, label %1117, label %1177
1117: ; preds = %1113
%1118 = sext i32 %1114 to i64
br label %1119
1119: ; preds = %1144, %1117
%1120 = phi i64 [ %1118, %1117 ], [ %1145, %1144 ]
%1121 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1120
%1122 = load i32, i32* %1121
%1123 = icmp eq i32 %1122, 0
br i1 %1123, label %1129, label %1124
1124: ; preds = %1139, %1134, %1129, %1119
%1125 = phi i64 [ %1120, %1119 ], [ %1130, %1129 ], [ %1135, %1134 ], [ %1140, %1139 ]
%1126 = phi i32 [ %1122, %1119 ], [ %1132, %1129 ], [ %1137, %1134 ], [ %1142, %1139 ]
%1127 = trunc i64 %1125 to i32
%1128 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.56, i64 0, i64 0), i32 %1127, i32 %1126)
br label %1177
1129: ; preds = %1119
%1130 = or i64 %1120, 1
%1131 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1130
%1132 = load i32, i32* %1131
%1133 = icmp eq i32 %1132, 0
br i1 %1133, label %1134, label %1124
1134: ; preds = %1129
%1135 = or i64 %1120, 2
%1136 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1135
%1137 = load i32, i32* %1136
%1138 = icmp eq i32 %1137, 0
br i1 %1138, label %1139, label %1124
1139: ; preds = %1134
%1140 = or i64 %1120, 3
%1141 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1140
%1142 = load i32, i32* %1141
%1143 = icmp eq i32 %1142, 0
br i1 %1143, label %1144, label %1124
1144: ; preds = %1139
%1145 = add nsw i64 %1120, 4
%1146 = trunc i64 %1145 to i32
%1147 = icmp eq i32 %1115, %1146
br i1 %1147, label %1177, label %1119
1148: ; preds = %1102, %1101
br i1 %1096, label %1149, label %1153
1149: ; preds = %1148
%1150 = shl nsw i32 %1095, 3
%1151 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.57, i64 0, i64 0), i32 %1150)
%1152 = icmp eq i32 %1061, -1
br i1 %1152, label %1158, label %1162
1153: ; preds = %1148
%1154 = shl nsw i32 %1062, 3
%1155 = shl nsw i32 %1095, 3
%1156 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.58, i64 0, i64 0), i32 %1154, i32 %1155)
%1157 = icmp eq i32 %1061, -1
br i1 %1157, label %1160, label %1162
1158: ; preds = %1149
%1159 = call i64 @fwrite(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.59, i64 0, i64 0), i64 34, i64 1, i32* %262)
br label %1177
1160: ; preds = %1153
%1161 = call i64 @fwrite(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.60, i64 0, i64 0), i64 13, i64 1, i32* %262)
br label %1177
1162: ; preds = %1153, %1149
%1163 = sext i32 %1061 to i64
%1164 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1163, i32 3
%1165 = load i8*, i8** %1164
%1166 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.61, i64 0, i64 0), i8* %20, i8* %1165)
%1167 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1163, i32 0
%1168 = load i32, i32* %1167
%1169 = icmp sgt i32 %1168, 0
br i1 %1169, label %1170, label %1173
1170: ; preds = %1162
%1171 = shl nsw i32 %1062, 3
%1172 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.62, i64 0, i64 0), i32 %1171)
br label %1173
1173: ; preds = %1170, %1162
%1174 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.33, i64 0, i64 0), i64 3, i64 1, i32* %262)
%1175 = select i1 %1096, i1 %1059, i1 false
%1176 = select i1 %1175, i32 1, i32 %1063
br label %1177
1177: ; preds = %1144, %1113, %1173, %1124, %1158, %1160, %1092
%1178 = phi i32 [ %1076, %1092 ], [ %1095, %1124 ], [ %1095, %1158 ], [ %1095, %1160 ], [ %1095, %1173 ], [ %1095, %1113 ], [ %1095, %1144 ]
%1179 = phi i32 [ %1063, %1092 ], [ %1063, %1124 ], [ %1063, %1158 ], [ %1063, %1160 ], [ %1176, %1173 ], [ %1063, %1113 ], [ %1063, %1144 ]
%1180 = icmp slt i32 %1178, 8192
br i1 %1180, label %1181, label %1185
1181: ; preds = %1177
%1182 = sext i32 %1178 to i64
%1183 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %1182
%1184 = load i32, i32* %1183
br label %1060
1185: ; preds = %1177
br i1 %1053, label %1196, label %1186
1186: ; preds = %1185
%1187 = icmp eq i32 %1179, 0
br i1 %1187, label %1190, label %1188
1188: ; preds = %1186
%1189 = call i64 @fwrite(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.63, i64 0, i64 0), i64 27, i64 1, i32* %262)
br label %1192
1190: ; preds = %1186
%1191 = call i64 @fwrite(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.64, i64 0, i64 0), i64 16, i64 1, i32* %262)
br label %1192
1192: ; preds = %1190, %1188
%1193 = call i64 @fwrite(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.65, i64 0, i64 0), i64 12, i64 1, i32* %262)
%1194 = call i64 @fwrite(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.66, i64 0, i64 0), i64 14, i64 1, i32* %262)
%1195 = call i64 @fwrite(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.38, i64 0, i64 0), i64 4, i64 1, i32* %262)
br label %1196
1196: ; preds = %1192, %1185
%1197 = call i64 @fwrite(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.39, i64 0, i64 0), i64 20, i64 1, i32* %262)
%1198 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.46, i64 0, i64 0), i64 2, i64 1, i32* %262)
%1199 = call i64 @ferror(i32* %262)
%1200 = icmp eq i64 %1199, 0
br i1 %1200, label %1201, label %1204
1201: ; preds = %1196
%1202 = call i64 @fclose(i32* %262)
%1203 = icmp eq i64 %1202, 0
br i1 %1203, label %1206, label %1204
1204: ; preds = %1201, %1196
%1205 = call i32 @exit(i32 1)
unreachable
1206: ; preds = %1201
%1207 = call i32 @exit(i32 0)
unreachable
}