void int_to_string_dec(int input, char *str) {
  char stack[12];
  char sign_flag = 0;
  int i;
  int j;
  if (input == 0) {
    str[0] = '0';
    str[1] = '\0';
    return;
  }
  if (input < 0) {
    sign_flag = 1;
    input = -input;
  }
  for (i = 0; input > 0; ++i) {
    stack[i] = input % 10 + '0';
    input /= 10;
  }
  j = 0;
  if (sign_flag == 1)
    str[j++] = '-';
  for (--i; i >= 0; --i, ++j)
    str[j] = stack[i];
  str[j] = '\0';
  return;
}


x86 assembly (clang, -O0):
<int_to_string_dec>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movb   $0x0,-0x1d(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    112d <int_to_string_dec+0x2d>
mov    -0x10(%rbp),%rax
movb   $0x30,(%rax)
mov    -0x10(%rbp),%rax
movb   $0x0,0x1(%rax)
jmp    11fb <int_to_string_dec+0xfb>
cmpl   $0x0,-0x4(%rbp)
jge    1143 <int_to_string_dec+0x43>
movb   $0x1,-0x1d(%rbp)
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x4(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x0,-0x4(%rbp)
jle    1188 <int_to_string_dec+0x88>
mov    -0x4(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
movslq -0x24(%rbp),%rax
mov    %cl,-0x1c(%rbp,%rax,1)
mov    -0x4(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    114a <int_to_string_dec+0x4a>
movl   $0x0,-0x28(%rbp)
movsbl -0x1d(%rbp),%eax
cmp    $0x1,%eax
jne    11b2 <int_to_string_dec+0xb2>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
movslq %ecx,%rcx
movb   $0x2d,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     11ef <int_to_string_dec+0xef>
movslq -0x24(%rbp),%rax
mov    -0x1c(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11bb <int_to_string_dec+0xbb>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
pop    %rbp
ret

x86 assembly (clang, -O2):
<int_to_string_dec>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
je     1220 <int_to_string_dec+0x120>
mov    %edi,%eax
neg    %eax
cmovs  %edi,%eax
xor    %r13d,%r13d
mov    $0xffffffffffffffff,%rbp
mov    $0xcccccccd,%r8d
nopl   0x0(%rax)
mov    %eax,%ebx
imul   %r8,%rbx
shr    $0x23,%rbx
lea    (%rbx,%rbx,1),%edx
lea    (%rdx,%rdx,4),%edx
mov    %eax,%ecx
sub    %edx,%ecx
or     $0x30,%cl
mov    %cl,-0xb(%rsp,%rbp,1)
add    $0x1,%r13d
add    $0x1,%rbp
cmp    $0x9,%eax
mov    %ebx,%eax
ja     1130 <int_to_string_dec+0x30>
xor    %r8d,%r8d
test   %edi,%edi
js     122b <int_to_string_dec+0x12b>
test   %r13d,%r13d
jle    123d <int_to_string_dec+0x13d>
lea    0x1(%rbp),%rax
mov    %eax,%ecx
mov    %r8d,%r10d
lea    (%r8,%r13,1),%r9d
mov    %r9,%r11
sub    %r10,%r11
cmp    $0x8,%r11
jae    1250 <int_to_string_dec+0x150>
mov    %r10,%rdi
mov    %r9d,%edx
sub    %edi,%edx
mov    %rdi,%rax
not    %rax
add    %r9,%rax
test   $0x3,%dl
je     11c8 <int_to_string_dec+0xc8>
sub    %dil,%r8b
add    %r8b,%r13b
movzbl %r13b,%edx
and    $0x3,%edx
xchg   %ax,%ax
add    $0xffffffffffffffff,%rcx
mov    %ecx,%ebp
movzbl -0xc(%rsp,%rbp,1),%ebx
mov    %bl,(%rsi,%rdi,1)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
jne    11b0 <int_to_string_dec+0xb0>
cmp    $0x3,%rax
jb     1240 <int_to_string_dec+0x140>
mov    $0xfffffffe,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rcx,%rax,1),%rdx
lea    0x1(%rdx),%ebp
movzbl -0xc(%rsp,%rbp,1),%ebx
mov    %bl,(%rsi,%rdi,1)
mov    %edx,%ebp
movzbl -0xc(%rsp,%rbp,1),%ebx
mov    %bl,0x1(%rsi,%rdi,1)
add    $0xffffffff,%edx
movzbl -0xc(%rsp,%rdx,1),%edx
mov    %dl,0x2(%rsi,%rdi,1)
add    $0xfffffffffffffffc,%rcx
mov    %ecx,%edx
movzbl -0xc(%rsp,%rdx,1),%edx
mov    %dl,0x3(%rsi,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%r9
jne    11e0 <int_to_string_dec+0xe0>
jmp    1240 <int_to_string_dec+0x140>
movb   $0x30,(%rsi)
mov    $0x1,%r9d
jmp    1240 <int_to_string_dec+0x140>
movb   $0x2d,(%rsi)
mov    $0x1,%r8d
test   %r13d,%r13d
jg     116e <int_to_string_dec+0x6e>
mov    %r8d,%r9d
movb   $0x0,(%rsi,%r9,1)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r10,%rdi
not    %rdi
lea    (%rdi,%r9,1),%rbx
cmp    %ebx,%ebp
jb     118b <int_to_string_dec+0x8b>
shr    $0x20,%rbx
jne    118b <int_to_string_dec+0x8b>
cmp    $0x20,%r11
jae    127a <int_to_string_dec+0x17a>
xor    %r15d,%r15d
jmp    133d <int_to_string_dec+0x23d>
mov    %r11,%r15
and    $0xffffffffffffffe0,%r15
lea    (%rdi,%r9,1),%r14
add    $0x1,%r14
and    $0xffffffffffffffe0,%r14
xor    %edi,%edi
pxor   %xmm0,%xmm0
mov    %rbp,%rbx
cs nopw 0x0(%rax,%rax,1)
mov    %rdi,%r12
or     %r10,%r12
mov    %ebx,%eax
movdqu -0x2b(%rsp,%rax,1),%xmm1
movdqu -0x1b(%rsp,%rax,1),%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,(%rsi,%r12,1)
movdqu %xmm1,0x10(%rsi,%r12,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rbx
cmp    %rdi,%r14
jne    12a0 <int_to_string_dec+0x1a0>
cmp    %r15,%r11
je     1240 <int_to_string_dec+0x140>
test   $0x18,%r11b
je     13a5 <int_to_string_dec+0x2a5>
mov    %r11,%r14
and    $0xfffffffffffffff8,%r14
lea    (%r14,%r10,1),%rdi
sub    %r14,%rcx
sub    %r15,%rbp
mov    %r9,%rbx
sub    %r10,%rbx
and    $0xfffffffffffffff8,%rbx
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
mov    %r15,%rax
or     %r10,%rax
mov    %ebp,%edx
movq   -0x13(%rsp,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rsi,%rax,1)
add    $0x8,%r15
add    $0xfffffffffffffff8,%rbp
cmp    %r15,%rbx
jne    1360 <int_to_string_dec+0x260>
cmp    %r14,%r11
jne    118e <int_to_string_dec+0x8e>
jmp    1240 <int_to_string_dec+0x140>
sub    %r15,%rcx
or     %r15,%r10
jmp    118b <int_to_string_dec+0x8b>

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

LLVM IR (-O2):
define void @int_to_string_dec(i32 %0, i8* nocapture writeonly %1) {
%3 = alloca [12 x i8]
%4 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 0
%5 = icmp eq i32 %0, 0
br i1 %5, label %6, label %7
6: ; preds = %2
store i8 48, i8* %1
br label %149
7: ; preds = %2
%8 = icmp slt i32 %0, 0
%9 = sub nsw i32 0, %0
%10 = select i1 %8, i32 %9, i32 %0
br label %11
11: ; preds = %7, %11
%12 = phi i64 [ 0, %7 ], [ %19, %11 ]
%13 = phi i32 [ %10, %7 ], [ %18, %11 ]
%14 = urem i32 %13, 10
%15 = trunc i32 %14 to i8
%16 = or i8 %15, 48
%17 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %12
store i8 %16, i8* %17
%18 = udiv i32 %13, 10
%19 = add nuw i64 %12, 1
%20 = icmp ult i32 %13, 10
br i1 %20, label %21, label %11
21: ; preds = %11
%22 = trunc i64 %19 to i32
br i1 %8, label %23, label %24
23: ; preds = %21
store i8 45, i8* %1
br label %24
24: ; preds = %23, %21
%25 = phi i32 [ 1, %23 ], [ 0, %21 ]
%26 = icmp sgt i32 %22, 0
br i1 %26, label %29, label %27
27: ; preds = %24
%28 = zext i32 %25 to i64
br label %149
29: ; preds = %24
%30 = and i64 %19, 4294967295
%31 = zext i32 %25 to i64
%32 = add nuw i32 %25, %22
%33 = zext i32 %32 to i64
%34 = sub nsw i64 %33, %31
%35 = icmp ult i64 %34, 8
br i1 %35, label %97, label %36
36: ; preds = %29
%37 = xor i64 %31, -1
%38 = add nsw i64 %37, %33
%39 = add i32 %22, -1
%40 = trunc i64 %38 to i32
%41 = icmp ult i32 %39, %40
%42 = icmp ugt i64 %38, 4294967295
%43 = or i1 %41, %42
br i1 %43, label %97, label %44
44: ; preds = %36
%45 = icmp ult i64 %34, 32
br i1 %45, label %75, label %46
46: ; preds = %44
%47 = and i64 %34, -32
br label %48
48: ; preds = %48, %46
%49 = phi i64 [ 0, %46 ], [ %66, %48 ]
%50 = or i64 %49, %31
%51 = sub i64 %12, %49
%52 = and i64 %51, 4294967295
%53 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %52
%54 = getelementptr inbounds i8, i8* %53, i64 -15
%55 = bitcast i8* %54 to <16 x i8>*
%56 = load <16 x i8>, <16 x i8>* %55
%57 = shufflevector <16 x i8> %56, <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>
%58 = getelementptr inbounds i8, i8* %53, i64 -31
%59 = bitcast i8* %58 to <16 x i8>*
%60 = load <16 x i8>, <16 x i8>* %59
%61 = shufflevector <16 x i8> %60, <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>
%62 = getelementptr inbounds i8, i8* %1, i64 %50
%63 = bitcast i8* %62 to <16 x i8>*
store <16 x i8> %57, <16 x i8>* %63
%64 = getelementptr inbounds i8, i8* %62, i64 16
%65 = bitcast i8* %64 to <16 x i8>*
store <16 x i8> %61, <16 x i8>* %65
%66 = add nuw i64 %49, 32
%67 = icmp eq i64 %66, %47
br i1 %67, label %68, label %48
68: ; preds = %48
%69 = icmp eq i64 %34, %47
br i1 %69, label %149, label %70
70: ; preds = %68
%71 = sub nsw i64 %30, %47
%72 = or i64 %47, %31
%73 = and i64 %34, 24
%74 = icmp eq i64 %73, 0
br i1 %74, label %97, label %75
75: ; preds = %44, %70
%76 = phi i64 [ %47, %70 ], [ 0, %44 ]
%77 = sub nsw i64 %33, %31
%78 = and i64 %77, -8
%79 = or i64 %78, %31
%80 = sub nsw i64 %30, %78
br label %81
81: ; preds = %81, %75
%82 = phi i64 [ %76, %75 ], [ %93, %81 ]
%83 = or i64 %82, %31
%84 = sub i64 %12, %82
%85 = and i64 %84, 4294967295
%86 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %85
%87 = getelementptr inbounds i8, i8* %86, i64 -7
%88 = bitcast i8* %87 to <8 x i8>*
%89 = load <8 x i8>, <8 x i8>* %88
%90 = shufflevector <8 x i8> %89, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%91 = getelementptr inbounds i8, i8* %1, i64 %83
%92 = bitcast i8* %91 to <8 x i8>*
store <8 x i8> %90, <8 x i8>* %92
%93 = add nuw i64 %82, 8
%94 = icmp eq i64 %93, %78
br i1 %94, label %95, label %81
95: ; preds = %81
%96 = icmp eq i64 %77, %78
br i1 %96, label %149, label %97
97: ; preds = %36, %29, %70, %95
%98 = phi i64 [ %31, %29 ], [ %31, %36 ], [ %72, %70 ], [ %79, %95 ]
%99 = phi i64 [ %30, %29 ], [ %30, %36 ], [ %71, %70 ], [ %80, %95 ]
%100 = sub nsw i64 %33, %98
%101 = xor i64 %98, -1
%102 = add nsw i64 %101, %33
%103 = and i64 %100, 3
%104 = icmp eq i64 %103, 0
br i1 %104, label %117, label %105
105: ; preds = %97, %105
%106 = phi i64 [ %114, %105 ], [ %98, %97 ]
%107 = phi i64 [ %109, %105 ], [ %99, %97 ]
%108 = phi i64 [ %115, %105 ], [ 0, %97 ]
%109 = add nsw i64 %107, -1
%110 = and i64 %109, 4294967295
%111 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %110
%112 = load i8, i8* %111
%113 = getelementptr inbounds i8, i8* %1, i64 %106
store i8 %112, i8* %113
%114 = add nuw nsw i64 %106, 1
%115 = add i64 %108, 1
%116 = icmp eq i64 %115, %103
br i1 %116, label %117, label %105
117: ; preds = %105, %97
%118 = phi i64 [ %98, %97 ], [ %114, %105 ]
%119 = phi i64 [ %99, %97 ], [ %109, %105 ]
%120 = icmp ult i64 %102, 3
br i1 %120, label %149, label %121
121: ; preds = %117, %121
%122 = phi i64 [ %147, %121 ], [ %118, %117 ]
%123 = phi i64 [ %142, %121 ], [ %119, %117 ]
%124 = add i64 %123, 4294967295
%125 = and i64 %124, 4294967295
%126 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %125
%127 = load i8, i8* %126
%128 = getelementptr inbounds i8, i8* %1, i64 %122
store i8 %127, i8* %128
%129 = add nuw nsw i64 %122, 1
%130 = add i64 %123, 4294967294
%131 = and i64 %130, 4294967295
%132 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %131
%133 = load i8, i8* %132
%134 = getelementptr inbounds i8, i8* %1, i64 %129
store i8 %133, i8* %134
%135 = add nuw nsw i64 %122, 2
%136 = add i64 %123, 4294967293
%137 = and i64 %136, 4294967295
%138 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %137
%139 = load i8, i8* %138
%140 = getelementptr inbounds i8, i8* %1, i64 %135
store i8 %139, i8* %140
%141 = add nuw nsw i64 %122, 3
%142 = add nsw i64 %123, -4
%143 = and i64 %142, 4294967295
%144 = getelementptr inbounds [12 x i8], [12 x i8]* %3, i64 0, i64 %143
%145 = load i8, i8* %144
%146 = getelementptr inbounds i8, i8* %1, i64 %141
store i8 %145, i8* %146
%147 = add nuw nsw i64 %122, 4
%148 = icmp eq i64 %147, %33
br i1 %148, label %149, label %121
149: ; preds = %117, %121, %68, %95, %27, %6
%150 = phi i64 [ 1, %6 ], [ %28, %27 ], [ %33, %95 ], [ %33, %68 ], [ %33, %121 ], [ %33, %117 ]
%151 = getelementptr inbounds i8, i8* %1, i64 %150
store i8 0, i8* %151
ret void
}