void itoa(int number, char *str, int base) {
  int digit, i = 0, j = 0;
  char temp[10];
  if (number == 0) {
    temp[i] = '0';
    i++;
  } else if (number < 0) {
    str[j] = '-';
    j++;
    number = -number;
  }
  while (number > 0) {
    digit = number % base;
    number = number / base;
    if (digit <= 9)
      temp[i] = digit + '0';
    else
      temp[i] = (digit - 10) + 'a';
    i++;
  }
  temp[i] = '\0';
  while (i >= 0) {
    i--;
    str[j] = temp[i];
    j++;
  }
  str[j] = '\0';
}


x86 assembly (clang, -O0):
<itoa>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x0,-0x4(%rbp)
jne    113d <itoa+0x3d>
movslq -0x1c(%rbp),%rax
movb   $0x30,-0x2a(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1169 <itoa+0x69>
cmpl   $0x0,-0x4(%rbp)
jge    1164 <itoa+0x64>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movb   $0x2d,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
xor    %eax,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1169 <itoa+0x69>
jmp    116e <itoa+0x6e>
cmpl   $0x0,-0x4(%rbp)
jle    11cc <itoa+0xcc>
mov    -0x4(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    -0x4(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    %eax,-0x4(%rbp)
cmpl   $0x9,-0x18(%rbp)
jg     11ab <itoa+0xab>
mov    -0x18(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
movslq -0x1c(%rbp),%rax
mov    %cl,-0x2a(%rbp,%rax,1)
jmp    11be <itoa+0xbe>
mov    -0x18(%rbp),%eax
sub    $0xa,%eax
add    $0x61,%eax
mov    %al,%cl
movslq -0x1c(%rbp),%rax
mov    %cl,-0x2a(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    116e <itoa+0x6e>
movslq -0x1c(%rbp),%rax
movb   $0x0,-0x2a(%rbp,%rax,1)
cmpl   $0x0,-0x1c(%rbp)
jl     1209 <itoa+0x109>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
mov    -0x2a(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11d5 <itoa+0xd5>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
pop    %rbp
ret

x86 assembly (clang, -O2):
<itoa>:
push   %rbx
test   %edi,%edi
je     1160 <itoa+0x60>
mov    %edx,%ecx
mov    %edi,%eax
xor    %r9d,%r9d
test   %edi,%edi
jns    111b <itoa+0x1b>
movb   $0x2d,(%rsi)
neg    %eax
mov    $0x1,%r9d
xor    %edi,%edi
mov    $0x30,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cltd
idiv   %ecx
cmp    $0xa,%edx
mov    $0x57,%ebx
cmovb  %r8d,%ebx
add    %dl,%bl
mov    %bl,-0xa(%rsp,%rdi,1)
add    $0x1,%rdi
test   %eax,%eax
jg     1130 <itoa+0x30>
mov    %edi,%eax
movb   $0x0,-0xa(%rsp,%rax,1)
test   %edi,%edi
jns    116f <itoa+0x6f>
mov    %r9d,%ebx
jmp    12e3 <itoa+0x1e3>
movw   $0x30,-0xa(%rsp)
xor    %r9d,%r9d
mov    $0x1,%edi
mov    %r9d,%r11d
mov    %edi,%r8d
lea    (%r9,%rdi,1),%ebx
add    $0x1,%ebx
mov    %rbx,%r9
sub    %r11,%r9
cmp    $0x8,%r9
jae    1193 <itoa+0x93>
mov    %r8,%r10
mov    %r11,%rcx
jmp    12c3 <itoa+0x1c3>
cmp    $0x20,%r9
jae    11a0 <itoa+0xa0>
xor    %edi,%edi
jmp    1260 <itoa+0x160>
mov    %r9,%rdi
and    $0xffffffffffffffe0,%rdi
lea    -0xa(%rsp),%rax
lea    (%r8,%rax,1),%rcx
add    $0xfffffffffffffff0,%rcx
lea    (%r11,%rsi,1),%rdx
add    $0x10,%rdx
xor    %eax,%eax
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x10(%rcx),%xmm1
movdqu (%rcx),%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,-0x10(%rdx,%rax,1)
movdqu %xmm1,(%rdx,%rax,1)
add    $0x20,%rax
add    $0xffffffffffffffe0,%rcx
cmp    %rax,%rdi
jne    11d0 <itoa+0xd0>
cmp    %rdi,%r9
je     12e3 <itoa+0x1e3>
test   $0x18,%r9b
je     12e9 <itoa+0x1e9>
mov    %r9,%rax
and    $0xfffffffffffffff8,%rax
mov    %r8,%r10
sub    %rax,%r10
lea    (%rax,%r11,1),%rcx
sub    %rdi,%r8
lea    (%rsp,%r8,1),%rdx
add    $0xffffffffffffffee,%rdx
add    %rsi,%r11
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movq   (%rdx),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%r11,%rdi,1)
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rdx
cmp    %rdi,%rax
jne    1290 <itoa+0x190>
cmp    %rax,%r9
je     12e3 <itoa+0x1e3>
lea    -0xa(%rsp),%rax
add    %r10,%rax
add    $0xffffffffffffffff,%rax
nop
movzbl (%rax),%edx
mov    %dl,(%rsi,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
cmp    %rcx,%rbx
jne    12d0 <itoa+0x1d0>
movb   $0x0,(%rsi,%rbx,1)
pop    %rbx
ret
add    %rdi,%r11
sub    %rdi,%r8
jmp    1188 <itoa+0x88>

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

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