#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ AES_KEY;

/* Variables and functions */
int AES_BLOCK_SIZE;
int const AES_DECRYPT;
int const AES_ENCRYPT;
int /*<<< orphan*/ AES_decrypt(unsigned char const *, unsigned char *,
                               int /*<<< orphan*/ const *);
int /*<<< orphan*/ AES_encrypt(unsigned char *, unsigned char *,
                               int /*<<< orphan*/ const *);
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char const *, int);
void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
                     const unsigned long length, const AES_KEY *key,
                     unsigned char *ivec, const int enc) {
  unsigned long n;
  unsigned long len = length;
  unsigned char tmp[AES_BLOCK_SIZE];
  const unsigned char *iv = ivec;
  assert(in && out && key && ivec);
  assert((AES_ENCRYPT == enc) || (AES_DECRYPT == enc));
  if (AES_ENCRYPT == enc) {
    while (len >= AES_BLOCK_SIZE) {
      for (n = 0; n < AES_BLOCK_SIZE; ++n)
        out[n] = in[n] ^ iv[n];
      AES_encrypt(out, out, key);
      iv = out;
      len -= AES_BLOCK_SIZE;
      in += AES_BLOCK_SIZE;
      out += AES_BLOCK_SIZE;
    }
    if (len) {
      for (n = 0; n < len; ++n)
        out[n] = in[n] ^ iv[n];
      for (n = len; n < AES_BLOCK_SIZE; ++n)
        out[n] = iv[n];
      AES_encrypt(out, out, key);
      iv = out;
    }
    memcpy(ivec, iv, AES_BLOCK_SIZE);
  } else if (in != out) {
    while (len >= AES_BLOCK_SIZE) {
      AES_decrypt(in, out, key);
      for (n = 0; n < AES_BLOCK_SIZE; ++n)
        out[n] ^= iv[n];
      iv = in;
      len -= AES_BLOCK_SIZE;
      in += AES_BLOCK_SIZE;
      out += AES_BLOCK_SIZE;
    }
    if (len) {
      AES_decrypt(in, tmp, key);
      for (n = 0; n < len; ++n)
        out[n] = tmp[n] ^ iv[n];
      iv = in;
    }
    memcpy(ivec, iv, AES_BLOCK_SIZE);
  } else {
    while (len >= AES_BLOCK_SIZE) {
      memcpy(tmp, in, AES_BLOCK_SIZE);
      AES_decrypt(in, out, key);
      for (n = 0; n < AES_BLOCK_SIZE; ++n)
        out[n] ^= ivec[n];
      memcpy(ivec, tmp, AES_BLOCK_SIZE);
      len -= AES_BLOCK_SIZE;
      in += AES_BLOCK_SIZE;
      out += AES_BLOCK_SIZE;
    }
    if (len) {
      memcpy(tmp, in, AES_BLOCK_SIZE);
      AES_decrypt(tmp, out, key);
      for (n = 0; n < len; ++n)
        out[n] ^= ivec[n];
      for (n = len; n < AES_BLOCK_SIZE; ++n)
        out[n] = tmp[n];
      memcpy(ivec, tmp, AES_BLOCK_SIZE);
    }
  }
}


