char *binString(int value) {
  static char binary[100];
  static char rev_bin[100];
  int x, y;
  for (x = 0; value > 0; x++) {
    binary[x] = (value % 2) ? '1' : '0';
    value >>= 1;
  }
  binary[x] = '\0';
  x = 0;
  while (binary[x] != '\0')
    x++;
  for (y = 0; x >= 0; x--, y++)
    rev_bin[y] = binary[x - 1];
  rev_bin[y] = '\0';
  return rev_bin;
}


x86 assembly (clang, -O0):
<binString>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x0,-0x4(%rbp)
jle    115a <binString+0x5a>
mov    -0x4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    $0x30,%eax
mov    $0x31,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%dl
movslq -0x8(%rbp),%rcx
lea    0x2ef0(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x4(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x4(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    110e <binString+0xe>
movslq -0x8(%rbp),%rcx
lea    0x2ecb(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x8(%rbp)
movslq -0x8(%rbp),%rcx
lea    0x2eb5(%rip),%rax
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1196 <binString+0x96>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1170 <binString+0x70>
movl   $0x0,-0xc(%rbp)
cmpl   $0x0,-0x8(%rbp)
jl     11df <binString+0xdf>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
movslq %eax,%rcx
lea    0x2e79(%rip),%rax
mov    (%rax,%rcx,1),%dl
movslq -0xc(%rbp),%rcx
lea    0x2edb(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    119d <binString+0x9d>
movslq -0xc(%rbp),%rcx
lea    0x2eb6(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
lea    0x2eab(%rip),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<binString>:
push   %rbp
push   %r15
push   %r14
push   %rbx
xor    %eax,%eax
test   %edi,%edi
jle    1138 <binString+0x38>
lea    0x2f1d(%rip),%rcx
mov    %edi,%edx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %edi,%ebx
and    $0x1,%bl
or     $0x30,%bl
mov    %bl,(%rax,%rcx,1)
shr    %edx
add    $0x1,%rax
cmp    $0x1,%edi
mov    %edx,%edi
ja     1120 <binString+0x20>
lea    0x2ef1(%rip),%r11
movb   $0x0,(%rax,%r11,1)
mov    $0xffffffff,%ecx
movabs $0xffffffff00000000,%rsi
ff ff ff
xor    %eax,%eax
movabs $0x100000000,%rdx
nop
add    %rdx,%rsi
add    $0x1,%ecx
cmpb   $0x0,(%rax,%r11,1)
lea    0x1(%rax),%rax
jne    1160 <binString+0x60>
sar    $0x20,%rsi
xor    %r8d,%r8d
test   %ecx,%ecx
mov    $0x0,%edx
cmovs  %ecx,%edx
mov    %eax,%r9d
sub    %edx,%r9d
cmp    $0x8,%r9d
jae    1195 <binString+0x95>
xor    %edi,%edi
jmp    12e8 <binString+0x1e8>
xor    %r10d,%r10d
cmp    $0x20,%r9d
jae    11a5 <binString+0xa5>
xor    %edi,%edi
jmp    126e <binString+0x16e>
mov    %r9d,%edi
and    $0xffffffe0,%edi
lea    -0x1(%rax),%edx
movslq %edx,%rdx
add    %r11,%rdx
add    $0xfffffffffffffff0,%rdx
test   %ecx,%ecx
mov    $0x0,%ebx
cmovs  %ecx,%ebx
mov    %eax,%r15d
sub    %ebx,%r15d
and    $0xffffffe0,%r15d
pxor   %xmm0,%xmm0
lea    0x2ec9(%rip),%r14
xor    %ebx,%ebx
nopl   0x0(%rax)
movdqu -0x10(%rdx),%xmm1
movdqu (%rdx),%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
movdqa %xmm2,(%rbx,%r14,1)
movdqa %xmm1,0x10(%rbx,%r14,1)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rdx
cmp    %rbx,%r15
jne    11e0 <binString+0xe0>
cmp    %r9,%rdi
je     1313 <binString+0x213>
test   $0x18,%r9b
je     12e5 <binString+0x1e5>
mov    %rdi,%rdx
mov    %r9d,%edi
and    $0xfffffff8,%edi
sub    %rdi,%rsi
mov    %r11,%rbx
sub    %rdx,%rbx
mov    %eax,%ebp
add    $0xffffffff,%ebp
movslq %ebp,%rbp
add    %rbp,%rbx
add    $0xfffffffffffffff8,%rbx
test   %ecx,%ecx
cmovs  %ecx,%r10d
mov    %eax,%r14d
sub    %r10d,%r14d
and    $0xfffffff8,%r14d
pxor   %xmm0,%xmm0
lea    0x2df6(%rip),%r10
nopw   0x0(%rax,%rax,1)
movq   (%rbx),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rdx,%r10,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rbx
cmp    %rdx,%r14
jne    12b0 <binString+0x1b0>
cmp    %r9,%rdi
jne    12e8 <binString+0x1e8>
jmp    1313 <binString+0x213>
sub    %rdi,%rsi
lea    (%rsi,%r11,1),%rdx
add    $0xffffffffffffffff,%rdx
test   %ecx,%ecx
cmovs  %ecx,%r8d
sub    %r8d,%eax
lea    0x2da0(%rip),%rcx
movzbl (%rdx),%ebx
mov    %bl,(%rdi,%rcx,1)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
cmp    %rdi,%rax
jne    1300 <binString+0x200>
mov    %r9d,%ecx
lea    0x2d83(%rip),%rax
movb   $0x0,(%rcx,%rax,1)
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

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