#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*/ E(unsigned char const *, unsigned char const *,
                     unsigned char *);
int /*<<< orphan*/ G(unsigned char *, unsigned char *, unsigned char *);
int /*<<< orphan*/ Gleak(unsigned char *, unsigned char *, unsigned char *,
                         unsigned char *);
int /*<<< orphan*/ KS(unsigned char *, unsigned char *);
scalar_t__ malloc(unsigned long long);
int /*<<< orphan*/ padding(unsigned char const *, unsigned long long,
                           unsigned char *, unsigned long long);
int crypto_aead_encrypt(unsigned char *c, unsigned long long *clen,
                        const unsigned char *m, unsigned long long mlen,
                        const unsigned char *ad, unsigned long long adlen,
                        const unsigned char *nsec, const unsigned char *npub,
                        const unsigned char *k) {
  unsigned char *mpad;
  unsigned long long mpadlen;
  unsigned char *adpad = NULL;
  unsigned long long adpadlen;
  unsigned char ukey[16];
  unsigned char datastate[8] = {0}, keystate[10], leak[6];
  unsigned char subkey[16 * 4];
  unsigned char tag[8];
  int i, j;
  if (mlen == 0) {
    mpadlen = 0;
    mpad = (unsigned char *)malloc(mpadlen);
    padding(m, mlen, mpad, mpadlen);
  } else {
    if ((mlen + 5) % 6 == 0) {
      mpadlen = mlen + 5;
    } else {
      mpadlen = ((mlen + 5) / 6 + 1) * 6;
    }
    mpad = (unsigned char *)malloc(mpadlen);
    padding(m, mlen, mpad, mpadlen);
  }
  if (adlen == 0) {
    adpadlen = 0;
  } else {
    if ((adlen + 5) % 6 == 0) {
      adpadlen = adlen + 5;
    } else {
      adpadlen = ((adlen + 5) / 6 + 1) * 6;
    }
    adpad = (unsigned char *)malloc(adpadlen);
    padding(ad, adlen, adpad, adpadlen);
  }
  E(npub, k, ukey);
  E(ukey, k, ukey + 8);
  for (i = 0; i < 10; i++) {
    keystate[i] = ukey[i + 6];
  }
  E(datastate, ukey, datastate);
  for (i = 0; i < adpadlen; i += 6) {
    KS(keystate, subkey);
    G(datastate, subkey, datastate);
    for (j = 0; j < 6; j++) {
      datastate[j + 2] ^= adpad[i + j];
    }
  }
  for (i = 0; i < mpadlen; i += 6) {
    KS(keystate, subkey);
    Gleak(datastate, subkey, datastate, leak);
    for (j = 0; j < 6; j++) {
      datastate[j + 2] ^= mpad[i + j];
      if ((i + j) < mlen) {
        c[i + j] = m[i + j] ^ leak[j];
      }
    }
  }
  E(datastate, k, tag);
  for (i = 0; i < 8; i++) {
    c[mlen + i] = tag[i];
  }
  *clen = mlen + 8;
  return 0;
}


