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

/* Forward declarations */

/* Type definitions */
typedef int uint32_t;

/* Variables and functions */
uint32_t lz68k_unpack(const char *src, char *dst) {
  uint32_t litcount;
  uint32_t backcount;
  uint32_t backoffset;
  uint32_t unpacked = 0;
  for (;;) {
    litcount = *src;
    ++src;
    if (litcount >= 128) {
      litcount &= 0x7F;
      litcount <<= 8;
      litcount |= (unsigned char)*src;
      ++src;
    }
    while (litcount--) {
      *dst = *src;
      ++dst;
      ++src;
      ++unpacked;
    }
    backoffset = *src;
    ++src;
    if (!backoffset) {
      return unpacked;
    }
    if (backoffset >= 128) {
      backoffset &= 0x7F;
      backoffset <<= 8;
      backoffset |= (unsigned char)*src;
      ++src;
    }
    backcount = *src;
    ++src;
    if (backcount >= 128) {
      backcount &= 0x7F;
      backcount <<= 8;
      backcount |= (unsigned char)*src;
      ++src;
    }
    while (backcount--) {
      *dst = *(dst - backoffset);
      ++dst;
      ++unpacked;
    }
  }
}


x86 assembly (clang, -O0):
<lz68k_unpack>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
cmpl   $0x80,-0x14(%rbp)
jl     1161 <lz68k_unpack+0x61>
mov    -0x14(%rbp),%eax
and    $0x7f,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    1166 <lz68k_unpack+0x66>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     11ac <lz68k_unpack+0xac>
mov    -0x8(%rbp),%rax
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1166 <lz68k_unpack+0x66>
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    11d1 <lz68k_unpack+0xd1>
mov    -0x20(%rbp),%eax
pop    %rbp
ret
cmpl   $0x80,-0x1c(%rbp)
jl     1209 <lz68k_unpack+0x109>
mov    -0x1c(%rbp),%eax
and    $0x7f,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
or     -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
cmpl   $0x80,-0x18(%rbp)
jl     1257 <lz68k_unpack+0x157>
mov    -0x18(%rbp),%eax
and    $0x7f,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x8,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
or     -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    125c <lz68k_unpack+0x15c>
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
cmp    $0x0,%eax
je     12a0 <lz68k_unpack+0x1a0>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    125c <lz68k_unpack+0x15c>
jmp    1113 <lz68k_unpack+0x13>

