#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 */

/* Variables and functions */
int EOF;
int /*<<< orphan*/ abort();
int /*<<< orphan*/ exit(int);
scalar_t__ fclose(int /*<<< orphan*/);
scalar_t__ ferror(int /*<<< orphan*/);
int getc(int /*<<< orphan*/);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *, ...);
int scanf(char *, int *);
int /*<<< orphan*/ sprintf(char *, char *, int, ...);
int /*<<< orphan*/ stdin;
int /*<<< orphan*/ stdout;
int /*<<< orphan*/ ungetc(int, int /*<<< orphan*/);
int main(int argc, char *argv[]) {
  unsigned int data[0x100000];
  int uni2index[0x110000];
  int index;
  if (argc != 1)
    exit(1);
  printf("/*\n");
  printf(" * Copyright (C) 1999-2003 Free Software Foundation, Inc.\n");
  printf(" * This file is part of the GNU LIBICONV Library.\n");
  printf(" *\n");
  printf(" * The GNU LIBICONV Library is free software; you can redistribute "
         "it\n");
  printf(" * and/or modify it under the terms of the GNU Library General "
         "Public\n");
  printf(" * License as published by the Free Software Foundation; either "
         "version 2\n");
  printf(" * of the License, or (at your option) any later version.\n");
  printf(" *\n");
  printf(" * The GNU LIBICONV Library is distributed in the hope that it will "
         "be\n");
  printf(" * useful, but WITHOUT ANY WARRANTY; without even the implied "
         "warranty of\n");
  printf(
      " * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n");
  printf(" * Library General Public License for more details.\n");
  printf(" *\n");
  printf(
      " * You should have received a copy of the GNU Library General Public\n");
  printf(" * License along with the GNU LIBICONV Library; see the file "
         "COPYING.LIB.\n");
  printf(" * If not, write to the Free Software Foundation, Inc., 51 Franklin "
         "Street,\n");
  printf(" * Fifth Floor, Boston, MA 02110-1301, USA.\n");
  printf(" */\n");
  printf("\n");
  printf("/*\n");
  printf(" * Transliteration table\n");
  printf(" */\n");
  printf("\n");
  {
    int c;
    int j;
    for (j = 0; j < 0x110000; j++)
      uni2index[j] = -1;
    index = 0;
    for (;;) {
      c = getc(stdin);
      if (c == EOF)
        break;
      if (c == '#') {
        do {
          c = getc(stdin);
        } while (!(c == EOF || c == '\n'));
        continue;
      }
      ungetc(c, stdin);
      if (scanf("%x", &j) != 1)
        exit(1);
      c = getc(stdin);
      if (c != '\t')
        exit(1);
      for (;;) {
        c = getc(stdin);
        if (c == EOF || c == '\n')
          exit(1);
        if (c == '\t')
          break;
        if (uni2index[j] < 0) {
          uni2index[j] = index;
          data[index++] = 0;
        }
        if (c >= 0x80) {
          if (c < 0xc0)
            exit(1);
          else {
            unsigned int i = (c < 0xe0   ? 2
                              : c < 0xf0 ? 3
                              : c < 0xf8 ? 4
                              : c < 0xfc ? 5
                                         : 6);
            c &= (1 << (8 - i)) - 1;
            while (--i > 0) {
              int cc = getc(stdin);
              if (!(cc >= 0x80 && cc < 0xc0))
                exit(1);
              c <<= 6;
              c |= (cc & 0x3f);
            }
          }
        }
        data[index++] = (unsigned int)c;
      }
      if (uni2index[j] >= 0)
        data[uni2index[j]] = index - uni2index[j] - 1;
      do {
        c = getc(stdin);
      } while (!(c == EOF || c == '\n'));
    }
  }
  printf("static const unsigned int translit_data[%d] = {", index);
  {
    int i;
    for (i = 0; i < index; i++) {
      if (data[i] < 32)
        printf("\n %3d,", data[i]);
      else if (data[i] == '\'')
        printf("'\\'',");
      else if (data[i] == '\\')
        printf("'\\\\',");
      else if (data[i] < 127)
        printf(" '%c',", data[i]);
      else if (data[i] < 256)
        printf("0x%02X,", data[i]);
      else
        printf("0x%04X,", data[i]);
    }
    printf("\n};\n");
  }
  printf("\n");
  {
    bool pages[0x1100];
    int line[0x22000];
    int tableno;
    struct {
      int minline;
      int maxline;
      int usecount;
      const char *suffix;
    } tables[0x2000];
    int i, j, p, j1, j2, t;
    for (p = 0; p < 0x1100; p++)
      pages[p] = false;
    for (j = 0; j < 0x110000; j++)
      if (uni2index[j] >= 0)
        pages[j >> 8] = true;
    for (j1 = 0; j1 < 0x22000; j1++) {
      bool all_invalid = true;
      for (j2 = 0; j2 < 8; j2++) {
        j = 8 * j1 + j2;
        if (uni2index[j] >= 0)
          all_invalid = false;
      }
      if (all_invalid)
        line[j1] = -1;
      else
        line[j1] = 0;
    }
    tableno = 0;
    for (j1 = 0; j1 < 0x22000; 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 (uni2index[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;
          printf("static const short translit_page%s[%d] = {\n",
                 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)
              printf("  /* 0x%04x */\n", 8 * j1);
            printf(" ");
            for (j2 = 0; j2 < 8; j2++) {
              j = 8 * j1 + j2;
              printf(" %4d,", uni2index[j]);
            }
            printf(" /* 0x%02x-0x%02x */\n", 8 * (j1 % 0x20),
                   8 * (j1 % 0x20) + 7);
          }
          printf("};\n");
        }
      if (p >= 0)
        printf("\n");
    }
    printf("#define translit_index(wc) \\\n  (");
    for (j1 = 0; j1 < 0x22000;) {
      t = line[j1];
      for (j2 = j1; j2 < 0x22000 && 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 == -1) {
      } 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 (uni2index[j] >= 0) {
              printf("wc == 0x%04x ? %d", j, uni2index[j]);
              break;
            }
        } else {
          if (j1 == 0) {
            printf("wc < 0x%04x", 8 * j2);
          } else {
            printf("wc >= 0x%04x && wc < 0x%04x", 8 * j1, 8 * j2);
          }
          printf(" ? translit_page%s[wc", tables[t].suffix);
          if (tables[t].minline > 0)
            printf("-0x%04x", 8 * j1);
          printf("]");
        }
        printf(" : \\\n   ");
      }
      j1 = j2;
    }
    printf("-1)\n");
  }
  if (ferror(stdout) || fclose(stdout))
    exit(1);
  exit(0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x8fc480,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x1,-0x8(%rbp)
je     11cd <main+0x2d>
mov    $0x1,%edi
call   10b0 <exit@plt>
lea    0x1e2c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1e22(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1e4f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1e74(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1e6a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1ea3(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1edc(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1f19(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1e2e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1f38(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1f72(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1faf(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1fe7(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1de8(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x2000(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x2038(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x2075(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x20b4(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x21af(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x2221(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1d14(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x20a9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x2177(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x21e9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x84001c(%rbp)
cmpl   $0x110000,-0x84001c(%rbp)
jge    135d <main+0x1bd>
movslq -0x84001c(%rbp),%rax
movl   $0xffffffff,-0x840010(%rbp,%rax,4)
ff ff ff ff
mov    -0x84001c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84001c(%rbp)
jmp    1327 <main+0x187>
movl   $0x0,-0x840014(%rbp)
mov    0x3c7a(%rip),%rax
mov    (%rax),%edi
call   10c0 <getc@plt>
mov    %eax,-0x840018(%rbp)
mov    -0x840018(%rbp),%eax
mov    0x3c58(%rip),%rcx
cmp    (%rcx),%eax
jne    1395 <main+0x1f5>
jmp    1739 <main+0x599>
cmpl   $0x23,-0x840018(%rbp)
jne    13fd <main+0x25d>
jmp    13a7 <main+0x207>
mov    0x3c3a(%rip),%rax
mov    (%rax),%edi
call   10c0 <getc@plt>
mov    %eax,-0x840018(%rbp)
mov    -0x840018(%rbp),%ecx
mov    $0x1,%al
mov    0x3c16(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0x8fc469(%rbp)
je     13e8 <main+0x248>
cmpl   $0xa,-0x840018(%rbp)
sete   %al
mov    %al,-0x8fc469(%rbp)
mov    -0x8fc469(%rbp),%al
xor    $0xff,%al
test   $0x1,%al
jne    13a7 <main+0x207>
jmp    1367 <main+0x1c7>
mov    -0x840018(%rbp),%edi
mov    0x3bde(%rip),%rax
mov    (%rax),%esi
call   1080 <ungetc@plt>
lea    0x1fa5(%rip),%rdi
lea    -0x84001c(%rbp),%rsi
call   1090 <scanf@plt>
cmp    $0x1,%eax
je     1437 <main+0x297>
mov    $0x1,%edi
call   10b0 <exit@plt>
mov    0x3baa(%rip),%rax
mov    (%rax),%edi
call   10c0 <getc@plt>
mov    %eax,-0x840018(%rbp)
cmpl   $0x9,-0x840018(%rbp)
je     1462 <main+0x2c2>
mov    $0x1,%edi
call   10b0 <exit@plt>
jmp    1467 <main+0x2c7>
mov    0x3b7a(%rip),%rax
mov    (%rax),%edi
call   10c0 <getc@plt>
mov    %eax,-0x840018(%rbp)
mov    -0x840018(%rbp),%eax
mov    0x3b58(%rip),%rcx
cmp    (%rcx),%eax
je     149d <main+0x2fd>
cmpl   $0xa,-0x840018(%rbp)
jne    14a7 <main+0x307>
mov    $0x1,%edi
call   10b0 <exit@plt>
cmpl   $0x9,-0x840018(%rbp)
jne    14b9 <main+0x319>
jmp    169c <main+0x4fc>
movslq -0x84001c(%rbp),%rax
cmpl   $0x0,-0x840010(%rbp,%rax,4)
jge    1500 <main+0x360>
mov    -0x840014(%rbp),%ecx
movslq -0x84001c(%rbp),%rax
mov    %ecx,-0x840010(%rbp,%rax,4)
mov    -0x840014(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x840014(%rbp)
cltq
movl   $0x0,-0x400010(%rbp,%rax,4)
cmpl   $0x80,-0x840018(%rbp)
jl     1677 <main+0x4d7>
cmpl   $0xc0,-0x840018(%rbp)
jge    152a <main+0x38a>
mov    $0x1,%edi
call   10b0 <exit@plt>
cmpl   $0xe0,-0x840018(%rbp)
jge    154a <main+0x3aa>
mov    $0x2,%eax
mov    %eax,-0x8fc470(%rbp)
jmp    15c1 <main+0x421>
cmpl   $0xf0,-0x840018(%rbp)
jge    156a <main+0x3ca>
mov    $0x3,%eax
mov    %eax,-0x8fc474(%rbp)
jmp    15b5 <main+0x415>
cmpl   $0xf8,-0x840018(%rbp)
jge    158a <main+0x3ea>
mov    $0x4,%eax
mov    %eax,-0x8fc478(%rbp)
jmp    15a9 <main+0x409>
mov    -0x840018(%rbp),%edx
mov    $0x6,%eax
mov    $0x5,%ecx
cmp    $0xfc,%edx
cmovl  %ecx,%eax
mov    %eax,-0x8fc478(%rbp)
mov    -0x8fc478(%rbp),%eax
mov    %eax,-0x8fc474(%rbp)
mov    -0x8fc474(%rbp),%eax
mov    %eax,-0x8fc470(%rbp)
mov    -0x8fc470(%rbp),%eax
mov    %eax,-0x840020(%rbp)
mov    $0x8,%ecx
sub    -0x840020(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
sub    $0x1,%eax
and    -0x840018(%rbp),%eax
mov    %eax,-0x840018(%rbp)
mov    -0x840020(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x840020(%rbp)
cmp    $0x0,%eax
jbe    166d <main+0x4cd>
mov    0x39db(%rip),%rax
mov    (%rax),%edi
call   10c0 <getc@plt>
mov    %eax,-0x840024(%rbp)
cmpl   $0x80,-0x840024(%rbp)
jl     163a <main+0x49a>
cmpl   $0xc0,-0x840024(%rbp)
jl     1644 <main+0x4a4>
mov    $0x1,%edi
call   10b0 <exit@plt>
mov    -0x840018(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x840018(%rbp)
mov    -0x840024(%rbp),%eax
and    $0x3f,%eax
or     -0x840018(%rbp),%eax
mov    %eax,-0x840018(%rbp)
jmp    15ee <main+0x44e>
jmp    1672 <main+0x4d2>
jmp    1677 <main+0x4d7>
mov    -0x840018(%rbp),%ecx
mov    -0x840014(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x840014(%rbp)
cltq
mov    %ecx,-0x400010(%rbp,%rax,4)
jmp    1467 <main+0x2c7>
movslq -0x84001c(%rbp),%rax
cmpl   $0x0,-0x840010(%rbp,%rax,4)
jl     16de <main+0x53e>
mov    -0x840014(%rbp),%ecx
movslq -0x84001c(%rbp),%rax
sub    -0x840010(%rbp,%rax,4),%ecx
sub    $0x1,%ecx
movslq -0x84001c(%rbp),%rax
movslq -0x840010(%rbp,%rax,4),%rax
ff
mov    %ecx,-0x400010(%rbp,%rax,4)
jmp    16e3 <main+0x543>
mov    0x38fe(%rip),%rax
mov    (%rax),%edi
call   10c0 <getc@plt>
mov    %eax,-0x840018(%rbp)
mov    -0x840018(%rbp),%ecx
mov    $0x1,%al
mov    0x38da(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0x8fc479(%rbp)
je     1724 <main+0x584>
cmpl   $0xa,-0x840018(%rbp)
sete   %al
mov    %al,-0x8fc479(%rbp)
mov    -0x8fc479(%rbp),%al
xor    $0xff,%al
test   $0x1,%al
jne    16e3 <main+0x543>
jmp    1367 <main+0x1c7>
mov    -0x840014(%rbp),%esi
lea    0x1c7a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x840028(%rbp)
mov    -0x840028(%rbp),%eax
cmp    -0x840014(%rbp),%eax
jge    18a7 <main+0x707>
movslq -0x840028(%rbp),%rax
cmpl   $0x20,-0x400010(%rbp,%rax,4)
20
jae    179f <main+0x5ff>
movslq -0x840028(%rbp),%rax
mov    -0x400010(%rbp,%rax,4),%esi
lea    0x1c5d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    188e <main+0x6ee>
movslq -0x840028(%rbp),%rax
cmpl   $0x27,-0x400010(%rbp,%rax,4)
27
jne    17c7 <main+0x627>
lea    0x1c3c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1889 <main+0x6e9>
movslq -0x840028(%rbp),%rax
cmpl   $0x5c,-0x400010(%rbp,%rax,4)
5c
jne    17ef <main+0x64f>
lea    0x1c1a(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    1884 <main+0x6e4>
movslq -0x840028(%rbp),%rax
cmpl   $0x7f,-0x400010(%rbp,%rax,4)
7f
jae    1825 <main+0x685>
movslq -0x840028(%rbp),%rax
mov    -0x400010(%rbp,%rax,4),%esi
lea    0x1bea(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    187f <main+0x6df>
movslq -0x840028(%rbp),%rax
cmpl   $0x100,-0x400010(%rbp,%rax,4)
jae    185e <main+0x6be>
movslq -0x840028(%rbp),%rax
mov    -0x400010(%rbp,%rax,4),%esi
lea    0x1bb8(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    187a <main+0x6da>
movslq -0x840028(%rbp),%rax
mov    -0x400010(%rbp,%rax,4),%esi
lea    0x1b9f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    187f <main+0x6df>
jmp    1884 <main+0x6e4>
jmp    1889 <main+0x6e9>
jmp    188e <main+0x6ee>
jmp    1893 <main+0x6f3>
mov    -0x840028(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x840028(%rbp)
jmp    1757 <main+0x5b7>
lea    0x1b6c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1c43(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x8fc44c(%rbp)
cmpl   $0x1100,-0x8fc44c(%rbp)
jge    1903 <main+0x763>
movslq -0x8fc44c(%rbp),%rax
movl   $0x0,-0x844430(%rbp,%rax,4)
mov    -0x8fc44c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc44c(%rbp)
jmp    18cd <main+0x72d>
movl   $0x0,-0x8fc448(%rbp)
cmpl   $0x110000,-0x8fc448(%rbp)
jge    1961 <main+0x7c1>
movslq -0x8fc448(%rbp),%rax
cmpl   $0x0,-0x840010(%rbp,%rax,4)
jl     1948 <main+0x7a8>
mov    -0x8fc448(%rbp),%eax
sar    $0x8,%eax
cltq
movl   $0x1,-0x844430(%rbp,%rax,4)
jmp    194d <main+0x7ad>
mov    -0x8fc448(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc448(%rbp)
jmp    190d <main+0x76d>
movl   $0x0,-0x8fc450(%rbp)
cmpl   $0x22000,-0x8fc450(%rbp)
jge    1a38 <main+0x898>
movl   $0x1,-0x8fc45c(%rbp)
movl   $0x0,-0x8fc454(%rbp)
cmpl   $0x8,-0x8fc454(%rbp)
jge    19e9 <main+0x849>
mov    -0x8fc450(%rbp),%eax
shl    $0x3,%eax
add    -0x8fc454(%rbp),%eax
mov    %eax,-0x8fc448(%rbp)
movslq -0x8fc448(%rbp),%rax
cmpl   $0x0,-0x840010(%rbp,%rax,4)
jl     19d0 <main+0x830>
movl   $0x0,-0x8fc45c(%rbp)
jmp    19d5 <main+0x835>
mov    -0x8fc454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc454(%rbp)
jmp    198f <main+0x7ef>
cmpl   $0x0,-0x8fc45c(%rbp)
je     1a0d <main+0x86d>
movslq -0x8fc450(%rbp),%rax
movl   $0xffffffff,-0x8cc430(%rbp,%rax,4)
ff ff ff ff
jmp    1a1f <main+0x87f>
movslq -0x8fc450(%rbp),%rax
movl   $0x0,-0x8cc430(%rbp,%rax,4)
jmp    1a24 <main+0x884>
mov    -0x8fc450(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc450(%rbp)
jmp    196b <main+0x7cb>
movl   $0x0,-0x8cc434(%rbp)
movl   $0x0,-0x8fc450(%rbp)
cmpl   $0x22000,-0x8fc450(%rbp)
jge    1bcd <main+0xa2d>
movslq -0x8fc450(%rbp),%rax
cmpl   $0x0,-0x8cc430(%rbp,%rax,4)
jl     1bb4 <main+0xa14>
cmpl   $0x0,-0x8cc434(%rbp)
jle    1b4a <main+0x9aa>
cmpl   $0x0,-0x8fc450(%rbp)
jle    1aae <main+0x90e>
mov    -0x8fc450(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x8cc430(%rbp,%rax,4),%eax
mov    -0x8cc434(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1b0b <main+0x96b>
mov    -0x8cc434(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
sar    $0x5,%eax
mov    -0x8fc450(%rbp),%ecx
sar    $0x5,%ecx
cmp    %ecx,%eax
jne    1b4a <main+0x9aa>
mov    -0x8fc450(%rbp),%eax
mov    -0x8cc434(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x8fc440(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
sub    0x4(%rcx),%eax
cmp    $0x8,%eax
jg     1b4a <main+0x9aa>
mov    -0x8cc434(%rbp),%ecx
sub    $0x1,%ecx
movslq -0x8fc450(%rbp),%rax
mov    %ecx,-0x8cc430(%rbp,%rax,4)
mov    -0x8fc450(%rbp),%ecx
mov    -0x8cc434(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
jmp    1baf <main+0xa0f>
mov    -0x8cc434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8cc434(%rbp)
mov    -0x8cc434(%rbp),%ecx
sub    $0x1,%ecx
movslq -0x8fc450(%rbp),%rax
mov    %ecx,-0x8cc430(%rbp,%rax,4)
mov    -0x8fc450(%rbp),%ecx
mov    -0x8cc434(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
mov    -0x8cc434(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
jmp    1bb4 <main+0xa14>
jmp    1bb9 <main+0xa19>
mov    -0x8fc450(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc450(%rbp)
jmp    1a4c <main+0x8ac>
movl   $0x0,-0x8fc458(%rbp)
mov    -0x8fc458(%rbp),%eax
cmp    -0x8cc434(%rbp),%eax
jge    1ccc <main+0xb2c>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movl   $0x0,0x8(%rax)
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
shl    $0x3,%eax
mov    %eax,-0x8fc450(%rbp)
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
add    $0x1,%eax
shl    $0x3,%eax
mov    %eax,-0x8fc454(%rbp)
mov    -0x8fc450(%rbp),%eax
mov    %eax,-0x8fc448(%rbp)
mov    -0x8fc448(%rbp),%eax
cmp    -0x8fc454(%rbp),%eax
jge    1cb3 <main+0xb13>
movslq -0x8fc448(%rbp),%rax
cmpl   $0x0,-0x840010(%rbp,%rax,4)
jl     1c9a <main+0xafa>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x8(%rax),%ecx
add    $0x1,%ecx
mov    %ecx,0x8(%rax)
jmp    1c9f <main+0xaff>
mov    -0x8fc448(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc448(%rbp)
jmp    1c55 <main+0xab5>
jmp    1cb8 <main+0xb18>
mov    -0x8fc458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc458(%rbp)
jmp    1bd7 <main+0xa37>
movl   $0x0,-0x8fc458(%rbp)
movl   $0xffffffff,-0x8fc44c(%rbp)
ff ff ff
movl   $0x0,-0x8fc444(%rbp)
mov    -0x8fc458(%rbp),%eax
cmp    -0x8cc434(%rbp),%eax
jge    1e2a <main+0xc8a>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1,0x8(%rax)
jle    1df4 <main+0xc54>
mov    -0x8fc44c(%rbp),%eax
movslq -0x8fc458(%rbp),%rdx
lea    -0x8fc440(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
mov    (%rcx),%ecx
sar    $0x5,%ecx
cmp    %ecx,%eax
jne    1d83 <main+0xbe3>
mov    $0x6,%edi
call   1070 <malloc@plt>
mov    %rax,-0x8fc468(%rbp)
mov    -0x8fc468(%rbp),%rdi
mov    -0x8fc44c(%rbp),%edx
mov    -0x8fc444(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x8fc444(%rbp)
lea    0x16a8(%rip),%rsi
mov    $0x0,%al
call   10a0 <sprintf@plt>
jmp    1dcf <main+0xc2f>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
sar    $0x5,%eax
mov    %eax,-0x8fc44c(%rbp)
mov    $0x3,%edi
call   1070 <malloc@plt>
mov    %rax,-0x8fc468(%rbp)
mov    -0x8fc468(%rbp),%rdi
mov    -0x8fc44c(%rbp),%edx
lea    0x165f(%rip),%rsi
mov    $0x0,%al
call   10a0 <sprintf@plt>
mov    -0x8fc468(%rbp),%rcx
movslq -0x8fc458(%rbp),%rdx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rdx,%rdx
add    %rdx,%rax
mov    %rcx,0x10(%rax)
jmp    1e11 <main+0xc71>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movq   $0x0,0x10(%rax)
jmp    1e16 <main+0xc76>
mov    -0x8fc458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc458(%rbp)
jmp    1cea <main+0xb4a>
movl   $0xffffffff,-0x8fc44c(%rbp)
ff ff ff
movl   $0x0,-0x8fc458(%rbp)
mov    -0x8fc458(%rbp),%eax
cmp    -0x8cc434(%rbp),%eax
jge    2041 <main+0xea1>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1,0x8(%rax)
jle    2028 <main+0xe88>
movl   $0x0,-0x8fc44c(%rbp)
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x10(%rax),%rsi
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%edx
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
sub    (%rax),%edx
add    $0x1,%edx
shl    $0x3,%edx
lea    0x155e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    (%rax),%eax
mov    %eax,-0x8fc450(%rbp)
mov    -0x8fc450(%rbp),%eax
movslq -0x8fc458(%rbp),%rdx
lea    -0x8fc440(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cmp    0x4(%rcx),%eax
jg     201a <main+0xe7a>
mov    -0x8fc450(%rbp),%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1f67 <main+0xdc7>
mov    -0x8fc450(%rbp),%eax
movslq -0x8fc458(%rbp),%rdx
lea    -0x8fc440(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
jle    1f67 <main+0xdc7>
mov    -0x8fc450(%rbp),%esi
shl    $0x3,%esi
lea    0x14f8(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x158c(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x8fc454(%rbp)
cmpl   $0x8,-0x8fc454(%rbp)
jge    1fd1 <main+0xe31>
mov    -0x8fc450(%rbp),%eax
shl    $0x3,%eax
add    -0x8fc454(%rbp),%eax
mov    %eax,-0x8fc448(%rbp)
movslq -0x8fc448(%rbp),%rax
mov    -0x840010(%rbp,%rax,4),%esi
lea    0x14b2(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8fc454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc454(%rbp)
jmp    1f7f <main+0xddf>
mov    -0x8fc450(%rbp),%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
mov    %edx,%esi
shl    $0x3,%esi
mov    -0x8fc450(%rbp),%eax
mov    $0x20,%ecx
cltd
idiv   %ecx
shl    $0x3,%edx
add    $0x7,%edx
lea    0x146f(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8fc450(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc450(%rbp)
jmp    1ef2 <main+0xd52>
lea    0x13fa(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    202d <main+0xe8d>
mov    -0x8fc458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc458(%rbp)
jmp    1e3e <main+0xc9e>
cmpl   $0x0,-0x8fc44c(%rbp)
jl     205c <main+0xebc>
lea    0x14aa(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x1421(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x8fc450(%rbp)
cmpl   $0x22000,-0x8fc450(%rbp)
jge    236e <main+0x11ce>
movslq -0x8fc450(%rbp),%rax
mov    -0x8cc430(%rbp,%rax,4),%eax
mov    %eax,-0x8fc458(%rbp)
mov    -0x8fc450(%rbp),%eax
mov    %eax,-0x8fc454(%rbp)
xor    %eax,%eax
cmpl   $0x22000,-0x8fc454(%rbp)
mov    %al,-0x8fc47a(%rbp)
jge    20d9 <main+0xf39>
movslq -0x8fc454(%rbp),%rax
mov    -0x8cc430(%rbp,%rax,4),%eax
cmp    -0x8fc458(%rbp),%eax
sete   %al
mov    %al,-0x8fc47a(%rbp)
mov    -0x8fc47a(%rbp),%al
test   $0x1,%al
jne    20ec <main+0xf4c>
jmp    2105 <main+0xf65>
jmp    20f1 <main+0xf51>
mov    -0x8fc454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc454(%rbp)
jmp    20a4 <main+0xf04>
cmpl   $0x0,-0x8fc458(%rbp)
jl     218d <main+0xfed>
mov    -0x8fc450(%rbp),%eax
movslq -0x8fc458(%rbp),%rdx
lea    -0x8fc440(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
cmp    (%rcx),%eax
je     213c <main+0xf9c>
mov    $0x0,%al
call   1030 <abort@plt>
mov    -0x8fc454(%rbp),%eax
movslq -0x8fc458(%rbp),%rdx
lea    -0x8fc440(%rbp),%rcx
imul   $0x18,%rdx,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    216c <main+0xfcc>
mov    $0x0,%al
call   1030 <abort@plt>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
add    $0x1,%eax
mov    %eax,-0x8fc454(%rbp)
cmpl   $0xffffffff,-0x8fc458(%rbp)
jne    219f <main+0xfff>
jmp    235d <main+0x11bd>
cmpl   $0x0,-0x8fc458(%rbp)
jl     21d2 <main+0x1032>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,0x8(%rax)
jne    21d2 <main+0x1032>
mov    $0x0,%al
call   1030 <abort@plt>
cmpl   $0x0,-0x8fc458(%rbp)
jl     229c <main+0x10fc>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x1,0x8(%rax)
jne    229c <main+0x10fc>
mov    -0x8fc454(%rbp),%eax
mov    -0x8fc450(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
je     221c <main+0x107c>
mov    $0x0,%al
call   1030 <abort@plt>
mov    -0x8fc450(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x8fc448(%rbp)
mov    -0x8fc448(%rbp),%eax
mov    -0x8fc454(%rbp),%ecx
shl    $0x3,%ecx
cmp    %ecx,%eax
jge    2297 <main+0x10f7>
movslq -0x8fc448(%rbp),%rax
cmpl   $0x0,-0x840010(%rbp,%rax,4)
jl     227e <main+0x10de>
mov    -0x8fc448(%rbp),%esi
movslq -0x8fc448(%rbp),%rax
mov    -0x840010(%rbp,%rax,4),%edx
lea    0x1233(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    2297 <main+0x10f7>
jmp    2283 <main+0x10e3>
mov    -0x8fc448(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8fc448(%rbp)
jmp    222b <main+0x108b>
jmp    234f <main+0x11af>
cmpl   $0x0,-0x8fc450(%rbp)
jne    22c5 <main+0x1125>
mov    -0x8fc454(%rbp),%esi
shl    $0x3,%esi
lea    0x120e(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    22e5 <main+0x1145>
mov    -0x8fc450(%rbp),%esi
shl    $0x3,%esi
mov    -0x8fc454(%rbp),%edx
shl    $0x3,%edx
lea    0x11d9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
mov    0x10(%rax),%rsi
lea    0x11ce(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movslq -0x8fc458(%rbp),%rcx
lea    -0x8fc440(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
cmpl   $0x0,(%rax)
jle    2341 <main+0x11a1>
mov    -0x8fc450(%rbp),%esi
shl    $0x3,%esi
lea    0x11af(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x11a9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0x119d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x8fc454(%rbp),%eax
mov    %eax,-0x8fc450(%rbp)
jmp    2074 <main+0xed4>
lea    0x1187(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    0x2c4d(%rip),%rax
mov    (%rax),%edi
call   1040 <ferror@plt>
cmp    $0x0,%rax
jne    23ac <main+0x120c>
mov    0x2c35(%rip),%rax
mov    (%rax),%edi
call   1050 <fclose@plt>
cmp    $0x0,%rax
je     23b6 <main+0x1216>
mov    $0x1,%edi
call   10b0 <exit@plt>
xor    %edi,%edi
call   10b0 <exit@plt>

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x8f8028,%rsp
cmp    $0x1,%edi
jne    1bfa <main+0xa2a>
lea    0x12d7(%rip),%rbx
mov    %rbx,%rdi
call   1050 <puts@plt>
lea    0xf38(%rip),%rdi
call   1050 <puts@plt>
lea    0xf66(%rip),%rdi
call   1050 <puts@plt>
lea    0x11a6(%rip),%rbp
mov    %rbp,%rdi
call   1050 <puts@plt>
lea    0xf7d(%rip),%rdi
call   1050 <puts@plt>
lea    0xfb7(%rip),%rdi
call   1050 <puts@plt>
lea    0xff1(%rip),%rdi
call   1050 <puts@plt>
lea    0x102f(%rip),%rdi
call   1050 <puts@plt>
mov    %rbp,%rdi
call   1050 <puts@plt>
lea    0x1055(%rip),%rdi
call   1050 <puts@plt>
lea    0x1090(%rip),%rdi
call   1050 <puts@plt>
lea    0x10ce(%rip),%rdi
call   1050 <puts@plt>
lea    0x1107(%rip),%rdi
call   1050 <puts@plt>
mov    %rbp,%rdi
call   1050 <puts@plt>
lea    0x112a(%rip),%rdi
call   1050 <puts@plt>
lea    0x1163(%rip),%rdi
call   1050 <puts@plt>
lea    0x11a1(%rip),%rdi
call   1050 <puts@plt>
lea    0x11e1(%rip),%rdi
call   1050 <puts@plt>
lea    0x121d(%rip),%rbp
mov    %rbp,%rdi
call   1050 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rbx,%rdi
call   1050 <puts@plt>
lea    0x11e3(%rip),%rdi
call   1050 <puts@plt>
mov    %rbp,%rdi
call   1050 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xb8020(%rsp),%rdi
mov    $0x440000,%edx
mov    $0xff,%esi
call   1090 <memset@plt>
movl   $0x110000,0x30020(%rsp)
mov    0x2cc0(%rip),%rbx
mov    (%rbx),%edi
call   10f0 <getc@plt>
mov    0x2caa(%rip),%r13
cmp    0x0(%r13),%eax
jne    1519 <main+0x349>
lea    0xcbc(%rip),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0x1191(%rip),%rdi
call   1050 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqa 0xb8020(%rsp,%rsi,8),%xmm0
packssdw 0xb8030(%rsp,%rsi,8),%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%ecx
mov    %ecx,%edx
and    $0x2,%dl
shr    %dl
mov    %ecx,%ebx
shr    $0x2,%bl
mov    %ecx,%eax
shr    $0x3,%al
and    %bl,%al
and    %dl,%al
mov    %ecx,%edx
shr    $0x4,%dl
mov    %ecx,%ebx
shr    $0x5,%bl
and    %dl,%bl
mov    %ecx,%edi
shr    $0x6,%dil
mov    %ecx,%edx
shr    $0x7,%dl
and    %dil,%dl
and    %bl,%dl
and    %al,%dl
and    %cl,%dl
movzbl %dl,%eax
neg    %eax
mov    %eax,0x30020(%rsp,%rsi,1)
add    $0x4,%rsi
cmp    $0x88000,%rsi
jne    1370 <main+0x1a0>
mov    0x30020(%rsp),%r15d
xor    %r14d,%r14d
test   %r15d,%r15d
js     1405 <main+0x235>
movl   $0x0,0x30020(%rsp)
movq   $0x0,0x20(%rsp)
mov    $0x1,%r14d
xor    %r15d,%r15d
mov    $0x1,%eax
jmp    143a <main+0x26a>
nopl   0x0(%rax)
mov    %r14d,0x30020(%rsp,%rax,4)
movslq %r14d,%rcx
lea    0x1(%r14),%edx
lea    (%rcx,%rcx,2),%rcx
mov    %eax,0x24(%rsp,%rcx,8)
mov    %eax,0x20(%rsp,%rcx,8)
mov    %edx,%r14d
add    $0x1,%rax
cmp    $0x22000,%rax
je     1486 <main+0x2b6>
cmpl   $0x0,0x30020(%rsp,%rax,4)
js     142e <main+0x25e>
test   %r14d,%r14d
jle    1410 <main+0x240>
lea    -0x1(%r14),%ecx
cmp    %ecx,0x3001c(%rsp,%rax,4)
je     1475 <main+0x2a5>
lea    (%rcx,%rcx,2),%rdx
mov    0x24(%rsp,%rdx,8),%edx
mov    %edx,%esi
sar    $0x5,%esi
mov    %eax,%edi
shr    $0x5,%edi
cmp    %edi,%esi
jne    1410 <main+0x240>
mov    %eax,%esi
sub    %edx,%esi
cmp    $0x8,%esi
jg     1410 <main+0x240>
mov    %ecx,0x30020(%rsp,%rax,4)
lea    (%rcx,%rcx,2),%rcx
mov    %eax,0x24(%rsp,%rcx,8)
jmp    142e <main+0x25e>
test   %r14d,%r14d
jle    19c1 <main+0x7f1>
mov    %r14d,%ebp
xor    %eax,%eax
jmp    14ad <main+0x2dd>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rbp,%rax
je     170b <main+0x53b>
lea    (%rax,%rax,2),%rcx
movl   $0x0,0x28(%rsp,%rcx,8)
mov    0x20(%rsp,%rcx,8),%edx
mov    0x24(%rsp,%rcx,8),%esi
shl    $0x3,%edx
lea    0x8(,%rsi,8),%esi
cmp    %esi,%edx
jge    14a0 <main+0x2d0>
lea    (%rsp,%rcx,8),%rcx
add    $0x28,%rcx
movslq %edx,%rdx
movslq %esi,%rsi
xor    %edi,%edi
jmp    14f9 <main+0x329>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rdx
cmp    %rdx,%rsi
je     14a0 <main+0x2d0>
cmpl   $0x0,0xb8020(%rsp,%rdx,4)
js     1508 <main+0x338>
add    $0x1,%edi
mov    %edi,(%rcx)
cmpl   $0x0,0xb8024(%rsp,%rdx,4)
js     14f0 <main+0x320>
add    $0x1,%edi
mov    %edi,(%rcx)
jmp    14f0 <main+0x320>
xor    %r12d,%r12d
lea    0x30020(%rsp),%r15
jmp    1541 <main+0x371>
cs nopw 0x0(%rax,%rax,1)
mov    (%rbx),%edi
call   10f0 <getc@plt>
cmp    0x0(%r13),%eax
je     1c04 <main+0xa34>
cmp    $0x23,%eax
jne    1564 <main+0x394>
cs nopw 0x0(%rax,%rax,1)
mov    (%rbx),%edi
call   10f0 <getc@plt>
cmp    $0xa,%eax
je     1530 <main+0x360>
cmp    0x0(%r13),%eax
jne    1550 <main+0x380>
jmp    1530 <main+0x360>
mov    (%rbx),%esi
mov    %eax,%edi
call   10b0 <ungetc@plt>
lea    0xa8c(%rip),%rdi
mov    %r15,%rsi
call   10c0 <scanf@plt>
cmp    $0x1,%eax
jne    1bfa <main+0xa2a>
mov    (%rbx),%edi
call   10f0 <getc@plt>
cmp    $0x9,%eax
jne    1bfa <main+0xa2a>
mov    (%rbx),%edi
call   10f0 <getc@plt>
cmp    $0xa,%eax
je     1bfa <main+0xa2a>
mov    %eax,%ebp
cmp    0x0(%r13),%ebp
je     1bfa <main+0xa2a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq 0x30020(%rsp),%rcx
mov    0xb8020(%rsp,%rcx,4),%eax
cmp    $0x9,%ebp
je     16d5 <main+0x505>
test   %eax,%eax
js     15f0 <main+0x420>
cmp    $0x80,%ebp
jge    1616 <main+0x446>
jmp    16a6 <main+0x4d6>
nopl   0x0(%rax)
mov    %r12d,0xb8020(%rsp,%rcx,4)
movslq %r12d,%rax
add    $0x1,%r12d
movl   $0x0,0x4f8020(%rsp,%rax,4)
cmp    $0x80,%ebp
jl     16a6 <main+0x4d6>
cmp    $0xbf,%ebp
jbe    1bfa <main+0xa2a>
mov    $0x2,%r14d
cmp    $0xe0,%ebp
jb     1660 <main+0x490>
mov    $0x3,%r14d
cmp    $0xf0,%ebp
jb     1660 <main+0x490>
mov    $0x4,%r14d
cmp    $0xf8,%ebp
jb     1660 <main+0x490>
cmp    $0xfc,%ebp
mov    $0x6,%r14d
sbb    $0x0,%r14d
nopl   0x0(%rax)
mov    $0x8,%cl
sub    %r14b,%cl
mov    $0xffffffff,%eax
shl    %cl,%eax
not    %eax
and    %eax,%ebp
add    $0xffffffff,%r14d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rbx),%edi
call   10f0 <getc@plt>
mov    %eax,%ecx
and    $0xffffffc0,%ecx
cmp    $0x80,%ecx
jne    1bfa <main+0xa2a>
shl    $0x6,%ebp
and    $0x3f,%eax
or     %eax,%ebp
add    $0xffffffff,%r14d
jne    1680 <main+0x4b0>
movslq %r12d,%rax
mov    %ebp,0x4f8020(%rsp,%rax,4)
mov    (%rbx),%edi
call   10f0 <getc@plt>
cmp    $0xa,%eax
je     1bfa <main+0xa2a>
mov    %eax,%ebp
add    $0x1,%r12d
cmp    0x0(%r13),%ebp
jne    15c0 <main+0x3f0>
jmp    1bfa <main+0xa2a>
test   %eax,%eax
js     16f0 <main+0x520>
mov    %eax,%ecx
not    %ecx
add    %r12d,%ecx
mov    %ecx,0x4f8020(%rsp,%rax,4)
nopw   0x0(%rax,%rax,1)
mov    (%rbx),%edi
call   10f0 <getc@plt>
cmp    $0xa,%eax
je     1530 <main+0x360>
cmp    0x0(%r13),%eax
jne    16f0 <main+0x520>
jmp    1530 <main+0x360>
test   %r14d,%r14d
jle    19c1 <main+0x7f1>
mov    %rbp,0x10(%rsp)
lea    0x0(,%rbp,8),%rax
lea    (%rax,%rax,2),%r13
mov    $0xffffffff,%eax
xor    %r12d,%r12d
movl   $0x0,0x8(%rsp)
jmp    1750 <main+0x580>
nopw   0x0(%rax,%rax,1)
xor    %ebx,%ebx
mov    %rbx,0x30(%rsp,%r12,1)
add    $0x18,%r12
cmp    %r12,%r13
je     17c7 <main+0x5f7>
cmpl   $0x2,0x28(%rsp,%r12,1)
jl     1740 <main+0x570>
mov    0x20(%rsp,%r12,1),%ebp
sar    $0x5,%ebp
cmp    %ebp,%eax
jne    17a0 <main+0x5d0>
mov    $0x6,%edi
mov    %eax,%ebp
call   10a0 <malloc@plt>
mov    %rax,%rbx
mov    0x8(%rsp),%ecx
add    $0x1,%ecx
mov    %rax,%rdi
lea    0x8d9(%rip),%rsi
mov    %ebp,%edx
mov    %ecx,0x8(%rsp)
xor    %eax,%eax
call   10d0 <sprintf@plt>
jmp    17c0 <main+0x5f0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x3,%edi
call   10a0 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
lea    0x8ae(%rip),%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   10d0 <sprintf@plt>
mov    %ebp,%eax
jmp    1742 <main+0x572>
test   %r14d,%r14d
mov    0x10(%rsp),%rcx
jle    19c1 <main+0x7f1>
mov    $0xffffffff,%eax
lea    0x8c5(%rip),%rbp
xor    %edx,%edx
jmp    1815 <main+0x645>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0xcf2(%rip),%rdi
call   1050 <puts@plt>
xor    %eax,%eax
mov    0x10(%rsp),%rcx
mov    0x18(%rsp),%rdx
add    $0x1,%rdx
cmp    %rcx,%rdx
je     19b3 <main+0x7e3>
lea    (%rdx,%rdx,2),%rbx
cmpl   $0x2,0x28(%rsp,%rbx,8)
jl     1808 <main+0x638>
mov    %rdx,0x18(%rsp)
mov    0x30(%rsp,%rbx,8),%rsi
mov    0x24(%rsp,%rbx,8),%eax
movslq 0x20(%rsp,%rbx,8),%r12
sub    %r12d,%eax
lea    0x8(,%rax,8),%edx
lea    0x826(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
cmp    0x24(%rsp,%rbx,8),%r12d
jg     17f0 <main+0x620>
lea    (%rsp,%rbx,8),%rax
add    $0x20,%rax
mov    %rax,0x8(%rsp)
lea    0x0(,%r12,8),%ebx
jmp    1972 <main+0x7a2>
nopl   0x0(%rax)
mov    $0x20,%edi
call   1030 <putchar@plt>
movslq %ebx,%r13
mov    0xb8020(%rsp,%r13,4),%esi
shl    $0x2,%r13
mov    %rbp,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %r13,%rax
or     $0x4,%rax
mov    0xb8020(%rsp,%rax,1),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %r13,%rax
or     $0x8,%rax
mov    0xb8020(%rsp,%rax,1),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %r13,%rax
or     $0xc,%rax
mov    0xb8020(%rsp,%rax,1),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %r13,%rax
or     $0x10,%rax
mov    0xb8020(%rsp,%rax,1),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %r13,%rax
or     $0x14,%rax
mov    0xb8020(%rsp,%rax,1),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %r13,%rax
or     $0x18,%rax
mov    0xb8020(%rsp,%rax,1),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
or     $0x1c,%r13
mov    0xb8020(%rsp,%r13,1),%esi
mov    %rbp,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %r14d,%esi
shl    $0x3,%esi
lea    0x7(,%r14,8),%edx
lea    0x75e(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0x1(%r12),%rax
mov    0x8(%rsp),%rcx
movslq 0x4(%rcx),%rcx
add    $0x8,%ebx
cmp    %rcx,%r12
mov    %rax,%r12
jge    17f0 <main+0x620>
lea    0x1f(%r12),%eax
test   %r12d,%r12d
cmovns %r12d,%eax
and    $0xffffffe0,%eax
mov    %r12d,%r14d
sub    %eax,%r14d
jne    1870 <main+0x6a0>
mov    0x8(%rsp),%rax
movslq (%rax),%rax
cmp    %rax,%r12
jle    1870 <main+0x6a0>
lea    0x6f1(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1080 <printf@plt>
jmp    1870 <main+0x6a0>
test   %eax,%eax
js     19c1 <main+0x7f1>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x6fa(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
lea    0x30024(%rsp),%r13
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %ebp,%r14d
movslq %ebp,%rdx
lea    0x0(,%rdx,4),%rax
add    %r13,%rax
mov    $0x21fff,%ecx
sub    %rdx,%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
cmp    %rdx,%rcx
je     1a30 <main+0x860>
lea    0x1(%rdx),%rbp
cmp    %r15d,(%rax,%rdx,4)
mov    %rbp,%rdx
je     1a00 <main+0x830>
add    %r14d,%ebp
test   %r15d,%r15d
jns    1a3a <main+0x86a>
cmp    $0xffffffff,%r15d
jne    1a71 <main+0x8a1>
jmp    1b89 <main+0x9b9>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x22000,%ebp
test   %r15d,%r15d
js     1a1a <main+0x84a>
mov    %r15d,%eax
lea    (%rax,%rax,2),%rcx
cmp    0x20(%rsp,%rcx,8),%r14d
jne    1bc1 <main+0x9f1>
mov    0x24(%rsp,%rcx,8),%eax
lea    0x1(%rax),%r12d
cmp    %r12d,%ebp
jg     1bc1 <main+0x9f1>
mov    0x28(%rsp,%rcx,8),%ecx
cmp    $0x1,%ecx
je     1aa0 <main+0x8d0>
mov    %r12d,%ebp
test   %ecx,%ecx
je     1bc1 <main+0x9f1>
test   %r14,%r14
je     1b20 <main+0x950>
lea    0x0(,%r14,8),%esi
lea    0x0(,%rbp,8),%edx
lea    0x665(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
jmp    1b35 <main+0x965>
nopl   0x0(%rax)
cmp    %r14d,%eax
jne    1bc1 <main+0x9f1>
shl    $0x3,%r14d
lea    0x0(,%r12,8),%eax
cmp    %eax,%r14d
jge    1b78 <main+0x9a8>
movslq %r14d,%rsi
add    $0x1,%rsi
sub    %r14d,%eax
nopl   0x0(%rax,%rax,1)
mov    0xb801c(%rsp,%rsi,4),%edx
test   %edx,%edx
jns    1ba1 <main+0x9d1>
mov    0xb8020(%rsp,%rsi,4),%edx
test   %edx,%edx
jns    1bb1 <main+0x9e1>
mov    0xb8024(%rsp,%rsi,4),%edx
test   %edx,%edx
jns    1ba7 <main+0x9d7>
mov    0xb8028(%rsp,%rsi,4),%edx
test   %edx,%edx
jns    1bad <main+0x9dd>
add    $0x4,%rsi
add    $0xfffffffc,%eax
jne    1ad0 <main+0x900>
jmp    1b78 <main+0x9a8>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rbp,8),%esi
lea    0x5d7(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
movslq %r15d,%rax
lea    (%rax,%rax,2),%rbx
mov    0x30(%rsp,%rbx,8),%rsi
lea    0x5c9(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
cmpl   $0x0,0x20(%rsp,%rbx,8)
jle    1b6b <main+0x99b>
shl    $0x3,%r14d
lea    0x5c6(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1080 <printf@plt>
mov    $0x5d,%edi
call   1030 <putchar@plt>
mov    %ebp,%r12d
lea    0x5b0(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
mov    %r12d,%ebp
cmp    $0x21fff,%ebp
jg     1bc8 <main+0x9f8>
movslq %ebp,%rax
mov    0x30020(%rsp,%rax,4),%r15d
jmp    19e0 <main+0x810>
add    $0xffffffffffffffff,%rsi
jmp    1bb1 <main+0x9e1>
add    $0x1,%rsi
jmp    1bb1 <main+0x9e1>
add    $0x2,%rsi
lea    0x52b(%rip),%rdi
xor    %eax,%eax
call   1080 <printf@plt>
jmp    1b78 <main+0x9a8>
xor    %eax,%eax
call   1040 <abort@plt>
lea    0x91d(%rip),%rdi
call   1050 <puts@plt>
mov    0x23f5(%rip),%rbx
mov    (%rbx),%edi
call   1060 <ferror@plt>
test   %rax,%rax
jne    1bfa <main+0xa2a>
mov    (%rbx),%edi
call   1070 <fclose@plt>
test   %rax,%rax
jne    1bfa <main+0xa2a>
xor    %edi,%edi
call   10e0 <exit@plt>
mov    $0x1,%edi
call   10e0 <exit@plt>
lea    0x3f8(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1080 <printf@plt>
test   %r12d,%r12d
jle    1350 <main+0x180>
mov    %r12d,%r12d
lea    0x40b(%rip),%rbx
lea    0x411(%rip),%r14
lea    0x404(%rip),%rbp
lea    0x409(%rip),%r15
xor    %r13d,%r13d
jmp    1c67 <main+0xa97>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rbx,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
add    $0x1,%r13
cmp    %r13,%r12
je     1350 <main+0x180>
mov    0x4f8020(%rsp,%r13,4),%esi
cmp    $0x1f,%esi
jbe    1c50 <main+0xa80>
cmp    $0x5c,%esi
je     1c83 <main+0xab3>
cmp    $0x27,%esi
jne    1c8f <main+0xabf>
mov    %rbp,%rdi
jmp    1c86 <main+0xab6>
mov    %r14,%rdi
xor    %eax,%eax
call   1080 <printf@plt>
jmp    1c5a <main+0xa8a>
cmp    $0x7e,%esi
ja     1c99 <main+0xac9>
mov    %r15,%rdi
jmp    1c53 <main+0xa83>
cmp    $0xff,%esi
ja     1caa <main+0xada>
lea    0x3a5(%rip),%rdi
jmp    1c53 <main+0xa83>
lea    0x3a4(%rip),%rdi
jmp    1c53 <main+0xa83>

LLVM IR (-O0):
%struct.anon = type { i32, i32, i32, i8* }
@.str = [4 x i8] c"/*\0A\00"
@.str.1 = [59 x i8] c" * Copyright (C) 1999-2003 Free Software Foundation, Inc.\0A\00"
@.str.2 = [51 x i8] c" * This file is part of the GNU LIBICONV Library.\0A\00"
@.str.3 = [4 x i8] c" *\0A\00"
@.str.4 = [71 x i8] c" * The GNU LIBICONV Library is free software; you can redistribute it\0A\00"
@.str.5 = [71 x i8] c" * and/or modify it under the terms of the GNU Library General Public\0A\00"
@.str.6 = [75 x i8] c" * License as published by the Free Software Foundation; either version 2\0A\00"
@.str.7 = [59 x i8] c" * of the License, or (at your option) any later version.\0A\00"
@.str.8 = [72 x i8] c" * The GNU LIBICONV Library is distributed in the hope that it will be\0A\00"
@.str.9 = [75 x i8] c" * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of\0A\00"
@.str.10 = [70 x i8] c" * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\0A\00"
@.str.11 = [53 x i8] c" * Library General Public License for more details.\0A\00"
@.str.12 = [70 x i8] c" * You should have received a copy of the GNU Library General Public\0A\00"
@.str.13 = [75 x i8] c" * License along with the GNU LIBICONV Library; see the file COPYING.LIB.\0A\00"
@.str.14 = [77 x i8] c" * If not, write to the Free Software Foundation, Inc., 51 Franklin Street,\0A\00"
@.str.15 = [45 x i8] c" * Fifth Floor, Boston, MA 02110-1301, USA.\0A\00"
@.str.16 = [5 x i8] c" */\0A\00"
@.str.17 = [2 x i8] c"\0A\00"
@.str.18 = [26 x i8] c" * Transliteration table\0A\00"
@stdin = global i32 0
@EOF = global i32 0
@.str.19 = [3 x i8] c"%x\00"
@.str.20 = [48 x i8] c"static const unsigned int translit_data[%d] = {\00"
@.str.21 = [7 x i8] c"\0A %3d,\00"
@.str.22 = [6 x i8] c"'\\'',\00"
@.str.23 = [6 x i8] c"'\\\\',\00"
@.str.24 = [7 x i8] c" '%c',\00"
@.str.25 = [8 x i8] c"0x%02X,\00"
@.str.26 = [8 x i8] c"0x%04X,\00"
@.str.27 = [5 x i8] c"\0A};\0A\00"
@.str.28 = [8 x i8] c"%02x_%d\00"
@.str.29 = [5 x i8] c"%02x\00"
@.str.30 = [44 x i8] c"static const short translit_page%s[%d] = {\0A\00"
@.str.31 = [16 x i8] c" /* 0x%04x */\0A\00"
@.str.32 = [2 x i8] c" \00"
@.str.33 = [6 x i8] c" %4d,\00"
@.str.34 = [22 x i8] c" /* 0x%02x-0x%02x */\0A\00"
@.str.35 = [4 x i8] c"};\0A\00"
@.str.36 = [33 x i8] c"#define translit_index(wc) \\\0A (\00"
@.str.37 = [18 x i8] c"wc == 0x%04x ? %d\00"
@.str.38 = [12 x i8] c"wc < 0x%04x\00"
@.str.39 = [28 x i8] c"wc >= 0x%04x && wc < 0x%04x\00"
@.str.40 = [22 x i8] c" ? translit_page%s[wc\00"
@.str.41 = [8 x i8] c"-0x%04x\00"
@.str.42 = [2 x i8] c"]\00"
@.str.43 = [9 x i8] c" : \\\0A \00"
@.str.44 = [5 x i8] c"-1)\0A\00"
@stdout = global i32 0
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [1048576 x i32]
%7 = alloca [1114112 x i32]
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [4352 x i32]
%15 = alloca [139264 x i32]
%16 = alloca i32
%17 = alloca [8192 x %struct.anon]
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i8*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%26 = load i32, i32* %4
%27 = icmp ne i32 %26, 1
br i1 %27, label %28, label %30
28: ; preds = %2
%29 = call i32 @exit(i32 1)
unreachable
30: ; preds = %2
%31 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
%32 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.1, i64 0, i64 0))
%33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([51 x i8], [51 x i8]* @.str.2, i64 0, i64 0))
%34 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.4, i64 0, i64 0))
%36 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([71 x i8], [71 x i8]* @.str.5, i64 0, i64 0))
%37 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.6, i64 0, i64 0))
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([59 x i8], [59 x i8]* @.str.7, i64 0, i64 0))
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.8, i64 0, i64 0))
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.9, i64 0, i64 0))
%42 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.10, i64 0, i64 0))
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.11, i64 0, i64 0))
%44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0))
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.12, i64 0, i64 0))
%46 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.13, i64 0, i64 0))
%47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([77 x i8], [77 x i8]* @.str.14, i64 0, i64 0))
%48 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.15, i64 0, i64 0))
%49 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i64 0, i64 0))
%51 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
%52 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.18, i64 0, i64 0))
%53 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.16, i64 0, i64 0))
%54 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i64 0, i64 0))
store i32 0, i32* %10
br label %55
55: ; preds = %62, %30
%56 = load i32, i32* %10
%57 = icmp slt i32 %56, 1114112
br i1 %57, label %58, label %65
58: ; preds = %55
%59 = load i32, i32* %10
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %60
store i32 -1, i32* %61
br label %62
62: ; preds = %58
%63 = load i32, i32* %10
%64 = add nsw i32 %63, 1
store i32 %64, i32* %10
br label %55
65: ; preds = %55
store i32 0, i32* %8
br label %66
66: ; preds = %237, %90, %65
%67 = load i32, i32* @stdin
%68 = call i32 @getc(i32 %67)
store i32 %68, i32* %9
%69 = load i32, i32* %9
%70 = load i32, i32* @EOF
%71 = icmp eq i32 %69, %70
br i1 %71, label %72, label %73
72: ; preds = %66
br label %238
73: ; preds = %66
%74 = load i32, i32* %9
%75 = icmp eq i32 %74, 35
br i1 %75, label %76, label %91
76: ; preds = %73
br label %77
77: ; preds = %87, %76
%78 = load i32, i32* @stdin
%79 = call i32 @getc(i32 %78)
store i32 %79, i32* %9
br label %80
80: ; preds = %77
%81 = load i32, i32* %9
%82 = load i32, i32* @EOF
%83 = icmp eq i32 %81, %82
br i1 %83, label %87, label %84
84: ; preds = %80
%85 = load i32, i32* %9
%86 = icmp eq i32 %85, 10
br label %87
87: ; preds = %84, %80
%88 = phi i1 [ true, %80 ], [ %86, %84 ]
%89 = xor i1 %88, true
br i1 %89, label %77, label %90
90: ; preds = %87
br label %66
91: ; preds = %73
%92 = load i32, i32* %9
%93 = load i32, i32* @stdin
%94 = call i32 @ungetc(i32 %92, i32 %93)
%95 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.19, i64 0, i64 0), i32* %10)
%96 = icmp ne i32 %95, 1
br i1 %96, label %97, label %99
97: ; preds = %91
%98 = call i32 @exit(i32 1)
unreachable
99: ; preds = %91
%100 = load i32, i32* @stdin
%101 = call i32 @getc(i32 %100)
store i32 %101, i32* %9
%102 = load i32, i32* %9
%103 = icmp ne i32 %102, 9
br i1 %103, label %104, label %106
104: ; preds = %99
%105 = call i32 @exit(i32 1)
unreachable
106: ; preds = %99
br label %107
107: ; preds = %197, %106
%108 = load i32, i32* @stdin
%109 = call i32 @getc(i32 %108)
store i32 %109, i32* %9
%110 = load i32, i32* %9
%111 = load i32, i32* @EOF
%112 = icmp eq i32 %110, %111
br i1 %112, label %116, label %113
113: ; preds = %107
%114 = load i32, i32* %9
%115 = icmp eq i32 %114, 10
br i1 %115, label %116, label %118
116: ; preds = %113, %107
%117 = call i32 @exit(i32 1)
unreachable
118: ; preds = %113
%119 = load i32, i32* %9
%120 = icmp eq i32 %119, 9
br i1 %120, label %121, label %122
121: ; preds = %118
br label %203
122: ; preds = %118
%123 = load i32, i32* %10
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %124
%126 = load i32, i32* %125
%127 = icmp slt i32 %126, 0
br i1 %127, label %128, label %137
128: ; preds = %122
%129 = load i32, i32* %8
%130 = load i32, i32* %10
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %131
store i32 %129, i32* %132
%133 = load i32, i32* %8
%134 = add nsw i32 %133, 1
store i32 %134, i32* %8
%135 = sext i32 %133 to i64
%136 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %135
store i32 0, i32* %136
br label %137
137: ; preds = %128, %122
%138 = load i32, i32* %9
%139 = icmp sge i32 %138, 128
br i1 %139, label %140, label %197
140: ; preds = %137
%141 = load i32, i32* %9
%142 = icmp slt i32 %141, 192
br i1 %142, label %143, label %145
143: ; preds = %140
%144 = call i32 @exit(i32 1)
unreachable
145: ; preds = %140
%146 = load i32, i32* %9
%147 = icmp slt i32 %146, 224
br i1 %147, label %148, label %149
148: ; preds = %145
br label %166
149: ; preds = %145
%150 = load i32, i32* %9
%151 = icmp slt i32 %150, 240
br i1 %151, label %152, label %153
152: ; preds = %149
br label %164
153: ; preds = %149
%154 = load i32, i32* %9
%155 = icmp slt i32 %154, 248
br i1 %155, label %156, label %157
156: ; preds = %153
br label %162
157: ; preds = %153
%158 = load i32, i32* %9
%159 = icmp slt i32 %158, 252
%160 = zext i1 %159 to i64
%161 = select i1 %159, i32 5, i32 6
br label %162
162: ; preds = %157, %156
%163 = phi i32 [ 4, %156 ], [ %161, %157 ]
br label %164
164: ; preds = %162, %152
%165 = phi i32 [ 3, %152 ], [ %163, %162 ]
br label %166
166: ; preds = %164, %148
%167 = phi i32 [ 2, %148 ], [ %165, %164 ]
store i32 %167, i32* %11
%168 = load i32, i32* %11
%169 = sub i32 8, %168
%170 = shl i32 1, %169
%171 = sub nsw i32 %170, 1
%172 = load i32, i32* %9
%173 = and i32 %172, %171
store i32 %173, i32* %9
br label %174
174: ; preds = %188, %166
%175 = load i32, i32* %11
%176 = add i32 %175, -1
store i32 %176, i32* %11
%177 = icmp ugt i32 %176, 0
br i1 %177, label %178, label %195
178: ; preds = %174
%179 = load i32, i32* @stdin
%180 = call i32 @getc(i32 %179)
store i32 %180, i32* %12
%181 = load i32, i32* %12
%182 = icmp sge i32 %181, 128
br i1 %182, label %183, label %186
183: ; preds = %178
%184 = load i32, i32* %12
%185 = icmp slt i32 %184, 192
br i1 %185, label %188, label %186
186: ; preds = %183, %178
%187 = call i32 @exit(i32 1)
unreachable
188: ; preds = %183
%189 = load i32, i32* %9
%190 = shl i32 %189, 6
store i32 %190, i32* %9
%191 = load i32, i32* %12
%192 = and i32 %191, 63
%193 = load i32, i32* %9
%194 = or i32 %193, %192
store i32 %194, i32* %9
br label %174
195: ; preds = %174
br label %196
196: ; preds = %195
br label %197
197: ; preds = %196, %137
%198 = load i32, i32* %9
%199 = load i32, i32* %8
%200 = add nsw i32 %199, 1
store i32 %200, i32* %8
%201 = sext i32 %199 to i64
%202 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %201
store i32 %198, i32* %202
br label %107
203: ; preds = %121
%204 = load i32, i32* %10
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %205
%207 = load i32, i32* %206
%208 = icmp sge i32 %207, 0
br i1 %208, label %209, label %223
209: ; preds = %203
%210 = load i32, i32* %8
%211 = load i32, i32* %10
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %212
%214 = load i32, i32* %213
%215 = sub nsw i32 %210, %214
%216 = sub nsw i32 %215, 1
%217 = load i32, i32* %10
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %218
%220 = load i32, i32* %219
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %221
store i32 %216, i32* %222
br label %223
223: ; preds = %209, %203
br label %224
224: ; preds = %234, %223
%225 = load i32, i32* @stdin
%226 = call i32 @getc(i32 %225)
store i32 %226, i32* %9
br label %227
227: ; preds = %224
%228 = load i32, i32* %9
%229 = load i32, i32* @EOF
%230 = icmp eq i32 %228, %229
br i1 %230, label %234, label %231
231: ; preds = %227
%232 = load i32, i32* %9
%233 = icmp eq i32 %232, 10
br label %234
234: ; preds = %231, %227
%235 = phi i1 [ true, %227 ], [ %233, %231 ]
%236 = xor i1 %235, true
br i1 %236, label %224, label %237
237: ; preds = %234
br label %66
238: ; preds = %72
%239 = load i32, i32* %8
%240 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.20, i64 0, i64 0), i32 %239)
store i32 0, i32* %13
br label %241
241: ; preds = %308, %238
%242 = load i32, i32* %13
%243 = load i32, i32* %8
%244 = icmp slt i32 %242, %243
br i1 %244, label %245, label %311
245: ; preds = %241
%246 = load i32, i32* %13
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %247
%249 = load i32, i32* %248
%250 = icmp ult i32 %249, 32
br i1 %250, label %251, label %257
251: ; preds = %245
%252 = load i32, i32* %13
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %253
%255 = load i32, i32* %254
%256 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.21, i64 0, i64 0), i32 %255)
br label %307
257: ; preds = %245
%258 = load i32, i32* %13
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %259
%261 = load i32, i32* %260
%262 = icmp eq i32 %261, 39
br i1 %262, label %263, label %265
263: ; preds = %257
%264 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0))
br label %306
265: ; preds = %257
%266 = load i32, i32* %13
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %267
%269 = load i32, i32* %268
%270 = icmp eq i32 %269, 92
br i1 %270, label %271, label %273
271: ; preds = %265
%272 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.23, i64 0, i64 0))
br label %305
273: ; preds = %265
%274 = load i32, i32* %13
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %275
%277 = load i32, i32* %276
%278 = icmp ult i32 %277, 127
br i1 %278, label %279, label %285
279: ; preds = %273
%280 = load i32, i32* %13
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %281
%283 = load i32, i32* %282
%284 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i64 0, i64 0), i32 %283)
br label %304
285: ; preds = %273
%286 = load i32, i32* %13
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %287
%289 = load i32, i32* %288
%290 = icmp ult i32 %289, 256
br i1 %290, label %291, label %297
291: ; preds = %285
%292 = load i32, i32* %13
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %293
%295 = load i32, i32* %294
%296 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.25, i64 0, i64 0), i32 %295)
br label %303
297: ; preds = %285
%298 = load i32, i32* %13
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %6, i64 0, i64 %299
%301 = load i32, i32* %300
%302 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.26, i64 0, i64 0), i32 %301)
br label %303
303: ; preds = %297, %291
br label %304
304: ; preds = %303, %279
br label %305
305: ; preds = %304, %271
br label %306
306: ; preds = %305, %263
br label %307
307: ; preds = %306, %251
br label %308
308: ; preds = %307
%309 = load i32, i32* %13
%310 = add nsw i32 %309, 1
store i32 %310, i32* %13
br label %241
311: ; preds = %241
%312 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.27, i64 0, i64 0))
%313 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i64 0, i64 0))
store i32 0, i32* %20
br label %314
314: ; preds = %321, %311
%315 = load i32, i32* %20
%316 = icmp slt i32 %315, 4352
br i1 %316, label %317, label %324
317: ; preds = %314
%318 = load i32, i32* %20
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds [4352 x i32], [4352 x i32]* %14, i64 0, i64 %319
store i32 0, i32* %320
br label %321
321: ; preds = %317
%322 = load i32, i32* %20
%323 = add nsw i32 %322, 1
store i32 %323, i32* %20
br label %314
324: ; preds = %314
store i32 0, i32* %19
br label %325
325: ; preds = %340, %324
%326 = load i32, i32* %19
%327 = icmp slt i32 %326, 1114112
br i1 %327, label %328, label %343
328: ; preds = %325
%329 = load i32, i32* %19
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %330
%332 = load i32, i32* %331
%333 = icmp sge i32 %332, 0
br i1 %333, label %334, label %339
334: ; preds = %328
%335 = load i32, i32* %19
%336 = ashr i32 %335, 8
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds [4352 x i32], [4352 x i32]* %14, i64 0, i64 %337
store i32 1, i32* %338
br label %339
339: ; preds = %334, %328
br label %340
340: ; preds = %339
%341 = load i32, i32* %19
%342 = add nsw i32 %341, 1
store i32 %342, i32* %19
br label %325
343: ; preds = %325
store i32 0, i32* %21
br label %344
344: ; preds = %378, %343
%345 = load i32, i32* %21
%346 = icmp slt i32 %345, 139264
br i1 %346, label %347, label %381
347: ; preds = %344
store i32 1, i32* %24
store i32 0, i32* %22
br label %348
348: ; preds = %363, %347
%349 = load i32, i32* %22
%350 = icmp slt i32 %349, 8
br i1 %350, label %351, label %366
351: ; preds = %348
%352 = load i32, i32* %21
%353 = mul nsw i32 8, %352
%354 = load i32, i32* %22
%355 = add nsw i32 %353, %354
store i32 %355, i32* %19
%356 = load i32, i32* %19
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %357
%359 = load i32, i32* %358
%360 = icmp sge i32 %359, 0
br i1 %360, label %361, label %362
361: ; preds = %351
store i32 0, i32* %24
br label %362
362: ; preds = %361, %351
br label %363
363: ; preds = %362
%364 = load i32, i32* %22
%365 = add nsw i32 %364, 1
store i32 %365, i32* %22
br label %348
366: ; preds = %348
%367 = load i32, i32* %24
%368 = icmp ne i32 %367, 0
br i1 %368, label %369, label %373
369: ; preds = %366
%370 = load i32, i32* %21
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds [139264 x i32], [139264 x i32]* %15, i64 0, i64 %371
store i32 -1, i32* %372
br label %377
373: ; preds = %366
%374 = load i32, i32* %21
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds [139264 x i32], [139264 x i32]* %15, i64 0, i64 %375
store i32 0, i32* %376
br label %377
377: ; preds = %373, %369
br label %378
378: ; preds = %377
%379 = load i32, i32* %21
%380 = add nsw i32 %379, 1
store i32 %380, i32* %21
br label %344
381: ; preds = %344
store i32 0, i32* %16
store i32 0, i32* %21
br label %382
382: ; preds = %460, %381
%383 = load i32, i32* %21
%384 = icmp slt i32 %383, 139264
br i1 %384, label %385, label %463
385: ; preds = %382
%386 = load i32, i32* %21
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds [139264 x i32], [139264 x i32]* %15, i64 0, i64 %387
%389 = load i32, i32* %388
%390 = icmp sge i32 %389, 0
br i1 %390, label %391, label %459
391: ; preds = %385
%392 = load i32, i32* %16
%393 = icmp sgt i32 %392, 0
br i1 %393, label %394, label %439
394: ; preds = %391
%395 = load i32, i32* %21
%396 = icmp sgt i32 %395, 0
br i1 %396, label %397, label %406
397: ; preds = %394
%398 = load i32, i32* %21
%399 = sub nsw i32 %398, 1
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds [139264 x i32], [139264 x i32]* %15, i64 0, i64 %400
%402 = load i32, i32* %401
%403 = load i32, i32* %16
%404 = sub nsw i32 %403, 1
%405 = icmp eq i32 %402, %404
br i1 %405, label %427, label %406
406: ; preds = %397, %394
%407 = load i32, i32* %16
%408 = sub nsw i32 %407, 1
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %409
%411 = getelementptr inbounds %struct.anon, %struct.anon* %410, i32 0, i32 1
%412 = load i32, i32* %411
%413 = ashr i32 %412, 5
%414 = load i32, i32* %21
%415 = ashr i32 %414, 5
%416 = icmp eq i32 %413, %415
br i1 %416, label %417, label %439
417: ; preds = %406
%418 = load i32, i32* %21
%419 = load i32, i32* %16
%420 = sub nsw i32 %419, 1
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %421
%423 = getelementptr inbounds %struct.anon, %struct.anon* %422, i32 0, i32 1
%424 = load i32, i32* %423
%425 = sub nsw i32 %418, %424
%426 = icmp sle i32 %425, 8
br i1 %426, label %427, label %439
427: ; preds = %417, %397
%428 = load i32, i32* %16
%429 = sub nsw i32 %428, 1
%430 = load i32, i32* %21
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds [139264 x i32], [139264 x i32]* %15, i64 0, i64 %431
store i32 %429, i32* %432
%433 = load i32, i32* %21
%434 = load i32, i32* %16
%435 = sub nsw i32 %434, 1
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %436
%438 = getelementptr inbounds %struct.anon, %struct.anon* %437, i32 0, i32 1
store i32 %433, i32* %438
br label %458
439: ; preds = %417, %406, %391
%440 = load i32, i32* %16
%441 = add nsw i32 %440, 1
store i32 %441, i32* %16
%442 = load i32, i32* %16
%443 = sub nsw i32 %442, 1
%444 = load i32, i32* %21
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds [139264 x i32], [139264 x i32]* %15, i64 0, i64 %445
store i32 %443, i32* %446
%447 = load i32, i32* %21
%448 = load i32, i32* %16
%449 = sub nsw i32 %448, 1
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %450
%452 = getelementptr inbounds %struct.anon, %struct.anon* %451, i32 0, i32 1
store i32 %447, i32* %452
%453 = load i32, i32* %16
%454 = sub nsw i32 %453, 1
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %455
%457 = getelementptr inbounds %struct.anon, %struct.anon* %456, i32 0, i32 0
store i32 %447, i32* %457
br label %458
458: ; preds = %439, %427
br label %459
459: ; preds = %458, %385
br label %460
460: ; preds = %459
%461 = load i32, i32* %21
%462 = add nsw i32 %461, 1
store i32 %462, i32* %21
br label %382
463: ; preds = %382
store i32 0, i32* %23
br label %464
464: ; preds = %509, %463
%465 = load i32, i32* %23
%466 = load i32, i32* %16
%467 = icmp slt i32 %465, %466
br i1 %467, label %468, label %512
468: ; preds = %464
%469 = load i32, i32* %23
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %470
%472 = getelementptr inbounds %struct.anon, %struct.anon* %471, i32 0, i32 2
store i32 0, i32* %472
%473 = load i32, i32* %23
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %474
%476 = getelementptr inbounds %struct.anon, %struct.anon* %475, i32 0, i32 0
%477 = load i32, i32* %476
%478 = mul nsw i32 8, %477
store i32 %478, i32* %21
%479 = load i32, i32* %23
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %480
%482 = getelementptr inbounds %struct.anon, %struct.anon* %481, i32 0, i32 1
%483 = load i32, i32* %482
%484 = add nsw i32 %483, 1
%485 = mul nsw i32 8, %484
store i32 %485, i32* %22
%486 = load i32, i32* %21
store i32 %486, i32* %19
br label %487
487: ; preds = %505, %468
%488 = load i32, i32* %19
%489 = load i32, i32* %22
%490 = icmp slt i32 %488, %489
br i1 %490, label %491, label %508
491: ; preds = %487
%492 = load i32, i32* %19
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %493
%495 = load i32, i32* %494
%496 = icmp sge i32 %495, 0
br i1 %496, label %497, label %504
497: ; preds = %491
%498 = load i32, i32* %23
%499 = sext i32 %498 to i64
%500 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %499
%501 = getelementptr inbounds %struct.anon, %struct.anon* %500, i32 0, i32 2
%502 = load i32, i32* %501
%503 = add nsw i32 %502, 1
store i32 %503, i32* %501
br label %504
504: ; preds = %497, %491
br label %505
505: ; preds = %504
%506 = load i32, i32* %19
%507 = add nsw i32 %506, 1
store i32 %507, i32* %19
br label %487
508: ; preds = %487
br label %509
509: ; preds = %508
%510 = load i32, i32* %23
%511 = add nsw i32 %510, 1
store i32 %511, i32* %23
br label %464
512: ; preds = %464
store i32 0, i32* %23
store i32 -1, i32* %20
store i32 0, i32* %18
br label %513
513: ; preds = %565, %512
%514 = load i32, i32* %23
%515 = load i32, i32* %16
%516 = icmp slt i32 %514, %515
br i1 %516, label %517, label %568
517: ; preds = %513
%518 = load i32, i32* %23
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %519
%521 = getelementptr inbounds %struct.anon, %struct.anon* %520, i32 0, i32 2
%522 = load i32, i32* %521
%523 = icmp sgt i32 %522, 1
br i1 %523, label %524, label %559
524: ; preds = %517
%525 = load i32, i32* %20
%526 = load i32, i32* %23
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %527
%529 = getelementptr inbounds %struct.anon, %struct.anon* %528, i32 0, i32 0
%530 = load i32, i32* %529
%531 = ashr i32 %530, 5
%532 = icmp eq i32 %525, %531
br i1 %532, label %533, label %541
533: ; preds = %524
%534 = call i64 @malloc(i32 6)
%535 = inttoptr i64 %534 to i8*
store i8* %535, i8** %25
%536 = load i8*, i8** %25
%537 = load i32, i32* %20
%538 = load i32, i32* %18
%539 = add nsw i32 %538, 1
store i32 %539, i32* %18
%540 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* %536, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.28, i64 0, i64 0), i32 %537, i32 %539)
br label %553
541: ; preds = %524
%542 = load i32, i32* %23
%543 = sext i32 %542 to i64
%544 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %543
%545 = getelementptr inbounds %struct.anon, %struct.anon* %544, i32 0, i32 0
%546 = load i32, i32* %545
%547 = ashr i32 %546, 5
store i32 %547, i32* %20
%548 = call i64 @malloc(i32 3)
%549 = inttoptr i64 %548 to i8*
store i8* %549, i8** %25
%550 = load i8*, i8** %25
%551 = load i32, i32* %20
%552 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* %550, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.29, i64 0, i64 0), i32 %551)
br label %553
553: ; preds = %541, %533
%554 = load i8*, i8** %25
%555 = load i32, i32* %23
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %556
%558 = getelementptr inbounds %struct.anon, %struct.anon* %557, i32 0, i32 3
store i8* %554, i8** %558
br label %564
559: ; preds = %517
%560 = load i32, i32* %23
%561 = sext i32 %560 to i64
%562 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %561
%563 = getelementptr inbounds %struct.anon, %struct.anon* %562, i32 0, i32 3
store i8* null, i8** %563
br label %564
564: ; preds = %559, %553
br label %565
565: ; preds = %564
%566 = load i32, i32* %23
%567 = add nsw i32 %566, 1
store i32 %567, i32* %23
br label %513
568: ; preds = %513
store i32 -1, i32* %20
store i32 0, i32* %23
br label %569
569: ; preds = %662, %568
%570 = load i32, i32* %23
%571 = load i32, i32* %16
%572 = icmp slt i32 %570, %571
br i1 %572, label %573, label %665
573: ; preds = %569
%574 = load i32, i32* %23
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %575
%577 = getelementptr inbounds %struct.anon, %struct.anon* %576, i32 0, i32 2
%578 = load i32, i32* %577
%579 = icmp sgt i32 %578, 1
br i1 %579, label %580, label %661
580: ; preds = %573
store i32 0, i32* %20
%581 = load i32, i32* %23
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %582
%584 = getelementptr inbounds %struct.anon, %struct.anon* %583, i32 0, i32 3
%585 = load i8*, i8** %584
%586 = load i32, i32* %23
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %587
%589 = getelementptr inbounds %struct.anon, %struct.anon* %588, i32 0, i32 1
%590 = load i32, i32* %589
%591 = load i32, i32* %23
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %592
%594 = getelementptr inbounds %struct.anon, %struct.anon* %593, i32 0, i32 0
%595 = load i32, i32* %594
%596 = sub nsw i32 %590, %595
%597 = add nsw i32 %596, 1
%598 = mul nsw i32 8, %597
%599 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.30, i64 0, i64 0), i8* %585, i32 %598)
%600 = load i32, i32* %23
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %601
%603 = getelementptr inbounds %struct.anon, %struct.anon* %602, i32 0, i32 0
%604 = load i32, i32* %603
store i32 %604, i32* %21
br label %605
605: ; preds = %656, %580
%606 = load i32, i32* %21
%607 = load i32, i32* %23
%608 = sext i32 %607 to i64
%609 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %608
%610 = getelementptr inbounds %struct.anon, %struct.anon* %609, i32 0, i32 1
%611 = load i32, i32* %610
%612 = icmp sle i32 %606, %611
br i1 %612, label %613, label %659
613: ; preds = %605
%614 = load i32, i32* %21
%615 = srem i32 %614, 32
%616 = icmp eq i32 %615, 0
br i1 %616, label %617, label %629
617: ; preds = %613
%618 = load i32, i32* %21
%619 = load i32, i32* %23
%620 = sext i32 %619 to i64
%621 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %620
%622 = getelementptr inbounds %struct.anon, %struct.anon* %621, i32 0, i32 0
%623 = load i32, i32* %622
%624 = icmp sgt i32 %618, %623
br i1 %624, label %625, label %629
625: ; preds = %617
%626 = load i32, i32* %21
%627 = mul nsw i32 8, %626
%628 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.31, i64 0, i64 0), i32 %627)
br label %629
629: ; preds = %625, %617, %613
%630 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.32, i64 0, i64 0))
store i32 0, i32* %22
br label %631
631: ; preds = %644, %629
%632 = load i32, i32* %22
%633 = icmp slt i32 %632, 8
br i1 %633, label %634, label %647
634: ; preds = %631
%635 = load i32, i32* %21
%636 = mul nsw i32 8, %635
%637 = load i32, i32* %22
%638 = add nsw i32 %636, %637
store i32 %638, i32* %19
%639 = load i32, i32* %19
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %640
%642 = load i32, i32* %641
%643 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0), i32 %642)
br label %644
644: ; preds = %634
%645 = load i32, i32* %22
%646 = add nsw i32 %645, 1
store i32 %646, i32* %22
br label %631
647: ; preds = %631
%648 = load i32, i32* %21
%649 = srem i32 %648, 32
%650 = mul nsw i32 8, %649
%651 = load i32, i32* %21
%652 = srem i32 %651, 32
%653 = mul nsw i32 8, %652
%654 = add nsw i32 %653, 7
%655 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.34, i64 0, i64 0), i32 %650, i32 %654)
br label %656
656: ; preds = %647
%657 = load i32, i32* %21
%658 = add nsw i32 %657, 1
store i32 %658, i32* %21
br label %605
659: ; preds = %605
%660 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.35, i64 0, i64 0))
br label %661
661: ; preds = %659, %573
br label %662
662: ; preds = %661
%663 = load i32, i32* %23
%664 = add nsw i32 %663, 1
store i32 %664, i32* %23
br label %569
665: ; preds = %569
%666 = load i32, i32* %20
%667 = icmp sge i32 %666, 0
br i1 %667, label %668, label %670
668: ; preds = %665
%669 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i64 0, i64 0))
br label %670
670: ; preds = %668, %665
%671 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.36, i64 0, i64 0))
store i32 0, i32* %21
br label %672
672: ; preds = %821, %670
%673 = load i32, i32* %21
%674 = icmp slt i32 %673, 139264
br i1 %674, label %675, label %823
675: ; preds = %672
%676 = load i32, i32* %21
%677 = sext i32 %676 to i64
%678 = getelementptr inbounds [139264 x i32], [139264 x i32]* %15, i64 0, i64 %677
%679 = load i32, i32* %678
store i32 %679, i32* %23
%680 = load i32, i32* %21
store i32 %680, i32* %22
br label %681
681: ; preds = %694, %675
%682 = load i32, i32* %22
%683 = icmp slt i32 %682, 139264
br i1 %683, label %684, label %691
684: ; preds = %681
%685 = load i32, i32* %22
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds [139264 x i32], [139264 x i32]* %15, i64 0, i64 %686
%688 = load i32, i32* %687
%689 = load i32, i32* %23
%690 = icmp eq i32 %688, %689
br label %691
691: ; preds = %684, %681
%692 = phi i1 [ false, %681 ], [ %690, %684 ]
br i1 %692, label %693, label %697
693: ; preds = %691
br label %694
694: ; preds = %693
%695 = load i32, i32* %22
%696 = add nsw i32 %695, 1
store i32 %696, i32* %22
br label %681
697: ; preds = %691
%698 = load i32, i32* %23
%699 = icmp sge i32 %698, 0
br i1 %699, label %700, label %728
700: ; preds = %697
%701 = load i32, i32* %21
%702 = load i32, i32* %23
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %703
%705 = getelementptr inbounds %struct.anon, %struct.anon* %704, i32 0, i32 0
%706 = load i32, i32* %705
%707 = icmp ne i32 %701, %706
br i1 %707, label %708, label %710
708: ; preds = %700
%709 = call i32 (...) @abort()
unreachable
710: ; preds = %700
%711 = load i32, i32* %22
%712 = load i32, i32* %23
%713 = sext i32 %712 to i64
%714 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %713
%715 = getelementptr inbounds %struct.anon, %struct.anon* %714, i32 0, i32 1
%716 = load i32, i32* %715
%717 = add nsw i32 %716, 1
%718 = icmp sgt i32 %711, %717
br i1 %718, label %719, label %721
719: ; preds = %710
%720 = call i32 (...) @abort()
unreachable
721: ; preds = %710
%722 = load i32, i32* %23
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %723
%725 = getelementptr inbounds %struct.anon, %struct.anon* %724, i32 0, i32 1
%726 = load i32, i32* %725
%727 = add nsw i32 %726, 1
store i32 %727, i32* %22
br label %728
728: ; preds = %721, %697
%729 = load i32, i32* %23
%730 = icmp eq i32 %729, -1
br i1 %730, label %731, label %732
731: ; preds = %728
br label %821
732: ; preds = %728
%733 = load i32, i32* %23
%734 = icmp sge i32 %733, 0
br i1 %734, label %735, label %744
735: ; preds = %732
%736 = load i32, i32* %23
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %737
%739 = getelementptr inbounds %struct.anon, %struct.anon* %738, i32 0, i32 2
%740 = load i32, i32* %739
%741 = icmp eq i32 %740, 0
br i1 %741, label %742, label %744
742: ; preds = %735
%743 = call i32 (...) @abort()
unreachable
744: ; preds = %735, %732
%745 = load i32, i32* %23
%746 = icmp sge i32 %745, 0
br i1 %746, label %747, label %787
747: ; preds = %744
%748 = load i32, i32* %23
%749 = sext i32 %748 to i64
%750 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %749
%751 = getelementptr inbounds %struct.anon, %struct.anon* %750, i32 0, i32 2
%752 = load i32, i32* %751
%753 = icmp eq i32 %752, 1
br i1 %753, label %754, label %787
754: ; preds = %747
%755 = load i32, i32* %22
%756 = load i32, i32* %21
%757 = add nsw i32 %756, 1
%758 = icmp ne i32 %755, %757
br i1 %758, label %759, label %761
759: ; preds = %754
%760 = call i32 (...) @abort()
unreachable
761: ; preds = %754
%762 = load i32, i32* %21
%763 = mul nsw i32 8, %762
store i32 %763, i32* %19
br label %764
764: ; preds = %783, %761
%765 = load i32, i32* %19
%766 = load i32, i32* %22
%767 = mul nsw i32 8, %766
%768 = icmp slt i32 %765, %767
br i1 %768, label %769, label %786
769: ; preds = %764
%770 = load i32, i32* %19
%771 = sext i32 %770 to i64
%772 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %771
%773 = load i32, i32* %772
%774 = icmp sge i32 %773, 0
br i1 %774, label %775, label %782
775: ; preds = %769
%776 = load i32, i32* %19
%777 = load i32, i32* %19
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %7, i64 0, i64 %778
%780 = load i32, i32* %779
%781 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.37, i64 0, i64 0), i32 %776, i32 %780)
br label %786
782: ; preds = %769
br label %783
783: ; preds = %782
%784 = load i32, i32* %19
%785 = add nsw i32 %784, 1
store i32 %785, i32* %19
br label %764
786: ; preds = %775, %764
br label %819
787: ; preds = %747, %744
%788 = load i32, i32* %21
%789 = icmp eq i32 %788, 0
br i1 %789, label %790, label %794
790: ; preds = %787
%791 = load i32, i32* %22
%792 = mul nsw i32 8, %791
%793 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.38, i64 0, i64 0), i32 %792)
br label %800
794: ; preds = %787
%795 = load i32, i32* %21
%796 = mul nsw i32 8, %795
%797 = load i32, i32* %22
%798 = mul nsw i32 8, %797
%799 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.39, i64 0, i64 0), i32 %796, i32 %798)
br label %800
800: ; preds = %794, %790
%801 = load i32, i32* %23
%802 = sext i32 %801 to i64
%803 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %802
%804 = getelementptr inbounds %struct.anon, %struct.anon* %803, i32 0, i32 3
%805 = load i8*, i8** %804
%806 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.40, i64 0, i64 0), i8* %805)
%807 = load i32, i32* %23
%808 = sext i32 %807 to i64
%809 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %17, i64 0, i64 %808
%810 = getelementptr inbounds %struct.anon, %struct.anon* %809, i32 0, i32 0
%811 = load i32, i32* %810
%812 = icmp sgt i32 %811, 0
br i1 %812, label %813, label %817
813: ; preds = %800
%814 = load i32, i32* %21
%815 = mul nsw i32 8, %814
%816 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.41, i64 0, i64 0), i32 %815)
br label %817
817: ; preds = %813, %800
%818 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %819
819: ; preds = %817, %786
%820 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.43, i64 0, i64 0))
br label %821
821: ; preds = %819, %731
%822 = load i32, i32* %22
store i32 %822, i32* %21
br label %672
823: ; preds = %672
%824 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.44, i64 0, i64 0))
%825 = load i32, i32* @stdout
%826 = call i64 @ferror(i32 %825)
%827 = icmp ne i64 %826, 0
br i1 %827, label %832, label %828
828: ; preds = %823
%829 = load i32, i32* @stdout
%830 = call i64 @fclose(i32 %829)
%831 = icmp ne i64 %830, 0
br i1 %831, label %832, label %834
832: ; preds = %828, %823
%833 = call i32 @exit(i32 1)
unreachable
834: ; preds = %828
%835 = call i32 @exit(i32 0)
unreachable
}

