void jam_ltoa(char *buffer, long number) {
  int index = 0;
  int rev_index = 0;
  char reverse[32];
  if (number < 0L) {
    buffer[index++] = '-';
    number = 0 - number;
  } else if (number == 0) {
    buffer[index++] = '0';
  }
  while (number != 0) {
    reverse[rev_index++] = (char)((number % 10) + '0');
    number /= 10;
  }
  while (rev_index > 0) {
    buffer[index++] = reverse[--rev_index];
  }
  buffer[index] = '\0';
}


x86 assembly (clang, -O0):
<jam_ltoa>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
jge    114a <jam_ltoa+0x4a>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
movslq %ecx,%rcx
movb   $0x2d,(%rax,%rcx,1)
xor    %eax,%eax
sub    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
jmp    1170 <jam_ltoa+0x70>
cmpq   $0x0,-0x10(%rbp)
jne    116b <jam_ltoa+0x6b>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
movslq %ecx,%rcx
movb   $0x30,(%rax,%rcx,1)
jmp    1170 <jam_ltoa+0x70>
jmp    1175 <jam_ltoa+0x75>
cmpq   $0x0,-0x10(%rbp)
je     11bc <jam_ltoa+0xbc>
mov    -0x10(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
add    $0x30,%rdx
mov    %dl,%cl
mov    -0x18(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
cltq
mov    %cl,-0x40(%rbp,%rax,1)
mov    -0x10(%rbp),%rax
mov    $0xa,%ecx
cqto
idiv   %rcx
mov    %rax,-0x10(%rbp)
jmp    1175 <jam_ltoa+0x75>
jmp    11c1 <jam_ltoa+0xc1>
cmpl   $0x0,-0x18(%rbp)
jle    11f4 <jam_ltoa+0xf4>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
cltq
mov    -0x40(%rbp,%rax,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x14(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    11c1 <jam_ltoa+0xc1>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
pop    %rbp
ret

x86 assembly (clang, -O2):
<jam_ltoa>:
push   %r15
push   %r14
push   %r12
push   %rbx
test   %rsi,%rsi
js     1122 <jam_ltoa+0x22>
xor    %r9d,%r9d
test   %rsi,%rsi
jne    112e <jam_ltoa+0x2e>
movb   $0x30,(%rdi)
mov    $0x1,%r9d
jmp    1240 <jam_ltoa+0x140>
movb   $0x2d,(%rdi)
neg    %rsi
mov    $0x1,%r9d
mov    $0xffffffffffffffff,%rcx
movabs $0x6666666666666667,%r10
66 66 66
mov    %r9d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsi,%rax
imul   %r10
mov    %rdx,%rax
shr    $0x3f,%rax
sar    $0x2,%rdx
add    %rax,%rdx
lea    (%rdx,%rdx,1),%eax
lea    (%rax,%rax,4),%eax
mov    %esi,%ebx
sub    %eax,%ebx
add    $0x30,%bl
mov    %bl,-0x27(%rsp,%rcx,1)
add    $0x9,%rsi
add    $0x1,%r8d
add    $0x1,%rcx
cmp    $0x13,%rsi
mov    %rdx,%rsi
jae    1150 <jam_ltoa+0x50>
lea    0x1(%rcx),%rax
test   %eax,%eax
jle    1240 <jam_ltoa+0x140>
mov    %eax,%edx
mov    %r9d,%r11d
mov    %r8d,%r9d
mov    %r9,%r10
sub    %r11,%r10
cmp    $0x8,%r10
jae    1250 <jam_ltoa+0x150>
mov    %r11,%rsi
mov    %r9d,%ecx
sub    %esi,%ecx
mov    %rsi,%rax
not    %rax
add    %r9,%rax
test   $0x3,%cl
je     11e8 <jam_ltoa+0xe8>
sub    %sil,%r8b
movzbl %r8b,%ecx
and    $0x3,%ecx
xchg   %ax,%ax
add    $0xffffffffffffffff,%rdx
mov    %edx,%ebx
movzbl -0x28(%rsp,%rbx,1),%ebx
mov    %bl,(%rdi,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    11d0 <jam_ltoa+0xd0>
cmp    $0x3,%rax
jb     1243 <jam_ltoa+0x143>
mov    $0xfffffffe,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdx,%rax,1),%rcx
lea    0x1(%rcx),%ebx
movzbl -0x28(%rsp,%rbx,1),%ebx
mov    %bl,(%rdi,%rsi,1)
mov    %ecx,%ebx
movzbl -0x28(%rsp,%rbx,1),%ebx
mov    %bl,0x1(%rdi,%rsi,1)
add    $0xffffffff,%ecx
movzbl -0x28(%rsp,%rcx,1),%ecx
mov    %cl,0x2(%rdi,%rsi,1)
add    $0xfffffffffffffffc,%rdx
mov    %edx,%ecx
movzbl -0x28(%rsp,%rcx,1),%ecx
mov    %cl,0x3(%rdi,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1200 <jam_ltoa+0x100>
jmp    1243 <jam_ltoa+0x143>
mov    %r9d,%r9d
movb   $0x0,(%rdi,%r9,1)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    %r11,%rax
not    %rax
lea    (%rax,%r9,1),%rsi
cmp    %esi,%ecx
jb     11ae <jam_ltoa+0xae>
shr    $0x20,%rsi
jne    11ae <jam_ltoa+0xae>
cmp    $0x20,%r10
jae    127a <jam_ltoa+0x17a>
xor    %r15d,%r15d
jmp    133d <jam_ltoa+0x23d>
mov    %r10,%r15
and    $0xffffffffffffffe0,%r15
lea    (%rax,%r9,1),%r14
add    $0x1,%r14
and    $0xffffffffffffffe0,%r14
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
mov    %rcx,%rsi
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%r12
or     %r11,%r12
mov    %esi,%eax
movdqu -0x47(%rsp,%rax,1),%xmm1
movdqu -0x37(%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,(%rdi,%r12,1)
movdqu %xmm1,0x10(%rdi,%r12,1)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rsi
cmp    %rbx,%r14
jne    12a0 <jam_ltoa+0x1a0>
cmp    %r15,%r10
je     1243 <jam_ltoa+0x143>
test   $0x18,%r10b
je     13a5 <jam_ltoa+0x2a5>
mov    %r10,%r14
and    $0xfffffffffffffff8,%r14
lea    (%r14,%r11,1),%rsi
sub    %r14,%rdx
sub    %r15,%rcx
mov    %r9,%r12
sub    %r11,%r12
and    $0xfffffffffffffff8,%r12
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
mov    %r15,%rax
or     %r11,%rax
mov    %ecx,%ebx
movq   -0x2f(%rsp,%rbx,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rdi,%rax,1)
add    $0x8,%r15
add    $0xfffffffffffffff8,%rcx
cmp    %r15,%r12
jne    1360 <jam_ltoa+0x260>
cmp    %r14,%r10
jne    11b1 <jam_ltoa+0xb1>
jmp    1243 <jam_ltoa+0x143>
sub    %r15,%rdx
or     %r15,%r11
jmp    11ae <jam_ltoa+0xae>

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

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