#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 */
void *get_byte(int);
int get_long(int);
int get_word(int);
int unlzss(unsigned char *out, int a2, int a3) {
  int a1;
  int d0, d1, d2, d3, d4, d6;
  int common_distances;
  unsigned char *copy_from;
  a1 = a3 + 20;
  d4 = get_word(a3);
  a3 = a3 + 3;
  common_distances = a3;
  *out++ = get_byte(a1++);
loc_cf6e:
  d0 = get_long(a2);
  a2 = a2 + 4;
  d1 = 0x1f;
  goto loc_cf7a;
loc_cf74:
  *out++ = get_byte(a1++);
loc_cf76:
  d1--;
  if (d1 < 0) {
    goto loc_cf6e;
  }
loc_cf7a:
  if (d0 & (1 << d1)) {
    goto loc_cf74;
  }
  d1--;
  if (d1 < 0) {
    goto loc_cf98;
  }
loc_cf82:
  if (d0 & (1 << d1)) {
    goto loc_cfa4;
  }
  d1--;
  if (d1 < 0) {
    goto loc_cf9e;
  }
loc_cf8a:
  d3 = get_byte(a1);
  a1++;
  if ((d0 & (1 << d1)) == 0) {
    goto loc_cfe6;
  }
  d3 = d3 | 0x100;
  goto loc_cfe6;
loc_cf98:
  d0 = get_long(a2);
  a2 = a2 + 4;
  d1 = 0x1f;
  goto loc_cf82;
loc_cf9e:
  d0 = get_long(a2);
  a2 = a2 + 4;
  d1 = 0x1f;
  goto loc_cf8a;
loc_cfa4:
  d1--;
  if (d1 < 0) {
    goto loc_cfcc;
  }
loc_cfa8:
  d2 = 0;
  d6 = 1;
loc_cfac:
  if (d0 & (1 << d1)) {
    goto loc_cfd2;
  }
  d1--;
  if (d1 < 0) {
    goto loc_cfc6;
  }
loc_cfb4:
  if ((d0 & (1 << d1)) == 0) {
    goto loc_cfba;
  }
  d2 = d2 + d6;
loc_cfba:
  d6 = d6 << 1;
  d1--;
  if (d1 >= 0) {
    goto loc_cfac;
  }
  d0 = get_long(a2);
  a2 = a2 + 4;
  d1 = 0x1f;
  goto loc_cfac;
loc_cfc6:
  d0 = get_long(a2);
  a2 = a2 + 4;
  d1 = 0x1f;
  goto loc_cfb4;
loc_cfcc:
  d0 = get_long(a2);
  a2 = a2 + 4;
  d1 = 0x1f;
  goto loc_cfa8;
loc_cfd2:
  d2 = d2 + d6;
  if (d2 == 16) {
    goto loc_d026;
  }
  d3 = get_byte(common_distances + d2);
  if (d4 & (1 << d2)) {
    d3 = d3 | 0x100;
  }
loc_cfe6:
  d1--;
  if (d1 < 0) {
    goto loc_d00e;
  }
loc_cfea:
  d2 = 0;
  d6 = 1;
loc_cfee:
  if (d0 & (1 << d1)) {
    goto loc_d014;
  }
  d1 = d1 - 1;
  if (d1 < 0) {
    goto loc_d008;
  }
loc_cff6:
  if ((d0 & (1 << d1))) {
    d2 = d2 + d6;
  }
  d6 = d6 << 1;
  d1--;
  if (d1 >= 0) {
    goto loc_cfee;
  }
  d0 = get_long(a2);
  a2 = a2 + 4;
  d1 = 0x1f;
  goto loc_cfee;
loc_d008:
  d0 = get_long(a2);
  a2 = a2 + 4;
  d1 = 0x1f;
  goto loc_cff6;
loc_d00e:
  d0 = get_long(a2);
  a2 = a2 + 4;
  d1 = 0x1f;
  goto loc_cfea;
loc_d014:
  d2 = d2 + d6 + 1;
  copy_from = out - d3;
  while (d2 >= 0) {
    *out++ = *copy_from++;
    d2--;
  }
  goto loc_cf76;
loc_d026:
  return 0;
}


