#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*/ uint8_t;
typedef int uint32_t;

/* Variables and functions */
int READ_ROUND_KEY_DOUBLE_WORD(int);
int rotl(int, int);
int rotr(int, int);
void Decrypt(uint8_t *block, uint8_t *roundKeys) {
  uint32_t *blk = (uint32_t *)block;
  uint32_t *rk = (uint32_t *)roundKeys;
  uint32_t b0 = blk[0];
  uint32_t b1 = blk[1];
  uint32_t b2 = blk[2];
  uint32_t b3 = blk[3];
  rk += 92;
  b0 = (rotr(b0, 9) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 5) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 3) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b3 = (rotr(b3, 9) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 5) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 3) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b2 = (rotr(b2, 9) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 5) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 3) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b1 = (rotr(b1, 9) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 5) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 3) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b0 = (rotr(b0, 9) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 5) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 3) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b3 = (rotr(b3, 9) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 5) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 3) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b2 = (rotr(b2, 9) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 5) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 3) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b1 = (rotr(b1, 9) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 5) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 3) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b0 = (rotr(b0, 9) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 5) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 3) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b3 = (rotr(b3, 9) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 5) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 3) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b2 = (rotr(b2, 9) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 5) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 3) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b1 = (rotr(b1, 9) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 5) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 3) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b0 = (rotr(b0, 9) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 5) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 3) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b3 = (rotr(b3, 9) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 5) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 3) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b2 = (rotr(b2, 9) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 5) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 3) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b1 = (rotr(b1, 9) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 5) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 3) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b0 = (rotr(b0, 9) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 5) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 3) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b3 = (rotr(b3, 9) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 5) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 3) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b2 = (rotr(b2, 9) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 5) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 3) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b1 = (rotr(b1, 9) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 5) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 3) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b0 = (rotr(b0, 9) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 5) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 3) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b3 = (rotr(b3, 9) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 5) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b1 = (rotl(b1, 3) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b2 = (rotr(b2, 9) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 5) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b0 = (rotl(b0, 3) - (b3 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  rk -= 4;
  b1 = (rotr(b1, 9) - (b0 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[0]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b2 = (rotl(b2, 5) - (b1 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[2]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  b3 = (rotl(b3, 3) - (b2 ^ READ_ROUND_KEY_DOUBLE_WORD(rk[3]))) ^
       READ_ROUND_KEY_DOUBLE_WORD(rk[1]);
  blk[0] = b0;
  blk[1] = b1;
  blk[2] = b2;
  blk[3] = b3;
}


x86 assembly (clang, -O0):
<Decrypt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x390,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0x170,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x38c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x390(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x390(%rbp),%ecx
mov    %eax,%edx
mov    -0x38c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x388(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x388(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x380(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x384(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x384(%rbp),%ecx
mov    %eax,%edx
mov    -0x380(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x37c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x37c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x374(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x378(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x378(%rbp),%ecx
mov    %eax,%edx
mov    -0x374(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x370(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x370(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x368(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x36c(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x36c(%rbp),%ecx
mov    %eax,%edx
mov    -0x368(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x364(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x364(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x35c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x360(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x360(%rbp),%ecx
mov    %eax,%edx
mov    -0x35c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x358(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x358(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x350(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x354(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x354(%rbp),%ecx
mov    %eax,%edx
mov    -0x350(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x34c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x34c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x344(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x348(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x348(%rbp),%ecx
mov    %eax,%edx
mov    -0x344(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x340(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x340(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x338(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x33c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x33c(%rbp),%ecx
mov    %eax,%edx
mov    -0x338(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x334(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x334(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x32c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x330(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x330(%rbp),%ecx
mov    %eax,%edx
mov    -0x32c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x328(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x328(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x320(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x324(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x324(%rbp),%ecx
mov    %eax,%edx
mov    -0x320(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x31c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x31c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x314(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x318(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x318(%rbp),%ecx
mov    %eax,%edx
mov    -0x314(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x310(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x310(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x308(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30c(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x30c(%rbp),%ecx
mov    %eax,%edx
mov    -0x308(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x304(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x304(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x2fc(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x300(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x300(%rbp),%ecx
mov    %eax,%edx
mov    -0x2fc(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x2f8(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x2f8(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x2f0(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2f4(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x2f4(%rbp),%ecx
mov    %eax,%edx
mov    -0x2f0(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x2ec(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x2ec(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x2e4(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x2e8(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x2e8(%rbp),%ecx
mov    %eax,%edx
mov    -0x2e4(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x2e0(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x2e0(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x2d8(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x2dc(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x2dc(%rbp),%ecx
mov    %eax,%edx
mov    -0x2d8(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x2d4(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x2d4(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x2cc(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2d0(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x2d0(%rbp),%ecx
mov    %eax,%edx
mov    -0x2cc(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x2c8(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x2c8(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x2c0(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c4(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x2c4(%rbp),%ecx
mov    %eax,%edx
mov    -0x2c0(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x2bc(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x2bc(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x2b4(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x2b8(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x2b8(%rbp),%ecx
mov    %eax,%edx
mov    -0x2b4(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x2b0(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x2b0(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x2a8(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x2ac(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x2ac(%rbp),%ecx
mov    %eax,%edx
mov    -0x2a8(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x2a4(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x2a4(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x29c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2a0(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x2a0(%rbp),%ecx
mov    %eax,%edx
mov    -0x29c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x298(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x298(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x290(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x294(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x294(%rbp),%ecx
mov    %eax,%edx
mov    -0x290(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x28c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x28c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x284(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x288(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x288(%rbp),%ecx
mov    %eax,%edx
mov    -0x284(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x280(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x280(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x278(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x27c(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x27c(%rbp),%ecx
mov    %eax,%edx
mov    -0x278(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x274(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x274(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x26c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x270(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x270(%rbp),%ecx
mov    %eax,%edx
mov    -0x26c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x268(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x268(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x260(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x264(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x264(%rbp),%ecx
mov    %eax,%edx
mov    -0x260(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x25c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x25c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x254(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x258(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x258(%rbp),%ecx
mov    %eax,%edx
mov    -0x254(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x250(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x250(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x248(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x24c(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x24c(%rbp),%ecx
mov    %eax,%edx
mov    -0x248(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x244(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x244(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x23c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x240(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x240(%rbp),%ecx
mov    %eax,%edx
mov    -0x23c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x238(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x238(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x230(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x234(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x234(%rbp),%ecx
mov    %eax,%edx
mov    -0x230(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x22c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x22c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x224(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x228(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x228(%rbp),%ecx
mov    %eax,%edx
mov    -0x224(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x220(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x220(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x218(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x21c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x21c(%rbp),%ecx
mov    %eax,%edx
mov    -0x218(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x214(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x214(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x20c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x210(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x210(%rbp),%ecx
mov    %eax,%edx
mov    -0x20c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x208(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x208(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x200(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x204(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x204(%rbp),%ecx
mov    %eax,%edx
mov    -0x200(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1fc(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x1fc(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x1f4(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1f8(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x1f8(%rbp),%ecx
mov    %eax,%edx
mov    -0x1f4(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x1f0(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x1e8(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x1ec(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x1ec(%rbp),%ecx
mov    %eax,%edx
mov    -0x1e8(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1e4(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x1e4(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x1dc(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x1e0(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x1e0(%rbp),%ecx
mov    %eax,%edx
mov    -0x1dc(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1d8(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x1d8(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x1d0(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x1d4(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x1d4(%rbp),%ecx
mov    %eax,%edx
mov    -0x1d0(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1cc(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x1cc(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x1c4(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c8(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x1c8(%rbp),%ecx
mov    %eax,%edx
mov    -0x1c4(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1c0(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x1c0(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x1b8(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x1bc(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x1bc(%rbp),%ecx
mov    %eax,%edx
mov    -0x1b8(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1b4(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x1b4(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x1ac(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x1b0(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x1b0(%rbp),%ecx
mov    %eax,%edx
mov    -0x1ac(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x1a8(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x1a8(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x1a0(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x1a4(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x1a4(%rbp),%ecx
mov    %eax,%edx
mov    -0x1a0(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x19c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x19c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x194(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x198(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x198(%rbp),%ecx
mov    %eax,%edx
mov    -0x194(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x190(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x190(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x188(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x18c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x18c(%rbp),%ecx
mov    %eax,%edx
mov    -0x188(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x184(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x184(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x17c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x180(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x180(%rbp),%ecx
mov    %eax,%edx
mov    -0x17c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x178(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x178(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x170(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x174(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x174(%rbp),%ecx
mov    %eax,%edx
mov    -0x170(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x16c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x16c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x164(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x168(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x168(%rbp),%ecx
mov    %eax,%edx
mov    -0x164(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x160(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x160(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x158(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x15c(%rbp),%ecx
mov    %eax,%edx
mov    -0x158(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x154(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x154(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x14c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x150(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x150(%rbp),%ecx
mov    %eax,%edx
mov    -0x14c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x148(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x148(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x140(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x144(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x144(%rbp),%ecx
mov    %eax,%edx
mov    -0x140(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x13c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x13c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x134(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x138(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x138(%rbp),%ecx
mov    %eax,%edx
mov    -0x134(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x130(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x130(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x128(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x12c(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x12c(%rbp),%ecx
mov    %eax,%edx
mov    -0x128(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x124(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x124(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x11c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x120(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x120(%rbp),%ecx
mov    %eax,%edx
mov    -0x11c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x118(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x118(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x110(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x114(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x114(%rbp),%ecx
mov    %eax,%edx
mov    -0x110(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x10c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x10c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x104(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x108(%rbp),%ecx
mov    %eax,%edx
mov    -0x104(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x100(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x100(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0xf8(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0xfc(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0xfc(%rbp),%ecx
mov    %eax,%edx
mov    -0xf8(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0xf4(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0xf4(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0xec(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0xf0(%rbp),%ecx
mov    %eax,%edx
mov    -0xec(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0xe8(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0xe8(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0xe0(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0xe4(%rbp),%ecx
mov    %eax,%edx
mov    -0xe0(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0xdc(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0xdc(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0xd4(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0xd8(%rbp),%ecx
mov    %eax,%edx
mov    -0xd4(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0xd0(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0xd0(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0xc8(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0xcc(%rbp),%ecx
mov    %eax,%edx
mov    -0xc8(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0xc4(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0xc4(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0xbc(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0xc0(%rbp),%ecx
mov    %eax,%edx
mov    -0xbc(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0xb8(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0xb0(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0xb4(%rbp),%ecx
mov    %eax,%edx
mov    -0xb0(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0xac(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0xac(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0xa4(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0xa8(%rbp),%ecx
mov    %eax,%edx
mov    -0xa4(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0xa0(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x98(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x9c(%rbp),%ecx
mov    %eax,%edx
mov    -0x98(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x94(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x8c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x90(%rbp),%ecx
mov    %eax,%edx
mov    -0x8c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x88(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x88(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x80(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x84(%rbp),%ecx
mov    %eax,%edx
mov    -0x80(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x7c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x74(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x78(%rbp),%ecx
mov    %eax,%edx
mov    -0x74(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x70(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x6c(%rbp),%ecx
mov    %eax,%edx
mov    -0x68(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x64(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x5c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x60(%rbp),%ecx
mov    %eax,%edx
mov    -0x5c(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x58(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,-0x50(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x54(%rbp),%ecx
mov    %eax,%edx
mov    -0x50(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x4c(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x48(%rbp),%ecx
mov    %eax,%edx
mov    -0x44(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x40(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    -0x3c(%rbp),%ecx
mov    %eax,%edx
mov    -0x38(%rbp),%eax
xor    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ecx
mov    -0x34(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0xc(%rax)
add    $0x390,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Decrypt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rax
mov    %rdi,(%rsp)
mov    (%rdi),%edi
mov    0x4(%rax),%ebp
mov    0x8(%rax),%ebx
mov    0xc(%rax),%r13d
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r15d
mov    0x170(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x174(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %ebp,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0x178(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x174(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebx,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0x17c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x174(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r13d
mov    0x160(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x164(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0x168(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x164(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0x16c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x164(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%ebp
mov    0x150(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x154(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0x158(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x154(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0x15c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x154(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r12d
mov    0x140(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x144(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0x148(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x144(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0x14c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x144(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r15d
mov    0x130(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x134(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0x138(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x134(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0x13c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x134(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r13d
mov    0x120(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x124(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0x128(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x124(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0x12c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x124(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%ebp
mov    0x110(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x114(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0x118(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x114(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0x11c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x114(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r12d
mov    0x100(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x104(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0x108(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x104(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0x10c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x104(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r15d
mov    0xf0(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0xf4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0xf8(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0xf4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0xfc(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0xf4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r13d
mov    0xe0(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0xe4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0xe8(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0xe4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0xec(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0xe4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%ebp
mov    0xd0(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0xd4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0xd8(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0xd4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0xdc(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0xd4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r12d
mov    0xc0(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0xc4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0xc8(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0xc4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0xcc(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0xc4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r15d
mov    0xb0(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0xb4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0xb8(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0xb4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0xbc(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0xb4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r13d
mov    0xa0(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0xa4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0xa8(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0xa4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0xac(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0xa4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%ebp
mov    0x90(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x94(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0x98(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x94(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0x9c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x94(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r12d
mov    0x80(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x84(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0x88(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x84(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0x8c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x84(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r15d
mov    0x70(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x74(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0x78(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x74(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0x7c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x74(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r13d
mov    0x60(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x64(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0x68(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x64(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0x6c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x64(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%ebp
mov    0x50(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x54(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0x58(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x54(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0x5c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x54(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r12d
mov    0x40(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x44(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0x48(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x44(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0x4c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x44(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r15d
mov    0x30(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x34(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0x38(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x34(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0x3c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x34(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebp
mov    %r13d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%r13d
mov    0x20(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
sub    %eax,%r13d
mov    0x24(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r15d
mov    0x28(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%r15d
mov    0x24(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r15d
mov    %r12d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%r12d
mov    0x2c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%r12d
mov    0x24(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r12d
mov    %ebp,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%ebx
mov    0x10(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebx
mov    0x14(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%ebx
mov    %r13d,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%r13d
mov    0x18(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebx,%eax
sub    %eax,%r13d
mov    0x14(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %eax,%r13d
mov    %r15d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0x1c(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r13d,%eax
sub    %eax,%ebp
mov    0x14(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%r15d
xor    %ebp,%r15d
mov    %r12d,%edi
mov    $0x9,%esi
call   1030 <rotr@plt>
mov    %eax,%ebp
mov    (%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r15d,%eax
sub    %eax,%ebp
mov    0x4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%r12d
xor    %ebp,%r12d
mov    %ebx,%edi
mov    $0x5,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0x8(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %r12d,%eax
sub    %eax,%ebp
mov    0x4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
mov    %eax,%ebx
xor    %ebp,%ebx
mov    %r13d,%edi
mov    $0x3,%esi
call   1040 <rotl@plt>
mov    %eax,%ebp
mov    0xc(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebx,%eax
sub    %eax,%ebp
mov    0x4(%r14),%edi
call   1050 <READ_ROUND_KEY_DOUBLE_WORD@plt>
xor    %ebp,%eax
mov    (%rsp),%rcx
mov    %r15d,(%rcx)
mov    %r12d,0x4(%rcx)
mov    %ebx,0x8(%rcx)
mov    %eax,0xc(%rcx)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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