#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 */
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, long);
int decompress(unsigned char *i_buf, long i_buf_size, unsigned char *o_buf,
               long o_buf_size, int last_code, int tic_size) {
  static int init = 1;
  static unsigned *t_pred;
  static unsigned char *t_suff, *stack;
  int i_buf_ptr = 0, o_buf_ptr = 0, stack_ptr;
  unsigned bits = 0, buf = 0;
  unsigned code, free_ent = 256, n_bits = 9, max_code = 1 << 9;
  if (init) {
    t_suff = (unsigned char *)malloc((1 << 15) * sizeof(*t_suff));
    if (t_suff == NULL)
      return -1;
    stack = (unsigned char *)malloc((1 << 15) * sizeof(*stack));
    if (stack == NULL)
      return -1;
    t_pred = (unsigned *)malloc((1 << 15) * sizeof(*t_pred));
    if (t_pred == NULL)
      return -1;
    init = 0;
  }
  if (last_code) {
    do {
      do {
        buf |= i_buf[i_buf_ptr++] << bits;
        bits += 8;
      } while (bits < n_bits);
      code = buf & ((1 << n_bits) - 1);
      buf >>= n_bits;
      bits -= n_bits;
      if (i_buf_ptr <= i_buf_size) {
        if (free_ent <= code)
          return -4;
        t_pred[free_ent] = code;
        stack_ptr = 0;
        while (code >= 256) {
          stack[stack_ptr++] = t_suff[code];
          code = t_pred[code];
        }
        stack_ptr--;
        if (o_buf_ptr >= o_buf_size)
          return -5;
        o_buf[o_buf_ptr++] = code;
        while (stack_ptr >= 0) {
          if (o_buf_ptr >= o_buf_size)
            return -5;
          o_buf[o_buf_ptr++] = stack[stack_ptr--];
        }
        t_suff[free_ent - 1] = code;
        t_suff[free_ent++] = code;
        if (free_ent >= max_code) {
          max_code = 1 << ++n_bits;
          if (n_bits > 15)
            return -2;
        }
      } else {
        return -3;
      }
    } while (i_buf_ptr < i_buf_size && free_ent < (unsigned)last_code);
  } else {
    if (i_buf_size > o_buf_size)
      return -5;
    memcpy(o_buf, i_buf, i_buf_size);
    o_buf_ptr = i_buf_size;
  }
  return o_buf_ptr;
}


