int compress(unsigned char *in, int num_lines_d2, int final_len,
             unsigned char *iout) {
  unsigned char *out = iout;
  int I, len = num_lines_d2;
  for (I = 0; I < final_len; I += num_lines_d2, in += num_lines_d2) {
    int i = 0;
    while (i < len) {
      int dup_len = 0;
      while ((i + dup_len < len) && (in[i + dup_len] == in[i])) {
        dup_len++;
      }
      if ((dup_len >= 1) && (in[i] == 0)) {
        while (dup_len >= 128) {
          *out++ = 0x00;
          i += 128;
          dup_len -= 128;
        }
        if (dup_len >= 1) {
          *out++ = dup_len;
          i += dup_len;
        }
      } else if (dup_len >= 2) {
        while (dup_len >= 64) {
          *out++ = 0x80;
          *out++ = in[i];
          i += 64;
          dup_len -= 64;
        }
        if (dup_len >= 2) {
          *out++ = dup_len + 0x80;
          *out++ = in[i];
          i += dup_len;
        }
      } else {
        int lit_len = -1;
        int add_more = 1;
        while (add_more) {
          lit_len++;
          if (i + lit_len == len)
            add_more = 0;
          if (i + lit_len < len - 3) {
            char a = in[i + lit_len + 0];
            char b = in[i + lit_len + 1];
            char c = in[i + lit_len + 2];
            if ((a == b) && (b == 0))
              add_more = 0;
            if ((a == b) && (b == c))
              add_more = 0;
          }
        }
        while (lit_len >= 64) {
          int j;
          *out++ = 0xc0;
          for (j = i; j < i + 64; j++) {
            *out++ = in[j];
          }
          i += 64;
          lit_len -= 64;
        }
        if (lit_len) {
          int j;
          *out++ = lit_len + 0xc0;
          for (j = i; j < i + lit_len; j++) {
            *out++ = in[j];
          }
          i += lit_len;
        }
      }
    }
  }
  return out - iout;
}


