#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(unsigned char);
int /*<<< orphan*/ memset(unsigned char *, int, unsigned char);
unsigned char *deobfuscate(unsigned char *s) {
  unsigned char key, mod, len;
  int i, j;
  unsigned char *d;
  key = s[0];
  mod = s[1];
  len = s[2] ^ key ^ mod;
  d = (unsigned char *)malloc(len + 1);
  memset(d, 0x00, len + 1);
  for (i = 0, j = 3; i < len; i++, j++) {
    d[i] = s[j] ^ mod;
    d[i] -= mod;
    d[i] ^= key;
  }
  d[len] = 0;
  return d;
}


x86 assembly (clang, -O0):
<deobfuscate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x9(%rbp)
mov    -0x8(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0xa(%rbp)
mov    -0x8(%rbp),%rax
movzbl 0x2(%rax),%eax
movzbl -0x9(%rbp),%ecx
xor    %ecx,%eax
movzbl -0xa(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0xb(%rbp)
movzbl -0xb(%rbp),%eax
add    $0x1,%eax
movzbl %al,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
movzbl -0xb(%rbp),%eax
add    $0x1,%eax
movzbl %al,%edx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,-0x10(%rbp)
movl   $0x3,-0x14(%rbp)
mov    -0x10(%rbp),%eax
movzbl -0xb(%rbp),%ecx
cmp    %ecx,%eax
jge    11fb <deobfuscate+0xdb>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
movzbl -0xa(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movzbl -0xa(%rbp),%esi
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
sub    %esi,%edx
mov    %dl,(%rax,%rcx,1)
movzbl -0x9(%rbp),%esi
mov    -0x20(%rbp),%rax
movslq -0x10(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    118c <deobfuscate+0x6c>
mov    -0x20(%rbp),%rax
movzbl -0xb(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<deobfuscate>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r15
mov    (%rdi),%r12b
mov    0x1(%rdi),%r14b
mov    %r14d,%ebp
xor    %r12b,%bpl
xor    0x2(%rdi),%bpl
lea    0x1(%rbp),%eax
movzbl %al,%r13d
mov    %r13d,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
xor    %esi,%esi
mov    %r13d,%edx
call   1030 <memset@plt>
mov    %rbx,%rax
movzbl %bpl,%r9d
test   %bpl,%bpl
je     120b <deobfuscate+0xeb>
mov    $0x3,%edi
cmp    $0x8,%r9b
jb     119b <deobfuscate+0x7b>
lea    (%r9,%r15,1),%rcx
add    $0x3,%rcx
cmp    %rax,%rcx
jbe    121f <deobfuscate+0xff>
lea    (%rax,%r9,1),%rdx
lea    0x3(%r15),%rcx
cmp    %rdx,%rcx
jae    121f <deobfuscate+0xff>
xor    %esi,%esi
mov    %rsi,%rcx
not    %rcx
test   $0x1,%r9b
je     11c1 <deobfuscate+0xa1>
mov    (%r15,%rdi,1),%dl
xor    %r14b,%dl
sub    %r14b,%dl
xor    %r12b,%dl
mov    %dl,(%rax,%rsi,1)
or     $0x1,%rsi
add    $0x1,%rdi
add    %r9,%rcx
je     120b <deobfuscate+0xeb>
lea    (%rdi,%r15,1),%rdx
add    $0x1,%rdx
mov    %r9,%rcx
sub    %rsi,%rcx
add    %rax,%rsi
add    $0x1,%rsi
xor    %edi,%edi
nopl   (%rax)
movzbl -0x1(%rdx,%rdi,1),%ebx
xor    %r14b,%bl
sub    %r14b,%bl
xor    %r12b,%bl
mov    %bl,-0x1(%rsi,%rdi,1)
movzbl (%rdx,%rdi,1),%ebx
xor    %r14b,%bl
sub    %r14b,%bl
xor    %r12b,%bl
mov    %bl,(%rsi,%rdi,1)
add    $0x2,%rdi
cmp    %rdi,%rcx
jne    11e0 <deobfuscate+0xc0>
movb   $0x0,(%rax,%r9,1)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movzbl %r14b,%edx
movzbl %r12b,%r8d
cmp    $0x20,%bpl
jae    1234 <deobfuscate+0x114>
xor    %esi,%esi
jmp    140b <deobfuscate+0x2eb>
mov    %r9d,%esi
and    $0xffffffe0,%esi
movd   %edx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
movd   %r8d,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
pshufd $0x0,%xmm1,%xmm1
movdqu 0x3(%r15),%xmm2
movdqu 0x13(%r15),%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
psubb  %xmm0,%xmm2
psubb  %xmm0,%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
movdqu %xmm2,(%rax)
movdqu %xmm3,0x10(%rax)
cmp    $0x20,%rsi
je     13fc <deobfuscate+0x2dc>
movdqu 0x23(%r15),%xmm2
movdqu 0x33(%r15),%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
psubb  %xmm0,%xmm2
psubb  %xmm0,%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
movdqu %xmm2,0x20(%rax)
movdqu %xmm3,0x30(%rax)
cmp    $0x40,%esi
je     13fc <deobfuscate+0x2dc>
movdqu 0x43(%r15),%xmm2
movdqu 0x53(%r15),%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
psubb  %xmm0,%xmm2
psubb  %xmm0,%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
movdqu %xmm2,0x40(%rax)
movdqu %xmm3,0x50(%rax)
cmp    $0x60,%esi
je     13fc <deobfuscate+0x2dc>
movdqu 0x63(%r15),%xmm2
movdqu 0x73(%r15),%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
psubb  %xmm0,%xmm2
psubb  %xmm0,%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
movdqu %xmm2,0x60(%rax)
movdqu %xmm3,0x70(%rax)
cmp    $0x80,%esi
je     13fc <deobfuscate+0x2dc>
movdqu 0x83(%r15),%xmm2
movdqu 0x93(%r15),%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
psubb  %xmm0,%xmm2
psubb  %xmm0,%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
movdqu %xmm2,0x80(%rax)
movdqu %xmm3,0x90(%rax)
cmp    $0xa0,%esi
je     13fc <deobfuscate+0x2dc>
movdqu 0xa3(%r15),%xmm2
movdqu 0xb3(%r15),%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
psubb  %xmm0,%xmm2
psubb  %xmm0,%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
movdqu %xmm2,0xa0(%rax)
movdqu %xmm3,0xb0(%rax)
cmp    $0xc0,%esi
je     13fc <deobfuscate+0x2dc>
movdqu 0xc3(%r15),%xmm2
movdqu 0xd3(%r15),%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
psubb  %xmm0,%xmm2
psubb  %xmm0,%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
movdqu %xmm2,0xc0(%rax)
movdqu %xmm3,0xd0(%rax)
cmp    %r9,%rsi
je     120b <deobfuscate+0xeb>
test   $0x18,%r9b
je     146f <deobfuscate+0x34f>
mov    %rsi,%rcx
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    0x3(%rsi),%rdi
movd   %edx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
movd   %r8d,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   0x3(%r15,%rcx,1),%xmm2
pxor   %xmm0,%xmm2
psubb  %xmm0,%xmm2
pxor   %xmm1,%xmm2
movq   %xmm2,(%rax,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    1440 <deobfuscate+0x320>
cmp    %r9,%rsi
jne    119d <deobfuscate+0x7d>
jmp    120b <deobfuscate+0xeb>
mov    %rsi,%rdi
or     $0x3,%rdi
jmp    119d <deobfuscate+0x7d>

LLVM IR (-O0):
define i8* @deobfuscate(i8* %0) {
%2 = alloca i8*
%3 = alloca i8
%4 = alloca i8
%5 = alloca i8
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
store i8* %0, i8** %2
%9 = load i8*, i8** %2
%10 = getelementptr inbounds i8, i8* %9, i64 0
%11 = load i8, i8* %10
store i8 %11, i8* %3
%12 = load i8*, i8** %2
%13 = getelementptr inbounds i8, i8* %12, i64 1
%14 = load i8, i8* %13
store i8 %14, i8* %4
%15 = load i8*, i8** %2
%16 = getelementptr inbounds i8, i8* %15, i64 2
%17 = load i8, i8* %16
%18 = zext i8 %17 to i32
%19 = load i8, i8* %3
%20 = zext i8 %19 to i32
%21 = xor i32 %18, %20
%22 = load i8, i8* %4
%23 = zext i8 %22 to i32
%24 = xor i32 %21, %23
%25 = trunc i32 %24 to i8
store i8 %25, i8* %5
%26 = load i8, i8* %5
%27 = zext i8 %26 to i32
%28 = add nsw i32 %27, 1
%29 = trunc i32 %28 to i8
%30 = call i64 @malloc(i8 zeroext %29)
%31 = inttoptr i64 %30 to i8*
store i8* %31, i8** %8
%32 = load i8*, i8** %8
%33 = load i8, i8* %5
%34 = zext i8 %33 to i32
%35 = add nsw i32 %34, 1
%36 = trunc i32 %35 to i8
%37 = call i32 @memset(i8* %32, i32 0, i8 zeroext %36)
store i32 0, i32* %6
store i32 3, i32* %7
br label %38
38: ; preds = %78, %1
%39 = load i32, i32* %6
%40 = load i8, i8* %5
%41 = zext i8 %40 to i32
%42 = icmp slt i32 %39, %41
br i1 %42, label %43, label %83
43: ; preds = %38
%44 = load i8*, i8** %2
%45 = load i32, i32* %7
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i8, i8* %44, i64 %46
%48 = load i8, i8* %47
%49 = zext i8 %48 to i32
%50 = load i8, i8* %4
%51 = zext i8 %50 to i32
%52 = xor i32 %49, %51
%53 = trunc i32 %52 to i8
%54 = load i8*, i8** %8
%55 = load i32, i32* %6
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8, i8* %54, i64 %56
store i8 %53, i8* %57
%58 = load i8, i8* %4
%59 = zext i8 %58 to i32
%60 = load i8*, i8** %8
%61 = load i32, i32* %6
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i8, i8* %60, i64 %62
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = sub nsw i32 %65, %59
%67 = trunc i32 %66 to i8
store i8 %67, i8* %63
%68 = load i8, i8* %3
%69 = zext i8 %68 to i32
%70 = load i8*, i8** %8
%71 = load i32, i32* %6
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i8, i8* %70, i64 %72
%74 = load i8, i8* %73
%75 = zext i8 %74 to i32
%76 = xor i32 %75, %69
%77 = trunc i32 %76 to i8
store i8 %77, i8* %73
br label %78
78: ; preds = %43
%79 = load i32, i32* %6
%80 = add nsw i32 %79, 1
store i32 %80, i32* %6
%81 = load i32, i32* %7
%82 = add nsw i32 %81, 1
store i32 %82, i32* %7
br label %38
83: ; preds = %38
%84 = load i8*, i8** %8
%85 = load i8, i8* %5
%86 = zext i8 %85 to i64
%87 = getelementptr inbounds i8, i8* %84, i64 %86
store i8 0, i8* %87
%88 = load i8*, i8** %8
ret i8* %88
}

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