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

/* Variables and functions */
int /*<<< orphan*/ load32(int /*<<< orphan*/ const *);
__attribute__((always_)) void load_key_words(const uint8_t key[32],
                                             uint32_t key_words[8]) {
  key_words[0] = load32(&key[0 * 4]);
  key_words[1] = load32(&key[1 * 4]);
  key_words[2] = load32(&key[2 * 4]);
  key_words[3] = load32(&key[3 * 4]);
  key_words[4] = load32(&key[4 * 4]);
  key_words[5] = load32(&key[5 * 4]);
  key_words[6] = load32(&key[6 * 4]);
  key_words[7] = load32(&key[7 * 4]);
}


x86 assembly (clang, -O0):
<load_key_words>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <load32@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rdi
add    $0x10,%rdi
call   1030 <load32@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rdi
add    $0x20,%rdi
call   1030 <load32@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rdi
add    $0x30,%rdi
call   1030 <load32@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rdi
add    $0x40,%rdi
call   1030 <load32@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rdi
add    $0x50,%rdi
call   1030 <load32@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x14(%rax)
mov    -0x8(%rbp),%rdi
add    $0x60,%rdi
call   1030 <load32@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x18(%rax)
mov    -0x8(%rbp),%rdi
add    $0x70,%rdi
call   1030 <load32@plt>
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x1c(%rax)
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<load_key_words>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
call   1030 <load32@plt>
mov    %eax,(%r14)
lea    0x10(%rbx),%rdi
call   1030 <load32@plt>
mov    %eax,0x4(%r14)
lea    0x20(%rbx),%rdi
call   1030 <load32@plt>
mov    %eax,0x8(%r14)
lea    0x30(%rbx),%rdi
call   1030 <load32@plt>
mov    %eax,0xc(%r14)
lea    0x40(%rbx),%rdi
call   1030 <load32@plt>
mov    %eax,0x10(%r14)
lea    0x50(%rbx),%rdi
call   1030 <load32@plt>
mov    %eax,0x14(%r14)
lea    0x60(%rbx),%rdi
call   1030 <load32@plt>
mov    %eax,0x18(%r14)
add    $0x70,%rbx
mov    %rbx,%rdi
call   1030 <load32@plt>
mov    %eax,0x1c(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @load_key_words(i32* %0, i32* %1) {
%3 = alloca i32*
%4 = alloca i32*
store i32* %0, i32** %3
store i32* %1, i32** %4
%5 = load i32*, i32** %3
%6 = getelementptr inbounds i32, i32* %5, i64 0
%7 = call i32 @load32(i32* %6)
%8 = load i32*, i32** %4
%9 = getelementptr inbounds i32, i32* %8, i64 0
store i32 %7, i32* %9
%10 = load i32*, i32** %3
%11 = getelementptr inbounds i32, i32* %10, i64 4
%12 = call i32 @load32(i32* %11)
%13 = load i32*, i32** %4
%14 = getelementptr inbounds i32, i32* %13, i64 1
store i32 %12, i32* %14
%15 = load i32*, i32** %3
%16 = getelementptr inbounds i32, i32* %15, i64 8
%17 = call i32 @load32(i32* %16)
%18 = load i32*, i32** %4
%19 = getelementptr inbounds i32, i32* %18, i64 2
store i32 %17, i32* %19
%20 = load i32*, i32** %3
%21 = getelementptr inbounds i32, i32* %20, i64 12
%22 = call i32 @load32(i32* %21)
%23 = load i32*, i32** %4
%24 = getelementptr inbounds i32, i32* %23, i64 3
store i32 %22, i32* %24
%25 = load i32*, i32** %3
%26 = getelementptr inbounds i32, i32* %25, i64 16
%27 = call i32 @load32(i32* %26)
%28 = load i32*, i32** %4
%29 = getelementptr inbounds i32, i32* %28, i64 4
store i32 %27, i32* %29
%30 = load i32*, i32** %3
%31 = getelementptr inbounds i32, i32* %30, i64 20
%32 = call i32 @load32(i32* %31)
%33 = load i32*, i32** %4
%34 = getelementptr inbounds i32, i32* %33, i64 5
store i32 %32, i32* %34
%35 = load i32*, i32** %3
%36 = getelementptr inbounds i32, i32* %35, i64 24
%37 = call i32 @load32(i32* %36)
%38 = load i32*, i32** %4
%39 = getelementptr inbounds i32, i32* %38, i64 6
store i32 %37, i32* %39
%40 = load i32*, i32** %3
%41 = getelementptr inbounds i32, i32* %40, i64 28
%42 = call i32 @load32(i32* %41)
%43 = load i32*, i32** %4
%44 = getelementptr inbounds i32, i32* %43, i64 7
store i32 %42, i32* %44
ret void
}

LLVM IR (-O2):
define void @load_key_words(i32* %0, i32* nocapture writeonly %1) {
%3 = tail call i32 @load32(i32* %0)
store i32 %3, i32* %1
%4 = getelementptr inbounds i32, i32* %0, i64 4
%5 = tail call i32 @load32(i32* %4)
%6 = getelementptr inbounds i32, i32* %1, i64 1
store i32 %5, i32* %6
%7 = getelementptr inbounds i32, i32* %0, i64 8
%8 = tail call i32 @load32(i32* %7)
%9 = getelementptr inbounds i32, i32* %1, i64 2
store i32 %8, i32* %9
%10 = getelementptr inbounds i32, i32* %0, i64 12
%11 = tail call i32 @load32(i32* %10)
%12 = getelementptr inbounds i32, i32* %1, i64 3
store i32 %11, i32* %12
%13 = getelementptr inbounds i32, i32* %0, i64 16
%14 = tail call i32 @load32(i32* %13)
%15 = getelementptr inbounds i32, i32* %1, i64 4
store i32 %14, i32* %15
%16 = getelementptr inbounds i32, i32* %0, i64 20
%17 = tail call i32 @load32(i32* %16)
%18 = getelementptr inbounds i32, i32* %1, i64 5
store i32 %17, i32* %18
%19 = getelementptr inbounds i32, i32* %0, i64 24
%20 = tail call i32 @load32(i32* %19)
%21 = getelementptr inbounds i32, i32* %1, i64 6
store i32 %20, i32* %21
%22 = getelementptr inbounds i32, i32* %0, i64 28
%23 = tail call i32 @load32(i32* %22)
%24 = getelementptr inbounds i32, i32* %1, i64 7
store i32 %23, i32* %24
ret void
}