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

/* Forward declarations */

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

/* Variables and functions */
int /*<<< orphan*/ exit(int);
scalar_t__ fclose(int /*<<< orphan*/ *);
scalar_t__ ferror(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char const *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int is_alpha(unsigned int);
int is_graphic(unsigned int);
int is_numeric(unsigned int);
scalar_t__ memcmp(unsigned char *, unsigned char *, int);
int /*<<< orphan*/ *stderr;
void output_attributes(const char *filename, const char *version) {
  FILE *stream;
  enum {
    NON_GRAPHIC = 0,
    GRAPHIC_NON_ALPHANUMERIC = 1,
    NUMERIC = 2,
    ALPHABETIC = 3
  };
  unsigned char attribute[0x110000];
  unsigned char attribute_packed[0x44000];
  unsigned int pages[0x440];
  unsigned int max_nonempty_page;
  {
    unsigned int ch;
    for (ch = 0; ch < 0x110000; ch++) {
      bool graphic = is_graphic(ch);
      bool alpha = is_alpha(ch);
      bool numeric = is_numeric(ch);
      if (alpha && numeric)
        fprintf(stderr, "Character 0x%04x is both alpha and numeric\n", ch);
      if (alpha && !graphic)
        fprintf(stderr, "Character 0x%04x is alpha but not graphic\n", ch);
      if (numeric && !graphic)
        fprintf(stderr, "Character 0x%04x is numeric but not graphic\n", ch);
      attribute[ch] = (alpha     ? ALPHABETIC
                       : numeric ? NUMERIC
                       : graphic ? GRAPHIC_NON_ALPHANUMERIC
                                 : NON_GRAPHIC);
    }
  }
  stream = fopen(filename, "w");
  if (stream == NULL) {
    fprintf(stderr, "cannot open '%s' for writing\n", filename);
    exit(1);
  }
  fprintf(stream, "/*\n");
  fprintf(stream, " * %s\n", filename);
  fprintf(stream, " *\n");
  fprintf(stream, " * Common Lisp character attribute table.\n");
  fprintf(
      stream,
      " * Generated automatically by the gen-ctype utility for Unicode %s.\n",
      version);
  fprintf(stream, " */\n");
  fprintf(stream, "\n");
  {
    unsigned int i1, i2;
    for (i1 = 0; i1 < 0x44000; i1++) {
      unsigned char b = 0;
      for (i2 = 0; i2 < 4; i2++)
        b |= attribute[4 * i1 + i2] << (2 * i2);
      attribute_packed[i1] = b;
    }
  }
  {
    unsigned int i, j;
    for (i = 0; i < 0x440; i++) {
      for (j = 0; j < i; j++)
        if (memcmp(&attribute_packed[j << 8], &attribute_packed[i << 8],
                   1 << 8) == 0)
          break;
      pages[i] = j;
    }
  }
  max_nonempty_page = 0;
  {
    unsigned int i1, i2;
    for (i1 = 0; i1 < 0x440; i1++)
      for (i2 = 0; i2 < 0x100; i2++)
        if (attribute_packed[(i1 << 8) + i2] != 0) {
          max_nonempty_page = i1;
          break;
        }
  }
  {
    unsigned int i1, i2a, i2b;
    for (i1 = 0; i1 < 0x440; i1++)
      if (pages[i1] == i1) {
        fprintf(
            stream,
            "static const uintB unicode_attribute_table_page%02x[256] = {\n",
            4 * i1);
        for (i2a = 0; i2a < 32; i2a++) {
          fprintf(stream, "  ");
          for (i2b = 0; i2b < 8; i2b++) {
            unsigned int i2 = 8 * i2a + i2b;
            fprintf(stream, "0x%02x%s ", attribute_packed[(i1 << 8) + i2],
                    (i2 < 255 ? "," : " "));
          }
          fprintf(stream, "/* 0x%04x-0x%04x */\n", 4 * ((i1 << 8) + (8 * i2a)),
                  4 * ((i1 << 8) + (8 * i2a + 7)) + 3);
        }
        fprintf(stream, "};\n");
        fprintf(stream, "\n");
      }
  }
  {
    unsigned int i1;
    fprintf(stream, "const uintB * const unicode_attribute_table[%d] = {\n",
            max_nonempty_page + 1);
    for (i1 = 0; i1 <= max_nonempty_page; i1++) {
      if ((i1 % 2) == 0)
        fprintf(stream, " ");
      fprintf(stream, " unicode_attribute_table_page%02x%s", 4 * pages[i1],
              (i1 < max_nonempty_page ? "," : ""));
      if ((i1 % 2) == 1 || i1 == max_nonempty_page)
        fprintf(stream, "\n");
    }
    fprintf(stream, "};\n");
    fprintf(stream, "\n");
  }
  if (ferror(stream) || fclose(stream)) {
    fprintf(stderr, "error writing to '%s'\n", filename);
    exit(1);
  }
}


x86 assembly (clang, -O0):
<output_attributes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x155170,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x155128(%rbp)
cmpl   $0x110000,-0x155128(%rbp)
jae    1320 <output_attributes+0x190>
mov    -0x155128(%rbp),%edi
call   1050 <is_graphic@plt>
mov    %eax,-0x15512c(%rbp)
mov    -0x155128(%rbp),%edi
call   10b0 <is_alpha@plt>
mov    %eax,-0x155130(%rbp)
mov    -0x155128(%rbp),%edi
call   1060 <is_numeric@plt>
mov    %eax,-0x155134(%rbp)
cmpl   $0x0,-0x155130(%rbp)
je     1228 <output_attributes+0x98>
cmpl   $0x0,-0x155134(%rbp)
je     1228 <output_attributes+0x98>
mov    0x2dcf(%rip),%rax
mov    (%rax),%rdi
mov    -0x155128(%rbp),%edx
lea    0xddf(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x155130(%rbp)
je     1260 <output_attributes+0xd0>
cmpl   $0x0,-0x15512c(%rbp)
jne    1260 <output_attributes+0xd0>
mov    0x2d97(%rip),%rax
mov    (%rax),%rdi
mov    -0x155128(%rbp),%edx
lea    0xdd3(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x155134(%rbp)
je     1298 <output_attributes+0x108>
cmpl   $0x0,-0x15512c(%rbp)
jne    1298 <output_attributes+0x108>
mov    0x2d5f(%rip),%rax
mov    (%rax),%rdi
mov    -0x155128(%rbp),%edx
lea    0xdc6(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
cmpl   $0x0,-0x155130(%rbp)
je     12b5 <output_attributes+0x125>
mov    $0x3,%eax
mov    %eax,-0x155168(%rbp)
jmp    12f7 <output_attributes+0x167>
cmpl   $0x0,-0x155134(%rbp)
je     12d2 <output_attributes+0x142>
mov    $0x2,%eax
mov    %eax,-0x15516c(%rbp)
jmp    12eb <output_attributes+0x15b>
mov    -0x15512c(%rbp),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x15516c(%rbp)
mov    -0x15516c(%rbp),%eax
mov    %eax,-0x155168(%rbp)
mov    -0x155168(%rbp),%eax
mov    %al,%cl
mov    -0x155128(%rbp),%eax
mov    %cl,-0x110020(%rbp,%rax,1)
mov    -0x155128(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x155128(%rbp)
jmp    11ad <output_attributes+0x1d>
mov    -0x8(%rbp),%rdi
lea    0xd59(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1365 <output_attributes+0x1d5>
mov    0x2c9a(%rip),%rax
mov    (%rax),%rdi
mov    -0x8(%rbp),%rdx
lea    0xd32(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>
mov    -0x18(%rbp),%rdi
lea    0xd34(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
mov    -0x8(%rbp),%rdx
lea    0xd22(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
lea    0xd17(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
lea    0xd09(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
mov    -0x10(%rbp),%rdx
lea    0xd1e(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
lea    0xdae(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
lea    0xe13(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x155138(%rbp)
cmpl   $0x44000,-0x155138(%rbp)
jae    1493 <output_attributes+0x303>
movb   $0x0,-0x15513d(%rbp)
movl   $0x0,-0x15513c(%rbp)
cmpl   $0x4,-0x15513c(%rbp)
jae    146c <output_attributes+0x2dc>
mov    -0x155138(%rbp),%eax
shl    $0x2,%eax
add    -0x15513c(%rbp),%eax
mov    %eax,%eax
movzbl -0x110020(%rbp,%rax,1),%eax
ff
mov    -0x15513c(%rbp),%ecx
shl    $0x1,%ecx
shl    %cl,%eax
mov    %eax,%ecx
movzbl -0x15513d(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x15513d(%rbp)
mov    -0x15513c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x15513c(%rbp)
jmp    1416 <output_attributes+0x286>
mov    -0x15513d(%rbp),%cl
mov    -0x155138(%rbp),%eax
mov    %cl,-0x154020(%rbp,%rax,1)
mov    -0x155138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x155138(%rbp)
jmp    13f5 <output_attributes+0x265>
movl   $0x0,-0x155144(%rbp)
cmpl   $0x440,-0x155144(%rbp)
jae    154c <output_attributes+0x3bc>
movl   $0x0,-0x155148(%rbp)
mov    -0x155148(%rbp),%eax
cmp    -0x155144(%rbp),%eax
jae    1525 <output_attributes+0x395>
mov    -0x155148(%rbp),%eax
shl    $0x8,%eax
mov    %eax,%eax
lea    -0x154020(%rbp),%rdi
add    %rax,%rdi
mov    -0x155144(%rbp),%eax
shl    $0x8,%eax
mov    %eax,%eax
lea    -0x154020(%rbp),%rsi
add    %rax,%rsi
mov    $0x100,%edx
call   1070 <memcmp@plt>
cmp    $0x0,%rax
jne    150c <output_attributes+0x37c>
jmp    1525 <output_attributes+0x395>
jmp    1511 <output_attributes+0x381>
mov    -0x155148(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x155148(%rbp)
jmp    14b7 <output_attributes+0x327>
mov    -0x155148(%rbp),%ecx
mov    -0x155144(%rbp),%eax
mov    %ecx,-0x155120(%rbp,%rax,4)
mov    -0x155144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x155144(%rbp)
jmp    149d <output_attributes+0x30d>
movl   $0x0,-0x155124(%rbp)
movl   $0x0,-0x15514c(%rbp)
cmpl   $0x440,-0x15514c(%rbp)
jae    15ef <output_attributes+0x45f>
movl   $0x0,-0x155150(%rbp)
cmpl   $0x100,-0x155150(%rbp)
jae    15d6 <output_attributes+0x446>
mov    -0x15514c(%rbp),%eax
shl    $0x8,%eax
add    -0x155150(%rbp),%eax
mov    %eax,%eax
movzbl -0x154020(%rbp,%rax,1),%eax
ff
cmp    $0x0,%eax
je     15bd <output_attributes+0x42d>
mov    -0x15514c(%rbp),%eax
mov    %eax,-0x155124(%rbp)
jmp    15d6 <output_attributes+0x446>
jmp    15c2 <output_attributes+0x432>
mov    -0x155150(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x155150(%rbp)
jmp    157a <output_attributes+0x3ea>
jmp    15db <output_attributes+0x44b>
mov    -0x15514c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x15514c(%rbp)
jmp    1560 <output_attributes+0x3d0>
movl   $0x0,-0x155154(%rbp)
cmpl   $0x440,-0x155154(%rbp)
jae    1786 <output_attributes+0x5f6>
mov    -0x155154(%rbp),%eax
mov    -0x155120(%rbp,%rax,4),%eax
cmp    -0x155154(%rbp),%eax
jne    176d <output_attributes+0x5dd>
mov    -0x18(%rbp),%rdi
mov    -0x155154(%rbp),%edx
shl    $0x2,%edx
lea    0xaed(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x155158(%rbp)
cmpl   $0x20,-0x155158(%rbp)
jae    1749 <output_attributes+0x5b9>
mov    -0x18(%rbp),%rdi
lea    0xb02(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x15515c(%rbp)
cmpl   $0x8,-0x15515c(%rbp)
jae    16ef <output_attributes+0x55f>
mov    -0x155158(%rbp),%eax
shl    $0x3,%eax
add    -0x15515c(%rbp),%eax
mov    %eax,-0x155160(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x155154(%rbp),%eax
shl    $0x8,%eax
add    -0x155160(%rbp),%eax
mov    %eax,%eax
movzbl -0x154020(%rbp,%rax,1),%edx
ff
mov    -0x155160(%rbp),%esi
lea    0xaa6(%rip),%rcx
lea    0xaab(%rip),%rax
cmp    $0xff,%esi
cmovb  %rax,%rcx
lea    0xa90(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x15515c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x15515c(%rbp)
jmp    1670 <output_attributes+0x4e0>
mov    -0x18(%rbp),%rdi
mov    -0x155154(%rbp),%edx
shl    $0x8,%edx
mov    -0x155158(%rbp),%eax
shl    $0x3,%eax
add    %eax,%edx
shl    $0x2,%edx
mov    -0x155154(%rbp),%ecx
shl    $0x8,%ecx
mov    -0x155158(%rbp),%eax
shl    $0x3,%eax
add    $0x7,%eax
add    %eax,%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
lea    0xa42(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x155158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x155158(%rbp)
jmp    1647 <output_attributes+0x4b7>
mov    -0x18(%rbp),%rdi
lea    0xa31(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
lea    0xa91(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1772 <output_attributes+0x5e2>
mov    -0x155154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x155154(%rbp)
jmp    15f9 <output_attributes+0x469>
mov    -0x18(%rbp),%rdi
mov    -0x155124(%rbp),%edx
add    $0x1,%edx
lea    0x9ef(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
movl   $0x0,-0x155164(%rbp)
mov    -0x155164(%rbp),%eax
cmp    -0x155124(%rbp),%eax
ja     1874 <output_attributes+0x6e4>
mov    -0x155164(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    17e1 <output_attributes+0x651>
mov    -0x18(%rbp),%rdi
lea    0x988(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
mov    -0x155164(%rbp),%eax
mov    -0x155120(%rbp,%rax,4),%edx
shl    $0x2,%edx
mov    -0x155164(%rbp),%esi
mov    -0x155124(%rbp),%r8d
lea    0x9ef(%rip),%rcx
lea    0x95e(%rip),%rax
cmp    %r8d,%esi
cmovb  %rax,%rcx
lea    0x9a0(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x155164(%rbp),%eax
and    $0x1,%eax
cmp    $0x1,%eax
je     1849 <output_attributes+0x6b9>
mov    -0x155164(%rbp),%eax
cmp    -0x155124(%rbp),%eax
jne    185b <output_attributes+0x6cb>
mov    -0x18(%rbp),%rdi
lea    0x9a3(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
jmp    1860 <output_attributes+0x6d0>
mov    -0x155164(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x155164(%rbp)
jmp    17ab <output_attributes+0x61b>
mov    -0x18(%rbp),%rdi
lea    0x906(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
lea    0x966(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    -0x18(%rbp),%rdi
call   1030 <ferror@plt>
cmp    $0x0,%rax
jne    18be <output_attributes+0x72e>
mov    -0x18(%rbp),%rdi
call   1040 <fclose@plt>
cmp    $0x0,%rax
je     18e4 <output_attributes+0x754>
mov    0x271b(%rip),%rax
mov    (%rax),%rdi
mov    -0x8(%rbp),%rdx
lea    0x90f(%rip),%rsi
mov    $0x0,%al
call   1080 <fprintf@plt>
mov    $0x1,%edi
call   10a0 <exit@plt>
add    $0x155170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<output_attributes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x155148,%rsp
mov    %rsi,(%rsp)
mov    %rdi,0x18(%rsp)
mov    $0x3,%r12d
lea    0xea5(%rip),%r13
xor    %ebp,%ebp
jmp    11fe <output_attributes+0x4e>
nopl   0x0(%rax,%rax,1)
test   %ebx,%ebx
cmovne %r12d,%ecx
mov    %cl,0x45140(%rsp,%rbp,1)
add    $0x1,%rbp
cmp    $0x110000,%rbp
je     12a0 <output_attributes+0xf0>
mov    %ebp,%edi
call   1050 <is_graphic@plt>
mov    %eax,%r14d
mov    %ebp,%edi
call   10d0 <is_alpha@plt>
mov    %eax,%ebx
mov    %ebp,%edi
call   1060 <is_numeric@plt>
mov    %eax,%r15d
test   %ebx,%ebx
je     123e <output_attributes+0x8e>
test   %r15d,%r15d
je     123e <output_attributes+0x8e>
mov    0x2db5(%rip),%rax
mov    (%rax),%rdi
lea    0xe1b(%rip),%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
test   %ebx,%ebx
je     125d <output_attributes+0xad>
test   %r14d,%r14d
jne    125d <output_attributes+0xad>
mov    0x2d92(%rip),%rax
mov    (%rax),%rdi
mov    %r13,%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
test   %r15d,%r15d
je     1281 <output_attributes+0xd1>
test   %r14d,%r14d
jne    1281 <output_attributes+0xd1>
mov    0x2d72(%rip),%rax
mov    (%rax),%rdi
lea    0xe2f(%rip),%rsi
mov    %ebp,%edx
xor    %eax,%eax
call   1090 <fprintf@plt>
xor    %eax,%eax
test   %r14d,%r14d
setne  %dl
mov    $0x2,%ecx
test   %r15d,%r15d
jne    11e0 <output_attributes+0x30>
mov    %dl,%al
mov    %eax,%ecx
jmp    11e0 <output_attributes+0x30>
lea    0xe2d(%rip),%rsi
mov    0x18(%rsp),%rbx
mov    %rbx,%rdi
call   10a0 <fopen@plt>
test   %rax,%rax
je     194f <output_attributes+0x79f>
mov    %rax,%r15
lea    0xe2d(%rip),%rdi
mov    $0x3,%esi
mov    $0x1,%edx
mov    %rax,%rcx
call   10c0 <fwrite@plt>
lea    0xe18(%rip),%rsi
xor    %ebp,%ebp
mov    %r15,%rdi
mov    %rbx,%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    0xe09(%rip),%rdi
mov    $0x3,%esi
mov    $0x1,%edx
mov    %r15,%rcx
call   10c0 <fwrite@plt>
lea    0xdf4(%rip),%rdi
mov    $0x2a,%esi
mov    $0x1,%edx
mov    %r15,%rcx
call   10c0 <fwrite@plt>
lea    0xe06(%rip),%rsi
mov    %r15,%rdi
mov    (%rsp),%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    0xe93(%rip),%rdi
mov    $0x4,%esi
mov    $0x1,%edx
mov    %r15,%rcx
call   10c0 <fwrite@plt>
mov    $0xa,%edi
mov    %r15,%rsi
call   1070 <fputc@plt>
nopl   0x0(%rax)
movdqa 0x45140(%rsp,%rbp,4),%xmm7
movdqa 0x45150(%rsp,%rbp,4),%xmm10
movdqa 0x45160(%rsp,%rbp,4),%xmm2
movdqa 0x45170(%rsp,%rbp,4),%xmm14
movdqa %xmm14,%xmm0
movdqa 0xc6d(%rip),%xmm4
pand   %xmm4,%xmm0
movdqa %xmm2,%xmm1
pand   %xmm4,%xmm1
packuswb %xmm0,%xmm1
movdqa %xmm10,%xmm0
pand   %xmm4,%xmm0
movdqa %xmm7,%xmm6
pand   %xmm4,%xmm6
packuswb %xmm0,%xmm6
packuswb %xmm1,%xmm6
movdqa %xmm14,%xmm0
pxor   %xmm3,%xmm3
punpckhbw %xmm3,%xmm0
movdqa %xmm0,(%rsp)
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xd4,%xmm0,%xmm0
movdqa %xmm14,%xmm1
punpcklbw %xmm3,%xmm1
movdqa %xmm1,0x20(%rsp)
pshufd $0xe8,%xmm1,%xmm1
pshuflw $0xd4,%xmm1,%xmm4
punpckldq %xmm0,%xmm4
movdqa %xmm2,%xmm15
punpckhbw %xmm3,%xmm15
pshufd $0xe8,%xmm15,%xmm0
pshuflw $0xed,%xmm0,%xmm0
movdqa %xmm2,%xmm13
punpcklbw %xmm3,%xmm13
pshufd $0xe8,%xmm13,%xmm5
pshuflw $0xed,%xmm5,%xmm5
punpckldq %xmm0,%xmm5
packuswb %xmm4,%xmm5
movdqa %xmm10,%xmm12
punpckhbw %xmm3,%xmm12
pshufd $0xe8,%xmm12,%xmm4
pshuflw $0xd4,%xmm4,%xmm4
movdqa %xmm10,%xmm8
punpcklbw %xmm3,%xmm8
pshufd $0xe8,%xmm8,%xmm1
pshuflw $0xd4,%xmm1,%xmm1
punpckldq %xmm4,%xmm1
movdqa %xmm7,%xmm9
punpckhbw %xmm3,%xmm9
pshufd $0xe8,%xmm9,%xmm4
pshuflw $0xed,%xmm4,%xmm0
movdqa %xmm7,%xmm11
punpcklbw %xmm3,%xmm11
pshufd $0xe8,%xmm11,%xmm4
pshuflw $0xed,%xmm4,%xmm4
punpckldq %xmm0,%xmm4
packuswb %xmm1,%xmm4
shufps $0xcc,%xmm5,%xmm4
movdqa 0xb7d(%rip),%xmm3
pand   %xmm3,%xmm14
pshuflw $0xe7,%xmm14,%xmm0
pshufhw $0xe7,%xmm0,%xmm0
pshufd $0x24,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
pand   %xmm3,%xmm2
pshuflw $0xe7,%xmm2,%xmm1
pshufhw $0xe7,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pshuflw $0xb1,%xmm1,%xmm1
packuswb %xmm0,%xmm1
pand   %xmm3,%xmm10
pshuflw $0xe7,%xmm10,%xmm0
pshufhw $0xe7,%xmm0,%xmm0
pshufd $0x24,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
pand   %xmm3,%xmm7
pshuflw $0xe7,%xmm7,%xmm2
pshufhw $0xe7,%xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pshuflw $0xb1,%xmm2,%xmm2
packuswb %xmm0,%xmm2
shufps $0xcc,%xmm1,%xmm2
pshufd $0xe7,(%rsp),%xmm0
pshuflw $0x74,%xmm0,%xmm0
pshufd $0xe7,0x20(%rsp),%xmm1
pshuflw $0x74,%xmm1,%xmm1
punpckldq %xmm0,%xmm1
pshufd $0xe7,%xmm15,%xmm0
pshuflw $0xe7,%xmm0,%xmm0
pshufd $0xe7,%xmm13,%xmm3
pshuflw $0xe7,%xmm3,%xmm3
punpckldq %xmm0,%xmm3
packuswb %xmm1,%xmm3
pshufd $0xe7,%xmm12,%xmm0
pshuflw $0x74,%xmm0,%xmm0
pshufd $0xe7,%xmm8,%xmm1
pshuflw $0x74,%xmm1,%xmm1
punpckldq %xmm0,%xmm1
pshufd $0xe7,%xmm9,%xmm0
pshuflw $0xe7,%xmm0,%xmm0
pshufd $0xe7,%xmm11,%xmm5
pshuflw $0xe7,%xmm5,%xmm5
punpckldq %xmm0,%xmm5
packuswb %xmm1,%xmm5
shufps $0xcc,%xmm3,%xmm5
psllw  $0x2,%xmm4
pand   0xa9b(%rip),%xmm4
por    %xmm6,%xmm4
psllw  $0x4,%xmm2
pand   0xa9a(%rip),%xmm2
por    %xmm4,%xmm2
psllw  $0x6,%xmm5
pand   0xa99(%rip),%xmm5
por    %xmm2,%xmm5
movdqa %xmm5,0x1140(%rsp,%rbp,1)
add    $0x10,%rbp
cmp    $0x44000,%rbp
jne    1360 <output_attributes+0x1b0>
xor    %r13d,%r13d
lea    0x1140(%rsp),%r12
jmp    15f2 <output_attributes+0x442>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,0x40(%rsp,%r13,4)
add    $0x1,%r13
cmp    $0x440,%r13
je     164a <output_attributes+0x49a>
mov    $0x0,%ebx
test   %r13,%r13
je     15e0 <output_attributes+0x430>
mov    %r13,%rax
shl    $0x8,%rax
lea    (%rsp,%rax,1),%r14
add    $0x1140,%r14
mov    %r12,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbp,%rdi
mov    %r14,%rsi
mov    $0x100,%edx
call   1080 <memcmp@plt>
test   %rax,%rax
je     15e0 <output_attributes+0x430>
add    $0x1,%rbx
add    $0x100,%rbp
cmp    %rbx,%r13
jne    1620 <output_attributes+0x470>
mov    %r13,%rbx
jmp    15e0 <output_attributes+0x430>
lea    0x1143(%rsp),%rax
xor    %ecx,%ecx
xor    %esi,%esi
jmp    1675 <output_attributes+0x4c5>
nopl   0x0(%rax,%rax,1)
mov    %ecx,%esi
add    $0x1,%rcx
add    $0x100,%rax
cmp    $0x440,%rcx
je     16aa <output_attributes+0x4fa>
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
cmpb   $0x0,-0x3(%rax,%rdx,1)
jne    1660 <output_attributes+0x4b0>
cmpb   $0x0,-0x2(%rax,%rdx,1)
jne    1660 <output_attributes+0x4b0>
cmpb   $0x0,-0x1(%rax,%rdx,1)
jne    1660 <output_attributes+0x4b0>
cmpb   $0x0,(%rax,%rdx,1)
jne    1660 <output_attributes+0x4b0>
add    $0x4,%rdx
cmp    $0x100,%rdx
jne    1680 <output_attributes+0x4d0>
jmp    1662 <output_attributes+0x4b2>
mov    %rsi,0x38(%rsp)
mov    $0x1f,%r12d
lea    0x1140(%rsp),%r13
lea    0xaf0(%rip),%rbp
lea    0xaf3(%rip),%rbx
xor    %edi,%edi
jmp    16ef <output_attributes+0x53f>
nop
add    $0x1,%rdi
add    $0x400,%r12d
add    $0x100,%r13
cmp    $0x440,%rdi
je     185a <output_attributes+0x6aa>
mov    0x40(%rsp,%rdi,4),%eax
cmp    %rax,%rdi
jne    16d0 <output_attributes+0x520>
mov    %rdi,0x20(%rsp)
lea    0x0(,%rdi,4),%edx
mov    %r15,%rdi
lea    0xa65(%rip),%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    $0x7,%r14d
mov    %r12d,(%rsp)
nop
mov    $0x2,%esi
mov    $0x1,%edx
lea    0xa80(%rip),%rdi
mov    %r15,%rcx
call   10c0 <fwrite@plt>
movzbl -0x7(%r13,%r14,1),%edx
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %rbx,%rcx
xor    %eax,%eax
call   1090 <fprintf@plt>
movzbl -0x6(%r13,%r14,1),%edx
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %rbx,%rcx
xor    %eax,%eax
call   1090 <fprintf@plt>
movzbl -0x5(%r13,%r14,1),%edx
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %rbx,%rcx
xor    %eax,%eax
call   1090 <fprintf@plt>
movzbl -0x4(%r13,%r14,1),%edx
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %rbx,%rcx
xor    %eax,%eax
call   1090 <fprintf@plt>
movzbl -0x3(%r13,%r14,1),%edx
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %rbx,%rcx
xor    %eax,%eax
call   1090 <fprintf@plt>
movzbl -0x2(%r13,%r14,1),%edx
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %rbx,%rcx
xor    %eax,%eax
call   1090 <fprintf@plt>
movzbl -0x1(%r13,%r14,1),%edx
mov    %r15,%rdi
mov    %rbp,%rsi
mov    %rbx,%rcx
xor    %eax,%eax
call   1090 <fprintf@plt>
movzbl 0x0(%r13,%r14,1),%edx
cmp    $0xff,%r14
lea    0x9cb(%rip),%rcx
cmovb  %rbx,%rcx
mov    %r15,%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    -0x1f(%r12),%edx
mov    %r15,%rdi
lea    0x9b9(%rip),%rsi
mov    %r12d,%ecx
xor    %eax,%eax
call   1090 <fprintf@plt>
add    $0x20,%r12d
add    $0x8,%r14
cmp    $0x107,%r14
jne    1720 <output_attributes+0x570>
mov    $0x3,%esi
mov    $0x1,%edx
lea    0x99e(%rip),%rdi
mov    %r15,%rcx
call   10c0 <fwrite@plt>
mov    $0xa,%edi
mov    %r15,%rsi
call   1070 <fputc@plt>
mov    (%rsp),%r12d
mov    0x20(%rsp),%rdi
jmp    16d0 <output_attributes+0x520>
mov    0x38(%rsp),%r13
lea    0x1(%r13),%edx
lea    0x96f(%rip),%rsi
mov    %r15,%rdi
xor    %eax,%eax
call   1090 <fprintf@plt>
lea    0x9cd(%rip),%r14
lea    0x98c(%rip),%r12
xor    %ebp,%ebp
jmp    18a5 <output_attributes+0x6f5>
cs nopw 0x0(%rax,%rax,1)
mov    $0xa,%edi
mov    %r15,%rsi
call   1070 <fputc@plt>
add    $0x1,%ebp
cmp    %r13d,%ebp
ja     18e5 <output_attributes+0x735>
test   $0x1,%bpl
jne    18b8 <output_attributes+0x708>
mov    $0x20,%edi
mov    %r15,%rsi
call   1070 <fputc@plt>
mov    %ebp,%eax
mov    0x40(%rsp,%rax,4),%edx
shl    $0x2,%edx
cmp    %r13d,%ebp
mov    %r14,%rcx
cmovb  %rbx,%rcx
mov    %r15,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1090 <fprintf@plt>
test   $0x1,%bpl
jne    1890 <output_attributes+0x6e0>
cmp    %ebp,%r13d
jne    189d <output_attributes+0x6ed>
jmp    1890 <output_attributes+0x6e0>
lea    0x8e9(%rip),%rdi
mov    $0x3,%esi
mov    $0x1,%edx
mov    %r15,%rcx
call   10c0 <fwrite@plt>
mov    $0xa,%edi
mov    %r15,%rsi
call   1070 <fputc@plt>
mov    %r15,%rdi
call   1030 <ferror@plt>
test   %rax,%rax
jne    1937 <output_attributes+0x787>
mov    %r15,%rdi
call   1040 <fclose@plt>
test   %rax,%rax
jne    1937 <output_attributes+0x787>
add    $0x155148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x26a2(%rip),%rax
mov    (%rax),%rdi
lea    0x8ea(%rip),%rsi
mov    0x18(%rsp),%rdx
jmp    1963 <output_attributes+0x7b3>
mov    0x268a(%rip),%rax
mov    (%rax),%rdi
lea    0x776(%rip),%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   1090 <fprintf@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>

LLVM IR (-O0):
@stderr = global i32* null
@.str = [44 x i8] c"Character 0x%04x is both alpha and numeric\0A\00"
@.str.1 = [43 x i8] c"Character 0x%04x is alpha but not graphic\0A\00"
@.str.2 = [45 x i8] c"Character 0x%04x is numeric but not graphic\0A\00"
@.str.3 = [2 x i8] c"w\00"
@.str.4 = [30 x i8] c"cannot open '%s' for writing\0A\00"
@.str.5 = [4 x i8] c"/*\0A\00"
@.str.6 = [7 x i8] c" * %s\0A\00"
@.str.7 = [4 x i8] c" *\0A\00"
@.str.8 = [43 x i8] c" * Common Lisp character attribute table.\0A\00"
@.str.9 = [69 x i8] c" * Generated automatically by the gen-ctype utility for Unicode %s.\0A\00"
@.str.10 = [5 x i8] c" */\0A\00"
@.str.11 = [2 x i8] c"\0A\00"
@.str.12 = [62 x i8] c"static const uintB unicode_attribute_table_page%02x[256] = {\0A\00"
@.str.13 = [3 x i8] c" \00"
@.str.14 = [10 x i8] c"0x%02x%s \00"
@.str.15 = [2 x i8] c",\00"
@.str.16 = [2 x i8] c" \00"
@.str.17 = [21 x i8] c"/* 0x%04x-0x%04x */\0A\00"
@.str.18 = [4 x i8] c"};\0A\00"
@.str.19 = [53 x i8] c"const uintB * const unicode_attribute_table[%d] = {\0A\00"
@.str.20 = [36 x i8] c" unicode_attribute_table_page%02x%s\00"
@.str.21 = [1 x i8] zeroinitializer
@.str.22 = [23 x i8] c"error writing to '%s'\0A\00"
define void @output_attributes(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32*
%6 = alloca [1114112 x i8]
%7 = alloca [278528 x i8]
%8 = alloca [1088 x i32]
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i8
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
store i8* %0, i8** %3
store i8* %1, i8** %4
store i32 0, i32* %10
br label %26
26: ; preds = %86, %2
%27 = load i32, i32* %10
%28 = icmp ult i32 %27, 1114112
br i1 %28, label %29, label %89
29: ; preds = %26
%30 = load i32, i32* %10
%31 = call i32 @is_graphic(i32 %30)
store i32 %31, i32* %11
%32 = load i32, i32* %10
%33 = call i32 @is_alpha(i32 %32)
store i32 %33, i32* %12
%34 = load i32, i32* %10
%35 = call i32 @is_numeric(i32 %34)
store i32 %35, i32* %13
%36 = load i32, i32* %12
%37 = icmp ne i32 %36, 0
br i1 %37, label %38, label %45
38: ; preds = %29
%39 = load i32, i32* %13
%40 = icmp ne i32 %39, 0
br i1 %40, label %41, label %45
41: ; preds = %38
%42 = load i32*, i32** @stderr
%43 = load i32, i32* %10
%44 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %43)
br label %45
45: ; preds = %41, %38, %29
%46 = load i32, i32* %12
%47 = icmp ne i32 %46, 0
br i1 %47, label %48, label %55
48: ; preds = %45
%49 = load i32, i32* %11
%50 = icmp ne i32 %49, 0
br i1 %50, label %55, label %51
51: ; preds = %48
%52 = load i32*, i32** @stderr
%53 = load i32, i32* %10
%54 = call i32 (i32*, i8*, ...) @fprintf(i32* %52, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0), i32 %53)
br label %55
55: ; preds = %51, %48, %45
%56 = load i32, i32* %13
%57 = icmp ne i32 %56, 0
br i1 %57, label %58, label %65
58: ; preds = %55
%59 = load i32, i32* %11
%60 = icmp ne i32 %59, 0
br i1 %60, label %65, label %61
61: ; preds = %58
%62 = load i32*, i32** @stderr
%63 = load i32, i32* %10
%64 = call i32 (i32*, i8*, ...) @fprintf(i32* %62, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.2, i64 0, i64 0), i32 %63)
br label %65
65: ; preds = %61, %58, %55
%66 = load i32, i32* %12
%67 = icmp ne i32 %66, 0
br i1 %67, label %68, label %69
68: ; preds = %65
br label %80
69: ; preds = %65
%70 = load i32, i32* %13
%71 = icmp ne i32 %70, 0
br i1 %71, label %72, label %73
72: ; preds = %69
br label %78
73: ; preds = %69
%74 = load i32, i32* %11
%75 = icmp ne i32 %74, 0
%76 = zext i1 %75 to i64
%77 = select i1 %75, i32 1, i32 0
br label %78
78: ; preds = %73, %72
%79 = phi i32 [ 2, %72 ], [ %77, %73 ]
br label %80
80: ; preds = %78, %68
%81 = phi i32 [ 3, %68 ], [ %79, %78 ]
%82 = trunc i32 %81 to i8
%83 = load i32, i32* %10
%84 = zext i32 %83 to i64
%85 = getelementptr inbounds [1114112 x i8], [1114112 x i8]* %6, i64 0, i64 %84
store i8 %82, i8* %85
br label %86
86: ; preds = %80
%87 = load i32, i32* %10
%88 = add i32 %87, 1
store i32 %88, i32* %10
br label %26
89: ; preds = %26
%90 = load i8*, i8** %3
%91 = call i32* @fopen(i8* %90, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
store i32* %91, i32** %5
%92 = load i32*, i32** %5
%93 = icmp eq i32* %92, null
br i1 %93, label %94, label %99
94: ; preds = %89
%95 = load i32*, i32** @stderr
%96 = load i8*, i8** %3
%97 = call i32 (i32*, i8*, ...) @fprintf(i32* %95, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.4, i64 0, i64 0), i8* %96)
%98 = call i32 @exit(i32 1)
unreachable
99: ; preds = %89
%100 = load i32*, i32** %5
%101 = call i32 (i32*, i8*, ...) @fprintf(i32* %100, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0))
%102 = load i32*, i32** %5
%103 = load i8*, i8** %3
%104 = call i32 (i32*, i8*, ...) @fprintf(i32* %102, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), i8* %103)
%105 = load i32*, i32** %5
%106 = call i32 (i32*, i8*, ...) @fprintf(i32* %105, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%107 = load i32*, i32** %5
%108 = call i32 (i32*, i8*, ...) @fprintf(i32* %107, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.8, i64 0, i64 0))
%109 = load i32*, i32** %5
%110 = load i8*, i8** %4
%111 = call i32 (i32*, i8*, ...) @fprintf(i32* %109, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.9, i64 0, i64 0), i8* %110)
%112 = load i32*, i32** %5
%113 = call i32 (i32*, i8*, ...) @fprintf(i32* %112, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0))
%114 = load i32*, i32** %5
%115 = call i32 (i32*, i8*, ...) @fprintf(i32* %114, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
store i32 0, i32* %14
br label %116
116: ; preds = %147, %99
%117 = load i32, i32* %14
%118 = icmp ult i32 %117, 278528
br i1 %118, label %119, label %150
119: ; preds = %116
store i8 0, i8* %16
store i32 0, i32* %15
br label %120
120: ; preds = %139, %119
%121 = load i32, i32* %15
%122 = icmp ult i32 %121, 4
br i1 %122, label %123, label %142
123: ; preds = %120
%124 = load i32, i32* %14
%125 = mul i32 4, %124
%126 = load i32, i32* %15
%127 = add i32 %125, %126
%128 = zext i32 %127 to i64
%129 = getelementptr inbounds [1114112 x i8], [1114112 x i8]* %6, i64 0, i64 %128
%130 = load i8, i8* %129
%131 = zext i8 %130 to i32
%132 = load i32, i32* %15
%133 = mul i32 2, %132
%134 = shl i32 %131, %133
%135 = load i8, i8* %16
%136 = zext i8 %135 to i32
%137 = or i32 %136, %134
%138 = trunc i32 %137 to i8
store i8 %138, i8* %16
br label %139
139: ; preds = %123
%140 = load i32, i32* %15
%141 = add i32 %140, 1
store i32 %141, i32* %15
br label %120
142: ; preds = %120
%143 = load i8, i8* %16
%144 = load i32, i32* %14
%145 = zext i32 %144 to i64
%146 = getelementptr inbounds [278528 x i8], [278528 x i8]* %7, i64 0, i64 %145
store i8 %143, i8* %146
br label %147
147: ; preds = %142
%148 = load i32, i32* %14
%149 = add i32 %148, 1
store i32 %149, i32* %14
br label %116
150: ; preds = %116
store i32 0, i32* %17
br label %151
151: ; preds = %180, %150
%152 = load i32, i32* %17
%153 = icmp ult i32 %152, 1088
br i1 %153, label %154, label %183
154: ; preds = %151
store i32 0, i32* %18
br label %155
155: ; preds = %172, %154
%156 = load i32, i32* %18
%157 = load i32, i32* %17
%158 = icmp ult i32 %156, %157
br i1 %158, label %159, label %175
159: ; preds = %155
%160 = load i32, i32* %18
%161 = shl i32 %160, 8
%162 = zext i32 %161 to i64
%163 = getelementptr inbounds [278528 x i8], [278528 x i8]* %7, i64 0, i64 %162
%164 = load i32, i32* %17
%165 = shl i32 %164, 8
%166 = zext i32 %165 to i64
%167 = getelementptr inbounds [278528 x i8], [278528 x i8]* %7, i64 0, i64 %166
%168 = call i64 @memcmp(i8* %163, i8* %167, i32 256)
%169 = icmp eq i64 %168, 0
br i1 %169, label %170, label %171
170: ; preds = %159
br label %175
171: ; preds = %159
br label %172
172: ; preds = %171
%173 = load i32, i32* %18
%174 = add i32 %173, 1
store i32 %174, i32* %18
br label %155
175: ; preds = %170, %155
%176 = load i32, i32* %18
%177 = load i32, i32* %17
%178 = zext i32 %177 to i64
%179 = getelementptr inbounds [1088 x i32], [1088 x i32]* %8, i64 0, i64 %178
store i32 %176, i32* %179
br label %180
180: ; preds = %175
%181 = load i32, i32* %17
%182 = add i32 %181, 1
store i32 %182, i32* %17
br label %151
183: ; preds = %151
store i32 0, i32* %9
store i32 0, i32* %19
br label %184
184: ; preds = %208, %183
%185 = load i32, i32* %19
%186 = icmp ult i32 %185, 1088
br i1 %186, label %187, label %211
187: ; preds = %184
store i32 0, i32* %20
br label %188
188: ; preds = %204, %187
%189 = load i32, i32* %20
%190 = icmp ult i32 %189, 256
br i1 %190, label %191, label %207
191: ; preds = %188
%192 = load i32, i32* %19
%193 = shl i32 %192, 8
%194 = load i32, i32* %20
%195 = add i32 %193, %194
%196 = zext i32 %195 to i64
%197 = getelementptr inbounds [278528 x i8], [278528 x i8]* %7, i64 0, i64 %196
%198 = load i8, i8* %197
%199 = zext i8 %198 to i32
%200 = icmp ne i32 %199, 0
br i1 %200, label %201, label %203
201: ; preds = %191
%202 = load i32, i32* %19
store i32 %202, i32* %9
br label %207
203: ; preds = %191
br label %204
204: ; preds = %203
%205 = load i32, i32* %20
%206 = add i32 %205, 1
store i32 %206, i32* %20
br label %188
207: ; preds = %201, %188
br label %208
208: ; preds = %207
%209 = load i32, i32* %19
%210 = add i32 %209, 1
store i32 %210, i32* %19
br label %184
211: ; preds = %184
store i32 0, i32* %21
br label %212
212: ; preds = %284, %211
%213 = load i32, i32* %21
%214 = icmp ult i32 %213, 1088
br i1 %214, label %215, label %287
215: ; preds = %212
%216 = load i32, i32* %21
%217 = zext i32 %216 to i64
%218 = getelementptr inbounds [1088 x i32], [1088 x i32]* %8, i64 0, i64 %217
%219 = load i32, i32* %218
%220 = load i32, i32* %21
%221 = icmp eq i32 %219, %220
br i1 %221, label %222, label %283
222: ; preds = %215
%223 = load i32*, i32** %5
%224 = load i32, i32* %21
%225 = mul i32 4, %224
%226 = call i32 (i32*, i8*, ...) @fprintf(i32* %223, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.12, i64 0, i64 0), i32 %225)
store i32 0, i32* %22
br label %227
227: ; preds = %275, %222
%228 = load i32, i32* %22
%229 = icmp ult i32 %228, 32
br i1 %229, label %230, label %278
230: ; preds = %227
%231 = load i32*, i32** %5
%232 = call i32 (i32*, i8*, ...) @fprintf(i32* %231, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0))
store i32 0, i32* %23
br label %233
233: ; preds = %255, %230
%234 = load i32, i32* %23
%235 = icmp ult i32 %234, 8
br i1 %235, label %236, label %258
236: ; preds = %233
%237 = load i32, i32* %22
%238 = mul i32 8, %237
%239 = load i32, i32* %23
%240 = add i32 %238, %239
store i32 %240, i32* %24
%241 = load i32*, i32** %5
%242 = load i32, i32* %21
%243 = shl i32 %242, 8
%244 = load i32, i32* %24
%245 = add i32 %243, %244
%246 = zext i32 %245 to i64
%247 = getelementptr inbounds [278528 x i8], [278528 x i8]* %7, i64 0, i64 %246
%248 = load i8, i8* %247
%249 = zext i8 %248 to i32
%250 = load i32, i32* %24
%251 = icmp ult i32 %250, 255
%252 = zext i1 %251 to i64
%253 = select i1 %251, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0)
%254 = call i32 (i32*, i8*, ...) @fprintf(i32* %241, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0), i32 %249, i8* %253)
br label %255
255: ; preds = %236
%256 = load i32, i32* %23
%257 = add i32 %256, 1
store i32 %257, i32* %23
br label %233
258: ; preds = %233
%259 = load i32*, i32** %5
%260 = load i32, i32* %21
%261 = shl i32 %260, 8
%262 = load i32, i32* %22
%263 = mul i32 8, %262
%264 = add i32 %261, %263
%265 = mul i32 4, %264
%266 = load i32, i32* %21
%267 = shl i32 %266, 8
%268 = load i32, i32* %22
%269 = mul i32 8, %268
%270 = add i32 %269, 7
%271 = add i32 %267, %270
%272 = mul i32 4, %271
%273 = add i32 %272, 3
%274 = call i32 (i32*, i8*, ...) @fprintf(i32* %259, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.17, i64 0, i64 0), i32 %265, i32 %273)
br label %275
275: ; preds = %258
%276 = load i32, i32* %22
%277 = add i32 %276, 1
store i32 %277, i32* %22
br label %227
278: ; preds = %227
%279 = load i32*, i32** %5
%280 = call i32 (i32*, i8*, ...) @fprintf(i32* %279, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0))
%281 = load i32*, i32** %5
%282 = call i32 (i32*, i8*, ...) @fprintf(i32* %281, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
br label %283
283: ; preds = %278, %215
br label %284
284: ; preds = %283
%285 = load i32, i32* %21
%286 = add i32 %285, 1
store i32 %286, i32* %21
br label %212
287: ; preds = %212
%288 = load i32*, i32** %5
%289 = load i32, i32* %9
%290 = add i32 %289, 1
%291 = call i32 (i32*, i8*, ...) @fprintf(i32* %288, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.19, i64 0, i64 0), i32 %290)
store i32 0, i32* %25
br label %292
292: ; preds = %327, %287
%293 = load i32, i32* %25
%294 = load i32, i32* %9
%295 = icmp ule i32 %293, %294
br i1 %295, label %296, label %330
296: ; preds = %292
%297 = load i32, i32* %25
%298 = urem i32 %297, 2
%299 = icmp eq i32 %298, 0
br i1 %299, label %300, label %303
300: ; preds = %296
%301 = load i32*, i32** %5
%302 = call i32 (i32*, i8*, ...) @fprintf(i32* %301, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0))
br label %303
303: ; preds = %300, %296
%304 = load i32*, i32** %5
%305 = load i32, i32* %25
%306 = zext i32 %305 to i64
%307 = getelementptr inbounds [1088 x i32], [1088 x i32]* %8, i64 0, i64 %306
%308 = load i32, i32* %307
%309 = mul i32 4, %308
%310 = load i32, i32* %25
%311 = load i32, i32* %9
%312 = icmp ult i32 %310, %311
%313 = zext i1 %312 to i64
%314 = select i1 %312, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.21, i64 0, i64 0)
%315 = call i32 (i32*, i8*, ...) @fprintf(i32* %304, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.20, i64 0, i64 0), i32 %309, i8* %314)
%316 = load i32, i32* %25
%317 = urem i32 %316, 2
%318 = icmp eq i32 %317, 1
br i1 %318, label %323, label %319
319: ; preds = %303
%320 = load i32, i32* %25
%321 = load i32, i32* %9
%322 = icmp eq i32 %320, %321
br i1 %322, label %323, label %326
323: ; preds = %319, %303
%324 = load i32*, i32** %5
%325 = call i32 (i32*, i8*, ...) @fprintf(i32* %324, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
br label %326
326: ; preds = %323, %319
br label %327
327: ; preds = %326
%328 = load i32, i32* %25
%329 = add i32 %328, 1
store i32 %329, i32* %25
br label %292
330: ; preds = %292
%331 = load i32*, i32** %5
%332 = call i32 (i32*, i8*, ...) @fprintf(i32* %331, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0))
%333 = load i32*, i32** %5
%334 = call i32 (i32*, i8*, ...) @fprintf(i32* %333, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.11, i64 0, i64 0))
%335 = load i32*, i32** %5
%336 = call i64 @ferror(i32* %335)
%337 = icmp ne i64 %336, 0
br i1 %337, label %342, label %338
338: ; preds = %330
%339 = load i32*, i32** %5
%340 = call i64 @fclose(i32* %339)
%341 = icmp ne i64 %340, 0
br i1 %341, label %342, label %347
342: ; preds = %338, %330
%343 = load i32*, i32** @stderr
%344 = load i8*, i8** %3
%345 = call i32 (i32*, i8*, ...) @fprintf(i32* %343, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.22, i64 0, i64 0), i8* %344)
%346 = call i32 @exit(i32 1)
unreachable
347: ; preds = %338
ret void
}

LLVM IR (-O2):
@stderr = global i32* null
@.str = [44 x i8] c"Character 0x%04x is both alpha and numeric\0A\00"
@.str.1 = [43 x i8] c"Character 0x%04x is alpha but not graphic\0A\00"
@.str.2 = [45 x i8] c"Character 0x%04x is numeric but not graphic\0A\00"
@.str.3 = [2 x i8] c"w\00"
@.str.4 = [30 x i8] c"cannot open '%s' for writing\0A\00"
@.str.5 = [4 x i8] c"/*\0A\00"
@.str.6 = [7 x i8] c" * %s\0A\00"
@.str.7 = [4 x i8] c" *\0A\00"
@.str.8 = [43 x i8] c" * Common Lisp character attribute table.\0A\00"
@.str.9 = [69 x i8] c" * Generated automatically by the gen-ctype utility for Unicode %s.\0A\00"
@.str.10 = [5 x i8] c" */\0A\00"
@.str.12 = [62 x i8] c"static const uintB unicode_attribute_table_page%02x[256] = {\0A\00"
@.str.13 = [3 x i8] c" \00"
@.str.14 = [10 x i8] c"0x%02x%s \00"
@.str.15 = [2 x i8] c",\00"
@.str.16 = [2 x i8] c" \00"
@.str.17 = [21 x i8] c"/* 0x%04x-0x%04x */\0A\00"
@.str.18 = [4 x i8] c"};\0A\00"
@.str.19 = [53 x i8] c"const uintB * const unicode_attribute_table[%d] = {\0A\00"
@.str.20 = [36 x i8] c" unicode_attribute_table_page%02x%s\00"
@.str.21 = [1 x i8] zeroinitializer
@.str.22 = [23 x i8] c"error writing to '%s'\0A\00"
define void @output_attributes(i8* %0, i8* %1) {
%3 = alloca [1114112 x i8]
%4 = alloca [278528 x i8]
%5 = alloca [1088 x i32]
%6 = getelementptr inbounds [1114112 x i8], [1114112 x i8]* %3, i64 0, i64 0
%7 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 0
%8 = bitcast [1088 x i32]* %5 to i8*
br label %9
9: ; preds = %2, %34
%10 = phi i64 [ 0, %2 ], [ %39, %34 ]
%11 = trunc i64 %10 to i32
%12 = tail call i32 @is_graphic(i32 %11)
%13 = tail call i32 @is_alpha(i32 %11)
%14 = tail call i32 @is_numeric(i32 %11)
%15 = icmp ne i32 %13, 0
%16 = icmp ne i32 %14, 0
%17 = select i1 %15, i1 %16, i1 false
br i1 %17, label %18, label %21
18: ; preds = %9
%19 = load i32*, i32** @stderr
%20 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %19, i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0), i32 %11)
br label %21
21: ; preds = %18, %9
%22 = icmp eq i32 %13, 0
%23 = icmp ne i32 %12, 0
%24 = select i1 %22, i1 true, i1 %23
br i1 %24, label %28, label %25
25: ; preds = %21
%26 = load i32*, i32** @stderr
%27 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %26, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.1, i64 0, i64 0), i32 %11)
br label %28
28: ; preds = %25, %21
%29 = icmp eq i32 %14, 0
%30 = select i1 %29, i1 true, i1 %23
br i1 %30, label %34, label %31
31: ; preds = %28
%32 = load i32*, i32** @stderr
%33 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %32, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.2, i64 0, i64 0), i32 %11)
br label %34
34: ; preds = %31, %28
%35 = zext i1 %23 to i8
%36 = select i1 %16, i8 2, i8 %35
%37 = select i1 %15, i8 3, i8 %36
%38 = getelementptr inbounds [1114112 x i8], [1114112 x i8]* %3, i64 0, i64 %10
store i8 %37, i8* %38
%39 = add nuw nsw i64 %10, 1
%40 = icmp eq i64 %39, 1114112
br i1 %40, label %41, label %9
41: ; preds = %34
%42 = tail call i32* @fopen(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0))
%43 = icmp eq i32* %42, null
br i1 %43, label %44, label %48
44: ; preds = %41
%45 = load i32*, i32** @stderr
%46 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %45, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.4, i64 0, i64 0), i8* %0)
%47 = tail call i32 @exit(i32 1)
unreachable
48: ; preds = %41
%49 = tail call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i64 0, i64 0), i64 3, i64 1, i32* %42)
%50 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.6, i64 0, i64 0), i8* %0)
%51 = tail call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0), i64 3, i64 1, i32* %42)
%52 = tail call i64 @fwrite(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.8, i64 0, i64 0), i64 42, i64 1, i32* %42)
%53 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.9, i64 0, i64 0), i8* %1)
%54 = tail call i64 @fwrite(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.10, i64 0, i64 0), i64 4, i64 1, i32* %42)
%55 = tail call i32 @fputc(i32 10, i32* %42)
br label %56
56: ; preds = %56, %48
%57 = phi i64 [ 0, %48 ], [ %74, %56 ]
%58 = shl i64 %57, 2
%59 = getelementptr inbounds [1114112 x i8], [1114112 x i8]* %3, i64 0, i64 %58
%60 = bitcast i8* %59 to <64 x i8>*
%61 = load <64 x i8>, <64 x i8>* %60
%62 = shufflevector <64 x i8> %61, <64 x i8> poison, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 16, i32 20, i32 24, i32 28, i32 32, i32 36, i32 40, i32 44, i32 48, i32 52, i32 56, i32 60>
%63 = shufflevector <64 x i8> %61, <64 x i8> poison, <16 x i32> <i32 1, i32 5, i32 9, i32 13, i32 17, i32 21, i32 25, i32 29, i32 33, i32 37, i32 41, i32 45, i32 49, i32 53, i32 57, i32 61>
%64 = shufflevector <64 x i8> %61, <64 x i8> poison, <16 x i32> <i32 2, i32 6, i32 10, i32 14, i32 18, i32 22, i32 26, i32 30, i32 34, i32 38, i32 42, i32 46, i32 50, i32 54, i32 58, i32 62>
%65 = shufflevector <64 x i8> %61, <64 x i8> poison, <16 x i32> <i32 3, i32 7, i32 11, i32 15, i32 19, i32 23, i32 27, i32 31, i32 35, i32 39, i32 43, i32 47, i32 51, i32 55, i32 59, i32 63>
%66 = shl <16 x i8> %63, <i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2, i8 2>
%67 = or <16 x i8> %62, %66
%68 = shl <16 x i8> %64, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%69 = or <16 x i8> %67, %68
%70 = shl <16 x i8> %65, <i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6, i8 6>
%71 = or <16 x i8> %69, %70
%72 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %57
%73 = bitcast i8* %72 to <16 x i8>*
store <16 x i8> %71, <16 x i8>* %73
%74 = add nuw i64 %57, 16
%75 = icmp eq i64 %74, 278528
br i1 %75, label %76, label %56
76: ; preds = %56, %94
%77 = phi i64 [ %97, %94 ], [ 0, %56 ]
%78 = icmp eq i64 %77, 0
br i1 %78, label %94, label %79
79: ; preds = %76
%80 = shl i64 %77, 8
%81 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %80
br label %82
82: ; preds = %79, %88
%83 = phi i64 [ 0, %79 ], [ %89, %88 ]
%84 = shl i64 %83, 8
%85 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %84
%86 = call i64 @memcmp(i8* %85, i8* %81, i32 256)
%87 = icmp eq i64 %86, 0
br i1 %87, label %91, label %88
88: ; preds = %82
%89 = add nuw nsw i64 %83, 1
%90 = icmp eq i64 %89, %77
br i1 %90, label %91, label %82
91: ; preds = %82, %88
%92 = phi i64 [ %77, %88 ], [ %83, %82 ]
%93 = trunc i64 %92 to i32
br label %94
94: ; preds = %91, %76
%95 = phi i32 [ 0, %76 ], [ %93, %91 ]
%96 = getelementptr inbounds [1088 x i32], [1088 x i32]* %5, i64 0, i64 %77
store i32 %95, i32* %96
%97 = add nuw nsw i64 %77, 1
%98 = icmp eq i64 %97, 1088
br i1 %98, label %99, label %76
99: ; preds = %94, %131
%100 = phi i64 [ %133, %131 ], [ 0, %94 ]
%101 = phi i32 [ %132, %131 ], [ 0, %94 ]
%102 = shl i64 %100, 8
%103 = trunc i64 %100 to i32
br label %125
104: ; preds = %125
%105 = or i64 %126, 1
%106 = add nuw nsw i64 %105, %102
%107 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %106
%108 = load i8, i8* %107
%109 = icmp eq i8 %108, 0
br i1 %109, label %110, label %131
110: ; preds = %104
%111 = or i64 %126, 2
%112 = add nuw nsw i64 %111, %102
%113 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %112
%114 = load i8, i8* %113
%115 = icmp eq i8 %114, 0
br i1 %115, label %116, label %131
116: ; preds = %110
%117 = or i64 %126, 3
%118 = add nuw nsw i64 %117, %102
%119 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %118
%120 = load i8, i8* %119
%121 = icmp eq i8 %120, 0
br i1 %121, label %122, label %131
122: ; preds = %116
%123 = add nuw nsw i64 %126, 4
%124 = icmp eq i64 %123, 256
br i1 %124, label %131, label %125
125: ; preds = %122, %99
%126 = phi i64 [ 0, %99 ], [ %123, %122 ]
%127 = add nuw nsw i64 %126, %102
%128 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %127
%129 = load i8, i8* %128
%130 = icmp eq i8 %129, 0
br i1 %130, label %104, label %131
131: ; preds = %122, %116, %110, %104, %125
%132 = phi i32 [ %103, %125 ], [ %103, %104 ], [ %103, %110 ], [ %103, %116 ], [ %101, %122 ]
%133 = add nuw nsw i64 %100, 1
%134 = icmp eq i64 %133, 1088
br i1 %134, label %135, label %99
135: ; preds = %131, %214
%136 = phi i64 [ %215, %214 ], [ 0, %131 ]
%137 = getelementptr inbounds [1088 x i32], [1088 x i32]* %5, i64 0, i64 %136
%138 = load i32, i32* %137
%139 = zext i32 %138 to i64
%140 = icmp eq i64 %136, %139
br i1 %140, label %141, label %214
141: ; preds = %135
%142 = trunc i64 %136 to i32
%143 = shl i32 %142, 2
%144 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([62 x i8], [62 x i8]* @.str.12, i64 0, i64 0), i32 %143)
%145 = shl i64 %136, 8
%146 = trunc i64 %145 to i32
%147 = or i32 %146, 7
br label %148
148: ; preds = %141, %148
%149 = phi i64 [ 0, %141 ], [ %209, %148 ]
%150 = trunc i64 %149 to i32
%151 = call i64 @fwrite(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0), i64 2, i64 1, i32* %42)
%152 = shl i64 %149, 3
%153 = add nuw nsw i64 %152, %145
%154 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %153
%155 = load i8, i8* %154
%156 = zext i8 %155 to i32
%157 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0), i32 %156, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0))
%158 = or i64 %152, 1
%159 = add nuw nsw i64 %158, %145
%160 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %159
%161 = load i8, i8* %160
%162 = zext i8 %161 to i32
%163 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0), i32 %162, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0))
%164 = or i64 %152, 2
%165 = add nuw nsw i64 %164, %145
%166 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %165
%167 = load i8, i8* %166
%168 = zext i8 %167 to i32
%169 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0), i32 %168, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0))
%170 = or i64 %152, 3
%171 = add nuw nsw i64 %170, %145
%172 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %171
%173 = load i8, i8* %172
%174 = zext i8 %173 to i32
%175 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0), i32 %174, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0))
%176 = or i64 %152, 4
%177 = add nuw nsw i64 %176, %145
%178 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %177
%179 = load i8, i8* %178
%180 = zext i8 %179 to i32
%181 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0), i32 %180, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0))
%182 = or i64 %152, 5
%183 = add nuw nsw i64 %182, %145
%184 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %183
%185 = load i8, i8* %184
%186 = zext i8 %185 to i32
%187 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0), i32 %186, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0))
%188 = or i64 %152, 6
%189 = add nuw nsw i64 %188, %145
%190 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %189
%191 = load i8, i8* %190
%192 = zext i8 %191 to i32
%193 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0), i32 %192, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0))
%194 = or i64 %152, 7
%195 = add nuw nsw i64 %194, %145
%196 = getelementptr inbounds [278528 x i8], [278528 x i8]* %4, i64 0, i64 %195
%197 = load i8, i8* %196
%198 = zext i8 %197 to i32
%199 = icmp ult i64 %194, 255
%200 = select i1 %199, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.16, i64 0, i64 0)
%201 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0), i32 %198, i8* %200)
%202 = shl i32 %150, 3
%203 = add nuw nsw i32 %147, %202
%204 = shl i32 %203, 2
%205 = or i32 %204, 3
%206 = trunc i64 %153 to i32
%207 = shl i32 %206, 2
%208 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.17, i64 0, i64 0), i32 %207, i32 %205)
%209 = add nuw nsw i64 %149, 1
%210 = icmp eq i64 %209, 32
br i1 %210, label %211, label %148
211: ; preds = %148
%212 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0), i64 3, i64 1, i32* %42)
%213 = call i32 @fputc(i32 10, i32* %42)
br label %214
214: ; preds = %135, %211
%215 = add nuw nsw i64 %136, 1
%216 = icmp eq i64 %215, 1088
br i1 %216, label %217, label %135
217: ; preds = %214
%218 = add i32 %132, 1
%219 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.19, i64 0, i64 0), i32 %218)
br label %220
220: ; preds = %217, %239
%221 = phi i32 [ 0, %217 ], [ %240, %239 ]
%222 = and i32 %221, 1
%223 = icmp eq i32 %222, 0
br i1 %223, label %224, label %226
224: ; preds = %220
%225 = call i32 @fputc(i32 32, i32* %42)
br label %226
226: ; preds = %224, %220
%227 = zext i32 %221 to i64
%228 = getelementptr inbounds [1088 x i32], [1088 x i32]* %5, i64 0, i64 %227
%229 = load i32, i32* %228
%230 = shl i32 %229, 2
%231 = icmp ult i32 %221, %132
%232 = select i1 %231, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.21, i64 0, i64 0)
%233 = call i32 (i32*, i8*, ...) @fprintf(i32* %42, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.20, i64 0, i64 0), i32 %230, i8* %232)
%234 = icmp ne i32 %222, 0
%235 = icmp eq i32 %221, %132
%236 = select i1 %234, i1 true, i1 %235
br i1 %236, label %237, label %239
237: ; preds = %226
%238 = call i32 @fputc(i32 10, i32* %42)
br label %239
239: ; preds = %226, %237
%240 = add i32 %221, 1
%241 = icmp ugt i32 %240, %132
br i1 %241, label %242, label %220
242: ; preds = %239
%243 = call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i64 0, i64 0), i64 3, i64 1, i32* %42)
%244 = call i32 @fputc(i32 10, i32* %42)
%245 = call i64 @ferror(i32* %42)
%246 = icmp eq i64 %245, 0
br i1 %246, label %247, label %250
247: ; preds = %242
%248 = call i64 @fclose(i32* %42)
%249 = icmp eq i64 %248, 0
br i1 %249, label %254, label %250
250: ; preds = %247, %242
%251 = load i32*, i32** @stderr
%252 = call i32 (i32*, i8*, ...) @fprintf(i32* %251, i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.22, i64 0, i64 0), i8* %0)
%253 = call i32 @exit(i32 1)
unreachable
254: ; preds = %247
ret void
}