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

/* Forward declarations */

/* Type definitions */
typedef union RunData {
  int dummy;
} RunData;

/* Variables and functions */
scalar_t__ compareruns(unsigned char *, int *, int, union RunData *, int *);
scalar_t__ encode_rle(unsigned char *, unsigned int, unsigned int,
                      union RunData *, int);
int EncodeImage(unsigned char *data, int pixels, unsigned char *fileArr) {
  union RunData *currP, *norunP;
  int i, match, depth;
  unsigned int filePos, run, nomatchrun;
  currP = NULL;
  norunP = NULL;
  nomatchrun = 0;
  filePos = 0;
  run = 1;
  depth = 1;
  currP = (union RunData *)&data[0];
  for (i = 1; i < pixels;) {
    if (compareruns(data, &i, pixels, currP, &depth))
      run++;
    else {
      if ((run * depth) > 2) {
        unsigned char *p = (unsigned char *)norunP;
        if (nomatchrun) {
          while (nomatchrun) {
            int cnt;
            cnt = (nomatchrun > 127) ? 127 : nomatchrun;
            fileArr[filePos++] = cnt;
            nomatchrun -= cnt;
            while (cnt--)
              fileArr[filePos++] = *p++;
          }
        }
        filePos += encode_rle(fileArr, filePos, run, currP, depth);
        norunP = NULL;
      } else {
        nomatchrun += run;
      }
      currP = (union RunData *)&data[i];
      if (norunP == NULL) {
        nomatchrun = 0;
        norunP = currP;
      }
      depth = 1;
      run = 1;
      i++;
    }
  }
  if (nomatchrun) {
    unsigned char *p = (unsigned char *)norunP;
    while (nomatchrun) {
      int cnt;
      cnt = (nomatchrun > 127) ? 127 : nomatchrun;
      fileArr[filePos++] = cnt;
      nomatchrun -= cnt;
      while (cnt--)
        fileArr[filePos++] = *p++;
    }
  }
  if (run > 0) {
    filePos += encode_rle(fileArr, filePos, run, currP, depth);
  }
  return filePos;
}


