#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 */
int /*<<< orphan*/ assert(unsigned char *);
scalar_t__ malloc(int);
unsigned char *alpha_rotate(unsigned char *i, int ox, int oy, int rot) {
  unsigned char *n, *p;
  int x, y;
  assert(n = (unsigned char *)malloc(ox * oy));
  switch (rot) {
  case 1:
    p = n + (oy - 1);
    for (y = 0; y < oy; y++, p--) {
      unsigned char *r = p;
      for (x = 0; x < ox; x++, r += oy)
        *r = *(i++);
    }
    break;
  case 2:
    i += ox * oy;
    p = n;
    for (y = ox * oy; y > 0; y--)
      *(p++) = *(i--);
    break;
  case 3:
    p = n;
    for (y = 0; y < oy; y++, p++) {
      unsigned char *r = p + (ox * oy);
      for (x = 0; x < ox; x++) {
        r -= oy;
        *r = *(i++);
      }
    }
    break;
  }
  return (n);
}


x86 assembly (clang, -O0):
<alpha_rotate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    -0xc(%rbp),%edi
mov    -0x10(%rbp),%eax
imul   %eax,%edi
call   1040 <malloc@plt>
mov    %rax,%rdi
mov    %rdi,-0x20(%rbp)
call   1030 <assert@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x44(%rbp)
sub    $0x1,%eax
je     1185 <alpha_rotate+0x65>
jmp    1163 <alpha_rotate+0x43>
mov    -0x44(%rbp),%eax
sub    $0x2,%eax
je     1221 <alpha_rotate+0x101>
jmp    1174 <alpha_rotate+0x54>
mov    -0x44(%rbp),%eax
sub    $0x3,%eax
je     1287 <alpha_rotate+0x167>
jmp    1329 <alpha_rotate+0x209>
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    121c <alpha_rotate+0xfc>
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11fd <alpha_rotate+0xdd>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %cl,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%ecx
mov    -0x38(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
jmp    11bb <alpha_rotate+0x9b>
jmp    1202 <alpha_rotate+0xe2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    11a0 <alpha_rotate+0x80>
jmp    1329 <alpha_rotate+0x209>
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    1282 <alpha_rotate+0x162>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1248 <alpha_rotate+0x128>
jmp    1329 <alpha_rotate+0x209>
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1324 <alpha_rotate+0x204>
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
imul   -0x10(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1305 <alpha_rotate+0x1e5>
mov    -0x10(%rbp),%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x40(%rbp),%rax
mov    %cl,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12be <alpha_rotate+0x19e>
jmp    130a <alpha_rotate+0x1ea>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1296 <alpha_rotate+0x176>
jmp    1329 <alpha_rotate+0x209>
mov    -0x20(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<alpha_rotate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%r14d
mov    %edx,%r12d
mov    %esi,%r13d
mov    %rdi,%rbx
mov    %edx,%ebp
imul   %esi,%ebp
mov    %ebp,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %rax,(%rsp)
mov    %rax,%rdi
call   1030 <assert@plt>
cmp    $0x1,%r14d
je     1266 <alpha_rotate+0x146>
cmp    $0x2,%r14d
je     1347 <alpha_rotate+0x227>
cmp    $0x3,%r14d
jne    13a6 <alpha_rotate+0x286>
test   %r12d,%r12d
jle    13a6 <alpha_rotate+0x286>
movslq %ebp,%r8
mov    %r12d,%r9d
mov    %r9,%rdx
neg    %rdx
lea    -0x1(%r13),%r10d
mov    %r13d,%r11d
and    $0x3,%r11d
mov    %r13d,%eax
and    $0xfffffffc,%eax
mov    %eax,0xc(%rsp)
lea    0x0(,%r9,4),%rbp
neg    %rbp
lea    (%r9,%r9,2),%rax
neg    %rax
add    %r9,%r9
neg    %r9
xor    %r15d,%r15d
mov    (%rsp),%r14
mov    %r13,0x10(%rsp)
jmp    11e1 <alpha_rotate+0xc1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r15d
add    $0x1,%r14
cmp    %r12d,%r15d
je     13a6 <alpha_rotate+0x286>
test   %r13d,%r13d
jle    11d0 <alpha_rotate+0xb0>
lea    (%r14,%r8,1),%rdi
cmp    $0x3,%r10d
jb     1244 <alpha_rotate+0x124>
mov    %r12,%r13
mov    %r11d,%r12d
mov    %r10d,%r11d
mov    %r8,%r10
mov    0xc(%rsp),%esi
movzbl (%rbx),%r8d
mov    %r8b,(%rdi,%rdx,1)
movzbl 0x1(%rbx),%ecx
mov    %cl,(%rdi,%r9,1)
movzbl 0x2(%rbx),%ecx
mov    %cl,(%rdi,%rax,1)
movzbl 0x3(%rbx),%ecx
mov    %cl,(%rdi,%rbp,1)
add    %rdx,%rdi
add    %rdx,%rdi
add    %rdx,%rdi
add    %rdx,%rdi
add    $0x4,%rbx
add    $0xfffffffc,%esi
jne    1200 <alpha_rotate+0xe0>
mov    %r10,%r8
mov    %r11d,%r10d
mov    %r12d,%r11d
mov    %r13,%r12
mov    0x10(%rsp),%r13
test   %r11d,%r11d
je     11d0 <alpha_rotate+0xb0>
add    %rdx,%rdi
mov    %r11d,%esi
nop
movzbl (%rbx),%ecx
add    $0x1,%rbx
mov    %cl,(%rdi)
add    %rdx,%rdi
add    $0xffffffff,%esi
jne    1250 <alpha_rotate+0x130>
jmp    11d0 <alpha_rotate+0xb0>
test   %r12d,%r12d
jle    13a6 <alpha_rotate+0x286>
lea    -0x1(%r12),%eax
add    %rax,%r15
mov    %r12d,%eax
lea    -0x1(%r13),%r9d
mov    %r13d,%edx
and    $0x7,%edx
mov    %r13d,%r8d
and    $0xfffffff8,%r8d
xor    %edi,%edi
jmp    12a0 <alpha_rotate+0x180>
nop
add    $0x1,%edi
add    $0xffffffffffffffff,%r15
cmp    %r12d,%edi
je     13a6 <alpha_rotate+0x286>
test   %r13d,%r13d
jle    1290 <alpha_rotate+0x170>
cmp    $0x7,%r9d
jae    12b0 <alpha_rotate+0x190>
mov    %r15,%rbp
jmp    1319 <alpha_rotate+0x1f9>
mov    %r8d,%esi
mov    %r15,%rbp
cs nopw 0x0(%rax,%rax,1)
movzbl (%rbx),%ecx
mov    %cl,0x0(%rbp)
movzbl 0x1(%rbx),%ecx
mov    %cl,0x0(%rbp,%rax,1)
add    %rax,%rbp
movzbl 0x2(%rbx),%ecx
mov    %cl,(%rax,%rbp,1)
add    %rax,%rbp
movzbl 0x3(%rbx),%ecx
mov    %cl,(%rax,%rbp,1)
add    %rax,%rbp
movzbl 0x4(%rbx),%ecx
mov    %cl,(%rax,%rbp,1)
add    %rax,%rbp
movzbl 0x5(%rbx),%ecx
mov    %cl,(%rax,%rbp,1)
add    %rax,%rbp
movzbl 0x6(%rbx),%ecx
mov    %cl,(%rax,%rbp,1)
add    %rax,%rbp
movzbl 0x7(%rbx),%ecx
add    $0x8,%rbx
mov    %cl,(%rax,%rbp,1)
add    %rax,%rbp
add    %rax,%rbp
add    $0xfffffff8,%esi
jne    12c0 <alpha_rotate+0x1a0>
test   %edx,%edx
je     1290 <alpha_rotate+0x170>
mov    %edx,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rbx),%ecx
add    $0x1,%rbx
mov    %cl,0x0(%rbp)
add    %rax,%rbp
add    $0xffffffff,%esi
jne    1330 <alpha_rotate+0x210>
jmp    1290 <alpha_rotate+0x170>
test   %ebp,%ebp
jle    13a6 <alpha_rotate+0x286>
mov    %ebp,%r10d
lea    (%rbx,%r10,1),%rax
lea    -0x1(%rbp),%r9d
cmp    $0x7,%r9d
jb     137f <alpha_rotate+0x25f>
lea    (%r10,%rbx,1),%rcx
add    $0x1,%rcx
cmp    %r15,%rcx
jbe    13b9 <alpha_rotate+0x299>
lea    (%r9,%r15,1),%rcx
add    $0x1,%rcx
mov    %r10,%rdx
sub    %r9,%rdx
add    %rbx,%rdx
cmp    %rcx,%rdx
jae    13b9 <alpha_rotate+0x299>
mov    (%rsp),%r15
add    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
movzbl (%rax),%ecx
add    $0xffffffffffffffff,%rax
mov    %cl,(%r15)
add    $0x1,%r15
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     1390 <alpha_rotate+0x270>
mov    (%rsp),%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1ffffffe0,%r11
cmp    $0x1f,%r9d
mov    (%rsp),%rdx
jae    13d4 <alpha_rotate+0x2b4>
xor    %esi,%esi
jmp    1480 <alpha_rotate+0x360>
lea    0x1(%r9),%r8
mov    %r8,%rsi
and    %r11,%rsi
lea    (%r10,%rbx,1),%rcx
add    $0xfffffffffffffff1,%rcx
xor    %edi,%edi
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movdqu -0x10(%rcx),%xmm1
movdqu (%rcx),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,(%rdx,%rdi,1)
movdqu %xmm1,0x10(%rdx,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rcx
cmp    %rdi,%rsi
jne    13f0 <alpha_rotate+0x2d0>
cmp    %rsi,%r8
je     13a6 <alpha_rotate+0x286>
test   $0x18,%r8b
je     14eb <alpha_rotate+0x3cb>
mov    (%rsp),%rdx
add    $0x1,%r9
add    $0x18,%r11
and    %r9,%r11
sub    %r11d,%ebp
add    %r11,%r15
sub    %r11,%rax
sub    %rsi,%r10
lea    (%r10,%rbx,1),%rcx
add    $0xfffffffffffffff9,%rcx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   (%rcx),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rdx,%rsi,1)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rcx
cmp    %rsi,%r11
jne    14b0 <alpha_rotate+0x390>
cmp    %r11,%r9
jne    1383 <alpha_rotate+0x263>
jmp    13a6 <alpha_rotate+0x286>
sub    %rsi,%rax
add    %rsi,%r15
sub    %esi,%ebp
jmp    1383 <alpha_rotate+0x263>

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

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