LLVM IR (-O2):
%struct.anon = type { i32, i32, i32, i8* }
@stdin = global i32 0
@EOF = global i32 0
@.str.19 = [3 x i8] c"%x\00"
@.str.20 = [48 x i8] c"static const unsigned int translit_data[%d] = {\00"
@.str.21 = [7 x i8] c"\0A %3d,\00"
@.str.22 = [6 x i8] c"'\\'',\00"
@.str.23 = [6 x i8] c"'\\\\',\00"
@.str.24 = [7 x i8] c" '%c',\00"
@.str.25 = [8 x i8] c"0x%02X,\00"
@.str.26 = [8 x i8] c"0x%04X,\00"
@.str.28 = [8 x i8] c"%02x_%d\00"
@.str.29 = [5 x i8] c"%02x\00"
@.str.30 = [44 x i8] c"static const short translit_page%s[%d] = {\0A\00"
@.str.31 = [16 x i8] c" /* 0x%04x */\0A\00"
@.str.33 = [6 x i8] c" %4d,\00"
@.str.34 = [22 x i8] c" /* 0x%02x-0x%02x */\0A\00"
@.str.36 = [33 x i8] c"#define translit_index(wc) \\\0A (\00"
@.str.37 = [18 x i8] c"wc == 0x%04x ? %d\00"
@.str.38 = [12 x i8] c"wc < 0x%04x\00"
@.str.39 = [28 x i8] c"wc >= 0x%04x && wc < 0x%04x\00"
@.str.40 = [22 x i8] c" ? translit_page%s[wc\00"
@.str.41 = [8 x i8] c"-0x%04x\00"
@.str.43 = [9 x i8] c" : \\\0A \00"
@stdout = global i32 0
@str.45 = [58 x i8] c" * Copyright (C) 1999-2003 Free Software Foundation, Inc.\00"
@str.46 = [50 x i8] c" * This file is part of the GNU LIBICONV Library.\00"
@str.48 = [70 x i8] c" * The GNU LIBICONV Library is free software; you can redistribute it\00"
@str.49 = [70 x i8] c" * and/or modify it under the terms of the GNU Library General Public\00"
@str.50 = [74 x i8] c" * License as published by the Free Software Foundation; either version 2\00"
@str.51 = [58 x i8] c" * of the License, or (at your option) any later version.\00"
@str.53 = [71 x i8] c" * The GNU LIBICONV Library is distributed in the hope that it will be\00"
@str.54 = [74 x i8] c" * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of\00"
@str.55 = [69 x i8] c" * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\00"
@str.56 = [52 x i8] c" * Library General Public License for more details.\00"
@str.57 = [3 x i8] c" *\00"
@str.58 = [69 x i8] c" * You should have received a copy of the GNU Library General Public\00"
@str.59 = [74 x i8] c" * License along with the GNU LIBICONV Library; see the file COPYING.LIB.\00"
@str.60 = [76 x i8] c" * If not, write to the Free Software Foundation, Inc., 51 Franklin Street,\00"
@str.61 = [44 x i8] c" * Fifth Floor, Boston, MA 02110-1301, USA.\00"
@str.63 = [3 x i8] c"/*\00"
@str.64 = [25 x i8] c" * Transliteration table\00"
@str.65 = [4 x i8] c" */\00"
@str.66 = [4 x i8] c"\0A};\00"
@str.67 = [4 x i8] c"-1)\00"
@str.68 = [3 x i8] c"};\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca [1048576 x i32]
%4 = alloca [1114112 x i32]
%5 = bitcast [1114112 x i32]* %4 to i8*
%6 = alloca i32
%7 = alloca [139264 x i32]
%8 = alloca [8192 x %struct.anon]
%9 = bitcast [1048576 x i32]* %3 to i8*
%10 = icmp eq i32 %0, 1
br i1 %10, label %13, label %11
11: ; preds = %2
%12 = tail call i32 @exit(i32 1)
unreachable
13: ; preds = %2
%14 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.63, i64 0, i64 0))
%15 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([58 x i8], [58 x i8]* @str.45, i64 0, i64 0))
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @str.46, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.57, i64 0, i64 0))
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([70 x i8], [70 x i8]* @str.48, i64 0, i64 0))
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([70 x i8], [70 x i8]* @str.49, i64 0, i64 0))
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @str.50, i64 0, i64 0))
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([58 x i8], [58 x i8]* @str.51, i64 0, i64 0))
%22 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.57, i64 0, i64 0))
%23 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @str.53, i64 0, i64 0))
%24 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @str.54, i64 0, i64 0))
%25 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @str.55, i64 0, i64 0))
%26 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @str.56, i64 0, i64 0))
%27 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.57, i64 0, i64 0))
%28 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @str.58, i64 0, i64 0))
%29 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @str.59, i64 0, i64 0))
%30 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([76 x i8], [76 x i8]* @str.60, i64 0, i64 0))
%31 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @str.61, i64 0, i64 0))
%32 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.65, i64 0, i64 0))
%33 = tail call i32 @putchar(i32 10)
%34 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.63, i64 0, i64 0))
%35 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str.64, i64 0, i64 0))
%36 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.65, i64 0, i64 0))
%37 = tail call i32 @putchar(i32 10)
%38 = bitcast i32* %6 to i8*
store i32 1114112, i32* %6
%39 = load i32, i32* @stdin
%40 = call i32 @getc(i32 %39)
%41 = load i32, i32* @EOF
%42 = icmp eq i32 %40, %41
br i1 %42, label %43, label %55
43: ; preds = %13
%44 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.20, i64 0, i64 0), i32 0)
br label %199
45: ; preds = %61
%46 = load i32, i32* @stdin
%47 = call i32 @getc(i32 %46)
%48 = load i32, i32* @EOF
%49 = icmp eq i32 %47, %48
br i1 %49, label %168, label %58
50: ; preds = %161
%51 = load i32, i32* @stdin
%52 = call i32 @getc(i32 %51)
%53 = load i32, i32* @EOF
%54 = icmp eq i32 %52, %53
br i1 %54, label %168, label %55
55: ; preds = %13, %50
%56 = phi i32 [ %52, %50 ], [ %40, %13 ]
%57 = phi i32 [ %92, %50 ], [ 0, %13 ]
br label %58
58: ; preds = %55, %45
%59 = phi i32 [ %56, %55 ], [ %47, %45 ]
%60 = icmp eq i32 %59, 35
br i1 %60, label %61, label %68
61: ; preds = %58, %61
%62 = load i32, i32* @stdin
%63 = call i32 @getc(i32 %62)
%64 = load i32, i32* @EOF
%65 = icmp ne i32 %63, %64
%66 = icmp ne i32 %63, 10
%67 = and i1 %66, %65
br i1 %67, label %61, label %45
68: ; preds = %58
%69 = load i32, i32* @stdin
%70 = call i32 @ungetc(i32 %59, i32 %69)
%71 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.19, i64 0, i64 0), i32* %6)
%72 = icmp eq i32 %71, 1
br i1 %72, label %75, label %73
73: ; preds = %68
%74 = call i32 @exit(i32 1)
unreachable
75: ; preds = %68
%76 = load i32, i32* @stdin
%77 = call i32 @getc(i32 %76)
%78 = icmp eq i32 %77, 9
br i1 %78, label %79, label %86
79: ; preds = %75
%80 = load i32, i32* @stdin
%81 = call i32 @getc(i32 %80)
%82 = load i32, i32* @EOF
%83 = icmp eq i32 %81, %82
%84 = icmp eq i32 %81, 10
%85 = or i1 %84, %83
br i1 %85, label %88, label %90
86: ; preds = %75
%87 = call i32 @exit(i32 1)
unreachable
88: ; preds = %79, %142
%89 = call i32 @exit(i32 1)
unreachable
90: ; preds = %79, %142
%91 = phi i32 [ %148, %142 ], [ %81, %79 ]
%92 = phi i32 [ %144, %142 ], [ %57, %79 ]
%93 = icmp eq i32 %91, 9
%94 = load i32, i32* %6
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %95
%97 = load i32, i32* %96
br i1 %93, label %153, label %98
98: ; preds = %90
%99 = icmp slt i32 %97, 0
br i1 %99, label %100, label %104
100: ; preds = %98
store i32 %92, i32* %96
%101 = add nsw i32 %92, 1
%102 = sext i32 %92 to i64
%103 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %3, i64 0, i64 %102
store i32 0, i32* %103
br label %104
104: ; preds = %100, %98
%105 = phi i32 [ %101, %100 ], [ %92, %98 ]
%106 = icmp sgt i32 %91, 127
br i1 %106, label %107, label %142
107: ; preds = %104
%108 = icmp ult i32 %91, 192
br i1 %108, label %109, label %111
109: ; preds = %107
%110 = call i32 @exit(i32 1)
unreachable
111: ; preds = %107
%112 = icmp ult i32 %91, 224
br i1 %112, label %120, label %113
113: ; preds = %111
%114 = icmp ult i32 %91, 240
br i1 %114, label %120, label %115
115: ; preds = %113
%116 = icmp ult i32 %91, 248
br i1 %116, label %120, label %117
117: ; preds = %115
%118 = icmp ult i32 %91, 252
%119 = select i1 %118, i32 5, i32 6
br label %120
120: ; preds = %111, %117, %115, %113
%121 = phi i32 [ 2, %111 ], [ 3, %113 ], [ %119, %117 ], [ 4, %115 ]
%122 = sub nuw nsw i32 8, %121
%123 = shl nsw i32 -1, %122
%124 = xor i32 %123, -1
%125 = and i32 %91, %124
%126 = add nsw i32 %121, -1
br label %127
127: ; preds = %120, %136
%128 = phi i32 [ %140, %136 ], [ %126, %120 ]
%129 = phi i32 [ %139, %136 ], [ %125, %120 ]
%130 = load i32, i32* @stdin
%131 = call i32 @getc(i32 %130)
%132 = and i32 %131, -64
%133 = icmp eq i32 %132, 128
br i1 %133, label %136, label %134
134: ; preds = %127
%135 = call i32 @exit(i32 1)
unreachable
136: ; preds = %127
%137 = shl i32 %129, 6
%138 = and i32 %131, 63
%139 = or i32 %138, %137
%140 = add nsw i32 %128, -1
%141 = icmp eq i32 %140, 0
br i1 %141, label %142, label %127
142: ; preds = %136, %104
%143 = phi i32 [ %91, %104 ], [ %139, %136 ]
%144 = add nsw i32 %105, 1
%145 = sext i32 %105 to i64
%146 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %3, i64 0, i64 %145
store i32 %143, i32* %146
%147 = load i32, i32* @stdin
%148 = call i32 @getc(i32 %147)
%149 = load i32, i32* @EOF
%150 = icmp eq i32 %148, %149
%151 = icmp eq i32 %148, 10
%152 = or i1 %151, %150
br i1 %152, label %88, label %90
153: ; preds = %90
%154 = icmp sgt i32 %97, -1
br i1 %154, label %155, label %160
155: ; preds = %153
%156 = xor i32 %97, -1
%157 = add i32 %92, %156
%158 = zext i32 %97 to i64
%159 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %3, i64 0, i64 %158
store i32 %157, i32* %159
br label %160
160: ; preds = %155, %153
br label %161
161: ; preds = %160, %161
%162 = load i32, i32* @stdin
%163 = call i32 @getc(i32 %162)
%164 = load i32, i32* @EOF
%165 = icmp ne i32 %163, %164
%166 = icmp ne i32 %163, 10
%167 = and i1 %166, %165
br i1 %167, label %161, label %50
168: ; preds = %50, %45
%169 = phi i32 [ %57, %45 ], [ %92, %50 ]
%170 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.20, i64 0, i64 0), i32 %169)
%171 = icmp sgt i32 %169, 0
br i1 %171, label %172, label %199
172: ; preds = %168
%173 = zext i32 %169 to i64
br label %174
174: ; preds = %172, %196
%175 = phi i64 [ 0, %172 ], [ %197, %196 ]
%176 = getelementptr inbounds [1048576 x i32], [1048576 x i32]* %3, i64 0, i64 %175
%177 = load i32, i32* %176
%178 = icmp ult i32 %177, 32
br i1 %178, label %179, label %181
179: ; preds = %174
%180 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.21, i64 0, i64 0), i32 %177)
br label %196
181: ; preds = %174
switch i32 %177, label %186 [
i32 39, label %182
i32 92, label %184
]
182: ; preds = %181
%183 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.22, i64 0, i64 0))
br label %196
184: ; preds = %181
%185 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.23, i64 0, i64 0))
br label %196
186: ; preds = %181
%187 = icmp ult i32 %177, 127
br i1 %187, label %188, label %190
188: ; preds = %186
%189 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.24, i64 0, i64 0), i32 %177)
br label %196
190: ; preds = %186
%191 = icmp ult i32 %177, 256
br i1 %191, label %192, label %194
192: ; preds = %190
%193 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.25, i64 0, i64 0), i32 %177)
br label %196
194: ; preds = %190
%195 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.26, i64 0, i64 0), i32 %177)
br label %196
196: ; preds = %179, %184, %192, %194, %188, %182
%197 = add nuw nsw i64 %175, 1
%198 = icmp eq i64 %197, %173
br i1 %198, label %199, label %174
199: ; preds = %196, %43, %168
%200 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.66, i64 0, i64 0))
%201 = call i32 @putchar(i32 10)
%202 = bitcast [139264 x i32]* %7 to i8*
%203 = bitcast [8192 x %struct.anon]* %8 to i8*
br label %204
204: ; preds = %199, %204
%205 = phi i64 [ 0, %199 ], [ %228, %204 ]
%206 = shl nsw i64 %205, 3
%207 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %206
%208 = bitcast i32* %207 to <8 x i32>*
%209 = load <8 x i32>, <8 x i32>* %208
%210 = icmp slt <8 x i32> %209, zeroinitializer
%211 = extractelement <8 x i1> %210, i64 6
%212 = extractelement <8 x i1> %210, i64 7
%213 = select i1 %212, i1 %211, i1 false
%214 = extractelement <8 x i1> %210, i64 5
%215 = select i1 %213, i1 %214, i1 false
%216 = extractelement <8 x i1> %210, i64 4
%217 = select i1 %215, i1 %216, i1 false
%218 = extractelement <8 x i1> %210, i64 3
%219 = select i1 %217, i1 %218, i1 false
%220 = extractelement <8 x i1> %210, i64 2
%221 = select i1 %219, i1 %220, i1 false
%222 = extractelement <8 x i1> %210, i64 1
%223 = select i1 %221, i1 %222, i1 false
%224 = extractelement <8 x i1> %210, i64 0
%225 = select i1 %223, i1 %224, i1 false
%226 = sext i1 %225 to i32
%227 = getelementptr inbounds [139264 x i32], [139264 x i32]* %7, i64 0, i64 %205
store i32 %226, i32* %227
%228 = add nuw nsw i64 %205, 1
%229 = icmp eq i64 %228, 139264
br i1 %229, label %230, label %204
230: ; preds = %204
%231 = getelementptr inbounds [139264 x i32], [139264 x i32]* %7, i64 0, i64 0
%232 = load i32, i32* %231
%233 = icmp sgt i32 %232, -1
br i1 %233, label %234, label %237
234: ; preds = %230
store i32 0, i32* %231
%235 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 0, i32 1
store i32 0, i32* %235
%236 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 0, i32 0
store i32 0, i32* %236
br label %237
237: ; preds = %230, %234
%238 = phi i32 [ 0, %234 ], [ %232, %230 ]
%239 = phi i32 [ 1, %234 ], [ 0, %230 ]
br label %244
240: ; preds = %283
%241 = icmp sgt i32 %284, 0
br i1 %241, label %242, label %443
242: ; preds = %240
%243 = zext i32 %284 to i64
br label %290
244: ; preds = %237, %283
%245 = phi i64 [ 1, %237 ], [ %285, %283 ]
%246 = phi i32 [ %239, %237 ], [ %284, %283 ]
%247 = getelementptr inbounds [139264 x i32], [139264 x i32]* %7, i64 0, i64 %245
%248 = load i32, i32* %247
%249 = icmp sgt i32 %248, -1
br i1 %249, label %250, label %283
250: ; preds = %244
%251 = icmp sgt i32 %246, 0
br i1 %251, label %254, label %252
252: ; preds = %250
%253 = trunc i64 %245 to i32
br label %277
254: ; preds = %250
%255 = add nuw i64 %245, 4294967295
%256 = and i64 %255, 4294967295
%257 = getelementptr inbounds [139264 x i32], [139264 x i32]* %7, i64 0, i64 %256
%258 = load i32, i32* %257
%259 = add nsw i32 %246, -1
%260 = icmp eq i32 %258, %259
%261 = zext i32 %259 to i64
br i1 %260, label %262, label %264
262: ; preds = %254
%263 = trunc i64 %245 to i32
br label %274
264: ; preds = %254
%265 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %261, i32 1
%266 = load i32, i32* %265
%267 = ashr i32 %266, 5
%268 = trunc i64 %245 to i32
%269 = lshr i32 %268, 5
%270 = icmp eq i32 %267, %269
%271 = sub nsw i32 %268, %266
%272 = icmp slt i32 %271, 9
%273 = select i1 %270, i1 %272, i1 false
br i1 %273, label %274, label %277
274: ; preds = %262, %264
%275 = phi i32 [ %263, %262 ], [ %268, %264 ]
store i32 %259, i32* %247
%276 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %261, i32 1
store i32 %275, i32* %276
br label %283
277: ; preds = %252, %264
%278 = phi i32 [ %253, %252 ], [ %268, %264 ]
%279 = add nsw i32 %246, 1
store i32 %246, i32* %247
%280 = sext i32 %246 to i64
%281 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %280, i32 1
store i32 %278, i32* %281
%282 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %280, i32 0
store i32 %278, i32* %282
br label %283
283: ; preds = %244, %277, %274
%284 = phi i32 [ %246, %274 ], [ %279, %277 ], [ %246, %244 ]
%285 = add nuw nsw i64 %245, 1
%286 = icmp eq i64 %285, 139264
br i1 %286, label %240, label %244
287: ; preds = %324
br i1 %241, label %288, label %443
288: ; preds = %287
%289 = zext i32 %284 to i64
br label %330
290: ; preds = %242, %324
%291 = phi i64 [ 0, %242 ], [ %325, %324 ]
%292 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %291, i32 2
store i32 0, i32* %292
%293 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %291, i32 0
%294 = load i32, i32* %293
%295 = shl i32 %294, 3
%296 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %291, i32 1
%297 = load i32, i32* %296
%298 = shl i32 %297, 3
%299 = add i32 %298, 8
%300 = icmp slt i32 %295, %299
br i1 %300, label %301, label %324
301: ; preds = %290
%302 = sext i32 %295 to i64
%303 = sext i32 %299 to i64
br label %304
304: ; preds = %320, %301
%305 = phi i32 [ 0, %301 ], [ %321, %320 ]
%306 = phi i64 [ %302, %301 ], [ %322, %320 ]
%307 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %306
%308 = load i32, i32* %307
%309 = icmp sgt i32 %308, -1
br i1 %309, label %310, label %312
310: ; preds = %304
%311 = add nsw i32 %305, 1
store i32 %311, i32* %292
br label %312
312: ; preds = %304, %310
%313 = phi i32 [ %305, %304 ], [ %311, %310 ]
%314 = or i64 %306, 1
%315 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %314
%316 = load i32, i32* %315
%317 = icmp sgt i32 %316, -1
br i1 %317, label %318, label %320
318: ; preds = %312
%319 = add nsw i32 %313, 1
store i32 %319, i32* %292
br label %320
320: ; preds = %318, %312
%321 = phi i32 [ %313, %312 ], [ %319, %318 ]
%322 = add nsw i64 %306, 2
%323 = icmp eq i64 %322, %303
br i1 %323, label %324, label %304
324: ; preds = %320, %290
%325 = add nuw nsw i64 %291, 1
%326 = icmp eq i64 %325, %243
br i1 %326, label %287, label %290
327: ; preds = %351
br i1 %241, label %328, label %443
328: ; preds = %327
%329 = zext i32 %284 to i64
br label %358
330: ; preds = %288, %351
%331 = phi i64 [ 0, %288 ], [ %356, %351 ]
%332 = phi i32 [ -1, %288 ], [ %354, %351 ]
%333 = phi i32 [ 0, %288 ], [ %353, %351 ]
%334 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %331, i32 2
%335 = load i32, i32* %334
%336 = icmp sgt i32 %335, 1
br i1 %336, label %337, label %351
337: ; preds = %330
%338 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %331, i32 0
%339 = load i32, i32* %338
%340 = ashr i32 %339, 5
%341 = icmp eq i32 %332, %340
br i1 %341, label %342, label %347
342: ; preds = %337
%343 = call i64 @malloc(i32 6)
%344 = inttoptr i64 %343 to i8*
%345 = add nsw i32 %333, 1
%346 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* dereferenceable(1) %344, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.28, i64 0, i64 0), i32 %332, i32 %345)
br label %351
347: ; preds = %337
%348 = call i64 @malloc(i32 3)
%349 = inttoptr i64 %348 to i8*
%350 = call i32 (i8*, i8*, i32, ...) @sprintf(i8* dereferenceable(1) %349, i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.29, i64 0, i64 0), i32 %340)
br label %351
351: ; preds = %330, %342, %347
%352 = phi i8* [ %344, %342 ], [ %349, %347 ], [ null, %330 ]
%353 = phi i32 [ %345, %342 ], [ %333, %347 ], [ %333, %330 ]
%354 = phi i32 [ %332, %342 ], [ %340, %347 ], [ %332, %330 ]
%355 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %331, i32 3
store i8* %352, i8** %355
%356 = add nuw nsw i64 %331, 1
%357 = icmp eq i64 %356, %289
br i1 %357, label %327, label %330
358: ; preds = %328, %435
%359 = phi i64 [ 0, %328 ], [ %437, %435 ]
%360 = phi i32 [ -1, %328 ], [ %436, %435 ]
%361 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %359, i32 2
%362 = load i32, i32* %361
%363 = icmp sgt i32 %362, 1
br i1 %363, label %364, label %435
364: ; preds = %358
%365 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %359, i32 3
%366 = load i8*, i8** %365
%367 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %359, i32 1
%368 = load i32, i32* %367
%369 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %359, i32 0
%370 = load i32, i32* %369
%371 = sub nsw i32 %368, %370
%372 = shl i32 %371, 3
%373 = add i32 %372, 8
%374 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.30, i64 0, i64 0), i8* %366, i32 %373)
%375 = load i32, i32* %367
%376 = icmp sgt i32 %370, %375
br i1 %376, label %433, label %377
377: ; preds = %364
%378 = sext i32 %370 to i64
br label %379
379: ; preds = %377, %391
%380 = phi i64 [ %378, %377 ], [ %429, %391 ]
%381 = trunc i64 %380 to i32
%382 = srem i32 %381, 32
%383 = icmp eq i32 %382, 0
br i1 %383, label %384, label %391
384: ; preds = %379
%385 = load i32, i32* %369
%386 = sext i32 %385 to i64
%387 = icmp sgt i64 %380, %386
br i1 %387, label %388, label %391
388: ; preds = %384
%389 = shl nsw i32 %381, 3
%390 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.31, i64 0, i64 0), i32 %389)
br label %391
391: ; preds = %388, %384, %379
%392 = call i32 @putchar(i32 32)
%393 = shl nsw i32 %381, 3
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %394
%396 = load i32, i32* %395
%397 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0), i32 %396)
%398 = or i64 %394, 1
%399 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %398
%400 = load i32, i32* %399
%401 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0), i32 %400)
%402 = or i64 %394, 2
%403 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %402
%404 = load i32, i32* %403
%405 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0), i32 %404)
%406 = or i64 %394, 3
%407 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %406
%408 = load i32, i32* %407
%409 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0), i32 %408)
%410 = or i64 %394, 4
%411 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %410
%412 = load i32, i32* %411
%413 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0), i32 %412)
%414 = or i64 %394, 5
%415 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %414
%416 = load i32, i32* %415
%417 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0), i32 %416)
%418 = or i64 %394, 6
%419 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %418
%420 = load i32, i32* %419
%421 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0), i32 %420)
%422 = or i64 %394, 7
%423 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %422
%424 = load i32, i32* %423
%425 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0), i32 %424)
%426 = shl nsw i32 %382, 3
%427 = or i32 %426, 7
%428 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.34, i64 0, i64 0), i32 %426, i32 %427)
%429 = add nsw i64 %380, 1
%430 = load i32, i32* %367
%431 = sext i32 %430 to i64
%432 = icmp slt i64 %380, %431
br i1 %432, label %379, label %433
433: ; preds = %391, %364
%434 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.68, i64 0, i64 0))
br label %435
435: ; preds = %358, %433
%436 = phi i32 [ 0, %433 ], [ %360, %358 ]
%437 = add nuw nsw i64 %359, 1
%438 = icmp eq i64 %437, %329
br i1 %438, label %439, label %358
439: ; preds = %435
%440 = icmp sgt i32 %436, -1
br i1 %440, label %441, label %443
441: ; preds = %439
%442 = call i32 @putchar(i32 10)
br label %443
443: ; preds = %240, %287, %327, %441, %439
%444 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.36, i64 0, i64 0))
br label %445
445: ; preds = %443, %551
%446 = phi i32 [ %238, %443 ], [ %554, %551 ]
%447 = phi i32 [ 0, %443 ], [ %549, %551 ]
%448 = sext i32 %447 to i64
br label %449
449: ; preds = %445, %453
%450 = phi i64 [ %448, %445 ], [ %451, %453 ]
%451 = add nsw i64 %450, 1
%452 = icmp eq i64 %451, 139264
br i1 %452, label %459, label %453
453: ; preds = %449
%454 = getelementptr inbounds [139264 x i32], [139264 x i32]* %7, i64 0, i64 %451
%455 = load i32, i32* %454
%456 = icmp eq i32 %455, %446
br i1 %456, label %449, label %457
457: ; preds = %453
%458 = trunc i64 %451 to i32
br label %459
459: ; preds = %449, %457
%460 = phi i32 [ %458, %457 ], [ 139264, %449 ]
%461 = icmp sgt i32 %446, -1
br i1 %461, label %462, label %476
462: ; preds = %459
%463 = zext i32 %446 to i64
%464 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %463, i32 0
%465 = load i32, i32* %464
%466 = icmp eq i32 %447, %465
br i1 %466, label %469, label %467
467: ; preds = %462
%468 = call i32 (...) @abort()
unreachable
469: ; preds = %462
%470 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %463, i32 1
%471 = load i32, i32* %470
%472 = add nsw i32 %471, 1
%473 = icmp sgt i32 %460, %472
br i1 %473, label %474, label %478
474: ; preds = %469
%475 = call i32 (...) @abort()
unreachable
476: ; preds = %459
%477 = icmp eq i32 %446, -1
br i1 %477, label %548, label %522
478: ; preds = %469
%479 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %463, i32 2
%480 = load i32, i32* %479
switch i32 %480, label %522 [
i32 0, label %481
i32 1, label %483
]
481: ; preds = %478
%482 = call i32 (...) @abort()
unreachable
483: ; preds = %478
%484 = icmp eq i32 %471, %447
br i1 %484, label %487, label %485
485: ; preds = %483
%486 = call i32 (...) @abort()
unreachable
487: ; preds = %483
%488 = shl i32 %447, 3
%489 = shl i32 %472, 3
%490 = icmp slt i32 %488, %489
br i1 %490, label %491, label %545
491: ; preds = %487
%492 = sext i32 %488 to i64
br label %493
493: ; preds = %518, %491
%494 = phi i64 [ %492, %491 ], [ %519, %518 ]
%495 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %494
%496 = load i32, i32* %495
%497 = icmp sgt i32 %496, -1
br i1 %497, label %498, label %503
498: ; preds = %513, %508, %503, %493
%499 = phi i64 [ %494, %493 ], [ %504, %503 ], [ %509, %508 ], [ %514, %513 ]
%500 = phi i32 [ %496, %493 ], [ %506, %503 ], [ %511, %508 ], [ %516, %513 ]
%501 = trunc i64 %499 to i32
%502 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.37, i64 0, i64 0), i32 %501, i32 %500)
br label %545
503: ; preds = %493
%504 = or i64 %494, 1
%505 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %504
%506 = load i32, i32* %505
%507 = icmp sgt i32 %506, -1
br i1 %507, label %498, label %508
508: ; preds = %503
%509 = or i64 %494, 2
%510 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %509
%511 = load i32, i32* %510
%512 = icmp sgt i32 %511, -1
br i1 %512, label %498, label %513
513: ; preds = %508
%514 = or i64 %494, 3
%515 = getelementptr inbounds [1114112 x i32], [1114112 x i32]* %4, i64 0, i64 %514
%516 = load i32, i32* %515
%517 = icmp sgt i32 %516, -1
br i1 %517, label %498, label %518
518: ; preds = %513
%519 = add nsw i64 %494, 4
%520 = trunc i64 %519 to i32
%521 = icmp eq i32 %489, %520
br i1 %521, label %545, label %493
522: ; preds = %478, %476
%523 = phi i32 [ %460, %476 ], [ %472, %478 ]
%524 = icmp eq i32 %447, 0
br i1 %524, label %525, label %528
525: ; preds = %522
%526 = shl nsw i32 %523, 3
%527 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.38, i64 0, i64 0), i32 %526)
br label %532
528: ; preds = %522
%529 = shl nsw i32 %447, 3
%530 = shl nsw i32 %523, 3
%531 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @.str.39, i64 0, i64 0), i32 %529, i32 %530)
br label %532
532: ; preds = %528, %525
%533 = sext i32 %446 to i64
%534 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %533, i32 3
%535 = load i8*, i8** %534
%536 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.40, i64 0, i64 0), i8* %535)
%537 = getelementptr inbounds [8192 x %struct.anon], [8192 x %struct.anon]* %8, i64 0, i64 %533, i32 0
%538 = load i32, i32* %537
%539 = icmp sgt i32 %538, 0
br i1 %539, label %540, label %543
540: ; preds = %532
%541 = shl nsw i32 %447, 3
%542 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.41, i64 0, i64 0), i32 %541)
br label %543
543: ; preds = %540, %532
%544 = call i32 @putchar(i32 93)
br label %545
545: ; preds = %518, %487, %498, %543
%546 = phi i32 [ %472, %498 ], [ %523, %543 ], [ %472, %487 ], [ %472, %518 ]
%547 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.43, i64 0, i64 0))
br label %548
548: ; preds = %476, %545
%549 = phi i32 [ %460, %476 ], [ %546, %545 ]
%550 = icmp slt i32 %549, 139264
br i1 %550, label %551, label %555
551: ; preds = %548
%552 = sext i32 %549 to i64
%553 = getelementptr inbounds [139264 x i32], [139264 x i32]* %7, i64 0, i64 %552
%554 = load i32, i32* %553
br label %445
555: ; preds = %548
%556 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.67, i64 0, i64 0))
%557 = load i32, i32* @stdout
%558 = call i64 @ferror(i32 %557)
%559 = icmp eq i64 %558, 0
br i1 %559, label %560, label %564
560: ; preds = %555
%561 = load i32, i32* @stdout
%562 = call i64 @fclose(i32 %561)
%563 = icmp eq i64 %562, 0
br i1 %563, label %566, label %564
564: ; preds = %560, %555
%565 = call i32 @exit(i32 1)
unreachable
566: ; preds = %560
%567 = call i32 @exit(i32 0)
unreachable
}