char *number(char *str, long num, int base, int size, int precision, int type) {
  static const char digits[16] = "0123456789ABCDEF";
  static const char human_tab[] = "BKMGTP";
  char tmp[66];
  char c, sign, locase;
  int i;
  unsigned int human_level = 0;
  locase = (type & 32);
  if (type & 128) {
    while (num > 1024) {
      num /= 1024;
      human_level++;
    }
  }
  if (type & 16)
    type &= ~1;
  if (base < 2 || base > 36)
    return (0);
  c = (type & 1) ? '0' : ' ';
  sign = 0;
  if (type & 2) {
    if (num < 0) {
      sign = '-';
      num = -num;
      size--;
    } else if (type & 4) {
      sign = '+';
      size--;
    } else if (type & 8) {
      sign = ' ';
      size--;
    }
  }
  if (type & 64) {
    if (base == 16)
      size -= 2;
    else if (base == 8)
      size--;
  }
  i = 0;
  if (type & 128)
    tmp[i++] = human_tab[human_level];
  if (num == 0)
    tmp[i++] = '0';
  else
    while (num != 0)
      tmp[i++] = (digits[({
                    int __res;
                    __res = ((unsigned long)num) % (unsigned)base;
                    num = ((unsigned long)num) / (unsigned)base;
                    __res;
                  })] |
                  locase);
  if (i > precision)
    precision = i;
  size -= precision;
  if (!(type & (1 + 16)))
    while (size-- > 0)
      *str++ = ' ';
  if (sign)
    *str++ = sign;
  if (type & 64) {
    if (base == 8)
      *str++ = '0';
    else if (base == 16) {
      *str++ = '0';
      *str++ = ('X' | locase);
    }
  }
  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    $0x10,%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)