x86 assembly (clang, -O0):
<unlzss>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%eax
add    $0x14,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%edi
call   1050 <get_word@plt>
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x14(%rbp),%edi
mov    %edi,%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
call   1040 <get_byte@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%edi
call   1030 <get_long@plt>
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1f,-0x1c(%rbp)
jmp    11e8 <unlzss+0xb8>
mov    -0x14(%rbp),%edi
mov    %edi,%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
call   1040 <get_byte@plt>
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    11e3 <unlzss+0xb3>
jmp    1188 <unlzss+0x58>
jmp    11e8 <unlzss+0xb8>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1207 <unlzss+0xd7>
jmp    11a8 <unlzss+0x78>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    121f <unlzss+0xef>
jmp    12a3 <unlzss+0x173>
jmp    1224 <unlzss+0xf4>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1243 <unlzss+0x113>
jmp    12e3 <unlzss+0x1b3>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    125b <unlzss+0x12b>
jmp    12c3 <unlzss+0x193>
jmp    1260 <unlzss+0x130>
mov    -0x14(%rbp),%edi
call   1040 <get_byte@plt>
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
jne    1293 <unlzss+0x163>
jmp    1443 <unlzss+0x313>
mov    -0x24(%rbp),%eax
or     $0x100,%eax
mov    %eax,-0x24(%rbp)
jmp    1443 <unlzss+0x313>
mov    -0xc(%rbp),%edi
call   1030 <get_long@plt>
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1f,-0x1c(%rbp)
jmp    1224 <unlzss+0xf4>
mov    -0xc(%rbp),%edi
call   1030 <get_long@plt>
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1f,-0x1c(%rbp)
jmp    1260 <unlzss+0x130>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    12fb <unlzss+0x1cb>
jmp    13d3 <unlzss+0x2a3>
jmp    1300 <unlzss+0x1d0>
movl   $0x0,-0x20(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     132d <unlzss+0x1fd>
jmp    13f3 <unlzss+0x2c3>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    1345 <unlzss+0x215>
jmp    13b3 <unlzss+0x283>
jmp    134a <unlzss+0x21a>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
jne    1369 <unlzss+0x239>
jmp    1372 <unlzss+0x242>
mov    -0x20(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     1393 <unlzss+0x263>
jmp    130e <unlzss+0x1de>
mov    -0xc(%rbp),%edi
call   1030 <get_long@plt>
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1f,-0x1c(%rbp)
jmp    130e <unlzss+0x1de>
mov    -0xc(%rbp),%edi
call   1030 <get_long@plt>
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1f,-0x1c(%rbp)
jmp    134a <unlzss+0x21a>
mov    -0xc(%rbp),%edi
call   1030 <get_long@plt>
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1f,-0x1c(%rbp)
jmp    1300 <unlzss+0x1d0>
mov    -0x20(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x10,-0x20(%rbp)
jne    140b <unlzss+0x2db>
jmp    15ad <unlzss+0x47d>
mov    -0x30(%rbp),%edi
add    -0x20(%rbp),%edi
call   1040 <get_byte@plt>
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     143e <unlzss+0x30e>
mov    -0x24(%rbp),%eax
or     $0x100,%eax
mov    %eax,-0x24(%rbp)
jmp    1443 <unlzss+0x313>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    145b <unlzss+0x32b>
jmp    152e <unlzss+0x3fe>
jmp    1460 <unlzss+0x330>
movl   $0x0,-0x20(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     148d <unlzss+0x35d>
jmp    154e <unlzss+0x41e>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    14a5 <unlzss+0x375>
jmp    150e <unlzss+0x3de>
jmp    14aa <unlzss+0x37a>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     14cd <unlzss+0x39d>
mov    -0x20(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     14ee <unlzss+0x3be>
jmp    146e <unlzss+0x33e>
mov    -0xc(%rbp),%edi
call   1030 <get_long@plt>
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1f,-0x1c(%rbp)
jmp    146e <unlzss+0x33e>
mov    -0xc(%rbp),%edi
call   1030 <get_long@plt>
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1f,-0x1c(%rbp)
jmp    14aa <unlzss+0x37a>
mov    -0xc(%rbp),%edi
call   1030 <get_long@plt>
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0xc(%rbp)
movl   $0x1f,-0x1c(%rbp)
jmp    1460 <unlzss+0x330>
mov    -0x20(%rbp),%eax
add    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     15a8 <unlzss+0x478>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    156e <unlzss+0x43e>
jmp    11cb <unlzss+0x9b>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<unlzss>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %edx,%r13d
mov    %esi,0xc(%rsp)
mov    %rdi,%r12
lea    0x14(%r13),%ebp
mov    %edx,%edi
call   1050 <get_word@plt>
mov    %eax,0x20(%rsp)
lea    0x3(%r13),%eax
mov    %rax,0x30(%rsp)
add    $0x15,%r13d
mov    %ebp,%edi
call   1040 <get_byte@plt>
mov    %al,(%r12)
add    $0x1,%r12
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
call   1030 <get_long@plt>
mov    %eax,%r9d
add    $0x4,%ebx
mov    %ebx,0xc(%rsp)
mov    $0x1f,%r15d
jmp    11c9 <unlzss+0x99>
nopl   (%rax)
lea    0x1(%r13),%ebx
mov    %r13d,%edi
mov    %r9d,%ebp
call   1040 <get_byte@plt>
mov    %ebp,%r9d
mov    %al,(%r12)
add    $0x1,%r12
mov    %ebx,%r13d
lea    -0x1(%r15),%eax
test   %r15d,%r15d
mov    %eax,%r15d
jle    1180 <unlzss+0x50>
bt     %r15d,%r9d
jb     11a0 <unlzss+0x70>
mov    %r15d,%eax
sub    $0x1,%eax
jae    11fc <unlzss+0xcc>
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
call   1030 <get_long@plt>
mov    %eax,%r9d
add    $0x4,%ebx
mov    %ebx,0xc(%rsp)
mov    $0x1e,%r15d
test   %eax,%eax
jns    12dc <unlzss+0x1ac>
jmp    1229 <unlzss+0xf9>
add    $0xfffffffe,%r15d
bt     %eax,%r9d
jae    12bd <unlzss+0x18d>
test   %eax,%eax
jne    1229 <unlzss+0xf9>
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
call   1030 <get_long@plt>
mov    %eax,%r9d
add    $0x4,%ebx
mov    %ebx,0xc(%rsp)
mov    $0x1f,%r15d
mov    $0x1,%r14d
bt     %r15d,%r9d
jb     130e <unlzss+0x1de>
mov    %r13,0x10(%rsp)
xor    %r13d,%r13d
mov    $0x1,%r14d
jmp    1260 <unlzss+0x130>
nopl   0x0(%rax)
add    %ebp,%r13d
add    %r14d,%r14d
bt     %r15d,%r9d
jb     12fc <unlzss+0x1cc>
test   %r15d,%r15d
jle    1270 <unlzss+0x140>
add    $0xffffffff,%r15d
jmp    128b <unlzss+0x15b>
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
call   1030 <get_long@plt>
mov    %eax,%r9d
add    $0x4,%ebx
mov    %ebx,0xc(%rsp)
mov    $0x1f,%r15d
bt     %r15d,%r9d
mov    %r14d,%ebp
mov    $0x0,%eax
cmovae %eax,%ebp
sub    $0x1,%r15d
jae    1250 <unlzss+0x120>
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
call   1030 <get_long@plt>
mov    %eax,%r9d
add    $0x4,%ebx
mov    %ebx,0xc(%rsp)
mov    $0x1f,%r15d
jmp    1250 <unlzss+0x120>
test   %eax,%eax
jne    12dc <unlzss+0x1ac>
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
call   1030 <get_long@plt>
mov    %eax,%r9d
add    $0x4,%ebx
mov    %ebx,0xc(%rsp)
mov    $0x1f,%r15d
mov    %r13d,%edi
mov    %r9d,%ebx
call   1040 <get_byte@plt>
mov    %ebx,%r9d
mov    %rax,0x28(%rsp)
add    $0x1,%r13d
mov    %ebx,0x1c(%rsp)
mov    %r15d,%ebx
jmp    1335 <unlzss+0x205>
add    %r13d,%r14d
cmp    $0x10,%r14d
mov    0x10(%rsp),%r13
je     1621 <unlzss+0x4f1>
mov    %r15d,%ebx
mov    0x30(%rsp),%rax
lea    (%rax,%r14,1),%edi
mov    %r9d,%ebp
call   1040 <get_byte@plt>
mov    %ebp,%r9d
mov    %rax,0x28(%rsp)
mov    %r14d,%r15d
mov    0x20(%rsp),%eax
mov    %eax,0x1c(%rsp)
mov    $0x1,%ebp
mov    %r15d,%ecx
shl    %cl,%ebp
mov    %ebx,%r15d
sub    $0x1,%r15d
jae    1363 <unlzss+0x233>
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
call   1030 <get_long@plt>
mov    %eax,%r9d
add    $0x4,%ebx
mov    %ebx,0xc(%rsp)
mov    $0x1f,%r15d
bt     %r15d,%r9d
mov    %r13,0x10(%rsp)
mov    %ebp,0x24(%rsp)
jae    142a <unlzss+0x2fa>
mov    $0x1,%r13d
xor    %r14d,%r14d
add    %r13d,%r14d
inc    %r14d
js     14ad <unlzss+0x37d>
mov    0x24(%rsp),%edx
and    0x1c(%rsp),%edx
movslq 0x28(%rsp),%rax
mov    %rax,%rcx
or     $0x100,%rcx
test   %edx,%edx
cmove  %rax,%rcx
mov    %r12,%rax
sub    %rcx,%rax
cmp    $0x1f,%r14d
jb     13de <unlzss+0x2ae>
mov    %r14d,%edx
mov    %rdx,%rsi
sub    %rcx,%rsi
add    %r12,%rsi
add    $0x1,%rsi
cmp    %rsi,%r12
jae    152e <unlzss+0x3fe>
lea    (%r12,%rdx,1),%rsi
add    $0x1,%rsi
cmp    %rsi,%rax
jae    152e <unlzss+0x3fe>
mov    0x10(%rsp),%r13
lea    0x1(%r14),%ecx
test   $0x7,%cl
je     14b7 <unlzss+0x387>
lea    0x1(%r14),%ecx
movzbl %cl,%ecx
and    $0x7,%ecx
xor    %edx,%edx
nopl   0x0(%rax)
movzbl (%rax,%rdx,1),%ebx
mov    %bl,(%r12,%rdx,1)
add    $0x1,%rdx
cmp    %edx,%ecx
jne    1400 <unlzss+0x2d0>
add    %rdx,%rax
add    %rdx,%r12
mov    %r14d,%ecx
sub    %edx,%ecx
cmp    $0x7,%r14d
jb     11bd <unlzss+0x8d>
jmp    14c4 <unlzss+0x394>
xor    %r14d,%r14d
mov    $0x1,%r13d
jmp    1450 <unlzss+0x320>
cs nopw 0x0(%rax,%rax,1)
nop
add    %ebx,%r14d
add    %r13d,%r13d
bt     %r15d,%r9d
jb     137f <unlzss+0x24f>
test   %r15d,%r15d
jle    1460 <unlzss+0x330>
add    $0xffffffff,%r15d
jmp    147b <unlzss+0x34b>
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%ebx
mov    %ebx,%edi
call   1030 <get_long@plt>
mov    %eax,%r9d
add    $0x4,%ebx
mov    %ebx,0xc(%rsp)
mov    $0x1f,%r15d
bt     %r15d,%r9d
mov    %r13d,%ebx
mov    $0x0,%eax
cmovae %eax,%ebx
sub    $0x1,%r15d
jae    1440 <unlzss+0x310>
mov    0xc(%rsp),%ebp
mov    %ebp,%edi
call   1030 <get_long@plt>
mov    %eax,%r9d
add    $0x4,%ebp
mov    %ebp,0xc(%rsp)
mov    $0x1f,%r15d
jmp    1440 <unlzss+0x310>
mov    0x10(%rsp),%r13
jmp    11bd <unlzss+0x8d>
mov    %r14d,%ecx
cmp    $0x7,%r14d
jb     11bd <unlzss+0x8d>
add    $0x1,%ecx
xor    %edx,%edx
nopl   0x0(%rax)
movzbl (%rax,%rdx,1),%ebx
mov    %bl,(%r12,%rdx,1)
movzbl 0x1(%rax,%rdx,1),%ebx
mov    %bl,0x1(%r12,%rdx,1)
movzbl 0x2(%rax,%rdx,1),%ebx
mov    %bl,0x2(%r12,%rdx,1)
movzbl 0x3(%rax,%rdx,1),%ebx
mov    %bl,0x3(%r12,%rdx,1)
movzbl 0x4(%rax,%rdx,1),%ebx
mov    %bl,0x4(%r12,%rdx,1)
movzbl 0x5(%rax,%rdx,1),%ebx
mov    %bl,0x5(%r12,%rdx,1)
movzbl 0x6(%rax,%rdx,1),%ebx
mov    %bl,0x6(%r12,%rdx,1)
movzbl 0x7(%rax,%rdx,1),%ebx
mov    %bl,0x7(%r12,%rdx,1)
add    $0x8,%rdx
cmp    %edx,%ecx
jne    14d0 <unlzss+0x3a0>
add    %rdx,%r12
jmp    11bd <unlzss+0x8d>
neg    %rcx
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rsi
mov    %rsi,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x60,%rsi
jae    1562 <unlzss+0x432>
xor    %ebx,%ebx
mov    0x10(%rsp),%r13
jmp    15e0 <unlzss+0x4b0>
and    $0xfffffffffffffffc,%rdi
lea    (%r12,%rcx,1),%rsi
add    $0x70,%rsi
xor    %ebx,%ebx
mov    0x10(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x70(%rsi,%rbx,1),%xmm0
movups -0x60(%rsi,%rbx,1),%xmm1
movups %xmm0,(%r12,%rbx,1)
movups %xmm1,0x10(%r12,%rbx,1)
movups -0x50(%rsi,%rbx,1),%xmm0
movups -0x40(%rsi,%rbx,1),%xmm1
movups %xmm0,0x20(%r12,%rbx,1)
movups %xmm1,0x30(%r12,%rbx,1)
movups -0x30(%rsi,%rbx,1),%xmm0
movups -0x20(%rsi,%rbx,1),%xmm1
movups %xmm0,0x40(%r12,%rbx,1)
movups %xmm1,0x50(%r12,%rbx,1)
movups -0x10(%rsi,%rbx,1),%xmm0
movups (%rsi,%rbx,1),%xmm1
movups %xmm0,0x60(%r12,%rbx,1)
movups %xmm1,0x70(%r12,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1580 <unlzss+0x450>
test   %rbp,%rbp
je     160a <unlzss+0x4da>
lea    (%r12,%rbx,1),%rsi
add    $0x10,%rsi
nopl   (%rax)
movups -0x10(%rsi,%rcx,1),%xmm0
movups (%rsi,%rcx,1),%xmm1
movups %xmm0,-0x10(%rsi)
movups %xmm1,(%rsi)
add    $0x20,%rsi
add    $0xffffffffffffffff,%rbp
jne    15f0 <unlzss+0x4c0>
add    %r8,%r12
cmp    %r8,%rdx
je     11bd <unlzss+0x8d>
add    %r8,%rax
sub    %r8d,%r14d
jmp    13e3 <unlzss+0x2b3>
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @unlzss(i8* nocapture %0, i32 %1, i32 %2) {
%4 = add nsw i32 %2, 20
%5 = tail call i32 @get_word(i32 %2)
%6 = add nsw i32 %2, 3
%7 = add nsw i32 %2, 21
%8 = tail call i8* @get_byte(i32 %4)
%9 = ptrtoint i8* %8 to i64
%10 = trunc i64 %9 to i8
%11 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %10, i8* %0
br label %12
12: ; preds = %18, %3
%13 = phi i32 [ %7, %3 ], [ %19, %18 ]
%14 = phi i32 [ %1, %3 ], [ %22, %18 ]
%15 = phi i8* [ %11, %3 ], [ %23, %18 ]
%16 = tail call i32 @get_long(i32 %14)
%17 = add nsw i32 %14, 4
br label %26
18: ; preds = %305, %311, %285, %175, %35
%19 = phi i32 [ %36, %35 ], [ %122, %175 ], [ %122, %285 ], [ %122, %311 ], [ %122, %305 ]
%20 = phi i32 [ %28, %35 ], [ %176, %175 ], [ %176, %285 ], [ %176, %311 ], [ %176, %305 ]
%21 = phi i32 [ %29, %35 ], [ %177, %175 ], [ %177, %285 ], [ %177, %311 ], [ %177, %305 ]
%22 = phi i32 [ %30, %35 ], [ %179, %175 ], [ %179, %285 ], [ %179, %311 ], [ %179, %305 ]
%23 = phi i8* [ %40, %35 ], [ %31, %175 ], [ %207, %285 ], [ %306, %305 ], [ %338, %311 ]
%24 = add nsw i32 %21, -1
%25 = icmp slt i32 %21, 1
br i1 %25, label %12, label %26
26: ; preds = %18, %12
%27 = phi i32 [ %13, %12 ], [ %19, %18 ]
%28 = phi i32 [ %16, %12 ], [ %20, %18 ]
%29 = phi i32 [ 31, %12 ], [ %24, %18 ]
%30 = phi i32 [ %17, %12 ], [ %22, %18 ]
%31 = phi i8* [ %15, %12 ], [ %23, %18 ]
%32 = shl nuw i32 1, %29
%33 = and i32 %32, %28
%34 = icmp eq i32 %33, 0
br i1 %34, label %41, label %35
35: ; preds = %26
%36 = add nsw i32 %27, 1
%37 = tail call i8* @get_byte(i32 %27)
%38 = ptrtoint i8* %37 to i64
%39 = trunc i64 %38 to i8
%40 = getelementptr inbounds i8, i8* %31, i64 1
store i8 %39, i8* %31
br label %18
41: ; preds = %26
%42 = add nsw i32 %29, -1
%43 = icmp eq i32 %29, 0
br i1 %43, label %50, label %44
44: ; preds = %41
%45 = shl nuw i32 1, %42
%46 = and i32 %45, %28
%47 = icmp eq i32 %46, 0
%48 = add nsw i32 %29, -2
%49 = icmp eq i32 %42, 0
br i1 %47, label %54, label %64
50: ; preds = %41
%51 = tail call i32 @get_long(i32 %30)
%52 = add nsw i32 %30, 4
%53 = icmp sgt i32 %51, -1
br i1 %53, label %55, label %65
54: ; preds = %44
br i1 %49, label %61, label %55
55: ; preds = %50, %54, %61
%56 = phi i32 [ %62, %61 ], [ %28, %54 ], [ %51, %50 ]
%57 = phi i32 [ 31, %61 ], [ %48, %54 ], [ 30, %50 ]
%58 = phi i32 [ %63, %61 ], [ %30, %54 ], [ %52, %50 ]
%59 = tail call i8* @get_byte(i32 %27)
%60 = add nsw i32 %27, 1
br label %118
61: ; preds = %54
%62 = tail call i32 @get_long(i32 %30)
%63 = add nsw i32 %30, 4
br label %55
64: ; preds = %44
br i1 %49, label %105, label %65
65: ; preds = %50, %64, %105
%66 = phi i32 [ %106, %105 ], [ %28, %64 ], [ %51, %50 ]
%67 = phi i32 [ 31, %105 ], [ %48, %64 ], [ 30, %50 ]
%68 = phi i32 [ %107, %105 ], [ %30, %64 ], [ %52, %50 ]
%69 = shl nuw i32 1, %67
%70 = and i32 %69, %66
%71 = icmp eq i32 %70, 0
br i1 %71, label %72, label %111
72: ; preds = %65, %95
%73 = phi i32 [ %89, %95 ], [ 1, %65 ]
%74 = phi i32 [ %98, %95 ], [ %68, %65 ]
%75 = phi i32 [ %88, %95 ], [ 0, %65 ]
%76 = phi i32 [ %97, %95 ], [ %67, %65 ]
%77 = phi i32 [ %96, %95 ], [ %66, %65 ]
%78 = add nsw i32 %76, -1
%79 = icmp slt i32 %76, 1
br i1 %79, label %102, label %80
80: ; preds = %72, %102
%81 = phi i32 [ %103, %102 ], [ %77, %72 ]
%82 = phi i32 [ 31, %102 ], [ %78, %72 ]
%83 = phi i32 [ %104, %102 ], [ %74, %72 ]
%84 = shl nuw i32 1, %82
%85 = and i32 %84, %81
%86 = icmp eq i32 %85, 0
%87 = select i1 %86, i32 0, i32 %73
%88 = add nsw i32 %87, %75
%89 = shl i32 %73, 1
%90 = add nsw i32 %82, -1
%91 = icmp eq i32 %82, 0
br i1 %91, label %92, label %95
92: ; preds = %80
%93 = tail call i32 @get_long(i32 %83)
%94 = add nsw i32 %83, 4
br label %95
95: ; preds = %92, %80
%96 = phi i32 [ %81, %80 ], [ %93, %92 ]
%97 = phi i32 [ %90, %80 ], [ 31, %92 ]
%98 = phi i32 [ %83, %80 ], [ %94, %92 ]
%99 = shl nuw i32 1, %97
%100 = and i32 %99, %96
%101 = icmp eq i32 %100, 0
br i1 %101, label %72, label %108
102: ; preds = %72
%103 = tail call i32 @get_long(i32 %74)
%104 = add nsw i32 %74, 4
br label %80
105: ; preds = %64
%106 = tail call i32 @get_long(i32 %30)
%107 = add nsw i32 %30, 4
br label %65
108: ; preds = %95
%109 = add nsw i32 %89, %88
%110 = icmp eq i32 %109, 16
br i1 %110, label %341, label %111
111: ; preds = %65, %108
%112 = phi i32 [ %109, %108 ], [ 1, %65 ]
%113 = phi i32 [ %98, %108 ], [ %68, %65 ]
%114 = phi i32 [ %97, %108 ], [ %67, %65 ]
%115 = phi i32 [ %96, %108 ], [ %66, %65 ]
%116 = add nsw i32 %6, %112
%117 = tail call i8* @get_byte(i32 %116)
br label %118
118: ; preds = %111, %55
%119 = phi i32 [ %112, %111 ], [ %57, %55 ]
%120 = phi i32 [ %5, %111 ], [ %56, %55 ]
%121 = phi i8* [ %117, %111 ], [ %59, %55 ]
%122 = phi i32 [ %27, %111 ], [ %60, %55 ]
%123 = phi i32 [ %115, %111 ], [ %56, %55 ]
%124 = phi i32 [ %114, %111 ], [ %57, %55 ]
%125 = phi i32 [ %113, %111 ], [ %58, %55 ]
%126 = ptrtoint i8* %121 to i64
%127 = shl nuw i32 1, %119
%128 = and i32 %127, %120
%129 = icmp eq i32 %128, 0
%130 = add nsw i32 %124, -1
%131 = icmp eq i32 %124, 0
br i1 %131, label %172, label %132
132: ; preds = %118, %172
%133 = phi i32 [ %173, %172 ], [ %123, %118 ]
%134 = phi i32 [ 31, %172 ], [ %130, %118 ]
%135 = phi i32 [ %174, %172 ], [ %125, %118 ]
%136 = shl nuw i32 1, %134
%137 = and i32 %136, %133
%138 = icmp eq i32 %137, 0
br i1 %138, label %139, label %175
139: ; preds = %132, %162
%140 = phi i32 [ %156, %162 ], [ 1, %132 ]
%141 = phi i32 [ %165, %162 ], [ %135, %132 ]
%142 = phi i32 [ %155, %162 ], [ 0, %132 ]
%143 = phi i32 [ %164, %162 ], [ %134, %132 ]
%144 = phi i32 [ %163, %162 ], [ %133, %132 ]
%145 = add nsw i32 %143, -1
%146 = icmp slt i32 %143, 1
br i1 %146, label %169, label %147
147: ; preds = %139, %169
%148 = phi i32 [ %170, %169 ], [ %144, %139 ]
%149 = phi i32 [ 31, %169 ], [ %145, %139 ]
%150 = phi i32 [ %171, %169 ], [ %141, %139 ]
%151 = shl nuw i32 1, %149
%152 = and i32 %151, %148
%153 = icmp eq i32 %152, 0
%154 = select i1 %153, i32 0, i32 %140
%155 = add nsw i32 %154, %142
%156 = shl i32 %140, 1
%157 = add nsw i32 %149, -1
%158 = icmp eq i32 %149, 0
br i1 %158, label %159, label %162
159: ; preds = %147
%160 = tail call i32 @get_long(i32 %150)
%161 = add nsw i32 %150, 4
br label %162
162: ; preds = %159, %147
%163 = phi i32 [ %148, %147 ], [ %160, %159 ]
%164 = phi i32 [ %157, %147 ], [ 31, %159 ]
%165 = phi i32 [ %150, %147 ], [ %161, %159 ]
%166 = shl nuw i32 1, %164
%167 = and i32 %166, %163
%168 = icmp eq i32 %167, 0
br i1 %168, label %139, label %175
169: ; preds = %139
%170 = tail call i32 @get_long(i32 %141)
%171 = add nsw i32 %141, 4
br label %147
172: ; preds = %118
%173 = tail call i32 @get_long(i32 %125)
%174 = add nsw i32 %125, 4
br label %132
175: ; preds = %162, %132
%176 = phi i32 [ %133, %132 ], [ %163, %162 ]
%177 = phi i32 [ %134, %132 ], [ %164, %162 ]
%178 = phi i32 [ 0, %132 ], [ %155, %162 ]
%179 = phi i32 [ %135, %132 ], [ %165, %162 ]
%180 = phi i32 [ 1, %132 ], [ %156, %162 ]
%181 = add i32 %178, 1
%182 = add i32 %181, %180
%183 = icmp sgt i32 %182, -1
br i1 %183, label %184, label %18
184: ; preds = %175
%185 = shl i64 %126, 32
%186 = ashr exact i64 %185, 32
%187 = or i64 %186, 256
%188 = select i1 %129, i64 %186, i64 %187
%189 = sub nsw i64 0, %188
%190 = getelementptr i8, i8* %31, i64 %189
%191 = zext i32 %182 to i64
%192 = add nuw nsw i64 %191, 1
%193 = icmp ult i32 %182, 31
br i1 %193, label %287, label %194
194: ; preds = %184
%195 = getelementptr i8, i8* %31, i64 1
%196 = zext i32 %182 to i64
%197 = getelementptr i8, i8* %195, i64 %196
%198 = getelementptr i8, i8* %31, i64 1
%199 = sub nsw i64 %196, %188
%200 = getelementptr i8, i8* %198, i64 %199
%201 = icmp ult i8* %31, %200
%202 = icmp ult i8* %190, %197
%203 = and i1 %201, %202
br i1 %203, label %287, label %204
204: ; preds = %194
%205 = and i64 %192, 8589934560
%206 = getelementptr i8, i8* %190, i64 %205
%207 = getelementptr i8, i8* %31, i64 %205
%208 = trunc i64 %205 to i32
%209 = sub i32 %182, %208
%210 = add nsw i64 %205, -32
%211 = lshr exact i64 %210, 5
%212 = add nuw nsw i64 %211, 1
%213 = and i64 %212, 3
%214 = icmp ult i64 %210, 96
br i1 %214, label %266, label %215
215: ; preds = %204
%216 = and i64 %212, 1152921504606846972
br label %217
217: ; preds = %217, %215
%218 = phi i64 [ 0, %215 ], [ %263, %217 ]
%219 = phi i64 [ 0, %215 ], [ %264, %217 ]
%220 = getelementptr i8, i8* %190, i64 %218
%221 = getelementptr i8, i8* %31, i64 %218
%222 = bitcast i8* %220 to <16 x i8>*
%223 = load <16 x i8>, <16 x i8>* %222
%224 = getelementptr i8, i8* %220, i64 16
%225 = bitcast i8* %224 to <16 x i8>*
%226 = load <16 x i8>, <16 x i8>* %225
%227 = bitcast i8* %221 to <16 x i8>*
store <16 x i8> %223, <16 x i8>* %227
%228 = getelementptr i8, i8* %221, i64 16
%229 = bitcast i8* %228 to <16 x i8>*
store <16 x i8> %226, <16 x i8>* %229
%230 = or i64 %218, 32
%231 = getelementptr i8, i8* %190, i64 %230
%232 = getelementptr i8, i8* %31, i64 %230
%233 = bitcast i8* %231 to <16 x i8>*
%234 = load <16 x i8>, <16 x i8>* %233
%235 = getelementptr i8, i8* %231, i64 16
%236 = bitcast i8* %235 to <16 x i8>*
%237 = load <16 x i8>, <16 x i8>* %236
%238 = bitcast i8* %232 to <16 x i8>*
store <16 x i8> %234, <16 x i8>* %238
%239 = getelementptr i8, i8* %232, i64 16
%240 = bitcast i8* %239 to <16 x i8>*
store <16 x i8> %237, <16 x i8>* %240
%241 = or i64 %218, 64
%242 = getelementptr i8, i8* %190, i64 %241
%243 = getelementptr i8, i8* %31, i64 %241
%244 = bitcast i8* %242 to <16 x i8>*
%245 = load <16 x i8>, <16 x i8>* %244
%246 = getelementptr i8, i8* %242, i64 16
%247 = bitcast i8* %246 to <16 x i8>*
%248 = load <16 x i8>, <16 x i8>* %247
%249 = bitcast i8* %243 to <16 x i8>*
store <16 x i8> %245, <16 x i8>* %249
%250 = getelementptr i8, i8* %243, i64 16
%251 = bitcast i8* %250 to <16 x i8>*
store <16 x i8> %248, <16 x i8>* %251
%252 = or i64 %218, 96
%253 = getelementptr i8, i8* %190, i64 %252
%254 = getelementptr i8, i8* %31, i64 %252
%255 = bitcast i8* %253 to <16 x i8>*
%256 = load <16 x i8>, <16 x i8>* %255
%257 = getelementptr i8, i8* %253, i64 16
%258 = bitcast i8* %257 to <16 x i8>*
%259 = load <16 x i8>, <16 x i8>* %258
%260 = bitcast i8* %254 to <16 x i8>*
store <16 x i8> %256, <16 x i8>* %260
%261 = getelementptr i8, i8* %254, i64 16
%262 = bitcast i8* %261 to <16 x i8>*
store <16 x i8> %259, <16 x i8>* %262
%263 = add nuw i64 %218, 128
%264 = add i64 %219, 4
%265 = icmp eq i64 %264, %216
br i1 %265, label %266, label %217
266: ; preds = %217, %204
%267 = phi i64 [ 0, %204 ], [ %263, %217 ]
%268 = icmp eq i64 %213, 0
br i1 %268, label %285, label %269
269: ; preds = %266, %269
%270 = phi i64 [ %282, %269 ], [ %267, %266 ]
%271 = phi i64 [ %283, %269 ], [ 0, %266 ]
%272 = getelementptr i8, i8* %190, i64 %270
%273 = getelementptr i8, i8* %31, i64 %270
%274 = bitcast i8* %272 to <16 x i8>*
%275 = load <16 x i8>, <16 x i8>* %274
%276 = getelementptr i8, i8* %272, i64 16
%277 = bitcast i8* %276 to <16 x i8>*
%278 = load <16 x i8>, <16 x i8>* %277
%279 = bitcast i8* %273 to <16 x i8>*
store <16 x i8> %275, <16 x i8>* %279
%280 = getelementptr i8, i8* %273, i64 16
%281 = bitcast i8* %280 to <16 x i8>*
store <16 x i8> %278, <16 x i8>* %281
%282 = add nuw i64 %270, 32
%283 = add i64 %271, 1
%284 = icmp eq i64 %283, %213
br i1 %284, label %285, label %269
285: ; preds = %269, %266
%286 = icmp eq i64 %192, %205
br i1 %286, label %18, label %287
287: ; preds = %194, %184, %285
%288 = phi i8* [ %190, %194 ], [ %190, %184 ], [ %206, %285 ]
%289 = phi i8* [ %31, %194 ], [ %31, %184 ], [ %207, %285 ]
%290 = phi i32 [ %182, %194 ], [ %182, %184 ], [ %209, %285 ]
%291 = add i32 %290, 1
%292 = and i32 %291, 7
%293 = icmp eq i32 %292, 0
br i1 %293, label %305, label %294
294: ; preds = %287, %294
%295 = phi i8* [ %299, %294 ], [ %288, %287 ]
%296 = phi i8* [ %301, %294 ], [ %289, %287 ]
%297 = phi i32 [ %302, %294 ], [ %290, %287 ]
%298 = phi i32 [ %303, %294 ], [ 0, %287 ]
%299 = getelementptr inbounds i8, i8* %295, i64 1
%300 = load i8, i8* %295
%301 = getelementptr inbounds i8, i8* %296, i64 1
store i8 %300, i8* %296
%302 = add nsw i32 %297, -1
%303 = add i32 %298, 1
%304 = icmp eq i32 %303, %292
br i1 %304, label %305, label %294
305: ; preds = %294, %287
%306 = phi i8* [ undef, %287 ], [ %301, %294 ]
%307 = phi i8* [ %288, %287 ], [ %299, %294 ]
%308 = phi i8* [ %289, %287 ], [ %301, %294 ]
%309 = phi i32 [ %290, %287 ], [ %302, %294 ]
%310 = icmp ult i32 %290, 7
br i1 %310, label %18, label %311
311: ; preds = %305, %311
%312 = phi i8* [ %336, %311 ], [ %307, %305 ]
%313 = phi i8* [ %338, %311 ], [ %308, %305 ]
%314 = phi i32 [ %339, %311 ], [ %309, %305 ]
%315 = getelementptr inbounds i8, i8* %312, i64 1
%316 = load i8, i8* %312
%317 = getelementptr inbounds i8, i8* %313, i64 1
store i8 %316, i8* %313
%318 = getelementptr inbounds i8, i8* %312, i64 2
%319 = load i8, i8* %315
%320 = getelementptr inbounds i8, i8* %313, i64 2
store i8 %319, i8* %317
%321 = getelementptr inbounds i8, i8* %312, i64 3
%322 = load i8, i8* %318
%323 = getelementptr inbounds i8, i8* %313, i64 3
store i8 %322, i8* %320
%324 = getelementptr inbounds i8, i8* %312, i64 4
%325 = load i8, i8* %321
%326 = getelementptr inbounds i8, i8* %313, i64 4
store i8 %325, i8* %323
%327 = getelementptr inbounds i8, i8* %312, i64 5
%328 = load i8, i8* %324
%329 = getelementptr inbounds i8, i8* %313, i64 5
store i8 %328, i8* %326
%330 = getelementptr inbounds i8, i8* %312, i64 6
%331 = load i8, i8* %327
%332 = getelementptr inbounds i8, i8* %313, i64 6
store i8 %331, i8* %329
%333 = getelementptr inbounds i8, i8* %312, i64 7
%334 = load i8, i8* %330
%335 = getelementptr inbounds i8, i8* %313, i64 7
store i8 %334, i8* %332
%336 = getelementptr inbounds i8, i8* %312, i64 8
%337 = load i8, i8* %333
%338 = getelementptr inbounds i8, i8* %313, i64 8
store i8 %337, i8* %335
%339 = add nsw i32 %314, -8
%340 = icmp eq i32 %314, 7
br i1 %340, label %18, label %311
341: ; preds = %108
ret i32 0
}