x86 assembly (clang, -O2):
<lz68k_unpack>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movabs $0xffffffffffffffc,%r8
ff ff 0f
xor    %eax,%eax
movabs $0x1ffffffe0,%r9
jmp    1136 <lz68k_unpack+0x36>
mov    %rsi,%rbp
cs nopw 0x0(%rax,%rax,1)
nop
add    %r10d,%eax
mov    %rbp,%rsi
movsbl (%rdi),%r10d
lea    0x1(%rdi),%rdx
test   %r10d,%r10d
je     1303 <lz68k_unpack+0x203>
lea    -0x1(%r10),%r14d
cmp    $0x1f,%r14d
jb     1173 <lz68k_unpack+0x73>
lea    (%rdi,%r14,1),%rcx
add    $0x2,%rcx
cmp    %rcx,%rsi
jae    121f <lz68k_unpack+0x11f>
lea    (%rsi,%r14,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rdx
jae    121f <lz68k_unpack+0x11f>
mov    %r10d,%ecx
lea    -0x1(%rcx),%r11d
test   $0x7,%cl
je     11c0 <lz68k_unpack+0xc0>
mov    %ecx,%edi
and    $0x7,%edi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movzbl (%rdx),%ebx
mov    %bl,(%rsi,%rbp,1)
add    $0x1,%rdx
add    $0x1,%rbp
cmp    %ebp,%edi
jne    1190 <lz68k_unpack+0x90>
lea    -0x1(%rdx),%rdi
sub    %ebp,%ecx
add    %rbp,%rsi
cmp    $0x7,%r11d
jae    11d0 <lz68k_unpack+0xd0>
jmp    1300 <lz68k_unpack+0x200>
cs nopw 0x0(%rax,%rax,1)
cmp    $0x7,%r11d
jb     1300 <lz68k_unpack+0x200>
nopw   0x0(%rax,%rax,1)
movzbl (%rdx),%ebx
mov    %bl,(%rsi)
movzbl 0x1(%rdx),%ebx
mov    %bl,0x1(%rsi)
movzbl 0x2(%rdx),%ebx
mov    %bl,0x2(%rsi)
movzbl 0x3(%rdx),%ebx
mov    %bl,0x3(%rsi)
movzbl 0x4(%rdx),%ebx
mov    %bl,0x4(%rsi)
movzbl 0x5(%rdx),%ebx
mov    %bl,0x5(%rsi)
movzbl 0x6(%rdx),%ebx
mov    %bl,0x6(%rsi)
movzbl 0x7(%rdx),%ebx
mov    %bl,0x7(%rsi)
add    $0x8,%rsi
add    $0x8,%rdx
add    $0xfffffff8,%ecx
jne    11d0 <lz68k_unpack+0xd0>
mov    %rdx,%rdi
add    $0xffffffffffffffff,%rdi
jmp    1300 <lz68k_unpack+0x200>
add    $0x1,%r14
mov    %r14,%r11
and    %r9,%r11
lea    -0x20(%r11),%rcx
mov    %rcx,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
mov    %ebx,%r15d
and    $0x3,%r15d
cmp    $0x60,%rcx
jae    1249 <lz68k_unpack+0x149>
xor    %ecx,%ecx
jmp    12a9 <lz68k_unpack+0x1a9>
and    %r8,%rbx
xor    %ecx,%ecx
xchg   %ax,%ax
movups 0x1(%rdi,%rcx,1),%xmm0
movups 0x11(%rdi,%rcx,1),%xmm1
movups %xmm0,(%rsi,%rcx,1)
movups %xmm1,0x10(%rsi,%rcx,1)
movups 0x21(%rdi,%rcx,1),%xmm0
movups 0x31(%rdi,%rcx,1),%xmm1
movups %xmm0,0x20(%rsi,%rcx,1)
movups %xmm1,0x30(%rsi,%rcx,1)
movups 0x41(%rdi,%rcx,1),%xmm0
movups 0x51(%rdi,%rcx,1),%xmm1
movups %xmm0,0x40(%rsi,%rcx,1)
movups %xmm1,0x50(%rsi,%rcx,1)
movups 0x61(%rdi,%rcx,1),%xmm0
movups 0x71(%rdi,%rcx,1),%xmm1
movups %xmm0,0x60(%rsi,%rcx,1)
movups %xmm1,0x70(%rsi,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rbx
jne    1250 <lz68k_unpack+0x150>
test   %r15,%r15
je     12eb <lz68k_unpack+0x1eb>
lea    (%rsi,%rcx,1),%rbx
add    $0x10,%rbx
add    %rdi,%rcx
add    $0x11,%rcx
shl    $0x5,%r15
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rcx,%rbp,1),%xmm0
movups (%rcx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rbx,%rbp,1)
movups %xmm1,(%rbx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r15
jne    12d0 <lz68k_unpack+0x1d0>
add    %r11,%rdx
add    %r11,%rsi
cmp    %r11,%r14
jne    141c <lz68k_unpack+0x31c>
add    %r11,%rdi
nopl   (%rax)
add    %r10d,%eax
movsbq (%rdx),%r15
test   %r15,%r15
je     14e3 <lz68k_unpack+0x3e3>
movsbl 0x2(%rdi),%r10d
add    $0x3,%rdi
test   %r10d,%r10d
je     1136 <lz68k_unpack+0x36>
mov    %r15,%r12
neg    %r12
lea    -0x1(%r10),%r11d
cmp    $0x1f,%r11d
jb     135d <lz68k_unpack+0x25d>
mov    %r11,%rcx
sub    %r15,%rcx
add    %rsi,%rcx
add    $0x1,%rcx
cmp    %rcx,%rsi
jae    13ef <lz68k_unpack+0x2ef>
lea    (%rsi,%r11,1),%rcx
add    $0x1,%rcx
lea    (%rsi,%r12,1),%rdx
cmp    %rcx,%rdx
jae    13ef <lz68k_unpack+0x2ef>
mov    %r10d,%ecx
lea    -0x1(%rcx),%r11d
mov    %ecx,%edx
and    $0x7,%edx
je     1384 <lz68k_unpack+0x284>
xor    %ebp,%ebp
nopl   (%rax)
movzbl (%rsi,%r12,1),%ebx
mov    %bl,(%rsi)
add    $0x1,%rsi
add    $0x1,%ebp
cmp    %ebp,%edx
jne    1370 <lz68k_unpack+0x270>
sub    %ebp,%ecx
mov    %rsi,%rbp
cmp    $0x7,%r11d
jb     1130 <lz68k_unpack+0x30>
mov    $0x7,%edx
sub    %r15,%rdx
nopl   0x0(%rax)
movzbl -0x7(%rsi,%rdx,1),%ebx
mov    %bl,(%rsi)
movzbl -0x6(%rsi,%rdx,1),%ebx
mov    %bl,0x1(%rsi)
movzbl -0x5(%rsi,%rdx,1),%ebx
mov    %bl,0x2(%rsi)
movzbl -0x4(%rsi,%rdx,1),%ebx
mov    %bl,0x3(%rsi)
movzbl -0x3(%rsi,%rdx,1),%ebx
mov    %bl,0x4(%rsi)
movzbl -0x2(%rsi,%rdx,1),%ebx
mov    %bl,0x5(%rsi)
movzbl -0x1(%rsi,%rdx,1),%ebx
mov    %bl,0x6(%rsi)
lea    0x8(%rsi),%rbp
movzbl (%rsi,%rdx,1),%ebx
mov    %bl,0x7(%rsi)
mov    %rbp,%rsi
add    $0xfffffff8,%ecx
jne    13a0 <lz68k_unpack+0x2a0>
jmp    1130 <lz68k_unpack+0x30>
add    $0x1,%r11
mov    %r11,%r14
and    %r9,%r14
lea    -0x20(%r14),%rdx
mov    %rdx,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%r13d
and    $0x3,%r13d
cmp    $0x60,%rdx
jae    1427 <lz68k_unpack+0x327>
xor    %edx,%edx
jmp    1499 <lz68k_unpack+0x399>
mov    %r10d,%ecx
sub    %r11d,%ecx
jmp    1176 <lz68k_unpack+0x76>
and    %r8,%rcx
lea    0x70(%rsi),%rbx
lea    (%rsi,%r12,1),%rbp
add    $0x70,%rbp
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x70(%rbp,%rdx,1),%xmm0
movups -0x60(%rbp,%rdx,1),%xmm1
movups %xmm0,-0x70(%rbx,%rdx,1)
movups %xmm1,-0x60(%rbx,%rdx,1)
movups -0x50(%rbp,%rdx,1),%xmm0
movups -0x40(%rbp,%rdx,1),%xmm1
movups %xmm0,-0x50(%rbx,%rdx,1)
movups %xmm1,-0x40(%rbx,%rdx,1)
movups -0x30(%rbp,%rdx,1),%xmm0
movups -0x20(%rbp,%rdx,1),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,1)
movups %xmm1,-0x20(%rbx,%rdx,1)
movups -0x10(%rbp,%rdx,1),%xmm0
movups 0x0(%rbp,%rdx,1),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,1)
movups %xmm1,(%rbx,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1440 <lz68k_unpack+0x340>
test   %r13,%r13
je     14cc <lz68k_unpack+0x3cc>
lea    (%rsi,%rdx,1),%rcx
add    $0x10,%rcx
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rcx,%r12,1),%xmm0
movups (%rcx,%r12,1),%xmm1
movups %xmm0,-0x10(%rcx)
movups %xmm1,(%rcx)
add    $0x20,%rcx
add    $0xffffffffffffffff,%r13
jne    14b0 <lz68k_unpack+0x3b0>
add    %r14,%rsi
cmp    %r14,%r11
je     1122 <lz68k_unpack+0x22>
mov    %r10d,%ecx
sub    %r14d,%ecx
jmp    1360 <lz68k_unpack+0x260>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @lz68k_unpack(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i8* %0, i8** %3
store i8* %1, i8** %4
store i32 0, i32* %8
br label %9
9: ; preds = %106, %2
%10 = load i8*, i8** %3
%11 = load i8, i8* %10
%12 = sext i8 %11 to i32
store i32 %12, i32* %5
%13 = load i8*, i8** %3
%14 = getelementptr inbounds i8, i8* %13, i32 1
store i8* %14, i8** %3
%15 = load i32, i32* %5
%16 = icmp sge i32 %15, 128
br i1 %16, label %17, label %29
17: ; preds = %9
%18 = load i32, i32* %5
%19 = and i32 %18, 127
store i32 %19, i32* %5
%20 = load i32, i32* %5
%21 = shl i32 %20, 8
store i32 %21, i32* %5
%22 = load i8*, i8** %3
%23 = load i8, i8* %22
%24 = zext i8 %23 to i32
%25 = load i32, i32* %5
%26 = or i32 %25, %24
store i32 %26, i32* %5
%27 = load i8*, i8** %3
%28 = getelementptr inbounds i8, i8* %27, i32 1
store i8* %28, i8** %3
br label %29
29: ; preds = %17, %9
br label %30
30: ; preds = %34, %29
%31 = load i32, i32* %5
%32 = add nsw i32 %31, -1
store i32 %32, i32* %5
%33 = icmp ne i32 %31, 0
br i1 %33, label %34, label %44
34: ; preds = %30
%35 = load i8*, i8** %3
%36 = load i8, i8* %35
%37 = load i8*, i8** %4
store i8 %36, i8* %37
%38 = load i8*, i8** %4
%39 = getelementptr inbounds i8, i8* %38, i32 1
store i8* %39, i8** %4
%40 = load i8*, i8** %3
%41 = getelementptr inbounds i8, i8* %40, i32 1
store i8* %41, i8** %3
%42 = load i32, i32* %8
%43 = add nsw i32 %42, 1
store i32 %43, i32* %8
br label %30
44: ; preds = %30
%45 = load i8*, i8** %3
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
store i32 %47, i32* %7
%48 = load i8*, i8** %3
%49 = getelementptr inbounds i8, i8* %48, i32 1
store i8* %49, i8** %3
%50 = load i32, i32* %7
%51 = icmp ne i32 %50, 0
br i1 %51, label %54, label %52
52: ; preds = %44
%53 = load i32, i32* %8
ret i32 %53
54: ; preds = %44
%55 = load i32, i32* %7
%56 = icmp sge i32 %55, 128
br i1 %56, label %57, label %69
57: ; preds = %54
%58 = load i32, i32* %7
%59 = and i32 %58, 127
store i32 %59, i32* %7
%60 = load i32, i32* %7
%61 = shl i32 %60, 8
store i32 %61, i32* %7
%62 = load i8*, i8** %3
%63 = load i8, i8* %62
%64 = zext i8 %63 to i32
%65 = load i32, i32* %7
%66 = or i32 %65, %64
store i32 %66, i32* %7
%67 = load i8*, i8** %3
%68 = getelementptr inbounds i8, i8* %67, i32 1
store i8* %68, i8** %3
br label %69
69: ; preds = %57, %54
%70 = load i8*, i8** %3
%71 = load i8, i8* %70
%72 = sext i8 %71 to i32
store i32 %72, i32* %6
%73 = load i8*, i8** %3
%74 = getelementptr inbounds i8, i8* %73, i32 1
store i8* %74, i8** %3
%75 = load i32, i32* %6
%76 = icmp sge i32 %75, 128
br i1 %76, label %77, label %89
77: ; preds = %69
%78 = load i32, i32* %6
%79 = and i32 %78, 127
store i32 %79, i32* %6
%80 = load i32, i32* %6
%81 = shl i32 %80, 8
store i32 %81, i32* %6
%82 = load i8*, i8** %3
%83 = load i8, i8* %82
%84 = zext i8 %83 to i32
%85 = load i32, i32* %6
%86 = or i32 %85, %84
store i32 %86, i32* %6
%87 = load i8*, i8** %3
%88 = getelementptr inbounds i8, i8* %87, i32 1
store i8* %88, i8** %3
br label %89
89: ; preds = %77, %69
br label %90
90: ; preds = %94, %89
%91 = load i32, i32* %6
%92 = add nsw i32 %91, -1
store i32 %92, i32* %6
%93 = icmp ne i32 %91, 0
br i1 %93, label %94, label %106
94: ; preds = %90
%95 = load i8*, i8** %4
%96 = load i32, i32* %7
%97 = sext i32 %96 to i64
%98 = sub i64 0, %97
%99 = getelementptr inbounds i8, i8* %95, i64 %98
%100 = load i8, i8* %99
%101 = load i8*, i8** %4
store i8 %100, i8* %101
%102 = load i8*, i8** %4
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %4
%104 = load i32, i32* %8
%105 = add nsw i32 %104, 1
store i32 %105, i32* %8
br label %90
106: ; preds = %90
br label %9
}

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