#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, " * Copyright (C) 1999-2002 Free Software Foundation, Inc.\n");
    fprintf(f, " * This file is part of the GNU LIBICONV Library.\n");
    fprintf(f, " *\n");
    fprintf(f, " * The GNU LIBICONV Library is free software; you can "
               "redistribute it\n");
    fprintf(f, " * and/or modify it under the terms of the GNU Library General "
               "Public\n");
    fprintf(f, " * License as published by the Free Software Foundation; "
               "either version 2\n");
    fprintf(f, " * of the License, or (at your option) any later version.\n");
    fprintf(f, " *\n");
    fprintf(f, " * The GNU LIBICONV Library is distributed in the hope that it "
               "will be\n");
    fprintf(f, " * useful, but WITHOUT ANY WARRANTY; without even the implied "
               "warranty of\n");
    fprintf(f, " * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See "
               "the GNU\n");
    fprintf(f, " * Library General Public License for more details.\n");
    fprintf(f, " *\n");
    fprintf(f, " * You should have received a copy of the GNU Library General "
               "Public\n");
    fprintf(f, " * License along with the GNU LIBICONV Library; see the file "
               "COPYING.LIB.\n");
    fprintf(f, " * If not, write to the Free Software Foundation, Inc., 59 "
               "Temple Place -\n");
    fprintf(f, " * Suite 330, Boston, MA 02111-1307, USA.\n");
    fprintf(f, " */\n");
    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_ILUNI;\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    0x3380(%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    0x293e(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x292d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2953(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2971(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2960(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2992(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x29c4(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x29fa(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2908(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2a0b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2a3e(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2a74(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2aa5(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x289f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2ab0(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2ae1(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2b17(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2b4d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2b99(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2dee(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x279a(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x18(%rbp),%rdx
lea    0x2b20(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2b41(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2d96(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x458(%rbp)
cmpl   $0x10,-0x458(%rbp)
jge    19f7 <main+0x817>
movl   $0x1,-0x53c(%rbp)
movl   $0x1,-0x540(%rbp)
movl   $0x0,-0x45c(%rbp)
cmpl   $0x10,-0x45c(%rbp)
jge    197f <main+0x79f>
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     1942 <main+0x762>
movl   $0x0,-0x53c(%rbp)
movslq -0x454(%rbp),%rax
mov    -0x430(%rbp,%rax,4),%eax
cmp    -0x454(%rbp),%eax
je     1966 <main+0x786>
movl   $0x0,-0x540(%rbp)
jmp    196b <main+0x78b>
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    18fe <main+0x71e>
cmpl   $0x0,-0x53c(%rbp)
je     19a3 <main+0x7c3>
movslq -0x458(%rbp),%rax
movl   $0xfffffffe,-0x4a0(%rbp,%rax,4)
fe ff ff ff
jmp    19de <main+0x7fe>
cmpl   $0x0,-0x540(%rbp)
je     19c7 <main+0x7e7>
movslq -0x458(%rbp),%rax
movl   $0xffffffff,-0x4a0(%rbp,%rax,4)
ff ff ff ff
jmp    19d9 <main+0x7f9>
movslq -0x458(%rbp),%rax
movl   $0x0,-0x4a0(%rbp,%rax,4)
jmp    19de <main+0x7fe>
jmp    19e3 <main+0x803>
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    18d3 <main+0x6f3>
movl   $0x0,-0x4a4(%rbp)
movl   $0x0,-0x458(%rbp)
cmpl   $0x10,-0x458(%rbp)
jge    1b0c <main+0x92c>
movslq -0x458(%rbp),%rax
cmpl   $0x0,-0x4a0(%rbp,%rax,4)
jl     1af3 <main+0x913>
cmpl   $0x0,-0x458(%rbp)
jle    1a9e <main+0x8be>
cmpl   $0x0,-0x4a4(%rbp)
jle    1a9e <main+0x8be>
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    1a9e <main+0x8be>
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    1aee <main+0x90e>
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    1af3 <main+0x913>
jmp    1af8 <main+0x918>
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    1a0b <main+0x82b>
movl   $0x0,-0x534(%rbp)
movl   $0x0,-0x454(%rbp)
cmpl   $0x100,-0x454(%rbp)
jge    1b6b <main+0x98b>
movslq -0x454(%rbp),%rax
cmpl   $0xfffd,-0x430(%rbp,%rax,4)
jne    1b52 <main+0x972>
movl   $0x1,-0x534(%rbp)
jmp    1b57 <main+0x977>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    1b20 <main+0x940>
cmpl   $0x0,-0x4a4(%rbp)
jle    1d75 <main+0xb95>
movl   $0x0,-0x544(%rbp)
mov    -0x544(%rbp),%eax
cmp    -0x4a4(%rbp),%eax
jge    1d60 <main+0xb80>
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x2819(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x1,-0x4a4(%rbp)
jle    1bd8 <main+0x9f8>
mov    -0x448(%rbp),%rdi
mov    -0x544(%rbp),%edx
add    $0x1,%edx
lea    0x29e0(%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    0x29d1(%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     1d37 <main+0xb57>
mov    -0x448(%rbp),%rdi
mov    -0x458(%rbp),%edx
shl    $0x4,%edx
lea    0x278f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x45c(%rbp)
cmpl   $0x2,-0x45c(%rbp)
jge    1d1e <main+0xb3e>
mov    -0x448(%rbp),%rdi
lea    0x28eb(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x460(%rbp)
cmpl   $0x8,-0x460(%rbp)
jge    1cf5 <main+0xb15>
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    0x2719(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x460(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x460(%rbp)
jmp    1c91 <main+0xab1>
mov    -0x448(%rbp),%rdi
lea    0x2955(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    1c65 <main+0xa85>
jmp    1d23 <main+0xb43>
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    1c23 <main+0xa43>
mov    -0x448(%rbp),%rdi
lea    0x26b7(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x544(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x544(%rbp)
jmp    1b82 <main+0x9a2>
mov    -0x448(%rbp),%rdi
lea    0x28ea(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x538(%rbp)
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x266f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x29a2(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2695(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x534(%rbp)
je     2222 <main+0x1042>
movl   $0x0,-0x458(%rbp)
cmpl   $0x10,-0x458(%rbp)
jge    21fb <main+0x101b>
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    1e38 <main+0xc58>
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    1e4b <main+0xc6b>
jmp    1e64 <main+0xc84>
jmp    1e50 <main+0xc70>
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    1e06 <main+0xc26>
xor    %eax,%eax
cmpl   $0x0,-0x458(%rbp)
mov    %al,-0x789ba(%rbp)
jne    1e89 <main+0xca9>
cmpl   $0x10,-0x45c(%rbp)
sete   %al
mov    %al,-0x789ba(%rbp)
mov    -0x789ba(%rbp),%dl
lea    0x26d2(%rip),%rax
lea    0x26cd(%rip),%rcx
test   $0x1,%dl
cmovne %rcx,%rax
mov    %rax,-0x550(%rbp)
cmpl   $0x0,-0x458(%rbp)
jne    1eed <main+0xd0d>
cmpl   $0x10,-0x45c(%rbp)
jne    1eca <main+0xcea>
jmp    1ee8 <main+0xd08>
mov    -0x448(%rbp),%rdi
mov    -0x45c(%rbp),%edx
shl    $0x4,%edx
lea    0x2588(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1f37 <main+0xd57>
cmpl   $0x10,-0x45c(%rbp)
jne    1f14 <main+0xd34>
mov    -0x448(%rbp),%rdi
lea    0x2576(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1f32 <main+0xd52>
mov    -0x448(%rbp),%rdi
mov    -0x45c(%rbp),%edx
shl    $0x4,%edx
lea    0x255d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1f37 <main+0xd57>
cmpl   $0xfffffffe,-0x548(%rbp)
jne    1f53 <main+0xd73>
movl   $0x1,-0x538(%rbp)
jmp    21bb <main+0xfdb>
cmpl   $0xffffffff,-0x548(%rbp)
jne    1f9d <main+0xdbd>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x252d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x2527(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    21b6 <main+0xfd6>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x2513(%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    2024 <main+0xe44>
movslq -0x454(%rbp),%rax
cmpl   $0xfffd,-0x430(%rbp,%rax,4)
jne    200b <main+0xe2b>
movl   $0x1,-0x534(%rbp)
jmp    2010 <main+0xe30>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    1fd2 <main+0xdf2>
cmpl   $0x0,-0x534(%rbp)
je     204b <main+0xe6b>
mov    -0x448(%rbp),%rdi
lea    0x2489(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2060 <main+0xe80>
mov    -0x448(%rbp),%rdi
lea    0x2484(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x2533(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x1,-0x4a4(%rbp)
jle    20a4 <main+0xec4>
mov    -0x448(%rbp),%rdi
mov    -0x548(%rbp),%edx
add    $0x1,%edx
lea    0x2514(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x243c(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movslq -0x548(%rbp),%rax
cmpl   $0x0,-0x530(%rbp,%rax,8)
jle    20f4 <main+0xf14>
mov    -0x448(%rbp),%rdi
movslq -0x548(%rbp),%rax
mov    -0x530(%rbp,%rax,8),%edx
shl    $0x4,%edx
lea    0x2404(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x23f7(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x534(%rbp)
je     2195 <main+0xfb5>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x23d2(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x23cd(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x23ca(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x23bd(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x1,-0x538(%rbp)
jmp    21b1 <main+0xfd1>
mov    -0x448(%rbp),%rdi
mov    -0x550(%rbp),%rdx
lea    0x230e(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    21b6 <main+0xfd6>
jmp    21bb <main+0xfdb>
cmpl   $0x0,-0x458(%rbp)
jne    21d5 <main+0xff5>
cmpl   $0x10,-0x45c(%rbp)
je     21ea <main+0x100a>
mov    -0x448(%rbp),%rdi
lea    0x250a(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x45c(%rbp),%eax
mov    %eax,-0x458(%rbp)
jmp    1dd9 <main+0xbf9>
cmpl   $0x0,-0x538(%rbp)
je     221d <main+0x103d>
mov    -0x448(%rbp),%rdi
lea    0x232b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    244e <main+0x126e>
movl   $0x0,-0x458(%rbp)
cmpl   $0x10,-0x458(%rbp)
jge    2439 <main+0x1259>
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    228b <main+0x10ab>
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    229e <main+0x10be>
jmp    22b7 <main+0x10d7>
jmp    22a3 <main+0x10c3>
mov    -0x45c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x45c(%rbp)
jmp    2259 <main+0x1079>
cmpl   $0x0,-0x458(%rbp)
jne    230e <main+0x112e>
cmpl   $0x10,-0x45c(%rbp)
jne    22eb <main+0x110b>
mov    -0x448(%rbp),%rdi
lea    0x228b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2309 <main+0x1129>
mov    -0x448(%rbp),%rdi
mov    -0x45c(%rbp),%edx
shl    $0x4,%edx
lea    0x2254(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2358 <main+0x1178>
cmpl   $0x10,-0x45c(%rbp)
jne    2335 <main+0x1155>
mov    -0x448(%rbp),%rdi
lea    0x2244(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2353 <main+0x1173>
mov    -0x448(%rbp),%rdi
mov    -0x45c(%rbp),%edx
shl    $0x4,%edx
lea    0x222d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2358 <main+0x1178>
cmpl   $0xffffffff,-0x554(%rbp)
jne    237f <main+0x119f>
mov    -0x448(%rbp),%rdi
lea    0x2131(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2428 <main+0x1248>
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x2204(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x1,-0x4a4(%rbp)
jle    23c3 <main+0x11e3>
mov    -0x448(%rbp),%rdi
mov    -0x554(%rbp),%edx
add    $0x1,%edx
lea    0x21f5(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x211d(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movslq -0x554(%rbp),%rax
cmpl   $0x0,-0x530(%rbp,%rax,8)
jle    2413 <main+0x1233>
mov    -0x448(%rbp),%rdi
movslq -0x554(%rbp),%rax
mov    -0x530(%rbp,%rax,8),%edx
shl    $0x4,%edx
lea    0x20e5(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x20d8(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x45c(%rbp),%eax
mov    %eax,-0x458(%rbp)
jmp    222c <main+0x104c>
mov    -0x448(%rbp),%rdi
lea    0x2313(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x2293(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x21e7(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x78980(%rbp)
cmpl   $0x10000,-0x78980(%rbp)
jge    24b8 <main+0x12d8>
movslq -0x78980(%rbp),%rax
movl   $0x0,-0x40560(%rbp,%rax,4)
mov    -0x78980(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78980(%rbp)
jmp    2482 <main+0x12a2>
movl   $0x0,-0x78984(%rbp)
cmpl   $0x100,-0x78984(%rbp)
jge    24f8 <main+0x1318>
movslq -0x78984(%rbp),%rax
movl   $0x0,-0x40960(%rbp,%rax,4)
mov    -0x78984(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78984(%rbp)
jmp    24c2 <main+0x12e2>
movl   $0x0,-0x7897c(%rbp)
cmpl   $0x100,-0x7897c(%rbp)
jge    2579 <main+0x1399>
movslq -0x7897c(%rbp),%rax
mov    -0x430(%rbp,%rax,4),%eax
mov    %eax,-0x78980(%rbp)
cmpl   $0xfffd,-0x78980(%rbp)
je     2560 <main+0x1380>
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    2565 <main+0x1385>
mov    -0x7897c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7897c(%rbp)
jmp    2502 <main+0x1322>
movl   $0x0,-0x78988(%rbp)
cmpl   $0x2000,-0x78988(%rbp)
jge    26a7 <main+0x14c7>
movl   $0x1,-0x78994(%rbp)
movl   $0x1,-0x78998(%rbp)
movl   $0x0,-0x7898c(%rbp)
cmpl   $0x8,-0x7898c(%rbp)
jge    262f <main+0x144f>
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     25f2 <main+0x1412>
movl   $0x0,-0x78994(%rbp)
movslq -0x78980(%rbp),%rax
mov    -0x40560(%rbp,%rax,4),%eax
cmp    -0x78980(%rbp),%eax
je     2616 <main+0x1436>
movl   $0x0,-0x78998(%rbp)
jmp    261b <main+0x143b>
mov    -0x7898c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7898c(%rbp)
jmp    25b1 <main+0x13d1>
cmpl   $0x0,-0x78994(%rbp)
je     2653 <main+0x1473>
movslq -0x78988(%rbp),%rax
movl   $0xfffffffe,-0x48960(%rbp,%rax,4)
fe ff ff ff
jmp    268e <main+0x14ae>
cmpl   $0x0,-0x78998(%rbp)
je     2677 <main+0x1497>
movslq -0x78988(%rbp),%rax
movl   $0xffffffff,-0x48960(%rbp,%rax,4)
ff ff ff ff
jmp    2689 <main+0x14a9>
movslq -0x78988(%rbp),%rax
movl   $0x0,-0x48960(%rbp,%rax,4)
jmp    268e <main+0x14ae>
jmp    2693 <main+0x14b3>
mov    -0x78988(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78988(%rbp)
jmp    2583 <main+0x13a3>
movl   $0x0,-0x48964(%rbp)
movl   $0x0,-0x78988(%rbp)
cmpl   $0x2000,-0x78988(%rbp)
jge    283c <main+0x165c>
movslq -0x78988(%rbp),%rax
cmpl   $0x0,-0x48960(%rbp,%rax,4)
jl     2823 <main+0x1643>
cmpl   $0x0,-0x48964(%rbp)
jle    27b9 <main+0x15d9>
cmpl   $0x0,-0x78988(%rbp)
jle    271d <main+0x153d>
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     277a <main+0x159a>
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    27b9 <main+0x15d9>
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     27b9 <main+0x15d9>
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    281e <main+0x163e>
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    2823 <main+0x1643>
jmp    2828 <main+0x1648>
mov    -0x78988(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78988(%rbp)
jmp    26bb <main+0x14db>
movl   $0x0,-0x78990(%rbp)
mov    -0x78990(%rbp),%eax
cmp    -0x48964(%rbp),%eax
jge    293b <main+0x175b>
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    2922 <main+0x1742>
movslq -0x78980(%rbp),%rax
cmpl   $0x0,-0x40560(%rbp,%rax,4)
je     2909 <main+0x1729>
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    290e <main+0x172e>
mov    -0x78980(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78980(%rbp)
jmp    28c4 <main+0x16e4>
jmp    2927 <main+0x1747>
mov    -0x78990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78990(%rbp)
jmp    2846 <main+0x1666>
movl   $0x0,-0x78990(%rbp)
movl   $0xffffffff,-0x78984(%rbp)
ff ff ff
movl   $0x0,-0x7897c(%rbp)
mov    -0x78990(%rbp),%eax
cmp    -0x48964(%rbp),%eax
jge    2a99 <main+0x18b9>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1,0x8(%rax)
jle    2a63 <main+0x1883>
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    29f2 <main+0x1812>
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    0x1bc7(%rip),%rsi
mov    $0x0,%al
call   10e0 <sprintf@plt>
jmp    2a3e <main+0x185e>
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    0x1abd(%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    2a80 <main+0x18a0>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movq   $0x0,0x10(%rax)
jmp    2a85 <main+0x18a5>
mov    -0x78990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78990(%rbp)
jmp    2959 <main+0x1779>
movl   $0xffffffff,-0x78984(%rbp)
ff ff ff
movl   $0x0,-0x78990(%rbp)
mov    -0x78990(%rbp),%eax
cmp    -0x48964(%rbp),%eax
jge    2cee <main+0x1b0e>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1,0x8(%rax)
jle    2cd5 <main+0x1af5>
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    0x1a69(%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     2cc0 <main+0x1ae0>
mov    -0x78988(%rbp),%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    2bec <main+0x1a0c>
mov    -0x78988(%rbp),%eax
movslq -0x78990(%rbp),%rdx
lea    -0x78970(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
jle    2bec <main+0x1a0c>
mov    -0x448(%rbp),%rdi
mov    -0x78988(%rbp),%edx
shl    $0x3,%edx
lea    0x19fe(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x1971(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x7898c(%rbp)
cmpl   $0x8,-0x7898c(%rbp)
jge    2c64 <main+0x1a84>
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    0x19aa(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x7898c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7898c(%rbp)
jmp    2c0b <main+0x1a2b>
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    0x1957(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x78988(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78988(%rbp)
jmp    2b70 <main+0x1990>
mov    -0x448(%rbp),%rdi
lea    0x172e(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2cda <main+0x1afa>
mov    -0x78990(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78990(%rbp)
jmp    2aad <main+0x18cd>
cmpl   $0x0,-0x78984(%rbp)
jl     2d10 <main+0x1b30>
mov    -0x448(%rbp),%rdi
lea    0x194f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x78974(%rbp)
movl   $0x0,-0x78988(%rbp)
cmpl   $0x2000,-0x78988(%rbp)
jge    2e25 <main+0x1c45>
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    2d89 <main+0x1ba9>
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    2d9c <main+0x1bbc>
jmp    2db5 <main+0x1bd5>
jmp    2da1 <main+0x1bc1>
mov    -0x7898c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7898c(%rbp)
jmp    2d54 <main+0x1b74>
cmpl   $0x0,-0x78990(%rbp)
jl     2de3 <main+0x1c03>
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     2e14 <main+0x1c34>
cmpl   $0xffffffff,-0x78990(%rbp)
jne    2e0a <main+0x1c2a>
cmpl   $0x0,-0x78988(%rbp)
je     2e14 <main+0x1c34>
movl   $0x1,-0x78974(%rbp)
mov    -0x7898c(%rbp),%eax
mov    %eax,-0x78988(%rbp)
jmp    2d24 <main+0x1b44>
movl   $0x0,-0x78978(%rbp)
mov    -0x448(%rbp),%rdi
mov    -0x20(%rbp),%rdx
lea    0x17d1(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x18f2(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x78974(%rbp)
je     2e7f <main+0x1c9f>
mov    -0x448(%rbp),%rdi
lea    0x17e2(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x78988(%rbp)
cmpl   $0x2000,-0x78988(%rbp)
jge    3260 <main+0x2080>
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    2eee <main+0x1d0e>
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    2f01 <main+0x1d21>
jmp    2f1a <main+0x1d3a>
jmp    2f06 <main+0x1d26>
mov    -0x7898c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7898c(%rbp)
jmp    2eb9 <main+0x1cd9>
cmpl   $0x0,-0x78990(%rbp)
jl     2fa2 <main+0x1dc2>
mov    -0x78988(%rbp),%eax
movslq -0x78990(%rbp),%rdx
lea    -0x78970(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
je     2f51 <main+0x1d71>
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    2f81 <main+0x1da1>
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    2fb4 <main+0x1dd4>
jmp    324f <main+0x206f>
cmpl   $0x0,-0x78988(%rbp)
jne    2fdb <main+0x1dfb>
mov    -0x448(%rbp),%rdi
lea    0x159b(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    2ff0 <main+0x1e10>
mov    -0x448(%rbp),%rdi
lea    0x1689(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x78990(%rbp)
jl     3023 <main+0x1e43>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,0x8(%rax)
jne    3023 <main+0x1e43>
mov    $0x0,%al
call   1030 <abort@plt>
cmpl   $0x0,-0x78990(%rbp)
jl     30f4 <main+0x1f14>
movslq -0x78990(%rbp),%rcx
lea    -0x78970(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1,0x8(%rax)
jne    30f4 <main+0x1f14>
mov    -0x7898c(%rbp),%eax
mov    -0x78988(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
je     306d <main+0x1e8d>
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    30ef <main+0x1f0f>
movslq -0x78980(%rbp),%rax
cmpl   $0x0,-0x40560(%rbp,%rax,4)
je     30d6 <main+0x1ef6>
mov    -0x448(%rbp),%rdi
mov    -0x78980(%rbp),%edx
movslq -0x78980(%rbp),%rax
mov    -0x40560(%rbp,%rax,4),%ecx
lea    0x15b0(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    30ef <main+0x1f0f>
jmp    30db <main+0x1efb>
mov    -0x78980(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78980(%rbp)
jmp    307c <main+0x1e9c>
jmp    324a <main+0x206a>
cmpl   $0x0,-0x78988(%rbp)
jne    3124 <main+0x1f44>
mov    -0x448(%rbp),%rdi
mov    -0x7898c(%rbp),%edx
shl    $0x3,%edx
lea    0x1585(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    314b <main+0x1f6b>
mov    -0x448(%rbp),%rdi
mov    -0x78988(%rbp),%edx
shl    $0x3,%edx
mov    -0x7898c(%rbp),%ecx
shl    $0x3,%ecx
lea    0x156a(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0xffffffff,-0x78990(%rbp)
jne    3199 <main+0x1fb9>
cmpl   $0x0,-0x78988(%rbp)
jne    317f <main+0x1f9f>
mov    -0x448(%rbp),%rdi
lea    0x155c(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    3194 <main+0x1fb4>
mov    -0x448(%rbp),%rdi
lea    0x1565(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    3245 <main+0x2065>
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    0x153c(%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    3207 <main+0x2027>
mov    -0x448(%rbp),%rdi
mov    -0x78988(%rbp),%edx
shl    $0x3,%edx
lea    0x1516(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x12e4(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x78988(%rbp)
jne    3240 <main+0x2060>
cmpl   $0x0,-0x40560(%rbp)
jne    3240 <main+0x2060>
movl   $0x1,-0x78978(%rbp)
jmp    3245 <main+0x2065>
jmp    324a <main+0x206a>
jmp    324f <main+0x206f>
mov    -0x7898c(%rbp),%eax
mov    %eax,-0x78988(%rbp)
jmp    2e89 <main+0x1ca9>
cmpl   $0x0,-0x78974(%rbp)
je     32e8 <main+0x2108>
cmpl   $0x0,-0x78978(%rbp)
je     3294 <main+0x20b4>
mov    -0x448(%rbp),%rdi
lea    0x1496(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    32a9 <main+0x20c9>
mov    -0x448(%rbp),%rdi
lea    0x1498(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x1494(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x148c(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x140c(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x1471(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
lea    0x13e4(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x448(%rbp),%rdi
call   1050 <ferror@plt>
cmp    $0x0,%rax
jne    333e <main+0x215e>
mov    -0x448(%rbp),%rdi
call   1060 <fclose@plt>
cmp    $0x0,%rax
je     3348 <main+0x2168>
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    0x2402(%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    0x23bc(%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
lea    0x18e3(%rip),%r14
mov    $0x3,%esi
mov    $0x1,%edx
mov    %r14,%rdi
mov    %rax,%rcx
call   1130 <fwrite@plt>
lea    0x18cb(%rip),%rdi
mov    $0x3a,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x18ed(%rip),%rdi
mov    $0x32,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x1907(%rip),%rbp
mov    $0x3,%esi
mov    $0x1,%edx
mov    %rbp,%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x18ef(%rip),%rdi
mov    $0x46,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x191d(%rip),%rdi
mov    $0x46,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x194b(%rip),%rdi
mov    $0x4a,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x197d(%rip),%rdi
mov    $0x3a,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    $0x3,%esi
mov    $0x1,%edx
mov    %rbp,%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x198a(%rip),%rdi
mov    $0x47,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x19b9(%rip),%rdi
mov    $0x4a,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x19eb(%rip),%rdi
mov    $0x45,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x1a18(%rip),%rdi
mov    $0x34,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    $0x3,%esi
mov    $0x1,%edx
mov    %rbp,%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x1a1f(%rip),%rdi
mov    $0x45,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x1a4c(%rip),%rdi
mov    $0x4a,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x1a7e(%rip),%rdi
mov    $0x4a,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x1ab0(%rip),%rdi
mov    $0x2a,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x1af8(%rip),%rbp
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbp,%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    $0xa,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
mov    $0x3,%esi
mov    $0x1,%edx
mov    %r14,%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x1a84(%rip),%rsi
mov    %rbx,%rdi
mov    0x10(%rsp),%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbp,%rdi
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 0x1675(%rip),%xmm8
pcmpeqd %xmm0,%xmm0
mov    0x20(%rsp),%r15
jmp    19bb <main+0x79b>
cs nopw 0x0(%rax,%rax,1)
movl   $0xfffffffe,(%rax)
add    $0x4,%rax
add    $0x10,%rcx
cmp    $0x10f,%rcx
je     1b6b <main+0x94b>
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     19a0 <main+0x780>
pshufd $0xff,%xmm4,%xmm5
movd   %xmm5,%edx
cmp    %rdx,%rcx
jne    1b60 <main+0x940>
lea    -0x1(%rcx),%rdx
pshufd $0xee,%xmm4,%xmm5
movd   %xmm5,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0x2(%rcx),%rdx
pshufd $0x55,%xmm4,%xmm5
movd   %xmm5,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0x3(%rcx),%rdx
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0x4(%rcx),%rdx
pshufd $0xff,%xmm3,%xmm4
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0x5(%rcx),%rdx
pshufd $0xee,%xmm3,%xmm4
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0x6(%rcx),%rdx
pshufd $0x55,%xmm3,%xmm4
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0x7(%rcx),%rdx
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0x8(%rcx),%rdx
pshufd $0xff,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0x9(%rcx),%rdx
pshufd $0xee,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0xa(%rcx),%rdx
pshufd $0x55,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0xb(%rcx),%rdx
movd   %xmm2,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0xc(%rcx),%rdx
pshufd $0xff,%xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0xd(%rcx),%rdx
pshufd $0xee,%xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0xe(%rcx),%rdx
pshufd $0x55,%xmm1,%xmm2
movd   %xmm2,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
lea    -0xf(%rcx),%rdx
movd   %xmm1,%esi
cmp    %rsi,%rdx
jne    1b60 <main+0x940>
movl   $0xffffffff,(%rax)
jmp    19a6 <main+0x786>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rax)
jmp    19a6 <main+0x786>
xor    %eax,%eax
xor    %r12d,%r12d
jmp    1bab <main+0x98b>
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     1be2 <main+0x9c2>
cmpl   $0x0,0x8430(%rsp,%rax,4)
js     1ba1 <main+0x981>
test   %rax,%rax
je     1b80 <main+0x960>
test   %r12d,%r12d
jle    1b80 <main+0x960>
lea    -0x1(%rax),%ecx
mov    0x8430(%rsp,%rcx,4),%ecx
lea    -0x1(%r12),%edx
cmp    %edx,%ecx
jne    1b80 <main+0x960>
mov    %ecx,0x8430(%rsp,%rax,4)
mov    %eax,0x38434(%rsp,%rcx,8)
jmp    1ba1 <main+0x981>
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    1c00 <main+0x9e0>
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    1f4b <main+0xd2b>
mov    %r14d,0x1c(%rsp)
mov    %r12d,%eax
mov    %rax,0x28(%rsp)
lea    0x1762(%rip),%r14
xor    %ebp,%ebp
jmp    1ce7 <main+0xac7>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x3,%esi
mov    $0x1,%edx
lea    0x174b(%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     1f39 <main+0xd19>
mov    %rbx,%rdi
lea    0x16de(%rip),%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0x1,%r12d
je     1d15 <main+0xaf5>
lea    0x1(%rbp),%edx
mov    %rbx,%rdi
lea    0x18b0(%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    0x18a6(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
sub    %r15d,%r12d
lea    0x16a2(%rip),%r13
jl     1cb0 <main+0xa90>
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    1d60 <main+0xb40>
jmp    1cb0 <main+0xa90>
mov    $0xa,%edi
mov    %rbx,%rsi
call   10a0 <fputc@plt>
mov    0x1c(%rsp),%r14d
lea    0x14be(%rip),%rsi
mov    %rbx,%rdi
mov    %r15,%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
lea    0x17ef(%rip),%rdi
mov    $0x2,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x14e1(%rip),%rdi
mov    $0x18,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
test   %r14b,%r14b
jne    2114 <main+0xef4>
lea    0x8434(%rsp),%rbp
lea    0x1552(%rip),%r14
lea    0x1556(%rip),%r13
xor    %r15d,%r15d
jmp    1fe3 <main+0xdc3>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x13,%esi
mov    $0x1,%edx
lea    0x14e3(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
cmp    $0x10,%r15d
jge    2462 <main+0x1242>
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     2040 <main+0xe20>
lea    0x1(%rdi),%r15
add    $0x10,%edx
cmp    %r12d,(%rcx,%rdi,4)
mov    %r15,%rdi
je     2010 <main+0xdf0>
add    %rax,%r15
mov    %rbx,%rdi
test   %rax,%rax
je     2082 <main+0xe62>
lea    0x154f(%rip),%rsi
jmp    2089 <main+0xe69>
nopl   0x0(%rax)
test   %rax,%rax
je     2058 <main+0xe38>
mov    $0xb,%esi
mov    $0x1,%edx
lea    0x1524(%rip),%rdi
jmp    2069 <main+0xe49>
mov    $0x2,%esi
mov    $0x1,%edx
lea    0x150e(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    $0x10,%r15d
cmp    $0xffffffff,%r12d
jne    209a <main+0xe7a>
jmp    1fc0 <main+0xda0>
lea    0x14da(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0xffffffff,%r12d
je     1fc0 <main+0xda0>
mov    %rbx,%rdi
lea    0x14fe(%rip),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmpl   $0x2,0x10(%rsp)
jl     20cd <main+0xead>
lea    0x1(%r12),%edx
mov    %rbx,%rdi
lea    0x14f8(%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    2102 <main+0xee2>
shl    $0x4,%edx
mov    %rbx,%rdi
lea    0x1403(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0x3,%esi
mov    $0x1,%edx
mov    %r13,%rdi
jmp    1fd1 <main+0xdb1>
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     2170 <main+0xf50>
lea    0x1(%rdx),%r15
cmp    %ebp,(%rax,%rdx,4)
mov    %r15,%rdx
je     2150 <main+0xf30>
add    %r12d,%r15d
jmp    2176 <main+0xf56>
cs nopw 0x0(%rax,%rax,1)
mov    $0x10,%r15d
mov    %r15d,%eax
xor    $0x10,%eax
or     %r12d,%eax
sete   %r14b
lea    0x13eb(%rip),%r13
lea    0x13e6(%rip),%rax
cmove  %rax,%r13
test   %r12,%r12
je     21c0 <main+0xfa0>
cmp    $0x10,%r15d
jne    21e0 <main+0xfc0>
mov    $0x9,%esi
mov    $0x1,%edx
lea    0x12dd(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
jmp    21f7 <main+0xfd7>
nopl   0x0(%rax,%rax,1)
cmp    $0x10,%r15d
je     21f7 <main+0xfd7>
mov    %r15d,%edx
shl    $0x4,%edx
mov    %rbx,%rdi
lea    0x12a3(%rip),%rsi
jmp    21f0 <main+0xfd0>
nopl   0x0(%rax,%rax,1)
mov    %r15d,%edx
shl    $0x4,%edx
mov    %rbx,%rdi
lea    0x12a8(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0xfffffffe,%ebp
je     2220 <main+0x1000>
cmp    $0xffffffff,%ebp
jne    2230 <main+0x1010>
lea    0x12aa(%rip),%rsi
lea    0x12b9(%rip),%rbp
jmp    2408 <main+0x11e8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x1,0x8(%rsp)
jmp    2425 <main+0x1205>
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    2320 <main+0x1100>
movslq %r12d,%rax
movslq %ecx,%rcx
cmp    %rax,%rcx
je     22d6 <main+0x10b6>
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
movdqa 0xd93(%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    2270 <main+0x1050>
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    22f4 <main+0x10d4>
xor    %edx,%edx
mov    $0x1,%esi
nopl   (%rax)
cmpl   $0xfffd,0x30(%rsp,%rax,4)
cmove  %esi,%edx
add    $0x1,%rax
cmp    %rax,%rcx
jne    22e0 <main+0x10c0>
test   %edx,%edx
je     2320 <main+0x1100>
mov    $0x14,%esi
mov    $0x1,%edx
lea    0x11cc(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
xor    %r12d,%r12d
jmp    233c <main+0x111c>
cs nopw 0x0(%rax,%rax,1)
mov    $0x10,%esi
mov    $0x1,%edx
lea    0x11b9(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    $0x1,%r12b
mov    %rbx,%rdi
lea    0x126c(%rip),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmpl   $0x2,0x10(%rsp)
jl     236d <main+0x114d>
lea    0x1(%rbp),%edx
mov    %rbx,%rdi
lea    0x1258(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0x2,%esi
mov    $0x1,%edx
lea    0x117d(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
mov    0x38430(%rsp,%rbp,8),%edx
test   %edx,%edx
jle    23a5 <main+0x1185>
shl    $0x4,%edx
mov    %rbx,%rdi
lea    0x1160(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0x3,%esi
mov    $0x1,%edx
lea    0x1150(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x1103(%rip),%rbp
test   %r12b,%r12b
jne    2415 <main+0x11f5>
mov    %rbx,%rdi
lea    0x1136(%rip),%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    %rbx,%rdi
lea    0x1139(%rip),%rsi
mov    %r13,%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
movl   $0x1,0x8(%rsp)
lea    0x1139(%rip),%rsi
lea    0x1141(%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    244d <main+0x122d>
mov    $0x4,%esi
mov    $0x1,%edx
lea    0x12bf(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
cmp    $0x10,%r15d
jl     2120 <main+0xf00>
cmpl   $0x0,0x8(%rsp)
je     247b <main+0x125b>
lea    0x10f3(%rip),%rdi
mov    $0x14,%esi
jmp    246e <main+0x124e>
lea    0x12fe(%rip),%rdi
mov    $0xc,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x127a(%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    24cd <main+0x12ad>
nopl   0x0(%rax)
add    $0x2,%rbp
cmp    $0x100,%rbp
je     24fa <main+0x12da>
movslq 0x30(%rsp,%rbp,4),%rax
cmp    $0xfffd,%rax
je     24e1 <main+0x12c1>
mov    %ebp,0x38430(%rsp,%rax,4)
movslq 0x34(%rsp,%rbp,4),%rax
cmp    $0xfffd,%rax
je     24c0 <main+0x12a0>
lea    0x1(%rbp),%ecx
mov    %ecx,0x38430(%rsp,%rax,4)
jmp    24c0 <main+0x12a0>
lea    0x430(%rsp),%rax
mov    $0x7,%ecx
pxor   %xmm0,%xmm0
pcmpeqd %xmm1,%xmm1
jmp    253b <main+0x131b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movl   $0xfffffffe,(%rax)
add    $0x4,%rax
add    $0x8,%rcx
cmp    $0x10007,%rcx
je     261b <main+0x13fb>
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     2520 <main+0x1300>
pshufd $0xff,%xmm3,%xmm4
movd   %xmm4,%edx
cmp    %rdx,%rcx
jne    2610 <main+0x13f0>
lea    -0x1(%rcx),%rdx
pshufd $0xee,%xmm3,%xmm4
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    2610 <main+0x13f0>
lea    -0x2(%rcx),%rdx
pshufd $0x55,%xmm3,%xmm4
movd   %xmm4,%esi
cmp    %rsi,%rdx
jne    2610 <main+0x13f0>
lea    -0x3(%rcx),%rdx
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    2610 <main+0x13f0>
lea    -0x4(%rcx),%rdx
pshufd $0xff,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    2610 <main+0x13f0>
lea    -0x5(%rcx),%rdx
pshufd $0xee,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    2610 <main+0x13f0>
lea    -0x6(%rcx),%rdx
pshufd $0x55,%xmm2,%xmm3
movd   %xmm3,%esi
cmp    %rsi,%rdx
jne    2610 <main+0x13f0>
lea    -0x7(%rcx),%rdx
movd   %xmm2,%esi
cmp    %rsi,%rdx
jne    2610 <main+0x13f0>
movl   $0xffffffff,(%rax)
jmp    2526 <main+0x1306>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rax)
jmp    2526 <main+0x1306>
mov    0x430(%rsp),%ebp
xor    %r12d,%r12d
test   %ebp,%ebp
js     2648 <main+0x1428>
movl   $0x0,0x430(%rsp)
movq   $0x0,0x8430(%rsp)
mov    $0x1,%r12d
xor    %ebp,%ebp
mov    $0x1,%eax
jmp    2681 <main+0x1461>
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     26d4 <main+0x14b4>
cmpl   $0x0,0x430(%rsp,%rax,4)
js     2675 <main+0x1455>
test   %r12d,%r12d
jle    2650 <main+0x1430>
lea    -0x1(%r12),%ecx
cmp    %ecx,0x42c(%rsp,%rax,4)
je     26c0 <main+0x14a0>
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    2650 <main+0x1430>
mov    %eax,%esi
sub    %edx,%esi
cmp    $0x8,%esi
jg     2650 <main+0x1430>
mov    %ecx,0x430(%rsp,%rax,4)
lea    (%rcx,%rcx,2),%rcx
mov    %eax,0x8434(%rsp,%rcx,8)
jmp    2675 <main+0x1455>
mov    %ebp,0x1c(%rsp)
test   %r12d,%r12d
jle    2a75 <main+0x1855>
mov    %r12d,%ebp
xor    %eax,%eax
jmp    26f9 <main+0x14d9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rbp,%rax
je     2769 <main+0x1549>
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    26f0 <main+0x14d0>
lea    (%rsp,%rcx,8),%rcx
add    $0x8438,%rcx
movslq %edx,%rdx
movslq %esi,%rsi
xor    %edi,%edi
jmp    2749 <main+0x1529>
nopl   0x0(%rax)
add    $0x2,%rdx
cmp    %rdx,%rsi
je     26f0 <main+0x14d0>
cmpl   $0x0,0x38430(%rsp,%rdx,4)
je     2758 <main+0x1538>
add    $0x1,%edi
mov    %edi,(%rcx)
cmpl   $0x0,0x38434(%rsp,%rdx,4)
je     2740 <main+0x1520>
add    $0x1,%edi
mov    %edi,(%rcx)
jmp    2740 <main+0x1520>
test   %r12d,%r12d
jle    2a75 <main+0x1855>
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    27b3 <main+0x1593>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %ebp,%ebp
mov    %rbp,0x8440(%rsp,%r14,1)
add    $0x18,%r14
cmp    %r14,%r15
je     2829 <main+0x1609>
cmpl   $0x2,0x8438(%rsp,%r14,1)
jl     27a0 <main+0x1580>
mov    0x8430(%rsp,%r14,1),%r13d
sar    $0x5,%r13d
cmp    %r13d,%eax
jne    2800 <main+0x15e0>
mov    $0x6,%edi
mov    %eax,%r13d
call   10c0 <malloc@plt>
mov    %rax,%rbp
mov    0x8(%rsp),%ecx
add    $0x1,%ecx
mov    %rax,%rdi
lea    0xdca(%rip),%rsi
mov    %r13d,%edx
mov    %ecx,0x8(%rsp)
xor    %eax,%eax
call   1110 <sprintf@plt>
jmp    2821 <main+0x1601>
mov    $0x3,%edi
call   10c0 <malloc@plt>
mov    %rax,%rbp
mov    %rax,%rdi
lea    0xcea(%rip),%rsi
mov    %r13d,%edx
xor    %eax,%eax
call   1110 <sprintf@plt>
mov    %r13d,%eax
jmp    27a2 <main+0x1582>
test   %r12d,%r12d
mov    0x28(%rsp),%rsi
jle    2a75 <main+0x1855>
mov    $0xffffffff,%eax
lea    0xdbd(%rip),%rbp
xor    %ecx,%ecx
mov    0x20(%rsp),%rdx
jmp    2887 <main+0x1667>
nopl   0x0(%rax)
mov    $0x3,%esi
mov    $0x1,%edx
lea    0xbab(%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     2a64 <main+0x1844>
lea    (%rcx,%rcx,2),%r14
cmpl   $0x2,0x8438(%rsp,%r14,8)
jl     287a <main+0x165a>
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    0xcfa(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    0x8434(%rsp,%r14,8),%r13d
jg     2850 <main+0x1630>
lea    (%rsp,%r14,8),%rax
add    $0x8430,%rax
mov    %rax,0x8(%rsp)
lea    0x0(,%r13,8),%r14d
jmp    2a20 <main+0x1800>
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    0xc0d(%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    2850 <main+0x1630>
lea    0x1f(%r13),%eax
test   %r13d,%r13d
cmovns %r13d,%eax
and    $0xffffffe0,%eax
mov    %r13d,%r12d
sub    %eax,%r12d
jne    2900 <main+0x16e0>
mov    0x8(%rsp),%rax
movslq (%rax),%rax
cmp    %rax,%r13
jle    2900 <main+0x16e0>
mov    %rbx,%rdi
lea    0xb9b(%rip),%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   10b0 <fprintf@plt>
jmp    2900 <main+0x16e0>
test   %eax,%eax
js     2a75 <main+0x1855>
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     2ad0 <main+0x18b0>
lea    0x1(%rcx),%rbp
cmp    %eax,(%rsi,%rcx,4)
mov    %rbp,%rcx
je     2ab0 <main+0x1890>
add    %edx,%ebp
test   %eax,%eax
jns    2ad9 <main+0x18b9>
jmp    2ae9 <main+0x18c9>
nopl   0x0(%rax)
mov    $0x2000,%ebp
test   %eax,%eax
js     2ae9 <main+0x18c9>
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     2b16 <main+0x18f6>
movslq %ebp,%rax
mov    0x430(%rsp,%rax,4),%eax
jmp    2a90 <main+0x1870>
lea    0xb02(%rip),%rsi
mov    %rbx,%rdi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
lea    0xc22(%rip),%rdi
mov    $0x2,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
test   %r12d,%r12d
je     2b63 <main+0x1943>
lea    0xb16(%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     2bc0 <main+0x19a0>
lea    0x1(%rdx),%r14
cmp    %ebp,(%rax,%rdx,4)
mov    %r14,%rdx
je     2ba0 <main+0x1980>
add    %r13d,%r14d
jmp    2bc6 <main+0x19a6>
cs nopw 0x0(%rax,%rax,1)
mov    $0x2000,%r14d
mov    %ebp,%r15d
test   %ebp,%ebp
js     2c00 <main+0x19e0>
lea    (%r15,%r15,2),%rax
cmp    0x8430(%rsp,%rax,8),%r13d
jne    2e84 <main+0x1c64>
mov    0x8434(%rsp,%rax,8),%eax
add    $0x1,%eax
cmp    %eax,%r14d
mov    %eax,%r14d
jle    2c09 <main+0x19e9>
jmp    2e84 <main+0x1c64>
cs nopw 0x0(%rax,%rax,1)
cmp    $0xfffffffe,%ebp
je     2d40 <main+0x1b20>
test   %r13,%r13
je     2c30 <main+0x1a10>
mov    $0x7,%esi
mov    $0x1,%edx
lea    0xa60(%rip),%rdi
jmp    2c41 <main+0x1a21>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x2,%esi
mov    $0x1,%edx
lea    0x936(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
test   %ebp,%ebp
js     2c65 <main+0x1a45>
lea    (%r15,%r15,2),%rax
mov    0x8438(%rsp,%rax,8),%eax
cmp    $0x1,%eax
je     2cc0 <main+0x1aa0>
test   %eax,%eax
je     2e84 <main+0x1c64>
test   %r13,%r13
je     2d60 <main+0x1b40>
lea    0x0(,%r13,8),%edx
lea    0x0(,%r14,8),%ecx
mov    %rbx,%rdi
lea    0xa33(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0xffffffff,%ebp
lea    0x434(%rsp),%r15
jne    2d8a <main+0x1b6a>
mov    $0xd,%esi
mov    $0x1,%edx
lea    0xa4e(%rip),%rdi
jmp    2e1c <main+0x1bfc>
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%r13),%eax
cmp    %eax,%r14d
jne    2e84 <main+0x1c64>
shl    $0x3,%r13d
lea    0x0(,%r14,8),%eax
cmp    %eax,%r13d
jge    2d40 <main+0x1b20>
movslq %r13d,%rdx
add    $0x1,%rdx
sub    %r13d,%eax
lea    0x434(%rsp),%r15
mov    0x3842c(%rsp,%rdx,4),%ecx
test   %ecx,%ecx
jne    2e3c <main+0x1c1c>
mov    0x38430(%rsp,%rdx,4),%ecx
test   %ecx,%ecx
jne    2e4c <main+0x1c2c>
mov    0x38434(%rsp,%rdx,4),%ecx
test   %ecx,%ecx
jne    2e42 <main+0x1c22>
mov    0x38438(%rsp,%rdx,4),%ecx
test   %ecx,%ecx
jne    2e48 <main+0x1c28>
add    $0x4,%rdx
add    $0xfffffffc,%eax
jne    2cf0 <main+0x1ad0>
jmp    2e24 <main+0x1c04>
nopw   0x0(%rax,%rax,1)
lea    0x434(%rsp),%r15
cmp    $0x1fff,%r14d
jle    2e2d <main+0x1c0d>
jmp    2e66 <main+0x1c46>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%r14,8),%edx
mov    %rbx,%rdi
lea    0x938(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0xffffffff,%ebp
lea    0x434(%rsp),%r15
je     2e0b <main+0x1beb>
movslq %ebp,%rax
lea    (%rax,%rax,2),%rbp
mov    0x8440(%rsp,%rbp,8),%rcx
mov    %rbx,%rdi
lea    0x96a(%rip),%rsi
mov    0x20(%rsp),%rdx
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmpl   $0x0,0x8430(%rsp,%rbp,8)
jle    2dd2 <main+0x1bb2>
lea    0x0(,%r13,8),%edx
mov    %rbx,%rdi
lea    0x958(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
mov    $0x3,%esi
mov    $0x1,%edx
lea    0x723(%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    2e2d <main+0x1c0d>
jmp    2e66 <main+0x1c46>
mov    $0x22,%esi
mov    $0x1,%edx
lea    0x8c0(%rip),%rdi
mov    %rbx,%rcx
call   1130 <fwrite@plt>
cmp    $0x1fff,%r14d
jg     2e66 <main+0x1c46>
movslq %r14d,%rax
mov    0x430(%rsp,%rax,4),%ebp
jmp    2b80 <main+0x1960>
add    $0xffffffffffffffff,%rdx
jmp    2e4c <main+0x1c2c>
add    $0x1,%rdx
jmp    2e4c <main+0x1c2c>
add    $0x2,%rdx
mov    %rbx,%rdi
lea    0x831(%rip),%rsi
xor    %eax,%eax
call   10b0 <fprintf@plt>
cmp    $0x1fff,%r14d
jle    2e2d <main+0x1c0d>
test   %r12d,%r12d
je     2eef <main+0x1ccf>
cmpl   $0x0,0x8(%rsp)
jne    2e8b <main+0x1c6b>
lea    0x8ca(%rip),%rdi
mov    $0x10,%esi
jmp    2e97 <main+0x1c77>
xor    %eax,%eax
call   1030 <abort@plt>
lea    0x899(%rip),%rdi
mov    $0x1b,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x8ad(%rip),%rdi
mov    $0xc,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x8a1(%rip),%rdi
mov    $0xe,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x81d(%rip),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x87e(%rip),%rdi
mov    $0x14,%esi
mov    $0x1,%edx
mov    %rbx,%rcx
call   1130 <fwrite@plt>
lea    0x7ed(%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 = [4 x i8] c"/*\0A\00"
@.str.7 = [59 x i8] c" * Copyright (C) 1999-2002 Free Software Foundation, Inc.\0A\00"
@.str.8 = [51 x i8] c" * This file is part of the GNU LIBICONV Library.\0A\00"
@.str.9 = [4 x i8] c" *\0A\00"
@.str.10 = [71 x i8] c" * The GNU LIBICONV Library is free software; you can redistribute it\0A\00"
@.str.11 = [71 x i8] c" * and/or modify it under the terms of the GNU Library General Public\0A\00"
@.str.12 = [75 x i8] c" * License as published by the Free Software Foundation; either version 2\0A\00"
@.str.13 = [59 x i8] c" * of the License, or (at your option) any later version.\0A\00"
@.str.14 = [72 x i8] c" * The GNU LIBICONV Library is distributed in the hope that it will be\0A\00"
@.str.15 = [75 x i8] c" * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of\0A\00"
@.str.16 = [70 x i8] c" * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\0A\00"
@.str.17 = [53 x i8] c" * Library General Public License for more details.\0A\00"
@.str.18 = [70 x i8] c" * You should have received a copy of the GNU Library General Public\0A\00"
@.str.19 = [75 x i8] c" * License along with the GNU LIBICONV Library; see the file COPYING.LIB.\0A\00"
@.str.20 = [75 x i8] c" * If not, write to the Free Software Foundation, Inc., 59 Temple Place -\0A\00"
@.str.21 = [43 x i8] c" * Suite 330, Boston, MA 02111-1307, USA.\0A\00"
@.str.22 = [5 x i8] c" */\0A\00"
@.str.23 = [2 x i8] c"\0A\00"
@.str.24 = [7 x i8] c" * %s\0A\00"
@.str.25 = [36 x i8] c"static const unsigned short %s_2uni\00"
@.str.26 = [4 x i8] c"_%d\00"
@.str.27 = [10 x i8] c"[%d] = {\0A\00"
@.str.28 = [16 x i8] c" /* 0x%02x */\0A\00"
@.str.29 = [2 x i8] c" \00"
@.str.30 = [9 x i8] c" 0x%04x,\00"
@.str.31 = [4 x i8] c"};\0A\00"
@.str.32 = [80 x i8] c"static int\0A%s_mbtowc (conv_t conv, ucs4_t *pwc, const unsigned char *s, int n)\0A\00"
@.str.33 = [3 x i8] c"{\0A\00"
@.str.34 = [25 x i8] c" unsigned char c = *s;\0A\00"
@.str.35 = [3 x i8] c" \00"
@.str.36 = [5 x i8] c" \00"
@.str.37 = [21 x i8] c" if (c < 0x%02x) {\0A\00"
@.str.38 = [10 x i8] c" else {\0A\00"
@.str.39 = [26 x i8] c" else if (c < 0x%02x) {\0A\00"
@.str.40 = [22 x i8] c"%s*pwc = (ucs4_t) c;\0A\00"
@.str.41 = [13 x i8] c"%sreturn 1;\0A\00"
@.str.42 = [3 x i8] c"%s\00"
@.str.43 = [21 x i8] c"unsigned short wc = \00"
@.str.44 = [17 x i8] c"*pwc = (ucs4_t) \00"
@.str.45 = [8 x i8] c"%s_2uni\00"
@.str.46 = [3 x i8] c"[c\00"
@.str.47 = [8 x i8] c"-0x%02x\00"
@.str.48 = [4 x i8] c"];\0A\00"
@.str.49 = [23 x i8] c"%sif (wc != 0xfffd) {\0A\00"
@.str.50 = [25 x i8] c"%s *pwc = (ucs4_t) wc;\0A\00"
@.str.51 = [15 x i8] c"%s return 1;\0A\00"
@.str.52 = [5 x i8] c"%s}\0A\00"
@.str.53 = [5 x i8] c" }\0A\00"
@.str.54 = [21 x i8] c" return RET_ILSEQ;\0A\00"
@.str.55 = [23 x i8] c" if (c < 0x%02x)\0A \00"
@.str.56 = [12 x i8] c" else\0A \00"
@.str.57 = [28 x i8] c" else if (c < 0x%02x)\0A \00"
@.str.58 = [20 x i8] c"*pwc = (ucs4_t) c;\0A\00"
@.str.59 = [24 x i8] c"*pwc = (ucs4_t) %s_2uni\00"
@.str.60 = [13 x i8] c" return 1;\0A\00"
@.str.61 = [3 x i8] c"}\0A\00"
@.str.62 = [8 x i8] c"%02x_%d\00"
@.str.63 = [5 x i8] c"%02x\00"
@.str.64 = [46 x i8] c"static const unsigned char %s_page%s[%d] = {\0A\00"
@.str.65 = [16 x i8] c" /* 0x%04x */\0A\00"
@.str.66 = [9 x i8] c" 0x%02x,\00"
@.str.67 = [22 x i8] c" /* 0x%02x-0x%02x */\0A\00"
@.str.68 = [72 x i8] c"static int\0A%s_wctomb (conv_t conv, unsigned char *r, ucs4_t wc, int n)\0A\00"
@.str.69 = [24 x i8] c" unsigned char c = 0;\0A\00"
@.str.70 = [8 x i8] c" else \00"
@.str.71 = [35 x i8] c"if (wc == 0x%04x)\0A c = 0x%02x;\0A\00"
@.str.72 = [17 x i8] c"if (wc < 0x%04x)\00"
@.str.73 = [33 x i8] c"if (wc >= 0x%04x && wc < 0x%04x)\00"
@.str.74 = [35 x i8] c" {\0A *r = wc;\0A return 1;\0A }\0A\00"
@.str.75 = [14 x i8] c"\0A c = wc;\0A\00"
@.str.76 = [22 x i8] c"\0A c = %s_page%s[wc\00"
@.str.77 = [8 x i8] c"-0x%04x\00"
@.str.78 = [28 x i8] c" if (c != 0 || wc == 0) {\0A\00"
@.str.79 = [17 x i8] c" if (c != 0) {\0A\00"
@.str.80 = [13 x i8] c" *r = c;\0A\00"
@.str.81 = [15 x i8] c" return 1;\0A\00"
@.str.82 = [21 x i8] c" return RET_ILUNI;\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 ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0))
%266 = load i32*, i32** %14
%267 = call i32 (i32*, i8*, ...) @fprintf(i32* %266, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.7, i64 0, i64 0))
%268 = load i32*, i32** %14
%269 = call i32 (i32*, i8*, ...) @fprintf(i32* %268, i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.8, i64 0, i64 0))
%270 = load i32*, i32** %14
%271 = call i32 (i32*, i8*, ...) @fprintf(i32* %270, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0))
%272 = load i32*, i32** %14
%273 = call i32 (i32*, i8*, ...) @fprintf(i32* %272, i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.10, i64 0, i64 0))
%274 = load i32*, i32** %14
%275 = call i32 (i32*, i8*, ...) @fprintf(i32* %274, i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.11, i64 0, i64 0))
%276 = load i32*, i32** %14
%277 = call i32 (i32*, i8*, ...) @fprintf(i32* %276, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.12, i64 0, i64 0))
%278 = load i32*, i32** %14
%279 = call i32 (i32*, i8*, ...) @fprintf(i32* %278, i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.13, i64 0, i64 0))
%280 = load i32*, i32** %14
%281 = call i32 (i32*, i8*, ...) @fprintf(i32* %280, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0))
%282 = load i32*, i32** %14
%283 = call i32 (i32*, i8*, ...) @fprintf(i32* %282, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.14, i64 0, i64 0))
%284 = load i32*, i32** %14
%285 = call i32 (i32*, i8*, ...) @fprintf(i32* %284, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.15, i64 0, i64 0))
%286 = load i32*, i32** %14
%287 = call i32 (i32*, i8*, ...) @fprintf(i32* %286, i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.16, i64 0, i64 0))
%288 = load i32*, i32** %14
%289 = call i32 (i32*, i8*, ...) @fprintf(i32* %288, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.17, i64 0, i64 0))
%290 = load i32*, i32** %14
%291 = call i32 (i32*, i8*, ...) @fprintf(i32* %290, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0))
%292 = load i32*, i32** %14
%293 = call i32 (i32*, i8*, ...) @fprintf(i32* %292, i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.18, i64 0, i64 0))
%294 = load i32*, i32** %14
%295 = call i32 (i32*, i8*, ...) @fprintf(i32* %294, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.19, i64 0, i64 0))
%296 = load i32*, i32** %14
%297 = call i32 (i32*, i8*, ...) @fprintf(i32* %296, i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.20, i64 0, i64 0))
%298 = load i32*, i32** %14
%299 = call i32 (i32*, i8*, ...) @fprintf(i32* %298, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.21, i64 0, i64 0))
%300 = load i32*, i32** %14
%301 = call i32 (i32*, i8*, ...) @fprintf(i32* %300, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.22, i64 0, i64 0))
%302 = load i32*, i32** %14
%303 = call i32 (i32*, i8*, ...) @fprintf(i32* %302, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0))
%304 = load i32*, i32** %14
%305 = call i32 (i32*, i8*, ...) @fprintf(i32* %304, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0))
%306 = load i32*, i32** %14
%307 = load i8*, i8** %6
%308 = call i32 (i32*, i8*, ...) @fprintf(i32* %306, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i64 0, i64 0), i8* %307)
%309 = load i32*, i32** %14
%310 = call i32 (i32*, i8*, ...) @fprintf(i32* %309, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.22, i64 0, i64 0))
%311 = load i32*, i32** %14
%312 = call i32 (i32*, i8*, ...) @fprintf(i32* %311, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0))
store i32 0, i32* %17
br label %313
313: ; preds = %363, %263
%314 = load i32, i32* %17
%315 = icmp slt i32 %314, 16
br i1 %315, label %316, label %366
316: ; preds = %313
store i32 1, i32* %25
store i32 1, i32* %26
store i32 0, i32* %18
br label %317
317: ; preds = %340, %316
%318 = load i32, i32* %18
%319 = icmp slt i32 %318, 16
br i1 %319, label %320, label %343
320: ; preds = %317
%321 = load i32, i32* %17
%322 = mul nsw i32 16, %321
%323 = load i32, i32* %18
%324 = add nsw i32 %322, %323
store i32 %324, i32* %16
%325 = load i32, i32* %16
%326 = sext i32 %325 to i64
%327 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %326
%328 = load i32, i32* %327
%329 = icmp ne i32 %328, 65533
br i1 %329, label %330, label %331
330: ; preds = %320
store i32 0, i32* %25
br label %331
331: ; preds = %330, %320
%332 = load i32, i32* %16
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %333
%335 = load i32, i32* %334
%336 = load i32, i32* %16
%337 = icmp ne i32 %335, %336
br i1 %337, label %338, label %339
338: ; preds = %331
store i32 0, i32* %26
br label %339
339: ; preds = %338, %331
br label %340
340: ; preds = %339
%341 = load i32, i32* %18
%342 = add nsw i32 %341, 1
store i32 %342, i32* %18
br label %317
343: ; preds = %317
%344 = load i32, i32* %25
%345 = icmp ne i32 %344, 0
br i1 %345, label %346, label %350
346: ; preds = %343
%347 = load i32, i32* %17
%348 = sext i32 %347 to i64
%349 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %348
store i32 -2, i32* %349
br label %362
350: ; preds = %343
%351 = load i32, i32* %26
%352 = icmp ne i32 %351, 0
br i1 %352, label %353, label %357
353: ; preds = %350
%354 = load i32, i32* %17
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %355
store i32 -1, i32* %356
br label %361
357: ; preds = %350
%358 = load i32, i32* %17
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %359
store i32 0, i32* %360
br label %361
361: ; preds = %357, %353
br label %362
362: ; preds = %361, %346
br label %363
363: ; preds = %362
%364 = load i32, i32* %17
%365 = add nsw i32 %364, 1
store i32 %365, i32* %17
br label %313
366: ; preds = %313
store i32 0, i32* %21
store i32 0, i32* %17
br label %367
367: ; preds = %424, %366
%368 = load i32, i32* %17
%369 = icmp slt i32 %368, 16
br i1 %369, label %370, label %427
370: ; preds = %367
%371 = load i32, i32* %17
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %372
%374 = load i32, i32* %373
%375 = icmp sge i32 %374, 0
br i1 %375, label %376, label %423
376: ; preds = %370
%377 = load i32, i32* %17
%378 = icmp sgt i32 %377, 0
br i1 %378, label %379, label %403
379: ; preds = %376
%380 = load i32, i32* %21
%381 = icmp sgt i32 %380, 0
br i1 %381, label %382, label %403
382: ; preds = %379
%383 = load i32, i32* %17
%384 = sub nsw i32 %383, 1
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %385
%387 = load i32, i32* %386
%388 = load i32, i32* %21
%389 = sub nsw i32 %388, 1
%390 = icmp eq i32 %387, %389
br i1 %390, label %391, label %403
391: ; preds = %382
%392 = load i32, i32* %21
%393 = sub nsw i32 %392, 1
%394 = load i32, i32* %17
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %395
store i32 %393, i32* %396
%397 = load i32, i32* %17
%398 = load i32, i32* %21
%399 = sub nsw i32 %398, 1
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %400
%402 = getelementptr inbounds %struct.anon, %struct.anon* %401, i32 0, i32 1
store i32 %397, i32* %402
br label %422
403: ; preds = %382, %379, %376
%404 = load i32, i32* %21
%405 = add nsw i32 %404, 1
store i32 %405, i32* %21
%406 = load i32, i32* %21
%407 = sub nsw i32 %406, 1
%408 = load i32, i32* %17
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %409
store i32 %407, i32* %410
%411 = load i32, i32* %17
%412 = load i32, i32* %21
%413 = sub nsw i32 %412, 1
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %414
%416 = getelementptr inbounds %struct.anon, %struct.anon* %415, i32 0, i32 1
store i32 %411, i32* %416
%417 = load i32, i32* %21
%418 = sub nsw i32 %417, 1
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %419
%421 = getelementptr inbounds %struct.anon, %struct.anon* %420, i32 0, i32 0
store i32 %411, i32* %421
br label %422
422: ; preds = %403, %391
br label %423
423: ; preds = %422, %370
br label %424
424: ; preds = %423
%425 = load i32, i32* %17
%426 = add nsw i32 %425, 1
store i32 %426, i32* %17
br label %367
427: ; preds = %367
store i32 0, i32* %23
store i32 0, i32* %16
br label %428
428: ; preds = %439, %427
%429 = load i32, i32* %16
%430 = icmp slt i32 %429, 256
br i1 %430, label %431, label %442
431: ; preds = %428
%432 = load i32, i32* %16
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %433
%435 = load i32, i32* %434
%436 = icmp eq i32 %435, 65533
br i1 %436, label %437, label %438
437: ; preds = %431
store i32 1, i32* %23
br label %438
438: ; preds = %437, %431
br label %439
439: ; preds = %438
%440 = load i32, i32* %16
%441 = add nsw i32 %440, 1
store i32 %441, i32* %16
br label %428
442: ; preds = %428
%443 = load i32, i32* %21
%444 = icmp sgt i32 %443, 0
br i1 %444, label %445, label %540
445: ; preds = %442
store i32 0, i32* %27
br label %446
446: ; preds = %534, %445
%447 = load i32, i32* %27
%448 = load i32, i32* %21
%449 = icmp slt i32 %447, %448
br i1 %449, label %450, label %537
450: ; preds = %446
%451 = load i32*, i32** %14
%452 = load i8*, i8** %7
%453 = call i32 (i32*, i8*, ...) @fprintf(i32* %451, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.25, i64 0, i64 0), i8* %452)
%454 = load i32, i32* %21
%455 = icmp sgt i32 %454, 1
br i1 %455, label %456, label %461
456: ; preds = %450
%457 = load i32*, i32** %14
%458 = load i32, i32* %27
%459 = add nsw i32 %458, 1
%460 = call i32 (i32*, i8*, ...) @fprintf(i32* %457, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %459)
br label %461
461: ; preds = %456, %450
%462 = load i32*, i32** %14
%463 = load i32, i32* %27
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %464
%466 = getelementptr inbounds %struct.anon, %struct.anon* %465, i32 0, i32 1
%467 = load i32, i32* %466
%468 = load i32, i32* %27
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %469
%471 = getelementptr inbounds %struct.anon, %struct.anon* %470, i32 0, i32 0
%472 = load i32, i32* %471
%473 = sub nsw i32 %467, %472
%474 = add nsw i32 %473, 1
%475 = mul nsw i32 16, %474
%476 = call i32 (i32*, i8*, ...) @fprintf(i32* %462, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.27, i64 0, i64 0), i32 %475)
%477 = load i32, i32* %27
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %478
%480 = getelementptr inbounds %struct.anon, %struct.anon* %479, i32 0, i32 0
%481 = load i32, i32* %480
store i32 %481, i32* %17
br label %482
482: ; preds = %528, %461
%483 = load i32, i32* %17
%484 = load i32, i32* %27
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %485
%487 = getelementptr inbounds %struct.anon, %struct.anon* %486, i32 0, i32 1
%488 = load i32, i32* %487
%489 = icmp sle i32 %483, %488
br i1 %489, label %490, label %531
490: ; preds = %482
%491 = load i32*, i32** %14
%492 = load i32, i32* %17
%493 = mul nsw i32 16, %492
%494 = call i32 (i32*, i8*, ...) @fprintf(i32* %491, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.28, i64 0, i64 0), i32 %493)
store i32 0, i32* %18
br label %495
495: ; preds = %524, %490
%496 = load i32, i32* %18
%497 = icmp slt i32 %496, 2
br i1 %497, label %498, label %527
498: ; preds = %495
%499 = load i32*, i32** %14
%500 = call i32 (i32*, i8*, ...) @fprintf(i32* %499, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.29, i64 0, i64 0))
store i32 0, i32* %19
br label %501
501: ; preds = %518, %498
%502 = load i32, i32* %19
%503 = icmp slt i32 %502, 8
br i1 %503, label %504, label %521
504: ; preds = %501
%505 = load i32, i32* %17
%506 = mul nsw i32 16, %505
%507 = load i32, i32* %18
%508 = mul nsw i32 8, %507
%509 = add nsw i32 %506, %508
%510 = load i32, i32* %19
%511 = add nsw i32 %509, %510
store i32 %511, i32* %16
%512 = load i32*, i32** %14
%513 = load i32, i32* %16
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %514
%516 = load i32, i32* %515
%517 = call i32 (i32*, i8*, ...) @fprintf(i32* %512, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %516)
br label %518
518: ; preds = %504
%519 = load i32, i32* %19
%520 = add nsw i32 %519, 1
store i32 %520, i32* %19
br label %501
521: ; preds = %501
%522 = load i32*, i32** %14
%523 = call i32 (i32*, i8*, ...) @fprintf(i32* %522, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0))
br label %524
524: ; preds = %521
%525 = load i32, i32* %18
%526 = add nsw i32 %525, 1
store i32 %526, i32* %18
br label %495
527: ; preds = %495
br label %528
528: ; preds = %527
%529 = load i32, i32* %17
%530 = add nsw i32 %529, 1
store i32 %530, i32* %17
br label %482
531: ; preds = %482
%532 = load i32*, i32** %14
%533 = call i32 (i32*, i8*, ...) @fprintf(i32* %532, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.31, i64 0, i64 0))
br label %534
534: ; preds = %531
%535 = load i32, i32* %27
%536 = add nsw i32 %535, 1
store i32 %536, i32* %27
br label %446
537: ; preds = %446
%538 = load i32*, i32** %14
%539 = call i32 (i32*, i8*, ...) @fprintf(i32* %538, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0))
br label %540
540: ; preds = %537, %442
store i32 0, i32* %24
%541 = load i32*, i32** %14
%542 = load i8*, i8** %7
%543 = call i32 (i32*, i8*, ...) @fprintf(i32* %541, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.32, i64 0, i64 0), i8* %542)
%544 = load i32*, i32** %14
%545 = call i32 (i32*, i8*, ...) @fprintf(i32* %544, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.33, i64 0, i64 0))
%546 = load i32*, i32** %14
%547 = call i32 (i32*, i8*, ...) @fprintf(i32* %546, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.34, i64 0, i64 0))
%548 = load i32, i32* %23
%549 = icmp ne i32 %548, 0
br i1 %549, label %550, label %726
550: ; preds = %540
store i32 0, i32* %17
br label %551
551: ; preds = %717, %550
%552 = load i32, i32* %17
%553 = icmp slt i32 %552, 16
br i1 %553, label %554, label %719
554: ; preds = %551
%555 = load i32, i32* %17
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %556
%558 = load i32, i32* %557
store i32 %558, i32* %28
%559 = load i32, i32* %17
store i32 %559, i32* %18
br label %560
560: ; preds = %573, %554
%561 = load i32, i32* %18
%562 = icmp slt i32 %561, 16
br i1 %562, label %563, label %570
563: ; preds = %560
%564 = load i32, i32* %18
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %565
%567 = load i32, i32* %566
%568 = load i32, i32* %28
%569 = icmp eq i32 %567, %568
br label %570
570: ; preds = %563, %560
%571 = phi i1 [ false, %560 ], [ %569, %563 ]
br i1 %571, label %572, label %576
572: ; preds = %570
br label %573
573: ; preds = %572
%574 = load i32, i32* %18
%575 = add nsw i32 %574, 1
store i32 %575, i32* %18
br label %560
576: ; preds = %570
%577 = load i32, i32* %17
%578 = icmp eq i32 %577, 0
br i1 %578, label %579, label %582
579: ; preds = %576
%580 = load i32, i32* %18
%581 = icmp eq i32 %580, 16
br label %582
582: ; preds = %579, %576
%583 = phi i1 [ false, %576 ], [ %581, %579 ]
%584 = zext i1 %583 to i64
%585 = select i1 %583, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.36, i64 0, i64 0)
store i8* %585, i8** %29
%586 = load i32, i32* %17
%587 = icmp eq i32 %586, 0
br i1 %587, label %588, label %598
588: ; preds = %582
%589 = load i32, i32* %18
%590 = icmp eq i32 %589, 16
br i1 %590, label %591, label %592
591: ; preds = %588
br label %597
592: ; preds = %588
%593 = load i32*, i32** %14
%594 = load i32, i32* %18
%595 = mul nsw i32 16, %594
%596 = call i32 (i32*, i8*, ...) @fprintf(i32* %593, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.37, i64 0, i64 0), i32 %595)
br label %597
597: ; preds = %592, %591
br label %610
598: ; preds = %582
%599 = load i32, i32* %18
%600 = icmp eq i32 %599, 16
br i1 %600, label %601, label %604
601: ; preds = %598
%602 = load i32*, i32** %14
%603 = call i32 (i32*, i8*, ...) @fprintf(i32* %602, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.38, i64 0, i64 0))
br label %609
604: ; preds = %598
%605 = load i32*, i32** %14
%606 = load i32, i32* %18
%607 = mul nsw i32 16, %606
%608 = call i32 (i32*, i8*, ...) @fprintf(i32* %605, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.39, i64 0, i64 0), i32 %607)
br label %609
609: ; preds = %604, %601
br label %610
610: ; preds = %609, %597
%611 = load i32, i32* %28
%612 = icmp eq i32 %611, -2
br i1 %612, label %613, label %614
613: ; preds = %610
store i32 1, i32* %24
br label %708
614: ; preds = %610
%615 = load i32, i32* %28
%616 = icmp eq i32 %615, -1
br i1 %616, label %617, label %624
617: ; preds = %614
%618 = load i32*, i32** %14
%619 = load i8*, i8** %29
%620 = call i32 (i32*, i8*, ...) @fprintf(i32* %618, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.40, i64 0, i64 0), i8* %619)
%621 = load i32*, i32** %14
%622 = load i8*, i8** %29
%623 = call i32 (i32*, i8*, ...) @fprintf(i32* %621, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.41, i64 0, i64 0), i8* %622)
br label %707
624: ; preds = %614
%625 = load i32*, i32** %14
%626 = load i8*, i8** %29
%627 = call i32 (i32*, i8*, ...) @fprintf(i32* %625, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.42, i64 0, i64 0), i8* %626)
store i32 0, i32* %23
%628 = load i32, i32* %17
%629 = mul nsw i32 16, %628
store i32 %629, i32* %16
br label %630
630: ; preds = %643, %624
%631 = load i32, i32* %16
%632 = load i32, i32* %18
%633 = mul nsw i32 16, %632
%634 = icmp slt i32 %631, %633
br i1 %634, label %635, label %646
635: ; preds = %630
%636 = load i32, i32* %16
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %637
%639 = load i32, i32* %638
%640 = icmp eq i32 %639, 65533
br i1 %640, label %641, label %642
641: ; preds = %635
store i32 1, i32* %23
br label %642
642: ; preds = %641, %635
br label %643
643: ; preds = %642
%644 = load i32, i32* %16
%645 = add nsw i32 %644, 1
store i32 %645, i32* %16
br label %630
646: ; preds = %630
%647 = load i32, i32* %23
%648 = icmp ne i32 %647, 0
br i1 %648, label %649, label %652
649: ; preds = %646
%650 = load i32*, i32** %14
%651 = call i32 (i32*, i8*, ...) @fprintf(i32* %650, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.43, i64 0, i64 0))
br label %655
652: ; preds = %646
%653 = load i32*, i32** %14
%654 = call i32 (i32*, i8*, ...) @fprintf(i32* %653, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.44, i64 0, i64 0))
br label %655
655: ; preds = %652, %649
%656 = load i32*, i32** %14
%657 = load i8*, i8** %7
%658 = call i32 (i32*, i8*, ...) @fprintf(i32* %656, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.45, i64 0, i64 0), i8* %657)
%659 = load i32, i32* %21
%660 = icmp sgt i32 %659, 1
br i1 %660, label %661, label %666
661: ; preds = %655
%662 = load i32*, i32** %14
%663 = load i32, i32* %28
%664 = add nsw i32 %663, 1
%665 = call i32 (i32*, i8*, ...) @fprintf(i32* %662, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %664)
br label %666
666: ; preds = %661, %655
%667 = load i32*, i32** %14
%668 = call i32 (i32*, i8*, ...) @fprintf(i32* %667, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.46, i64 0, i64 0))
%669 = load i32, i32* %28
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %670
%672 = getelementptr inbounds %struct.anon, %struct.anon* %671, i32 0, i32 0
%673 = load i32, i32* %672
%674 = icmp sgt i32 %673, 0
br i1 %674, label %675, label %684
675: ; preds = %666
%676 = load i32*, i32** %14
%677 = load i32, i32* %28
%678 = sext i32 %677 to i64
%679 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %678
%680 = getelementptr inbounds %struct.anon, %struct.anon* %679, i32 0, i32 0
%681 = load i32, i32* %680
%682 = mul nsw i32 16, %681
%683 = call i32 (i32*, i8*, ...) @fprintf(i32* %676, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i32 %682)
br label %684
684: ; preds = %675, %666
%685 = load i32*, i32** %14
%686 = call i32 (i32*, i8*, ...) @fprintf(i32* %685, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.48, i64 0, i64 0))
%687 = load i32, i32* %23
%688 = icmp ne i32 %687, 0
br i1 %688, label %689, label %702
689: ; preds = %684
%690 = load i32*, i32** %14
%691 = load i8*, i8** %29
%692 = call i32 (i32*, i8*, ...) @fprintf(i32* %690, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.49, i64 0, i64 0), i8* %691)
%693 = load i32*, i32** %14
%694 = load i8*, i8** %29
%695 = call i32 (i32*, i8*, ...) @fprintf(i32* %693, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.50, i64 0, i64 0), i8* %694)
%696 = load i32*, i32** %14
%697 = load i8*, i8** %29
%698 = call i32 (i32*, i8*, ...) @fprintf(i32* %696, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.51, i64 0, i64 0), i8* %697)
%699 = load i32*, i32** %14
%700 = load i8*, i8** %29
%701 = call i32 (i32*, i8*, ...) @fprintf(i32* %699, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.52, i64 0, i64 0), i8* %700)
store i32 1, i32* %24
br label %706
702: ; preds = %684
%703 = load i32*, i32** %14
%704 = load i8*, i8** %29
%705 = call i32 (i32*, i8*, ...) @fprintf(i32* %703, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.41, i64 0, i64 0), i8* %704)
br label %706
706: ; preds = %702, %689
br label %707
707: ; preds = %706, %617
br label %708
708: ; preds = %707, %613
%709 = load i32, i32* %17
%710 = icmp eq i32 %709, 0
br i1 %710, label %711, label %714
711: ; preds = %708
%712 = load i32, i32* %18
%713 = icmp eq i32 %712, 16
br i1 %713, label %717, label %714
714: ; preds = %711, %708
%715 = load i32*, i32** %14
%716 = call i32 (i32*, i8*, ...) @fprintf(i32* %715, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.53, i64 0, i64 0))
br label %717
717: ; preds = %714, %711
%718 = load i32, i32* %18
store i32 %718, i32* %17
br label %551
719: ; preds = %551
%720 = load i32, i32* %24
%721 = icmp ne i32 %720, 0
br i1 %721, label %722, label %725
722: ; preds = %719
%723 = load i32*, i32** %14
%724 = call i32 (i32*, i8*, ...) @fprintf(i32* %723, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.54, i64 0, i64 0))
br label %725
725: ; preds = %722, %719
br label %822
726: ; preds = %540
store i32 0, i32* %17
br label %727
727: ; preds = %817, %726
%728 = load i32, i32* %17
%729 = icmp slt i32 %728, 16
br i1 %729, label %730, label %819
730: ; preds = %727
%731 = load i32, i32* %17
%732 = sext i32 %731 to i64
%733 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %732
%734 = load i32, i32* %733
store i32 %734, i32* %30
%735 = load i32, i32* %17
store i32 %735, i32* %18
br label %736
736: ; preds = %749, %730
%737 = load i32, i32* %18
%738 = icmp slt i32 %737, 16
br i1 %738, label %739, label %746
739: ; preds = %736
%740 = load i32, i32* %18
%741 = sext i32 %740 to i64
%742 = getelementptr inbounds [16 x i32], [16 x i32]* %20, i64 0, i64 %741
%743 = load i32, i32* %742
%744 = load i32, i32* %30
%745 = icmp eq i32 %743, %744
br label %746
746: ; preds = %739, %736
%747 = phi i1 [ false, %736 ], [ %745, %739 ]
br i1 %747, label %748, label %752
748: ; preds = %746
br label %749
749: ; preds = %748
%750 = load i32, i32* %18
%751 = add nsw i32 %750, 1
store i32 %751, i32* %18
br label %736
752: ; preds = %746
%753 = load i32, i32* %17
%754 = icmp eq i32 %753, 0
br i1 %754, label %755, label %767
755: ; preds = %752
%756 = load i32, i32* %18
%757 = icmp eq i32 %756, 16
br i1 %757, label %758, label %761
758: ; preds = %755
%759 = load i32*, i32** %14
%760 = call i32 (i32*, i8*, ...) @fprintf(i32* %759, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0))
br label %766
761: ; preds = %755
%762 = load i32*, i32** %14
%763 = load i32, i32* %18
%764 = mul nsw i32 16, %763
%765 = call i32 (i32*, i8*, ...) @fprintf(i32* %762, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.55, i64 0, i64 0), i32 %764)
br label %766
766: ; preds = %761, %758
br label %779
767: ; preds = %752
%768 = load i32, i32* %18
%769 = icmp eq i32 %768, 16
br i1 %769, label %770, label %773
770: ; preds = %767
%771 = load i32*, i32** %14
%772 = call i32 (i32*, i8*, ...) @fprintf(i32* %771, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.56, i64 0, i64 0))
br label %778
773: ; preds = %767
%774 = load i32*, i32** %14
%775 = load i32, i32* %18
%776 = mul nsw i32 16, %775
%777 = call i32 (i32*, i8*, ...) @fprintf(i32* %774, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.57, i64 0, i64 0), i32 %776)
br label %778
778: ; preds = %773, %770
br label %779
779: ; preds = %778, %766
%780 = load i32, i32* %30
%781 = icmp eq i32 %780, -1
br i1 %781, label %782, label %785
782: ; preds = %779
%783 = load i32*, i32** %14
%784 = call i32 (i32*, i8*, ...) @fprintf(i32* %783, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.58, i64 0, i64 0))
br label %817
785: ; preds = %779
%786 = load i32*, i32** %14
%787 = load i8*, i8** %7
%788 = call i32 (i32*, i8*, ...) @fprintf(i32* %786, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.59, i64 0, i64 0), i8* %787)
%789 = load i32, i32* %21
%790 = icmp sgt i32 %789, 1
br i1 %790, label %791, label %796
791: ; preds = %785
%792 = load i32*, i32** %14
%793 = load i32, i32* %30
%794 = add nsw i32 %793, 1
%795 = call i32 (i32*, i8*, ...) @fprintf(i32* %792, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %794)
br label %796
796: ; preds = %791, %785
%797 = load i32*, i32** %14
%798 = call i32 (i32*, i8*, ...) @fprintf(i32* %797, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.46, i64 0, i64 0))
%799 = load i32, i32* %30
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %800
%802 = getelementptr inbounds %struct.anon, %struct.anon* %801, i32 0, i32 0
%803 = load i32, i32* %802
%804 = icmp sgt i32 %803, 0
br i1 %804, label %805, label %814
805: ; preds = %796
%806 = load i32*, i32** %14
%807 = load i32, i32* %30
%808 = sext i32 %807 to i64
%809 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %22, i64 0, i64 %808
%810 = getelementptr inbounds %struct.anon, %struct.anon* %809, i32 0, i32 0
%811 = load i32, i32* %810
%812 = mul nsw i32 16, %811
%813 = call i32 (i32*, i8*, ...) @fprintf(i32* %806, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i32 %812)
br label %814
814: ; preds = %805, %796
%815 = load i32*, i32** %14
%816 = call i32 (i32*, i8*, ...) @fprintf(i32* %815, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.48, i64 0, i64 0))
br label %817
817: ; preds = %814, %782
%818 = load i32, i32* %18
store i32 %818, i32* %17
br label %727
819: ; preds = %727
%820 = load i32*, i32** %14
%821 = call i32 (i32*, i8*, ...) @fprintf(i32* %820, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.60, i64 0, i64 0))
br label %822
822: ; preds = %819, %725
%823 = load i32*, i32** %14
%824 = call i32 (i32*, i8*, ...) @fprintf(i32* %823, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.61, i64 0, i64 0))
%825 = load i32*, i32** %14
%826 = call i32 (i32*, i8*, ...) @fprintf(i32* %825, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0))
store i32 0, i32* %39
br label %827
827: ; preds = %834, %822
%828 = load i32, i32* %39
%829 = icmp slt i32 %828, 65536
br i1 %829, label %830, label %837
830: ; preds = %827
%831 = load i32, i32* %39
%832 = sext i32 %831 to i64
%833 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %832
store i32 0, i32* %833
br label %834
834: ; preds = %830
%835 = load i32, i32* %39
%836 = add nsw i32 %835, 1
store i32 %836, i32* %39
br label %827
837: ; preds = %827
store i32 0, i32* %40
br label %838
838: ; preds = %845, %837
%839 = load i32, i32* %40
%840 = icmp slt i32 %839, 256
br i1 %840, label %841, label %848
841: ; preds = %838
%842 = load i32, i32* %40
%843 = sext i32 %842 to i64
%844 = getelementptr inbounds [256 x i32], [256 x i32]* %32, i64 0, i64 %843
store i32 0, i32* %844
br label %845
845: ; preds = %841
%846 = load i32, i32* %40
%847 = add nsw i32 %846, 1
store i32 %847, i32* %40
br label %838
848: ; preds = %838
store i32 0, i32* %38
br label %849
849: ; preds = %869, %848
%850 = load i32, i32* %38
%851 = icmp slt i32 %850, 256
br i1 %851, label %852, label %872
852: ; preds = %849
%853 = load i32, i32* %38
%854 = sext i32 %853 to i64
%855 = getelementptr inbounds [256 x i32], [256 x i32]* %10, i64 0, i64 %854
%856 = load i32, i32* %855
store i32 %856, i32* %39
%857 = load i32, i32* %39
%858 = icmp ne i32 %857, 65533
br i1 %858, label %859, label %868
859: ; preds = %852
%860 = load i32, i32* %38
%861 = load i32, i32* %39
%862 = sext i32 %861 to i64
%863 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %862
store i32 %860, i32* %863
%864 = load i32, i32* %39
%865 = ashr i32 %864, 8
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds [256 x i32], [256 x i32]* %32, i64 0, i64 %866
store i32 1, i32* %867
br label %868
868: ; preds = %859, %852
br label %869
869: ; preds = %868
%870 = load i32, i32* %38
%871 = add nsw i32 %870, 1
store i32 %871, i32* %38
br label %849
872: ; preds = %849
store i32 0, i32* %41
br label %873
873: ; preds = %923, %872
%874 = load i32, i32* %41
%875 = icmp slt i32 %874, 8192
br i1 %875, label %876, label %926
876: ; preds = %873
store i32 1, i32* %44
store i32 1, i32* %45
store i32 0, i32* %42
br label %877
877: ; preds = %900, %876
%878 = load i32, i32* %42
%879 = icmp slt i32 %878, 8
br i1 %879, label %880, label %903
880: ; preds = %877
%881 = load i32, i32* %41
%882 = mul nsw i32 8, %881
%883 = load i32, i32* %42
%884 = add nsw i32 %882, %883
store i32 %884, i32* %39
%885 = load i32, i32* %39
%886 = sext i32 %885 to i64
%887 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %886
%888 = load i32, i32* %887
%889 = icmp ne i32 %888, 0
br i1 %889, label %890, label %891
890: ; preds = %880
store i32 0, i32* %44
br label %891
891: ; preds = %890, %880
%892 = load i32, i32* %39
%893 = sext i32 %892 to i64
%894 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %893
%895 = load i32, i32* %894
%896 = load i32, i32* %39
%897 = icmp ne i32 %895, %896
br i1 %897, label %898, label %899
898: ; preds = %891
store i32 0, i32* %45
br label %899
899: ; preds = %898, %891
br label %900
900: ; preds = %899
%901 = load i32, i32* %42
%902 = add nsw i32 %901, 1
store i32 %902, i32* %42
br label %877
903: ; preds = %877
%904 = load i32, i32* %44
%905 = icmp ne i32 %904, 0
br i1 %905, label %906, label %910
906: ; preds = %903
%907 = load i32, i32* %41
%908 = sext i32 %907 to i64
%909 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %908
store i32 -2, i32* %909
br label %922
910: ; preds = %903
%911 = load i32, i32* %45
%912 = icmp ne i32 %911, 0
br i1 %912, label %913, label %917
913: ; preds = %910
%914 = load i32, i32* %41
%915 = sext i32 %914 to i64
%916 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %915
store i32 -1, i32* %916
br label %921
917: ; preds = %910
%918 = load i32, i32* %41
%919 = sext i32 %918 to i64
%920 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %919
store i32 0, i32* %920
br label %921
921: ; preds = %917, %913
br label %922
922: ; preds = %921, %906
br label %923
923: ; preds = %922
%924 = load i32, i32* %41
%925 = add nsw i32 %924, 1
store i32 %925, i32* %41
br label %873
926: ; preds = %873
store i32 0, i32* %34
store i32 0, i32* %41
br label %927
927: ; preds = %1005, %926
%928 = load i32, i32* %41
%929 = icmp slt i32 %928, 8192
br i1 %929, label %930, label %1008
930: ; preds = %927
%931 = load i32, i32* %41
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %932
%934 = load i32, i32* %933
%935 = icmp sge i32 %934, 0
br i1 %935, label %936, label %1004
936: ; preds = %930
%937 = load i32, i32* %34
%938 = icmp sgt i32 %937, 0
br i1 %938, label %939, label %984
939: ; preds = %936
%940 = load i32, i32* %41
%941 = icmp sgt i32 %940, 0
br i1 %941, label %942, label %951
942: ; preds = %939
%943 = load i32, i32* %41
%944 = sub nsw i32 %943, 1
%945 = sext i32 %944 to i64
%946 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %945
%947 = load i32, i32* %946
%948 = load i32, i32* %34
%949 = sub nsw i32 %948, 1
%950 = icmp eq i32 %947, %949
br i1 %950, label %972, label %951
951: ; preds = %942, %939
%952 = load i32, i32* %34
%953 = sub nsw i32 %952, 1
%954 = sext i32 %953 to i64
%955 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %954
%956 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %955, i32 0, i32 1
%957 = load i32, i32* %956
%958 = ashr i32 %957, 5
%959 = load i32, i32* %41
%960 = ashr i32 %959, 5
%961 = icmp eq i32 %958, %960
br i1 %961, label %962, label %984
962: ; preds = %951
%963 = load i32, i32* %41
%964 = load i32, i32* %34
%965 = sub nsw i32 %964, 1
%966 = sext i32 %965 to i64
%967 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %966
%968 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %967, i32 0, i32 1
%969 = load i32, i32* %968
%970 = sub nsw i32 %963, %969
%971 = icmp sle i32 %970, 8
br i1 %971, label %972, label %984
972: ; preds = %962, %942
%973 = load i32, i32* %34
%974 = sub nsw i32 %973, 1
%975 = load i32, i32* %41
%976 = sext i32 %975 to i64
%977 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %976
store i32 %974, i32* %977
%978 = load i32, i32* %41
%979 = load i32, i32* %34
%980 = sub nsw i32 %979, 1
%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 1
store i32 %978, i32* %983
br label %1003
984: ; preds = %962, %951, %936
%985 = load i32, i32* %34
%986 = add nsw i32 %985, 1
store i32 %986, i32* %34
%987 = load i32, i32* %34
%988 = sub nsw i32 %987, 1
%989 = load i32, i32* %41
%990 = sext i32 %989 to i64
%991 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %990
store i32 %988, i32* %991
%992 = load i32, i32* %41
%993 = load i32, i32* %34
%994 = sub nsw i32 %993, 1
%995 = sext i32 %994 to i64
%996 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %995
%997 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %996, i32 0, i32 1
store i32 %992, i32* %997
%998 = load i32, i32* %34
%999 = sub nsw i32 %998, 1
%1000 = sext i32 %999 to i64
%1001 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1000
%1002 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1001, i32 0, i32 0
store i32 %992, i32* %1002
br label %1003
1003: ; preds = %984, %972
br label %1004
1004: ; preds = %1003, %930
br label %1005
1005: ; preds = %1004
%1006 = load i32, i32* %41
%1007 = add nsw i32 %1006, 1
store i32 %1007, i32* %41
br label %927
1008: ; preds = %927
store i32 0, i32* %43
br label %1009
1009: ; preds = %1054, %1008
%1010 = load i32, i32* %43
%1011 = load i32, i32* %34
%1012 = icmp slt i32 %1010, %1011
br i1 %1012, label %1013, label %1057
1013: ; preds = %1009
%1014 = load i32, i32* %43
%1015 = sext i32 %1014 to i64
%1016 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1015
%1017 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1016, i32 0, i32 2
store i32 0, i32* %1017
%1018 = load i32, i32* %43
%1019 = sext i32 %1018 to i64
%1020 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1019
%1021 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1020, i32 0, i32 0
%1022 = load i32, i32* %1021
%1023 = mul nsw i32 8, %1022
store i32 %1023, i32* %41
%1024 = load i32, i32* %43
%1025 = sext i32 %1024 to i64
%1026 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1025
%1027 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1026, i32 0, i32 1
%1028 = load i32, i32* %1027
%1029 = add nsw i32 %1028, 1
%1030 = mul nsw i32 8, %1029
store i32 %1030, i32* %42
%1031 = load i32, i32* %41
store i32 %1031, i32* %39
br label %1032
1032: ; preds = %1050, %1013
%1033 = load i32, i32* %39
%1034 = load i32, i32* %42
%1035 = icmp slt i32 %1033, %1034
br i1 %1035, label %1036, label %1053
1036: ; preds = %1032
%1037 = load i32, i32* %39
%1038 = sext i32 %1037 to i64
%1039 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %1038
%1040 = load i32, i32* %1039
%1041 = icmp ne i32 %1040, 0
br i1 %1041, label %1042, label %1049
1042: ; preds = %1036
%1043 = load i32, i32* %43
%1044 = sext i32 %1043 to i64
%1045 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1044
%1046 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1045, i32 0, i32 2
%1047 = load i32, i32* %1046
%1048 = add nsw i32 %1047, 1
store i32 %1048, i32* %1046
br label %1049
1049: ; preds = %1042, %1036
br label %1050
1050: ; preds = %1049
%1051 = load i32, i32* %39
%1052 = add nsw i32 %1051, 1
store i32 %1052, i32* %39
br label %1032
1053: ; preds = %1032
br label %1054
1054: ; preds = %1053
%1055 = load i32, i32* %43
%1056 = add nsw i32 %1055, 1
store i32 %1056, i32* %43
br label %1009
1057: ; preds = %1009
store i32 0, i32* %43
store i32 -1, i32* %40
store i32 0, i32* %38
br label %1058
1058: ; preds = %1108, %1057
%1059 = load i32, i32* %43
%1060 = load i32, i32* %34
%1061 = icmp slt i32 %1059, %1060
br i1 %1061, label %1062, label %1111
1062: ; preds = %1058
%1063 = load i32, i32* %43
%1064 = sext i32 %1063 to i64
%1065 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1064
%1066 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1065, i32 0, i32 2
%1067 = load i32, i32* %1066
%1068 = icmp sgt i32 %1067, 1
br i1 %1068, label %1069, label %1102
1069: ; preds = %1062
%1070 = load i32, i32* %40
%1071 = load i32, i32* %43
%1072 = sext i32 %1071 to i64
%1073 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1072
%1074 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1073, i32 0, i32 0
%1075 = load i32, i32* %1074
%1076 = ashr i32 %1075, 5
%1077 = icmp eq i32 %1070, %1076
br i1 %1077, label %1078, label %1085
1078: ; preds = %1069
%1079 = call i8* @malloc(i32 6)
store i8* %1079, i8** %46
%1080 = load i8*, i8** %46
%1081 = load i32, i32* %40
%1082 = load i32, i32* %38
%1083 = add nsw i32 %1082, 1
store i32 %1083, i32* %38
%1084 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* %1080, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.62, i64 0, i64 0), i32 %1081, i32 %1083)
br label %1096
1085: ; preds = %1069
%1086 = load i32, i32* %43
%1087 = sext i32 %1086 to i64
%1088 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1087
%1089 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1088, i32 0, i32 0
%1090 = load i32, i32* %1089
%1091 = ashr i32 %1090, 5
store i32 %1091, i32* %40
%1092 = call i8* @malloc(i32 3)
store i8* %1092, i8** %46
%1093 = load i8*, i8** %46
%1094 = load i32, i32* %40
%1095 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* %1093, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.63, i64 0, i64 0), i32 %1094)
br label %1096
1096: ; preds = %1085, %1078
%1097 = load i8*, i8** %46
%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 3
store i8* %1097, i8** %1101
br label %1107
1102: ; preds = %1062
%1103 = load i32, i32* %43
%1104 = sext i32 %1103 to i64
%1105 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1104
%1106 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1105, i32 0, i32 3
store i8* null, i8** %1106
br label %1107
1107: ; preds = %1102, %1096
br label %1108
1108: ; preds = %1107
%1109 = load i32, i32* %43
%1110 = add nsw i32 %1109, 1
store i32 %1110, i32* %43
br label %1058
1111: ; preds = %1058
store i32 -1, i32* %40
store i32 0, i32* %43
br label %1112
1112: ; preds = %1212, %1111
%1113 = load i32, i32* %43
%1114 = load i32, i32* %34
%1115 = icmp slt i32 %1113, %1114
br i1 %1115, label %1116, label %1215
1116: ; preds = %1112
%1117 = load i32, i32* %43
%1118 = sext i32 %1117 to i64
%1119 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1118
%1120 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1119, i32 0, i32 2
%1121 = load i32, i32* %1120
%1122 = icmp sgt i32 %1121, 1
br i1 %1122, label %1123, label %1211
1123: ; preds = %1116
store i32 0, i32* %40
%1124 = load i32*, i32** %14
%1125 = load i8*, i8** %7
%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 3
%1130 = load i8*, i8** %1129
%1131 = load i32, i32* %43
%1132 = sext i32 %1131 to i64
%1133 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1132
%1134 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1133, i32 0, i32 1
%1135 = load i32, i32* %1134
%1136 = load i32, i32* %43
%1137 = sext i32 %1136 to i64
%1138 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1137
%1139 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1138, i32 0, i32 0
%1140 = load i32, i32* %1139
%1141 = sub nsw i32 %1135, %1140
%1142 = add nsw i32 %1141, 1
%1143 = mul nsw i32 8, %1142
%1144 = call i32 (i32*, i8*, ...) @fprintf(i32* %1124, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.64, i64 0, i64 0), i8* %1125, i8* %1130, i32 %1143)
%1145 = load i32, i32* %43
%1146 = sext i32 %1145 to i64
%1147 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1146
%1148 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1147, i32 0, i32 0
%1149 = load i32, i32* %1148
store i32 %1149, i32* %41
br label %1150
1150: ; preds = %1205, %1123
%1151 = load i32, i32* %41
%1152 = load i32, i32* %43
%1153 = sext i32 %1152 to i64
%1154 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1153
%1155 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1154, i32 0, i32 1
%1156 = load i32, i32* %1155
%1157 = icmp sle i32 %1151, %1156
br i1 %1157, label %1158, label %1208
1158: ; preds = %1150
%1159 = load i32, i32* %41
%1160 = srem i32 %1159, 32
%1161 = icmp eq i32 %1160, 0
br i1 %1161, label %1162, label %1175
1162: ; preds = %1158
%1163 = load i32, i32* %41
%1164 = load i32, i32* %43
%1165 = sext i32 %1164 to i64
%1166 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1165
%1167 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1166, i32 0, i32 0
%1168 = load i32, i32* %1167
%1169 = icmp sgt i32 %1163, %1168
br i1 %1169, label %1170, label %1175
1170: ; preds = %1162
%1171 = load i32*, i32** %14
%1172 = load i32, i32* %41
%1173 = mul nsw i32 8, %1172
%1174 = call i32 (i32*, i8*, ...) @fprintf(i32* %1171, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.65, i64 0, i64 0), i32 %1173)
br label %1175
1175: ; preds = %1170, %1162, %1158
%1176 = load i32*, i32** %14
%1177 = call i32 (i32*, i8*, ...) @fprintf(i32* %1176, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.29, i64 0, i64 0))
store i32 0, i32* %42
br label %1178
1178: ; preds = %1192, %1175
%1179 = load i32, i32* %42
%1180 = icmp slt i32 %1179, 8
br i1 %1180, label %1181, label %1195
1181: ; preds = %1178
%1182 = load i32, i32* %41
%1183 = mul nsw i32 8, %1182
%1184 = load i32, i32* %42
%1185 = add nsw i32 %1183, %1184
store i32 %1185, i32* %39
%1186 = load i32*, i32** %14
%1187 = load i32, i32* %39
%1188 = sext i32 %1187 to i64
%1189 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %1188
%1190 = load i32, i32* %1189
%1191 = call i32 (i32*, i8*, ...) @fprintf(i32* %1186, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.66, i64 0, i64 0), i32 %1190)
br label %1192
1192: ; preds = %1181
%1193 = load i32, i32* %42
%1194 = add nsw i32 %1193, 1
store i32 %1194, i32* %42
br label %1178
1195: ; preds = %1178
%1196 = load i32*, i32** %14
%1197 = load i32, i32* %41
%1198 = srem i32 %1197, 32
%1199 = mul nsw i32 8, %1198
%1200 = load i32, i32* %41
%1201 = srem i32 %1200, 32
%1202 = mul nsw i32 8, %1201
%1203 = add nsw i32 %1202, 7
%1204 = call i32 (i32*, i8*, ...) @fprintf(i32* %1196, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.67, i64 0, i64 0), i32 %1199, i32 %1203)
br label %1205
1205: ; preds = %1195
%1206 = load i32, i32* %41
%1207 = add nsw i32 %1206, 1
store i32 %1207, i32* %41
br label %1150
1208: ; preds = %1150
%1209 = load i32*, i32** %14
%1210 = call i32 (i32*, i8*, ...) @fprintf(i32* %1209, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.31, i64 0, i64 0))
br label %1211
1211: ; preds = %1208, %1116
br label %1212
1212: ; preds = %1211
%1213 = load i32, i32* %43
%1214 = add nsw i32 %1213, 1
store i32 %1214, i32* %43
br label %1112
1215: ; preds = %1112
%1216 = load i32, i32* %40
%1217 = icmp sge i32 %1216, 0
br i1 %1217, label %1218, label %1221
1218: ; preds = %1215
%1219 = load i32*, i32** %14
%1220 = call i32 (i32*, i8*, ...) @fprintf(i32* %1219, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.23, i64 0, i64 0))
br label %1221
1221: ; preds = %1218, %1215
store i32 0, i32* %36
store i32 0, i32* %41
br label %1222
1222: ; preds = %1267, %1221
%1223 = load i32, i32* %41
%1224 = icmp slt i32 %1223, 8192
br i1 %1224, label %1225, label %1269
1225: ; preds = %1222
%1226 = load i32, i32* %41
%1227 = sext i32 %1226 to i64
%1228 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %1227
%1229 = load i32, i32* %1228
store i32 %1229, i32* %43
%1230 = load i32, i32* %41
store i32 %1230, i32* %42
br label %1231
1231: ; preds = %1244, %1225
%1232 = load i32, i32* %42
%1233 = icmp slt i32 %1232, 8192
br i1 %1233, label %1234, label %1241
1234: ; preds = %1231
%1235 = load i32, i32* %42
%1236 = sext i32 %1235 to i64
%1237 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %1236
%1238 = load i32, i32* %1237
%1239 = load i32, i32* %43
%1240 = icmp eq i32 %1238, %1239
br label %1241
1241: ; preds = %1234, %1231
%1242 = phi i1 [ false, %1231 ], [ %1240, %1234 ]
br i1 %1242, label %1243, label %1247
1243: ; preds = %1241
br label %1244
1244: ; preds = %1243
%1245 = load i32, i32* %42
%1246 = add nsw i32 %1245, 1
store i32 %1246, i32* %42
br label %1231
1247: ; preds = %1241
%1248 = load i32, i32* %43
%1249 = icmp sge i32 %1248, 0
br i1 %1249, label %1250, label %1257
1250: ; preds = %1247
%1251 = load i32, i32* %43
%1252 = sext i32 %1251 to i64
%1253 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1252
%1254 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1253, i32 0, i32 1
%1255 = load i32, i32* %1254
%1256 = add nsw i32 %1255, 1
store i32 %1256, i32* %42
br label %1257
1257: ; preds = %1250, %1247
%1258 = load i32, i32* %43
%1259 = icmp eq i32 %1258, -2
br i1 %1259, label %1267, label %1260
1260: ; preds = %1257
%1261 = load i32, i32* %43
%1262 = icmp eq i32 %1261, -1
br i1 %1262, label %1263, label %1266
1263: ; preds = %1260
%1264 = load i32, i32* %41
%1265 = icmp eq i32 %1264, 0
br i1 %1265, label %1267, label %1266
1266: ; preds = %1263, %1260
store i32 1, i32* %36
br label %1267
1267: ; preds = %1266, %1263, %1257
%1268 = load i32, i32* %42
store i32 %1268, i32* %41
br label %1222
1269: ; preds = %1222
store i32 0, i32* %37
%1270 = load i32*, i32** %14
%1271 = load i8*, i8** %7
%1272 = call i32 (i32*, i8*, ...) @fprintf(i32* %1270, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.68, i64 0, i64 0), i8* %1271)
%1273 = load i32*, i32** %14
%1274 = call i32 (i32*, i8*, ...) @fprintf(i32* %1273, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.33, i64 0, i64 0))
%1275 = load i32, i32* %36
%1276 = icmp ne i32 %1275, 0
br i1 %1276, label %1277, label %1280
1277: ; preds = %1269
%1278 = load i32*, i32** %14
%1279 = call i32 (i32*, i8*, ...) @fprintf(i32* %1278, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.69, i64 0, i64 0))
br label %1280
1280: ; preds = %1277, %1269
store i32 0, i32* %41
br label %1281
1281: ; preds = %1467, %1280
%1282 = load i32, i32* %41
%1283 = icmp slt i32 %1282, 8192
br i1 %1283, label %1284, label %1469
1284: ; preds = %1281
%1285 = load i32, i32* %41
%1286 = sext i32 %1285 to i64
%1287 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %1286
%1288 = load i32, i32* %1287
store i32 %1288, i32* %43
%1289 = load i32, i32* %41
store i32 %1289, i32* %42
br label %1290
1290: ; preds = %1303, %1284
%1291 = load i32, i32* %42
%1292 = icmp slt i32 %1291, 8192
br i1 %1292, label %1293, label %1300
1293: ; preds = %1290
%1294 = load i32, i32* %42
%1295 = sext i32 %1294 to i64
%1296 = getelementptr inbounds [8192 x i32], [8192 x i32]* %33, i64 0, i64 %1295
%1297 = load i32, i32* %1296
%1298 = load i32, i32* %43
%1299 = icmp eq i32 %1297, %1298
br label %1300
1300: ; preds = %1293, %1290
%1301 = phi i1 [ false, %1290 ], [ %1299, %1293 ]
br i1 %1301, label %1302, label %1306
1302: ; preds = %1300
br label %1303
1303: ; preds = %1302
%1304 = load i32, i32* %42
%1305 = add nsw i32 %1304, 1
store i32 %1305, i32* %42
br label %1290
1306: ; preds = %1300
%1307 = load i32, i32* %43
%1308 = icmp sge i32 %1307, 0
br i1 %1308, label %1309, label %1337
1309: ; preds = %1306
%1310 = load i32, i32* %41
%1311 = load i32, i32* %43
%1312 = sext i32 %1311 to i64
%1313 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1312
%1314 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1313, i32 0, i32 0
%1315 = load i32, i32* %1314
%1316 = icmp ne i32 %1310, %1315
br i1 %1316, label %1317, label %1319
1317: ; preds = %1309
%1318 = call i32 (...) @abort()
unreachable
1319: ; preds = %1309
%1320 = load i32, i32* %42
%1321 = load i32, i32* %43
%1322 = sext i32 %1321 to i64
%1323 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1322
%1324 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1323, i32 0, i32 1
%1325 = load i32, i32* %1324
%1326 = add nsw i32 %1325, 1
%1327 = icmp sgt i32 %1320, %1326
br i1 %1327, label %1328, label %1330
1328: ; preds = %1319
%1329 = call i32 (...) @abort()
unreachable
1330: ; preds = %1319
%1331 = load i32, i32* %43
%1332 = sext i32 %1331 to i64
%1333 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1332
%1334 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1333, i32 0, i32 1
%1335 = load i32, i32* %1334
%1336 = add nsw i32 %1335, 1
store i32 %1336, i32* %42
br label %1337
1337: ; preds = %1330, %1306
%1338 = load i32, i32* %43
%1339 = icmp eq i32 %1338, -2
br i1 %1339, label %1340, label %1341
1340: ; preds = %1337
br label %1467
1341: ; preds = %1337
%1342 = load i32, i32* %41
%1343 = icmp eq i32 %1342, 0
br i1 %1343, label %1344, label %1347
1344: ; preds = %1341
%1345 = load i32*, i32** %14
%1346 = call i32 (i32*, i8*, ...) @fprintf(i32* %1345, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0))
br label %1350
1347: ; preds = %1341
%1348 = load i32*, i32** %14
%1349 = call i32 (i32*, i8*, ...) @fprintf(i32* %1348, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.70, i64 0, i64 0))
br label %1350
1350: ; preds = %1347, %1344
%1351 = load i32, i32* %43
%1352 = icmp sge i32 %1351, 0
br i1 %1352, label %1353, label %1362
1353: ; preds = %1350
%1354 = load i32, i32* %43
%1355 = sext i32 %1354 to i64
%1356 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1355
%1357 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1356, i32 0, i32 2
%1358 = load i32, i32* %1357
%1359 = icmp eq i32 %1358, 0
br i1 %1359, label %1360, label %1362
1360: ; preds = %1353
%1361 = call i32 (...) @abort()
unreachable
1362: ; preds = %1353, %1350
%1363 = load i32, i32* %43
%1364 = icmp sge i32 %1363, 0
br i1 %1364, label %1365, label %1406
1365: ; preds = %1362
%1366 = load i32, i32* %43
%1367 = sext i32 %1366 to i64
%1368 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1367
%1369 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1368, i32 0, i32 2
%1370 = load i32, i32* %1369
%1371 = icmp eq i32 %1370, 1
br i1 %1371, label %1372, label %1406
1372: ; preds = %1365
%1373 = load i32, i32* %42
%1374 = load i32, i32* %41
%1375 = add nsw i32 %1374, 1
%1376 = icmp ne i32 %1373, %1375
br i1 %1376, label %1377, label %1379
1377: ; preds = %1372
%1378 = call i32 (...) @abort()
unreachable
1379: ; preds = %1372
%1380 = load i32, i32* %41
%1381 = mul nsw i32 8, %1380
store i32 %1381, i32* %39
br label %1382
1382: ; preds = %1402, %1379
%1383 = load i32, i32* %39
%1384 = load i32, i32* %42
%1385 = mul nsw i32 8, %1384
%1386 = icmp slt i32 %1383, %1385
br i1 %1386, label %1387, label %1405
1387: ; preds = %1382
%1388 = load i32, i32* %39
%1389 = sext i32 %1388 to i64
%1390 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %1389
%1391 = load i32, i32* %1390
%1392 = icmp ne i32 %1391, 0
br i1 %1392, label %1393, label %1401
1393: ; preds = %1387
%1394 = load i32*, i32** %14
%1395 = load i32, i32* %39
%1396 = load i32, i32* %39
%1397 = sext i32 %1396 to i64
%1398 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 %1397
%1399 = load i32, i32* %1398
%1400 = call i32 (i32*, i8*, ...) @fprintf(i32* %1394, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.71, i64 0, i64 0), i32 %1395, i32 %1399)
br label %1405
1401: ; preds = %1387
br label %1402
1402: ; preds = %1401
%1403 = load i32, i32* %39
%1404 = add nsw i32 %1403, 1
store i32 %1404, i32* %39
br label %1382
1405: ; preds = %1393, %1382
br label %1466
1406: ; preds = %1365, %1362
%1407 = load i32, i32* %41
%1408 = icmp eq i32 %1407, 0
br i1 %1408, label %1409, label %1414
1409: ; preds = %1406
%1410 = load i32*, i32** %14
%1411 = load i32, i32* %42
%1412 = mul nsw i32 8, %1411
%1413 = call i32 (i32*, i8*, ...) @fprintf(i32* %1410, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.72, i64 0, i64 0), i32 %1412)
br label %1421
1414: ; preds = %1406
%1415 = load i32*, i32** %14
%1416 = load i32, i32* %41
%1417 = mul nsw i32 8, %1416
%1418 = load i32, i32* %42
%1419 = mul nsw i32 8, %1418
%1420 = call i32 (i32*, i8*, ...) @fprintf(i32* %1415, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.73, i64 0, i64 0), i32 %1417, i32 %1419)
br label %1421
1421: ; preds = %1414, %1409
%1422 = load i32, i32* %43
%1423 = icmp eq i32 %1422, -1
br i1 %1423, label %1424, label %1434
1424: ; preds = %1421
%1425 = load i32, i32* %41
%1426 = icmp eq i32 %1425, 0
br i1 %1426, label %1427, label %1430
1427: ; preds = %1424
%1428 = load i32*, i32** %14
%1429 = call i32 (i32*, i8*, ...) @fprintf(i32* %1428, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.74, i64 0, i64 0))
br label %1433
1430: ; preds = %1424
%1431 = load i32*, i32** %14
%1432 = call i32 (i32*, i8*, ...) @fprintf(i32* %1431, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.75, i64 0, i64 0))
br label %1433
1433: ; preds = %1430, %1427
br label %1465
1434: ; preds = %1421
%1435 = load i32*, i32** %14
%1436 = load i8*, i8** %7
%1437 = load i32, i32* %43
%1438 = sext i32 %1437 to i64
%1439 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1438
%1440 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1439, i32 0, i32 3
%1441 = load i8*, i8** %1440
%1442 = call i32 (i32*, i8*, ...) @fprintf(i32* %1435, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.76, i64 0, i64 0), i8* %1436, i8* %1441)
%1443 = load i32, i32* %43
%1444 = sext i32 %1443 to i64
%1445 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %35, i64 0, i64 %1444
%1446 = getelementptr inbounds %struct.anon.0, %struct.anon.0* %1445, i32 0, i32 0
%1447 = load i32, i32* %1446
%1448 = icmp sgt i32 %1447, 0
br i1 %1448, label %1449, label %1454
1449: ; preds = %1434
%1450 = load i32*, i32** %14
%1451 = load i32, i32* %41
%1452 = mul nsw i32 8, %1451
%1453 = call i32 (i32*, i8*, ...) @fprintf(i32* %1450, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.77, i64 0, i64 0), i32 %1452)
br label %1454
1454: ; preds = %1449, %1434
%1455 = load i32*, i32** %14
%1456 = call i32 (i32*, i8*, ...) @fprintf(i32* %1455, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.48, i64 0, i64 0))
%1457 = load i32, i32* %41
%1458 = icmp eq i32 %1457, 0
br i1 %1458, label %1459, label %1464
1459: ; preds = %1454
%1460 = getelementptr inbounds [65536 x i32], [65536 x i32]* %31, i64 0, i64 0
%1461 = load i32, i32* %1460
%1462 = icmp eq i32 %1461, 0
br i1 %1462, label %1463, label %1464
1463: ; preds = %1459
store i32 1, i32* %37
br label %1464
1464: ; preds = %1463, %1459, %1454
br label %1465
1465: ; preds = %1464, %1433
br label %1466
1466: ; preds = %1465, %1405
br label %1467
1467: ; preds = %1466, %1340
%1468 = load i32, i32* %42
store i32 %1468, i32* %41
br label %1281
1469: ; preds = %1281
%1470 = load i32, i32* %36
%1471 = icmp ne i32 %1470, 0
br i1 %1471, label %1472, label %1488
1472: ; preds = %1469
%1473 = load i32, i32* %37
%1474 = icmp ne i32 %1473, 0
br i1 %1474, label %1475, label %1478
1475: ; preds = %1472
%1476 = load i32*, i32** %14
%1477 = call i32 (i32*, i8*, ...) @fprintf(i32* %1476, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.78, i64 0, i64 0))
br label %1481
1478: ; preds = %1472
%1479 = load i32*, i32** %14
%1480 = call i32 (i32*, i8*, ...) @fprintf(i32* %1479, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.79, i64 0, i64 0))
br label %1481
1481: ; preds = %1478, %1475
%1482 = load i32*, i32** %14
%1483 = call i32 (i32*, i8*, ...) @fprintf(i32* %1482, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.80, i64 0, i64 0))
%1484 = load i32*, i32** %14
%1485 = call i32 (i32*, i8*, ...) @fprintf(i32* %1484, i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.81, i64 0, i64 0))
%1486 = load i32*, i32** %14
%1487 = call i32 (i32*, i8*, ...) @fprintf(i32* %1486, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.53, i64 0, i64 0))
br label %1488
1488: ; preds = %1481, %1469
%1489 = load i32*, i32** %14
%1490 = call i32 (i32*, i8*, ...) @fprintf(i32* %1489, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.82, i64 0, i64 0))
%1491 = load i32*, i32** %14
%1492 = call i32 (i32*, i8*, ...) @fprintf(i32* %1491, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.61, i64 0, i64 0))
%1493 = load i32*, i32** %14
%1494 = call i64 @ferror(i32* %1493)
%1495 = icmp ne i64 %1494, 0
br i1 %1495, label %1500, label %1496
1496: ; preds = %1488
%1497 = load i32*, i32** %14
%1498 = call i64 @fclose(i32* %1497)
%1499 = icmp ne i64 %1498, 0
br i1 %1499, label %1500, label %1502
1500: ; preds = %1496, %1488
%1501 = call i32 @exit(i32 1)
unreachable
1502: ; preds = %1496
%1503 = 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.6 = [4 x i8] c"/*\0A\00"
@.str.7 = [59 x i8] c" * Copyright (C) 1999-2002 Free Software Foundation, Inc.\0A\00"
@.str.8 = [51 x i8] c" * This file is part of the GNU LIBICONV Library.\0A\00"
@.str.9 = [4 x i8] c" *\0A\00"
@.str.10 = [71 x i8] c" * The GNU LIBICONV Library is free software; you can redistribute it\0A\00"
@.str.11 = [71 x i8] c" * and/or modify it under the terms of the GNU Library General Public\0A\00"
@.str.12 = [75 x i8] c" * License as published by the Free Software Foundation; either version 2\0A\00"
@.str.13 = [59 x i8] c" * of the License, or (at your option) any later version.\0A\00"
@.str.14 = [72 x i8] c" * The GNU LIBICONV Library is distributed in the hope that it will be\0A\00"
@.str.15 = [75 x i8] c" * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of\0A\00"
@.str.16 = [70 x i8] c" * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\0A\00"
@.str.17 = [53 x i8] c" * Library General Public License for more details.\0A\00"
@.str.18 = [70 x i8] c" * You should have received a copy of the GNU Library General Public\0A\00"
@.str.19 = [75 x i8] c" * License along with the GNU LIBICONV Library; see the file COPYING.LIB.\0A\00"
@.str.20 = [75 x i8] c" * If not, write to the Free Software Foundation, Inc., 59 Temple Place -\0A\00"
@.str.21 = [43 x i8] c" * Suite 330, Boston, MA 02111-1307, USA.\0A\00"
@.str.22 = [5 x i8] c" */\0A\00"
@.str.24 = [7 x i8] c" * %s\0A\00"
@.str.25 = [36 x i8] c"static const unsigned short %s_2uni\00"
@.str.26 = [4 x i8] c"_%d\00"
@.str.27 = [10 x i8] c"[%d] = {\0A\00"
@.str.28 = [16 x i8] c" /* 0x%02x */\0A\00"
@.str.30 = [9 x i8] c" 0x%04x,\00"
@.str.31 = [4 x i8] c"};\0A\00"
@.str.32 = [80 x i8] c"static int\0A%s_mbtowc (conv_t conv, ucs4_t *pwc, const unsigned char *s, int n)\0A\00"
@.str.33 = [3 x i8] c"{\0A\00"
@.str.34 = [25 x i8] c" unsigned char c = *s;\0A\00"
@.str.35 = [3 x i8] c" \00"
@.str.36 = [5 x i8] c" \00"
@.str.37 = [21 x i8] c" if (c < 0x%02x) {\0A\00"
@.str.38 = [10 x i8] c" else {\0A\00"
@.str.39 = [26 x i8] c" else if (c < 0x%02x) {\0A\00"
@.str.40 = [22 x i8] c"%s*pwc = (ucs4_t) c;\0A\00"
@.str.41 = [13 x i8] c"%sreturn 1;\0A\00"
@.str.43 = [21 x i8] c"unsigned short wc = \00"
@.str.44 = [17 x i8] c"*pwc = (ucs4_t) \00"
@.str.45 = [8 x i8] c"%s_2uni\00"
@.str.46 = [3 x i8] c"[c\00"
@.str.47 = [8 x i8] c"-0x%02x\00"
@.str.48 = [4 x i8] c"];\0A\00"
@.str.49 = [23 x i8] c"%sif (wc != 0xfffd) {\0A\00"
@.str.50 = [25 x i8] c"%s *pwc = (ucs4_t) wc;\0A\00"
@.str.51 = [15 x i8] c"%s return 1;\0A\00"
@.str.52 = [5 x i8] c"%s}\0A\00"
@.str.53 = [5 x i8] c" }\0A\00"
@.str.54 = [21 x i8] c" return RET_ILSEQ;\0A\00"
@.str.55 = [23 x i8] c" if (c < 0x%02x)\0A \00"
@.str.56 = [12 x i8] c" else\0A \00"
@.str.57 = [28 x i8] c" else if (c < 0x%02x)\0A \00"
@.str.58 = [20 x i8] c"*pwc = (ucs4_t) c;\0A\00"
@.str.59 = [24 x i8] c"*pwc = (ucs4_t) %s_2uni\00"
@.str.60 = [13 x i8] c" return 1;\0A\00"
@.str.61 = [3 x i8] c"}\0A\00"
@.str.62 = [8 x i8] c"%02x_%d\00"
@.str.63 = [5 x i8] c"%02x\00"
@.str.64 = [46 x i8] c"static const unsigned char %s_page%s[%d] = {\0A\00"
@.str.65 = [16 x i8] c" /* 0x%04x */\0A\00"
@.str.66 = [9 x i8] c" 0x%02x,\00"
@.str.67 = [22 x i8] c" /* 0x%02x-0x%02x */\0A\00"
@.str.68 = [72 x i8] c"static int\0A%s_wctomb (conv_t conv, unsigned char *r, ucs4_t wc, int n)\0A\00"
@.str.69 = [24 x i8] c" unsigned char c = 0;\0A\00"
@.str.70 = [8 x i8] c" else \00"
@.str.71 = [35 x i8] c"if (wc == 0x%04x)\0A c = 0x%02x;\0A\00"
@.str.72 = [17 x i8] c"if (wc < 0x%04x)\00"
@.str.73 = [33 x i8] c"if (wc >= 0x%04x && wc < 0x%04x)\00"
@.str.74 = [35 x i8] c" {\0A *r = wc;\0A return 1;\0A }\0A\00"
@.str.75 = [14 x i8] c"\0A c = wc;\0A\00"
@.str.76 = [22 x i8] c"\0A c = %s_page%s[wc\00"
@.str.77 = [8 x i8] c"-0x%04x\00"
@.str.78 = [28 x i8] c" if (c != 0 || wc == 0) {\0A\00"
@.str.79 = [17 x i8] c" if (c != 0) {\0A\00"
@.str.80 = [13 x i8] c" *r = c;\0A\00"
@.str.81 = [15 x i8] c" return 1;\0A\00"
@.str.82 = [21 x i8] c" return RET_ILUNI;\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 i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i64 3, i64 1, i32* %262)
%268 = call i64 @fwrite(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.7, i64 0, i64 0), i64 58, i64 1, i32* %262)
%269 = call i64 @fwrite(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.8, i64 0, i64 0), i64 50, i64 1, i32* %262)
%270 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i64 3, i64 1, i32* %262)
%271 = call i64 @fwrite(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.10, i64 0, i64 0), i64 70, i64 1, i32* %262)
%272 = call i64 @fwrite(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.11, i64 0, i64 0), i64 70, i64 1, i32* %262)
%273 = call i64 @fwrite(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.12, i64 0, i64 0), i64 74, i64 1, i32* %262)
%274 = call i64 @fwrite(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.13, i64 0, i64 0), i64 58, i64 1, i32* %262)
%275 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i64 3, i64 1, i32* %262)
%276 = call i64 @fwrite(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.14, i64 0, i64 0), i64 71, i64 1, i32* %262)
%277 = call i64 @fwrite(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.15, i64 0, i64 0), i64 74, i64 1, i32* %262)
%278 = call i64 @fwrite(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.16, i64 0, i64 0), i64 69, i64 1, i32* %262)
%279 = call i64 @fwrite(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.17, i64 0, i64 0), i64 52, i64 1, i32* %262)
%280 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.9, i64 0, i64 0), i64 3, i64 1, i32* %262)
%281 = call i64 @fwrite(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.18, i64 0, i64 0), i64 69, i64 1, i32* %262)
%282 = call i64 @fwrite(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.19, i64 0, i64 0), i64 74, i64 1, i32* %262)
%283 = call i64 @fwrite(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.20, i64 0, i64 0), i64 74, i64 1, i32* %262)
%284 = call i64 @fwrite(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.21, i64 0, i64 0), i64 42, i64 1, i32* %262)
%285 = call i64 @fwrite(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.22, i64 0, i64 0), i64 4, i64 1, i32* %262)
%286 = call i32 @fputc(i32 10, i32* %262)
%287 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i64 0, i64 0), i64 3, i64 1, i32* %262)
%288 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i64 0, i64 0), i8* %18)
%289 = call i64 @fwrite(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.22, i64 0, i64 0), i64 4, i64 1, i32* %262)
%290 = call i32 @fputc(i32 10, i32* %262)
%291 = bitcast [16 x i32]* %5 to i8*
%292 = bitcast [16 x %struct.anon]* %6 to i8*
br label %293
293: ; preds = %266, %387
%294 = phi i64 [ 0, %266 ], [ %388, %387 ]
%295 = shl nsw i64 %294, 4
%296 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %295
%297 = bitcast i32* %296 to <16 x i32>*
%298 = load <16 x i32>, <16 x i32>* %297
%299 = freeze <16 x i32> %298
%300 = icmp ne <16 x i32> %299, <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>
%301 = bitcast <16 x i1> %300 to i16
%302 = icmp eq i16 %301, 0
br i1 %302, label %303, label %305
303: ; preds = %293
%304 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %294
store i32 -2, i32* %304
br label %387
305: ; preds = %293
%306 = or i64 %295, 15
%307 = or i64 %295, 14
%308 = or i64 %295, 13
%309 = or i64 %295, 12
%310 = or i64 %295, 11
%311 = or i64 %295, 10
%312 = or i64 %295, 9
%313 = or i64 %295, 8
%314 = or i64 %295, 7
%315 = or i64 %295, 6
%316 = or i64 %295, 5
%317 = or i64 %295, 4
%318 = or i64 %295, 3
%319 = or i64 %295, 2
%320 = or i64 %295, 1
%321 = extractelement <16 x i32> %299, i64 15
%322 = zext i32 %321 to i64
%323 = icmp ne i64 %306, %322
%324 = extractelement <16 x i32> %299, i64 0
%325 = zext i32 %324 to i64
%326 = icmp ne i64 %295, %325
%327 = extractelement <16 x i32> %299, i64 1
%328 = zext i32 %327 to i64
%329 = icmp ne i64 %320, %328
%330 = extractelement <16 x i32> %299, i64 2
%331 = zext i32 %330 to i64
%332 = icmp ne i64 %319, %331
%333 = extractelement <16 x i32> %299, i64 3
%334 = zext i32 %333 to i64
%335 = icmp ne i64 %318, %334
%336 = extractelement <16 x i32> %299, i64 4
%337 = zext i32 %336 to i64
%338 = icmp ne i64 %317, %337
%339 = extractelement <16 x i32> %299, i64 5
%340 = zext i32 %339 to i64
%341 = icmp ne i64 %316, %340
%342 = extractelement <16 x i32> %299, i64 6
%343 = zext i32 %342 to i64
%344 = icmp ne i64 %315, %343
%345 = extractelement <16 x i32> %299, i64 7
%346 = zext i32 %345 to i64
%347 = icmp ne i64 %314, %346
%348 = extractelement <16 x i32> %299, i64 8
%349 = zext i32 %348 to i64
%350 = icmp ne i64 %313, %349
%351 = extractelement <16 x i32> %299, i64 9
%352 = zext i32 %351 to i64
%353 = icmp ne i64 %312, %352
%354 = extractelement <16 x i32> %299, i64 10
%355 = zext i32 %354 to i64
%356 = icmp ne i64 %311, %355
%357 = extractelement <16 x i32> %299, i64 11
%358 = zext i32 %357 to i64
%359 = icmp ne i64 %310, %358
%360 = extractelement <16 x i32> %299, i64 12
%361 = zext i32 %360 to i64
%362 = icmp ne i64 %309, %361
%363 = extractelement <16 x i32> %299, i64 13
%364 = zext i32 %363 to i64
%365 = icmp ne i64 %308, %364
%366 = extractelement <16 x i32> %299, i64 14
%367 = zext i32 %366 to i64
%368 = icmp ne i64 %307, %367
%369 = or i1 %323, %368
%370 = select i1 %369, i1 true, i1 %365
%371 = select i1 %370, i1 true, i1 %362
%372 = select i1 %371, i1 true, i1 %359
%373 = select i1 %372, i1 true, i1 %356
%374 = select i1 %373, i1 true, i1 %353
%375 = select i1 %374, i1 true, i1 %350
%376 = select i1 %375, i1 true, i1 %347
%377 = select i1 %376, i1 true, i1 %344
%378 = select i1 %377, i1 true, i1 %341
%379 = select i1 %378, i1 true, i1 %338
%380 = select i1 %379, i1 true, i1 %335
%381 = select i1 %380, i1 true, i1 %332
%382 = select i1 %381, i1 true, i1 %329
%383 = select i1 %382, i1 true, i1 %326
%384 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %294
br i1 %383, label %386, label %385
385: ; preds = %305
store i32 -1, i32* %384
br label %387
386: ; preds = %305
store i32 0, i32* %384
br label %387
387: ; preds = %385, %386, %303
%388 = add nuw nsw i64 %294, 1
%389 = icmp eq i64 %388, 16
br i1 %389, label %424, label %293
390: ; preds = %451, %390
%391 = phi i64 [ %415, %390 ], [ 0, %451 ]
%392 = phi <4 x i32> [ %412, %390 ], [ zeroinitializer, %451 ]
%393 = phi <4 x i32> [ %414, %390 ], [ zeroinitializer, %451 ]
%394 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %391
%395 = bitcast i32* %394 to <4 x i32>*
%396 = load <4 x i32>, <4 x i32>* %395
%397 = getelementptr inbounds i32, i32* %394, i64 4
%398 = bitcast i32* %397 to <4 x i32>*
%399 = load <4 x i32>, <4 x i32>* %398
%400 = icmp eq <4 x i32> %396, <i32 65533, i32 65533, i32 65533, i32 65533>
%401 = icmp eq <4 x i32> %399, <i32 65533, i32 65533, i32 65533, i32 65533>
%402 = or i64 %391, 8
%403 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %402
%404 = bitcast i32* %403 to <4 x i32>*
%405 = load <4 x i32>, <4 x i32>* %404
%406 = getelementptr inbounds i32, i32* %403, i64 4
%407 = bitcast i32* %406 to <4 x i32>*
%408 = load <4 x i32>, <4 x i32>* %407
%409 = icmp eq <4 x i32> %405, <i32 65533, i32 65533, i32 65533, i32 65533>
%410 = icmp eq <4 x i32> %408, <i32 65533, i32 65533, i32 65533, i32 65533>
%411 = select <4 x i1> %409, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %400
%412 = select <4 x i1> %411, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> %392
%413 = select <4 x i1> %410, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %401
%414 = select <4 x i1> %413, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> %393
%415 = add nuw nsw i64 %391, 16
%416 = icmp eq i64 %415, 256
br i1 %416, label %417, label %390
417: ; preds = %390
%418 = icmp eq <4 x i32> %412, zeroinitializer
%419 = select <4 x i1> %418, <4 x i32> %414, <4 x i32> %412
%420 = icmp ne <4 x i32> %419, zeroinitializer
%421 = bitcast <4 x i1> %420 to i4
%422 = icmp eq i4 %421, 0
%423 = icmp sgt i32 %452, 0
br i1 %423, label %455, label %560
424: ; preds = %387, %451
%425 = phi i64 [ %453, %451 ], [ 0, %387 ]
%426 = phi i32 [ %452, %451 ], [ 0, %387 ]
%427 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %425
%428 = load i32, i32* %427
%429 = icmp sgt i32 %428, -1
br i1 %429, label %430, label %451
430: ; preds = %424
%431 = icmp ne i64 %425, 0
%432 = icmp sgt i32 %426, 0
%433 = select i1 %431, i1 %432, i1 false
br i1 %433, label %434, label %445
434: ; preds = %430
%435 = add nuw i64 %425, 4294967295
%436 = and i64 %435, 4294967295
%437 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %436
%438 = load i32, i32* %437
%439 = add nsw i32 %426, -1
%440 = icmp eq i32 %438, %439
br i1 %440, label %441, label %445
441: ; preds = %434
store i32 %438, i32* %427
%442 = zext i32 %438 to i64
%443 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %442, i32 1
%444 = trunc i64 %425 to i32
store i32 %444, i32* %443
br label %451
445: ; preds = %434, %430
%446 = add nsw i32 %426, 1
store i32 %426, i32* %427
%447 = sext i32 %426 to i64
%448 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %447, i32 1
%449 = trunc i64 %425 to i32
store i32 %449, i32* %448
%450 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %447, i32 0
store i32 %449, i32* %450
br label %451
451: ; preds = %424, %445, %441
%452 = phi i32 [ %426, %441 ], [ %446, %445 ], [ %426, %424 ]
%453 = add nuw nsw i64 %425, 1
%454 = icmp eq i64 %453, 16
br i1 %454, label %390, label %424
455: ; preds = %417
%456 = icmp eq i32 %452, 1
%457 = zext i32 %452 to i64
br label %458
458: ; preds = %455, %554
%459 = phi i64 [ 0, %455 ], [ %556, %554 ]
%460 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.25, i64 0, i64 0), i8* %20)
br i1 %456, label %465, label %461
461: ; preds = %458
%462 = trunc i64 %459 to i32
%463 = add i32 %462, 1
%464 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %463)
br label %465
465: ; preds = %461, %458
%466 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %459, i32 1
%467 = load i32, i32* %466
%468 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %459, i32 0
%469 = load i32, i32* %468
%470 = sub nsw i32 %467, %469
%471 = shl i32 %470, 4
%472 = add i32 %471, 16
%473 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.27, i64 0, i64 0), i32 %472)
%474 = icmp slt i32 %467, %469
br i1 %474, label %554, label %475
475: ; preds = %465
%476 = zext i32 %469 to i64
%477 = add i32 %467, 1
br label %478
478: ; preds = %475, %478
%479 = phi i64 [ %476, %475 ], [ %551, %478 ]
%480 = trunc i64 %479 to i32
%481 = shl nsw i32 %480, 4
%482 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.28, i64 0, i64 0), i32 %481)
%483 = sext i32 %481 to i64
%484 = call i32 @fputc(i32 32, i32* %262)
%485 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %483
%486 = load i32, i32* %485
%487 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %486)
%488 = or i64 %483, 1
%489 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %488
%490 = load i32, i32* %489
%491 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %490)
%492 = or i64 %483, 2
%493 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %492
%494 = load i32, i32* %493
%495 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %494)
%496 = or i64 %483, 3
%497 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %496
%498 = load i32, i32* %497
%499 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %498)
%500 = or i64 %483, 4
%501 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %500
%502 = load i32, i32* %501
%503 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %502)
%504 = or i64 %483, 5
%505 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %504
%506 = load i32, i32* %505
%507 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %506)
%508 = or i64 %483, 6
%509 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %508
%510 = load i32, i32* %509
%511 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %510)
%512 = or i64 %483, 7
%513 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %512
%514 = load i32, i32* %513
%515 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %514)
%516 = call i32 @fputc(i32 10, i32* %262)
%517 = call i32 @fputc(i32 32, i32* %262)
%518 = or i64 %483, 8
%519 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %518
%520 = load i32, i32* %519
%521 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %520)
%522 = or i64 %483, 9
%523 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %522
%524 = load i32, i32* %523
%525 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %524)
%526 = or i64 %483, 10
%527 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %526
%528 = load i32, i32* %527
%529 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %528)
%530 = or i64 %483, 11
%531 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %530
%532 = load i32, i32* %531
%533 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %532)
%534 = or i64 %483, 12
%535 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %534
%536 = load i32, i32* %535
%537 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %536)
%538 = or i64 %483, 13
%539 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %538
%540 = load i32, i32* %539
%541 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %540)
%542 = or i64 %483, 14
%543 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %542
%544 = load i32, i32* %543
%545 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %544)
%546 = or i64 %483, 15
%547 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %546
%548 = load i32, i32* %547
%549 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.30, i64 0, i64 0), i32 %548)
%550 = call i32 @fputc(i32 10, i32* %262)
%551 = add i64 %479, 1
%552 = trunc i64 %551 to i32
%553 = icmp eq i32 %477, %552
br i1 %553, label %554, label %478
554: ; preds = %478, %465
%555 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.31, i64 0, i64 0), i64 3, i64 1, i32* %262)
%556 = add nuw nsw i64 %459, 1
%557 = icmp eq i64 %556, %457
br i1 %557, label %558, label %458
558: ; preds = %554
%559 = call i32 @fputc(i32 10, i32* %262)
br label %560
560: ; preds = %558, %417
%561 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.32, i64 0, i64 0), i8* %20)
%562 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.33, i64 0, i64 0), i64 2, i64 1, i32* %262)
%563 = call i64 @fwrite(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.34, i64 0, i64 0), i64 24, i64 1, i32* %262)
%564 = icmp sgt i32 %452, 1
br i1 %422, label %686, label %565
565: ; preds = %560, %679
%566 = phi i32 [ %678, %679 ], [ 0, %560 ]
%567 = phi i32 [ %582, %679 ], [ 0, %560 ]
%568 = sext i32 %567 to i64
%569 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %568
%570 = load i32, i32* %569
br label %571
571: ; preds = %565, %575
%572 = phi i64 [ %568, %565 ], [ %573, %575 ]
%573 = add nsw i64 %572, 1
%574 = icmp eq i64 %573, 16
br i1 %574, label %581, label %575
575: ; preds = %571
%576 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %573
%577 = load i32, i32* %576
%578 = icmp eq i32 %577, %570
br i1 %578, label %571, label %579
579: ; preds = %575
%580 = trunc i64 %573 to i32
br label %581
581: ; preds = %571, %579
%582 = phi i32 [ %580, %579 ], [ 16, %571 ]
%583 = icmp eq i32 %567, 0
%584 = icmp eq i32 %582, 16
%585 = select i1 %583, i1 %584, i1 false
%586 = select i1 %585, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.36, i64 0, i64 0)
br i1 %583, label %587, label %591
587: ; preds = %581
br i1 %584, label %597, label %588
588: ; preds = %587
%589 = shl nsw i32 %582, 4
%590 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.37, i64 0, i64 0), i32 %589)
br label %597
591: ; preds = %581
br i1 %584, label %592, label %594
592: ; preds = %591
%593 = call i64 @fwrite(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.38, i64 0, i64 0), i64 9, i64 1, i32* %262)
br label %597
594: ; preds = %591
%595 = shl nsw i32 %582, 4
%596 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.39, i64 0, i64 0), i32 %595)
br label %597
597: ; preds = %592, %594, %588, %587
switch i32 %570, label %598 [
i32 -2, label %677
i32 -1, label %668
]
598: ; preds = %597
%599 = call i32 @fputs(i8* %586, i32* %262)
%600 = shl i32 %567, 4
%601 = shl i32 %582, 4
%602 = icmp slt i32 %600, %601
br i1 %602, label %603, label %646
603: ; preds = %598
%604 = sext i32 %600 to i64
%605 = sext i32 %601 to i64
%606 = sub nsw i64 %605, %604
%607 = icmp eq i64 %606, 0
br i1 %607, label %632, label %608
608: ; preds = %603, %608
%609 = phi i64 [ %623, %608 ], [ 0, %603 ]
%610 = phi <4 x i32> [ %621, %608 ], [ zeroinitializer, %603 ]
%611 = phi <4 x i32> [ %622, %608 ], [ zeroinitializer, %603 ]
%612 = add i64 %609, %604
%613 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %612
%614 = bitcast i32* %613 to <4 x i32>*
%615 = load <4 x i32>, <4 x i32>* %614
%616 = getelementptr inbounds i32, i32* %613, i64 4
%617 = bitcast i32* %616 to <4 x i32>*
%618 = load <4 x i32>, <4 x i32>* %617
%619 = icmp eq <4 x i32> %615, <i32 65533, i32 65533, i32 65533, i32 65533>
%620 = icmp eq <4 x i32> %618, <i32 65533, i32 65533, i32 65533, i32 65533>
%621 = select <4 x i1> %619, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> %610
%622 = select <4 x i1> %620, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> %611
%623 = add nuw i64 %609, 8
%624 = icmp eq i64 %623, %606
br i1 %624, label %625, label %608
625: ; preds = %608
%626 = icmp eq <4 x i32> %621, zeroinitializer
%627 = select <4 x i1> %626, <4 x i32> %622, <4 x i32> %621
%628 = icmp ne <4 x i32> %627, zeroinitializer
%629 = bitcast <4 x i1> %628 to i4
%630 = icmp ne i4 %629, 0
%631 = zext i1 %630 to i32
br label %641
632: ; preds = %603, %632
%633 = phi i64 [ %639, %632 ], [ %604, %603 ]
%634 = phi i32 [ %638, %632 ], [ 0, %603 ]
%635 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %633
%636 = load i32, i32* %635
%637 = icmp eq i32 %636, 65533
%638 = select i1 %637, i32 1, i32 %634
%639 = add nsw i64 %633, 1
%640 = icmp eq i64 %639, %605
br i1 %640, label %641, label %632
641: ; preds = %632, %625
%642 = phi i32 [ %631, %625 ], [ %638, %632 ]
%643 = icmp eq i32 %642, 0
br i1 %643, label %646, label %644
644: ; preds = %641
%645 = call i64 @fwrite(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.43, i64 0, i64 0), i64 20, i64 1, i32* %262)
br label %648
646: ; preds = %598, %641
%647 = call i64 @fwrite(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.44, i64 0, i64 0), i64 16, i64 1, i32* %262)
br label %648
648: ; preds = %646, %644
%649 = phi i1 [ true, %646 ], [ false, %644 ]
%650 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.45, i64 0, i64 0), i8* %20)
br i1 %564, label %651, label %654
651: ; preds = %648
%652 = add nsw i32 %570, 1
%653 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %652)
br label %654
654: ; preds = %651, %648
%655 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.46, i64 0, i64 0), i64 2, i64 1, i32* %262)
%656 = sext i32 %570 to i64
%657 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %656, i32 0
%658 = load i32, i32* %657
%659 = icmp sgt i32 %658, 0
br i1 %659, label %660, label %663
660: ; preds = %654
%661 = shl nsw i32 %658, 4
%662 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i32 %661)
br label %663
663: ; preds = %660, %654
%664 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.48, i64 0, i64 0), i64 3, i64 1, i32* %262)
br i1 %649, label %673, label %665
665: ; preds = %663
%666 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.49, i64 0, i64 0), i8* %586)
%667 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.50, i64 0, i64 0), i8* %586)
br label %668
668: ; preds = %597, %665
%669 = phi i8* [ getelementptr inbounds ([15 x i8], [15 x i8]* @.str.51, i64 0, i64 0), %665 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.40, i64 0, i64 0), %597 ]
%670 = phi i8* [ getelementptr inbounds ([5 x i8], [5 x i8]* @.str.52, i64 0, i64 0), %665 ], [ getelementptr inbounds ([13 x i8], [13 x i8]* @.str.41, i64 0, i64 0), %597 ]
%671 = phi i32 [ 1, %665 ], [ %566, %597 ]
%672 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* %669, i8* %586)
br label %673
673: ; preds = %668, %663
%674 = phi i8* [ getelementptr inbounds ([13 x i8], [13 x i8]* @.str.41, i64 0, i64 0), %663 ], [ %670, %668 ]
%675 = phi i32 [ %566, %663 ], [ %671, %668 ]
%676 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* %674, i8* %586)
br label %677
677: ; preds = %673, %597
%678 = phi i32 [ 1, %597 ], [ %675, %673 ]
br i1 %585, label %682, label %679
679: ; preds = %677
%680 = call i64 @fwrite(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.53, i64 0, i64 0), i64 4, i64 1, i32* %262)
%681 = icmp slt i32 %582, 16
br i1 %681, label %565, label %682
682: ; preds = %677, %679
%683 = icmp eq i32 %678, 0
br i1 %683, label %738, label %684
684: ; preds = %682
%685 = call i64 @fwrite(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.54, i64 0, i64 0), i64 20, i64 1, i32* %262)
br label %738
686: ; preds = %560, %734
%687 = phi i32 [ %714, %734 ], [ 0, %560 ]
%688 = sext i32 %687 to i64
%689 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %688
%690 = load i32, i32* %689
br label %691
691: ; preds = %686, %695
%692 = phi i64 [ %688, %686 ], [ %693, %695 ]
%693 = add nsw i64 %692, 1
%694 = icmp eq i64 %693, 16
br i1 %694, label %703, label %695
695: ; preds = %691
%696 = getelementptr inbounds [16 x i32], [16 x i32]* %5, i64 0, i64 %693
%697 = load i32, i32* %696
%698 = icmp eq i32 %697, %690
br i1 %698, label %691, label %699
699: ; preds = %695
%700 = trunc i64 %693 to i32
%701 = icmp eq i32 %687, 0
%702 = shl nsw i32 %700, 4
br i1 %701, label %707, label %711
703: ; preds = %691
%704 = icmp eq i32 %687, 0
br i1 %704, label %705, label %709
705: ; preds = %703
%706 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), i64 2, i64 1, i32* %262)
br label %713
707: ; preds = %699
%708 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.55, i64 0, i64 0), i32 %702)
br label %713
709: ; preds = %703
%710 = call i64 @fwrite(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.56, i64 0, i64 0), i64 11, i64 1, i32* %262)
br label %713
711: ; preds = %699
%712 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.57, i64 0, i64 0), i32 %702)
br label %713
713: ; preds = %709, %711, %705, %707
%714 = phi i32 [ 16, %709 ], [ %700, %711 ], [ 16, %705 ], [ %700, %707 ]
%715 = icmp eq i32 %690, -1
br i1 %715, label %716, label %718
716: ; preds = %713
%717 = call i64 @fwrite(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.58, i64 0, i64 0), i64 19, i64 1, i32* %262)
br label %734
718: ; preds = %713
%719 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.59, i64 0, i64 0), i8* %20)
br i1 %564, label %720, label %723
720: ; preds = %718
%721 = add nuw nsw i32 %690, 1
%722 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i64 0, i64 0), i32 %721)
br label %723
723: ; preds = %720, %718
%724 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.46, i64 0, i64 0), i64 2, i64 1, i32* %262)
%725 = sext i32 %690 to i64
%726 = getelementptr inbounds [16 x %struct.anon], [16 x %struct.anon]* %6, i64 0, i64 %725, i32 0
%727 = load i32, i32* %726
%728 = icmp sgt i32 %727, 0
br i1 %728, label %729, label %732
729: ; preds = %723
%730 = shl nsw i32 %727, 4
%731 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i32 %730)
br label %732
732: ; preds = %729, %723
%733 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.48, i64 0, i64 0), i64 3, i64 1, i32* %262)
br label %734
734: ; preds = %732, %716
%735 = icmp slt i32 %714, 16
br i1 %735, label %686, label %736
736: ; preds = %734
%737 = call i64 @fwrite(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.60, i64 0, i64 0), i64 12, i64 1, i32* %262)
br label %738
738: ; preds = %682, %684, %736
%739 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.61, i64 0, i64 0), i64 2, i64 1, i32* %262)
%740 = call i32 @fputc(i32 10, i32* %262)
%741 = bitcast [8192 x i32]* %9 to i8*
%742 = bitcast [8192 x %struct.anon.0]* %10 to i8*
br label %743
743: ; preds = %761, %738
%744 = phi i64 [ 0, %738 ], [ %762, %761 ]
%745 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %744
%746 = load i32, i32* %745
%747 = icmp eq i32 %746, 65533
br i1 %747, label %752, label %748
748: ; preds = %743
%749 = sext i32 %746 to i64
%750 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %749
%751 = trunc i64 %744 to i32
store i32 %751, i32* %750
br label %752
752: ; preds = %743, %748
%753 = or i64 %744, 1
%754 = getelementptr inbounds [256 x i32], [256 x i32]* %3, i64 0, i64 %753
%755 = load i32, i32* %754
%756 = icmp eq i32 %755, 65533
br i1 %756, label %761, label %757
757: ; preds = %752
%758 = sext i32 %755 to i64
%759 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %758
%760 = trunc i64 %753 to i32
store i32 %760, i32* %759
br label %761
761: ; preds = %757, %752
%762 = add nuw nsw i64 %744, 2
%763 = icmp eq i64 %762, 256
br i1 %763, label %764, label %743
764: ; preds = %761, %818
%765 = phi i64 [ %819, %818 ], [ 0, %761 ]
%766 = shl nsw i64 %765, 3
%767 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %766
%768 = bitcast i32* %767 to <8 x i32>*
%769 = load <8 x i32>, <8 x i32>* %768
%770 = freeze <8 x i32> %769
%771 = icmp ne <8 x i32> %770, zeroinitializer
%772 = bitcast <8 x i1> %771 to i8
%773 = icmp eq i8 %772, 0
br i1 %773, label %774, label %776
774: ; preds = %764
%775 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %765
store i32 -2, i32* %775
br label %818
776: ; preds = %764
%777 = or i64 %766, 7
%778 = or i64 %766, 6
%779 = or i64 %766, 5
%780 = or i64 %766, 4
%781 = or i64 %766, 3
%782 = or i64 %766, 2
%783 = or i64 %766, 1
%784 = extractelement <8 x i32> %770, i64 7
%785 = zext i32 %784 to i64
%786 = icmp ne i64 %777, %785
%787 = extractelement <8 x i32> %770, i64 0
%788 = zext i32 %787 to i64
%789 = icmp ne i64 %766, %788
%790 = extractelement <8 x i32> %770, i64 1
%791 = zext i32 %790 to i64
%792 = icmp ne i64 %783, %791
%793 = extractelement <8 x i32> %770, i64 2
%794 = zext i32 %793 to i64
%795 = icmp ne i64 %782, %794
%796 = extractelement <8 x i32> %770, i64 3
%797 = zext i32 %796 to i64
%798 = icmp ne i64 %781, %797
%799 = extractelement <8 x i32> %770, i64 4
%800 = zext i32 %799 to i64
%801 = icmp ne i64 %780, %800
%802 = extractelement <8 x i32> %770, i64 5
%803 = zext i32 %802 to i64
%804 = icmp ne i64 %779, %803
%805 = extractelement <8 x i32> %770, i64 6
%806 = zext i32 %805 to i64
%807 = icmp ne i64 %778, %806
%808 = or i1 %786, %807
%809 = select i1 %808, i1 true, i1 %804
%810 = select i1 %809, i1 true, i1 %801
%811 = select i1 %810, i1 true, i1 %798
%812 = select i1 %811, i1 true, i1 %795
%813 = select i1 %812, i1 true, i1 %792
%814 = select i1 %813, i1 true, i1 %789
%815 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %765
br i1 %814, label %817, label %816
816: ; preds = %776
store i32 -1, i32* %815
br label %818
817: ; preds = %776
store i32 0, i32* %815
br label %818
818: ; preds = %816, %817, %774
%819 = add nuw nsw i64 %765, 1
%820 = icmp eq i64 %819, 8192
br i1 %820, label %821, label %764
821: ; preds = %818
%822 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 0
%823 = load i32, i32* %822
%824 = icmp sgt i32 %823, -1
br i1 %824, label %825, label %828
825: ; preds = %821
store i32 0, i32* %822
%826 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 0, i32 1
store i32 0, i32* %826
%827 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 0, i32 0
store i32 0, i32* %827
br label %828
828: ; preds = %821, %825
%829 = phi i32 [ 0, %825 ], [ %823, %821 ]
%830 = phi i32 [ 1, %825 ], [ 0, %821 ]
br label %835
831: ; preds = %874
%832 = icmp sgt i32 %875, 0
br i1 %832, label %833, label %1032
833: ; preds = %831
%834 = zext i32 %875 to i64
br label %881
835: ; preds = %828, %874
%836 = phi i64 [ 1, %828 ], [ %876, %874 ]
%837 = phi i32 [ %830, %828 ], [ %875, %874 ]
%838 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %836
%839 = load i32, i32* %838
%840 = icmp sgt i32 %839, -1
br i1 %840, label %841, label %874
841: ; preds = %835
%842 = icmp sgt i32 %837, 0
br i1 %842, label %845, label %843
843: ; preds = %841
%844 = trunc i64 %836 to i32
br label %868
845: ; preds = %841
%846 = add nuw i64 %836, 4294967295
%847 = and i64 %846, 4294967295
%848 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %847
%849 = load i32, i32* %848
%850 = add nsw i32 %837, -1
%851 = icmp eq i32 %849, %850
%852 = zext i32 %850 to i64
br i1 %851, label %853, label %855
853: ; preds = %845
%854 = trunc i64 %836 to i32
br label %865
855: ; preds = %845
%856 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %852, i32 1
%857 = load i32, i32* %856
%858 = ashr i32 %857, 5
%859 = trunc i64 %836 to i32
%860 = lshr i32 %859, 5
%861 = icmp eq i32 %858, %860
%862 = sub nsw i32 %859, %857
%863 = icmp slt i32 %862, 9
%864 = select i1 %861, i1 %863, i1 false
br i1 %864, label %865, label %868
865: ; preds = %853, %855
%866 = phi i32 [ %854, %853 ], [ %859, %855 ]
store i32 %850, i32* %838
%867 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %852, i32 1
store i32 %866, i32* %867
br label %874
868: ; preds = %843, %855
%869 = phi i32 [ %844, %843 ], [ %859, %855 ]
%870 = add nsw i32 %837, 1
store i32 %837, i32* %838
%871 = sext i32 %837 to i64
%872 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %871, i32 1
store i32 %869, i32* %872
%873 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %871, i32 0
store i32 %869, i32* %873
br label %874
874: ; preds = %835, %868, %865
%875 = phi i32 [ %837, %865 ], [ %870, %868 ], [ %837, %835 ]
%876 = add nuw nsw i64 %836, 1
%877 = icmp eq i64 %876, 8192
br i1 %877, label %831, label %835
878: ; preds = %915
br i1 %832, label %879, label %1032
879: ; preds = %878
%880 = zext i32 %875 to i64
br label %921
881: ; preds = %833, %915
%882 = phi i64 [ 0, %833 ], [ %916, %915 ]
%883 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %882, i32 2
store i32 0, i32* %883
%884 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %882, i32 0
%885 = load i32, i32* %884
%886 = shl i32 %885, 3
%887 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %882, i32 1
%888 = load i32, i32* %887
%889 = shl i32 %888, 3
%890 = add i32 %889, 8
%891 = icmp slt i32 %886, %890
br i1 %891, label %892, label %915
892: ; preds = %881
%893 = sext i32 %886 to i64
%894 = sext i32 %890 to i64
br label %895
895: ; preds = %911, %892
%896 = phi i32 [ 0, %892 ], [ %912, %911 ]
%897 = phi i64 [ %893, %892 ], [ %913, %911 ]
%898 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %897
%899 = load i32, i32* %898
%900 = icmp eq i32 %899, 0
br i1 %900, label %903, label %901
901: ; preds = %895
%902 = add nsw i32 %896, 1
store i32 %902, i32* %883
br label %903
903: ; preds = %895, %901
%904 = phi i32 [ %896, %895 ], [ %902, %901 ]
%905 = or i64 %897, 1
%906 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %905
%907 = load i32, i32* %906
%908 = icmp eq i32 %907, 0
br i1 %908, label %911, label %909
909: ; preds = %903
%910 = add nsw i32 %904, 1
store i32 %910, i32* %883
br label %911
911: ; preds = %909, %903
%912 = phi i32 [ %904, %903 ], [ %910, %909 ]
%913 = add nsw i64 %897, 2
%914 = icmp eq i64 %913, %894
br i1 %914, label %915, label %895
915: ; preds = %911, %881
%916 = add nuw nsw i64 %882, 1
%917 = icmp eq i64 %916, %834
br i1 %917, label %878, label %881
918: ; preds = %940
br i1 %832, label %919, label %1032
919: ; preds = %918
%920 = zext i32 %875 to i64
br label %947
921: ; preds = %879, %940
%922 = phi i64 [ 0, %879 ], [ %945, %940 ]
%923 = phi i32 [ -1, %879 ], [ %943, %940 ]
%924 = phi i32 [ 0, %879 ], [ %942, %940 ]
%925 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %922, i32 2
%926 = load i32, i32* %925
%927 = icmp sgt i32 %926, 1
br i1 %927, label %928, label %940
928: ; preds = %921
%929 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %922, i32 0
%930 = load i32, i32* %929
%931 = ashr i32 %930, 5
%932 = icmp eq i32 %923, %931
br i1 %932, label %933, label %937
933: ; preds = %928
%934 = call dereferenceable_or_null(6) i8* @malloc(i32 6)
%935 = add nsw i32 %924, 1
%936 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* dereferenceable(1) %934, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.62, i64 0, i64 0), i32 %923, i32 %935)
br label %940
937: ; preds = %928
%938 = call dereferenceable_or_null(3) i8* @malloc(i32 3)
%939 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* dereferenceable(1) %938, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.63, i64 0, i64 0), i32 %931)
br label %940
940: ; preds = %921, %933, %937
%941 = phi i8* [ %934, %933 ], [ %938, %937 ], [ null, %921 ]
%942 = phi i32 [ %935, %933 ], [ %924, %937 ], [ %924, %921 ]
%943 = phi i32 [ %923, %933 ], [ %931, %937 ], [ %923, %921 ]
%944 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %922, i32 3
store i8* %941, i8** %944
%945 = add nuw nsw i64 %922, 1
%946 = icmp eq i64 %945, %880
br i1 %946, label %918, label %921
947: ; preds = %919, %1024
%948 = phi i64 [ 0, %919 ], [ %1026, %1024 ]
%949 = phi i32 [ -1, %919 ], [ %1025, %1024 ]
%950 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %948, i32 2
%951 = load i32, i32* %950
%952 = icmp sgt i32 %951, 1
br i1 %952, label %953, label %1024
953: ; preds = %947
%954 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %948, i32 3
%955 = load i8*, i8** %954
%956 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %948, i32 1
%957 = load i32, i32* %956
%958 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %948, i32 0
%959 = load i32, i32* %958
%960 = sub nsw i32 %957, %959
%961 = shl i32 %960, 3
%962 = add i32 %961, 8
%963 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.64, i64 0, i64 0), i8* %20, i8* %955, i32 %962)
%964 = load i32, i32* %956
%965 = icmp sgt i32 %959, %964
br i1 %965, label %1022, label %966
966: ; preds = %953
%967 = sext i32 %959 to i64
br label %968
968: ; preds = %966, %980
%969 = phi i64 [ %967, %966 ], [ %1018, %980 ]
%970 = trunc i64 %969 to i32
%971 = srem i32 %970, 32
%972 = icmp eq i32 %971, 0
br i1 %972, label %973, label %980
973: ; preds = %968
%974 = load i32, i32* %958
%975 = sext i32 %974 to i64
%976 = icmp sgt i64 %969, %975
br i1 %976, label %977, label %980
977: ; preds = %973
%978 = shl nsw i32 %970, 3
%979 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.65, i64 0, i64 0), i32 %978)
br label %980
980: ; preds = %977, %973, %968
%981 = call i32 @fputc(i32 32, i32* %262)
%982 = shl nsw i32 %970, 3
%983 = sext i32 %982 to i64
%984 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %983
%985 = load i32, i32* %984
%986 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.66, i64 0, i64 0), i32 %985)
%987 = or i64 %983, 1
%988 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %987
%989 = load i32, i32* %988
%990 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.66, i64 0, i64 0), i32 %989)
%991 = or i64 %983, 2
%992 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %991
%993 = load i32, i32* %992
%994 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.66, i64 0, i64 0), i32 %993)
%995 = or i64 %983, 3
%996 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %995
%997 = load i32, i32* %996
%998 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.66, i64 0, i64 0), i32 %997)
%999 = or i64 %983, 4
%1000 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %999
%1001 = load i32, i32* %1000
%1002 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.66, i64 0, i64 0), i32 %1001)
%1003 = or i64 %983, 5
%1004 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1003
%1005 = load i32, i32* %1004
%1006 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.66, i64 0, i64 0), i32 %1005)
%1007 = or i64 %983, 6
%1008 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1007
%1009 = load i32, i32* %1008
%1010 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.66, i64 0, i64 0), i32 %1009)
%1011 = or i64 %983, 7
%1012 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1011
%1013 = load i32, i32* %1012
%1014 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.66, i64 0, i64 0), i32 %1013)
%1015 = shl nsw i32 %971, 3
%1016 = or i32 %1015, 7
%1017 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.67, i64 0, i64 0), i32 %1015, i32 %1016)
%1018 = add nsw i64 %969, 1
%1019 = load i32, i32* %956
%1020 = sext i32 %1019 to i64
%1021 = icmp slt i64 %969, %1020
br i1 %1021, label %968, label %1022
1022: ; preds = %980, %953
%1023 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.31, i64 0, i64 0), i64 3, i64 1, i32* %262)
br label %1024
1024: ; preds = %947, %1022
%1025 = phi i32 [ 0, %1022 ], [ %949, %947 ]
%1026 = add nuw nsw i64 %948, 1
%1027 = icmp eq i64 %1026, %920
br i1 %1027, label %1028, label %947
1028: ; preds = %1024
%1029 = icmp sgt i32 %1025, -1
br i1 %1029, label %1030, label %1032
1030: ; preds = %1028
%1031 = call i32 @fputc(i32 10, i32* %262)
br label %1032
1032: ; preds = %831, %878, %918, %1030, %1028
br label %1033
1033: ; preds = %1032, %1065
%1034 = phi i32 [ %1068, %1065 ], [ %829, %1032 ]
%1035 = phi i32 [ %1057, %1065 ], [ 0, %1032 ]
%1036 = phi i32 [ %1063, %1065 ], [ 0, %1032 ]
%1037 = sext i32 %1035 to i64
br label %1038
1038: ; preds = %1033, %1042
%1039 = phi i64 [ %1037, %1033 ], [ %1040, %1042 ]
%1040 = add nsw i64 %1039, 1
%1041 = icmp eq i64 %1040, 8192
br i1 %1041, label %1048, label %1042
1042: ; preds = %1038
%1043 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %1040
%1044 = load i32, i32* %1043
%1045 = icmp eq i32 %1044, %1034
br i1 %1045, label %1038, label %1046
1046: ; preds = %1042
%1047 = trunc i64 %1040 to i32
br label %1048
1048: ; preds = %1038, %1046
%1049 = phi i32 [ %1047, %1046 ], [ 8192, %1038 ]
%1050 = icmp sgt i32 %1034, -1
br i1 %1050, label %1051, label %1056
1051: ; preds = %1048
%1052 = zext i32 %1034 to i64
%1053 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1052, i32 1
%1054 = load i32, i32* %1053
%1055 = add nsw i32 %1054, 1
br label %1056
1056: ; preds = %1051, %1048
%1057 = phi i32 [ %1055, %1051 ], [ %1049, %1048 ]
%1058 = icmp eq i32 %1034, -2
%1059 = icmp eq i32 %1034, -1
%1060 = icmp eq i32 %1035, 0
%1061 = select i1 %1059, i1 %1060, i1 false
%1062 = select i1 %1058, i1 true, i1 %1061
%1063 = select i1 %1062, i32 %1036, i32 1
%1064 = icmp slt i32 %1057, 8192
br i1 %1064, label %1065, label %1069
1065: ; preds = %1056
%1066 = sext i32 %1057 to i64
%1067 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %1066
%1068 = load i32, i32* %1067
br label %1033
1069: ; preds = %1056
%1070 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.68, i64 0, i64 0), i8* %20)
%1071 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.33, i64 0, i64 0), i64 2, i64 1, i32* %262)
%1072 = icmp eq i32 %1063, 0
br i1 %1072, label %1075, label %1073
1073: ; preds = %1069
%1074 = call i64 @fwrite(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.69, i64 0, i64 0), i64 23, i64 1, i32* %262)
br label %1075
1075: ; preds = %1073, %1069
%1076 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 0
%1077 = load i32, i32* %1076
%1078 = icmp eq i32 %1077, 0
br label %1079
1079: ; preds = %1075, %1200
%1080 = phi i32 [ %829, %1075 ], [ %1203, %1200 ]
%1081 = phi i32 [ 0, %1075 ], [ %1197, %1200 ]
%1082 = phi i32 [ 0, %1075 ], [ %1198, %1200 ]
%1083 = sext i32 %1081 to i64
br label %1084
1084: ; preds = %1079, %1088
%1085 = phi i64 [ %1083, %1079 ], [ %1086, %1088 ]
%1086 = add nsw i64 %1085, 1
%1087 = icmp eq i64 %1086, 8192
br i1 %1087, label %1094, label %1088
1088: ; preds = %1084
%1089 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %1086
%1090 = load i32, i32* %1089
%1091 = icmp eq i32 %1090, %1080
br i1 %1091, label %1084, label %1092
1092: ; preds = %1088
%1093 = trunc i64 %1086 to i32
br label %1094
1094: ; preds = %1084, %1092
%1095 = phi i32 [ %1093, %1092 ], [ 8192, %1084 ]
%1096 = icmp sgt i32 %1080, -1
br i1 %1096, label %1097, label %1111
1097: ; preds = %1094
%1098 = zext i32 %1080 to i64
%1099 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1098, i32 0
%1100 = load i32, i32* %1099
%1101 = icmp eq i32 %1081, %1100
br i1 %1101, label %1104, label %1102
1102: ; preds = %1097
%1103 = call i32 (...) @abort()
unreachable
1104: ; preds = %1097
%1105 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1098, i32 1
%1106 = load i32, i32* %1105
%1107 = add nsw i32 %1106, 1
%1108 = icmp sgt i32 %1095, %1107
br i1 %1108, label %1109, label %1113
1109: ; preds = %1104
%1110 = call i32 (...) @abort()
unreachable
1111: ; preds = %1094
%1112 = icmp eq i32 %1080, -2
br i1 %1112, label %1196, label %1113
1113: ; preds = %1104, %1111
%1114 = phi i32 [ %1095, %1111 ], [ %1107, %1104 ]
%1115 = icmp eq i32 %1081, 0
br i1 %1115, label %1116, label %1118
1116: ; preds = %1113
%1117 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.35, i64 0, i64 0), i64 2, i64 1, i32* %262)
br label %1120
1118: ; preds = %1113
%1119 = call i64 @fwrite(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.70, i64 0, i64 0), i64 7, i64 1, i32* %262)
br label %1120
1120: ; preds = %1118, %1116
br i1 %1096, label %1121, label %1167
1121: ; preds = %1120
%1122 = zext i32 %1080 to i64
%1123 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1122, i32 2
%1124 = load i32, i32* %1123
switch i32 %1124, label %1167 [
i32 0, label %1125
i32 1, label %1127
]
1125: ; preds = %1121
%1126 = call i32 (...) @abort()
unreachable
1127: ; preds = %1121
%1128 = add nsw i32 %1081, 1
%1129 = icmp eq i32 %1114, %1128
br i1 %1129, label %1132, label %1130
1130: ; preds = %1127
%1131 = call i32 (...) @abort()
unreachable
1132: ; preds = %1127
%1133 = shl i32 %1081, 3
%1134 = shl i32 %1114, 3
%1135 = icmp slt i32 %1133, %1134
br i1 %1135, label %1136, label %1196
1136: ; preds = %1132
%1137 = sext i32 %1133 to i64
br label %1138
1138: ; preds = %1163, %1136
%1139 = phi i64 [ %1137, %1136 ], [ %1164, %1163 ]
%1140 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1139
%1141 = load i32, i32* %1140
%1142 = icmp eq i32 %1141, 0
br i1 %1142, label %1148, label %1143
1143: ; preds = %1158, %1153, %1148, %1138
%1144 = phi i64 [ %1139, %1138 ], [ %1149, %1148 ], [ %1154, %1153 ], [ %1159, %1158 ]
%1145 = phi i32 [ %1141, %1138 ], [ %1151, %1148 ], [ %1156, %1153 ], [ %1161, %1158 ]
%1146 = trunc i64 %1144 to i32
%1147 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.71, i64 0, i64 0), i32 %1146, i32 %1145)
br label %1196
1148: ; preds = %1138
%1149 = or i64 %1139, 1
%1150 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1149
%1151 = load i32, i32* %1150
%1152 = icmp eq i32 %1151, 0
br i1 %1152, label %1153, label %1143
1153: ; preds = %1148
%1154 = or i64 %1139, 2
%1155 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1154
%1156 = load i32, i32* %1155
%1157 = icmp eq i32 %1156, 0
br i1 %1157, label %1158, label %1143
1158: ; preds = %1153
%1159 = or i64 %1139, 3
%1160 = getelementptr inbounds [65536 x i32], [65536 x i32]* %7, i64 0, i64 %1159
%1161 = load i32, i32* %1160
%1162 = icmp eq i32 %1161, 0
br i1 %1162, label %1163, label %1143
1163: ; preds = %1158
%1164 = add nsw i64 %1139, 4
%1165 = trunc i64 %1164 to i32
%1166 = icmp eq i32 %1134, %1165
br i1 %1166, label %1196, label %1138
1167: ; preds = %1121, %1120
br i1 %1115, label %1168, label %1172
1168: ; preds = %1167
%1169 = shl nsw i32 %1114, 3
%1170 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.72, i64 0, i64 0), i32 %1169)
%1171 = icmp eq i32 %1080, -1
br i1 %1171, label %1177, label %1181
1172: ; preds = %1167
%1173 = shl nsw i32 %1081, 3
%1174 = shl nsw i32 %1114, 3
%1175 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.73, i64 0, i64 0), i32 %1173, i32 %1174)
%1176 = icmp eq i32 %1080, -1
br i1 %1176, label %1179, label %1181
1177: ; preds = %1168
%1178 = call i64 @fwrite(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.74, i64 0, i64 0), i64 34, i64 1, i32* %262)
br label %1196
1179: ; preds = %1172
%1180 = call i64 @fwrite(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.75, i64 0, i64 0), i64 13, i64 1, i32* %262)
br label %1196
1181: ; preds = %1172, %1168
%1182 = sext i32 %1080 to i64
%1183 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1182, i32 3
%1184 = load i8*, i8** %1183
%1185 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.76, i64 0, i64 0), i8* %20, i8* %1184)
%1186 = getelementptr inbounds [8192 x %struct.anon.0], [8192 x %struct.anon.0]* %10, i64 0, i64 %1182, i32 0
%1187 = load i32, i32* %1186
%1188 = icmp sgt i32 %1187, 0
br i1 %1188, label %1189, label %1192
1189: ; preds = %1181
%1190 = shl nsw i32 %1081, 3
%1191 = call i32 (i32*, i8*, ...) @fprintf(i32* %262, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.77, i64 0, i64 0), i32 %1190)
br label %1192
1192: ; preds = %1189, %1181
%1193 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.48, i64 0, i64 0), i64 3, i64 1, i32* %262)
%1194 = select i1 %1115, i1 %1078, i1 false
%1195 = select i1 %1194, i32 1, i32 %1082
br label %1196
1196: ; preds = %1163, %1132, %1192, %1143, %1177, %1179, %1111
%1197 = phi i32 [ %1095, %1111 ], [ %1114, %1143 ], [ %1114, %1177 ], [ %1114, %1179 ], [ %1114, %1192 ], [ %1114, %1132 ], [ %1114, %1163 ]
%1198 = phi i32 [ %1082, %1111 ], [ %1082, %1143 ], [ %1082, %1177 ], [ %1082, %1179 ], [ %1195, %1192 ], [ %1082, %1132 ], [ %1082, %1163 ]
%1199 = icmp slt i32 %1197, 8192
br i1 %1199, label %1200, label %1204
1200: ; preds = %1196
%1201 = sext i32 %1197 to i64
%1202 = getelementptr inbounds [8192 x i32], [8192 x i32]* %9, i64 0, i64 %1201
%1203 = load i32, i32* %1202
br label %1079
1204: ; preds = %1196
br i1 %1072, label %1215, label %1205
1205: ; preds = %1204
%1206 = icmp eq i32 %1198, 0
br i1 %1206, label %1209, label %1207
1207: ; preds = %1205
%1208 = call i64 @fwrite(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.78, i64 0, i64 0), i64 27, i64 1, i32* %262)
br label %1211
1209: ; preds = %1205
%1210 = call i64 @fwrite(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.79, i64 0, i64 0), i64 16, i64 1, i32* %262)
br label %1211
1211: ; preds = %1209, %1207
%1212 = call i64 @fwrite(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.80, i64 0, i64 0), i64 12, i64 1, i32* %262)
%1213 = call i64 @fwrite(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.81, i64 0, i64 0), i64 14, i64 1, i32* %262)
%1214 = call i64 @fwrite(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.53, i64 0, i64 0), i64 4, i64 1, i32* %262)
br label %1215
1215: ; preds = %1211, %1204
%1216 = call i64 @fwrite(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.82, i64 0, i64 0), i64 20, i64 1, i32* %262)
%1217 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.61, i64 0, i64 0), i64 2, i64 1, i32* %262)
%1218 = call i64 @ferror(i32* %262)
%1219 = icmp eq i64 %1218, 0
br i1 %1219, label %1220, label %1223
1220: ; preds = %1215
%1221 = call i64 @fclose(i32* %262)
%1222 = icmp eq i64 %1221, 0
br i1 %1222, label %1225, label %1223
1223: ; preds = %1220, %1215
%1224 = call i32 @exit(i32 1)
unreachable
1225: ; preds = %1220
%1226 = call i32 @exit(i32 0)
unreachable
}