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 SumB[16], LastABlock[16], MacAESTag[16], Key[16], Double[16];
  unsigned long long a;
  unsigned char PaddedPMN[16];
  unsigned char LastPlaintextBlock[16], PaddedBlock[16];
  unsigned long long l;
  unsigned char StolenR[16];
  unsigned char Z[3][16], NextZ[16], U[16];
  unsigned char AESInputBlock[16], AESOutputBlock[16];
  unsigned long long i, j;
  for (j = 0; j < 16; j++)
    Key[j] = k[j];
  keyschedule(Key, 10);
  for (j = 0; j < 16; j++)
    AESInputBlock[j] = 0x0;
  AES128Enc(AESInputBlock, Z[0]);
  for (i = 0; i < 2; i++)
    Times2(Z[i], Z[i + 1]);
  Times2(Z[2], NextZ);
  if (adlen == 0) {
    for (j = 0; j < 16; j++)
      MacAESTag[j] = 0x0;
  } else {
    if (adlen % 16 == 0)
      a = adlen / 16;
    else
      a = adlen / 16 + 1;
    for (j = 0; j < 16; j++)
      SumB[j] = 0x0;
    for (i = 0; i < a - 1; i++) {
      for (j = 0; j < 16; j++)
        AESInputBlock[j] = ad[i * 16 + j] ^ NextZ[j];
      AES128Enc(AESInputBlock, AESOutputBlock);
      for (j = 0; j < 16; j++)
        SumB[j] = SumB[j] ^ AESOutputBlock[j];
      Times2(NextZ, Double);
      for (j = 0; j < 16; j++)
        NextZ[j] = Double[j];
    }
    if (adlen % 16 != 0) {
      for (j = 0; j < adlen % 16; j++)
        LastABlock[j] = ad[(a - 1) * 16 + j];
      LastABlock[adlen % 16] = 0x80;
      for (j = adlen % 16 + 1; j < 16; j++)
        LastABlock[j] = 0x0;
      for (j = 0; j < 16; j++)
        AESInputBlock[j] = SumB[j] ^ LastABlock[j] ^ Z[1][j];
    } else {
      for (j = 0; j < 16; j++)
        AESInputBlock[j] = SumB[j] ^ ad[(a - 1) * 16 + j] ^ Z[2][j];
    }
    AES128Enc(AESInputBlock, MacAESTag);
  }
  *clen = mlen + 16;
  for (j = 0; j < 13; j++)
    PaddedPMN[j] = npub[j];
  PaddedPMN[13] = 0x80;
  for (j = 13 + 1; j < 16; j++)
    PaddedPMN[j] = 0x0;
  AES128Enc(PaddedPMN, U);
  if (mlen == 0) {
    for (j = 0; j < 16; j++)
      AESInputBlock[j] = Z[2][j] ^ U[j];
    AES128Enc(AESInputBlock, AESOutputBlock);
    for (j = 0; j < 16; j++)
      c[j] = AESOutputBlock[j] ^ MacAESTag[j];
  } else {
    l = mlen / 16;
    if (mlen % 16 != 0) {
      l = l + 1;
      for (j = 0; j < mlen % 16; j++) {
        LastPlaintextBlock[j] = m[(l - 1) * 16 + j];
        PaddedBlock[j] = 0x0;
      }
      LastPlaintextBlock[mlen % 16] = 0x0;
      PaddedBlock[mlen % 16] = 0x80;
      for (j = mlen % 16 + 1; j < 16; j++) {
        LastPlaintextBlock[j] = 0x0;
        PaddedBlock[j] = 0x0;
      }
    } else {
      for (j = 0; j < 16; j++) {
        LastPlaintextBlock[j] = m[(l - 1) * 16 + j];
        PaddedBlock[j] = 0x0;
      }
    }
    Times2(Z[2], NextZ);
    for (j = 0; j < 16; j++)
      AESInputBlock[j] = NextZ[j] ^ U[j];
    AES128Enc(AESInputBlock, AESOutputBlock);
    for (i = 0; i < l - 1; i++) {
      Times2(NextZ, Double);
      for (j = 0; j < 16; j++) {
        NextZ[j] = Double[j];
        AESInputBlock[j] = m[i * 16 + j] ^ NextZ[j] ^ U[j];
        c[i * 16 + j] = AESOutputBlock[j] ^ AESInputBlock[j];
      }
      AES128Enc(AESInputBlock, AESOutputBlock);
    }
    if (mlen % 16 != 0) {
      for (j = 0; j < mlen % 16; j++) {
        c[(l - 1) * 16 + j] = AESOutputBlock[j] ^ LastPlaintextBlock[j];
        StolenR[j] = 0x0;
      }
      for (j = (mlen % 16); j < 16; j++)
        StolenR[j] = AESOutputBlock[j] ^ PaddedBlock[j];
    } else {
      for (j = 0; j < 16; j++)
        c[(l - 1) * 16 + j] = AESOutputBlock[j] ^ LastPlaintextBlock[j];
    }
    if (mlen % 16 != 0) {
      for (j = 0; j < 16; j++)
        AESInputBlock[j] = LastPlaintextBlock[j] ^ StolenR[j] ^ Z[1][j] ^ U[j];
      AES128Enc(AESInputBlock, AESOutputBlock);
      for (j = 0; j < 16; j++)
        c[(l - 1) * 16 + (mlen % 16) + j] = AESOutputBlock[j] ^ MacAESTag[j];
    } else {
      for (j = 0; j < 16; j++)
        AESInputBlock[j] = LastPlaintextBlock[j] ^ Z[2][j] ^ U[j];
      AES128Enc(AESInputBlock, AESOutputBlock);
      for (j = 0; j < 16; j++)
        c[l * 16 + j] = AESOutputBlock[j] ^ MacAESTag[j];
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<crypto_aead_encrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%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,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    11a8 <crypto_aead_encrypt+0x78>
mov    0x20(%rbp),%rax
mov    -0x160(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x70(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    116a <crypto_aead_encrypt+0x3a>
lea    -0x70(%rbp),%rdi
mov    $0xa,%esi
mov    $0x0,%al
call   1050 <keyschedule@plt>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    11f7 <crypto_aead_encrypt+0xc7>
mov    -0x160(%rbp),%rax
movb   $0x0,-0x140(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    11c3 <crypto_aead_encrypt+0x93>
lea    -0x140(%rbp),%rdi
lea    -0x110(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x158(%rbp)
cmpq   $0x2,-0x158(%rbp)
02
jae    1271 <crypto_aead_encrypt+0x141>
mov    -0x158(%rbp),%rax
lea    -0x110(%rbp),%rdi
shl    $0x4,%rax
add    %rax,%rdi
mov    -0x158(%rbp),%rax
add    $0x1,%rax
lea    -0x110(%rbp),%rsi
shl    $0x4,%rax
add    %rax,%rsi
mov    $0x0,%al
call   1040 <Times2@plt>
mov    -0x158(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x158(%rbp)
jmp    1217 <crypto_aead_encrypt+0xe7>
lea    -0x110(%rbp),%rdi
add    $0x20,%rdi
lea    -0x120(%rbp),%rsi
mov    $0x0,%al
call   1040 <Times2@plt>
cmpq   $0x0,-0x30(%rbp)
jne    12d6 <crypto_aead_encrypt+0x1a6>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    12d1 <crypto_aead_encrypt+0x1a1>
mov    -0x160(%rbp),%rax
movb   $0x0,-0x60(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    12a0 <crypto_aead_encrypt+0x170>
jmp    168b <crypto_aead_encrypt+0x55b>
mov    -0x30(%rbp),%rax
and    $0xf,%rax
cmp    $0x0,%rax
jne    12fc <crypto_aead_encrypt+0x1cc>
mov    -0x30(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x88(%rbp)
jmp    130f <crypto_aead_encrypt+0x1df>
mov    -0x30(%rbp),%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %rax,-0x88(%rbp)
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    134b <crypto_aead_encrypt+0x21b>
mov    -0x160(%rbp),%rax
movb   $0x0,-0x40(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    131a <crypto_aead_encrypt+0x1ea>
movq   $0x0,-0x158(%rbp)
mov    -0x158(%rbp),%rax
mov    -0x88(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    14c2 <crypto_aead_encrypt+0x392>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    13dc <crypto_aead_encrypt+0x2ac>
mov    -0x28(%rbp),%rax
mov    -0x158(%rbp),%rcx
shl    $0x4,%rcx
add    -0x160(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x160(%rbp),%rcx
movzbl -0x120(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    137c <crypto_aead_encrypt+0x24c>
lea    -0x140(%rbp),%rdi
lea    -0x150(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    144b <crypto_aead_encrypt+0x31b>
mov    -0x160(%rbp),%rax
movzbl -0x40(%rbp,%rax,1),%eax
mov    -0x160(%rbp),%rcx
movzbl -0x150(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x40(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    13fc <crypto_aead_encrypt+0x2cc>
lea    -0x120(%rbp),%rdi
lea    -0x80(%rbp),%rsi
mov    $0x0,%al
call   1040 <Times2@plt>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    14a6 <crypto_aead_encrypt+0x376>
mov    -0x160(%rbp),%rax
mov    -0x80(%rbp,%rax,1),%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x120(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1468 <crypto_aead_encrypt+0x338>
jmp    14ab <crypto_aead_encrypt+0x37b>
mov    -0x158(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x158(%rbp)
jmp    1356 <crypto_aead_encrypt+0x226>
mov    -0x30(%rbp),%rax
and    $0xf,%rax
cmp    $0x0,%rax
je     15f7 <crypto_aead_encrypt+0x4c7>
movq   $0x0,-0x160(%rbp)
mov    -0x160(%rbp),%rax
mov    -0x30(%rbp),%rcx
and    $0xf,%rcx
cmp    %rcx,%rax
jae    1536 <crypto_aead_encrypt+0x406>
mov    -0x28(%rbp),%rax
mov    -0x88(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x160(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    14df <crypto_aead_encrypt+0x3af>
mov    -0x30(%rbp),%rax
and    $0xf,%rax
movb   $0x80,-0x50(%rbp,%rax,1)
mov    -0x30(%rbp),%rax
and    $0xf,%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1587 <crypto_aead_encrypt+0x457>
mov    -0x160(%rbp),%rax
movb   $0x0,-0x50(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1556 <crypto_aead_encrypt+0x426>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    15f2 <crypto_aead_encrypt+0x4c2>
mov    -0x160(%rbp),%rax
movzbl -0x40(%rbp,%rax,1),%eax
mov    -0x160(%rbp),%rcx
movzbl -0x50(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    -0x160(%rbp),%rcx
movzbl -0x100(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1592 <crypto_aead_encrypt+0x462>
jmp    1679 <crypto_aead_encrypt+0x549>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1674 <crypto_aead_encrypt+0x544>
mov    -0x160(%rbp),%rax
movzbl -0x40(%rbp,%rax,1),%eax
mov    -0x28(%rbp),%rcx
mov    -0x88(%rbp),%rdx
sub    $0x1,%rdx
shl    $0x4,%rdx
add    -0x160(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    -0x160(%rbp),%rcx
movzbl -0xf0(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1602 <crypto_aead_encrypt+0x4d2>
jmp    1679 <crypto_aead_encrypt+0x549>
lea    -0x140(%rbp),%rdi
lea    -0x60(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
mov    -0x20(%rbp),%rcx
add    $0x10,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x0,-0x160(%rbp)
cmpq   $0xd,-0x160(%rbp)
0d
jae    16e6 <crypto_aead_encrypt+0x5b6>
mov    0x18(%rbp),%rax
mov    -0x160(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0xa0(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    16a5 <crypto_aead_encrypt+0x575>
movb   $0x80,-0x93(%rbp)
movq   $0xe,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    172c <crypto_aead_encrypt+0x5fc>
mov    -0x160(%rbp),%rax
movb   $0x0,-0xa0(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    16f8 <crypto_aead_encrypt+0x5c8>
lea    -0xa0(%rbp),%rdi
lea    -0x130(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
cmpq   $0x0,-0x20(%rbp)
jne    1823 <crypto_aead_encrypt+0x6f3>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    17ac <crypto_aead_encrypt+0x67c>
mov    -0x160(%rbp),%rax
movzbl -0xf0(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0x130(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1757 <crypto_aead_encrypt+0x627>
lea    -0x140(%rbp),%rdi
lea    -0x150(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    181e <crypto_aead_encrypt+0x6ee>
mov    -0x160(%rbp),%rax
movzbl -0x150(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0x60(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x160(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    17cc <crypto_aead_encrypt+0x69c>
jmp    1f0a <crypto_aead_encrypt+0xdda>
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
cmp    $0x0,%rax
je     1945 <crypto_aead_encrypt+0x815>
mov    -0xc8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc8(%rbp)
movq   $0x0,-0x160(%rbp)
mov    -0x160(%rbp),%rax
mov    -0x20(%rbp),%rcx
and    $0xf,%rcx
cmp    %rcx,%rax
jae    18ca <crypto_aead_encrypt+0x79a>
mov    -0x18(%rbp),%rax
mov    -0xc8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x160(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0xb0(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
movb   $0x0,-0xc0(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1861 <crypto_aead_encrypt+0x731>
mov    -0x20(%rbp),%rax
and    $0xf,%rax
movb   $0x0,-0xb0(%rbp,%rax,1)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
movb   $0x80,-0xc0(%rbp,%rax,1)
80
mov    -0x20(%rbp),%rax
and    $0xf,%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1940 <crypto_aead_encrypt+0x810>
mov    -0x160(%rbp),%rax
movb   $0x0,-0xb0(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
movb   $0x0,-0xc0(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    18fd <crypto_aead_encrypt+0x7cd>
jmp    19b4 <crypto_aead_encrypt+0x884>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    19af <crypto_aead_encrypt+0x87f>
mov    -0x18(%rbp),%rax
mov    -0xc8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x160(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0xb0(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
movb   $0x0,-0xc0(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1950 <crypto_aead_encrypt+0x820>
jmp    19b4 <crypto_aead_encrypt+0x884>
lea    -0x110(%rbp),%rdi
add    $0x20,%rdi
lea    -0x120(%rbp),%rsi
mov    $0x0,%al
call   1040 <Times2@plt>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1a2d <crypto_aead_encrypt+0x8fd>
mov    -0x160(%rbp),%rax
movzbl -0x120(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0x130(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    19d8 <crypto_aead_encrypt+0x8a8>
lea    -0x140(%rbp),%rdi
lea    -0x150(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x158(%rbp)
mov    -0x158(%rbp),%rax
mov    -0xc8(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    1b76 <crypto_aead_encrypt+0xa46>
lea    -0x120(%rbp),%rdi
lea    -0x80(%rbp),%rsi
mov    $0x0,%al
call   1040 <Times2@plt>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1b4a <crypto_aead_encrypt+0xa1a>
mov    -0x160(%rbp),%rax
mov    -0x80(%rbp,%rax,1),%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x120(%rbp,%rax,1)
mov    -0x18(%rbp),%rax
mov    -0x158(%rbp),%rcx
shl    $0x4,%rcx
add    -0x160(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x160(%rbp),%rcx
movzbl -0x120(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    -0x160(%rbp),%rcx
movzbl -0x130(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
movzbl -0x150(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0x140(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0x158(%rbp),%rcx
shl    $0x4,%rcx
add    -0x160(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1a85 <crypto_aead_encrypt+0x955>
lea    -0x140(%rbp),%rdi
lea    -0x150(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
mov    -0x158(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x158(%rbp)
jmp    1a4d <crypto_aead_encrypt+0x91d>
mov    -0x20(%rbp),%rax
and    $0xf,%rax
cmp    $0x0,%rax
je     1c79 <crypto_aead_encrypt+0xb49>
movq   $0x0,-0x160(%rbp)
mov    -0x160(%rbp),%rax
mov    -0x20(%rbp),%rcx
and    $0xf,%rcx
cmp    %rcx,%rax
jae    1c10 <crypto_aead_encrypt+0xae0>
mov    -0x160(%rbp),%rax
movzbl -0x150(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0xb0(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0xc8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x160(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x160(%rbp),%rax
movb   $0x0,-0xe0(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1b93 <crypto_aead_encrypt+0xa63>
mov    -0x20(%rbp),%rax
and    $0xf,%rax
mov    %rax,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1c74 <crypto_aead_encrypt+0xb44>
mov    -0x160(%rbp),%rax
movzbl -0x150(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0xc0(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0xe0(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1c1f <crypto_aead_encrypt+0xaef>
jmp    1ced <crypto_aead_encrypt+0xbbd>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1ce8 <crypto_aead_encrypt+0xbb8>
mov    -0x160(%rbp),%rax
movzbl -0x150(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0xb0(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0xc8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x160(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1c84 <crypto_aead_encrypt+0xb54>
jmp    1ced <crypto_aead_encrypt+0xbbd>
mov    -0x20(%rbp),%rax
and    $0xf,%rax
cmp    $0x0,%rax
je     1e12 <crypto_aead_encrypt+0xce2>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1d81 <crypto_aead_encrypt+0xc51>
mov    -0x160(%rbp),%rax
movzbl -0xb0(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0xe0(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    -0x160(%rbp),%rcx
movzbl -0x100(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    -0x160(%rbp),%rcx
movzbl -0x130(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1d0a <crypto_aead_encrypt+0xbda>
lea    -0x140(%rbp),%rdi
lea    -0x150(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1e0d <crypto_aead_encrypt+0xcdd>
mov    -0x160(%rbp),%rax
movzbl -0x150(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0x60(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0xc8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
mov    -0x20(%rbp),%rsi
and    $0xf,%rsi
add    %rsi,%rcx
add    -0x160(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1da1 <crypto_aead_encrypt+0xc71>
jmp    1f05 <crypto_aead_encrypt+0xdd5>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1e83 <crypto_aead_encrypt+0xd53>
mov    -0x160(%rbp),%rax
movzbl -0xb0(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0xf0(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    -0x160(%rbp),%rcx
movzbl -0x130(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x160(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1e1d <crypto_aead_encrypt+0xced>
lea    -0x140(%rbp),%rdi
lea    -0x150(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x160(%rbp)
cmpq   $0x10,-0x160(%rbp)
10
jae    1f00 <crypto_aead_encrypt+0xdd0>
mov    -0x160(%rbp),%rax
movzbl -0x150(%rbp,%rax,1),%eax
ff
mov    -0x160(%rbp),%rcx
movzbl -0x60(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
mov    -0xc8(%rbp),%rcx
shl    $0x4,%rcx
add    -0x160(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x160(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x160(%rbp)
jmp    1ea3 <crypto_aead_encrypt+0xd73>
jmp    1f05 <crypto_aead_encrypt+0xdd5>
jmp    1f0a <crypto_aead_encrypt+0xdda>
xor    %eax,%eax
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<crypto_aead_encrypt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
mov    %r9,%rbp
mov    %r8,0x128(%rsp)
mov    %rcx,%r12
mov    %rdx,0xe8(%rsp)
mov    %rsi,%r15
mov    %rdi,0x88(%rsp)
mov    0x1e8(%rsp),%r13
mov    0x1f0(%rsp),%rax
movups (%rax),%xmm0
movaps %xmm0,0x190(%rsp)
lea    0x190(%rsp),%rdi
mov    $0xa,%esi
xor    %eax,%eax
call   1070 <keyschedule@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
lea    0x20(%rsp),%rdi
lea    0x90(%rsp),%r14
mov    %r14,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
lea    0xa0(%rsp),%rbx
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <Times2@plt>
lea    0xb0(%rsp),%r14
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <Times2@plt>
lea    0x110(%rsp),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <Times2@plt>
test   %rbp,%rbp
mov    %r12,0x130(%rsp)
je     13d9 <crypto_aead_encrypt+0x289>
mov    %r15,0x188(%rsp)
xor    %ecx,%ecx
mov    %rbp,%rax
and    $0xf,%rax
mov    %rax,0x180(%rsp)
setne  %cl
shr    $0x4,%rbp
add    %rbp,%rcx
mov    %rcx,0x178(%rsp)
mov    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x170(%rsp)
je     13e6 <crypto_aead_encrypt+0x296>
mov    0x128(%rsp),%r12
movl   $0x0,0x3c(%rsp)
movl   $0x0,0x40(%rsp)
movl   $0x0,0x44(%rsp)
movl   $0x0,0x48(%rsp)
movl   $0x0,0x4c(%rsp)
movl   $0x0,0x50(%rsp)
movl   $0x0,0x54(%rsp)
movl   $0x0,0x58(%rsp)
movl   $0x0,0x5c(%rsp)
movl   $0x0,0x78(%rsp)
movl   $0x0,0x80(%rsp)
xor    %r13d,%r13d
xor    %r15d,%r15d
xor    %r14d,%r14d
xor    %ebx,%ebx
xor    %ebp,%ebp
nopl   (%rax)
mov    %rax,0x138(%rsp)
movups (%r12),%xmm0
xorps  0x110(%rsp),%xmm0
movaps %xmm0,0x20(%rsp)
lea    0x20(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
mov    0x3c(%rsp),%eax
xor    (%rsp),%al
mov    %eax,0x3c(%rsp)
mov    0x40(%rsp),%eax
xor    0x1(%rsp),%al
mov    %eax,0x40(%rsp)
mov    0x44(%rsp),%eax
xor    0x2(%rsp),%al
mov    %eax,0x44(%rsp)
mov    0x48(%rsp),%eax
xor    0x3(%rsp),%al
mov    %eax,0x48(%rsp)
mov    0x4c(%rsp),%eax
xor    0x4(%rsp),%al
mov    %eax,0x4c(%rsp)
mov    0x50(%rsp),%eax
xor    0x5(%rsp),%al
mov    %eax,0x50(%rsp)
mov    0x54(%rsp),%eax
xor    0x6(%rsp),%al
mov    %eax,0x54(%rsp)
mov    0x58(%rsp),%eax
xor    0x7(%rsp),%al
mov    %eax,0x58(%rsp)
mov    0x5c(%rsp),%eax
xor    0x8(%rsp),%al
mov    %eax,0x5c(%rsp)
mov    0x78(%rsp),%eax
xor    0x9(%rsp),%al
mov    %eax,0x78(%rsp)
mov    0x80(%rsp),%eax
xor    0xa(%rsp),%al
mov    %eax,0x80(%rsp)
xor    0xb(%rsp),%r13b
xor    0xc(%rsp),%r15b
xor    0xd(%rsp),%r14b
xor    0xe(%rsp),%bl
xor    0xf(%rsp),%bpl
lea    0x110(%rsp),%rdi
lea    0x150(%rsp),%rsi
xor    %eax,%eax
call   1060 <Times2@plt>
mov    0x138(%rsp),%rax
movaps 0x150(%rsp),%xmm0
movaps %xmm0,0x110(%rsp)
add    $0x10,%r12
add    $0xffffffffffffffff,%rax
jne    12d0 <crypto_aead_encrypt+0x180>
jmp    144e <crypto_aead_encrypt+0x2fe>
xorps  %xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
jmp    1782 <crypto_aead_encrypt+0x632>
movl   $0x0,0x3c(%rsp)
movl   $0x0,0x40(%rsp)
movl   $0x0,0x44(%rsp)
movl   $0x0,0x48(%rsp)
movl   $0x0,0x4c(%rsp)
movl   $0x0,0x50(%rsp)
movl   $0x0,0x54(%rsp)
movl   $0x0,0x58(%rsp)
movl   $0x0,0x5c(%rsp)
movl   $0x0,0x78(%rsp)
movl   $0x0,0x80(%rsp)
xor    %r13d,%r13d
xor    %r15d,%r15d
xor    %r14d,%r14d
xor    %ebx,%ebx
xor    %ebp,%ebp
mov    %r13d,0xcc(%rsp)
mov    %ebp,0x138(%rsp)
mov    0x180(%rsp),%rbp
test   %rbp,%rbp
je     15fc <crypto_aead_encrypt+0x4ac>
mov    0x178(%rsp),%rcx
shl    $0x4,%rcx
mov    0x128(%rsp),%rax
lea    (%rcx,%rax,1),%rsi
add    $0xfffffffffffffff0,%rsi
lea    0x60(%rsp),%rdi
mov    %rbp,%rdx
call   1040 <memcpy@plt>
movb   $0x80,0x60(%rsp,%rbp,1)
cmp    $0xf,%rbp
mov    0x130(%rsp),%r12
mov    0x1e8(%rsp),%r13
mov    %rbp,%rdx
mov    0xcc(%rsp),%ebp
je     14d4 <crypto_aead_encrypt+0x384>
lea    0x60(%rsp),%rax
lea    (%rdx,%rax,1),%rdi
add    $0x1,%rdi
xor    $0xf,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x3c(%rsp),%eax
xor    0x60(%rsp),%al
xor    0xa0(%rsp),%al
mov    %al,0x20(%rsp)
mov    0x40(%rsp),%ecx
xor    0x61(%rsp),%cl
xor    0xa1(%rsp),%cl
mov    0x44(%rsp),%eax
xor    0x62(%rsp),%al
xor    0xa2(%rsp),%al
mov    %cl,0x21(%rsp)
mov    %al,0x22(%rsp)
mov    0x48(%rsp),%ecx
xor    0x63(%rsp),%cl
xor    0xa3(%rsp),%cl
mov    0x4c(%rsp),%eax
xor    0x64(%rsp),%al
mov    %cl,0x23(%rsp)
xor    0xa4(%rsp),%al
mov    %al,0x24(%rsp)
mov    0x50(%rsp),%ecx
xor    0x65(%rsp),%cl
xor    0xa5(%rsp),%cl
mov    0x54(%rsp),%eax
xor    0x66(%rsp),%al
xor    0xa6(%rsp),%al
mov    %cl,0x25(%rsp)
mov    %al,0x26(%rsp)
mov    0x58(%rsp),%ecx
xor    0x67(%rsp),%cl
xor    0xa7(%rsp),%cl
mov    0x5c(%rsp),%eax
xor    0x68(%rsp),%al
mov    %cl,0x27(%rsp)
xor    0xa8(%rsp),%al
mov    %al,0x28(%rsp)
mov    0x78(%rsp),%ecx
xor    0x69(%rsp),%cl
xor    0xa9(%rsp),%cl
mov    0x80(%rsp),%eax
xor    0x6a(%rsp),%al
xor    0xaa(%rsp),%al
mov    %cl,0x29(%rsp)
mov    %al,0x2a(%rsp)
xor    0x6b(%rsp),%bpl
xor    0xab(%rsp),%bpl
xor    0x6c(%rsp),%r15b
mov    %bpl,0x2b(%rsp)
xor    0xac(%rsp),%r15b
mov    %r15b,0x2c(%rsp)
xor    0x6d(%rsp),%r14b
xor    0xad(%rsp),%r14b
xor    0x6e(%rsp),%bl
xor    0xae(%rsp),%bl
mov    %r14b,0x2d(%rsp)
mov    %bl,0x2e(%rsp)
mov    $0x1,%eax
lea    0x6f(%rsp),%rcx
jmp    1749 <crypto_aead_encrypt+0x5f9>
mov    0x170(%rsp),%rdx
shl    $0x4,%rdx
mov    0x128(%rsp),%rax
mov    0x3c(%rsp),%ecx
xor    (%rax,%rdx,1),%cl
xor    0xb0(%rsp),%cl
mov    %cl,0x20(%rsp)
mov    0x40(%rsp),%ecx
xor    0x1(%rax,%rdx,1),%cl
xor    0xb1(%rsp),%cl
mov    %cl,0x21(%rsp)
mov    0x44(%rsp),%ecx
xor    0x2(%rax,%rdx,1),%cl
xor    0xb2(%rsp),%cl
mov    %cl,0x22(%rsp)
mov    0x48(%rsp),%ecx
xor    0x3(%rax,%rdx,1),%cl
xor    0xb3(%rsp),%cl
mov    %cl,0x23(%rsp)
mov    0x4c(%rsp),%ecx
xor    0x4(%rax,%rdx,1),%cl
xor    0xb4(%rsp),%cl
mov    %cl,0x24(%rsp)
mov    0x50(%rsp),%ecx
xor    0x5(%rax,%rdx,1),%cl
xor    0xb5(%rsp),%cl
mov    %cl,0x25(%rsp)
mov    0x54(%rsp),%ecx
xor    0x6(%rax,%rdx,1),%cl
xor    0xb6(%rsp),%cl
mov    %cl,0x26(%rsp)
mov    0x58(%rsp),%ecx
xor    0x7(%rax,%rdx,1),%cl
xor    0xb7(%rsp),%cl
mov    %cl,0x27(%rsp)
mov    0x5c(%rsp),%ecx
xor    0x8(%rax,%rdx,1),%cl
xor    0xb8(%rsp),%cl
mov    %cl,0x28(%rsp)
mov    0x78(%rsp),%ecx
xor    0x9(%rax,%rdx,1),%cl
xor    0xb9(%rsp),%cl
mov    %cl,0x29(%rsp)
mov    0x80(%rsp),%ecx
xor    0xa(%rax,%rdx,1),%cl
xor    0xba(%rsp),%cl
mov    %cl,0x2a(%rsp)
mov    0xcc(%rsp),%ecx
xor    0xb(%rax,%rdx,1),%cl
xor    0xbb(%rsp),%cl
mov    %cl,0x2b(%rsp)
xor    0xc(%rax,%rdx,1),%r15b
xor    0xbc(%rsp),%r15b
mov    %r15b,0x2c(%rsp)
xor    0xd(%rax,%rdx,1),%r14b
xor    0xbd(%rsp),%r14b
mov    %r14b,0x2d(%rsp)
xor    0xe(%rax,%rdx,1),%bl
xor    0xbe(%rsp),%bl
mov    %bl,0x2e(%rsp)
lea    (%rax,%rdx,1),%rcx
add    $0xf,%rcx
mov    $0x2,%eax
mov    0x130(%rsp),%r12
mov    0x1e8(%rsp),%r13
mov    0x138(%rsp),%edx
xor    (%rcx),%dl
shl    $0x4,%rax
xor    0x9f(%rsp,%rax,1),%dl
mov    %dl,0x2f(%rsp)
lea    0x20(%rsp),%rdi
lea    0x10(%rsp),%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
lea    0xb0(%rsp),%r14
mov    0x188(%rsp),%r15
lea    0x10(%r12),%rax
mov    %rax,(%r15)
mov    0x0(%r13),%rax
mov    0x5(%r13),%rcx
mov    %rcx,0x165(%rsp)
mov    %rax,0x160(%rsp)
movb   $0x80,0x16d(%rsp)
80
movw   $0x0,0x16e(%rsp)
lea    0x160(%rsp),%rdi
lea    0x100(%rsp),%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
test   %r12,%r12
je     1876 <crypto_aead_encrypt+0x726>
mov    %r12,%r13
shr    $0x4,%r13
mov    %r12,%rbp
and    $0xf,%rbp
mov    %rbp,0x80(%rsp)
je     1958 <crypto_aead_encrypt+0x808>
add    $0x1,%r13
and    $0xfffffffffffffff0,%r12
lea    0xf0(%rsp),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
add    0xe8(%rsp),%r12
lea    0xd0(%rsp),%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
call   1040 <memcpy@plt>
movb   $0x0,0xd0(%rsp,%rbp,1)
movb   $0x80,0xf0(%rsp,%rbp,1)
80
cmp    $0xf,%rbp
je     1980 <crypto_aead_encrypt+0x830>
lea    0x1(%rbp),%r15
lea    (%rsp,%r15,1),%rdi
add    $0xd0,%rdi
xor    $0xf,%rbp
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
lea    (%rsp,%r15,1),%rdi
add    $0xf0,%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1030 <memset@plt>
jmp    1980 <crypto_aead_encrypt+0x830>
movaps 0x100(%rsp),%xmm0
xorps  0xb0(%rsp),%xmm0
movaps %xmm0,0x20(%rsp)
lea    0x20(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
mov    0x10(%rsp),%al
xor    (%rsp),%al
mov    0x88(%rsp),%rbx
mov    %al,(%rbx)
mov    0x11(%rsp),%al
xor    0x1(%rsp),%al
mov    %al,0x1(%rbx)
mov    0x12(%rsp),%al
xor    0x2(%rsp),%al
mov    %al,0x2(%rbx)
mov    0x13(%rsp),%al
xor    0x3(%rsp),%al
mov    %al,0x3(%rbx)
mov    0x14(%rsp),%al
xor    0x4(%rsp),%al
mov    %al,0x4(%rbx)
mov    0x15(%rsp),%al
xor    0x5(%rsp),%al
mov    %al,0x5(%rbx)
mov    0x16(%rsp),%al
xor    0x6(%rsp),%al
mov    %al,0x6(%rbx)
mov    0x17(%rsp),%al
xor    0x7(%rsp),%al
mov    %al,0x7(%rbx)
mov    0x18(%rsp),%al
xor    0x8(%rsp),%al
mov    %al,0x8(%rbx)
mov    0x19(%rsp),%al
xor    0x9(%rsp),%al
mov    %al,0x9(%rbx)
mov    0x1a(%rsp),%al
xor    0xa(%rsp),%al
mov    %al,0xa(%rbx)
mov    0x1b(%rsp),%al
xor    0xb(%rsp),%al
mov    %al,0xb(%rbx)
mov    0x1c(%rsp),%al
xor    0xc(%rsp),%al
mov    %al,0xc(%rbx)
mov    0x1d(%rsp),%al
xor    0xd(%rsp),%al
mov    %al,0xd(%rbx)
mov    0x1e(%rsp),%al
xor    0xe(%rsp),%al
mov    %al,0xe(%rbx)
mov    0x1f(%rsp),%al
xor    0xf(%rsp),%al
mov    $0xf,%r15d
jmp    1e6c <crypto_aead_encrypt+0xd1c>
lea    -0x10(%r12),%rax
and    $0xfffffffffffffff0,%rax
xorps  %xmm0,%xmm0
movaps %xmm0,0xf0(%rsp)
mov    0xe8(%rsp),%rcx
movups (%rcx,%rax,1),%xmm0
movaps %xmm0,0xd0(%rsp)
lea    0x110(%rsp),%rsi
mov    %r14,%rdi
xor    %eax,%eax
call   1060 <Times2@plt>
movaps 0x100(%rsp),%xmm0
xorps  0x110(%rsp),%xmm0
movaps %xmm0,0x20(%rsp)
lea    0x20(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
mov    %r13,0x78(%rsp)
mov    %r13,%r15
add    $0xffffffffffffffff,%r15
je     1aec <crypto_aead_encrypt+0x99c>
mov    0x88(%rsp),%rax
lea    0x1(%rax),%rbx
mov    0xe8(%rsp),%rax
lea    0x1(%rax),%r12
mov    %rsp,%r14
xor    %r13d,%r13d
jmp    1a35 <crypto_aead_encrypt+0x8e5>
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rbp,1),%xmm0
xorps  0x150(%rsp),%xmm0
xorps  0x100(%rsp),%xmm0
movaps %xmm0,0x20(%rsp)
xorps  (%rsp),%xmm0
movups %xmm0,(%rdx,%rbp,1)
lea    0x20(%rsp),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
add    $0x1,%r13
add    $0x10,%rbx
add    $0x10,%r12
cmp    %r15,%r13
je     1aec <crypto_aead_encrypt+0x99c>
mov    %r13,%rbp
shl    $0x4,%rbp
lea    0x110(%rsp),%rdi
lea    0x150(%rsp),%rsi
xor    %eax,%eax
call   1060 <Times2@plt>
movaps 0x150(%rsp),%xmm0
movaps %xmm0,0x110(%rsp)
mov    0xe8(%rsp),%rsi
lea    (%rsi,%rbp,1),%rax
add    $0x10,%rax
mov    0x88(%rsp),%rdx
lea    (%rdx,%rbp,1),%rcx
cmp    %rax,%rcx
jae    19f0 <crypto_aead_encrypt+0x8a0>
lea    (%rsi,%rbp,1),%rax
lea    (%rdx,%rbp,1),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jae    19f0 <crypto_aead_encrypt+0x8a0>
xor    %eax,%eax
nop
movzbl -0x1(%r12,%rax,1),%ecx
xor    0x150(%rsp,%rax,1),%cl
xor    0x100(%rsp,%rax,1),%cl
mov    %cl,0x20(%rsp,%rax,1)
xor    (%rsp,%rax,1),%cl
mov    %cl,-0x1(%rbx,%rax,1)
movzbl (%r12,%rax,1),%ecx
xor    0x151(%rsp,%rax,1),%cl
xor    0x101(%rsp,%rax,1),%cl
mov    %cl,0x21(%rsp,%rax,1)
xor    0x1(%rsp,%rax,1),%cl
mov    %cl,(%rbx,%rax,1)
add    $0x2,%rax
cmp    $0x10,%rax
jne    1aa0 <crypto_aead_encrypt+0x950>
jmp    1a11 <crypto_aead_encrypt+0x8c1>
shl    $0x4,%r15
mov    0x80(%rsp),%r14
test   %r14,%r14
je     1b2e <crypto_aead_encrypt+0x9de>
lea    0x140(%rsp),%rdi
xor    %ebx,%ebx
xor    %esi,%esi
mov    %r14,%rdx
call   1030 <memset@plt>
mov    0x130(%rsp),%rsi
mov    %esi,%ebp
and    $0x1,%ebp
cmp    $0x1,%r14
jne    1b4c <crypto_aead_encrypt+0x9fc>
mov    0x88(%rsp),%rdi
jmp    1b97 <crypto_aead_encrypt+0xa47>
movaps 0xd0(%rsp),%xmm0
xorps  (%rsp),%xmm0
mov    0x88(%rsp),%rbx
movups %xmm0,(%rbx,%r15,1)
jmp    1d6a <crypto_aead_encrypt+0xc1a>
mov    %r14,%rcx
sub    %rbp,%rcx
mov    0x88(%rsp),%rdi
lea    (%r15,%rdi,1),%rdx
add    $0x1,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0xd0(%rsp,%rbx,1),%eax
xor    (%rsp,%rbx,1),%al
mov    %al,-0x1(%rdx,%rbx,1)
movzbl 0xd1(%rsp,%rbx,1),%eax
xor    0x1(%rsp,%rbx,1),%al
mov    %al,(%rdx,%rbx,1)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    1b70 <crypto_aead_encrypt+0xa20>
test   %rbp,%rbp
je     1bac <crypto_aead_encrypt+0xa5c>
mov    0xd0(%rsp,%rbx,1),%al
xor    (%rsp,%rbx,1),%al
add    %r15,%rbx
mov    %al,(%rdi,%rbx,1)
neg    %esi
mov    %r14,%rcx
xor    $0xf,%rcx
mov    %r14,%rax
and    $0x3,%rsi
je     1bec <crypto_aead_encrypt+0xa9c>
mov    %r14,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0xf0(%rsp,%rax,1),%edx
xor    (%rsp,%rax,1),%dl
mov    %dl,0x140(%rsp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1bd0 <crypto_aead_encrypt+0xa80>
cmp    $0x3,%rcx
jb     1c55 <crypto_aead_encrypt+0xb05>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0xf0(%rsp,%rax,1),%ecx
movzbl 0xf1(%rsp,%rax,1),%edx
xor    (%rsp,%rax,1),%cl
xor    0x1(%rsp,%rax,1),%dl
mov    %cl,0x140(%rsp,%rax,1)
movzbl 0xf2(%rsp,%rax,1),%ecx
xor    0x2(%rsp,%rax,1),%cl
mov    %dl,0x141(%rsp,%rax,1)
movzbl 0xf3(%rsp,%rax,1),%edx
xor    0x3(%rsp,%rax,1),%dl
mov    %cl,0x142(%rsp,%rax,1)
mov    %dl,0x143(%rsp,%rax,1)
add    $0x4,%rax
cmp    $0x10,%rax
jne    1c00 <crypto_aead_encrypt+0xab0>
test   %r14,%r14
mov    %rdi,%rbx
je     1d6a <crypto_aead_encrypt+0xc1a>
movaps 0x140(%rsp),%xmm0
xorps  0xd0(%rsp),%xmm0
xorps  0xa0(%rsp),%xmm0
xorps  0x100(%rsp),%xmm0
movaps %xmm0,0x20(%rsp)
lea    0x20(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
or     %r14,%r15
mov    0x10(%rsp),%al
xor    (%rsp),%al
mov    %al,(%rbx,%r15,1)
mov    0x11(%rsp),%al
xor    0x1(%rsp),%al
mov    %al,0x1(%rbx,%r15,1)
mov    0x12(%rsp),%al
xor    0x2(%rsp),%al
mov    %al,0x2(%rbx,%r15,1)
mov    0x13(%rsp),%al
xor    0x3(%rsp),%al
mov    %al,0x3(%rbx,%r15,1)
mov    0x14(%rsp),%al
xor    0x4(%rsp),%al
mov    %al,0x4(%rbx,%r15,1)
mov    0x15(%rsp),%al
xor    0x5(%rsp),%al
mov    %al,0x5(%rbx,%r15,1)
mov    0x16(%rsp),%al
xor    0x6(%rsp),%al
mov    %al,0x6(%rbx,%r15,1)
mov    0x17(%rsp),%al
xor    0x7(%rsp),%al
mov    %al,0x7(%rbx,%r15,1)
mov    0x18(%rsp),%al
xor    0x8(%rsp),%al
mov    %al,0x8(%rbx,%r15,1)
mov    0x19(%rsp),%al
xor    0x9(%rsp),%al
mov    %al,0x9(%rbx,%r15,1)
mov    0x1a(%rsp),%al
xor    0xa(%rsp),%al
mov    %al,0xa(%rbx,%r15,1)
mov    0x1b(%rsp),%al
xor    0xb(%rsp),%al
mov    %al,0xb(%rbx,%r15,1)
mov    0x1c(%rsp),%al
xor    0xc(%rsp),%al
mov    %al,0xc(%rbx,%r15,1)
mov    0x1d(%rsp),%al
xor    0xd(%rsp),%al
mov    %al,0xd(%rbx,%r15,1)
mov    0x1e(%rsp),%al
xor    0xe(%rsp),%al
mov    %al,0xe(%rbx,%r15,1)
mov    0x1f(%rsp),%al
xor    0xf(%rsp),%al
add    $0xf,%r15
jmp    1e6c <crypto_aead_encrypt+0xd1c>
movaps 0xb0(%rsp),%xmm0
xorps  0xd0(%rsp),%xmm0
xorps  0x100(%rsp),%xmm0
movaps %xmm0,0x20(%rsp)
lea    0x20(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
mov    0x78(%rsp),%r15
shl    $0x4,%r15
mov    0x10(%rsp),%al
xor    (%rsp),%al
mov    %al,(%rbx,%r15,1)
mov    0x11(%rsp),%al
xor    0x1(%rsp),%al
mov    %al,0x1(%rbx,%r15,1)
mov    0x12(%rsp),%al
xor    0x2(%rsp),%al
mov    %al,0x2(%rbx,%r15,1)
mov    0x13(%rsp),%al
xor    0x3(%rsp),%al
mov    %al,0x3(%rbx,%r15,1)
mov    0x14(%rsp),%al
xor    0x4(%rsp),%al
mov    %al,0x4(%rbx,%r15,1)
mov    0x15(%rsp),%al
xor    0x5(%rsp),%al
mov    %al,0x5(%rbx,%r15,1)
mov    0x16(%rsp),%al
xor    0x6(%rsp),%al
mov    %al,0x6(%rbx,%r15,1)
mov    0x17(%rsp),%al
xor    0x7(%rsp),%al
mov    %al,0x7(%rbx,%r15,1)
mov    0x18(%rsp),%al
xor    0x8(%rsp),%al
mov    %al,0x8(%rbx,%r15,1)
mov    0x19(%rsp),%al
xor    0x9(%rsp),%al
mov    %al,0x9(%rbx,%r15,1)
mov    0x1a(%rsp),%al
xor    0xa(%rsp),%al
mov    %al,0xa(%rbx,%r15,1)
mov    0x1b(%rsp),%al
xor    0xb(%rsp),%al
mov    %al,0xb(%rbx,%r15,1)
mov    0x1c(%rsp),%al
xor    0xc(%rsp),%al
mov    %al,0xc(%rbx,%r15,1)
mov    0x1d(%rsp),%al
xor    0xd(%rsp),%al
mov    %al,0xd(%rbx,%r15,1)
mov    0x1e(%rsp),%al
xor    0xe(%rsp),%al
mov    %al,0xe(%rbx,%r15,1)
mov    0x1f(%rsp),%al
xor    0xf(%rsp),%al
or     $0xf,%r15
mov    %al,(%rbx,%r15,1)
xor    %eax,%eax
add    $0x1a8,%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 [16 x i8]
%20 = alloca [16 x i8]
%21 = alloca [16 x i8]
%22 = alloca [16 x i8]
%23 = alloca [16 x i8]
%24 = alloca i64
%25 = alloca [16 x i8]
%26 = alloca [16 x i8]
%27 = alloca [16 x i8]
%28 = alloca i64
%29 = alloca [16 x i8]
%30 = alloca [3 x [16 x i8]]
%31 = alloca [16 x i8]
%32 = alloca [16 x i8]
%33 = alloca [16 x i8]
%34 = alloca [16 x i8]
%35 = alloca i64
%36 = alloca i64
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 i64 0, i64* %36
br label %37
37: ; preds = %47, %9
%38 = load i64, i64* %36
%39 = icmp ult i64 %38, 16
br i1 %39, label %40, label %50
40: ; preds = %37
%41 = load i8*, i8** %18
%42 = load i64, i64* %36
%43 = getelementptr inbounds i8, i8* %41, i64 %42
%44 = load i8, i8* %43
%45 = load i64, i64* %36
%46 = getelementptr inbounds [16 x i8], [16 x i8]* %22, i64 0, i64 %45
store i8 %44, i8* %46
br label %47
47: ; preds = %40
%48 = load i64, i64* %36
%49 = add i64 %48, 1
store i64 %49, i64* %36
br label %37
50: ; preds = %37
%51 = getelementptr inbounds [16 x i8], [16 x i8]* %22, i64 0, i64 0
%52 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @keyschedule to i32 (i8*, i32, ...)*)(i8* %51, i32 10)
store i64 0, i64* %36
br label %53
53: ; preds = %59, %50
%54 = load i64, i64* %36
%55 = icmp ult i64 %54, 16
br i1 %55, label %56, label %62
56: ; preds = %53
%57 = load i64, i64* %36
%58 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 %57
store i8 0, i8* %58
br label %59
59: ; preds = %56
%60 = load i64, i64* %36
%61 = add i64 %60, 1
store i64 %61, i64* %36
br label %53
62: ; preds = %53
%63 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%64 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %30, i64 0, i64 0
%65 = getelementptr inbounds [16 x i8], [16 x i8]* %64, i64 0, i64 0
%66 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %63, i8* %65)
store i64 0, i64* %35
br label %67
67: ; preds = %79, %62
%68 = load i64, i64* %35
%69 = icmp ult i64 %68, 2
br i1 %69, label %70, label %82
70: ; preds = %67
%71 = load i64, i64* %35
%72 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %30, i64 0, i64 %71
%73 = getelementptr inbounds [16 x i8], [16 x i8]* %72, i64 0, i64 0
%74 = load i64, i64* %35
%75 = add i64 %74, 1
%76 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %30, i64 0, i64 %75
%77 = getelementptr inbounds [16 x i8], [16 x i8]* %76, i64 0, i64 0
%78 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %73, i8* %77)
br label %79
79: ; preds = %70
%80 = load i64, i64* %35
%81 = add i64 %80, 1
store i64 %81, i64* %35
br label %67
82: ; preds = %67
%83 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %30, i64 0, i64 2
%84 = getelementptr inbounds [16 x i8], [16 x i8]* %83, i64 0, i64 0
%85 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 0
%86 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %84, i8* %85)
%87 = load i64, i64* %15
%88 = icmp eq i64 %87, 0
br i1 %88, label %89, label %100
89: ; preds = %82
store i64 0, i64* %36
br label %90
90: ; preds = %96, %89
%91 = load i64, i64* %36
%92 = icmp ult i64 %91, 16
br i1 %92, label %93, label %99
93: ; preds = %90
%94 = load i64, i64* %36
%95 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %94
store i8 0, i8* %95
br label %96
96: ; preds = %93
%97 = load i64, i64* %36
%98 = add i64 %97, 1
store i64 %98, i64* %36
br label %90
99: ; preds = %90
br label %297
100: ; preds = %82
%101 = load i64, i64* %15
%102 = urem i64 %101, 16
%103 = icmp eq i64 %102, 0
br i1 %103, label %104, label %107
104: ; preds = %100
%105 = load i64, i64* %15
%106 = udiv i64 %105, 16
store i64 %106, i64* %24
br label %111
107: ; preds = %100
%108 = load i64, i64* %15
%109 = udiv i64 %108, 16
%110 = add i64 %109, 1
store i64 %110, i64* %24
br label %111
111: ; preds = %107, %104
store i64 0, i64* %36
br label %112
112: ; preds = %118, %111
%113 = load i64, i64* %36
%114 = icmp ult i64 %113, 16
br i1 %114, label %115, label %121
115: ; preds = %112
%116 = load i64, i64* %36
%117 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %116
store i8 0, i8* %117
br label %118
118: ; preds = %115
%119 = load i64, i64* %36
%120 = add i64 %119, 1
store i64 %120, i64* %36
br label %112
121: ; preds = %112
store i64 0, i64* %35
br label %122
122: ; preds = %191, %121
%123 = load i64, i64* %35
%124 = load i64, i64* %24
%125 = sub i64 %124, 1
%126 = icmp ult i64 %123, %125
br i1 %126, label %127, label %194
127: ; preds = %122
store i64 0, i64* %36
br label %128
128: ; preds = %148, %127
%129 = load i64, i64* %36
%130 = icmp ult i64 %129, 16
br i1 %130, label %131, label %151
131: ; preds = %128
%132 = load i8*, i8** %14
%133 = load i64, i64* %35
%134 = mul i64 %133, 16
%135 = load i64, i64* %36
%136 = add i64 %134, %135
%137 = getelementptr inbounds i8, i8* %132, i64 %136
%138 = load i8, i8* %137
%139 = zext i8 %138 to i32
%140 = load i64, i64* %36
%141 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 %140
%142 = load i8, i8* %141
%143 = zext i8 %142 to i32
%144 = xor i32 %139, %143
%145 = trunc i32 %144 to i8
%146 = load i64, i64* %36
%147 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 %146
store i8 %145, i8* %147
br label %148
148: ; preds = %131
%149 = load i64, i64* %36
%150 = add i64 %149, 1
store i64 %150, i64* %36
br label %128
151: ; preds = %128
%152 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%153 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 0
%154 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %152, i8* %153)
store i64 0, i64* %36
br label %155
155: ; preds = %171, %151
%156 = load i64, i64* %36
%157 = icmp ult i64 %156, 16
br i1 %157, label %158, label %174
158: ; preds = %155
%159 = load i64, i64* %36
%160 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %159
%161 = load i8, i8* %160
%162 = zext i8 %161 to i32
%163 = load i64, i64* %36
%164 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 %163
%165 = load i8, i8* %164
%166 = zext i8 %165 to i32
%167 = xor i32 %162, %166
%168 = trunc i32 %167 to i8
%169 = load i64, i64* %36
%170 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %169
store i8 %168, i8* %170
br label %171
171: ; preds = %158
%172 = load i64, i64* %36
%173 = add i64 %172, 1
store i64 %173, i64* %36
br label %155
174: ; preds = %155
%175 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 0
%176 = getelementptr inbounds [16 x i8], [16 x i8]* %23, i64 0, i64 0
%177 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %175, i8* %176)
store i64 0, i64* %36
br label %178
178: ; preds = %187, %174
%179 = load i64, i64* %36
%180 = icmp ult i64 %179, 16
br i1 %180, label %181, label %190
181: ; preds = %178
%182 = load i64, i64* %36
%183 = getelementptr inbounds [16 x i8], [16 x i8]* %23, i64 0, i64 %182
%184 = load i8, i8* %183
%185 = load i64, i64* %36
%186 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 %185
store i8 %184, i8* %186
br label %187
187: ; preds = %181
%188 = load i64, i64* %36
%189 = add i64 %188, 1
store i64 %189, i64* %36
br label %178
190: ; preds = %178
br label %191
191: ; preds = %190
%192 = load i64, i64* %35
%193 = add i64 %192, 1
store i64 %193, i64* %35
br label %122
194: ; preds = %122
%195 = load i64, i64* %15
%196 = urem i64 %195, 16
%197 = icmp ne i64 %196, 0
br i1 %197, label %198, label %261
198: ; preds = %194
store i64 0, i64* %36
br label %199
199: ; preds = %215, %198
%200 = load i64, i64* %36
%201 = load i64, i64* %15
%202 = urem i64 %201, 16
%203 = icmp ult i64 %200, %202
br i1 %203, label %204, label %218
204: ; preds = %199
%205 = load i8*, i8** %14
%206 = load i64, i64* %24
%207 = sub i64 %206, 1
%208 = mul i64 %207, 16
%209 = load i64, i64* %36
%210 = add i64 %208, %209
%211 = getelementptr inbounds i8, i8* %205, i64 %210
%212 = load i8, i8* %211
%213 = load i64, i64* %36
%214 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %213
store i8 %212, i8* %214
br label %215
215: ; preds = %204
%216 = load i64, i64* %36
%217 = add i64 %216, 1
store i64 %217, i64* %36
br label %199
218: ; preds = %199
%219 = load i64, i64* %15
%220 = urem i64 %219, 16
%221 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %220
store i8 -128, i8* %221
%222 = load i64, i64* %15
%223 = urem i64 %222, 16
%224 = add i64 %223, 1
store i64 %224, i64* %36
br label %225
225: ; preds = %231, %218
%226 = load i64, i64* %36
%227 = icmp ult i64 %226, 16
br i1 %227, label %228, label %234
228: ; preds = %225
%229 = load i64, i64* %36
%230 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %229
store i8 0, i8* %230
br label %231
231: ; preds = %228
%232 = load i64, i64* %36
%233 = add i64 %232, 1
store i64 %233, i64* %36
br label %225
234: ; preds = %225
store i64 0, i64* %36
br label %235
235: ; preds = %257, %234
%236 = load i64, i64* %36
%237 = icmp ult i64 %236, 16
br i1 %237, label %238, label %260
238: ; preds = %235
%239 = load i64, i64* %36
%240 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %239
%241 = load i8, i8* %240
%242 = zext i8 %241 to i32
%243 = load i64, i64* %36
%244 = getelementptr inbounds [16 x i8], [16 x i8]* %20, i64 0, i64 %243
%245 = load i8, i8* %244
%246 = zext i8 %245 to i32
%247 = xor i32 %242, %246
%248 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %30, i64 0, i64 1
%249 = load i64, i64* %36
%250 = getelementptr inbounds [16 x i8], [16 x i8]* %248, i64 0, i64 %249
%251 = load i8, i8* %250
%252 = zext i8 %251 to i32
%253 = xor i32 %247, %252
%254 = trunc i32 %253 to i8
%255 = load i64, i64* %36
%256 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 %255
store i8 %254, i8* %256
br label %257
257: ; preds = %238
%258 = load i64, i64* %36
%259 = add i64 %258, 1
store i64 %259, i64* %36
br label %235
260: ; preds = %235
br label %293
261: ; preds = %194
store i64 0, i64* %36
br label %262
262: ; preds = %289, %261
%263 = load i64, i64* %36
%264 = icmp ult i64 %263, 16
br i1 %264, label %265, label %292
265: ; preds = %262
%266 = load i64, i64* %36
%267 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %266
%268 = load i8, i8* %267
%269 = zext i8 %268 to i32
%270 = load i8*, i8** %14
%271 = load i64, i64* %24
%272 = sub i64 %271, 1
%273 = mul i64 %272, 16
%274 = load i64, i64* %36
%275 = add i64 %273, %274
%276 = getelementptr inbounds i8, i8* %270, i64 %275
%277 = load i8, i8* %276
%278 = zext i8 %277 to i32
%279 = xor i32 %269, %278
%280 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %30, i64 0, i64 2
%281 = load i64, i64* %36
%282 = getelementptr inbounds [16 x i8], [16 x i8]* %280, i64 0, i64 %281
%283 = load i8, i8* %282
%284 = zext i8 %283 to i32
%285 = xor i32 %279, %284
%286 = trunc i32 %285 to i8
%287 = load i64, i64* %36
%288 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 %287
store i8 %286, i8* %288
br label %289
289: ; preds = %265
%290 = load i64, i64* %36
%291 = add i64 %290, 1
store i64 %291, i64* %36
br label %262
292: ; preds = %262
br label %293
293: ; preds = %292, %260
%294 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%295 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 0
%296 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %294, i8* %295)
br label %297
297: ; preds = %293, %99
%298 = load i64, i64* %13
%299 = add i64 %298, 16
%300 = load i64*, i64** %11
store i64 %299, i64* %300
store i64 0, i64* %36
br label %301
301: ; preds = %311, %297
%302 = load i64, i64* %36
%303 = icmp ult i64 %302, 13
br i1 %303, label %304, label %314
304: ; preds = %301
%305 = load i8*, i8** %17
%306 = load i64, i64* %36
%307 = getelementptr inbounds i8, i8* %305, i64 %306
%308 = load i8, i8* %307
%309 = load i64, i64* %36
%310 = getelementptr inbounds [16 x i8], [16 x i8]* %25, i64 0, i64 %309
store i8 %308, i8* %310
br label %311
311: ; preds = %304
%312 = load i64, i64* %36
%313 = add i64 %312, 1
store i64 %313, i64* %36
br label %301
314: ; preds = %301
%315 = getelementptr inbounds [16 x i8], [16 x i8]* %25, i64 0, i64 13
store i8 -128, i8* %315
store i64 14, i64* %36
br label %316
316: ; preds = %322, %314
%317 = load i64, i64* %36
%318 = icmp ult i64 %317, 16
br i1 %318, label %319, label %325
319: ; preds = %316
%320 = load i64, i64* %36
%321 = getelementptr inbounds [16 x i8], [16 x i8]* %25, i64 0, i64 %320
store i8 0, i8* %321
br label %322
322: ; preds = %319
%323 = load i64, i64* %36
%324 = add i64 %323, 1
store i64 %324, i64* %36
br label %316
325: ; preds = %316
%326 = getelementptr inbounds [16 x i8], [16 x i8]* %25, i64 0, i64 0
%327 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 0
%328 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %326, i8* %327)
%329 = load i64, i64* %13
%330 = icmp eq i64 %329, 0
br i1 %330, label %331, label %377
331: ; preds = %325
store i64 0, i64* %36
br label %332
332: ; preds = %349, %331
%333 = load i64, i64* %36
%334 = icmp ult i64 %333, 16
br i1 %334, label %335, label %352
335: ; preds = %332
%336 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %30, i64 0, i64 2
%337 = load i64, i64* %36
%338 = getelementptr inbounds [16 x i8], [16 x i8]* %336, i64 0, i64 %337
%339 = load i8, i8* %338
%340 = zext i8 %339 to i32
%341 = load i64, i64* %36
%342 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 %341
%343 = load i8, i8* %342
%344 = zext i8 %343 to i32
%345 = xor i32 %340, %344
%346 = trunc i32 %345 to i8
%347 = load i64, i64* %36
%348 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 %347
store i8 %346, i8* %348
br label %349
349: ; preds = %335
%350 = load i64, i64* %36
%351 = add i64 %350, 1
store i64 %351, i64* %36
br label %332
352: ; preds = %332
%353 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%354 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 0
%355 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %353, i8* %354)
store i64 0, i64* %36
br label %356
356: ; preds = %373, %352
%357 = load i64, i64* %36
%358 = icmp ult i64 %357, 16
br i1 %358, label %359, label %376
359: ; preds = %356
%360 = load i64, i64* %36
%361 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 %360
%362 = load i8, i8* %361
%363 = zext i8 %362 to i32
%364 = load i64, i64* %36
%365 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %364
%366 = load i8, i8* %365
%367 = zext i8 %366 to i32
%368 = xor i32 %363, %367
%369 = trunc i32 %368 to i8
%370 = load i8*, i8** %10
%371 = load i64, i64* %36
%372 = getelementptr inbounds i8, i8* %370, i64 %371
store i8 %369, i8* %372
br label %373
373: ; preds = %359
%374 = load i64, i64* %36
%375 = add i64 %374, 1
store i64 %375, i64* %36
br label %356
376: ; preds = %356
br label %747
377: ; preds = %325
%378 = load i64, i64* %13
%379 = udiv i64 %378, 16
store i64 %379, i64* %28
%380 = load i64, i64* %13
%381 = urem i64 %380, 16
%382 = icmp ne i64 %381, 0
br i1 %382, label %383, label %429
383: ; preds = %377
%384 = load i64, i64* %28
%385 = add i64 %384, 1
store i64 %385, i64* %28
store i64 0, i64* %36
br label %386
386: ; preds = %404, %383
%387 = load i64, i64* %36
%388 = load i64, i64* %13
%389 = urem i64 %388, 16
%390 = icmp ult i64 %387, %389
br i1 %390, label %391, label %407
391: ; preds = %386
%392 = load i8*, i8** %12
%393 = load i64, i64* %28
%394 = sub i64 %393, 1
%395 = mul i64 %394, 16
%396 = load i64, i64* %36
%397 = add i64 %395, %396
%398 = getelementptr inbounds i8, i8* %392, i64 %397
%399 = load i8, i8* %398
%400 = load i64, i64* %36
%401 = getelementptr inbounds [16 x i8], [16 x i8]* %26, i64 0, i64 %400
store i8 %399, i8* %401
%402 = load i64, i64* %36
%403 = getelementptr inbounds [16 x i8], [16 x i8]* %27, i64 0, i64 %402
store i8 0, i8* %403
br label %404
404: ; preds = %391
%405 = load i64, i64* %36
%406 = add i64 %405, 1
store i64 %406, i64* %36
br label %386
407: ; preds = %386
%408 = load i64, i64* %13
%409 = urem i64 %408, 16
%410 = getelementptr inbounds [16 x i8], [16 x i8]* %26, i64 0, i64 %409
store i8 0, i8* %410
%411 = load i64, i64* %13
%412 = urem i64 %411, 16
%413 = getelementptr inbounds [16 x i8], [16 x i8]* %27, i64 0, i64 %412
store i8 -128, i8* %413
%414 = load i64, i64* %13
%415 = urem i64 %414, 16
%416 = add i64 %415, 1
store i64 %416, i64* %36
br label %417
417: ; preds = %425, %407
%418 = load i64, i64* %36
%419 = icmp ult i64 %418, 16
br i1 %419, label %420, label %428
420: ; preds = %417
%421 = load i64, i64* %36
%422 = getelementptr inbounds [16 x i8], [16 x i8]* %26, i64 0, i64 %421
store i8 0, i8* %422
%423 = load i64, i64* %36
%424 = getelementptr inbounds [16 x i8], [16 x i8]* %27, i64 0, i64 %423
store i8 0, i8* %424
br label %425
425: ; preds = %420
%426 = load i64, i64* %36
%427 = add i64 %426, 1
store i64 %427, i64* %36
br label %417
428: ; preds = %417
br label %450
429: ; preds = %377
store i64 0, i64* %36
br label %430
430: ; preds = %446, %429
%431 = load i64, i64* %36
%432 = icmp ult i64 %431, 16
br i1 %432, label %433, label %449
433: ; preds = %430
%434 = load i8*, i8** %12
%435 = load i64, i64* %28
%436 = sub i64 %435, 1
%437 = mul i64 %436, 16
%438 = load i64, i64* %36
%439 = add i64 %437, %438
%440 = getelementptr inbounds i8, i8* %434, i64 %439
%441 = load i8, i8* %440
%442 = load i64, i64* %36
%443 = getelementptr inbounds [16 x i8], [16 x i8]* %26, i64 0, i64 %442
store i8 %441, i8* %443
%444 = load i64, i64* %36
%445 = getelementptr inbounds [16 x i8], [16 x i8]* %27, i64 0, i64 %444
store i8 0, i8* %445
br label %446
446: ; preds = %433
%447 = load i64, i64* %36
%448 = add i64 %447, 1
store i64 %448, i64* %36
br label %430
449: ; preds = %430
br label %450
450: ; preds = %449, %428
%451 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %30, i64 0, i64 2
%452 = getelementptr inbounds [16 x i8], [16 x i8]* %451, i64 0, i64 0
%453 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 0
%454 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %452, i8* %453)
store i64 0, i64* %36
br label %455
455: ; preds = %471, %450
%456 = load i64, i64* %36
%457 = icmp ult i64 %456, 16
br i1 %457, label %458, label %474
458: ; preds = %455
%459 = load i64, i64* %36
%460 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 %459
%461 = load i8, i8* %460
%462 = zext i8 %461 to i32
%463 = load i64, i64* %36
%464 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 %463
%465 = load i8, i8* %464
%466 = zext i8 %465 to i32
%467 = xor i32 %462, %466
%468 = trunc i32 %467 to i8
%469 = load i64, i64* %36
%470 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 %469
store i8 %468, i8* %470
br label %471
471: ; preds = %458
%472 = load i64, i64* %36
%473 = add i64 %472, 1
store i64 %473, i64* %36
br label %455
474: ; preds = %455
%475 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%476 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 0
%477 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %475, i8* %476)
store i64 0, i64* %35
br label %478
478: ; preds = %540, %474
%479 = load i64, i64* %35
%480 = load i64, i64* %28
%481 = sub i64 %480, 1
%482 = icmp ult i64 %479, %481
br i1 %482, label %483, label %543
483: ; preds = %478
%484 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 0
%485 = getelementptr inbounds [16 x i8], [16 x i8]* %23, i64 0, i64 0
%486 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %484, i8* %485)
store i64 0, i64* %36
br label %487
487: ; preds = %533, %483
%488 = load i64, i64* %36
%489 = icmp ult i64 %488, 16
br i1 %489, label %490, label %536
490: ; preds = %487
%491 = load i64, i64* %36
%492 = getelementptr inbounds [16 x i8], [16 x i8]* %23, i64 0, i64 %491
%493 = load i8, i8* %492
%494 = load i64, i64* %36
%495 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 %494
store i8 %493, i8* %495
%496 = load i8*, i8** %12
%497 = load i64, i64* %35
%498 = mul i64 %497, 16
%499 = load i64, i64* %36
%500 = add i64 %498, %499
%501 = getelementptr inbounds i8, i8* %496, i64 %500
%502 = load i8, i8* %501
%503 = zext i8 %502 to i32
%504 = load i64, i64* %36
%505 = getelementptr inbounds [16 x i8], [16 x i8]* %31, i64 0, i64 %504
%506 = load i8, i8* %505
%507 = zext i8 %506 to i32
%508 = xor i32 %503, %507
%509 = load i64, i64* %36
%510 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 %509
%511 = load i8, i8* %510
%512 = zext i8 %511 to i32
%513 = xor i32 %508, %512
%514 = trunc i32 %513 to i8
%515 = load i64, i64* %36
%516 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 %515
store i8 %514, i8* %516
%517 = load i64, i64* %36
%518 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 %517
%519 = load i8, i8* %518
%520 = zext i8 %519 to i32
%521 = load i64, i64* %36
%522 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 %521
%523 = load i8, i8* %522
%524 = zext i8 %523 to i32
%525 = xor i32 %520, %524
%526 = trunc i32 %525 to i8
%527 = load i8*, i8** %10
%528 = load i64, i64* %35
%529 = mul i64 %528, 16
%530 = load i64, i64* %36
%531 = add i64 %529, %530
%532 = getelementptr inbounds i8, i8* %527, i64 %531
store i8 %526, i8* %532
br label %533
533: ; preds = %490
%534 = load i64, i64* %36
%535 = add i64 %534, 1
store i64 %535, i64* %36
br label %487
536: ; preds = %487
%537 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%538 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 0
%539 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %537, i8* %538)
br label %540
540: ; preds = %536
%541 = load i64, i64* %35
%542 = add i64 %541, 1
store i64 %542, i64* %35
br label %478
543: ; preds = %478
%544 = load i64, i64* %13
%545 = urem i64 %544, 16
%546 = icmp ne i64 %545, 0
br i1 %546, label %547, label %599
547: ; preds = %543
store i64 0, i64* %36
br label %548
548: ; preds = %573, %547
%549 = load i64, i64* %36
%550 = load i64, i64* %13
%551 = urem i64 %550, 16
%552 = icmp ult i64 %549, %551
br i1 %552, label %553, label %576
553: ; preds = %548
%554 = load i64, i64* %36
%555 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 %554
%556 = load i8, i8* %555
%557 = zext i8 %556 to i32
%558 = load i64, i64* %36
%559 = getelementptr inbounds [16 x i8], [16 x i8]* %26, i64 0, i64 %558
%560 = load i8, i8* %559
%561 = zext i8 %560 to i32
%562 = xor i32 %557, %561
%563 = trunc i32 %562 to i8
%564 = load i8*, i8** %10
%565 = load i64, i64* %28
%566 = sub i64 %565, 1
%567 = mul i64 %566, 16
%568 = load i64, i64* %36
%569 = add i64 %567, %568
%570 = getelementptr inbounds i8, i8* %564, i64 %569
store i8 %563, i8* %570
%571 = load i64, i64* %36
%572 = getelementptr inbounds [16 x i8], [16 x i8]* %29, i64 0, i64 %571
store i8 0, i8* %572
br label %573
573: ; preds = %553
%574 = load i64, i64* %36
%575 = add i64 %574, 1
store i64 %575, i64* %36
br label %548
576: ; preds = %548
%577 = load i64, i64* %13
%578 = urem i64 %577, 16
store i64 %578, i64* %36
br label %579
579: ; preds = %595, %576
%580 = load i64, i64* %36
%581 = icmp ult i64 %580, 16
br i1 %581, label %582, label %598
582: ; preds = %579
%583 = load i64, i64* %36
%584 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 %583
%585 = load i8, i8* %584
%586 = zext i8 %585 to i32
%587 = load i64, i64* %36
%588 = getelementptr inbounds [16 x i8], [16 x i8]* %27, i64 0, i64 %587
%589 = load i8, i8* %588
%590 = zext i8 %589 to i32
%591 = xor i32 %586, %590
%592 = trunc i32 %591 to i8
%593 = load i64, i64* %36
%594 = getelementptr inbounds [16 x i8], [16 x i8]* %29, i64 0, i64 %593
store i8 %592, i8* %594
br label %595
595: ; preds = %582
%596 = load i64, i64* %36
%597 = add i64 %596, 1
store i64 %597, i64* %36
br label %579
598: ; preds = %579
br label %625
599: ; preds = %543
store i64 0, i64* %36
br label %600
600: ; preds = %621, %599
%601 = load i64, i64* %36
%602 = icmp ult i64 %601, 16
br i1 %602, label %603, label %624
603: ; preds = %600
%604 = load i64, i64* %36
%605 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 %604
%606 = load i8, i8* %605
%607 = zext i8 %606 to i32
%608 = load i64, i64* %36
%609 = getelementptr inbounds [16 x i8], [16 x i8]* %26, i64 0, i64 %608
%610 = load i8, i8* %609
%611 = zext i8 %610 to i32
%612 = xor i32 %607, %611
%613 = trunc i32 %612 to i8
%614 = load i8*, i8** %10
%615 = load i64, i64* %28
%616 = sub i64 %615, 1
%617 = mul i64 %616, 16
%618 = load i64, i64* %36
%619 = add i64 %617, %618
%620 = getelementptr inbounds i8, i8* %614, i64 %619
store i8 %613, i8* %620
br label %621
621: ; preds = %603
%622 = load i64, i64* %36
%623 = add i64 %622, 1
store i64 %623, i64* %36
br label %600
624: ; preds = %600
br label %625
625: ; preds = %624, %598
%626 = load i64, i64* %13
%627 = urem i64 %626, 16
%628 = icmp ne i64 %627, 0
br i1 %628, label %629, label %692
629: ; preds = %625
store i64 0, i64* %36
br label %630
630: ; preds = %657, %629
%631 = load i64, i64* %36
%632 = icmp ult i64 %631, 16
br i1 %632, label %633, label %660
633: ; preds = %630
%634 = load i64, i64* %36
%635 = getelementptr inbounds [16 x i8], [16 x i8]* %26, i64 0, i64 %634
%636 = load i8, i8* %635
%637 = zext i8 %636 to i32
%638 = load i64, i64* %36
%639 = getelementptr inbounds [16 x i8], [16 x i8]* %29, i64 0, i64 %638
%640 = load i8, i8* %639
%641 = zext i8 %640 to i32
%642 = xor i32 %637, %641
%643 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %30, i64 0, i64 1
%644 = load i64, i64* %36
%645 = getelementptr inbounds [16 x i8], [16 x i8]* %643, i64 0, i64 %644
%646 = load i8, i8* %645
%647 = zext i8 %646 to i32
%648 = xor i32 %642, %647
%649 = load i64, i64* %36
%650 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 %649
%651 = load i8, i8* %650
%652 = zext i8 %651 to i32
%653 = xor i32 %648, %652
%654 = trunc i32 %653 to i8
%655 = load i64, i64* %36
%656 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 %655
store i8 %654, i8* %656
br label %657
657: ; preds = %633
%658 = load i64, i64* %36
%659 = add i64 %658, 1
store i64 %659, i64* %36
br label %630
660: ; preds = %630
%661 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%662 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 0
%663 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %661, i8* %662)
store i64 0, i64* %36
br label %664
664: ; preds = %688, %660
%665 = load i64, i64* %36
%666 = icmp ult i64 %665, 16
br i1 %666, label %667, label %691
667: ; preds = %664
%668 = load i64, i64* %36
%669 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 %668
%670 = load i8, i8* %669
%671 = zext i8 %670 to i32
%672 = load i64, i64* %36
%673 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %672
%674 = load i8, i8* %673
%675 = zext i8 %674 to i32
%676 = xor i32 %671, %675
%677 = trunc i32 %676 to i8
%678 = load i8*, i8** %10
%679 = load i64, i64* %28
%680 = sub i64 %679, 1
%681 = mul i64 %680, 16
%682 = load i64, i64* %13
%683 = urem i64 %682, 16
%684 = add i64 %681, %683
%685 = load i64, i64* %36
%686 = add i64 %684, %685
%687 = getelementptr inbounds i8, i8* %678, i64 %686
store i8 %677, i8* %687
br label %688
688: ; preds = %667
%689 = load i64, i64* %36
%690 = add i64 %689, 1
store i64 %690, i64* %36
br label %664
691: ; preds = %664
br label %746
692: ; preds = %625
store i64 0, i64* %36
br label %693
693: ; preds = %715, %692
%694 = load i64, i64* %36
%695 = icmp ult i64 %694, 16
br i1 %695, label %696, label %718
696: ; preds = %693
%697 = load i64, i64* %36
%698 = getelementptr inbounds [16 x i8], [16 x i8]* %26, i64 0, i64 %697
%699 = load i8, i8* %698
%700 = zext i8 %699 to i32
%701 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %30, i64 0, i64 2
%702 = load i64, i64* %36
%703 = getelementptr inbounds [16 x i8], [16 x i8]* %701, i64 0, i64 %702
%704 = load i8, i8* %703
%705 = zext i8 %704 to i32
%706 = xor i32 %700, %705
%707 = load i64, i64* %36
%708 = getelementptr inbounds [16 x i8], [16 x i8]* %32, i64 0, i64 %707
%709 = load i8, i8* %708
%710 = zext i8 %709 to i32
%711 = xor i32 %706, %710
%712 = trunc i32 %711 to i8
%713 = load i64, i64* %36
%714 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 %713
store i8 %712, i8* %714
br label %715
715: ; preds = %696
%716 = load i64, i64* %36
%717 = add i64 %716, 1
store i64 %717, i64* %36
br label %693
718: ; preds = %693
%719 = getelementptr inbounds [16 x i8], [16 x i8]* %33, i64 0, i64 0
%720 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 0
%721 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %719, i8* %720)
store i64 0, i64* %36
br label %722
722: ; preds = %742, %718
%723 = load i64, i64* %36
%724 = icmp ult i64 %723, 16
br i1 %724, label %725, label %745
725: ; preds = %722
%726 = load i64, i64* %36
%727 = getelementptr inbounds [16 x i8], [16 x i8]* %34, i64 0, i64 %726
%728 = load i8, i8* %727
%729 = zext i8 %728 to i32
%730 = load i64, i64* %36
%731 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %730
%732 = load i8, i8* %731
%733 = zext i8 %732 to i32
%734 = xor i32 %729, %733
%735 = trunc i32 %734 to i8
%736 = load i8*, i8** %10
%737 = load i64, i64* %28
%738 = mul i64 %737, 16
%739 = load i64, i64* %36
%740 = add i64 %738, %739
%741 = getelementptr inbounds i8, i8* %736, i64 %740
store i8 %735, i8* %741
br label %742
742: ; preds = %725
%743 = load i64, i64* %36
%744 = add i64 %743, 1
store i64 %744, i64* %36
br label %722
745: ; preds = %722
br label %746
746: ; preds = %745, %691
br label %747
747: ; preds = %746, %376
ret i32 0
}

LLVM IR (-O2):
define i32 @crypto_aead_encrypt(i8* nocapture writeonly %0, i64* nocapture writeonly %1, i8* nocapture %2, i64 %3, i8* nocapture %4, i64 %5, i8* nocapture readnone %6, i8* nocapture %7, i8* nocapture %8) {
%10 = alloca [16 x i8]
%11 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%12 = alloca [16 x i8]
%13 = alloca [16 x i8]
%14 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%15 = alloca <16 x i8>
%16 = getelementptr inbounds <16 x i8>, <16 x i8>* %15, i64 0, i64 0
%17 = alloca [16 x i8]
%18 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 0
%19 = alloca <16 x i8>
%20 = getelementptr inbounds <16 x i8>, <16 x i8>* %19, i64 0, i64 0
%21 = alloca [16 x i8]
%22 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 0
%23 = alloca <16 x i8>
%24 = getelementptr inbounds <16 x i8>, <16 x i8>* %23, i64 0, i64 0
%25 = alloca [3 x [16 x i8]]
%26 = alloca <16 x i8>
%27 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 0
%28 = alloca <16 x i8>
%29 = alloca <16 x i8>
%30 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 0
%31 = alloca <16 x i8>
%32 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%33 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 0
%34 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%35 = getelementptr inbounds <16 x i8>, <16 x i8>* %15, i64 0, i64 0
%36 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 0
%37 = getelementptr inbounds <16 x i8>, <16 x i8>* %19, i64 0, i64 0
%38 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 0
%39 = getelementptr inbounds <16 x i8>, <16 x i8>* %23, i64 0, i64 0
%40 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 0, i64 0
%41 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 0
%42 = getelementptr inbounds <16 x i8>, <16 x i8>* %28, i64 0, i64 0
%43 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 0
%44 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 0
%45 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @keyschedule to i32 (i8*, i32, ...)*)(i8* %34, i32 10)
%46 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %43, i8* %40)
%47 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 0
%48 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %40, i8* %47)
%49 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 0
%50 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %47, i8* %49)
%51 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %49, i8* %41)
%52 = icmp eq i64 %5, 0
br i1 %52, label %53, label %55
53: ; preds = %9
%54 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 0
br label %403
55: ; preds = %9
%56 = and i64 %5, 15
%57 = icmp eq i64 %56, 0
%58 = xor i1 %57, true
%59 = lshr i64 %5, 4
%60 = zext i1 %58 to i64
%61 = add nsw i64 %59, -1
%62 = add nsw i64 %61, %60
%63 = icmp eq i64 %62, 0
br i1 %63, label %140, label %64
64: ; preds = %55
%65 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 1
%66 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 2
%67 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 3
%68 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 4
%69 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 5
%70 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 6
%71 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 7
%72 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 8
%73 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 9
%74 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 10
%75 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 11
%76 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 12
%77 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 13
%78 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 14
%79 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 15
br label %80
80: ; preds = %64, %80
%81 = phi i8 [ 0, %64 ], [ %106, %80 ]
%82 = phi i8 [ 0, %64 ], [ %108, %80 ]
%83 = phi i8 [ 0, %64 ], [ %110, %80 ]
%84 = phi i8 [ 0, %64 ], [ %112, %80 ]
%85 = phi i8 [ 0, %64 ], [ %114, %80 ]
%86 = phi i8 [ 0, %64 ], [ %116, %80 ]
%87 = phi i8 [ 0, %64 ], [ %118, %80 ]
%88 = phi i8 [ 0, %64 ], [ %120, %80 ]
%89 = phi i8 [ 0, %64 ], [ %122, %80 ]
%90 = phi i8 [ 0, %64 ], [ %124, %80 ]
%91 = phi i8 [ 0, %64 ], [ %126, %80 ]
%92 = phi i8 [ 0, %64 ], [ %128, %80 ]
%93 = phi i8 [ 0, %64 ], [ %130, %80 ]
%94 = phi i8 [ 0, %64 ], [ %132, %80 ]
%95 = phi i8 [ 0, %64 ], [ %134, %80 ]
%96 = phi i8 [ 0, %64 ], [ %136, %80 ]
%97 = phi i64 [ 0, %64 ], [ %138, %80 ]
%98 = shl i64 %97, 4
%99 = getelementptr inbounds i8, i8* %4, i64 %98
%100 = bitcast i8* %99 to <16 x i8>*
%101 = load <16 x i8>, <16 x i8>* %100
%102 = load <16 x i8>, <16 x i8>* %26
%103 = xor <16 x i8> %102, %101
store <16 x i8> %103, <16 x i8>* %29
%104 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %43, i8* %44)
%105 = load i8, i8* %44
%106 = xor i8 %105, %81
%107 = load i8, i8* %65
%108 = xor i8 %107, %82
%109 = load i8, i8* %66
%110 = xor i8 %109, %83
%111 = load i8, i8* %67
%112 = xor i8 %111, %84
%113 = load i8, i8* %68
%114 = xor i8 %113, %85
%115 = load i8, i8* %69
%116 = xor i8 %115, %86
%117 = load i8, i8* %70
%118 = xor i8 %117, %87
%119 = load i8, i8* %71
%120 = xor i8 %119, %88
%121 = load i8, i8* %72
%122 = xor i8 %121, %89
%123 = load i8, i8* %73
%124 = xor i8 %123, %90
%125 = load i8, i8* %74
%126 = xor i8 %125, %91
%127 = load i8, i8* %75
%128 = xor i8 %127, %92
%129 = load i8, i8* %76
%130 = xor i8 %129, %93
%131 = load i8, i8* %77
%132 = xor i8 %131, %94
%133 = load i8, i8* %78
%134 = xor i8 %133, %95
%135 = load i8, i8* %79
%136 = xor i8 %135, %96
%137 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %41, i8* %35)
%138 = add nuw i64 %97, 1
%139 = icmp eq i64 %138, %62
br i1 %139, label %140, label %80
140: ; preds = %80, %55
%141 = phi i8 [ 0, %55 ], [ %106, %80 ]
%142 = phi i8 [ 0, %55 ], [ %108, %80 ]
%143 = phi i8 [ 0, %55 ], [ %110, %80 ]
%144 = phi i8 [ 0, %55 ], [ %112, %80 ]
%145 = phi i8 [ 0, %55 ], [ %114, %80 ]
%146 = phi i8 [ 0, %55 ], [ %116, %80 ]
%147 = phi i8 [ 0, %55 ], [ %118, %80 ]
%148 = phi i8 [ 0, %55 ], [ %120, %80 ]
%149 = phi i8 [ 0, %55 ], [ %122, %80 ]
%150 = phi i8 [ 0, %55 ], [ %124, %80 ]
%151 = phi i8 [ 0, %55 ], [ %126, %80 ]
%152 = phi i8 [ 0, %55 ], [ %128, %80 ]
%153 = phi i8 [ 0, %55 ], [ %130, %80 ]
%154 = phi i8 [ 0, %55 ], [ %132, %80 ]
%155 = phi i8 [ 0, %55 ], [ %134, %80 ]
%156 = phi i8 [ 0, %55 ], [ %136, %80 ]
br i1 %57, label %157, label %278
157: ; preds = %140
%158 = shl i64 %62, 4
%159 = getelementptr inbounds i8, i8* %4, i64 %158
%160 = load i8, i8* %159
%161 = xor i8 %160, %141
%162 = load i8, i8* %49
%163 = xor i8 %161, %162
store i8 %163, i8* %43
%164 = or i64 %158, 1
%165 = getelementptr inbounds i8, i8* %4, i64 %164
%166 = load i8, i8* %165
%167 = xor i8 %166, %142
%168 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 1
%169 = load i8, i8* %168
%170 = xor i8 %167, %169
%171 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 1
store i8 %170, i8* %171
%172 = or i64 %158, 2
%173 = getelementptr inbounds i8, i8* %4, i64 %172
%174 = load i8, i8* %173
%175 = xor i8 %174, %143
%176 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 2
%177 = load i8, i8* %176
%178 = xor i8 %175, %177
%179 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 2
store i8 %178, i8* %179
%180 = or i64 %158, 3
%181 = getelementptr inbounds i8, i8* %4, i64 %180
%182 = load i8, i8* %181
%183 = xor i8 %182, %144
%184 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 3
%185 = load i8, i8* %184
%186 = xor i8 %183, %185
%187 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 3
store i8 %186, i8* %187
%188 = or i64 %158, 4
%189 = getelementptr inbounds i8, i8* %4, i64 %188
%190 = load i8, i8* %189
%191 = xor i8 %190, %145
%192 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 4
%193 = load i8, i8* %192
%194 = xor i8 %191, %193
%195 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 4
store i8 %194, i8* %195
%196 = or i64 %158, 5
%197 = getelementptr inbounds i8, i8* %4, i64 %196
%198 = load i8, i8* %197
%199 = xor i8 %198, %146
%200 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 5
%201 = load i8, i8* %200
%202 = xor i8 %199, %201
%203 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 5
store i8 %202, i8* %203
%204 = or i64 %158, 6
%205 = getelementptr inbounds i8, i8* %4, i64 %204
%206 = load i8, i8* %205
%207 = xor i8 %206, %147
%208 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 6
%209 = load i8, i8* %208
%210 = xor i8 %207, %209
%211 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 6
store i8 %210, i8* %211
%212 = or i64 %158, 7
%213 = getelementptr inbounds i8, i8* %4, i64 %212
%214 = load i8, i8* %213
%215 = xor i8 %214, %148
%216 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 7
%217 = load i8, i8* %216
%218 = xor i8 %215, %217
%219 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 7
store i8 %218, i8* %219
%220 = or i64 %158, 8
%221 = getelementptr inbounds i8, i8* %4, i64 %220
%222 = load i8, i8* %221
%223 = xor i8 %222, %149
%224 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 8
%225 = load i8, i8* %224
%226 = xor i8 %223, %225
%227 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 8
store i8 %226, i8* %227
%228 = or i64 %158, 9
%229 = getelementptr inbounds i8, i8* %4, i64 %228
%230 = load i8, i8* %229
%231 = xor i8 %230, %150
%232 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 9
%233 = load i8, i8* %232
%234 = xor i8 %231, %233
%235 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 9
store i8 %234, i8* %235
%236 = or i64 %158, 10
%237 = getelementptr inbounds i8, i8* %4, i64 %236
%238 = load i8, i8* %237
%239 = xor i8 %238, %151
%240 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 10
%241 = load i8, i8* %240
%242 = xor i8 %239, %241
%243 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 10
store i8 %242, i8* %243
%244 = or i64 %158, 11
%245 = getelementptr inbounds i8, i8* %4, i64 %244
%246 = load i8, i8* %245
%247 = xor i8 %246, %152
%248 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 11
%249 = load i8, i8* %248
%250 = xor i8 %247, %249
%251 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 11
store i8 %250, i8* %251
%252 = or i64 %158, 12
%253 = getelementptr inbounds i8, i8* %4, i64 %252
%254 = load i8, i8* %253
%255 = xor i8 %254, %153
%256 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 12
%257 = load i8, i8* %256
%258 = xor i8 %255, %257
%259 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 12
store i8 %258, i8* %259
%260 = or i64 %158, 13
%261 = getelementptr inbounds i8, i8* %4, i64 %260
%262 = load i8, i8* %261
%263 = xor i8 %262, %154
%264 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 13
%265 = load i8, i8* %264
%266 = xor i8 %263, %265
%267 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 13
store i8 %266, i8* %267
%268 = or i64 %158, 14
%269 = getelementptr inbounds i8, i8* %4, i64 %268
%270 = load i8, i8* %269
%271 = xor i8 %270, %155
%272 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 2, i64 14
%273 = load i8, i8* %272
%274 = xor i8 %271, %273
%275 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 14
store i8 %274, i8* %275
%276 = or i64 %158, 15
%277 = getelementptr inbounds i8, i8* %4, i64 %276
br label %393
278: ; preds = %140
%279 = add nuw nsw i64 %59, %60
%280 = shl i64 %279, 4
%281 = add i64 %280, -16
%282 = getelementptr i8, i8* %4, i64 %281
%283 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 %56
store i8 -128, i8* %283
%284 = icmp eq i64 %56, 15
br i1 %284, label %289, label %285
285: ; preds = %278
%286 = add nuw nsw i64 %56, 1
%287 = getelementptr [16 x i8], [16 x i8]* %10, i64 0, i64 %286
%288 = xor i64 %56, 15
br label %289
289: ; preds = %285, %278
%290 = load i8, i8* %32
%291 = xor i8 %290, %141
%292 = load i8, i8* %47
%293 = xor i8 %291, %292
store i8 %293, i8* %43
%294 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 1
%295 = load i8, i8* %294
%296 = xor i8 %295, %142
%297 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 1
%298 = load i8, i8* %297
%299 = xor i8 %296, %298
%300 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 1
store i8 %299, i8* %300
%301 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 2
%302 = load i8, i8* %301
%303 = xor i8 %302, %143
%304 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 2
%305 = load i8, i8* %304
%306 = xor i8 %303, %305
%307 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 2
store i8 %306, i8* %307
%308 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 3
%309 = load i8, i8* %308
%310 = xor i8 %309, %144
%311 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 3
%312 = load i8, i8* %311
%313 = xor i8 %310, %312
%314 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 3
store i8 %313, i8* %314
%315 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 4
%316 = load i8, i8* %315
%317 = xor i8 %316, %145
%318 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 4
%319 = load i8, i8* %318
%320 = xor i8 %317, %319
%321 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 4
store i8 %320, i8* %321
%322 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 5
%323 = load i8, i8* %322
%324 = xor i8 %323, %146
%325 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 5
%326 = load i8, i8* %325
%327 = xor i8 %324, %326
%328 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 5
store i8 %327, i8* %328
%329 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 6
%330 = load i8, i8* %329
%331 = xor i8 %330, %147
%332 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 6
%333 = load i8, i8* %332
%334 = xor i8 %331, %333
%335 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 6
store i8 %334, i8* %335
%336 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 7
%337 = load i8, i8* %336
%338 = xor i8 %337, %148
%339 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 7
%340 = load i8, i8* %339
%341 = xor i8 %338, %340
%342 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 7
store i8 %341, i8* %342
%343 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 8
%344 = load i8, i8* %343
%345 = xor i8 %344, %149
%346 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 8
%347 = load i8, i8* %346
%348 = xor i8 %345, %347
%349 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 8
store i8 %348, i8* %349
%350 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 9
%351 = load i8, i8* %350
%352 = xor i8 %351, %150
%353 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 9
%354 = load i8, i8* %353
%355 = xor i8 %352, %354
%356 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 9
store i8 %355, i8* %356
%357 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 10
%358 = load i8, i8* %357
%359 = xor i8 %358, %151
%360 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 10
%361 = load i8, i8* %360
%362 = xor i8 %359, %361
%363 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 10
store i8 %362, i8* %363
%364 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 11
%365 = load i8, i8* %364
%366 = xor i8 %365, %152
%367 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 11
%368 = load i8, i8* %367
%369 = xor i8 %366, %368
%370 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 11
store i8 %369, i8* %370
%371 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 12
%372 = load i8, i8* %371
%373 = xor i8 %372, %153
%374 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 12
%375 = load i8, i8* %374
%376 = xor i8 %373, %375
%377 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 12
store i8 %376, i8* %377
%378 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 13
%379 = load i8, i8* %378
%380 = xor i8 %379, %154
%381 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 13
%382 = load i8, i8* %381
%383 = xor i8 %380, %382
%384 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 13
store i8 %383, i8* %384
%385 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 14
%386 = load i8, i8* %385
%387 = xor i8 %386, %155
%388 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 14
%389 = load i8, i8* %388
%390 = xor i8 %387, %389
%391 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 14
store i8 %390, i8* %391
%392 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 15
br label %393
393: ; preds = %289, %157
%394 = phi i8* [ %392, %289 ], [ %277, %157 ]
%395 = phi i64 [ 1, %289 ], [ 2, %157 ]
%396 = load i8, i8* %394
%397 = xor i8 %396, %156
%398 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 %395, i64 15
%399 = load i8, i8* %398
%400 = xor i8 %397, %399
%401 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 15
store i8 %400, i8* %401
%402 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %43, i8* %33)
br label %403
403: ; preds = %53, %393
%404 = add i64 %3, 16
store i64 %404, i64* %1
%405 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 13
store i8 -128, i8* %405
%406 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 14
%407 = bitcast i8* %406 to i16*
store i16 0, i16* %407
%408 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %36, i8* %42)
%409 = icmp eq i64 %3, 0
br i1 %409, label %410, label %508
410: ; preds = %403
%411 = bitcast i8* %49 to <16 x i8>*
%412 = load <16 x i8>, <16 x i8>* %411
%413 = load <16 x i8>, <16 x i8>* %28
%414 = xor <16 x i8> %413, %412
store <16 x i8> %414, <16 x i8>* %29
%415 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %43, i8* %44)
%416 = load i8, i8* %44
%417 = load i8, i8* %33
%418 = xor i8 %417, %416
store i8 %418, i8* %0
%419 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 1
%420 = load i8, i8* %419
%421 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 1
%422 = load i8, i8* %421
%423 = xor i8 %422, %420
%424 = getelementptr inbounds i8, i8* %0, i64 1
store i8 %423, i8* %424
%425 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 2
%426 = load i8, i8* %425
%427 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 2
%428 = load i8, i8* %427
%429 = xor i8 %428, %426
%430 = getelementptr inbounds i8, i8* %0, i64 2
store i8 %429, i8* %430
%431 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 3
%432 = load i8, i8* %431
%433 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 3
%434 = load i8, i8* %433
%435 = xor i8 %434, %432
%436 = getelementptr inbounds i8, i8* %0, i64 3
store i8 %435, i8* %436
%437 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 4
%438 = load i8, i8* %437
%439 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 4
%440 = load i8, i8* %439
%441 = xor i8 %440, %438
%442 = getelementptr inbounds i8, i8* %0, i64 4
store i8 %441, i8* %442
%443 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 5
%444 = load i8, i8* %443
%445 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 5
%446 = load i8, i8* %445
%447 = xor i8 %446, %444
%448 = getelementptr inbounds i8, i8* %0, i64 5
store i8 %447, i8* %448
%449 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 6
%450 = load i8, i8* %449
%451 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 6
%452 = load i8, i8* %451
%453 = xor i8 %452, %450
%454 = getelementptr inbounds i8, i8* %0, i64 6
store i8 %453, i8* %454
%455 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 7
%456 = load i8, i8* %455
%457 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 7
%458 = load i8, i8* %457
%459 = xor i8 %458, %456
%460 = getelementptr inbounds i8, i8* %0, i64 7
store i8 %459, i8* %460
%461 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 8
%462 = load i8, i8* %461
%463 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 8
%464 = load i8, i8* %463
%465 = xor i8 %464, %462
%466 = getelementptr inbounds i8, i8* %0, i64 8
store i8 %465, i8* %466
%467 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 9
%468 = load i8, i8* %467
%469 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 9
%470 = load i8, i8* %469
%471 = xor i8 %470, %468
%472 = getelementptr inbounds i8, i8* %0, i64 9
store i8 %471, i8* %472
%473 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 10
%474 = load i8, i8* %473
%475 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 10
%476 = load i8, i8* %475
%477 = xor i8 %476, %474
%478 = getelementptr inbounds i8, i8* %0, i64 10
store i8 %477, i8* %478
%479 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 11
%480 = load i8, i8* %479
%481 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 11
%482 = load i8, i8* %481
%483 = xor i8 %482, %480
%484 = getelementptr inbounds i8, i8* %0, i64 11
store i8 %483, i8* %484
%485 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 12
%486 = load i8, i8* %485
%487 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 12
%488 = load i8, i8* %487
%489 = xor i8 %488, %486
%490 = getelementptr inbounds i8, i8* %0, i64 12
store i8 %489, i8* %490
%491 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 13
%492 = load i8, i8* %491
%493 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 13
%494 = load i8, i8* %493
%495 = xor i8 %494, %492
%496 = getelementptr inbounds i8, i8* %0, i64 13
store i8 %495, i8* %496
%497 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 14
%498 = load i8, i8* %497
%499 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 14
%500 = load i8, i8* %499
%501 = xor i8 %500, %498
%502 = getelementptr inbounds i8, i8* %0, i64 14
store i8 %501, i8* %502
%503 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 15
%504 = load i8, i8* %503
%505 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 15
%506 = load i8, i8* %505
%507 = xor i8 %506, %504
br label %934
508: ; preds = %403
%509 = lshr i64 %3, 4
%510 = and i64 %3, 15
%511 = icmp eq i64 %510, 0
br i1 %511, label %512, label %516
512: ; preds = %508
%513 = add i64 %3, -16
%514 = and i64 %513, -16
%515 = getelementptr i8, i8* %2, i64 %514
br label %528
516: ; preds = %508
%517 = add nuw nsw i64 %509, 1
%518 = and i64 %3, -16
%519 = getelementptr i8, i8* %2, i64 %518
%520 = getelementptr inbounds <16 x i8>, <16 x i8>* %19, i64 0, i64 %510
store i8 0, i8* %520
%521 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %510
store i8 -128, i8* %521
%522 = add nuw nsw i64 %510, 1
%523 = icmp eq i64 %510, 15
br i1 %523, label %528, label %524
524: ; preds = %516
%525 = getelementptr <16 x i8>, <16 x i8>* %19, i64 0, i64 %522
%526 = xor i64 %510, 15
%527 = getelementptr [16 x i8], [16 x i8]* %21, i64 0, i64 %522
br label %528
528: ; preds = %524, %512, %516
%529 = phi i64 [ %517, %516 ], [ %509, %512 ], [ %517, %524 ]
%530 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %49, i8* %41)
%531 = load <16 x i8>, <16 x i8>* %26
%532 = load <16 x i8>, <16 x i8>* %28
%533 = xor <16 x i8> %532, %531
store <16 x i8> %533, <16 x i8>* %29
%534 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %43, i8* %44)
%535 = add nsw i64 %529, -1
%536 = icmp eq i64 %535, 0
br i1 %536, label %599, label %537
537: ; preds = %528, %595
%538 = phi i64 [ %597, %595 ], [ 0, %528 ]
%539 = shl i64 %538, 4
%540 = add i64 %539, 16
%541 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %41, i8* %35)
%542 = shl i64 %538, 4
%543 = getelementptr i8, i8* %2, i64 %540
%544 = getelementptr i8, i8* %2, i64 %539
%545 = getelementptr i8, i8* %0, i64 %540
%546 = getelementptr i8, i8* %0, i64 %539
%547 = icmp ult i8* %546, %543
%548 = icmp ult i8* %544, %545
%549 = and i1 %547, %548
br i1 %549, label %562, label %550
550: ; preds = %537
%551 = load <16 x i8>, <16 x i8>* %15
%552 = getelementptr inbounds i8, i8* %2, i64 %542
%553 = bitcast i8* %552 to <16 x i8>*
%554 = load <16 x i8>, <16 x i8>* %553
%555 = xor <16 x i8> %554, %551
%556 = load <16 x i8>, <16 x i8>* %28
%557 = xor <16 x i8> %555, %556
store <16 x i8> %557, <16 x i8>* %29
%558 = load <16 x i8>, <16 x i8>* %31
%559 = xor <16 x i8> %558, %557
%560 = getelementptr inbounds i8, i8* %0, i64 %542
%561 = bitcast i8* %560 to <16 x i8>*
store <16 x i8> %559, <16 x i8>* %561
br label %595
562: ; preds = %537, %562
%563 = phi i64 [ %593, %562 ], [ 0, %537 ]
%564 = getelementptr inbounds <16 x i8>, <16 x i8>* %15, i64 0, i64 %563
%565 = load i8, i8* %564
%566 = add nuw nsw i64 %563, %542
%567 = getelementptr inbounds i8, i8* %2, i64 %566
%568 = load i8, i8* %567
%569 = xor i8 %568, %565
%570 = getelementptr inbounds <16 x i8>, <16 x i8>* %28, i64 0, i64 %563
%571 = load i8, i8* %570
%572 = xor i8 %569, %571
%573 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %563
store i8 %572, i8* %573
%574 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 %563
%575 = load i8, i8* %574
%576 = xor i8 %575, %572
%577 = getelementptr inbounds i8, i8* %0, i64 %566
store i8 %576, i8* %577
%578 = or i64 %563, 1
%579 = getelementptr inbounds <16 x i8>, <16 x i8>* %15, i64 0, i64 %578
%580 = load i8, i8* %579
%581 = add nuw nsw i64 %578, %542
%582 = getelementptr inbounds i8, i8* %2, i64 %581
%583 = load i8, i8* %582
%584 = xor i8 %583, %580
%585 = getelementptr inbounds <16 x i8>, <16 x i8>* %28, i64 0, i64 %578
%586 = load i8, i8* %585
%587 = xor i8 %584, %586
%588 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %578
store i8 %587, i8* %588
%589 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 %578
%590 = load i8, i8* %589
%591 = xor i8 %590, %587
%592 = getelementptr inbounds i8, i8* %0, i64 %581
store i8 %591, i8* %592
%593 = add nuw nsw i64 %563, 2
%594 = icmp eq i64 %593, 16
br i1 %594, label %595, label %562
595: ; preds = %562, %550
%596 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %43, i8* %44)
%597 = add nuw i64 %538, 1
%598 = icmp eq i64 %597, %535
br i1 %598, label %599, label %537
599: ; preds = %595, %528
%600 = shl i64 %535, 4
br i1 %511, label %606, label %601
601: ; preds = %599
%602 = and i64 %3, 1
%603 = icmp eq i64 %510, 1
br i1 %603, label %633, label %604
604: ; preds = %601
%605 = sub nsw i64 %510, %602
br label %612
606: ; preds = %599
%607 = getelementptr inbounds i8, i8* %0, i64 %600
%608 = load <16 x i8>, <16 x i8>* %31
%609 = load <16 x i8>, <16 x i8>* %19
%610 = xor <16 x i8> %609, %608
%611 = bitcast i8* %607 to <16 x i8>*
store <16 x i8> %610, <16 x i8>* %611
br label %817
612: ; preds = %612, %604
%613 = phi i64 [ 0, %604 ], [ %630, %612 ]
%614 = phi i64 [ 0, %604 ], [ %631, %612 ]
%615 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 %613
%616 = load i8, i8* %615
%617 = getelementptr inbounds <16 x i8>, <16 x i8>* %19, i64 0, i64 %613
%618 = load i8, i8* %617
%619 = xor i8 %618, %616
%620 = add nuw nsw i64 %613, %600
%621 = getelementptr inbounds i8, i8* %0, i64 %620
store i8 %619, i8* %621
%622 = or i64 %613, 1
%623 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 %622
%624 = load i8, i8* %623
%625 = getelementptr inbounds <16 x i8>, <16 x i8>* %19, i64 0, i64 %622
%626 = load i8, i8* %625
%627 = xor i8 %626, %624
%628 = add nuw nsw i64 %622, %600
%629 = getelementptr inbounds i8, i8* %0, i64 %628
store i8 %627, i8* %629
%630 = add nuw nsw i64 %613, 2
%631 = add i64 %614, 2
%632 = icmp eq i64 %631, %605
br i1 %632, label %633, label %612
633: ; preds = %612, %601
%634 = phi i64 [ 0, %601 ], [ %630, %612 ]
%635 = icmp eq i64 %602, 0
br i1 %635, label %644, label %636
636: ; preds = %633
%637 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 %634
%638 = load i8, i8* %637
%639 = getelementptr inbounds <16 x i8>, <16 x i8>* %19, i64 0, i64 %634
%640 = load i8, i8* %639
%641 = xor i8 %640, %638
%642 = add nuw nsw i64 %634, %600
%643 = getelementptr inbounds i8, i8* %0, i64 %642
store i8 %641, i8* %643
br label %644
644: ; preds = %633, %636
%645 = sub i64 0, %3
%646 = xor i64 %510, 15
%647 = and i64 %645, 3
%648 = icmp eq i64 %647, 0
br i1 %648, label %661, label %649
649: ; preds = %644, %649
%650 = phi i64 [ %658, %649 ], [ %510, %644 ]
%651 = phi i64 [ %659, %649 ], [ 0, %644 ]
%652 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 %650
%653 = load i8, i8* %652
%654 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %650
%655 = load i8, i8* %654
%656 = xor i8 %655, %653
%657 = getelementptr inbounds <16 x i8>, <16 x i8>* %23, i64 0, i64 %650
store i8 %656, i8* %657
%658 = add nuw nsw i64 %650, 1
%659 = add i64 %651, 1
%660 = icmp eq i64 %659, %647
br i1 %660, label %661, label %649
661: ; preds = %649, %644
%662 = phi i64 [ %510, %644 ], [ %658, %649 ]
%663 = icmp ult i64 %646, 3
br i1 %663, label %695, label %664
664: ; preds = %661, %664
%665 = phi i64 [ %693, %664 ], [ %662, %661 ]
%666 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 %665
%667 = load i8, i8* %666
%668 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %665
%669 = load i8, i8* %668
%670 = xor i8 %669, %667
%671 = getelementptr inbounds <16 x i8>, <16 x i8>* %23, i64 0, i64 %665
store i8 %670, i8* %671
%672 = add nuw nsw i64 %665, 1
%673 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 %672
%674 = load i8, i8* %673
%675 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %672
%676 = load i8, i8* %675
%677 = xor i8 %676, %674
%678 = getelementptr inbounds <16 x i8>, <16 x i8>* %23, i64 0, i64 %672
store i8 %677, i8* %678
%679 = add nuw nsw i64 %665, 2
%680 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 %679
%681 = load i8, i8* %680
%682 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %679
%683 = load i8, i8* %682
%684 = xor i8 %683, %681
%685 = getelementptr inbounds <16 x i8>, <16 x i8>* %23, i64 0, i64 %679
store i8 %684, i8* %685
%686 = add nuw nsw i64 %665, 3
%687 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 %686
%688 = load i8, i8* %687
%689 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %686
%690 = load i8, i8* %689
%691 = xor i8 %690, %688
%692 = getelementptr inbounds <16 x i8>, <16 x i8>* %23, i64 0, i64 %686
store i8 %691, i8* %692
%693 = add nuw nsw i64 %665, 4
%694 = icmp eq i64 %693, 16
br i1 %694, label %695, label %664
695: ; preds = %664, %661
br i1 %511, label %817, label %696
696: ; preds = %695
%697 = load <16 x i8>, <16 x i8>* %19
%698 = load <16 x i8>, <16 x i8>* %23
%699 = xor <16 x i8> %698, %697
%700 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %25, i64 0, i64 1, i64 0
%701 = bitcast i8* %700 to <16 x i8>*
%702 = load <16 x i8>, <16 x i8>* %701
%703 = xor <16 x i8> %699, %702
%704 = load <16 x i8>, <16 x i8>* %28
%705 = xor <16 x i8> %703, %704
store <16 x i8> %705, <16 x i8>* %29
%706 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %43, i8* %44)
%707 = shl i64 %535, 4
%708 = or i64 %707, %510
%709 = load i8, i8* %44
%710 = load i8, i8* %33
%711 = xor i8 %710, %709
%712 = getelementptr inbounds i8, i8* %0, i64 %708
store i8 %711, i8* %712
%713 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 1
%714 = load i8, i8* %713
%715 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 1
%716 = load i8, i8* %715
%717 = xor i8 %716, %714
%718 = add i64 %708, 1
%719 = getelementptr inbounds i8, i8* %0, i64 %718
store i8 %717, i8* %719
%720 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 2
%721 = load i8, i8* %720
%722 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 2
%723 = load i8, i8* %722
%724 = xor i8 %723, %721
%725 = add i64 %708, 2
%726 = getelementptr inbounds i8, i8* %0, i64 %725
store i8 %724, i8* %726
%727 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 3
%728 = load i8, i8* %727
%729 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 3
%730 = load i8, i8* %729
%731 = xor i8 %730, %728
%732 = add i64 %708, 3
%733 = getelementptr inbounds i8, i8* %0, i64 %732
store i8 %731, i8* %733
%734 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 4
%735 = load i8, i8* %734
%736 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 4
%737 = load i8, i8* %736
%738 = xor i8 %737, %735
%739 = add i64 %708, 4
%740 = getelementptr inbounds i8, i8* %0, i64 %739
store i8 %738, i8* %740
%741 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 5
%742 = load i8, i8* %741
%743 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 5
%744 = load i8, i8* %743
%745 = xor i8 %744, %742
%746 = add i64 %708, 5
%747 = getelementptr inbounds i8, i8* %0, i64 %746
store i8 %745, i8* %747
%748 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 6
%749 = load i8, i8* %748
%750 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 6
%751 = load i8, i8* %750
%752 = xor i8 %751, %749
%753 = add i64 %708, 6
%754 = getelementptr inbounds i8, i8* %0, i64 %753
store i8 %752, i8* %754
%755 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 7
%756 = load i8, i8* %755
%757 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 7
%758 = load i8, i8* %757
%759 = xor i8 %758, %756
%760 = add i64 %708, 7
%761 = getelementptr inbounds i8, i8* %0, i64 %760
store i8 %759, i8* %761
%762 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 8
%763 = load i8, i8* %762
%764 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 8
%765 = load i8, i8* %764
%766 = xor i8 %765, %763
%767 = add i64 %708, 8
%768 = getelementptr inbounds i8, i8* %0, i64 %767
store i8 %766, i8* %768
%769 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 9
%770 = load i8, i8* %769
%771 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 9
%772 = load i8, i8* %771
%773 = xor i8 %772, %770
%774 = add i64 %708, 9
%775 = getelementptr inbounds i8, i8* %0, i64 %774
store i8 %773, i8* %775
%776 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 10
%777 = load i8, i8* %776
%778 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 10
%779 = load i8, i8* %778
%780 = xor i8 %779, %777
%781 = add i64 %708, 10
%782 = getelementptr inbounds i8, i8* %0, i64 %781
store i8 %780, i8* %782
%783 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 11
%784 = load i8, i8* %783
%785 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 11
%786 = load i8, i8* %785
%787 = xor i8 %786, %784
%788 = add i64 %708, 11
%789 = getelementptr inbounds i8, i8* %0, i64 %788
store i8 %787, i8* %789
%790 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 12
%791 = load i8, i8* %790
%792 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 12
%793 = load i8, i8* %792
%794 = xor i8 %793, %791
%795 = add i64 %708, 12
%796 = getelementptr inbounds i8, i8* %0, i64 %795
store i8 %794, i8* %796
%797 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 13
%798 = load i8, i8* %797
%799 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 13
%800 = load i8, i8* %799
%801 = xor i8 %800, %798
%802 = add i64 %708, 13
%803 = getelementptr inbounds i8, i8* %0, i64 %802
store i8 %801, i8* %803
%804 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 14
%805 = load i8, i8* %804
%806 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 14
%807 = load i8, i8* %806
%808 = xor i8 %807, %805
%809 = add i64 %708, 14
%810 = getelementptr inbounds i8, i8* %0, i64 %809
store i8 %808, i8* %810
%811 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 15
%812 = load i8, i8* %811
%813 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 15
%814 = load i8, i8* %813
%815 = xor i8 %814, %812
%816 = add i64 %708, 15
br label %934
817: ; preds = %606, %695
%818 = load <16 x i8>, <16 x i8>* %19
%819 = bitcast i8* %49 to <16 x i8>*
%820 = load <16 x i8>, <16 x i8>* %819
%821 = xor <16 x i8> %820, %818
%822 = load <16 x i8>, <16 x i8>* %28
%823 = xor <16 x i8> %821, %822
store <16 x i8> %823, <16 x i8>* %29
%824 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %43, i8* %44)
%825 = shl i64 %529, 4
%826 = load i8, i8* %44
%827 = load i8, i8* %33
%828 = xor i8 %827, %826
%829 = getelementptr inbounds i8, i8* %0, i64 %825
store i8 %828, i8* %829
%830 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 1
%831 = load i8, i8* %830
%832 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 1
%833 = load i8, i8* %832
%834 = xor i8 %833, %831
%835 = or i64 %825, 1
%836 = getelementptr inbounds i8, i8* %0, i64 %835
store i8 %834, i8* %836
%837 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 2
%838 = load i8, i8* %837
%839 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 2
%840 = load i8, i8* %839
%841 = xor i8 %840, %838
%842 = or i64 %825, 2
%843 = getelementptr inbounds i8, i8* %0, i64 %842
store i8 %841, i8* %843
%844 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 3
%845 = load i8, i8* %844
%846 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 3
%847 = load i8, i8* %846
%848 = xor i8 %847, %845
%849 = or i64 %825, 3
%850 = getelementptr inbounds i8, i8* %0, i64 %849
store i8 %848, i8* %850
%851 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 4
%852 = load i8, i8* %851
%853 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 4
%854 = load i8, i8* %853
%855 = xor i8 %854, %852
%856 = or i64 %825, 4
%857 = getelementptr inbounds i8, i8* %0, i64 %856
store i8 %855, i8* %857
%858 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 5
%859 = load i8, i8* %858
%860 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 5
%861 = load i8, i8* %860
%862 = xor i8 %861, %859
%863 = or i64 %825, 5
%864 = getelementptr inbounds i8, i8* %0, i64 %863
store i8 %862, i8* %864
%865 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 6
%866 = load i8, i8* %865
%867 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 6
%868 = load i8, i8* %867
%869 = xor i8 %868, %866
%870 = or i64 %825, 6
%871 = getelementptr inbounds i8, i8* %0, i64 %870
store i8 %869, i8* %871
%872 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 7
%873 = load i8, i8* %872
%874 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 7
%875 = load i8, i8* %874
%876 = xor i8 %875, %873
%877 = or i64 %825, 7
%878 = getelementptr inbounds i8, i8* %0, i64 %877
store i8 %876, i8* %878
%879 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 8
%880 = load i8, i8* %879
%881 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 8
%882 = load i8, i8* %881
%883 = xor i8 %882, %880
%884 = or i64 %825, 8
%885 = getelementptr inbounds i8, i8* %0, i64 %884
store i8 %883, i8* %885
%886 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 9
%887 = load i8, i8* %886
%888 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 9
%889 = load i8, i8* %888
%890 = xor i8 %889, %887
%891 = or i64 %825, 9
%892 = getelementptr inbounds i8, i8* %0, i64 %891
store i8 %890, i8* %892
%893 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 10
%894 = load i8, i8* %893
%895 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 10
%896 = load i8, i8* %895
%897 = xor i8 %896, %894
%898 = or i64 %825, 10
%899 = getelementptr inbounds i8, i8* %0, i64 %898
store i8 %897, i8* %899
%900 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 11
%901 = load i8, i8* %900
%902 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 11
%903 = load i8, i8* %902
%904 = xor i8 %903, %901
%905 = or i64 %825, 11
%906 = getelementptr inbounds i8, i8* %0, i64 %905
store i8 %904, i8* %906
%907 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 12
%908 = load i8, i8* %907
%909 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 12
%910 = load i8, i8* %909
%911 = xor i8 %910, %908
%912 = or i64 %825, 12
%913 = getelementptr inbounds i8, i8* %0, i64 %912
store i8 %911, i8* %913
%914 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 13
%915 = load i8, i8* %914
%916 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 13
%917 = load i8, i8* %916
%918 = xor i8 %917, %915
%919 = or i64 %825, 13
%920 = getelementptr inbounds i8, i8* %0, i64 %919
store i8 %918, i8* %920
%921 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 14
%922 = load i8, i8* %921
%923 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 14
%924 = load i8, i8* %923
%925 = xor i8 %924, %922
%926 = or i64 %825, 14
%927 = getelementptr inbounds i8, i8* %0, i64 %926
store i8 %925, i8* %927
%928 = getelementptr inbounds <16 x i8>, <16 x i8>* %31, i64 0, i64 15
%929 = load i8, i8* %928
%930 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 15
%931 = load i8, i8* %930
%932 = xor i8 %931, %929
%933 = or i64 %825, 15
br label %934
934: ; preds = %696, %817, %410
%935 = phi i64 [ %816, %696 ], [ %933, %817 ], [ 15, %410 ]
%936 = phi i8 [ %815, %696 ], [ %932, %817 ], [ %507, %410 ]
%937 = getelementptr inbounds i8, i8* %0, i64 %935
store i8 %936, i8* %937
ret i32 0
}