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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ decipher(unsigned int *, unsigned int *, unsigned int *);
int /*<<< orphan*/ memset(unsigned char *, int /*<<< orphan*/, int);
int qqdecrypt(unsigned char *instr, int instrlen, unsigned char *key,
              unsigned char *outstr, int *outstrlen_ptr) {
  unsigned char decrypted[8], m[8], *crypt_buff, *crypt_buff_pre_8, *outp;
  int count, context_start, pos_in_byte, padding;
  if ((instrlen % 8) || (instrlen < 16))
    return 0;
  decipher((unsigned int *)instr, (unsigned int *)key,
           (unsigned int *)decrypted);
  pos_in_byte = decrypted[0] & 0x7;
  count = instrlen - pos_in_byte - 10;
  if (*outstrlen_ptr < count || count < 0)
    return 0;
  memset(m, 0, 8);
  crypt_buff_pre_8 = m;
  *outstrlen_ptr = count;
  crypt_buff = instr + 8;
  context_start = 8;
  pos_in_byte++;
  padding = 1;
  while (padding <= 2) {
    if (pos_in_byte < 8) {
      pos_in_byte++;
      padding++;
    }
    if (pos_in_byte == 8) {
      crypt_buff_pre_8 = instr;
      {
        char bNeedRet = 0;
        for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
          if (context_start + pos_in_byte >= instrlen) {
            bNeedRet = 1;
            break;
          }
          decrypted[pos_in_byte] ^= crypt_buff[pos_in_byte];
        }
        if (!bNeedRet) {
          decipher((unsigned int *)decrypted, (unsigned int *)key,
                   (unsigned int *)decrypted);
          context_start += 8;
          crypt_buff += 8;
          pos_in_byte = 0;
        }
      };
    }
  }
  outp = outstr;
  while (count != 0) {
    if (pos_in_byte < 8) {
      *outp = crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte];
      outp++;
      count--;
      pos_in_byte++;
    }
    if (pos_in_byte == 8) {
      crypt_buff_pre_8 = crypt_buff - 8;
      {
        char bNeedRet = 0;
        for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
          if (context_start + pos_in_byte >= instrlen) {
            bNeedRet = 1;
            break;
          }
          decrypted[pos_in_byte] ^= crypt_buff[pos_in_byte];
        }
        if (!bNeedRet) {
          decipher((unsigned int *)decrypted, (unsigned int *)key,
                   (unsigned int *)decrypted);
          context_start += 8;
          crypt_buff += 8;
          pos_in_byte = 0;
        }
      };
    }
  }
  for (padding = 1; padding < 8; padding++) {
    if (pos_in_byte < 8) {
      if (crypt_buff_pre_8[pos_in_byte] ^ decrypted[pos_in_byte]) {
        return 0;
      }
      pos_in_byte++;
    }
    if (pos_in_byte == 8) {
      crypt_buff_pre_8 = crypt_buff;
      {
        char bNeedRet = 0;
        for (pos_in_byte = 0; pos_in_byte < 8; pos_in_byte++) {
          if (context_start + pos_in_byte >= instrlen) {
            bNeedRet = 1;
            break;
          }
          decrypted[pos_in_byte] ^= crypt_buff[pos_in_byte];
        }
        if (!bNeedRet) {
          decipher((unsigned int *)decrypted, (unsigned int *)key,
                   (unsigned int *)decrypted);
          context_start += 8;
          crypt_buff += 8;
          pos_in_byte = 0;
        }
      };
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<qqdecrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1159 <qqdecrypt+0x39>
cmpl   $0x10,-0x14(%rbp)
jge    1165 <qqdecrypt+0x45>
movl   $0x0,-0x4(%rbp)
jmp    14d8 <qqdecrypt+0x3b8>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
lea    -0x38(%rbp),%rdx
call   1040 <decipher@plt>
movzbl -0x38(%rbp),%eax
and    $0x7,%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x64(%rbp),%eax
sub    $0xa,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
cmp    -0x5c(%rbp),%eax
jl     11a5 <qqdecrypt+0x85>
cmpl   $0x0,-0x5c(%rbp)
jge    11b1 <qqdecrypt+0x91>
movl   $0x0,-0x4(%rbp)
jmp    14d8 <qqdecrypt+0x3b8>
lea    -0x40(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1030 <memset@plt>
lea    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x5c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
movl   $0x8,-0x60(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
movl   $0x1,-0x68(%rbp)
cmpl   $0x2,-0x68(%rbp)
jg     12c4 <qqdecrypt+0x1a4>
cmpl   $0x8,-0x64(%rbp)
jge    121b <qqdecrypt+0xfb>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x8,-0x64(%rbp)
jne    12bf <qqdecrypt+0x19f>
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
movb   $0x0,-0x69(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x8,-0x64(%rbp)
jge    1283 <qqdecrypt+0x163>
mov    -0x60(%rbp),%eax
add    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     125a <qqdecrypt+0x13a>
movb   $0x1,-0x69(%rbp)
jmp    1283 <qqdecrypt+0x163>
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
movslq -0x64(%rbp),%rax
movzbl -0x38(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x38(%rbp,%rax,1)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1238 <qqdecrypt+0x118>
cmpb   $0x0,-0x69(%rbp)
jne    12ba <qqdecrypt+0x19a>
lea    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%rsi
lea    -0x38(%rbp),%rdx
call   1040 <decipher@plt>
mov    -0x60(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x64(%rbp)
jmp    12bf <qqdecrypt+0x19f>
jmp    11f5 <qqdecrypt+0xd5>
mov    -0x28(%rbp),%rax
mov    %rax,-0x58(%rbp)
cmpl   $0x0,-0x5c(%rbp)
je     13ca <qqdecrypt+0x2aa>
cmpl   $0x8,-0x64(%rbp)
jge    131d <qqdecrypt+0x1fd>
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
movslq -0x64(%rbp),%rcx
movzbl -0x38(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x58(%rbp),%rax
mov    %cl,(%rax)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x8,-0x64(%rbp)
jne    13c5 <qqdecrypt+0x2a5>
mov    -0x48(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x50(%rbp)
movb   $0x0,-0x6a(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x8,-0x64(%rbp)
jge    1389 <qqdecrypt+0x269>
mov    -0x60(%rbp),%eax
add    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1360 <qqdecrypt+0x240>
movb   $0x1,-0x6a(%rbp)
jmp    1389 <qqdecrypt+0x269>
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
movslq -0x64(%rbp),%rax
movzbl -0x38(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x38(%rbp,%rax,1)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    133e <qqdecrypt+0x21e>
cmpb   $0x0,-0x6a(%rbp)
jne    13c0 <qqdecrypt+0x2a0>
lea    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%rsi
lea    -0x38(%rbp),%rdx
call   1040 <decipher@plt>
mov    -0x60(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x64(%rbp)
jmp    13c5 <qqdecrypt+0x2a5>
jmp    12cc <qqdecrypt+0x1ac>
movl   $0x1,-0x68(%rbp)
cmpl   $0x8,-0x68(%rbp)
jge    14d1 <qqdecrypt+0x3b1>
cmpl   $0x8,-0x64(%rbp)
jge    141a <qqdecrypt+0x2fa>
mov    -0x50(%rbp),%rax
movslq -0x64(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
movslq -0x64(%rbp),%rcx
movzbl -0x38(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
cmp    $0x0,%eax
je     1411 <qqdecrypt+0x2f1>
movl   $0x0,-0x4(%rbp)
jmp    14d8 <qqdecrypt+0x3b8>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
cmpl   $0x8,-0x64(%rbp)
jne    14be <qqdecrypt+0x39e>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
movb   $0x0,-0x6b(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x8,-0x64(%rbp)
jge    1482 <qqdecrypt+0x362>
mov    -0x60(%rbp),%eax
add    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     1459 <qqdecrypt+0x339>
movb   $0x1,-0x6b(%rbp)
jmp    1482 <qqdecrypt+0x362>
mov    -0x48(%rbp),%rax
movslq -0x64(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
movslq -0x64(%rbp),%rax
movzbl -0x38(%rbp,%rax,1),%ecx
xor    %edx,%ecx
mov    %cl,-0x38(%rbp,%rax,1)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1437 <qqdecrypt+0x317>
cmpb   $0x0,-0x6b(%rbp)
jne    14b9 <qqdecrypt+0x399>
lea    -0x38(%rbp),%rdi
mov    -0x20(%rbp),%rsi
lea    -0x38(%rbp),%rdx
call   1040 <decipher@plt>
mov    -0x60(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x60(%rbp)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x64(%rbp)
jmp    14be <qqdecrypt+0x39e>
jmp    14c3 <qqdecrypt+0x3a3>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13d1 <qqdecrypt+0x2b1>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qqdecrypt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
xor    %ebx,%ebx
cmp    $0x10,%esi
jl     1587 <qqdecrypt+0x467>
mov    %esi,%eax
and    $0x7,%eax
jne    1587 <qqdecrypt+0x467>
mov    %r8,%r13
mov    %rcx,%r12
mov    %rdx,%r14
lea    0x8(%rsp),%rdx
mov    %rdi,0x20(%rsp)
mov    %esi,0x10(%rsp)
mov    %r14,%rsi
call   1040 <decipher@plt>
movzbl 0x8(%rsp),%r15d
and    $0x7,%r15d
mov    0x10(%rsp),%ebp
sub    %r15d,%ebp
sub    $0xa,%ebp
jb     1587 <qqdecrypt+0x467>
cmp    %ebp,0x0(%r13)
jl     1587 <qqdecrypt+0x467>
mov    %r12,0x28(%rsp)
mov    %r14,0x18(%rsp)
lea    0x30(%rsp),%rbx
mov    $0x8,%r14d
mov    %rbx,%rdi
mov    %ebp,0x14(%rsp)
xor    %esi,%esi
mov    $0x8,%edx
call   1030 <memset@plt>
mov    0x14(%rsp),%esi
mov    0x10(%rsp),%edx
mov    %esi,0x0(%r13)
mov    0x20(%rsp),%rbp
lea    0x8(%rbp),%r13
add    $0x1,%r15d
mov    $0x1,%r12d
lea    0x8(%rsp),%rdi
jmp    121a <qqdecrypt+0xfa>
movzbl 0x7(%r13),%eax
xor    %al,0xf(%rsp)
mov    0x18(%rsp),%rsi
mov    %rdi,%rdx
mov    %rdi,%rbx
call   1040 <decipher@plt>
mov    %rbx,%rdi
mov    0x20(%rsp),%rbp
mov    0x14(%rsp),%esi
mov    0x10(%rsp),%edx
add    $0x8,%r14d
add    $0x8,%r13
mov    %rbp,%rbx
nopl   0x0(%rax)
cmp    $0x3,%r12d
jae    12ff <qqdecrypt+0x1df>
xor    %eax,%eax
cmp    $0x8,%r15d
setl   %al
add    %eax,%r15d
add    %eax,%r12d
cmp    $0x8,%r15d
jne    1210 <qqdecrypt+0xf0>
cmp    %edx,%r14d
mov    %edx,%eax
cmovg  %r14d,%eax
xor    %r15d,%r15d
sub    %r14d,%eax
je     1206 <qqdecrypt+0xe6>
movzbl 0x0(%r13),%ecx
xor    %cl,0x8(%rsp)
cmp    $0x1,%eax
jne    1259 <qqdecrypt+0x139>
mov    %rbp,%rbx
mov    $0x1,%r15d
jmp    1210 <qqdecrypt+0xf0>
movzbl 0x1(%r13),%ecx
xor    %cl,0x9(%rsp)
cmp    $0x2,%eax
jne    1272 <qqdecrypt+0x152>
mov    %rbp,%rbx
mov    $0x2,%r15d
jmp    1210 <qqdecrypt+0xf0>
movzbl 0x2(%r13),%ecx
xor    %cl,0xa(%rsp)
cmp    $0x3,%eax
jne    128b <qqdecrypt+0x16b>
mov    %rbp,%rbx
mov    $0x3,%r15d
jmp    1210 <qqdecrypt+0xf0>
movzbl 0x3(%r13),%ecx
xor    %cl,0xb(%rsp)
cmp    $0x4,%eax
jne    12a7 <qqdecrypt+0x187>
mov    %rbp,%rbx
mov    $0x4,%r15d
jmp    1210 <qqdecrypt+0xf0>
movzbl 0x4(%r13),%ecx
xor    %cl,0xc(%rsp)
cmp    $0x5,%eax
jne    12c3 <qqdecrypt+0x1a3>
mov    %rbp,%rbx
mov    $0x5,%r15d
jmp    1210 <qqdecrypt+0xf0>
movzbl 0x5(%r13),%ecx
xor    %cl,0xd(%rsp)
cmp    $0x6,%eax
jne    12df <qqdecrypt+0x1bf>
mov    %rbp,%rbx
mov    $0x6,%r15d
jmp    1210 <qqdecrypt+0xf0>
movzbl 0x6(%r13),%ecx
xor    %cl,0xe(%rsp)
cmp    $0x7,%eax
jne    11d5 <qqdecrypt+0xb5>
mov    %rbp,%rbx
mov    $0x7,%r15d
jmp    1210 <qqdecrypt+0xf0>
test   %esi,%esi
je     1432 <qqdecrypt+0x312>
lea    0x8(%rsp),%r12
mov    0x28(%rsp),%rbp
jmp    1328 <qqdecrypt+0x208>
mov    $0x1,%r15d
nopl   0x0(%rax)
test   %esi,%esi
je     1432 <qqdecrypt+0x312>
cmp    $0x7,%r15d
jg     1347 <qqdecrypt+0x227>
movslq %r15d,%rax
movzbl 0x8(%rsp,%rax,1),%ecx
xor    (%rbx,%rax,1),%cl
mov    %cl,0x0(%rbp)
add    $0x1,%rbp
add    $0xffffffff,%esi
add    $0x1,%r15d
cmp    $0x8,%r15d
jne    1320 <qqdecrypt+0x200>
lea    -0x8(%r13),%rbx
cmp    %edx,%r14d
mov    %edx,%eax
cmovg  %r14d,%eax
xor    %r15d,%r15d
sub    %r14d,%eax
je     1320 <qqdecrypt+0x200>
movzbl 0x0(%r13),%ecx
xor    %cl,0x8(%rsp)
cmp    $0x1,%eax
je     1313 <qqdecrypt+0x1f3>
movzbl 0x1(%r13),%ecx
xor    %cl,0x9(%rsp)
cmp    $0x2,%eax
jne    1386 <qqdecrypt+0x266>
mov    $0x2,%r15d
jmp    1320 <qqdecrypt+0x200>
movzbl 0x2(%r13),%ecx
xor    %cl,0xa(%rsp)
cmp    $0x3,%eax
jne    139c <qqdecrypt+0x27c>
mov    $0x3,%r15d
jmp    1320 <qqdecrypt+0x200>
movzbl 0x3(%r13),%ecx
xor    %cl,0xb(%rsp)
cmp    $0x4,%eax
jne    13b5 <qqdecrypt+0x295>
mov    $0x4,%r15d
jmp    1320 <qqdecrypt+0x200>
movzbl 0x4(%r13),%ecx
xor    %cl,0xc(%rsp)
cmp    $0x5,%eax
jne    13ce <qqdecrypt+0x2ae>
mov    $0x5,%r15d
jmp    1320 <qqdecrypt+0x200>
movzbl 0x5(%r13),%ecx
xor    %cl,0xd(%rsp)
cmp    $0x6,%eax
jne    13e7 <qqdecrypt+0x2c7>
mov    $0x6,%r15d
jmp    1320 <qqdecrypt+0x200>
movzbl 0x6(%r13),%ecx
xor    %cl,0xe(%rsp)
cmp    $0x7,%eax
jne    1400 <qqdecrypt+0x2e0>
mov    $0x7,%r15d
jmp    1320 <qqdecrypt+0x200>
movzbl 0x7(%r13),%eax
xor    %al,0xf(%rsp)
mov    %r12,%rdi
mov    %esi,0x14(%rsp)
mov    0x18(%rsp),%rsi
mov    %r12,%rdx
call   1040 <decipher@plt>
mov    0x14(%rsp),%esi
mov    0x10(%rsp),%edx
add    $0x8,%r14d
add    $0x8,%r13
jmp    1320 <qqdecrypt+0x200>
mov    $0x7,%ebp
lea    0x8(%rsp),%r12
jmp    145b <qqdecrypt+0x33b>
xchg   %ax,%ax
cmp    $0x8,%r15d
je     1480 <qqdecrypt+0x360>
mov    %r13,%rax
mov    %rbx,%r13
mov    %r13,%rbx
mov    %rax,%r13
add    $0xffffffff,%ebp
je     157e <qqdecrypt+0x45e>
cmp    $0x7,%r15d
jg     1440 <qqdecrypt+0x320>
movslq %r15d,%rax
movzbl (%rbx,%rax,1),%ecx
cmp    0x8(%rsp,%rax,1),%cl
jne    1585 <qqdecrypt+0x465>
add    $0x1,%r15d
jmp    1440 <qqdecrypt+0x320>
nopl   0x0(%rax,%rax,1)
cmp    %edx,%r14d
mov    %edx,%eax
cmovg  %r14d,%eax
xor    %r15d,%r15d
sub    %r14d,%eax
je     14aa <qqdecrypt+0x38a>
movzbl 0x0(%r13),%ecx
xor    %cl,0x8(%rsp)
cmp    $0x1,%eax
jne    14af <qqdecrypt+0x38f>
mov    %r13,%rax
mov    $0x1,%r15d
jmp    144c <qqdecrypt+0x32c>
mov    %r13,%rax
jmp    144c <qqdecrypt+0x32c>
movzbl 0x1(%r13),%ecx
xor    %cl,0x9(%rsp)
cmp    $0x2,%eax
jne    14c8 <qqdecrypt+0x3a8>
mov    %r13,%rax
mov    $0x2,%r15d
jmp    144c <qqdecrypt+0x32c>
movzbl 0x2(%r13),%ecx
xor    %cl,0xa(%rsp)
cmp    $0x3,%eax
jne    14e4 <qqdecrypt+0x3c4>
mov    %r13,%rax
mov    $0x3,%r15d
jmp    144c <qqdecrypt+0x32c>
movzbl 0x3(%r13),%ecx
xor    %cl,0xb(%rsp)
cmp    $0x4,%eax
jne    1500 <qqdecrypt+0x3e0>
mov    %r13,%rax
mov    $0x4,%r15d
jmp    144c <qqdecrypt+0x32c>
movzbl 0x4(%r13),%ecx
xor    %cl,0xc(%rsp)
cmp    $0x5,%eax
jne    151c <qqdecrypt+0x3fc>
mov    %r13,%rax
mov    $0x5,%r15d
jmp    144c <qqdecrypt+0x32c>
movzbl 0x5(%r13),%ecx
xor    %cl,0xd(%rsp)
cmp    $0x6,%eax
jne    1538 <qqdecrypt+0x418>
mov    %r13,%rax
mov    $0x6,%r15d
jmp    144c <qqdecrypt+0x32c>
movzbl 0x6(%r13),%ecx
xor    %cl,0xe(%rsp)
cmp    $0x7,%eax
jne    1554 <qqdecrypt+0x434>
mov    %r13,%rax
mov    $0x7,%r15d
jmp    144c <qqdecrypt+0x32c>
movzbl 0x7(%r13),%eax
xor    %al,0xf(%rsp)
mov    %r12,%rdi
mov    0x18(%rsp),%rsi
mov    %r12,%rdx
call   1040 <decipher@plt>
mov    0x10(%rsp),%edx
add    $0x8,%r14d
lea    0x8(%r13),%rax
jmp    144c <qqdecrypt+0x32c>
mov    $0x1,%ebx
jmp    1587 <qqdecrypt+0x467>
xor    %ebx,%ebx
mov    %ebx,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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