void calcchr(unsigned char bmp60[][16], int pc6001a, int size_y_out) {
  int i, j;
  int chr;
  const unsigned char dots2 = 0x03;
  const unsigned char dots3 = 0x07;
  const unsigned char dots4 = 0x0f;
  const unsigned char dots8 = 0xff;
  const int lower[] = {11, 10, 9, 8, 6, 4, 2, 0};
  const int line_shape[][4] = {
      {1, 1, 1, 0}, {1, 1, 0, 1}, {1, 0, 1, 1}, {0, 1, 1, 1},
      {1, 1, 1, 1}, {0, 0, 1, 1}, {1, 1, 0, 0}, {0, 1, 0, 1},
      {1, 0, 0, 1}, {0, 1, 1, 0}, {1, 0, 1, 0},
  };
  const int boxdraw_6001a[] = {0x90, 0x91, 0x92, 0x93, 0x8f, 0x96,
                               0x95, 0x98, 0x99, 0x9a, 0x9b};
  for (i = 0; i < sizeof(line_shape) / sizeof(line_shape[0][0]) / 4; i++) {
    chr = pc6001a ? boxdraw_6001a[i] : 0x11 + i;
    for (j = 0; j < 12; j++) {
      bmp60[chr][j] = 0;
    }
    bmp60[chr][size_y_out / 2 - 1] = bmp60[chr][size_y_out / 2] =
        (line_shape[i][0] ? (dots4 << 4) : 0) | (line_shape[i][1] ? dots4 : 0);
    for (j = 0; j < size_y_out / 2 + 1; j++) {
      bmp60[chr][j] |= line_shape[i][2] ? (dots2 << 3) : 0;
    }
    for (j = size_y_out / 2 - 1; j < size_y_out; j++) {
      bmp60[chr][j] |= line_shape[i][3] ? (dots2 << 3) : 0;
    }
  }
  if (!pc6001a)
    return;
  bmp60[0x04][0] = bmp60[0x04][3] = dots2 << 5;
  bmp60[0x04][1] = bmp60[0x04][2] = 0x90;
  for (i = 0; i < 4; i++) {
    bmp60[0x03][i] = bmp60[0x04][i] >> 2;
    bmp60[0x0a][i] = bmp60[0x04][i] >> 4;
    bmp60[0x05][i + 4] = bmp60[0x04][i];
    bmp60[0x09][i + 4] = bmp60[0x0a][i];
    bmp60[0x06][i + 8] = bmp60[0x04][i];
    bmp60[0x07][i + 8] = bmp60[0x03][i];
    bmp60[0x08][i + 8] = bmp60[0x0a][i];
  }
  for (i = 0; i < 8; i++) {
    for (j = lower[i]; j < 12; j++) {
      chr = 0x80 + i;
      bmp60[chr][j] = dots8;
    }
  }
  for (i = 0; i < 7; i++) {
    for (j = 0; j < 12; j++) {
      chr = 0x88 + i;
      bmp60[chr][j] = 0x100 - (0x80 >> i);
    }
  }
  bmp60[0x94][0] = bmp60[0x94][1] = dots8;
  for (i = 0; i < 12; i++) {
    bmp60[0x97][i] = dots2 << 6;
  }
  for (i = 0; i < 4; i++) {
    chr = 0x9c + i;
    for (j = 0; j < 4; j++) {
      bmp60[chr][j] = (i & 0x02) ? (dots2 << 3) : 0;
    }
    for (j = 8; j < 12; j++) {
      bmp60[chr][j] = (i & 0x02) ? 0 : (dots2 << 3);
    }
    bmp60[chr][(i & 0x02) ? 4 : 7] = (i & 0x01) ? (dots3 << 3) : (dots3 << 2);
    bmp60[chr][(i & 0x02) ? 5 : 6] = (i & 0x01) ? (dots4 << 4) : (dots4 << 0);
    bmp60[chr][(i & 0x02) ? 6 : 5] = (i & 0x01) ? (dots3 << 5) : (dots3 << 0);
  }
  for (i = 0; i < 4; i++) {
    chr = 0xe0 + i;
    for (j = 0; j < 12; j++) {
      bmp60[chr][j] = (i == 0) ? 0 : (dots2 << 3);
    }
    bmp60[chr][2] |= (i == 1) ? 0 : (dots4 << 4);
    bmp60[chr][2] |= (i == 3) ? 0 : (dots4 << 0);
    bmp60[chr][3] = bmp60[chr][2];
    bmp60[chr][8] = bmp60[chr][2];
    bmp60[chr][9] = bmp60[chr][2];
  }
  for (j = 0; j < 12; j++) {
    bmp60[0xe4][j] = (0x02 << (j * 8 / 12)) - 0x01;
    bmp60[0xe5][j] = 0x100 - (0x80 >> (j * 8 / 12));
    bmp60[0xe6][j] = (0x100 >> (j * 8 / 12)) - 0x01;
    bmp60[0xe7][j] = 0x100 - (0x01 << (j * 8 / 12));
  }
  for (i = 0; i < 3; i++) {
    chr = 0xee + i;
    for (j = 0; j < 12; j++) {
      if (i == 0 || i == 2) {
        bmp60[chr][j] = 0x01 << (j * 2 / 3);
      }
      if (i == 1 || i == 2) {
        bmp60[chr][j] |= 0x80 >> (j * 2 / 3);
      }
    }
  }
  bmp60[0xf1][5] = bmp60[0xf1][6] = 0xaa;
  bmp60[0xf7][5] = bmp60[0xf7][6] = 0xaa;
  bmp60[0xf3][5] = bmp60[0xf3][6] = dots8;
  bmp60[0xf4][5] = bmp60[0xf4][6] = dots8;
  bmp60[0xf5][5] = bmp60[0xf5][6] = 0xa0;
  bmp60[0xf6][5] = bmp60[0xf6][6] = 0x0a;
  for (i = 0; i < 6; i++) {
    bmp60[0xf5][i] |= dots2 << 3;
    bmp60[0xf6][i] |= dots2 << 3;
    if (i % 2 == 0) {
      bmp60[0xf2][i] |= dots2 << 3;
      bmp60[0xf3][i] |= dots2 << 3;
      bmp60[0xf7][i] |= dots2 << 3;
    }
  }
  for (i = 6; i < 12; i++) {
    bmp60[0xf5][i] |= dots2 << 3;
    bmp60[0xf6][i] |= dots2 << 3;
    if (i % 2 == 0) {
      bmp60[0xf2][i] |= dots2 << 3;
      bmp60[0xf4][i] |= dots2 << 3;
      bmp60[0xf7][i] |= dots2 << 3;
    }
  }
}


