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

/* Variables and functions */
int /*<<< orphan*/ RC2_decrypt(unsigned long *, int /*<<< orphan*/ *);
int /*<<< orphan*/ RC2_encrypt(unsigned long *, int /*<<< orphan*/ *);
void RC2_cbc_encrypt(const unsigned char *in, unsigned char *out, long length,
                     RC2_KEY *ks, unsigned char *iv, int encrypt) {
  unsigned long tin0, tin1;
  unsigned long tout0, tout1, xor0, xor1;
  long l = length;
  unsigned long tin[2];
  if (encrypt) {
    (tout0 = ((unsigned long)(*((iv)++))),
     tout0 |= ((unsigned long)(*((iv)++))) << 8L,
     tout0 |= ((unsigned long)(*((iv)++))) << 16L,
     tout0 |= ((unsigned long)(*((iv)++))) << 24L);
    (tout1 = ((unsigned long)(*((iv)++))),
     tout1 |= ((unsigned long)(*((iv)++))) << 8L,
     tout1 |= ((unsigned long)(*((iv)++))) << 16L,
     tout1 |= ((unsigned long)(*((iv)++))) << 24L);
    iv -= 8;
    for (l -= 8; l >= 0; l -= 8) {
      (tin0 = ((unsigned long)(*((in)++))),
       tin0 |= ((unsigned long)(*((in)++))) << 8L,
       tin0 |= ((unsigned long)(*((in)++))) << 16L,
       tin0 |= ((unsigned long)(*((in)++))) << 24L);
      (tin1 = ((unsigned long)(*((in)++))),
       tin1 |= ((unsigned long)(*((in)++))) << 8L,
       tin1 |= ((unsigned long)(*((in)++))) << 16L,
       tin1 |= ((unsigned long)(*((in)++))) << 24L);
      tin0 ^= tout0;
      tin1 ^= tout1;
      tin[0] = tin0;
      tin[1] = tin1;
      RC2_encrypt(tin, ks);
      tout0 = tin[0];
      (*((out)++) = (unsigned char)(((tout0)) & 0xff),
       *((out)++) = (unsigned char)(((tout0) >> 8L) & 0xff),
       *((out)++) = (unsigned char)(((tout0) >> 16L) & 0xff),
       *((out)++) = (unsigned char)(((tout0) >> 24L) & 0xff));
      tout1 = tin[1];
      (*((out)++) = (unsigned char)(((tout1)) & 0xff),
       *((out)++) = (unsigned char)(((tout1) >> 8L) & 0xff),
       *((out)++) = (unsigned char)(((tout1) >> 16L) & 0xff),
       *((out)++) = (unsigned char)(((tout1) >> 24L) & 0xff));
    }
    if (l != -8) {
      {
        in += l + 8;
        tin0 = tin1 = 0;
        switch (l + 8) {
        case 8:
          tin1 = ((unsigned long)(*(--(in)))) << 24L;
        case 7:
          tin1 |= ((unsigned long)(*(--(in)))) << 16L;
        case 6:
          tin1 |= ((unsigned long)(*(--(in)))) << 8L;
        case 5:
          tin1 |= ((unsigned long)(*(--(in))));
        case 4:
          tin0 = ((unsigned long)(*(--(in)))) << 24L;
        case 3:
          tin0 |= ((unsigned long)(*(--(in)))) << 16L;
        case 2:
          tin0 |= ((unsigned long)(*(--(in)))) << 8L;
        case 1:
          tin0 |= ((unsigned long)(*(--(in))));
        }
      };
      tin0 ^= tout0;
      tin1 ^= tout1;
      tin[0] = tin0;
      tin[1] = tin1;
      RC2_encrypt(tin, ks);
      tout0 = tin[0];
      (*((out)++) = (unsigned char)(((tout0)) & 0xff),
       *((out)++) = (unsigned char)(((tout0) >> 8L) & 0xff),
       *((out)++) = (unsigned char)(((tout0) >> 16L) & 0xff),
       *((out)++) = (unsigned char)(((tout0) >> 24L) & 0xff));
      tout1 = tin[1];
      (*((out)++) = (unsigned char)(((tout1)) & 0xff),
       *((out)++) = (unsigned char)(((tout1) >> 8L) & 0xff),
       *((out)++) = (unsigned char)(((tout1) >> 16L) & 0xff),
       *((out)++) = (unsigned char)(((tout1) >> 24L) & 0xff));
    }
    (*((iv)++) = (unsigned char)(((tout0)) & 0xff),
     *((iv)++) = (unsigned char)(((tout0) >> 8L) & 0xff),
     *((iv)++) = (unsigned char)(((tout0) >> 16L) & 0xff),
     *((iv)++) = (unsigned char)(((tout0) >> 24L) & 0xff));
    (*((iv)++) = (unsigned char)(((tout1)) & 0xff),
     *((iv)++) = (unsigned char)(((tout1) >> 8L) & 0xff),
     *((iv)++) = (unsigned char)(((tout1) >> 16L) & 0xff),
     *((iv)++) = (unsigned char)(((tout1) >> 24L) & 0xff));
  } else {
    (xor0 = ((unsigned long)(*((iv)++))),
     xor0 |= ((unsigned long)(*((iv)++))) << 8L,
     xor0 |= ((unsigned long)(*((iv)++))) << 16L,
     xor0 |= ((unsigned long)(*((iv)++))) << 24L);
    (xor1 = ((unsigned long)(*((iv)++))),
     xor1 |= ((unsigned long)(*((iv)++))) << 8L,
     xor1 |= ((unsigned long)(*((iv)++))) << 16L,
     xor1 |= ((unsigned long)(*((iv)++))) << 24L);
    iv -= 8;
    for (l -= 8; l >= 0; l -= 8) {
      (tin0 = ((unsigned long)(*((in)++))),
       tin0 |= ((unsigned long)(*((in)++))) << 8L,
       tin0 |= ((unsigned long)(*((in)++))) << 16L,
       tin0 |= ((unsigned long)(*((in)++))) << 24L);
      tin[0] = tin0;
      (tin1 = ((unsigned long)(*((in)++))),
       tin1 |= ((unsigned long)(*((in)++))) << 8L,
       tin1 |= ((unsigned long)(*((in)++))) << 16L,
       tin1 |= ((unsigned long)(*((in)++))) << 24L);
      tin[1] = tin1;
      RC2_decrypt(tin, ks);
      tout0 = tin[0] ^ xor0;
      tout1 = tin[1] ^ xor1;
      (*((out)++) = (unsigned char)(((tout0)) & 0xff),
       *((out)++) = (unsigned char)(((tout0) >> 8L) & 0xff),
       *((out)++) = (unsigned char)(((tout0) >> 16L) & 0xff),
       *((out)++) = (unsigned char)(((tout0) >> 24L) & 0xff));
      (*((out)++) = (unsigned char)(((tout1)) & 0xff),
       *((out)++) = (unsigned char)(((tout1) >> 8L) & 0xff),
       *((out)++) = (unsigned char)(((tout1) >> 16L) & 0xff),
       *((out)++) = (unsigned char)(((tout1) >> 24L) & 0xff));
      xor0 = tin0;
      xor1 = tin1;
    }
    if (l != -8) {
      (tin0 = ((unsigned long)(*((in)++))),
       tin0 |= ((unsigned long)(*((in)++))) << 8L,
       tin0 |= ((unsigned long)(*((in)++))) << 16L,
       tin0 |= ((unsigned long)(*((in)++))) << 24L);
      tin[0] = tin0;
      (tin1 = ((unsigned long)(*((in)++))),
       tin1 |= ((unsigned long)(*((in)++))) << 8L,
       tin1 |= ((unsigned long)(*((in)++))) << 16L,
       tin1 |= ((unsigned long)(*((in)++))) << 24L);
      tin[1] = tin1;
      RC2_decrypt(tin, ks);
      tout0 = tin[0] ^ xor0;
      tout1 = tin[1] ^ xor1;
      {
        out += l + 8;
        switch (l + 8) {
        case 8:
          *(--(out)) = (unsigned char)(((tout1) >> 24L) & 0xff);
        case 7:
          *(--(out)) = (unsigned char)(((tout1) >> 16L) & 0xff);
        case 6:
          *(--(out)) = (unsigned char)(((tout1) >> 8L) & 0xff);
        case 5:
          *(--(out)) = (unsigned char)(((tout1)) & 0xff);
        case 4:
          *(--(out)) = (unsigned char)(((tout0) >> 24L) & 0xff);
        case 3:
          *(--(out)) = (unsigned char)(((tout0) >> 16L) & 0xff);
        case 2:
          *(--(out)) = (unsigned char)(((tout0) >> 8L) & 0xff);
        case 1:
          *(--(out)) = (unsigned char)(((tout0)) & 0xff);
        }
      };
      xor0 = tin0;
      xor1 = tin1;
    }
    (*((iv)++) = (unsigned char)(((xor0)) & 0xff),
     *((iv)++) = (unsigned char)(((xor0) >> 8L) & 0xff),
     *((iv)++) = (unsigned char)(((xor0) >> 16L) & 0xff),
     *((iv)++) = (unsigned char)(((xor0) >> 24L) & 0xff));
    (*((iv)++) = (unsigned char)(((xor1)) & 0xff),
     *((iv)++) = (unsigned char)(((xor1) >> 8L) & 0xff),
     *((iv)++) = (unsigned char)(((xor1) >> 16L) & 0xff),
     *((iv)++) = (unsigned char)(((xor1) >> 24L) & 0xff));
  }
  tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0;
  tin[0] = tin[1] = 0;
}


