#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*/ plain_pre_8;

/* Variables and functions */
int /*<<< orphan*/ encipher(unsigned int *, unsigned int *, unsigned int *);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, int);
int /*<<< orphan*/ memset(unsigned char *, int, int);
int random();
void qqencrypt(unsigned char *instr, int instrlen, unsigned char *key,
               unsigned char *outstr, int *outstrlen_ptr) {
  unsigned char plain[8], plain_pre_8[8], *crypted, *crypted_pre_8, *inp;
  int pos_in_byte = 1, is_header = 1, count = 0, padding = 0;
  pos_in_byte = (instrlen + 0x0a) % 8;
  if (pos_in_byte) {
    pos_in_byte = 8 - pos_in_byte;
  }
  plain[0] = (random() & 0xf8) | pos_in_byte;
  memset(plain + 1, random() & 0xff, pos_in_byte++);
  memset(plain_pre_8, 0x00, sizeof(plain_pre_8));
  crypted = crypted_pre_8 = outstr;
  padding = 1;
  while (padding <= 2) {
    if (pos_in_byte < 8) {
      plain[pos_in_byte++] = random() & 0xff;
      padding++;
    }
    if (pos_in_byte == 8) {
      {
        for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
          if (is_header) {
            plain[pos_in_byte] ^= plain_pre_8[pos_in_byte];
          } else {
            plain[pos_in_byte] ^= crypted_pre_8[pos_in_byte];
          }
        }
        encipher((unsigned int *)plain, (unsigned int *)key,
                 (unsigned int *)crypted);
        for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
          crypted[pos_in_byte] ^= plain_pre_8[pos_in_byte];
        }
        memcpy(plain_pre_8, plain, 8);
        crypted_pre_8 = crypted;
        crypted += 8;
        count += 8;
        pos_in_byte = 0;
        is_header = 0;
      };
    }
  }
  inp = instr;
  while (instrlen > 0) {
    if (pos_in_byte < 8) {
      plain[pos_in_byte++] = *(inp++);
      instrlen--;
    }
    if (pos_in_byte == 8) {
      {
        for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
          if (is_header) {
            plain[pos_in_byte] ^= plain_pre_8[pos_in_byte];
          } else {
            plain[pos_in_byte] ^= crypted_pre_8[pos_in_byte];
          }
        }
        encipher((unsigned int *)plain, (unsigned int *)key,
                 (unsigned int *)crypted);
        for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
          crypted[pos_in_byte] ^= plain_pre_8[pos_in_byte];
        }
        memcpy(plain_pre_8, plain, 8);
        crypted_pre_8 = crypted;
        crypted += 8;
        count += 8;
        pos_in_byte = 0;
        is_header = 0;
      };
    }
  }
  padding = 1;
  while (padding <= 7) {
    if (pos_in_byte < 8) {
      plain[pos_in_byte++] = 0x00;
      padding++;
    }
    if (pos_in_byte == 8) {
      {
        for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
          if (is_header) {
            plain[pos_in_byte] ^= plain_pre_8[pos_in_byte];
          } else {
            plain[pos_in_byte] ^= crypted_pre_8[pos_in_byte];
          }
        }
        encipher((unsigned int *)plain, (unsigned int *)key,
                 (unsigned int *)crypted);
        for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
          crypted[pos_in_byte] ^= plain_pre_8[pos_in_byte];
        }
        memcpy(plain_pre_8, plain, 8);
        crypted_pre_8 = crypted;
        crypted += 8;
        count += 8;
        pos_in_byte = 0;
        is_header = 0;
      };
    }
  }
  *outstrlen_ptr = count;
}