x86 assembly (clang, -O0):
<EncodeImage>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12e8 <EncodeImage+0x1c8>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    -0x20(%rbp),%rcx
lea    -0x2c(%rbp),%rsi
lea    -0x34(%rbp),%r8
call   1030 <compareruns@plt>
cmp    $0x0,%rax
je     11aa <EncodeImage+0x8a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12e3 <EncodeImage+0x1c3>
mov    -0x3c(%rbp),%eax
imul   -0x34(%rbp),%eax
cmp    $0x2,%eax
jbe    129a <EncodeImage+0x17a>
mov    -0x28(%rbp),%rax
mov    %rax,-0x48(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     126a <EncodeImage+0x14a>
jmp    11d1 <EncodeImage+0xb1>
cmpl   $0x0,-0x40(%rbp)
je     1265 <EncodeImage+0x145>
cmpl   $0x7f,-0x40(%rbp)
jbe    11f2 <EncodeImage+0xd2>
mov    $0x7f,%eax
mov    %eax,-0x60(%rbp)
jmp    11f8 <EncodeImage+0xd8>
mov    -0x40(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x4c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x4c(%rbp)
cmp    $0x0,%eax
je     1260 <EncodeImage+0x140>
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
mov    (%rax),%dl
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1222 <EncodeImage+0x102>
jmp    11d1 <EncodeImage+0xb1>
jmp    126a <EncodeImage+0x14a>
mov    -0x18(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x34(%rbp),%r8d
call   1040 <encode_rle@plt>
mov    %rax,%rcx
mov    -0x38(%rbp),%eax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
movq   $0x0,-0x28(%rbp)
jmp    12a3 <EncodeImage+0x183>
mov    -0x3c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    12cc <EncodeImage+0x1ac>
movl   $0x0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x1,-0x34(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116e <EncodeImage+0x4e>
cmpl   $0x0,-0x40(%rbp)
je     1393 <EncodeImage+0x273>
mov    -0x28(%rbp),%rax
mov    %rax,-0x58(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     138e <EncodeImage+0x26e>
cmpl   $0x7f,-0x40(%rbp)
jbe    131b <EncodeImage+0x1fb>
mov    $0x7f,%eax
mov    %eax,-0x64(%rbp)
jmp    1321 <EncodeImage+0x201>
mov    -0x40(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x5c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x5c(%rbp)
cmp    $0x0,%eax
je     1389 <EncodeImage+0x269>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x58(%rbp)
mov    (%rax),%dl
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    134b <EncodeImage+0x22b>
jmp    12fa <EncodeImage+0x1da>
jmp    1393 <EncodeImage+0x273>
cmpl   $0x0,-0x3c(%rbp)
jbe    13c0 <EncodeImage+0x2a0>
mov    -0x18(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x34(%rbp),%r8d
call   1040 <encode_rle@plt>
mov    %rax,%rcx
mov    -0x38(%rbp),%eax
add    %rcx,%rax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<EncodeImage>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rdx,%r12
movl   $0x1,(%rsp)
movl   $0x1,0x4(%rsp)
cmp    $0x2,%esi
jl     164a <EncodeImage+0x52a>
mov    %esi,%ebp
lea    0x1(%r12),%rax
mov    %rax,0x18(%rsp)
mov    $0x1,%edx
xor    %r15d,%r15d
xor    %r13d,%r13d
mov    %rdi,%rcx
xor    %r14d,%r14d
mov    %rdi,0x10(%rsp)
mov    %esi,0x8(%rsp)
jmp    11a1 <EncodeImage+0x81>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%edx
add    $0x1,%edx
mov    0x4(%rsp),%eax
mov    0x20(%rsp),%rcx
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%ebp
cmp    %ebp,%eax
jge    1428 <EncodeImage+0x308>
mov    %edx,0xc(%rsp)
lea    0x4(%rsp),%rsi
mov    %ebp,%edx
mov    %rcx,0x20(%rsp)
mov    %rsp,%r8
call   1030 <compareruns@plt>
test   %rax,%rax
jne    1180 <EncodeImage+0x60>
mov    (%rsp),%r8d
mov    %r8d,%eax
mov    0xc(%rsp),%ecx
imul   %ecx,%eax
cmp    $0x3,%eax
jae    11e3 <EncodeImage+0xc3>
add    %ecx,%r15d
jmp    13e9 <EncodeImage+0x2c9>
nopl   0x0(%rax)
mov    %r11d,%r13d
test   %r15d,%r15d
je     13c9 <EncodeImage+0x2a9>
cmp    $0x7f,%r15d
mov    $0x7f,%eax
cmovb  %r15d,%eax
mov    %r13d,%ecx
mov    %al,(%r12,%rcx,1)
sub    %eax,%r15d
lea    0x1(%r13),%r11d
test   %eax,%eax
je     11e0 <EncodeImage+0xc0>
lea    -0x1(%rax),%r10d
cmp    $0xf,%r10d
jb     1320 <EncodeImage+0x200>
lea    (%rax,%r13,1),%ecx
cmp    %r11d,%ecx
jb     1320 <EncodeImage+0x200>
mov    %r11d,%ecx
lea    (%r10,%rcx,1),%rdx
add    0x18(%rsp),%rdx
cmp    %rdx,%r14
jae    124b <EncodeImage+0x12b>
lea    (%r14,%r10,1),%rdx
add    $0x1,%rdx
add    %r12,%rcx
cmp    %rdx,%rcx
jb     1320 <EncodeImage+0x200>
add    $0x1,%r10
movabs $0x1ffffffe0,%rcx
lea    0x10(%rcx),%r9
and    %r10,%r9
lea    -0x10(%r9),%rcx
mov    %rcx,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x30,%rcx
jae    127e <EncodeImage+0x15e>
xor    %esi,%esi
jmp    12d3 <EncodeImage+0x1b3>
and    $0xfffffffffffffffc,%rdi
lea    0x21(%r13),%edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
lea    -0x20(%rdx),%ecx
movups (%r14,%rsi,1),%xmm0
movups %xmm0,(%r12,%rcx,1)
lea    -0x10(%rdx),%ecx
movups 0x10(%r14,%rsi,1),%xmm0
movups %xmm0,(%r12,%rcx,1)
movups 0x20(%r14,%rsi,1),%xmm0
mov    %edx,%ecx
movups %xmm0,(%r12,%rcx,1)
lea    0x10(%rdx),%ecx
movups 0x30(%r14,%rsi,1),%xmm0
movups %xmm0,(%r12,%rcx,1)
add    $0x40,%rsi
add    $0x40,%edx
add    $0xfffffffffffffffc,%rdi
jne    1290 <EncodeImage+0x170>
test   %rbp,%rbp
je     1305 <EncodeImage+0x1e5>
lea    (%r14,%rsi,1),%rdx
lea    (%rsi,%r13,1),%ecx
add    $0x1,%ecx
shl    $0x4,%rbp
xor    %esi,%esi
nopl   0x0(%rax)
lea    (%rcx,%rsi,1),%edi
movups (%rdx,%rsi,1),%xmm0
movups %xmm0,(%r12,%rdi,1)
add    $0x10,%rsi
cmp    %rsi,%rbp
jne    12f0 <EncodeImage+0x1d0>
add    %r9d,%r11d
add    %r9,%r14
cmp    %r9,%r10
je     11e0 <EncodeImage+0xc0>
sub    %r9d,%eax
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rax),%r9d
test   $0x3,%al
je     136b <EncodeImage+0x24b>
mov    %r11d,%edi
mov    %eax,%ecx
and    $0x3,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rdi,%rsi,1),%ebp
movzbl (%r14,%rsi,1),%edx
mov    %dl,(%r12,%rbp,1)
add    $0x1,%rsi
cmp    %esi,%ecx
jne    1340 <EncodeImage+0x220>
add    %esi,%r11d
sub    %esi,%eax
add    %rsi,%r14
mov    %r11d,%r13d
cmp    $0x3,%r9d
jb     11e3 <EncodeImage+0xc3>
jmp    1375 <EncodeImage+0x255>
cmp    $0x3,%r9d
jb     11e3 <EncodeImage+0xc3>
mov    %r11d,%edx
mov    %eax,%esi
xor    %ecx,%ecx
nopl   0x0(%rax)
lea    (%rdx,%rcx,1),%rax
movzbl (%r14,%rcx,1),%ebx
mov    %eax,%edi
mov    %bl,(%r12,%rdi,1)
lea    0x1(%rax),%edi
movzbl 0x1(%r14,%rcx,1),%ebx
mov    %bl,(%r12,%rdi,1)
lea    0x2(%rax),%edi
movzbl 0x2(%r14,%rcx,1),%ebx
mov    %bl,(%r12,%rdi,1)
add    $0x3,%eax
movzbl 0x3(%r14,%rcx,1),%ebx
mov    %bl,(%r12,%rax,1)
add    $0x4,%rcx
cmp    %ecx,%esi
jne    1380 <EncodeImage+0x260>
add    %ecx,%r11d
add    %rcx,%r14
jmp    11e0 <EncodeImage+0xc0>
mov    %r12,%rdi
mov    %r13d,%esi
mov    0xc(%rsp),%edx
mov    0x20(%rsp),%rcx
call   1040 <encode_rle@plt>
add    %r13d,%eax
xor    %r14d,%r14d
mov    %eax,%r13d
xor    %r15d,%r15d
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%ebp
movslq 0x4(%rsp),%rax
mov    %rax,%rcx
add    %rdi,%rcx
test   %r14,%r14
cmove  %rcx,%r14
mov    $0x0,%edx
cmove  %edx,%r15d
add    $0x1,%eax
movl   $0x1,(%rsp)
mov    %eax,0x4(%rsp)
mov    $0x1,%edx
cmp    %ebp,%eax
jl     11a1 <EncodeImage+0x81>
test   %r15d,%r15d
jne    1448 <EncodeImage+0x328>
mov    %r13d,%r11d
test   %edx,%edx
jne    1655 <EncodeImage+0x535>
jmp    166c <EncodeImage+0x54c>
nopl   (%rax)
mov    %r11d,%r13d
sub    %r9d,%r15d
je     1430 <EncodeImage+0x310>
cmp    $0x7f,%r15d
mov    $0x7f,%r9d
cmovb  %r15d,%r9d
mov    %r13d,%eax
mov    %r9b,(%r12,%rax,1)
lea    0x1(%r13),%r11d
lea    -0x1(%r9),%r10d
cmp    $0x1f,%r10d
jb     149d <EncodeImage+0x37d>
lea    (%r9,%r13,1),%eax
cmp    %r11d,%eax
jb     149d <EncodeImage+0x37d>
mov    %r11d,%eax
lea    (%r10,%rax,1),%rsi
add    0x18(%rsp),%rsi
cmp    %rsi,%r14
jae    1540 <EncodeImage+0x420>
lea    (%r14,%r10,1),%rsi
add    $0x1,%rsi
add    %r12,%rax
cmp    %rsi,%rax
jae    1540 <EncodeImage+0x420>
mov    %r9d,%r10d
lea    -0x1(%r10),%r8d
test   $0x3,%r10b
je     14dd <EncodeImage+0x3bd>
mov    %r11d,%edi
mov    %r10d,%eax
and    $0x3,%eax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rdi,%rsi,1),%ebp
movzbl (%r14,%rsi,1),%ebx
mov    %bl,(%r12,%rbp,1)
add    $0x1,%rsi
cmp    %esi,%eax
jne    14c0 <EncodeImage+0x3a0>
add    %esi,%r11d
sub    %esi,%r10d
add    %rsi,%r14
cmp    $0x3,%r8d
jb     1440 <EncodeImage+0x320>
mov    %r11d,%r8d
mov    %r10d,%esi
xor    %ebp,%ebp
nop
lea    (%r8,%rbp,1),%rax
movzbl (%r14,%rbp,1),%ebx
mov    %eax,%edi
mov    %bl,(%r12,%rdi,1)
lea    0x1(%rax),%edi
movzbl 0x1(%r14,%rbp,1),%ebx
mov    %bl,(%r12,%rdi,1)
lea    0x2(%rax),%edi
movzbl 0x2(%r14,%rbp,1),%ebx
mov    %bl,(%r12,%rdi,1)
add    $0x3,%eax
movzbl 0x3(%r14,%rbp,1),%ebx
mov    %bl,(%r12,%rax,1)
add    $0x4,%rbp
cmp    %ebp,%esi
jne    14f0 <EncodeImage+0x3d0>
add    %ebp,%r11d
add    %rbp,%r14
jmp    1440 <EncodeImage+0x320>
nopl   0x0(%rax)
add    $0x1,%r10
mov    %r10,%r8
movabs $0x1ffffffe0,%rax
and    %rax,%r8
lea    -0x20(%r8),%rax
mov    %rax,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x60,%rax
jae    1575 <EncodeImage+0x455>
xor    %ebx,%ebx
jmp    15f3 <EncodeImage+0x4d3>
and    $0xfffffffffffffffc,%rdi
lea    0x41(%r13),%ebp
xor    %ebx,%ebx
nop
lea    -0x40(%rbp),%eax
movups (%r14,%rbx,1),%xmm0
movups 0x10(%r14,%rbx,1),%xmm1
movups %xmm0,(%r12,%rax,1)
movups %xmm1,0x10(%r12,%rax,1)
lea    -0x20(%rbp),%eax
movups 0x20(%r14,%rbx,1),%xmm0
movups 0x30(%r14,%rbx,1),%xmm1
movups %xmm0,(%r12,%rax,1)
movups %xmm1,0x10(%r12,%rax,1)
movups 0x40(%r14,%rbx,1),%xmm0
movups 0x50(%r14,%rbx,1),%xmm1
mov    %ebp,%eax
movups %xmm0,(%r12,%rax,1)
movups %xmm1,0x10(%r12,%rax,1)
lea    0x20(%rbp),%eax
movups 0x60(%r14,%rbx,1),%xmm0
movups 0x70(%r14,%rbx,1),%xmm1
movups %xmm0,(%r12,%rax,1)
movups %xmm1,0x10(%r12,%rax,1)
sub    $0xffffffffffffff80,%rbx
sub    $0xffffff80,%ebp
add    $0xfffffffffffffffc,%rdi
jne    1580 <EncodeImage+0x460>
test   %rsi,%rsi
je     1630 <EncodeImage+0x510>
lea    (%r14,%rbx,1),%rdi
add    $0x10,%rdi
add    %r13d,%ebx
add    $0x1,%ebx
shl    $0x5,%rsi
xor    %eax,%eax
nopl   0x0(%rax)
lea    (%rbx,%rax,1),%ebp
movups -0x10(%rdi,%rax,1),%xmm0
movups (%rdi,%rax,1),%xmm1
movups %xmm0,(%r12,%rbp,1)
movups %xmm1,0x10(%r12,%rbp,1)
add    $0x20,%rax
cmp    %rax,%rsi
jne    1610 <EncodeImage+0x4f0>
add    %r8d,%r11d
add    %r8,%r14
cmp    %r8,%r10
je     1440 <EncodeImage+0x320>
mov    %r9d,%r10d
sub    %r8d,%r10d
jmp    14a0 <EncodeImage+0x380>
mov    $0x1,%edx
xor    %r11d,%r11d
mov    %rdi,%rcx
mov    (%rsp),%r8d
mov    %r12,%rdi
mov    %r11d,%esi
mov    %r11d,%ebx
call   1040 <encode_rle@plt>
add    %ebx,%eax
mov    %eax,%r11d
mov    %r11d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%union.RunData = type { i32 }
define i32 @EncodeImage(i8* %0, i32 %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i8*
%7 = alloca %union.RunData*
%8 = alloca %union.RunData*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i8*
%16 = alloca i32
%17 = alloca i8*
%18 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i8* %2, i8** %6
store %union.RunData* null, %union.RunData** %7
store %union.RunData* null, %union.RunData** %8
store i32 0, i32* %14
store i32 0, i32* %12
store i32 1, i32* %13
store i32 1, i32* %11
%19 = load i8*, i8** %4
%20 = getelementptr inbounds i8, i8* %19, i64 0
%21 = bitcast i8* %20 to %union.RunData*
store %union.RunData* %21, %union.RunData** %7
store i32 1, i32* %9
br label %22
22: ; preds = %110, %3
%23 = load i32, i32* %9
%24 = load i32, i32* %5
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %111
26: ; preds = %22
%27 = load i8*, i8** %4
%28 = load i32, i32* %5
%29 = load %union.RunData*, %union.RunData** %7
%30 = call i64 @compareruns(i8* %27, i32* %9, i32 %28, %union.RunData* %29, i32* %11)
%31 = icmp ne i64 %30, 0
br i1 %31, label %32, label %35
32: ; preds = %26
%33 = load i32, i32* %13
%34 = add i32 %33, 1
store i32 %34, i32* %13
br label %110
35: ; preds = %26
%36 = load i32, i32* %13
%37 = load i32, i32* %11
%38 = mul i32 %36, %37
%39 = icmp ugt i32 %38, 2
br i1 %39, label %40, label %93
40: ; preds = %35
%41 = load %union.RunData*, %union.RunData** %8
%42 = bitcast %union.RunData* %41 to i8*
store i8* %42, i8** %15
%43 = load i32, i32* %14
%44 = icmp ne i32 %43, 0
br i1 %44, label %45, label %82
45: ; preds = %40
br label %46
46: ; preds = %80, %45
%47 = load i32, i32* %14
%48 = icmp ne i32 %47, 0
br i1 %48, label %49, label %81
49: ; preds = %46
%50 = load i32, i32* %14
%51 = icmp ugt i32 %50, 127
br i1 %51, label %52, label %53
52: ; preds = %49
br label %55
53: ; preds = %49
%54 = load i32, i32* %14
br label %55
55: ; preds = %53, %52
%56 = phi i32 [ 127, %52 ], [ %54, %53 ]
store i32 %56, i32* %16
%57 = load i32, i32* %16
%58 = trunc i32 %57 to i8
%59 = load i8*, i8** %6
%60 = load i32, i32* %12
%61 = add i32 %60, 1
store i32 %61, i32* %12
%62 = zext i32 %60 to i64
%63 = getelementptr inbounds i8, i8* %59, i64 %62
store i8 %58, i8* %63
%64 = load i32, i32* %16
%65 = load i32, i32* %14
%66 = sub i32 %65, %64
store i32 %66, i32* %14
br label %67
67: ; preds = %71, %55
%68 = load i32, i32* %16
%69 = add nsw i32 %68, -1
store i32 %69, i32* %16
%70 = icmp ne i32 %68, 0
br i1 %70, label %71, label %80
71: ; preds = %67
%72 = load i8*, i8** %15
%73 = getelementptr inbounds i8, i8* %72, i32 1
store i8* %73, i8** %15
%74 = load i8, i8* %72
%75 = load i8*, i8** %6
%76 = load i32, i32* %12
%77 = add i32 %76, 1
store i32 %77, i32* %12
%78 = zext i32 %76 to i64
%79 = getelementptr inbounds i8, i8* %75, i64 %78
store i8 %74, i8* %79
br label %67
80: ; preds = %67
br label %46
81: ; preds = %46
br label %82
82: ; preds = %81, %40
%83 = load i8*, i8** %6
%84 = load i32, i32* %12
%85 = load i32, i32* %13
%86 = load %union.RunData*, %union.RunData** %7
%87 = load i32, i32* %11
%88 = call i64 @encode_rle(i8* %83, i32 %84, i32 %85, %union.RunData* %86, i32 %87)
%89 = load i32, i32* %12
%90 = zext i32 %89 to i64
%91 = add nsw i64 %90, %88
%92 = trunc i64 %91 to i32
store i32 %92, i32* %12
store %union.RunData* null, %union.RunData** %8
br label %97
93: ; preds = %35
%94 = load i32, i32* %13
%95 = load i32, i32* %14
%96 = add i32 %95, %94
store i32 %96, i32* %14
br label %97
97: ; preds = %93, %82
%98 = load i8*, i8** %4
%99 = load i32, i32* %9
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %98, i64 %100
%102 = bitcast i8* %101 to %union.RunData*
store %union.RunData* %102, %union.RunData** %7
%103 = load %union.RunData*, %union.RunData** %8
%104 = icmp eq %union.RunData* %103, null
br i1 %104, label %105, label %107
105: ; preds = %97
store i32 0, i32* %14
%106 = load %union.RunData*, %union.RunData** %7
store %union.RunData* %106, %union.RunData** %8
br label %107
107: ; preds = %105, %97
store i32 1, i32* %11
store i32 1, i32* %13
%108 = load i32, i32* %9
%109 = add nsw i32 %108, 1
store i32 %109, i32* %9
br label %110
110: ; preds = %107, %32
br label %22
111: ; preds = %22
%112 = load i32, i32* %14
%113 = icmp ne i32 %112, 0
br i1 %113, label %114, label %153
114: ; preds = %111
%115 = load %union.RunData*, %union.RunData** %8
%116 = bitcast %union.RunData* %115 to i8*
store i8* %116, i8** %17
br label %117
117: ; preds = %151, %114
%118 = load i32, i32* %14
%119 = icmp ne i32 %118, 0
br i1 %119, label %120, label %152
120: ; preds = %117
%121 = load i32, i32* %14
%122 = icmp ugt i32 %121, 127
br i1 %122, label %123, label %124
123: ; preds = %120
br label %126
124: ; preds = %120
%125 = load i32, i32* %14
br label %126
126: ; preds = %124, %123
%127 = phi i32 [ 127, %123 ], [ %125, %124 ]
store i32 %127, i32* %18
%128 = load i32, i32* %18
%129 = trunc i32 %128 to i8
%130 = load i8*, i8** %6
%131 = load i32, i32* %12
%132 = add i32 %131, 1
store i32 %132, i32* %12
%133 = zext i32 %131 to i64
%134 = getelementptr inbounds i8, i8* %130, i64 %133
store i8 %129, i8* %134
%135 = load i32, i32* %18
%136 = load i32, i32* %14
%137 = sub i32 %136, %135
store i32 %137, i32* %14
br label %138
138: ; preds = %142, %126
%139 = load i32, i32* %18
%140 = add nsw i32 %139, -1
store i32 %140, i32* %18
%141 = icmp ne i32 %139, 0
br i1 %141, label %142, label %151
142: ; preds = %138
%143 = load i8*, i8** %17
%144 = getelementptr inbounds i8, i8* %143, i32 1
store i8* %144, i8** %17
%145 = load i8, i8* %143
%146 = load i8*, i8** %6
%147 = load i32, i32* %12
%148 = add i32 %147, 1
store i32 %148, i32* %12
%149 = zext i32 %147 to i64
%150 = getelementptr inbounds i8, i8* %146, i64 %149
store i8 %145, i8* %150
br label %138
151: ; preds = %138
br label %117
152: ; preds = %117
br label %153
153: ; preds = %152, %111
%154 = load i32, i32* %13
%155 = icmp ugt i32 %154, 0
br i1 %155, label %156, label %167
156: ; preds = %153
%157 = load i8*, i8** %6
%158 = load i32, i32* %12
%159 = load i32, i32* %13
%160 = load %union.RunData*, %union.RunData** %7
%161 = load i32, i32* %11
%162 = call i64 @encode_rle(i8* %157, i32 %158, i32 %159, %union.RunData* %160, i32 %161)
%163 = load i32, i32* %12
%164 = zext i32 %163 to i64
%165 = add nsw i64 %164, %162
%166 = trunc i64 %165 to i32
store i32 %166, i32* %12
br label %167
167: ; preds = %156, %153
%168 = load i32, i32* %12
ret i32 %168
}

LLVM IR (-O2):
%union.RunData = type { i32 }
define i32 @EncodeImage(i8* %0, i32 %1, i8* %2) {
%4 = alloca i32
%5 = alloca i32
%6 = bitcast i32* %4 to i8*
%7 = bitcast i32* %5 to i8*
store i32 1, i32* %5
%8 = bitcast i8* %0 to %union.RunData*
store i32 1, i32* %4
%9 = icmp sgt i32 %1, 1
br i1 %9, label %10, label %415
10: ; preds = %3
%11 = getelementptr i8, i8* %2, i64 1
br label %12
12: ; preds = %10, %213
%13 = phi i32 [ %219, %213 ], [ 0, %10 ]
%14 = phi i32 [ %218, %213 ], [ 1, %10 ]
%15 = phi i32 [ %217, %213 ], [ 0, %10 ]
%16 = phi %union.RunData* [ %216, %213 ], [ %8, %10 ]
%17 = phi %union.RunData* [ %215, %213 ], [ null, %10 ]
%18 = call i64 @compareruns(i8* %0, i32* %4, i32 %1, %union.RunData* %16, i32* %5)
%19 = icmp eq i64 %18, 0
br i1 %19, label %23, label %20
20: ; preds = %12
%21 = add i32 %14, 1
%22 = load i32, i32* %4
br label %213
23: ; preds = %12
%24 = load i32, i32* %5
%25 = mul i32 %24, %14
%26 = icmp ugt i32 %25, 2
br i1 %26, label %27, label %199
27: ; preds = %23
%28 = icmp eq i32 %13, 0
br i1 %28, label %194, label %29
29: ; preds = %27
%30 = bitcast %union.RunData* %17 to i8*
br label %31
31: ; preds = %29, %190
%32 = phi i32 [ %192, %190 ], [ %15, %29 ]
%33 = phi i32 [ %40, %190 ], [ %13, %29 ]
%34 = phi i8* [ %191, %190 ], [ %30, %29 ]
%35 = icmp ult i32 %33, 127
%36 = select i1 %35, i32 %33, i32 127
%37 = trunc i32 %36 to i8
%38 = zext i32 %32 to i64
%39 = getelementptr inbounds i8, i8* %2, i64 %38
store i8 %37, i8* %39
%40 = sub i32 %33, %36
%41 = add i32 %32, 1
%42 = icmp eq i32 %36, 0
br i1 %42, label %190, label %43
43: ; preds = %31
%44 = add nsw i32 %36, -1
%45 = zext i32 %44 to i64
%46 = add nuw nsw i64 %45, 1
%47 = icmp ult i32 %44, 15
%48 = add i32 %32, %36
%49 = icmp ult i32 %48, %41
%50 = select i1 %47, i1 true, i1 %49
br i1 %50, label %137, label %51
51: ; preds = %43
%52 = getelementptr i8, i8* %34, i64 1
%53 = add nsw i32 %36, -1
%54 = zext i32 %53 to i64
%55 = getelementptr i8, i8* %52, i64 %54
%56 = zext i32 %41 to i64
%57 = getelementptr i8, i8* %2, i64 %56
%58 = add nuw nsw i64 %54, %56
%59 = getelementptr i8, i8* %11, i64 %58
%60 = icmp ult i8* %34, %59
%61 = icmp ult i8* %57, %55
%62 = and i1 %60, %61
br i1 %62, label %137, label %63
63: ; preds = %51
%64 = and i64 %46, 8589934576
%65 = trunc i64 %64 to i32
%66 = add i32 %41, %65
%67 = trunc i64 %64 to i32
%68 = sub i32 %36, %67
%69 = getelementptr i8, i8* %34, i64 %64
%70 = add nsw i64 %64, -16
%71 = lshr exact i64 %70, 4
%72 = add nuw nsw i64 %71, 1
%73 = and i64 %72, 3
%74 = icmp ult i64 %70, 48
br i1 %74, label %118, label %75
75: ; preds = %63
%76 = and i64 %72, 2305843009213693948
br label %77
77: ; preds = %77, %75
%78 = phi i64 [ 0, %75 ], [ %115, %77 ]
%79 = phi i64 [ 0, %75 ], [ %116, %77 ]
%80 = trunc i64 %78 to i32
%81 = add i32 %41, %80
%82 = getelementptr i8, i8* %34, i64 %78
%83 = bitcast i8* %82 to <16 x i8>*
%84 = load <16 x i8>, <16 x i8>* %83
%85 = zext i32 %81 to i64
%86 = getelementptr inbounds i8, i8* %2, i64 %85
%87 = bitcast i8* %86 to <16 x i8>*
store <16 x i8> %84, <16 x i8>* %87
%88 = or i64 %78, 16
%89 = trunc i64 %88 to i32
%90 = add i32 %41, %89
%91 = getelementptr i8, i8* %34, i64 %88
%92 = bitcast i8* %91 to <16 x i8>*
%93 = load <16 x i8>, <16 x i8>* %92
%94 = zext i32 %90 to i64
%95 = getelementptr inbounds i8, i8* %2, i64 %94
%96 = bitcast i8* %95 to <16 x i8>*
store <16 x i8> %93, <16 x i8>* %96
%97 = or i64 %78, 32
%98 = trunc i64 %97 to i32
%99 = add i32 %41, %98
%100 = getelementptr i8, i8* %34, i64 %97
%101 = bitcast i8* %100 to <16 x i8>*
%102 = load <16 x i8>, <16 x i8>* %101
%103 = zext i32 %99 to i64
%104 = getelementptr inbounds i8, i8* %2, i64 %103
%105 = bitcast i8* %104 to <16 x i8>*
store <16 x i8> %102, <16 x i8>* %105
%106 = or i64 %78, 48
%107 = trunc i64 %106 to i32
%108 = add i32 %41, %107
%109 = getelementptr i8, i8* %34, i64 %106
%110 = bitcast i8* %109 to <16 x i8>*
%111 = load <16 x i8>, <16 x i8>* %110
%112 = zext i32 %108 to i64
%113 = getelementptr inbounds i8, i8* %2, i64 %112
%114 = bitcast i8* %113 to <16 x i8>*
store <16 x i8> %111, <16 x i8>* %114
%115 = add nuw i64 %78, 64
%116 = add i64 %79, 4
%117 = icmp eq i64 %116, %76
br i1 %117, label %118, label %77
118: ; preds = %77, %63
%119 = phi i64 [ 0, %63 ], [ %115, %77 ]
%120 = icmp eq i64 %73, 0
br i1 %120, label %135, label %121
121: ; preds = %118, %121
%122 = phi i64 [ %132, %121 ], [ %119, %118 ]
%123 = phi i64 [ %133, %121 ], [ 0, %118 ]
%124 = trunc i64 %122 to i32
%125 = add i32 %41, %124
%126 = getelementptr i8, i8* %34, i64 %122
%127 = bitcast i8* %126 to <16 x i8>*
%128 = load <16 x i8>, <16 x i8>* %127
%129 = zext i32 %125 to i64
%130 = getelementptr inbounds i8, i8* %2, i64 %129
%131 = bitcast i8* %130 to <16 x i8>*
store <16 x i8> %128, <16 x i8>* %131
%132 = add nuw i64 %122, 16
%133 = add i64 %123, 1
%134 = icmp eq i64 %133, %73
br i1 %134, label %135, label %121
135: ; preds = %121, %118
%136 = icmp eq i64 %46, %64
br i1 %136, label %190, label %137
137: ; preds = %51, %43, %135
%138 = phi i32 [ %41, %51 ], [ %41, %43 ], [ %66, %135 ]
%139 = phi i32 [ %36, %51 ], [ %36, %43 ], [ %68, %135 ]
%140 = phi i8* [ %34, %51 ], [ %34, %43 ], [ %69, %135 ]
%141 = add i32 %139, -1
%142 = and i32 %139, 3
%143 = icmp eq i32 %142, 0
br i1 %143, label %157, label %144
144: ; preds = %137, %144
%145 = phi i32 [ %154, %144 ], [ %138, %137 ]
%146 = phi i32 [ %149, %144 ], [ %139, %137 ]
%147 = phi i8* [ %150, %144 ], [ %140, %137 ]
%148 = phi i32 [ %155, %144 ], [ 0, %137 ]
%149 = add nsw i32 %146, -1
%150 = getelementptr inbounds i8, i8* %147, i64 1
%151 = load i8, i8* %147
%152 = zext i32 %145 to i64
%153 = getelementptr inbounds i8, i8* %2, i64 %152
store i8 %151, i8* %153
%154 = add i32 %145, 1
%155 = add i32 %148, 1
%156 = icmp eq i32 %155, %142
br i1 %156, label %157, label %144
157: ; preds = %144, %137
%158 = phi i8* [ undef, %137 ], [ %150, %144 ]
%159 = phi i32 [ undef, %137 ], [ %154, %144 ]
%160 = phi i32 [ %138, %137 ], [ %154, %144 ]
%161 = phi i32 [ %139, %137 ], [ %149, %144 ]
%162 = phi i8* [ %140, %137 ], [ %150, %144 ]
%163 = icmp ult i32 %141, 3
br i1 %163, label %190, label %164
164: ; preds = %157, %164
%165 = phi i32 [ %188, %164 ], [ %160, %157 ]
%166 = phi i32 [ %183, %164 ], [ %161, %157 ]
%167 = phi i8* [ %184, %164 ], [ %162, %157 ]
%168 = getelementptr inbounds i8, i8* %167, i64 1
%169 = load i8, i8* %167
%170 = zext i32 %165 to i64
%171 = getelementptr inbounds i8, i8* %2, i64 %170
store i8 %169, i8* %171
%172 = add i32 %165, 1
%173 = getelementptr inbounds i8, i8* %167, i64 2
%174 = load i8, i8* %168
%175 = zext i32 %172 to i64
%176 = getelementptr inbounds i8, i8* %2, i64 %175
store i8 %174, i8* %176
%177 = add i32 %165, 2
%178 = getelementptr inbounds i8, i8* %167, i64 3
%179 = load i8, i8* %173
%180 = zext i32 %177 to i64
%181 = getelementptr inbounds i8, i8* %2, i64 %180
store i8 %179, i8* %181
%182 = add i32 %165, 3
%183 = add nsw i32 %166, -4
%184 = getelementptr inbounds i8, i8* %167, i64 4
%185 = load i8, i8* %178
%186 = zext i32 %182 to i64
%187 = getelementptr inbounds i8, i8* %2, i64 %186
store i8 %185, i8* %187
%188 = add i32 %165, 4
%189 = icmp eq i32 %183, 0
br i1 %189, label %190, label %164
190: ; preds = %157, %164, %135, %31
%191 = phi i8* [ %34, %31 ], [ %69, %135 ], [ %158, %157 ], [ %184, %164 ]
%192 = phi i32 [ %41, %31 ], [ %66, %135 ], [ %159, %157 ], [ %188, %164 ]
%193 = icmp eq i32 %40, 0
br i1 %193, label %194, label %31
194: ; preds = %190, %27
%195 = phi i32 [ %15, %27 ], [ %192, %190 ]
%196 = call i64 @encode_rle(i8* %2, i32 %195, i32 %14, %union.RunData* %16, i32 %24)
%197 = trunc i64 %196 to i32
%198 = add i32 %195, %197
br label %201
199: ; preds = %23
%200 = add i32 %13, %14
br label %201
201: ; preds = %199, %194
%202 = phi %union.RunData* [ null, %194 ], [ %17, %199 ]
%203 = phi i32 [ %198, %194 ], [ %15, %199 ]
%204 = phi i32 [ 0, %194 ], [ %200, %199 ]
%205 = load i32, i32* %4
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i8, i8* %0, i64 %206
%208 = bitcast i8* %207 to %union.RunData*
%209 = icmp eq %union.RunData* %202, null
%210 = select i1 %209, %union.RunData* %208, %union.RunData* %202
%211 = select i1 %209, i32 0, i32 %204
store i32 1, i32* %5
%212 = add nsw i32 %205, 1
store i32 %212, i32* %4
br label %213
213: ; preds = %201, %20
%214 = phi i32 [ %22, %20 ], [ %212, %201 ]
%215 = phi %union.RunData* [ %17, %20 ], [ %210, %201 ]
%216 = phi %union.RunData* [ %16, %20 ], [ %208, %201 ]
%217 = phi i32 [ %15, %20 ], [ %203, %201 ]
%218 = phi i32 [ %21, %20 ], [ 1, %201 ]
%219 = phi i32 [ %13, %20 ], [ %211, %201 ]
%220 = icmp slt i32 %214, %1
br i1 %220, label %12, label %221
221: ; preds = %213
%222 = icmp eq i32 %219, 0
br i1 %222, label %412, label %223
223: ; preds = %221
%224 = bitcast %union.RunData* %215 to i8*
%225 = getelementptr i8, i8* %2, i64 1
br label %231
226: ; preds = %379, %386, %357
%227 = phi i8* [ %266, %357 ], [ %380, %379 ], [ %406, %386 ]
%228 = phi i32 [ %263, %357 ], [ %381, %379 ], [ %410, %386 ]
%229 = sub i32 %233, %236
%230 = icmp eq i32 %229, 0
br i1 %230, label %412, label %231
231: ; preds = %223, %226
%232 = phi i8* [ %224, %223 ], [ %227, %226 ]
%233 = phi i32 [ %219, %223 ], [ %229, %226 ]
%234 = phi i32 [ %217, %223 ], [ %228, %226 ]
%235 = icmp ult i32 %233, 127
%236 = select i1 %235, i32 %233, i32 127
%237 = trunc i32 %236 to i8
%238 = zext i32 %234 to i64
%239 = getelementptr inbounds i8, i8* %2, i64 %238
store i8 %237, i8* %239
%240 = add i32 %234, 1
%241 = add nsw i32 %236, -1
%242 = zext i32 %241 to i64
%243 = add nuw nsw i64 %242, 1
%244 = icmp ult i32 %241, 31
%245 = add i32 %234, %236
%246 = icmp ult i32 %245, %240
%247 = select i1 %244, i1 true, i1 %246
br i1 %247, label %359, label %248
248: ; preds = %231
%249 = getelementptr i8, i8* %232, i64 1
%250 = add nsw i32 %236, -1
%251 = zext i32 %250 to i64
%252 = getelementptr i8, i8* %249, i64 %251
%253 = zext i32 %240 to i64
%254 = getelementptr i8, i8* %2, i64 %253
%255 = add nuw nsw i64 %251, %253
%256 = getelementptr i8, i8* %225, i64 %255
%257 = icmp ult i8* %232, %256
%258 = icmp ult i8* %254, %252
%259 = and i1 %257, %258
br i1 %259, label %359, label %260
260: ; preds = %248
%261 = and i64 %243, 8589934560
%262 = trunc i64 %261 to i32
%263 = add i32 %240, %262
%264 = trunc i64 %261 to i32
%265 = sub i32 %236, %264
%266 = getelementptr i8, i8* %232, i64 %261
%267 = add nsw i64 %261, -32
%268 = lshr exact i64 %267, 5
%269 = add nuw nsw i64 %268, 1
%270 = and i64 %269, 3
%271 = icmp ult i64 %267, 96
br i1 %271, label %335, label %272
272: ; preds = %260
%273 = and i64 %269, 1152921504606846972
br label %274
274: ; preds = %274, %272
%275 = phi i64 [ 0, %272 ], [ %332, %274 ]
%276 = phi i64 [ 0, %272 ], [ %333, %274 ]
%277 = trunc i64 %275 to i32
%278 = add i32 %240, %277
%279 = getelementptr i8, i8* %232, i64 %275
%280 = bitcast i8* %279 to <16 x i8>*
%281 = load <16 x i8>, <16 x i8>* %280
%282 = getelementptr i8, i8* %279, i64 16
%283 = bitcast i8* %282 to <16 x i8>*
%284 = load <16 x i8>, <16 x i8>* %283
%285 = zext i32 %278 to i64
%286 = getelementptr inbounds i8, i8* %2, i64 %285
%287 = bitcast i8* %286 to <16 x i8>*
store <16 x i8> %281, <16 x i8>* %287
%288 = getelementptr inbounds i8, i8* %286, i64 16
%289 = bitcast i8* %288 to <16 x i8>*
store <16 x i8> %284, <16 x i8>* %289
%290 = or i64 %275, 32
%291 = trunc i64 %290 to i32
%292 = add i32 %240, %291
%293 = getelementptr i8, i8* %232, i64 %290
%294 = bitcast i8* %293 to <16 x i8>*
%295 = load <16 x i8>, <16 x i8>* %294
%296 = getelementptr i8, i8* %293, i64 16
%297 = bitcast i8* %296 to <16 x i8>*
%298 = load <16 x i8>, <16 x i8>* %297
%299 = zext i32 %292 to i64
%300 = getelementptr inbounds i8, i8* %2, i64 %299
%301 = bitcast i8* %300 to <16 x i8>*
store <16 x i8> %295, <16 x i8>* %301
%302 = getelementptr inbounds i8, i8* %300, i64 16
%303 = bitcast i8* %302 to <16 x i8>*
store <16 x i8> %298, <16 x i8>* %303
%304 = or i64 %275, 64
%305 = trunc i64 %304 to i32
%306 = add i32 %240, %305
%307 = getelementptr i8, i8* %232, i64 %304
%308 = bitcast i8* %307 to <16 x i8>*
%309 = load <16 x i8>, <16 x i8>* %308
%310 = getelementptr i8, i8* %307, i64 16
%311 = bitcast i8* %310 to <16 x i8>*
%312 = load <16 x i8>, <16 x i8>* %311
%313 = zext i32 %306 to i64
%314 = getelementptr inbounds i8, i8* %2, i64 %313
%315 = bitcast i8* %314 to <16 x i8>*
store <16 x i8> %309, <16 x i8>* %315
%316 = getelementptr inbounds i8, i8* %314, i64 16
%317 = bitcast i8* %316 to <16 x i8>*
store <16 x i8> %312, <16 x i8>* %317
%318 = or i64 %275, 96
%319 = trunc i64 %318 to i32
%320 = add i32 %240, %319
%321 = getelementptr i8, i8* %232, i64 %318
%322 = bitcast i8* %321 to <16 x i8>*
%323 = load <16 x i8>, <16 x i8>* %322
%324 = getelementptr i8, i8* %321, i64 16
%325 = bitcast i8* %324 to <16 x i8>*
%326 = load <16 x i8>, <16 x i8>* %325
%327 = zext i32 %320 to i64
%328 = getelementptr inbounds i8, i8* %2, i64 %327
%329 = bitcast i8* %328 to <16 x i8>*
store <16 x i8> %323, <16 x i8>* %329
%330 = getelementptr inbounds i8, i8* %328, i64 16
%331 = bitcast i8* %330 to <16 x i8>*
store <16 x i8> %326, <16 x i8>* %331
%332 = add nuw i64 %275, 128
%333 = add i64 %276, 4
%334 = icmp eq i64 %333, %273
br i1 %334, label %335, label %274
335: ; preds = %274, %260
%336 = phi i64 [ 0, %260 ], [ %332, %274 ]
%337 = icmp eq i64 %270, 0
br i1 %337, label %357, label %338
338: ; preds = %335, %338
%339 = phi i64 [ %354, %338 ], [ %336, %335 ]
%340 = phi i64 [ %355, %338 ], [ 0, %335 ]
%341 = trunc i64 %339 to i32
%342 = add i32 %240, %341
%343 = getelementptr i8, i8* %232, i64 %339
%344 = bitcast i8* %343 to <16 x i8>*
%345 = load <16 x i8>, <16 x i8>* %344
%346 = getelementptr i8, i8* %343, i64 16
%347 = bitcast i8* %346 to <16 x i8>*
%348 = load <16 x i8>, <16 x i8>* %347
%349 = zext i32 %342 to i64
%350 = getelementptr inbounds i8, i8* %2, i64 %349
%351 = bitcast i8* %350 to <16 x i8>*
store <16 x i8> %345, <16 x i8>* %351
%352 = getelementptr inbounds i8, i8* %350, i64 16
%353 = bitcast i8* %352 to <16 x i8>*
store <16 x i8> %348, <16 x i8>* %353
%354 = add nuw i64 %339, 32
%355 = add i64 %340, 1
%356 = icmp eq i64 %355, %270
br i1 %356, label %357, label %338
357: ; preds = %338, %335
%358 = icmp eq i64 %243, %261
br i1 %358, label %226, label %359
359: ; preds = %248, %231, %357
%360 = phi i32 [ %240, %248 ], [ %240, %231 ], [ %263, %357 ]
%361 = phi i32 [ %236, %248 ], [ %236, %231 ], [ %265, %357 ]
%362 = phi i8* [ %232, %248 ], [ %232, %231 ], [ %266, %357 ]
%363 = add i32 %361, -1
%364 = and i32 %361, 3
%365 = icmp eq i32 %364, 0
br i1 %365, label %379, label %366
366: ; preds = %359, %366
%367 = phi i32 [ %376, %366 ], [ %360, %359 ]
%368 = phi i32 [ %371, %366 ], [ %361, %359 ]
%369 = phi i8* [ %372, %366 ], [ %362, %359 ]
%370 = phi i32 [ %377, %366 ], [ 0, %359 ]
%371 = add nsw i32 %368, -1
%372 = getelementptr inbounds i8, i8* %369, i64 1
%373 = load i8, i8* %369
%374 = zext i32 %367 to i64
%375 = getelementptr inbounds i8, i8* %2, i64 %374
store i8 %373, i8* %375
%376 = add i32 %367, 1
%377 = add i32 %370, 1
%378 = icmp eq i32 %377, %364
br i1 %378, label %379, label %366
379: ; preds = %366, %359
%380 = phi i8* [ undef, %359 ], [ %372, %366 ]
%381 = phi i32 [ undef, %359 ], [ %376, %366 ]
%382 = phi i32 [ %360, %359 ], [ %376, %366 ]
%383 = phi i32 [ %361, %359 ], [ %371, %366 ]
%384 = phi i8* [ %362, %359 ], [ %372, %366 ]
%385 = icmp ult i32 %363, 3
br i1 %385, label %226, label %386
386: ; preds = %379, %386
%387 = phi i32 [ %410, %386 ], [ %382, %379 ]
%388 = phi i32 [ %405, %386 ], [ %383, %379 ]
%389 = phi i8* [ %406, %386 ], [ %384, %379 ]
%390 = getelementptr inbounds i8, i8* %389, i64 1
%391 = load i8, i8* %389
%392 = zext i32 %387 to i64
%393 = getelementptr inbounds i8, i8* %2, i64 %392
store i8 %391, i8* %393
%394 = add i32 %387, 1
%395 = getelementptr inbounds i8, i8* %389, i64 2
%396 = load i8, i8* %390
%397 = zext i32 %394 to i64
%398 = getelementptr inbounds i8, i8* %2, i64 %397
store i8 %396, i8* %398
%399 = add i32 %387, 2
%400 = getelementptr inbounds i8, i8* %389, i64 3
%401 = load i8, i8* %395
%402 = zext i32 %399 to i64
%403 = getelementptr inbounds i8, i8* %2, i64 %402
store i8 %401, i8* %403
%404 = add i32 %387, 3
%405 = add nsw i32 %388, -4
%406 = getelementptr inbounds i8, i8* %389, i64 4
%407 = load i8, i8* %400
%408 = zext i32 %404 to i64
%409 = getelementptr inbounds i8, i8* %2, i64 %408
store i8 %407, i8* %409
%410 = add i32 %387, 4
%411 = icmp eq i32 %405, 0
br i1 %411, label %226, label %386
412: ; preds = %226, %221
%413 = phi i32 [ %217, %221 ], [ %228, %226 ]
%414 = icmp eq i32 %218, 0
br i1 %414, label %423, label %415
415: ; preds = %3, %412
%416 = phi i32 [ %413, %412 ], [ 0, %3 ]
%417 = phi %union.RunData* [ %216, %412 ], [ %8, %3 ]
%418 = phi i32 [ %218, %412 ], [ 1, %3 ]
%419 = load i32, i32* %5
%420 = call i64 @encode_rle(i8* %2, i32 %416, i32 %418, %union.RunData* %417, i32 %419)
%421 = trunc i64 %420 to i32
%422 = add i32 %416, %421
br label %423
423: ; preds = %415, %412
%424 = phi i32 [ %422, %415 ], [ %413, %412 ]
ret i32 %424
}