char *toBinary(int decimal) {
  static char binary[1000];
  int k = 0, n = 0;
  int negative = 0;
  int remain;
  char temp[1000];
  if (decimal < 0) {
    decimal = -decimal;
    negative = 1;
  }
  while (decimal > 0) {
    remain = decimal % 2;
    decimal = decimal / 2;
    temp[k++] = remain + '0';
  }
  if (negative)
    temp[k++] = '1';
  else
    temp[k++] = '0';
  while (k >= 0)
    binary[n++] = temp[--k];
  binary[n - 1] = 0;
  return binary;
}


x86 assembly (clang, -O0):
<toBinary>:
push   %rbp
mov    %rsp,%rbp
sub    $0x380,%rsp
mov    %edi,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0x0,-0x4(%rbp)
jge    113c <toBinary+0x3c>
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x4(%rbp)
movl   $0x1,-0x10(%rbp)
jmp    1141 <toBinary+0x41>
cmpl   $0x0,-0x4(%rbp)
jle    1188 <toBinary+0x88>
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %edx,-0x14(%rbp)
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4(%rbp)
mov    -0x14(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x8(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x8(%rbp)
cltq
mov    %cl,-0x400(%rbp,%rax,1)
jmp    1141 <toBinary+0x41>
cmpl   $0x0,-0x10(%rbp)
je     11ac <toBinary+0xac>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x8(%rbp)
cltq
movb   $0x31,-0x400(%rbp,%rax,1)
31
jmp    11c1 <toBinary+0xc1>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x8(%rbp)
cltq
movb   $0x30,-0x400(%rbp,%rax,1)
30
jmp    11c6 <toBinary+0xc6>
cmpl   $0x0,-0x8(%rbp)
jl     11ff <toBinary+0xff>
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
cltq
mov    -0x400(%rbp,%rax,1),%dl
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0xc(%rbp)
movslq %eax,%rcx
lea    0x2e39(%rip),%rax
mov    %dl,(%rax,%rcx,1)
jmp    11c6 <toBinary+0xc6>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x2e21(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
lea    0x2e16(%rip),%rax
add    $0x380,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<toBinary>:
sub    $0x368,%rsp
mov    %edi,%ecx
neg    %ecx
cmovs  %edi,%ecx
xor    %r10d,%r10d
test   %ecx,%ecx
je     1138 <toBinary+0x38>
mov    %ecx,%edx
nopw   0x0(%rax,%rax,1)
shr    %edx
mov    %ecx,%eax
and    $0x1,%al
or     $0x30,%al
mov    %al,-0x80(%rsp,%r10,1)
add    $0x1,%r10
cmp    $0x1,%ecx
mov    %edx,%ecx
ja     1120 <toBinary+0x20>
mov    %r10d,%esi
shr    $0x1f,%edi
or     $0x30,%dil
mov    %dil,-0x80(%rsp,%rsi,1)
mov    $0xffffffffffffffff,%rcx
cmp    $0xffffffff,%r10d
jl     12ba <toBinary+0x1ba>
lea    0x1(%rsi),%r8
lea    0x2(%r10),%edi
cmp    $0x6,%r10d
jae    116d <toBinary+0x6d>
xor    %ecx,%ecx
jmp    1283 <toBinary+0x183>
cmp    $0xe,%r10d
jae    117a <toBinary+0x7a>
xor    %ecx,%ecx
jmp    121d <toBinary+0x11d>
mov    %edi,%ecx
and    $0xfffffff0,%ecx
movdqu -0x8f(%rsp,%rsi,1),%xmm1
ff ff
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
movdqa %xmm1,0x2e6e(%rip)
cmp    $0x10,%rcx
je     1209 <toBinary+0x109>
lea    -0x80(%rsp),%rax
movdqu -0x1f(%rsi,%rax,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
movdqa %xmm0,0x2e37(%rip)
cmp    %rdi,%rcx
je     12b3 <toBinary+0x1b3>
test   $0x8,%dil
jne    121d <toBinary+0x11d>
sub    %rcx,%r8
jmp    1283 <toBinary+0x183>
mov    %rcx,%rdx
mov    %edi,%ecx
and    $0xfffffff8,%ecx
sub    %rcx,%r8
sub    %rdx,%rsi
lea    -0x80(%rsp),%rax
add    %rax,%rsi
add    $0xfffffffffffffff9,%rsi
pxor   %xmm0,%xmm0
lea    0x2dee(%rip),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   (%rsi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rdx,%r9,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    %rdx,%rcx
jne    1250 <toBinary+0x150>
cmp    %rdi,%rcx
je     12b3 <toBinary+0x1b3>
lea    -0x80(%rsp),%rax
lea    (%r8,%rax,1),%rdx
add    $0xffffffffffffffff,%rdx
lea    0x2d99(%rip),%rsi
nopw   0x0(%rax,%rax,1)
movzbl (%rdx),%eax
mov    %al,(%rcx,%rsi,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
cmp    %rcx,%rdi
jne    12a0 <toBinary+0x1a0>
add    $0x1,%r10d
movslq %r10d,%rcx
lea    0x2d6f(%rip),%rax
movb   $0x0,(%rcx,%rax,1)
add    $0x368,%rsp
ret

LLVM IR (-O0):
@toBinary.binary = internal global [1000 x i8] zeroinitializer
define i8* @toBinary(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca [1000 x i8]
store i32 %0, i32* %2
store i32 0, i32* %3
store i32 0, i32* %4
store i32 0, i32* %5
%8 = load i32, i32* %2
%9 = icmp slt i32 %8, 0
br i1 %9, label %10, label %13
10: ; preds = %1
%11 = load i32, i32* %2
%12 = sub nsw i32 0, %11
store i32 %12, i32* %2
store i32 1, i32* %5
br label %13
13: ; preds = %10, %1
br label %14
14: ; preds = %17, %13
%15 = load i32, i32* %2
%16 = icmp sgt i32 %15, 0
br i1 %16, label %17, label %29
17: ; preds = %14
%18 = load i32, i32* %2
%19 = srem i32 %18, 2
store i32 %19, i32* %6
%20 = load i32, i32* %2
%21 = sdiv i32 %20, 2
store i32 %21, i32* %2
%22 = load i32, i32* %6
%23 = add nsw i32 %22, 48
%24 = trunc i32 %23 to i8
%25 = load i32, i32* %3
%26 = add nsw i32 %25, 1
store i32 %26, i32* %3
%27 = sext i32 %25 to i64
%28 = getelementptr inbounds [1000 x i8], [1000 x i8]* %7, i64 0, i64 %27
store i8 %24, i8* %28
br label %14
29: ; preds = %14
%30 = load i32, i32* %5
%31 = icmp ne i32 %30, 0
br i1 %31, label %32, label %37
32: ; preds = %29
%33 = load i32, i32* %3
%34 = add nsw i32 %33, 1
store i32 %34, i32* %3
%35 = sext i32 %33 to i64
%36 = getelementptr inbounds [1000 x i8], [1000 x i8]* %7, i64 0, i64 %35
store i8 49, i8* %36
br label %42
37: ; preds = %29
%38 = load i32, i32* %3
%39 = add nsw i32 %38, 1
store i32 %39, i32* %3
%40 = sext i32 %38 to i64
%41 = getelementptr inbounds [1000 x i8], [1000 x i8]* %7, i64 0, i64 %40
store i8 48, i8* %41
br label %42
42: ; preds = %37, %32
br label %43
43: ; preds = %46, %42
%44 = load i32, i32* %3
%45 = icmp sge i32 %44, 0
br i1 %45, label %46, label %56
46: ; preds = %43
%47 = load i32, i32* %3
%48 = add nsw i32 %47, -1
store i32 %48, i32* %3
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [1000 x i8], [1000 x i8]* %7, i64 0, i64 %49
%51 = load i8, i8* %50
%52 = load i32, i32* %4
%53 = add nsw i32 %52, 1
store i32 %53, i32* %4
%54 = sext i32 %52 to i64
%55 = getelementptr inbounds [1000 x i8], [1000 x i8]* @toBinary.binary, i64 0, i64 %54
store i8 %51, i8* %55
br label %43
56: ; preds = %43
%57 = load i32, i32* %4
%58 = sub nsw i32 %57, 1
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [1000 x i8], [1000 x i8]* @toBinary.binary, i64 0, i64 %59
store i8 0, i8* %60
ret i8* getelementptr inbounds ([1000 x i8], [1000 x i8]* @toBinary.binary, i64 0, i64 0)
}

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