#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);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int, int, int, int);
int getc(int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, ...);
int scanf(char *, ...);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ stdin;
int /*<<< orphan*/ ungetc(int, int /*<<< orphan*/);
void do_gb18030uni(const char *name) {
  int c;
  unsigned int bytes;
  int i1, i2, i3, i4, i, j, k;
  int charset2uni[4 * 10 * 126 * 10];
  int uni2charset[0x10000];
  struct {
    int low;
    int high;
    int diff;
    int total;
  } ranges[256];
  int ranges_count, ranges_total;
  for (i = 0; i < 4 * 10 * 126 * 10; i++)
    charset2uni[i] = 0;
  for (j = 0; j < 0x10000; j++)
    uni2charset[j] = 0;
  for (;;) {
    c = getc(stdin);
    if (c == EOF)
      break;
    if (c == '\n' || c == ' ' || c == '\t')
      continue;
    if (c == '#') {
      do {
        c = getc(stdin);
      } while (!(c == EOF || c == '\n'));
      continue;
    }
    ungetc(c, stdin);
    if (scanf("0x%x", &bytes) != 1)
      exit(1);
    i1 = (bytes >> 24) & 0xff;
    i2 = (bytes >> 16) & 0xff;
    i3 = (bytes >> 8) & 0xff;
    i4 = bytes & 0xff;
    if (!(i1 >= 0x81 && i1 <= 0x84 && i2 >= 0x30 && i2 <= 0x39 && i3 >= 0x81 &&
          i3 <= 0xfe && i4 >= 0x30 && i4 <= 0x39)) {
      fprintf(stderr, "lost entry for %02x %02x %02x %02x\n", i1, i2, i3, i4);
      exit(1);
    }
    i = (((i1 - 0x81) * 10 + (i2 - 0x30)) * 126 + (i3 - 0x81)) * 10 +
        (i4 - 0x30);
    if (scanf(" 0x%x", &j) != 1)
      exit(1);
    if (!(j >= 0 && j < 0x10000))
      exit(1);
    charset2uni[i] = j;
    uni2charset[j] = i;
  }
  ranges_count = 0;
  for (i = 0; i < 4 * 10 * 126 * 10; i++)
    if (charset2uni[i] != 0) {
      int diff;
      j = charset2uni[i];
      diff = j - i;
      if (ranges_count > 0) {
        if (!(i > ranges[ranges_count - 1].high))
          exit(1);
        if (!(j >
              ranges[ranges_count - 1].high + ranges[ranges_count - 1].diff))
          exit(1);
        if (!(diff >= ranges[ranges_count - 1].diff))
          exit(1);
      }
      if (ranges_count > 0 && diff == ranges[ranges_count - 1].diff)
        ranges[ranges_count - 1].high = i;
      else {
        if (ranges_count == 256)
          exit(1);
        ranges[ranges_count].low = i;
        ranges[ranges_count].high = i;
        ranges[ranges_count].diff = diff;
        ranges_count++;
      }
    }
  ranges_total = 0;
  for (k = 0; k < ranges_count; k++) {
    ranges[k].total = ranges_total;
    ranges_total += ranges[k].high - ranges[k].low + 1;
  }
  printf("static const unsigned short %s_charset2uni_ranges[%d] = {\n", name,
         2 * ranges_count);
  for (k = 0; k < ranges_count; k++) {
    printf("  0x%04x, 0x%04x", ranges[k].low, ranges[k].high);
    if (k + 1 < ranges_count)
      printf(",");
    if ((k % 4) == 3 && k + 1 < ranges_count)
      printf("\n");
  }
  printf("\n");
  printf("};\n");
  printf("\n");
  printf("static const unsigned short %s_uni2charset_ranges[%d] = {\n", name,
         2 * ranges_count);
  for (k = 0; k < ranges_count; k++) {
    printf("  0x%04x, 0x%04x", ranges[k].low + ranges[k].diff,
           ranges[k].high + ranges[k].diff);
    if (k + 1 < ranges_count)
      printf(",");
    if ((k % 4) == 3 && k + 1 < ranges_count)
      printf("\n");
  }
  printf("\n");
  printf("};\n");
  printf("\n");
  printf("static const struct { unsigned short diff; unsigned short "
         "bitmap_offset; } %s_ranges[%d] = {\n ",
         name, ranges_count);
  for (k = 0; k < ranges_count; k++) {
    printf(" { %5d, 0x%04x }", ranges[k].diff, ranges[k].total);
    if (k + 1 < ranges_count)
      printf(",");
    if ((k % 4) == 3 && k + 1 < ranges_count)
      printf("\n ");
  }
  printf("\n");
  printf("};\n");
  printf("\n");
  printf("static const unsigned char %s_bitmap[%d] = {\n ", name,
         (ranges_total + 7) / 8);
  {
    int accu = 0;
    for (k = 0; k < ranges_count; k++) {
      for (i = ranges[k].total;
           i <= ranges[k].total + (ranges[k].high - ranges[k].low);) {
        if (charset2uni[i - ranges[k].total + ranges[k].low] != 0)
          accu |= (1 << (i % 8));
        i++;
        if ((i % 8) == 0) {
          printf(" 0x%02x", accu);
          if ((i / 8) < (ranges_total + 7) / 8)
            printf(",");
          if (((i / 8) % 12) == 0)
            printf("\n ");
          accu = 0;
        }
      }
      if (i != (k + 1 < ranges_count ? ranges[k + 1].total : ranges_total))
        abort();
    }
    if ((ranges_total % 8) != 0)
      printf(" 0x%02x", accu);
    printf("\n");
  }
  printf("};\n");
  printf("\n");
  printf("static int\n");
  printf(
      "%s_mbtowc (conv_t conv, ucs4_t *pwc, const unsigned char *s, int n)\n",
      name);
  printf("{\n");
  printf("  unsigned char c1 = s[0];\n");
  printf("  if (c1 >= 0x81 && c1 <= 0x84) {\n");
  printf("    if (n >= 2) {\n");
  printf("      unsigned char c2 = s[1];\n");
  printf("      if (c2 >= 0x30 && c2 <= 0x39) {\n");
  printf("        if (n >= 3) {\n");
  printf("          unsigned char c3 = s[2];\n");
  printf("          if (c3 >= 0x81 && c3 <= 0xfe) {\n");
  printf("            if (n >= 4) {\n");
  printf("              unsigned char c4 = s[3];\n");
  printf("              if (c4 >= 0x30 && c4 <= 0x39) {\n");
  printf("                unsigned int i = (((c1 - 0x81) * 10 + (c2 - 0x30)) * "
         "126 + (c3 - 0x81)) * 10 + (c4 - 0x30);\n");
  printf("                if (i >= %d && i <= %d) {\n", ranges[0].low,
         ranges[ranges_count - 1].high);
  printf("                  unsigned int k1 = 0;\n");
  printf("                  unsigned int k2 = %d;\n", ranges_count - 1);
  printf("                  while (k1 < k2) {\n");
  printf("                    unsigned int k = (k1 + k2) / 2;\n");
  printf("                    if (i <= %s_charset2uni_ranges[2*k+1])\n", name);
  printf("                      k2 = k;\n");
  printf("                    else if (i >= %s_charset2uni_ranges[2*k+2])\n",
         name);
  printf("                      k1 = k + 1;\n");
  printf("                    else\n");
  printf("                      return RET_ILSEQ;\n");
  printf("                  }\n");
  printf("                  {\n");
  printf("                    unsigned int bitmap_index = i - "
         "%s_charset2uni_ranges[2*k1] + %s_ranges[k1].bitmap_offset;\n",
         name, name);
  printf("                    if ((%s_bitmap[bitmap_index >> 3] >> "
         "(bitmap_index & 7)) & 1) {\n",
         name);
  printf("                      unsigned int diff = %s_ranges[k1].diff;\n",
         name);
  printf("                      *pwc = (ucs4_t) (i + diff);\n");
  printf("                      return 4;\n");
  printf("                    }\n");
  printf("                  }\n");
  printf("                }\n");
  printf("              }\n");
  printf("              return RET_ILSEQ;\n");
  printf("            }\n");
  printf("            return RET_TOOFEW(0);\n");
  printf("          }\n");
  printf("          return RET_ILSEQ;\n");
  printf("        }\n");
  printf("        return RET_TOOFEW(0);\n");
  printf("      }\n");
  printf("      return RET_ILSEQ;\n");
  printf("    }\n");
  printf("    return RET_TOOFEW(0);\n");
  printf("  }\n");
  printf("  return RET_ILSEQ;\n");
  printf("}\n");
  printf("\n");
  printf("static int\n");
  printf("%s_wctomb (conv_t conv, unsigned char *r, ucs4_t wc, int n)\n", name);
  printf("{\n");
  printf("  if (n >= 4) {\n");
  printf("    unsigned int i = wc;\n");
  printf("    if (i >= 0x%04x && i <= 0x%04x) {\n",
         ranges[0].low + ranges[0].diff,
         ranges[ranges_count - 1].high + ranges[ranges_count - 1].diff);
  printf("      unsigned int k1 = 0;\n");
  printf("      unsigned int k2 = %d;\n", ranges_count - 1);
  printf("      while (k1 < k2) {\n");
  printf("        unsigned int k = (k1 + k2) / 2;\n");
  printf("        if (i <= %s_uni2charset_ranges[2*k+1])\n", name);
  printf("          k2 = k;\n");
  printf("        else if (i >= %s_uni2charset_ranges[2*k+2])\n", name);
  printf("          k1 = k + 1;\n");
  printf("        else\n");
  printf("          return RET_ILUNI;\n");
  printf("      }\n");
  printf("      {\n");
  printf("        unsigned int bitmap_index = i - %s_uni2charset_ranges[2*k1] "
         "+ %s_ranges[k1].bitmap_offset;\n",
         name, name);
  printf("        if ((%s_bitmap[bitmap_index >> 3] >> (bitmap_index & 7)) & "
         "1) {\n",
         name);
  printf("          unsigned int diff = %s_ranges[k1].diff;\n", name);
  printf("          i -= diff;\n");
  printf("          r[3] = (i %% 10) + 0x30; i = i / 10;\n");
  printf("          r[2] = (i %% 126) + 0x81; i = i / 126;\n");
  printf("          r[1] = (i %% 10) + 0x30; i = i / 10;\n");
  printf("          r[0] = i + 0x81;\n");
  printf("          return 4;\n");
  printf("        }\n");
  printf("      }\n");
  printf("    }\n");
  printf("    return RET_ILUNI;\n");
  printf("  }\n");
  printf("  return RET_TOOSMALL;\n");
  printf("}\n");
}


