int crypto_aead_decrypt(unsigned char *m, unsigned long long *mlen,
                        unsigned char *nsec, const unsigned char *c,
                        unsigned long long clen, const unsigned char *ad,
                        unsigned long long adlen, 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 LastCiphertextBlock[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);
  }
  if (clen < 16)
    return -2;
  *mlen = clen - 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 (clen == 16) {
    for (j = 0; j < 16; j++)
      AESInputBlock[j] = Z[2][j] ^ U[j];
    AES128Enc(AESInputBlock, AESOutputBlock);
    for (j = 0; j < 16; j++) {
      if (c[j] != (AESOutputBlock[j] ^ MacAESTag[j]))
        return -1;
    }
  } else {
    l = clen / 16 - 1;
    if (clen % 16 != 0) {
      l = l + 1;
      for (j = 0; j < clen % 16; j++) {
        LastCiphertextBlock[j] = c[(l - 1) * 16 + j];
        PaddedBlock[j] = 0x0;
      }
      LastCiphertextBlock[clen % 16] = 0x0;
      PaddedBlock[clen % 16] = 0x80;
      for (j = clen % 16 + 1; j < 16; j++) {
        LastCiphertextBlock[j] = 0x0;
        PaddedBlock[j] = 0x0;
      }
    } else {
      for (j = 0; j < 16; j++) {
        LastCiphertextBlock[j] = c[(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++) {
        AESInputBlock[j] = AESOutputBlock[j] ^ c[i * 16 + j];
        m[i * 16 + j] = AESInputBlock[j] ^ Double[j] ^ U[j];
        NextZ[j] = Double[j];
      }
      AES128Enc(AESInputBlock, AESOutputBlock);
    }
    if (clen % 16 != 0) {
      for (j = 0; j < clen % 16; j++) {
        m[(l - 1) * 16 + j] = AESOutputBlock[j] ^ c[(l - 1) * 16 + j];
        StolenR[j] = 0x0;
      }
      for (j = (clen % 16); j < 16; j++)
        StolenR[j] = AESOutputBlock[j] ^ PaddedBlock[j];
    } else {
      for (j = 0; j < 16; j++) {
        m[(l - 1) * 16 + j] = AESOutputBlock[j] ^ c[(l - 1) * 16 + j];
        StolenR[j] = 0x0;
      }
    }
    if (clen % 16 != 0) {
      for (j = 0; j < (clen % 16); j++)
        AESInputBlock[j] = m[(l - 1) * 16 + j] ^ Z[1][j] ^ U[j];
      for (j = (clen % 16); j < 16; j++)
        AESInputBlock[j] = StolenR[j] ^ Z[1][j] ^ U[j];
      AES128Enc(AESInputBlock, AESOutputBlock);
      for (j = 0; j < 16; j++) {
        if (c[(l - 1) * 16 + clen % 16 + j] !=
            (AESOutputBlock[j] ^ MacAESTag[j]))
          return -1;
      }
    } else {
      for (j = 0; j < 16; j++)
        AESInputBlock[j] = m[(l - 1) * 16 + j] ^ Z[2][j] ^ U[j];
      AES128Enc(AESInputBlock, AESOutputBlock);
      for (j = 0; j < 16; j++) {
        if (c[l * 16 + j] != (AESOutputBlock[j] ^ MacAESTag[j]))
          return -1;
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<crypto_aead_decrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    11a8 <crypto_aead_decrypt+0x78>
mov    0x20(%rbp),%rax
mov    -0x170(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    116a <crypto_aead_decrypt+0x3a>
lea    -0x80(%rbp),%rdi
mov    $0xa,%esi
mov    $0x0,%al
call   1050 <keyschedule@plt>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    11f7 <crypto_aead_decrypt+0xc7>
mov    -0x170(%rbp),%rax
movb   $0x0,-0x150(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    11c3 <crypto_aead_decrypt+0x93>
lea    -0x150(%rbp),%rdi
lea    -0x120(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x168(%rbp)
cmpq   $0x2,-0x168(%rbp)
02
jae    1271 <crypto_aead_decrypt+0x141>
mov    -0x168(%rbp),%rax
lea    -0x120(%rbp),%rdi
shl    $0x4,%rax
add    %rax,%rdi
mov    -0x168(%rbp),%rax
add    $0x1,%rax
lea    -0x120(%rbp),%rsi
shl    $0x4,%rax
add    %rax,%rsi
mov    $0x0,%al
call   1040 <Times2@plt>
mov    -0x168(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x168(%rbp)
jmp    1217 <crypto_aead_decrypt+0xe7>
lea    -0x120(%rbp),%rdi
add    $0x20,%rdi
lea    -0x130(%rbp),%rsi
mov    $0x0,%al
call   1040 <Times2@plt>
cmpq   $0x0,0x10(%rbp)
jne    12d6 <crypto_aead_decrypt+0x1a6>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    12d1 <crypto_aead_decrypt+0x1a1>
mov    -0x170(%rbp),%rax
movb   $0x0,-0x70(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    12a0 <crypto_aead_decrypt+0x170>
jmp    1691 <crypto_aead_decrypt+0x561>
mov    0x10(%rbp),%rax
and    $0xf,%rax
cmp    $0x0,%rax
jne    12fc <crypto_aead_decrypt+0x1cc>
mov    0x10(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x98(%rbp)
jmp    130f <crypto_aead_decrypt+0x1df>
mov    0x10(%rbp),%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %rax,-0x98(%rbp)
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    134b <crypto_aead_decrypt+0x21b>
mov    -0x170(%rbp),%rax
movb   $0x0,-0x50(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    131a <crypto_aead_decrypt+0x1ea>
movq   $0x0,-0x168(%rbp)
mov    -0x168(%rbp),%rax
mov    -0x98(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    14c8 <crypto_aead_decrypt+0x398>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    13dc <crypto_aead_decrypt+0x2ac>
mov    -0x38(%rbp),%rax
mov    -0x168(%rbp),%rcx
shl    $0x4,%rcx
add    -0x170(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x170(%rbp),%rcx
movzbl -0x130(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    137c <crypto_aead_decrypt+0x24c>
lea    -0x150(%rbp),%rdi
lea    -0x160(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    144b <crypto_aead_decrypt+0x31b>
mov    -0x170(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
mov    -0x170(%rbp),%rcx
movzbl -0x160(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    13fc <crypto_aead_decrypt+0x2cc>
lea    -0x130(%rbp),%rdi
lea    -0x90(%rbp),%rsi
mov    $0x0,%al
call   1040 <Times2@plt>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    14ac <crypto_aead_decrypt+0x37c>
mov    -0x170(%rbp),%rax
mov    -0x90(%rbp,%rax,1),%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    146b <crypto_aead_decrypt+0x33b>
jmp    14b1 <crypto_aead_decrypt+0x381>
mov    -0x168(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x168(%rbp)
jmp    1356 <crypto_aead_decrypt+0x226>
mov    0x10(%rbp),%rax
and    $0xf,%rax
cmp    $0x0,%rax
je     15fd <crypto_aead_decrypt+0x4cd>
movq   $0x0,-0x170(%rbp)
mov    -0x170(%rbp),%rax
mov    0x10(%rbp),%rcx
and    $0xf,%rcx
cmp    %rcx,%rax
jae    153c <crypto_aead_decrypt+0x40c>
mov    -0x38(%rbp),%rax
mov    -0x98(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x170(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x60(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    14e5 <crypto_aead_decrypt+0x3b5>
mov    0x10(%rbp),%rax
and    $0xf,%rax
movb   $0x80,-0x60(%rbp,%rax,1)
mov    0x10(%rbp),%rax
and    $0xf,%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    158d <crypto_aead_decrypt+0x45d>
mov    -0x170(%rbp),%rax
movb   $0x0,-0x60(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    155c <crypto_aead_decrypt+0x42c>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    15f8 <crypto_aead_decrypt+0x4c8>
mov    -0x170(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
mov    -0x170(%rbp),%rcx
movzbl -0x60(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    -0x170(%rbp),%rcx
movzbl -0x110(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1598 <crypto_aead_decrypt+0x468>
jmp    167f <crypto_aead_decrypt+0x54f>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    167a <crypto_aead_decrypt+0x54a>
mov    -0x170(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
mov    -0x38(%rbp),%rcx
mov    -0x98(%rbp),%rdx
sub    $0x1,%rdx
shl    $0x4,%rdx
add    -0x170(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    -0x170(%rbp),%rcx
movzbl -0x100(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1608 <crypto_aead_decrypt+0x4d8>
jmp    167f <crypto_aead_decrypt+0x54f>
lea    -0x150(%rbp),%rdi
lea    -0x70(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
cmpq   $0x10,-0x30(%rbp)
jae    16a8 <crypto_aead_decrypt+0x578>
movl   $0xfffffffe,-0x4(%rbp)
jmp    2039 <crypto_aead_decrypt+0xf09>
mov    -0x30(%rbp),%rcx
sub    $0x10,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
movq   $0x0,-0x170(%rbp)
cmpq   $0xd,-0x170(%rbp)
0d
jae    1703 <crypto_aead_decrypt+0x5d3>
mov    0x18(%rbp),%rax
mov    -0x170(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0xb0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    16c2 <crypto_aead_decrypt+0x592>
movb   $0x80,-0xa3(%rbp)
movq   $0xe,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    1749 <crypto_aead_decrypt+0x619>
mov    -0x170(%rbp),%rax
movb   $0x0,-0xb0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1715 <crypto_aead_decrypt+0x5e5>
lea    -0xb0(%rbp),%rdi
lea    -0x140(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
cmpq   $0x10,-0x30(%rbp)
jne    1858 <crypto_aead_decrypt+0x728>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    17c9 <crypto_aead_decrypt+0x699>
mov    -0x170(%rbp),%rax
movzbl -0x100(%rbp,%rax,1),%eax
ff
mov    -0x170(%rbp),%rcx
movzbl -0x140(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1774 <crypto_aead_decrypt+0x644>
lea    -0x150(%rbp),%rdi
lea    -0x160(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    1853 <crypto_aead_decrypt+0x723>
mov    -0x28(%rbp),%rax
mov    -0x170(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x170(%rbp),%rcx
movzbl -0x160(%rbp,%rcx,1),%ecx
ff
mov    -0x170(%rbp),%rdx
movzbl -0x70(%rbp,%rdx,1),%edx
xor    %edx,%ecx
cmp    %ecx,%eax
je     1837 <crypto_aead_decrypt+0x707>
movl   $0xffffffff,-0x4(%rbp)
jmp    2039 <crypto_aead_decrypt+0xf09>
jmp    183c <crypto_aead_decrypt+0x70c>
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    17e9 <crypto_aead_decrypt+0x6b9>
jmp    2032 <crypto_aead_decrypt+0xf02>
mov    -0x30(%rbp),%rax
shr    $0x4,%rax
sub    $0x1,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x30(%rbp),%rax
and    $0xf,%rax
cmp    $0x0,%rax
je     197e <crypto_aead_decrypt+0x84e>
mov    -0xd8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd8(%rbp)
movq   $0x0,-0x170(%rbp)
mov    -0x170(%rbp),%rax
mov    -0x30(%rbp),%rcx
and    $0xf,%rcx
cmp    %rcx,%rax
jae    1903 <crypto_aead_decrypt+0x7d3>
mov    -0x28(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x170(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0xc0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
movb   $0x0,-0xd0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    189a <crypto_aead_decrypt+0x76a>
mov    -0x30(%rbp),%rax
and    $0xf,%rax
movb   $0x0,-0xc0(%rbp,%rax,1)
mov    -0x30(%rbp),%rax
and    $0xf,%rax
movb   $0x80,-0xd0(%rbp,%rax,1)
80
mov    -0x30(%rbp),%rax
and    $0xf,%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    1979 <crypto_aead_decrypt+0x849>
mov    -0x170(%rbp),%rax
movb   $0x0,-0xc0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
movb   $0x0,-0xd0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1936 <crypto_aead_decrypt+0x806>
jmp    19ed <crypto_aead_decrypt+0x8bd>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    19e8 <crypto_aead_decrypt+0x8b8>
mov    -0x28(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x170(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0xc0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
movb   $0x0,-0xd0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1989 <crypto_aead_decrypt+0x859>
jmp    19ed <crypto_aead_decrypt+0x8bd>
lea    -0x120(%rbp),%rdi
add    $0x20,%rdi
lea    -0x130(%rbp),%rsi
mov    $0x0,%al
call   1040 <Times2@plt>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    1a66 <crypto_aead_decrypt+0x936>
mov    -0x170(%rbp),%rax
movzbl -0x130(%rbp,%rax,1),%eax
ff
mov    -0x170(%rbp),%rcx
movzbl -0x140(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1a11 <crypto_aead_decrypt+0x8e1>
lea    -0x150(%rbp),%rdi
lea    -0x160(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x168(%rbp)
mov    -0x168(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    1bb5 <crypto_aead_decrypt+0xa85>
lea    -0x130(%rbp),%rdi
lea    -0x90(%rbp),%rsi
mov    $0x0,%al
call   1040 <Times2@plt>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    1b89 <crypto_aead_decrypt+0xa59>
mov    -0x170(%rbp),%rax
movzbl -0x160(%rbp,%rax,1),%eax
ff
mov    -0x28(%rbp),%rcx
mov    -0x168(%rbp),%rdx
shl    $0x4,%rdx
add    -0x170(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
movzbl -0x150(%rbp,%rax,1),%eax
ff
mov    -0x170(%rbp),%rcx
movzbl -0x90(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    -0x170(%rbp),%rcx
movzbl -0x140(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x168(%rbp),%rcx
shl    $0x4,%rcx
add    -0x170(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x170(%rbp),%rax
mov    -0x90(%rbp,%rax,1),%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1ac1 <crypto_aead_decrypt+0x991>
lea    -0x150(%rbp),%rdi
lea    -0x160(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
mov    -0x168(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x168(%rbp)
jmp    1a86 <crypto_aead_decrypt+0x956>
mov    -0x30(%rbp),%rax
and    $0xf,%rax
cmp    $0x0,%rax
je     1cc7 <crypto_aead_decrypt+0xb97>
movq   $0x0,-0x170(%rbp)
mov    -0x170(%rbp),%rax
mov    -0x30(%rbp),%rcx
and    $0xf,%rcx
cmp    %rcx,%rax
jae    1c5e <crypto_aead_decrypt+0xb2e>
mov    -0x170(%rbp),%rax
movzbl -0x160(%rbp,%rax,1),%eax
ff
mov    -0x28(%rbp),%rcx
mov    -0xd8(%rbp),%rdx
sub    $0x1,%rdx
shl    $0x4,%rdx
add    -0x170(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x170(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x170(%rbp),%rax
movb   $0x0,-0xf0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1bd2 <crypto_aead_decrypt+0xaa2>
mov    -0x30(%rbp),%rax
and    $0xf,%rax
mov    %rax,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    1cc2 <crypto_aead_decrypt+0xb92>
mov    -0x170(%rbp),%rax
movzbl -0x160(%rbp,%rax,1),%eax
ff
mov    -0x170(%rbp),%rcx
movzbl -0xd0(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0xf0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1c6d <crypto_aead_decrypt+0xb3d>
jmp    1d59 <crypto_aead_decrypt+0xc29>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    1d54 <crypto_aead_decrypt+0xc24>
mov    -0x170(%rbp),%rax
movzbl -0x160(%rbp,%rax,1),%eax
ff
mov    -0x28(%rbp),%rcx
mov    -0xd8(%rbp),%rdx
sub    $0x1,%rdx
shl    $0x4,%rdx
add    -0x170(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x170(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x170(%rbp),%rax
movb   $0x0,-0xf0(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1cd2 <crypto_aead_decrypt+0xba2>
jmp    1d59 <crypto_aead_decrypt+0xc29>
mov    -0x30(%rbp),%rax
and    $0xf,%rax
cmp    $0x0,%rax
je     1f13 <crypto_aead_decrypt+0xde3>
movq   $0x0,-0x170(%rbp)
mov    -0x170(%rbp),%rax
mov    -0x30(%rbp),%rcx
and    $0xf,%rcx
cmp    %rcx,%rax
jae    1df5 <crypto_aead_decrypt+0xcc5>
mov    -0x10(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x170(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x170(%rbp),%rcx
movzbl -0x110(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    -0x170(%rbp),%rcx
movzbl -0x140(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1d76 <crypto_aead_decrypt+0xc46>
mov    -0x30(%rbp),%rax
and    $0xf,%rax
mov    %rax,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    1e6a <crypto_aead_decrypt+0xd3a>
mov    -0x170(%rbp),%rax
movzbl -0xf0(%rbp,%rax,1),%eax
ff
mov    -0x170(%rbp),%rcx
movzbl -0x110(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    -0x170(%rbp),%rcx
movzbl -0x140(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1e04 <crypto_aead_decrypt+0xcd4>
lea    -0x150(%rbp),%rdi
lea    -0x160(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    1f0e <crypto_aead_decrypt+0xdde>
mov    -0x28(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
mov    -0x30(%rbp),%rdx
and    $0xf,%rdx
add    %rdx,%rcx
add    -0x170(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x170(%rbp),%rcx
movzbl -0x160(%rbp,%rcx,1),%ecx
ff
mov    -0x170(%rbp),%rdx
movzbl -0x70(%rbp,%rdx,1),%edx
xor    %edx,%ecx
cmp    %ecx,%eax
je     1ef2 <crypto_aead_decrypt+0xdc2>
movl   $0xffffffff,-0x4(%rbp)
jmp    2039 <crypto_aead_decrypt+0xf09>
jmp    1ef7 <crypto_aead_decrypt+0xdc7>
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1e8a <crypto_aead_decrypt+0xd5a>
jmp    202d <crypto_aead_decrypt+0xefd>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    1f93 <crypto_aead_decrypt+0xe63>
mov    -0x10(%rbp),%rax
mov    -0xd8(%rbp),%rcx
sub    $0x1,%rcx
shl    $0x4,%rcx
add    -0x170(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x170(%rbp),%rcx
movzbl -0x100(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    -0x170(%rbp),%rcx
movzbl -0x140(%rbp,%rcx,1),%ecx
ff
xor    %ecx,%eax
mov    %al,%cl
mov    -0x170(%rbp),%rax
mov    %cl,-0x150(%rbp,%rax,1)
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1f1e <crypto_aead_decrypt+0xdee>
lea    -0x150(%rbp),%rdi
lea    -0x160(%rbp),%rsi
mov    $0x0,%al
call   1030 <AES128Enc@plt>
movq   $0x0,-0x170(%rbp)
cmpq   $0x10,-0x170(%rbp)
10
jae    2028 <crypto_aead_decrypt+0xef8>
mov    -0x28(%rbp),%rax
mov    -0xd8(%rbp),%rcx
shl    $0x4,%rcx
add    -0x170(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x170(%rbp),%rcx
movzbl -0x160(%rbp,%rcx,1),%ecx
ff
mov    -0x170(%rbp),%rdx
movzbl -0x70(%rbp,%rdx,1),%edx
xor    %edx,%ecx
cmp    %ecx,%eax
je     200c <crypto_aead_decrypt+0xedc>
movl   $0xffffffff,-0x4(%rbp)
jmp    2039 <crypto_aead_decrypt+0xf09>
jmp    2011 <crypto_aead_decrypt+0xee1>
mov    -0x170(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x170(%rbp)
jmp    1fb3 <crypto_aead_decrypt+0xe83>
jmp    202d <crypto_aead_decrypt+0xefd>
jmp    2032 <crypto_aead_decrypt+0xf02>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<crypto_aead_decrypt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r9,%r13
mov    %r8,%r15
mov    %rcx,0x38(%rsp)
mov    %rsi,%r12
mov    %rdi,0xd8(%rsp)
mov    0x1d0(%rsp),%rbp
mov    0x1e0(%rsp),%rax
movups (%rax),%xmm0
movaps %xmm0,0x180(%rsp)
lea    0x180(%rsp),%rdi
mov    $0xa,%esi
xor    %eax,%eax
call   1070 <keyschedule@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,0x10(%rsp)
lea    0x10(%rsp),%rdi
lea    0x90(%rsp),%rbx
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
lea    0xa0(%rsp),%r14
mov    %rbx,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <Times2@plt>
lea    0xb0(%rsp),%rbx
mov    %r14,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <Times2@plt>
lea    0xf0(%rsp),%rsi
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <Times2@plt>
test   %rbp,%rbp
je     13d8 <crypto_aead_decrypt+0x288>
mov    %r12,0x170(%rsp)
mov    %r15,0x118(%rsp)
xor    %ecx,%ecx
mov    %rbp,%rax
and    $0xf,%rax
mov    %rax,0x168(%rsp)
setne  %cl
shr    $0x4,%rbp
add    %rbp,%rcx
mov    %rcx,0x160(%rsp)
mov    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %r13,0x138(%rsp)
mov    %rax,0x158(%rsp)
je     13e5 <crypto_aead_decrypt+0x295>
mov    %rax,%rcx
mov    %r13,%rbx
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,0x60(%rsp)
movl   $0x0,0x64(%rsp)
movl   $0x0,0x68(%rsp)
movl   $0x0,0x88(%rsp)
xor    %r14d,%r14d
xor    %r15d,%r15d
xor    %r12d,%r12d
xor    %r13d,%r13d
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    %rcx,0x178(%rsp)
movups (%rbx),%xmm0
xorps  0xf0(%rsp),%xmm0
movaps %xmm0,0x10(%rsp)
lea    0x10(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
mov    0x44(%rsp),%eax
xor    (%rsp),%al
mov    %eax,0x44(%rsp)
mov    0x48(%rsp),%eax
xor    0x1(%rsp),%al
mov    %eax,0x48(%rsp)
mov    0x4c(%rsp),%eax
xor    0x2(%rsp),%al
mov    %eax,0x4c(%rsp)
mov    0x50(%rsp),%eax
xor    0x3(%rsp),%al
mov    %eax,0x50(%rsp)
mov    0x54(%rsp),%eax
xor    0x4(%rsp),%al
mov    %eax,0x54(%rsp)
mov    0x58(%rsp),%eax
xor    0x5(%rsp),%al
mov    %eax,0x58(%rsp)
mov    0x5c(%rsp),%eax
xor    0x6(%rsp),%al
mov    %eax,0x5c(%rsp)
mov    0x60(%rsp),%eax
xor    0x7(%rsp),%al
mov    %eax,0x60(%rsp)
mov    0x64(%rsp),%eax
xor    0x8(%rsp),%al
mov    %eax,0x64(%rsp)
mov    0x68(%rsp),%eax
xor    0x9(%rsp),%al
mov    %eax,0x68(%rsp)
mov    0x88(%rsp),%eax
xor    0xa(%rsp),%al
mov    %eax,0x88(%rsp)
xor    0xb(%rsp),%r14b
xor    0xc(%rsp),%r15b
xor    0xd(%rsp),%r12b
xor    0xe(%rsp),%r13b
xor    0xf(%rsp),%bpl
lea    0xf0(%rsp),%rdi
lea    0x120(%rsp),%rsi
xor    %eax,%eax
call   1060 <Times2@plt>
mov    0x178(%rsp),%rcx
movaps 0x120(%rsp),%xmm0
movaps %xmm0,0xf0(%rsp)
add    $0x10,%rbx
add    $0xffffffffffffffff,%rcx
jne    12d0 <crypto_aead_decrypt+0x180>
jmp    144e <crypto_aead_decrypt+0x2fe>
xorps  %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
jmp    174c <crypto_aead_decrypt+0x5fc>
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,0x60(%rsp)
movl   $0x0,0x64(%rsp)
movl   $0x0,0x68(%rsp)
movl   $0x0,0x88(%rsp)
xor    %r14d,%r14d
xor    %r15d,%r15d
xor    %r12d,%r12d
xor    %r13d,%r13d
xor    %ebp,%ebp
mov    %ebp,%ebx
mov    0x168(%rsp),%rbp
test   %rbp,%rbp
je     15de <crypto_aead_decrypt+0x48e>
mov    0x160(%rsp),%rcx
shl    $0x4,%rcx
mov    0x138(%rsp),%rax
lea    (%rcx,%rax,1),%rsi
add    $0xfffffffffffffff0,%rsi
lea    0x70(%rsp),%rdi
mov    %rbp,%rdx
call   1040 <memcpy@plt>
movb   $0x80,0x70(%rsp,%rbp,1)
cmp    $0xf,%rbp
mov    %rbp,%rdx
mov    0x88(%rsp),%ebp
je     14b7 <crypto_aead_decrypt+0x367>
lea    0x70(%rsp),%rax
lea    (%rdx,%rax,1),%rdi
add    $0x1,%rdi
xor    $0xf,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x44(%rsp),%eax
xor    0x70(%rsp),%al
xor    0xa0(%rsp),%al
mov    %al,0x10(%rsp)
mov    0x48(%rsp),%ecx
xor    0x71(%rsp),%cl
xor    0xa1(%rsp),%cl
mov    0x4c(%rsp),%eax
xor    0x72(%rsp),%al
xor    0xa2(%rsp),%al
mov    %cl,0x11(%rsp)
mov    %al,0x12(%rsp)
mov    0x50(%rsp),%ecx
xor    0x73(%rsp),%cl
xor    0xa3(%rsp),%cl
mov    0x54(%rsp),%eax
xor    0x74(%rsp),%al
mov    %cl,0x13(%rsp)
xor    0xa4(%rsp),%al
mov    %al,0x14(%rsp)
mov    0x58(%rsp),%ecx
xor    0x75(%rsp),%cl
xor    0xa5(%rsp),%cl
mov    0x5c(%rsp),%eax
xor    0x76(%rsp),%al
xor    0xa6(%rsp),%al
mov    %cl,0x15(%rsp)
mov    %al,0x16(%rsp)
mov    0x60(%rsp),%ecx
xor    0x77(%rsp),%cl
xor    0xa7(%rsp),%cl
mov    0x64(%rsp),%eax
xor    0x78(%rsp),%al
mov    %cl,0x17(%rsp)
xor    0xa8(%rsp),%al
mov    %al,0x18(%rsp)
mov    0x68(%rsp),%eax
xor    0x79(%rsp),%al
xor    0xa9(%rsp),%al
xor    0x7a(%rsp),%bpl
xor    0xaa(%rsp),%bpl
mov    %al,0x19(%rsp)
mov    %bpl,0x1a(%rsp)
xor    0x7b(%rsp),%r14b
xor    0xab(%rsp),%r14b
xor    0x7c(%rsp),%r15b
mov    %r14b,0x1b(%rsp)
xor    0xac(%rsp),%r15b
mov    %r15b,0x1c(%rsp)
xor    0x7d(%rsp),%r12b
xor    0xad(%rsp),%r12b
xor    0x7e(%rsp),%r13b
xor    0xae(%rsp),%r13b
mov    %r12b,0x1d(%rsp)
mov    %r13b,0x1e(%rsp)
mov    $0x1,%eax
lea    0x7f(%rsp),%rcx
jmp    171a <crypto_aead_decrypt+0x5ca>
mov    0x158(%rsp),%rdx
shl    $0x4,%rdx
mov    0x138(%rsp),%rax
mov    0x44(%rsp),%ecx
xor    (%rax,%rdx,1),%cl
xor    0xb0(%rsp),%cl
mov    %cl,0x10(%rsp)
mov    0x48(%rsp),%ecx
xor    0x1(%rax,%rdx,1),%cl
xor    0xb1(%rsp),%cl
mov    %cl,0x11(%rsp)
mov    0x4c(%rsp),%ecx
xor    0x2(%rax,%rdx,1),%cl
xor    0xb2(%rsp),%cl
mov    %cl,0x12(%rsp)
mov    0x50(%rsp),%ecx
xor    0x3(%rax,%rdx,1),%cl
xor    0xb3(%rsp),%cl
mov    %cl,0x13(%rsp)
mov    0x54(%rsp),%ecx
xor    0x4(%rax,%rdx,1),%cl
xor    0xb4(%rsp),%cl
mov    %cl,0x14(%rsp)
mov    0x58(%rsp),%ecx
xor    0x5(%rax,%rdx,1),%cl
xor    0xb5(%rsp),%cl
mov    %cl,0x15(%rsp)
mov    0x5c(%rsp),%ecx
xor    0x6(%rax,%rdx,1),%cl
xor    0xb6(%rsp),%cl
mov    %cl,0x16(%rsp)
mov    0x60(%rsp),%ecx
xor    0x7(%rax,%rdx,1),%cl
xor    0xb7(%rsp),%cl
mov    %cl,0x17(%rsp)
mov    0x64(%rsp),%ecx
xor    0x8(%rax,%rdx,1),%cl
xor    0xb8(%rsp),%cl
mov    %cl,0x18(%rsp)
mov    0x68(%rsp),%ecx
xor    0x9(%rax,%rdx,1),%cl
xor    0xb9(%rsp),%cl
mov    %cl,0x19(%rsp)
mov    0x88(%rsp),%ecx
xor    0xa(%rax,%rdx,1),%cl
xor    0xba(%rsp),%cl
mov    %cl,0x1a(%rsp)
xor    0xb(%rax,%rdx,1),%r14b
xor    0xbb(%rsp),%r14b
mov    %r14b,0x1b(%rsp)
xor    0xc(%rax,%rdx,1),%r15b
xor    0xbc(%rsp),%r15b
mov    %r15b,0x1c(%rsp)
xor    0xd(%rax,%rdx,1),%r12b
xor    0xbd(%rsp),%r12b
mov    %r12b,0x1d(%rsp)
xor    0xe(%rax,%rdx,1),%r13b
xor    0xbe(%rsp),%r13b
mov    %r13b,0x1e(%rsp)
lea    (%rax,%rdx,1),%rcx
add    $0xf,%rcx
mov    $0x2,%eax
xor    (%rcx),%bl
shl    $0x4,%rax
xor    0x9f(%rsp,%rax,1),%bl
mov    %bl,0x1f(%rsp)
lea    0x10(%rsp),%rdi
lea    0x20(%rsp),%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
mov    0x118(%rsp),%r15
mov    0x170(%rsp),%r12
mov    $0xfffffffe,%eax
cmp    $0x10,%r15
jb     216b <crypto_aead_decrypt+0x101b>
mov    0x1d8(%rsp),%rax
lea    -0x10(%r15),%rcx
mov    %rcx,(%r12)
mov    (%rax),%rcx
mov    0x5(%rax),%rax
mov    %rax,0x145(%rsp)
mov    %rcx,0x140(%rsp)
movb   $0x80,0x14d(%rsp)
80
movw   $0x0,0x14e(%rsp)
lea    0x140(%rsp),%rdi
lea    0xc0(%rsp),%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
cmp    $0x10,%r15
jne    18f4 <crypto_aead_decrypt+0x7a4>
movaps 0xc0(%rsp),%xmm0
xorps  0xb0(%rsp),%xmm0
movaps %xmm0,0x10(%rsp)
lea    0x10(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
mov    0x20(%rsp),%cl
xor    (%rsp),%cl
mov    $0xffffffff,%eax
mov    0x38(%rsp),%rdx
cmp    %cl,(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x21(%rsp),%cl
xor    0x1(%rsp),%cl
cmp    %cl,0x1(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x22(%rsp),%cl
xor    0x2(%rsp),%cl
cmp    %cl,0x2(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x23(%rsp),%cl
xor    0x3(%rsp),%cl
cmp    %cl,0x3(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x24(%rsp),%cl
xor    0x4(%rsp),%cl
cmp    %cl,0x4(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x25(%rsp),%cl
xor    0x5(%rsp),%cl
cmp    %cl,0x5(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x26(%rsp),%cl
xor    0x6(%rsp),%cl
cmp    %cl,0x6(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x27(%rsp),%cl
xor    0x7(%rsp),%cl
cmp    %cl,0x7(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x28(%rsp),%cl
xor    0x8(%rsp),%cl
cmp    %cl,0x8(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x29(%rsp),%cl
xor    0x9(%rsp),%cl
cmp    %cl,0x9(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x2a(%rsp),%cl
xor    0xa(%rsp),%cl
cmp    %cl,0xa(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x2b(%rsp),%cl
xor    0xb(%rsp),%cl
cmp    %cl,0xb(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x2c(%rsp),%cl
xor    0xc(%rsp),%cl
cmp    %cl,0xc(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x2d(%rsp),%cl
xor    0xd(%rsp),%cl
mov    0x38(%rsp),%rdx
cmp    %cl,0xd(%rdx)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x2e(%rsp),%cl
xor    0xe(%rsp),%cl
mov    $0xf,%esi
mov    0x38(%rsp),%rdx
cmp    %cl,0xe(%rdx)
je     2154 <crypto_aead_decrypt+0x1004>
jmp    216b <crypto_aead_decrypt+0x101b>
mov    %r15,%rbp
shr    $0x4,%rbp
lea    -0x1(%rbp),%r14
mov    %r15,%rbx
and    $0xf,%rbx
mov    %r15,0x118(%rsp)
mov    %rbx,0x88(%rsp)
je     1958 <crypto_aead_decrypt+0x808>
lea    0x100(%rsp),%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1030 <memset@plt>
movb   $0x80,0x100(%rsp,%rbx,1)
80
cmp    $0xf,%rbx
je     1951 <crypto_aead_decrypt+0x801>
lea    (%rbx,%r12,1),%rdi
add    $0x1,%rdi
xor    $0xf,%rbx
xor    %esi,%esi
mov    %rbx,%rdx
call   1030 <memset@plt>
mov    %rbp,0x68(%rsp)
jmp    196f <crypto_aead_decrypt+0x81f>
mov    %r14,0x68(%rsp)
xorps  %xmm0,%xmm0
movaps %xmm0,0x100(%rsp)
add    $0xfffffffffffffffe,%rbp
mov    %rbp,%r14
lea    0xf0(%rsp),%rsi
lea    0xb0(%rsp),%rdi
xor    %eax,%eax
call   1060 <Times2@plt>
movaps 0xc0(%rsp),%xmm0
xorps  0xf0(%rsp),%xmm0
movaps %xmm0,0x10(%rsp)
lea    0x10(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
test   %r14,%r14
je     1adf <crypto_aead_decrypt+0x98f>
mov    0xd8(%rsp),%rax
lea    0x1(%rax),%r13
mov    0x38(%rsp),%rax
lea    0x1(%rax),%r12
mov    %rsp,%rbp
xor    %r15d,%r15d
jmp    1a1a <crypto_aead_decrypt+0x8ca>
movups (%rdx,%r14,1),%xmm0
xorps  (%rsp),%xmm0
movaps %xmm0,0x10(%rsp)
xorps  0x120(%rsp),%xmm0
xorps  0xc0(%rsp),%xmm0
movups %xmm0,(%rsi,%r14,1)
lea    0x10(%rsp),%rdi
mov    %rbp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
add    $0x1,%r15
add    $0x10,%r13
add    $0x10,%r12
mov    %rbx,%r14
cmp    %rbx,%r15
je     1adf <crypto_aead_decrypt+0x98f>
mov    %r14,%rbx
mov    %r15,%r14
shl    $0x4,%r14
lea    0xf0(%rsp),%rdi
lea    0x120(%rsp),%rsi
xor    %eax,%eax
call   1060 <Times2@plt>
movaps 0x120(%rsp),%xmm0
movaps %xmm0,0xf0(%rsp)
mov    0x38(%rsp),%rdx
lea    (%rdx,%r14,1),%rax
add    $0x10,%rax
mov    0xd8(%rsp),%rsi
lea    (%rsi,%r14,1),%rcx
cmp    %rax,%rcx
jae    19d0 <crypto_aead_decrypt+0x880>
lea    (%rdx,%r14,1),%rax
lea    (%rsi,%r14,1),%rcx
add    $0x10,%rcx
cmp    %rcx,%rax
jae    19d0 <crypto_aead_decrypt+0x880>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x1(%r12,%rax,1),%ecx
xor    (%rsp,%rax,1),%cl
mov    %cl,0x10(%rsp,%rax,1)
xor    0x120(%rsp,%rax,1),%cl
xor    0xc0(%rsp,%rax,1),%cl
mov    %cl,-0x1(%r13,%rax,1)
movzbl (%r12,%rax,1),%ecx
xor    0x1(%rsp,%rax,1),%cl
mov    %cl,0x11(%rsp,%rax,1)
xor    0x121(%rsp,%rax,1),%cl
xor    0xc1(%rsp,%rax,1),%cl
mov    %cl,0x0(%r13,%rax,1)
add    $0x2,%rax
cmp    $0x10,%rax
jne    1a90 <crypto_aead_decrypt+0x940>
jmp    19f3 <crypto_aead_decrypt+0x8a3>
shl    $0x4,%r14
mov    0x88(%rsp),%r15
test   %r15,%r15
je     1e7e <crypto_aead_decrypt+0xd2e>
lea    0xe0(%rsp),%rdi
xor    %ebx,%ebx
xor    %esi,%esi
mov    %r15,%rdx
call   1030 <memset@plt>
mov    0x118(%rsp),%r10
mov    %r10d,%eax
and    $0x1,%eax
mov    %r15,%r8
add    $0xffffffffffffffff,%r8
je     217d <crypto_aead_decrypt+0x102d>
mov    %r15,%rcx
sub    %rax,%rcx
mov    0xd8(%rsp),%r9
lea    (%r9,%r14,1),%rsi
add    $0x1,%rsi
mov    0x38(%rsp),%rbp
lea    (%r14,%rbp,1),%rdi
add    $0x1,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%rdi,%rbx,1),%edx
xor    (%rsp,%rbx,1),%dl
mov    %dl,-0x1(%rsi,%rbx,1)
movzbl (%rdi,%rbx,1),%edx
xor    0x1(%rsp,%rbx,1),%dl
mov    %dl,(%rsi,%rbx,1)
add    $0x2,%rbx
cmp    %rbx,%rcx
jne    1b50 <crypto_aead_decrypt+0xa00>
test   %rax,%rax
je     1b84 <crypto_aead_decrypt+0xa34>
lea    (%rbx,%r14,1),%rax
mov    0x0(%rbp,%rax,1),%cl
xor    (%rsp,%rbx,1),%cl
mov    %cl,(%r9,%rax,1)
mov    $0x10,%ecx
sub    %r15,%rcx
mov    %r15,%rbp
xor    $0xf,%rbp
mov    %rcx,%rdi
mov    %r15,%rsi
and    $0x3,%rdi
je     1bcc <crypto_aead_decrypt+0xa7c>
mov    %r15,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x100(%rsp,%rsi,1),%edx
xor    (%rsp,%rsi,1),%dl
mov    %dl,0xe0(%rsp,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    1bb0 <crypto_aead_decrypt+0xa60>
cmp    $0x3,%rbp
jb     1c35 <crypto_aead_decrypt+0xae5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl 0x100(%rsp,%rsi,1),%edx
movzbl 0x101(%rsp,%rsi,1),%ebx
xor    (%rsp,%rsi,1),%dl
xor    0x1(%rsp,%rsi,1),%bl
mov    %dl,0xe0(%rsp,%rsi,1)
movzbl 0x102(%rsp,%rsi,1),%edx
xor    0x2(%rsp,%rsi,1),%dl
mov    %bl,0xe1(%rsp,%rsi,1)
movzbl 0x103(%rsp,%rsi,1),%ebx
xor    0x3(%rsp,%rsi,1),%bl
mov    %dl,0xe2(%rsp,%rsi,1)
mov    %bl,0xe3(%rsp,%rsi,1)
add    $0x4,%rsi
cmp    $0x10,%rsi
jne    1be0 <crypto_aead_decrypt+0xa90>
test   %r15,%r15
je     1faf <crypto_aead_decrypt+0xe5f>
and    $0x1,%r10d
test   %r8,%r8
je     2198 <crypto_aead_decrypt+0x1048>
mov    %r15,%rsi
sub    %r10,%rsi
lea    (%r14,%r9,1),%rdi
add    $0x1,%rdi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movzbl 0xa0(%rsp,%rdx,1),%ebx
xor    -0x1(%rdi,%rdx,1),%bl
movzbl 0xa1(%rsp,%rdx,1),%eax
xor    0xc0(%rsp,%rdx,1),%bl
mov    %bl,0x10(%rsp,%rdx,1)
xor    (%rdi,%rdx,1),%al
xor    0xc1(%rsp,%rdx,1),%al
mov    %al,0x11(%rsp,%rdx,1)
add    $0x2,%rdx
cmp    %rdx,%rsi
jne    1c60 <crypto_aead_decrypt+0xb10>
test   %r10,%r10
je     1cb5 <crypto_aead_decrypt+0xb65>
lea    (%rdx,%r14,1),%rax
mov    0xa0(%rsp,%rdx,1),%bl
xor    (%r9,%rax,1),%bl
xor    0xc0(%rsp,%rdx,1),%bl
mov    %bl,0x10(%rsp,%rdx,1)
mov    %r15,%rdx
test   $0x1,%cl
je     1cde <crypto_aead_decrypt+0xb8e>
mov    0xa0(%rsp,%r15,1),%al
xor    0xe0(%rsp,%r15,1),%al
xor    0xc0(%rsp,%r15,1),%al
mov    %al,0x10(%rsp,%r15,1)
lea    0x1(%r15),%rdx
test   %rbp,%rbp
je     1d2e <crypto_aead_decrypt+0xbde>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0xa0(%rsp,%rdx,1),%eax
movzbl 0xa1(%rsp,%rdx,1),%ecx
xor    0xe0(%rsp,%rdx,1),%al
xor    0xc0(%rsp,%rdx,1),%al
xor    0xe1(%rsp,%rdx,1),%cl
xor    0xc1(%rsp,%rdx,1),%cl
mov    %al,0x10(%rsp,%rdx,1)
mov    %cl,0x11(%rsp,%rdx,1)
add    $0x2,%rdx
cmp    $0x10,%rdx
jne    1cf0 <crypto_aead_decrypt+0xba0>
lea    0x10(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
mov    0x20(%rsp),%cl
xor    (%rsp),%cl
or     %r15,%r14
mov    $0xffffffff,%eax
mov    0x38(%rsp),%rdx
cmp    %cl,(%rdx,%r14,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x21(%rsp),%cl
xor    0x1(%rsp),%cl
cmp    %cl,0x1(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x22(%rsp),%cl
xor    0x2(%rsp),%cl
cmp    %cl,0x2(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x23(%rsp),%cl
xor    0x3(%rsp),%cl
cmp    %cl,0x3(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x24(%rsp),%cl
xor    0x4(%rsp),%cl
cmp    %cl,0x4(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x25(%rsp),%cl
xor    0x5(%rsp),%cl
cmp    %cl,0x5(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x26(%rsp),%cl
xor    0x6(%rsp),%cl
cmp    %cl,0x6(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x27(%rsp),%cl
xor    0x7(%rsp),%cl
cmp    %cl,0x7(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x28(%rsp),%cl
xor    0x8(%rsp),%cl
cmp    %cl,0x8(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x29(%rsp),%cl
xor    0x9(%rsp),%cl
cmp    %cl,0x9(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x2a(%rsp),%cl
xor    0xa(%rsp),%cl
cmp    %cl,0xa(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x2b(%rsp),%cl
xor    0xb(%rsp),%cl
cmp    %cl,0xb(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %r14,%rsi
mov    0x2c(%rsp),%cl
xor    0xc(%rsp),%cl
mov    0x38(%rsp),%rdx
cmp    %cl,0xc(%r14,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x2d(%rsp),%cl
xor    0xd(%rsp),%cl
mov    0x38(%rsp),%rdx
cmp    %cl,0xd(%rsi,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    0x2e(%rsp),%cl
xor    0xe(%rsp),%cl
mov    0x38(%rsp),%rdx
cmp    %cl,0xe(%rsi,%rdx,1)
jne    216b <crypto_aead_decrypt+0x101b>
add    $0xf,%rsi
jmp    2154 <crypto_aead_decrypt+0x1004>
xorps  %xmm0,%xmm0
movaps %xmm0,0xe0(%rsp)
mov    0x38(%rsp),%rdx
mov    (%rdx,%r14,1),%al
xor    (%rsp),%al
mov    0xd8(%rsp),%r9
mov    %al,(%r9,%r14,1)
mov    %r14,%rax
or     $0x1,%rax
mov    (%rdx,%rax,1),%cl
xor    0x1(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0x2,%rax
mov    (%rdx,%rax,1),%cl
xor    0x2(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0x3,%rax
mov    (%rdx,%rax,1),%cl
xor    0x3(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0x4,%rax
mov    (%rdx,%rax,1),%cl
xor    0x4(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0x5,%rax
mov    (%rdx,%rax,1),%cl
xor    0x5(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0x6,%rax
mov    (%rdx,%rax,1),%cl
xor    0x6(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0x7,%rax
mov    (%rdx,%rax,1),%cl
xor    0x7(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0x8,%rax
mov    (%rdx,%rax,1),%cl
xor    0x8(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0x9,%rax
mov    (%rdx,%rax,1),%cl
xor    0x9(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0xa,%rax
mov    (%rdx,%rax,1),%cl
xor    0xa(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0xb,%rax
mov    (%rdx,%rax,1),%cl
xor    0xb(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0xc,%rax
mov    (%rdx,%rax,1),%cl
xor    0xc(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0xd,%rax
mov    (%rdx,%rax,1),%cl
xor    0xd(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0xe,%rax
mov    (%rdx,%rax,1),%cl
xor    0xe(%rsp),%cl
mov    %cl,(%r9,%rax,1)
mov    %r14,%rax
or     $0xf,%rax
mov    (%rdx,%rax,1),%cl
xor    0xf(%rsp),%cl
mov    %cl,(%r9,%rax,1)
movups (%r9,%r14,1),%xmm0
xorps  0xb0(%rsp),%xmm0
xorps  0xc0(%rsp),%xmm0
movaps %xmm0,0x10(%rsp)
lea    0x10(%rsp),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1050 <AES128Enc@plt>
mov    0x38(%rsp),%rsi
mov    0x20(%rsp),%cl
xor    (%rsp),%cl
mov    0x68(%rsp),%rdi
shl    $0x4,%rdi
mov    $0xffffffff,%eax
cmp    %cl,(%rsi,%rdi,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0x1,%rcx
mov    0x21(%rsp),%dl
xor    0x1(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0x2,%rcx
mov    0x22(%rsp),%dl
xor    0x2(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0x3,%rcx
mov    0x23(%rsp),%dl
xor    0x3(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0x4,%rcx
mov    0x24(%rsp),%dl
xor    0x4(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0x5,%rcx
mov    0x25(%rsp),%dl
xor    0x5(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0x6,%rcx
mov    0x26(%rsp),%dl
xor    0x6(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0x7,%rcx
mov    0x27(%rsp),%dl
xor    0x7(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0x8,%rcx
mov    0x28(%rsp),%dl
xor    0x8(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0x9,%rcx
mov    0x29(%rsp),%dl
xor    0x9(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0xa,%rcx
mov    0x2a(%rsp),%dl
xor    0xa(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rcx
or     $0xb,%rcx
mov    0x2b(%rsp),%dl
xor    0xb(%rsp),%dl
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rdi,%rbp
mov    %rdi,%rcx
or     $0xc,%rcx
mov    0x2c(%rsp),%dl
xor    0xc(%rsp),%dl
mov    0x38(%rsp),%rsi
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rbp,%rcx
or     $0xd,%rcx
mov    0x2d(%rsp),%dl
xor    0xd(%rsp),%dl
mov    0x38(%rsp),%rsi
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rbp,%rcx
or     $0xe,%rcx
mov    0x2e(%rsp),%dl
xor    0xe(%rsp),%dl
mov    0x38(%rsp),%rsi
cmp    %dl,(%rsi,%rcx,1)
jne    216b <crypto_aead_decrypt+0x101b>
mov    %rbp,%rsi
or     $0xf,%rsi
mov    0x2f(%rsp),%cl
xor    0xf(%rsp),%cl
xor    %eax,%eax
mov    0x38(%rsp),%rdx
cmp    %cl,(%rdx,%rsi,1)
setne  %al
neg    %eax
add    $0x198,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x38(%rsp),%rbp
mov    0xd8(%rsp),%r9
test   %rax,%rax
jne    1b75 <crypto_aead_decrypt+0xa25>
jmp    1b84 <crypto_aead_decrypt+0xa34>
xor    %edx,%edx
test   %r10,%r10
jne    1c9b <crypto_aead_decrypt+0xb4b>
jmp    1cb5 <crypto_aead_decrypt+0xb65>

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

LLVM IR (-O2):
define i32 @crypto_aead_decrypt(i8* nocapture %0, i64* nocapture writeonly %1, i8* nocapture readnone %2, i8* nocapture %3, i64 %4, i8* nocapture %5, i64 %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 [3 x [16 x i8]]
%24 = alloca <16 x i8>
%25 = getelementptr inbounds <16 x i8>, <16 x i8>* %24, i64 0, i64 0
%26 = alloca <16 x i8>
%27 = alloca <16 x i8>
%28 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 0
%29 = alloca <16 x i8>
%30 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%31 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 0
%32 = getelementptr inbounds [16 x i8], [16 x i8]* %13, i64 0, i64 0
%33 = getelementptr inbounds <16 x i8>, <16 x i8>* %15, i64 0, i64 0
%34 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 0
%35 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 0
%36 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 0
%37 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 0, i64 0
%38 = getelementptr inbounds <16 x i8>, <16 x i8>* %24, i64 0, i64 0
%39 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 0
%40 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 0
%41 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 0
%42 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @keyschedule to i32 (i8*, i32, ...)*)(i8* %32, i32 10)
%43 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %40, i8* %37)
%44 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 0
%45 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %37, i8* %44)
%46 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 0
%47 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %44, i8* %46)
%48 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %46, i8* %38)
%49 = icmp eq i64 %6, 0
br i1 %49, label %50, label %52
50: ; preds = %9
%51 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 0
br label %400
52: ; preds = %9
%53 = and i64 %6, 15
%54 = icmp eq i64 %53, 0
%55 = xor i1 %54, true
%56 = lshr i64 %6, 4
%57 = zext i1 %55 to i64
%58 = add nsw i64 %56, -1
%59 = add nsw i64 %58, %57
%60 = icmp eq i64 %59, 0
br i1 %60, label %137, label %61
61: ; preds = %52
%62 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 1
%63 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 2
%64 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 3
%65 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 4
%66 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 5
%67 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 6
%68 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 7
%69 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 8
%70 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 9
%71 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 10
%72 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 11
%73 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 12
%74 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 13
%75 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 14
%76 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 15
br label %77
77: ; preds = %61, %77
%78 = phi i8 [ 0, %61 ], [ %103, %77 ]
%79 = phi i8 [ 0, %61 ], [ %105, %77 ]
%80 = phi i8 [ 0, %61 ], [ %107, %77 ]
%81 = phi i8 [ 0, %61 ], [ %109, %77 ]
%82 = phi i8 [ 0, %61 ], [ %111, %77 ]
%83 = phi i8 [ 0, %61 ], [ %113, %77 ]
%84 = phi i8 [ 0, %61 ], [ %115, %77 ]
%85 = phi i8 [ 0, %61 ], [ %117, %77 ]
%86 = phi i8 [ 0, %61 ], [ %119, %77 ]
%87 = phi i8 [ 0, %61 ], [ %121, %77 ]
%88 = phi i8 [ 0, %61 ], [ %123, %77 ]
%89 = phi i8 [ 0, %61 ], [ %125, %77 ]
%90 = phi i8 [ 0, %61 ], [ %127, %77 ]
%91 = phi i8 [ 0, %61 ], [ %129, %77 ]
%92 = phi i8 [ 0, %61 ], [ %131, %77 ]
%93 = phi i8 [ 0, %61 ], [ %133, %77 ]
%94 = phi i64 [ 0, %61 ], [ %135, %77 ]
%95 = shl i64 %94, 4
%96 = getelementptr inbounds i8, i8* %5, i64 %95
%97 = bitcast i8* %96 to <16 x i8>*
%98 = load <16 x i8>, <16 x i8>* %97
%99 = load <16 x i8>, <16 x i8>* %24
%100 = xor <16 x i8> %99, %98
store <16 x i8> %100, <16 x i8>* %27
%101 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %40, i8* %41)
%102 = load i8, i8* %41
%103 = xor i8 %102, %78
%104 = load i8, i8* %62
%105 = xor i8 %104, %79
%106 = load i8, i8* %63
%107 = xor i8 %106, %80
%108 = load i8, i8* %64
%109 = xor i8 %108, %81
%110 = load i8, i8* %65
%111 = xor i8 %110, %82
%112 = load i8, i8* %66
%113 = xor i8 %112, %83
%114 = load i8, i8* %67
%115 = xor i8 %114, %84
%116 = load i8, i8* %68
%117 = xor i8 %116, %85
%118 = load i8, i8* %69
%119 = xor i8 %118, %86
%120 = load i8, i8* %70
%121 = xor i8 %120, %87
%122 = load i8, i8* %71
%123 = xor i8 %122, %88
%124 = load i8, i8* %72
%125 = xor i8 %124, %89
%126 = load i8, i8* %73
%127 = xor i8 %126, %90
%128 = load i8, i8* %74
%129 = xor i8 %128, %91
%130 = load i8, i8* %75
%131 = xor i8 %130, %92
%132 = load i8, i8* %76
%133 = xor i8 %132, %93
%134 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %38, i8* %33)
%135 = add nuw i64 %94, 1
%136 = icmp eq i64 %135, %59
br i1 %136, label %137, label %77
137: ; preds = %77, %52
%138 = phi i8 [ 0, %52 ], [ %103, %77 ]
%139 = phi i8 [ 0, %52 ], [ %105, %77 ]
%140 = phi i8 [ 0, %52 ], [ %107, %77 ]
%141 = phi i8 [ 0, %52 ], [ %109, %77 ]
%142 = phi i8 [ 0, %52 ], [ %111, %77 ]
%143 = phi i8 [ 0, %52 ], [ %113, %77 ]
%144 = phi i8 [ 0, %52 ], [ %115, %77 ]
%145 = phi i8 [ 0, %52 ], [ %117, %77 ]
%146 = phi i8 [ 0, %52 ], [ %119, %77 ]
%147 = phi i8 [ 0, %52 ], [ %121, %77 ]
%148 = phi i8 [ 0, %52 ], [ %123, %77 ]
%149 = phi i8 [ 0, %52 ], [ %125, %77 ]
%150 = phi i8 [ 0, %52 ], [ %127, %77 ]
%151 = phi i8 [ 0, %52 ], [ %129, %77 ]
%152 = phi i8 [ 0, %52 ], [ %131, %77 ]
%153 = phi i8 [ 0, %52 ], [ %133, %77 ]
br i1 %54, label %154, label %275
154: ; preds = %137
%155 = shl i64 %59, 4
%156 = getelementptr inbounds i8, i8* %5, i64 %155
%157 = load i8, i8* %156
%158 = xor i8 %157, %138
%159 = load i8, i8* %46
%160 = xor i8 %158, %159
store i8 %160, i8* %40
%161 = or i64 %155, 1
%162 = getelementptr inbounds i8, i8* %5, i64 %161
%163 = load i8, i8* %162
%164 = xor i8 %163, %139
%165 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 1
%166 = load i8, i8* %165
%167 = xor i8 %164, %166
%168 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 1
store i8 %167, i8* %168
%169 = or i64 %155, 2
%170 = getelementptr inbounds i8, i8* %5, i64 %169
%171 = load i8, i8* %170
%172 = xor i8 %171, %140
%173 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 2
%174 = load i8, i8* %173
%175 = xor i8 %172, %174
%176 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 2
store i8 %175, i8* %176
%177 = or i64 %155, 3
%178 = getelementptr inbounds i8, i8* %5, i64 %177
%179 = load i8, i8* %178
%180 = xor i8 %179, %141
%181 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 3
%182 = load i8, i8* %181
%183 = xor i8 %180, %182
%184 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 3
store i8 %183, i8* %184
%185 = or i64 %155, 4
%186 = getelementptr inbounds i8, i8* %5, i64 %185
%187 = load i8, i8* %186
%188 = xor i8 %187, %142
%189 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 4
%190 = load i8, i8* %189
%191 = xor i8 %188, %190
%192 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 4
store i8 %191, i8* %192
%193 = or i64 %155, 5
%194 = getelementptr inbounds i8, i8* %5, i64 %193
%195 = load i8, i8* %194
%196 = xor i8 %195, %143
%197 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 5
%198 = load i8, i8* %197
%199 = xor i8 %196, %198
%200 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 5
store i8 %199, i8* %200
%201 = or i64 %155, 6
%202 = getelementptr inbounds i8, i8* %5, i64 %201
%203 = load i8, i8* %202
%204 = xor i8 %203, %144
%205 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 6
%206 = load i8, i8* %205
%207 = xor i8 %204, %206
%208 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 6
store i8 %207, i8* %208
%209 = or i64 %155, 7
%210 = getelementptr inbounds i8, i8* %5, i64 %209
%211 = load i8, i8* %210
%212 = xor i8 %211, %145
%213 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 7
%214 = load i8, i8* %213
%215 = xor i8 %212, %214
%216 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 7
store i8 %215, i8* %216
%217 = or i64 %155, 8
%218 = getelementptr inbounds i8, i8* %5, i64 %217
%219 = load i8, i8* %218
%220 = xor i8 %219, %146
%221 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 8
%222 = load i8, i8* %221
%223 = xor i8 %220, %222
%224 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 8
store i8 %223, i8* %224
%225 = or i64 %155, 9
%226 = getelementptr inbounds i8, i8* %5, i64 %225
%227 = load i8, i8* %226
%228 = xor i8 %227, %147
%229 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 9
%230 = load i8, i8* %229
%231 = xor i8 %228, %230
%232 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 9
store i8 %231, i8* %232
%233 = or i64 %155, 10
%234 = getelementptr inbounds i8, i8* %5, i64 %233
%235 = load i8, i8* %234
%236 = xor i8 %235, %148
%237 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 10
%238 = load i8, i8* %237
%239 = xor i8 %236, %238
%240 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 10
store i8 %239, i8* %240
%241 = or i64 %155, 11
%242 = getelementptr inbounds i8, i8* %5, i64 %241
%243 = load i8, i8* %242
%244 = xor i8 %243, %149
%245 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 11
%246 = load i8, i8* %245
%247 = xor i8 %244, %246
%248 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 11
store i8 %247, i8* %248
%249 = or i64 %155, 12
%250 = getelementptr inbounds i8, i8* %5, i64 %249
%251 = load i8, i8* %250
%252 = xor i8 %251, %150
%253 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 12
%254 = load i8, i8* %253
%255 = xor i8 %252, %254
%256 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 12
store i8 %255, i8* %256
%257 = or i64 %155, 13
%258 = getelementptr inbounds i8, i8* %5, i64 %257
%259 = load i8, i8* %258
%260 = xor i8 %259, %151
%261 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 13
%262 = load i8, i8* %261
%263 = xor i8 %260, %262
%264 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 13
store i8 %263, i8* %264
%265 = or i64 %155, 14
%266 = getelementptr inbounds i8, i8* %5, i64 %265
%267 = load i8, i8* %266
%268 = xor i8 %267, %152
%269 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 2, i64 14
%270 = load i8, i8* %269
%271 = xor i8 %268, %270
%272 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 14
store i8 %271, i8* %272
%273 = or i64 %155, 15
%274 = getelementptr inbounds i8, i8* %5, i64 %273
br label %390
275: ; preds = %137
%276 = add nuw nsw i64 %56, %57
%277 = shl i64 %276, 4
%278 = add i64 %277, -16
%279 = getelementptr i8, i8* %5, i64 %278
%280 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 %53
store i8 -128, i8* %280
%281 = icmp eq i64 %53, 15
br i1 %281, label %286, label %282
282: ; preds = %275
%283 = add nuw nsw i64 %53, 1
%284 = getelementptr [16 x i8], [16 x i8]* %10, i64 0, i64 %283
%285 = xor i64 %53, 15
br label %286
286: ; preds = %282, %275
%287 = load i8, i8* %30
%288 = xor i8 %287, %138
%289 = load i8, i8* %44
%290 = xor i8 %288, %289
store i8 %290, i8* %40
%291 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 1
%292 = load i8, i8* %291
%293 = xor i8 %292, %139
%294 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 1
%295 = load i8, i8* %294
%296 = xor i8 %293, %295
%297 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 1
store i8 %296, i8* %297
%298 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 2
%299 = load i8, i8* %298
%300 = xor i8 %299, %140
%301 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 2
%302 = load i8, i8* %301
%303 = xor i8 %300, %302
%304 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 2
store i8 %303, i8* %304
%305 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 3
%306 = load i8, i8* %305
%307 = xor i8 %306, %141
%308 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 3
%309 = load i8, i8* %308
%310 = xor i8 %307, %309
%311 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 3
store i8 %310, i8* %311
%312 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 4
%313 = load i8, i8* %312
%314 = xor i8 %313, %142
%315 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 4
%316 = load i8, i8* %315
%317 = xor i8 %314, %316
%318 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 4
store i8 %317, i8* %318
%319 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 5
%320 = load i8, i8* %319
%321 = xor i8 %320, %143
%322 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 5
%323 = load i8, i8* %322
%324 = xor i8 %321, %323
%325 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 5
store i8 %324, i8* %325
%326 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 6
%327 = load i8, i8* %326
%328 = xor i8 %327, %144
%329 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 6
%330 = load i8, i8* %329
%331 = xor i8 %328, %330
%332 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 6
store i8 %331, i8* %332
%333 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 7
%334 = load i8, i8* %333
%335 = xor i8 %334, %145
%336 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 7
%337 = load i8, i8* %336
%338 = xor i8 %335, %337
%339 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 7
store i8 %338, i8* %339
%340 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 8
%341 = load i8, i8* %340
%342 = xor i8 %341, %146
%343 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 8
%344 = load i8, i8* %343
%345 = xor i8 %342, %344
%346 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 8
store i8 %345, i8* %346
%347 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 9
%348 = load i8, i8* %347
%349 = xor i8 %348, %147
%350 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 9
%351 = load i8, i8* %350
%352 = xor i8 %349, %351
%353 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 9
store i8 %352, i8* %353
%354 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 10
%355 = load i8, i8* %354
%356 = xor i8 %355, %148
%357 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 10
%358 = load i8, i8* %357
%359 = xor i8 %356, %358
%360 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 10
store i8 %359, i8* %360
%361 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 11
%362 = load i8, i8* %361
%363 = xor i8 %362, %149
%364 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 11
%365 = load i8, i8* %364
%366 = xor i8 %363, %365
%367 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 11
store i8 %366, i8* %367
%368 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 12
%369 = load i8, i8* %368
%370 = xor i8 %369, %150
%371 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 12
%372 = load i8, i8* %371
%373 = xor i8 %370, %372
%374 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 12
store i8 %373, i8* %374
%375 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 13
%376 = load i8, i8* %375
%377 = xor i8 %376, %151
%378 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 13
%379 = load i8, i8* %378
%380 = xor i8 %377, %379
%381 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 13
store i8 %380, i8* %381
%382 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 14
%383 = load i8, i8* %382
%384 = xor i8 %383, %152
%385 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 14
%386 = load i8, i8* %385
%387 = xor i8 %384, %386
%388 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 14
store i8 %387, i8* %388
%389 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 15
br label %390
390: ; preds = %286, %154
%391 = phi i8* [ %389, %286 ], [ %274, %154 ]
%392 = phi i64 [ 1, %286 ], [ 2, %154 ]
%393 = load i8, i8* %391
%394 = xor i8 %393, %153
%395 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 %392, i64 15
%396 = load i8, i8* %395
%397 = xor i8 %394, %396
%398 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 15
store i8 %397, i8* %398
%399 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %40, i8* %31)
br label %400
400: ; preds = %50, %390
%401 = icmp ult i64 %4, 16
br i1 %401, label %1243, label %402
402: ; preds = %400
%403 = add i64 %4, -16
store i64 %403, i64* %1
%404 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 13
store i8 -128, i8* %404
%405 = getelementptr inbounds [16 x i8], [16 x i8]* %17, i64 0, i64 14
%406 = bitcast i8* %405 to i16*
store i16 0, i16* %406
%407 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %34, i8* %39)
%408 = icmp eq i64 %4, 16
br i1 %408, label %409, label %546
409: ; preds = %402
%410 = bitcast i8* %46 to <16 x i8>*
%411 = load <16 x i8>, <16 x i8>* %410
%412 = load <16 x i8>, <16 x i8>* %26
%413 = xor <16 x i8> %412, %411
store <16 x i8> %413, <16 x i8>* %27
%414 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %40, i8* %41)
%415 = load i8, i8* %3
%416 = load i8, i8* %41
%417 = load i8, i8* %31
%418 = xor i8 %417, %416
%419 = icmp eq i8 %415, %418
br i1 %419, label %420, label %1243
420: ; preds = %409
%421 = getelementptr inbounds i8, i8* %3, i64 1
%422 = load i8, i8* %421
%423 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 1
%424 = load i8, i8* %423
%425 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 1
%426 = load i8, i8* %425
%427 = xor i8 %426, %424
%428 = icmp eq i8 %422, %427
br i1 %428, label %429, label %1243
429: ; preds = %420
%430 = getelementptr inbounds i8, i8* %3, i64 2
%431 = load i8, i8* %430
%432 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 2
%433 = load i8, i8* %432
%434 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 2
%435 = load i8, i8* %434
%436 = xor i8 %435, %433
%437 = icmp eq i8 %431, %436
br i1 %437, label %438, label %1243
438: ; preds = %429
%439 = getelementptr inbounds i8, i8* %3, i64 3
%440 = load i8, i8* %439
%441 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 3
%442 = load i8, i8* %441
%443 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 3
%444 = load i8, i8* %443
%445 = xor i8 %444, %442
%446 = icmp eq i8 %440, %445
br i1 %446, label %447, label %1243
447: ; preds = %438
%448 = getelementptr inbounds i8, i8* %3, i64 4
%449 = load i8, i8* %448
%450 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 4
%451 = load i8, i8* %450
%452 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 4
%453 = load i8, i8* %452
%454 = xor i8 %453, %451
%455 = icmp eq i8 %449, %454
br i1 %455, label %456, label %1243
456: ; preds = %447
%457 = getelementptr inbounds i8, i8* %3, i64 5
%458 = load i8, i8* %457
%459 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 5
%460 = load i8, i8* %459
%461 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 5
%462 = load i8, i8* %461
%463 = xor i8 %462, %460
%464 = icmp eq i8 %458, %463
br i1 %464, label %465, label %1243
465: ; preds = %456
%466 = getelementptr inbounds i8, i8* %3, i64 6
%467 = load i8, i8* %466
%468 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 6
%469 = load i8, i8* %468
%470 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 6
%471 = load i8, i8* %470
%472 = xor i8 %471, %469
%473 = icmp eq i8 %467, %472
br i1 %473, label %474, label %1243
474: ; preds = %465
%475 = getelementptr inbounds i8, i8* %3, i64 7
%476 = load i8, i8* %475
%477 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 7
%478 = load i8, i8* %477
%479 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 7
%480 = load i8, i8* %479
%481 = xor i8 %480, %478
%482 = icmp eq i8 %476, %481
br i1 %482, label %483, label %1243
483: ; preds = %474
%484 = getelementptr inbounds i8, i8* %3, i64 8
%485 = load i8, i8* %484
%486 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 8
%487 = load i8, i8* %486
%488 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 8
%489 = load i8, i8* %488
%490 = xor i8 %489, %487
%491 = icmp eq i8 %485, %490
br i1 %491, label %492, label %1243
492: ; preds = %483
%493 = getelementptr inbounds i8, i8* %3, i64 9
%494 = load i8, i8* %493
%495 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 9
%496 = load i8, i8* %495
%497 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 9
%498 = load i8, i8* %497
%499 = xor i8 %498, %496
%500 = icmp eq i8 %494, %499
br i1 %500, label %501, label %1243
501: ; preds = %492
%502 = getelementptr inbounds i8, i8* %3, i64 10
%503 = load i8, i8* %502
%504 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 10
%505 = load i8, i8* %504
%506 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 10
%507 = load i8, i8* %506
%508 = xor i8 %507, %505
%509 = icmp eq i8 %503, %508
br i1 %509, label %510, label %1243
510: ; preds = %501
%511 = getelementptr inbounds i8, i8* %3, i64 11
%512 = load i8, i8* %511
%513 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 11
%514 = load i8, i8* %513
%515 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 11
%516 = load i8, i8* %515
%517 = xor i8 %516, %514
%518 = icmp eq i8 %512, %517
br i1 %518, label %519, label %1243
519: ; preds = %510
%520 = getelementptr inbounds i8, i8* %3, i64 12
%521 = load i8, i8* %520
%522 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 12
%523 = load i8, i8* %522
%524 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 12
%525 = load i8, i8* %524
%526 = xor i8 %525, %523
%527 = icmp eq i8 %521, %526
br i1 %527, label %528, label %1243
528: ; preds = %519
%529 = getelementptr inbounds i8, i8* %3, i64 13
%530 = load i8, i8* %529
%531 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 13
%532 = load i8, i8* %531
%533 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 13
%534 = load i8, i8* %533
%535 = xor i8 %534, %532
%536 = icmp eq i8 %530, %535
br i1 %536, label %537, label %1243
537: ; preds = %528
%538 = getelementptr inbounds i8, i8* %3, i64 14
%539 = load i8, i8* %538
%540 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 14
%541 = load i8, i8* %540
%542 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 14
%543 = load i8, i8* %542
%544 = xor i8 %543, %541
%545 = icmp eq i8 %539, %544
br i1 %545, label %1232, label %1243
546: ; preds = %402
%547 = lshr i64 %4, 4
%548 = add nsw i64 %547, -1
%549 = and i64 %4, 15
%550 = icmp eq i64 %549, 0
br i1 %550, label %551, label %553
551: ; preds = %546
%552 = add nsw i64 %547, -2
br label %560
553: ; preds = %546
%554 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %549
store i8 -128, i8* %554
%555 = icmp eq i64 %549, 15
br i1 %555, label %560, label %556
556: ; preds = %553
%557 = add nuw nsw i64 %549, 1
%558 = getelementptr [16 x i8], [16 x i8]* %19, i64 0, i64 %557
%559 = xor i64 %549, 15
br label %560
560: ; preds = %556, %551, %553
%561 = phi i64 [ %548, %556 ], [ %552, %551 ], [ %548, %553 ]
%562 = phi i64 [ %547, %556 ], [ %548, %551 ], [ %547, %553 ]
%563 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %46, i8* %38)
%564 = load <16 x i8>, <16 x i8>* %24
%565 = load <16 x i8>, <16 x i8>* %26
%566 = xor <16 x i8> %565, %564
store <16 x i8> %566, <16 x i8>* %27
%567 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %40, i8* %41)
%568 = icmp eq i64 %561, 0
br i1 %568, label %631, label %569
569: ; preds = %560, %627
%570 = phi i64 [ %629, %627 ], [ 0, %560 ]
%571 = shl i64 %570, 4
%572 = add i64 %571, 16
%573 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @Times2 to i32 (i8*, i8*, ...)*)(i8* %38, i8* %33)
%574 = shl i64 %570, 4
%575 = getelementptr i8, i8* %3, i64 %572
%576 = getelementptr i8, i8* %3, i64 %571
%577 = getelementptr i8, i8* %0, i64 %572
%578 = getelementptr i8, i8* %0, i64 %571
%579 = icmp ult i8* %578, %575
%580 = icmp ult i8* %576, %577
%581 = and i1 %579, %580
br i1 %581, label %594, label %582
582: ; preds = %569
%583 = load <16 x i8>, <16 x i8>* %29
%584 = getelementptr inbounds i8, i8* %3, i64 %574
%585 = bitcast i8* %584 to <16 x i8>*
%586 = load <16 x i8>, <16 x i8>* %585
%587 = xor <16 x i8> %586, %583
store <16 x i8> %587, <16 x i8>* %27
%588 = load <16 x i8>, <16 x i8>* %15
%589 = xor <16 x i8> %588, %587
%590 = load <16 x i8>, <16 x i8>* %26
%591 = xor <16 x i8> %589, %590
%592 = getelementptr inbounds i8, i8* %0, i64 %574
%593 = bitcast i8* %592 to <16 x i8>*
store <16 x i8> %591, <16 x i8>* %593
br label %627
594: ; preds = %569, %594
%595 = phi i64 [ %625, %594 ], [ 0, %569 ]
%596 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %595
%597 = load i8, i8* %596
%598 = add nuw nsw i64 %595, %574
%599 = getelementptr inbounds i8, i8* %3, i64 %598
%600 = load i8, i8* %599
%601 = xor i8 %600, %597
%602 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 %595
store i8 %601, i8* %602
%603 = getelementptr inbounds <16 x i8>, <16 x i8>* %15, i64 0, i64 %595
%604 = load i8, i8* %603
%605 = xor i8 %604, %601
%606 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 %595
%607 = load i8, i8* %606
%608 = xor i8 %605, %607
%609 = getelementptr inbounds i8, i8* %0, i64 %598
store i8 %608, i8* %609
%610 = or i64 %595, 1
%611 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %610
%612 = load i8, i8* %611
%613 = add nuw nsw i64 %610, %574
%614 = getelementptr inbounds i8, i8* %3, i64 %613
%615 = load i8, i8* %614
%616 = xor i8 %615, %612
%617 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 %610
store i8 %616, i8* %617
%618 = getelementptr inbounds <16 x i8>, <16 x i8>* %15, i64 0, i64 %610
%619 = load i8, i8* %618
%620 = xor i8 %619, %616
%621 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 %610
%622 = load i8, i8* %621
%623 = xor i8 %620, %622
%624 = getelementptr inbounds i8, i8* %0, i64 %613
store i8 %623, i8* %624
%625 = add nuw nsw i64 %595, 2
%626 = icmp eq i64 %625, 16
br i1 %626, label %627, label %594
627: ; preds = %594, %582
%628 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %40, i8* %41)
%629 = add nuw i64 %570, 1
%630 = icmp eq i64 %629, %561
br i1 %630, label %631, label %569
631: ; preds = %627, %560
%632 = shl i64 %561, 4
br i1 %550, label %639, label %633
633: ; preds = %631
%634 = add nsw i64 %549, -1
%635 = and i64 %4, 1
%636 = icmp eq i64 %634, 0
br i1 %636, label %771, label %637
637: ; preds = %633
%638 = sub nsw i64 %549, %635
br label %750
639: ; preds = %631
%640 = load i8, i8* %41
%641 = getelementptr inbounds i8, i8* %3, i64 %632
%642 = load i8, i8* %641
%643 = xor i8 %642, %640
%644 = getelementptr inbounds i8, i8* %0, i64 %632
store i8 %643, i8* %644
%645 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 1
%646 = load i8, i8* %645
%647 = or i64 %632, 1
%648 = getelementptr inbounds i8, i8* %3, i64 %647
%649 = load i8, i8* %648
%650 = xor i8 %649, %646
%651 = getelementptr inbounds i8, i8* %0, i64 %647
store i8 %650, i8* %651
%652 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 2
%653 = load i8, i8* %652
%654 = or i64 %632, 2
%655 = getelementptr inbounds i8, i8* %3, i64 %654
%656 = load i8, i8* %655
%657 = xor i8 %656, %653
%658 = getelementptr inbounds i8, i8* %0, i64 %654
store i8 %657, i8* %658
%659 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 3
%660 = load i8, i8* %659
%661 = or i64 %632, 3
%662 = getelementptr inbounds i8, i8* %3, i64 %661
%663 = load i8, i8* %662
%664 = xor i8 %663, %660
%665 = getelementptr inbounds i8, i8* %0, i64 %661
store i8 %664, i8* %665
%666 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 4
%667 = load i8, i8* %666
%668 = or i64 %632, 4
%669 = getelementptr inbounds i8, i8* %3, i64 %668
%670 = load i8, i8* %669
%671 = xor i8 %670, %667
%672 = getelementptr inbounds i8, i8* %0, i64 %668
store i8 %671, i8* %672
%673 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 5
%674 = load i8, i8* %673
%675 = or i64 %632, 5
%676 = getelementptr inbounds i8, i8* %3, i64 %675
%677 = load i8, i8* %676
%678 = xor i8 %677, %674
%679 = getelementptr inbounds i8, i8* %0, i64 %675
store i8 %678, i8* %679
%680 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 6
%681 = load i8, i8* %680
%682 = or i64 %632, 6
%683 = getelementptr inbounds i8, i8* %3, i64 %682
%684 = load i8, i8* %683
%685 = xor i8 %684, %681
%686 = getelementptr inbounds i8, i8* %0, i64 %682
store i8 %685, i8* %686
%687 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 7
%688 = load i8, i8* %687
%689 = or i64 %632, 7
%690 = getelementptr inbounds i8, i8* %3, i64 %689
%691 = load i8, i8* %690
%692 = xor i8 %691, %688
%693 = getelementptr inbounds i8, i8* %0, i64 %689
store i8 %692, i8* %693
%694 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 8
%695 = load i8, i8* %694
%696 = or i64 %632, 8
%697 = getelementptr inbounds i8, i8* %3, i64 %696
%698 = load i8, i8* %697
%699 = xor i8 %698, %695
%700 = getelementptr inbounds i8, i8* %0, i64 %696
store i8 %699, i8* %700
%701 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 9
%702 = load i8, i8* %701
%703 = or i64 %632, 9
%704 = getelementptr inbounds i8, i8* %3, i64 %703
%705 = load i8, i8* %704
%706 = xor i8 %705, %702
%707 = getelementptr inbounds i8, i8* %0, i64 %703
store i8 %706, i8* %707
%708 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 10
%709 = load i8, i8* %708
%710 = or i64 %632, 10
%711 = getelementptr inbounds i8, i8* %3, i64 %710
%712 = load i8, i8* %711
%713 = xor i8 %712, %709
%714 = getelementptr inbounds i8, i8* %0, i64 %710
store i8 %713, i8* %714
%715 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 11
%716 = load i8, i8* %715
%717 = or i64 %632, 11
%718 = getelementptr inbounds i8, i8* %3, i64 %717
%719 = load i8, i8* %718
%720 = xor i8 %719, %716
%721 = getelementptr inbounds i8, i8* %0, i64 %717
store i8 %720, i8* %721
%722 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 12
%723 = load i8, i8* %722
%724 = or i64 %632, 12
%725 = getelementptr inbounds i8, i8* %3, i64 %724
%726 = load i8, i8* %725
%727 = xor i8 %726, %723
%728 = getelementptr inbounds i8, i8* %0, i64 %724
store i8 %727, i8* %728
%729 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 13
%730 = load i8, i8* %729
%731 = or i64 %632, 13
%732 = getelementptr inbounds i8, i8* %3, i64 %731
%733 = load i8, i8* %732
%734 = xor i8 %733, %730
%735 = getelementptr inbounds i8, i8* %0, i64 %731
store i8 %734, i8* %735
%736 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 14
%737 = load i8, i8* %736
%738 = or i64 %632, 14
%739 = getelementptr inbounds i8, i8* %3, i64 %738
%740 = load i8, i8* %739
%741 = xor i8 %740, %737
%742 = getelementptr inbounds i8, i8* %0, i64 %738
store i8 %741, i8* %742
%743 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 15
%744 = load i8, i8* %743
%745 = or i64 %632, 15
%746 = getelementptr inbounds i8, i8* %3, i64 %745
%747 = load i8, i8* %746
%748 = xor i8 %747, %744
%749 = getelementptr inbounds i8, i8* %0, i64 %745
store i8 %748, i8* %749
br label %840
750: ; preds = %750, %637
%751 = phi i64 [ 0, %637 ], [ %768, %750 ]
%752 = phi i64 [ 0, %637 ], [ %769, %750 ]
%753 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %751
%754 = load i8, i8* %753
%755 = add nuw nsw i64 %751, %632
%756 = getelementptr inbounds i8, i8* %3, i64 %755
%757 = load i8, i8* %756
%758 = xor i8 %757, %754
%759 = getelementptr inbounds i8, i8* %0, i64 %755
store i8 %758, i8* %759
%760 = or i64 %751, 1
%761 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %760
%762 = load i8, i8* %761
%763 = add nuw nsw i64 %760, %632
%764 = getelementptr inbounds i8, i8* %3, i64 %763
%765 = load i8, i8* %764
%766 = xor i8 %765, %762
%767 = getelementptr inbounds i8, i8* %0, i64 %763
store i8 %766, i8* %767
%768 = add nuw nsw i64 %751, 2
%769 = add i64 %752, 2
%770 = icmp eq i64 %769, %638
br i1 %770, label %771, label %750
771: ; preds = %750, %633
%772 = phi i64 [ 0, %633 ], [ %768, %750 ]
%773 = icmp eq i64 %635, 0
br i1 %773, label %782, label %774
774: ; preds = %771
%775 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %772
%776 = load i8, i8* %775
%777 = add nuw nsw i64 %772, %632
%778 = getelementptr inbounds i8, i8* %3, i64 %777
%779 = load i8, i8* %778
%780 = xor i8 %779, %776
%781 = getelementptr inbounds i8, i8* %0, i64 %777
store i8 %780, i8* %781
br label %782
782: ; preds = %771, %774
%783 = sub nuw nsw i64 16, %549
%784 = xor i64 %549, 15
%785 = and i64 %783, 3
%786 = icmp eq i64 %785, 0
br i1 %786, label %799, label %787
787: ; preds = %782, %787
%788 = phi i64 [ %796, %787 ], [ %549, %782 ]
%789 = phi i64 [ %797, %787 ], [ 0, %782 ]
%790 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %788
%791 = load i8, i8* %790
%792 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %788
%793 = load i8, i8* %792
%794 = xor i8 %793, %791
%795 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %788
store i8 %794, i8* %795
%796 = add nuw nsw i64 %788, 1
%797 = add i64 %789, 1
%798 = icmp eq i64 %797, %785
br i1 %798, label %799, label %787
799: ; preds = %787, %782
%800 = phi i64 [ %549, %782 ], [ %796, %787 ]
%801 = icmp ult i64 %784, 3
br i1 %801, label %833, label %802
802: ; preds = %799, %802
%803 = phi i64 [ %831, %802 ], [ %800, %799 ]
%804 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %803
%805 = load i8, i8* %804
%806 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %803
%807 = load i8, i8* %806
%808 = xor i8 %807, %805
%809 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %803
store i8 %808, i8* %809
%810 = add nuw nsw i64 %803, 1
%811 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %810
%812 = load i8, i8* %811
%813 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %810
%814 = load i8, i8* %813
%815 = xor i8 %814, %812
%816 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %810
store i8 %815, i8* %816
%817 = add nuw nsw i64 %803, 2
%818 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %817
%819 = load i8, i8* %818
%820 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %817
%821 = load i8, i8* %820
%822 = xor i8 %821, %819
%823 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %817
store i8 %822, i8* %823
%824 = add nuw nsw i64 %803, 3
%825 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 %824
%826 = load i8, i8* %825
%827 = getelementptr inbounds [16 x i8], [16 x i8]* %19, i64 0, i64 %824
%828 = load i8, i8* %827
%829 = xor i8 %828, %826
%830 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %824
store i8 %829, i8* %830
%831 = add nuw nsw i64 %803, 4
%832 = icmp eq i64 %831, 16
br i1 %832, label %833, label %802
833: ; preds = %802, %799
br i1 %550, label %840, label %834
834: ; preds = %833
%835 = shl i64 %561, 4
%836 = and i64 %4, 1
%837 = icmp eq i64 %634, 0
br i1 %837, label %885, label %838
838: ; preds = %834
%839 = sub nsw i64 %549, %836
br label %858
840: ; preds = %639, %833
%841 = shl i64 %561, 4
%842 = getelementptr inbounds i8, i8* %0, i64 %841
%843 = bitcast i8* %842 to <16 x i8>*
%844 = load <16 x i8>, <16 x i8>* %843
%845 = bitcast i8* %46 to <16 x i8>*
%846 = load <16 x i8>, <16 x i8>* %845
%847 = xor <16 x i8> %846, %844
%848 = load <16 x i8>, <16 x i8>* %26
%849 = xor <16 x i8> %847, %848
store <16 x i8> %849, <16 x i8>* %27
%850 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %40, i8* %41)
%851 = shl i64 %562, 4
%852 = getelementptr inbounds i8, i8* %3, i64 %851
%853 = load i8, i8* %852
%854 = load i8, i8* %41
%855 = load i8, i8* %31
%856 = xor i8 %855, %854
%857 = icmp eq i8 %853, %856
br i1 %857, label %1090, label %1243
858: ; preds = %858, %838
%859 = phi i64 [ 0, %838 ], [ %882, %858 ]
%860 = phi i64 [ 0, %838 ], [ %883, %858 ]
%861 = add nuw nsw i64 %859, %835
%862 = getelementptr inbounds i8, i8* %0, i64 %861
%863 = load i8, i8* %862
%864 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 %859
%865 = load i8, i8* %864
%866 = xor i8 %865, %863
%867 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 %859
%868 = load i8, i8* %867
%869 = xor i8 %866, %868
%870 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 %859
store i8 %869, i8* %870
%871 = or i64 %859, 1
%872 = add nuw nsw i64 %871, %835
%873 = getelementptr inbounds i8, i8* %0, i64 %872
%874 = load i8, i8* %873
%875 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 %871
%876 = load i8, i8* %875
%877 = xor i8 %876, %874
%878 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 %871
%879 = load i8, i8* %878
%880 = xor i8 %877, %879
%881 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 %871
store i8 %880, i8* %881
%882 = add nuw nsw i64 %859, 2
%883 = add i64 %860, 2
%884 = icmp eq i64 %883, %839
br i1 %884, label %885, label %858
885: ; preds = %858, %834
%886 = phi i64 [ 0, %834 ], [ %882, %858 ]
%887 = icmp eq i64 %836, 0
br i1 %887, label %899, label %888
888: ; preds = %885
%889 = add nuw nsw i64 %886, %835
%890 = getelementptr inbounds i8, i8* %0, i64 %889
%891 = load i8, i8* %890
%892 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 %886
%893 = load i8, i8* %892
%894 = xor i8 %893, %891
%895 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 %886
%896 = load i8, i8* %895
%897 = xor i8 %894, %896
%898 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 %886
store i8 %897, i8* %898
br label %899
899: ; preds = %885, %888
%900 = and i64 %783, 1
%901 = icmp eq i64 %900, 0
br i1 %901, label %913, label %902
902: ; preds = %899
%903 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %549
%904 = load i8, i8* %903
%905 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 %549
%906 = load i8, i8* %905
%907 = xor i8 %906, %904
%908 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 %549
%909 = load i8, i8* %908
%910 = xor i8 %907, %909
%911 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 %549
store i8 %910, i8* %911
%912 = add nuw nsw i64 %549, 1
br label %913
913: ; preds = %902, %899
%914 = phi i64 [ %549, %899 ], [ %912, %902 ]
%915 = icmp eq i64 %784, 0
br i1 %915, label %939, label %916
916: ; preds = %913, %916
%917 = phi i64 [ %937, %916 ], [ %914, %913 ]
%918 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %917
%919 = load i8, i8* %918
%920 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 %917
%921 = load i8, i8* %920
%922 = xor i8 %921, %919
%923 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 %917
%924 = load i8, i8* %923
%925 = xor i8 %922, %924
%926 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 %917
store i8 %925, i8* %926
%927 = add nuw nsw i64 %917, 1
%928 = getelementptr inbounds [16 x i8], [16 x i8]* %21, i64 0, i64 %927
%929 = load i8, i8* %928
%930 = getelementptr inbounds [3 x [16 x i8]], [3 x [16 x i8]]* %23, i64 0, i64 1, i64 %927
%931 = load i8, i8* %930
%932 = xor i8 %931, %929
%933 = getelementptr inbounds <16 x i8>, <16 x i8>* %26, i64 0, i64 %927
%934 = load i8, i8* %933
%935 = xor i8 %932, %934
%936 = getelementptr inbounds <16 x i8>, <16 x i8>* %27, i64 0, i64 %927
store i8 %935, i8* %936
%937 = add nuw nsw i64 %917, 2
%938 = icmp eq i64 %937, 16
br i1 %938, label %939, label %916
939: ; preds = %916, %913
%940 = call i32 (i8*, i8*, ...) bitcast (i32 (...)* @AES128Enc to i32 (i8*, i8*, ...)*)(i8* %40, i8* %41)
%941 = or i64 %835, %549
%942 = getelementptr inbounds i8, i8* %3, i64 %941
%943 = load i8, i8* %942
%944 = load i8, i8* %41
%945 = load i8, i8* %31
%946 = xor i8 %945, %944
%947 = icmp eq i8 %943, %946
br i1 %947, label %948, label %1243
948: ; preds = %939
%949 = add i64 %941, 1
%950 = getelementptr inbounds i8, i8* %3, i64 %949
%951 = load i8, i8* %950
%952 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 1
%953 = load i8, i8* %952
%954 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 1
%955 = load i8, i8* %954
%956 = xor i8 %955, %953
%957 = icmp eq i8 %951, %956
br i1 %957, label %958, label %1243
958: ; preds = %948
%959 = add i64 %941, 2
%960 = getelementptr inbounds i8, i8* %3, i64 %959
%961 = load i8, i8* %960
%962 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 2
%963 = load i8, i8* %962
%964 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 2
%965 = load i8, i8* %964
%966 = xor i8 %965, %963
%967 = icmp eq i8 %961, %966
br i1 %967, label %968, label %1243
968: ; preds = %958
%969 = add i64 %941, 3
%970 = getelementptr inbounds i8, i8* %3, i64 %969
%971 = load i8, i8* %970
%972 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 3
%973 = load i8, i8* %972
%974 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 3
%975 = load i8, i8* %974
%976 = xor i8 %975, %973
%977 = icmp eq i8 %971, %976
br i1 %977, label %978, label %1243
978: ; preds = %968
%979 = add i64 %941, 4
%980 = getelementptr inbounds i8, i8* %3, i64 %979
%981 = load i8, i8* %980
%982 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 4
%983 = load i8, i8* %982
%984 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 4
%985 = load i8, i8* %984
%986 = xor i8 %985, %983
%987 = icmp eq i8 %981, %986
br i1 %987, label %988, label %1243
988: ; preds = %978
%989 = add i64 %941, 5
%990 = getelementptr inbounds i8, i8* %3, i64 %989
%991 = load i8, i8* %990
%992 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 5
%993 = load i8, i8* %992
%994 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 5
%995 = load i8, i8* %994
%996 = xor i8 %995, %993
%997 = icmp eq i8 %991, %996
br i1 %997, label %998, label %1243
998: ; preds = %988
%999 = add i64 %941, 6
%1000 = getelementptr inbounds i8, i8* %3, i64 %999
%1001 = load i8, i8* %1000
%1002 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 6
%1003 = load i8, i8* %1002
%1004 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 6
%1005 = load i8, i8* %1004
%1006 = xor i8 %1005, %1003
%1007 = icmp eq i8 %1001, %1006
br i1 %1007, label %1008, label %1243
1008: ; preds = %998
%1009 = add i64 %941, 7
%1010 = getelementptr inbounds i8, i8* %3, i64 %1009
%1011 = load i8, i8* %1010
%1012 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 7
%1013 = load i8, i8* %1012
%1014 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 7
%1015 = load i8, i8* %1014
%1016 = xor i8 %1015, %1013
%1017 = icmp eq i8 %1011, %1016
br i1 %1017, label %1018, label %1243
1018: ; preds = %1008
%1019 = add i64 %941, 8
%1020 = getelementptr inbounds i8, i8* %3, i64 %1019
%1021 = load i8, i8* %1020
%1022 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 8
%1023 = load i8, i8* %1022
%1024 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 8
%1025 = load i8, i8* %1024
%1026 = xor i8 %1025, %1023
%1027 = icmp eq i8 %1021, %1026
br i1 %1027, label %1028, label %1243
1028: ; preds = %1018
%1029 = add i64 %941, 9
%1030 = getelementptr inbounds i8, i8* %3, i64 %1029
%1031 = load i8, i8* %1030
%1032 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 9
%1033 = load i8, i8* %1032
%1034 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 9
%1035 = load i8, i8* %1034
%1036 = xor i8 %1035, %1033
%1037 = icmp eq i8 %1031, %1036
br i1 %1037, label %1038, label %1243
1038: ; preds = %1028
%1039 = add i64 %941, 10
%1040 = getelementptr inbounds i8, i8* %3, i64 %1039
%1041 = load i8, i8* %1040
%1042 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 10
%1043 = load i8, i8* %1042
%1044 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 10
%1045 = load i8, i8* %1044
%1046 = xor i8 %1045, %1043
%1047 = icmp eq i8 %1041, %1046
br i1 %1047, label %1048, label %1243
1048: ; preds = %1038
%1049 = add i64 %941, 11
%1050 = getelementptr inbounds i8, i8* %3, i64 %1049
%1051 = load i8, i8* %1050
%1052 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 11
%1053 = load i8, i8* %1052
%1054 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 11
%1055 = load i8, i8* %1054
%1056 = xor i8 %1055, %1053
%1057 = icmp eq i8 %1051, %1056
br i1 %1057, label %1058, label %1243
1058: ; preds = %1048
%1059 = add i64 %941, 12
%1060 = getelementptr inbounds i8, i8* %3, i64 %1059
%1061 = load i8, i8* %1060
%1062 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 12
%1063 = load i8, i8* %1062
%1064 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 12
%1065 = load i8, i8* %1064
%1066 = xor i8 %1065, %1063
%1067 = icmp eq i8 %1061, %1066
br i1 %1067, label %1068, label %1243
1068: ; preds = %1058
%1069 = add i64 %941, 13
%1070 = getelementptr inbounds i8, i8* %3, i64 %1069
%1071 = load i8, i8* %1070
%1072 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 13
%1073 = load i8, i8* %1072
%1074 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 13
%1075 = load i8, i8* %1074
%1076 = xor i8 %1075, %1073
%1077 = icmp eq i8 %1071, %1076
br i1 %1077, label %1078, label %1243
1078: ; preds = %1068
%1079 = add i64 %941, 14
%1080 = getelementptr inbounds i8, i8* %3, i64 %1079
%1081 = load i8, i8* %1080
%1082 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 14
%1083 = load i8, i8* %1082
%1084 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 14
%1085 = load i8, i8* %1084
%1086 = xor i8 %1085, %1083
%1087 = icmp eq i8 %1081, %1086
br i1 %1087, label %1088, label %1243
1088: ; preds = %1078
%1089 = add i64 %941, 15
br label %1232
1090: ; preds = %840
%1091 = or i64 %851, 1
%1092 = getelementptr inbounds i8, i8* %3, i64 %1091
%1093 = load i8, i8* %1092
%1094 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 1
%1095 = load i8, i8* %1094
%1096 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 1
%1097 = load i8, i8* %1096
%1098 = xor i8 %1097, %1095
%1099 = icmp eq i8 %1093, %1098
br i1 %1099, label %1100, label %1243
1100: ; preds = %1090
%1101 = or i64 %851, 2
%1102 = getelementptr inbounds i8, i8* %3, i64 %1101
%1103 = load i8, i8* %1102
%1104 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 2
%1105 = load i8, i8* %1104
%1106 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 2
%1107 = load i8, i8* %1106
%1108 = xor i8 %1107, %1105
%1109 = icmp eq i8 %1103, %1108
br i1 %1109, label %1110, label %1243
1110: ; preds = %1100
%1111 = or i64 %851, 3
%1112 = getelementptr inbounds i8, i8* %3, i64 %1111
%1113 = load i8, i8* %1112
%1114 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 3
%1115 = load i8, i8* %1114
%1116 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 3
%1117 = load i8, i8* %1116
%1118 = xor i8 %1117, %1115
%1119 = icmp eq i8 %1113, %1118
br i1 %1119, label %1120, label %1243
1120: ; preds = %1110
%1121 = or i64 %851, 4
%1122 = getelementptr inbounds i8, i8* %3, i64 %1121
%1123 = load i8, i8* %1122
%1124 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 4
%1125 = load i8, i8* %1124
%1126 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 4
%1127 = load i8, i8* %1126
%1128 = xor i8 %1127, %1125
%1129 = icmp eq i8 %1123, %1128
br i1 %1129, label %1130, label %1243
1130: ; preds = %1120
%1131 = or i64 %851, 5
%1132 = getelementptr inbounds i8, i8* %3, i64 %1131
%1133 = load i8, i8* %1132
%1134 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 5
%1135 = load i8, i8* %1134
%1136 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 5
%1137 = load i8, i8* %1136
%1138 = xor i8 %1137, %1135
%1139 = icmp eq i8 %1133, %1138
br i1 %1139, label %1140, label %1243
1140: ; preds = %1130
%1141 = or i64 %851, 6
%1142 = getelementptr inbounds i8, i8* %3, i64 %1141
%1143 = load i8, i8* %1142
%1144 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 6
%1145 = load i8, i8* %1144
%1146 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 6
%1147 = load i8, i8* %1146
%1148 = xor i8 %1147, %1145
%1149 = icmp eq i8 %1143, %1148
br i1 %1149, label %1150, label %1243
1150: ; preds = %1140
%1151 = or i64 %851, 7
%1152 = getelementptr inbounds i8, i8* %3, i64 %1151
%1153 = load i8, i8* %1152
%1154 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 7
%1155 = load i8, i8* %1154
%1156 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 7
%1157 = load i8, i8* %1156
%1158 = xor i8 %1157, %1155
%1159 = icmp eq i8 %1153, %1158
br i1 %1159, label %1160, label %1243
1160: ; preds = %1150
%1161 = or i64 %851, 8
%1162 = getelementptr inbounds i8, i8* %3, i64 %1161
%1163 = load i8, i8* %1162
%1164 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 8
%1165 = load i8, i8* %1164
%1166 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 8
%1167 = load i8, i8* %1166
%1168 = xor i8 %1167, %1165
%1169 = icmp eq i8 %1163, %1168
br i1 %1169, label %1170, label %1243
1170: ; preds = %1160
%1171 = or i64 %851, 9
%1172 = getelementptr inbounds i8, i8* %3, i64 %1171
%1173 = load i8, i8* %1172
%1174 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 9
%1175 = load i8, i8* %1174
%1176 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 9
%1177 = load i8, i8* %1176
%1178 = xor i8 %1177, %1175
%1179 = icmp eq i8 %1173, %1178
br i1 %1179, label %1180, label %1243
1180: ; preds = %1170
%1181 = or i64 %851, 10
%1182 = getelementptr inbounds i8, i8* %3, i64 %1181
%1183 = load i8, i8* %1182
%1184 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 10
%1185 = load i8, i8* %1184
%1186 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 10
%1187 = load i8, i8* %1186
%1188 = xor i8 %1187, %1185
%1189 = icmp eq i8 %1183, %1188
br i1 %1189, label %1190, label %1243
1190: ; preds = %1180
%1191 = or i64 %851, 11
%1192 = getelementptr inbounds i8, i8* %3, i64 %1191
%1193 = load i8, i8* %1192
%1194 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 11
%1195 = load i8, i8* %1194
%1196 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 11
%1197 = load i8, i8* %1196
%1198 = xor i8 %1197, %1195
%1199 = icmp eq i8 %1193, %1198
br i1 %1199, label %1200, label %1243
1200: ; preds = %1190
%1201 = or i64 %851, 12
%1202 = getelementptr inbounds i8, i8* %3, i64 %1201
%1203 = load i8, i8* %1202
%1204 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 12
%1205 = load i8, i8* %1204
%1206 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 12
%1207 = load i8, i8* %1206
%1208 = xor i8 %1207, %1205
%1209 = icmp eq i8 %1203, %1208
br i1 %1209, label %1210, label %1243
1210: ; preds = %1200
%1211 = or i64 %851, 13
%1212 = getelementptr inbounds i8, i8* %3, i64 %1211
%1213 = load i8, i8* %1212
%1214 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 13
%1215 = load i8, i8* %1214
%1216 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 13
%1217 = load i8, i8* %1216
%1218 = xor i8 %1217, %1215
%1219 = icmp eq i8 %1213, %1218
br i1 %1219, label %1220, label %1243
1220: ; preds = %1210
%1221 = or i64 %851, 14
%1222 = getelementptr inbounds i8, i8* %3, i64 %1221
%1223 = load i8, i8* %1222
%1224 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 14
%1225 = load i8, i8* %1224
%1226 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 14
%1227 = load i8, i8* %1226
%1228 = xor i8 %1227, %1225
%1229 = icmp eq i8 %1223, %1228
br i1 %1229, label %1230, label %1243
1230: ; preds = %1220
%1231 = or i64 %851, 15
br label %1232
1232: ; preds = %537, %1088, %1230
%1233 = phi i64 [ %1231, %1230 ], [ %1089, %1088 ], [ 15, %537 ]
%1234 = getelementptr inbounds i8, i8* %3, i64 %1233
%1235 = load i8, i8* %1234
%1236 = getelementptr inbounds <16 x i8>, <16 x i8>* %29, i64 0, i64 15
%1237 = load i8, i8* %1236
%1238 = getelementptr inbounds [16 x i8], [16 x i8]* %12, i64 0, i64 15
%1239 = load i8, i8* %1238
%1240 = xor i8 %1239, %1237
%1241 = icmp ne i8 %1235, %1240
%1242 = sext i1 %1241 to i32
br label %1243
1243: ; preds = %1232, %939, %948, %958, %968, %978, %988, %998, %1008, %1018, %1028, %1038, %1048, %1058, %1068, %1078, %840, %1090, %1100, %1110, %1120, %1130, %1140, %1150, %1160, %1170, %1180, %1190, %1200, %1210, %1220, %409, %420, %429, %438, %447, %456, %465, %474, %483, %492, %501, %510, %519, %528, %537, %400
%1244 = phi i32 [ -2, %400 ], [ -1, %409 ], [ -1, %420 ], [ -1, %429 ], [ -1, %438 ], [ -1, %447 ], [ -1, %456 ], [ -1, %465 ], [ -1, %474 ], [ -1, %483 ], [ -1, %492 ], [ -1, %501 ], [ -1, %510 ], [ -1, %519 ], [ -1, %528 ], [ -1, %537 ], [ -1, %840 ], [ -1, %1090 ], [ -1, %1100 ], [ -1, %1110 ], [ -1, %1120 ], [ -1, %1130 ], [ -1, %1140 ], [ -1, %1150 ], [ -1, %1160 ], [ -1, %1170 ], [ -1, %1180 ], [ -1, %1190 ], [ -1, %1200 ], [ -1, %1210 ], [ -1, %1220 ], [ -1, %939 ], [ -1, %948 ], [ -1, %958 ], [ -1, %968 ], [ -1, %978 ], [ -1, %988 ], [ -1, %998 ], [ -1, %1008 ], [ -1, %1018 ], [ -1, %1028 ], [ -1, %1038 ], [ -1, %1048 ], [ -1, %1058 ], [ -1, %1068 ], [ -1, %1078 ], [ %1242, %1232 ]
ret i32 %1244
}