x86 assembly (clang, -O0):
<qqencrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x1,-0x54(%rbp)
movl   $0x1,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0xc(%rbp),%eax
add    $0xa,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %edx,-0x54(%rbp)
cmpl   $0x0,-0x54(%rbp)
je     119d <qqencrypt+0x5d>
mov    $0x8,%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    $0x0,%al
call   1060 <random@plt>
and    $0xf8,%eax
or     -0x54(%rbp),%eax
mov    %al,-0x30(%rbp)
lea    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
mov    $0x0,%al
call   1060 <random@plt>
mov    -0x68(%rbp),%rdi
mov    %eax,%esi
and    $0xff,%esi
mov    -0x54(%rbp),%edx
mov    %edx,%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
call   1030 <memset@plt>
lea    -0x38(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1030 <memset@plt>
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    %rax,-0x40(%rbp)
movl   $0x1,-0x60(%rbp)
cmpl   $0x2,-0x60(%rbp)
jg     1339 <qqencrypt+0x1f9>
cmpl   $0x8,-0x54(%rbp)
jge    123d <qqencrypt+0xfd>
mov    $0x0,%al
call   1060 <random@plt>
and    $0xff,%eax
mov    %al,%cl
mov    -0x54(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x54(%rbp)
cltq
mov    %cl,-0x30(%rbp,%rax,1)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x8,-0x54(%rbp)
jne    1334 <qqencrypt+0x1f4>
movl   $0x0,-0x54(%rbp)
cmpl   $0x8,-0x54(%rbp)
jge    12ad <qqencrypt+0x16d>
cmpl   $0x0,-0x58(%rbp)
je     127f <qqencrypt+0x13f>
movslq -0x54(%rbp),%rax
movzbl -0x38(%rbp,%rax,1),%edx
movslq -0x54(%rbp),%rax
movzbl -0x30(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x30(%rbp,%rax,1)
jmp    129a <qqencrypt+0x15a>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
movslq -0x54(%rbp),%rax
movzbl -0x30(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x30(%rbp,%rax,1)
jmp    129f <qqencrypt+0x15f>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    124e <qqencrypt+0x10e>
lea    -0x30(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x40(%rbp),%rdx
call   1040 <encipher@plt>
movl   $0x0,-0x54(%rbp)
cmpl   $0x8,-0x54(%rbp)
jge    12f7 <qqencrypt+0x1b7>
movslq -0x54(%rbp),%rax
movzbl -0x38(%rbp,%rax,1),%esi
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12c5 <qqencrypt+0x185>
lea    -0x38(%rbp),%rdi
lea    -0x30(%rbp),%rsi
mov    $0x8,%edx
call   1050 <memcpy@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
jmp    1201 <qqencrypt+0xc1>
mov    -0x8(%rbp),%rax
mov    %rax,-0x50(%rbp)
cmpl   $0x0,-0xc(%rbp)
jle    147c <qqencrypt+0x33c>
cmpl   $0x8,-0x54(%rbp)
jge    1380 <qqencrypt+0x240>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
mov    (%rax),%cl
mov    -0x54(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x54(%rbp)
cltq
mov    %cl,-0x30(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x8,-0x54(%rbp)
jne    1477 <qqencrypt+0x337>
movl   $0x0,-0x54(%rbp)
cmpl   $0x8,-0x54(%rbp)
jge    13f0 <qqencrypt+0x2b0>
cmpl   $0x0,-0x58(%rbp)
je     13c2 <qqencrypt+0x282>
movslq -0x54(%rbp),%rax
movzbl -0x38(%rbp,%rax,1),%edx
movslq -0x54(%rbp),%rax
movzbl -0x30(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x30(%rbp,%rax,1)
jmp    13dd <qqencrypt+0x29d>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
movslq -0x54(%rbp),%rax
movzbl -0x30(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x30(%rbp,%rax,1)
jmp    13e2 <qqencrypt+0x2a2>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1391 <qqencrypt+0x251>
lea    -0x30(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x40(%rbp),%rdx
call   1040 <encipher@plt>
movl   $0x0,-0x54(%rbp)
cmpl   $0x8,-0x54(%rbp)
jge    143a <qqencrypt+0x2fa>
movslq -0x54(%rbp),%rax
movzbl -0x38(%rbp,%rax,1),%esi
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1408 <qqencrypt+0x2c8>
lea    -0x38(%rbp),%rdi
lea    -0x30(%rbp),%rsi
mov    $0x8,%edx
call   1050 <memcpy@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
jmp    1341 <qqencrypt+0x201>
movl   $0x1,-0x60(%rbp)
cmpl   $0x7,-0x60(%rbp)
jg     15ae <qqencrypt+0x46e>
cmpl   $0x8,-0x54(%rbp)
jge    14b2 <qqencrypt+0x372>
mov    -0x54(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x54(%rbp)
cltq
movb   $0x0,-0x30(%rbp,%rax,1)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x8,-0x54(%rbp)
jne    15a9 <qqencrypt+0x469>
movl   $0x0,-0x54(%rbp)
cmpl   $0x8,-0x54(%rbp)
jge    1522 <qqencrypt+0x3e2>
cmpl   $0x0,-0x58(%rbp)
je     14f4 <qqencrypt+0x3b4>
movslq -0x54(%rbp),%rax
movzbl -0x38(%rbp,%rax,1),%edx
movslq -0x54(%rbp),%rax
movzbl -0x30(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x30(%rbp,%rax,1)
jmp    150f <qqencrypt+0x3cf>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
movslq -0x54(%rbp),%rax
movzbl -0x30(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x30(%rbp,%rax,1)
jmp    1514 <qqencrypt+0x3d4>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    14c3 <qqencrypt+0x383>
lea    -0x30(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x40(%rbp),%rdx
call   1040 <encipher@plt>
movl   $0x0,-0x54(%rbp)
cmpl   $0x8,-0x54(%rbp)
jge    156c <qqencrypt+0x42c>
movslq -0x54(%rbp),%rax
movzbl -0x38(%rbp,%rax,1),%esi
mov    -0x40(%rbp),%rax
movslq -0x54(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    153a <qqencrypt+0x3fa>
lea    -0x38(%rbp),%rdi
lea    -0x30(%rbp),%rsi
mov    $0x8,%edx
call   1050 <memcpy@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
jmp    1483 <qqencrypt+0x343>
mov    -0x5c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qqencrypt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r8,0x30(%rsp)
mov    %rcx,%rbx
mov    %rdx,0x20(%rsp)
mov    %rdi,0x18(%rsp)
lea    0xa(%rsi),%eax
lea    0x11(%rsi),%ecx
test   %eax,%eax
cmovns %eax,%ecx
and    $0xfffffff8,%ecx
neg    %ecx
mov    %rsi,0x28(%rsp)
lea    (%rsi,%rcx,1),%eax
add    $0xa,%eax
mov    $0x8,%ebp
sub    %eax,%ebp
test   %eax,%eax
cmove  %eax,%ebp
xor    %eax,%eax
call   1060 <random@plt>
and    $0xf8,%eax
or     %ebp,%eax
mov    %al,0x4(%rsp)
lea    0x5(%rsp),%r14
xor    %eax,%eax
call   1060 <random@plt>
movzbl %al,%esi
lea    0x1(%rbp),%r13d
mov    %r14,%rdi
mov    %ebp,%edx
call   1030 <memset@plt>
lea    0xc(%rsp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1030 <memset@plt>
mov    $0x1,%r12d
movl   $0x0,0x14(%rsp)
mov    $0x1,%ebp
mov    %rbx,%r14
jmp    11ed <qqencrypt+0xad>
nop
mov    %r14,%r15
cmp    $0x3,%r12d
jge    1328 <qqencrypt+0x1e8>
cmp    $0x7,%r13d
jg     1209 <qqencrypt+0xc9>
xor    %eax,%eax
call   1060 <random@plt>
movslq %r13d,%rcx
add    $0x1,%r13d
mov    %al,0x4(%rsp,%rcx,1)
add    $0x1,%r12d
cmp    $0x8,%r13d
jne    11e0 <qqencrypt+0xa0>
test   %ebp,%ebp
je     1259 <qqencrypt+0x119>
movzbl 0xc(%rsp),%eax
xor    %al,0x4(%rsp)
movzbl 0xd(%rsp),%eax
xor    %al,0x5(%rsp)
movzbl 0xe(%rsp),%eax
xor    %al,0x6(%rsp)
movzbl 0xf(%rsp),%eax
xor    %al,0x7(%rsp)
movzbl 0x10(%rsp),%eax
xor    %al,0x8(%rsp)
movzbl 0x11(%rsp),%eax
xor    %al,0x9(%rsp)
movzbl 0x12(%rsp),%eax
xor    %al,0xa(%rsp)
lea    0x13(%rsp),%rbx
jmp    1294 <qqencrypt+0x154>
movzbl (%rbx),%eax
xor    %al,0x4(%rsp)
movzbl 0x1(%rbx),%eax
xor    %al,0x5(%rsp)
movzbl 0x2(%rbx),%eax
xor    %al,0x6(%rsp)
movzbl 0x3(%rbx),%eax
xor    %al,0x7(%rsp)
movzbl 0x4(%rbx),%eax
xor    %al,0x8(%rsp)
movzbl 0x5(%rbx),%eax
xor    %al,0x9(%rsp)
movzbl 0x6(%rbx),%eax
xor    %al,0xa(%rsp)
add    $0x7,%rbx
mov    0x14(%rsp),%ebp
movzbl (%rbx),%eax
xor    %al,0xb(%rsp)
lea    0x4(%rsp),%rbx
mov    %rbx,%rdi
mov    0x20(%rsp),%rsi
mov    %r14,%rdx
call   1040 <encipher@plt>
movzbl 0xc(%rsp),%eax
xor    %al,(%r14)
movzbl 0xd(%rsp),%eax
xor    %al,0x1(%r14)
movzbl 0xe(%rsp),%eax
xor    %al,0x2(%r14)
movzbl 0xf(%rsp),%eax
xor    %al,0x3(%r14)
movzbl 0x10(%rsp),%eax
xor    %al,0x4(%r14)
movzbl 0x11(%rsp),%eax
xor    %al,0x5(%r14)
movzbl 0x12(%rsp),%eax
xor    %al,0x6(%r14)
movzbl 0x13(%rsp),%eax
xor    %al,0x7(%r14)
lea    0xc(%rsp),%rdi
mov    %rbx,%rsi
mov    $0x8,%edx
call   1050 <memcpy@plt>
lea    0x8(%r14),%r15
add    $0x8,%ebp
mov    %ebp,0x14(%rsp)
xor    %r13d,%r13d
mov    %r14,%rbx
xor    %ebp,%ebp
mov    %r15,%r14
jmp    11e3 <qqencrypt+0xa3>
mov    %ebp,%edi
mov    0x28(%rsp),%r14
test   %r14d,%r14d
jle    1497 <qqencrypt+0x357>
mov    0x18(%rsp),%rsi
jmp    1355 <qqencrypt+0x215>
nop
mov    %r15,%rbp
mov    %rbx,%r15
mov    %r15,%rbx
mov    %rbp,%r15
test   %r14d,%r14d
jle    149a <qqencrypt+0x35a>
cmp    $0x7,%r13d
jg     1340 <qqencrypt+0x200>
movzbl (%rsi),%eax
add    $0x1,%rsi
movslq %r13d,%rcx
add    $0x1,%r13d
mov    %al,0x4(%rsp,%rcx,1)
add    $0xffffffff,%r14d
cmp    $0x8,%r13d
jne    1340 <qqencrypt+0x200>
test   %edi,%edi
mov    %rsi,0x18(%rsp)
je     13c6 <qqencrypt+0x286>
movzbl 0xc(%rsp),%eax
xor    %al,0x4(%rsp)
movzbl 0xd(%rsp),%eax
xor    %al,0x5(%rsp)
movzbl 0xe(%rsp),%eax
xor    %al,0x6(%rsp)
movzbl 0xf(%rsp),%eax
xor    %al,0x7(%rsp)
movzbl 0x10(%rsp),%eax
xor    %al,0x8(%rsp)
movzbl 0x11(%rsp),%eax
xor    %al,0x9(%rsp)
movzbl 0x12(%rsp),%eax
xor    %al,0xa(%rsp)
lea    0x13(%rsp),%rbx
jmp    1401 <qqencrypt+0x2c1>
movzbl (%rbx),%eax
xor    %al,0x4(%rsp)
movzbl 0x1(%rbx),%eax
xor    %al,0x5(%rsp)
movzbl 0x2(%rbx),%eax
xor    %al,0x6(%rsp)
movzbl 0x3(%rbx),%eax
xor    %al,0x7(%rsp)
movzbl 0x4(%rbx),%eax
xor    %al,0x8(%rsp)
movzbl 0x5(%rbx),%eax
xor    %al,0x9(%rsp)
movzbl 0x6(%rbx),%eax
xor    %al,0xa(%rsp)
add    $0x7,%rbx
mov    0x14(%rsp),%r12d
movzbl (%rbx),%eax
xor    %al,0xb(%rsp)
lea    0x4(%rsp),%rbx
mov    %rbx,%rdi
mov    0x20(%rsp),%rsi
mov    %r15,%rdx
call   1040 <encipher@plt>
movzbl 0xc(%rsp),%eax
xor    %al,(%r15)
movzbl 0xd(%rsp),%eax
xor    %al,0x1(%r15)
movzbl 0xe(%rsp),%eax
xor    %al,0x2(%r15)
movzbl 0xf(%rsp),%eax
xor    %al,0x3(%r15)
movzbl 0x10(%rsp),%eax
xor    %al,0x4(%r15)
movzbl 0x11(%rsp),%eax
xor    %al,0x5(%r15)
movzbl 0x12(%rsp),%eax
xor    %al,0x6(%r15)
movzbl 0x13(%rsp),%eax
xor    %al,0x7(%r15)
lea    0xc(%rsp),%rdi
mov    %rbx,%rsi
mov    $0x8,%edx
call   1050 <memcpy@plt>
lea    0x8(%r15),%rbp
add    $0x8,%r12d
mov    %r12d,0x14(%rsp)
xor    %r13d,%r13d
xor    %edi,%edi
mov    0x18(%rsp),%rsi
jmp    1346 <qqencrypt+0x206>
mov    %r15,%rbp
mov    $0x1,%r15d
lea    0x4(%rsp),%r14
jmp    14c6 <qqencrypt+0x386>
nopw   0x0(%rax,%rax,1)
mov    %rbp,%rax
mov    %rbx,%rbp
mov    %rbp,%rbx
mov    %rax,%rbp
cmp    $0x8,%r15d
jge    15ec <qqencrypt+0x4ac>
cmp    $0x7,%r13d
jg     14b0 <qqencrypt+0x370>
movslq %r13d,%rax
add    $0x1,%r13d
movb   $0x0,0x4(%rsp,%rax,1)
add    $0x1,%r15d
cmp    $0x8,%r13d
jne    14b0 <qqencrypt+0x370>
test   %edi,%edi
je     152c <qqencrypt+0x3ec>
movzbl 0xc(%rsp),%eax
xor    %al,0x4(%rsp)
movzbl 0xd(%rsp),%eax
xor    %al,0x5(%rsp)
movzbl 0xe(%rsp),%eax
xor    %al,0x6(%rsp)
movzbl 0xf(%rsp),%eax
xor    %al,0x7(%rsp)
movzbl 0x10(%rsp),%eax
xor    %al,0x8(%rsp)
movzbl 0x11(%rsp),%eax
xor    %al,0x9(%rsp)
movzbl 0x12(%rsp),%eax
xor    %al,0xa(%rsp)
lea    0x13(%rsp),%rbx
jmp    1567 <qqencrypt+0x427>
movzbl (%rbx),%eax
xor    %al,0x4(%rsp)
movzbl 0x1(%rbx),%eax
xor    %al,0x5(%rsp)
movzbl 0x2(%rbx),%eax
xor    %al,0x6(%rsp)
movzbl 0x3(%rbx),%eax
xor    %al,0x7(%rsp)
movzbl 0x4(%rbx),%eax
xor    %al,0x8(%rsp)
movzbl 0x5(%rbx),%eax
xor    %al,0x9(%rsp)
movzbl 0x6(%rbx),%eax
xor    %al,0xa(%rsp)
add    $0x7,%rbx
mov    0x14(%rsp),%r12d
movzbl (%rbx),%eax
xor    %al,0xb(%rsp)
mov    %r14,%rdi
mov    0x20(%rsp),%rsi
mov    %rbp,%rdx
call   1040 <encipher@plt>
movzbl 0xc(%rsp),%eax
xor    %al,0x0(%rbp)
movzbl 0xd(%rsp),%eax
xor    %al,0x1(%rbp)
movzbl 0xe(%rsp),%eax
xor    %al,0x2(%rbp)
movzbl 0xf(%rsp),%eax
xor    %al,0x3(%rbp)
movzbl 0x10(%rsp),%eax
xor    %al,0x4(%rbp)
movzbl 0x11(%rsp),%eax
xor    %al,0x5(%rbp)
movzbl 0x12(%rsp),%eax
xor    %al,0x6(%rbp)
movzbl 0x13(%rsp),%eax
xor    %al,0x7(%rbp)
lea    0xc(%rsp),%rdi
mov    %r14,%rsi
mov    $0x8,%edx
call   1050 <memcpy@plt>
lea    0x8(%rbp),%rax
add    $0x8,%r12d
mov    %r12d,0x14(%rsp)
xor    %r13d,%r13d
xor    %edi,%edi
jmp    14b6 <qqencrypt+0x376>
mov    0x30(%rsp),%rax
mov    0x14(%rsp),%ecx
mov    %ecx,(%rax)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @qqencrypt(i8* nocapture %0, i32 %1, i8* %2, i8* %3, i32* nocapture writeonly %4) {
%6 = alloca [8 x i8]
%7 = alloca [8 x i8]
%8 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 0
%9 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 0
%10 = add nsw i32 %1, 10
%11 = srem i32 %10, 8
%12 = icmp eq i32 %11, 0
%13 = sub nsw i32 8, %11
%14 = select i1 %12, i32 0, i32 %13
%15 = tail call i32 (...) @random()
%16 = and i32 %15, 248
%17 = or i32 %16, %14
%18 = trunc i32 %17 to i8
store i8 %18, i8* %8
%19 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 1
%20 = tail call i32 (...) @random()
%21 = and i32 %20, 255
%22 = add nuw nsw i32 %14, 1
%23 = call i32 @memset(i8* %19, i32 %21, i32 %14)
%24 = call i32 @memset(i8* %9, i32 0, i32 8)
%25 = bitcast [8 x i8]* %6 to i32*
%26 = bitcast i8* %2 to i32*
%27 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 1
%28 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 2
%29 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 2
%30 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 3
%31 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 3
%32 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 4
%33 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 4
%34 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 5
%35 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 5
%36 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 6
%37 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 6
%38 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 7
%39 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 7
%40 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 2
%41 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 3
%42 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 4
%43 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 5
%44 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 6
%45 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 7
%46 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 1
%47 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 2
%48 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 3
%49 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 4
%50 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 5
%51 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 6
%52 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 7
br label %82
53: ; preds = %196
%54 = icmp sgt i32 %1, 0
br i1 %54, label %55, label %203
55: ; preds = %53
%56 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 1
%57 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 2
%58 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 2
%59 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 3
%60 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 3
%61 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 4
%62 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 4
%63 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 5
%64 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 5
%65 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 6
%66 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 6
%67 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 7
%68 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 7
%69 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 2
%70 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 3
%71 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 4
%72 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 5
%73 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 6
%74 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 7
%75 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 1
%76 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 2
%77 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 3
%78 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 4
%79 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 5
%80 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 6
%81 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 7
br label %235
82: ; preds = %5, %196
%83 = phi i32 [ 1, %5 ], [ %99, %196 ]
%84 = phi i32 [ 0, %5 ], [ %201, %196 ]
%85 = phi i32 [ 1, %5 ], [ %200, %196 ]
%86 = phi i32 [ %22, %5 ], [ %199, %196 ]
%87 = phi i8* [ %3, %5 ], [ %198, %196 ]
%88 = phi i8* [ %3, %5 ], [ %197, %196 ]
%89 = icmp slt i32 %86, 8
br i1 %89, label %90, label %97
90: ; preds = %82
%91 = call i32 (...) @random()
%92 = trunc i32 %91 to i8
%93 = add nsw i32 %86, 1
%94 = sext i32 %86 to i64
%95 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 %94
store i8 %92, i8* %95
%96 = add nsw i32 %83, 1
br label %97
97: ; preds = %90, %82
%98 = phi i32 [ %93, %90 ], [ %86, %82 ]
%99 = phi i32 [ %96, %90 ], [ %83, %82 ]
%100 = icmp eq i32 %98, 8
br i1 %100, label %101, label %196
101: ; preds = %97
%102 = icmp eq i32 %85, 0
br i1 %102, label %125, label %103
103: ; preds = %101
%104 = load i8, i8* %9
%105 = load i8, i8* %8
%106 = xor i8 %105, %104
store i8 %106, i8* %8
%107 = load i8, i8* %27
%108 = load i8, i8* %19
%109 = xor i8 %108, %107
store i8 %109, i8* %19
%110 = load i8, i8* %28
%111 = load i8, i8* %29
%112 = xor i8 %111, %110
store i8 %112, i8* %29
%113 = load i8, i8* %30
%114 = load i8, i8* %31
%115 = xor i8 %114, %113
store i8 %115, i8* %31
%116 = load i8, i8* %32
%117 = load i8, i8* %33
%118 = xor i8 %117, %116
store i8 %118, i8* %33
%119 = load i8, i8* %34
%120 = load i8, i8* %35
%121 = xor i8 %120, %119
store i8 %121, i8* %35
%122 = load i8, i8* %36
%123 = load i8, i8* %37
%124 = xor i8 %123, %122
store i8 %124, i8* %37
br label %154
125: ; preds = %101
%126 = load i8, i8* %87
%127 = load i8, i8* %8
%128 = xor i8 %127, %126
store i8 %128, i8* %8
%129 = getelementptr inbounds i8, i8* %87, i64 1
%130 = load i8, i8* %129
%131 = load i8, i8* %19
%132 = xor i8 %131, %130
store i8 %132, i8* %19
%133 = getelementptr inbounds i8, i8* %87, i64 2
%134 = load i8, i8* %133
%135 = load i8, i8* %40
%136 = xor i8 %135, %134
store i8 %136, i8* %40
%137 = getelementptr inbounds i8, i8* %87, i64 3
%138 = load i8, i8* %137
%139 = load i8, i8* %41
%140 = xor i8 %139, %138
store i8 %140, i8* %41
%141 = getelementptr inbounds i8, i8* %87, i64 4
%142 = load i8, i8* %141
%143 = load i8, i8* %42
%144 = xor i8 %143, %142
store i8 %144, i8* %42
%145 = getelementptr inbounds i8, i8* %87, i64 5
%146 = load i8, i8* %145
%147 = load i8, i8* %43
%148 = xor i8 %147, %146
store i8 %148, i8* %43
%149 = getelementptr inbounds i8, i8* %87, i64 6
%150 = load i8, i8* %149
%151 = load i8, i8* %44
%152 = xor i8 %151, %150
store i8 %152, i8* %44
%153 = getelementptr inbounds i8, i8* %87, i64 7
br label %154
154: ; preds = %125, %103
%155 = phi i8* [ %153, %125 ], [ %38, %103 ]
%156 = phi i8* [ %45, %125 ], [ %39, %103 ]
%157 = load i8, i8* %155
%158 = load i8, i8* %156
%159 = xor i8 %158, %157
store i8 %159, i8* %156
%160 = bitcast i8* %88 to i32*
%161 = call i32 @encipher(i32* %25, i32* %26, i32* %160)
%162 = load i8, i8* %9
%163 = load i8, i8* %88
%164 = xor i8 %163, %162
store i8 %164, i8* %88
%165 = load i8, i8* %46
%166 = getelementptr inbounds i8, i8* %88, i64 1
%167 = load i8, i8* %166
%168 = xor i8 %167, %165
store i8 %168, i8* %166
%169 = load i8, i8* %47
%170 = getelementptr inbounds i8, i8* %88, i64 2
%171 = load i8, i8* %170
%172 = xor i8 %171, %169
store i8 %172, i8* %170
%173 = load i8, i8* %48
%174 = getelementptr inbounds i8, i8* %88, i64 3
%175 = load i8, i8* %174
%176 = xor i8 %175, %173
store i8 %176, i8* %174
%177 = load i8, i8* %49
%178 = getelementptr inbounds i8, i8* %88, i64 4
%179 = load i8, i8* %178
%180 = xor i8 %179, %177
store i8 %180, i8* %178
%181 = load i8, i8* %50
%182 = getelementptr inbounds i8, i8* %88, i64 5
%183 = load i8, i8* %182
%184 = xor i8 %183, %181
store i8 %184, i8* %182
%185 = load i8, i8* %51
%186 = getelementptr inbounds i8, i8* %88, i64 6
%187 = load i8, i8* %186
%188 = xor i8 %187, %185
store i8 %188, i8* %186
%189 = load i8, i8* %52
%190 = getelementptr inbounds i8, i8* %88, i64 7
%191 = load i8, i8* %190
%192 = xor i8 %191, %189
store i8 %192, i8* %190
%193 = call i32 @memcpy(i8* %9, i8* %8, i32 8)
%194 = getelementptr inbounds i8, i8* %88, i64 8
%195 = add nsw i32 %84, 8
br label %196
196: ; preds = %154, %97
%197 = phi i8* [ %194, %154 ], [ %88, %97 ]
%198 = phi i8* [ %88, %154 ], [ %87, %97 ]
%199 = phi i32 [ 0, %154 ], [ %98, %97 ]
%200 = phi i32 [ 0, %154 ], [ %85, %97 ]
%201 = phi i32 [ %195, %154 ], [ %84, %97 ]
%202 = icmp slt i32 %99, 3
br i1 %202, label %82, label %53
203: ; preds = %347, %53
%204 = phi i8* [ %197, %53 ], [ %350, %347 ]
%205 = phi i8* [ %198, %53 ], [ %351, %347 ]
%206 = phi i32 [ %199, %53 ], [ %352, %347 ]
%207 = phi i32 [ %200, %53 ], [ %353, %347 ]
%208 = phi i32 [ %201, %53 ], [ %354, %347 ]
%209 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 1
%210 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 2
%211 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 2
%212 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 3
%213 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 3
%214 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 4
%215 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 4
%216 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 5
%217 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 5
%218 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 6
%219 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 6
%220 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 7
%221 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 7
%222 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 2
%223 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 3
%224 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 4
%225 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 5
%226 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 6
%227 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 7
%228 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 1
%229 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 2
%230 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 3
%231 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 4
%232 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 5
%233 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 6
%234 = getelementptr inbounds [8 x i8], [8 x i8]* %7, i64 0, i64 7
br label %356
235: ; preds = %55, %347
%236 = phi i32 [ %201, %55 ], [ %354, %347 ]
%237 = phi i32 [ %200, %55 ], [ %353, %347 ]
%238 = phi i32 [ %199, %55 ], [ %352, %347 ]
%239 = phi i8* [ %0, %55 ], [ %348, %347 ]
%240 = phi i8* [ %198, %55 ], [ %351, %347 ]
%241 = phi i8* [ %197, %55 ], [ %350, %347 ]
%242 = phi i32 [ %1, %55 ], [ %349, %347 ]
%243 = icmp slt i32 %238, 8
br i1 %243, label %244, label %347
244: ; preds = %235
%245 = getelementptr inbounds i8, i8* %239, i64 1
%246 = load i8, i8* %239
%247 = add nsw i32 %238, 1
%248 = sext i32 %238 to i64
%249 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 %248
store i8 %246, i8* %249
%250 = add nsw i32 %242, -1
%251 = icmp eq i32 %247, 8
br i1 %251, label %252, label %347
252: ; preds = %244
%253 = icmp eq i32 %237, 0
br i1 %253, label %276, label %254
254: ; preds = %252
%255 = load i8, i8* %9
%256 = load i8, i8* %8
%257 = xor i8 %256, %255
store i8 %257, i8* %8
%258 = load i8, i8* %56
%259 = load i8, i8* %19
%260 = xor i8 %259, %258
store i8 %260, i8* %19
%261 = load i8, i8* %57
%262 = load i8, i8* %58
%263 = xor i8 %262, %261
store i8 %263, i8* %58
%264 = load i8, i8* %59
%265 = load i8, i8* %60
%266 = xor i8 %265, %264
store i8 %266, i8* %60
%267 = load i8, i8* %61
%268 = load i8, i8* %62
%269 = xor i8 %268, %267
store i8 %269, i8* %62
%270 = load i8, i8* %63
%271 = load i8, i8* %64
%272 = xor i8 %271, %270
store i8 %272, i8* %64
%273 = load i8, i8* %65
%274 = load i8, i8* %66
%275 = xor i8 %274, %273
store i8 %275, i8* %66
br label %305
276: ; preds = %252
%277 = load i8, i8* %240
%278 = load i8, i8* %8
%279 = xor i8 %278, %277
store i8 %279, i8* %8
%280 = getelementptr inbounds i8, i8* %240, i64 1
%281 = load i8, i8* %280
%282 = load i8, i8* %19
%283 = xor i8 %282, %281
store i8 %283, i8* %19
%284 = getelementptr inbounds i8, i8* %240, i64 2
%285 = load i8, i8* %284
%286 = load i8, i8* %69
%287 = xor i8 %286, %285
store i8 %287, i8* %69
%288 = getelementptr inbounds i8, i8* %240, i64 3
%289 = load i8, i8* %288
%290 = load i8, i8* %70
%291 = xor i8 %290, %289
store i8 %291, i8* %70
%292 = getelementptr inbounds i8, i8* %240, i64 4
%293 = load i8, i8* %292
%294 = load i8, i8* %71
%295 = xor i8 %294, %293
store i8 %295, i8* %71
%296 = getelementptr inbounds i8, i8* %240, i64 5
%297 = load i8, i8* %296
%298 = load i8, i8* %72
%299 = xor i8 %298, %297
store i8 %299, i8* %72
%300 = getelementptr inbounds i8, i8* %240, i64 6
%301 = load i8, i8* %300
%302 = load i8, i8* %73
%303 = xor i8 %302, %301
store i8 %303, i8* %73
%304 = getelementptr inbounds i8, i8* %240, i64 7
br label %305
305: ; preds = %276, %254
%306 = phi i8* [ %304, %276 ], [ %67, %254 ]
%307 = phi i8* [ %74, %276 ], [ %68, %254 ]
%308 = load i8, i8* %306
%309 = load i8, i8* %307
%310 = xor i8 %309, %308
store i8 %310, i8* %307
%311 = bitcast i8* %241 to i32*
%312 = call i32 @encipher(i32* %25, i32* %26, i32* %311)
%313 = load i8, i8* %9
%314 = load i8, i8* %241
%315 = xor i8 %314, %313
store i8 %315, i8* %241
%316 = load i8, i8* %75
%317 = getelementptr inbounds i8, i8* %241, i64 1
%318 = load i8, i8* %317
%319 = xor i8 %318, %316
store i8 %319, i8* %317
%320 = load i8, i8* %76
%321 = getelementptr inbounds i8, i8* %241, i64 2
%322 = load i8, i8* %321
%323 = xor i8 %322, %320
store i8 %323, i8* %321
%324 = load i8, i8* %77
%325 = getelementptr inbounds i8, i8* %241, i64 3
%326 = load i8, i8* %325
%327 = xor i8 %326, %324
store i8 %327, i8* %325
%328 = load i8, i8* %78
%329 = getelementptr inbounds i8, i8* %241, i64 4
%330 = load i8, i8* %329
%331 = xor i8 %330, %328
store i8 %331, i8* %329
%332 = load i8, i8* %79
%333 = getelementptr inbounds i8, i8* %241, i64 5
%334 = load i8, i8* %333
%335 = xor i8 %334, %332
store i8 %335, i8* %333
%336 = load i8, i8* %80
%337 = getelementptr inbounds i8, i8* %241, i64 6
%338 = load i8, i8* %337
%339 = xor i8 %338, %336
store i8 %339, i8* %337
%340 = load i8, i8* %81
%341 = getelementptr inbounds i8, i8* %241, i64 7
%342 = load i8, i8* %341
%343 = xor i8 %342, %340
store i8 %343, i8* %341
%344 = call i32 @memcpy(i8* %9, i8* %8, i32 8)
%345 = getelementptr inbounds i8, i8* %241, i64 8
%346 = add nsw i32 %236, 8
br label %347
347: ; preds = %235, %305, %244
%348 = phi i8* [ %245, %305 ], [ %245, %244 ], [ %239, %235 ]
%349 = phi i32 [ %250, %305 ], [ %250, %244 ], [ %242, %235 ]
%350 = phi i8* [ %345, %305 ], [ %241, %244 ], [ %241, %235 ]
%351 = phi i8* [ %241, %305 ], [ %240, %244 ], [ %240, %235 ]
%352 = phi i32 [ 0, %305 ], [ %247, %244 ], [ %238, %235 ]
%353 = phi i32 [ 0, %305 ], [ %237, %244 ], [ %237, %235 ]
%354 = phi i32 [ %346, %305 ], [ %236, %244 ], [ %236, %235 ]
%355 = icmp sgt i32 %349, 0
br i1 %355, label %235, label %203
356: ; preds = %203, %465
%357 = phi i32 [ 1, %203 ], [ %466, %465 ]
%358 = phi i32 [ %208, %203 ], [ %471, %465 ]
%359 = phi i32 [ %207, %203 ], [ %470, %465 ]
%360 = phi i32 [ %206, %203 ], [ %469, %465 ]
%361 = phi i8* [ %205, %203 ], [ %468, %465 ]
%362 = phi i8* [ %204, %203 ], [ %467, %465 ]
%363 = icmp slt i32 %360, 8
br i1 %363, label %364, label %465
364: ; preds = %356
%365 = add nsw i32 %360, 1
%366 = sext i32 %360 to i64
%367 = getelementptr inbounds [8 x i8], [8 x i8]* %6, i64 0, i64 %366
store i8 0, i8* %367
%368 = add nsw i32 %357, 1
%369 = icmp eq i32 %365, 8
br i1 %369, label %370, label %465
370: ; preds = %364
%371 = icmp eq i32 %359, 0
br i1 %371, label %394, label %372
372: ; preds = %370
%373 = load i8, i8* %9
%374 = load i8, i8* %8
%375 = xor i8 %374, %373
store i8 %375, i8* %8
%376 = load i8, i8* %209
%377 = load i8, i8* %19
%378 = xor i8 %377, %376
store i8 %378, i8* %19
%379 = load i8, i8* %210
%380 = load i8, i8* %211
%381 = xor i8 %380, %379
store i8 %381, i8* %211
%382 = load i8, i8* %212
%383 = load i8, i8* %213
%384 = xor i8 %383, %382
store i8 %384, i8* %213
%385 = load i8, i8* %214
%386 = load i8, i8* %215
%387 = xor i8 %386, %385
store i8 %387, i8* %215
%388 = load i8, i8* %216
%389 = load i8, i8* %217
%390 = xor i8 %389, %388
store i8 %390, i8* %217
%391 = load i8, i8* %218
%392 = load i8, i8* %219
%393 = xor i8 %392, %391
store i8 %393, i8* %219
br label %423
394: ; preds = %370
%395 = load i8, i8* %361
%396 = load i8, i8* %8
%397 = xor i8 %396, %395
store i8 %397, i8* %8
%398 = getelementptr inbounds i8, i8* %361, i64 1
%399 = load i8, i8* %398
%400 = load i8, i8* %19
%401 = xor i8 %400, %399
store i8 %401, i8* %19
%402 = getelementptr inbounds i8, i8* %361, i64 2
%403 = load i8, i8* %402
%404 = load i8, i8* %222
%405 = xor i8 %404, %403
store i8 %405, i8* %222
%406 = getelementptr inbounds i8, i8* %361, i64 3
%407 = load i8, i8* %406
%408 = load i8, i8* %223
%409 = xor i8 %408, %407
store i8 %409, i8* %223
%410 = getelementptr inbounds i8, i8* %361, i64 4
%411 = load i8, i8* %410
%412 = load i8, i8* %224
%413 = xor i8 %412, %411
store i8 %413, i8* %224
%414 = getelementptr inbounds i8, i8* %361, i64 5
%415 = load i8, i8* %414
%416 = load i8, i8* %225
%417 = xor i8 %416, %415
store i8 %417, i8* %225
%418 = getelementptr inbounds i8, i8* %361, i64 6
%419 = load i8, i8* %418
%420 = load i8, i8* %226
%421 = xor i8 %420, %419
store i8 %421, i8* %226
%422 = getelementptr inbounds i8, i8* %361, i64 7
br label %423
423: ; preds = %394, %372
%424 = phi i8* [ %422, %394 ], [ %220, %372 ]
%425 = phi i8* [ %227, %394 ], [ %221, %372 ]
%426 = load i8, i8* %424
%427 = load i8, i8* %425
%428 = xor i8 %427, %426
store i8 %428, i8* %425
%429 = bitcast i8* %362 to i32*
%430 = call i32 @encipher(i32* %25, i32* %26, i32* %429)
%431 = load i8, i8* %9
%432 = load i8, i8* %362
%433 = xor i8 %432, %431
store i8 %433, i8* %362
%434 = load i8, i8* %228
%435 = getelementptr inbounds i8, i8* %362, i64 1
%436 = load i8, i8* %435
%437 = xor i8 %436, %434
store i8 %437, i8* %435
%438 = load i8, i8* %229
%439 = getelementptr inbounds i8, i8* %362, i64 2
%440 = load i8, i8* %439
%441 = xor i8 %440, %438
store i8 %441, i8* %439
%442 = load i8, i8* %230
%443 = getelementptr inbounds i8, i8* %362, i64 3
%444 = load i8, i8* %443
%445 = xor i8 %444, %442
store i8 %445, i8* %443
%446 = load i8, i8* %231
%447 = getelementptr inbounds i8, i8* %362, i64 4
%448 = load i8, i8* %447
%449 = xor i8 %448, %446
store i8 %449, i8* %447
%450 = load i8, i8* %232
%451 = getelementptr inbounds i8, i8* %362, i64 5
%452 = load i8, i8* %451
%453 = xor i8 %452, %450
store i8 %453, i8* %451
%454 = load i8, i8* %233
%455 = getelementptr inbounds i8, i8* %362, i64 6
%456 = load i8, i8* %455
%457 = xor i8 %456, %454
store i8 %457, i8* %455
%458 = load i8, i8* %234
%459 = getelementptr inbounds i8, i8* %362, i64 7
%460 = load i8, i8* %459
%461 = xor i8 %460, %458
store i8 %461, i8* %459
%462 = call i32 @memcpy(i8* %9, i8* %8, i32 8)
%463 = getelementptr inbounds i8, i8* %362, i64 8
%464 = add nsw i32 %358, 8
br label %465
465: ; preds = %356, %423, %364
%466 = phi i32 [ %368, %423 ], [ %368, %364 ], [ %357, %356 ]
%467 = phi i8* [ %463, %423 ], [ %362, %364 ], [ %362, %356 ]
%468 = phi i8* [ %362, %423 ], [ %361, %364 ], [ %361, %356 ]
%469 = phi i32 [ 0, %423 ], [ %365, %364 ], [ %360, %356 ]
%470 = phi i32 [ 0, %423 ], [ %359, %364 ], [ %359, %356 ]
%471 = phi i32 [ %464, %423 ], [ %358, %364 ], [ %358, %356 ]
%472 = icmp slt i32 %466, 8
br i1 %472, label %356, label %473
473: ; preds = %465
store i32 %471, i32* %4
ret void
}