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

/* Variables and functions */
int /*<<< orphan*/ READ_ROUND_KEY_WORD(int /*<<< orphan*/);
int rot32l8(int);
int rot32r8(int);
int /*<<< orphan*/ speckey(int /*<<< orphan*/ *, int /*<<< orphan*/ *);
void round_f(uint16_t *block, uint16_t *roundKeys) {
  uint16_t temp;
  block[0] ^= READ_ROUND_KEY_WORD(roundKeys[0]);
  block[1] ^= READ_ROUND_KEY_WORD(roundKeys[1]);
  speckey(&block[0], &block[1]);
  block[0] ^= READ_ROUND_KEY_WORD(roundKeys[2]);
  block[1] ^= READ_ROUND_KEY_WORD(roundKeys[3]);
  speckey(&block[0], &block[1]);
  block[0] ^= READ_ROUND_KEY_WORD(roundKeys[4]);
  block[1] ^= READ_ROUND_KEY_WORD(roundKeys[5]);
  speckey(&block[0], &block[1]);
  block[0] ^= READ_ROUND_KEY_WORD(roundKeys[6]);
  block[1] ^= READ_ROUND_KEY_WORD(roundKeys[7]);
  speckey(&block[0], &block[1]);
  block[2] ^= READ_ROUND_KEY_WORD(roundKeys[8]);
  block[3] ^= READ_ROUND_KEY_WORD(roundKeys[9]);
  speckey(&block[2], &block[3]);
  block[2] ^= READ_ROUND_KEY_WORD(roundKeys[10]);
  block[3] ^= READ_ROUND_KEY_WORD(roundKeys[11]);
  speckey(&block[2], &block[3]);
  block[2] ^= READ_ROUND_KEY_WORD(roundKeys[12]);
  block[3] ^= READ_ROUND_KEY_WORD(roundKeys[13]);
  speckey(&block[2], &block[3]);
  block[2] ^= READ_ROUND_KEY_WORD(roundKeys[14]);
  block[3] ^= READ_ROUND_KEY_WORD(roundKeys[15]);
  speckey(&block[2], &block[3]);
  block[4] ^= READ_ROUND_KEY_WORD(roundKeys[16]);
  block[5] ^= READ_ROUND_KEY_WORD(roundKeys[17]);
  speckey(&block[4], &block[5]);
  block[4] ^= READ_ROUND_KEY_WORD(roundKeys[18]);
  block[5] ^= READ_ROUND_KEY_WORD(roundKeys[19]);
  speckey(&block[4], &block[5]);
  block[4] ^= READ_ROUND_KEY_WORD(roundKeys[20]);
  block[5] ^= READ_ROUND_KEY_WORD(roundKeys[21]);
  speckey(&block[4], &block[5]);
  block[4] ^= READ_ROUND_KEY_WORD(roundKeys[22]);
  block[5] ^= READ_ROUND_KEY_WORD(roundKeys[23]);
  speckey(&block[4], &block[5]);
  block[6] ^= READ_ROUND_KEY_WORD(roundKeys[24]);
  block[7] ^= READ_ROUND_KEY_WORD(roundKeys[25]);
  speckey(&block[6], &block[7]);
  block[6] ^= READ_ROUND_KEY_WORD(roundKeys[26]);
  block[7] ^= READ_ROUND_KEY_WORD(roundKeys[27]);
  speckey(&block[6], &block[7]);
  block[6] ^= READ_ROUND_KEY_WORD(roundKeys[28]);
  block[7] ^= READ_ROUND_KEY_WORD(roundKeys[29]);
  speckey(&block[6], &block[7]);
  block[6] ^= READ_ROUND_KEY_WORD(roundKeys[30]);
  block[7] ^= READ_ROUND_KEY_WORD(roundKeys[31]);
  speckey(&block[6], &block[7]);
  uint32_t *Block = (uint32_t *)block;
  uint32_t t = Block[0] ^ Block[1];
  uint32_t tx[2];
  tx[0] = Block[0];
  tx[1] = Block[1];
  t = rot32l8(t) ^ rot32r8(t);
  Block[0] ^= t;
  Block[1] ^= t;
  t = Block[0];
  Block[0] = (Block[0] & 0xffff0000) | (Block[1] & 0x0000ffff);
  Block[1] = (Block[1] & 0xffff0000) | (t & 0x0000ffff);
  Block[0] ^= Block[2];
  Block[1] ^= Block[3];
  Block[2] = tx[0];
  Block[3] = tx[1];
}


