#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 *xmalloc(size_t);
unsigned char *xrealloc(unsigned char *, size_t);
size_t createcolumn(unsigned char **column, int *colours, int height) {
  size_t size = 256, length = 0;
  unsigned char *data = xmalloc(size);
  int i, y, top, transparent, opaque;
  for (y = 0; y < height;) {
    top = y;
    transparent = opaque = 0;
    for (; y < height && colours[y] == -1; y++)
      transparent++;
    for (; y < height && colours[y] >= 0; y++)
      opaque++;
    if (opaque > 0) {
      while (size < length + opaque + 8)
        size *= 2, data = xrealloc(data, size);
      data[length++] = top + transparent;
      data[length++] = opaque;
      data[length++] = 0;
      for (i = 0; i < opaque; i++)
        data[length++] = colours[top + transparent + i];
      data[length++] = 0;
    }
  }
  data[length++] = 0xff;
  *column = data;
  return length;
}


x86 assembly (clang, -O0):
<createcolumn>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movq   $0x100,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
call   1040 <xmalloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1315 <createcolumn+0x1f5>
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x38(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x45(%rbp)
jge    119a <createcolumn+0x7a>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
sete   %al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
test   $0x1,%al
jne    11aa <createcolumn+0x8a>
jmp    11c1 <createcolumn+0xa1>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1177 <createcolumn+0x57>
jmp    11c6 <createcolumn+0xa6>
mov    -0x38(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x46(%rbp)
jge    11e9 <createcolumn+0xc9>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
setge  %al
mov    %al,-0x46(%rbp)
mov    -0x46(%rbp),%al
test   $0x1,%al
jne    11f9 <createcolumn+0xd9>
jmp    1210 <createcolumn+0xf0>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11c6 <createcolumn+0xa6>
cmpl   $0x0,-0x44(%rbp)
jle    1310 <createcolumn+0x1f0>
jmp    121f <createcolumn+0xff>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x44(%rbp),%rdx
add    %rdx,%rcx
add    $0x8,%rcx
cmp    %rcx,%rax
jae    125d <createcolumn+0x13d>
mov    -0x20(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1030 <xrealloc@plt>
mov    %rax,-0x30(%rbp)
jmp    121f <createcolumn+0xff>
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x28(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x28(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    12f9 <createcolumn+0x1d9>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %al,%dl
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x28(%rbp)
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12b4 <createcolumn+0x194>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
movb   $0x0,(%rax,%rcx,1)
jmp    1157 <createcolumn+0x37>
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
movb   $0xff,(%rax,%rcx,1)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<createcolumn>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %edx,%r12d
mov    %rsi,%rbx
mov    %rdi,0x30(%rsp)
mov    $0x100,%r13d
mov    $0x100,%edi
call   1040 <xmalloc@plt>
xor    %r15d,%r15d
test   %r12d,%r12d
jle    116d <createcolumn+0x4d>
mov    %r12d,%r9d
lea    0x30(%rbx),%rcx
mov    %rcx,0x20(%rsp)
lea    0xc(%rbx),%rcx
mov    %rcx,0x28(%rsp)
xor    %ebp,%ebp
mov    %rbx,%r8
jmp    11c3 <createcolumn+0xa3>
xor    %ebp,%ebp
movb   $0xff,(%rax,%rbp,1)
add    $0x1,%rbp
mov    0x30(%rsp),%rcx
mov    %rax,(%rcx)
mov    %rbp,%rax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%rsi,%r10,1),%rbp
add    $0xffffffffffffffff,%rbp
mov    0x18(%rsp),%r9
mov    0x14(%rsp),%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rbp
movb   $0x0,(%rax,%rcx,1)
mov    %rbx,%r8
mov    %edi,%r15d
cmp    %r12d,%edi
jge    116f <createcolumn+0x4f>
xor    %r14d,%r14d
mov    %r15d,%edi
cmp    %r12d,%r15d
jge    1204 <createcolumn+0xe4>
movslq %r15d,%rsi
lea    (%r8,%rsi,4),%rcx
mov    %r9,%rdx
sub    %rsi,%rdx
xor    %r14d,%r14d
xchg   %ax,%ax
cmpl   $0xffffffff,(%rcx,%r14,4)
jne    1200 <createcolumn+0xe0>
add    $0x1,%r14
cmp    %r14,%rdx
jne    11e0 <createcolumn+0xc0>
jmp    116f <createcolumn+0x4f>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r15,%r14,1),%edi
cmp    %r12d,%edi
jge    11bb <createcolumn+0x9b>
movslq %edi,%rcx
mov    %r12d,%ebx
sub    %edi,%ebx
lea    (%r8,%rcx,4),%rdx
mov    %r9,%rsi
sub    %rcx,%rsi
xor    %ecx,%ecx
nopl   (%rax)
cmpl   $0x0,(%rdx,%rcx,4)
js     1238 <createcolumn+0x118>
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1220 <createcolumn+0x100>
mov    %r12d,%edi
test   %ebx,%ebx
jne    1244 <createcolumn+0x124>
jmp    11bb <createcolumn+0x9b>
add    %ecx,%edi
mov    %ecx,%ebx
test   %ebx,%ebx
je     11bb <createcolumn+0x9b>
mov    %r8,0x8(%rsp)
mov    %r12d,0x4(%rsp)
mov    %ebx,%ecx
lea    (%rcx,%rbp,1),%r12
add    $0x8,%r12
cmp    %r12,%r13
mov    %r9,0x18(%rsp)
mov    %edi,0x14(%rsp)
jae    1283 <createcolumn+0x163>
cs nopw 0x0(%rax,%rax,1)
add    %r13,%r13
mov    %rax,%rdi
mov    %r13,%rsi
call   1030 <xrealloc@plt>
cmp    %r12,%r13
jb     1270 <createcolumn+0x150>
add    %r15d,%r14d
mov    %r14b,(%rax,%rbp,1)
mov    %rbx,%r11
mov    %r11b,0x1(%rax,%rbp,1)
lea    0x3(%rbp),%r10
movb   $0x0,0x2(%rax,%rbp,1)
movslq %r14d,%r8
cmp    $0x2,%r11d
mov    $0x1,%ecx
cmovb  %ecx,%r11d
cmp    $0x8,%r11d
jae    12c2 <createcolumn+0x1a2>
xor    %esi,%esi
mov    0x4(%rsp),%r12d
mov    0x8(%rsp),%rbx
jmp    1410 <createcolumn+0x2f0>
lea    (%rax,%rbp,1),%rcx
add    $0x3,%rcx
lea    (%r8,%r11,1),%rdx
mov    0x8(%rsp),%rdi
lea    (%rdi,%rdx,4),%rdx
cmp    %rdx,%rcx
jae    12ff <createcolumn+0x1df>
lea    (%r11,%rbp,1),%rcx
add    %rax,%rcx
add    $0x3,%rcx
lea    (%rdi,%r8,4),%rdx
cmp    %rdx,%rcx
jbe    12ff <createcolumn+0x1df>
xor    %esi,%esi
mov    0x4(%rsp),%r12d
mov    %rdi,%rbx
jmp    1410 <createcolumn+0x2f0>
mov    %r11d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
mov    0x4(%rsp),%r12d
movdqa 0xcdc(%rip),%xmm2
je     14c9 <createcolumn+0x3a9>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%rax,%rbp,1),%rdx
add    $0xf,%rdx
mov    0x20(%rsp),%rcx
lea    (%rcx,%r8,4),%rcx
xor    %ebp,%ebp
mov    0x8(%rsp),%rbx
nopl   0x0(%rax)
movdqu -0x30(%rcx,%rbp,4),%xmm0
movdqu -0x20(%rcx,%rbp,4),%xmm1
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,-0xc(%rdx,%rbp,1)
movd   %xmm1,-0x8(%rdx,%rbp,1)
movdqu -0x10(%rcx,%rbp,4),%xmm0
movdqu (%rcx,%rbp,4),%xmm1
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,-0x4(%rdx,%rbp,1)
movd   %xmm1,(%rdx,%rbp,1)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1350 <createcolumn+0x230>
test   $0x1,%r9b
je     13f6 <createcolumn+0x2d6>
lea    (%r10,%rbp,1),%rcx
add    %r8,%rbp
mov    %rbx,%rdx
movdqu (%rbx,%rbp,4),%xmm0
movdqu 0x10(%rbx,%rbp,4),%xmm1
pand   %xmm2,%xmm0
packuswb %xmm0,%xmm0
packuswb %xmm0,%xmm0
pand   %xmm2,%xmm1
packuswb %xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm0,(%rax,%rcx,1)
movd   %xmm1,0x4(%rax,%rcx,1)
lea    (%r10,%rsi,1),%rcx
cmp    %r11,%rsi
je     1191 <createcolumn+0x71>
mov    %rcx,%r10
cs nopw 0x0(%rax,%rax,1)
mov    %rsi,%r9
not    %r9
add    %r11,%r9
mov    %r11,%rcx
and    $0x3,%rcx
je     146b <createcolumn+0x34b>
lea    (%rsi,%r8,1),%rdx
lea    (%rbx,%rdx,4),%rdx
lea    (%rax,%r10,1),%rbp
neg    %rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rdx),%ebx
mov    %bl,0x0(%rbp)
add    $0xffffffffffffffff,%rdi
add    $0x4,%rdx
add    $0x1,%rbp
cmp    %rdi,%rcx
jne    1440 <createcolumn+0x320>
sub    %rdi,%rsi
sub    %rdi,%r10
lea    -0x1(%r10),%rbp
mov    %r10,%rcx
mov    0x8(%rsp),%rbx
jmp    146b <createcolumn+0x34b>
cmp    $0x3,%r9
mov    0x18(%rsp),%r9
mov    0x14(%rsp),%edi
jb     11b0 <createcolumn+0x90>
mov    0x28(%rsp),%rcx
lea    (%rcx,%r8,4),%rcx
add    $0xffffffffffffffff,%r10
mov    %r10,%rbp
xchg   %ax,%ax
movzbl -0xc(%rcx,%rsi,4),%edx
mov    %dl,0x1(%rax,%rbp,1)
movzbl -0x8(%rcx,%rsi,4),%edx
mov    %dl,0x2(%rax,%rbp,1)
movzbl -0x4(%rcx,%rsi,4),%edx
mov    %dl,0x3(%rax,%rbp,1)
movzbl (%rcx,%rsi,4),%edx
mov    %dl,0x4(%rax,%rbp,1)
add    $0x4,%rsi
add    $0x4,%rbp
cmp    %rsi,%r11
jne    1490 <createcolumn+0x370>
lea    0x1(%rbp),%rcx
jmp    11b0 <createcolumn+0x90>
xor    %ebp,%ebp
mov    0x8(%rsp),%rbx
test   $0x1,%r9b
jne    13be <createcolumn+0x29e>
jmp    13f6 <createcolumn+0x2d6>

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

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