#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*/ rol(unsigned char *, unsigned char *, unsigned int);
void mix(unsigned char *buf, unsigned int s) {
  unsigned char ab[16];
  unsigned int i;
  for (i = 0; i < s; i++) {
    ab[i] = buf[i] ^ buf[s + i];
  }
  rol(ab, ab, s);
  for (i = 0; i < s; i++) {
    buf[i] ^= ab[i];
    buf[s + i] ^= ab[i];
  }
}


x86 assembly (clang, -O0):
<mix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1166 <mix+0x56>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    -0x24(%rbp),%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x24(%rbp),%eax
mov    %cl,-0x20(%rbp,%rax,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1126 <mix+0x16>
lea    -0x20(%rbp),%rdi
lea    -0x20(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   1030 <rol@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    11cc <mix+0xbc>
mov    -0x24(%rbp),%eax
movzbl -0x20(%rbp,%rax,1),%esi
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
movzbl -0x20(%rbp,%rax,1),%esi
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x24(%rbp),%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    117d <mix+0x6d>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mix>:
push   %r15
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %esi,%r14d
test   %esi,%esi
je     11ac <mix+0x9c>
mov    %rdi,%rbx
mov    %r14d,%r15d
cmp    $0x8,%r14d
jae    11bf <mix+0xaf>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r15b
je     1153 <mix+0x43>
lea    (%rax,%r14,1),%edx
mov    (%rbx,%rdx,1),%dl
xor    (%rbx,%rax,1),%dl
mov    %dl,(%rsp,%rax,1)
or     $0x1,%rax
add    %r15,%rcx
je     1188 <mix+0x78>
nopl   0x0(%rax,%rax,1)
lea    (%r15,%rax,1),%rcx
mov    %ecx,%edx
movzbl (%rbx,%rdx,1),%edx
xor    (%rbx,%rax,1),%dl
mov    %dl,(%rsp,%rax,1)
add    $0x1,%ecx
movzbl (%rbx,%rcx,1),%ecx
xor    0x1(%rbx,%rax,1),%cl
mov    %cl,0x1(%rsp,%rax,1)
add    $0x2,%rax
cmp    %rax,%r15
jne    1160 <mix+0x50>
mov    %rsp,%rdi
mov    %rdi,%rsi
mov    %r14d,%edx
call   1030 <rol@plt>
test   %r14d,%r14d
je     13d8 <mix+0x2c8>
cmp    $0x8,%r14d
jae    11e7 <mix+0xd7>
xor    %eax,%eax
jmp    138e <mix+0x27e>
mov    %rsp,%rdi
mov    %rdi,%rsi
mov    %r14d,%edx
call   1030 <rol@plt>
jmp    13d8 <mix+0x2c8>
lea    -0x1(%r15),%rcx
xor    %eax,%eax
mov    %r14d,%edx
add    %ecx,%edx
jb     1136 <mix+0x26>
shr    $0x20,%rcx
jne    1136 <mix+0x26>
cmp    $0x20,%r14d
jae    1213 <mix+0x103>
xor    %eax,%eax
jmp    12d4 <mix+0x1c4>
lea    -0x1(%r15),%rcx
xor    %eax,%eax
mov    %r14d,%edx
add    %ecx,%edx
jb     138e <mix+0x27e>
shr    $0x20,%rcx
jne    138e <mix+0x27e>
cmp    $0x20,%r14d
jae    1307 <mix+0x1f7>
xor    %eax,%eax
jmp    1361 <mix+0x251>
mov    %r15d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rcx
mov    %rcx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     13e2 <mix+0x2d2>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
mov    %r14d,%edi
nopl   (%rax)
movups (%rbx,%rcx,1),%xmm0
movups 0x10(%rbx,%rcx,1),%xmm1
mov    %edi,%edx
movups (%rbx,%rdx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbx,%rdx,1),%xmm0
xorps  %xmm1,%xmm0
movaps %xmm2,(%rsp,%rcx,1)
movaps %xmm0,0x10(%rsp,%rcx,1)
movups 0x20(%rbx,%rcx,1),%xmm0
movups 0x30(%rbx,%rcx,1),%xmm1
lea    0x20(%rdi),%edx
movups (%rbx,%rdx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbx,%rdx,1),%xmm0
xorps  %xmm1,%xmm0
movaps %xmm2,0x20(%rsp,%rcx,1)
movaps %xmm0,0x30(%rsp,%rcx,1)
add    $0x40,%rcx
add    $0x40,%edi
add    $0xfffffffffffffffe,%rsi
jne    1240 <mix+0x130>
test   $0x1,%r8b
je     12c1 <mix+0x1b1>
movups (%rbx,%rcx,1),%xmm0
movups 0x10(%rbx,%rcx,1),%xmm1
lea    (%rcx,%r14,1),%edx
movups (%rbx,%rdx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbx,%rdx,1),%xmm0
xorps  %xmm1,%xmm0
movaps %xmm2,(%rsp,%rcx,1)
movaps %xmm0,0x10(%rsp,%rcx,1)
cmp    %r15,%rax
je     1188 <mix+0x78>
test   $0x18,%r15b
je     1136 <mix+0x26>
mov    %rax,%rcx
mov    %r15d,%eax
and    $0xfffffff8,%eax
nopl   (%rax)
lea    (%r15,%rcx,1),%edx
mov    (%rbx,%rdx,1),%rdx
xor    (%rbx,%rcx,1),%rdx
mov    %rdx,(%rsp,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    12e0 <mix+0x1d0>
cmp    %r15,%rax
jne    1136 <mix+0x26>
jmp    1188 <mix+0x78>
mov    %r15d,%eax
and    $0xffffffe0,%eax
xor    %ecx,%ecx
nop
movaps (%rsp,%rcx,1),%xmm0
movaps 0x10(%rsp,%rcx,1),%xmm1
movups (%rbx,%rcx,1),%xmm2
movups 0x10(%rbx,%rcx,1),%xmm3
xorps  %xmm0,%xmm2
xorps  %xmm1,%xmm3
movups %xmm2,(%rbx,%rcx,1)
movups %xmm3,0x10(%rbx,%rcx,1)
lea    (%r15,%rcx,1),%edx
movups (%rbx,%rdx,1),%xmm2
movups 0x10(%rbx,%rdx,1),%xmm3
xorps  %xmm0,%xmm2
xorps  %xmm1,%xmm3
movups %xmm2,(%rbx,%rdx,1)
movups %xmm3,0x10(%rbx,%rdx,1)
add    $0x20,%rcx
cmp    %rcx,%rax
jne    1310 <mix+0x200>
cmp    %r15,%rax
je     13d8 <mix+0x2c8>
test   $0x18,%r15b
je     138e <mix+0x27e>
mov    %rax,%rcx
mov    %r15d,%eax
and    $0xfffffff8,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rsp,%rcx,1),%rdx
xor    %rdx,(%rbx,%rcx,1)
lea    (%r15,%rcx,1),%esi
xor    %rdx,(%rbx,%rsi,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1370 <mix+0x260>
cmp    %r15,%rax
je     13d8 <mix+0x2c8>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r15b
je     13ab <mix+0x29b>
mov    (%rsp,%rax,1),%dl
xor    %dl,(%rbx,%rax,1)
add    %eax,%r14d
xor    %dl,(%rbx,%r14,1)
or     $0x1,%rax
add    %r15,%rcx
je     13d8 <mix+0x2c8>
movzbl (%rsp,%rax,1),%ecx
xor    %cl,(%rbx,%rax,1)
lea    (%r15,%rax,1),%rdx
mov    %edx,%esi
xor    %cl,(%rbx,%rsi,1)
movzbl 0x1(%rsp,%rax,1),%ecx
xor    %cl,0x1(%rbx,%rax,1)
add    $0x1,%edx
xor    %cl,(%rbx,%rdx,1)
add    $0x2,%rax
cmp    %rax,%r15
jne    13b0 <mix+0x2a0>
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret
xor    %ecx,%ecx
test   $0x1,%r8b
jne    129c <mix+0x18c>
jmp    12c1 <mix+0x1b1>

LLVM IR (-O0):
define void @mix(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca [16 x i8]
%6 = alloca i32
store i8* %0, i8** %3
store i32 %1, i32* %4
store i32 0, i32* %6
br label %7
7: ; preds = %31, %2
%8 = load i32, i32* %6
%9 = load i32, i32* %4
%10 = icmp ult i32 %8, %9
br i1 %10, label %11, label %34
11: ; preds = %7
%12 = load i8*, i8** %3
%13 = load i32, i32* %6
%14 = zext i32 %13 to i64
%15 = getelementptr inbounds i8, i8* %12, i64 %14
%16 = load i8, i8* %15
%17 = zext i8 %16 to i32
%18 = load i8*, i8** %3
%19 = load i32, i32* %4
%20 = load i32, i32* %6
%21 = add i32 %19, %20
%22 = zext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %18, i64 %22
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
%26 = xor i32 %17, %25
%27 = trunc i32 %26 to i8
%28 = load i32, i32* %6
%29 = zext i32 %28 to i64
%30 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 %29
store i8 %27, i8* %30
br label %31
31: ; preds = %11
%32 = load i32, i32* %6
%33 = add i32 %32, 1
store i32 %33, i32* %6
br label %7
34: ; preds = %7
%35 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 0
%36 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 0
%37 = load i32, i32* %4
%38 = call i32 @rol(i8* %35, i8* %36, i32 %37)
store i32 0, i32* %6
br label %39
39: ; preds = %72, %34
%40 = load i32, i32* %6
%41 = load i32, i32* %4
%42 = icmp ult i32 %40, %41
br i1 %42, label %43, label %75
43: ; preds = %39
%44 = load i32, i32* %6
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 %45
%47 = load i8, i8* %46
%48 = zext i8 %47 to i32
%49 = load i8*, i8** %3
%50 = load i32, i32* %6
%51 = zext i32 %50 to i64
%52 = getelementptr inbounds i8, i8* %49, i64 %51
%53 = load i8, i8* %52
%54 = zext i8 %53 to i32
%55 = xor i32 %54, %48
%56 = trunc i32 %55 to i8
store i8 %56, i8* %52
%57 = load i32, i32* %6
%58 = zext i32 %57 to i64
%59 = getelementptr inbounds [16 x i8], [16 x i8]* %5, i64 0, i64 %58
%60 = load i8, i8* %59
%61 = zext i8 %60 to i32
%62 = load i8*, i8** %3
%63 = load i32, i32* %4
%64 = load i32, i32* %6
%65 = add i32 %63, %64
%66 = zext i32 %65 to i64
%67 = getelementptr inbounds i8, i8* %62, i64 %66
%68 = load i8, i8* %67
%69 = zext i8 %68 to i32
%70 = xor i32 %69, %61
%71 = trunc i32 %70 to i8
store i8 %71, i8* %67
br label %72
72: ; preds = %43
%73 = load i32, i32* %6
%74 = add i32 %73, 1
store i32 %74, i32* %6
br label %39
75: ; preds = %39
ret void
}

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