#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*/ core(unsigned char *, unsigned int *);
int /*<<< orphan*/ kexp(unsigned int *, unsigned int const,
                        unsigned char const *, unsigned char const *);
int crypto_stream_chacha20_xor(unsigned char *out, const unsigned char *msg,
                               unsigned long long mlen,
                               const unsigned int counter,
                               const unsigned char *nonce,
                               const unsigned char *key) {
  unsigned long long i;
  unsigned int st[16];
  unsigned char blk[64];
  kexp(st, counter, nonce, key);
  for (;;) {
    core(blk, st);
    st[12] = st[12] + 1;
    if (mlen <= 64) {
      for (i = 0; i < mlen; ++i)
        out[i] = msg[i] ^ blk[i];
      return 0;
    }
    for (i = 0; i < 64; ++i) {
      out[i] = msg[i] ^ blk[i];
    }
    mlen -= 64;
    msg += 64;
    out += 64;
  }
  return 0;
}


x86 assembly (clang, -O0):
<crypto_stream_chacha20_xor>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
lea    -0x80(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
call   1040 <kexp@plt>
lea    -0xc0(%rbp),%rdi
lea    -0x80(%rbp),%rsi
call   1030 <core@plt>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
cmpq   $0x40,-0x18(%rbp)
ja     11d3 <crypto_stream_chacha20_xor+0xb3>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    11c8 <crypto_stream_chacha20_xor+0xa8>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x38(%rbp),%rcx
movzbl -0xc0(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1182 <crypto_stream_chacha20_xor+0x62>
xor    %eax,%eax
add    $0xc0,%rsp
pop    %rbp
ret
movq   $0x0,-0x38(%rbp)
cmpq   $0x40,-0x38(%rbp)
jae    121e <crypto_stream_chacha20_xor+0xfe>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x38(%rbp),%rcx
movzbl -0xc0(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    11db <crypto_stream_chacha20_xor+0xbb>
mov    -0x18(%rbp),%rax
sub    $0x40,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x8(%rbp)
jmp    1156 <crypto_stream_chacha20_xor+0x36>

x86 assembly (clang, -O2):
<crypto_stream_chacha20_xor>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rdx,%rbx
mov    %rsi,%r13
mov    %rdi,%r14
lea    0x40(%rsp),%r15
mov    %r15,%rdi
mov    %ecx,%esi
mov    %r8,%rdx
mov    %r9,%rcx
call   1040 <kexp@plt>
mov    %rsp,%rdi
mov    %r15,%rsi
call   1030 <core@plt>
addl   $0x1,0x70(%rsp)
cmp    $0x41,%rbx
jae    1216 <crypto_stream_chacha20_xor+0xf6>
mov    %r13,%r12
mov    %r14,%r15
test   %rbx,%rbx
je     1202 <crypto_stream_chacha20_xor+0xe2>
cmp    $0x8,%rbx
jae    1308 <crypto_stream_chacha20_xor+0x1e8>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %rbx,%rsi
mov    %rbx,%rdx
and    $0x3,%rdx
je     11b6 <crypto_stream_chacha20_xor+0x96>
cs nopw 0x0(%rax,%rax,1)
movzbl (%rsp,%rax,1),%ecx
xor    (%r12,%rax,1),%cl
mov    %cl,(%r15,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    11a0 <crypto_stream_chacha20_xor+0x80>
cmp    $0x3,%rsi
jb     1202 <crypto_stream_chacha20_xor+0xe2>
nopl   0x0(%rax)
movzbl (%rsp,%rax,1),%ecx
xor    (%r12,%rax,1),%cl
mov    %cl,(%r15,%rax,1)
movzbl 0x1(%rsp,%rax,1),%ecx
xor    0x1(%r12,%rax,1),%cl
mov    %cl,0x1(%r15,%rax,1)
movzbl 0x2(%rsp,%rax,1),%ecx
xor    0x2(%r12,%rax,1),%cl
mov    %cl,0x2(%r15,%rax,1)
movzbl 0x3(%rsp,%rax,1),%ecx
xor    0x3(%r12,%rax,1),%cl
mov    %cl,0x3(%r15,%rax,1)
add    $0x4,%rax
cmp    %rax,%rbx
jne    11c0 <crypto_stream_chacha20_xor+0xa0>
xor    %eax,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
mov    %r14,%r15
mov    %r13,%r12
jmp    1289 <crypto_stream_chacha20_xor+0x169>
movups (%r12),%xmm0
xorps  (%rsp),%xmm0
movups %xmm0,(%r15)
movups 0x10(%r12),%xmm0
xorps  0x10(%rsp),%xmm0
movups %xmm0,0x10(%r15)
movups 0x20(%r12),%xmm0
xorps  0x20(%rsp),%xmm0
movups %xmm0,0x20(%r15)
movups 0x30(%r12),%xmm0
xorps  0x30(%rsp),%xmm0
movups %xmm0,0x30(%r15)
add    $0xffffffffffffffc0,%rbx
add    $0x40,%r12
add    $0x40,%r15
mov    %rsp,%rdi
lea    0x40(%rsp),%rsi
call   1030 <core@plt>
addl   $0x1,0x70(%rsp)
add    $0x1,%rbp
cmp    $0x41,%rbx
jb     116f <crypto_stream_chacha20_xor+0x4f>
mov    %rbp,%rax
shl    $0x6,%rax
lea    (%rax,%r13,1),%rcx
add    $0x40,%rcx
cmp    %rcx,%r15
jae    1220 <crypto_stream_chacha20_xor+0x100>
add    %r14,%rax
add    $0x40,%rax
cmp    %rax,%r12
jae    1220 <crypto_stream_chacha20_xor+0x100>
mov    $0x3,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl -0x3(%rsp,%rax,1),%ecx
xor    -0x3(%r12,%rax,1),%cl
mov    %cl,-0x3(%r15,%rax,1)
movzbl -0x2(%rsp,%rax,1),%ecx
xor    -0x2(%r12,%rax,1),%cl
mov    %cl,-0x2(%r15,%rax,1)
movzbl -0x1(%rsp,%rax,1),%ecx
xor    -0x1(%r12,%rax,1),%cl
mov    %cl,-0x1(%r15,%rax,1)
movzbl (%rsp,%rax,1),%ecx
xor    (%r12,%rax,1),%cl
mov    %cl,(%r15,%rax,1)
add    $0x4,%rax
cmp    $0x43,%rax
jne    12c0 <crypto_stream_chacha20_xor+0x1a0>
jmp    125d <crypto_stream_chacha20_xor+0x13d>
lea    (%r15,%rbx,1),%rax
lea    (%r12,%rbx,1),%rcx
lea    (%rsp,%rbx,1),%rdx
cmp    %rcx,%r15
setb   %sil
cmp    %rax,%r12
setb   %dil
cmp    %rdx,%r15
setb   %cl
mov    %rsp,%rdx
cmp    %rax,%rdx
setb   %dl
xor    %eax,%eax
test   %dil,%sil
jne    1184 <crypto_stream_chacha20_xor+0x64>
and    %dl,%cl
jne    1184 <crypto_stream_chacha20_xor+0x64>
cmp    $0x20,%rbx
jae    1351 <crypto_stream_chacha20_xor+0x231>
xor    %eax,%eax
jmp    1401 <crypto_stream_chacha20_xor+0x2e1>
mov    %rbx,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rcx
mov    %rcx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1433 <crypto_stream_chacha20_xor+0x313>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%r12,%rcx,1),%xmm0
movups 0x10(%r12,%rcx,1),%xmm1
xorps  (%rsp,%rcx,1),%xmm0
xorps  0x10(%rsp,%rcx,1),%xmm1
movups %xmm0,(%r15,%rcx,1)
movups %xmm1,0x10(%r15,%rcx,1)
movups 0x20(%r12,%rcx,1),%xmm0
movups 0x30(%r12,%rcx,1),%xmm1
xorps  0x20(%rsp,%rcx,1),%xmm0
xorps  0x30(%rsp,%rcx,1),%xmm1
movups %xmm0,0x20(%r15,%rcx,1)
movups %xmm1,0x30(%r15,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1380 <crypto_stream_chacha20_xor+0x260>
test   $0x1,%dl
je     13ef <crypto_stream_chacha20_xor+0x2cf>
movups (%r12,%rcx,1),%xmm0
movups 0x10(%r12,%rcx,1),%xmm1
xorps  (%rsp,%rcx,1),%xmm0
xorps  0x10(%rsp,%rcx,1),%xmm1
movups %xmm0,(%r15,%rcx,1)
movups %xmm1,0x10(%r15,%rcx,1)
cmp    %rax,%rbx
je     1202 <crypto_stream_chacha20_xor+0xe2>
test   $0x18,%bl
je     1184 <crypto_stream_chacha20_xor+0x64>
mov    %rax,%rcx
mov    %rbx,%rax
and    $0xfffffffffffffff8,%rax
nopl   0x0(%rax,%rax,1)
mov    (%rsp,%rcx,1),%rdx
xor    (%r12,%rcx,1),%rdx
mov    %rdx,(%r15,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1410 <crypto_stream_chacha20_xor+0x2f0>
cmp    %rax,%rbx
jne    1184 <crypto_stream_chacha20_xor+0x64>
jmp    1202 <crypto_stream_chacha20_xor+0xe2>
xor    %ecx,%ecx
test   $0x1,%dl
jne    13d0 <crypto_stream_chacha20_xor+0x2b0>
jmp    13ef <crypto_stream_chacha20_xor+0x2cf>

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

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