movl   $0x0,-0x7c(%rbp)
mov    -0x28(%rbp),%eax
and    $0x20,%eax
mov    %al,-0x73(%rbp)
mov    -0x28(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     1177 <number+0x77>
jmp    1144 <number+0x44>
cmpq   $0x400,-0x18(%rbp)
jle    1172 <number+0x72>
mov    -0x18(%rbp),%rax
mov    $0x400,%ecx
cqto
idiv   %rcx
mov    %rax,-0x18(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1144 <number+0x44>
jmp    1177 <number+0x77>
mov    -0x28(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     118f <number+0x8f>
mov    -0x28(%rbp),%eax
and    $0xfffffffe,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jl     11a3 <number+0xa3>
cmpl   $0x24,-0x1c(%rbp)
jle    11b0 <number+0xb0>
movq   $0x0,-0x8(%rbp)
jmp    1532 <number+0x432>
mov    -0x28(%rbp),%edx
and    $0x1,%edx
mov    $0x20,%eax
mov    $0x30,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,-0x71(%rbp)
movb   $0x0,-0x72(%rbp)
mov    -0x28(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     124f <number+0x14f>
cmpq   $0x0,-0x18(%rbp)
jge    1203 <number+0x103>
movb   $0x2d,-0x72(%rbp)
xor    %eax,%eax
sub    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    124a <number+0x14a>
mov    -0x28(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     1224 <number+0x124>
movb   $0x2b,-0x72(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1245 <number+0x145>
mov    -0x28(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1240 <number+0x140>
movb   $0x20,-0x72(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1245 <number+0x145>
jmp    124a <number+0x14a>
jmp    124f <number+0x14f>
mov    -0x28(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     1293 <number+0x193>
cmpl   $0x10,-0x1c(%rbp)
jne    1276 <number+0x176>
mov    -0x20(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    128e <number+0x18e>
cmpl   $0x8,-0x1c(%rbp)
jne    1289 <number+0x189>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    128e <number+0x18e>
jmp    1293 <number+0x193>
movl   $0x0,-0x78(%rbp)
mov    -0x28(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     12cb <number+0x1cb>
mov    -0x7c(%rbp),%eax
mov    %eax,%ecx
lea    0xd59(%rip),%rax
mov    (%rax,%rcx,1),%cl
mov    -0x78(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x78(%rbp)
cltq
mov    %cl,-0x70(%rbp,%rax,1)
cmpq   $0x0,-0x18(%rbp)
jne    12ed <number+0x1ed>
mov    -0x78(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x78(%rbp)
cltq
movb   $0x30,-0x70(%rbp,%rax,1)
jmp    135c <number+0x25c>
jmp    12f2 <number+0x1f2>
cmpq   $0x0,-0x18(%rbp)
je     1357 <number+0x257>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %edx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x18(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x84(%rbp)
movslq -0x84(%rbp),%rcx
lea    0xccb(%rip),%rax
movsbl (%rax,%rcx,1),%eax
movsbl -0x73(%rbp),%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x78(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x78(%rbp)
cltq
mov    %cl,-0x70(%rbp,%rax,1)
jmp    12f2 <number+0x1f2>
jmp    135c <number+0x25c>
mov    -0x78(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    136e <number+0x26e>
mov    -0x78(%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    13bd <number+0x2bd>
jmp    138d <number+0x28d>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    13b8 <number+0x2b8>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x20,(%rax)
jmp    138d <number+0x28d>
jmp    13bd <number+0x2bd>
cmpb   $0x0,-0x72(%rbp)
je     13db <number+0x2db>
mov    -0x72(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x28(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     144b <number+0x34b>
cmpl   $0x8,-0x1c(%rbp)
jne    140b <number+0x30b>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
jmp    1446 <number+0x346>
cmpl   $0x10,-0x1c(%rbp)
jne    1441 <number+0x341>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
movsbl -0x73(%rbp),%eax
or     $0x58,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1446 <number+0x346>
jmp    144b <number+0x34b>
mov    -0x28(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
jne    1491 <number+0x391>
jmp    145f <number+0x35f>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    148c <number+0x38c>
mov    -0x71(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    145f <number+0x35f>
jmp    1491 <number+0x391>
jmp    1496 <number+0x396>
mov    -0x78(%rbp),%eax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x24(%rbp)
cmp    %ecx,%eax
jge    14c3 <number+0x3c3>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
jmp    1496 <number+0x396>
jmp    14c8 <number+0x3c8>
mov    -0x78(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x78(%rbp)
cmp    $0x0,%eax
jle    14fa <number+0x3fa>
movslq -0x78(%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    14c8 <number+0x3c8>
jmp    14ff <number+0x3ff>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    152a <number+0x42a>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x20,(%rax)
jmp    14ff <number+0x3ff>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x10,%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    %r9d,%ebp
mov    %ecx,%r14d
mov    %edx,%r9d
mov    %rdi,%r13
xor    %eax,%eax
cmp    $0x401,%rsi
jl     1173 <number+0x63>
mov    %ebp,%ecx
and    $0x80,%ecx
je     1173 <number+0x63>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rsi,%rcx
add    $0x3ff,%rsi
test   %rcx,%rcx
cmovns %rcx,%rsi
sar    $0xa,%rsi
add    $0x1,%eax
cmp    $0x1003ff,%rcx
jg     1150 <number+0x40>
mov    %eax,%eax
mov    %ebp,%ebx
and    $0xfffffffe,%ebx
test   $0x10,%bpl
cmove  %ebp,%ebx
lea    -0x25(%r9),%ecx
cmp    $0xffffffdd,%ecx
jae    118f <number+0x7f>
xor    %ebx,%ebx
jmp    1415 <number+0x305>
mov    $0x1,%r10b
test   $0x2,%bl
jne    11a1 <number+0x91>
xor    %r11d,%r11d
test   $0x40,%bl
je     11ea <number+0xda>
jmp    11d4 <number+0xc4>
test   %rsi,%rsi
js     11b9 <number+0xa9>
test   $0x4,%bl
jne    11c5 <number+0xb5>
test   $0x8,%bl
je     1197 <number+0x87>
add    $0xffffffff,%r14d
mov    $0x20,%r11b
jmp    11cc <number+0xbc>
neg    %rsi
add    $0xffffffff,%r14d
mov    $0x2d,%r11b
jmp    11cc <number+0xbc>
add    $0xffffffff,%r14d
mov    $0x2b,%r11b
xor    %r10d,%r10d
test   $0x40,%bl
je     11ea <number+0xda>
cmp    $0x8,%r9d
je     11e6 <number+0xd6>
cmp    $0x10,%r9d
jne    11ea <number+0xda>
add    $0xfffffffe,%r14d
jmp    11ea <number+0xda>
add    $0xffffffff,%r14d
xor    %r15d,%r15d
test   $0x80,%bl
je     1206 <number+0xf6>
lea    0xe17(%rip),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,0x20(%rsp)
mov    $0x1,%r15d
and    $0x20,%bpl
test   %rsi,%rsi
je     1251 <number+0x141>
mov    %r9d,%ecx
mov    %r15d,%r15d
lea    0xde4(%rip),%rdi
jmp    1240 <number+0x130>
xchg   %ax,%ax
mov    %rsi,%rax
xor    %edx,%edx
div    %rcx
movzbl (%rdx,%rdi,1),%edx
or     %bpl,%dl
mov    %dl,0x20(%rsp,%r15,1)
add    $0x1,%r15
cmp    %rcx,%rsi
mov    %rax,%rsi
jb     125d <number+0x14d>
mov    %rsi,%rax
shr    $0x20,%rax
jne    1220 <number+0x110>
mov    %esi,%eax
xor    %edx,%edx
div    %ecx
jmp    1228 <number+0x118>
mov    %r15d,%eax
add    $0x1,%r15d
movb   $0x30,0x20(%rsp,%rax,1)
cmp    %r8d,%r15d
mov    %r8d,%r12d
cmovg  %r15d,%r12d
sub    %r12d,%r14d
test   $0x11,%bl
je     127b <number+0x16b>
test   %r10b,%r10b
je     12d6 <number+0x1c6>
test   $0x40,%bl
jne    12e3 <number+0x1d3>
jmp    12f8 <number+0x1e8>
lea    -0x1(%r14),%eax
test   %r14d,%r14d
jle    14e7 <number+0x3d7>
mov    %eax,%r14d
lea    0x1(%r14),%rdx
mov    %r13,%rdi
mov    $0x20,%esi
mov    %r8d,0x14(%rsp)
mov    %r9,0x18(%rsp)
mov    %r10d,0x10(%rsp)
mov    %r11d,0xc(%rsp)
call   1030 <memset@plt>
mov    0xc(%rsp),%r11d
mov    0x10(%rsp),%r10d
mov    0x18(%rsp),%r9
mov    0x14(%rsp),%r8d
add    %r14,%r13
add    $0x1,%r13
mov    $0xffffffff,%r14d
test   %r10b,%r10b
jne    1274 <number+0x164>
mov    %r11b,0x0(%r13)
add    $0x1,%r13
test   $0x40,%bl
je     12f8 <number+0x1e8>
cmp    $0x10,%r9d
je     1339 <number+0x229>
cmp    $0x8,%r9d
jne    12f8 <number+0x1e8>
movb   $0x30,0x0(%r13)
add    $0x1,%r13
test   $0x10,%bl
jne    134f <number+0x23f>
lea    -0x1(%r14),%ebp
test   %r14d,%r14d
jle    1334 <number+0x224>
and    $0x1,%bl
shl    $0x4,%bl
or     $0x20,%bl
mov    %r14d,%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,%r14d
jmp    134f <number+0x23f>
mov    %ebp,%r14d
jmp    134f <number+0x23f>
movb   $0x30,0x0(%r13)
or     $0x58,%bpl
mov    %bpl,0x1(%r13)
add    $0x2,%r13
test   $0x10,%bl
je     12fd <number+0x1ed>
cmp    %r8d,%r15d
jge    1375 <number+0x265>
mov    %r15d,%eax
not    %eax
add    %eax,%r12d
lea    0x1(%r12),%rdx
mov    %r13,%rdi
mov    $0x30,%esi
call   1030 <memset@plt>
add    %r12,%r13
add    $0x1,%r13
mov    %r15d,%eax
test   %r15d,%r15d
mov    $0x1,%edx
mov    $0x1,%esi
cmovle %r15d,%esi
mov    %r15d,%ecx
sub    %esi,%ecx
cmp    $0x1f,%ecx
jb     13c9 <number+0x2b9>
test   %r15d,%r15d
cmovle %r15d,%edx
lea    -0x1(%r15),%esi
lea    0x20(%rsp),%rdi
add    %rsi,%rdi
add    $0x1,%rdi
cmp    %rdi,%r13
jae    1427 <number+0x317>
sub    %edx,%r15d
lea    (%r15,%r13,1),%rdx
add    $0x1,%rdx
sub    %r15,%rsi
add    %rsp,%rsi
add    $0x20,%rsi
cmp    %rdx,%rsi
jae    1427 <number+0x317>
mov    %rax,%rdx
mov    %r13,%rbx
lea    0x1(%rdx),%eax
add    $0xffffffff,%edx
lea    (%rsp,%rdx,1),%rcx
add    $0x20,%rcx
nopl   (%rax)
movzbl (%rcx),%edx
mov    %dl,(%rbx)
add    $0x1,%rbx
add    $0xffffffff,%eax
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%eax
jg     13e0 <number+0x2d0>
test   %r14d,%r14d
jle    1415 <number+0x305>
mov    %r14d,%edx
mov    %rbx,%rdi
mov    $0x20,%esi
call   1030 <memset@plt>
add    $0xffffffff,%r14d
add    %r14,%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+0x340>
cmp    %rsi,%rcx
jne    13cf <number+0x2bf>
jmp    13f5 <number+0x2e5>
mov    %eax,%r14d
test   %r10b,%r10b
jne    1274 <number+0x164>
jmp    12d6 <number+0x1c6>

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

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