x86 assembly (clang, -O0):
<AES_cbc_encrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    0x2e79(%rip),%rax
mov    (%rax),%eax
mov    %rsp,%rcx
mov    %rcx,-0x48(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x58(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x8(%rbp)
mov    %al,-0x59(%rbp)
je     11d7 <AES_cbc_encrypt+0x97>
xor    %eax,%eax
cmpq   $0x0,-0x10(%rbp)
mov    %al,-0x59(%rbp)
je     11d7 <AES_cbc_encrypt+0x97>
xor    %eax,%eax
cmpq   $0x0,-0x20(%rbp)
mov    %al,-0x59(%rbp)
je     11d7 <AES_cbc_encrypt+0x97>
cmpq   $0x0,-0x28(%rbp)
setne  %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x2de5(%rip),%rax
mov    (%rax),%ecx
mov    $0x1,%al
cmp    -0x2c(%rbp),%ecx
mov    %al,-0x69(%rbp)
je     120d <AES_cbc_encrypt+0xcd>
mov    0x2dde(%rip),%rax
mov    (%rax),%eax
cmp    -0x2c(%rbp),%eax
sete   %al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    0x2daf(%rip),%rax
mov    (%rax),%eax
cmp    -0x2c(%rbp),%eax
jne    13d3 <AES_cbc_encrypt+0x293>
jmp    1231 <AES_cbc_encrypt+0xf1>
mov    -0x40(%rbp),%rax
mov    0x2dac(%rip),%rcx
movslq (%rcx),%rcx
cmp    %rcx,%rax
jb     1300 <AES_cbc_encrypt+0x1c0>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    0x2d8d(%rip),%rcx
movslq (%rcx),%rcx
cmp    %rcx,%rax
jae    129f <AES_cbc_encrypt+0x15f>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x58(%rbp),%rcx
mov    -0x38(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1250 <AES_cbc_encrypt+0x110>
mov    -0x10(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1050 <AES_encrypt@plt>
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    0x2d29(%rip),%rax
movslq (%rax),%rcx
mov    -0x40(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x2d14(%rip),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    0x2cfd(%rip),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    1231 <AES_cbc_encrypt+0xf1>
cmpq   $0x0,-0x40(%rbp)
je     13b8 <AES_cbc_encrypt+0x278>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    1359 <AES_cbc_encrypt+0x219>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x58(%rbp),%rcx
mov    -0x38(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1313 <AES_cbc_encrypt+0x1d3>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    0x2c7c(%rip),%rcx
movslq (%rcx),%rcx
cmp    %rcx,%rax
jae    139f <AES_cbc_encrypt+0x25f>
mov    -0x58(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1361 <AES_cbc_encrypt+0x221>
mov    -0x10(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1050 <AES_encrypt@plt>
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    0x2c21(%rip),%rax
mov    (%rax),%edx
call   1040 <memcpy@plt>
jmp    1702 <AES_cbc_encrypt+0x5c2>
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
je     1538 <AES_cbc_encrypt+0x3f8>
jmp    13e6 <AES_cbc_encrypt+0x2a6>
mov    -0x40(%rbp),%rax
mov    0x2bf7(%rip),%rcx
movslq (%rcx),%rcx
cmp    %rcx,%rax
jb     14ab <AES_cbc_encrypt+0x36b>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1060 <AES_decrypt@plt>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    0x2bc7(%rip),%rcx
movslq (%rcx),%rcx
cmp    %rcx,%rax
jae    145b <AES_cbc_encrypt+0x31b>
mov    -0x58(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1416 <AES_cbc_encrypt+0x2d6>
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    0x2b7e(%rip),%rax
movslq (%rax),%rcx
mov    -0x40(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x2b69(%rip),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    0x2b52(%rip),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    13e6 <AES_cbc_encrypt+0x2a6>
cmpq   $0x0,-0x40(%rbp)
je     151d <AES_cbc_encrypt+0x3dd>
mov    -0x68(%rbp),%rsi
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rdx
call   1060 <AES_decrypt@plt>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    1515 <AES_cbc_encrypt+0x3d5>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x58(%rbp),%rcx
mov    -0x38(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    14cf <AES_cbc_encrypt+0x38f>
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    0x2abc(%rip),%rax
mov    (%rax),%edx
call   1040 <memcpy@plt>
jmp    16fd <AES_cbc_encrypt+0x5bd>
jmp    153d <AES_cbc_encrypt+0x3fd>
mov    -0x40(%rbp),%rax
mov    0x2aa0(%rip),%rcx
movslq (%rcx),%rcx
cmp    %rcx,%rax
jb     1626 <AES_cbc_encrypt+0x4e6>
mov    -0x68(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    0x2a85(%rip),%rax
mov    (%rax),%edx
call   1040 <memcpy@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1060 <AES_decrypt@plt>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    0x2a5a(%rip),%rcx
movslq (%rcx),%rcx
cmp    %rcx,%rax
jae    15c8 <AES_cbc_encrypt+0x488>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1583 <AES_cbc_encrypt+0x443>
mov    -0x68(%rbp),%rsi
mov    -0x28(%rbp),%rdi
mov    0x2a11(%rip),%rax
mov    (%rax),%edx
call   1040 <memcpy@plt>
mov    0x2a03(%rip),%rax
movslq (%rax),%rcx
mov    -0x40(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x29ee(%rip),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    0x29d7(%rip),%rax
mov    (%rax),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
jmp    153d <AES_cbc_encrypt+0x3fd>
cmpq   $0x0,-0x40(%rbp)
je     16f8 <AES_cbc_encrypt+0x5b8>
mov    -0x68(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    0x29a8(%rip),%rax
mov    (%rax),%edx
call   1040 <memcpy@plt>
mov    -0x68(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1060 <AES_decrypt@plt>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    169c <AES_cbc_encrypt+0x55c>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1660 <AES_cbc_encrypt+0x520>
mov    -0x40(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    0x2939(%rip),%rcx
movslq (%rcx),%rcx
cmp    %rcx,%rax
jae    16e2 <AES_cbc_encrypt+0x5a2>
mov    -0x68(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    16a4 <AES_cbc_encrypt+0x564>
mov    -0x68(%rbp),%rsi
mov    -0x28(%rbp),%rdi
mov    0x28f7(%rip),%rax
mov    (%rax),%edx
call   1040 <memcpy@plt>
jmp    16fd <AES_cbc_encrypt+0x5bd>
jmp    1702 <AES_cbc_encrypt+0x5c2>
mov    -0x48(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<AES_cbc_encrypt>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9d,-0x38(%rbp)
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%r13
mov    0x2e83(%rip),%r14
mov    (%r14),%eax
mov    %rsp,%rdx
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rdx
mov    %rdx,-0x48(%rbp)
mov    %rdx,%rsp
test   %rdi,%rdi
setne  %al
test   %rsi,%rsi
setne  %bl
and    %al,%bl
mov    %rcx,-0x40(%rbp)
test   %rcx,%rcx
setne  %al
mov    %r8,-0x30(%rbp)
test   %r8,%r8
setne  %dl
and    %al,%dl
and    %bl,%dl
movzbl %dl,%edi
call   1030 <assert@plt>
xor    %edi,%edi
mov    -0x38(%rbp),%ebx
test   %ebx,%ebx
sete   %dil
call   1030 <assert@plt>
test   %ebx,%ebx
je     129d <AES_cbc_encrypt+0x15d>
mov    (%r14),%edx
movslq %edx,%rax
cmp    %r12,%r13
je     12c7 <AES_cbc_encrypt+0x187>
cmp    %r15,%rax
jbe    131a <AES_cbc_encrypt+0x1da>
mov    -0x30(%rbp),%rsi
test   %r15,%r15
je     1291 <AES_cbc_encrypt+0x151>
mov    %rsi,-0x38(%rbp)
mov    %r13,%rdi
mov    -0x48(%rbp),%rbx
mov    %rbx,%rsi
mov    -0x40(%rbp),%rdx
call   1060 <AES_decrypt@plt>
cmp    $0x8,%r15
jae    13e2 <AES_cbc_encrypt+0x2a2>
xor    %eax,%eax
mov    %rbx,%rdi
mov    -0x38(%rbp),%rsi
mov    %rax,%rcx
not    %rcx
add    %r15,%rcx
mov    %r15,%rdx
and    $0x3,%rdx
je     1245 <AES_cbc_encrypt+0x105>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rsi,%rax,1),%ebx
xor    (%rdi,%rax,1),%bl
mov    %bl,(%r12,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1230 <AES_cbc_encrypt+0xf0>
cmp    $0x3,%rcx
jb     128e <AES_cbc_encrypt+0x14e>
nopl   0x0(%rax,%rax,1)
movzbl (%rsi,%rax,1),%ecx
xor    (%rdi,%rax,1),%cl
mov    %cl,(%r12,%rax,1)
movzbl 0x1(%rsi,%rax,1),%ecx
xor    0x1(%rdi,%rax,1),%cl
mov    %cl,0x1(%r12,%rax,1)
movzbl 0x2(%rsi,%rax,1),%ecx
xor    0x2(%rdi,%rax,1),%cl
mov    %cl,0x2(%r12,%rax,1)
movzbl 0x3(%rsi,%rax,1),%ecx
xor    0x3(%rdi,%rax,1),%cl
mov    %cl,0x3(%r12,%rax,1)
add    $0x4,%rax
cmp    %rax,%r15
jne    1250 <AES_cbc_encrypt+0x110>
mov    %r13,%rsi
mov    -0x30(%rbp),%rdi
mov    (%r14),%edx
jmp    1978 <AES_cbc_encrypt+0x838>
movslq (%r14),%rdx
cmp    %r15,%rdx
jbe    1376 <AES_cbc_encrypt+0x236>
mov    -0x30(%rbp),%rbx
test   %r15,%r15
je     13da <AES_cbc_encrypt+0x29a>
cmp    $0x8,%r15
jae    1433 <AES_cbc_encrypt+0x2f3>
xor    %eax,%eax
jmp    17af <AES_cbc_encrypt+0x66f>
cmp    %r15,%rax
mov    -0x48(%rbp),%rdi
mov    %r13,%rbx
jbe    147d <AES_cbc_encrypt+0x33d>
mov    -0x30(%rbp),%r12
test   %r15,%r15
je     197d <AES_cbc_encrypt+0x83d>
mov    %r13,%rsi
mov    %rdi,%r14
call   1040 <memcpy@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
mov    -0x40(%rbp),%rdx
call   1060 <AES_decrypt@plt>
cmp    $0x8,%r15
jae    1506 <AES_cbc_encrypt+0x3c6>
xor    %eax,%eax
mov    -0x48(%rbp),%rsi
mov    0x2cd3(%rip),%r8
jmp    18ea <AES_cbc_encrypt+0x7aa>
mov    -0x30(%rbp),%rbx
jmp    133a <AES_cbc_encrypt+0x1fa>
cltq
sub    %rax,%r15
mov    %r13,%rsi
add    %rax,%r13
add    %rax,%r12
mov    %rsi,%rbx
cmp    %rax,%r15
jb     11df <AES_cbc_encrypt+0x9f>
mov    %r13,%rdi
mov    %r12,%rsi
mov    -0x40(%rbp),%rdx
call   1060 <AES_decrypt@plt>
cmpl   $0x0,(%r14)
mov    $0x0,%eax
je     1320 <AES_cbc_encrypt+0x1e0>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movzbl (%rbx,%rcx,1),%eax
xor    %al,(%r12,%rcx,1)
add    $0x1,%rcx
movslq (%r14),%rax
cmp    %rax,%rcx
jb     1360 <AES_cbc_encrypt+0x220>
jmp    1320 <AES_cbc_encrypt+0x1e0>
mov    -0x30(%rbp),%rax
jmp    13a8 <AES_cbc_encrypt+0x268>
nopl   0x0(%rax)
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    -0x40(%rbp),%rdx
call   1050 <AES_encrypt@plt>
movslq (%r14),%rdx
sub    %rdx,%r15
add    %rdx,%r13
lea    (%rbx,%rdx,1),%r12
mov    %rbx,%rax
cmp    %rdx,%r15
jb     12ad <AES_cbc_encrypt+0x16d>
mov    %r12,%rbx
test   %edx,%edx
je     1380 <AES_cbc_encrypt+0x240>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rax,%rcx,1),%edx
xor    0x0(%r13,%rcx,1),%dl
mov    %dl,(%rbx,%rcx,1)
add    $0x1,%rcx
movslq (%r14),%rdx
cmp    %rdx,%rcx
jb     13c0 <AES_cbc_encrypt+0x280>
jmp    1380 <AES_cbc_encrypt+0x240>
mov    %rbx,%r12
jmp    1867 <AES_cbc_encrypt+0x727>
lea    (%r12,%r15,1),%rax
lea    (%rbx,%r15,1),%rcx
mov    -0x38(%rbp),%rsi
lea    (%rsi,%r15,1),%rdx
cmp    %rcx,%r12
setb   %r8b
cmp    %rax,%rbx
setb   %dil
cmp    %rdx,%r12
setb   %cl
cmp    %rax,%rsi
setb   %dl
xor    %eax,%eax
test   %dil,%r8b
mov    %rbx,%rdi
jne    1212 <AES_cbc_encrypt+0xd2>
and    %dl,%cl
jne    1212 <AES_cbc_encrypt+0xd2>
cmp    $0x20,%r15
jae    153b <AES_cbc_encrypt+0x3fb>
xor    %eax,%eax
jmp    170f <AES_cbc_encrypt+0x5cf>
lea    (%r12,%r15,1),%rax
lea    (%r15,%r13,1),%rcx
lea    (%rbx,%r15,1),%rdx
cmp    %rcx,%r12
setb   %sil
cmp    %rax,%r13
setb   %dil
cmp    %rdx,%r12
setb   %cl
cmp    %rax,%rbx
setb   %dl
xor    %eax,%eax
test   %dil,%sil
jne    17af <AES_cbc_encrypt+0x66f>
and    %dl,%cl
jne    17af <AES_cbc_encrypt+0x66f>
cmp    $0x20,%r15
jae    15bc <AES_cbc_encrypt+0x47c>
xor    %eax,%eax
jmp    177f <AES_cbc_encrypt+0x63f>
mov    -0x30(%rbp),%r12
jmp    14c1 <AES_cbc_encrypt+0x381>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r12,%rdi
mov    %r14,%r15
mov    -0x48(%rbp),%r14
mov    %r14,%rsi
call   1040 <memcpy@plt>
mov    %r14,%rdi
mov    %r15,%r14
movslq (%r15),%rdx
mov    -0x38(%rbp),%r15
sub    %rdx,%r15
add    %rdx,%r13
add    %rdx,%rbx
cmp    %rdx,%r15
jb     12db <AES_cbc_encrypt+0x19b>
mov    %r15,-0x38(%rbp)
mov    %r13,%rsi
call   1040 <memcpy@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
mov    -0x40(%rbp),%rdx
call   1060 <AES_decrypt@plt>
cmpl   $0x0,(%r14)
mov    $0x0,%edx
je     1490 <AES_cbc_encrypt+0x350>
xor    %eax,%eax
nopl   0x0(%rax)
movzbl (%r12,%rax,1),%ecx
xor    %cl,(%rbx,%rax,1)
add    $0x1,%rax
movslq (%r14),%rdx
cmp    %rdx,%rax
jb     14f0 <AES_cbc_encrypt+0x3b0>
jmp    1490 <AES_cbc_encrypt+0x350>
lea    (%r12,%r15,1),%rax
cmp    %rax,%rbx
mov    -0x48(%rbp),%rsi
mov    0x2ad0(%rip),%r8
jae    152a <AES_cbc_encrypt+0x3ea>
lea    (%rbx,%r15,1),%rax
cmp    %r12,%rax
jbe    152a <AES_cbc_encrypt+0x3ea>
xor    %eax,%eax
jmp    18ea <AES_cbc_encrypt+0x7aa>
cmp    $0x20,%r15
jae    164d <AES_cbc_encrypt+0x50d>
xor    %eax,%eax
jmp    18ba <AES_cbc_encrypt+0x77a>
mov    %r15,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rcx
mov    %rcx,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
test   %rcx,%rcx
je     16d8 <AES_cbc_encrypt+0x598>
mov    %rbx,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
xorps  (%rdi,%rcx,1),%xmm0
xorps  0x10(%rdi,%rcx,1),%xmm1
movups %xmm0,(%r12,%rcx,1)
movups %xmm1,0x10(%r12,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
xorps  0x20(%rdi,%rcx,1),%xmm0
xorps  0x30(%rdi,%rcx,1),%xmm1
movups %xmm0,0x20(%r12,%rcx,1)
movups %xmm1,0x30(%r12,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1570 <AES_cbc_encrypt+0x430>
jmp    16da <AES_cbc_encrypt+0x59a>
mov    %r15,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rcx
mov    %rcx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1743 <AES_cbc_encrypt+0x603>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x0(%r13,%rcx,1),%xmm0
movups 0x10(%r13,%rcx,1),%xmm1
movups (%rbx,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbx,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%r12,%rcx,1)
movups %xmm0,0x10(%r12,%rcx,1)
movups 0x20(%r13,%rcx,1),%xmm0
movups 0x30(%r13,%rcx,1),%xmm1
movups 0x20(%rbx,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x30(%rbx,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,0x20(%r12,%rcx,1)
movups %xmm0,0x30(%r12,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rsi
jne    15f0 <AES_cbc_encrypt+0x4b0>
jmp    1745 <AES_cbc_encrypt+0x605>
mov    %r15,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rcx
mov    %rcx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1881 <AES_cbc_encrypt+0x741>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%r12,%rcx,1),%xmm0
movups 0x10(%r12,%rcx,1),%xmm1
movups (%rbx,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbx,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups 0x20(%rbx,%rcx,1),%xmm1
movups 0x30(%rbx,%rcx,1),%xmm3
movups %xmm2,(%rbx,%rcx,1)
movups %xmm0,0x10(%rbx,%rcx,1)
movups 0x20(%r12,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups 0x30(%r12,%rcx,1),%xmm1
xorps  %xmm3,%xmm1
movups %xmm0,0x20(%rbx,%rcx,1)
movups %xmm1,0x30(%rbx,%rcx,1)
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1680 <AES_cbc_encrypt+0x540>
jmp    1883 <AES_cbc_encrypt+0x743>
xor    %ecx,%ecx
test   $0x1,%bl
je     16fc <AES_cbc_encrypt+0x5bc>
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
xorps  (%rdi,%rcx,1),%xmm0
xorps  0x10(%rdi,%rcx,1),%xmm1
movups %xmm0,(%r12,%rcx,1)
movups %xmm1,0x10(%r12,%rcx,1)
cmp    %rax,%r15
je     128e <AES_cbc_encrypt+0x14e>
test   $0x18,%r15b
je     1212 <AES_cbc_encrypt+0xd2>
mov    %rax,%rcx
mov    %r15,%rax
and    $0xfffffffffffffff8,%rax
nopl   0x0(%rax)
mov    (%rsi,%rcx,1),%rdx
xor    (%rdi,%rcx,1),%rdx
mov    %rdx,(%r12,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1720 <AES_cbc_encrypt+0x5e0>
cmp    %rax,%r15
jne    1212 <AES_cbc_encrypt+0xd2>
jmp    128e <AES_cbc_encrypt+0x14e>
xor    %ecx,%ecx
test   $0x1,%dl
je     1770 <AES_cbc_encrypt+0x630>
movups 0x0(%r13,%rcx,1),%xmm0
movups 0x10(%r13,%rcx,1),%xmm1
movups (%rbx,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbx,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%r12,%rcx,1)
movups %xmm0,0x10(%r12,%rcx,1)
cmp    %rax,%r15
je     184d <AES_cbc_encrypt+0x70d>
test   $0x18,%r15b
je     17af <AES_cbc_encrypt+0x66f>
mov    %rax,%rcx
mov    %r15,%rax
and    $0xfffffffffffffff8,%rax
nopl   0x0(%rax)
mov    (%rbx,%rcx,1),%rdx
xor    0x0(%r13,%rcx,1),%rdx
mov    %rdx,(%r12,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1790 <AES_cbc_encrypt+0x650>
cmp    %rax,%r15
je     184d <AES_cbc_encrypt+0x70d>
mov    %rax,%rsi
not    %rsi
add    %r15,%rsi
mov    %r15,%rdx
and    $0x3,%rdx
je     17e7 <AES_cbc_encrypt+0x6a7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rax,1),%ecx
xor    0x0(%r13,%rax,1),%cl
mov    %cl,(%r12,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    17d0 <AES_cbc_encrypt+0x690>
cmp    $0x3,%rsi
jb     184d <AES_cbc_encrypt+0x70d>
nopl   (%rax)
movzbl (%rbx,%rax,1),%ecx
xor    0x0(%r13,%rax,1),%cl
mov    %cl,(%r12,%rax,1)
movzbl 0x1(%rbx,%rax,1),%ecx
xor    0x1(%r13,%rax,1),%cl
mov    %cl,0x1(%r12,%rax,1)
movzbl 0x2(%rbx,%rax,1),%ecx
xor    0x2(%r13,%rax,1),%cl
mov    %cl,0x2(%r12,%rax,1)
movzbl 0x3(%rbx,%rax,1),%ecx
xor    0x3(%r13,%rax,1),%cl
mov    %cl,0x3(%r12,%rax,1)
add    $0x4,%rax
cmp    %rax,%r15
jne    17f0 <AES_cbc_encrypt+0x6b0>
jmp    184d <AES_cbc_encrypt+0x70d>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rbx,%r15,1),%eax
mov    %al,(%r12,%r15,1)
add    $0x1,%r15
movslq (%r14),%rax
cmp    %rax,%r15
jb     1840 <AES_cbc_encrypt+0x700>
mov    %r12,%rdi
mov    %r12,%rsi
mov    -0x40(%rbp),%rdx
call   1050 <AES_encrypt@plt>
mov    (%r14),%edx
mov    -0x30(%rbp),%rdi
mov    %r12,%rsi
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <memcpy@plt>
xor    %ecx,%ecx
test   $0x1,%dl
je     18ab <AES_cbc_encrypt+0x76b>
movups (%r12,%rcx,1),%xmm0
movups 0x10(%r12,%rcx,1),%xmm1
movups (%rbx,%rcx,1),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%rbx,%rcx,1),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,(%rbx,%rcx,1)
movups %xmm0,0x10(%rbx,%rcx,1)
cmp    %rax,%r15
je     196d <AES_cbc_encrypt+0x82d>
test   $0x18,%r15b
je     18ea <AES_cbc_encrypt+0x7aa>
mov    %rax,%rcx
mov    %r15,%rax
and    $0xfffffffffffffff8,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r12,%rcx,1),%rdx
xor    %rdx,(%rbx,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    18d0 <AES_cbc_encrypt+0x790>
cmp    %rax,%r15
je     196d <AES_cbc_encrypt+0x82d>
mov    %rax,%rdi
not    %rdi
add    %r15,%rdi
mov    %r15,%rdx
and    $0x3,%rdx
je     1912 <AES_cbc_encrypt+0x7d2>
nopl   0x0(%rax)
movzbl (%r12,%rax,1),%ecx
xor    %cl,(%rbx,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1900 <AES_cbc_encrypt+0x7c0>
cmp    $0x3,%rdi
jb     196d <AES_cbc_encrypt+0x82d>
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rax,1),%ecx
xor    %cl,(%rbx,%rax,1)
movzbl 0x1(%r12,%rax,1),%ecx
xor    %cl,0x1(%rbx,%rax,1)
movzbl 0x2(%r12,%rax,1),%ecx
xor    %cl,0x2(%rbx,%rax,1)
movzbl 0x3(%r12,%rax,1),%ecx
xor    %cl,0x3(%rbx,%rax,1)
add    $0x4,%rax
cmp    %rax,%r15
jne    1920 <AES_cbc_encrypt+0x7e0>
jmp    196d <AES_cbc_encrypt+0x82d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rsi,%r15,1),%eax
mov    %al,(%rbx,%r15,1)
add    $0x1,%r15
movslq (%r8),%rdx
cmp    %rdx,%r15
jb     1960 <AES_cbc_encrypt+0x820>
mov    %r12,%rdi
call   1040 <memcpy@plt>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@AES_BLOCK_SIZE = global i32 0
@AES_ENCRYPT = constant i32 0
@AES_DECRYPT = constant i32 0
define void @AES_cbc_encrypt(i8* %0, i8* %1, i64 %2, i32* %3, i8* %4, i32 %5) {
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i32*
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i64
%14 = alloca i64
%15 = alloca i8*
%16 = alloca i64
%17 = alloca i8*
store i8* %0, i8** %7
store i8* %1, i8** %8
store i64 %2, i64* %9
store i32* %3, i32** %10
store i8* %4, i8** %11
store i32 %5, i32* %12
%18 = load i64, i64* %9
store i64 %18, i64* %14
%19 = load i32, i32* @AES_BLOCK_SIZE
%20 = zext i32 %19 to i64
%21 = call i8* @llvm.stacksave()
store i8* %21, i8** %15
%22 = alloca i8, i64 %20
store i64 %20, i64* %16
%23 = load i8*, i8** %11
store i8* %23, i8** %17
%24 = load i8*, i8** %7
%25 = icmp ne i8* %24, null
br i1 %25, label %26, label %35
26: ; preds = %6
%27 = load i8*, i8** %8
%28 = icmp ne i8* %27, null
br i1 %28, label %29, label %35
29: ; preds = %26
%30 = load i32*, i32** %10
%31 = icmp ne i32* %30, null
br i1 %31, label %32, label %35
32: ; preds = %29
%33 = load i8*, i8** %11
%34 = icmp ne i8* %33, null
br label %35
35: ; preds = %32, %29, %26, %6
%36 = phi i1 [ false, %29 ], [ false, %26 ], [ false, %6 ], [ %34, %32 ]
%37 = zext i1 %36 to i32
%38 = call i32 @assert(i32 %37)
%39 = load i32, i32* @AES_ENCRYPT
%40 = load i32, i32* %12
%41 = icmp eq i32 %39, %40
br i1 %41, label %46, label %42
42: ; preds = %35
%43 = load i32, i32* @AES_DECRYPT
%44 = load i32, i32* %12
%45 = icmp eq i32 %43, %44
br label %46
46: ; preds = %42, %35
%47 = phi i1 [ true, %35 ], [ %45, %42 ]
%48 = zext i1 %47 to i32
%49 = call i32 @assert(i32 %48)
%50 = load i32, i32* @AES_ENCRYPT
%51 = load i32, i32* %12
%52 = icmp eq i32 %50, %51
br i1 %52, label %53, label %158
53: ; preds = %46
br label %54
54: ; preds = %84, %53
%55 = load i64, i64* %14
%56 = load i32, i32* @AES_BLOCK_SIZE
%57 = sext i32 %56 to i64
%58 = icmp uge i64 %55, %57
br i1 %58, label %59, label %102
59: ; preds = %54
store i64 0, i64* %13
br label %60
60: ; preds = %81, %59
%61 = load i64, i64* %13
%62 = load i32, i32* @AES_BLOCK_SIZE
%63 = sext i32 %62 to i64
%64 = icmp ult i64 %61, %63
br i1 %64, label %65, label %84
65: ; preds = %60
%66 = load i8*, i8** %7
%67 = load i64, i64* %13
%68 = getelementptr inbounds i8, i8* %66, i64 %67
%69 = load i8, i8* %68
%70 = zext i8 %69 to i32
%71 = load i8*, i8** %17
%72 = load i64, i64* %13
%73 = getelementptr inbounds i8, i8* %71, i64 %72
%74 = load i8, i8* %73
%75 = zext i8 %74 to i32
%76 = xor i32 %70, %75
%77 = trunc i32 %76 to i8
%78 = load i8*, i8** %8
%79 = load i64, i64* %13
%80 = getelementptr inbounds i8, i8* %78, i64 %79
store i8 %77, i8* %80
br label %81
81: ; preds = %65
%82 = load i64, i64* %13
%83 = add i64 %82, 1
store i64 %83, i64* %13
br label %60
84: ; preds = %60
%85 = load i8*, i8** %8
%86 = load i8*, i8** %8
%87 = load i32*, i32** %10
%88 = call i32 @AES_encrypt(i8* %85, i8* %86, i32* %87)
%89 = load i8*, i8** %8
store i8* %89, i8** %17
%90 = load i32, i32* @AES_BLOCK_SIZE
%91 = sext i32 %90 to i64
%92 = load i64, i64* %14
%93 = sub i64 %92, %91
store i64 %93, i64* %14
%94 = load i32, i32* @AES_BLOCK_SIZE
%95 = load i8*, i8** %7
%96 = sext i32 %94 to i64
%97 = getelementptr inbounds i8, i8* %95, i64 %96
store i8* %97, i8** %7
%98 = load i32, i32* @AES_BLOCK_SIZE
%99 = load i8*, i8** %8
%100 = sext i32 %98 to i64
%101 = getelementptr inbounds i8, i8* %99, i64 %100
store i8* %101, i8** %8
br label %54
102: ; preds = %54
%103 = load i64, i64* %14
%104 = icmp ne i64 %103, 0
br i1 %104, label %105, label %153
105: ; preds = %102
store i64 0, i64* %13
br label %106
106: ; preds = %126, %105
%107 = load i64, i64* %13
%108 = load i64, i64* %14
%109 = icmp ult i64 %107, %108
br i1 %109, label %110, label %129
110: ; preds = %106
%111 = load i8*, i8** %7
%112 = load i64, i64* %13
%113 = getelementptr inbounds i8, i8* %111, i64 %112
%114 = load i8, i8* %113
%115 = zext i8 %114 to i32
%116 = load i8*, i8** %17
%117 = load i64, i64* %13
%118 = getelementptr inbounds i8, i8* %116, i64 %117
%119 = load i8, i8* %118
%120 = zext i8 %119 to i32
%121 = xor i32 %115, %120
%122 = trunc i32 %121 to i8
%123 = load i8*, i8** %8
%124 = load i64, i64* %13
%125 = getelementptr inbounds i8, i8* %123, i64 %124
store i8 %122, i8* %125
br label %126
126: ; preds = %110
%127 = load i64, i64* %13
%128 = add i64 %127, 1
store i64 %128, i64* %13
br label %106
129: ; preds = %106
%130 = load i64, i64* %14
store i64 %130, i64* %13
br label %131
131: ; preds = %144, %129
%132 = load i64, i64* %13
%133 = load i32, i32* @AES_BLOCK_SIZE
%134 = sext i32 %133 to i64
%135 = icmp ult i64 %132, %134
br i1 %135, label %136, label %147
136: ; preds = %131
%137 = load i8*, i8** %17
%138 = load i64, i64* %13
%139 = getelementptr inbounds i8, i8* %137, i64 %138
%140 = load i8, i8* %139
%141 = load i8*, i8** %8
%142 = load i64, i64* %13
%143 = getelementptr inbounds i8, i8* %141, i64 %142
store i8 %140, i8* %143
br label %144
144: ; preds = %136
%145 = load i64, i64* %13
%146 = add i64 %145, 1
store i64 %146, i64* %13
br label %131
147: ; preds = %131
%148 = load i8*, i8** %8
%149 = load i8*, i8** %8
%150 = load i32*, i32** %10
%151 = call i32 @AES_encrypt(i8* %148, i8* %149, i32* %150)
%152 = load i8*, i8** %8
store i8* %152, i8** %17
br label %153
153: ; preds = %147, %102
%154 = load i8*, i8** %11
%155 = load i8*, i8** %17
%156 = load i32, i32* @AES_BLOCK_SIZE
%157 = call i32 @memcpy(i8* %154, i8* %155, i32 %156)
br label %348
158: ; preds = %46
%159 = load i8*, i8** %7
%160 = load i8*, i8** %8
%161 = icmp ne i8* %159, %160
br i1 %161, label %162, label %244
162: ; preds = %158
br label %163
163: ; preds = %194, %162
%164 = load i64, i64* %14
%165 = load i32, i32* @AES_BLOCK_SIZE
%166 = sext i32 %165 to i64
%167 = icmp uge i64 %164, %166
br i1 %167, label %168, label %208
168: ; preds = %163
%169 = load i8*, i8** %7
%170 = load i8*, i8** %8
%171 = load i32*, i32** %10
%172 = call i32 @AES_decrypt(i8* %169, i8* %170, i32* %171)
store i64 0, i64* %13
br label %173
173: ; preds = %191, %168
%174 = load i64, i64* %13
%175 = load i32, i32* @AES_BLOCK_SIZE
%176 = sext i32 %175 to i64
%177 = icmp ult i64 %174, %176
br i1 %177, label %178, label %194
178: ; preds = %173
%179 = load i8*, i8** %17
%180 = load i64, i64* %13
%181 = getelementptr inbounds i8, i8* %179, i64 %180
%182 = load i8, i8* %181
%183 = zext i8 %182 to i32
%184 = load i8*, i8** %8
%185 = load i64, i64* %13
%186 = getelementptr inbounds i8, i8* %184, i64 %185
%187 = load i8, i8* %186
%188 = zext i8 %187 to i32
%189 = xor i32 %188, %183
%190 = trunc i32 %189 to i8
store i8 %190, i8* %186
br label %191
191: ; preds = %178
%192 = load i64, i64* %13
%193 = add i64 %192, 1
store i64 %193, i64* %13
br label %173
194: ; preds = %173
%195 = load i8*, i8** %7
store i8* %195, i8** %17
%196 = load i32, i32* @AES_BLOCK_SIZE
%197 = sext i32 %196 to i64
%198 = load i64, i64* %14
%199 = sub i64 %198, %197
store i64 %199, i64* %14
%200 = load i32, i32* @AES_BLOCK_SIZE
%201 = load i8*, i8** %7
%202 = sext i32 %200 to i64
%203 = getelementptr inbounds i8, i8* %201, i64 %202
store i8* %203, i8** %7
%204 = load i32, i32* @AES_BLOCK_SIZE
%205 = load i8*, i8** %8
%206 = sext i32 %204 to i64
%207 = getelementptr inbounds i8, i8* %205, i64 %206
store i8* %207, i8** %8
br label %163
208: ; preds = %163
%209 = load i64, i64* %14
%210 = icmp ne i64 %209, 0
br i1 %210, label %211, label %239
211: ; preds = %208
%212 = load i8*, i8** %7
%213 = load i32*, i32** %10
%214 = call i32 @AES_decrypt(i8* %212, i8* %22, i32* %213)
store i64 0, i64* %13
br label %215
215: ; preds = %234, %211
%216 = load i64, i64* %13
%217 = load i64, i64* %14
%218 = icmp ult i64 %216, %217
br i1 %218, label %219, label %237
219: ; preds = %215
%220 = load i64, i64* %13
%221 = getelementptr inbounds i8, i8* %22, i64 %220
%222 = load i8, i8* %221
%223 = zext i8 %222 to i32
%224 = load i8*, i8** %17
%225 = load i64, i64* %13
%226 = getelementptr inbounds i8, i8* %224, i64 %225
%227 = load i8, i8* %226
%228 = zext i8 %227 to i32
%229 = xor i32 %223, %228
%230 = trunc i32 %229 to i8
%231 = load i8*, i8** %8
%232 = load i64, i64* %13
%233 = getelementptr inbounds i8, i8* %231, i64 %232
store i8 %230, i8* %233
br label %234
234: ; preds = %219
%235 = load i64, i64* %13
%236 = add i64 %235, 1
store i64 %236, i64* %13
br label %215
237: ; preds = %215
%238 = load i8*, i8** %7
store i8* %238, i8** %17
br label %239
239: ; preds = %237, %208
%240 = load i8*, i8** %11
%241 = load i8*, i8** %17
%242 = load i32, i32* @AES_BLOCK_SIZE
%243 = call i32 @memcpy(i8* %240, i8* %241, i32 %242)
br label %347
244: ; preds = %158
br label %245
245: ; preds = %279, %244
%246 = load i64, i64* %14
%247 = load i32, i32* @AES_BLOCK_SIZE
%248 = sext i32 %247 to i64
%249 = icmp uge i64 %246, %248
br i1 %249, label %250, label %295
250: ; preds = %245
%251 = load i8*, i8** %7
%252 = load i32, i32* @AES_BLOCK_SIZE
%253 = call i32 @memcpy(i8* %22, i8* %251, i32 %252)
%254 = load i8*, i8** %7
%255 = load i8*, i8** %8
%256 = load i32*, i32** %10
%257 = call i32 @AES_decrypt(i8* %254, i8* %255, i32* %256)
store i64 0, i64* %13
br label %258
258: ; preds = %276, %250
%259 = load i64, i64* %13
%260 = load i32, i32* @AES_BLOCK_SIZE
%261 = sext i32 %260 to i64
%262 = icmp ult i64 %259, %261
br i1 %262, label %263, label %279
263: ; preds = %258
%264 = load i8*, i8** %11
%265 = load i64, i64* %13
%266 = getelementptr inbounds i8, i8* %264, i64 %265
%267 = load i8, i8* %266
%268 = zext i8 %267 to i32
%269 = load i8*, i8** %8
%270 = load i64, i64* %13
%271 = getelementptr inbounds i8, i8* %269, i64 %270
%272 = load i8, i8* %271
%273 = zext i8 %272 to i32
%274 = xor i32 %273, %268
%275 = trunc i32 %274 to i8
store i8 %275, i8* %271
br label %276
276: ; preds = %263
%277 = load i64, i64* %13
%278 = add i64 %277, 1
store i64 %278, i64* %13
br label %258
279: ; preds = %258
%280 = load i8*, i8** %11
%281 = load i32, i32* @AES_BLOCK_SIZE
%282 = call i32 @memcpy(i8* %280, i8* %22, i32 %281)
%283 = load i32, i32* @AES_BLOCK_SIZE
%284 = sext i32 %283 to i64
%285 = load i64, i64* %14
%286 = sub i64 %285, %284
store i64 %286, i64* %14
%287 = load i32, i32* @AES_BLOCK_SIZE
%288 = load i8*, i8** %7
%289 = sext i32 %287 to i64
%290 = getelementptr inbounds i8, i8* %288, i64 %289
store i8* %290, i8** %7
%291 = load i32, i32* @AES_BLOCK_SIZE
%292 = load i8*, i8** %8
%293 = sext i32 %291 to i64
%294 = getelementptr inbounds i8, i8* %292, i64 %293
store i8* %294, i8** %8
br label %245
295: ; preds = %245
%296 = load i64, i64* %14
%297 = icmp ne i64 %296, 0
br i1 %297, label %298, label %346
298: ; preds = %295
%299 = load i8*, i8** %7
%300 = load i32, i32* @AES_BLOCK_SIZE
%301 = call i32 @memcpy(i8* %22, i8* %299, i32 %300)
%302 = load i8*, i8** %8
%303 = load i32*, i32** %10
%304 = call i32 @AES_decrypt(i8* %22, i8* %302, i32* %303)
store i64 0, i64* %13
br label %305
305: ; preds = %322, %298
%306 = load i64, i64* %13
%307 = load i64, i64* %14
%308 = icmp ult i64 %306, %307
br i1 %308, label %309, label %325
309: ; preds = %305
%310 = load i8*, i8** %11
%311 = load i64, i64* %13
%312 = getelementptr inbounds i8, i8* %310, i64 %311
%313 = load i8, i8* %312
%314 = zext i8 %313 to i32
%315 = load i8*, i8** %8
%316 = load i64, i64* %13
%317 = getelementptr inbounds i8, i8* %315, i64 %316
%318 = load i8, i8* %317
%319 = zext i8 %318 to i32
%320 = xor i32 %319, %314
%321 = trunc i32 %320 to i8
store i8 %321, i8* %317
br label %322
322: ; preds = %309
%323 = load i64, i64* %13
%324 = add i64 %323, 1
store i64 %324, i64* %13
br label %305
325: ; preds = %305
%326 = load i64, i64* %14
store i64 %326, i64* %13
br label %327
327: ; preds = %339, %325
%328 = load i64, i64* %13
%329 = load i32, i32* @AES_BLOCK_SIZE
%330 = sext i32 %329 to i64
%331 = icmp ult i64 %328, %330
br i1 %331, label %332, label %342
332: ; preds = %327
%333 = load i64, i64* %13
%334 = getelementptr inbounds i8, i8* %22, i64 %333
%335 = load i8, i8* %334
%336 = load i8*, i8** %8
%337 = load i64, i64* %13
%338 = getelementptr inbounds i8, i8* %336, i64 %337
store i8 %335, i8* %338
br label %339
339: ; preds = %332
%340 = load i64, i64* %13
%341 = add i64 %340, 1
store i64 %341, i64* %13
br label %327
342: ; preds = %327
%343 = load i8*, i8** %11
%344 = load i32, i32* @AES_BLOCK_SIZE
%345 = call i32 @memcpy(i8* %343, i8* %22, i32 %344)
br label %346
346: ; preds = %342, %295
br label %347
347: ; preds = %346, %239
br label %348
348: ; preds = %347, %153
%349 = load i8*, i8** %15
ret void
}

LLVM IR (-O2):
@AES_BLOCK_SIZE = global i32 0
@AES_ENCRYPT = constant i32 0
@AES_DECRYPT = constant i32 0
define void @AES_cbc_encrypt(i8* %0, i8* %1, i64 %2, i32* %3, i8* %4, i32 %5) {
%7 = load i32, i32* @AES_BLOCK_SIZE
%8 = zext i32 %7 to i64
%9 = alloca i8, i64 %8
%10 = icmp ne i8* %0, null
%11 = icmp ne i8* %1, null
%12 = and i1 %10, %11
%13 = icmp ne i32* %3, null
%14 = and i1 %12, %13
%15 = icmp ne i8* %4, null
%16 = and i1 %14, %15
%17 = zext i1 %16 to i32
%18 = tail call i32 @assert(i32 %17)
%19 = icmp eq i32 %5, 0
%20 = zext i1 %19 to i32
%21 = tail call i32 @assert(i32 %20)
br i1 %19, label %22, label %244
22: ; preds = %6
%23 = load i32, i32* @AES_BLOCK_SIZE
%24 = sext i32 %23 to i64
%25 = icmp ugt i64 %24, %2
br i1 %25, label %53, label %26
26: ; preds = %22, %45
%27 = phi i32 [ %47, %45 ], [ %23, %22 ]
%28 = phi i8* [ %30, %45 ], [ %4, %22 ]
%29 = phi i8* [ %50, %45 ], [ %0, %22 ]
%30 = phi i8* [ %51, %45 ], [ %1, %22 ]
%31 = phi i64 [ %49, %45 ], [ %2, %22 ]
%32 = icmp eq i32 %27, 0
br i1 %32, label %45, label %33
33: ; preds = %26, %33
%34 = phi i64 [ %41, %33 ], [ 0, %26 ]
%35 = getelementptr inbounds i8, i8* %29, i64 %34
%36 = load i8, i8* %35
%37 = getelementptr inbounds i8, i8* %28, i64 %34
%38 = load i8, i8* %37
%39 = xor i8 %38, %36
%40 = getelementptr inbounds i8, i8* %30, i64 %34
store i8 %39, i8* %40
%41 = add nuw i64 %34, 1
%42 = load i32, i32* @AES_BLOCK_SIZE
%43 = sext i32 %42 to i64
%44 = icmp ult i64 %41, %43
br i1 %44, label %33, label %45
45: ; preds = %33, %26
%46 = tail call i32 @AES_encrypt(i8* %30, i8* %30, i32* %3)
%47 = load i32, i32* @AES_BLOCK_SIZE
%48 = sext i32 %47 to i64
%49 = sub i64 %31, %48
%50 = getelementptr inbounds i8, i8* %29, i64 %48
%51 = getelementptr inbounds i8, i8* %30, i64 %48
%52 = icmp ult i64 %49, %48
br i1 %52, label %53, label %26
53: ; preds = %45, %22
%54 = phi i32 [ %23, %22 ], [ %47, %45 ]
%55 = phi i64 [ %2, %22 ], [ %49, %45 ]
%56 = phi i8* [ %1, %22 ], [ %51, %45 ]
%57 = phi i8* [ %0, %22 ], [ %50, %45 ]
%58 = phi i8* [ %4, %22 ], [ %30, %45 ]
%59 = icmp eq i64 %55, 0
br i1 %59, label %240, label %60
60: ; preds = %53
%61 = icmp ult i64 %55, 8
br i1 %61, label %172, label %62
62: ; preds = %60
%63 = getelementptr i8, i8* %56, i64 %55
%64 = getelementptr i8, i8* %57, i64 %55
%65 = getelementptr i8, i8* %58, i64 %55
%66 = icmp ult i8* %56, %64
%67 = icmp ult i8* %57, %63
%68 = and i1 %66, %67
%69 = icmp ult i8* %56, %65
%70 = icmp ult i8* %58, %63
%71 = and i1 %69, %70
%72 = or i1 %68, %71
br i1 %72, label %172, label %73
73: ; preds = %62
%74 = icmp ult i64 %55, 32
br i1 %74, label %154, label %75
75: ; preds = %73
%76 = and i64 %55, -32
%77 = add i64 %76, -32
%78 = lshr exact i64 %77, 5
%79 = add nuw nsw i64 %78, 1
%80 = and i64 %79, 1
%81 = icmp eq i64 %77, 0
br i1 %81, label %127, label %82
82: ; preds = %75
%83 = and i64 %79, 1152921504606846974
br label %84
84: ; preds = %84, %82
%85 = phi i64 [ 0, %82 ], [ %124, %84 ]
%86 = phi i64 [ 0, %82 ], [ %125, %84 ]
%87 = getelementptr inbounds i8, i8* %57, i64 %85
%88 = bitcast i8* %87 to <16 x i8>*
%89 = load <16 x i8>, <16 x i8>* %88
%90 = getelementptr inbounds i8, i8* %87, i64 16
%91 = bitcast i8* %90 to <16 x i8>*
%92 = load <16 x i8>, <16 x i8>* %91
%93 = getelementptr inbounds i8, i8* %58, i64 %85
%94 = bitcast i8* %93 to <16 x i8>*
%95 = load <16 x i8>, <16 x i8>* %94
%96 = getelementptr inbounds i8, i8* %93, i64 16
%97 = bitcast i8* %96 to <16 x i8>*
%98 = load <16 x i8>, <16 x i8>* %97
%99 = xor <16 x i8> %95, %89
%100 = xor <16 x i8> %98, %92
%101 = getelementptr inbounds i8, i8* %56, i64 %85
%102 = bitcast i8* %101 to <16 x i8>*
store <16 x i8> %99, <16 x i8>* %102
%103 = getelementptr inbounds i8, i8* %101, i64 16
%104 = bitcast i8* %103 to <16 x i8>*
store <16 x i8> %100, <16 x i8>* %104
%105 = or i64 %85, 32
%106 = getelementptr inbounds i8, i8* %57, i64 %105
%107 = bitcast i8* %106 to <16 x i8>*
%108 = load <16 x i8>, <16 x i8>* %107
%109 = getelementptr inbounds i8, i8* %106, i64 16
%110 = bitcast i8* %109 to <16 x i8>*
%111 = load <16 x i8>, <16 x i8>* %110
%112 = getelementptr inbounds i8, i8* %58, i64 %105
%113 = bitcast i8* %112 to <16 x i8>*
%114 = load <16 x i8>, <16 x i8>* %113
%115 = getelementptr inbounds i8, i8* %112, i64 16
%116 = bitcast i8* %115 to <16 x i8>*
%117 = load <16 x i8>, <16 x i8>* %116
%118 = xor <16 x i8> %114, %108
%119 = xor <16 x i8> %117, %111
%120 = getelementptr inbounds i8, i8* %56, i64 %105
%121 = bitcast i8* %120 to <16 x i8>*
store <16 x i8> %118, <16 x i8>* %121
%122 = getelementptr inbounds i8, i8* %120, i64 16
%123 = bitcast i8* %122 to <16 x i8>*
store <16 x i8> %119, <16 x i8>* %123
%124 = add nuw i64 %85, 64
%125 = add i64 %86, 2
%126 = icmp eq i64 %125, %83
br i1 %126, label %127, label %84
127: ; preds = %84, %75
%128 = phi i64 [ 0, %75 ], [ %124, %84 ]
%129 = icmp eq i64 %80, 0
br i1 %129, label %149, label %130
130: ; preds = %127
%131 = getelementptr inbounds i8, i8* %57, i64 %128
%132 = bitcast i8* %131 to <16 x i8>*
%133 = load <16 x i8>, <16 x i8>* %132
%134 = getelementptr inbounds i8, i8* %131, i64 16
%135 = bitcast i8* %134 to <16 x i8>*
%136 = load <16 x i8>, <16 x i8>* %135
%137 = getelementptr inbounds i8, i8* %58, i64 %128
%138 = bitcast i8* %137 to <16 x i8>*
%139 = load <16 x i8>, <16 x i8>* %138
%140 = getelementptr inbounds i8, i8* %137, i64 16
%141 = bitcast i8* %140 to <16 x i8>*
%142 = load <16 x i8>, <16 x i8>* %141
%143 = xor <16 x i8> %139, %133
%144 = xor <16 x i8> %142, %136
%145 = getelementptr inbounds i8, i8* %56, i64 %128
%146 = bitcast i8* %145 to <16 x i8>*
store <16 x i8> %143, <16 x i8>* %146
%147 = getelementptr inbounds i8, i8* %145, i64 16
%148 = bitcast i8* %147 to <16 x i8>*
store <16 x i8> %144, <16 x i8>* %148
br label %149
149: ; preds = %127, %130
%150 = icmp eq i64 %55, %76
br i1 %150, label %193, label %151
151: ; preds = %149
%152 = and i64 %55, 24
%153 = icmp eq i64 %152, 0
br i1 %153, label %172, label %154
154: ; preds = %73, %151
%155 = phi i64 [ %76, %151 ], [ 0, %73 ]
%156 = and i64 %55, -8
br label %157
157: ; preds = %157, %154
%158 = phi i64 [ %155, %154 ], [ %168, %157 ]
%159 = getelementptr inbounds i8, i8* %57, i64 %158
%160 = bitcast i8* %159 to <8 x i8>*
%161 = load <8 x i8>, <8 x i8>* %160
%162 = getelementptr inbounds i8, i8* %58, i64 %158
%163 = bitcast i8* %162 to <8 x i8>*
%164 = load <8 x i8>, <8 x i8>* %163
%165 = xor <8 x i8> %164, %161
%166 = getelementptr inbounds i8, i8* %56, i64 %158
%167 = bitcast i8* %166 to <8 x i8>*
store <8 x i8> %165, <8 x i8>* %167
%168 = add nuw i64 %158, 8
%169 = icmp eq i64 %168, %156
br i1 %169, label %170, label %157
170: ; preds = %157
%171 = icmp eq i64 %55, %156
br i1 %171, label %193, label %172
172: ; preds = %62, %60, %151, %170
%173 = phi i64 [ 0, %60 ], [ 0, %62 ], [ %76, %151 ], [ %156, %170 ]
%174 = xor i64 %173, -1
%175 = add i64 %55, %174
%176 = and i64 %55, 3
%177 = icmp eq i64 %176, 0
br i1 %177, label %190, label %178
178: ; preds = %172, %178
%179 = phi i64 [ %187, %178 ], [ %173, %172 ]
%180 = phi i64 [ %188, %178 ], [ 0, %172 ]
%181 = getelementptr inbounds i8, i8* %57, i64 %179
%182 = load i8, i8* %181
%183 = getelementptr inbounds i8, i8* %58, i64 %179
%184 = load i8, i8* %183
%185 = xor i8 %184, %182
%186 = getelementptr inbounds i8, i8* %56, i64 %179
store i8 %185, i8* %186
%187 = add nuw i64 %179, 1
%188 = add i64 %180, 1
%189 = icmp eq i64 %188, %176
br i1 %189, label %190, label %178
190: ; preds = %178, %172
%191 = phi i64 [ %173, %172 ], [ %187, %178 ]
%192 = icmp ult i64 %175, 3
br i1 %192, label %193, label %197
193: ; preds = %190, %197, %170, %149
%194 = load i32, i32* @AES_BLOCK_SIZE
%195 = sext i32 %194 to i64
%196 = icmp ult i64 %55, %195
br i1 %196, label %228, label %237
197: ; preds = %190, %197
%198 = phi i64 [ %226, %197 ], [ %191, %190 ]
%199 = getelementptr inbounds i8, i8* %57, i64 %198
%200 = load i8, i8* %199
%201 = getelementptr inbounds i8, i8* %58, i64 %198
%202 = load i8, i8* %201
%203 = xor i8 %202, %200
%204 = getelementptr inbounds i8, i8* %56, i64 %198
store i8 %203, i8* %204
%205 = add nuw i64 %198, 1
%206 = getelementptr inbounds i8, i8* %57, i64 %205
%207 = load i8, i8* %206
%208 = getelementptr inbounds i8, i8* %58, i64 %205
%209 = load i8, i8* %208
%210 = xor i8 %209, %207
%211 = getelementptr inbounds i8, i8* %56, i64 %205
store i8 %210, i8* %211
%212 = add nuw i64 %198, 2
%213 = getelementptr inbounds i8, i8* %57, i64 %212
%214 = load i8, i8* %213
%215 = getelementptr inbounds i8, i8* %58, i64 %212
%216 = load i8, i8* %215
%217 = xor i8 %216, %214
%218 = getelementptr inbounds i8, i8* %56, i64 %212
store i8 %217, i8* %218
%219 = add nuw i64 %198, 3
%220 = getelementptr inbounds i8, i8* %57, i64 %219
%221 = load i8, i8* %220
%222 = getelementptr inbounds i8, i8* %58, i64 %219
%223 = load i8, i8* %222
%224 = xor i8 %223, %221
%225 = getelementptr inbounds i8, i8* %56, i64 %219
store i8 %224, i8* %225
%226 = add nuw i64 %198, 4
%227 = icmp eq i64 %226, %55
br i1 %227, label %193, label %197
228: ; preds = %193, %228
%229 = phi i64 [ %233, %228 ], [ %55, %193 ]
%230 = getelementptr inbounds i8, i8* %58, i64 %229
%231 = load i8, i8* %230
%232 = getelementptr inbounds i8, i8* %56, i64 %229
store i8 %231, i8* %232
%233 = add nuw i64 %229, 1
%234 = load i32, i32* @AES_BLOCK_SIZE
%235 = sext i32 %234 to i64
%236 = icmp ult i64 %233, %235
br i1 %236, label %228, label %237
237: ; preds = %228, %193
%238 = tail call i32 @AES_encrypt(i8* %56, i8* %56, i32* %3)
%239 = load i32, i32* @AES_BLOCK_SIZE
br label %240
240: ; preds = %237, %53
%241 = phi i32 [ %239, %237 ], [ %54, %53 ]
%242 = phi i8* [ %56, %237 ], [ %58, %53 ]
%243 = tail call i32 @memcpy(i8* %4, i8* %242, i32 %241)
br label %652
244: ; preds = %6
%245 = icmp eq i8* %0, %1
%246 = load i32, i32* @AES_BLOCK_SIZE
%247 = sext i32 %246 to i64
%248 = icmp ugt i64 %247, %2
br i1 %245, label %250, label %249
249: ; preds = %244
br i1 %248, label %277, label %251
250: ; preds = %244
br i1 %248, label %481, label %452
251: ; preds = %249, %270
%252 = phi i8* [ %253, %270 ], [ %4, %249 ]
%253 = phi i8* [ %274, %270 ], [ %0, %249 ]
%254 = phi i8* [ %275, %270 ], [ %1, %249 ]
%255 = phi i64 [ %273, %270 ], [ %2, %249 ]
%256 = tail call i32 @AES_decrypt(i8* %253, i8* %254, i32* %3)
%257 = load i32, i32* @AES_BLOCK_SIZE
%258 = icmp eq i32 %257, 0
br i1 %258, label %270, label %259
259: ; preds = %251, %259
%260 = phi i64 [ %266, %259 ], [ 0, %251 ]
%261 = getelementptr inbounds i8, i8* %252, i64 %260
%262 = load i8, i8* %261
%263 = getelementptr inbounds i8, i8* %254, i64 %260
%264 = load i8, i8* %263
%265 = xor i8 %264, %262
store i8 %265, i8* %263
%266 = add nuw i64 %260, 1
%267 = load i32, i32* @AES_BLOCK_SIZE
%268 = sext i32 %267 to i64
%269 = icmp ult i64 %266, %268
br i1 %269, label %259, label %270
270: ; preds = %259, %251
%271 = phi i32 [ 0, %251 ], [ %267, %259 ]
%272 = sext i32 %271 to i64
%273 = sub i64 %255, %272
%274 = getelementptr inbounds i8, i8* %253, i64 %272
%275 = getelementptr inbounds i8, i8* %254, i64 %272
%276 = icmp ult i64 %273, %272
br i1 %276, label %277, label %251
277: ; preds = %270, %249
%278 = phi i64 [ %2, %249 ], [ %273, %270 ]
%279 = phi i8* [ %1, %249 ], [ %275, %270 ]
%280 = phi i8* [ %0, %249 ], [ %274, %270 ]
%281 = phi i8* [ %4, %249 ], [ %253, %270 ]
%282 = icmp eq i64 %278, 0
br i1 %282, label %448, label %283
283: ; preds = %277
%284 = call i32 @AES_decrypt(i8* %280, i8* %9, i32* %3)
%285 = icmp ult i64 %278, 8
br i1 %285, label %396, label %286
286: ; preds = %283
%287 = getelementptr i8, i8* %279, i64 %278
%288 = getelementptr i8, i8* %9, i64 %278
%289 = getelementptr i8, i8* %281, i64 %278
%290 = icmp ult i8* %279, %288
%291 = icmp ult i8* %9, %287
%292 = and i1 %290, %291
%293 = icmp ult i8* %279, %289
%294 = icmp ult i8* %281, %287
%295 = and i1 %293, %294
%296 = or i1 %292, %295
br i1 %296, label %396, label %297
297: ; preds = %286
%298 = icmp ult i64 %278, 32
br i1 %298, label %378, label %299
299: ; preds = %297
%300 = and i64 %278, -32
%301 = add i64 %300, -32
%302 = lshr exact i64 %301, 5
%303 = add nuw nsw i64 %302, 1
%304 = and i64 %303, 1
%305 = icmp eq i64 %301, 0
br i1 %305, label %351, label %306
306: ; preds = %299
%307 = and i64 %303, 1152921504606846974
br label %308
308: ; preds = %308, %306
%309 = phi i64 [ 0, %306 ], [ %348, %308 ]
%310 = phi i64 [ 0, %306 ], [ %349, %308 ]
%311 = getelementptr inbounds i8, i8* %9, i64 %309
%312 = bitcast i8* %311 to <16 x i8>*
%313 = load <16 x i8>, <16 x i8>* %312
%314 = getelementptr inbounds i8, i8* %311, i64 16
%315 = bitcast i8* %314 to <16 x i8>*
%316 = load <16 x i8>, <16 x i8>* %315
%317 = getelementptr inbounds i8, i8* %281, i64 %309
%318 = bitcast i8* %317 to <16 x i8>*
%319 = load <16 x i8>, <16 x i8>* %318
%320 = getelementptr inbounds i8, i8* %317, i64 16
%321 = bitcast i8* %320 to <16 x i8>*
%322 = load <16 x i8>, <16 x i8>* %321
%323 = xor <16 x i8> %319, %313
%324 = xor <16 x i8> %322, %316
%325 = getelementptr inbounds i8, i8* %279, i64 %309
%326 = bitcast i8* %325 to <16 x i8>*
store <16 x i8> %323, <16 x i8>* %326
%327 = getelementptr inbounds i8, i8* %325, i64 16
%328 = bitcast i8* %327 to <16 x i8>*
store <16 x i8> %324, <16 x i8>* %328
%329 = or i64 %309, 32
%330 = getelementptr inbounds i8, i8* %9, i64 %329
%331 = bitcast i8* %330 to <16 x i8>*
%332 = load <16 x i8>, <16 x i8>* %331
%333 = getelementptr inbounds i8, i8* %330, i64 16
%334 = bitcast i8* %333 to <16 x i8>*
%335 = load <16 x i8>, <16 x i8>* %334
%336 = getelementptr inbounds i8, i8* %281, i64 %329
%337 = bitcast i8* %336 to <16 x i8>*
%338 = load <16 x i8>, <16 x i8>* %337
%339 = getelementptr inbounds i8, i8* %336, i64 16
%340 = bitcast i8* %339 to <16 x i8>*
%341 = load <16 x i8>, <16 x i8>* %340
%342 = xor <16 x i8> %338, %332
%343 = xor <16 x i8> %341, %335
%344 = getelementptr inbounds i8, i8* %279, i64 %329
%345 = bitcast i8* %344 to <16 x i8>*
store <16 x i8> %342, <16 x i8>* %345
%346 = getelementptr inbounds i8, i8* %344, i64 16
%347 = bitcast i8* %346 to <16 x i8>*
store <16 x i8> %343, <16 x i8>* %347
%348 = add nuw i64 %309, 64
%349 = add i64 %310, 2
%350 = icmp eq i64 %349, %307
br i1 %350, label %351, label %308
351: ; preds = %308, %299
%352 = phi i64 [ 0, %299 ], [ %348, %308 ]
%353 = icmp eq i64 %304, 0
br i1 %353, label %373, label %354
354: ; preds = %351
%355 = getelementptr inbounds i8, i8* %9, i64 %352
%356 = bitcast i8* %355 to <16 x i8>*
%357 = load <16 x i8>, <16 x i8>* %356
%358 = getelementptr inbounds i8, i8* %355, i64 16
%359 = bitcast i8* %358 to <16 x i8>*
%360 = load <16 x i8>, <16 x i8>* %359
%361 = getelementptr inbounds i8, i8* %281, i64 %352
%362 = bitcast i8* %361 to <16 x i8>*
%363 = load <16 x i8>, <16 x i8>* %362
%364 = getelementptr inbounds i8, i8* %361, i64 16
%365 = bitcast i8* %364 to <16 x i8>*
%366 = load <16 x i8>, <16 x i8>* %365
%367 = xor <16 x i8> %363, %357
%368 = xor <16 x i8> %366, %360
%369 = getelementptr inbounds i8, i8* %279, i64 %352
%370 = bitcast i8* %369 to <16 x i8>*
store <16 x i8> %367, <16 x i8>* %370
%371 = getelementptr inbounds i8, i8* %369, i64 16
%372 = bitcast i8* %371 to <16 x i8>*
store <16 x i8> %368, <16 x i8>* %372
br label %373
373: ; preds = %351, %354
%374 = icmp eq i64 %278, %300
br i1 %374, label %448, label %375
375: ; preds = %373
%376 = and i64 %278, 24
%377 = icmp eq i64 %376, 0
br i1 %377, label %396, label %378
378: ; preds = %297, %375
%379 = phi i64 [ %300, %375 ], [ 0, %297 ]
%380 = and i64 %278, -8
br label %381
381: ; preds = %381, %378
%382 = phi i64 [ %379, %378 ], [ %392, %381 ]
%383 = getelementptr inbounds i8, i8* %9, i64 %382
%384 = bitcast i8* %383 to <8 x i8>*
%385 = load <8 x i8>, <8 x i8>* %384
%386 = getelementptr inbounds i8, i8* %281, i64 %382
%387 = bitcast i8* %386 to <8 x i8>*
%388 = load <8 x i8>, <8 x i8>* %387
%389 = xor <8 x i8> %388, %385
%390 = getelementptr inbounds i8, i8* %279, i64 %382
%391 = bitcast i8* %390 to <8 x i8>*
store <8 x i8> %389, <8 x i8>* %391
%392 = add nuw i64 %382, 8
%393 = icmp eq i64 %392, %380
br i1 %393, label %394, label %381
394: ; preds = %381
%395 = icmp eq i64 %278, %380
br i1 %395, label %448, label %396
396: ; preds = %286, %283, %375, %394
%397 = phi i64 [ 0, %283 ], [ 0, %286 ], [ %300, %375 ], [ %380, %394 ]
%398 = xor i64 %397, -1
%399 = add i64 %278, %398
%400 = and i64 %278, 3
%401 = icmp eq i64 %400, 0
br i1 %401, label %414, label %402
402: ; preds = %396, %402
%403 = phi i64 [ %411, %402 ], [ %397, %396 ]
%404 = phi i64 [ %412, %402 ], [ 0, %396 ]
%405 = getelementptr inbounds i8, i8* %9, i64 %403
%406 = load i8, i8* %405
%407 = getelementptr inbounds i8, i8* %281, i64 %403
%408 = load i8, i8* %407
%409 = xor i8 %408, %406
%410 = getelementptr inbounds i8, i8* %279, i64 %403
store i8 %409, i8* %410
%411 = add nuw i64 %403, 1
%412 = add i64 %404, 1
%413 = icmp eq i64 %412, %400
br i1 %413, label %414, label %402
414: ; preds = %402, %396
%415 = phi i64 [ %397, %396 ], [ %411, %402 ]
%416 = icmp ult i64 %399, 3
br i1 %416, label %448, label %417
417: ; preds = %414, %417
%418 = phi i64 [ %446, %417 ], [ %415, %414 ]
%419 = getelementptr inbounds i8, i8* %9, i64 %418
%420 = load i8, i8* %419
%421 = getelementptr inbounds i8, i8* %281, i64 %418
%422 = load i8, i8* %421
%423 = xor i8 %422, %420
%424 = getelementptr inbounds i8, i8* %279, i64 %418
store i8 %423, i8* %424
%425 = add nuw i64 %418, 1
%426 = getelementptr inbounds i8, i8* %9, i64 %425
%427 = load i8, i8* %426
%428 = getelementptr inbounds i8, i8* %281, i64 %425
%429 = load i8, i8* %428
%430 = xor i8 %429, %427
%431 = getelementptr inbounds i8, i8* %279, i64 %425
store i8 %430, i8* %431
%432 = add nuw i64 %418, 2
%433 = getelementptr inbounds i8, i8* %9, i64 %432
%434 = load i8, i8* %433
%435 = getelementptr inbounds i8, i8* %281, i64 %432
%436 = load i8, i8* %435
%437 = xor i8 %436, %434
%438 = getelementptr inbounds i8, i8* %279, i64 %432
store i8 %437, i8* %438
%439 = add nuw i64 %418, 3
%440 = getelementptr inbounds i8, i8* %9, i64 %439
%441 = load i8, i8* %440
%442 = getelementptr inbounds i8, i8* %281, i64 %439
%443 = load i8, i8* %442
%444 = xor i8 %443, %441
%445 = getelementptr inbounds i8, i8* %279, i64 %439
store i8 %444, i8* %445
%446 = add nuw i64 %418, 4
%447 = icmp eq i64 %446, %278
br i1 %447, label %448, label %417
448: ; preds = %414, %417, %373, %394, %277
%449 = phi i8* [ %281, %277 ], [ %280, %394 ], [ %280, %373 ], [ %280, %417 ], [ %280, %414 ]
%450 = load i32, i32* @AES_BLOCK_SIZE
%451 = call i32 @memcpy(i8* %4, i8* %449, i32 %450)
br label %652
452: ; preds = %250, %472
%453 = phi i32 [ %475, %472 ], [ %246, %250 ]
%454 = phi i8* [ %478, %472 ], [ %0, %250 ]
%455 = phi i8* [ %479, %472 ], [ %0, %250 ]
%456 = phi i64 [ %477, %472 ], [ %2, %250 ]
%457 = call i32 @memcpy(i8* %9, i8* %454, i32 %453)
%458 = call i32 @AES_decrypt(i8* %454, i8* %455, i32* %3)
%459 = load i32, i32* @AES_BLOCK_SIZE
%460 = icmp eq i32 %459, 0
br i1 %460, label %472, label %461
461: ; preds = %452, %461
%462 = phi i64 [ %468, %461 ], [ 0, %452 ]
%463 = getelementptr inbounds i8, i8* %4, i64 %462
%464 = load i8, i8* %463
%465 = getelementptr inbounds i8, i8* %455, i64 %462
%466 = load i8, i8* %465
%467 = xor i8 %466, %464
store i8 %467, i8* %465
%468 = add nuw i64 %462, 1
%469 = load i32, i32* @AES_BLOCK_SIZE
%470 = sext i32 %469 to i64
%471 = icmp ult i64 %468, %470
br i1 %471, label %461, label %472
472: ; preds = %461, %452
%473 = phi i32 [ 0, %452 ], [ %469, %461 ]
%474 = call i32 @memcpy(i8* %4, i8* %9, i32 %473)
%475 = load i32, i32* @AES_BLOCK_SIZE
%476 = sext i32 %475 to i64
%477 = sub i64 %456, %476
%478 = getelementptr inbounds i8, i8* %454, i64 %476
%479 = getelementptr inbounds i8, i8* %455, i64 %476
%480 = icmp ult i64 %477, %476
br i1 %480, label %481, label %452
481: ; preds = %472, %250
%482 = phi i64 [ %2, %250 ], [ %477, %472 ]
%483 = phi i8* [ %0, %250 ], [ %479, %472 ]
%484 = phi i8* [ %0, %250 ], [ %478, %472 ]
%485 = phi i32 [ %246, %250 ], [ %475, %472 ]
%486 = icmp eq i64 %482, 0
br i1 %486, label %652, label %487
487: ; preds = %481
%488 = call i32 @memcpy(i8* %9, i8* %484, i32 %485)
%489 = call i32 @AES_decrypt(i8* %9, i8* %483, i32* %3)
%490 = icmp ult i64 %482, 8
br i1 %490, label %589, label %491
491: ; preds = %487
%492 = getelementptr i8, i8* %483, i64 %482
%493 = getelementptr i8, i8* %4, i64 %482
%494 = icmp ult i8* %483, %493
%495 = icmp ugt i8* %492, %4
%496 = and i1 %494, %495
br i1 %496, label %589, label %497
497: ; preds = %491
%498 = icmp ult i64 %482, 32
br i1 %498, label %572, label %499
499: ; preds = %497
%500 = and i64 %482, -32
%501 = add i64 %500, -32
%502 = lshr exact i64 %501, 5
%503 = add nuw nsw i64 %502, 1
%504 = and i64 %503, 1
%505 = icmp eq i64 %501, 0
br i1 %505, label %547, label %506
506: ; preds = %499
%507 = and i64 %503, 1152921504606846974
br label %508
508: ; preds = %508, %506
%509 = phi i64 [ 0, %506 ], [ %544, %508 ]
%510 = phi i64 [ 0, %506 ], [ %545, %508 ]
%511 = getelementptr inbounds i8, i8* %4, i64 %509
%512 = bitcast i8* %511 to <16 x i8>*
%513 = load <16 x i8>, <16 x i8>* %512
%514 = getelementptr inbounds i8, i8* %511, i64 16
%515 = bitcast i8* %514 to <16 x i8>*
%516 = load <16 x i8>, <16 x i8>* %515
%517 = getelementptr inbounds i8, i8* %483, i64 %509
%518 = bitcast i8* %517 to <16 x i8>*
%519 = load <16 x i8>, <16 x i8>* %518
%520 = getelementptr inbounds i8, i8* %517, i64 16
%521 = bitcast i8* %520 to <16 x i8>*
%522 = load <16 x i8>, <16 x i8>* %521
%523 = xor <16 x i8> %519, %513
%524 = xor <16 x i8> %522, %516
%525 = bitcast i8* %517 to <16 x i8>*
store <16 x i8> %523, <16 x i8>* %525
%526 = bitcast i8* %520 to <16 x i8>*
store <16 x i8> %524, <16 x i8>* %526
%527 = or i64 %509, 32
%528 = getelementptr inbounds i8, i8* %4, i64 %527
%529 = bitcast i8* %528 to <16 x i8>*
%530 = load <16 x i8>, <16 x i8>* %529
%531 = getelementptr inbounds i8, i8* %528, i64 16
%532 = bitcast i8* %531 to <16 x i8>*
%533 = load <16 x i8>, <16 x i8>* %532
%534 = getelementptr inbounds i8, i8* %483, i64 %527
%535 = bitcast i8* %534 to <16 x i8>*
%536 = load <16 x i8>, <16 x i8>* %535
%537 = getelementptr inbounds i8, i8* %534, i64 16
%538 = bitcast i8* %537 to <16 x i8>*
%539 = load <16 x i8>, <16 x i8>* %538
%540 = xor <16 x i8> %536, %530
%541 = xor <16 x i8> %539, %533
%542 = bitcast i8* %534 to <16 x i8>*
store <16 x i8> %540, <16 x i8>* %542
%543 = bitcast i8* %537 to <16 x i8>*
store <16 x i8> %541, <16 x i8>* %543
%544 = add nuw i64 %509, 64
%545 = add i64 %510, 2
%546 = icmp eq i64 %545, %507
br i1 %546, label %547, label %508
547: ; preds = %508, %499
%548 = phi i64 [ 0, %499 ], [ %544, %508 ]
%549 = icmp eq i64 %504, 0
br i1 %549, label %567, label %550
550: ; preds = %547
%551 = getelementptr inbounds i8, i8* %4, i64 %548
%552 = bitcast i8* %551 to <16 x i8>*
%553 = load <16 x i8>, <16 x i8>* %552
%554 = getelementptr inbounds i8, i8* %551, i64 16
%555 = bitcast i8* %554 to <16 x i8>*
%556 = load <16 x i8>, <16 x i8>* %555
%557 = getelementptr inbounds i8, i8* %483, i64 %548
%558 = bitcast i8* %557 to <16 x i8>*
%559 = load <16 x i8>, <16 x i8>* %558
%560 = getelementptr inbounds i8, i8* %557, i64 16
%561 = bitcast i8* %560 to <16 x i8>*
%562 = load <16 x i8>, <16 x i8>* %561
%563 = xor <16 x i8> %559, %553
%564 = xor <16 x i8> %562, %556
%565 = bitcast i8* %557 to <16 x i8>*
store <16 x i8> %563, <16 x i8>* %565
%566 = bitcast i8* %560 to <16 x i8>*
store <16 x i8> %564, <16 x i8>* %566
br label %567
567: ; preds = %547, %550
%568 = icmp eq i64 %482, %500
br i1 %568, label %609, label %569
569: ; preds = %567
%570 = and i64 %482, 24
%571 = icmp eq i64 %570, 0
br i1 %571, label %589, label %572
572: ; preds = %497, %569
%573 = phi i64 [ %500, %569 ], [ 0, %497 ]
%574 = and i64 %482, -8
br label %575
575: ; preds = %575, %572
%576 = phi i64 [ %573, %572 ], [ %585, %575 ]
%577 = getelementptr inbounds i8, i8* %4, i64 %576
%578 = bitcast i8* %577 to <8 x i8>*
%579 = load <8 x i8>, <8 x i8>* %578
%580 = getelementptr inbounds i8, i8* %483, i64 %576
%581 = bitcast i8* %580 to <8 x i8>*
%582 = load <8 x i8>, <8 x i8>* %581
%583 = xor <8 x i8> %582, %579
%584 = bitcast i8* %580 to <8 x i8>*
store <8 x i8> %583, <8 x i8>* %584
%585 = add nuw i64 %576, 8
%586 = icmp eq i64 %585, %574
br i1 %586, label %587, label %575
587: ; preds = %575
%588 = icmp eq i64 %482, %574
br i1 %588, label %609, label %589
589: ; preds = %491, %487, %569, %587
%590 = phi i64 [ 0, %487 ], [ 0, %491 ], [ %500, %569 ], [ %574, %587 ]
%591 = xor i64 %590, -1
%592 = add i64 %482, %591
%593 = and i64 %482, 3
%594 = icmp eq i64 %593, 0
br i1 %594, label %606, label %595
595: ; preds = %589, %595
%596 = phi i64 [ %603, %595 ], [ %590, %589 ]
%597 = phi i64 [ %604, %595 ], [ 0, %589 ]
%598 = getelementptr inbounds i8, i8* %4, i64 %596
%599 = load i8, i8* %598
%600 = getelementptr inbounds i8, i8* %483, i64 %596
%601 = load i8, i8* %600
%602 = xor i8 %601, %599
store i8 %602, i8* %600
%603 = add nuw i64 %596, 1
%604 = add i64 %597, 1
%605 = icmp eq i64 %604, %593
br i1 %605, label %606, label %595
606: ; preds = %595, %589
%607 = phi i64 [ %590, %589 ], [ %603, %595 ]
%608 = icmp ult i64 %592, 3
br i1 %608, label %609, label %613
609: ; preds = %606, %613, %587, %567
%610 = load i32, i32* @AES_BLOCK_SIZE
%611 = sext i32 %610 to i64
%612 = icmp ult i64 %482, %611
br i1 %612, label %640, label %649
613: ; preds = %606, %613
%614 = phi i64 [ %638, %613 ], [ %607, %606 ]
%615 = getelementptr inbounds i8, i8* %4, i64 %614
%616 = load i8, i8* %615
%617 = getelementptr inbounds i8, i8* %483, i64 %614
%618 = load i8, i8* %617
%619 = xor i8 %618, %616
store i8 %619, i8* %617
%620 = add nuw i64 %614, 1
%621 = getelementptr inbounds i8, i8* %4, i64 %620
%622 = load i8, i8* %621
%623 = getelementptr inbounds i8, i8* %483, i64 %620
%624 = load i8, i8* %623
%625 = xor i8 %624, %622
store i8 %625, i8* %623
%626 = add nuw i64 %614, 2
%627 = getelementptr inbounds i8, i8* %4, i64 %626
%628 = load i8, i8* %627
%629 = getelementptr inbounds i8, i8* %483, i64 %626
%630 = load i8, i8* %629
%631 = xor i8 %630, %628
store i8 %631, i8* %629
%632 = add nuw i64 %614, 3
%633 = getelementptr inbounds i8, i8* %4, i64 %632
%634 = load i8, i8* %633
%635 = getelementptr inbounds i8, i8* %483, i64 %632
%636 = load i8, i8* %635
%637 = xor i8 %636, %634
store i8 %637, i8* %635
%638 = add nuw i64 %614, 4
%639 = icmp eq i64 %638, %482
br i1 %639, label %609, label %613
640: ; preds = %609, %640
%641 = phi i64 [ %645, %640 ], [ %482, %609 ]
%642 = getelementptr inbounds i8, i8* %9, i64 %641
%643 = load i8, i8* %642
%644 = getelementptr inbounds i8, i8* %483, i64 %641
store i8 %643, i8* %644
%645 = add nuw i64 %641, 1
%646 = load i32, i32* @AES_BLOCK_SIZE
%647 = sext i32 %646 to i64
%648 = icmp ult i64 %645, %647
br i1 %648, label %640, label %649
649: ; preds = %640, %609
%650 = phi i32 [ %610, %609 ], [ %646, %640 ]
%651 = call i32 @memcpy(i8* %4, i8* %9, i32 %650)
br label %652
652: ; preds = %448, %649, %481, %240
ret void
}