#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*/ printf(char *);
unsigned int random();
int /*<<< orphan*/ srandom(int /*<<< orphan*/);
unsigned char *str_replace(char *, unsigned char *, unsigned char *);
int strlen(unsigned char *);
int /*<<< orphan*/ time(int /*<<< orphan*/);
int obfuscate(unsigned char *s, unsigned char *d) {
  unsigned int seed;
  unsigned char key, mod;
  unsigned char *rep = NULL;
  unsigned char nl[] = "\n";
  unsigned char tb[] = "\t";
  unsigned char cr[] = "\r";
  int i, j, len;
  srandom(time(0));
  seed = random();
  key = (unsigned char)(seed & 0x000000ff);
  mod = (unsigned char)((seed & 0x0000ff00) >> 8);
  rep = str_replace("\\n", nl, s);
  rep = str_replace("\\t", tb, rep);
  rep = str_replace("\\r", cr, rep);
  len = strlen(rep);
  if (len > 255) {
    printf("String too long\n");
    return 0;
  }
  d[0] = key;
  d[1] = mod;
  d[2] = (unsigned char)len ^ key ^ mod;
  for (i = 0, j = 3; i < len; i++, j++) {
    d[j] = rep[i] ^ key;
    d[j] += mod;
    d[j] ^= mod;
  }
  return len;
}


