char *m_dump_number(unsigned long long num, int base) {
  static char ret[80];
  char intret[80];
  int retpos = 0;
  int intretpos = 0;
  if (base < 0) {
    unsigned long long bit63 = 1;
    bit63 <<= 63;
    base = -base;
    if (num & bit63) {
      num ^= 0xffffffffffffffffULL;
      num += 1;
      ret[retpos++] = '-';
    }
  }
  if (num == 0) {
    ret[retpos++] = '0';
  } else {
    while (num != 0) {
      unsigned long long quot = num / base;
      int dig = num % base;
      intret[intretpos++] = "0123456789"
                            "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                            "abcdefghijklmnopqrstuvwxyz"[dig];
      num = quot;
    }
    do {
      ret[retpos++] = intret[--intretpos];
    } while (intretpos != 0);
  }
  ret[retpos++] = 0;
  return ret;
}


x86 assembly (clang, -O0):
<m_dump_number>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x68(%rbp)
cmpl   $0x0,-0xc(%rbp)
jge    1187 <m_dump_number+0x87>
movq   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%rax
shl    $0x3f,%rax
mov    %rax,-0x70(%rbp)
xor    %eax,%eax
sub    -0xc(%rbp),%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%rax
and    -0x70(%rbp),%rax
cmp    $0x0,%rax
je     1182 <m_dump_number+0x82>
mov    -0x8(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x64(%rbp)
movslq %eax,%rcx
lea    0x2eb2(%rip),%rax
movb   $0x2d,(%rax,%rcx,1)
jmp    1187 <m_dump_number+0x87>
cmpq   $0x0,-0x8(%rbp)
jne    11b0 <m_dump_number+0xb0>
mov    -0x64(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x64(%rbp)
movslq %eax,%rcx
lea    0x2e89(%rip),%rax
movb   $0x30,(%rax,%rcx,1)
jmp    124a <m_dump_number+0x14a>
jmp    11b5 <m_dump_number+0xb5>
cmpq   $0x0,-0x8(%rbp)
je     120f <m_dump_number+0x10f>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
xor    %edx,%edx
div    %rcx
mov    %edx,%eax
mov    %eax,-0x7c(%rbp)
movslq -0x7c(%rbp),%rcx
lea    0xe12(%rip),%rax
mov    (%rax,%rcx,1),%cl
mov    -0x68(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x68(%rbp)
cltq
mov    %cl,-0x60(%rbp,%rax,1)
mov    -0x78(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    11b5 <m_dump_number+0xb5>
jmp    1214 <m_dump_number+0x114>
mov    -0x68(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x68(%rbp)
cltq
mov    -0x60(%rbp,%rax,1),%dl
mov    -0x64(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x64(%rbp)
movslq %eax,%rcx
lea    0x2df8(%rip),%rax
mov    %dl,(%rax,%rcx,1)
cmpl   $0x0,-0x68(%rbp)
jne    1214 <m_dump_number+0x114>
jmp    124a <m_dump_number+0x14a>
mov    -0x64(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x64(%rbp)
movslq %eax,%rcx
lea    0x2dd1(%rip),%rax
movb   $0x0,(%rax,%rcx,1)
lea    0x2dc6(%rip),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<m_dump_number>:
test   %esi,%esi
jns    110b <m_dump_number+0xb>
neg    %esi
test   %rdi,%rdi
js     1126 <m_dump_number+0x26>
test   %rdi,%rdi
je     1115 <m_dump_number+0x15>
xor    %r8d,%r8d
jmp    1136 <m_dump_number+0x36>
movb   $0x30,0x2f14(%rip)
mov    $0x1,%ecx
jmp    1288 <m_dump_number+0x188>
neg    %rdi
movb   $0x2d,0x2f00(%rip)
mov    $0x1,%r8d
mov    %esi,%r9d
xor    %esi,%esi
lea    0xebe(%rip),%r10
movabs $0x100000000,%r11
xor    %ecx,%ecx
jmp    1173 <m_dump_number+0x73>
mov    %rdi,%rax
xor    %edx,%edx
div    %r9
movslq %edx,%rdx
movzbl (%rdx,%r10,1),%edx
mov    %dl,-0x58(%rsp,%rcx,1)
add    $0x1,%rcx
add    %r11,%rsi
cmp    %r9,%rdi
mov    %rax,%rdi
jb     1185 <m_dump_number+0x85>
mov    %rdi,%rax
shr    $0x20,%rax
jne    1150 <m_dump_number+0x50>
mov    %edi,%eax
xor    %edx,%edx
div    %r9d
jmp    1158 <m_dump_number+0x58>
mov    %rsi,%rdx
sar    $0x20,%rdx
shr    $0x25,%rsi
jne    119d <m_dump_number+0x9d>
mov    %r8,%rax
mov    %rdx,%rcx
jmp    125e <m_dump_number+0x15e>
movslq %ecx,%r9
and    $0x1f,%ecx
sub    %rcx,%rdx
mov    %rdx,%rax
add    %r8,%rax
lea    (%rsp,%r9,1),%rsi
add    $0xffffffffffffff98,%rsi
sub    %rcx,%r9
xor    %edi,%edi
pxor   %xmm0,%xmm0
lea    0x2e6c(%rip),%r10
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r8,%rdx
or     %rdi,%rdx
movdqu -0x10(%rsi),%xmm1
movdqu (%rsi),%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,(%rdx,%r10,1)
movdqu %xmm1,0x10(%rdx,%r10,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rsi
cmp    %rdi,%r9
jne    11d0 <m_dump_number+0xd0>
test   %rcx,%rcx
je     1285 <m_dump_number+0x185>
lea    0x2dcb(%rip),%rdi
mov    %rax,%rsi
nopl   0x0(%rax,%rax,1)
lea    0x1(%rsi),%rax
movzbl -0x59(%rsp,%rcx,1),%edx
mov    %dl,(%rsi,%rdi,1)
mov    %rax,%rsi
add    $0xffffffffffffffff,%rcx
jne    1270 <m_dump_number+0x170>
movslq %eax,%rcx
lea    0x2da1(%rip),%rax
movb   $0x0,(%rcx,%rax,1)
ret

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

LLVM IR (-O2):
@m_dump_number.ret = internal global [80 x i8] zeroinitializer
@.str = [63 x i8] c"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\00"
define i8* @m_dump_number(i64 %0, i32 %1) {
%3 = alloca [80 x i8]
%4 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 0
%5 = icmp slt i32 %1, 0
br i1 %5, label %6, label %11
6: ; preds = %2
%7 = sub nsw i32 0, %1
%8 = icmp sgt i64 %0, -1
br i1 %8, label %11, label %9
9: ; preds = %6
%10 = sub i64 0, %0
store i8 45, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @m_dump_number.ret, i64 0, i64 0)
br label %14
11: ; preds = %6, %2
%12 = phi i32 [ %1, %2 ], [ %7, %6 ]
%13 = icmp eq i64 %0, 0
br i1 %13, label %19, label %14
14: ; preds = %9, %11
%15 = phi i64 [ %10, %9 ], [ %0, %11 ]
%16 = phi i32 [ %7, %9 ], [ %12, %11 ]
%17 = phi i64 [ 1, %9 ], [ 0, %11 ]
%18 = zext i32 %16 to i64
br label %20
19: ; preds = %11
store i8 48, i8* getelementptr inbounds ([80 x i8], [80 x i8]* @m_dump_number.ret, i64 0, i64 0)
br label %78
20: ; preds = %14, %20
%21 = phi i64 [ 0, %14 ], [ %29, %20 ]
%22 = phi i64 [ %15, %14 ], [ %23, %20 ]
%23 = udiv i64 %22, %18
%24 = urem i64 %22, %18
%25 = shl nuw i64 %24, 32
%26 = ashr exact i64 %25, 32
%27 = getelementptr inbounds [63 x i8], [63 x i8]* @.str, i64 0, i64 %26
%28 = load i8, i8* %27
%29 = add nuw i64 %21, 1
%30 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 %21
store i8 %28, i8* %30
%31 = icmp ult i64 %22, %18
br i1 %31, label %32, label %20
32: ; preds = %20
%33 = shl i64 %29, 32
%34 = ashr exact i64 %33, 32
%35 = icmp ult i64 %33, 137438953472
br i1 %35, label %62, label %36
36: ; preds = %32
%37 = and i64 %29, 31
%38 = sub nsw i64 %34, %37
%39 = add nsw i64 %17, %38
br label %40
40: ; preds = %40, %36
%41 = phi i64 [ 0, %36 ], [ %58, %40 ]
%42 = or i64 %17, %41
%43 = xor i64 %41, -1
%44 = add i64 %34, %43
%45 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 %44
%46 = getelementptr inbounds i8, i8* %45, i64 -15
%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 i8, i8* %45, i64 -31
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = shufflevector <16 x i8> %52, <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>
%54 = getelementptr inbounds [80 x i8], [80 x i8]* @m_dump_number.ret, i64 0, i64 %42
%55 = bitcast i8* %54 to <16 x i8>*
store <16 x i8> %49, <16 x i8>* %55
%56 = getelementptr inbounds i8, i8* %54, i64 16
%57 = bitcast i8* %56 to <16 x i8>*
store <16 x i8> %53, <16 x i8>* %57
%58 = add nuw i64 %41, 32
%59 = icmp eq i64 %58, %38
br i1 %59, label %60, label %40
60: ; preds = %40
%61 = icmp eq i64 %37, 0
br i1 %61, label %74, label %62
62: ; preds = %32, %60
%63 = phi i64 [ %17, %32 ], [ %39, %60 ]
%64 = phi i64 [ %34, %32 ], [ %37, %60 ]
br label %65
65: ; preds = %62, %65
%66 = phi i64 [ %71, %65 ], [ %63, %62 ]
%67 = phi i64 [ %68, %65 ], [ %64, %62 ]
%68 = add nsw i64 %67, -1
%69 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 %68
%70 = load i8, i8* %69
%71 = add nuw nsw i64 %66, 1
%72 = getelementptr inbounds [80 x i8], [80 x i8]* @m_dump_number.ret, i64 0, i64 %66
store i8 %70, i8* %72
%73 = icmp eq i64 %68, 0
br i1 %73, label %74, label %65
74: ; preds = %65, %60
%75 = phi i64 [ %39, %60 ], [ %71, %65 ]
%76 = shl i64 %75, 32
%77 = ashr exact i64 %76, 32
br label %78
78: ; preds = %74, %19
%79 = phi i64 [ 1, %19 ], [ %77, %74 ]
%80 = getelementptr inbounds [80 x i8], [80 x i8]* @m_dump_number.ret, i64 0, i64 %79
store i8 0, i8* %80
ret i8* getelementptr inbounds ([80 x i8], [80 x i8]* @m_dump_number.ret, i64 0, i64 0)
}