void genwidebmp(int bitarray[0x10000][16], int dpi, int tinynum) {
  char header_string[257];
  int header[16][256];
  int hdrlen;
  int startcol;
  unsigned leftcol[0x100][16];
  int d1, d2, d3, d4;
  int codept;
  int thisrow;
  unsigned toprow[32][256];
  char hexdigit[16][5] = {{0x6, 0x9, 0x9, 0x9, 0x6}, {0x2, 0x6, 0x2, 0x2, 0x7},
                          {0xF, 0x1, 0xF, 0x8, 0xF}, {0xE, 0x1, 0x7, 0x1, 0xE},
                          {0x9, 0x9, 0xF, 0x1, 0x1}, {0xF, 0x8, 0xF, 0x1, 0xF},
                          {0x8, 0x8, 0xF, 0x9, 0xF}, {0xF, 0x1, 0x2, 0x4, 0x4},
                          {0x6, 0x9, 0x6, 0x9, 0x6}, {0xF, 0x9, 0xF, 0x1, 0x1},
                          {0xF, 0x9, 0xF, 0x9, 0x9}, {0xE, 0x9, 0xE, 0x9, 0xE},
                          {0x7, 0x8, 0x8, 0x8, 0x7}, {0xE, 0x9, 0x9, 0x9, 0xE},
                          {0xF, 0x8, 0xE, 0x8, 0xF}, {0xF, 0x8, 0xE, 0x8, 0x8}};
  int digitrow;
  int hexalpha1, hexalpha2;
  int DataOffset = 14 + 40 + 8;
  int ImageSize;
  int FileSize;
  int Width, Height;
  int ppm;
  int i, j, k;
  unsigned bytesout;
  void output4(int), output2(int);
  Width = 258 * 16;
  Height = 260 * 16;
  ImageSize = Height * (Width / 8);
  FileSize = DataOffset + ImageSize;
  if (dpi == 0)
    dpi = 96;
  ppm = (int)((double)dpi * 100.0 / 2.54 + 0.5);
  putchar('B');
  putchar('M');
  output4(FileSize);
  output4(0x0000);
  output4(DataOffset);
  output4(40);
  output4(Width);
  output4(Height);
  output2(1);
  output2(1);
  output4(0);
  output4(ImageSize);
  output4(ppm);
  output4(ppm);
  output4(2);
  output4(2);
  output4(0x00000000);
  output4(0x00FFFFFF);
  memset((void *)header, 0, 256 * 16 * sizeof(int));
  memset((void *)header_string, ' ', 256 * sizeof(char));
  header_string[256] = '\0';
  hdrlen = strlen("GNU Unifont 6.3");
  if (hdrlen > 256)
    hdrlen = 256;
  startcol = 128 - ((hdrlen + 1) >> 1);
  strncpy(&header_string[startcol], "GNU Unifont 6.3", hdrlen);
  for (j = 0; j < 256; j++) {
    for (i = 0; i < 16; i++) {
      header[i][j] = bitarray[(unsigned)header_string[j]][i];
    }
  }
  memset((void *)leftcol, 0, 256 * 16 * sizeof(unsigned));
  for (codept = 0x0000; codept < 0x10000; codept += 0x100) {
    d1 = (codept >> 12) & 0xF;
    d2 = (codept >> 8) & 0xF;
    thisrow = codept >> 8;
    if (tinynum) {
      for (digitrow = 0; digitrow < 5; digitrow++) {
        leftcol[thisrow][6 + digitrow] =
            (hexdigit[d1][digitrow] << 10) | (hexdigit[d2][digitrow] << 4);
      }
    } else {
      hexalpha1 = d1 < 0xA ? '0' + d1 : 'A' + d1 - 0xA;
      hexalpha2 = d2 < 0xA ? '0' + d2 : 'A' + d2 - 0xA;
      for (i = 0; i < 16; i++) {
        leftcol[thisrow][i] =
            (bitarray[hexalpha1][i] << 2) | (bitarray[hexalpha2][i] >> 6);
      }
    }
    for (i = 0; i < 15; i++) {
      leftcol[thisrow][i] |= 0x00000002;
    }
    leftcol[thisrow][15] = 0x0000FFFE;
    if (d2 == 0xF) {
      leftcol[thisrow][15] |= 0x00FF0000;
    }
    if ((thisrow % 0x40) == 0x3F) {
      leftcol[thisrow][15] |= 0xFFFF0000;
    }
  }
  memset((void *)toprow, 0, 32 * 256 * sizeof(unsigned));
  for (codept = 0x00; codept <= 0xFF; codept++) {
    d3 = (codept >> 4) & 0xF;
    d4 = codept & 0xF;
    if (tinynum) {
      for (digitrow = 0; digitrow < 5; digitrow++) {
        toprow[16 + 6 + digitrow][codept] =
            (hexdigit[d3][digitrow] << 10) | (hexdigit[d4][digitrow] << 4);
      }
    } else {
      hexalpha1 = d3 < 0xA ? '0' + d3 : 'A' + d3 - 0xA;
      hexalpha2 = d4 < 0xA ? '0' + d4 : 'A' + d4 - 0xA;
      for (i = 0; i < 16; i++) {
        toprow[14 + i][codept] =
            (bitarray[hexalpha1][i]) | (bitarray[hexalpha2][i] >> 7);
      }
    }
  }
  for (j = 0; j < 256; j++) {
    toprow[16 + 15][j] = 0x0000;
  }
  for (j = 0; j < 256; j++) {
    toprow[16 + 14][j] |= 0xFFFF;
  }
  for (i = 13; i >= 0; i--) {
    for (j = 0; j < 256; j++) {
      toprow[16 + i][j] |= 0x0001;
    }
  }
  for (i = 8; i < 16; i++) {
    for (j = 0x0F; j < 0x100; j += 0x10) {
      toprow[i][j] |= 0x0001;
    }
  }
  for (i = 0xFF00; i >= 0; i -= 0x100) {
    thisrow = i >> 8;
    for (j = 15; j >= 0; j--) {
      putchar((~leftcol[thisrow][j] >> 24) & 0xFF);
      putchar((~leftcol[thisrow][j] >> 16) & 0xFF);
      putchar((~leftcol[thisrow][j] >> 8) & 0xFF);
      putchar(~leftcol[thisrow][j] & 0xFF);
      for (k = 0x00; k < 0x100; k++) {
        bytesout = ~bitarray[i + k][j] & 0xFFFF;
        putchar((bytesout >> 8) & 0xFF);
        putchar(bytesout & 0xFF);
      }
    }
  }
  putchar(0x00);
  putchar(0x00);
  putchar(0x00);
  putchar(0x01);
  for (j = 0; j < 256; j++) {
    putchar((~toprow[16 + 15][j] >> 8) & 0xFF);
    putchar(~toprow[16 + 15][j] & 0xFF);
  }
  putchar(0xFF);
  putchar(0xFF);
  putchar(0xFF);
  putchar(0xFC);
  for (j = 0; j < 256; j++) {
    putchar((~toprow[16 + 14][j] >> 8) & 0xFF);
    putchar(~toprow[16 + 14][j] & 0xFF);
  }
  for (i = 16 + 13; i >= 0; i--) {
    if (i >= 8) {
      putchar(0xFF);
      putchar(0xFF);
      putchar(0xFF);
      putchar(0xFD);
    } else {
      putchar(0xFF);
      putchar(0xFF);
      putchar(0xFF);
      putchar(0xFF);
    }
    for (j = 0; j < 256; j++) {
      putchar((~toprow[i][j] >> 8) & 0xFF);
      putchar(~toprow[i][j] & 0xFF);
    }
  }
  for (i = 7; i >= 0; i--) {
    for (j = 0; j < 258; j++) {
      putchar(0xFF);
      putchar(0xFF);
    }
  }
  for (i = 15; i >= 0; i--) {
    putchar(0xFF);
    putchar(0xFF);
    putchar(0xFF);
    putchar(0xFF);
    for (j = 0; j < 256; j++) {
      bytesout = ~header[i][j] & 0xFFFF;
      putchar((bytesout >> 8) & 0xFF);
      putchar(bytesout & 0xFF);
    }
  }
  for (i = 7; i >= 0; i--) {
    for (j = 0; j < 258; j++) {
      putchar(0xFF);
      putchar(0xFF);
    }
  }
  return;
}


