#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 */
int /*<<< orphan*/ free(char *);
char *malloc(int);
char *int2binary(int n) {
  int k, i;
  char *rascunho, *str;
  rascunho = malloc(8 * sizeof(int));
  for (k = 0; n > 0; n /= 2) {
    if (n % 2 == 0) {
      rascunho[k] = '0';
    } else {
      rascunho[k] = '1';
    }
    k++;
  }
  if (k == 0) {
    rascunho[k++] = '0';
  }
  str = malloc(k + 1);
  for (i = 0; i < k; i++) {
    str[i] = rascunho[k - i - 1];
  }
  str[k] = '\0';
  free(rascunho);
  return str;
}


x86 assembly (clang, -O0):
<int2binary>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %edi,-0x4(%rbp)
mov    $0x20,%edi
call   1040 <malloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x0,-0x4(%rbp)
jle    1197 <int2binary+0x77>
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    116f <int2binary+0x4f>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movb   $0x30,(%rax,%rcx,1)
jmp    117b <int2binary+0x5b>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movb   $0x31,(%rax,%rcx,1)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4(%rbp)
jmp    1140 <int2binary+0x20>
cmpl   $0x0,-0x8(%rbp)
jne    11b7 <int2binary+0x97>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x8(%rbp)
movslq %ecx,%rcx
movb   $0x30,(%rax,%rcx,1)
mov    -0x8(%rbp),%edi
add    $0x1,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1205 <int2binary+0xe5>
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11cd <int2binary+0xad>
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<int2binary>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %edi,%ebp
mov    $0x20,%edi
call   1040 <malloc@plt>
mov    %rax,%r15
test   %ebp,%ebp
jle    115d <int2binary+0x3d>
xor    %ebx,%ebx
mov    %ebp,%eax
xchg   %ax,%ax
mov    %ebp,%ecx
and    $0x1,%cl
or     $0x30,%cl
mov    %cl,(%r15,%rbx,1)
add    $0x1,%rbx
shr    %eax
cmp    $0x1,%ebp
mov    %eax,%ebp
ja     1140 <int2binary+0x20>
test   %ebx,%ebx
jne    1166 <int2binary+0x46>
movb   $0x30,(%r15)
mov    $0x1,%ebx
lea    0x1(%rbx),%edi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    %ebx,%eax
cmp    $0x8,%ebx
jae    117f <int2binary+0x5f>
xor    %ecx,%ecx
jmp    1273 <int2binary+0x153>
cmp    $0x10,%ebx
jae    118b <int2binary+0x6b>
xor    %ecx,%ecx
jmp    121b <int2binary+0xfb>
movslq %ebx,%rdx
mov    %eax,%ecx
and    $0xfffffff0,%ecx
movdqu -0x10(%rdx,%r15,1),%xmm1
pxor   %xmm0,%xmm0
movdqa %xmm1,%xmm2
punpcklbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqu %xmm1,(%r14)
cmp    $0x10,%rcx
je     1212 <int2binary+0xf2>
movdqu -0x20(%rdx,%r15,1),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqu %xmm0,0x10(%r14)
cmp    %rax,%rcx
je     1292 <int2binary+0x172>
test   $0x8,%al
je     1273 <int2binary+0x153>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
mov    %rax,%rsi
sub    %rdx,%rsi
add    %r15,%rsi
add    $0xfffffffffffffff8,%rsi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   (%rsi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%r14,%rdx,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    %rdx,%rcx
jne    1240 <int2binary+0x120>
cmp    %rax,%rcx
je     1292 <int2binary+0x172>
mov    %rax,%rdx
sub    %rcx,%rdx
mov    %r14,%rsi
add    %rcx,%rsi
nop
movzbl -0x1(%r15,%rdx,1),%ecx
mov    %cl,(%rsi)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1280 <int2binary+0x160>
movb   $0x0,(%r14,%rax,1)
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i8* @int2binary(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8*
store i32 %0, i32* %2
%7 = call i8* @malloc(i32 32)
store i8* %7, i8** %5
store i32 0, i32* %3
br label %8
8: ; preds = %28, %1
%9 = load i32, i32* %2
%10 = icmp sgt i32 %9, 0
br i1 %10, label %11, label %31
11: ; preds = %8
%12 = load i32, i32* %2
%13 = srem i32 %12, 2
%14 = icmp eq i32 %13, 0
br i1 %14, label %15, label %20
15: ; preds = %11
%16 = load i8*, i8** %5
%17 = load i32, i32* %3
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds i8, i8* %16, i64 %18
store i8 48, i8* %19
br label %25
20: ; preds = %11
%21 = load i8*, i8** %5
%22 = load i32, i32* %3
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8, i8* %21, i64 %23
store i8 49, i8* %24
br label %25
25: ; preds = %20, %15
%26 = load i32, i32* %3
%27 = add nsw i32 %26, 1
store i32 %27, i32* %3
br label %28
28: ; preds = %25
%29 = load i32, i32* %2
%30 = sdiv i32 %29, 2
store i32 %30, i32* %2
br label %8
31: ; preds = %8
%32 = load i32, i32* %3
%33 = icmp eq i32 %32, 0
br i1 %33, label %34, label %40
34: ; preds = %31
%35 = load i8*, i8** %5
%36 = load i32, i32* %3
%37 = add nsw i32 %36, 1
store i32 %37, i32* %3
%38 = sext i32 %36 to i64
%39 = getelementptr inbounds i8, i8* %35, i64 %38
store i8 48, i8* %39
br label %40
40: ; preds = %34, %31
%41 = load i32, i32* %3
%42 = add nsw i32 %41, 1
%43 = call i8* @malloc(i32 %42)
store i8* %43, i8** %6
store i32 0, i32* %4
br label %44
44: ; preds = %61, %40
%45 = load i32, i32* %4
%46 = load i32, i32* %3
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %64
48: ; preds = %44
%49 = load i8*, i8** %5
%50 = load i32, i32* %3
%51 = load i32, i32* %4
%52 = sub nsw i32 %50, %51
%53 = sub nsw i32 %52, 1
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8, i8* %49, i64 %54
%56 = load i8, i8* %55
%57 = load i8*, i8** %6
%58 = load i32, i32* %4
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8, i8* %57, i64 %59
store i8 %56, i8* %60
br label %61
61: ; preds = %48
%62 = load i32, i32* %4
%63 = add nsw i32 %62, 1
store i32 %63, i32* %4
br label %44
64: ; preds = %44
%65 = load i8*, i8** %6
%66 = load i32, i32* %3
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i8, i8* %65, i64 %67
store i8 0, i8* %68
%69 = load i8*, i8** %5
%70 = call i32 @free(i8* %69)
%71 = load i8*, i8** %6
ret i8* %71
}

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