x86 assembly (clang, -O0):
<compress>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14da <compress+0x3da>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14b6 <compress+0x3b6>
movl   $0x0,-0x30(%rbp)
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x45(%rbp)
jge    1186 <compress+0x86>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
test   $0x1,%al
jne    1196 <compress+0x96>
jmp    11a4 <compress+0xa4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    114d <compress+0x4d>
cmpl   $0x1,-0x30(%rbp)
jl     1230 <compress+0x130>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1230 <compress+0x130>
jmp    11c8 <compress+0xc8>
cmpl   $0x80,-0x30(%rbp)
jl     1202 <compress+0x102>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x0,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x80,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x80,%eax
mov    %eax,-0x30(%rbp)
jmp    11c8 <compress+0xc8>
cmpl   $0x1,-0x30(%rbp)
jl     122b <compress+0x12b>
mov    -0x30(%rbp),%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    14b1 <compress+0x3b1>
cmpl   $0x2,-0x30(%rbp)
jl     12dd <compress+0x1dd>
jmp    123f <compress+0x13f>
cmpl   $0x40,-0x30(%rbp)
jl     128e <compress+0x18e>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0x80,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x40,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x40,%eax
mov    %eax,-0x30(%rbp)
jmp    123f <compress+0x13f>
cmpl   $0x2,-0x30(%rbp)
jl     12d8 <compress+0x1d8>
mov    -0x30(%rbp),%eax
add    $0x80,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    14ac <compress+0x3ac>
movl   $0xffffffff,-0x34(%rbp)
movl   $0x1,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
je     13bf <compress+0x2bf>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    1314 <compress+0x214>
movl   $0x0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x34(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    13ba <compress+0x2ba>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x39(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x3a(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x3b(%rbp)
movsbl -0x39(%rbp),%eax
movsbl -0x3a(%rbp),%ecx
cmp    %ecx,%eax
jne    138e <compress+0x28e>
movsbl -0x3a(%rbp),%eax
cmp    $0x0,%eax
jne    138e <compress+0x28e>
movl   $0x0,-0x38(%rbp)
movsbl -0x39(%rbp),%eax
movsbl -0x3a(%rbp),%ecx
cmp    %ecx,%eax
jne    13b5 <compress+0x2b5>
movsbl -0x3a(%rbp),%eax
movsbl -0x3b(%rbp),%ecx
cmp    %ecx,%eax
jne    13b5 <compress+0x2b5>
movl   $0x0,-0x38(%rbp)
jmp    13ba <compress+0x2ba>
jmp    12eb <compress+0x1eb>
jmp    13c4 <compress+0x2c4>
cmpl   $0x40,-0x34(%rbp)
jl     1438 <compress+0x338>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movb   $0xc0,(%rax)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x40,%ecx
cmp    %ecx,%eax
jge    1421 <compress+0x321>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13e6 <compress+0x2e6>
mov    -0x2c(%rbp),%eax
add    $0x40,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
sub    $0x40,%eax
mov    %eax,-0x34(%rbp)
jmp    13c4 <compress+0x2c4>
cmpl   $0x0,-0x34(%rbp)
je     14a7 <compress+0x3a7>
mov    -0x34(%rbp),%eax
add    $0xc0,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    149e <compress+0x39e>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1463 <compress+0x363>
mov    -0x34(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    14ac <compress+0x3ac>
jmp    14b1 <compress+0x3b1>
jmp    113a <compress+0x3a>
jmp    14bb <compress+0x3bb>
mov    -0xc(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    1127 <compress+0x27>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    %rcx,%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<compress>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,%r15
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
mov    %edx,0x18(%rsp)
test   %edx,%edx
jle    1767 <compress+0x657>
lea    -0x3(%rsi),%eax
movslq %esi,%rcx
movslq %eax,%r14
lea    0x100(%rdi),%rax
mov    %rax,0x28(%rsp)
mov    %rcx,0x10(%rsp)
neg    %ecx
mov    %rcx,0x60(%rsp)
lea    0x70(%rdi),%rax
mov    %rax,0x30(%rsp)
movdqa 0xe99(%rip),%xmm2
xor    %ecx,%ecx
mov    %rdi,%rbp
mov    0x20(%rsp),%r15
xor    %edx,%edx
mov    %rsi,0x8(%rsp)
mov    %rdi,(%rsp)
jmp    11ab <compress+0x9b>
xchg   %ax,%ax
mov    0x1c(%rsp),%edx
add    %esi,%edx
mov    0x10(%rsp),%rax
add    %rax,%rbp
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
add    %rax,0x28(%rsp)
add    %rax,0x30(%rsp)
cmp    0x18(%rsp),%edx
jge    1767 <compress+0x657>
test   %esi,%esi
mov    %rcx,0x40(%rsp)
mov    %edx,0x1c(%rsp)
jle    1180 <compress+0x70>
imul   0x10(%rsp),%rcx
lea    0x40(%rcx),%rax
mov    %rax,0x50(%rsp)
mov    %rcx,0x58(%rsp)
lea    (%rcx,%rdi,1),%rax
add    $0x1,%rax
mov    %rax,0x38(%rsp)
xor    %r13d,%r13d
jmp    11f5 <compress+0xe5>
mov    %r9d,%r13d
mov    %r10,%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %esi,%r13d
jge    1180 <compress+0x70>
cmp    %esi,%r13d
jge    1310 <compress+0x200>
mov    %r13d,%edx
movslq %r13d,%r11
lea    (%r11,%rbp,1),%r8
mov    0x0(%rbp,%r11,1),%bl
mov    %esi,%r12d
sub    %r13d,%r12d
mov    0x10(%rsp),%rax
sub    %r11,%rax
xor    %edi,%edi
nopl   (%rax)
lea    (%rdx,%rdi,1),%ecx
movslq %ecx,%rcx
cmp    %bl,0x0(%rbp,%rcx,1)
jne    1240 <compress+0x130>
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1220 <compress+0x110>
test   %r12d,%r12d
jne    124c <compress+0x13c>
jmp    1310 <compress+0x200>
nop
mov    %edi,%r12d
test   %r12d,%r12d
je     1310 <compress+0x200>
cmpb   $0x0,0x0(%rbp,%r11,1)
je     150b <compress+0x3fb>
cmp    $0x1,%r12d
jbe    1310 <compress+0x200>
cmp    $0x3f,%r12d
jle    157e <compress+0x46e>
mov    %r12d,%r9d
sub    $0x7f,%r9d
mov    $0x0,%eax
cmovb  %eax,%r9d
add    $0x3f,%r9d
cmp    $0x1c0,%r9d
jb     12c1 <compress+0x1b1>
mov    %r12d,%edx
sub    $0x7f,%edx
cmovb  %eax,%edx
add    $0x3f,%edx
shr    $0x6,%edx
mov    %rdx,%rcx
shl    $0x6,%rcx
add    %r11,%rcx
add    0x38(%rsp),%rcx
cmp    %rcx,%r15
jae    16ad <compress+0x59d>
lea    (%r15,%rdx,2),%rcx
add    $0x2,%rcx
cmp    %rcx,%r8
jae    16ad <compress+0x59d>
mov    %r11,%r13
mov    %r15,%rcx
nopw   0x0(%rax,%rax,1)
mov    %r12d,%eax
movb   $0x80,(%rcx)
movzbl 0x0(%rbp,%r13,1),%edx
mov    %dl,0x1(%rcx)
add    $0x2,%rcx
add    $0x40,%r13
lea    -0x40(%rax),%r12d
cmp    $0x7f,%eax
ja     12d0 <compress+0x1c0>
mov    %rcx,%r15
cmp    $0x2,%r12d
jge    1587 <compress+0x477>
jmp    15a2 <compress+0x492>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %r13d,%rcx
mov    0x60(%rsp),%rax
lea    (%rax,%r13,1),%r8d
xor    %r10d,%r10d
mov    %rcx,%rdi
cmp    %r14,%rdi
jge    135c <compress+0x24c>
jmp    133d <compress+0x22d>
nopl   0x0(%rax)
add    $0xffffffff,%r10d
add    $0x1,%rdi
cmp    %r14,%rdi
jge    135c <compress+0x24c>
mov    0x1(%rbp,%rdi,1),%al
cmp    %al,0x0(%rbp,%rdi,1)
sete   %bl
test   %al,%al
sete   %dl
cmp    0x2(%rbp,%rdi,1),%al
sete   %al
test   %dl,%bl
jne    1361 <compress+0x251>
and    %al,%bl
jne    1361 <compress+0x251>
cmp    %r10d,%r8d
jne    1330 <compress+0x220>
mov    %r10d,%eax
not    %eax
neg    %r10d
cmp    $0x3f,%eax
jl     1470 <compress+0x360>
mov    0x58(%rsp),%rax
lea    (%rax,%rcx,1),%r8
mov    0x50(%rsp),%rax
lea    (%rax,%rcx,1),%r9
xor    %r11d,%r11d
mov    (%rsp),%rdi
jmp    13d5 <compress+0x2c5>
nopl   (%rax)
movups 0x0(%rbp,%rcx,1),%xmm0
movups %xmm0,0x1(%r15)
movups 0x10(%rbp,%rcx,1),%xmm0
movups %xmm0,0x11(%r15)
movups 0x20(%rbp,%rcx,1),%xmm0
movups %xmm0,0x21(%r15)
movdqu 0x30(%rbp,%rcx,1),%xmm0
movdqu %xmm0,0x31(%r15)
mov    %r12,%r15
lea    -0x40(%r10),%eax
add    $0x1,%r11
mov    %r13,%rcx
cmp    $0x7f,%r10d
mov    %eax,%r10d
jle    1477 <compress+0x367>
mov    %r11,%rax
shl    $0x6,%rax
movb   $0xc0,(%r15)
lea    0x40(%rcx),%r13
lea    0x1(%r15),%rbx
lea    (%r9,%rax,1),%rdx
add    %rdi,%rdx
lea    0x41(%r15),%r12
cmp    %rdx,%rbx
jae    1390 <compress+0x280>
add    %r8,%rax
add    %rdi,%rax
cmp    %r12,%rax
jae    1390 <compress+0x280>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x0(%rbp,%rcx,1),%eax
mov    %al,(%rbx)
movzbl 0x1(%rbp,%rcx,1),%eax
mov    %al,0x1(%rbx)
movzbl 0x2(%rbp,%rcx,1),%eax
mov    %al,0x2(%rbx)
movzbl 0x3(%rbp,%rcx,1),%eax
mov    %al,0x3(%rbx)
movzbl 0x4(%rbp,%rcx,1),%eax
mov    %al,0x4(%rbx)
movzbl 0x5(%rbp,%rcx,1),%eax
mov    %al,0x5(%rbx)
movzbl 0x6(%rbp,%rcx,1),%eax
mov    %al,0x6(%rbx)
movzbl 0x7(%rbp,%rcx,1),%eax
mov    %al,0x7(%rbx)
add    $0x8,%rcx
add    $0x8,%rbx
cmp    %r13,%rcx
jl     1410 <compress+0x300>
mov    %rbx,%r15
jmp    13bd <compress+0x2ad>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r10d,%eax
mov    (%rsp),%rdi
test   %eax,%eax
je     11f0 <compress+0xe0>
lea    -0x40(%rax),%ecx
mov    %cl,(%r15)
lea    (%rax,%r13,1),%r9d
lea    0x1(%r15),%r10
test   %eax,%eax
jle    11de <compress+0xce>
movslq %r13d,%rcx
movslq %r9d,%rdx
lea    0x1(%rcx),%rax
cmp    %rdx,%rax
mov    %rdx,%r11
cmovg  %rax,%r11
sub    %rcx,%r11
cmp    $0x20,%r11
jb     1680 <compress+0x570>
cmp    %rdx,%rax
cmovle %rdx,%rax
lea    (%rax,%rbp,1),%rsi
cmp    %rsi,%r10
jae    14dd <compress+0x3cd>
sub    %rcx,%rax
add    %r15,%rax
add    $0x1,%rax
lea    (%rcx,%rbp,1),%rsi
cmp    %rax,%rsi
jb     1680 <compress+0x570>
mov    %r11,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rsi
mov    %rsi,%rax
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r12d
and    $0x3,%r12d
cmp    $0x60,%rsi
jae    15ab <compress+0x49b>
xor    %esi,%esi
jmp    1625 <compress+0x515>
cmp    $0x80,%r12d
jl     1570 <compress+0x460>
cmp    $0xff,%r12d
mov    $0xff,%eax
cmovl  %r12d,%eax
neg    %eax
lea    (%r12,%rax,1),%ebx
add    $0x7f,%ebx
mov    %rbx,0x48(%rsp)
shr    $0x7,%ebx
lea    0x1(%rbx),%rdx
mov    %r15,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
movdqa 0xab5(%rip),%xmm2
mov    0x8(%rsp),%rsi
add    %rbx,%r15
add    $0x1,%r15
mov    0x48(%rsp),%rax
and    $0xffffff80,%eax
add    %eax,%r13d
add    $0x80,%r13d
sub    %eax,%r12d
add    $0xffffff80,%r12d
test   %r12d,%r12d
jle    15a2 <compress+0x492>
mov    %r12b,(%r15)
add    $0x1,%r15
jmp    159f <compress+0x48f>
mov    %edx,%r13d
cmp    $0x2,%r12d
jl     15a2 <compress+0x492>
mov    %r12d,%eax
xor    $0x80,%al
mov    %al,(%r15)
movslq %r13d,%r13
mov    0x0(%rbp,%r13,1),%al
mov    %al,0x1(%r15)
add    $0x2,%r15
add    %r12d,%r13d
mov    (%rsp),%rdi
jmp    11f0 <compress+0xe0>
and    $0xfffffffffffffffc,%rax
mov    0x30(%rsp),%rsi
lea    (%rsi,%rcx,1),%rbx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups -0x70(%rbx,%rsi,1),%xmm0
movups -0x60(%rbx,%rsi,1),%xmm1
movups %xmm0,0x1(%r15,%rsi,1)
movups %xmm1,0x11(%r15,%rsi,1)
movups -0x50(%rbx,%rsi,1),%xmm0
movups -0x40(%rbx,%rsi,1),%xmm1
movups %xmm0,0x21(%r15,%rsi,1)
movups %xmm1,0x31(%r15,%rsi,1)
movups -0x30(%rbx,%rsi,1),%xmm0
movups -0x20(%rbx,%rsi,1),%xmm1
movups %xmm0,0x41(%r15,%rsi,1)
movups %xmm1,0x51(%r15,%rsi,1)
movdqu -0x10(%rbx,%rsi,1),%xmm0
movdqu (%rbx,%rsi,1),%xmm1
movdqu %xmm0,0x61(%r15,%rsi,1)
movdqu %xmm1,0x71(%r15,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rax
jne    15c0 <compress+0x4b0>
test   %r12,%r12
je     165f <compress+0x54f>
lea    (%r15,%rsi,1),%rax
add    $0x11,%rax
shl    $0x5,%r12
add    %rcx,%rsi
add    %rbp,%rsi
xor    %ebx,%ebx
xchg   %ax,%ax
movdqu (%rsi,%rbx,1),%xmm0
movdqu 0x10(%rsi,%rbx,1),%xmm1
movdqu %xmm0,-0x10(%rax,%rbx,1)
movdqu %xmm1,(%rax,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r12
jne    1640 <compress+0x530>
add    %r8,%r10
cmp    %r8,%r11
jne    1677 <compress+0x567>
mov    %r9d,%r13d
mov    %r10,%r15
mov    0x8(%rsp),%rsi
jmp    11f0 <compress+0xe0>
add    %r8,%rcx
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rsi
mov    %r10,%r15
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%rcx,1),%eax
mov    %al,(%r15)
add    $0x1,%rcx
add    $0x1,%r15
cmp    %rdx,%rcx
jl     1690 <compress+0x580>
mov    %r9d,%r13d
jmp    11f0 <compress+0xe0>
shr    $0x6,%r9d
add    $0x1,%r9d
mov    %r9d,%r8d
and    $0xfffffff8,%r8d
mov    %r8,%r13
shl    $0x6,%r13
add    %r11,%r13
lea    (%r15,%r8,2),%rcx
mov    %r8d,%edi
shl    $0x6,%edi
sub    %edi,%r12d
add    0x28(%rsp),%r11
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movzbl -0x100(%r11),%ebx
ff
movzbl -0x80(%r11),%edx
movzbl (%r11),%r10d
movzbl -0x40(%r11),%eax
shl    $0x8,%eax
or     %edx,%eax
movzbl -0xc0(%r11),%edx
ff
shl    $0x8,%edx
or     %ebx,%edx
movd   %edx,%xmm0
pinsrw $0x1,%eax,%xmm0
movzbl 0x80(%r11),%edx
movzbl 0x40(%r11),%eax
shl    $0x8,%eax
or     %r10d,%eax
pinsrw $0x2,%eax,%xmm0
movzbl 0xc0(%r11),%eax
shl    $0x8,%eax
or     %edx,%eax
pinsrw $0x3,%eax,%xmm0
movdqa %xmm2,%xmm1
punpcklbw %xmm0,%xmm1
movdqu %xmm1,(%r15,%rdi,2)
add    $0x8,%rdi
add    $0x200,%r11
cmp    %rdi,%r8
jne    16e0 <compress+0x5d0>
cmp    %r9,%r8
jne    12d0 <compress+0x1c0>
jmp    12f0 <compress+0x1e0>
sub    0x20(%rsp),%r15d
mov    %r15d,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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