void int2bin(long decimal, char *binary) {
  int k = 0, n = 0;
  int neg_flag = 0;
  int remain;
  char temp[80];
  if (decimal < 0) {
    decimal = -decimal;
    neg_flag = 1;
  }
  do {
    remain = decimal % 2;
    decimal = decimal / 2;
    temp[k++] = remain + '0';
  } while (decimal > 0);
  while (k < 32) {
    temp[k++] = '0';
  }
  if (neg_flag)
    temp[k++] = '-';
  while (k >= 0)
    binary[n++] = temp[--k];
  binary[n - 1] = 0;
}


x86 assembly (clang, -O0):
<int2bin>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpq   $0x0,-0x8(%rbp)
jge    113d <int2bin+0x3d>
xor    %eax,%eax
sub    -0x8(%rbp),%rax
mov    %rax,-0x8(%rbp)
movl   $0x1,-0x1c(%rbp)
jmp    1142 <int2bin+0x42>
mov    -0x8(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %edx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x8(%rbp)
mov    -0x20(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x14(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
cltq
mov    %cl,-0x70(%rbp,%rax,1)
cmpq   $0x0,-0x8(%rbp)
jg     1142 <int2bin+0x42>
jmp    1190 <int2bin+0x90>
cmpl   $0x20,-0x14(%rbp)
jge    11b1 <int2bin+0xb1>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x14(%rbp)
cltq
movb   $0x30,-0x70(%rbp,%rax,1)
jmp    1190 <int2bin+0x90>
cmpl   $0x0,-0x1c(%rbp)
je     11cd <int2bin+0xcd>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x14(%rbp)
cltq
movb   $0x2d,-0x70(%rbp,%rax,1)
jmp    11d2 <int2bin+0xd2>
cmpl   $0x0,-0x14(%rbp)
jl     1205 <int2bin+0x105>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
cltq
mov    -0x70(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    11d2 <int2bin+0xd2>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
pop    %rbp
ret

x86 assembly (clang, -O2):
<int2bin>:
push   %rbp
push   %r14
push   %rbx
sub    $0x50,%rsp
mov    %rsi,%rbx
mov    %rdi,%r14
mov    %rdi,%rcx
neg    %rcx
cmovs  %rdi,%rcx
xor    %eax,%eax
mov    %rcx,%rdx
nopl   (%rax)
shr    $0x3f,%rdx
add    %rcx,%rdx
mov    %edx,%esi
and    $0xfe,%esi
mov    %ecx,%edi
sub    %esi,%edi
sar    %rdx
add    $0x30,%dil
mov    %dil,(%rsp,%rax,1)
add    $0x1,%rax
cmp    $0x1,%rcx
mov    %rdx,%rcx
jg     1130 <int2bin+0x20>
lea    -0x1(%rax),%ecx
cmp    $0x1f,%ecx
jb     1181 <int2bin+0x71>
test   %r14,%r14
js     11b4 <int2bin+0xa4>
test   %eax,%eax
js     11c1 <int2bin+0xb1>
mov    %eax,%r8d
lea    0x1(%rax),%ebp
cmp    $0x7,%eax
jae    11cb <int2bin+0xbb>
xor    %edx,%edx
mov    %r8,%r9
jmp    12d2 <int2bin+0x1c2>
mov    %eax,%ecx
lea    (%rsp,%rcx,1),%rdi
cmp    $0x20,%eax
mov    $0x1f,%edx
mov    $0x1f,%ebp
cmovae %eax,%ebp
cmovae %eax,%edx
sub    %eax,%edx
add    $0x1,%rdx
mov    $0x30,%esi
call   1030 <memset@plt>
add    $0x1,%ebp
mov    %ebp,%eax
test   %r14,%r14
jns    1168 <int2bin+0x58>
mov    %eax,%ecx
add    $0x1,%eax
movb   $0x2d,(%rsp,%rcx,1)
test   %eax,%eax
jns    116c <int2bin+0x5c>
mov    $0xffffffff,%eax
jmp    12f3 <int2bin+0x1e3>
cmp    $0x1f,%eax
jae    11d7 <int2bin+0xc7>
xor    %edx,%edx
jmp    1280 <int2bin+0x170>
mov    %ebp,%edx
and    $0xffffffe0,%edx
mov    %rsp,%rsi
lea    (%r8,%rsi,1),%rdi
add    $0xfffffffffffffff0,%rdi
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopl   (%rax)
movdqu -0x10(%rdi),%xmm1
movdqu (%rdi),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,(%rbx,%rsi,1)
movdqu %xmm1,0x10(%rbx,%rsi,1)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rdi
cmp    %rsi,%rdx
jne    11f0 <int2bin+0xe0>
cmp    %rbp,%rdx
je     12f3 <int2bin+0x1e3>
test   $0x18,%bpl
je     1302 <int2bin+0x1f2>
mov    %rdx,%rdi
mov    %ebp,%edx
and    $0xfffffff8,%edx
mov    %r8,%r9
sub    %rdx,%r9
sub    %rdi,%r8
lea    (%rsp,%r8,1),%rsi
add    $0xfffffffffffffff8,%rsi
pxor   %xmm0,%xmm0
nopl   (%rax)
movq   (%rsi),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rbx,%rdi,1)
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rsi
cmp    %rdi,%rdx
jne    12a0 <int2bin+0x190>
cmp    %rbp,%rdx
je     12f3 <int2bin+0x1e3>
mov    %rsp,%rsi
add    %r9,%rsi
add    $0xffffffffffffffff,%rsi
nopl   0x0(%rax)
movzbl (%rsi),%ecx
mov    %cl,(%rbx,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
cmp    %rdx,%rbp
jne    12e0 <int2bin+0x1d0>
cltq
movb   $0x0,(%rbx,%rax,1)
add    $0x50,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
sub    %rdx,%r8
jmp    1179 <int2bin+0x69>

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

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