x86 assembly (clang, -O0):
<calcchr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movb   $0x3,-0x1d(%rbp)
movb   $0x7,-0x1e(%rbp)
movb   $0xf,-0x1f(%rbp)
movb   $0xff,-0x20(%rbp)
mov    0xec4(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xec1(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xebe(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0xebb(%rip),%rax
mov    %rax,-0x28(%rbp)
lea    -0xf0(%rbp),%rdi
lea    0xeb1(%rip),%rsi
mov    $0xb0,%edx
call   1030 <memcpy@plt>
lea    -0x120(%rbp),%rdi
lea    0xf49(%rip),%rsi
mov    $0x2c,%edx
call   1030 <memcpy@plt>
movl   $0x0,-0x14(%rbp)
movslq -0x14(%rbp),%rax
cmp    $0xb,%rax
jae    13c1 <calcchr+0x2b1>
cmpl   $0x0,-0xc(%rbp)
je     11c6 <calcchr+0xb6>
movslq -0x14(%rbp),%rax
mov    -0x120(%rbp,%rax,4),%eax
mov    %eax,-0x124(%rbp)
jmp    11d2 <calcchr+0xc2>
mov    -0x14(%rbp),%eax
add    $0x11,%eax
mov    %eax,-0x124(%rbp)
mov    -0x124(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0xc,-0x18(%rbp)
jge    1211 <calcchr+0x101>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11e2 <calcchr+0xd2>
movslq -0x14(%rbp),%rcx
lea    -0xf0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%edx
xor    %eax,%eax
mov    $0xf0,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
movslq -0x14(%rbp),%rdx
lea    -0xf0(%rbp),%rcx
shl    $0x4,%rdx
add    %rdx,%rcx
mov    0x4(%rcx),%esi
xor    %ecx,%ecx
mov    $0xf,%edx
cmp    $0x0,%esi
cmovne %edx,%ecx
or     %ecx,%eax
mov    %al,-0x131(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    %rax,-0x140(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x131(%rbp),%dl
mov    %eax,%ecx
mov    -0x140(%rbp),%rax
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    %rax,-0x130(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x131(%rbp),%dl
mov    %eax,%ecx
mov    -0x130(%rbp),%rax
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x144(%rbp)
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x144(%rbp),%eax
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1345 <calcchr+0x235>
movslq -0x14(%rbp),%rcx
lea    -0xf0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%ecx
xor    %esi,%esi
mov    $0x18,%eax
cmp    $0x0,%ecx
cmovne %eax,%esi
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12d2 <calcchr+0x1c2>
mov    -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13ae <calcchr+0x29e>
movslq -0x14(%rbp),%rcx
lea    -0xf0(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0xc(%rax),%ecx
xor    %esi,%esi
mov    $0x18,%eax
cmp    $0x0,%ecx
cmovne %eax,%esi
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1356 <calcchr+0x246>
jmp    13b3 <calcchr+0x2a3>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1198 <calcchr+0x88>
cmpl   $0x0,-0xc(%rbp)
jne    13d0 <calcchr+0x2c0>
jmp    1c72 <calcchr+0xb62>
mov    -0x8(%rbp),%rax
movb   $0x60,0x43(%rax)
mov    -0x8(%rbp),%rax
movb   $0x60,0x40(%rax)
mov    -0x8(%rbp),%rax
movb   $0x90,0x42(%rax)
mov    -0x8(%rbp),%rax
movb   $0x90,0x41(%rax)
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    14eb <calcchr+0x3db>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0x40(%rax,%rcx,1),%eax
sar    $0x2,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,0x30(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0x40(%rax,%rcx,1),%eax
sar    $0x4,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %dl,0xa0(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    0x40(%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    %dl,0x50(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    0xa0(%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x4,%ecx
movslq %ecx,%rcx
mov    %dl,0x90(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    0x40(%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
mov    %dl,0x60(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    0x30(%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
mov    %dl,0x70(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    0xa0(%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x8,%ecx
movslq %ecx,%rcx
mov    %dl,0x80(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13f7 <calcchr+0x2e7>
movl   $0x0,-0x14(%rbp)
cmpl   $0x8,-0x14(%rbp)
jge    1554 <calcchr+0x444>
movslq -0x14(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0xc,-0x18(%rbp)
jge    1541 <calcchr+0x431>
mov    -0x14(%rbp),%eax
add    $0x80,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movb   $0xff,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1507 <calcchr+0x3f7>
jmp    1546 <calcchr+0x436>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    14f2 <calcchr+0x3e2>
movl   $0x0,-0x14(%rbp)
cmpl   $0x7,-0x14(%rbp)
jge    15cd <calcchr+0x4bd>
movl   $0x0,-0x18(%rbp)
cmpl   $0xc,-0x18(%rbp)
jge    15ba <calcchr+0x4aa>
mov    -0x14(%rbp),%eax
add    $0x88,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%ecx
mov    $0x80,%eax
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x100,%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    156c <calcchr+0x45c>
jmp    15bf <calcchr+0x4af>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    155b <calcchr+0x44b>
mov    -0x8(%rbp),%rax
movb   $0xff,0x941(%rax)
mov    -0x8(%rbp),%rax
movb   $0xff,0x940(%rax)
movl   $0x0,-0x14(%rbp)
cmpl   $0xc,-0x14(%rbp)
jge    1612 <calcchr+0x502>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0xc0,0x970(%rax,%rcx,1)
c0
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    15ea <calcchr+0x4da>
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    1799 <calcchr+0x689>
mov    -0x14(%rbp),%eax
add    $0x9c,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0x4,-0x18(%rbp)
jge    1678 <calcchr+0x568>
mov    -0x14(%rbp),%edx
and    $0x2,%edx
xor    %eax,%eax
mov    $0x18,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1635 <calcchr+0x525>
movl   $0x8,-0x18(%rbp)
cmpl   $0xc,-0x18(%rbp)
jge    16c2 <calcchr+0x5b2>
mov    -0x14(%rbp),%edx
and    $0x2,%edx
mov    $0x18,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    167f <calcchr+0x56f>
mov    -0x14(%rbp),%edx
and    $0x1,%edx
mov    $0x1c,%eax
mov    $0x38,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%edi
and    $0x2,%edi
mov    $0x7,%ecx
mov    $0x4,%esi
cmp    $0x0,%edi
cmovne %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%edx
and    $0x1,%edx
mov    $0xf,%eax
mov    $0xf0,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%edi
and    $0x2,%edi
mov    $0x6,%ecx
mov    $0x5,%esi
cmp    $0x0,%edi
cmovne %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%edx
and    $0x1,%edx
mov    $0x7,%eax
mov    $0xe0,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x14(%rbp),%edi
and    $0x2,%edi
mov    $0x5,%ecx
mov    $0x6,%esi
cmp    $0x0,%edi
cmovne %esi,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1619 <calcchr+0x509>
movl   $0x0,-0x14(%rbp)
cmpl   $0x4,-0x14(%rbp)
jge    18c6 <calcchr+0x7b6>
mov    -0x14(%rbp),%eax
add    $0xe0,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0xc,-0x18(%rbp)
jge    17fc <calcchr+0x6ec>
mov    -0x14(%rbp),%edx
mov    $0x18,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmove  %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    17bc <calcchr+0x6ac>
mov    -0x14(%rbp),%ecx
mov    $0xf0,%edx
xor    %eax,%eax
cmp    $0x1,%ecx
cmove  %eax,%edx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movzbl 0x2(%rax),%ecx
or     %edx,%ecx
mov    %cl,0x2(%rax)
mov    -0x14(%rbp),%ecx
mov    $0xf,%edx
xor    %eax,%eax
cmp    $0x3,%ecx
cmove  %eax,%edx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movzbl 0x2(%rax),%ecx
or     %edx,%ecx
mov    %cl,0x2(%rax)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x2(%rax),%cl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rdx
shl    $0x4,%rdx
add    %rdx,%rax
mov    %cl,0x3(%rax)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x2(%rax),%cl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rdx
shl    $0x4,%rdx
add    %rdx,%rax
mov    %cl,0x8(%rax)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x2(%rax),%cl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rdx
shl    $0x4,%rdx
add    %rdx,%rax
mov    %cl,0x9(%rax)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    17a0 <calcchr+0x690>
movl   $0x0,-0x18(%rbp)
cmpl   $0xc,-0x18(%rbp)
jge    199d <calcchr+0x88d>
mov    -0x18(%rbp),%eax
shl    $0x3,%eax
mov    $0xc,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0x2,%eax
shl    %cl,%eax
sub    $0x1,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,0xe40(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
shl    $0x3,%eax
mov    $0xc,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0x80,%eax
sar    %cl,%eax
mov    %eax,%ecx
mov    $0x100,%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,0xe50(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
shl    $0x3,%eax
mov    $0xc,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0x100,%eax
sar    %cl,%eax
sub    $0x1,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,0xe60(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
shl    $0x3,%eax
mov    $0xc,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,%ecx
mov    $0x100,%eax
sub    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,0xe70(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    18cd <calcchr+0x7bd>
movl   $0x0,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
jge    1a7a <calcchr+0x96a>
mov    -0x14(%rbp),%eax
add    $0xee,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
cmpl   $0xc,-0x18(%rbp)
jge    1a67 <calcchr+0x957>
cmpl   $0x0,-0x14(%rbp)
je     19de <calcchr+0x8ce>
cmpl   $0x2,-0x14(%rbp)
jne    1a0d <calcchr+0x8fd>
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
cmpl   $0x1,-0x14(%rbp)
je     1a21 <calcchr+0x911>
cmpl   $0x2,-0x14(%rbp)
jne    1a54 <calcchr+0x944>
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    $0x80,%esi
sar    %cl,%esi
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    1a59 <calcchr+0x949>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    19c0 <calcchr+0x8b0>
jmp    1a6c <calcchr+0x95c>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    19a4 <calcchr+0x894>
mov    -0x8(%rbp),%rax
movb   $0xaa,0xf16(%rax)
mov    -0x8(%rbp),%rax
movb   $0xaa,0xf15(%rax)
mov    -0x8(%rbp),%rax
movb   $0xaa,0xf76(%rax)
mov    -0x8(%rbp),%rax
movb   $0xaa,0xf75(%rax)
mov    -0x8(%rbp),%rax
movb   $0xff,0xf36(%rax)
mov    -0x8(%rbp),%rax
movb   $0xff,0xf35(%rax)
mov    -0x8(%rbp),%rax
movb   $0xff,0xf46(%rax)
mov    -0x8(%rbp),%rax
movb   $0xff,0xf45(%rax)
mov    -0x8(%rbp),%rax
movb   $0xa0,0xf56(%rax)
mov    -0x8(%rbp),%rax
movb   $0xa0,0xf55(%rax)
mov    -0x8(%rbp),%rax
movb   $0xa,0xf66(%rax)
mov    -0x8(%rbp),%rax
movb   $0xa,0xf65(%rax)
movl   $0x0,-0x14(%rbp)
cmpl   $0x6,-0x14(%rbp)
jge    1bb8 <calcchr+0xaa8>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0xf50(%rax,%rcx,1),%edx
or     $0x18,%edx
mov    %dl,0xf50(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0xf60(%rax,%rcx,1),%edx
or     $0x18,%edx
mov    %dl,0xf60(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1ba5 <calcchr+0xa95>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0xf20(%rax,%rcx,1),%edx
or     $0x18,%edx
mov    %dl,0xf20(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0xf30(%rax,%rcx,1),%edx
or     $0x18,%edx
mov    %dl,0xf30(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0xf70(%rax,%rcx,1),%edx
or     $0x18,%edx
mov    %dl,0xf70(%rax,%rcx,1)
jmp    1baa <calcchr+0xa9a>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1b05 <calcchr+0x9f5>
movl   $0x6,-0x14(%rbp)
cmpl   $0xc,-0x14(%rbp)
jge    1c72 <calcchr+0xb62>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0xf50(%rax,%rcx,1),%edx
or     $0x18,%edx
mov    %dl,0xf50(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0xf60(%rax,%rcx,1),%edx
or     $0x18,%edx
mov    %dl,0xf60(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1c5f <calcchr+0xb4f>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0xf20(%rax,%rcx,1),%edx
or     $0x18,%edx
mov    %dl,0xf20(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0xf40(%rax,%rcx,1),%edx
or     $0x18,%edx
mov    %dl,0xf40(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl 0xf70(%rax,%rcx,1),%edx
or     $0x18,%edx
mov    %dl,0xf70(%rax,%rcx,1)
jmp    1c64 <calcchr+0xb54>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1bbf <calcchr+0xaaf>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calcchr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %edx,%eax
shr    $0x1f,%eax
add    %edx,%eax
sar    %eax
mov    %eax,-0x74(%rsp)
movslq %eax,%rcx
lea    -0x1(%rcx),%eax
cltq
mov    %rax,(%rsp)
lea    0x1(%rcx),%r12d
movslq %edx,%r11
mov    %r11,%rax
sub    %rcx,%rax
lea    0x1(%rax),%r13
mov    %r12d,%ebp
and    $0xffffffe0,%ebp
mov    %rbp,-0x68(%rsp)
add    $0xffffffffffffffe0,%rbp
mov    %rbp,-0x20(%rsp)
shr    $0x5,%rbp
add    $0x1,%rbp
add    $0xffffffffffffffe1,%rax
mov    %rax,-0x18(%rsp)
mov    %rax,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
mov    %rbp,%rax
mov    %rbp,-0x28(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,-0x38(%rsp)
mov    %r12d,%r10d
and    $0xfffffff8,%r10d
mov    %r13,%rbp
and    $0xffffffffffffffe0,%rbp
mov    %rbx,%rax
mov    %rbx,-0x30(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,-0x48(%rsp)
mov    %r13,%rax
mov    %r13,-0x80(%rsp)
and    $0xfffffffffffffff8,%r13
lea    -0x1(%rcx),%rax
mov    %rax,-0x60(%rsp)
mov    %rbp,-0x70(%rsp)
lea    (%rcx,%rbp,1),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x50(%rsp)
lea    -0x1(%rcx,%r13,1),%rax
mov    %rax,-0x8(%rsp)
lea    0x30(%rdi),%rax
mov    %rax,-0x40(%rsp)
lea    0x2f(%rcx,%rdi,1),%rax
mov    %rax,-0x58(%rsp)
mov    %rcx,0x8(%rsp)
lea    (%rdi,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rsp)
xor    %ecx,%ecx
mov    %esi,-0x78(%rsp)
jmp    120e <calcchr+0x10e>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    $0xb,%rcx
je     1564 <calcchr+0x464>
test   %esi,%esi
je     1220 <calcchr+0x120>
lea    0xde7(%rip),%rax
mov    (%rax,%rcx,4),%eax
jmp    1223 <calcchr+0x123>
xchg   %ax,%ax
lea    0x11(%rcx),%eax
mov    $0x2a8,%ebp
shr    %cl,%rbp
movslq %eax,%r14
shl    $0x4,%r14
and    $0x1,%bpl
shl    $0x4,%bpl
mov    $0x524,%eax
bt     %rcx,%rax
mov    $0x0,%eax
mov    $0xf,%ebx
cmovae %ebx,%eax
lea    (%rdi,%r14,1),%r15
or     %bpl,%al
add    $0xf0,%al
movl   $0x0,0x8(%rdi,%r14,1)
movq   $0x0,(%rdi,%r14,1)
mov    0x8(%rsp),%rbp
mov    %al,0x0(%rbp,%r15,1)
mov    (%rsp),%rbp
mov    %al,0x0(%rbp,%r15,1)
cmp    $0xffffffff,%edx
jl     13cd <calcchr+0x2cd>
mov    $0x1c2,%eax
bt     %rcx,%rax
mov    $0x0,%r8d
mov    $0x18,%eax
cmovae %eax,%r8d
cmp    $0x8,%r12d
jae    12b0 <calcchr+0x1b0>
xor    %ebx,%ebx
jmp    13c0 <calcchr+0x2c0>
nopl   0x0(%rax,%rax,1)
movzbl %r8b,%r9d
cmp    $0x20,%r12d
jae    12c1 <calcchr+0x1c1>
xor    %eax,%eax
jmp    1378 <calcchr+0x278>
movd   %r9d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
cmpq   $0x0,-0x20(%rsp)
je     1552 <calcchr+0x452>
mov    -0x40(%rsp),%rax
lea    (%rax,%r14,1),%rbx
mov    -0x38(%rsp),%rax
xor    %ebp,%ebp
movdqu -0x30(%rbx,%rbp,1),%xmm1
movdqu -0x20(%rbx,%rbp,1),%xmm2
movdqu -0x10(%rbx,%rbp,1),%xmm3
movdqu (%rbx,%rbp,1),%xmm4
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,-0x30(%rbx,%rbp,1)
movdqu %xmm2,-0x20(%rbx,%rbp,1)
por    %xmm0,%xmm3
por    %xmm0,%xmm4
movdqu %xmm3,-0x10(%rbx,%rbp,1)
movdqu %xmm4,(%rbx,%rbp,1)
add    $0x40,%rbp
add    $0xfffffffffffffffe,%rax
jne    12f0 <calcchr+0x1f0>
testb  $0x1,-0x28(%rsp)
je     1363 <calcchr+0x263>
movdqu 0x0(%rbp,%r15,1),%xmm1
movdqu 0x10(%rbp,%r15,1),%xmm2
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,0x0(%rbp,%r15,1)
movdqu %xmm2,0x10(%rbp,%r15,1)
cmp    %r12,-0x68(%rsp)
je     13cd <calcchr+0x2cd>
mov    -0x68(%rsp),%rbx
mov    %rbx,%rax
test   $0x18,%r12b
je     13c0 <calcchr+0x2c0>
movd   %r9d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movq   (%r15,%rax,1),%xmm1
por    %xmm0,%xmm1
movq   %xmm1,(%r15,%rax,1)
add    $0x8,%rax
cmp    %rax,%r10
jne    1390 <calcchr+0x290>
mov    %r10,%rbx
cmp    %r12,%r10
je     13cd <calcchr+0x2cd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
or     %r8b,(%r15,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    13c0 <calcchr+0x2c0>
cmp    %edx,-0x74(%rsp)
jg     1200 <calcchr+0x100>
mov    $0x641,%eax
bt     %rcx,%rax
mov    $0x0,%ebp
mov    $0x18,%eax
cmovae %eax,%ebp
mov    -0x60(%rsp),%rbx
cmpq   $0x8,-0x80(%rsp)
jb     1540 <calcchr+0x440>
movzbl %bpl,%r9d
cmpq   $0x20,-0x80(%rsp)
jae    1411 <calcchr+0x311>
xor    %eax,%eax
jmp    14f3 <calcchr+0x3f3>
movd   %r9d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
cmpq   $0x20,-0x18(%rsp)
jae    1431 <calcchr+0x331>
xor    %r8d,%r8d
jmp    14a0 <calcchr+0x3a0>
mov    -0x58(%rsp),%rax
lea    (%rax,%r14,1),%rsi
mov    -0x48(%rsp),%rax
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x30(%rsi,%r8,1),%xmm1
movdqu -0x20(%rsi,%r8,1),%xmm2
movdqu -0x10(%rsi,%r8,1),%xmm3
movdqu (%rsi,%r8,1),%xmm4
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,-0x30(%rsi,%r8,1)
movdqu %xmm2,-0x20(%rsi,%r8,1)
por    %xmm0,%xmm3
por    %xmm0,%xmm4
movdqu %xmm3,-0x10(%rsi,%r8,1)
movdqu %xmm4,(%rsi,%r8,1)
add    $0x40,%r8
add    $0xfffffffffffffffe,%rax
jne    1450 <calcchr+0x350>
testb  $0x1,-0x30(%rsp)
je     14ce <calcchr+0x3ce>
add    -0x60(%rsp),%r8
movdqu (%r15,%r8,1),%xmm1
movdqu 0x10(%r15,%r8,1),%xmm2
por    %xmm0,%xmm1
por    %xmm0,%xmm2
movdqu %xmm1,(%r15,%r8,1)
movdqu %xmm2,0x10(%r15,%r8,1)
mov    -0x70(%rsp),%rax
cmp    %rax,-0x80(%rsp)
mov    -0x78(%rsp),%esi
je     1200 <calcchr+0x100>
mov    -0x70(%rsp),%rax
mov    -0x50(%rsp),%rbx
testb  $0x18,-0x80(%rsp)
je     1540 <calcchr+0x440>
movd   %r9d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
add    -0x10(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
movq   (%r14,%rax,1),%xmm1
por    %xmm0,%xmm1
movq   %xmm1,(%r14,%rax,1)
add    $0x8,%rax
cmp    %rax,%r13
jne    1510 <calcchr+0x410>
mov    -0x8(%rsp),%rbx
cmp    %r13,-0x80(%rsp)
je     1200 <calcchr+0x100>
nopl   0x0(%rax)
or     %bpl,(%r15,%rbx,1)
add    $0x1,%rbx
cmp    %rbx,%r11
jne    1540 <calcchr+0x440>
jmp    1200 <calcchr+0x100>
xor    %ebp,%ebp
testb  $0x1,-0x28(%rsp)
jne    133f <calcchr+0x23f>
jmp    1363 <calcchr+0x263>
test   %esi,%esi
je     1abd <calcchr+0x9bd>
movl   $0x60909060,0x40(%rdi)
movb   $0x18,0x30(%rdi)
movb   $0x6,0xa0(%rdi)
movb   $0x60,0x54(%rdi)
movb   $0x6,0x94(%rdi)
movw   $0x9060,0x68(%rdi)
movw   $0x2418,0x78(%rdi)
movw   $0x906,0x88(%rdi)
06 09
movw   $0x2424,0x31(%rdi)
movw   $0x909,0xa1(%rdi)
09 09
movw   $0x9090,0x55(%rdi)
movw   $0x909,0x95(%rdi)
09 09
movb   $0x90,0x6a(%rdi)
movb   $0x24,0x7a(%rdi)
movb   $0x9,0x8a(%rdi)
movb   $0x18,0x33(%rdi)
movb   $0x6,0xa3(%rdi)
movb   $0x60,0x57(%rdi)
movb   $0x6,0x97(%rdi)
movb   $0x60,0x6b(%rdi)
movb   $0x18,0x7b(%rdi)
movb   $0x6,0x8b(%rdi)
movb   $0xff,0x80b(%rdi)
movw   $0xffff,0x81a(%rdi)
ff ff
movw   $0xffff,0x829(%rdi)
ff ff
movb   $0xff,0x82b(%rdi)
movl   $0xffffffff,0x838(%rdi)
ff ff ff
movw   $0xffff,0x84a(%rdi)
ff ff
movl   $0xffffffff,0x846(%rdi)
ff ff ff
movq   $0xffffffffffffffff,0x854(%rdi)
ff ff ff ff
movw   $0xffff,0x86a(%rdi)
ff ff
movq   $0xffffffffffffffff,0x862(%rdi)
ff ff ff ff
movl   $0xffffffff,0x878(%rdi)
ff ff ff
movq   $0xffffffffffffffff,0x870(%rdi)
ff ff ff ff
movabs $0x8080808080808080,%rax
80 80 80
mov    %rax,0x880(%rdi)
movl   $0x80808080,0x888(%rdi)
80 80 80
movabs $0xc0c0c0c0c0c0c0c0,%rax
c0 c0 c0
mov    %rax,0x890(%rdi)
movl   $0xc0c0c0c0,0x898(%rdi)
c0 c0 c0
movabs $0xe0e0e0e0e0e0e0e0,%rcx
e0 e0 e0
mov    %rcx,0x8a0(%rdi)
movl   $0xe0e0e0e0,0x8a8(%rdi)
e0 e0 e0
movabs $0xf0f0f0f0f0f0f0f0,%rcx
f0 f0 f0
mov    %rcx,0x8b0(%rdi)
movl   $0xf0f0f0f0,0x8b8(%rdi)
f0 f0 f0
movabs $0xf8f8f8f8f8f8f8f8,%rcx
f8 f8 f8
mov    %rcx,0x8c0(%rdi)
movl   $0xf8f8f8f8,0x8c8(%rdi)
f8 f8 f8
movabs $0xfcfcfcfcfcfcfcfc,%rcx
fc fc fc
mov    %rcx,0x8d0(%rdi)
movl   $0xfcfcfcfc,0x8d8(%rdi)
movabs $0xfefefefefefefefe,%rcx
fe fe fe
mov    %rcx,0x8e0(%rdi)
movl   $0xfefefefe,0x8e8(%rdi)
fe fe fe
movb   $0xff,0x941(%rdi)
movb   $0xff,0x940(%rdi)
mov    %rax,0x970(%rdi)
movl   $0xc0c0c0c0,0x978(%rdi)
c0 c0 c0
movl   $0x0,0x9c0(%rdi)
movl   $0x18181818,0x9c8(%rdi)
18 18 18
movb   $0x1c,0x9c7(%rdi)
movb   $0xf,0x9c6(%rdi)
movb   $0x7,0x9c5(%rdi)
movl   $0x0,0x9d0(%rdi)
movl   $0x18181818,0x9d8(%rdi)
18 18 18
movb   $0x38,0x9d7(%rdi)
movb   $0xf0,0x9d6(%rdi)
movb   $0xe0,0x9d5(%rdi)
movl   $0x18181818,0x9e0(%rdi)
18 18 18
movl   $0x0,0x9e8(%rdi)
movw   $0xf1c,0x9e4(%rdi)
1c 0f
movb   $0x7,0x9e6(%rdi)
movl   $0x18181818,0x9f0(%rdi)
18 18 18
movl   $0x0,0x9f8(%rdi)
movw   $0xf038,0x9f4(%rdi)
38 f0
movb   $0xe0,0x9f6(%rdi)
movl   $0x0,0xe08(%rdi)
movq   $0x0,0xe00(%rdi)
movw   $0xffff,0xe02(%rdi)
ff ff
movw   $0xffff,0xe08(%rdi)
ff ff
movabs $0x1818181818181818,%rax
18 18 18
mov    %rax,0xe10(%rdi)
movl   $0x18181818,0xe18(%rdi)
18 18 18
movw   $0x1f1f,0xe12(%rdi)
1f 1f
movw   $0x1f1f,0xe18(%rdi)
1f 1f
mov    %rax,0xe20(%rdi)
movl   $0x18181818,0xe28(%rdi)
18 18 18
movw   $0xffff,0xe22(%rdi)
ff ff
movw   $0xffff,0xe28(%rdi)
ff ff
mov    %rax,0xe30(%rdi)
movl   $0x18181818,0xe38(%rdi)
18 18 18
movw   $0xf8f8,0xe32(%rdi)
f8 f8
movw   $0xf8f8,0xe38(%rdi)
f8 f8
lea    0xe70(%rdi),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movzbl %dl,%ecx
imul   $0xab,%ecx,%ecx
shr    $0xb,%ecx
mov    $0x2,%esi
shl    %cl,%esi
add    $0xff,%sil
mov    %sil,-0x30(%rax)
mov    $0x80,%esi
shr    %cl,%esi
mov    $0x100,%ebp
shr    %cl,%ebp
neg    %sil
mov    %sil,-0x20(%rax)
add    $0xff,%bpl
mov    %bpl,-0x10(%rax)
mov    $0xffffffff,%esi
shl    %cl,%esi
mov    %sil,(%rax)
add    $0x8,%rdx
add    $0x1,%rax
cmp    $0x60,%rdx
jne    1880 <calcchr+0x780>
movabs $0x1010080404020101,%rax
08 10 10
mov    %rax,0xee0(%rdi)
movl   $0x80404020,0xee8(%rdi)
40 40 80
orb    $0x80,0xef0(%rdi)
orb    $0x80,0xef1(%rdi)
orb    $0x40,0xef2(%rdi)
orb    $0x20,0xef3(%rdi)
orb    $0x20,0xef4(%rdi)
orb    $0x10,0xef5(%rdi)
orb    $0x8,0xef6(%rdi)
orb    $0x8,0xef7(%rdi)
orb    $0x4,0xef8(%rdi)
orb    $0x2,0xef9(%rdi)
orb    $0x2,0xefa(%rdi)
orb    $0x1,0xefb(%rdi)
lea    0xf00(%rdi),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movzbl %dl,%ecx
imul   $0xab,%ecx,%ecx
shr    $0x9,%ecx
mov    $0x80,%esi
shr    %cl,%esi
bts    %ecx,%esi
mov    %sil,(%rax)
add    $0x2,%rdx
add    $0x1,%rax
cmp    $0x18,%rdx
jne    1950 <calcchr+0x850>
movw   $0xaaaa,0xf15(%rdi)
aa aa
movb   $0xaa,0xf75(%rdi)
movw   $0xffff,0xf35(%rdi)
ff ff
movb   $0xff,0xf45(%rdi)
orb    $0x18,0xf50(%rdi)
orb    $0x18,0xf60(%rdi)
orb    $0x18,0xf20(%rdi)
orb    $0x18,0xf30(%rdi)
orb    $0x18,0xf70(%rdi)
orb    $0x18,0xf51(%rdi)
orb    $0x18,0xf61(%rdi)
orb    $0x18,0xf52(%rdi)
orb    $0x18,0xf62(%rdi)
orb    $0x18,0xf22(%rdi)
orb    $0x18,0xf32(%rdi)
orb    $0x18,0xf72(%rdi)
orb    $0x18,0xf53(%rdi)
orb    $0x18,0xf63(%rdi)
orb    $0x18,0xf54(%rdi)
orb    $0x18,0xf64(%rdi)
orb    $0x18,0xf24(%rdi)
orb    $0x18,0xf34(%rdi)
orb    $0x18,0xf74(%rdi)
movb   $0xb8,0xf55(%rdi)
movb   $0x1a,0xf65(%rdi)
movb   $0xb8,0xf56(%rdi)
movb   $0x1a,0xf66(%rdi)
orb    $0x18,0xf26(%rdi)
movb   $0xff,0xf46(%rdi)
movb   $0xba,0xf76(%rdi)
orb    $0x18,0xf57(%rdi)
orb    $0x18,0xf67(%rdi)
orb    $0x18,0xf58(%rdi)
orb    $0x18,0xf68(%rdi)
orb    $0x18,0xf28(%rdi)
orb    $0x18,0xf48(%rdi)
orb    $0x18,0xf78(%rdi)
orb    $0x18,0xf59(%rdi)
orb    $0x18,0xf69(%rdi)
orb    $0x18,0xf5a(%rdi)
orb    $0x18,0xf6a(%rdi)
orb    $0x18,0xf2a(%rdi)
orb    $0x18,0xf4a(%rdi)
orb    $0x18,0xf7a(%rdi)
orb    $0x18,0xf5b(%rdi)
orb    $0x18,0xf6b(%rdi)
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@__const.calcchr.boxdraw_6001a = [11 x i32] [i32 144, i32 145, i32 146, i32 147, i32 143, i32 150, i32 149, i32 152, i32 153, i32 154, i32 155]
define void @calcchr([16 x i8]* %0, i32 %1, i32 %2) {
%4 = icmp eq i32 %1, 0
%5 = sdiv i32 %2, 2
%6 = sext i32 %5 to i64
%7 = add nsw i32 %5, -1
%8 = sext i32 %7 to i64
%9 = icmp slt i32 %2, -1
%10 = icmp sgt i32 %5, %2
%11 = add nsw i32 %5, 1
%12 = add nsw i64 %6, -1
%13 = zext i32 %11 to i64
%14 = sext i32 %2 to i64
%15 = add nsw i64 %14, 1
%16 = sub nsw i64 %15, %6
%17 = and i64 %13, 4294967264
%18 = add nsw i64 %17, -32
%19 = lshr exact i64 %18, 5
%20 = add nuw nsw i64 %19, 1
%21 = add nsw i64 %16, -32
%22 = lshr i64 %21, 5
%23 = add nuw nsw i64 %22, 1
%24 = icmp ult i32 %11, 8
%25 = icmp ult i32 %11, 32
%26 = and i64 %13, 4294967264
%27 = and i64 %20, 1
%28 = icmp eq i64 %18, 0
%29 = and i64 %20, 1152921504606846974
%30 = icmp eq i64 %27, 0
%31 = icmp eq i64 %26, %13
%32 = and i64 %13, 24
%33 = icmp eq i64 %32, 0
%34 = and i64 %13, 4294967288
%35 = icmp eq i64 %34, %13
%36 = icmp ult i64 %16, 8
%37 = icmp ult i64 %16, 32
%38 = and i64 %16, -32
%39 = and i64 %23, 1
%40 = icmp ult i64 %21, 32
%41 = and i64 %23, 1152921504606846974
%42 = icmp eq i64 %39, 0
%43 = icmp eq i64 %16, %38
%44 = add nsw i64 %12, %38
%45 = and i64 %16, 24
%46 = icmp eq i64 %45, 0
%47 = and i64 %16, -8
%48 = add nsw i64 %12, %47
%49 = icmp eq i64 %16, %47
br label %50
50: ; preds = %3, %230
%51 = phi i64 [ 0, %3 ], [ %231, %230 ]
br i1 %4, label %55, label %52
52: ; preds = %50
%53 = getelementptr inbounds [11 x i32], [11 x i32]* @__const.calcchr.boxdraw_6001a, i64 0, i64 %51
%54 = load i32, i32* %53
br label %58
55: ; preds = %50
%56 = trunc i64 %51 to i32
%57 = add i32 %56, 17
br label %58
58: ; preds = %55, %52
%59 = phi i32 [ %54, %52 ], [ %57, %55 ]
%60 = sext i32 %59 to i64
%61 = getelementptr [16 x i8], [16 x i8]* %0, i64 %60, i64 0
%62 = lshr i64 680, %51
%63 = and i64 %62, 1
%64 = icmp eq i64 %63, 0
%65 = select i1 %64, i8 -16, i8 0
%66 = lshr i64 1316, %51
%67 = and i64 %66, 1
%68 = icmp eq i64 %67, 0
%69 = select i1 %68, i8 15, i8 0
%70 = or i8 %65, %69
%71 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %6
store i8 %70, i8* %71
%72 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %8
store i8 %70, i8* %72
br i1 %9, label %142, label %73
73: ; preds = %58
%74 = lshr i64 450, %51
%75 = and i64 %74, 1
%76 = icmp eq i64 %75, 0
%77 = select i1 %76, i8 24, i8 0
br i1 %24, label %140, label %78
78: ; preds = %73
br i1 %25, label %126, label %79
79: ; preds = %78
%80 = insertelement <16 x i8> poison, i8 %77, i64 0
%81 = shufflevector <16 x i8> %80, <16 x i8> poison, <16 x i32> zeroinitializer
%82 = insertelement <16 x i8> poison, i8 %77, i64 0
%83 = shufflevector <16 x i8> %82, <16 x i8> poison, <16 x i32> zeroinitializer
br i1 %28, label %111, label %84
84: ; preds = %79, %84
%85 = phi i64 [ %108, %84 ], [ 0, %79 ]
%86 = phi i64 [ %109, %84 ], [ 0, %79 ]
%87 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %85
%88 = bitcast i8* %87 to <16 x i8>*
%89 = load <16 x i8>, <16 x i8>* %88
%90 = getelementptr inbounds i8, i8* %87, i64 16
%91 = bitcast i8* %90 to <16 x i8>*
%92 = load <16 x i8>, <16 x i8>* %91
%93 = or <16 x i8> %89, %81
%94 = or <16 x i8> %92, %83
%95 = bitcast i8* %87 to <16 x i8>*
store <16 x i8> %93, <16 x i8>* %95
%96 = bitcast i8* %90 to <16 x i8>*
store <16 x i8> %94, <16 x i8>* %96
%97 = or i64 %85, 32
%98 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %97
%99 = bitcast i8* %98 to <16 x i8>*
%100 = load <16 x i8>, <16 x i8>* %99
%101 = getelementptr inbounds i8, i8* %98, i64 16
%102 = bitcast i8* %101 to <16 x i8>*
%103 = load <16 x i8>, <16 x i8>* %102
%104 = or <16 x i8> %100, %81
%105 = or <16 x i8> %103, %83
%106 = bitcast i8* %98 to <16 x i8>*
store <16 x i8> %104, <16 x i8>* %106
%107 = bitcast i8* %101 to <16 x i8>*
store <16 x i8> %105, <16 x i8>* %107
%108 = add nuw i64 %85, 64
%109 = add i64 %86, 2
%110 = icmp eq i64 %109, %29
br i1 %110, label %111, label %84
111: ; preds = %84, %79
%112 = phi i64 [ 0, %79 ], [ %108, %84 ]
br i1 %30, label %124, label %113
113: ; preds = %111
%114 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %112
%115 = bitcast i8* %114 to <16 x i8>*
%116 = load <16 x i8>, <16 x i8>* %115
%117 = getelementptr inbounds i8, i8* %114, i64 16
%118 = bitcast i8* %117 to <16 x i8>*
%119 = load <16 x i8>, <16 x i8>* %118
%120 = or <16 x i8> %116, %81
%121 = or <16 x i8> %119, %83
%122 = bitcast i8* %114 to <16 x i8>*
store <16 x i8> %120, <16 x i8>* %122
%123 = bitcast i8* %117 to <16 x i8>*
store <16 x i8> %121, <16 x i8>* %123
br label %124
124: ; preds = %111, %113
br i1 %31, label %142, label %125
125: ; preds = %124
br i1 %33, label %140, label %126
126: ; preds = %78, %125
%127 = phi i64 [ %26, %125 ], [ 0, %78 ]
%128 = insertelement <8 x i8> poison, i8 %77, i64 0
%129 = shufflevector <8 x i8> %128, <8 x i8> poison, <8 x i32> zeroinitializer
br label %130
130: ; preds = %130, %126
%131 = phi i64 [ %127, %126 ], [ %137, %130 ]
%132 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %131
%133 = bitcast i8* %132 to <8 x i8>*
%134 = load <8 x i8>, <8 x i8>* %133
%135 = or <8 x i8> %134, %129
%136 = bitcast i8* %132 to <8 x i8>*
store <8 x i8> %135, <8 x i8>* %136
%137 = add nuw i64 %131, 8
%138 = icmp eq i64 %137, %34
br i1 %138, label %139, label %130
139: ; preds = %130
br i1 %35, label %142, label %140
140: ; preds = %73, %125, %139
%141 = phi i64 [ 0, %73 ], [ %26, %125 ], [ %34, %139 ]
br label %216
142: ; preds = %216, %124, %139, %58
br i1 %10, label %230, label %143
143: ; preds = %142
%144 = lshr i64 1601, %51
%145 = and i64 %144, 1
%146 = icmp eq i64 %145, 0
%147 = select i1 %146, i8 24, i8 0
br i1 %36, label %214, label %148
148: ; preds = %143
br i1 %37, label %199, label %149
149: ; preds = %148
%150 = insertelement <16 x i8> poison, i8 %147, i64 0
%151 = shufflevector <16 x i8> %150, <16 x i8> poison, <16 x i32> zeroinitializer
%152 = insertelement <16 x i8> poison, i8 %147, i64 0
%153 = shufflevector <16 x i8> %152, <16 x i8> poison, <16 x i32> zeroinitializer
br i1 %40, label %183, label %154
154: ; preds = %149, %154
%155 = phi i64 [ %180, %154 ], [ 0, %149 ]
%156 = phi i64 [ %181, %154 ], [ 0, %149 ]
%157 = add i64 %12, %155
%158 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %157
%159 = bitcast i8* %158 to <16 x i8>*
%160 = load <16 x i8>, <16 x i8>* %159
%161 = getelementptr inbounds i8, i8* %158, i64 16
%162 = bitcast i8* %161 to <16 x i8>*
%163 = load <16 x i8>, <16 x i8>* %162
%164 = or <16 x i8> %160, %151
%165 = or <16 x i8> %163, %153
%166 = bitcast i8* %158 to <16 x i8>*
store <16 x i8> %164, <16 x i8>* %166
%167 = bitcast i8* %161 to <16 x i8>*
store <16 x i8> %165, <16 x i8>* %167
%168 = or i64 %155, 32
%169 = add i64 %12, %168
%170 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %169
%171 = bitcast i8* %170 to <16 x i8>*
%172 = load <16 x i8>, <16 x i8>* %171
%173 = getelementptr inbounds i8, i8* %170, i64 16
%174 = bitcast i8* %173 to <16 x i8>*
%175 = load <16 x i8>, <16 x i8>* %174
%176 = or <16 x i8> %172, %151
%177 = or <16 x i8> %175, %153
%178 = bitcast i8* %170 to <16 x i8>*
store <16 x i8> %176, <16 x i8>* %178
%179 = bitcast i8* %173 to <16 x i8>*
store <16 x i8> %177, <16 x i8>* %179
%180 = add nuw i64 %155, 64
%181 = add i64 %156, 2
%182 = icmp eq i64 %181, %41
br i1 %182, label %183, label %154
183: ; preds = %154, %149
%184 = phi i64 [ 0, %149 ], [ %180, %154 ]
br i1 %42, label %197, label %185
185: ; preds = %183
%186 = add i64 %12, %184
%187 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %186
%188 = bitcast i8* %187 to <16 x i8>*
%189 = load <16 x i8>, <16 x i8>* %188
%190 = getelementptr inbounds i8, i8* %187, i64 16
%191 = bitcast i8* %190 to <16 x i8>*
%192 = load <16 x i8>, <16 x i8>* %191
%193 = or <16 x i8> %189, %151
%194 = or <16 x i8> %192, %153
%195 = bitcast i8* %187 to <16 x i8>*
store <16 x i8> %193, <16 x i8>* %195
%196 = bitcast i8* %190 to <16 x i8>*
store <16 x i8> %194, <16 x i8>* %196
br label %197
197: ; preds = %183, %185
br i1 %43, label %230, label %198
198: ; preds = %197
br i1 %46, label %214, label %199
199: ; preds = %148, %198
%200 = phi i64 [ %38, %198 ], [ 0, %148 ]
%201 = insertelement <8 x i8> poison, i8 %147, i64 0
%202 = shufflevector <8 x i8> %201, <8 x i8> poison, <8 x i32> zeroinitializer
br label %203
203: ; preds = %203, %199
%204 = phi i64 [ %200, %199 ], [ %211, %203 ]
%205 = add i64 %12, %204
%206 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %205
%207 = bitcast i8* %206 to <8 x i8>*
%208 = load <8 x i8>, <8 x i8>* %207
%209 = or <8 x i8> %208, %202
%210 = bitcast i8* %206 to <8 x i8>*
store <8 x i8> %209, <8 x i8>* %210
%211 = add nuw i64 %204, 8
%212 = icmp eq i64 %211, %47
br i1 %212, label %213, label %203
213: ; preds = %203
br i1 %49, label %230, label %214
214: ; preds = %143, %198, %213
%215 = phi i64 [ %12, %143 ], [ %44, %198 ], [ %48, %213 ]
br label %223
216: ; preds = %140, %216
%217 = phi i64 [ %221, %216 ], [ %141, %140 ]
%218 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %217
%219 = load i8, i8* %218
%220 = or i8 %219, %77
store i8 %220, i8* %218
%221 = add nuw nsw i64 %217, 1
%222 = icmp eq i64 %221, %13
br i1 %222, label %142, label %216
223: ; preds = %214, %223
%224 = phi i64 [ %228, %223 ], [ %215, %214 ]
%225 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 %60, i64 %224
%226 = load i8, i8* %225
%227 = or i8 %226, %147
store i8 %227, i8* %225
%228 = add nsw i64 %224, 1
%229 = icmp eq i64 %228, %14
br i1 %229, label %230, label %223
230: ; preds = %223, %197, %213, %142
%231 = add nuw nsw i64 %51, 1
%232 = icmp eq i64 %231, 11
br i1 %232, label %233, label %50
233: ; preds = %230
br i1 %4, label %549, label %234
234: ; preds = %233
%235 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 4, i64 3
store i8 96, i8* %235
%236 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 4, i64 0
store i8 96, i8* %236
%237 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 4, i64 2
store i8 -112, i8* %237
%238 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 4, i64 1
store i8 -112, i8* %238
%239 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 3, i64 0
store i8 24, i8* %239
%240 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 10, i64 0
store i8 6, i8* %240
%241 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 5, i64 4
store i8 96, i8* %241
%242 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 9, i64 4
store i8 6, i8* %242
%243 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 6, i64 8
store i8 96, i8* %243
%244 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 7, i64 8
store i8 24, i8* %244
%245 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 8, i64 8
store i8 6, i8* %245
%246 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 3, i64 1
store i8 36, i8* %246
%247 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 10, i64 1
store i8 9, i8* %247
%248 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 5, i64 5
store i8 -112, i8* %248
%249 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 9, i64 5
store i8 9, i8* %249
%250 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 6, i64 9
store i8 -112, i8* %250
%251 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 7, i64 9
store i8 36, i8* %251
%252 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 8, i64 9
store i8 9, i8* %252
%253 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 3, i64 2
store i8 36, i8* %253
%254 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 10, i64 2
store i8 9, i8* %254
%255 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 5, i64 6
store i8 -112, i8* %255
%256 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 9, i64 6
store i8 9, i8* %256
%257 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 6, i64 10
store i8 -112, i8* %257
%258 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 7, i64 10
store i8 36, i8* %258
%259 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 8, i64 10
store i8 9, i8* %259
%260 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 3, i64 3
store i8 24, i8* %260
%261 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 10, i64 3
store i8 6, i8* %261
%262 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 5, i64 7
store i8 96, i8* %262
%263 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 9, i64 7
store i8 6, i8* %263
%264 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 6, i64 11
store i8 96, i8* %264
%265 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 7, i64 11
store i8 24, i8* %265
%266 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 8, i64 11
store i8 6, i8* %266
%267 = getelementptr [16 x i8], [16 x i8]* %0, i64 128, i64 11
store i8 -1, i8* %267
%268 = getelementptr [16 x i8], [16 x i8]* %0, i64 129, i64 10
%269 = bitcast i8* %268 to i16*
store i16 -1, i16* %269
%270 = getelementptr [16 x i8], [16 x i8]* %0, i64 130, i64 9
%271 = getelementptr [16 x i8], [16 x i8]* %0, i64 131, i64 8
%272 = bitcast i8* %271 to i32*
store i32 -1, i32* %272
%273 = getelementptr [16 x i8], [16 x i8]* %0, i64 132, i64 6
%274 = getelementptr [16 x i8], [16 x i8]* %0, i64 133, i64 4
%275 = bitcast i8* %274 to i64*
store i64 -1, i64* %275
%276 = getelementptr [16 x i8], [16 x i8]* %0, i64 134, i64 2
%277 = getelementptr [16 x i8], [16 x i8]* %0, i64 135, i64 0
%278 = getelementptr [16 x i8], [16 x i8]* %0, i64 136, i64 0
%279 = getelementptr [16 x i8], [16 x i8]* %0, i64 137, i64 0
%280 = getelementptr [16 x i8], [16 x i8]* %0, i64 138, i64 0
%281 = getelementptr [16 x i8], [16 x i8]* %0, i64 139, i64 0
%282 = getelementptr [16 x i8], [16 x i8]* %0, i64 140, i64 0
%283 = getelementptr [16 x i8], [16 x i8]* %0, i64 141, i64 0
%284 = getelementptr [16 x i8], [16 x i8]* %0, i64 142, i64 0
%285 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 148, i64 1
store i8 -1, i8* %285
%286 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 148, i64 0
store i8 -1, i8* %286
%287 = getelementptr [16 x i8], [16 x i8]* %0, i64 151, i64 0
%288 = getelementptr [16 x i8], [16 x i8]* %0, i64 156, i64 8
%289 = getelementptr [16 x i8], [16 x i8]* %0, i64 156, i64 0
%290 = bitcast i8* %289 to i32*
store i32 0, i32* %290
%291 = bitcast i8* %288 to i32*
store i32 404232216, i32* %291
%292 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 156, i64 7
store i8 28, i8* %292
%293 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 156, i64 6
store i8 15, i8* %293
%294 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 156, i64 5
store i8 7, i8* %294
%295 = getelementptr [16 x i8], [16 x i8]* %0, i64 157, i64 8
%296 = getelementptr [16 x i8], [16 x i8]* %0, i64 157, i64 0
%297 = bitcast i8* %296 to i32*
store i32 0, i32* %297
%298 = bitcast i8* %295 to i32*
store i32 404232216, i32* %298
%299 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 157, i64 7
store i8 56, i8* %299
%300 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 157, i64 6
store i8 -16, i8* %300
%301 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 157, i64 5
store i8 -32, i8* %301
%302 = getelementptr [16 x i8], [16 x i8]* %0, i64 158, i64 8
%303 = getelementptr [16 x i8], [16 x i8]* %0, i64 158, i64 0
%304 = bitcast i8* %303 to i32*
store i32 404232216, i32* %304
%305 = bitcast i8* %302 to i32*
store i32 0, i32* %305
%306 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 158, i64 4
store i8 28, i8* %306
%307 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 158, i64 5
store i8 15, i8* %307
%308 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 158, i64 6
store i8 7, i8* %308
%309 = getelementptr [16 x i8], [16 x i8]* %0, i64 159, i64 8
%310 = getelementptr [16 x i8], [16 x i8]* %0, i64 159, i64 0
%311 = bitcast i8* %310 to i32*
store i32 404232216, i32* %311
%312 = bitcast i8* %309 to i32*
store i32 0, i32* %312
%313 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 159, i64 4
store i8 56, i8* %313
%314 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 159, i64 5
store i8 -16, i8* %314
%315 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 159, i64 6
store i8 -32, i8* %315
%316 = getelementptr [16 x i8], [16 x i8]* %0, i64 224, i64 0
%317 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 224, i64 2
store i8 -1, i8* %317
%318 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 224, i64 3
store i8 -1, i8* %318
%319 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 224, i64 8
store i8 -1, i8* %319
%320 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 224, i64 9
store i8 -1, i8* %320
%321 = getelementptr [16 x i8], [16 x i8]* %0, i64 225, i64 0
%322 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 225, i64 2
store i8 31, i8* %322
%323 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 225, i64 3
store i8 31, i8* %323
%324 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 225, i64 8
store i8 31, i8* %324
%325 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 225, i64 9
store i8 31, i8* %325
%326 = getelementptr [16 x i8], [16 x i8]* %0, i64 226, i64 0
%327 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 226, i64 2
store i8 -1, i8* %327
%328 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 226, i64 3
store i8 -1, i8* %328
%329 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 226, i64 8
store i8 -1, i8* %329
%330 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 226, i64 9
store i8 -1, i8* %330
%331 = getelementptr [16 x i8], [16 x i8]* %0, i64 227, i64 0
%332 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 227, i64 2
store i8 -8, i8* %332
%333 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 227, i64 3
store i8 -8, i8* %333
%334 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 227, i64 8
store i8 -8, i8* %334
%335 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 227, i64 9
store i8 -8, i8* %335
br label %336
336: ; preds = %234, %336
%337 = phi i64 [ 0, %234 ], [ %357, %336 ]
%338 = trunc i64 %337 to i8
%339 = shl i8 %338, 3
%340 = udiv i8 %339, 12
%341 = zext i8 %340 to i32
%342 = shl nuw nsw i32 2, %341
%343 = trunc i32 %342 to i8
%344 = add i8 %343, -1
%345 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 228, i64 %337
store i8 %344, i8* %345
%346 = lshr i32 128, %341
%347 = trunc i32 %346 to i8
%348 = sub i8 0, %347
%349 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 229, i64 %337
store i8 %348, i8* %349
%350 = lshr i32 256, %341
%351 = trunc i32 %350 to i8
%352 = add i8 %351, -1
%353 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 230, i64 %337
store i8 %352, i8* %353
%354 = shl nsw i32 -1, %341
%355 = trunc i32 %354 to i8
%356 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 231, i64 %337
store i8 %355, i8* %356
%357 = add nuw nsw i64 %337, 1
%358 = icmp eq i64 %357, 12
br i1 %358, label %359, label %336
359: ; preds = %336
%360 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 0
store i8 1, i8* %360
%361 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 1
store i8 1, i8* %361
%362 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 2
store i8 2, i8* %362
%363 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 3
store i8 4, i8* %363
%364 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 4
store i8 4, i8* %364
%365 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 5
store i8 8, i8* %365
%366 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 6
store i8 16, i8* %366
%367 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 7
store i8 16, i8* %367
%368 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 8
store i8 32, i8* %368
%369 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 9
store i8 64, i8* %369
%370 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 10
store i8 64, i8* %370
%371 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 238, i64 11
store i8 -128, i8* %371
%372 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 0
%373 = load i8, i8* %372
%374 = or i8 %373, -128
store i8 %374, i8* %372
%375 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 1
%376 = load i8, i8* %375
%377 = or i8 %376, -128
store i8 %377, i8* %375
%378 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 2
%379 = load i8, i8* %378
%380 = or i8 %379, 64
store i8 %380, i8* %378
%381 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 3
%382 = load i8, i8* %381
%383 = or i8 %382, 32
store i8 %383, i8* %381
%384 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 4
%385 = load i8, i8* %384
%386 = or i8 %385, 32
store i8 %386, i8* %384
%387 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 5
%388 = load i8, i8* %387
%389 = or i8 %388, 16
store i8 %389, i8* %387
%390 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 6
%391 = load i8, i8* %390
%392 = or i8 %391, 8
store i8 %392, i8* %390
%393 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 7
%394 = load i8, i8* %393
%395 = or i8 %394, 8
store i8 %395, i8* %393
%396 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 8
%397 = load i8, i8* %396
%398 = or i8 %397, 4
store i8 %398, i8* %396
%399 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 9
%400 = load i8, i8* %399
%401 = or i8 %400, 2
store i8 %401, i8* %399
%402 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 10
%403 = load i8, i8* %402
%404 = or i8 %403, 2
store i8 %404, i8* %402
%405 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 239, i64 11
%406 = load i8, i8* %405
%407 = or i8 %406, 1
store i8 %407, i8* %405
br label %408
408: ; preds = %359, %408
%409 = phi i64 [ %426, %408 ], [ 0, %359 ]
%410 = trunc i64 %409 to i8
%411 = shl i8 %410, 1
%412 = udiv i8 %411, 3
%413 = zext i8 %412 to i32
%414 = shl nuw nsw i32 1, %413
%415 = trunc i32 %414 to i8
%416 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 240, i64 %409
store i8 %415, i8* %416
%417 = trunc i64 %409 to i8
%418 = shl i8 %417, 1
%419 = udiv i8 %418, 3
%420 = zext i8 %419 to i32
%421 = lshr i32 128, %420
%422 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 240, i64 %409
%423 = load i8, i8* %422
%424 = trunc i32 %421 to i8
%425 = or i8 %423, %424
store i8 %425, i8* %422
%426 = add nuw nsw i64 %409, 1
%427 = icmp eq i64 %426, 12
br i1 %427, label %428, label %408
428: ; preds = %408
%429 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 241, i64 6
store i8 -86, i8* %429
%430 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 241, i64 5
store i8 -86, i8* %430
%431 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 247, i64 6
%432 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 247, i64 5
store i8 -86, i8* %432
%433 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 243, i64 6
store i8 -1, i8* %433
%434 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 243, i64 5
store i8 -1, i8* %434
%435 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 244, i64 6
%436 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 244, i64 5
store i8 -1, i8* %436
%437 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 6
%438 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 5
%439 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 6
%440 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 5
%441 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 0
%442 = load i8, i8* %441
%443 = or i8 %442, 24
store i8 %443, i8* %441
%444 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 0
%445 = load i8, i8* %444
%446 = or i8 %445, 24
store i8 %446, i8* %444
%447 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 242, i64 0
%448 = load i8, i8* %447
%449 = or i8 %448, 24
store i8 %449, i8* %447
%450 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 243, i64 0
%451 = load i8, i8* %450
%452 = or i8 %451, 24
store i8 %452, i8* %450
%453 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 247, i64 0
%454 = load i8, i8* %453
%455 = or i8 %454, 24
store i8 %455, i8* %453
%456 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 1
%457 = load i8, i8* %456
%458 = or i8 %457, 24
store i8 %458, i8* %456
%459 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 1
%460 = load i8, i8* %459
%461 = or i8 %460, 24
store i8 %461, i8* %459
%462 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 2
%463 = load i8, i8* %462
%464 = or i8 %463, 24
store i8 %464, i8* %462
%465 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 2
%466 = load i8, i8* %465
%467 = or i8 %466, 24
store i8 %467, i8* %465
%468 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 242, i64 2
%469 = load i8, i8* %468
%470 = or i8 %469, 24
store i8 %470, i8* %468
%471 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 243, i64 2
%472 = load i8, i8* %471
%473 = or i8 %472, 24
store i8 %473, i8* %471
%474 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 247, i64 2
%475 = load i8, i8* %474
%476 = or i8 %475, 24
store i8 %476, i8* %474
%477 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 3
%478 = load i8, i8* %477
%479 = or i8 %478, 24
store i8 %479, i8* %477
%480 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 3
%481 = load i8, i8* %480
%482 = or i8 %481, 24
store i8 %482, i8* %480
%483 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 4
%484 = load i8, i8* %483
%485 = or i8 %484, 24
store i8 %485, i8* %483
%486 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 4
%487 = load i8, i8* %486
%488 = or i8 %487, 24
store i8 %488, i8* %486
%489 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 242, i64 4
%490 = load i8, i8* %489
%491 = or i8 %490, 24
store i8 %491, i8* %489
%492 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 243, i64 4
%493 = load i8, i8* %492
%494 = or i8 %493, 24
store i8 %494, i8* %492
%495 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 247, i64 4
%496 = load i8, i8* %495
%497 = or i8 %496, 24
store i8 %497, i8* %495
store i8 -72, i8* %438
store i8 26, i8* %440
store i8 -72, i8* %437
store i8 26, i8* %439
%498 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 242, i64 6
%499 = load i8, i8* %498
%500 = or i8 %499, 24
store i8 %500, i8* %498
store i8 -1, i8* %435
store i8 -70, i8* %431
%501 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 7
%502 = load i8, i8* %501
%503 = or i8 %502, 24
store i8 %503, i8* %501
%504 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 7
%505 = load i8, i8* %504
%506 = or i8 %505, 24
store i8 %506, i8* %504
%507 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 8
%508 = load i8, i8* %507
%509 = or i8 %508, 24
store i8 %509, i8* %507
%510 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 8
%511 = load i8, i8* %510
%512 = or i8 %511, 24
store i8 %512, i8* %510
%513 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 242, i64 8
%514 = load i8, i8* %513
%515 = or i8 %514, 24
store i8 %515, i8* %513
%516 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 244, i64 8
%517 = load i8, i8* %516
%518 = or i8 %517, 24
store i8 %518, i8* %516
%519 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 247, i64 8
%520 = load i8, i8* %519
%521 = or i8 %520, 24
store i8 %521, i8* %519
%522 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 9
%523 = load i8, i8* %522
%524 = or i8 %523, 24
store i8 %524, i8* %522
%525 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 9
%526 = load i8, i8* %525
%527 = or i8 %526, 24
store i8 %527, i8* %525
%528 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 10
%529 = load i8, i8* %528
%530 = or i8 %529, 24
store i8 %530, i8* %528
%531 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 10
%532 = load i8, i8* %531
%533 = or i8 %532, 24
store i8 %533, i8* %531
%534 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 242, i64 10
%535 = load i8, i8* %534
%536 = or i8 %535, 24
store i8 %536, i8* %534
%537 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 244, i64 10
%538 = load i8, i8* %537
%539 = or i8 %538, 24
store i8 %539, i8* %537
%540 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 247, i64 10
%541 = load i8, i8* %540
%542 = or i8 %541, 24
store i8 %542, i8* %540
%543 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 245, i64 11
%544 = load i8, i8* %543
%545 = or i8 %544, 24
store i8 %545, i8* %543
%546 = getelementptr inbounds [16 x i8], [16 x i8]* %0, i64 246, i64 11
%547 = load i8, i8* %546
%548 = or i8 %547, 24
store i8 %548, i8* %546
br label %549
549: ; preds = %428, %233
ret void
}