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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
unsigned char *alloca(int);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, int);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, int);
void OutlineCharacter(unsigned char *bitmap, int width, int height) {
  int x;
  int y;
  unsigned char *outline;
  outline = alloca(((width + 7) / 8) * height);
  memset(outline, 0, ((width + 7) / 8) * height);
  for (y = 0; y < height; ++y) {
    for (x = 0; x < width; ++x) {
      if (~bitmap[y * ((width + 7) / 8) + x / 8] & (0x80 >> x % 8)) {
        if (y &&
            bitmap[(y - 1) * ((width + 7) / 8) + x / 8] & (0x80 >> x % 8)) {
          outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
        } else if (x && bitmap[y * ((width + 7) / 8) + (x - 1) / 8] &
                            (0x80 >> (x - 1) % 8)) {
          outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
        } else if (x < width - 1 &&
                   bitmap[y * ((width + 7) / 8) + (x + 1) / 8] &
                       (0x80 >> (x + 1) % 8)) {
          outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
        } else if (y < height - 1 &&
                   bitmap[(y + 1) * ((width + 7) / 8) + x / 8] &
                       (0x80 >> x % 8)) {
          outline[y * ((width + 7) / 8) + x / 8] |= (0x80 >> x % 8);
        }
      }
    }
  }
  memcpy(bitmap, outline, ((width + 7) / 8) * height);
}