x86 assembly (clang, -O0):
<RC2_cbc_encrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%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,-0x68(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     181c <RC2_cbc_encrypt+0x6fc>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x68(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x68(%rbp)
jl     148e <RC2_cbc_encrypt+0x36e>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x50(%rbp),%rax
xor    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x78(%rbp)
lea    -0x80(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1040 <RC2_encrypt@plt>
mov    -0x80(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x78(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x68(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x68(%rbp)
jmp    124d <RC2_cbc_encrypt+0x12d>
cmpq   $0xfffffffffffffff8,-0x68(%rbp)
je     1717 <RC2_cbc_encrypt+0x5f7>
mov    -0x68(%rbp),%rax
mov    -0x8(%rbp),%rcx
lea    0x8(%rax,%rcx,1),%rax
mov    %rax,-0x8(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x68(%rbp),%rax
add    $0x7,%rax
mov    %rax,-0x88(%rbp)
sub    $0x7,%rax
ja     15d2 <RC2_cbc_encrypt+0x4b2>
mov    -0x88(%rbp),%rax
lea    0xb3f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x18,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x10,%rax
or     -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x8,%rax
or     -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
movzbl -0x1(%rax),%eax
or     -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x18,%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x10,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
movzbl -0x1(%rax),%eax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x50(%rbp),%rax
xor    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x78(%rbp)
lea    -0x80(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1040 <RC2_encrypt@plt>
mov    -0x80(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x78(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1ef2 <RC2_cbc_encrypt+0xdd2>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x68(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x68(%rbp)
jl     1b55 <RC2_cbc_encrypt+0xa35>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x78(%rbp)
lea    -0x80(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1030 <RC2_decrypt@plt>
mov    -0x80(%rbp),%rax
xor    -0x58(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x78(%rbp),%rax
xor    -0x60(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x50(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x68(%rbp)
jmp    1914 <RC2_cbc_encrypt+0x7f4>
cmpq   $0xfffffffffffffff8,-0x68(%rbp)
je     1df2 <RC2_cbc_encrypt+0xcd2>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x8,%rcx
mov    -0x38(%rbp),%rax
or     %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x10,%rcx
mov    -0x38(%rbp),%rax
or     %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x18,%rcx
mov    -0x38(%rbp),%rax
or     %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x8,%rcx
mov    -0x40(%rbp),%rax
or     %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x10,%rcx
mov    -0x40(%rbp),%rax
or     %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x18,%rcx
mov    -0x40(%rbp),%rax
or     %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rsi
lea    -0x80(%rbp),%rdi
call   1030 <RC2_decrypt@plt>
mov    -0x80(%rbp),%rax
mov    -0x58(%rbp),%rcx
xor    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x60(%rbp),%rcx
xor    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x10(%rbp),%rcx
lea    0x8(%rax,%rcx,1),%rax
mov    %rax,-0x10(%rbp)
mov    -0x68(%rbp),%rax
add    $0x7,%rax
mov    %rax,-0x90(%rbp)
sub    $0x7,%rax
ja     1de2 <RC2_cbc_encrypt+0xcc2>
mov    -0x90(%rbp),%rax
lea    0x32f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x50(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x50(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x50(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x50(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x48(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x48(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x48(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x48(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x60(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x60(%rbp),%rax
shr    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x60(%rbp),%rax
shr    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x60(%rbp),%rax
shr    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
movq   $0x0,-0x60(%rbp)
movq   $0x0,-0x58(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x78(%rbp)
movq   $0x0,-0x80(%rbp)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<RC2_cbc_encrypt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rcx,%r13
mov    %rdx,%r15
mov    %rsi,%rbp
mov    %rdi,%r14
mov    (%r8),%edx
mov    %r8,0x20(%rsp)
mov    0x4(%r8),%ebx
test   %r9d,%r9d
je     1295 <RC2_cbc_encrypt+0x175>
cmp    $0x8,%r15
jl     11a8 <RC2_cbc_encrypt+0x88>
mov    %rsp,%r12
mov    %rbx,%rsi
nopl   0x0(%rax,%rax,1)
mov    %r15,%rbx
add    $0xfffffffffffffff8,%r15
mov    (%r14),%eax
mov    0x4(%r14),%ecx
xor    %rdx,%rax
add    $0x8,%r14
xor    %rsi,%rcx
mov    %rax,(%rsp)
mov    %rcx,0x8(%rsp)
mov    %r12,%rdi
mov    %r13,%rsi
call   1040 <RC2_encrypt@plt>
mov    (%rsp),%rdx
mov    %edx,0x0(%rbp)
mov    0x8(%rsp),%rsi
mov    %esi,0x4(%rbp)
add    $0x8,%rbp
cmp    $0xf,%rbx
ja     1160 <RC2_cbc_encrypt+0x40>
mov    %rsi,%rbx
test   %r15,%r15
je     1419 <RC2_cbc_encrypt+0x2f9>
xor    %eax,%eax
lea    -0x1(%r15),%rcx
cmp    $0x6,%rcx
ja     1473 <RC2_cbc_encrypt+0x353>
mov    %rdx,%rdi
add    %r15,%r14
lea    0xe32(%rip),%rdx
movslq (%rdx,%rcx,4),%rsi
add    %rdx,%rsi
xor    %ecx,%ecx
jmp    *%rsi
movzbl -0x1(%r14),%eax
add    $0xffffffffffffffff,%r14
shl    $0x10,%rax
movzbl -0x1(%r14),%ecx
add    $0xffffffffffffffff,%r14
shl    $0x8,%rcx
or     %rcx,%rax
movzbl -0x1(%r14),%ecx
add    $0xffffffffffffffff,%r14
or     %rcx,%rax
mov    %rax,%rcx
movzbl -0x1(%r14),%eax
add    $0xffffffffffffffff,%r14
shl    $0x18,%rax
movzbl -0x1(%r14),%edx
add    $0xffffffffffffffff,%r14
shl    $0x10,%rdx
or     %rdx,%rax
movzbl -0x1(%r14),%edx
add    $0xffffffffffffffff,%r14
shl    $0x8,%rdx
or     %rdx,%rax
movzbl -0x1(%r14),%edx
or     %rdx,%rax
mov    %rdi,%rdx
xor    %rdx,%rax
xor    %rbx,%rcx
mov    %rax,(%rsp)
mov    %rcx,0x8(%rsp)
mov    %rsp,%rdi
mov    %r13,%rsi
call   1040 <RC2_encrypt@plt>
mov    (%rsp),%rdx
mov    %rdx,%r8
shr    $0x8,%r8
mov    %rdx,%r9
shr    $0x10,%r9
mov    %rdx,%rax
shr    $0x18,%rax
mov    %edx,0x0(%rbp)
mov    0x8(%rsp),%rsi
mov    %rsi,%rcx
shr    $0x8,%rcx
mov    %rsi,%rdi
shr    $0x10,%rdi
mov    %rsi,%rbx
shr    $0x18,%rbx
mov    %esi,0x4(%rbp)
jmp    1443 <RC2_cbc_encrypt+0x323>
cmp    $0x8,%r15
jl     1345 <RC2_cbc_encrypt+0x225>
mov    %r13,0x28(%rsp)
mov    %r15,%rax
mov    %rbx,%r15
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rbx
mov    %r15,%r13
mov    %rax,%r15
mov    %rax,0x18(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rsp)
mov    (%r14),%r12d
mov    %r12,(%rsp)
mov    0x4(%r14),%r15d
add    $0x8,%r14
mov    %r15,0x8(%rsp)
mov    %rsp,%rdi
mov    0x28(%rsp),%rsi
call   1030 <RC2_decrypt@plt>
mov    %r12,%rdx
xor    (%rsp),%rbx
xor    0x8(%rsp),%r13
mov    %bl,0x0(%rbp)
mov    %bh,0x1(%rbp)
mov    %rbx,%rax
shr    $0x10,%rax
mov    %al,0x2(%rbp)
shr    $0x18,%rbx
mov    %bl,0x3(%rbp)
mov    %r13,%rcx
mov    %cl,0x4(%rbp)
mov    %ch,0x5(%rbp)
mov    %r13,%rax
shr    $0x10,%rax
mov    %al,0x6(%rbp)
mov    0x30(%rsp),%rax
shr    $0x18,%rcx
mov    %cl,0x7(%rbp)
add    $0x8,%rbp
cmpq   $0xf,0x18(%rsp)
ja     12b0 <RC2_cbc_encrypt+0x190>
mov    %r15,%rbx
mov    0x28(%rsp),%r13
mov    %rax,%r15
test   %r15,%r15
je     13e7 <RC2_cbc_encrypt+0x2c7>
mov    %rdx,%r12
mov    (%r14),%eax
mov    %rax,0x18(%rsp)
mov    %rax,(%rsp)
mov    0x4(%r14),%eax
mov    %rax,%r14
mov    %rax,0x8(%rsp)
mov    %rsp,%rdi
mov    %r13,%rsi
call   1030 <RC2_decrypt@plt>
lea    -0x1(%r15),%rax
cmp    $0x6,%rax
ja     13df <RC2_cbc_encrypt+0x2bf>
mov    %r12,%rdx
xor    (%rsp),%rdx
xor    0x8(%rsp),%rbx
add    %r15,%rbp
lea    0xc88(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    %rbx,%rax
shr    $0x10,%rax
mov    %al,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
mov    %bh,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
mov    %bl,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
mov    %rdx,%rax
shr    $0x18,%rax
mov    %al,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
mov    %rdx,%rax
shr    $0x10,%rax
mov    %al,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
mov    %dh,-0x1(%rbp)
add    $0xffffffffffffffff,%rbp
mov    %dl,-0x1(%rbp)
mov    %r14,%rbx
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%rbp
mov    %dl,0x0(%rbp)
mov    %dh,0x1(%rbp)
mov    %rdx,%rax
shr    $0x10,%rax
mov    %al,0x2(%rbp)
shr    $0x18,%rdx
mov    %dl,0x3(%rbp)
mov    %bl,0x4(%rbp)
mov    %bh,0x5(%rbp)
mov    %rbx,%rax
shr    $0x10,%rax
mov    %al,0x6(%rbp)
shr    $0x18,%rbx
jmp    1461 <RC2_cbc_encrypt+0x341>
mov    %rdx,%r8
shr    $0x8,%r8
mov    %rdx,%r9
shr    $0x10,%r9
mov    %rdx,%rax
shr    $0x18,%rax
mov    %rbx,%rcx
shr    $0x8,%rcx
mov    %rbx,%rdi
shr    $0x10,%rdi
mov    %rbx,%rsi
shr    $0x18,%rbx
mov    0x20(%rsp),%rbp
mov    %dl,0x0(%rbp)
mov    %r8b,0x1(%rbp)
mov    %r9b,0x2(%rbp)
mov    %al,0x3(%rbp)
mov    %sil,0x4(%rbp)
mov    %cl,0x5(%rbp)
mov    %dil,0x6(%rbp)
mov    %bl,0x7(%rbp)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
jmp    123d <RC2_cbc_encrypt+0x11d>

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

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