x86 assembly (clang, -O0):
<do_gb18030uni>:
push   %rbp
mov    %rsp,%rbp
sub    $0x723d0,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0xc4e0,-0x24(%rbp)
jge    11b0 <do_gb18030uni+0x40>
movslq -0x24(%rbp),%rax
movl   $0x0,-0x313b0(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1186 <do_gb18030uni+0x16>
movl   $0x0,-0x28(%rbp)
cmpl   $0x10000,-0x28(%rbp)
jge    11e1 <do_gb18030uni+0x71>
movslq -0x28(%rbp),%rax
movl   $0x0,-0x713b0(%rbp,%rax,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11b7 <do_gb18030uni+0x47>
jmp    11e6 <do_gb18030uni+0x76>
mov    0x3dfb(%rip),%rax
mov    (%rax),%edi
call   1090 <getc@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    0x3ddf(%rip),%rcx
cmp    (%rcx),%eax
jne    120e <do_gb18030uni+0x9e>
jmp    1417 <do_gb18030uni+0x2a7>
cmpl   $0xa,-0xc(%rbp)
je     122c <do_gb18030uni+0xbc>
cmpl   $0x20,-0xc(%rbp)
je     122c <do_gb18030uni+0xbc>
cmpl   $0x9,-0xc(%rbp)
jne    1231 <do_gb18030uni+0xc1>
jmp    11e6 <do_gb18030uni+0x76>
cmpl   $0x23,-0xc(%rbp)
jne    128d <do_gb18030uni+0x11d>
jmp    1240 <do_gb18030uni+0xd0>
mov    0x3da1(%rip),%rax
mov    (%rax),%edi
call   1090 <getc@plt>
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%ecx
mov    $0x1,%al
mov    0x3d83(%rip),%rdx
cmp    (%rdx),%ecx
mov    %al,-0x723c1(%rbp)
je     1278 <do_gb18030uni+0x108>
cmpl   $0xa,-0xc(%rbp)
sete   %al
mov    %al,-0x723c1(%rbp)
mov    -0x723c1(%rbp),%al
xor    $0xff,%al
test   $0x1,%al
jne    1240 <do_gb18030uni+0xd0>
jmp    11e6 <do_gb18030uni+0x76>
mov    -0xc(%rbp),%edi
mov    0x3d51(%rip),%rax
mov    (%rax),%esi
call   1060 <ungetc@plt>
lea    0x1d80(%rip),%rdi
lea    -0x10(%rbp),%rsi
mov    $0x0,%al
call   1070 <scanf@plt>
cmp    $0x1,%eax
je     12c3 <do_gb18030uni+0x153>
mov    $0x1,%edi
call   1080 <exit@plt>
mov    -0x10(%rbp),%eax
shr    $0x18,%eax
and    $0xff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
and    $0xff,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x81,-0x14(%rbp)
jl     1354 <do_gb18030uni+0x1e4>
cmpl   $0x84,-0x14(%rbp)
jg     1354 <do_gb18030uni+0x1e4>
cmpl   $0x30,-0x18(%rbp)
jl     1354 <do_gb18030uni+0x1e4>
cmpl   $0x39,-0x18(%rbp)
jg     1354 <do_gb18030uni+0x1e4>
cmpl   $0x81,-0x1c(%rbp)
jl     1354 <do_gb18030uni+0x1e4>
cmpl   $0xfe,-0x1c(%rbp)
jg     1354 <do_gb18030uni+0x1e4>
cmpl   $0x30,-0x20(%rbp)
jl     1354 <do_gb18030uni+0x1e4>
cmpl   $0x39,-0x20(%rbp)
jle    1381 <do_gb18030uni+0x211>
mov    0x3c75(%rip),%rax
mov    (%rax),%edi
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x20(%rbp),%r9d
lea    0x1c8e(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0x1,%edi
call   1080 <exit@plt>
mov    -0x14(%rbp),%eax
sub    $0x81,%eax
imul   $0xa,%eax,%eax
mov    -0x18(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
imul   $0x7e,%eax,%eax
mov    -0x1c(%rbp),%ecx
sub    $0x81,%ecx
add    %ecx,%eax
imul   $0xa,%eax,%eax
mov    -0x20(%rbp),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
lea    0x1c6d(%rip),%rdi
lea    -0x28(%rbp),%rsi
mov    $0x0,%al
call   1070 <scanf@plt>
cmp    $0x1,%eax
je     13d5 <do_gb18030uni+0x265>
mov    $0x1,%edi
call   1080 <exit@plt>
cmpl   $0x0,-0x28(%rbp)
jl     13ec <do_gb18030uni+0x27c>
cmpl   $0x10000,-0x28(%rbp)
jl     13f6 <do_gb18030uni+0x286>
mov    $0x1,%edi
call   1080 <exit@plt>
mov    -0x28(%rbp),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0x313b0(%rbp,%rax,4)
mov    -0x24(%rbp),%ecx
movslq -0x28(%rbp),%rax
mov    %ecx,-0x713b0(%rbp,%rax,4)
jmp    11e6 <do_gb18030uni+0x76>
movl   $0x0,-0x723b4(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0xc4e0,-0x24(%rbp)
jge    1614 <do_gb18030uni+0x4a4>
movslq -0x24(%rbp),%rax
cmpl   $0x0,-0x313b0(%rbp,%rax,4)
je     1601 <do_gb18030uni+0x491>
movslq -0x24(%rbp),%rax
mov    -0x313b0(%rbp,%rax,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x723bc(%rbp)
cmpl   $0x0,-0x723b4(%rbp)
jle    1525 <do_gb18030uni+0x3b5>
mov    -0x24(%rbp),%eax
mov    -0x723b4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x723b0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
cmp    0x4(%rcx),%eax
jg     149e <do_gb18030uni+0x32e>
mov    $0x1,%edi
call   1080 <exit@plt>
mov    -0x28(%rbp),%eax
mov    -0x723b4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x723b0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%ecx
mov    -0x723b4(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rsi
lea    -0x723b0(%rbp),%rdx
shl    $0x4,%rsi
add    %rsi,%rdx
add    0x8(%rdx),%ecx
cmp    %ecx,%eax
jg     14ed <do_gb18030uni+0x37d>
mov    $0x1,%edi
call   1080 <exit@plt>
mov    -0x723bc(%rbp),%eax
mov    -0x723b4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x723b0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
cmp    0x8(%rcx),%eax
jge    1520 <do_gb18030uni+0x3b0>
mov    $0x1,%edi
call   1080 <exit@plt>
jmp    1525 <do_gb18030uni+0x3b5>
cmpl   $0x0,-0x723b4(%rbp)
jle    1580 <do_gb18030uni+0x410>
mov    -0x723bc(%rbp),%eax
mov    -0x723b4(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rdx
lea    -0x723b0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
cmp    0x8(%rcx),%eax
jne    1580 <do_gb18030uni+0x410>
mov    -0x24(%rbp),%ecx
mov    -0x723b4(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rdx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
jmp    15fc <do_gb18030uni+0x48c>
cmpl   $0x100,-0x723b4(%rbp)
jne    159a <do_gb18030uni+0x42a>
mov    $0x1,%edi
call   1080 <exit@plt>
mov    -0x24(%rbp),%ecx
movslq -0x723b4(%rbp),%rdx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x723b4(%rbp),%rdx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
mov    -0x723bc(%rbp),%ecx
movslq -0x723b4(%rbp),%rdx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x723b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x723b4(%rbp)
jmp    1601 <do_gb18030uni+0x491>
jmp    1606 <do_gb18030uni+0x496>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1428 <do_gb18030uni+0x2b8>
movl   $0x0,-0x723b8(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x723b4(%rbp),%eax
jge    1695 <do_gb18030uni+0x525>
mov    -0x723b8(%rbp),%ecx
movslq -0x2c(%rbp),%rdx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0xc(%rax)
movslq -0x2c(%rbp),%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x4(%rax),%eax
movslq -0x2c(%rbp),%rdx
lea    -0x723b0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
sub    (%rcx),%eax
add    $0x1,%eax
add    -0x723b8(%rbp),%eax
mov    %eax,-0x723b8(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1625 <do_gb18030uni+0x4b5>
mov    -0x8(%rbp),%rsi
mov    -0x723b4(%rbp),%edx
shl    $0x1,%edx
lea    0x1981(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x723b4(%rbp),%eax
jge    1764 <do_gb18030uni+0x5f4>
movslq -0x2c(%rbp),%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%esi
movslq -0x2c(%rbp),%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x4(%rax),%edx
lea    0x196f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cmp    -0x723b4(%rbp),%eax
jge    171d <do_gb18030uni+0x5ad>
lea    0x1960(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x3,%edx
jne    1751 <do_gb18030uni+0x5e1>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cmp    -0x723b4(%rbp),%eax
jge    1751 <do_gb18030uni+0x5e1>
lea    0x1d53(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1756 <do_gb18030uni+0x5e6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16b7 <do_gb18030uni+0x547>
lea    0x1d32(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x18ff(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1d16(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
mov    -0x723b4(%rbp),%edx
shl    $0x1,%edx
lea    0x18da(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x723b4(%rbp),%eax
jge    1887 <do_gb18030uni+0x717>
movslq -0x2c(%rbp),%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%esi
movslq -0x2c(%rbp),%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
add    0x8(%rax),%esi
movslq -0x2c(%rbp),%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x4(%rax),%edx
movslq -0x2c(%rbp),%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
add    0x8(%rax),%edx
lea    0x184c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cmp    -0x723b4(%rbp),%eax
jge    1840 <do_gb18030uni+0x6d0>
lea    0x183d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x3,%edx
jne    1874 <do_gb18030uni+0x704>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cmp    -0x723b4(%rbp),%eax
jge    1874 <do_gb18030uni+0x704>
lea    0x1c30(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1879 <do_gb18030uni+0x709>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    17b0 <do_gb18030uni+0x640>
lea    0x1c0f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x17dc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1bf3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
mov    -0x723b4(%rbp),%edx
lea    0x17f5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x723b4(%rbp),%eax
jge    197e <do_gb18030uni+0x80e>
movslq -0x2c(%rbp),%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%esi
movslq -0x2c(%rbp),%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0xc(%rax),%edx
lea    0x1806(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cmp    -0x723b4(%rbp),%eax
jge    1937 <do_gb18030uni+0x7c7>
lea    0x1746(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x3,%edx
jne    196b <do_gb18030uni+0x7fb>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cmp    -0x723b4(%rbp),%eax
jge    196b <do_gb18030uni+0x7fb>
lea    0x17ef(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1970 <do_gb18030uni+0x800>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18d0 <do_gb18030uni+0x760>
lea    0x1b18(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x16e5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1afc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
mov    -0x723b8(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
lea    0x1761(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x723c0(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x723b4(%rbp),%eax
jge    1bd0 <do_gb18030uni+0xa60>
movslq -0x2c(%rbp),%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0xc(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
movslq -0x2c(%rbp),%rdx
lea    -0x723b0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
mov    0xc(%rcx),%ecx
movslq -0x2c(%rbp),%rsi
lea    -0x723b0(%rbp),%rdx
shl    $0x4,%rsi
add    %rsi,%rdx
mov    0x4(%rdx),%edx
movslq -0x2c(%rbp),%rdi
lea    -0x723b0(%rbp),%rsi
shl    $0x4,%rdi
add    %rdi,%rsi
sub    (%rsi),%edx
add    %edx,%ecx
cmp    %ecx,%eax
jg     1b56 <do_gb18030uni+0x9e6>
mov    -0x24(%rbp),%eax
movslq -0x2c(%rbp),%rdx
lea    -0x723b0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
sub    0xc(%rcx),%eax
movslq -0x2c(%rbp),%rdx
lea    -0x723b0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
add    (%rcx),%eax
cltq
cmpl   $0x0,-0x313b0(%rbp,%rax,4)
je     1aac <do_gb18030uni+0x93c>
mov    -0x24(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
mov    $0x1,%eax
shl    %cl,%eax
or     -0x723c0(%rbp),%eax
mov    %eax,-0x723c0(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1b51 <do_gb18030uni+0x9e1>
mov    -0x723c0(%rbp),%esi
lea    0x1680(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x24(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x723c8(%rbp)
mov    -0x723b8(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x723c8(%rbp),%eax
cmp    %ecx,%eax
jge    1b1d <do_gb18030uni+0x9ad>
lea    0x1560(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x24(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    $0xc,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1b47 <do_gb18030uni+0x9d7>
lea    0x1613(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x723c0(%rbp)
jmp    1a05 <do_gb18030uni+0x895>
mov    -0x24(%rbp),%eax
mov    %eax,-0x723cc(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cmp    -0x723b4(%rbp),%eax
jge    1b96 <do_gb18030uni+0xa26>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0xc(%rax),%eax
mov    %eax,-0x723d0(%rbp)
jmp    1ba2 <do_gb18030uni+0xa32>
mov    -0x723b8(%rbp),%eax
mov    %eax,-0x723d0(%rbp)
mov    -0x723cc(%rbp),%eax
mov    -0x723d0(%rbp),%ecx
cmp    %ecx,%eax
je     1bbd <do_gb18030uni+0xa4d>
mov    $0x0,%al
call   1030 <abort@plt>
jmp    1bc2 <do_gb18030uni+0xa52>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19de <do_gb18030uni+0x86e>
mov    -0x723b8(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     1bfb <do_gb18030uni+0xa8b>
mov    -0x723c0(%rbp),%esi
lea    0x1562(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x189b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1468(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x187f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1532(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0x152c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x192b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1555(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1563(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1578(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x157d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x158f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x15a8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x15b1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x15c7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x15e4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x15f1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x160b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x162c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x723b0(%rbp),%esi
mov    -0x723b4(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x4(%rax),%edx
lea    0x1668(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1685(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x723b4(%rbp),%esi
sub    $0x1,%esi
lea    0x1696(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x16b1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x16c8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0x16eb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1719(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0x1726(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1759(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x176e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x177a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1904(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1787(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
mov    -0x8(%rbp),%rdx
lea    0x1786(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0x17e4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0x1827(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1858(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x187d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1890(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1884(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1878(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x186c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x16ca(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1852(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1853(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1838(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1696(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x181e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x181f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1804(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1662(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x17ea(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x17eb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x17d0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x162e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x17b6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x155f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1212(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0x17ae(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x160b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x133e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x17c1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x723b0(%rbp),%esi
add    -0x723a8(%rbp),%esi
mov    -0x723b4(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x4(%rax),%edx
mov    -0x723b4(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    -0x723b0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
add    0x8(%rax),%edx
lea    0x1787(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x13da(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x723b4(%rbp),%esi
sub    $0x1,%esi
lea    0x13eb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1406(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x141d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0x175b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x146e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0x176b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x14ae(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x14c3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1776(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1659(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x14dc(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
mov    -0x8(%rbp),%rdx
lea    0x1761(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0x1539(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rsi
lea    0x157c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1793(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x179b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x17bd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x17e1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1803(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x159a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x15ad(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x15a1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1595(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x169a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x157b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x17bd(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0x1561(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
add    $0x723d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<do_gb18030uni>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x323b8,%rsp
mov    %rdi,0x18(%rsp)
lea    0x1030(%rsp),%rdi
xor    %ebp,%ebp
mov    $0x31380,%edx
xor    %esi,%esi
call   1070 <memset@plt>
movl   $0x10000,0x14(%rsp)
mov    0x2e0d(%rip),%r13
mov    0x0(%r13),%edi
call   10c0 <getc@plt>
mov    0x2df5(%rip),%r14
jmp    1229 <do_gb18030uni+0x89>
lea    (%r15,%r15,4),%ecx
lea    (%r12,%rcx,2),%ecx
mov    %ecx,%edx
shl    $0x7,%edx
sub    %ecx,%edx
sub    %ecx,%edx
add    0x8(%rsp),%edx
lea    (%rdx,%rdx,4),%ecx
lea    (%rbx,%rcx,2),%ecx
add    $0xffe6414e,%ecx
movslq %ecx,%rcx
mov    %eax,0x1030(%rsp,%rcx,4)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13),%edi
call   10c0 <getc@plt>
cmp    (%r14),%eax
je     132f <do_gb18030uni+0x18f>
lea    -0x9(%rax),%ecx
cmp    $0x2,%ecx
jb     1220 <do_gb18030uni+0x80>
cmp    $0x20,%eax
je     1220 <do_gb18030uni+0x80>
cmp    $0x23,%eax
jne    1265 <do_gb18030uni+0xc5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13),%edi
call   10c0 <getc@plt>
cmp    $0xa,%eax
je     1220 <do_gb18030uni+0x80>
cmp    (%r14),%eax
jne    1250 <do_gb18030uni+0xb0>
jmp    1220 <do_gb18030uni+0x80>
mov    0x0(%r13),%esi
mov    %eax,%edi
call   1090 <ungetc@plt>
lea    0xdae(%rip),%rdi
lea    0x2c(%rsp),%rsi
xor    %eax,%eax
call   10a0 <scanf@plt>
cmp    $0x1,%eax
jne    1325 <do_gb18030uni+0x185>
mov    0x2c(%rsp),%eax
mov    %eax,%r15d
shr    $0x18,%r15d
mov    %eax,%ecx
shr    $0x10,%ecx
movzbl %cl,%r12d
movzbl %ah,%ebx
movzbl %al,%r9d
add    $0x7f000000,%eax
cmp    $0x3ffffff,%eax
ja     1c92 <do_gb18030uni+0xaf2>
cmp    $0x30,%r12d
jb     1c92 <do_gb18030uni+0xaf2>
cmp    $0x39,%r12d
ja     1c92 <do_gb18030uni+0xaf2>
cmp    $0x81,%ebx
jb     1c92 <do_gb18030uni+0xaf2>
cmp    $0xff,%ebx
je     1c92 <do_gb18030uni+0xaf2>
cmp    $0x30,%r9d
jb     1c92 <do_gb18030uni+0xaf2>
cmp    $0x3a,%r9d
jae    1c92 <do_gb18030uni+0xaf2>
mov    %ebx,0x8(%rsp)
mov    %r9,%rbx
lea    0xd1f(%rip),%rdi
lea    0x14(%rsp),%rsi
xor    %eax,%eax
call   10a0 <scanf@plt>
cmp    $0x1,%eax
jne    1325 <do_gb18030uni+0x185>
mov    0x14(%rsp),%eax
cmp    $0x10000,%eax
jb     11ed <do_gb18030uni+0x4d>
mov    $0x1,%edi
call   10b0 <exit@plt>
xor    %eax,%eax
xor    %r15d,%r15d
jmp    1365 <do_gb18030uni+0x1c5>
cmp    $0x100,%r15d
je     1325 <do_gb18030uni+0x185>
movslq %r15d,%rdx
shl    $0x4,%rdx
mov    %eax,0x30(%rsp,%rdx,1)
mov    %eax,0x34(%rsp,%rdx,1)
mov    %ecx,0x38(%rsp,%rdx,1)
add    $0x1,%r15d
add    $0x1,%rax
add    $0xffffffff,%ebp
cmp    $0xc4e0,%rax
je     13aa <do_gb18030uni+0x20a>
mov    0x1030(%rsp,%rax,4),%edx
test   %edx,%edx
je     1356 <do_gb18030uni+0x1b6>
mov    %edx,0x14(%rsp)
lea    (%rdx,%rbp,1),%ecx
test   %r15d,%r15d
jle    133f <do_gb18030uni+0x19f>
lea    -0x1(%r15),%esi
shl    $0x4,%rsi
movslq 0x34(%rsp,%rsi,1),%rdi
cmp    %rdi,%rax
jle    1325 <do_gb18030uni+0x185>
mov    0x38(%rsp,%rsi,1),%ebx
add    %ebx,%edi
cmp    %edi,%edx
jle    1325 <do_gb18030uni+0x185>
cmp    %ebx,%ecx
jl     1325 <do_gb18030uni+0x185>
jne    1336 <do_gb18030uni+0x196>
lea    (%rsp,%rsi,1),%rcx
add    $0x34,%rcx
mov    %eax,(%rcx)
jmp    1356 <do_gb18030uni+0x1b6>
mov    %r15d,%r13d
test   %r15d,%r15d
jle    13c4 <do_gb18030uni+0x224>
cmp    $0x1,%r15d
mov    0x18(%rsp),%rbx
jne    13e8 <do_gb18030uni+0x248>
xor    %eax,%eax
xor    %r14d,%r14d
jmp    142c <do_gb18030uni+0x28c>
lea    (%r15,%r15,1),%ebp
lea    0xc5b(%rip),%rdi
xor    %r14d,%r14d
mov    0x18(%rsp),%rbx
mov    %rbx,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1060 <printf@plt>
jmp    14d1 <do_gb18030uni+0x331>
mov    %r13d,%ecx
and    $0xfffffffe,%ecx
lea    0x4c(%rsp),%rdx
xor    %eax,%eax
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
mov    %r14d,-0x10(%rdx)
add    -0x18(%rdx),%r14d
sub    -0x1c(%rdx),%r14d
add    $0x1,%r14d
mov    %r14d,(%rdx)
add    -0x8(%rdx),%r14d
sub    -0xc(%rdx),%r14d
add    $0x1,%r14d
add    $0x2,%rax
add    $0x20,%rdx
cmp    %rax,%rcx
jne    1400 <do_gb18030uni+0x260>
test   $0x1,%r13b
je     1449 <do_gb18030uni+0x2a9>
shl    $0x4,%rax
mov    %r14d,0x3c(%rsp,%rax,1)
add    0x34(%rsp,%rax,1),%r14d
sub    0x30(%rsp,%rax,1),%r14d
add    $0x1,%r14d
lea    (%r15,%r15,1),%ebp
lea    0xbd6(%rip),%rdi
mov    %rbx,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1060 <printf@plt>
test   %r15d,%r15d
jle    14d1 <do_gb18030uni+0x331>
mov    %ebp,0x20(%rsp)
mov    %r15,0x8(%rsp)
lea    0x34(%rsp),%rbx
lea    0xbeb(%rip),%r15
xor    %ebp,%ebp
jmp    1489 <do_gb18030uni+0x2e9>
xchg   %ax,%ax
add    $0x10,%rbx
cmp    %rbp,%r13
je     14c3 <do_gb18030uni+0x323>
mov    %rbp,%r12
mov    -0x4(%rbx),%esi
mov    (%rbx),%edx
mov    %r15,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbp
cmp    %r13,%rbp
jae    1480 <do_gb18030uni+0x2e0>
mov    $0x2c,%edi
call   1030 <putchar@plt>
not    %r12d
test   $0x3,%r12b
jne    1480 <do_gb18030uni+0x2e0>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    1480 <do_gb18030uni+0x2e0>
mov    0x18(%rsp),%rbx
mov    0x8(%rsp),%r15
mov    0x20(%rsp),%ebp
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x104f(%rip),%rdi
call   1050 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xb7e(%rip),%rdi
mov    %rbx,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1060 <printf@plt>
test   %r15d,%r15d
mov    %r15,0x8(%rsp)
jle    1616 <do_gb18030uni+0x476>
lea    0x38(%rsp),%rbx
lea    0xb47(%rip),%r15
xor    %ebp,%ebp
jmp    1539 <do_gb18030uni+0x399>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x10,%rbx
cmp    %rbp,%r13
je     1578 <do_gb18030uni+0x3d8>
mov    %rbp,%r12
mov    (%rbx),%edx
mov    -0x8(%rbx),%esi
add    %edx,%esi
add    -0x4(%rbx),%edx
mov    %r15,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%rbp
cmp    %r13,%rbp
jae    1530 <do_gb18030uni+0x390>
mov    $0x2c,%edi
call   1030 <putchar@plt>
not    %r12d
test   $0x3,%r12b
jne    1530 <do_gb18030uni+0x390>
mov    $0xa,%edi
call   1030 <putchar@plt>
jmp    1530 <do_gb18030uni+0x390>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xfa8(%rip),%rdi
call   1050 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xb12(%rip),%rdi
mov    0x18(%rsp),%rsi
mov    0x8(%rsp),%rbx
mov    %ebx,%edx
xor    %eax,%eax
call   1060 <printf@plt>
test   %ebx,%ebx
jle    164a <do_gb18030uni+0x4aa>
lea    0x3c(%rsp),%rbx
lea    0xb4a(%rip),%r15
xor    %r12d,%r12d
jmp    15d9 <do_gb18030uni+0x439>
nopl   0x0(%rax,%rax,1)
add    $0x10,%rbx
cmp    %r12,%r13
je     164a <do_gb18030uni+0x4aa>
mov    %r12,%rbp
mov    -0x4(%rbx),%esi
mov    (%rbx),%edx
mov    %r15,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
add    $0x1,%r12
cmp    %r13,%r12
jae    15d0 <do_gb18030uni+0x430>
mov    $0x2c,%edi
call   1030 <putchar@plt>
not    %ebp
test   $0x3,%bpl
jne    15d0 <do_gb18030uni+0x430>
lea    0xb40(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    15d0 <do_gb18030uni+0x430>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xf0a(%rip),%rdi
call   1050 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xa74(%rip),%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xed6(%rip),%rdi
call   1050 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x7(%r14),%eax
lea    0xe(%r14),%ebp
test   %eax,%eax
cmovns %eax,%ebp
sar    $0x3,%ebp
lea    0xaa0(%rip),%rdi
mov    0x18(%rsp),%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x8(%rsp),%rax
test   %eax,%eax
mov    $0x0,%ecx
cmovg  %eax,%ecx
mov    %rcx,0x20(%rsp)
xor    %r15d,%r15d
xor    %ebx,%ebx
jmp    16b9 <do_gb18030uni+0x519>
nopw   0x0(%rax,%rax,1)
cmp    %eax,%r12d
jne    1c8b <do_gb18030uni+0xaeb>
cmp    0x20(%rsp),%r15
je     17b9 <do_gb18030uni+0x619>
mov    %r15,%rdx
shl    $0x4,%rdx
mov    0x30(%rsp,%rdx,1),%eax
mov    0x3c(%rsp,%rdx,1),%ecx
mov    0x34(%rsp,%rdx,1),%esi
add    %ecx,%esi
sub    %eax,%esi
cmp    %esi,%ecx
jle    1700 <do_gb18030uni+0x560>
mov    %ecx,%r12d
add    $0x1,%r15
mov    %r14d,%eax
cmp    %r15d,0x8(%rsp)
jle    16b0 <do_gb18030uni+0x510>
mov    %r15,%rax
shl    $0x4,%rax
mov    0x3c(%rsp,%rax,1),%eax
jmp    16b0 <do_gb18030uni+0x510>
nopl   (%rax)
lea    (%rsp,%rdx,1),%r13
add    $0x3c,%r13
mov    %ecx,%r12d
jmp    1740 <do_gb18030uni+0x5a0>
nopl   (%rax)
imul   $0xaaaaaaab,%ebx,%eax
add    $0x2aaaaaa8,%eax
ror    $0x2,%eax
xor    %ebx,%ebx
cmp    $0x15555554,%eax
jbe    17a4 <do_gb18030uni+0x604>
mov    0x0(%r13),%ecx
mov    -0xc(%r13),%eax
mov    -0x8(%r13),%edx
add    %ecx,%edx
sub    %eax,%edx
lea    -0x1(%r12),%esi
cmp    %edx,%esi
jge    16e2 <do_gb18030uni+0x542>
mov    %ebx,%edx
sub    %ecx,%eax
add    %r12d,%eax
cltq
mov    %r12d,%ecx
and    $0x7,%cl
mov    $0x1,%ebx
shl    %cl,%ebx
mov    0x1030(%rsp,%rax,4),%eax
test   %eax,%eax
cmove  %eax,%ebx
or     %edx,%ebx
add    $0x1,%r12d
test   $0x7,%r12b
jne    1727 <do_gb18030uni+0x587>
lea    0x9db(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x7(%r12),%ebx
test   %r12d,%r12d
cmovns %r12d,%ebx
sar    $0x3,%ebx
cmp    %ebp,%ebx
jge    1710 <do_gb18030uni+0x570>
mov    $0x2c,%edi
call   1030 <putchar@plt>
jmp    1710 <do_gb18030uni+0x570>
xor    %ebx,%ebx
lea    0x9a0(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    1727 <do_gb18030uni+0x587>
test   $0x7,%r14b
je     17cf <do_gb18030uni+0x62f>
lea    0x98a(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xd51(%rip),%rdi
call   1050 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x10ae(%rip),%rdi
call   1050 <puts@plt>
lea    0x956(%rip),%rdi
mov    0x18(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x1000(%rip),%rdi
call   1050 <puts@plt>
lea    0xd10(%rip),%rdi
call   1050 <puts@plt>
lea    0xd1f(%rip),%rdi
call   1050 <puts@plt>
lea    0xd35(%rip),%rdi
call   1050 <puts@plt>
lea    0xd3b(%rip),%rdi
call   1050 <puts@plt>
lea    0xd4e(%rip),%rdi
call   1050 <puts@plt>
lea    0xd68(%rip),%rdi
call   1050 <puts@plt>
lea    0xd72(%rip),%rdi
call   1050 <puts@plt>
lea    0xd89(%rip),%rdi
call   1050 <puts@plt>
lea    0xda7(%rip),%rdi
call   1050 <puts@plt>
lea    0xdb5(%rip),%rdi
call   1050 <puts@plt>
lea    0xdd0(%rip),%rdi
call   1050 <puts@plt>
lea    0xdf2(%rip),%rdi
call   1050 <puts@plt>
mov    0x30(%rsp),%esi
mov    0x8(%rsp),%r12
movslq %r12d,%rbp
add    $0xffffffff,%r12d
shl    $0x4,%rbp
lea    0x30(%rsp),%r14
mov    -0xc(%rbp,%r14,1),%edx
lea    0x8cb(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xe26(%rip),%rdi
call   1050 <puts@plt>
lea    0x8dc(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xe30(%rip),%rdi
call   1050 <puts@plt>
lea    0xe48(%rip),%rdi
call   1050 <puts@plt>
lea    0x8dc(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xe5f(%rip),%rdi
call   1050 <puts@plt>
lea    0x8fb(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xe60(%rip),%rdi
call   1050 <puts@plt>
lea    0xe76(%rip),%rdi
call   1050 <puts@plt>
lea    0xe83(%rip),%rdi
call   1050 <puts@plt>
lea    0xf07(%rip),%r15
mov    %r15,%rdi
call   1050 <puts@plt>
lea    0xe90(%rip),%rdi
call   1050 <puts@plt>
lea    0x8ec(%rip),%rdi
mov    %rbx,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x948(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x98c(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xe62(%rip),%rdi
call   1050 <puts@plt>
lea    0xe88(%rip),%rdi
call   1050 <puts@plt>
lea    0xe9c(%rip),%rdi
call   1050 <puts@plt>
mov    %r15,%rdi
call   1050 <puts@plt>
lea    0xe8c(%rip),%rdi
call   1050 <puts@plt>
lea    0xe82(%rip),%rdi
call   1050 <puts@plt>
lea    0xdea(%rip),%rdi
call   1050 <puts@plt>
lea    0xe6c(%rip),%rdi
call   1050 <puts@plt>
lea    0xe6e(%rip),%rdi
call   1050 <puts@plt>
lea    0xe56(%rip),%rdi
call   1050 <puts@plt>
lea    0xdbe(%rip),%rdi
call   1050 <puts@plt>
lea    0xe40(%rip),%rdi
call   1050 <puts@plt>
lea    0xe42(%rip),%rdi
call   1050 <puts@plt>
lea    0xe2a(%rip),%r15
mov    %r15,%rdi
call   1050 <puts@plt>
lea    0xd8f(%rip),%rdi
call   1050 <puts@plt>
lea    0xe11(%rip),%rdi
call   1050 <puts@plt>
lea    0xe13(%rip),%rdi
call   1050 <puts@plt>
lea    0xdfb(%rip),%rdi
call   1050 <puts@plt>
lea    0xd63(%rip),%rdi
call   1050 <puts@plt>
lea    0xde5(%rip),%r13
mov    %r13,%rdi
call   1050 <puts@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xdf0(%rip),%rdi
call   1050 <puts@plt>
lea    0x8b2(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xd47(%rip),%rdi
call   1050 <puts@plt>
lea    0xb58(%rip),%rdi
call   1050 <puts@plt>
lea    0xdc6(%rip),%rdi
call   1050 <puts@plt>
mov    0x38(%rsp),%esi
add    0x30(%rsp),%esi
mov    -0x8(%rbp,%r14,1),%edx
add    -0xc(%rbp,%r14,1),%edx
lea    0x8a8(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xbfd(%rip),%rdi
call   1050 <puts@plt>
lea    0x6b3(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xc07(%rip),%rdi
call   1050 <puts@plt>
lea    0xc1f(%rip),%rdi
call   1050 <puts@plt>
lea    0x88c(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xc36(%rip),%rdi
call   1050 <puts@plt>
lea    0x89f(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xc37(%rip),%rdi
call   1050 <puts@plt>
lea    0xc4d(%rip),%rdi
call   1050 <puts@plt>
lea    0xd38(%rip),%rdi
call   1050 <puts@plt>
mov    %r15,%rdi
call   1050 <puts@plt>
lea    0xc6e(%rip),%rdi
call   1050 <puts@plt>
lea    0x88b(%rip),%rdi
mov    %rbx,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x726(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x76a(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xcfe(%rip),%rdi
call   1050 <puts@plt>
lea    0x8ad(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x8cf(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x8f3(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xcdd(%rip),%rdi
call   1050 <puts@plt>
lea    0xc30(%rip),%rdi
call   1050 <puts@plt>
lea    0xc44(%rip),%rdi
call   1050 <puts@plt>
mov    %r15,%rdi
call   1050 <puts@plt>
lea    0xc34(%rip),%rdi
call   1050 <puts@plt>
lea    0xc7a(%rip),%rdi
call   1050 <puts@plt>
lea    0xc1e(%rip),%rdi
call   1050 <puts@plt>
lea    0xca8(%rip),%rdi
call   1050 <puts@plt>
mov    %r13,%rdi
call   1050 <puts@plt>
add    $0x323b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
call   1040 <abort@plt>
mov    0x2337(%rip),%rax
mov    (%rax),%edi
lea    0x35e(%rip),%rsi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    %ebx,%r8d
call   1080 <fprintf@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>

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

LLVM IR (-O2):
%struct.anon = type { i32, i32, i32, i32 }
@stdin = global i32 0
@EOF = global i32 0
@.str = [5 x i8] c"0x%x\00"
@stderr = global i32 0
@.str.1 = [36 x i8] c"lost entry for %02x %02x %02x %02x\0A\00"
@.str.2 = [6 x i8] c" 0x%x\00"
@.str.3 = [59 x i8] c"static const unsigned short %s_charset2uni_ranges[%d] = {\0A\00"
@.str.4 = [17 x i8] c" 0x%04x, 0x%04x\00"
@.str.8 = [59 x i8] c"static const unsigned short %s_uni2charset_ranges[%d] = {\0A\00"
@.str.9 = [95 x i8] c"static const struct { unsigned short diff; unsigned short bitmap_offset; } %s_ranges[%d] = {\0A \00"
@.str.10 = [17 x i8] c" { %5d, 0x%04x }\00"
@.str.11 = [3 x i8] c"\0A \00"
@.str.12 = [47 x i8] c"static const unsigned char %s_bitmap[%d] = {\0A \00"
@.str.13 = [8 x i8] c" 0x%02x\00"
@.str.15 = [69 x i8] c"%s_mbtowc (conv_t conv, ucs4_t *pwc, const unsigned char *s, int n)\0A\00"
@.str.29 = [43 x i8] c" if (i >= %d && i <= %d) {\0A\00"
@.str.31 = [41 x i8] c" unsigned int k2 = %d;\0A\00"
@.str.34 = [60 x i8] c" if (i <= %s_charset2uni_ranges[2*k+1])\0A\00"
@.str.36 = [65 x i8] c" else if (i >= %s_charset2uni_ranges[2*k+2])\0A\00"
@.str.42 = [112 x i8] c" unsigned int bitmap_index = i - %s_charset2uni_ranges[2*k1] + %s_ranges[k1].bitmap_offset;\0A\00"
@.str.43 = [85 x i8] c" if ((%s_bitmap[bitmap_index >> 3] >> (bitmap_index & 7)) & 1) {\0A\00"
@.str.44 = [63 x i8] c" unsigned int diff = %s_ranges[k1].diff;\0A\00"
@.str.64 = [61 x i8] c"%s_wctomb (conv_t conv, unsigned char *r, ucs4_t wc, int n)\0A\00"
@.str.67 = [39 x i8] c" if (i >= 0x%04x && i <= 0x%04x) {\0A\00"
@.str.69 = [29 x i8] c" unsigned int k2 = %d;\0A\00"
@.str.72 = [48 x i8] c" if (i <= %s_uni2charset_ranges[2*k+1])\0A\00"
@.str.74 = [53 x i8] c" else if (i >= %s_uni2charset_ranges[2*k+2])\0A\00"
@.str.79 = [100 x i8] c" unsigned int bitmap_index = i - %s_uni2charset_ranges[2*k1] + %s_ranges[k1].bitmap_offset;\0A\00"
@.str.80 = [73 x i8] c" if ((%s_bitmap[bitmap_index >> 3] >> (bitmap_index & 7)) & 1) {\0A\00"
@.str.81 = [51 x i8] c" unsigned int diff = %s_ranges[k1].diff;\0A\00"
@.str.83 = [48 x i8] c" r[3] = (i %% 10) + 0x30; i = i / 10;\0A\00"
@.str.84 = [50 x i8] c" r[2] = (i %% 126) + 0x81; i = i / 126;\0A\00"
@.str.85 = [48 x i8] c" r[1] = (i %% 10) + 0x30; i = i / 10;\0A\00"
@str.92 = [3 x i8] c"};\00"
@str.95 = [27 x i8] c" unsigned char c1 = s[0];\00"
@str.96 = [34 x i8] c" if (c1 >= 0x81 && c1 <= 0x84) {\00"
@str.97 = [18 x i8] c" if (n >= 2) {\00"
@str.98 = [31 x i8] c" unsigned char c2 = s[1];\00"
@str.99 = [38 x i8] c" if (c2 >= 0x30 && c2 <= 0x39) {\00"
@str.100 = [22 x i8] c" if (n >= 3) {\00"
@str.101 = [35 x i8] c" unsigned char c3 = s[2];\00"
@str.102 = [42 x i8] c" if (c3 >= 0x81 && c3 <= 0xfe) {\00"
@str.103 = [26 x i8] c" if (n >= 4) {\00"
@str.104 = [39 x i8] c" unsigned char c4 = s[3];\00"
@str.105 = [46 x i8] c" if (c4 >= 0x30 && c4 <= 0x39) {\00"
@str.106 = [108 x i8] c" unsigned int i = (((c1 - 0x81) * 10 + (c2 - 0x30)) * 126 + (c3 - 0x81)) * 10 + (c4 - 0x30);\00"
@str.107 = [39 x i8] c" unsigned int k1 = 0;\00"
@str.108 = [36 x i8] c" while (k1 < k2) {\00"
@str.109 = [52 x i8] c" unsigned int k = (k1 + k2) / 2;\00"
@str.110 = [30 x i8] c" k2 = k;\00"
@str.111 = [34 x i8] c" k1 = k + 1;\00"
@str.112 = [25 x i8] c" else\00"
@str.113 = [40 x i8] c" return RET_ILSEQ;\00"
@str.115 = [20 x i8] c" {\00"
@str.116 = [50 x i8] c" *pwc = (ucs4_t) (i + diff);\00"
@str.117 = [32 x i8] c" return 4;\00"
@str.118 = [22 x i8] c" }\00"
@str.119 = [20 x i8] c" }\00"
@str.120 = [18 x i8] c" }\00"
@str.121 = [16 x i8] c" }\00"
@str.122 = [32 x i8] c" return RET_ILSEQ;\00"
@str.123 = [14 x i8] c" }\00"
@str.124 = [34 x i8] c" return RET_TOOFEW(0);\00"
@str.125 = [12 x i8] c" }\00"
@str.126 = [28 x i8] c" return RET_ILSEQ;\00"
@str.128 = [30 x i8] c" return RET_TOOFEW(0);\00"
@str.130 = [24 x i8] c" return RET_ILSEQ;\00"
@str.132 = [26 x i8] c" return RET_TOOFEW(0);\00"
@str.134 = [20 x i8] c" return RET_ILSEQ;\00"
@str.136 = [11 x i8] c"static int\00"
@str.137 = [2 x i8] c"{\00"
@str.138 = [16 x i8] c" if (n >= 4) {\00"
@str.139 = [25 x i8] c" unsigned int i = wc;\00"
@str.140 = [27 x i8] c" unsigned int k1 = 0;\00"
@str.141 = [24 x i8] c" while (k1 < k2) {\00"
@str.142 = [40 x i8] c" unsigned int k = (k1 + k2) / 2;\00"
@str.143 = [18 x i8] c" k2 = k;\00"
@str.144 = [22 x i8] c" k1 = k + 1;\00"
@str.145 = [13 x i8] c" else\00"
@str.146 = [28 x i8] c" return RET_ILUNI;\00"
@str.148 = [8 x i8] c" {\00"
@str.149 = [21 x i8] c" i -= diff;\00"
@str.150 = [27 x i8] c" r[0] = i + 0x81;\00"
@str.151 = [20 x i8] c" return 4;\00"
@str.152 = [10 x i8] c" }\00"
@str.153 = [8 x i8] c" }\00"
@str.154 = [6 x i8] c" }\00"
@str.155 = [22 x i8] c" return RET_ILUNI;\00"
@str.156 = [4 x i8] c" }\00"
@str.157 = [23 x i8] c" return RET_TOOSMALL;\00"
@str.158 = [2 x i8] c"}\00"
define void @do_gb18030uni(i8* %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca [50400 x i32]
%5 = bitcast [50400 x i32]* %4 to i8*
%6 = alloca [256 x %struct.anon]
%7 = bitcast i32* %2 to i8*
%8 = bitcast i32* %3 to i8*
%9 = bitcast [256 x %struct.anon]* %6 to i8*
store i32 65536, i32* %3
%10 = load i32, i32* @stdin
%11 = call i32 @getc(i32 %10)
%12 = load i32, i32* @EOF
%13 = icmp eq i32 %11, %12
br i1 %13, label %14, label %15
14: ; preds = %77, %1
br label %93
15: ; preds = %1, %77
%16 = phi i32 [ %79, %77 ], [ %11, %1 ]
switch i32 %16, label %24 [
i32 32, label %77
i32 10, label %77
i32 9, label %77
i32 35, label %17
]
17: ; preds = %15, %17
%18 = load i32, i32* @stdin
%19 = call i32 @getc(i32 %18)
%20 = load i32, i32* @EOF
%21 = icmp ne i32 %19, %20
%22 = icmp ne i32 %19, 10
%23 = and i1 %22, %21
br i1 %23, label %17, label %77
24: ; preds = %15
%25 = load i32, i32* @stdin
%26 = call i32 @ungetc(i32 %16, i32 %25)
%27 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32* %2)
%28 = icmp eq i32 %27, 1
br i1 %28, label %31, label %29
29: ; preds = %24
%30 = call i32 @exit(i32 1)
unreachable
31: ; preds = %24
%32 = load i32, i32* %2
%33 = lshr i32 %32, 24
%34 = lshr i32 %32, 16
%35 = and i32 %34, 255
%36 = lshr i32 %32, 8
%37 = and i32 %36, 255
%38 = and i32 %32, 255
%39 = add i32 %32, 2130706432
%40 = icmp ult i32 %39, 67108864
%41 = icmp ugt i32 %35, 47
%42 = select i1 %40, i1 %41, i1 false
%43 = icmp ult i32 %35, 58
%44 = select i1 %42, i1 %43, i1 false
%45 = icmp ugt i32 %37, 128
%46 = select i1 %44, i1 %45, i1 false
%47 = icmp ne i32 %37, 255
%48 = select i1 %46, i1 %47, i1 false
%49 = icmp ugt i32 %38, 47
%50 = select i1 %48, i1 %49, i1 false
%51 = icmp ult i32 %38, 58
%52 = select i1 %50, i1 %51, i1 false
br i1 %52, label %57, label %53
53: ; preds = %31
%54 = load i32, i32* @stderr
%55 = call i32 @fprintf(i32 %54, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0), i32 %33, i32 %35, i32 %37, i32 %38)
%56 = call i32 @exit(i32 1)
unreachable
57: ; preds = %31
%58 = mul nuw nsw i32 %33, 10
%59 = add nuw nsw i32 %58, %35
%60 = mul nuw nsw i32 %59, 126
%61 = add nuw nsw i32 %60, %37
%62 = mul nuw nsw i32 %61, 10
%63 = add nuw nsw i32 %38, -1687218
%64 = add nsw i32 %63, %62
%65 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32* %3)
%66 = icmp eq i32 %65, 1
br i1 %66, label %69, label %67
67: ; preds = %57
%68 = call i32 @exit(i32 1)
unreachable
69: ; preds = %57
%70 = load i32, i32* %3
%71 = icmp ult i32 %70, 65536
br i1 %71, label %74, label %72
72: ; preds = %69
%73 = call i32 @exit(i32 1)
unreachable
74: ; preds = %69
%75 = sext i32 %64 to i64
%76 = getelementptr inbounds [50400 x i32], [50400 x i32]* %4, i64 0, i64 %75
store i32 %70, i32* %76
br label %77
77: ; preds = %17, %74, %15, %15, %15
%78 = load i32, i32* @stdin
%79 = call i32 @getc(i32 %78)
%80 = load i32, i32* @EOF
%81 = icmp eq i32 %79, %80
br i1 %81, label %14, label %15
82: ; preds = %136
%83 = icmp sgt i32 %137, 0
br i1 %83, label %87, label %84
84: ; preds = %82
%85 = shl nsw i32 %137, 1
%86 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str.3, i64 0, i64 0), i8* %0, i32 %85)
br label %202
87: ; preds = %82
%88 = zext i32 %137 to i64
%89 = and i64 %88, 1
%90 = icmp eq i32 %137, 1
br i1 %90, label %164, label %91
91: ; preds = %87
%92 = and i64 %88, 4294967294
br label %140
93: ; preds = %14, %136
%94 = phi i64 [ %138, %136 ], [ 0, %14 ]
%95 = phi i32 [ %137, %136 ], [ 0, %14 ]
%96 = getelementptr inbounds [50400 x i32], [50400 x i32]* %4, i64 0, i64 %94
%97 = load i32, i32* %96
%98 = icmp eq i32 %97, 0
br i1 %98, label %136, label %99
99: ; preds = %93
store i32 %97, i32* %3
%100 = trunc i64 %94 to i32
%101 = sub nsw i32 %97, %100
%102 = icmp sgt i32 %95, 0
br i1 %102, label %103, label %130
103: ; preds = %99
%104 = add nsw i32 %95, -1
%105 = zext i32 %104 to i64
%106 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %105, i32 1
%107 = load i32, i32* %106
%108 = sext i32 %107 to i64
%109 = icmp sgt i64 %94, %108
br i1 %109, label %112, label %110
110: ; preds = %103
%111 = call i32 @exit(i32 1)
unreachable
112: ; preds = %103
%113 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %105, i32 2
%114 = load i32, i32* %113
%115 = add nsw i32 %114, %107
%116 = icmp sgt i32 %97, %115
br i1 %116, label %119, label %117
117: ; preds = %112
%118 = call i32 @exit(i32 1)
unreachable
119: ; preds = %112
%120 = icmp slt i32 %101, %114
br i1 %120, label %121, label %123
121: ; preds = %119
%122 = call i32 @exit(i32 1)
unreachable
123: ; preds = %119
%124 = icmp eq i32 %101, %114
br i1 %124, label %125, label %126
125: ; preds = %123
store i32 %100, i32* %106
br label %136
126: ; preds = %123
%127 = icmp eq i32 %95, 256
br i1 %127, label %128, label %130
128: ; preds = %126
%129 = call i32 @exit(i32 1)
unreachable
130: ; preds = %99, %126
%131 = sext i32 %95 to i64
%132 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %131, i32 0
store i32 %100, i32* %132
%133 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %131, i32 1
store i32 %100, i32* %133
%134 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %131, i32 2
store i32 %101, i32* %134
%135 = add nsw i32 %95, 1
br label %136
136: ; preds = %125, %130, %93
%137 = phi i32 [ %95, %93 ], [ %95, %125 ], [ %135, %130 ]
%138 = add nuw nsw i64 %94, 1
%139 = icmp eq i64 %138, 50400
br i1 %139, label %82, label %93
140: ; preds = %140, %91
%141 = phi i64 [ 0, %91 ], [ %161, %140 ]
%142 = phi i32 [ 0, %91 ], [ %160, %140 ]
%143 = phi i64 [ 0, %91 ], [ %162, %140 ]
%144 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %141, i32 3
store i32 %142, i32* %144
%145 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %141, i32 1
%146 = load i32, i32* %145
%147 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %141, i32 0
%148 = load i32, i32* %147
%149 = add i32 %142, 1
%150 = add i32 %149, %146
%151 = sub i32 %150, %148
%152 = or i64 %141, 1
%153 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %152, i32 3
store i32 %151, i32* %153
%154 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %152, i32 1
%155 = load i32, i32* %154
%156 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %152, i32 0
%157 = load i32, i32* %156
%158 = add i32 %151, 1
%159 = add i32 %158, %155
%160 = sub i32 %159, %157
%161 = add nuw nsw i64 %141, 2
%162 = add i64 %143, 2
%163 = icmp eq i64 %162, %92
br i1 %163, label %164, label %140
164: ; preds = %140, %87
%165 = phi i32 [ undef, %87 ], [ %160, %140 ]
%166 = phi i64 [ 0, %87 ], [ %161, %140 ]
%167 = phi i32 [ 0, %87 ], [ %160, %140 ]
%168 = icmp eq i64 %89, 0
br i1 %168, label %178, label %169
169: ; preds = %164
%170 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %166, i32 3
store i32 %167, i32* %170
%171 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %166, i32 1
%172 = load i32, i32* %171
%173 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %166, i32 0
%174 = load i32, i32* %173
%175 = add i32 %167, 1
%176 = add i32 %175, %172
%177 = sub i32 %176, %174
br label %178
178: ; preds = %164, %169
%179 = phi i32 [ %165, %164 ], [ %177, %169 ]
%180 = shl nsw i32 %137, 1
%181 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str.3, i64 0, i64 0), i8* %0, i32 %180)
br i1 %83, label %182, label %202
182: ; preds = %178
%183 = zext i32 %137 to i64
%184 = zext i32 %137 to i64
br label %185
185: ; preds = %182, %200
%186 = phi i64 [ 0, %182 ], [ %192, %200 ]
%187 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %186, i32 0
%188 = load i32, i32* %187
%189 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %186, i32 1
%190 = load i32, i32* %189
%191 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i32 %188, i32 %190)
%192 = add nuw nsw i64 %186, 1
%193 = icmp ult i64 %192, %183
br i1 %193, label %194, label %200
194: ; preds = %185
%195 = call i32 @putchar(i32 44)
%196 = and i64 %186, 3
%197 = icmp eq i64 %196, 3
br i1 %197, label %198, label %200
198: ; preds = %194
%199 = call i32 @putchar(i32 10)
br label %200
200: ; preds = %185, %194, %198
%201 = icmp eq i64 %192, %184
br i1 %201, label %202, label %185
202: ; preds = %200, %84, %178
%203 = phi i32 [ %85, %84 ], [ %180, %178 ], [ %180, %200 ]
%204 = phi i32 [ 0, %84 ], [ %179, %178 ], [ %179, %200 ]
%205 = call i32 @putchar(i32 10)
%206 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.92, i64 0, i64 0))
%207 = call i32 @putchar(i32 10)
%208 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([59 x i8], [59 x i8]* @.str.8, i64 0, i64 0), i8* %0, i32 %203)
br i1 %83, label %209, label %258
209: ; preds = %202
%210 = zext i32 %137 to i64
%211 = zext i32 %137 to i64
br label %212
212: ; preds = %209, %231
%213 = phi i64 [ 0, %209 ], [ %223, %231 ]
%214 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %213, i32 0
%215 = load i32, i32* %214
%216 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %213, i32 2
%217 = load i32, i32* %216
%218 = add nsw i32 %217, %215
%219 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %213, i32 1
%220 = load i32, i32* %219
%221 = add nsw i32 %220, %217
%222 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.4, i64 0, i64 0), i32 %218, i32 %221)
%223 = add nuw nsw i64 %213, 1
%224 = icmp ult i64 %223, %210
br i1 %224, label %225, label %231
225: ; preds = %212
%226 = call i32 @putchar(i32 44)
%227 = and i64 %213, 3
%228 = icmp eq i64 %227, 3
br i1 %228, label %229, label %231
229: ; preds = %225
%230 = call i32 @putchar(i32 10)
br label %231
231: ; preds = %212, %225, %229
%232 = icmp eq i64 %223, %211
br i1 %232, label %233, label %212
233: ; preds = %231
%234 = call i32 @putchar(i32 10)
%235 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.92, i64 0, i64 0))
%236 = call i32 @putchar(i32 10)
%237 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([95 x i8], [95 x i8]* @.str.9, i64 0, i64 0), i8* %0, i32 %137)
br i1 %83, label %238, label %263
238: ; preds = %233
%239 = zext i32 %137 to i64
%240 = zext i32 %137 to i64
br label %241
241: ; preds = %238, %256
%242 = phi i64 [ 0, %238 ], [ %248, %256 ]
%243 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %242, i32 2
%244 = load i32, i32* %243
%245 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %242, i32 3
%246 = load i32, i32* %245
%247 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.10, i64 0, i64 0), i32 %244, i32 %246)
%248 = add nuw nsw i64 %242, 1
%249 = icmp ult i64 %248, %239
br i1 %249, label %250, label %256
250: ; preds = %241
%251 = call i32 @putchar(i32 44)
%252 = and i64 %242, 3
%253 = icmp eq i64 %252, 3
br i1 %253, label %254, label %256
254: ; preds = %250
%255 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0))
br label %256
256: ; preds = %241, %250, %254
%257 = icmp eq i64 %248, %240
br i1 %257, label %263, label %241
258: ; preds = %202
%259 = call i32 @putchar(i32 10)
%260 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.92, i64 0, i64 0))
%261 = call i32 @putchar(i32 10)
%262 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([95 x i8], [95 x i8]* @.str.9, i64 0, i64 0), i8* %0, i32 %137)
br label %263
263: ; preds = %256, %258, %233
%264 = call i32 @putchar(i32 10)
%265 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.92, i64 0, i64 0))
%266 = call i32 @putchar(i32 10)
%267 = add nsw i32 %204, 7
%268 = sdiv i32 %267, 8
%269 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @.str.12, i64 0, i64 0), i8* %0, i32 %268)
%270 = call i32 @llvm.smax.i32(i32 %137, i32 0)
%271 = zext i32 %270 to i64
br label %272
272: ; preds = %332, %263
%273 = phi i64 [ %326, %332 ], [ 0, %263 ]
%274 = phi i32 [ %325, %332 ], [ 0, %263 ]
%275 = icmp eq i64 %273, %271
br i1 %275, label %337, label %276
276: ; preds = %272
%277 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %273, i32 3
%278 = load i32, i32* %277
%279 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %273, i32 1
%280 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %273, i32 0
%281 = load i32, i32* %279
%282 = load i32, i32* %280
%283 = add i32 %281, %278
%284 = sub i32 %283, %282
%285 = icmp sgt i32 %278, %284
br i1 %285, label %323, label %286
286: ; preds = %276, %315
%287 = phi i32 [ %319, %315 ], [ %282, %276 ]
%288 = phi i32 [ %317, %315 ], [ %278, %276 ]
%289 = phi i32 [ %316, %315 ], [ %274, %276 ]
%290 = phi i32 [ %301, %315 ], [ %278, %276 ]
%291 = sub i32 %290, %288
%292 = add nsw i32 %291, %287
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [50400 x i32], [50400 x i32]* %4, i64 0, i64 %293
%295 = load i32, i32* %294
%296 = icmp eq i32 %295, 0
%297 = and i32 %290, 7
%298 = shl nuw nsw i32 1, %297
%299 = select i1 %296, i32 0, i32 %298
%300 = or i32 %299, %289
%301 = add nsw i32 %290, 1
%302 = and i32 %301, 7
%303 = icmp eq i32 %302, 0
br i1 %303, label %304, label %315
304: ; preds = %286
%305 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.13, i64 0, i64 0), i32 %300)
%306 = sdiv i32 %301, 8
%307 = icmp slt i32 %306, %268
br i1 %307, label %308, label %310
308: ; preds = %304
%309 = call i32 @putchar(i32 44)
br label %310
310: ; preds = %308, %304
%311 = srem i32 %306, 12
%312 = icmp eq i32 %311, 0
br i1 %312, label %313, label %315
313: ; preds = %310
%314 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i64 0, i64 0))
br label %315
315: ; preds = %310, %313, %286
%316 = phi i32 [ %300, %286 ], [ 0, %313 ], [ 0, %310 ]
%317 = load i32, i32* %277
%318 = load i32, i32* %279
%319 = load i32, i32* %280
%320 = add i32 %318, %317
%321 = sub i32 %320, %319
%322 = icmp slt i32 %290, %321
br i1 %322, label %286, label %323
323: ; preds = %315, %276
%324 = phi i32 [ %278, %276 ], [ %301, %315 ]
%325 = phi i32 [ %274, %276 ], [ %316, %315 ]
%326 = add nuw nsw i64 %273, 1
%327 = trunc i64 %326 to i32
%328 = icmp sgt i32 %137, %327
br i1 %328, label %329, label %332
329: ; preds = %323
%330 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %326, i32 3
%331 = load i32, i32* %330
br label %332
332: ; preds = %323, %329
%333 = phi i32 [ %331, %329 ], [ %204, %323 ]
%334 = icmp eq i32 %324, %333
br i1 %334, label %272, label %335
335: ; preds = %332
%336 = call i32 (...) @abort()
unreachable
337: ; preds = %272
%338 = and i32 %204, 7
%339 = icmp eq i32 %338, 0
br i1 %339, label %342, label %340
340: ; preds = %337
%341 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.13, i64 0, i64 0), i32 %274)
br label %342
342: ; preds = %340, %337
%343 = call i32 @putchar(i32 10)
%344 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.92, i64 0, i64 0))
%345 = call i32 @putchar(i32 10)
%346 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.136, i64 0, i64 0))
%347 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([69 x i8], [69 x i8]* @.str.15, i64 0, i64 0), i8* %0)
%348 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.137, i64 0, i64 0))
%349 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.95, i64 0, i64 0))
%350 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str.96, i64 0, i64 0))
%351 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.97, i64 0, i64 0))
%352 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @str.98, i64 0, i64 0))
%353 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @str.99, i64 0, i64 0))
%354 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.100, i64 0, i64 0))
%355 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([35 x i8], [35 x i8]* @str.101, i64 0, i64 0))
%356 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([42 x i8], [42 x i8]* @str.102, i64 0, i64 0))
%357 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.103, i64 0, i64 0))
%358 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @str.104, i64 0, i64 0))
%359 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @str.105, i64 0, i64 0))
%360 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([108 x i8], [108 x i8]* @str.106, i64 0, i64 0))
%361 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 0, i32 0
%362 = load i32, i32* %361
%363 = add nsw i32 %137, -1
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %364, i32 1
%366 = load i32, i32* %365
%367 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([43 x i8], [43 x i8]* @.str.29, i64 0, i64 0), i32 %362, i32 %366)
%368 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @str.107, i64 0, i64 0))
%369 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @.str.31, i64 0, i64 0), i32 %363)
%370 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @str.108, i64 0, i64 0))
%371 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([52 x i8], [52 x i8]* @str.109, i64 0, i64 0))
%372 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.34, i64 0, i64 0), i8* %0)
%373 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str.110, i64 0, i64 0))
%374 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([65 x i8], [65 x i8]* @.str.36, i64 0, i64 0), i8* %0)
%375 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str.111, i64 0, i64 0))
%376 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str.112, i64 0, i64 0))
%377 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @str.113, i64 0, i64 0))
%378 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str.119, i64 0, i64 0))
%379 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str.115, i64 0, i64 0))
%380 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([112 x i8], [112 x i8]* @.str.42, i64 0, i64 0), i8* %0, i8* %0)
%381 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([85 x i8], [85 x i8]* @.str.43, i64 0, i64 0), i8* %0)
%382 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @.str.44, i64 0, i64 0), i8* %0)
%383 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @str.116, i64 0, i64 0))
%384 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.117, i64 0, i64 0))
%385 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.118, i64 0, i64 0))
%386 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str.119, i64 0, i64 0))
%387 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.120, i64 0, i64 0))
%388 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @str.121, i64 0, i64 0))
%389 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str.122, i64 0, i64 0))
%390 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @str.123, i64 0, i64 0))
%391 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([34 x i8], [34 x i8]* @str.124, i64 0, i64 0))
%392 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.125, i64 0, i64 0))
%393 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.126, i64 0, i64 0))
%394 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.152, i64 0, i64 0))
%395 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str.128, i64 0, i64 0))
%396 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.153, i64 0, i64 0))
%397 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str.130, i64 0, i64 0))
%398 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @str.154, i64 0, i64 0))
%399 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str.132, i64 0, i64 0))
%400 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.156, i64 0, i64 0))
%401 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str.134, i64 0, i64 0))
%402 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.158, i64 0, i64 0))
%403 = call i32 @putchar(i32 10)
%404 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.136, i64 0, i64 0))
%405 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([61 x i8], [61 x i8]* @.str.64, i64 0, i64 0), i8* %0)
%406 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.137, i64 0, i64 0))
%407 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @str.138, i64 0, i64 0))
%408 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str.139, i64 0, i64 0))
%409 = load i32, i32* %361
%410 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 0, i32 2
%411 = load i32, i32* %410
%412 = add nsw i32 %411, %409
%413 = load i32, i32* %365
%414 = getelementptr inbounds [256 x %struct.anon], [256 x %struct.anon]* %6, i64 0, i64 %364, i32 2
%415 = load i32, i32* %414
%416 = add nsw i32 %415, %413
%417 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str.67, i64 0, i64 0), i32 %412, i32 %416)
%418 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.140, i64 0, i64 0))
%419 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @.str.69, i64 0, i64 0), i32 %363)
%420 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @str.141, i64 0, i64 0))
%421 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @str.142, i64 0, i64 0))
%422 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.72, i64 0, i64 0), i8* %0)
%423 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.143, i64 0, i64 0))
%424 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @.str.74, i64 0, i64 0), i8* %0)
%425 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.144, i64 0, i64 0))
%426 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @str.145, i64 0, i64 0))
%427 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str.146, i64 0, i64 0))
%428 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.153, i64 0, i64 0))
%429 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.148, i64 0, i64 0))
%430 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([100 x i8], [100 x i8]* @.str.79, i64 0, i64 0), i8* %0, i8* %0)
%431 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([73 x i8], [73 x i8]* @.str.80, i64 0, i64 0), i8* %0)
%432 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([51 x i8], [51 x i8]* @.str.81, i64 0, i64 0), i8* %0)
%433 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.149, i64 0, i64 0))
%434 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.83, i64 0, i64 0))
%435 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.84, i64 0, i64 0))
%436 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([48 x i8], [48 x i8]* @.str.85, i64 0, i64 0))
%437 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.150, i64 0, i64 0))
%438 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @str.151, i64 0, i64 0))
%439 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.152, i64 0, i64 0))
%440 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str.153, i64 0, i64 0))
%441 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @str.154, i64 0, i64 0))
%442 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str.155, i64 0, i64 0))
%443 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @str.156, i64 0, i64 0))
%444 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str.157, i64 0, i64 0))
%445 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str.158, i64 0, i64 0))
ret void
}