#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 putbe(uint8_t *data, uint32_t num, uint32_t bits) {
  uint32_t i, bytes;
  bytes = bits >> 3;
  for (i = 0; i < bytes; i++) {
    data[i] = (num >> ((bytes - 1 - i) << 3)) & 0xff;
  }
  return (bytes);
}


x86 assembly (clang, -O0):
<putbe>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%eax
sar    $0x3,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    115a <putbe+0x5a>
mov    -0xc(%rbp),%edx
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x14(%rbp),%ecx
shl    $0x3,%ecx
sar    %cl,%edx
and    $0xff,%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    111e <putbe+0x1e>
mov    -0x18(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<putbe>:
mov    %edx,%eax
sar    $0x3,%eax
cmp    $0x8,%edx
jl     1307 <putbe+0x207>
cmp    $0x2,%eax
mov    $0x1,%r8d
cmovge %eax,%r8d
cmp    $0x4,%r8d
jae    1129 <putbe+0x29>
xor    %r11d,%r11d
jmp    12de <putbe+0x1de>
mov    %r8d,%r11d
and    $0x7ffffffc,%r11d
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm12
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm5
lea    -0x4(%r11),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1308 <putbe+0x208>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
movdqa 0xea3(%rip),%xmm2
xor    %r10d,%r10d
pcmpeqd %xmm8,%xmm8
movaps 0xea3(%rip),%xmm11
movdqa 0xeaa(%rip),%xmm9
movdqa 0xeb1(%rip),%xmm10
nop
movdqa %xmm2,%xmm13
movdqa %xmm2,%xmm7
pxor   %xmm8,%xmm7
paddd  %xmm12,%xmm7
pslld  $0x3,%xmm7
pshuflw $0xfe,%xmm7,%xmm0
movdqa %xmm5,%xmm3
psrad  %xmm0,%xmm3
pshuflw $0x54,%xmm7,%xmm4
movdqa %xmm5,%xmm0
psrad  %xmm4,%xmm0
pshufd $0xee,%xmm7,%xmm4
pshuflw $0xfe,%xmm4,%xmm7
movdqa %xmm5,%xmm6
psrad  %xmm7,%xmm6
punpcklqdq %xmm3,%xmm0
pshuflw $0x54,%xmm4,%xmm3
movdqa %xmm5,%xmm4
psrad  %xmm3,%xmm4
punpckhqdq %xmm6,%xmm4
shufps $0xcc,%xmm4,%xmm0
movdqa %xmm12,%xmm3
psubd  %xmm2,%xmm3
pslld  $0x3,%xmm3
paddd  %xmm9,%xmm3
pshuflw $0xfe,%xmm3,%xmm4
movdqa %xmm5,%xmm6
psrad  %xmm4,%xmm6
pshuflw $0x54,%xmm3,%xmm4
movdqa %xmm5,%xmm7
psrad  %xmm4,%xmm7
pshufd $0xee,%xmm3,%xmm3
pshuflw $0xfe,%xmm3,%xmm4
movdqa %xmm5,%xmm1
psrad  %xmm4,%xmm1
andps  %xmm11,%xmm0
movups %xmm0,(%rdi,%r10,4)
pshuflw $0x54,%xmm3,%xmm0
movdqa %xmm5,%xmm3
psrad  %xmm0,%xmm3
punpcklqdq %xmm6,%xmm7
punpckhqdq %xmm1,%xmm3
shufps $0xcc,%xmm3,%xmm7
andps  %xmm11,%xmm7
movups %xmm7,0x10(%rdi,%r10,4)
add    $0x8,%r10
paddd  %xmm10,%xmm2
add    $0xfffffffffffffffe,%rcx
jne    1190 <putbe+0x90>
movdqa 0xddd(%rip),%xmm0
psubd  %xmm13,%xmm0
test   $0x1,%r9b
je     12d9 <putbe+0x1d9>
paddd  %xmm0,%xmm12
pslld  $0x3,%xmm12
pshuflw $0xfe,%xmm12,%xmm0
movdqa %xmm5,%xmm1
psrad  %xmm0,%xmm1
pshuflw $0x54,%xmm12,%xmm0
movdqa %xmm5,%xmm2
psrad  %xmm0,%xmm2
punpcklqdq %xmm1,%xmm2
pshufd $0xee,%xmm12,%xmm0
pshuflw $0xfe,%xmm0,%xmm1
movdqa %xmm5,%xmm3
psrad  %xmm1,%xmm3
pshuflw $0x54,%xmm0,%xmm0
psrad  %xmm0,%xmm5
punpckhqdq %xmm3,%xmm5
shufps $0xcc,%xmm5,%xmm2
andps  0xd4c(%rip),%xmm2
movups %xmm2,(%rdi,%r10,4)
cmp    %r8,%r11
je     1307 <putbe+0x207>
mov    %eax,%ecx
sub    %r11d,%ecx
lea    -0x8(,%rcx,8),%ecx
nopw   0x0(%rax,%rax,1)
mov    %esi,%edx
sar    %cl,%edx
movzbl %dl,%edx
mov    %edx,(%rdi,%r11,4)
add    $0x1,%r11
add    $0xfffffff8,%ecx
cmp    %r11,%r8
jne    12f0 <putbe+0x1f0>
ret
movdqa 0xcf0(%rip),%xmm0
xor    %r10d,%r10d
test   $0x1,%r9b
jne    127e <putbe+0x17e>
jmp    12d9 <putbe+0x1d9>

LLVM IR (-O0):
define i32 @putbe(i32* %0, i32 %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%9 = load i32, i32* %6
%10 = ashr i32 %9, 3
store i32 %10, i32* %8
store i32 0, i32* %7
br label %11
11: ; preds = %28, %3
%12 = load i32, i32* %7
%13 = load i32, i32* %8
%14 = icmp slt i32 %12, %13
br i1 %14, label %15, label %31
15: ; preds = %11
%16 = load i32, i32* %5
%17 = load i32, i32* %8
%18 = sub nsw i32 %17, 1
%19 = load i32, i32* %7
%20 = sub nsw i32 %18, %19
%21 = shl i32 %20, 3
%22 = ashr i32 %16, %21
%23 = and i32 %22, 255
%24 = load i32*, i32** %4
%25 = load i32, i32* %7
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i32, i32* %24, i64 %26
store i32 %23, i32* %27
br label %28
28: ; preds = %15
%29 = load i32, i32* %7
%30 = add nsw i32 %29, 1
store i32 %30, i32* %7
br label %11
31: ; preds = %11
%32 = load i32, i32* %8
ret i32 %32
}

LLVM IR (-O2):
define i32 @putbe(i32* nocapture writeonly %0, i32 %1, i32 %2) {
%4 = ashr i32 %2, 3
%5 = icmp sgt i32 %2, 7
br i1 %5, label %6, label %74
6: ; preds = %3
%7 = call i32 @llvm.smax.i32(i32 %4, i32 1)
%8 = zext i32 %7 to i64
%9 = icmp ult i32 %7, 4
br i1 %9, label %61, label %10
10: ; preds = %6
%11 = and i64 %8, 2147483644
%12 = insertelement <4 x i32> poison, i32 %4, i64 0
%13 = shufflevector <4 x i32> %12, <4 x i32> poison, <4 x i32> zeroinitializer
%14 = insertelement <4 x i32> poison, i32 %1, i64 0
%15 = shufflevector <4 x i32> %14, <4 x i32> poison, <4 x i32> zeroinitializer
%16 = add nsw i64 %11, -4
%17 = lshr exact i64 %16, 2
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 1
%20 = icmp eq i64 %16, 0
br i1 %20, label %48, label %21
21: ; preds = %10
%22 = and i64 %18, 9223372036854775806
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %42, %23 ]
%25 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %21 ], [ %43, %23 ]
%26 = phi i64 [ 0, %21 ], [ %44, %23 ]
%27 = xor <4 x i32> %25, <i32 -1, i32 -1, i32 -1, i32 -1>
%28 = add nsw <4 x i32> %13, %27
%29 = shl <4 x i32> %28, <i32 3, i32 3, i32 3, i32 3>
%30 = ashr <4 x i32> %15, %29
%31 = and <4 x i32> %30, <i32 255, i32 255, i32 255, i32 255>
%32 = getelementptr inbounds i32, i32* %0, i64 %24
%33 = bitcast i32* %32 to <4 x i32>*
store <4 x i32> %31, <4 x i32>* %33
%34 = or i64 %24, 4
%35 = sub <4 x i32> <i32 536870907, i32 536870907, i32 536870907, i32 536870907>, %25
%36 = add <4 x i32> %13, %35
%37 = shl <4 x i32> %36, <i32 3, i32 3, i32 3, i32 3>
%38 = ashr <4 x i32> %15, %37
%39 = and <4 x i32> %38, <i32 255, i32 255, i32 255, i32 255>
%40 = getelementptr inbounds i32, i32* %0, i64 %34
%41 = bitcast i32* %40 to <4 x i32>*
store <4 x i32> %39, <4 x i32>* %41
%42 = add nuw i64 %24, 8
%43 = add <4 x i32> %25, <i32 8, i32 8, i32 8, i32 8>
%44 = add i64 %26, 2
%45 = icmp eq i64 %44, %22
br i1 %45, label %46, label %23
46: ; preds = %23
%47 = sub <4 x i32> <i32 -9, i32 -9, i32 -9, i32 -9>, %25
br label %48
48: ; preds = %46, %10
%49 = phi i64 [ 0, %10 ], [ %42, %46 ]
%50 = phi <4 x i32> [ <i32 -1, i32 -2, i32 -3, i32 -4>, %10 ], [ %47, %46 ]
%51 = icmp eq i64 %19, 0
br i1 %51, label %59, label %52
52: ; preds = %48
%53 = add nsw <4 x i32> %13, %50
%54 = shl <4 x i32> %53, <i32 3, i32 3, i32 3, i32 3>
%55 = ashr <4 x i32> %15, %54
%56 = and <4 x i32> %55, <i32 255, i32 255, i32 255, i32 255>
%57 = getelementptr inbounds i32, i32* %0, i64 %49
%58 = bitcast i32* %57 to <4 x i32>*
store <4 x i32> %56, <4 x i32>* %58
br label %59
59: ; preds = %48, %52
%60 = icmp eq i64 %11, %8
br i1 %60, label %74, label %61
61: ; preds = %6, %59
%62 = phi i64 [ 0, %6 ], [ %11, %59 ]
br label %63
63: ; preds = %61, %63
%64 = phi i64 [ %72, %63 ], [ %62, %61 ]
%65 = trunc i64 %64 to i32
%66 = xor i32 %65, -1
%67 = add nsw i32 %4, %66
%68 = shl i32 %67, 3
%69 = ashr i32 %1, %68
%70 = and i32 %69, 255
%71 = getelementptr inbounds i32, i32* %0, i64 %64
store i32 %70, i32* %71
%72 = add nuw nsw i64 %64, 1
%73 = icmp eq i64 %72, %8
br i1 %73, label %74, label %63
74: ; preds = %63, %59, %3
ret i32 %4
}