#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 */

/* Variables and functions */
char *malloc(int);
char *int_to_binstr(int num, int bits_wanted) {
  char *bin_string = malloc(bits_wanted);
  int i;
  for (i = 0; i < bits_wanted; i++) {
    bin_string[(bits_wanted - 1) - i] = (char)(int)'0' + ((num >> i) & 1);
  }
  return bin_string;
}


x86 assembly (clang, -O0):
<int_to_binstr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    -0x8(%rbp),%edi
call   1030 <malloc@plt>
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    116e <int_to_binstr+0x5e>
mov    -0x4(%rbp),%eax
mov    -0x14(%rbp),%ecx
sar    %cl,%eax
and    $0x1,%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1131 <int_to_binstr+0x21>
mov    -0x10(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<int_to_binstr>:
push   %r14
push   %rbx
push   %rax
mov    %esi,%r14d
mov    %edi,%ebx
mov    %esi,%edi
call   1030 <malloc@plt>
test   %r14d,%r14d
jle    13ea <int_to_binstr+0x2da>
mov    %r14d,%r9d
cmp    $0x10,%r14d
jae    1139 <int_to_binstr+0x29>
xor    %edx,%edx
jmp    136e <int_to_binstr+0x25e>
lea    -0x1(%r9),%r8
lea    -0x1(%r14),%ecx
mov    %ecx,%edi
sub    %r8d,%edi
xor    %edx,%edx
cmp    %ecx,%edi
jg     136e <int_to_binstr+0x25e>
shr    $0x20,%r8
jne    136e <int_to_binstr+0x25e>
mov    %r9d,%edx
and    $0xfffffff0,%edx
movd   %ebx,%xmm0
pshufd $0x0,%xmm0,%xmm9
movdqa 0xe8d(%rip),%xmm13
movdqa 0xe94(%rip),%xmm14
movdqa 0xe9b(%rip),%xmm15
movdqa 0xea3(%rip),%xmm4
movaps 0xeab(%rip),%xmm11
pxor   %xmm10,%xmm10
movdqa 0xecd(%rip),%xmm12
mov    %rdx,%rdi
cs nopw 0x0(%rax,%rax,1)
pshuflw $0xfe,%xmm13,%xmm0
movdqa %xmm9,%xmm5
psrld  %xmm0,%xmm5
pshuflw $0x54,%xmm13,%xmm6
movdqa %xmm9,%xmm0
psrld  %xmm6,%xmm0
pshufd $0xee,%xmm13,%xmm6
pshuflw $0xfe,%xmm6,%xmm7
movdqa %xmm9,%xmm1
psrld  %xmm7,%xmm1
punpcklqdq %xmm5,%xmm0
pshuflw $0x54,%xmm6,%xmm5
movdqa %xmm9,%xmm6
psrld  %xmm5,%xmm6
punpckhqdq %xmm1,%xmm6
pshuflw $0xfe,%xmm14,%xmm1
movdqa %xmm9,%xmm5
psrld  %xmm1,%xmm5
shufps $0xcc,%xmm6,%xmm0
pshuflw $0x54,%xmm14,%xmm1
movdqa %xmm9,%xmm6
psrld  %xmm1,%xmm6
pshufd $0xee,%xmm14,%xmm1
pshuflw $0xfe,%xmm1,%xmm7
movdqa %xmm9,%xmm2
psrld  %xmm7,%xmm2
punpcklqdq %xmm5,%xmm6
pshuflw $0x54,%xmm1,%xmm1
movdqa %xmm9,%xmm5
psrld  %xmm1,%xmm5
punpckhqdq %xmm2,%xmm5
pshuflw $0xfe,%xmm15,%xmm1
movdqa %xmm9,%xmm2
psrld  %xmm1,%xmm2
shufps $0xcc,%xmm5,%xmm6
pshuflw $0x54,%xmm15,%xmm1
movdqa %xmm9,%xmm7
psrld  %xmm1,%xmm7
pshufd $0xee,%xmm15,%xmm1
pshuflw $0xfe,%xmm1,%xmm5
movdqa %xmm9,%xmm3
psrld  %xmm5,%xmm3
punpcklqdq %xmm2,%xmm7
pshuflw $0x54,%xmm1,%xmm1
movdqa %xmm9,%xmm2
psrld  %xmm1,%xmm2
punpckhqdq %xmm3,%xmm2
pshuflw $0xfe,%xmm4,%xmm1
movdqa %xmm9,%xmm3
psrld  %xmm1,%xmm3
shufps $0xcc,%xmm2,%xmm7
pshuflw $0x54,%xmm4,%xmm1
movdqa %xmm9,%xmm5
psrld  %xmm1,%xmm5
pshufd $0xee,%xmm4,%xmm1
pshuflw $0xfe,%xmm1,%xmm2
movdqa %xmm9,%xmm8
psrld  %xmm2,%xmm8
punpcklqdq %xmm3,%xmm5
pshuflw $0x54,%xmm1,%xmm1
movdqa %xmm9,%xmm2
psrld  %xmm1,%xmm2
punpckhqdq %xmm8,%xmm2
shufps $0xcc,%xmm2,%xmm5
andps  %xmm11,%xmm5
andps  %xmm11,%xmm7
packuswb %xmm7,%xmm5
andps  %xmm11,%xmm6
andps  %xmm11,%xmm0
packuswb %xmm0,%xmm6
packuswb %xmm6,%xmm5
pand   0xd4d(%rip),%xmm5
por    0xd55(%rip),%xmm5
movdqa %xmm5,%xmm0
punpcklbw %xmm10,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
punpckhbw %xmm10,%xmm5
pshufd $0x4e,%xmm5,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm0,%xmm1
movslq %ecx,%rcx
movdqu %xmm1,-0xf(%rax,%rcx,1)
paddd  %xmm12,%xmm4
paddd  %xmm12,%xmm15
paddd  %xmm12,%xmm14
paddd  %xmm12,%xmm13
add    $0xfffffff0,%ecx
add    $0xfffffffffffffff0,%rdi
jne    11b0 <int_to_binstr+0xa0>
cmp    %r9,%rdx
je     13ea <int_to_binstr+0x2da>
mov    %rdx,%rdi
not    %rdi
test   $0x1,%r9b
je     139a <int_to_binstr+0x28a>
mov    %ebx,%esi
mov    %edx,%ecx
shr    %cl,%esi
and    $0x1,%sil
or     $0x30,%sil
mov    %edx,%ecx
not    %ecx
add    %r14d,%ecx
movslq %ecx,%rcx
mov    %sil,(%rax,%rcx,1)
or     $0x1,%rdx
add    %r9,%rdi
je     13ea <int_to_binstr+0x2da>
mov    %edx,%edi
not    %edi
add    %r14d,%edi
cs nopw 0x0(%rax,%rax,1)
mov    %ebx,%esi
mov    %edx,%ecx
shr    %cl,%esi
and    $0x1,%sil
or     $0x30,%sil
movslq %edi,%rdi
mov    %sil,(%rax,%rdi,1)
lea    0x1(%rdx),%ecx
mov    %ebx,%esi
shr    %cl,%esi
and    $0x1,%sil
or     $0x30,%sil
lea    -0x1(%rdi),%ecx
movslq %ecx,%rcx
mov    %sil,(%rax,%rcx,1)
add    $0x2,%rdx
add    $0xfffffffe,%edi
cmp    %r9,%rdx
jne    13b0 <int_to_binstr+0x2a0>
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define noalias i8* @int_to_binstr(i32 %0, i32 %1) {
%3 = tail call i8* @malloc(i32 %1)
%4 = icmp sgt i32 %1, 0
br i1 %4, label %5, label %86
5: ; preds = %2
%6 = zext i32 %1 to i64
%7 = icmp ult i32 %1, 16
br i1 %7, label %40, label %8
8: ; preds = %5
%9 = add nsw i64 %6, -1
%10 = add i32 %1, -1
%11 = trunc i64 %9 to i32
%12 = sub i32 %10, %11
%13 = icmp sgt i32 %12, %10
%14 = icmp ugt i64 %9, 4294967295
%15 = or i1 %13, %14
br i1 %15, label %40, label %16
16: ; preds = %8
%17 = and i64 %6, 4294967280
%18 = insertelement <16 x i32> poison, i32 %0, i64 0
%19 = shufflevector <16 x i32> %18, <16 x i32> poison, <16 x i32> zeroinitializer
%20 = getelementptr inbounds i8, i8* %3, i64 -15
br label %21
21: ; preds = %21, %16
%22 = phi i64 [ 0, %16 ], [ %35, %21 ]
%23 = phi <16 x i32> [ <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>, %16 ], [ %36, %21 ]
%24 = trunc i64 %22 to i32
%25 = lshr <16 x i32> %19, %23
%26 = trunc <16 x i32> %25 to <16 x i8>
%27 = and <16 x i8> %26, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1>
%28 = or <16 x i8> %27, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%29 = xor i32 %24, -1
%30 = add i32 %29, %1
%31 = sext i32 %30 to i64
%32 = shufflevector <16 x i8> %28, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%33 = getelementptr inbounds i8, i8* %20, i64 %31
%34 = bitcast i8* %33 to <16 x i8>*
store <16 x i8> %32, <16 x i8>* %34
%35 = add nuw i64 %22, 16
%36 = add <16 x i32> %23, <i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16>
%37 = icmp eq i64 %35, %17
br i1 %37, label %38, label %21
38: ; preds = %21
%39 = icmp eq i64 %17, %6
br i1 %39, label %86, label %40
40: ; preds = %8, %5, %38
%41 = phi i64 [ 0, %8 ], [ 0, %5 ], [ %17, %38 ]
%42 = xor i64 %41, -1
%43 = and i64 %6, 1
%44 = icmp eq i64 %43, 0
br i1 %44, label %57, label %45
45: ; preds = %40
%46 = trunc i64 %41 to i32
%47 = lshr i32 %0, %46
%48 = trunc i32 %47 to i8
%49 = and i8 %48, 1
%50 = or i8 %49, 48
%51 = trunc i64 %41 to i32
%52 = xor i32 %51, -1
%53 = add i32 %52, %1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %3, i64 %54
store i8 %50, i8* %55
%56 = or i64 %41, 1
br label %57
57: ; preds = %45, %40
%58 = phi i64 [ %41, %40 ], [ %56, %45 ]
%59 = sub nsw i64 0, %6
%60 = icmp eq i64 %42, %59
br i1 %60, label %86, label %61
61: ; preds = %57, %61
%62 = phi i64 [ %84, %61 ], [ %58, %57 ]
%63 = trunc i64 %62 to i32
%64 = lshr i32 %0, %63
%65 = trunc i32 %64 to i8
%66 = and i8 %65, 1
%67 = or i8 %66, 48
%68 = trunc i64 %62 to i32
%69 = xor i32 %68, -1
%70 = add i32 %69, %1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %3, i64 %71
store i8 %67, i8* %72
%73 = add nuw nsw i64 %62, 1
%74 = trunc i64 %73 to i32
%75 = lshr i32 %0, %74
%76 = trunc i32 %75 to i8
%77 = and i8 %76, 1
%78 = or i8 %77, 48
%79 = trunc i64 %73 to i32
%80 = xor i32 %79, -1
%81 = add i32 %80, %1
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i8, i8* %3, i64 %82
store i8 %78, i8* %83
%84 = add nuw nsw i64 %62, 2
%85 = icmp eq i64 %84, %6
br i1 %85, label %86, label %61
86: ; preds = %57, %61, %38, %2
ret i8* %3
}