x86 assembly (clang, -O0):
<crypto_aead_encrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movq   $0x0,-0x48(%rbp)
lea    -0x68(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1030 <memset@plt>
cmpq   $0x0,-0x20(%rbp)
jne    11f1 <crypto_aead_encrypt+0x81>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rdi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   1080 <padding@plt>
jmp    125e <crypto_aead_encrypt+0xee>
mov    -0x20(%rbp),%rax
add    $0x5,%rax
mov    $0x6,%ecx
xor    %edx,%edx
div    %rcx
cmp    $0x0,%rdx
jne    121e <crypto_aead_encrypt+0xae>
mov    -0x20(%rbp),%rax
add    $0x5,%rax
mov    %rax,-0x40(%rbp)
jmp    123c <crypto_aead_encrypt+0xcc>
mov    -0x20(%rbp),%rax
add    $0x5,%rax
mov    $0x6,%ecx
xor    %edx,%edx
div    %rcx
add    $0x1,%rax
imul   $0x6,%rax,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rdi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   1080 <padding@plt>
cmpq   $0x0,-0x30(%rbp)
jne    1276 <crypto_aead_encrypt+0x106>
movq   $0x0,-0x50(%rbp)
jmp    12e3 <crypto_aead_encrypt+0x173>
mov    -0x30(%rbp),%rax
add    $0x5,%rax
mov    $0x6,%ecx
xor    %edx,%edx
div    %rcx
cmp    $0x0,%rdx
jne    12a3 <crypto_aead_encrypt+0x133>
mov    -0x30(%rbp),%rax
add    $0x5,%rax
mov    %rax,-0x50(%rbp)
jmp    12c1 <crypto_aead_encrypt+0x151>
mov    -0x30(%rbp),%rax
add    $0x5,%rax
mov    $0x6,%ecx
xor    %edx,%edx
div    %rcx
add    $0x1,%rax
imul   $0x6,%rax,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x50(%rbp),%rcx
call   1080 <padding@plt>
mov    0x18(%rbp),%rdi
mov    0x20(%rbp),%rsi
lea    -0x60(%rbp),%rdx
call   1050 <E@plt>
lea    -0x60(%rbp),%rdi
mov    0x20(%rbp),%rsi
lea    -0x60(%rbp),%rdx
add    $0x8,%rdx
call   1050 <E@plt>
movl   $0x0,-0xcc(%rbp)
cmpl   $0xa,-0xcc(%rbp)
jge    134e <crypto_aead_encrypt+0x1de>
mov    -0xcc(%rbp),%eax
add    $0x6,%eax
cltq
mov    -0x60(%rbp,%rax,1),%cl
movslq -0xcc(%rbp),%rax
mov    %cl,-0x72(%rbp,%rax,1)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1313 <crypto_aead_encrypt+0x1a3>
lea    -0x68(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x68(%rbp),%rdx
call   1050 <E@plt>
movl   $0x0,-0xcc(%rbp)
movslq -0xcc(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    140f <crypto_aead_encrypt+0x29f>
lea    -0x72(%rbp),%rdi
lea    -0xc0(%rbp),%rsi
call   1070 <KS@plt>
lea    -0x68(%rbp),%rdi
lea    -0xc0(%rbp),%rsi
lea    -0x68(%rbp),%rdx
call   1060 <G@plt>
movl   $0x0,-0xd0(%rbp)
cmpl   $0x6,-0xd0(%rbp)
jge    13f6 <crypto_aead_encrypt+0x286>
mov    -0x48(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0xd0(%rbp),%eax
add    $0x2,%eax
cltq
movzbl -0x68(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x68(%rbp,%rax,1)
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    13a8 <crypto_aead_encrypt+0x238>
jmp    13fb <crypto_aead_encrypt+0x28b>
mov    -0xcc(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0xcc(%rbp)
jmp    1369 <crypto_aead_encrypt+0x1f9>
movl   $0x0,-0xcc(%rbp)
movslq -0xcc(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    151d <crypto_aead_encrypt+0x3ad>
lea    -0x72(%rbp),%rdi
lea    -0xc0(%rbp),%rsi
call   1070 <KS@plt>
lea    -0x68(%rbp),%rdi
lea    -0xc0(%rbp),%rsi
lea    -0x68(%rbp),%rdx
lea    -0x78(%rbp),%rcx
call   1090 <Gleak@plt>
movl   $0x0,-0xd0(%rbp)
cmpl   $0x6,-0xd0(%rbp)
jge    1504 <crypto_aead_encrypt+0x394>
mov    -0x38(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0xd0(%rbp),%eax
add    $0x2,%eax
cltq
movzbl -0x68(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x68(%rbp,%rax,1)
mov    -0xcc(%rbp),%eax
add    -0xd0(%rbp),%eax
cltq
cmp    -0x20(%rbp),%rax
jae    14eb <crypto_aead_encrypt+0x37b>
mov    -0x18(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
movslq -0xd0(%rbp),%rcx
movzbl -0x78(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    14f0 <crypto_aead_encrypt+0x380>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    145c <crypto_aead_encrypt+0x2ec>
jmp    1509 <crypto_aead_encrypt+0x399>
mov    -0xcc(%rbp),%eax
add    $0x6,%eax
mov    %eax,-0xcc(%rbp)
jmp    1419 <crypto_aead_encrypt+0x2a9>
lea    -0x68(%rbp),%rdi
mov    0x20(%rbp),%rsi
lea    -0xc8(%rbp),%rdx
call   1050 <E@plt>
movl   $0x0,-0xcc(%rbp)
cmpl   $0x8,-0xcc(%rbp)
jge    157f <crypto_aead_encrypt+0x40f>
movslq -0xcc(%rbp),%rax
mov    -0xc8(%rbp,%rax,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0xcc(%rbp),%rsi
add    %rsi,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    153b <crypto_aead_encrypt+0x3cb>
mov    -0x20(%rbp),%rcx
add    $0x8,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
xor    %eax,%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<crypto_aead_encrypt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0x48(%rsp)
mov    %r8,0x40(%rsp)
mov    %rcx,%r14
mov    %rdx,%r13
mov    %rsi,0x58(%rsp)
mov    %rdi,%r15
movq   $0x0,0x8(%rsp)
movabs $0xaaaaaaaaaaaaaaab,%rdx
aa aa aa
test   %rcx,%rcx
mov    %r13,0x60(%rsp)
je     11f4 <crypto_aead_encrypt+0x94>
lea    0x5(%r14),%rcx
mov    %rcx,%rax
mul    %rdx
shr    %rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rdx,%rdx,2),%rax
neg    %rax
add    %r14,%rax
add    $0x5,%rax
mov    %r14,%rbx
sub    %rax,%rbx
add    $0xb,%rbx
test   %rax,%rax
cmove  %rcx,%rbx
mov    %rbx,%rdi
call   1030 <malloc@plt>
mov    %rax,%rbp
mov    %r13,%rdi
mov    %r14,%rsi
mov    %rax,%rdx
mov    %rbx,0x18(%rsp)
mov    %rbx,%rcx
jmp    120f <crypto_aead_encrypt+0xaf>
xor    %eax,%eax
mov    %rax,0x18(%rsp)
xor    %edi,%edi
call   1030 <malloc@plt>
mov    %rax,%rbp
mov    %r13,%rdi
xor    %esi,%esi
mov    %rax,%rdx
xor    %ecx,%ecx
call   1070 <padding@plt>
mov    0x100(%rsp),%r12
mov    0xf8(%rsp),%rdi
mov    0x48(%rsp),%rsi
test   %rsi,%rsi
mov    %r15,0x50(%rsp)
je     1298 <crypto_aead_encrypt+0x138>
lea    0x5(%rsi),%rcx
mov    %rcx,%rax
movabs $0xaaaaaaaaaaaaaaab,%rdx
aa aa aa
mul    %rdx
shr    %rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rdx,%rdx,2),%rax
neg    %rax
add    %rsi,%rax
add    $0x5,%rax
mov    %rsi,%rbx
sub    %rax,%rbx
add    $0xb,%rbx
test   %rax,%rax
cmove  %rcx,%rbx
mov    %rbx,%rdi
mov    %rsi,%r15
call   1030 <malloc@plt>
mov    %rax,%r13
mov    0x40(%rsp),%rdi
mov    %r15,%rsi
mov    %rax,%rdx
mov    %rbx,%rcx
call   1070 <padding@plt>
mov    0xf8(%rsp),%rdi
jmp    129d <crypto_aead_encrypt+0x13d>
xor    %r13d,%r13d
xor    %ebx,%ebx
lea    0x30(%rsp),%r15
mov    %r12,%rsi
mov    %r15,%rdx
call   1040 <E@plt>
lea    0x38(%rsp),%rdx
mov    %r15,%rdi
mov    %r12,%rsi
call   1040 <E@plt>
mov    0x36(%rsp),%rax
mov    %rax,0x20(%rsp)
movzwl 0x3e(%rsp),%eax
mov    %ax,0x28(%rsp)
lea    0x8(%rsp),%rdi
mov    %r15,%rsi
mov    %rdi,%rdx
call   1040 <E@plt>
test   %rbx,%rbx
je     1357 <crypto_aead_encrypt+0x1f7>
mov    %rbx,%r15
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
lea    0x20(%rsp),%rdi
lea    0x70(%rsp),%r12
mov    %r12,%rsi
call   1060 <KS@plt>
lea    0x8(%rsp),%rdi
mov    %r12,%rsi
mov    %rdi,%rdx
call   1050 <G@plt>
movzbl 0x0(%r13,%rbx,1),%eax
xor    %al,0xa(%rsp)
movzbl 0x1(%r13,%rbx,1),%eax
xor    %al,0xb(%rsp)
movzbl 0x2(%r13,%rbx,1),%eax
xor    %al,0xc(%rsp)
movzbl 0x3(%r13,%rbx,1),%eax
xor    %al,0xd(%rsp)
movzbl 0x4(%r13,%rbx,1),%eax
xor    %al,0xe(%rsp)
movzbl 0x5(%r13,%rbx,1),%eax
xor    %al,0xf(%rsp)
add    $0x6,%rbx
cmp    %rbx,%r15
ja     12f0 <crypto_aead_encrypt+0x190>
cmpq   $0x0,0x18(%rsp)
mov    0x50(%rsp),%r12
je     147a <crypto_aead_encrypt+0x31a>
xor    %ebx,%ebx
lea    0x70(%rsp),%r15
lea    0x8(%rsp),%r13
jmp    1392 <crypto_aead_encrypt+0x232>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rax
mov    %rax,%rbx
cmp    %rax,0x18(%rsp)
jbe    147a <crypto_aead_encrypt+0x31a>
lea    0x20(%rsp),%rdi
mov    %r15,%rsi
call   1060 <KS@plt>
mov    %r13,%rdi
mov    %r15,%rsi
mov    %r13,%rdx
lea    0x12(%rsp),%rcx
call   1080 <Gleak@plt>
movzbl 0x0(%rbp,%rbx,1),%eax
xor    %al,0xa(%rsp)
cmp    %r14,%rbx
mov    0x60(%rsp),%rdx
jae    13d1 <crypto_aead_encrypt+0x271>
movzbl 0x12(%rsp),%eax
xor    (%rdx,%rbx,1),%al
mov    %al,(%r12,%rbx,1)
movzbl 0x1(%rbp,%rbx,1),%eax
xor    %al,0xb(%rsp)
lea    0x1(%rbx),%rax
cmp    %r14,%rax
jae    13f1 <crypto_aead_encrypt+0x291>
movzbl 0x13(%rsp),%ecx
xor    0x1(%rdx,%rbx,1),%cl
mov    %cl,0x1(%r12,%rbx,1)
movzbl 0x2(%rbp,%rbx,1),%ecx
xor    %cl,0xc(%rsp)
add    $0x1,%rax
cmp    %r14,%rax
jae    1411 <crypto_aead_encrypt+0x2b1>
movzbl 0x14(%rsp),%ecx
xor    0x2(%rdx,%rbx,1),%cl
mov    %cl,0x2(%r12,%rbx,1)
movzbl 0x3(%rbp,%rbx,1),%ecx
xor    %cl,0xd(%rsp)
add    $0x1,%rax
cmp    %r14,%rax
jae    1431 <crypto_aead_encrypt+0x2d1>
movzbl 0x15(%rsp),%ecx
xor    0x3(%rdx,%rbx,1),%cl
mov    %cl,0x3(%r12,%rbx,1)
movzbl 0x4(%rbp,%rbx,1),%ecx
xor    %cl,0xe(%rsp)
add    $0x1,%rax
cmp    %r14,%rax
jae    1451 <crypto_aead_encrypt+0x2f1>
movzbl 0x16(%rsp),%ecx
xor    0x4(%rdx,%rbx,1),%cl
mov    %cl,0x4(%r12,%rbx,1)
movzbl 0x5(%rbp,%rbx,1),%ecx
xor    %cl,0xf(%rsp)
add    $0x1,%rax
cmp    %r14,%rax
jae    1380 <crypto_aead_encrypt+0x220>
movzbl 0x17(%rsp),%ecx
xor    0x5(%rdx,%rbx,1),%cl
mov    %cl,0x5(%r12,%rbx,1)
jmp    1380 <crypto_aead_encrypt+0x220>
lea    0x8(%rsp),%rdi
lea    0x68(%rsp),%rdx
mov    0x100(%rsp),%rsi
call   1040 <E@plt>
mov    0x68(%rsp),%rax
mov    %rax,(%r12,%r14,1)
add    $0x8,%r14
mov    0x58(%rsp),%rax
mov    %r14,(%rax)
xor    %eax,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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