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

/* Variables and functions */
uint32_t read_word(uint8_t *buf, int offset) {
  uint32_t b0 = buf[offset + 0] & 0xff;
  uint32_t b1 = buf[offset + 1] & 0xff;
  uint32_t b2 = buf[offset + 2] & 0xff;
  uint32_t b3 = buf[offset + 3] & 0xff;
  return b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
}


x86 assembly (clang, -O0):
<read_word>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x0,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
and    $0xff,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
and    $0xff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
and    $0xff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
and    $0xff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x14(%rbp),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x18(%rbp),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<read_word>:
movslq %esi,%rax
movzbl (%rdi,%rax,4),%ecx
mov    0x4(%rdi,%rax,4),%edx
mov    0x8(%rdi,%rax,4),%esi
mov    0xc(%rdi,%rax,4),%eax
shl    $0x8,%edx
movzwl %dx,%edx
or     %ecx,%edx
movzbl %sil,%ecx
shl    $0x10,%ecx
or     %edx,%ecx
shl    $0x18,%eax
or     %ecx,%eax
ret

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

LLVM IR (-O2):
define i32 @read_word(i32* nocapture %0, i32 %1) {
%3 = sext i32 %1 to i64
%4 = getelementptr inbounds i32, i32* %0, i64 %3
%5 = load i32, i32* %4
%6 = and i32 %5, 255
%7 = add nsw i32 %1, 1
%8 = sext i32 %7 to i64
%9 = getelementptr inbounds i32, i32* %0, i64 %8
%10 = load i32, i32* %9
%11 = add nsw i32 %1, 2
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds i32, i32* %0, i64 %12
%14 = load i32, i32* %13
%15 = add nsw i32 %1, 3
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds i32, i32* %0, i64 %16
%18 = load i32, i32* %17
%19 = shl i32 %10, 8
%20 = and i32 %19, 65280
%21 = or i32 %20, %6
%22 = shl i32 %14, 16
%23 = and i32 %22, 16711680
%24 = or i32 %21, %23
%25 = shl i32 %18, 24
%26 = or i32 %24, %25
ret i32 %26
}