#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 uint16_t;

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


x86 assembly (clang, -O0):
<round_f_inverse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x1c(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    -0x8(%rbp),%rcx
xor    0x4(%rcx),%eax
mov    -0x8(%rbp),%rcx
xor    0x8(%rcx),%eax
mov    -0x8(%rbp),%rcx
xor    0xc(%rcx),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x8,%eax
mov    -0x14(%rbp),%ecx
sar    $0x8,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
xor    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
xor    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
xor    0x14(%rax),%ecx
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
xor    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%ecx
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
xor    -0x14(%rbp),%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   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x7c(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x1c(%rax),%ecx
mov    %ecx,0x1c(%rax)
mov    -0x10(%rbp),%rax
mov    0x78(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%ecx
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rdi
add    $0x18,%rdi
mov    -0x8(%rbp),%rsi
add    $0x1c,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x74(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x1c(%rax),%ecx
mov    %ecx,0x1c(%rax)
mov    -0x10(%rbp),%rax
mov    0x70(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%ecx
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rdi
add    $0x18,%rdi
mov    -0x8(%rbp),%rsi
add    $0x1c,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x6c(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x1c(%rax),%ecx
mov    %ecx,0x1c(%rax)
mov    -0x10(%rbp),%rax
mov    0x68(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%ecx
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rdi
add    $0x18,%rdi
mov    -0x8(%rbp),%rsi
add    $0x1c,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x64(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x1c(%rax),%ecx
mov    %ecx,0x1c(%rax)
mov    -0x10(%rbp),%rax
mov    0x60(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%ecx
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rdi
add    $0x10,%rdi
mov    -0x8(%rbp),%rsi
add    $0x14,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x5c(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x14(%rax),%ecx
mov    %ecx,0x14(%rax)
mov    -0x10(%rbp),%rax
mov    0x58(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rdi
add    $0x10,%rdi
mov    -0x8(%rbp),%rsi
add    $0x14,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x54(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x14(%rax),%ecx
mov    %ecx,0x14(%rax)
mov    -0x10(%rbp),%rax
mov    0x50(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rdi
add    $0x10,%rdi
mov    -0x8(%rbp),%rsi
add    $0x14,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x4c(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x14(%rax),%ecx
mov    %ecx,0x14(%rax)
mov    -0x10(%rbp),%rax
mov    0x48(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rdi
add    $0x10,%rdi
mov    -0x8(%rbp),%rsi
add    $0x14,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x44(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x14(%rax),%ecx
mov    %ecx,0x14(%rax)
mov    -0x10(%rbp),%rax
mov    0x40(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rdi
add    $0x8,%rdi
mov    -0x8(%rbp),%rsi
add    $0xc,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x3c(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x10(%rbp),%rax
mov    0x38(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rdi
add    $0x8,%rdi
mov    -0x8(%rbp),%rsi
add    $0xc,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x34(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rdi
add    $0x8,%rdi
mov    -0x8(%rbp),%rsi
add    $0xc,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x2c(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rdi
add    $0x8,%rdi
mov    -0x8(%rbp),%rsi
add    $0xc,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x24(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
add    $0x4,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x1c(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
add    $0x4,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x14(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
add    $0x4,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0xc(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
add    $0x4,%rsi
call   1040 <speckey_inverse@plt>
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
xor    (%rax),%ecx
mov    %ecx,(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<round_f_inverse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
mov    0x10(%rdi),%ecx
mov    0x14(%rdi),%edi
mov    0x18(%rbx),%eax
mov    (%rbx),%edx
xor    %eax,%edx
mov    %ecx,(%rbx)
mov    0x4(%rbx),%esi
xor    %edi,%esi
mov    %edi,0x4(%rbx)
xor    %ecx,%edi
xor    0x8(%rbx),%ecx
mov    %eax,0x8(%rbx)
mov    0x1c(%rbx),%ebp
mov    0xc(%rbx),%r8d
xor    %ebp,%r8d
mov    %ebp,0xc(%rbx)
xor    %ebp,%eax
lea    0x10(%rbx),%rbp
xor    %edi,%eax
mov    %eax,%edi
shl    $0x8,%edi
sar    $0x8,%eax
or     %edi,%eax
lea    0x4(%rbx),%rdi
mov    %rdi,0x10(%rsp)
xor    %eax,%edx
mov    %edx,0x10(%rbx)
lea    0x14(%rbx),%r15
xor    %eax,%esi
mov    %esi,0x14(%rbx)
lea    0x8(%rbx),%rdx
mov    %rdx,0x8(%rsp)
xor    %eax,%ecx
mov    %ecx,0x18(%rbx)
lea    0x18(%rbx),%r12
xor    %r8d,%eax
lea    0xc(%rbx),%rcx
mov    %rcx,(%rsp)
mov    %eax,0x1c(%rbx)
lea    0x1c(%rbx),%r13
mov    %r12,%rdi
mov    %r13,%rsi
call   1040 <speckey_inverse@plt>
mov    0x7c(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x1c(%rbx)
mov    0x78(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x18(%rbx)
mov    %r12,%rdi
mov    %r13,%rsi
call   1040 <speckey_inverse@plt>
mov    0x74(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x1c(%rbx)
mov    0x70(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x18(%rbx)
mov    %r12,%rdi
mov    %r13,%rsi
call   1040 <speckey_inverse@plt>
mov    0x6c(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x1c(%rbx)
mov    0x68(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x18(%rbx)
mov    %r12,%rdi
mov    %r13,%rsi
call   1040 <speckey_inverse@plt>
mov    0x64(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x1c(%rbx)
mov    0x60(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x18(%rbx)
mov    %rbp,%rdi
mov    %r15,%rsi
call   1040 <speckey_inverse@plt>
mov    0x5c(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x14(%rbx)
mov    0x58(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x10(%rbx)
mov    %rbp,%rdi
mov    %r15,%rsi
call   1040 <speckey_inverse@plt>
mov    0x54(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x14(%rbx)
mov    0x50(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x10(%rbx)
mov    %rbp,%rdi
mov    %r15,%rsi
call   1040 <speckey_inverse@plt>
mov    0x4c(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x14(%rbx)
mov    0x48(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x10(%rbx)
mov    %rbp,%rdi
mov    %r15,%rsi
call   1040 <speckey_inverse@plt>
mov    0x44(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x14(%rbx)
mov    0x40(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x10(%rbx)
mov    0x8(%rsp),%rbp
mov    %rbp,%rdi
mov    (%rsp),%r15
mov    %r15,%rsi
call   1040 <speckey_inverse@plt>
mov    0x3c(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0xc(%rbx)
mov    0x38(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x8(%rbx)
mov    %rbp,%rdi
mov    %r15,%rsi
call   1040 <speckey_inverse@plt>
mov    0x34(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0xc(%rbx)
mov    0x30(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x8(%rbx)
mov    %rbp,%rdi
mov    %r15,%rsi
call   1040 <speckey_inverse@plt>
mov    0x2c(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0xc(%rbx)
mov    0x28(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x8(%rbx)
mov    %rbp,%rdi
mov    %r15,%rsi
call   1040 <speckey_inverse@plt>
mov    0x24(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0xc(%rbx)
mov    0x20(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x8(%rbx)
mov    %rbx,%rdi
mov    0x10(%rsp),%rbp
mov    %rbp,%rsi
call   1040 <speckey_inverse@plt>
mov    0x1c(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x4(%rbx)
mov    0x18(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,(%rbx)
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1040 <speckey_inverse@plt>
mov    0x14(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x4(%rbx)
mov    0x10(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,(%rbx)
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1040 <speckey_inverse@plt>
mov    0xc(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x4(%rbx)
mov    0x8(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,(%rbx)
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1040 <speckey_inverse@plt>
mov    0x4(%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,0x4(%rbx)
mov    (%r14),%edi
call   1030 <READ_ROUND_KEY_WORD@plt>
xor    %eax,(%rbx)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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