#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 */
char pow(int, unsigned short);
int stage_1(long *pointer, char *rompointer, char *bufferpointer) {
  unsigned short in_val;
  unsigned short out_val = 0;
  unsigned short num_times;
  unsigned short offset;
  for (in_val = (*((*pointer)++ + rompointer) & 0xFF); in_val != 0xFF;
       in_val = (*((*pointer)++ + rompointer) & 0xFF)) {
    if (in_val > 0x7F) {
      out_val = in_val;
      in_val = (*((*pointer)++ + rompointer) & 0xFF);
    }
    num_times = 0x08 - (in_val & 0x0F);
    in_val = ((in_val & 0xF0) / 0x10) + ((in_val & 0x0F) * 0x10);
    out_val = (out_val & 0x0F) + (in_val * 0x10);
    offset = (*((*pointer)++ + rompointer) & 0xFF) * pow(2, (num_times + 1));
    if (offset >= 0x200) {
      return -1;
    }
    num_times = pow(2, num_times);
    for (; num_times != 0; num_times--, offset += 2) {
      *(bufferpointer + offset + 1) = (out_val & 0x00FF);
      *(bufferpointer + offset) = ((out_val & 0xFF00) / 0x100);
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<stage_1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movw   $0x0,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax,%rcx,1),%eax
and    $0xff,%eax
mov    %ax,-0x22(%rbp)
movzwl -0x22(%rbp),%eax
cmp    $0xff,%eax
je     12dd <stage_1+0x1cd>
movzwl -0x22(%rbp),%eax
cmp    $0x7f,%eax
jle    1192 <stage_1+0x82>
mov    -0x22(%rbp),%ax
mov    %ax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax,%rcx,1),%eax
and    $0xff,%eax
mov    %ax,-0x22(%rbp)
movzwl -0x22(%rbp),%ecx
and    $0xf,%ecx
mov    $0x8,%eax
sub    %ecx,%eax
mov    %ax,-0x26(%rbp)
movzwl -0x22(%rbp),%eax
and    $0xf0,%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
movzwl -0x22(%rbp),%ecx
and    $0xf,%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %ax,-0x22(%rbp)
movzwl -0x24(%rbp),%eax
and    $0xf,%eax
movzwl -0x22(%rbp),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    %ax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax,%rcx,1),%eax
and    $0xff,%eax
mov    %eax,-0x2c(%rbp)
movzwl -0x26(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%edi
movzwl %ax,%esi
call   1030 <pow@plt>
mov    %al,%cl
mov    -0x2c(%rbp),%eax
movsbl %cl,%ecx
imul   %ecx,%eax
mov    %ax,-0x28(%rbp)
movzwl -0x28(%rbp),%eax
cmp    $0x200,%eax
jl     1238 <stage_1+0x128>
movl   $0xffffffff,-0x4(%rbp)
jmp    12e4 <stage_1+0x1d4>
mov    $0x2,%edi
movzwl -0x26(%rbp),%esi
call   1030 <pow@plt>
movsbl %al,%eax
mov    %ax,-0x26(%rbp)
movzwl -0x26(%rbp),%eax
cmp    $0x0,%eax
je     12b1 <stage_1+0x1a1>
movzwl -0x24(%rbp),%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movzwl -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,0x1(%rax,%rcx,1)
movzwl -0x24(%rbp),%eax
and    $0xff00,%eax
mov    $0x100,%ecx
cltd
idiv   %ecx
mov    %al,%dl
mov    -0x20(%rbp),%rax
movzwl -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x26(%rbp),%ax
add    $0xffff,%ax
mov    %ax,-0x26(%rbp)
movzwl -0x28(%rbp),%eax
add    $0x2,%eax
mov    %ax,-0x28(%rbp)
jmp    124d <stage_1+0x13d>
jmp    12b6 <stage_1+0x1a6>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,(%rax)
mov    -0x18(%rbp),%rax
movsbl (%rax,%rcx,1),%eax
and    $0xff,%eax
mov    %ax,-0x22(%rbp)
jmp    114c <stage_1+0x3c>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stage_1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%rbx
mov    (%rdi),%rcx
lea    0x1(%rcx),%rax
mov    %rax,(%rdi)
mov    (%rsi,%rcx,1),%dl
cmp    $0xff,%dl
je     13e0 <stage_1+0x2d0>
lea    0x1(%rbx),%rbp
mov    %rbp,(%rsp)
xor    %r13d,%r13d
mov    %rsi,0x10(%rsp)
mov    %rdi,0x8(%rsp)
jmp    1170 <stage_1+0x60>
xchg   %ax,%ax
mov    0x8(%rsp),%rdi
mov    (%rdi),%rcx
lea    0x1(%rcx),%rax
mov    %rax,(%rdi)
mov    0x10(%rsp),%rsi
mov    (%rsi,%rcx,1),%dl
cmp    $0xff,%dl
je     13e0 <stage_1+0x2d0>
movzbl %dl,%r15d
test   %r15b,%r15b
js     1190 <stage_1+0x80>
mov    %r15d,%edx
mov    %r13d,%r15d
jmp    119e <stage_1+0x8e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rcx
mov    %rcx,(%rdi)
movzbl (%rsi,%rax,1),%edx
mov    %rcx,%rax
movzwl %dx,%r13d
mov    %r13d,%ebp
and    $0xf,%ebp
lea    0x1(%rax),%rcx
mov    %rcx,(%rdi)
movzbl (%rsi,%rax,1),%r14d
mov    $0x9,%eax
sub    %ebp,%eax
movzwl %ax,%esi
mov    $0x2,%edi
call   1030 <pow@plt>
movsbl %al,%r12d
imul   %r14d,%r12d
movzwl %r12w,%r14d
cmp    $0x1ff,%r14d
ja     13e4 <stage_1+0x2d4>
and    $0xfffffff0,%r13d
mov    %ebp,%eax
shl    $0x8,%eax
or     %r13d,%eax
and    $0xf,%r15d
or     %eax,%r15d
mov    %r15d,%r13d
movzwl %bp,%eax
mov    $0x8,%ecx
sub    %eax,%ecx
movzwl %cx,%esi
mov    $0x2,%edi
call   1030 <pow@plt>
test   %al,%al
je     1150 <stage_1+0x40>
movsbl %al,%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
cmp    $0xf,%cx
jb     1340 <stage_1+0x230>
movswl %ax,%r8d
lea    -0x1(%r8),%edx
mov    %edx,%edi
add    %dx,%di
setb   %sil
add    %r12w,%di
jb     1340 <stage_1+0x230>
test   %sil,%sil
jne    1340 <stage_1+0x230>
mov    (%rsp),%rsi
add    %r14,%rsi
movzwl %dx,%edx
lea    (%rsi,%rdx,2),%rdi
cmp    %rsi,%rdi
jb     1340 <stage_1+0x230>
add    %rbx,%r14
lea    (%r14,%rdx,2),%rdx
cmp    %r14,%rdx
jb     1340 <stage_1+0x230>
movzwl %cx,%r9d
add    $0x1,%r9d
mov    %r9d,%r10d
and    $0xfffffff0,%r10d
movzbl %bpl,%ecx
movd   %ecx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
movzbl %r13b,%ecx
movd   %ecx,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
punpcklbw %xmm1,%xmm0
lea    -0x10(%r10),%edx
mov    %edx,%r11d
shr    $0x4,%r11d
add    $0x1,%r11d
test   %edx,%edx
je     13cf <stage_1+0x2bf>
mov    %r11d,%esi
and    $0xfffffffe,%esi
xor    %edi,%edi
mov    %r12d,%edx
nopw   0x0(%rax,%rax,1)
lea    0x10(%rdx),%eax
movzwl %dx,%ecx
movzwl %ax,%eax
movdqu %xmm0,(%rbx,%rcx,1)
movdqu %xmm0,(%rbx,%rax,1)
lea    0x20(%rdx),%eax
lea    0x30(%rdx),%ecx
movzwl %ax,%eax
movzwl %cx,%ecx
movdqu %xmm0,(%rbx,%rax,1)
movdqu %xmm0,(%rbx,%rcx,1)
add    $0x20,%edi
add    $0x40,%edx
add    $0xfffffffe,%esi
jne    12d0 <stage_1+0x1c0>
test   $0x1,%r11b
je     1325 <stage_1+0x215>
lea    (%r12,%rdi,2),%eax
lea    (%r12,%rdi,2),%ecx
add    $0x10,%ecx
movzwl %ax,%eax
movzwl %cx,%ecx
movdqu %xmm0,(%rbx,%rax,1)
movdqu %xmm0,(%rbx,%rcx,1)
cmp    %r10d,%r9d
je     1150 <stage_1+0x40>
sub    %r10d,%r8d
lea    (%r12,%r10,2),%r12d
mov    %r8d,%eax
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rax),%ecx
mov    %eax,%esi
and    $0x3,%si
je     136b <stage_1+0x25b>
xor    %edx,%edx
nopl   (%rax)
movzwl %r12w,%edi
mov    %r13b,0x1(%rbx,%rdi,1)
mov    %bpl,(%rbx,%rdi,1)
add    $0x2,%r12d
add    $0x1,%edx
cmp    %dx,%si
jne    1350 <stage_1+0x240>
sub    %edx,%eax
cmp    $0x3,%cx
jb     1150 <stage_1+0x40>
cs nopw 0x0(%rax,%rax,1)
nop
movzwl %r12w,%ecx
mov    %r13b,0x1(%rbx,%rcx,1)
mov    %bpl,(%rbx,%rcx,1)
lea    0x2(%r12),%ecx
movzwl %cx,%ecx
mov    %r13b,0x1(%rbx,%rcx,1)
mov    %bpl,(%rbx,%rcx,1)
lea    0x4(%r12),%ecx
movzwl %cx,%ecx
mov    %r13b,0x1(%rbx,%rcx,1)
mov    %bpl,(%rbx,%rcx,1)
lea    0x6(%r12),%ecx
movzwl %cx,%ecx
mov    %r13b,0x1(%rbx,%rcx,1)
mov    %bpl,(%rbx,%rcx,1)
add    $0x8,%r12d
add    $0xfffc,%ax
jne    1380 <stage_1+0x270>
jmp    1150 <stage_1+0x40>
xor    %edi,%edi
test   $0x1,%r11b
jne    130a <stage_1+0x1fa>
jmp    1325 <stage_1+0x215>
xor    %eax,%eax
jmp    13e9 <stage_1+0x2d9>
mov    $0xffffffff,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @stage_1(i64* %0, i8* %1, i8* %2) {
%4 = alloca i32
%5 = alloca i64*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i16
%9 = alloca i16
%10 = alloca i16
%11 = alloca i16
store i64* %0, i64** %5
store i8* %1, i8** %6
store i8* %2, i8** %7
store i16 0, i16* %9
%12 = load i64*, i64** %5
%13 = load i64, i64* %12
%14 = add nsw i64 %13, 1
store i64 %14, i64* %12
%15 = load i8*, i8** %6
%16 = getelementptr inbounds i8, i8* %15, i64 %13
%17 = load i8, i8* %16
%18 = sext i8 %17 to i32
%19 = and i32 %18, 255
%20 = trunc i32 %19 to i16
store i16 %20, i16* %8
br label %21
21: ; preds = %121, %3
%22 = load i16, i16* %8
%23 = zext i16 %22 to i32
%24 = icmp ne i32 %23, 255
br i1 %24, label %25, label %131
25: ; preds = %21
%26 = load i16, i16* %8
%27 = zext i16 %26 to i32
%28 = icmp sgt i32 %27, 127
br i1 %28, label %29, label %40
29: ; preds = %25
%30 = load i16, i16* %8
store i16 %30, i16* %9
%31 = load i64*, i64** %5
%32 = load i64, i64* %31
%33 = add nsw i64 %32, 1
store i64 %33, i64* %31
%34 = load i8*, i8** %6
%35 = getelementptr inbounds i8, i8* %34, i64 %32
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
%38 = and i32 %37, 255
%39 = trunc i32 %38 to i16
store i16 %39, i16* %8
br label %40
40: ; preds = %29, %25
%41 = load i16, i16* %8
%42 = zext i16 %41 to i32
%43 = and i32 %42, 15
%44 = sub nsw i32 8, %43
%45 = trunc i32 %44 to i16
store i16 %45, i16* %10
%46 = load i16, i16* %8
%47 = zext i16 %46 to i32
%48 = and i32 %47, 240
%49 = sdiv i32 %48, 16
%50 = load i16, i16* %8
%51 = zext i16 %50 to i32
%52 = and i32 %51, 15
%53 = mul nsw i32 %52, 16
%54 = add nsw i32 %49, %53
%55 = trunc i32 %54 to i16
store i16 %55, i16* %8
%56 = load i16, i16* %9
%57 = zext i16 %56 to i32
%58 = and i32 %57, 15
%59 = load i16, i16* %8
%60 = zext i16 %59 to i32
%61 = mul nsw i32 %60, 16
%62 = add nsw i32 %58, %61
%63 = trunc i32 %62 to i16
store i16 %63, i16* %9
%64 = load i64*, i64** %5
%65 = load i64, i64* %64
%66 = add nsw i64 %65, 1
store i64 %66, i64* %64
%67 = load i8*, i8** %6
%68 = getelementptr inbounds i8, i8* %67, i64 %65
%69 = load i8, i8* %68
%70 = sext i8 %69 to i32
%71 = and i32 %70, 255
%72 = load i16, i16* %10
%73 = zext i16 %72 to i32
%74 = add nsw i32 %73, 1
%75 = trunc i32 %74 to i16
%76 = call signext i8 @pow(i32 2, i16 zeroext %75)
%77 = sext i8 %76 to i32
%78 = mul nsw i32 %71, %77
%79 = trunc i32 %78 to i16
store i16 %79, i16* %11
%80 = load i16, i16* %11
%81 = zext i16 %80 to i32
%82 = icmp sge i32 %81, 512
br i1 %82, label %83, label %84
83: ; preds = %40
store i32 -1, i32* %4
br label %132
84: ; preds = %40
%85 = load i16, i16* %10
%86 = call signext i8 @pow(i32 2, i16 zeroext %85)
%87 = sext i8 %86 to i16
store i16 %87, i16* %10
br label %88
88: ; preds = %113, %84
%89 = load i16, i16* %10
%90 = zext i16 %89 to i32
%91 = icmp ne i32 %90, 0
br i1 %91, label %92, label %120
92: ; preds = %88
%93 = load i16, i16* %9
%94 = zext i16 %93 to i32
%95 = and i32 %94, 255
%96 = trunc i32 %95 to i8
%97 = load i8*, i8** %7
%98 = load i16, i16* %11
%99 = zext i16 %98 to i32
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %97, i64 %100
%102 = getelementptr inbounds i8, i8* %101, i64 1
store i8 %96, i8* %102
%103 = load i16, i16* %9
%104 = zext i16 %103 to i32
%105 = and i32 %104, 65280
%106 = sdiv i32 %105, 256
%107 = trunc i32 %106 to i8
%108 = load i8*, i8** %7
%109 = load i16, i16* %11
%110 = zext i16 %109 to i32
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i8, i8* %108, i64 %111
store i8 %107, i8* %112
br label %113
113: ; preds = %92
%114 = load i16, i16* %10
%115 = add i16 %114, -1
store i16 %115, i16* %10
%116 = load i16, i16* %11
%117 = zext i16 %116 to i32
%118 = add nsw i32 %117, 2
%119 = trunc i32 %118 to i16
store i16 %119, i16* %11
br label %88
120: ; preds = %88
br label %121
121: ; preds = %120
%122 = load i64*, i64** %5
%123 = load i64, i64* %122
%124 = add nsw i64 %123, 1
store i64 %124, i64* %122
%125 = load i8*, i8** %6
%126 = getelementptr inbounds i8, i8* %125, i64 %123
%127 = load i8, i8* %126
%128 = sext i8 %127 to i32
%129 = and i32 %128, 255
%130 = trunc i32 %129 to i16
store i16 %130, i16* %8
br label %21
131: ; preds = %21
store i32 0, i32* %4
br label %132
132: ; preds = %131, %83
%133 = load i32, i32* %4
ret i32 %133
}

