char *number(char *str, int num, int base, int size, int precision, int type) {
  char c, sign, tmp[36];
  const char *digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  int i;
  if (type & 64)
    digits = "0123456789abcdefghijklmnopqrstuvwxyz";
  if (type & 16)
    type &= ~1;
  if (base < 2 || base > 36)
    return 0;
  c = (type & 1) ? '0' : ' ';
  if (type & 2 && num < 0) {
    sign = '-';
    num = -num;
  } else
    sign = (type & 4) ? '+' : ((type & 8) ? ' ' : 0);
  if (sign)
    size--;
  if (type & 32) {
    if (base == 16)
      size -= 2;
    else if (base == 8)
      size--;
  }
  i = 0;
  if (num == 0)
    tmp[i++] = '0';
  else
    while (num != 0)
      tmp[i++] = digits[({
        int __res;
        __asm__("divl %4"
                : "=a"(num), "=d"(__res)
                : "0"(num), "1"(0), "r"(base));
        __res;
      })];
  if (i > precision)
    precision = i;
  size -= precision;
  if (!(type & (1 + 16)))
    while (size-- > 0)
      *str++ = ' ';
  if (sign)
    *str++ = sign;
  if (type & 32) {
    if (base == 8)
      *str++ = '0';
    else if (base == 16) {
      *str++ = '0';
      *str++ = digits[33];
    }
  }
  if (!(type & 16))
    while (size-- > 0)
      *str++ = c;
  while (i < precision--)
    *str++ = '0';
  while (i-- > 0)
    *str++ = tmp[i];
  while (size-- > 0)
    *str++ = ' ';
  return str;
}


