#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 */
void to_uint8(uint8_t *target, const uint32_t *src, const size_t num_bytes) {
  for (size_t i = 0; i < num_bytes / 4; i++) {
    target[i * 4] = (src[i] >> 24) & 0xFF;
    target[i * 4 + 1] = (src[i] >> 16) & 0xFF;
    target[i * 4 + 2] = (src[i] >> 8) & 0xFF;
    target[i * 4 + 3] = src[i] & 0xFF;
  }
}


x86 assembly (clang, -O0):
<to_uint8>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shr    $0x2,%rcx
cmp    %rcx,%rax
jae    11ca <to_uint8+0xca>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sar    $0x18,%edx
and    $0xff,%edx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x2,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sar    $0x10,%edx
and    $0xff,%edx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x2,%rcx
mov    %edx,0x4(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sar    $0x8,%edx
and    $0xff,%edx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x2,%rcx
mov    %edx,0x8(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
and    $0xff,%edx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x2,%rcx
mov    %edx,0xc(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1118 <to_uint8+0x18>
pop    %rbp
ret

x86 assembly (clang, -O2):
<to_uint8>:
push   %rbx
cmp    $0x4,%rdx
jb     115b <to_uint8+0x5b>
mov    %rdx,%r8
mov    %rdx,%r9
shr    $0x2,%r9
cmp    $0x10,%rdx
jae    115d <to_uint8+0x5d>
xor    %edx,%edx
mov    %rdx,%rax
shl    $0x4,%rax
add    %rdi,%rax
add    $0xc,%rax
nopw   0x0(%rax,%rax,1)
movzbl 0x3(%rsi,%rdx,4),%ecx
mov    %ecx,-0xc(%rax)
movzbl 0x2(%rsi,%rdx,4),%ecx
mov    %ecx,-0x8(%rax)
movzbl 0x1(%rsi,%rdx,4),%ecx
mov    %ecx,-0x4(%rax)
movzbl (%rsi,%rdx,4),%ecx
mov    %ecx,(%rax)
add    $0x1,%rdx
add    $0x10,%rax
cmp    %rdx,%r9
jne    1130 <to_uint8+0x30>
pop    %rbx
ret
lea    -0x1(%r9),%rax
lea    0x8(%rdi),%r10
mov    $0x10,%ecx
mul    %rcx
seto   %bl
lea    (%rdi,%rax,1),%r11
add    $0x8,%r11
xor    %edx,%edx
cmp    %r10,%r11
jb     1119 <to_uint8+0x19>
test   %bl,%bl
jne    1119 <to_uint8+0x19>
lea    0xc(%rdi),%r10
lea    (%rdi,%rax,1),%rcx
add    $0xc,%rcx
cmp    %r10,%rcx
jb     1119 <to_uint8+0x19>
test   %bl,%bl
jne    1119 <to_uint8+0x19>
lea    0x4(%rdi),%r10
lea    (%rdi,%rax,1),%rcx
add    $0x4,%rcx
cmp    %r10,%rcx
jb     1119 <to_uint8+0x19>
test   %bl,%bl
jne    1119 <to_uint8+0x19>
add    %rdi,%rax
cmp    %rdi,%rax
jb     1119 <to_uint8+0x19>
test   %bl,%bl
jne    1119 <to_uint8+0x19>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    11ec <to_uint8+0xec>
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%r8
lea    (%rdi,%r8,4),%rax
cmp    %rsi,%rax
ja     1117 <to_uint8+0x17>
mov    %r9,%rdx
and    $0xfffffffffffffffc,%rdx
xor    %eax,%eax
movdqa 0xe03(%rip),%xmm0
mov    %rdi,%rcx
movdqu (%rsi,%rax,4),%xmm1
movdqa %xmm1,%xmm2
psrld  $0x18,%xmm2
movdqa %xmm1,%xmm3
psrld  $0x10,%xmm3
pand   %xmm0,%xmm3
movdqa %xmm1,%xmm4
psrld  $0x8,%xmm4
pand   %xmm0,%xmm4
pand   %xmm0,%xmm1
movdqa %xmm4,%xmm5
punpckldq %xmm1,%xmm5
movdqa %xmm2,%xmm6
punpckldq %xmm3,%xmm6
movdqa %xmm6,%xmm7
punpcklqdq %xmm5,%xmm7
punpckhqdq %xmm5,%xmm6
punpckhdq %xmm1,%xmm4
punpckhdq %xmm3,%xmm2
movdqa %xmm2,%xmm1
punpcklqdq %xmm4,%xmm1
punpckhqdq %xmm4,%xmm2
movdqu %xmm2,0x30(%rcx)
movdqu %xmm1,0x20(%rcx)
movdqu %xmm6,0x10(%rcx)
movdqu %xmm7,(%rcx)
add    $0x4,%rax
add    $0x40,%rcx
cmp    %rax,%rdx
jne    1200 <to_uint8+0x100>
cmp    %rdx,%r9
je     115b <to_uint8+0x5b>
jmp    1119 <to_uint8+0x19>

LLVM IR (-O0):
define void @to_uint8(i32* %0, i32* %1, i64 %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i64
%7 = alloca i64
store i32* %0, i32** %4
store i32* %1, i32** %5
store i64 %2, i64* %6
store i64 0, i64* %7
br label %8
8: ; preds = %56, %3
%9 = load i64, i64* %7
%10 = load i64, i64* %6
%11 = udiv i64 %10, 4
%12 = icmp ult i64 %9, %11
br i1 %12, label %13, label %59
13: ; preds = %8
%14 = load i32*, i32** %5
%15 = load i64, i64* %7
%16 = getelementptr inbounds i32, i32* %14, i64 %15
%17 = load i32, i32* %16
%18 = ashr i32 %17, 24
%19 = and i32 %18, 255
%20 = load i32*, i32** %4
%21 = load i64, i64* %7
%22 = mul i64 %21, 4
%23 = getelementptr inbounds i32, i32* %20, i64 %22
store i32 %19, i32* %23
%24 = load i32*, i32** %5
%25 = load i64, i64* %7
%26 = getelementptr inbounds i32, i32* %24, i64 %25
%27 = load i32, i32* %26
%28 = ashr i32 %27, 16
%29 = and i32 %28, 255
%30 = load i32*, i32** %4
%31 = load i64, i64* %7
%32 = mul i64 %31, 4
%33 = add i64 %32, 1
%34 = getelementptr inbounds i32, i32* %30, i64 %33
store i32 %29, i32* %34
%35 = load i32*, i32** %5
%36 = load i64, i64* %7
%37 = getelementptr inbounds i32, i32* %35, i64 %36
%38 = load i32, i32* %37
%39 = ashr i32 %38, 8
%40 = and i32 %39, 255
%41 = load i32*, i32** %4
%42 = load i64, i64* %7
%43 = mul i64 %42, 4
%44 = add i64 %43, 2
%45 = getelementptr inbounds i32, i32* %41, i64 %44
store i32 %40, i32* %45
%46 = load i32*, i32** %5
%47 = load i64, i64* %7
%48 = getelementptr inbounds i32, i32* %46, i64 %47
%49 = load i32, i32* %48
%50 = and i32 %49, 255
%51 = load i32*, i32** %4
%52 = load i64, i64* %7
%53 = mul i64 %52, 4
%54 = add i64 %53, 3
%55 = getelementptr inbounds i32, i32* %51, i64 %54
store i32 %50, i32* %55
br label %56
56: ; preds = %13
%57 = load i64, i64* %7
%58 = add i64 %57, 1
store i64 %58, i64* %7
br label %8
59: ; preds = %8
ret void
}

LLVM IR (-O2):
define void @to_uint8(i32* nocapture writeonly %0, i32* nocapture %1, i64 %2) {
%4 = bitcast i32* %0 to i8*
%5 = icmp ult i64 %2, 4
br i1 %5, label %80, label %6
6: ; preds = %3
%7 = lshr i64 %2, 2
%8 = icmp ult i64 %2, 16
br i1 %8, label %78, label %9
9: ; preds = %6
%10 = add nsw i64 %7, -1
%11 = getelementptr i32, i32* %0, i64 2
%12 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %10, i64 16)
%13 = extractvalue { i64, i1 } %12, 0
%14 = extractvalue { i64, i1 } %12, 1
%15 = bitcast i32* %11 to i8*
%16 = getelementptr i8, i8* %15, i64 %13
%17 = icmp ult i8* %16, %15
%18 = or i1 %17, %14
%19 = getelementptr i32, i32* %0, i64 3
%20 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %10, i64 16)
%21 = extractvalue { i64, i1 } %20, 0
%22 = extractvalue { i64, i1 } %20, 1
%23 = bitcast i32* %19 to i8*
%24 = getelementptr i8, i8* %23, i64 %21
%25 = icmp ult i8* %24, %23
%26 = or i1 %25, %22
%27 = getelementptr i32, i32* %0, i64 1
%28 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %10, i64 16)
%29 = extractvalue { i64, i1 } %28, 0
%30 = extractvalue { i64, i1 } %28, 1
%31 = bitcast i32* %27 to i8*
%32 = getelementptr i8, i8* %31, i64 %29
%33 = icmp ult i8* %32, %31
%34 = or i1 %33, %30
%35 = call { i64, i1 } @llvm.umul.with.overflow.i64(i64 %10, i64 16)
%36 = extractvalue { i64, i1 } %35, 0
%37 = extractvalue { i64, i1 } %35, 1
%38 = getelementptr i8, i8* %4, i64 %36
%39 = icmp ult i8* %38, %4
%40 = or i1 %39, %37
%41 = or i1 %18, %26
%42 = or i1 %41, %34
%43 = or i1 %42, %40
br i1 %43, label %78, label %44
44: ; preds = %9
%45 = and i64 %2, -4
%46 = getelementptr i32, i32* %0, i64 %45
%47 = getelementptr i32, i32* %1, i64 %7
%48 = icmp ugt i32* %47, %0
%49 = icmp ugt i32* %46, %1
%50 = and i1 %48, %49
br i1 %50, label %78, label %51
51: ; preds = %44
%52 = and i64 %7, 4611686018427387900
%53 = getelementptr inbounds i32, i32* %0, i64 -3
br label %54
54: ; preds = %54, %51
%55 = phi i64 [ 0, %51 ], [ %74, %54 ]
%56 = getelementptr inbounds i32, i32* %1, i64 %55
%57 = bitcast i32* %56 to <4 x i32>*
%58 = load <4 x i32>, <4 x i32>* %57
%59 = lshr <4 x i32> %58, <i32 24, i32 24, i32 24, i32 24>
%60 = shl i64 %55, 2
%61 = lshr <4 x i32> %58, <i32 16, i32 16, i32 16, i32 16>
%62 = and <4 x i32> %61, <i32 255, i32 255, i32 255, i32 255>
%63 = lshr <4 x i32> %58, <i32 8, i32 8, i32 8, i32 8>
%64 = and <4 x i32> %63, <i32 255, i32 255, i32 255, i32 255>
%65 = bitcast i32* %56 to <4 x i32>*
%66 = load <4 x i32>, <4 x i32>* %65
%67 = and <4 x i32> %66, <i32 255, i32 255, i32 255, i32 255>
%68 = or i64 %60, 3
%69 = getelementptr inbounds i32, i32* %53, i64 %68
%70 = bitcast i32* %69 to <16 x i32>*
%71 = shufflevector <4 x i32> %59, <4 x i32> %62, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%72 = shufflevector <4 x i32> %64, <4 x i32> %67, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
%73 = shufflevector <8 x i32> %71, <8 x i32> %72, <16 x i32> <i32 0, i32 4, i32 8, i32 12, i32 1, i32 5, i32 9, i32 13, i32 2, i32 6, i32 10, i32 14, i32 3, i32 7, i32 11, i32 15>
store <16 x i32> %73, <16 x i32>* %70
%74 = add nuw i64 %55, 4
%75 = icmp eq i64 %74, %52
br i1 %75, label %76, label %54
76: ; preds = %54
%77 = icmp eq i64 %7, %52
br i1 %77, label %80, label %78
78: ; preds = %44, %9, %6, %76
%79 = phi i64 [ 0, %44 ], [ 0, %9 ], [ 0, %6 ], [ %52, %76 ]
br label %81
80: ; preds = %81, %76, %3
ret void
81: ; preds = %78, %81
%82 = phi i64 [ %102, %81 ], [ %79, %78 ]
%83 = getelementptr inbounds i32, i32* %1, i64 %82
%84 = load i32, i32* %83
%85 = lshr i32 %84, 24
%86 = shl i64 %82, 2
%87 = getelementptr inbounds i32, i32* %0, i64 %86
store i32 %85, i32* %87
%88 = load i32, i32* %83
%89 = lshr i32 %88, 16
%90 = and i32 %89, 255
%91 = or i64 %86, 1
%92 = getelementptr inbounds i32, i32* %0, i64 %91
store i32 %90, i32* %92
%93 = load i32, i32* %83
%94 = lshr i32 %93, 8
%95 = and i32 %94, 255
%96 = or i64 %86, 2
%97 = getelementptr inbounds i32, i32* %0, i64 %96
store i32 %95, i32* %97
%98 = load i32, i32* %83
%99 = and i32 %98, 255
%100 = or i64 %86, 3
%101 = getelementptr inbounds i32, i32* %0, i64 %100
store i32 %99, i32* %101
%102 = add nuw nsw i64 %82, 1
%103 = icmp eq i64 %102, %7
br i1 %103, label %80, label %81
}