LLVM IR (-O2):
define i32 @stage_1(i64* nocapture %0, i8* nocapture %1, i8* nocapture writeonly %2) {
%4 = load i64, i64* %0
%5 = add nsw i64 %4, 1
store i64 %5, i64* %0
%6 = getelementptr inbounds i8, i8* %1, i64 %4
%7 = load i8, i8* %6
%8 = icmp eq i8 %7, -1
br i1 %8, label %197, label %9
9: ; preds = %3
%10 = getelementptr i8, i8* %2, i64 1
br label %17
11: ; preds = %172, %176, %153, %51
%12 = load i64, i64* %0
%13 = add nsw i64 %12, 1
store i64 %13, i64* %0
%14 = getelementptr inbounds i8, i8* %1, i64 %12
%15 = load i8, i8* %14
%16 = icmp eq i8 %15, -1
br i1 %16, label %197, label %17
17: ; preds = %9, %11
%18 = phi i8 [ %15, %11 ], [ %7, %9 ]
%19 = phi i64 [ %13, %11 ], [ %5, %9 ]
%20 = phi i64 [ %12, %11 ], [ %4, %9 ]
%21 = phi i16 [ %41, %11 ], [ 0, %9 ]
%22 = zext i8 %18 to i16
%23 = icmp slt i8 %18, 0
br i1 %23, label %24, label %29
24: ; preds = %17
%25 = add nsw i64 %20, 2
store i64 %25, i64* %0
%26 = getelementptr inbounds i8, i8* %1, i64 %19
%27 = load i8, i8* %26
%28 = zext i8 %27 to i16
br label %29
29: ; preds = %24, %17
%30 = phi i64 [ %25, %24 ], [ %19, %17 ]
%31 = phi i16 [ %28, %24 ], [ %22, %17 ]
%32 = phi i16 [ %22, %24 ], [ %21, %17 ]
%33 = zext i16 %31 to i32
%34 = and i32 %33, 15
%35 = trunc i32 %34 to i16
%36 = and i32 %33, 240
%37 = shl nuw nsw i32 %34, 8
%38 = or i32 %37, %36
%39 = and i16 %32, 15
%40 = trunc i32 %38 to i16
%41 = or i16 %39, %40
%42 = add nsw i64 %30, 1
store i64 %42, i64* %0
%43 = getelementptr inbounds i8, i8* %1, i64 %30
%44 = load i8, i8* %43
%45 = zext i8 %44 to i16
%46 = sub nsw i16 9, %35
%47 = tail call signext i8 @pow(i32 2, i16 zeroext %46)
%48 = sext i8 %47 to i16
%49 = mul nsw i16 %48, %45
%50 = icmp ugt i16 %49, 511
br i1 %50, label %197, label %51
51: ; preds = %29
%52 = sub nsw i16 8, %35
%53 = tail call signext i8 @pow(i32 2, i16 zeroext %52)
%54 = icmp eq i8 %53, 0
br i1 %54, label %11, label %55
55: ; preds = %51
%56 = sext i8 %53 to i16
%57 = trunc i16 %41 to i8
%58 = trunc i32 %34 to i8
%59 = add nsw i16 %56, -1
%60 = zext i16 %59 to i32
%61 = add nuw nsw i32 %60, 1
%62 = icmp ult i16 %59, 15
br i1 %62, label %155, label %63
63: ; preds = %55
%64 = add nsw i16 %56, -1
%65 = call { i16, i1 } @llvm.umul.with.overflow.i16(i16 %64, i16 2)
%66 = extractvalue { i16, i1 } %65, 0
%67 = extractvalue { i16, i1 } %65, 1
%68 = xor i16 %49, -1
%69 = icmp ugt i16 %66, %68
%70 = or i1 %69, %67
%71 = zext i16 %49 to i64
%72 = getelementptr i8, i8* %10, i64 %71
%73 = zext i16 %64 to i64
%74 = shl nuw nsw i64 %73, 1
%75 = getelementptr i8, i8* %72, i64 %74
%76 = icmp ult i8* %75, %72
%77 = getelementptr i8, i8* %2, i64 %71
%78 = zext i16 %64 to i64
%79 = shl nuw nsw i64 %78, 1
%80 = getelementptr i8, i8* %77, i64 %79
%81 = icmp ult i8* %80, %77
%82 = or i1 %70, %76
%83 = or i1 %82, %81
br i1 %83, label %155, label %84
84: ; preds = %63
%85 = and i32 %61, 131056
%86 = trunc i32 %85 to i16
%87 = shl i16 %86, 1
%88 = add i16 %49, %87
%89 = trunc i32 %85 to i16
%90 = sub i16 %56, %89
%91 = insertelement <8 x i8> poison, i8 %58, i64 0
%92 = shufflevector <8 x i8> %91, <8 x i8> poison, <8 x i32> zeroinitializer
%93 = insertelement <8 x i8> poison, i8 %57, i64 0
%94 = shufflevector <8 x i8> %93, <8 x i8> poison, <8 x i32> zeroinitializer
%95 = insertelement <8 x i8> poison, i8 %58, i64 0
%96 = shufflevector <8 x i8> %95, <8 x i8> poison, <8 x i32> zeroinitializer
%97 = insertelement <8 x i8> poison, i8 %57, i64 0
%98 = shufflevector <8 x i8> %97, <8 x i8> poison, <8 x i32> zeroinitializer
%99 = add nsw i32 %85, -16
%100 = lshr exact i32 %99, 4
%101 = add nuw nsw i32 %100, 1
%102 = and i32 %101, 1
%103 = icmp eq i32 %99, 0
br i1 %103, label %137, label %104
104: ; preds = %84
%105 = and i32 %101, 536870910
%106 = shufflevector <8 x i8> %92, <8 x i8> %94, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
%107 = shufflevector <8 x i8> %96, <8 x i8> %98, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
%108 = shufflevector <8 x i8> %92, <8 x i8> %94, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
%109 = shufflevector <8 x i8> %96, <8 x i8> %98, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
br label %110
110: ; preds = %110, %104
%111 = phi i32 [ 0, %104 ], [ %134, %110 ]
%112 = phi i32 [ 0, %104 ], [ %135, %110 ]
%113 = trunc i32 %111 to i16
%114 = shl i16 %113, 1
%115 = add i16 %49, %114
%116 = add i16 %115, 16
%117 = zext i16 %115 to i64
%118 = zext i16 %116 to i64
%119 = getelementptr inbounds i8, i8* %2, i64 %117
%120 = getelementptr inbounds i8, i8* %2, i64 %118
%121 = bitcast i8* %119 to <16 x i8>*
%122 = bitcast i8* %120 to <16 x i8>*
store <16 x i8> %106, <16 x i8>* %121
store <16 x i8> %107, <16 x i8>* %122
%123 = trunc i32 %111 to i16
%124 = shl i16 %123, 1
%125 = or i16 %124, 32
%126 = add i16 %49, %125
%127 = add i16 %126, 16
%128 = zext i16 %126 to i64
%129 = zext i16 %127 to i64
%130 = getelementptr inbounds i8, i8* %2, i64 %128
%131 = getelementptr inbounds i8, i8* %2, i64 %129
%132 = bitcast i8* %130 to <16 x i8>*
%133 = bitcast i8* %131 to <16 x i8>*
store <16 x i8> %108, <16 x i8>* %132
store <16 x i8> %109, <16 x i8>* %133
%134 = add nuw i32 %111, 32
%135 = add i32 %112, 2
%136 = icmp eq i32 %135, %105
br i1 %136, label %137, label %110
137: ; preds = %110, %84
%138 = phi i32 [ 0, %84 ], [ %134, %110 ]
%139 = icmp eq i32 %102, 0
br i1 %139, label %153, label %140
140: ; preds = %137
%141 = trunc i32 %138 to i16
%142 = shl i16 %141, 1
%143 = add i16 %49, %142
%144 = add i16 %143, 16
%145 = zext i16 %143 to i64
%146 = zext i16 %144 to i64
%147 = getelementptr inbounds i8, i8* %2, i64 %145
%148 = getelementptr inbounds i8, i8* %2, i64 %146
%149 = bitcast i8* %147 to <16 x i8>*
%150 = bitcast i8* %148 to <16 x i8>*
%151 = shufflevector <8 x i8> %92, <8 x i8> %94, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
store <16 x i8> %151, <16 x i8>* %149
%152 = shufflevector <8 x i8> %96, <8 x i8> %98, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
store <16 x i8> %152, <16 x i8>* %150
br label %153
153: ; preds = %137, %140
%154 = icmp eq i32 %61, %85
br i1 %154, label %11, label %155
155: ; preds = %63, %55, %153
%156 = phi i16 [ %49, %63 ], [ %49, %55 ], [ %88, %153 ]
%157 = phi i16 [ %56, %63 ], [ %56, %55 ], [ %90, %153 ]
%158 = add i16 %157, -1
%159 = and i16 %157, 3
%160 = icmp eq i16 %159, 0
br i1 %160, label %172, label %161
161: ; preds = %155, %161
%162 = phi i16 [ %169, %161 ], [ %156, %155 ]
%163 = phi i16 [ %168, %161 ], [ %157, %155 ]
%164 = phi i16 [ %170, %161 ], [ 0, %155 ]
%165 = zext i16 %162 to i64
%166 = getelementptr inbounds i8, i8* %2, i64 %165
%167 = getelementptr inbounds i8, i8* %166, i64 1
store i8 %57, i8* %167
store i8 %58, i8* %166
%168 = add i16 %163, -1
%169 = add i16 %162, 2
%170 = add i16 %164, 1
%171 = icmp eq i16 %170, %159
br i1 %171, label %172, label %161
172: ; preds = %161, %155
%173 = phi i16 [ %156, %155 ], [ %169, %161 ]
%174 = phi i16 [ %157, %155 ], [ %168, %161 ]
%175 = icmp ult i16 %158, 3
br i1 %175, label %11, label %176
176: ; preds = %172, %176
%177 = phi i16 [ %195, %176 ], [ %173, %172 ]
%178 = phi i16 [ %194, %176 ], [ %174, %172 ]
%179 = zext i16 %177 to i64
%180 = getelementptr inbounds i8, i8* %2, i64 %179
%181 = getelementptr inbounds i8, i8* %180, i64 1
store i8 %57, i8* %181
store i8 %58, i8* %180
%182 = add i16 %177, 2
%183 = zext i16 %182 to i64
%184 = getelementptr inbounds i8, i8* %2, i64 %183
%185 = getelementptr inbounds i8, i8* %184, i64 1
store i8 %57, i8* %185
store i8 %58, i8* %184
%186 = add i16 %177, 4
%187 = zext i16 %186 to i64
%188 = getelementptr inbounds i8, i8* %2, i64 %187
%189 = getelementptr inbounds i8, i8* %188, i64 1
store i8 %57, i8* %189
store i8 %58, i8* %188
%190 = add i16 %177, 6
%191 = zext i16 %190 to i64
%192 = getelementptr inbounds i8, i8* %2, i64 %191
%193 = getelementptr inbounds i8, i8* %192, i64 1
store i8 %57, i8* %193
store i8 %58, i8* %192
%194 = add i16 %178, -4
%195 = add i16 %177, 8
%196 = icmp eq i16 %194, 0
br i1 %196, label %11, label %176
197: ; preds = %29, %11, %3
%198 = phi i32 [ 0, %3 ], [ 0, %11 ], [ -1, %29 ]
ret i32 %198
}