#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 strlen(char *);
char *GetLeftRotatedString(char *original, int count) {
  int length, i;
  char *new;
  char *source;
  char *destination;
  length = strlen(original);
  new = (char *)malloc((length + 1) * sizeof(char));
  count = count % length;
  source = original;
  destination = new + (length - count);
  for (i = 0; i < count; i++) {
    *destination = *source;
    source++;
    destination++;
  }
  *destination = '\0';
  destination = new;
  for (i = length - count; i > 0; i--) {
    *destination = *source;
    source++;
    destination++;
  }
  return new;
}


x86 assembly (clang, -O0):
<GetLeftRotatedString>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
cltd
idivl  -0x10(%rbp)
mov    %edx,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11bd <GetLeftRotatedString+0x9d>
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    117f <GetLeftRotatedString+0x5f>
mov    -0x30(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    1211 <GetLeftRotatedString+0xf1>
mov    -0x28(%rbp),%rax
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    11d5 <GetLeftRotatedString+0xb5>
mov    -0x20(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<GetLeftRotatedString>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %esi,%ebp
mov    %rdi,%rbx
call   1030 <strlen@plt>
mov    %eax,%r14d
lea    0x1(%r14),%edi
call   1040 <malloc@plt>
mov    %rax,%r11
mov    %ebp,%eax
cltd
idiv   %r14d
mov    %r14d,%r12d
sub    %edx,%r12d
movslq %r12d,%r10
lea    (%r11,%r10,1),%rsi
test   %edx,%edx
jle    1313 <GetLeftRotatedString+0x1f3>
lea    -0x1(%rdx),%r9d
xor    %r8d,%r8d
cmp    $0x1f,%r9d
jb     127a <GetLeftRotatedString+0x15a>
lea    (%r9,%rbx,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rsi
jae    1196 <GetLeftRotatedString+0x76>
movslq %r14d,%rcx
add    %r9,%rcx
movslq %edx,%rdi
sub    %rdi,%rcx
add    %r11,%rcx
add    $0x1,%rcx
cmp    %rbx,%rcx
ja     127a <GetLeftRotatedString+0x15a>
add    $0x1,%r9
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r15d
and    $0x3,%r15d
cmp    $0x60,%rcx
jae    11c1 <GetLeftRotatedString+0xa1>
xor    %ecx,%ecx
jmp    1229 <GetLeftRotatedString+0x109>
and    $0xfffffffffffffffc,%rdi
lea    (%r10,%r11,1),%rbp
add    $0x70,%rbp
xor    %ecx,%ecx
nop
movups (%rbx,%rcx,1),%xmm0
movups 0x10(%rbx,%rcx,1),%xmm1
movups %xmm0,-0x70(%rbp,%rcx,1)
movups %xmm1,-0x60(%rbp,%rcx,1)
movups 0x20(%rbx,%rcx,1),%xmm0
movups 0x30(%rbx,%rcx,1),%xmm1
movups %xmm0,-0x50(%rbp,%rcx,1)
movups %xmm1,-0x40(%rbp,%rcx,1)
movups 0x40(%rbx,%rcx,1),%xmm0
movups 0x50(%rbx,%rcx,1),%xmm1
movups %xmm0,-0x30(%rbp,%rcx,1)
movups %xmm1,-0x20(%rbp,%rcx,1)
movups 0x60(%rbx,%rcx,1),%xmm0
movups 0x70(%rbx,%rcx,1),%xmm1
movups %xmm0,-0x10(%rbp,%rcx,1)
movups %xmm1,0x0(%rbp,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rdi
jne    11d0 <GetLeftRotatedString+0xb0>
test   %r15,%r15
je     126b <GetLeftRotatedString+0x14b>
lea    (%rcx,%rbx,1),%rdi
add    $0x10,%rdi
add    %rcx,%r10
lea    (%r11,%r10,1),%rcx
add    $0x10,%rcx
shl    $0x5,%r15
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r15
jne    1250 <GetLeftRotatedString+0x130>
add    %r8,%rsi
add    %r8,%rbx
cmp    %r8,%r9
je     1313 <GetLeftRotatedString+0x1f3>
mov    %edx,%edi
sub    %r8d,%edi
mov    %r8d,%r9d
not    %r9d
add    %edx,%r9d
and    $0x7,%edi
je     12b8 <GetLeftRotatedString+0x198>
neg    %edi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rbx),%ecx
mov    %cl,(%rsi)
add    $0x1,%rbx
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
cmp    %ebp,%edi
jne    12a0 <GetLeftRotatedString+0x180>
sub    %ebp,%r8d
cmp    $0x7,%r9d
jb     1313 <GetLeftRotatedString+0x1f3>
mov    %edx,%ecx
sub    %r8d,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rbx),%eax
mov    %al,(%rsi)
movzbl 0x1(%rbx),%eax
mov    %al,0x1(%rsi)
movzbl 0x2(%rbx),%eax
mov    %al,0x2(%rsi)
movzbl 0x3(%rbx),%eax
mov    %al,0x3(%rsi)
movzbl 0x4(%rbx),%eax
mov    %al,0x4(%rsi)
movzbl 0x5(%rbx),%eax
mov    %al,0x5(%rsi)
movzbl 0x6(%rbx),%eax
mov    %al,0x6(%rsi)
movzbl 0x7(%rbx),%eax
mov    %al,0x7(%rsi)
add    $0x8,%rbx
add    $0x8,%rsi
add    $0xfffffff8,%ecx
jne    12d0 <GetLeftRotatedString+0x1b0>
movb   $0x0,(%rsi)
test   %r12d,%r12d
jle    1366 <GetLeftRotatedString+0x246>
not    %edx
add    %edx,%r14d
cmp    $0x7,%r14d
jb     1340 <GetLeftRotatedString+0x220>
lea    (%rbx,%r14,1),%rax
add    $0x1,%rax
cmp    %r11,%rax
jbe    1372 <GetLeftRotatedString+0x252>
lea    (%r11,%r14,1),%rax
add    $0x1,%rax
cmp    %rax,%rbx
jae    1372 <GetLeftRotatedString+0x252>
mov    %r11,%rdi
mov    %rbx,%rbp
add    $0x1,%r12d
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl 0x0(%rbp,%rcx,1),%eax
mov    %al,(%rdi,%rcx,1)
add    $0x1,%rcx
add    $0xffffffff,%r12d
cmp    $0x1,%r12d
ja     1350 <GetLeftRotatedString+0x230>
mov    %r11,%rax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1ffffffe0,%rdx
cmp    $0x1f,%r14d
jae    1389 <GetLeftRotatedString+0x269>
xor    %esi,%esi
jmp    146b <GetLeftRotatedString+0x34b>
lea    0x1(%r14),%r8
mov    %r8,%rsi
and    %rdx,%rsi
lea    -0x20(%rsi),%rax
mov    %rax,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
mov    %ebp,%r9d
and    $0x3,%r9d
cmp    $0x60,%rax
jae    13b3 <GetLeftRotatedString+0x293>
xor    %ecx,%ecx
jmp    1420 <GetLeftRotatedString+0x300>
and    $0xfffffffffffffffc,%rbp
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%rbx,%rcx,1),%xmm0
movups 0x10(%rbx,%rcx,1),%xmm1
movups %xmm0,(%r11,%rcx,1)
movups %xmm1,0x10(%r11,%rcx,1)
movups 0x20(%rbx,%rcx,1),%xmm0
movups 0x30(%rbx,%rcx,1),%xmm1
movups %xmm0,0x20(%r11,%rcx,1)
movups %xmm1,0x30(%r11,%rcx,1)
movups 0x40(%rbx,%rcx,1),%xmm0
movups 0x50(%rbx,%rcx,1),%xmm1
movups %xmm0,0x40(%r11,%rcx,1)
movups %xmm1,0x50(%r11,%rcx,1)
movups 0x60(%rbx,%rcx,1),%xmm0
movups 0x70(%rbx,%rcx,1),%xmm1
movups %xmm0,0x60(%r11,%rcx,1)
movups %xmm1,0x70(%r11,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rbp
jne    13c0 <GetLeftRotatedString+0x2a0>
test   %r9,%r9
je     145c <GetLeftRotatedString+0x33c>
lea    (%rbx,%rcx,1),%rbp
add    $0x10,%rbp
add    %r11,%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rbp,%rdi,1),%xmm0
movups 0x0(%rbp,%rdi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,1)
movups %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1440 <GetLeftRotatedString+0x320>
cmp    %rsi,%r8
je     1366 <GetLeftRotatedString+0x246>
test   $0x18,%r8b
je     14af <GetLeftRotatedString+0x38f>
add    $0x1,%r14
add    $0x18,%rdx
and    %r14,%rdx
mov    %r11,%rdi
add    %rdx,%rdi
lea    (%rbx,%rdx,1),%rbp
sub    %edx,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx,%rsi,1),%rax
mov    %rax,(%r11,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdx
jne    1490 <GetLeftRotatedString+0x370>
cmp    %rdx,%r14
jne    1346 <GetLeftRotatedString+0x226>
jmp    1366 <GetLeftRotatedString+0x246>
sub    %esi,%r12d
add    %rsi,%rbx
mov    %r11,%rdi
add    %rsi,%rdi
jmp    1343 <GetLeftRotatedString+0x223>

LLVM IR (-O0):
define i8* @GetLeftRotatedString(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
store i8* %0, i8** %3
store i32 %1, i32* %4
%10 = load i8*, i8** %3
%11 = call i32 @strlen(i8* %10)
store i32 %11, i32* %5
%12 = load i32, i32* %5
%13 = add nsw i32 %12, 1
%14 = sext i32 %13 to i64
%15 = mul i64 %14, 1
%16 = trunc i64 %15 to i32
%17 = call i64 @malloc(i32 %16)
%18 = inttoptr i64 %17 to i8*
store i8* %18, i8** %7
%19 = load i32, i32* %4
%20 = load i32, i32* %5
%21 = srem i32 %19, %20
store i32 %21, i32* %4
%22 = load i8*, i8** %3
store i8* %22, i8** %8
%23 = load i8*, i8** %7
%24 = load i32, i32* %5
%25 = load i32, i32* %4
%26 = sub nsw i32 %24, %25
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %23, i64 %27
store i8* %28, i8** %9
store i32 0, i32* %6
br label %29
29: ; preds = %41, %2
%30 = load i32, i32* %6
%31 = load i32, i32* %4
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %44
33: ; preds = %29
%34 = load i8*, i8** %8
%35 = load i8, i8* %34
%36 = load i8*, i8** %9
store i8 %35, i8* %36
%37 = load i8*, i8** %8
%38 = getelementptr inbounds i8, i8* %37, i32 1
store i8* %38, i8** %8
%39 = load i8*, i8** %9
%40 = getelementptr inbounds i8, i8* %39, i32 1
store i8* %40, i8** %9
br label %41
41: ; preds = %33
%42 = load i32, i32* %6
%43 = add nsw i32 %42, 1
store i32 %43, i32* %6
br label %29
44: ; preds = %29
%45 = load i8*, i8** %9
store i8 0, i8* %45
%46 = load i8*, i8** %7
store i8* %46, i8** %9
%47 = load i32, i32* %5
%48 = load i32, i32* %4
%49 = sub nsw i32 %47, %48
store i32 %49, i32* %6
br label %50
50: ; preds = %61, %44
%51 = load i32, i32* %6
%52 = icmp sgt i32 %51, 0
br i1 %52, label %53, label %64
53: ; preds = %50
%54 = load i8*, i8** %8
%55 = load i8, i8* %54
%56 = load i8*, i8** %9
store i8 %55, i8* %56
%57 = load i8*, i8** %8
%58 = getelementptr inbounds i8, i8* %57, i32 1
store i8* %58, i8** %8
%59 = load i8*, i8** %9
%60 = getelementptr inbounds i8, i8* %59, i32 1
store i8* %60, i8** %9
br label %61
61: ; preds = %53
%62 = load i32, i32* %6
%63 = add nsw i32 %62, -1
store i32 %63, i32* %6
br label %50
64: ; preds = %50
%65 = load i8*, i8** %7
ret i8* %65
}

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