x86 assembly (clang, -O0):
<decompress>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8d,-0x2c(%rbp)
mov    %r9d,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x100,-0x4c(%rbp)
movl   $0x9,-0x50(%rbp)
movl   $0x200,-0x54(%rbp)
cmpl   $0x0,0x2eb8(%rip)
je     1209 <decompress+0xe9>
mov    $0x8000,%edi
call   1040 <malloc@plt>
mov    %rax,0x2eb9(%rip)
cmpq   $0x0,0x2eb1(%rip)
jne    11a9 <decompress+0x89>
movl   $0xffffffff,-0x4(%rbp)
jmp    1481 <decompress+0x361>
mov    $0x8000,%edi
call   1040 <malloc@plt>
mov    %rax,0x2e96(%rip)
cmpq   $0x0,0x2e8e(%rip)
jne    11d4 <decompress+0xb4>
movl   $0xffffffff,-0x4(%rbp)
jmp    1481 <decompress+0x361>
mov    $0x20000,%edi
call   1040 <malloc@plt>
mov    %rax,0x2e5b(%rip)
cmpq   $0x0,0x2e53(%rip)
jne    11ff <decompress+0xdf>
movl   $0xffffffff,-0x4(%rbp)
jmp    1481 <decompress+0x361>
movl   $0x0,0x2e27(%rip)
cmpl   $0x0,-0x2c(%rbp)
je     1449 <decompress+0x329>
jmp    1218 <decompress+0xf8>
jmp    121d <decompress+0xfd>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x40(%rbp),%ecx
shl    %cl,%eax
or     -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x50(%rbp),%eax
jb     121d <decompress+0xfd>
mov    -0x44(%rbp),%eax
mov    -0x50(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
sub    $0x1,%ecx
and    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x50(%rbp),%ecx
mov    -0x44(%rbp),%eax
shr    %cl,%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x18(%rbp),%rax
jg     1409 <decompress+0x2e9>
mov    -0x4c(%rbp),%eax
cmp    -0x48(%rbp),%eax
ja     12a6 <decompress+0x186>
movl   $0xfffffffc,-0x4(%rbp)
jmp    1481 <decompress+0x361>
mov    -0x48(%rbp),%edx
mov    0x2d90(%rip),%rax
mov    -0x4c(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x3c(%rbp)
cmpl   $0x100,-0x48(%rbp)
jb     1304 <decompress+0x1e4>
mov    0x2d77(%rip),%rax
mov    -0x48(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    0x2d72(%rip),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    0x2d4a(%rip),%rax
mov    -0x48(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
jmp    12bd <decompress+0x19d>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
movslq -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jl     1327 <decompress+0x207>
movl   $0xfffffffb,-0x4(%rbp)
jmp    1481 <decompress+0x361>
mov    -0x48(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
cmpl   $0x0,-0x3c(%rbp)
jl     1397 <decompress+0x277>
movslq -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jl     1365 <decompress+0x245>
movl   $0xfffffffb,-0x4(%rbp)
jmp    1481 <decompress+0x361>
mov    0x2ce4(%rip),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x38(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1341 <decompress+0x221>
mov    -0x48(%rbp),%eax
mov    %al,%dl
mov    0x2ca5(%rip),%rax
mov    -0x4c(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%eax
mov    %al,%dl
mov    0x2c8e(%rip),%rax
mov    -0x4c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x4c(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x4c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jb     1404 <decompress+0x2e4>
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp)
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x54(%rbp)
cmpl   $0xf,-0x50(%rbp)
jbe    13ff <decompress+0x2df>
movl   $0xfffffffe,-0x4(%rbp)
jmp    1481 <decompress+0x361>
jmp    1404 <decompress+0x2e4>
jmp    1415 <decompress+0x2f5>
movl   $0xfffffffd,-0x4(%rbp)
jmp    1481 <decompress+0x361>
jmp    141a <decompress+0x2fa>
movslq -0x34(%rbp),%rcx
xor    %eax,%eax
cmp    -0x18(%rbp),%rcx
mov    %al,-0x55(%rbp)
jge    1439 <decompress+0x319>
mov    -0x4c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
setb   %al
mov    %al,-0x55(%rbp)
mov    -0x55(%rbp),%al
test   $0x1,%al
jne    1218 <decompress+0xf8>
jmp    147b <decompress+0x35b>
mov    -0x18(%rbp),%rax
cmp    -0x28(%rbp),%rax
jle    1463 <decompress+0x343>
movl   $0xfffffffb,-0x4(%rbp)
jmp    1481 <decompress+0x361>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   1030 <memcpy@plt>
mov    -0x18(%rbp),%rax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decompress>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r8d,%ebx
mov    %rcx,0x18(%rsp)
mov    %rdx,%rbp
mov    %rsi,%r15
mov    %rdi,%r13
cmpb   $0x0,0x2eef(%rip)
je     17d9 <decompress+0x6b9>
test   %ebx,%ebx
je     1830 <decompress+0x710>
mov    0x2ee2(%rip),%rax
mov    %rax,0x78(%rsp)
mov    0x2ede(%rip),%rax
mov    %rax,0x40(%rsp)
mov    0x2eda(%rip),%r10
mov    %ebx,%eax
mov    %rax,0x70(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0x58(%rsp)
lea    0x1(%r10),%rax
mov    %rax,0x60(%rsp)
lea    0xc(%r13),%rax
mov    %rax,0x68(%rsp)
movl   $0x200,0x2c(%rsp)
mov    $0x9,%r9d
xor    %esi,%esi
mov    $0x100,%r8d
pxor   %xmm14,%xmm14
movdqa 0xe44(%rip),%xmm8
movdqa 0xe4b(%rip),%xmm12
movdqa 0xe52(%rip),%xmm13
movdqa 0xe59(%rip),%xmm9
movdqa 0xe60(%rip),%xmm10
movdqa 0xe67(%rip),%xmm11
xor    %r14d,%r14d
xor    %edx,%edx
xor    %r12d,%r12d
mov    %r15,0x20(%rsp)
mov    %rbp,0x10(%rsp)
mov    %r15,%rax
lea    0x8(%rdx),%ecx
cmp    %ecx,%r9d
cmova  %r9d,%ecx
movslq %esi,%rsi
mov    %edx,%r15d
not    %r15d
add    %ecx,%r15d
cmp    $0x38,%r15d
jae    1230 <decompress+0x110>
mov    %rax,%r15
jmp    149d <decompress+0x37d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rbx
shr    $0x3,%r15d
add    $0x1,%r15d
mov    %r15d,%eax
and    $0xfffffff8,%eax
movd   %edx,%xmm1
pshufd $0x0,%xmm1,%xmm15
paddd  %xmm8,%xmm15
movd   %r12d,%xmm7
lea    -0x8(%rax),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     15d9 <decompress+0x4b9>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
mov    0x68(%rsp),%rcx
add    %rsi,%rcx
pxor   %xmm4,%xmm4
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm15,%xmm1
paddd  %xmm12,%xmm1
movd   -0xc(%rcx,%rdi,1),%xmm5
movd   -0x8(%rcx,%rdi,1),%xmm6
punpcklbw %xmm14,%xmm5
punpcklwd %xmm14,%xmm5
punpcklbw %xmm14,%xmm6
punpcklwd %xmm14,%xmm6
movdqa %xmm15,%xmm2
pslld  $0x17,%xmm2
paddd  %xmm13,%xmm2
cvttps2dq %xmm2,%xmm2
pshufd $0xf5,%xmm5,%xmm0
pmuludq %xmm2,%xmm5
pshufd $0xe8,%xmm5,%xmm5
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm0
punpckldq %xmm0,%xmm5
por    %xmm7,%xmm5
pslld  $0x17,%xmm1
paddd  %xmm13,%xmm1
cvttps2dq %xmm1,%xmm0
pshufd $0xf5,%xmm6,%xmm1
pmuludq %xmm0,%xmm6
pshufd $0xe8,%xmm6,%xmm6
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm1,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm6
por    %xmm4,%xmm6
movdqa %xmm15,%xmm0
paddd  %xmm9,%xmm0
movdqa %xmm15,%xmm1
paddd  %xmm10,%xmm1
movd   -0x4(%rcx,%rdi,1),%xmm2
movd   (%rcx,%rdi,1),%xmm4
punpcklbw %xmm14,%xmm2
punpcklwd %xmm14,%xmm2
punpcklbw %xmm14,%xmm4
punpcklwd %xmm14,%xmm4
pslld  $0x17,%xmm0
paddd  %xmm13,%xmm0
cvttps2dq %xmm0,%xmm0
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm0,%xmm2
pshufd $0xe8,%xmm2,%xmm7
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm3,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm7
por    %xmm5,%xmm7
pslld  $0x17,%xmm1
paddd  %xmm13,%xmm1
cvttps2dq %xmm1,%xmm0
pshufd $0xf5,%xmm4,%xmm1
pmuludq %xmm0,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm1,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm4
por    %xmm6,%xmm4
add    $0x10,%rdi
paddd  %xmm11,%xmm15
add    $0xfffffffffffffffe,%rbp
jne    1290 <decompress+0x170>
test   $0x1,%r8b
je     146c <decompress+0x34c>
add    %rsi,%rdi
movdqa %xmm15,%xmm1
paddd  %xmm12,%xmm1
movd   0x0(%r13,%rdi,1),%xmm0
movd   0x4(%r13,%rdi,1),%xmm5
punpcklbw %xmm14,%xmm0
punpcklwd %xmm14,%xmm0
punpcklbw %xmm14,%xmm5
punpcklwd %xmm14,%xmm5
pslld  $0x17,%xmm15
paddd  %xmm13,%xmm15
cvttps2dq %xmm15,%xmm2
pshufd $0xf5,%xmm0,%xmm3
pmuludq %xmm2,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshufd $0xf5,%xmm2,%xmm2
pmuludq %xmm3,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm0
por    %xmm0,%xmm7
pslld  $0x17,%xmm1
paddd  %xmm13,%xmm1
cvttps2dq %xmm1,%xmm0
pshufd $0xf5,%xmm5,%xmm1
pmuludq %xmm0,%xmm5
pshufd $0xe8,%xmm5,%xmm2
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm1,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
por    %xmm2,%xmm4
por    %xmm4,%xmm7
add    %rax,%rsi
lea    (%rdx,%rax,8),%edx
pshufd $0xee,%xmm7,%xmm0
por    %xmm7,%xmm0
pshufd $0x55,%xmm0,%xmm1
por    %xmm0,%xmm1
movd   %xmm1,%r12d
mov    %r12d,%r11d
cmp    %r15,%rax
mov    0x20(%rsp),%r15
mov    %rbx,%r8
je     14b9 <decompress+0x399>
mov    %r12d,%r11d
movzbl 0x0(%r13,%rsi,1),%edi
mov    %edx,%ecx
shl    %cl,%edi
add    $0x1,%rsi
or     %edi,%r11d
add    $0x8,%edx
cmp    %r9d,%edx
jb     14a0 <decompress+0x380>
mov    $0xffffffff,%edi
mov    %r9d,%ecx
shl    %cl,%edi
mov    %r11d,%eax
shr    %cl,%eax
movslq %esi,%rbp
cmp    %r15,%rbp
mov    0x18(%rsp),%rbx
jg     186b <decompress+0x74b>
not    %edi
and    %edi,%r11d
mov    %r11d,%ecx
cmp    %rcx,%r8
jbe    1873 <decompress+0x753>
mov    %rbp,0x80(%rsp)
mov    %eax,0xc(%rsp)
mov    0x78(%rsp),%r12
mov    %r11d,(%r12,%r8,4)
cmp    $0x100,%r11d
jb     15b0 <decompress+0x490>
mov    %r8,0x38(%rsp)
mov    $0x1,%ecx
xor    %r15d,%r15d
mov    0x40(%rsp),%r8
xchg   %ax,%ax
mov    %r15,%rdi
mov    %ecx,%ebp
mov    %r11d,%ecx
movzbl (%r8,%rcx,1),%eax
add    $0x1,%r15
mov    %al,(%r10,%rdi,1)
mov    (%r12,%rcx,4),%r11d
lea    0x1(%rbp),%ecx
cmp    $0xff,%r11d
ja     1520 <decompress+0x400>
movslq %r14d,%rcx
cmp    %rbx,%rcx
jge    1850 <decompress+0x730>
mov    0x10(%rsp),%rax
mov    %r11b,(%rax,%rcx,1)
add    $0x1,%r14d
test   %r15d,%r15d
jle    15ee <decompress+0x4ce>
movslq %r14d,%r14
cmp    %r14,%rbx
mov    %r14,%r8
cmovg  %rbx,%r8
mov    %r15d,%ecx
sub    %r14,%r8
lea    -0x1(%rcx),%rax
cmp    %rax,%r8
mov    %rax,%r12
cmovb  %r8,%r12
add    $0x1,%r12
cmp    $0x11,%r12
jae    1607 <decompress+0x4e7>
mov    0x20(%rsp),%r15
mov    0x10(%rsp),%rbp
mov    0x38(%rsp),%r8
mov    0xc(%rsp),%r12d
jmp    173b <decompress+0x61b>
nopl   0x0(%rax,%rax,1)
movslq %r14d,%r14
cmp    %rbx,%r14
mov    0x10(%rsp),%rbp
jge    1850 <decompress+0x730>
mov    %r11b,0x0(%rbp,%r14,1)
add    $0x1,%r14d
mov    0x40(%rsp),%rax
mov    0xc(%rsp),%r12d
jmp    1770 <decompress+0x650>
pxor   %xmm4,%xmm4
xor    %edi,%edi
test   $0x1,%r8b
jne    13d7 <decompress+0x2b7>
jmp    146c <decompress+0x34c>
mov    0x20(%rsp),%r15
mov    0x40(%rsp),%rax
mov    0x38(%rsp),%r8
mov    0xc(%rsp),%r12d
jmp    1770 <decompress+0x650>
cmp    %r14,%rbx
mov    %r14,%rbx
cmovg  0x18(%rsp),%rbx
sub    %r14,%rbx
cmp    %rax,%rbx
mov    %rax,0x30(%rsp)
cmovae %rax,%rbx
lea    -0x1(%r15),%eax
cmp    %ebx,%eax
jb     17c5 <decompress+0x6a5>
mov    %r12,0x48(%rsp)
mov    %r8,0x50(%rsp)
shr    $0x20,%rbx
mov    0x38(%rsp),%r8
mov    0xc(%rsp),%r12d
jne    172c <decompress+0x60c>
mov    0x18(%rsp),%rax
cmp    %r14,%rax
mov    %r14,%r15
cmovg  %rax,%r15
sub    %r14,%r15
mov    0x30(%rsp),%rax
cmp    %rax,%r15
cmovae %rax,%r15
mov    0x10(%rsp),%rax
add    %r14,%rax
mov    %rax,0x30(%rsp)
mov    %edi,%ebx
mov    0x60(%rsp),%rax
add    %rbx,%rax
cmp    %rax,0x30(%rsp)
jae    16a0 <decompress+0x580>
lea    (%r15,%r14,1),%rax
add    0x58(%rsp),%rax
sub    %r15,%rbx
add    %r10,%rbx
cmp    %rax,%rbx
jb     172c <decompress+0x60c>
mov    0x48(%rsp),%r15
mov    %r15d,%eax
and    $0xf,%eax
test   %rax,%rax
mov    $0x10,%ebx
cmove  %rbx,%rax
sub    %rax,%r15
sub    %r15,%rcx
add    %r15,%r14
mov    %ebp,%ebx
add    $0xffffffffffffffff,%rbx
mov    0x50(%rsp),%rbp
cmp    %rbx,%rbp
cmovb  %rbp,%rbx
sub    %rax,%rbx
add    $0x1,%rbx
xor    %ebp,%ebp
mov    0x30(%rsp),%r15
mov    %edi,%eax
movdqu -0xf(%r10,%rax,1),%xmm0
movdqa %xmm0,%xmm1
punpcklbw %xmm14,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm14,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm1,%xmm0
movdqu %xmm0,(%r15,%rbp,1)
add    $0x10,%rbp
add    $0xfffffffffffffff0,%rdi
cmp    %rbp,%rbx
jne    16e0 <decompress+0x5c0>
mov    0x20(%rsp),%r15
mov    0x10(%rsp),%rbp
mov    0x18(%rsp),%rbx
add    $0x1,%rcx
nop
cmp    %rbx,%r14
jge    1850 <decompress+0x730>
lea    -0x2(%rcx),%rax
mov    %eax,%eax
movzbl (%r10,%rax,1),%eax
mov    %al,0x0(%rbp,%r14,1)
add    $0x1,%r14
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%rcx
ja     1740 <decompress+0x620>
mov    0x40(%rsp),%rax
nopl   0x0(%rax)
mov    %r11b,-0x1(%rax,%r8,1)
mov    %r11b,(%rax,%r8,1)
add    $0x1,%r8
mov    0x2c(%rsp),%eax
mov    %r9d,%ecx
cmp    %rax,%r8
jb     17a1 <decompress+0x681>
lea    0x1(%r9),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,0x2c(%rsp)
cmp    $0xf,%ecx
ja     187b <decompress+0x75b>
cmp    %r15,0x80(%rsp)
jge    1856 <decompress+0x736>
sub    %r9d,%edx
mov    %ecx,%r9d
cmp    0x70(%rsp),%r8
jb     11fb <decompress+0xdb>
jmp    1856 <decompress+0x736>
mov    0x20(%rsp),%r15
mov    0x10(%rsp),%rbp
mov    0x18(%rsp),%rbx
jmp    159c <decompress+0x47c>
mov    $0x8000,%edi
call   1040 <malloc@plt>
mov    %rax,0x285e(%rip)
mov    $0xffffffff,%r14d
test   %rax,%rax
je     1856 <decompress+0x736>
mov    $0x8000,%edi
call   1040 <malloc@plt>
mov    %rax,0x284a(%rip)
test   %rax,%rax
je     1856 <decompress+0x736>
mov    $0x20000,%edi
call   1040 <malloc@plt>
mov    %rax,0x2824(%rip)
test   %rax,%rax
je     1856 <decompress+0x736>
movb   $0x1,0x2810(%rip)
test   %ebx,%ebx
jne    1157 <decompress+0x37>
mov    $0xfffffffb,%r14d
cmp    0x18(%rsp),%r15
jg     1856 <decompress+0x736>
mov    %rbp,%rdi
mov    %r13,%rsi
mov    %r15,%rdx
call   1030 <memcpy@plt>
mov    %r15d,%r14d
jmp    1856 <decompress+0x736>
mov    $0xfffffffb,%r14d
mov    %r14d,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xfffffffd,%r14d
jmp    1856 <decompress+0x736>
mov    $0xfffffffc,%r14d
jmp    1856 <decompress+0x736>
mov    $0xfffffffe,%r14d
jmp    1856 <decompress+0x736>

LLVM IR (-O0):
@decompress.init = internal global i32 1
@decompress.t_pred = internal global i32* null
@decompress.t_suff = internal global i8* null
@decompress.stack = internal global i8* null
define i32 @decompress(i8* %0, i64 %1, i8* %2, i64 %3, i32 %4, i32 %5) {
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i8*
%11 = alloca i64
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
store i8* %0, i8** %8
store i64 %1, i64* %9
store i8* %2, i8** %10
store i64 %3, i64* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i32 0, i32* %14
store i32 0, i32* %15
store i32 0, i32* %17
store i32 0, i32* %18
store i32 256, i32* %20
store i32 9, i32* %21
store i32 512, i32* %22
%23 = load i32, i32* @decompress.init
%24 = icmp ne i32 %23, 0
br i1 %24, label %25, label %44
25: ; preds = %6
%26 = call i64 @malloc(i32 32768)
%27 = inttoptr i64 %26 to i8*
store i8* %27, i8** @decompress.t_suff
%28 = load i8*, i8** @decompress.t_suff
%29 = icmp eq i8* %28, null
br i1 %29, label %30, label %31
30: ; preds = %25
store i32 -1, i32* %7
br label %205
31: ; preds = %25
%32 = call i64 @malloc(i32 32768)
%33 = inttoptr i64 %32 to i8*
store i8* %33, i8** @decompress.stack
%34 = load i8*, i8** @decompress.stack
%35 = icmp eq i8* %34, null
br i1 %35, label %36, label %37
36: ; preds = %31
store i32 -1, i32* %7
br label %205
37: ; preds = %31
%38 = call i64 @malloc(i32 131072)
%39 = inttoptr i64 %38 to i32*
store i32* %39, i32** @decompress.t_pred
%40 = load i32*, i32** @decompress.t_pred
%41 = icmp eq i32* %40, null
br i1 %41, label %42, label %43
42: ; preds = %37
store i32 -1, i32* %7
br label %205
43: ; preds = %37
store i32 0, i32* @decompress.init
br label %44
44: ; preds = %43, %6
%45 = load i32, i32* %12
%46 = icmp ne i32 %45, 0
br i1 %46, label %47, label %191
47: ; preds = %44
br label %48
48: ; preds = %188, %47
br label %49
49: ; preds = %63, %48
%50 = load i8*, i8** %8
%51 = load i32, i32* %14
%52 = add nsw i32 %51, 1
store i32 %52, i32* %14
%53 = sext i32 %51 to i64
%54 = getelementptr inbounds i8, i8* %50, i64 %53
%55 = load i8, i8* %54
%56 = zext i8 %55 to i32
%57 = load i32, i32* %17
%58 = shl i32 %56, %57
%59 = load i32, i32* %18
%60 = or i32 %59, %58
store i32 %60, i32* %18
%61 = load i32, i32* %17
%62 = add i32 %61, 8
store i32 %62, i32* %17
br label %63
63: ; preds = %49
%64 = load i32, i32* %17
%65 = load i32, i32* %21
%66 = icmp ult i32 %64, %65
br i1 %66, label %49, label %67
67: ; preds = %63
%68 = load i32, i32* %18
%69 = load i32, i32* %21
%70 = shl i32 1, %69
%71 = sub nsw i32 %70, 1
%72 = and i32 %68, %71
store i32 %72, i32* %19
%73 = load i32, i32* %21
%74 = load i32, i32* %18
%75 = lshr i32 %74, %73
store i32 %75, i32* %18
%76 = load i32, i32* %21
%77 = load i32, i32* %17
%78 = sub i32 %77, %76
store i32 %78, i32* %17
%79 = load i32, i32* %14
%80 = sext i32 %79 to i64
%81 = load i64, i64* %9
%82 = icmp sle i64 %80, %81
br i1 %82, label %83, label %177
83: ; preds = %67
%84 = load i32, i32* %20
%85 = load i32, i32* %19
%86 = icmp ule i32 %84, %85
br i1 %86, label %87, label %88
87: ; preds = %83
store i32 -4, i32* %7
br label %205
88: ; preds = %83
%89 = load i32, i32* %19
%90 = load i32*, i32** @decompress.t_pred
%91 = load i32, i32* %20
%92 = zext i32 %91 to i64
%93 = getelementptr inbounds i32, i32* %90, i64 %92
store i32 %89, i32* %93
store i32 0, i32* %16
br label %94
94: ; preds = %97, %88
%95 = load i32, i32* %19
%96 = icmp uge i32 %95, 256
br i1 %96, label %97, label %113
97: ; preds = %94
%98 = load i8*, i8** @decompress.t_suff
%99 = load i32, i32* %19
%100 = zext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %98, i64 %100
%102 = load i8, i8* %101
%103 = load i8*, i8** @decompress.stack
%104 = load i32, i32* %16
%105 = add nsw i32 %104, 1
store i32 %105, i32* %16
%106 = sext i32 %104 to i64
%107 = getelementptr inbounds i8, i8* %103, i64 %106
store i8 %102, i8* %107
%108 = load i32*, i32** @decompress.t_pred
%109 = load i32, i32* %19
%110 = zext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %108, i64 %110
%112 = load i32, i32* %111
store i32 %112, i32* %19
br label %94
113: ; preds = %94
%114 = load i32, i32* %16
%115 = add nsw i32 %114, -1
store i32 %115, i32* %16
%116 = load i32, i32* %15
%117 = sext i32 %116 to i64
%118 = load i64, i64* %11
%119 = icmp sge i64 %117, %118
br i1 %119, label %120, label %121
120: ; preds = %113
store i32 -5, i32* %7
br label %205
121: ; preds = %113
%122 = load i32, i32* %19
%123 = trunc i32 %122 to i8
%124 = load i8*, i8** %10
%125 = load i32, i32* %15
%126 = add nsw i32 %125, 1
store i32 %126, i32* %15
%127 = sext i32 %125 to i64
%128 = getelementptr inbounds i8, i8* %124, i64 %127
store i8 %123, i8* %128
br label %129
129: ; preds = %138, %121
%130 = load i32, i32* %16
%131 = icmp sge i32 %130, 0
br i1 %131, label %132, label %150
132: ; preds = %129
%133 = load i32, i32* %15
%134 = sext i32 %133 to i64
%135 = load i64, i64* %11
%136 = icmp sge i64 %134, %135
br i1 %136, label %137, label %138
137: ; preds = %132
store i32 -5, i32* %7
br label %205
138: ; preds = %132
%139 = load i8*, i8** @decompress.stack
%140 = load i32, i32* %16
%141 = add nsw i32 %140, -1
store i32 %141, i32* %16
%142 = sext i32 %140 to i64
%143 = getelementptr inbounds i8, i8* %139, i64 %142
%144 = load i8, i8* %143
%145 = load i8*, i8** %10
%146 = load i32, i32* %15
%147 = add nsw i32 %146, 1
store i32 %147, i32* %15
%148 = sext i32 %146 to i64
%149 = getelementptr inbounds i8, i8* %145, i64 %148
store i8 %144, i8* %149
br label %129
150: ; preds = %129
%151 = load i32, i32* %19
%152 = trunc i32 %151 to i8
%153 = load i8*, i8** @decompress.t_suff
%154 = load i32, i32* %20
%155 = sub i32 %154, 1
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds i8, i8* %153, i64 %156
store i8 %152, i8* %157
%158 = load i32, i32* %19
%159 = trunc i32 %158 to i8
%160 = load i8*, i8** @decompress.t_suff
%161 = load i32, i32* %20
%162 = add i32 %161, 1
store i32 %162, i32* %20
%163 = zext i32 %161 to i64
%164 = getelementptr inbounds i8, i8* %160, i64 %163
store i8 %159, i8* %164
%165 = load i32, i32* %20
%166 = load i32, i32* %22
%167 = icmp uge i32 %165, %166
br i1 %167, label %168, label %176
168: ; preds = %150
%169 = load i32, i32* %21
%170 = add i32 %169, 1
store i32 %170, i32* %21
%171 = shl i32 1, %170
store i32 %171, i32* %22
%172 = load i32, i32* %21
%173 = icmp ugt i32 %172, 15
br i1 %173, label %174, label %175
174: ; preds = %168
store i32 -2, i32* %7
br label %205
175: ; preds = %168
br label %176
176: ; preds = %175, %150
br label %178
177: ; preds = %67
store i32 -3, i32* %7
br label %205
178: ; preds = %176
br label %179
179: ; preds = %178
%180 = load i32, i32* %14
%181 = sext i32 %180 to i64
%182 = load i64, i64* %9
%183 = icmp slt i64 %181, %182
br i1 %183, label %184, label %188
184: ; preds = %179
%185 = load i32, i32* %20
%186 = load i32, i32* %12
%187 = icmp ult i32 %185, %186
br label %188
188: ; preds = %184, %179
%189 = phi i1 [ false, %179 ], [ %187, %184 ]
br i1 %189, label %48, label %190
190: ; preds = %188
br label %203
191: ; preds = %44
%192 = load i64, i64* %9
%193 = load i64, i64* %11
%194 = icmp sgt i64 %192, %193
br i1 %194, label %195, label %196
195: ; preds = %191
store i32 -5, i32* %7
br label %205
196: ; preds = %191
%197 = load i8*, i8** %10
%198 = load i8*, i8** %8
%199 = load i64, i64* %9
%200 = call i32 @memcpy(i8* %197, i8* %198, i64 %199)
%201 = load i64, i64* %9
%202 = trunc i64 %201 to i32
store i32 %202, i32* %15
br label %203
203: ; preds = %196, %190
%204 = load i32, i32* %15
store i32 %204, i32* %7
br label %205
205: ; preds = %203, %195, %177, %174, %137, %120, %87, %42, %36, %30
%206 = load i32, i32* %7
ret i32 %206
}

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