char *number(char *str, unsigned long long num, int base, int size,
             int precision, int type) {
  char c, sign, tmp[66];
  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' : ' ';
  sign = 0;
  if (type & 2) {
    if ((signed long long)num < 0) {
      sign = '-';
      num = -(signed long long)num;
      size--;
    } else if (type & 4) {
      sign = '+';
      size--;
    } else if (type & 8) {
      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[({
        unsigned int __base = (base);
        unsigned int __rem;
        (void)(((typeof((num)) *)0) == ((unsigned long long *)0));
        if (((num) >> 32) == 0) {
          __rem = (unsigned int)(num) % __base;
          (num) = (unsigned int)(num) / __base;
        } else
          __rem = __div64_32(&(num), __base);
        __rem;
      })];
    }
  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
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
lea    0xec8(%rip),%rax
mov    %rax,-0x78(%rbp)
mov    -0x28(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     1156 <number+0x46>
lea    0xed3(%rip),%rax
mov    %rax,-0x78(%rbp)
mov    -0x28(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     116e <number+0x5e>
mov    -0x28(%rbp),%eax
and    $0xfffffffe,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jl     1182 <number+0x72>
cmpl   $0x24,-0x1c(%rbp)
jle    118f <number+0x7f>
movq   $0x0,-0x8(%rbp)
jmp    1510 <number+0x400>
mov    -0x28(%rbp),%edx
and    $0x1,%edx
mov    $0x20,%eax
mov    $0x30,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,-0x29(%rbp)
movb   $0x0,-0x2a(%rbp)
mov    -0x28(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     122e <number+0x11e>
cmpq   $0x0,-0x18(%rbp)
jge    11e2 <number+0xd2>
movb   $0x2d,-0x2a(%rbp)
xor    %eax,%eax
sub    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1229 <number+0x119>
mov    -0x28(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     1203 <number+0xf3>
movb   $0x2b,-0x2a(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1224 <number+0x114>
mov    -0x28(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     121f <number+0x10f>
movb   $0x20,-0x2a(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1224 <number+0x114>
jmp    1229 <number+0x119>
jmp    122e <number+0x11e>
mov    -0x28(%rbp),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     1272 <number+0x162>
cmpl   $0x10,-0x1c(%rbp)
jne    1255 <number+0x145>
mov    -0x20(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    126d <number+0x15d>
cmpl   $0x8,-0x1c(%rbp)
jne    1268 <number+0x158>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    126d <number+0x15d>
jmp    1272 <number+0x162>
movl   $0x0,-0x7c(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    129b <number+0x18b>
mov    -0x7c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x7c(%rbp)
cltq
movb   $0x30,-0x70(%rbp,%rax,1)
jmp    133c <number+0x22c>
jmp    12a0 <number+0x190>
cmpq   $0x0,-0x18(%rbp)
je     1337 <number+0x227>
mov    -0x78(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x20,%rax
cmp    $0x0,%rax
jne    12f1 <number+0x1e1>
mov    -0x18(%rbp),%rax
xor    %edx,%edx
divl   -0x80(%rbp)
mov    %edx,-0x84(%rbp)
mov    -0x18(%rbp),%rax
xor    %edx,%edx
divl   -0x80(%rbp)
mov    %eax,%eax
mov    %rax,-0x18(%rbp)
jmp    1305 <number+0x1f5>
mov    -0x80(%rbp),%esi
lea    -0x18(%rbp),%rdi
mov    $0x0,%al
call   1030 <__div64_32@plt>
mov    %eax,-0x84(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x84(%rbp),%ecx
mov    %ecx,-0x88(%rbp)
mov    -0x88(%rbp),%ecx
mov    (%rax,%rcx,1),%cl
mov    -0x7c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x7c(%rbp)
cltq
mov    %cl,-0x70(%rbp,%rax,1)
jmp    12a0 <number+0x190>
jmp    133c <number+0x22c>
mov    -0x7c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    134e <number+0x23e>
mov    -0x7c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x28(%rbp),%eax
and    $0x11,%eax
cmp    $0x0,%eax
jne    139d <number+0x28d>
jmp    136d <number+0x25d>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    1398 <number+0x288>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x20,(%rax)
jmp    136d <number+0x25d>
jmp    139d <number+0x28d>
cmpb   $0x0,-0x2a(%rbp)
je     13bb <number+0x2ab>
mov    -0x2a(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
and    $0x20,%eax
cmp    $0x0,%eax
je     1429 <number+0x319>
cmpl   $0x8,-0x1c(%rbp)
jne    13eb <number+0x2db>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
jmp    1424 <number+0x314>
cmpl   $0x10,-0x1c(%rbp)
jne    141f <number+0x30f>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
mov    -0x78(%rbp),%rax
mov    0x21(%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1424 <number+0x314>
jmp    1429 <number+0x319>
mov    -0x28(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
jne    146f <number+0x35f>
jmp    143d <number+0x32d>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    146a <number+0x35a>
mov    -0x29(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    143d <number+0x32d>
jmp    146f <number+0x35f>
jmp    1474 <number+0x364>
mov    -0x7c(%rbp),%eax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x24(%rbp)
cmp    %ecx,%eax
jge    14a1 <number+0x391>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
jmp    1474 <number+0x364>
jmp    14a6 <number+0x396>
mov    -0x7c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x7c(%rbp)
cmp    $0x0,%eax
jle    14d8 <number+0x3c8>
movslq -0x7c(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    14a6 <number+0x396>
jmp    14dd <number+0x3cd>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    1508 <number+0x3f8>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x20,(%rax)
jmp    14dd <number+0x3cd>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<number>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rcx,(%rsp)
mov    %edx,%ebp
mov    %rsi,0x10(%rsp)
test   $0x40,%r9b
lea    0xebc(%rip),%rcx
lea    0xeda(%rip),%r15
cmove  %rcx,%r15
mov    %r9d,%r12d
and    $0xfffffffe,%r12d
test   $0x10,%r9b
cmove  %r9d,%r12d
lea    -0x25(%rbp),%ecx
cmp    $0xffffffdd,%ecx
jae    116d <number+0x4d>
xor    %ebx,%ebx
jmp    1415 <number+0x2f5>
mov    %rsi,%rax
mov    %rdi,%r13
mov    $0x1,%dl
test   $0x2,%r12b
jne    118b <number+0x6b>
movl   $0x0,0x8(%rsp)
test   $0x20,%r12b
je     11f9 <number+0xd9>
jmp    11db <number+0xbb>
test   %rax,%rax
js     11ab <number+0x8b>
test   $0x4,%r12b
jne    11c2 <number+0xa2>
test   $0x8,%r12b
je     117b <number+0x5b>
mov    (%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,(%rsp)
mov    $0x20,%cl
jmp    11cf <number+0xaf>
neg    %rax
mov    %rax,0x10(%rsp)
mov    (%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,(%rsp)
mov    $0x2d,%cl
jmp    11cf <number+0xaf>
mov    (%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,(%rsp)
mov    $0x2b,%cl
mov    %ecx,0x8(%rsp)
xor    %edx,%edx
test   $0x20,%r12b
je     11f9 <number+0xd9>
cmp    $0x8,%ebp
je     11ee <number+0xce>
cmp    $0x10,%ebp
jne    11f9 <number+0xd9>
mov    (%rsp),%rcx
add    $0xfffffffe,%ecx
jmp    11f5 <number+0xd5>
mov    (%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,(%rsp)
test   %rax,%rax
mov    %r8d,0xc(%rsp)
mov    %r9d,0x18(%rsp)
mov    %edx,0x1c(%rsp)
je     1267 <number+0x147>
lea    0x10(%rsp),%rbx
xor    %r14d,%r14d
jmp    1248 <number+0x128>
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <__div64_32@plt>
mov    %eax,%edx
mov    0x10(%rsp),%rax
mov    %edx,%ecx
movzbl (%r15,%rcx,1),%ecx
mov    %cl,0x20(%rsp,%r14,1)
add    $0x1,%r14
test   %rax,%rax
je     125c <number+0x13c>
mov    %rax,%rcx
shr    $0x20,%rcx
jne    1220 <number+0x100>
xor    %edx,%edx
div    %ebp
mov    %rax,0x10(%rsp)
jmp    1233 <number+0x113>
mov    (%rsp),%r15
mov    0xc(%rsp),%r8d
jmp    1276 <number+0x156>
movb   $0x30,0x20(%rsp)
mov    $0x1,%r14d
mov    (%rsp),%r15
cmp    %r8d,%r14d
mov    %r8d,%ebx
cmovg  %r14d,%ebx
sub    %ebx,%r15d
test   $0x11,%r12b
je     1298 <number+0x178>
cmpb   $0x0,0x1c(%rsp)
je     12cd <number+0x1ad>
test   $0x20,%r12b
jne    12df <number+0x1bf>
jmp    12f2 <number+0x1d2>
lea    -0x1(%r15),%eax
test   %r15d,%r15d
jle    14e7 <number+0x3c7>
mov    %eax,%r15d
lea    0x1(%r15),%rdx
mov    %r13,%rdi
mov    $0x20,%esi
call   1030 <memset@plt>
add    %r15,%r13
add    $0x1,%r13
mov    $0xffffffff,%r15d
cmpb   $0x0,0x1c(%rsp)
jne    1290 <number+0x170>
mov    0x8(%rsp),%eax
mov    %al,0x0(%r13)
add    $0x1,%r13
test   $0x20,%r12b
je     12f2 <number+0x1d2>
cmp    $0x10,%ebp
je     1332 <number+0x212>
cmp    $0x8,%ebp
jne    12f2 <number+0x1d2>
movb   $0x30,0x0(%r13)
add    $0x1,%r13
test   $0x10,%r12b
jne    1352 <number+0x232>
lea    -0x1(%r15),%ebp
test   %r15d,%r15d
jle    132d <number+0x20d>
and    $0x1,%r12b
shl    $0x4,%r12b
or     $0x20,%r12b
mov    %r15d,%edx
movzbl %r12b,%esi
mov    %r13,%rdi
call   1030 <memset@plt>
mov    %ebp,%eax
add    %rax,%r13
add    $0x1,%r13
mov    $0xffffffff,%r15d
jmp    1352 <number+0x232>
mov    %ebp,%r15d
jmp    1352 <number+0x232>
testb  $0x40,0x18(%rsp)
sete   %al
movb   $0x30,0x0(%r13)
shl    $0x5,%al
or     $0x58,%al
mov    %al,0x1(%r13)
add    $0x2,%r13
test   $0x10,%r12b
je     12f8 <number+0x1d8>
cmp    0xc(%rsp),%r14d
jge    1378 <number+0x258>
mov    %r14d,%eax
not    %eax
add    %eax,%ebx
lea    0x1(%rbx),%rdx
mov    %r13,%rdi
mov    $0x30,%esi
call   1030 <memset@plt>
add    %rbx,%r13
add    $0x1,%r13
mov    %r14d,%eax
test   %r14d,%r14d
mov    $0x1,%edx
mov    $0x1,%esi
cmovle %r14d,%esi
mov    %r14d,%ecx
sub    %esi,%ecx
cmp    $0x1f,%ecx
jb     13cc <number+0x2ac>
test   %r14d,%r14d
cmovle %r14d,%edx
lea    -0x1(%r14),%esi
lea    0x20(%rsp),%rdi
add    %rsi,%rdi
add    $0x1,%rdi
cmp    %rdi,%r13
jae    1427 <number+0x307>
sub    %edx,%r14d
lea    (%r14,%r13,1),%rdx
add    $0x1,%rdx
sub    %r14,%rsi
add    %rsp,%rsi
add    $0x20,%rsi
cmp    %rdx,%rsi
jae    1427 <number+0x307>
mov    %rax,%rdx
mov    %r13,%rbx
lea    0x1(%rdx),%eax
add    $0xffffffff,%edx
lea    (%rsp,%rdx,1),%rcx
add    $0x20,%rcx
movzbl (%rcx),%edx
mov    %dl,(%rbx)
add    $0x1,%rbx
add    $0xffffffff,%eax
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%eax
jg     13e0 <number+0x2c0>
test   %r15d,%r15d
jle    1415 <number+0x2f5>
mov    %r15d,%edx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1030 <memset@plt>
add    $0xffffffff,%r15d
add    %r15,%rbx
add    $0x1,%rbx
mov    %rbx,%rax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%rcx
mov    %rcx,%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 0x1(%rsp,%rbp,1),%xmm1
movdqu 0x11(%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    1450 <number+0x330>
cmp    %rsi,%rcx
jne    13d2 <number+0x2b2>
jmp    13f5 <number+0x2d5>
mov    %eax,%r15d
cmpb   $0x0,0x1c(%rsp)
jne    1290 <number+0x170>
jmp    12cd <number+0x1ad>

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

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