x86 assembly (clang, -O0):
<OutlineCharacter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
imul   -0x10(%rbp),%edi
call   1040 <alloca@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
imul   -0x10(%rbp),%edx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1554 <OutlineCharacter+0x424>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1541 <OutlineCharacter+0x411>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%esi
cltd
idiv   %esi
imul   %eax,%ecx
mov    -0x14(%rbp),%eax
mov    $0x8,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x30(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x24(%rbp),%eax
mov    %edx,%ecx
mov    $0x80,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     152e <OutlineCharacter+0x3fe>
cmpl   $0x0,-0x18(%rbp)
je     12c5 <OutlineCharacter+0x195>
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%esi
cltd
idiv   %esi
imul   %eax,%ecx
mov    -0x14(%rbp),%eax
mov    $0x8,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x40(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x34(%rbp),%eax
mov    %edx,%ecx
mov    $0x80,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     12c5 <OutlineCharacter+0x195>
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
mov    $0x80,%esi
sar    %cl,%esi
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%edi
cltd
idiv   %edi
imul   %eax,%ecx
mov    -0x14(%rbp),%eax
mov    $0x8,%edi
cltd
idiv   %edi
mov    %eax,%edx
mov    -0x48(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    1529 <OutlineCharacter+0x3f9>
cmpl   $0x0,-0x14(%rbp)
je     1386 <OutlineCharacter+0x256>
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%esi
cltd
idiv   %esi
imul   %eax,%ecx
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    $0x8,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x58(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x4c(%rbp),%eax
mov    %edx,%ecx
mov    $0x80,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1386 <OutlineCharacter+0x256>
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
mov    $0x80,%esi
sar    %cl,%esi
mov    -0x20(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%edi
cltd
idiv   %edi
imul   %eax,%ecx
mov    -0x14(%rbp),%eax
mov    $0x8,%edi
cltd
idiv   %edi
mov    %eax,%edx
mov    -0x60(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    1524 <OutlineCharacter+0x3f4>
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    144e <OutlineCharacter+0x31e>
mov    -0x8(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%esi
cltd
idiv   %esi
imul   %eax,%ecx
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    $0x8,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x70(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x64(%rbp),%eax
mov    %edx,%ecx
mov    $0x80,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     144e <OutlineCharacter+0x31e>
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
mov    $0x80,%esi
sar    %cl,%esi
mov    -0x20(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%edi
cltd
idiv   %edi
imul   %eax,%ecx
mov    -0x14(%rbp),%eax
mov    $0x8,%edi
cltd
idiv   %edi
mov    %eax,%edx
mov    -0x78(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    151f <OutlineCharacter+0x3ef>
mov    -0x18(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    151a <OutlineCharacter+0x3ea>
mov    -0x8(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%esi
cltd
idiv   %esi
imul   %eax,%ecx
mov    -0x14(%rbp),%eax
mov    $0x8,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x88(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x7c(%rbp),%eax
mov    %edx,%ecx
mov    $0x80,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     151a <OutlineCharacter+0x3ea>
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,%ecx
mov    $0x80,%esi
sar    %cl,%esi
mov    -0x20(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%edi
cltd
idiv   %edi
imul   %eax,%ecx
mov    -0x14(%rbp),%eax
mov    $0x8,%edi
cltd
idiv   %edi
mov    %eax,%edx
mov    -0x90(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
jmp    151f <OutlineCharacter+0x3ef>
jmp    1524 <OutlineCharacter+0x3f4>
jmp    1529 <OutlineCharacter+0x3f9>
jmp    152e <OutlineCharacter+0x3fe>
jmp    1533 <OutlineCharacter+0x403>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    119b <OutlineCharacter+0x6b>
jmp    1546 <OutlineCharacter+0x416>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1188 <OutlineCharacter+0x58>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0xc(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
imul   -0x10(%rbp),%edx
call   1050 <memcpy@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<OutlineCharacter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %edx,%r13d
mov    %esi,%r14d
mov    %rdi,%rbx
lea    0x7(%r14),%eax
lea    0xe(%r14),%r15d
test   %eax,%eax
cmovns %eax,%r15d
sar    $0x3,%r15d
mov    %r15d,%ebp
imul   %edx,%ebp
mov    %ebp,%edi
call   1040 <alloca@plt>
mov    %rax,%r12
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebp,0x8(%rsp)
mov    %ebp,%edx
call   1030 <memset@plt>
test   %r13d,%r13d
jle    12ea <OutlineCharacter+0x1ba>
lea    -0x1(%r14),%eax
mov    %eax,0xc(%rsp)
lea    -0x1(%r13),%eax
mov    %rax,0x10(%rsp)
movslq %r15d,%rax
mov    %rax,0x20(%rsp)
mov    %r13d,%ecx
xor    %edx,%edx
mov    %rcx,0x18(%rsp)
jmp    11c1 <OutlineCharacter+0x91>
nopw   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rcx
mov    %r13,%rdx
cmp    %rcx,%r13
je     12ea <OutlineCharacter+0x1ba>
test   %r14d,%r14d
jle    1210 <OutlineCharacter+0xe0>
mov    %rdx,%rdi
mov    0x20(%rsp),%rax
imul   %rax,%rdi
lea    -0x1(%rdx),%rsi
imul   %rax,%rsi
lea    0x1(%rdx),%r13
mov    %r13,%r11
imul   %rax,%r11
movzbl (%rbx,%rdi,1),%eax
test   $0x80,%al
jne    1230 <OutlineCharacter+0x100>
test   %rdx,%rdx
je     11f8 <OutlineCharacter+0xc8>
cmpb   $0x0,(%rbx,%rsi,1)
js     1227 <OutlineCharacter+0xf7>
cmp    $0x2,%r14d
jb     1219 <OutlineCharacter+0xe9>
and    $0x40,%eax
je     1219 <OutlineCharacter+0xe9>
orb    $0x80,(%r12,%rdi,1)
jmp    123a <OutlineCharacter+0x10a>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    %rdx,%r13
jmp    11b5 <OutlineCharacter+0x85>
cmp    0x10(%rsp),%rdx
jge    1230 <OutlineCharacter+0x100>
cmpb   $0x0,(%rbx,%r11,1)
jns    1230 <OutlineCharacter+0x100>
orb    $0x80,(%r12,%rdi,1)
nopl   0x0(%rax)
cmp    $0x1,%r14d
je     11b5 <OutlineCharacter+0x85>
mov    $0x1,%eax
jmp    127a <OutlineCharacter+0x14a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rax),%ecx
mov    %ecx,%ebp
shr    $0x3,%ebp
add    %rdi,%rbp
movzbl (%rbx,%rbp,1),%ebp
and    $0x7,%cl
shl    %cl,%ebp
test   $0x80,%bpl
je     12b4 <OutlineCharacter+0x184>
or     %r9b,(%r12,%r15,1)
add    $0x1,%eax
cmp    %eax,%r14d
je     11b0 <OutlineCharacter+0x80>
mov    %eax,%r8d
shr    $0x3,%r8d
lea    (%rdi,%r8,1),%r15
movzbl (%rbx,%r15,1),%r10d
not    %r10d
mov    %eax,%ecx
and    $0x7,%cl
mov    $0x80,%r9d
shr    %cl,%r9d
test   %r10d,%r9d
je     126e <OutlineCharacter+0x13e>
test   %rdx,%rdx
je     1250 <OutlineCharacter+0x120>
lea    (%rsi,%r8,1),%rcx
movzbl (%rbx,%rcx,1),%ecx
test   %ecx,%r9d
jne    126a <OutlineCharacter+0x13a>
jmp    1250 <OutlineCharacter+0x120>
cmp    0xc(%rsp),%eax
jge    12d4 <OutlineCharacter+0x1a4>
lea    0x1(%rax),%ecx
mov    %ecx,%ebp
shr    $0x3,%ebp
add    %rdi,%rbp
movzbl (%rbx,%rbp,1),%ebp
and    $0x7,%cl
shl    %cl,%ebp
test   $0x80,%bpl
jne    126a <OutlineCharacter+0x13a>
cmp    0x10(%rsp),%rdx
jge    126e <OutlineCharacter+0x13e>
add    %r11,%r8
movzbl (%rbx,%r8,1),%ecx
test   %ecx,%r9d
jne    126a <OutlineCharacter+0x13a>
jmp    126e <OutlineCharacter+0x13e>
mov    %rbx,%rdi
mov    %r12,%rsi
mov    0x8(%rsp),%edx
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <memcpy@plt>

LLVM IR (-O0):
define void @OutlineCharacter(i8* %0, i32 %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%10 = load i32, i32* %5
%11 = add nsw i32 %10, 7
%12 = sdiv i32 %11, 8
%13 = load i32, i32* %6
%14 = mul nsw i32 %12, %13
%15 = call i8* @alloca(i32 %14)
store i8* %15, i8** %9
%16 = load i8*, i8** %9
%17 = load i32, i32* %5
%18 = add nsw i32 %17, 7
%19 = sdiv i32 %18, 8
%20 = load i32, i32* %6
%21 = mul nsw i32 %19, %20
%22 = call i32 @memset(i8* %16, i32 0, i32 %21)
store i32 0, i32* %8
br label %23
23: ; preds = %235, %3
%24 = load i32, i32* %8
%25 = load i32, i32* %6
%26 = icmp slt i32 %24, %25
br i1 %26, label %27, label %238
27: ; preds = %23
store i32 0, i32* %7
br label %28
28: ; preds = %231, %27
%29 = load i32, i32* %7
%30 = load i32, i32* %5
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %234
32: ; preds = %28
%33 = load i8*, i8** %4
%34 = load i32, i32* %8
%35 = load i32, i32* %5
%36 = add nsw i32 %35, 7
%37 = sdiv i32 %36, 8
%38 = mul nsw i32 %34, %37
%39 = load i32, i32* %7
%40 = sdiv i32 %39, 8
%41 = add nsw i32 %38, %40
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %33, i64 %42
%44 = load i8, i8* %43
%45 = zext i8 %44 to i32
%46 = xor i32 %45, -1
%47 = load i32, i32* %7
%48 = srem i32 %47, 8
%49 = ashr i32 128, %48
%50 = and i32 %46, %49
%51 = icmp ne i32 %50, 0
br i1 %51, label %52, label %230
52: ; preds = %32
%53 = load i32, i32* %8
%54 = icmp ne i32 %53, 0
br i1 %54, label %55, label %94
55: ; preds = %52
%56 = load i8*, i8** %4
%57 = load i32, i32* %8
%58 = sub nsw i32 %57, 1
%59 = load i32, i32* %5
%60 = add nsw i32 %59, 7
%61 = sdiv i32 %60, 8
%62 = mul nsw i32 %58, %61
%63 = load i32, i32* %7
%64 = sdiv i32 %63, 8
%65 = add nsw i32 %62, %64
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i8, i8* %56, i64 %66
%68 = load i8, i8* %67
%69 = zext i8 %68 to i32
%70 = load i32, i32* %7
%71 = srem i32 %70, 8
%72 = ashr i32 128, %71
%73 = and i32 %69, %72
%74 = icmp ne i32 %73, 0
br i1 %74, label %75, label %94
75: ; preds = %55
%76 = load i32, i32* %7
%77 = srem i32 %76, 8
%78 = ashr i32 128, %77
%79 = load i8*, i8** %9
%80 = load i32, i32* %8
%81 = load i32, i32* %5
%82 = add nsw i32 %81, 7
%83 = sdiv i32 %82, 8
%84 = mul nsw i32 %80, %83
%85 = load i32, i32* %7
%86 = sdiv i32 %85, 8
%87 = add nsw i32 %84, %86
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i8, i8* %79, i64 %88
%90 = load i8, i8* %89
%91 = zext i8 %90 to i32
%92 = or i32 %91, %78
%93 = trunc i32 %92 to i8
store i8 %93, i8* %89
br label %229
94: ; preds = %55, %52
%95 = load i32, i32* %7
%96 = icmp ne i32 %95, 0
br i1 %96, label %97, label %137
97: ; preds = %94
%98 = load i8*, i8** %4
%99 = load i32, i32* %8
%100 = load i32, i32* %5
%101 = add nsw i32 %100, 7
%102 = sdiv i32 %101, 8
%103 = mul nsw i32 %99, %102
%104 = load i32, i32* %7
%105 = sub nsw i32 %104, 1
%106 = sdiv i32 %105, 8
%107 = add nsw i32 %103, %106
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i8, i8* %98, i64 %108
%110 = load i8, i8* %109
%111 = zext i8 %110 to i32
%112 = load i32, i32* %7
%113 = sub nsw i32 %112, 1
%114 = srem i32 %113, 8
%115 = ashr i32 128, %114
%116 = and i32 %111, %115
%117 = icmp ne i32 %116, 0
br i1 %117, label %118, label %137
118: ; preds = %97
%119 = load i32, i32* %7
%120 = srem i32 %119, 8
%121 = ashr i32 128, %120
%122 = load i8*, i8** %9
%123 = load i32, i32* %8
%124 = load i32, i32* %5
%125 = add nsw i32 %124, 7
%126 = sdiv i32 %125, 8
%127 = mul nsw i32 %123, %126
%128 = load i32, i32* %7
%129 = sdiv i32 %128, 8
%130 = add nsw i32 %127, %129
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i8, i8* %122, i64 %131
%133 = load i8, i8* %132
%134 = zext i8 %133 to i32
%135 = or i32 %134, %121
%136 = trunc i32 %135 to i8
store i8 %136, i8* %132
br label %228
137: ; preds = %97, %94
%138 = load i32, i32* %7
%139 = load i32, i32* %5
%140 = sub nsw i32 %139, 1
%141 = icmp slt i32 %138, %140
br i1 %141, label %142, label %182
142: ; preds = %137
%143 = load i8*, i8** %4
%144 = load i32, i32* %8
%145 = load i32, i32* %5
%146 = add nsw i32 %145, 7
%147 = sdiv i32 %146, 8
%148 = mul nsw i32 %144, %147
%149 = load i32, i32* %7
%150 = add nsw i32 %149, 1
%151 = sdiv i32 %150, 8
%152 = add nsw i32 %148, %151
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds i8, i8* %143, i64 %153
%155 = load i8, i8* %154
%156 = zext i8 %155 to i32
%157 = load i32, i32* %7
%158 = add nsw i32 %157, 1
%159 = srem i32 %158, 8
%160 = ashr i32 128, %159
%161 = and i32 %156, %160
%162 = icmp ne i32 %161, 0
br i1 %162, label %163, label %182
163: ; preds = %142
%164 = load i32, i32* %7
%165 = srem i32 %164, 8
%166 = ashr i32 128, %165
%167 = load i8*, i8** %9
%168 = load i32, i32* %8
%169 = load i32, i32* %5
%170 = add nsw i32 %169, 7
%171 = sdiv i32 %170, 8
%172 = mul nsw i32 %168, %171
%173 = load i32, i32* %7
%174 = sdiv i32 %173, 8
%175 = add nsw i32 %172, %174
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i8, i8* %167, i64 %176
%178 = load i8, i8* %177
%179 = zext i8 %178 to i32
%180 = or i32 %179, %166
%181 = trunc i32 %180 to i8
store i8 %181, i8* %177
br label %227
182: ; preds = %142, %137
%183 = load i32, i32* %8
%184 = load i32, i32* %6
%185 = sub nsw i32 %184, 1
%186 = icmp slt i32 %183, %185
br i1 %186, label %187, label %226
187: ; preds = %182
%188 = load i8*, i8** %4
%189 = load i32, i32* %8
%190 = add nsw i32 %189, 1
%191 = load i32, i32* %5
%192 = add nsw i32 %191, 7
%193 = sdiv i32 %192, 8
%194 = mul nsw i32 %190, %193
%195 = load i32, i32* %7
%196 = sdiv i32 %195, 8
%197 = add nsw i32 %194, %196
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i8, i8* %188, i64 %198
%200 = load i8, i8* %199
%201 = zext i8 %200 to i32
%202 = load i32, i32* %7
%203 = srem i32 %202, 8
%204 = ashr i32 128, %203
%205 = and i32 %201, %204
%206 = icmp ne i32 %205, 0
br i1 %206, label %207, label %226
207: ; preds = %187
%208 = load i32, i32* %7
%209 = srem i32 %208, 8
%210 = ashr i32 128, %209
%211 = load i8*, i8** %9
%212 = load i32, i32* %8
%213 = load i32, i32* %5
%214 = add nsw i32 %213, 7
%215 = sdiv i32 %214, 8
%216 = mul nsw i32 %212, %215
%217 = load i32, i32* %7
%218 = sdiv i32 %217, 8
%219 = add nsw i32 %216, %218
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i8, i8* %211, i64 %220
%222 = load i8, i8* %221
%223 = zext i8 %222 to i32
%224 = or i32 %223, %210
%225 = trunc i32 %224 to i8
store i8 %225, i8* %221
br label %226
226: ; preds = %207, %187, %182
br label %227
227: ; preds = %226, %163
br label %228
228: ; preds = %227, %118
br label %229
229: ; preds = %228, %75
br label %230
230: ; preds = %229, %32
br label %231
231: ; preds = %230
%232 = load i32, i32* %7
%233 = add nsw i32 %232, 1
store i32 %233, i32* %7
br label %28
234: ; preds = %28
br label %235
235: ; preds = %234
%236 = load i32, i32* %8
%237 = add nsw i32 %236, 1
store i32 %237, i32* %8
br label %23
238: ; preds = %23
%239 = load i8*, i8** %4
%240 = load i8*, i8** %9
%241 = load i32, i32* %5
%242 = add nsw i32 %241, 7
%243 = sdiv i32 %242, 8
%244 = load i32, i32* %6
%245 = mul nsw i32 %243, %244
%246 = call i32 @memcpy(i8* %239, i8* %240, i32 %245)
ret void
}

LLVM IR (-O2):
define void @OutlineCharacter(i8* %0, i32 %1, i32 %2) {
%4 = add nsw i32 %1, 7
%5 = sdiv i32 %4, 8
%6 = mul nsw i32 %5, %2
%7 = tail call i8* @alloca(i32 %6)
%8 = tail call i32 @memset(i8* %7, i32 0, i32 %6)
%9 = icmp sgt i32 %2, 0
br i1 %9, label %10, label %126
10: ; preds = %3
%11 = icmp sgt i32 %1, 0
%12 = add nsw i32 %1, -1
%13 = add nsw i32 %2, -1
%14 = sext i32 %5 to i64
%15 = zext i32 %13 to i64
%16 = zext i32 %2 to i64
%17 = icmp ult i32 %1, 2
%18 = icmp eq i32 %1, 1
br label %19
19: ; preds = %10, %123
%20 = phi i64 [ 0, %10 ], [ %124, %123 ]
br i1 %11, label %23, label %21
21: ; preds = %19
%22 = add nuw nsw i64 %20, 1
br label %123
23: ; preds = %19
%24 = mul nsw i64 %20, %14
%25 = icmp eq i64 %20, 0
%26 = add nsw i64 %20, -1
%27 = mul nsw i64 %26, %14
%28 = icmp slt i64 %20, %15
%29 = add nuw nsw i64 %20, 1
%30 = mul nsw i64 %29, %14
%31 = getelementptr inbounds i8, i8* %0, i64 %24
%32 = load i8, i8* %31
%33 = zext i8 %32 to i32
%34 = and i32 %33, 128
%35 = icmp eq i32 %34, 0
br i1 %35, label %36, label %58
36: ; preds = %23
br i1 %25, label %41, label %37
37: ; preds = %36
%38 = getelementptr inbounds i8, i8* %0, i64 %27
%39 = load i8, i8* %38
%40 = icmp sgt i8 %39, -1
br i1 %40, label %41, label %54
41: ; preds = %36, %37
%42 = and i32 %33, 64
%43 = icmp eq i32 %42, 0
%44 = select i1 %17, i1 true, i1 %43
br i1 %44, label %49, label %45
45: ; preds = %41
%46 = getelementptr inbounds i8, i8* %7, i64 %24
%47 = load i8, i8* %46
%48 = or i8 %47, -128
store i8 %48, i8* %46
br label %59
49: ; preds = %41
br i1 %28, label %50, label %58
50: ; preds = %49
%51 = getelementptr inbounds i8, i8* %0, i64 %30
%52 = load i8, i8* %51
%53 = icmp sgt i8 %52, -1
br i1 %53, label %58, label %54
54: ; preds = %50, %37
%55 = getelementptr inbounds i8, i8* %7, i64 %24
%56 = load i8, i8* %55
%57 = or i8 %56, -128
store i8 %57, i8* %55
br label %58
58: ; preds = %54, %50, %49, %23
br i1 %18, label %123, label %59
59: ; preds = %45, %58
br label %60
60: ; preds = %59, %120
%61 = phi i32 [ %121, %120 ], [ 1, %59 ]
%62 = lshr i32 %61, 3
%63 = zext i32 %62 to i64
%64 = add nsw i64 %24, %63
%65 = getelementptr inbounds i8, i8* %0, i64 %64
%66 = load i8, i8* %65
%67 = zext i8 %66 to i32
%68 = xor i32 %67, -1
%69 = and i32 %61, 7
%70 = lshr i32 128, %69
%71 = and i32 %70, %68
%72 = icmp eq i32 %71, 0
br i1 %72, label %120, label %73
73: ; preds = %60
br i1 %25, label %81, label %74
74: ; preds = %73
%75 = add nsw i64 %27, %63
%76 = getelementptr inbounds i8, i8* %0, i64 %75
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
%79 = and i32 %70, %78
%80 = icmp eq i32 %79, 0
br i1 %80, label %81, label %115
81: ; preds = %73, %74
%82 = add nsw i32 %61, -1
%83 = lshr i32 %82, 3
%84 = zext i32 %83 to i64
%85 = add nsw i64 %24, %84
%86 = getelementptr inbounds i8, i8* %0, i64 %85
%87 = load i8, i8* %86
%88 = zext i8 %87 to i32
%89 = and i32 %82, 7
%90 = lshr i32 128, %89
%91 = and i32 %90, %88
%92 = icmp eq i32 %91, 0
br i1 %92, label %93, label %115
93: ; preds = %81
%94 = icmp slt i32 %61, %12
br i1 %94, label %95, label %107
95: ; preds = %93
%96 = add nuw nsw i32 %61, 1
%97 = lshr i32 %96, 3
%98 = zext i32 %97 to i64
%99 = add nsw i64 %24, %98
%100 = getelementptr inbounds i8, i8* %0, i64 %99
%101 = load i8, i8* %100
%102 = zext i8 %101 to i32
%103 = and i32 %96, 7
%104 = lshr i32 128, %103
%105 = and i32 %104, %102
%106 = icmp eq i32 %105, 0
br i1 %106, label %107, label %115
107: ; preds = %95, %93
br i1 %28, label %108, label %120
108: ; preds = %107
%109 = add nsw i64 %30, %63
%110 = getelementptr inbounds i8, i8* %0, i64 %109
%111 = load i8, i8* %110
%112 = zext i8 %111 to i32
%113 = and i32 %70, %112
%114 = icmp eq i32 %113, 0
br i1 %114, label %120, label %115
115: ; preds = %108, %95, %81, %74
%116 = getelementptr inbounds i8, i8* %7, i64 %64
%117 = load i8, i8* %116
%118 = trunc i32 %70 to i8
%119 = or i8 %117, %118
store i8 %119, i8* %116
br label %120
120: ; preds = %115, %60, %107, %108
%121 = add nuw nsw i32 %61, 1
%122 = icmp eq i32 %121, %1
br i1 %122, label %123, label %60
123: ; preds = %120, %58, %21
%124 = phi i64 [ %22, %21 ], [ %29, %58 ], [ %29, %120 ]
%125 = icmp eq i64 %124, %16
br i1 %125, label %126, label %19
126: ; preds = %123, %3
%127 = tail call i32 @memcpy(i8* %0, i8* %7, i32 %6)
ret void
}