x86 assembly (clang, -O0):
<round_f>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
add    $0x4,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    0xc(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
add    $0x4,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    0x14(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
add    $0x4,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
mov    0x1c(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
add    $0x4,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x10(%rbp),%rax
mov    0x24(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rdi
add    $0x8,%rdi
mov    -0x8(%rbp),%rsi
add    $0xc,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x10(%rbp),%rax
mov    0x2c(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rdi
add    $0x8,%rdi
mov    -0x8(%rbp),%rsi
add    $0xc,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x10(%rbp),%rax
mov    0x34(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rdi
add    $0x8,%rdi
mov    -0x8(%rbp),%rsi
add    $0xc,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x10(%rbp),%rax
mov    0x3c(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rdi
add    $0x8,%rdi
mov    -0x8(%rbp),%rsi
add    $0xc,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
mov    -0x10(%rbp),%rax
mov    0x44(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x14(%rax),%ecx
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rdi
add    $0x10,%rdi
mov    -0x8(%rbp),%rsi
add    $0x14,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x48(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
mov    -0x10(%rbp),%rax
mov    0x4c(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x14(%rax),%ecx
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rdi
add    $0x10,%rdi
mov    -0x8(%rbp),%rsi
add    $0x14,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x50(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
mov    -0x10(%rbp),%rax
mov    0x54(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x14(%rax),%ecx
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rdi
add    $0x10,%rdi
mov    -0x8(%rbp),%rsi
add    $0x14,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x58(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
mov    -0x10(%rbp),%rax
mov    0x5c(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x14(%rax),%ecx
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rdi
add    $0x10,%rdi
mov    -0x8(%rbp),%rsi
add    $0x14,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%ecx
mov    %ecx,0x18(%rax)
mov    -0x10(%rbp),%rax
mov    0x64(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x1c(%rax),%ecx
mov    %ecx,0x1c(%rax)
mov    -0x8(%rbp),%rdi
add    $0x18,%rdi
mov    -0x8(%rbp),%rsi
add    $0x1c,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x68(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%ecx
mov    %ecx,0x18(%rax)
mov    -0x10(%rbp),%rax
mov    0x6c(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x1c(%rax),%ecx
mov    %ecx,0x1c(%rax)
mov    -0x8(%rbp),%rdi
add    $0x18,%rdi
mov    -0x8(%rbp),%rsi
add    $0x1c,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x70(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%ecx
mov    %ecx,0x18(%rax)
mov    -0x10(%rbp),%rax
mov    0x74(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x1c(%rax),%ecx
mov    %ecx,0x1c(%rax)
mov    -0x8(%rbp),%rdi
add    $0x18,%rdi
mov    -0x8(%rbp),%rsi
add    $0x1c,%rsi
call   1050 <speckey@plt>
mov    -0x10(%rbp),%rax
mov    0x78(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%ecx
mov    %ecx,0x18(%rax)
mov    -0x10(%rbp),%rax
mov    0x7c(%rax),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x1c(%rax),%ecx
mov    %ecx,0x1c(%rax)
mov    -0x8(%rbp),%rdi
add    $0x18,%rdi
mov    -0x8(%rbp),%rsi
add    $0x1c,%rsi
call   1050 <speckey@plt>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    -0x20(%rbp),%rcx
xor    0x4(%rcx),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%edi
call   1060 <rot32l8@plt>
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%edi
call   1030 <rot32r8@plt>
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
xor    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
and    $0xffff0000,%ecx
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%eax
and    $0xffff,%eax
or     %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%ecx
and    $0xffff0000,%ecx
mov    -0x24(%rbp),%eax
and    $0xffff,%eax
or     %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x20(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x20(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0xc(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<round_f>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rsi,%r14
mov    %rdi,%rbx
mov    (%rsi),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,(%rbx)
mov    0x4(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
lea    0x4(%rbx),%r15
xor    %eax,0x4(%rbx)
mov    %rbx,%rdi
mov    %r15,%rsi
call   1050 <speckey@plt>
mov    0x8(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,(%rbx)
mov    0xc(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x4(%rbx)
mov    %rbx,%rdi
mov    %r15,%rsi
call   1050 <speckey@plt>
mov    0x10(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,(%rbx)
mov    0x14(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x4(%rbx)
mov    %rbx,%rdi
mov    %r15,%rsi
call   1050 <speckey@plt>
mov    0x18(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,(%rbx)
mov    0x1c(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x4(%rbx)
mov    %rbx,%rdi
mov    %r15,%rsi
call   1050 <speckey@plt>
mov    0x20(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
lea    0x8(%rbx),%r15
xor    %eax,0x8(%rbx)
mov    0x24(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
lea    0xc(%rbx),%r12
xor    %eax,0xc(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x28(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x8(%rbx)
mov    0x2c(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0xc(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x30(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x8(%rbx)
mov    0x34(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0xc(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x38(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x8(%rbx)
mov    0x3c(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0xc(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x40(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
lea    0x10(%rbx),%r15
xor    %eax,0x10(%rbx)
mov    0x44(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
lea    0x14(%rbx),%r12
xor    %eax,0x14(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x48(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x10(%rbx)
mov    0x4c(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x14(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x50(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x10(%rbx)
mov    0x54(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x14(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x58(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x10(%rbx)
mov    0x5c(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x14(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x60(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
lea    0x18(%rbx),%r15
xor    %eax,0x18(%rbx)
mov    0x64(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
lea    0x1c(%rbx),%r12
xor    %eax,0x1c(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x68(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x18(%rbx)
mov    0x6c(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x1c(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x70(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x18(%rbx)
mov    0x74(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x1c(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    0x78(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x18(%rbx)
mov    0x7c(%r14),%edi
call   1040 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x1c(%rbx)
mov    %r15,%rdi
mov    %r12,%rsi
call   1050 <speckey@plt>
mov    (%rbx),%r15d
mov    0x4(%rbx),%r12d
mov    %r12d,%ebp
xor    %r15d,%ebp
mov    %ebp,%edi
call   1060 <rot32l8@plt>
mov    %eax,%r14d
mov    %ebp,%edi
call   1030 <rot32r8@plt>
xor    %r14d,%eax
mov    (%rbx),%ecx
xor    %eax,%ecx
xor    0x4(%rbx),%eax
movzwl %cx,%edx
and    $0xffff0000,%ecx
movzwl %ax,%esi
or     %ecx,%esi
and    $0xffff0000,%eax
xor    0x8(%rbx),%esi
or     %eax,%edx
mov    %esi,(%rbx)
xor    0xc(%rbx),%edx
mov    %edx,0x4(%rbx)
mov    %r15d,0x8(%rbx)
mov    %r12d,0xc(%rbx)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @round_f(i32* %0, i32* %1) {
%3 = load i32, i32* %1
%4 = tail call i32 @READ_ROUND_KEY_WORD(i32 %3)
%5 = load i32, i32* %0
%6 = xor i32 %5, %4
store i32 %6, i32* %0
%7 = getelementptr inbounds i32, i32* %1, i64 1
%8 = load i32, i32* %7
%9 = tail call i32 @READ_ROUND_KEY_WORD(i32 %8)
%10 = getelementptr inbounds i32, i32* %0, i64 1
%11 = load i32, i32* %10
%12 = xor i32 %11, %9
store i32 %12, i32* %10
%13 = tail call i32 @speckey(i32* %0, i32* %10)
%14 = getelementptr inbounds i32, i32* %1, i64 2
%15 = load i32, i32* %14
%16 = tail call i32 @READ_ROUND_KEY_WORD(i32 %15)
%17 = load i32, i32* %0
%18 = xor i32 %17, %16
store i32 %18, i32* %0
%19 = getelementptr inbounds i32, i32* %1, i64 3
%20 = load i32, i32* %19
%21 = tail call i32 @READ_ROUND_KEY_WORD(i32 %20)
%22 = load i32, i32* %10
%23 = xor i32 %22, %21
store i32 %23, i32* %10
%24 = tail call i32 @speckey(i32* %0, i32* %10)
%25 = getelementptr inbounds i32, i32* %1, i64 4
%26 = load i32, i32* %25
%27 = tail call i32 @READ_ROUND_KEY_WORD(i32 %26)
%28 = load i32, i32* %0
%29 = xor i32 %28, %27
store i32 %29, i32* %0
%30 = getelementptr inbounds i32, i32* %1, i64 5
%31 = load i32, i32* %30
%32 = tail call i32 @READ_ROUND_KEY_WORD(i32 %31)
%33 = load i32, i32* %10
%34 = xor i32 %33, %32
store i32 %34, i32* %10
%35 = tail call i32 @speckey(i32* %0, i32* %10)
%36 = getelementptr inbounds i32, i32* %1, i64 6
%37 = load i32, i32* %36
%38 = tail call i32 @READ_ROUND_KEY_WORD(i32 %37)
%39 = load i32, i32* %0
%40 = xor i32 %39, %38
store i32 %40, i32* %0
%41 = getelementptr inbounds i32, i32* %1, i64 7
%42 = load i32, i32* %41
%43 = tail call i32 @READ_ROUND_KEY_WORD(i32 %42)
%44 = load i32, i32* %10
%45 = xor i32 %44, %43
store i32 %45, i32* %10
%46 = tail call i32 @speckey(i32* %0, i32* %10)
%47 = getelementptr inbounds i32, i32* %1, i64 8
%48 = load i32, i32* %47
%49 = tail call i32 @READ_ROUND_KEY_WORD(i32 %48)
%50 = getelementptr inbounds i32, i32* %0, i64 2
%51 = load i32, i32* %50
%52 = xor i32 %51, %49
store i32 %52, i32* %50
%53 = getelementptr inbounds i32, i32* %1, i64 9
%54 = load i32, i32* %53
%55 = tail call i32 @READ_ROUND_KEY_WORD(i32 %54)
%56 = getelementptr inbounds i32, i32* %0, i64 3
%57 = load i32, i32* %56
%58 = xor i32 %57, %55
store i32 %58, i32* %56
%59 = tail call i32 @speckey(i32* %50, i32* %56)
%60 = getelementptr inbounds i32, i32* %1, i64 10
%61 = load i32, i32* %60
%62 = tail call i32 @READ_ROUND_KEY_WORD(i32 %61)
%63 = load i32, i32* %50
%64 = xor i32 %63, %62
store i32 %64, i32* %50
%65 = getelementptr inbounds i32, i32* %1, i64 11
%66 = load i32, i32* %65
%67 = tail call i32 @READ_ROUND_KEY_WORD(i32 %66)
%68 = load i32, i32* %56
%69 = xor i32 %68, %67
store i32 %69, i32* %56
%70 = tail call i32 @speckey(i32* %50, i32* %56)
%71 = getelementptr inbounds i32, i32* %1, i64 12
%72 = load i32, i32* %71
%73 = tail call i32 @READ_ROUND_KEY_WORD(i32 %72)
%74 = load i32, i32* %50
%75 = xor i32 %74, %73
store i32 %75, i32* %50
%76 = getelementptr inbounds i32, i32* %1, i64 13
%77 = load i32, i32* %76
%78 = tail call i32 @READ_ROUND_KEY_WORD(i32 %77)
%79 = load i32, i32* %56
%80 = xor i32 %79, %78
store i32 %80, i32* %56
%81 = tail call i32 @speckey(i32* %50, i32* %56)
%82 = getelementptr inbounds i32, i32* %1, i64 14
%83 = load i32, i32* %82
%84 = tail call i32 @READ_ROUND_KEY_WORD(i32 %83)
%85 = load i32, i32* %50
%86 = xor i32 %85, %84
store i32 %86, i32* %50
%87 = getelementptr inbounds i32, i32* %1, i64 15
%88 = load i32, i32* %87
%89 = tail call i32 @READ_ROUND_KEY_WORD(i32 %88)
%90 = load i32, i32* %56
%91 = xor i32 %90, %89
store i32 %91, i32* %56
%92 = tail call i32 @speckey(i32* %50, i32* %56)
%93 = getelementptr inbounds i32, i32* %1, i64 16
%94 = load i32, i32* %93
%95 = tail call i32 @READ_ROUND_KEY_WORD(i32 %94)
%96 = getelementptr inbounds i32, i32* %0, i64 4
%97 = load i32, i32* %96
%98 = xor i32 %97, %95
store i32 %98, i32* %96
%99 = getelementptr inbounds i32, i32* %1, i64 17
%100 = load i32, i32* %99
%101 = tail call i32 @READ_ROUND_KEY_WORD(i32 %100)
%102 = getelementptr inbounds i32, i32* %0, i64 5
%103 = load i32, i32* %102
%104 = xor i32 %103, %101
store i32 %104, i32* %102
%105 = tail call i32 @speckey(i32* %96, i32* %102)
%106 = getelementptr inbounds i32, i32* %1, i64 18
%107 = load i32, i32* %106
%108 = tail call i32 @READ_ROUND_KEY_WORD(i32 %107)
%109 = load i32, i32* %96
%110 = xor i32 %109, %108
store i32 %110, i32* %96
%111 = getelementptr inbounds i32, i32* %1, i64 19
%112 = load i32, i32* %111
%113 = tail call i32 @READ_ROUND_KEY_WORD(i32 %112)
%114 = load i32, i32* %102
%115 = xor i32 %114, %113
store i32 %115, i32* %102
%116 = tail call i32 @speckey(i32* %96, i32* %102)
%117 = getelementptr inbounds i32, i32* %1, i64 20
%118 = load i32, i32* %117
%119 = tail call i32 @READ_ROUND_KEY_WORD(i32 %118)
%120 = load i32, i32* %96
%121 = xor i32 %120, %119
store i32 %121, i32* %96
%122 = getelementptr inbounds i32, i32* %1, i64 21
%123 = load i32, i32* %122
%124 = tail call i32 @READ_ROUND_KEY_WORD(i32 %123)
%125 = load i32, i32* %102
%126 = xor i32 %125, %124
store i32 %126, i32* %102
%127 = tail call i32 @speckey(i32* %96, i32* %102)
%128 = getelementptr inbounds i32, i32* %1, i64 22
%129 = load i32, i32* %128
%130 = tail call i32 @READ_ROUND_KEY_WORD(i32 %129)
%131 = load i32, i32* %96
%132 = xor i32 %131, %130
store i32 %132, i32* %96
%133 = getelementptr inbounds i32, i32* %1, i64 23
%134 = load i32, i32* %133
%135 = tail call i32 @READ_ROUND_KEY_WORD(i32 %134)
%136 = load i32, i32* %102
%137 = xor i32 %136, %135
store i32 %137, i32* %102
%138 = tail call i32 @speckey(i32* %96, i32* %102)
%139 = getelementptr inbounds i32, i32* %1, i64 24
%140 = load i32, i32* %139
%141 = tail call i32 @READ_ROUND_KEY_WORD(i32 %140)
%142 = getelementptr inbounds i32, i32* %0, i64 6
%143 = load i32, i32* %142
%144 = xor i32 %143, %141
store i32 %144, i32* %142
%145 = getelementptr inbounds i32, i32* %1, i64 25
%146 = load i32, i32* %145
%147 = tail call i32 @READ_ROUND_KEY_WORD(i32 %146)
%148 = getelementptr inbounds i32, i32* %0, i64 7
%149 = load i32, i32* %148
%150 = xor i32 %149, %147
store i32 %150, i32* %148
%151 = tail call i32 @speckey(i32* %142, i32* %148)
%152 = getelementptr inbounds i32, i32* %1, i64 26
%153 = load i32, i32* %152
%154 = tail call i32 @READ_ROUND_KEY_WORD(i32 %153)
%155 = load i32, i32* %142
%156 = xor i32 %155, %154
store i32 %156, i32* %142
%157 = getelementptr inbounds i32, i32* %1, i64 27
%158 = load i32, i32* %157
%159 = tail call i32 @READ_ROUND_KEY_WORD(i32 %158)
%160 = load i32, i32* %148
%161 = xor i32 %160, %159
store i32 %161, i32* %148
%162 = tail call i32 @speckey(i32* %142, i32* %148)
%163 = getelementptr inbounds i32, i32* %1, i64 28
%164 = load i32, i32* %163
%165 = tail call i32 @READ_ROUND_KEY_WORD(i32 %164)
%166 = load i32, i32* %142
%167 = xor i32 %166, %165
store i32 %167, i32* %142
%168 = getelementptr inbounds i32, i32* %1, i64 29
%169 = load i32, i32* %168
%170 = tail call i32 @READ_ROUND_KEY_WORD(i32 %169)
%171 = load i32, i32* %148
%172 = xor i32 %171, %170
store i32 %172, i32* %148
%173 = tail call i32 @speckey(i32* %142, i32* %148)
%174 = getelementptr inbounds i32, i32* %1, i64 30
%175 = load i32, i32* %174
%176 = tail call i32 @READ_ROUND_KEY_WORD(i32 %175)
%177 = load i32, i32* %142
%178 = xor i32 %177, %176
store i32 %178, i32* %142
%179 = getelementptr inbounds i32, i32* %1, i64 31
%180 = load i32, i32* %179
%181 = tail call i32 @READ_ROUND_KEY_WORD(i32 %180)
%182 = load i32, i32* %148
%183 = xor i32 %182, %181
store i32 %183, i32* %148
%184 = tail call i32 @speckey(i32* %142, i32* %148)
%185 = load i32, i32* %0
%186 = load i32, i32* %10
%187 = xor i32 %186, %185
%188 = tail call i32 @rot32l8(i32 %187)
%189 = tail call i32 @rot32r8(i32 %187)
%190 = xor i32 %189, %188
%191 = load i32, i32* %0
%192 = xor i32 %191, %190
%193 = load i32, i32* %10
%194 = xor i32 %193, %190
%195 = and i32 %192, -65536
%196 = and i32 %194, 65535
%197 = or i32 %196, %195
%198 = and i32 %194, -65536
%199 = and i32 %192, 65535
%200 = or i32 %198, %199
%201 = load i32, i32* %50
%202 = xor i32 %201, %197
store i32 %202, i32* %0
%203 = load i32, i32* %56
%204 = xor i32 %203, %200
store i32 %204, i32* %10
store i32 %185, i32* %50
store i32 %186, i32* %56
ret void
}