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

/* Variables and functions */
extern void pdf_buf_unpack_32_W(uint8_t *in, uint32_t *out, size_t in_len,
                                uint8_t *w, size_t w_len) {
  size_t i;
  uint32_t j = 0;
  for (i = 0; i < in_len;) {
    uint32_t v = 0;
    uint8_t n = w[j % w_len];
    uint8_t k;
    for (k = 0; k < n; k++) {
      v <<= 8;
      v += in[i++];
    }
    out[j++] = v;
  }
}


x86 assembly (clang, -O0):
<pdf_buf_unpack_32_W>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    11d0 <pdf_buf_unpack_32_W+0xd0>
movq   $0x0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax,%rdx,8),%rax
mov    %rax,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
jge    11b0 <pdf_buf_unpack_32_W+0xb0>
mov    -0x40(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,8),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1166 <pdf_buf_unpack_32_W+0x66>
mov    -0x40(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %rdx,(%rax,%rcx,8)
jmp    1128 <pdf_buf_unpack_32_W+0x28>
pop    %rbp
ret

x86 assembly (clang, -O2):
<pdf_buf_unpack_32_W>:
push   %r15
push   %r14
push   %rbx
test   %rdx,%rdx
je     11e9 <pdf_buf_unpack_32_W+0xe9>
mov    %rdx,%r9
xor    %r11d,%r11d
xor    %r10d,%r10d
jmp    1133 <pdf_buf_unpack_32_W+0x33>
nopl   0x0(%rax)
xor    %ebx,%ebx
mov    %rbx,(%rsi,%r10,8)
add    $0x1,%r10
cmp    %r9,%r11
jae    11e9 <pdf_buf_unpack_32_W+0xe9>
mov    %r10,%rax
or     %r8,%rax
shr    $0x20,%rax
je     1150 <pdf_buf_unpack_32_W+0x50>
mov    %r10,%rax
xor    %edx,%edx
div    %r8
jmp    1158 <pdf_buf_unpack_32_W+0x58>
nopl   0x0(%rax)
mov    %r10d,%eax
xor    %edx,%edx
div    %r8d
mov    (%rcx,%rdx,8),%r14
test   %r14,%r14
jle    1120 <pdf_buf_unpack_32_W+0x20>
lea    -0x1(%r14),%rax
mov    %r14d,%r15d
and    $0x3,%r15d
cmp    $0x3,%rax
jae    1180 <pdf_buf_unpack_32_W+0x80>
mov    %r11,%rax
xor    %ebx,%ebx
jmp    11bd <pdf_buf_unpack_32_W+0xbd>
nopl   0x0(%rax)
mov    %r14,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %r11,%rax
xor    %ebx,%ebx
nopl   0x0(%rax)
shl    $0x8,%rbx
add    (%rdi,%rax,8),%rbx
shl    $0x8,%rbx
add    0x8(%rdi,%rax,8),%rbx
shl    $0x8,%rbx
add    0x10(%rdi,%rax,8),%rbx
shl    $0x8,%rbx
add    0x18(%rdi,%rax,8),%rbx
add    $0x4,%rax
add    $0xfffffffffffffffc,%rdx
jne    1190 <pdf_buf_unpack_32_W+0x90>
test   %r15,%r15
je     11e1 <pdf_buf_unpack_32_W+0xe1>
lea    (%rdi,%rax,8),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
shl    $0x8,%rbx
add    (%rax,%rdx,8),%rbx
add    $0x1,%rdx
cmp    %rdx,%r15
jne    11d0 <pdf_buf_unpack_32_W+0xd0>
add    %r14,%r11
jmp    1122 <pdf_buf_unpack_32_W+0x22>
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @pdf_buf_unpack_32_W(i64* %0, i64* %1, i64 %2, i64* %3, i64 %4) {
%6 = alloca i64*
%7 = alloca i64*
%8 = alloca i64
%9 = alloca i64*
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
store i64* %0, i64** %6
store i64* %1, i64** %7
store i64 %2, i64* %8
store i64* %3, i64** %9
store i64 %4, i64* %10
store i64 0, i64* %12
store i64 0, i64* %11
br label %16
16: ; preds = %44, %5
%17 = load i64, i64* %11
%18 = load i64, i64* %8
%19 = icmp ult i64 %17, %18
br i1 %19, label %20, label %50
20: ; preds = %16
store i64 0, i64* %13
%21 = load i64*, i64** %9
%22 = load i64, i64* %12
%23 = load i64, i64* %10
%24 = urem i64 %22, %23
%25 = getelementptr inbounds i64, i64* %21, i64 %24
%26 = load i64, i64* %25
store i64 %26, i64* %14
store i64 0, i64* %15
br label %27
27: ; preds = %41, %20
%28 = load i64, i64* %15
%29 = load i64, i64* %14
%30 = icmp slt i64 %28, %29
br i1 %30, label %31, label %44
31: ; preds = %27
%32 = load i64, i64* %13
%33 = shl i64 %32, 8
store i64 %33, i64* %13
%34 = load i64*, i64** %6
%35 = load i64, i64* %11
%36 = add i64 %35, 1
store i64 %36, i64* %11
%37 = getelementptr inbounds i64, i64* %34, i64 %35
%38 = load i64, i64* %37
%39 = load i64, i64* %13
%40 = add i64 %39, %38
store i64 %40, i64* %13
br label %41
41: ; preds = %31
%42 = load i64, i64* %15
%43 = add nsw i64 %42, 1
store i64 %43, i64* %15
br label %27
44: ; preds = %27
%45 = load i64, i64* %13
%46 = load i64*, i64** %7
%47 = load i64, i64* %12
%48 = add i64 %47, 1
store i64 %48, i64* %12
%49 = getelementptr inbounds i64, i64* %46, i64 %47
store i64 %45, i64* %49
br label %16
50: ; preds = %16
ret void
}

LLVM IR (-O2):
define void @pdf_buf_unpack_32_W(i64* nocapture %0, i64* nocapture writeonly %1, i64 %2, i64* nocapture %3, i64 %4) {
%6 = icmp eq i64 %2, 0
br i1 %6, label %71, label %7
7: ; preds = %5, %65
%8 = phi i64 [ %67, %65 ], [ 0, %5 ]
%9 = phi i64 [ %68, %65 ], [ 0, %5 ]
%10 = urem i64 %9, %4
%11 = getelementptr inbounds i64, i64* %3, i64 %10
%12 = load i64, i64* %11
%13 = icmp sgt i64 %12, 0
br i1 %13, label %14, label %65
14: ; preds = %7
%15 = add i64 %12, -1
%16 = and i64 %12, 3
%17 = icmp ult i64 %15, 3
br i1 %17, label %46, label %18
18: ; preds = %14
%19 = and i64 %12, -4
br label %20
20: ; preds = %20, %18
%21 = phi i64 [ %8, %18 ], [ %40, %20 ]
%22 = phi i64 [ 0, %18 ], [ %43, %20 ]
%23 = phi i64 [ 0, %18 ], [ %44, %20 ]
%24 = shl i64 %22, 8
%25 = add i64 %21, 1
%26 = getelementptr inbounds i64, i64* %0, i64 %21
%27 = load i64, i64* %26
%28 = add i64 %27, %24
%29 = shl i64 %28, 8
%30 = add i64 %21, 2
%31 = getelementptr inbounds i64, i64* %0, i64 %25
%32 = load i64, i64* %31
%33 = add i64 %32, %29
%34 = shl i64 %33, 8
%35 = add i64 %21, 3
%36 = getelementptr inbounds i64, i64* %0, i64 %30
%37 = load i64, i64* %36
%38 = add i64 %37, %34
%39 = shl i64 %38, 8
%40 = add i64 %21, 4
%41 = getelementptr inbounds i64, i64* %0, i64 %35
%42 = load i64, i64* %41
%43 = add i64 %42, %39
%44 = add i64 %23, 4
%45 = icmp eq i64 %44, %19
br i1 %45, label %46, label %20
46: ; preds = %20, %14
%47 = phi i64 [ undef, %14 ], [ %43, %20 ]
%48 = phi i64 [ %8, %14 ], [ %40, %20 ]
%49 = phi i64 [ 0, %14 ], [ %43, %20 ]
%50 = icmp eq i64 %16, 0
br i1 %50, label %62, label %51
51: ; preds = %46, %51
%52 = phi i64 [ %56, %51 ], [ %48, %46 ]
%53 = phi i64 [ %59, %51 ], [ %49, %46 ]
%54 = phi i64 [ %60, %51 ], [ 0, %46 ]
%55 = shl i64 %53, 8
%56 = add i64 %52, 1
%57 = getelementptr inbounds i64, i64* %0, i64 %52
%58 = load i64, i64* %57
%59 = add i64 %58, %55
%60 = add i64 %54, 1
%61 = icmp eq i64 %60, %16
br i1 %61, label %62, label %51
62: ; preds = %51, %46
%63 = phi i64 [ %47, %46 ], [ %59, %51 ]
%64 = add i64 %8, %12
br label %65
65: ; preds = %62, %7
%66 = phi i64 [ 0, %7 ], [ %63, %62 ]
%67 = phi i64 [ %8, %7 ], [ %64, %62 ]
%68 = add i64 %9, 1
%69 = getelementptr inbounds i64, i64* %1, i64 %9
store i64 %66, i64* %69
%70 = icmp ult i64 %67, %2
br i1 %70, label %7, label %71
71: ; preds = %65, %5
ret void
}