#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 uint8_t;
typedef int uint32_t;
typedef int *uint16_t;

/* Variables and functions */
int *malloc(int);
int decompress(uint8_t *input, int inputLength, uint8_t **outputRef) {
  uint8_t *inputEnd = input + inputLength;
  int uncompressedLength = *(uint32_t *)input;
  input += sizeof(uint32_t);
  *outputRef = malloc(uncompressedLength);
  uint8_t *output = *outputRef;
  while (input < inputEnd) {
    if ((*input & 0x80) == 0) {
      uint8_t length = *input++;
      while (length > 0) {
        *output++ = *input++;
        length--;
      }
    } else {
      uint8_t firstByte = *input++;
      uint8_t length = firstByte & 0x3f;
      uint16_t offset;
      if ((firstByte & 0x40) == 0) {
        offset = *input++;
      } else {
        offset = *(uint16_t *)input;
        input += sizeof(uint16_t);
      }
      uint8_t *start = output - offset;
      while (length > 0) {
        *output++ = *start++;
        length--;
      }
    }
  }
  return (int)(output - *outputRef);
}


x86 assembly (clang, -O0):
<decompress>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
mov    -0x24(%rbp),%edi
call   1030 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1292 <decompress+0x182>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
jne    11dd <decompress+0xcd>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jle    11d8 <decompress+0xc8>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    119e <decompress+0x8e>
jmp    128d <decompress+0x17d>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
and    $0x3f,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
jne    1224 <decompress+0x114>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
movslq (%rax),%rax
mov    %rax,-0x48(%rbp)
jmp    123b <decompress+0x12b>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x8(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %rax,-0x50(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jle    1288 <decompress+0x178>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x50(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    124e <decompress+0x13e>
jmp    128d <decompress+0x17d>
jmp    1168 <decompress+0x58>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decompress>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %rdx,%r14
mov    %esi,%ebp
mov    %rdi,%rbx
mov    (%rdi),%edi
call   1030 <malloc@plt>
mov    %rax,(%r14)
cmp    $0x5,%ebp
jl     1429 <decompress+0x319>
movslq %ebp,%rcx
lea    (%rbx,%rcx,4),%r9
movabs $0x1fffffff8,%r8
add    $0x10,%rbx
mov    %rax,%rdx
jmp    115c <decompress+0x4c>
nopl   0x0(%rax)
mov    %rdi,%rbx
cmp    %r9,%rdi
jae    142c <decompress+0x31c>
mov    (%rbx),%ebp
test   $0x80,%bpl
jne    11d0 <decompress+0xc0>
lea    0x4(%rbx),%rdi
test   %ebp,%ebp
jle    1150 <decompress+0x40>
lea    -0x1(%rbp),%r11d
cmp    $0x7,%r11d
jb     1330 <decompress+0x220>
lea    (%rbx,%r11,4),%rcx
add    $0x8,%rcx
cmp    %rcx,%rdx
jae    1198 <decompress+0x88>
lea    (%rdx,%r11,4),%rcx
add    $0x4,%rcx
cmp    %rcx,%rdi
jb     1330 <decompress+0x220>
add    $0x1,%r11
mov    %r11,%r10
and    %r8,%r10
lea    -0x8(%r10),%rcx
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%r14d
and    $0x3,%r14d
cmp    $0x18,%rcx
jae    126b <decompress+0x15b>
xor    %ecx,%ecx
jmp    12d9 <decompress+0x1c9>
nopl   0x0(%rax)
mov    %ebp,%esi
and    $0x3f,%esi
test   $0x40,%bpl
jne    11f0 <decompress+0xe0>
movslq 0x4(%rbx),%rbp
add    $0x8,%rbx
jmp    11f8 <decompress+0xe8>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x4(%rbx),%rbp
add    $0x24,%rbx
mov    %rbx,%rdi
test   %esi,%esi
je     1150 <decompress+0x40>
mov    %rdx,%rcx
sub    %rbp,%rcx
sar    $0x2,%rcx
lea    -0x1(%rsi),%r11d
cmp    $0x3,%r11d
jb     1400 <decompress+0x2f0>
lea    (%rcx,%r11,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%rdx
jae    1239 <decompress+0x129>
lea    (%rdx,%r11,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%rcx
jb     1400 <decompress+0x2f0>
add    $0x1,%r11
lea    0x4(%r8),%r10
and    %r11,%r10
lea    -0x4(%r10),%rbp
mov    %rbp,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %ebx,%r14d
and    $0x7,%r14d
cmp    $0x1c,%rbp
jae    1359 <decompress+0x249>
xor    %ebp,%ebp
jmp    13b8 <decompress+0x2a8>
and    $0xfffffffffffffffc,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x4(%rbx,%rcx,4),%xmm0
movups 0x14(%rbx,%rcx,4),%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
movups 0x24(%rbx,%rcx,4),%xmm0
movups 0x34(%rbx,%rcx,4),%xmm1
movups %xmm0,0x20(%rdx,%rcx,4)
movups %xmm1,0x30(%rdx,%rcx,4)
movups 0x44(%rbx,%rcx,4),%xmm0
movups 0x54(%rbx,%rcx,4),%xmm1
movups %xmm0,0x40(%rdx,%rcx,4)
movups %xmm1,0x50(%rdx,%rcx,4)
movups 0x64(%rbx,%rcx,4),%xmm0
movups 0x74(%rbx,%rcx,4),%xmm1
movups %xmm0,0x60(%rdx,%rcx,4)
movups %xmm1,0x70(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rsi
jne    1280 <decompress+0x170>
test   %r14,%r14
je     131b <decompress+0x20b>
lea    (%rdx,%rcx,4),%rsi
add    $0x10,%rsi
lea    (%rbx,%rcx,4),%rcx
add    $0x14,%rcx
shl    $0x5,%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbx,1)
movups %xmm1,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r14
jne    1300 <decompress+0x1f0>
lea    (%rdi,%r10,4),%rdi
lea    (%rdx,%r10,4),%rdx
cmp    %r10,%r11
je     1150 <decompress+0x40>
sub    %r10d,%ebp
nop
add    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdi),%ecx
mov    %ecx,(%rdx)
add    $0x4,%rdx
add    $0x4,%rdi
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     1340 <decompress+0x230>
jmp    1150 <decompress+0x40>
and    $0xfffffffffffffff8,%rbx
xor    %ebp,%ebp
nop
movups (%rcx,%rbp,4),%xmm0
movups %xmm0,(%rdx,%rbp,4)
movups 0x10(%rcx,%rbp,4),%xmm0
movups %xmm0,0x10(%rdx,%rbp,4)
movups 0x20(%rcx,%rbp,4),%xmm0
movups %xmm0,0x20(%rdx,%rbp,4)
movups 0x30(%rcx,%rbp,4),%xmm0
movups %xmm0,0x30(%rdx,%rbp,4)
movups 0x40(%rcx,%rbp,4),%xmm0
movups %xmm0,0x40(%rdx,%rbp,4)
movups 0x50(%rcx,%rbp,4),%xmm0
movups %xmm0,0x50(%rdx,%rbp,4)
movups 0x60(%rcx,%rbp,4),%xmm0
movups %xmm0,0x60(%rdx,%rbp,4)
movups 0x70(%rcx,%rbp,4),%xmm0
movups %xmm0,0x70(%rdx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffff8,%rbx
jne    1360 <decompress+0x250>
test   %r14,%r14
je     13e3 <decompress+0x2d3>
lea    (%rdx,%rbp,4),%r15
lea    (%rcx,%rbp,4),%rbp
shl    $0x4,%r14
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups 0x0(%rbp,%rbx,1),%xmm0
movups %xmm0,(%r15,%rbx,1)
add    $0x10,%rbx
cmp    %rbx,%r14
jne    13d0 <decompress+0x2c0>
lea    (%rdx,%r10,4),%rdx
cmp    %r10,%r11
je     1150 <decompress+0x40>
lea    (%rcx,%r10,4),%rcx
sub    %r10d,%esi
nopw   0x0(%rax,%rax,1)
add    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rcx),%ebp
add    $0x4,%rcx
mov    %ebp,(%rdx)
add    $0x4,%rdx
add    $0xffffffff,%esi
cmp    $0x1,%esi
ja     1410 <decompress+0x300>
jmp    1150 <decompress+0x40>
mov    %rax,%rdx
sub    %rax,%rdx
shr    $0x2,%rdx
mov    %edx,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

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