x86 assembly (clang, -O0):
<genwidebmp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x101f0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
lea    -0x101a0(%rbp),%rdi
lea    0x1e9d(%rip),%rsi
mov    $0x50,%edx
call   1060 <memcpy@plt>
movl   $0x3e,-0x101b0(%rbp)
movl   $0x1020,-0x101bc(%rbp)
movl   $0x1040,-0x101c0(%rbp)
mov    -0x101c0(%rbp),%eax
mov    %eax,-0x101d8(%rbp)
mov    -0x101bc(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x101d8(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x101b4(%rbp)
mov    -0x101b0(%rbp),%eax
add    -0x101b4(%rbp),%eax
mov    %eax,-0x101b8(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    11f9 <genwidebmp+0x99>
movl   $0x60,-0xc(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0x1e0a(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  0x1df6(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  0x1de2(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x101c4(%rbp)
mov    $0x42,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0x4d,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    -0x101b8(%rbp),%edi
call   1070 <output4@plt>
xor    %edi,%edi
call   1070 <output4@plt>
mov    -0x101b0(%rbp),%edi
call   1070 <output4@plt>
mov    $0x28,%edi
call   1070 <output4@plt>
mov    -0x101bc(%rbp),%edi
call   1070 <output4@plt>
mov    -0x101c0(%rbp),%edi
call   1070 <output4@plt>
mov    $0x1,%edi
call   1080 <output2@plt>
mov    $0x1,%edi
call   1080 <output2@plt>
xor    %edi,%edi
call   1070 <output4@plt>
mov    -0x101b4(%rbp),%edi
call   1070 <output4@plt>
mov    -0x101c4(%rbp),%edi
call   1070 <output4@plt>
mov    -0x101c4(%rbp),%edi
call   1070 <output4@plt>
mov    $0x2,%edi
call   1070 <output4@plt>
mov    $0x2,%edi
call   1070 <output4@plt>
xor    %edi,%edi
call   1070 <output4@plt>
mov    $0xffffff,%edi
call   1070 <output4@plt>
lea    -0x4120(%rbp),%rdi
xor    %esi,%esi
mov    $0x4000,%edx
call   1050 <memset@plt>
lea    -0x120(%rbp),%rdi
mov    $0x20,%esi
mov    $0x100,%edx
call   1050 <memset@plt>
movb   $0x0,-0x20(%rbp)
movl   $0xf,-0x4124(%rbp)
cmpl   $0x100,-0x4124(%rbp)
jle    1333 <genwidebmp+0x1d3>
movl   $0x100,-0x4124(%rbp)
mov    -0x4124(%rbp),%ecx
add    $0x1,%ecx
sar    $0x1,%ecx
mov    $0x80,%eax
sub    %ecx,%eax
mov    %eax,-0x4128(%rbp)
movslq -0x4128(%rbp),%rax
lea    -0x120(%rbp),%rdi
add    %rax,%rdi
movslq -0x4124(%rbp),%rdx
lea    0x1d05(%rip),%rsi
call   1040 <strncpy@plt>
movl   $0x0,-0x101cc(%rbp)
cmpl   $0x100,-0x101cc(%rbp)
jge    1413 <genwidebmp+0x2b3>
movl   $0x0,-0x101c8(%rbp)
cmpl   $0x10,-0x101c8(%rbp)
jge    13fa <genwidebmp+0x29a>
mov    -0x8(%rbp),%rax
movslq -0x101cc(%rbp),%rcx
movsbl -0x120(%rbp,%rcx,1),%ecx
ff
mov    %ecx,%ecx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101c8(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x101c8(%rbp),%rcx
lea    -0x4120(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x101c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101c8(%rbp)
jmp    1394 <genwidebmp+0x234>
jmp    13ff <genwidebmp+0x29f>
mov    -0x101cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101cc(%rbp)
jmp    137a <genwidebmp+0x21a>
lea    -0x8130(%rbp),%rdi
xor    %esi,%esi
mov    $0x4000,%edx
call   1050 <memset@plt>
movl   $0x0,-0x8144(%rbp)
cmpl   $0x10000,-0x8144(%rbp)
jge    1713 <genwidebmp+0x5b3>
mov    -0x8144(%rbp),%eax
sar    $0xc,%eax
and    $0xf,%eax
mov    %eax,-0x8134(%rbp)
mov    -0x8144(%rbp),%eax
sar    $0x8,%eax
and    $0xf,%eax
mov    %eax,-0x8138(%rbp)
mov    -0x8144(%rbp),%eax
sar    $0x8,%eax
mov    %eax,-0x8148(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     1519 <genwidebmp+0x3b9>
movl   $0x0,-0x101a4(%rbp)
cmpl   $0x5,-0x101a4(%rbp)
jge    1514 <genwidebmp+0x3b4>
movslq -0x8134(%rbp),%rcx
lea    -0x101a0(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
movslq -0x101a4(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
shl    $0xa,%edx
movslq -0x8138(%rbp),%rcx
lea    -0x101a0(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
movslq -0x101a4(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x4,%eax
or     %eax,%edx
movslq -0x8148(%rbp),%rcx
lea    -0x8130(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    -0x101a4(%rbp),%ecx
add    $0x6,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x101a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101a4(%rbp)
jmp    1487 <genwidebmp+0x327>
jmp    1626 <genwidebmp+0x4c6>
cmpl   $0xa,-0x8134(%rbp)
jge    153a <genwidebmp+0x3da>
mov    -0x8134(%rbp),%eax
add    $0x30,%eax
mov    %eax,-0x101dc(%rbp)
jmp    154c <genwidebmp+0x3ec>
mov    -0x8134(%rbp),%eax
add    $0x41,%eax
sub    $0xa,%eax
mov    %eax,-0x101dc(%rbp)
mov    -0x101dc(%rbp),%eax
mov    %eax,-0x101a8(%rbp)
cmpl   $0xa,-0x8138(%rbp)
jge    1579 <genwidebmp+0x419>
mov    -0x8138(%rbp),%eax
add    $0x30,%eax
mov    %eax,-0x101e0(%rbp)
jmp    158b <genwidebmp+0x42b>
mov    -0x8138(%rbp),%eax
add    $0x41,%eax
sub    $0xa,%eax
mov    %eax,-0x101e0(%rbp)
mov    -0x101e0(%rbp),%eax
mov    %eax,-0x101ac(%rbp)
movl   $0x0,-0x101c8(%rbp)
cmpl   $0x10,-0x101c8(%rbp)
jge    1621 <genwidebmp+0x4c1>
mov    -0x8(%rbp),%rax
movslq -0x101a8(%rbp),%rcx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101c8(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
shl    $0x2,%edx
mov    -0x8(%rbp),%rax
movslq -0x101ac(%rbp),%rcx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101c8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sar    $0x6,%eax
or     %eax,%edx
movslq -0x8148(%rbp),%rcx
lea    -0x8130(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101c8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x101c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101c8(%rbp)
jmp    15a1 <genwidebmp+0x441>
jmp    1626 <genwidebmp+0x4c6>
movl   $0x0,-0x101c8(%rbp)
cmpl   $0xf,-0x101c8(%rbp)
jge    1676 <genwidebmp+0x516>
movslq -0x8148(%rbp),%rcx
lea    -0x8130(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101c8(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x2,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x101c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101c8(%rbp)
jmp    1630 <genwidebmp+0x4d0>
movslq -0x8148(%rbp),%rcx
lea    -0x8130(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movl   $0xfffe,0x3c(%rax)
cmpl   $0xf,-0x8138(%rbp)
jne    16c0 <genwidebmp+0x560>
movslq -0x8148(%rbp),%rcx
lea    -0x8130(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    0x3c(%rax),%ecx
or     $0xff0000,%ecx
mov    %ecx,0x3c(%rax)
mov    -0x8148(%rbp),%eax
mov    $0x40,%ecx
cltd
idiv   %ecx
cmp    $0x3f,%edx
jne    16f8 <genwidebmp+0x598>
movslq -0x8148(%rbp),%rcx
lea    -0x8130(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    0x3c(%rax),%ecx
or     $0xffff0000,%ecx
mov    %ecx,0x3c(%rax)
jmp    16fd <genwidebmp+0x59d>
mov    -0x8144(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x8144(%rbp)
jmp    1430 <genwidebmp+0x2d0>
lea    -0x10150(%rbp),%rdi
xor    %esi,%esi
mov    $0x8000,%edx
call   1050 <memset@plt>
movl   $0x0,-0x8144(%rbp)
cmpl   $0xff,-0x8144(%rbp)
jg     192f <genwidebmp+0x7cf>
mov    -0x8144(%rbp),%eax
sar    $0x4,%eax
and    $0xf,%eax
mov    %eax,-0x813c(%rbp)
mov    -0x8144(%rbp),%eax
and    $0xf,%eax
mov    %eax,-0x8140(%rbp)
cmpl   $0x0,-0x10(%rbp)
je     1807 <genwidebmp+0x6a7>
movl   $0x0,-0x101a4(%rbp)
cmpl   $0x5,-0x101a4(%rbp)
jge    1802 <genwidebmp+0x6a2>
movslq -0x813c(%rbp),%rcx
lea    -0x101a0(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
movslq -0x101a4(%rbp),%rcx
movsbl (%rax,%rcx,1),%edx
shl    $0xa,%edx
movslq -0x8140(%rbp),%rcx
lea    -0x101a0(%rbp),%rax
imul   $0x5,%rcx,%rcx
add    %rcx,%rax
movslq -0x101a4(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
shl    $0x4,%eax
or     %eax,%edx
mov    -0x101a4(%rbp),%eax
add    $0x16,%eax
movslq %eax,%rcx
lea    -0x10150(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x8144(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x101a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101a4(%rbp)
jmp    1775 <genwidebmp+0x615>
jmp    1916 <genwidebmp+0x7b6>
cmpl   $0xa,-0x813c(%rbp)
jge    1828 <genwidebmp+0x6c8>
mov    -0x813c(%rbp),%eax
add    $0x30,%eax
mov    %eax,-0x101e4(%rbp)
jmp    183a <genwidebmp+0x6da>
mov    -0x813c(%rbp),%eax
add    $0x41,%eax
sub    $0xa,%eax
mov    %eax,-0x101e4(%rbp)
mov    -0x101e4(%rbp),%eax
mov    %eax,-0x101a8(%rbp)
cmpl   $0xa,-0x8140(%rbp)
jge    1867 <genwidebmp+0x707>
mov    -0x8140(%rbp),%eax
add    $0x30,%eax
mov    %eax,-0x101e8(%rbp)
jmp    1879 <genwidebmp+0x719>
mov    -0x8140(%rbp),%eax
add    $0x41,%eax
sub    $0xa,%eax
mov    %eax,-0x101e8(%rbp)
mov    -0x101e8(%rbp),%eax
mov    %eax,-0x101ac(%rbp)
movl   $0x0,-0x101c8(%rbp)
cmpl   $0x10,-0x101c8(%rbp)
jge    1911 <genwidebmp+0x7b1>
mov    -0x8(%rbp),%rax
movslq -0x101a8(%rbp),%rcx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101c8(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x101ac(%rbp),%rcx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101c8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sar    $0x7,%eax
or     %eax,%edx
mov    -0x101c8(%rbp),%eax
add    $0xe,%eax
movslq %eax,%rcx
lea    -0x10150(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x8144(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x101c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101c8(%rbp)
jmp    188f <genwidebmp+0x72f>
jmp    1916 <genwidebmp+0x7b6>
jmp    191b <genwidebmp+0x7bb>
mov    -0x8144(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8144(%rbp)
jmp    1730 <genwidebmp+0x5d0>
movl   $0x0,-0x101cc(%rbp)
cmpl   $0x100,-0x101cc(%rbp)
jge    196f <genwidebmp+0x80f>
movslq -0x101cc(%rbp),%rax
movl   $0x0,-0x8550(%rbp,%rax,4)
mov    -0x101cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101cc(%rbp)
jmp    1939 <genwidebmp+0x7d9>
movl   $0x0,-0x101cc(%rbp)
cmpl   $0x100,-0x101cc(%rbp)
jge    19b8 <genwidebmp+0x858>
movslq -0x101cc(%rbp),%rax
mov    -0x8950(%rbp,%rax,4),%ecx
or     $0xffff,%ecx
mov    %ecx,-0x8950(%rbp,%rax,4)
mov    -0x101cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101cc(%rbp)
jmp    1979 <genwidebmp+0x819>
movl   $0xd,-0x101c8(%rbp)
cmpl   $0x0,-0x101c8(%rbp)
jl     1a40 <genwidebmp+0x8e0>
movl   $0x0,-0x101cc(%rbp)
cmpl   $0x100,-0x101cc(%rbp)
jge    1a27 <genwidebmp+0x8c7>
mov    -0x101c8(%rbp),%eax
add    $0x10,%eax
movslq %eax,%rcx
lea    -0x10150(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x101cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101cc(%rbp)
jmp    19d9 <genwidebmp+0x879>
jmp    1a2c <genwidebmp+0x8cc>
mov    -0x101c8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x101c8(%rbp)
jmp    19c2 <genwidebmp+0x862>
movl   $0x8,-0x101c8(%rbp)
cmpl   $0x10,-0x101c8(%rbp)
jge    1ac3 <genwidebmp+0x963>
movl   $0xf,-0x101cc(%rbp)
cmpl   $0x100,-0x101cc(%rbp)
jge    1aaa <genwidebmp+0x94a>
movslq -0x101c8(%rbp),%rcx
lea    -0x10150(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x101cc(%rbp),%eax
add    $0x10,%eax
mov    %eax,-0x101cc(%rbp)
jmp    1a61 <genwidebmp+0x901>
jmp    1aaf <genwidebmp+0x94f>
mov    -0x101c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101c8(%rbp)
jmp    1a4a <genwidebmp+0x8ea>
movl   $0xff00,-0x101c8(%rbp)
cmpl   $0x0,-0x101c8(%rbp)
jl     1c82 <genwidebmp+0xb22>
mov    -0x101c8(%rbp),%eax
sar    $0x8,%eax
mov    %eax,-0x8148(%rbp)
movl   $0xf,-0x101cc(%rbp)
cmpl   $0x0,-0x101cc(%rbp)
jl     1c67 <genwidebmp+0xb07>
movslq -0x8148(%rbp),%rcx
lea    -0x8130(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
xor    $0xffffffff,%edi
shr    $0x18,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movslq -0x8148(%rbp),%rcx
lea    -0x8130(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
xor    $0xffffffff,%edi
shr    $0x10,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movslq -0x8148(%rbp),%rcx
lea    -0x8130(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
xor    $0xffffffff,%edi
shr    $0x8,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movslq -0x8148(%rbp),%rcx
lea    -0x8130(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
xor    $0xffffffff,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movl   $0x0,-0x101d0(%rbp)
cmpl   $0x100,-0x101d0(%rbp)
jge    1c4e <genwidebmp+0xaee>
mov    -0x8(%rbp),%rax
mov    -0x101c8(%rbp),%ecx
add    -0x101d0(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
xor    $0xffffffff,%eax
and    $0xffff,%eax
mov    %eax,-0x101d4(%rbp)
mov    -0x101d4(%rbp),%edi
shr    $0x8,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    -0x101d4(%rbp),%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    -0x101d0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101d0(%rbp)
jmp    1bcf <genwidebmp+0xa6f>
jmp    1c53 <genwidebmp+0xaf3>
mov    -0x101cc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x101cc(%rbp)
jmp    1af3 <genwidebmp+0x993>
jmp    1c6c <genwidebmp+0xb0c>
mov    -0x101c8(%rbp),%eax
sub    $0x100,%eax
mov    %eax,-0x101c8(%rbp)
jmp    1acd <genwidebmp+0x96d>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0x1,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movl   $0x0,-0x101cc(%rbp)
cmpl   $0x100,-0x101cc(%rbp)
jge    1d16 <genwidebmp+0xbb6>
movslq -0x101cc(%rbp),%rax
mov    -0x8550(%rbp,%rax,4),%edi
xor    $0xffffffff,%edi
shr    $0x8,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movslq -0x101cc(%rbp),%rax
mov    -0x8550(%rbp,%rax,4),%edi
xor    $0xffffffff,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    -0x101cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101cc(%rbp)
jmp    1cb3 <genwidebmp+0xb53>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xfc,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movl   $0x0,-0x101cc(%rbp)
cmpl   $0x100,-0x101cc(%rbp)
jge    1db3 <genwidebmp+0xc53>
movslq -0x101cc(%rbp),%rax
mov    -0x8950(%rbp,%rax,4),%edi
xor    $0xffffffff,%edi
shr    $0x8,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movslq -0x101cc(%rbp),%rax
mov    -0x8950(%rbp,%rax,4),%edi
xor    $0xffffffff,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    -0x101cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101cc(%rbp)
jmp    1d50 <genwidebmp+0xbf0>
movl   $0x1d,-0x101c8(%rbp)
cmpl   $0x0,-0x101c8(%rbp)
jl     1ee4 <genwidebmp+0xd84>
cmpl   $0x8,-0x101c8(%rbp)
jl     1e0c <genwidebmp+0xcac>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xfd,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
jmp    1e3c <genwidebmp+0xcdc>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movl   $0x0,-0x101cc(%rbp)
cmpl   $0x100,-0x101cc(%rbp)
jge    1ecb <genwidebmp+0xd6b>
movslq -0x101c8(%rbp),%rcx
lea    -0x10150(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
xor    $0xffffffff,%edi
shr    $0x8,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movslq -0x101c8(%rbp),%rcx
lea    -0x10150(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
xor    $0xffffffff,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    -0x101cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101cc(%rbp)
jmp    1e46 <genwidebmp+0xce6>
jmp    1ed0 <genwidebmp+0xd70>
mov    -0x101c8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x101c8(%rbp)
jmp    1dbd <genwidebmp+0xc5d>
movl   $0x7,-0x101c8(%rbp)
cmpl   $0x0,-0x101c8(%rbp)
jl     1f5a <genwidebmp+0xdfa>
movl   $0x0,-0x101cc(%rbp)
cmpl   $0x102,-0x101cc(%rbp)
jge    1f41 <genwidebmp+0xde1>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    -0x101cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101cc(%rbp)
jmp    1f05 <genwidebmp+0xda5>
jmp    1f46 <genwidebmp+0xde6>
mov    -0x101c8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x101c8(%rbp)
jmp    1eee <genwidebmp+0xd8e>
movl   $0xf,-0x101c8(%rbp)
cmpl   $0x0,-0x101c8(%rbp)
jl     203e <genwidebmp+0xede>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
movl   $0x0,-0x101cc(%rbp)
cmpl   $0x100,-0x101cc(%rbp)
jge    2025 <genwidebmp+0xec5>
movslq -0x101c8(%rbp),%rcx
lea    -0x4120(%rbp),%rax
shl    $0xa,%rcx
add    %rcx,%rax
movslq -0x101cc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
xor    $0xffffffff,%eax
and    $0xffff,%eax
mov    %eax,-0x101d4(%rbp)
mov    -0x101d4(%rbp),%edi
shr    $0x8,%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    -0x101d4(%rbp),%edi
and    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    -0x101cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101cc(%rbp)
jmp    1fab <genwidebmp+0xe4b>
jmp    202a <genwidebmp+0xeca>
mov    -0x101c8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x101c8(%rbp)
jmp    1f64 <genwidebmp+0xe04>
movl   $0x7,-0x101c8(%rbp)
cmpl   $0x0,-0x101c8(%rbp)
jl     20b4 <genwidebmp+0xf54>
movl   $0x0,-0x101cc(%rbp)
cmpl   $0x102,-0x101cc(%rbp)
jge    209b <genwidebmp+0xf3b>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    $0xff,%edi
mov    $0x0,%al
call   1030 <putchar@plt>
mov    -0x101cc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x101cc(%rbp)
jmp    205f <genwidebmp+0xeff>
jmp    20a0 <genwidebmp+0xf40>
mov    -0x101c8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x101c8(%rbp)
jmp    2048 <genwidebmp+0xee8>
add    $0x101f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<genwidebmp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10128,%rsp
mov    %edx,%r14d
mov    %rdi,%r13
test   %esi,%esi
mov    $0x60,%eax
cmovne %esi,%eax
cvtsi2sd %eax,%xmm0
mulsd  0xe93(%rip),%xmm0
divsd  0xe93(%rip),%xmm0
addsd  0xe93(%rip),%xmm0
cvttsd2si %xmm0,%r15d
xor    %ebp,%ebp
mov    $0x42,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0x4d,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0x20c13e,%edi
call   1050 <output4@plt>
xor    %edi,%edi
call   1050 <output4@plt>
mov    $0x3e,%edi
call   1050 <output4@plt>
mov    $0x28,%edi
call   1050 <output4@plt>
mov    $0x1020,%edi
call   1050 <output4@plt>
mov    $0x1040,%edi
call   1050 <output4@plt>
mov    $0x1,%edi
call   1060 <output2@plt>
mov    $0x1,%edi
call   1060 <output2@plt>
xor    %edi,%edi
call   1050 <output4@plt>
mov    $0x20c100,%edi
call   1050 <output4@plt>
mov    %r15d,%edi
call   1050 <output4@plt>
mov    %r15d,%edi
call   1050 <output4@plt>
mov    $0x2,%edi
call   1050 <output4@plt>
mov    $0x2,%edi
call   1050 <output4@plt>
xor    %edi,%edi
call   1050 <output4@plt>
mov    $0xffffff,%edi
call   1050 <output4@plt>
lea    0x8120(%rsp),%rdi
mov    $0x4000,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movaps 0xdd6(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0x100(%rsp)
movb   $0x0,0x110(%rsp)
movabs $0x66696e5520554e47,%rax
6e 69 66
mov    %rax,0x88(%rsp)
movabs $0x332e3620746e6f66,%rax
36 2e 33
mov    %rax,0x8f(%rsp)
mov    $0x20,%al
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbq %al,%rax
mov    %eax,%eax
shl    $0x6,%rax
mov    0x0(%r13,%rax,1),%ecx
mov    %ecx,0x8120(%rsp,%rbp,4)
mov    0x4(%r13,%rax,1),%ecx
mov    %ecx,0x8520(%rsp,%rbp,4)
mov    0x8(%r13,%rax,1),%ecx
mov    %ecx,0x8920(%rsp,%rbp,4)
mov    0xc(%r13,%rax,1),%ecx
mov    %ecx,0x8d20(%rsp,%rbp,4)
mov    0x10(%r13,%rax,1),%ecx
mov    %ecx,0x9120(%rsp,%rbp,4)
mov    0x14(%r13,%rax,1),%ecx
mov    %ecx,0x9520(%rsp,%rbp,4)
mov    0x18(%r13,%rax,1),%ecx
mov    %ecx,0x9920(%rsp,%rbp,4)
mov    0x1c(%r13,%rax,1),%ecx
mov    %ecx,0x9d20(%rsp,%rbp,4)
mov    0x20(%r13,%rax,1),%ecx
mov    %ecx,0xa120(%rsp,%rbp,4)
mov    0x24(%r13,%rax,1),%ecx
mov    %ecx,0xa520(%rsp,%rbp,4)
mov    0x28(%r13,%rax,1),%ecx
mov    %ecx,0xa920(%rsp,%rbp,4)
mov    0x2c(%r13,%rax,1),%ecx
mov    %ecx,0xad20(%rsp,%rbp,4)
mov    0x30(%r13,%rax,1),%ecx
mov    %ecx,0xb120(%rsp,%rbp,4)
mov    0x34(%r13,%rax,1),%ecx
mov    %ecx,0xb520(%rsp,%rbp,4)
mov    0x38(%r13,%rax,1),%ecx
mov    %ecx,0xb920(%rsp,%rbp,4)
mov    0x3c(%r13,%rax,1),%eax
mov    %eax,0xbd20(%rsp,%rbp,4)
cmp    $0xff,%rbp
je     13d1 <genwidebmp+0x291>
movzbl 0x11(%rsp,%rbp,1),%eax
add    $0x1,%rbp
jmp    12f0 <genwidebmp+0x1b0>
lea    0xc120(%rsp),%rbp
xor    %r12d,%r12d
mov    $0x4000,%edx
mov    %rbp,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
movdqa 0xc3d(%rip),%xmm0
lea    0xc66(%rip),%r15
xor    %r11d,%r11d
jmp    1557 <genwidebmp+0x417>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edi,%eax
or     $0x30,%eax
add    $0x37,%edi
cmp    $0xa000,%r11
cmovb  %eax,%edi
lea    0x30(%r10),%ecx
lea    0x37(%r10),%eax
cmp    $0xa,%r10d
cmovb  %ecx,%eax
shl    $0x6,%rdi
movdqu 0x0(%r13,%rdi,1),%xmm1
pslld  $0x2,%xmm1
shl    $0x6,%rax
movdqu 0x0(%r13,%rax,1),%xmm2
psrad  $0x6,%xmm2
por    %xmm1,%xmm2
movdqa %xmm2,0x0(%rbp)
movdqu 0x10(%r13,%rdi,1),%xmm1
pslld  $0x2,%xmm1
movdqu 0x10(%r13,%rax,1),%xmm2
psrad  $0x6,%xmm2
por    %xmm1,%xmm2
movdqa %xmm2,0x10(%rbp)
movdqu 0x20(%r13,%rdi,1),%xmm1
pslld  $0x2,%xmm1
movdqu 0x20(%r13,%rax,1),%xmm2
psrad  $0x6,%xmm2
por    %xmm1,%xmm2
movdqa %xmm2,0x20(%rbp)
movdqu 0x30(%r13,%rdi,1),%xmm1
pslld  $0x2,%xmm1
movdqu 0x30(%r13,%rax,1),%xmm2
psrad  $0x6,%xmm2
por    %xmm1,%xmm2
movdqa %xmm2,0x30(%rbp)
mov    0x18(%rbp),%r9d
mov    0x1c(%rbp),%ebx
mov    0x20(%rbp),%eax
mov    0x24(%rbp),%ecx
mov    0x28(%rbp),%esi
movdqa 0x0(%rbp),%xmm1
por    %xmm0,%xmm1
movdqa %xmm1,0x0(%rbp)
orb    $0x2,0x10(%rbp)
orb    $0x2,0x14(%rbp)
or     $0x2,%r9d
mov    %r9d,0x18(%rbp)
or     $0x2,%ebx
mov    %ebx,0x1c(%rbp)
or     $0x2,%eax
mov    %eax,0x20(%rbp)
or     $0x2,%ecx
mov    %ecx,0x24(%rbp)
or     $0x2,%esi
mov    %esi,0x28(%rbp)
movdqu 0x2c(%rbp),%xmm1
por    %xmm0,%xmm1
movdqu %xmm1,0x2c(%rbp)
cmp    $0xf,%r10d
mov    $0xfffe,%eax
mov    $0xfffffe,%ecx
cmove  %ecx,%eax
mov    %r11d,%ecx
not    %ecx
test   $0x3f00,%ecx
mov    $0xfffffffe,%ecx
cmove  %ecx,%eax
mov    %eax,0x3c(%rbp)
lea    0x100(%r11),%rax
add    $0x40,%rbp
add    $0x1,%r12d
cmp    $0xff00,%r11
mov    %rax,%r11
jae    15e5 <genwidebmp+0x4a5>
mov    %r11d,%edi
shr    $0xc,%edi
mov    %r12d,%r10d
and    $0xf,%r10d
test   %r14d,%r14d
je     1410 <genwidebmp+0x2d0>
mov    %edi,%eax
mov    %r10d,%ecx
lea    (%rax,%rax,4),%rsi
movsbl (%r15,%rsi,1),%eax
shl    $0xa,%eax
lea    (%rcx,%rcx,4),%rdx
movsbl (%r15,%rdx,1),%r9d
shl    $0x4,%r9d
or     %eax,%r9d
movsbl 0x1(%r15,%rsi,1),%eax
shl    $0xa,%eax
movsbl 0x1(%r15,%rdx,1),%ebx
shl    $0x4,%ebx
or     %eax,%ebx
movsbl 0x2(%r15,%rsi,1),%ecx
shl    $0xa,%ecx
movsbl 0x2(%r15,%rdx,1),%eax
shl    $0x4,%eax
or     %ecx,%eax
movsbl 0x3(%r15,%rsi,1),%r8d
shl    $0xa,%r8d
movsbl 0x3(%r15,%rdx,1),%ecx
shl    $0x4,%ecx
or     %r8d,%ecx
movsbl 0x4(%r15,%rsi,1),%edi
shl    $0xa,%edi
movsbl 0x4(%r15,%rdx,1),%esi
shl    $0x4,%esi
or     %edi,%esi
jmp    14cd <genwidebmp+0x38d>
lea    0x120(%rsp),%rdi
xor    %ebp,%ebp
mov    $0x7c00,%edx
xor    %esi,%esi
call   1040 <memset@plt>
lea    0x4(%r13),%r8
lea    0x3d20(%rsp),%rcx
jmp    16b6 <genwidebmp+0x576>
nopl   0x0(%rax)
mov    %edx,%edx
mov    %edi,%esi
lea    (%rdx,%rdx,4),%rdx
movsbl (%r15,%rdx,1),%edi
shl    $0xa,%edi
lea    (%rsi,%rsi,4),%rsi
movsbl (%r15,%rsi,1),%ebx
shl    $0x4,%ebx
or     %edi,%ebx
mov    %ebx,0x5920(%rsp,%rbp,4)
movsbl 0x1(%r15,%rdx,1),%edi
shl    $0xa,%edi
movsbl 0x1(%r15,%rsi,1),%ebx
shl    $0x4,%ebx
or     %edi,%ebx
mov    %ebx,0x5d20(%rsp,%rbp,4)
movsbl 0x2(%r15,%rdx,1),%edi
shl    $0xa,%edi
movsbl 0x2(%r15,%rsi,1),%ebx
shl    $0x4,%ebx
or     %edi,%ebx
mov    %ebx,0x6120(%rsp,%rbp,4)
movsbl 0x3(%r15,%rdx,1),%edi
shl    $0xa,%edi
movsbl 0x3(%r15,%rsi,1),%ebx
shl    $0x4,%ebx
or     %edi,%ebx
mov    %ebx,0x6520(%rsp,%rbp,4)
movsbl 0x4(%r15,%rdx,1),%edx
shl    $0xa,%edx
movsbl 0x4(%r15,%rsi,1),%esi
shl    $0x4,%esi
or     %edx,%esi
mov    %esi,0x6920(%rsp,%rbp,4)
add    $0x1,%rbp
add    $0x4,%rcx
cmp    $0x100,%rbp
je     1732 <genwidebmp+0x5f2>
mov    %ebp,%edx
shr    $0x4,%edx
mov    %ebp,%edi
and    $0xf,%edi
test   %r14d,%r14d
jne    1610 <genwidebmp+0x4d0>
mov    %edx,%esi
or     $0x30,%esi
add    $0x37,%edx
cmp    $0xa0,%rbp
cmovb  %esi,%edx
lea    0x30(%rdi),%ebx
lea    0x37(%rdi),%esi
cmp    $0xa,%edi
cmovb  %ebx,%esi
shl    $0x6,%rdx
add    %r8,%rdx
shl    $0x6,%rsi
add    %r8,%rsi
mov    %rcx,%rdi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    -0x4(%rsi,%rbx,4),%eax
sar    $0x7,%eax
or     -0x4(%rdx,%rbx,4),%eax
mov    %eax,-0x400(%rdi)
mov    (%rsi,%rbx,4),%eax
sar    $0x7,%eax
or     (%rdx,%rbx,4),%eax
mov    %eax,(%rdi)
add    $0x2,%rbx
add    $0x800,%rdi
cmp    $0x10,%rbx
jne    1700 <genwidebmp+0x5c0>
jmp    16a1 <genwidebmp+0x561>
lea    0x7d20(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x400,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movdqa 0x8f0(%rip),%xmm0
movdqa 0x7920(%rsp,%rbx,4),%xmm1
por    %xmm0,%xmm1
movdqa 0x7930(%rsp,%rbx,4),%xmm2
por    %xmm0,%xmm2
movdqa %xmm1,0x7920(%rsp,%rbx,4)
movdqa %xmm2,0x7930(%rsp,%rbx,4)
movdqa 0x7940(%rsp,%rbx,4),%xmm1
por    %xmm0,%xmm1
movdqa 0x7950(%rsp,%rbx,4),%xmm2
por    %xmm0,%xmm2
movdqa %xmm1,0x7940(%rsp,%rbx,4)
movdqa %xmm2,0x7950(%rsp,%rbx,4)
add    $0x10,%rbx
cmp    $0x100,%rbx
jne    1750 <genwidebmp+0x610>
lea    0x7550(%rsp),%rax
mov    $0xd,%ecx
movdqa 0x886(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa -0x30(%rax,%rdx,4),%xmm1
por    %xmm0,%xmm1
movdqa -0x20(%rax,%rdx,4),%xmm2
por    %xmm0,%xmm2
movdqa %xmm1,-0x30(%rax,%rdx,4)
movdqa %xmm2,-0x20(%rax,%rdx,4)
movdqa -0x10(%rax,%rdx,4),%xmm1
por    %xmm0,%xmm1
movdqa (%rax,%rdx,4),%xmm2
por    %xmm0,%xmm2
movdqa %xmm1,-0x10(%rax,%rdx,4)
movdqa %xmm2,(%rax,%rdx,4)
add    $0x10,%rdx
cmp    $0x100,%rdx
jne    17e0 <genwidebmp+0x6a0>
add    $0xfffffffffffffc00,%rax
sub    $0x1,%rcx
jae    17d0 <genwidebmp+0x690>
xor    %eax,%eax
nopl   0x0(%rax)
orb    $0x1,0x215c(%rsp,%rax,1)
01
orb    $0x1,0x219c(%rsp,%rax,1)
01
orb    $0x1,0x21dc(%rsp,%rax,1)
01
orb    $0x1,0x221c(%rsp,%rax,1)
01
orb    $0x1,0x225c(%rsp,%rax,1)
01
orb    $0x1,0x229c(%rsp,%rax,1)
01
orb    $0x1,0x22dc(%rsp,%rax,1)
01
orb    $0x1,0x231c(%rsp,%rax,1)
01
orb    $0x1,0x235c(%rsp,%rax,1)
01
orb    $0x1,0x239c(%rsp,%rax,1)
01
orb    $0x1,0x23dc(%rsp,%rax,1)
01
orb    $0x1,0x241c(%rsp,%rax,1)
01
orb    $0x1,0x245c(%rsp,%rax,1)
01
orb    $0x1,0x249c(%rsp,%rax,1)
01
orb    $0x1,0x24dc(%rsp,%rax,1)
01
orb    $0x1,0x251c(%rsp,%rax,1)
01
add    $0x400,%rax
cmp    $0x2000,%rax
jne    1840 <genwidebmp+0x700>
add    $0x3fc03c,%r13
mov    $0xff00,%r14d
nop
mov    %r14d,%r15d
shr    $0x8,%r15d
mov    $0xf,%r12d
mov    %r13,0x8(%rsp)
mov    %r13,%rbp
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rax
shl    $0x6,%rax
add    %rsp,%rax
add    $0xc120,%rax
mov    (%rax,%r12,4),%ebx
not    %ebx
mov    %ebx,%eax
shr    $0x18,%eax
mov    %eax,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    %ebx,%eax
shr    $0x10,%eax
movzbl %al,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
movzbl %bh,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
movzbl %bl,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    0x0(%rbp,%rbx,1),%eax
not    %eax
movzbl %ah,%edi
mov    %eax,%r13d
xor    %eax,%eax
call   1030 <putchar@plt>
movzbl %r13b,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0x40,%rbx
cmp    $0x4000,%rbx
jne    1950 <genwidebmp+0x810>
add    $0xfffffffffffffffc,%rbp
sub    $0x1,%r12
jae    1900 <genwidebmp+0x7c0>
lea    -0x100(%r14),%rax
mov    0x8(%rsp),%r13
add    $0xffffffffffffc000,%r13
test   %r14,%r14
mov    %rax,%r14
jne    18e0 <genwidebmp+0x7a0>
xor    %edi,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
xor    %edi,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
xor    %edi,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0x1,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x7d20(%rsp,%rbx,4),%eax
not    %eax
movzbl %ah,%edi
mov    %eax,%ebp
xor    %eax,%eax
call   1030 <putchar@plt>
movzbl %bpl,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0x1,%rbx
cmp    $0x100,%rbx
jne    19e0 <genwidebmp+0x8a0>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xfc,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
xor    %ebx,%ebx
nop
mov    0x7920(%rsp,%rbx,4),%eax
not    %eax
movzbl %ah,%edi
mov    %eax,%ebp
xor    %eax,%eax
call   1030 <putchar@plt>
movzbl %bpl,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0x1,%rbx
cmp    $0x100,%rbx
jne    1a40 <genwidebmp+0x900>
lea    0x7520(%rsp),%r15
mov    $0x1d,%r14d
nopl   0x0(%rax,%rax,1)
xor    %ebx,%ebx
cmp    $0x8,%r14
setb   %bl
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
lea    (%rbx,%rbx,1),%edi
add    $0xfd,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
xor    %ebp,%ebp
nop
mov    (%r15,%rbp,4),%ebx
not    %ebx
movzbl %bh,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
movzbl %bl,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    $0x100,%rbp
jne    1ac0 <genwidebmp+0x980>
add    $0xfffffffffffffc00,%r15
sub    $0x1,%r14
jae    1a80 <genwidebmp+0x940>
mov    $0x102,%ebx
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1b00 <genwidebmp+0x9c0>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1b30 <genwidebmp+0x9f0>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1b60 <genwidebmp+0xa20>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1b90 <genwidebmp+0xa50>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1bc0 <genwidebmp+0xa80>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1bf0 <genwidebmp+0xab0>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1c20 <genwidebmp+0xae0>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1c50 <genwidebmp+0xb10>
lea    0xbd20(%rsp),%r15
mov    $0xf,%r14d
nopl   0x0(%rax,%rax,1)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rbp,4),%ebx
not    %ebx
movzbl %bh,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
movzbl %bl,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    $0x100,%rbp
jne    1cc0 <genwidebmp+0xb80>
add    $0xfffffffffffffc00,%r15
sub    $0x1,%r14
jae    1c80 <genwidebmp+0xb40>
mov    $0x102,%ebx
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1d00 <genwidebmp+0xbc0>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1d30 <genwidebmp+0xbf0>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1d60 <genwidebmp+0xc20>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1d90 <genwidebmp+0xc50>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1dc0 <genwidebmp+0xc80>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1df0 <genwidebmp+0xcb0>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1e20 <genwidebmp+0xce0>
mov    $0x102,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
mov    $0xff,%edi
xor    %eax,%eax
call   1030 <putchar@plt>
add    $0xffffffff,%ebx
jne    1e50 <genwidebmp+0xd10>
add    $0x10128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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