x86 assembly (clang, -O0):
<obfuscate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movq   $0x0,-0x28(%rbp)
mov    0xe9d(%rip),%ax
mov    %ax,-0x2a(%rbp)
mov    0xe76(%rip),%ax
mov    %ax,-0x2c(%rbp)
mov    0xe6d(%rip),%ax
mov    %ax,-0x2e(%rbp)
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1030 <srandom@plt>
mov    $0x0,%al
call   1080 <random@plt>
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xff,%eax
mov    %al,-0x1d(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xff00,%eax
shr    $0x8,%eax
mov    %al,-0x1e(%rbp)
lea    -0x2a(%rbp),%rsi
mov    -0x10(%rbp),%rdx
lea    0xe2b(%rip),%rdi
call   1060 <str_replace@plt>
mov    %rax,-0x28(%rbp)
lea    -0x2c(%rbp),%rsi
mov    -0x28(%rbp),%rdx
lea    0xe16(%rip),%rdi
call   1060 <str_replace@plt>
mov    %rax,-0x28(%rbp)
lea    -0x2e(%rbp),%rsi
mov    -0x28(%rbp),%rdx
lea    0xe01(%rip),%rdi
call   1060 <str_replace@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x3c(%rbp)
cmpl   $0xff,-0x3c(%rbp)
jle    1243 <obfuscate+0xe3>
lea    0xddb(%rip),%rdi
call   1050 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    12f1 <obfuscate+0x191>
mov    -0x1d(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x1e(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x3c(%rbp),%eax
movzbl %al,%eax
movzbl -0x1d(%rbp),%ecx
xor    %ecx,%eax
movzbl -0x1e(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
movl   $0x0,-0x34(%rbp)
movl   $0x3,-0x38(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    12eb <obfuscate+0x18b>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
movzbl -0x1d(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movzbl -0x1e(%rbp),%esi
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
add    %esi,%edx
mov    %dl,(%rax,%rcx,1)
movzbl -0x1e(%rbp),%esi
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    127f <obfuscate+0x11f>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<obfuscate>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rsi,%r14
mov    %rdi,%rbp
movw   $0xa,0xe(%rsp)
movw   $0x9,0xc(%rsp)
movw   $0xd,0xa(%rsp)
xor    %r12d,%r12d
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,%edi
call   1030 <srandom@plt>
xor    %eax,%eax
call   1080 <random@plt>
mov    %eax,%ebx
lea    0xe58(%rip),%rdi
lea    0xe(%rsp),%rsi
mov    %rbp,%rdx
call   1060 <str_replace@plt>
lea    0xe47(%rip),%rdi
lea    0xc(%rsp),%rsi
mov    %rax,%rdx
call   1060 <str_replace@plt>
lea    0xe36(%rip),%rdi
lea    0xa(%rsp),%rsi
mov    %rax,%rdx
call   1060 <str_replace@plt>
mov    %rax,%r15
mov    %rax,%rdi
call   1050 <strlen@plt>
cmp    $0x100,%eax
jl     1200 <obfuscate+0xa0>
lea    0xe13(%rip),%rdi
call   1040 <puts@plt>
jmp    12b8 <obfuscate+0x158>
mov    %ebx,%ecx
shr    $0x8,%ecx
mov    %bl,(%r14)
mov    %cl,0x1(%r14)
mov    %ecx,%edx
xor    %ebx,%edx
xor    %eax,%edx
mov    %dl,0x2(%r14)
test   %eax,%eax
jle    12b5 <obfuscate+0x155>
mov    %eax,%r10d
mov    $0x3,%ebp
cmp    $0x8,%eax
jb     1249 <obfuscate+0xe9>
lea    0x3(%r14),%rsi
lea    (%r15,%r10,1),%rdi
cmp    %rdi,%rsi
jae    12c8 <obfuscate+0x168>
lea    (%r10,%r14,1),%rsi
add    $0x3,%rsi
cmp    %rsi,%r15
jae    12c8 <obfuscate+0x168>
xor    %edi,%edi
mov    %rdi,%rsi
not    %rsi
test   $0x1,%r10b
je     126d <obfuscate+0x10d>
mov    (%r15,%rdi,1),%dl
xor    %bl,%dl
add    %cl,%dl
xor    %cl,%dl
mov    %dl,(%r14,%rbp,1)
or     $0x1,%rdi
add    $0x1,%rbp
add    %r10,%rsi
je     12b5 <obfuscate+0x155>
sub    %rdi,%r10
lea    (%rdi,%r15,1),%rsi
add    $0x1,%rsi
lea    (%r14,%rbp,1),%rdi
add    $0x1,%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movzbl -0x1(%rsi,%rbp,1),%edx
xor    %bl,%dl
add    %cl,%dl
xor    %cl,%dl
mov    %dl,-0x1(%rdi,%rbp,1)
movzbl (%rsi,%rbp,1),%edx
xor    %bl,%dl
add    %cl,%dl
xor    %cl,%dl
mov    %dl,(%rdi,%rbp,1)
add    $0x2,%rbp
cmp    %rbp,%r10
jne    1290 <obfuscate+0x130>
mov    %eax,%r12d
mov    %r12d,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
movzbl %bl,%r9d
movzbl %cl,%r8d
cmp    $0x20,%eax
jae    12dc <obfuscate+0x17c>
xor    %edi,%edi
jmp    14c6 <obfuscate+0x366>
mov    %r10d,%edi
and    $0xffffffe0,%edi
movd   %r9d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm1
movd   %r8d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqu (%r15),%xmm2
movdqu 0x10(%r15),%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
paddb  %xmm0,%xmm2
paddb  %xmm0,%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
movdqu %xmm2,0x3(%r14)
movdqu %xmm3,0x13(%r14)
cmp    $0x20,%rdi
je     14b7 <obfuscate+0x357>
movdqu 0x20(%r15),%xmm2
movdqu 0x30(%r15),%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
paddb  %xmm0,%xmm2
paddb  %xmm0,%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
movdqu %xmm2,0x23(%r14)
movdqu %xmm3,0x33(%r14)
cmp    $0x40,%edi
je     14b7 <obfuscate+0x357>
movdqu 0x40(%r15),%xmm2
movdqu 0x50(%r15),%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
paddb  %xmm0,%xmm2
paddb  %xmm0,%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
movdqu %xmm2,0x43(%r14)
movdqu %xmm3,0x53(%r14)
cmp    $0x60,%edi
je     14b7 <obfuscate+0x357>
movdqu 0x60(%r15),%xmm2
movdqu 0x70(%r15),%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
paddb  %xmm0,%xmm2
paddb  %xmm0,%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
movdqu %xmm2,0x63(%r14)
movdqu %xmm3,0x73(%r14)
cmp    $0x80,%edi
je     14b7 <obfuscate+0x357>
movdqu 0x80(%r15),%xmm2
movdqu 0x90(%r15),%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
paddb  %xmm0,%xmm2
paddb  %xmm0,%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
movdqu %xmm2,0x83(%r14)
movdqu %xmm3,0x93(%r14)
cmp    $0xa0,%edi
je     14b7 <obfuscate+0x357>
movdqu 0xa0(%r15),%xmm2
movdqu 0xb0(%r15),%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
paddb  %xmm0,%xmm2
paddb  %xmm0,%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
movdqu %xmm2,0xa3(%r14)
movdqu %xmm3,0xb3(%r14)
cmp    $0xc0,%edi
je     14b7 <obfuscate+0x357>
movdqu 0xc0(%r15),%xmm2
movdqu 0xd0(%r15),%xmm3
pxor   %xmm1,%xmm2
pxor   %xmm1,%xmm3
paddb  %xmm0,%xmm2
paddb  %xmm0,%xmm3
pxor   %xmm0,%xmm2
pxor   %xmm0,%xmm3
movdqu %xmm2,0xc3(%r14)
movdqu %xmm3,0xd3(%r14)
cmp    %r10,%rdi
je     12b5 <obfuscate+0x155>
test   $0x18,%r10b
je     1520 <obfuscate+0x3c0>
mov    %rdi,%rsi
mov    %r10d,%edi
and    $0xfffffff8,%edi
lea    0x3(%rdi),%rbp
movd   %r9d,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
movd   %r8d,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
nop
movq   (%r15,%rsi,1),%xmm2
pxor   %xmm0,%xmm2
paddb  %xmm1,%xmm2
pxor   %xmm1,%xmm2
movq   %xmm2,0x3(%r14,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rdi
jne    14f0 <obfuscate+0x390>
cmp    %r10,%rdi
jne    124b <obfuscate+0xeb>
jmp    12b5 <obfuscate+0x155>
mov    %rdi,%rbp
or     $0x3,%rbp
jmp    124b <obfuscate+0xeb>

LLVM IR (-O0):
@__const.obfuscate.nl = [2 x i8] c"\0A\00"
@__const.obfuscate.tb = [2 x i8] c"\09\00"
@__const.obfuscate.cr = [2 x i8] c"\0D\00"
@.str = [3 x i8] c"\\n\00"
@.str.1 = [3 x i8] c"\\t\00"
@.str.2 = [3 x i8] c"\\r\00"
@.str.3 = [17 x i8] c"String too long\0A\00"
define i32 @obfuscate(i8* %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8
%8 = alloca i8
%9 = alloca i8*
%10 = alloca [2 x i8]
%11 = alloca [2 x i8]
%12 = alloca [2 x i8]
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i8* null, i8** %9
%16 = bitcast [2 x i8]* %10 to i8*
%17 = bitcast [2 x i8]* %11 to i8*
%18 = bitcast [2 x i8]* %12 to i8*
%19 = call i32 @time(i32 0)
%20 = call i32 @srandom(i32 %19)
%21 = call i32 (...) @random()
store i32 %21, i32* %6
%22 = load i32, i32* %6
%23 = and i32 %22, 255
%24 = trunc i32 %23 to i8
store i8 %24, i8* %7
%25 = load i32, i32* %6
%26 = and i32 %25, 65280
%27 = lshr i32 %26, 8
%28 = trunc i32 %27 to i8
store i8 %28, i8* %8
%29 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 0
%30 = load i8*, i8** %4
%31 = call i8* @str_replace(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %29, i8* %30)
store i8* %31, i8** %9
%32 = getelementptr inbounds [2 x i8], [2 x i8]* %11, i64 0, i64 0
%33 = load i8*, i8** %9
%34 = call i8* @str_replace(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %32, i8* %33)
store i8* %34, i8** %9
%35 = getelementptr inbounds [2 x i8], [2 x i8]* %12, i64 0, i64 0
%36 = load i8*, i8** %9
%37 = call i8* @str_replace(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* %35, i8* %36)
store i8* %37, i8** %9
%38 = load i8*, i8** %9
%39 = call i32 @strlen(i8* %38)
store i32 %39, i32* %15
%40 = load i32, i32* %15
%41 = icmp sgt i32 %40, 255
br i1 %41, label %42, label %44
42: ; preds = %2
%43 = call i32 @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0))
store i32 0, i32* %3
br label %109
44: ; preds = %2
%45 = load i8, i8* %7
%46 = load i8*, i8** %5
%47 = getelementptr inbounds i8, i8* %46, i64 0
store i8 %45, i8* %47
%48 = load i8, i8* %8
%49 = load i8*, i8** %5
%50 = getelementptr inbounds i8, i8* %49, i64 1
store i8 %48, i8* %50
%51 = load i32, i32* %15
%52 = trunc i32 %51 to i8
%53 = zext i8 %52 to i32
%54 = load i8, i8* %7
%55 = zext i8 %54 to i32
%56 = xor i32 %53, %55
%57 = load i8, i8* %8
%58 = zext i8 %57 to i32
%59 = xor i32 %56, %58
%60 = trunc i32 %59 to i8
%61 = load i8*, i8** %5
%62 = getelementptr inbounds i8, i8* %61, i64 2
store i8 %60, i8* %62
store i32 0, i32* %13
store i32 3, i32* %14
br label %63
63: ; preds = %102, %44
%64 = load i32, i32* %13
%65 = load i32, i32* %15
%66 = icmp slt i32 %64, %65
br i1 %66, label %67, label %107
67: ; preds = %63
%68 = load i8*, i8** %9
%69 = load i32, i32* %13
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i8, i8* %68, i64 %70
%72 = load i8, i8* %71
%73 = zext i8 %72 to i32
%74 = load i8, i8* %7
%75 = zext i8 %74 to i32
%76 = xor i32 %73, %75
%77 = trunc i32 %76 to i8
%78 = load i8*, i8** %5
%79 = load i32, i32* %14
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i8, i8* %78, i64 %80
store i8 %77, i8* %81
%82 = load i8, i8* %8
%83 = zext i8 %82 to i32
%84 = load i8*, i8** %5
%85 = load i32, i32* %14
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %84, i64 %86
%88 = load i8, i8* %87
%89 = zext i8 %88 to i32
%90 = add nsw i32 %89, %83
%91 = trunc i32 %90 to i8
store i8 %91, i8* %87
%92 = load i8, i8* %8
%93 = zext i8 %92 to i32
%94 = load i8*, i8** %5
%95 = load i32, i32* %14
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i8, i8* %94, i64 %96
%98 = load i8, i8* %97
%99 = zext i8 %98 to i32
%100 = xor i32 %99, %93
%101 = trunc i32 %100 to i8
store i8 %101, i8* %97
br label %102
102: ; preds = %67
%103 = load i32, i32* %13
%104 = add nsw i32 %103, 1
store i32 %104, i32* %13
%105 = load i32, i32* %14
%106 = add nsw i32 %105, 1
store i32 %106, i32* %14
br label %63
107: ; preds = %63
%108 = load i32, i32* %15
store i32 %108, i32* %3
br label %109
109: ; preds = %107, %42
%110 = load i32, i32* %3
ret i32 %110
}

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