x86 assembly (clang, -O0):
<number>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
lea    0xee0(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    -0x24(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     113e <number+0x3e>
lea    0xeeb(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    -0x24(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     1156 <number+0x56>
mov    -0x24(%rbp),%eax
and    $0xfffffffe,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x2,-0x18(%rbp)
jl     116a <number+0x6a>
cmpl   $0x24,-0x18(%rbp)
jle    1177 <number+0x77>
movq   $0x0,-0x8(%rbp)
jmp    149a <number+0x39a>
mov    -0x24(%rbp),%edx
and    $0x1,%edx
mov    $0x20,%eax
mov    $0x30,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,-0x25(%rbp)
mov    -0x24(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     11ba <number+0xba>
cmpl   $0x0,-0x14(%rbp)
jge    11ba <number+0xba>
movb   $0x2d,-0x26(%rbp)
xor    %eax,%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    11f2 <number+0xf2>
mov    -0x24(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     11d6 <number+0xd6>
mov    $0x2b,%eax
mov    %eax,-0x68(%rbp)
jmp    11ec <number+0xec>
mov    -0x24(%rbp),%edx
and    $0x8,%edx
xor    %eax,%eax
mov    $0x20,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %al,-0x26(%rbp)
cmpb   $0x0,-0x26(%rbp)
je     1205 <number+0x105>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     1249 <number+0x149>
cmpl   $0x10,-0x18(%rbp)
jne    122c <number+0x12c>
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x1c(%rbp)
jmp    1244 <number+0x144>
cmpl   $0x8,-0x18(%rbp)
jne    123f <number+0x13f>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1244 <number+0x144>
jmp    1249 <number+0x149>
movl   $0x0,-0x5c(%rbp)
cmpl   $0x0,-0x14(%rbp)
jne    1271 <number+0x171>
mov    -0x5c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x5c(%rbp)
cltq
movb   $0x30,-0x50(%rbp,%rax,1)
jmp    12c6 <number+0x1c6>
jmp    1276 <number+0x176>
cmpl   $0x0,-0x14(%rbp)
je     12c1 <number+0x1c1>
mov    -0x58(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,-0x14(%rbp)
mov    %edx,-0x60(%rbp)
mov    -0x60(%rbp),%ecx
mov    %ecx,-0x64(%rbp)
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x5c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x5c(%rbp)
cltq
mov    %cl,-0x50(%rbp,%rax,1)
jmp    1276 <number+0x176>
jmp    12c6 <number+0x1c6>
mov    -0x5c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    12d8 <number+0x1d8>
mov    -0x5c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
and    $0x11,%eax
cmp    $0x0,%eax
jne    1327 <number+0x227>
jmp    12f7 <number+0x1f7>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
jle    1322 <number+0x222>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x20,(%rax)
jmp    12f7 <number+0x1f7>
jmp    1327 <number+0x227>
cmpb   $0x0,-0x26(%rbp)
je     1345 <number+0x245>
mov    -0x26(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     13b3 <number+0x2b3>
cmpl   $0x8,-0x18(%rbp)
jne    1375 <number+0x275>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
jmp    13ae <number+0x2ae>
cmpl   $0x10,-0x18(%rbp)
jne    13a9 <number+0x2a9>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
mov    -0x58(%rbp),%rax
mov    0x21(%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    13ae <number+0x2ae>
jmp    13b3 <number+0x2b3>
mov    -0x24(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
jne    13f9 <number+0x2f9>
jmp    13c7 <number+0x2c7>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
jle    13f4 <number+0x2f4>
mov    -0x25(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    13c7 <number+0x2c7>
jmp    13f9 <number+0x2f9>
jmp    13fe <number+0x2fe>
mov    -0x5c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x20(%rbp)
cmp    %ecx,%eax
jge    142b <number+0x32b>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
jmp    13fe <number+0x2fe>
jmp    1430 <number+0x330>
mov    -0x5c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x5c(%rbp)
cmp    $0x0,%eax
jle    1462 <number+0x362>
movslq -0x5c(%rbp),%rax
mov    -0x50(%rbp,%rax,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1430 <number+0x330>
jmp    1467 <number+0x367>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
jle    1492 <number+0x392>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x20,(%rax)
jmp    1467 <number+0x367>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<number>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9d,%r12d
mov    %edx,%ebp
mov    %esi,%eax
test   $0x40,%r12b
lea    0xed0(%rip),%rdx
lea    0xeee(%rip),%rsi
cmove  %rdx,%rsi
mov    %r9d,%ebx
and    $0xfffffffe,%ebx
test   $0x10,%r12b
cmove  %r9d,%ebx
lea    -0x25(%rbp),%edx
cmp    $0xffffffdd,%edx
jae    1158 <number+0x48>
xor    %ebx,%ebx
jmp    1385 <number+0x275>
mov    %rdi,%r13
test   %eax,%eax
jns    116d <number+0x5d>
mov    %ebx,%edx
and    $0x2,%edx
je     116d <number+0x5d>
neg    %eax
mov    $0x2d,%dil
jmp    1185 <number+0x75>
lea    0x0(,%rbx,4),%edx
and    $0x20,%dl
test   $0x4,%bl
movzbl %dl,%edx
mov    $0x2b,%edi
cmove  %edx,%edi
cmp    $0x1,%dil
adc    $0xffffffff,%ecx
test   $0x20,%bl
je     119e <number+0x8e>
cmp    $0x8,%ebp
je     11ca <number+0xba>
cmp    $0x10,%ebp
jne    119e <number+0x8e>
add    $0xfffffffe,%ecx
test   %eax,%eax
je     11d1 <number+0xc1>
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nop
xor    %edx,%edx
div    %ebp
movslq %edx,%rdx
movzbl (%rsi,%rdx,1),%edx
mov    %dl,0x10(%rsp,%r15,1)
add    $0x1,%r15
test   %eax,%eax
jne    11b0 <number+0xa0>
jmp    11dc <number+0xcc>
add    $0xffffffff,%ecx
test   %eax,%eax
jne    11a2 <number+0x92>
movb   $0x30,0x10(%rsp)
mov    $0x1,%r15d
cmp    %r8d,%r15d
mov    %r8d,%r14d
cmovg  %r15d,%r14d
sub    %r14d,%ecx
test   $0x11,%bl
jne    1232 <number+0x122>
lea    -0x1(%rcx),%eax
test   %ecx,%ecx
jle    1457 <number+0x347>
mov    %eax,%eax
mov    %rax,0x8(%rsp)
lea    0x1(%rax),%rdx
mov    %edi,(%rsp)
mov    %r13,%rdi
mov    $0x20,%esi
mov    %r8d,0x4(%rsp)
call   1030 <memset@plt>
mov    (%rsp),%edi
mov    0x4(%rsp),%r8d
mov    0x8(%rsp),%rax
add    %rax,%r13
add    $0x1,%r13
mov    $0xffffffff,%ecx
test   %dil,%dil
je     123f <number+0x12f>
mov    %dil,0x0(%r13)
add    $0x1,%r13
test   $0x20,%bl
je     1257 <number+0x147>
cmp    $0x10,%ebp
je     1293 <number+0x183>
cmp    $0x8,%ebp
jne    1257 <number+0x147>
movb   $0x30,0x0(%r13)
add    $0x1,%r13
test   $0x10,%bl
jne    12b1 <number+0x1a1>
lea    -0x1(%rcx),%ebp
test   %ecx,%ecx
jle    128f <number+0x17f>
and    $0x1,%bl
shl    $0x4,%bl
or     $0x20,%bl
mov    %ecx,%edx
movzbl %bl,%esi
mov    %r13,%rdi
mov    %r8d,%ebx
call   1030 <memset@plt>
mov    %ebx,%r8d
mov    %ebp,%eax
add    %rax,%r13
add    $0x1,%r13
mov    $0xffffffff,%ecx
jmp    12b1 <number+0x1a1>
mov    %ebp,%ecx
jmp    12b1 <number+0x1a1>
movzbl %r12b,%eax
shr    $0x6,%eax
movb   $0x30,0x0(%r13)
shl    $0x5,%al
or     $0x58,%al
mov    %al,0x1(%r13)
add    $0x2,%r13
test   $0x10,%bl
je     125c <number+0x14c>
cmp    %r8d,%r15d
jge    12dc <number+0x1cc>
mov    %r15d,%eax
not    %eax
add    %eax,%r14d
lea    0x1(%r14),%rdx
mov    %r13,%rdi
mov    $0x30,%esi
mov    %rcx,%rbx
call   1030 <memset@plt>
mov    %rbx,%rcx
add    %r14,%r13
add    $0x1,%r13
mov    %r15d,%eax
test   %r15d,%r15d
mov    $0x1,%edx
mov    $0x1,%esi
cmovle %r15d,%esi
mov    %r15d,%r8d
sub    %esi,%r8d
cmp    $0x1f,%r8d
jb     1336 <number+0x226>
test   %r15d,%r15d
cmovle %r15d,%edx
lea    -0x1(%r15),%esi
lea    0x10(%rsp),%rdi
add    %rsi,%rdi
add    $0x1,%rdi
cmp    %rdi,%r13
jae    1397 <number+0x287>
sub    %edx,%r15d
lea    (%r15,%r13,1),%rdx
add    $0x1,%rdx
sub    %r15,%rsi
add    %rsp,%rsi
add    $0x10,%rsi
cmp    %rdx,%rsi
jae    1397 <number+0x287>
mov    %rax,%rdx
mov    %r13,%rbx
lea    0x1(%rdx),%eax
add    $0xffffffff,%edx
lea    (%rsp,%rdx,1),%rsi
add    $0x10,%rsi
nopw   0x0(%rax,%rax,1)
movzbl (%rsi),%edx
mov    %dl,(%rbx)
add    $0x1,%rbx
add    $0xffffffff,%eax
add    $0xffffffffffffffff,%rsi
cmp    $0x1,%eax
jg     1350 <number+0x240>
test   %ecx,%ecx
jle    1385 <number+0x275>
mov    %ecx,%edx
mov    %rbx,%rdi
mov    $0x20,%esi
mov    %rcx,%rbp
call   1030 <memset@plt>
add    $0xffffffff,%ebp
add    %rbp,%rbx
add    $0x1,%rbx
mov    %rbx,%rax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%r8
mov    %r8,%rsi
and    $0xffffffffffffffe0,%rsi
mov    %rax,%rdx
sub    %rsi,%rdx
lea    (%rsi,%r13,1),%rbx
add    $0xffffffffffffffff,%rax
xor    %edi,%edi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%ebp
movdqu -0xf(%rsp,%rbp,1),%xmm1
movdqu 0x1(%rsp,%rbp,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,0x0(%r13,%rdi,1)
movdqu %xmm1,0x10(%r13,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rax
cmp    %rdi,%rsi
jne    13c0 <number+0x2b0>
cmp    %rsi,%r8
jne    133c <number+0x22c>
jmp    1365 <number+0x255>
mov    %eax,%ecx
test   %dil,%dil
jne    1237 <number+0x127>
jmp    123f <number+0x12f>

LLVM IR (-O0):
@.str = [37 x i8] c"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\00"
@.str.1 = [37 x i8] c"0123456789abcdefghijklmnopqrstuvwxyz\00"
define i8* @number(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i8
%15 = alloca i8
%16 = alloca [36 x i8]
%17 = alloca i8*
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
store i8* %0, i8** %8
store i32 %1, i32* %9
store i32 %2, i32* %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
store i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i8** %17
%21 = load i32, i32* %13
%22 = and i32 %21, 64
%23 = icmp ne i32 %22, 0
br i1 %23, label %24, label %25
24: ; preds = %6
store i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i8** %17
br label %25
25: ; preds = %24, %6
%26 = load i32, i32* %13
%27 = and i32 %26, 16
%28 = icmp ne i32 %27, 0
br i1 %28, label %29, label %32
29: ; preds = %25
%30 = load i32, i32* %13
%31 = and i32 %30, -2
store i32 %31, i32* %13
br label %32
32: ; preds = %29, %25
%33 = load i32, i32* %10
%34 = icmp slt i32 %33, 2
br i1 %34, label %38, label %35
35: ; preds = %32
%36 = load i32, i32* %10
%37 = icmp sgt i32 %36, 36
br i1 %37, label %38, label %39
38: ; preds = %35, %32
store i8* null, i8** %7
br label %219
39: ; preds = %35
%40 = load i32, i32* %13
%41 = and i32 %40, 1
%42 = icmp ne i32 %41, 0
%43 = zext i1 %42 to i64
%44 = select i1 %42, i32 48, i32 32
%45 = trunc i32 %44 to i8
store i8 %45, i8* %14
%46 = load i32, i32* %13
%47 = and i32 %46, 2
%48 = icmp ne i32 %47, 0
br i1 %48, label %49, label %55
49: ; preds = %39
%50 = load i32, i32* %9
%51 = icmp slt i32 %50, 0
br i1 %51, label %52, label %55
52: ; preds = %49
store i8 45, i8* %15
%53 = load i32, i32* %9
%54 = sub nsw i32 0, %53
store i32 %54, i32* %9
br label %69
55: ; preds = %49, %39
%56 = load i32, i32* %13
%57 = and i32 %56, 4
%58 = icmp ne i32 %57, 0
br i1 %58, label %59, label %60
59: ; preds = %55
br label %66
60: ; preds = %55
%61 = load i32, i32* %13
%62 = and i32 %61, 8
%63 = icmp ne i32 %62, 0
%64 = zext i1 %63 to i64
%65 = select i1 %63, i32 32, i32 0
br label %66
66: ; preds = %60, %59
%67 = phi i32 [ 43, %59 ], [ %65, %60 ]
%68 = trunc i32 %67 to i8
store i8 %68, i8* %15
br label %69
69: ; preds = %66, %52
%70 = load i8, i8* %15
%71 = icmp ne i8 %70, 0
br i1 %71, label %72, label %75
72: ; preds = %69
%73 = load i32, i32* %11
%74 = add nsw i32 %73, -1
store i32 %74, i32* %11
br label %75
75: ; preds = %72, %69
%76 = load i32, i32* %13
%77 = and i32 %76, 32
%78 = icmp ne i32 %77, 0
br i1 %78, label %79, label %93
79: ; preds = %75
%80 = load i32, i32* %10
%81 = icmp eq i32 %80, 16
br i1 %81, label %82, label %85
82: ; preds = %79
%83 = load i32, i32* %11
%84 = sub nsw i32 %83, 2
store i32 %84, i32* %11
br label %92
85: ; preds = %79
%86 = load i32, i32* %10
%87 = icmp eq i32 %86, 8
br i1 %87, label %88, label %91
88: ; preds = %85
%89 = load i32, i32* %11
%90 = add nsw i32 %89, -1
store i32 %90, i32* %11
br label %91
91: ; preds = %88, %85
br label %92
92: ; preds = %91, %82
br label %93
93: ; preds = %92, %75
store i32 0, i32* %18
%94 = load i32, i32* %9
%95 = icmp eq i32 %94, 0
br i1 %95, label %96, label %101
96: ; preds = %93
%97 = load i32, i32* %18
%98 = add nsw i32 %97, 1
store i32 %98, i32* %18
%99 = sext i32 %97 to i64
%100 = getelementptr inbounds [36 x i8], [36 x i8]* %16, i64 0, i64 %99
store i8 48, i8* %100
br label %122
101: ; preds = %93
br label %102
102: ; preds = %105, %101
%103 = load i32, i32* %9
%104 = icmp ne i32 %103, 0
br i1 %104, label %105, label %121
105: ; preds = %102
%106 = load i8*, i8** %17
%107 = load i32, i32* %9
%108 = load i32, i32* %10
%109 = call { i32, i32 } asm "divl $4", "={ax},={dx},0,1,r,~{dirflag},~{fpsr},~{flags}"(i32 %107, i32 0, i32 %108)
%110 = extractvalue { i32, i32 } %109, 0
%111 = extractvalue { i32, i32 } %109, 1
store i32 %110, i32* %9
store i32 %111, i32* %19
%112 = load i32, i32* %19
store i32 %112, i32* %20
%113 = load i32, i32* %20
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %106, i64 %114
%116 = load i8, i8* %115
%117 = load i32, i32* %18
%118 = add nsw i32 %117, 1
store i32 %118, i32* %18
%119 = sext i32 %117 to i64
%120 = getelementptr inbounds [36 x i8], [36 x i8]* %16, i64 0, i64 %119
store i8 %116, i8* %120
br label %102
121: ; preds = %102
br label %122
122: ; preds = %121, %96
%123 = load i32, i32* %18
%124 = load i32, i32* %12
%125 = icmp sgt i32 %123, %124
br i1 %125, label %126, label %128
126: ; preds = %122
%127 = load i32, i32* %18
store i32 %127, i32* %12
br label %128
128: ; preds = %126, %122
%129 = load i32, i32* %12
%130 = load i32, i32* %11
%131 = sub nsw i32 %130, %129
store i32 %131, i32* %11
%132 = load i32, i32* %13
%133 = and i32 %132, 17
%134 = icmp ne i32 %133, 0
br i1 %134, label %144, label %135
135: ; preds = %128
br label %136
136: ; preds = %140, %135
%137 = load i32, i32* %11
%138 = add nsw i32 %137, -1
store i32 %138, i32* %11
%139 = icmp sgt i32 %137, 0
br i1 %139, label %140, label %143
140: ; preds = %136
%141 = load i8*, i8** %8
%142 = getelementptr inbounds i8, i8* %141, i32 1
store i8* %142, i8** %8
store i8 32, i8* %141
br label %136
143: ; preds = %136
br label %144
144: ; preds = %143, %128
%145 = load i8, i8* %15
%146 = icmp ne i8 %145, 0
br i1 %146, label %147, label %151
147: ; preds = %144
%148 = load i8, i8* %15
%149 = load i8*, i8** %8
%150 = getelementptr inbounds i8, i8* %149, i32 1
store i8* %150, i8** %8
store i8 %148, i8* %149
br label %151
151: ; preds = %147, %144
%152 = load i32, i32* %13
%153 = and i32 %152, 32
%154 = icmp ne i32 %153, 0
br i1 %154, label %155, label %174
155: ; preds = %151
%156 = load i32, i32* %10
%157 = icmp eq i32 %156, 8
br i1 %157, label %158, label %161
158: ; preds = %155
%159 = load i8*, i8** %8
%160 = getelementptr inbounds i8, i8* %159, i32 1
store i8* %160, i8** %8
store i8 48, i8* %159
br label %173
161: ; preds = %155
%162 = load i32, i32* %10
%163 = icmp eq i32 %162, 16
br i1 %163, label %164, label %172
164: ; preds = %161
%165 = load i8*, i8** %8
%166 = getelementptr inbounds i8, i8* %165, i32 1
store i8* %166, i8** %8
store i8 48, i8* %165
%167 = load i8*, i8** %17
%168 = getelementptr inbounds i8, i8* %167, i64 33
%169 = load i8, i8* %168
%170 = load i8*, i8** %8
%171 = getelementptr inbounds i8, i8* %170, i32 1
store i8* %171, i8** %8
store i8 %169, i8* %170
br label %172
172: ; preds = %164, %161
br label %173
173: ; preds = %172, %158
br label %174
174: ; preds = %173, %151
%175 = load i32, i32* %13
%176 = and i32 %175, 16
%177 = icmp ne i32 %176, 0
br i1 %177, label %188, label %178
178: ; preds = %174
br label %179
179: ; preds = %183, %178
%180 = load i32, i32* %11
%181 = add nsw i32 %180, -1
store i32 %181, i32* %11
%182 = icmp sgt i32 %180, 0
br i1 %182, label %183, label %187
183: ; preds = %179
%184 = load i8, i8* %14
%185 = load i8*, i8** %8
%186 = getelementptr inbounds i8, i8* %185, i32 1
store i8* %186, i8** %8
store i8 %184, i8* %185
br label %179
187: ; preds = %179
br label %188
188: ; preds = %187, %174
br label %189
189: ; preds = %194, %188
%190 = load i32, i32* %18
%191 = load i32, i32* %12
%192 = add nsw i32 %191, -1
store i32 %192, i32* %12
%193 = icmp slt i32 %190, %191
br i1 %193, label %194, label %197
194: ; preds = %189
%195 = load i8*, i8** %8
%196 = getelementptr inbounds i8, i8* %195, i32 1
store i8* %196, i8** %8
store i8 48, i8* %195
br label %189
197: ; preds = %189
br label %198
198: ; preds = %202, %197
%199 = load i32, i32* %18
%200 = add nsw i32 %199, -1
store i32 %200, i32* %18
%201 = icmp sgt i32 %199, 0
br i1 %201, label %202, label %209
202: ; preds = %198
%203 = load i32, i32* %18
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds [36 x i8], [36 x i8]* %16, i64 0, i64 %204
%206 = load i8, i8* %205
%207 = load i8*, i8** %8
%208 = getelementptr inbounds i8, i8* %207, i32 1
store i8* %208, i8** %8
store i8 %206, i8* %207
br label %198
209: ; preds = %198
br label %210
210: ; preds = %214, %209
%211 = load i32, i32* %11
%212 = add nsw i32 %211, -1
store i32 %212, i32* %11
%213 = icmp sgt i32 %211, 0
br i1 %213, label %214, label %217
214: ; preds = %210
%215 = load i8*, i8** %8
%216 = getelementptr inbounds i8, i8* %215, i32 1
store i8* %216, i8** %8
store i8 32, i8* %215
br label %210
217: ; preds = %210
%218 = load i8*, i8** %8
store i8* %218, i8** %7
br label %219
219: ; preds = %217, %38
%220 = load i8*, i8** %7
ret i8* %220
}

LLVM IR (-O2):
@.str = [37 x i8] c"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\00"
@.str.1 = [37 x i8] c"0123456789abcdefghijklmnopqrstuvwxyz\00"
define i8* @number(i8* writeonly %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca [36 x i8]
%8 = getelementptr inbounds [36 x i8], [36 x i8]* %7, i64 0, i64 0
%9 = and i32 %5, 64
%10 = icmp eq i32 %9, 0
%11 = select i1 %10, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0)
%12 = and i32 %5, 16
%13 = icmp eq i32 %12, 0
%14 = and i32 %5, -2
%15 = select i1 %13, i32 %5, i32 %14
%16 = add i32 %2, -37
%17 = icmp ult i32 %16, -35
br i1 %17, label %188, label %18
18: ; preds = %6
%19 = and i32 %15, 1
%20 = icmp eq i32 %19, 0
%21 = select i1 %20, i8 32, i8 48
%22 = and i32 %15, 2
%23 = icmp ne i32 %22, 0
%24 = icmp slt i32 %1, 0
%25 = and i1 %24, %23
br i1 %25, label %26, label %28
26: ; preds = %18
%27 = sub nsw i32 0, %1
br label %35
28: ; preds = %18
%29 = and i32 %15, 4
%30 = icmp eq i32 %29, 0
%31 = trunc i32 %15 to i8
%32 = shl i8 %31, 2
%33 = and i8 %32, 32
%34 = select i1 %30, i8 %33, i8 43
br label %35
35: ; preds = %28, %26
%36 = phi i32 [ %27, %26 ], [ %1, %28 ]
%37 = phi i8 [ 45, %26 ], [ %34, %28 ]
%38 = icmp eq i8 %37, 0
%39 = xor i1 %38, true
%40 = sext i1 %39 to i32
%41 = add nsw i32 %40, %3
%42 = and i32 %15, 32
%43 = icmp eq i32 %42, 0
br i1 %43, label %49, label %44
44: ; preds = %35
switch i32 %2, label %49 [
i32 16, label %45
i32 8, label %47
]
45: ; preds = %44
%46 = add nsw i32 %41, -2
br label %49
47: ; preds = %44
%48 = add nsw i32 %41, -1
br label %49
49: ; preds = %44, %45, %47, %35
%50 = phi i32 [ %46, %45 ], [ %48, %47 ], [ %41, %35 ], [ %41, %44 ]
%51 = icmp eq i32 %36, 0
br i1 %51, label %52, label %53
52: ; preds = %49
store i8 48, i8* %8
br label %67
53: ; preds = %49, %53
%54 = phi i64 [ %62, %53 ], [ 0, %49 ]
%55 = phi i32 [ %57, %53 ], [ %36, %49 ]
%56 = tail call { i32, i32 } asm "divl $4", "={ax},={dx},0,1,r,~{dirflag},~{fpsr},~{flags}"(i32 %55, i32 0, i32 %2)
%57 = extractvalue { i32, i32 } %56, 0
%58 = extractvalue { i32, i32 } %56, 1
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8, i8* %11, i64 %59
%61 = load i8, i8* %60
%62 = add nuw i64 %54, 1
%63 = getelementptr inbounds [36 x i8], [36 x i8]* %7, i64 0, i64 %54
store i8 %61, i8* %63
%64 = icmp eq i32 %57, 0
br i1 %64, label %65, label %53
65: ; preds = %53
%66 = trunc i64 %62 to i32
br label %67
67: ; preds = %65, %52
%68 = phi i32 [ 1, %52 ], [ %66, %65 ]
%69 = icmp sgt i32 %68, %4
%70 = select i1 %69, i32 %68, i32 %4
%71 = sub nsw i32 %50, %70
%72 = and i32 %15, 17
%73 = icmp eq i32 %72, 0
br i1 %73, label %74, label %81
74: ; preds = %67
%75 = add i32 %71, -1
%76 = icmp sgt i32 %71, 0
br i1 %76, label %77, label %81
77: ; preds = %74
%78 = zext i32 %75 to i64
%79 = add nuw nsw i64 %78, 1
%80 = getelementptr i8, i8* %0, i64 %79
br label %81
81: ; preds = %77, %74, %67
%82 = phi i32 [ %71, %67 ], [ %75, %74 ], [ -1, %77 ]
%83 = phi i8* [ %0, %67 ], [ %0, %74 ], [ %80, %77 ]
br i1 %38, label %86, label %84
84: ; preds = %81
%85 = getelementptr inbounds i8, i8* %83, i64 1
store i8 %37, i8* %83
br label %86
86: ; preds = %84, %81
%87 = phi i8* [ %85, %84 ], [ %83, %81 ]
br i1 %43, label %95, label %88
88: ; preds = %86
switch i32 %2, label %95 [
i32 8, label %89
i32 16, label %91
]
89: ; preds = %88
%90 = getelementptr inbounds i8, i8* %87, i64 1
store i8 48, i8* %87
br label %95
91: ; preds = %88
%92 = getelementptr inbounds i8, i8* %87, i64 1
store i8 48, i8* %87
%93 = select i1 %10, i8 88, i8 120
%94 = getelementptr inbounds i8, i8* %87, i64 2
store i8 %93, i8* %92
br label %95
95: ; preds = %88, %89, %91, %86
%96 = phi i8* [ %90, %89 ], [ %94, %91 ], [ %87, %86 ], [ %87, %88 ]
%97 = and i32 %15, 16
%98 = icmp eq i32 %97, 0
br i1 %98, label %99, label %107
99: ; preds = %95
%100 = add i32 %82, -1
%101 = icmp sgt i32 %82, 0
br i1 %101, label %102, label %107
102: ; preds = %99
%103 = zext i32 %82 to i64
%104 = zext i32 %100 to i64
%105 = add nuw nsw i64 %104, 1
%106 = getelementptr i8, i8* %96, i64 %105
br label %107
107: ; preds = %102, %99, %95
%108 = phi i32 [ %82, %95 ], [ %100, %99 ], [ -1, %102 ]
%109 = phi i8* [ %96, %95 ], [ %96, %99 ], [ %106, %102 ]
%110 = icmp slt i32 %68, %4
br i1 %110, label %111, label %117
111: ; preds = %107
%112 = xor i32 %68, -1
%113 = add i32 %70, %112
%114 = zext i32 %113 to i64
%115 = add nuw nsw i64 %114, 1
%116 = getelementptr i8, i8* %109, i64 %115
br label %117
117: ; preds = %107, %111
%118 = phi i8* [ %109, %107 ], [ %116, %111 ]
%119 = zext i32 %68 to i64
%120 = call i32 @llvm.smin.i32(i32 %68, i32 1)
%121 = sub i32 %68, %120
%122 = zext i32 %121 to i64
%123 = add nuw nsw i64 %122, 1
%124 = icmp ult i32 %121, 31
br i1 %124, label %166, label %125
125: ; preds = %117
%126 = call i32 @llvm.smin.i32(i32 %68, i32 1)
%127 = sub i32 %68, %126
%128 = zext i32 %127 to i64
%129 = add nuw nsw i64 %128, 1
%130 = getelementptr i8, i8* %118, i64 %129
%131 = add i32 %68, -1
%132 = zext i32 %131 to i64
%133 = sub nsw i64 %132, %128
%134 = getelementptr [36 x i8], [36 x i8]* %7, i64 0, i64 %133
%135 = add nuw nsw i64 %132, 1
%136 = getelementptr [36 x i8], [36 x i8]* %7, i64 0, i64 %135
%137 = icmp ult i8* %118, %136
%138 = icmp ult i8* %134, %130
%139 = and i1 %137, %138
br i1 %139, label %166, label %140
140: ; preds = %125
%141 = and i64 %123, 8589934560
%142 = sub nsw i64 %119, %141
%143 = getelementptr i8, i8* %118, i64 %141
br label %144
144: ; preds = %144, %140
%145 = phi i64 [ 0, %140 ], [ %162, %144 ]
%146 = getelementptr i8, i8* %118, i64 %145
%147 = xor i64 %145, -1
%148 = add i64 %147, %119
%149 = and i64 %148, 4294967295
%150 = getelementptr inbounds [36 x i8], [36 x i8]* %7, i64 0, i64 %149
%151 = getelementptr inbounds i8, i8* %150, i64 -15
%152 = bitcast i8* %151 to <16 x i8>*
%153 = load <16 x i8>, <16 x i8>* %152
%154 = shufflevector <16 x i8> %153, <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>
%155 = getelementptr inbounds i8, i8* %150, i64 -31
%156 = bitcast i8* %155 to <16 x i8>*
%157 = load <16 x i8>, <16 x i8>* %156
%158 = shufflevector <16 x i8> %157, <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>
%159 = bitcast i8* %146 to <16 x i8>*
store <16 x i8> %154, <16 x i8>* %159
%160 = getelementptr i8, i8* %146, i64 16
%161 = bitcast i8* %160 to <16 x i8>*
store <16 x i8> %158, <16 x i8>* %161
%162 = add nuw i64 %145, 32
%163 = icmp eq i64 %162, %141
br i1 %163, label %164, label %144
164: ; preds = %144
%165 = icmp eq i64 %123, %141
br i1 %165, label %169, label %166
166: ; preds = %125, %117, %164
%167 = phi i64 [ %119, %125 ], [ %119, %117 ], [ %142, %164 ]
%168 = phi i8* [ %118, %125 ], [ %118, %117 ], [ %143, %164 ]
br label %178
169: ; preds = %178, %164
%170 = phi i8* [ %143, %164 ], [ %185, %178 ]
%171 = icmp sgt i32 %108, 0
br i1 %171, label %172, label %188
172: ; preds = %169
%173 = zext i32 %108 to i64
%174 = add nsw i32 %108, -1
%175 = zext i32 %174 to i64
%176 = add nuw nsw i64 %175, 1
%177 = getelementptr i8, i8* %170, i64 %176
br label %188
178: ; preds = %166, %178
%179 = phi i64 [ %181, %178 ], [ %167, %166 ]
%180 = phi i8* [ %185, %178 ], [ %168, %166 ]
%181 = add nsw i64 %179, -1
%182 = and i64 %181, 4294967295
%183 = getelementptr inbounds [36 x i8], [36 x i8]* %7, i64 0, i64 %182
%184 = load i8, i8* %183
%185 = getelementptr inbounds i8, i8* %180, i64 1
store i8 %184, i8* %180
%186 = trunc i64 %179 to i32
%187 = icmp sgt i32 %186, 1
br i1 %187, label %178, label %169
188: ; preds = %172, %169, %6
%189 = phi i8* [ null, %6 ], [ %170, %169 ], [ %177, %172 ]
ret i8* %189
}