#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
char *number(char *str, long num, int base, int size, int precision, int type) {
  static const char digits[16] = "0123456789ABCDEF";
  char tmp[66];
  char c, sign, locase;
  int i;
  locase = (type & 32);
  if (type & 16)
    type &= ~1;
  if (base < 2 || base > 16)
    return NULL;
  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 (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
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x28(%rbp),%eax
and    $0x20,%eax
mov    %al,-0x73(%rbp)
mov    -0x28(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
je     113b <number+0x3b>
mov    -0x28(%rbp),%eax
and    $0xfffffffe,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x2,-0x1c(%rbp)
jl     114f <number+0x4f>
cmpl   $0x10,-0x1c(%rbp)
jle    115c <number+0x5c>
movq   $0x0,-0x8(%rbp)
jmp    14a7 <number+0x3a7>
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     11fb <number+0xfb>
cmpq   $0x0,-0x18(%rbp)
jge    11af <number+0xaf>
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    11f6 <number+0xf6>
mov    -0x28(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     11d0 <number+0xd0>
movb   $0x2b,-0x72(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    11f1 <number+0xf1>
mov    -0x28(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     11ec <number+0xec>
movb   $0x20,-0x72(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    11f1 <number+0xf1>
jmp    11f6 <number+0xf6>
jmp    11fb <number+0xfb>
mov    -0x28(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     123f <number+0x13f>
cmpl   $0x10,-0x1c(%rbp)
jne    1222 <number+0x122>
mov    -0x20(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    123a <number+0x13a>
cmpl   $0x8,-0x1c(%rbp)
jne    1235 <number+0x135>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    123a <number+0x13a>
jmp    123f <number+0x13f>
movl   $0x0,-0x78(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1268 <number+0x168>
mov    -0x78(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x78(%rbp)
cltq
movb   $0x30,-0x70(%rbp,%rax,1)
jmp    12d1 <number+0x1d1>
jmp    126d <number+0x16d>
cmpq   $0x0,-0x18(%rbp)
je     12cc <number+0x1cc>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %edx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,-0x18(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x80(%rbp)
movslq -0x80(%rbp),%rcx
lea    0xd56(%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    126d <number+0x16d>
jmp    12d1 <number+0x1d1>
mov    -0x78(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    12e3 <number+0x1e3>
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    1332 <number+0x232>
jmp    1302 <number+0x202>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    132d <number+0x22d>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x20,(%rax)
jmp    1302 <number+0x202>
jmp    1332 <number+0x232>
cmpb   $0x0,-0x72(%rbp)
je     1350 <number+0x250>
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     13c0 <number+0x2c0>
cmpl   $0x8,-0x1c(%rbp)
jne    1380 <number+0x280>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
jmp    13bb <number+0x2bb>
cmpl   $0x10,-0x1c(%rbp)
jne    13b6 <number+0x2b6>
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    13bb <number+0x2bb>
jmp    13c0 <number+0x2c0>
mov    -0x28(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
jne    1406 <number+0x306>
jmp    13d4 <number+0x2d4>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    1401 <number+0x301>
mov    -0x71(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    13d4 <number+0x2d4>
jmp    1406 <number+0x306>
jmp    140b <number+0x30b>
mov    -0x78(%rbp),%eax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x24(%rbp)
cmp    %ecx,%eax
jge    1438 <number+0x338>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
jmp    140b <number+0x30b>
jmp    143d <number+0x33d>
mov    -0x78(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x78(%rbp)
cmp    $0x0,%eax
jle    146f <number+0x36f>
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    143d <number+0x33d>
jmp    1474 <number+0x374>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    149f <number+0x39f>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x20,(%rax)
jmp    1474 <number+0x374>
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    $0x68,%rsp
mov    %r9d,%ebp
mov    %edx,%r9d
mov    %ebp,%ebx
and    $0xfffffffe,%ebx
test   $0x10,%bpl
cmove  %ebp,%ebx
lea    -0x11(%r9),%eax
cmp    $0xfffffff1,%eax
jae    1140 <number+0x30>
xor    %ebx,%ebx
jmp    13b5 <number+0x2a5>
mov    %ecx,%r14d
mov    %rdi,%r13
mov    $0x1,%r10b
test   $0x2,%bl
jne    1158 <number+0x48>
xor    %r11d,%r11d
test   $0x40,%bl
je     11a1 <number+0x91>
jmp    118b <number+0x7b>
test   %rsi,%rsi
js     1170 <number+0x60>
test   $0x4,%bl
jne    117c <number+0x6c>
test   $0x8,%bl
je     114e <number+0x3e>
add    $0xffffffff,%r14d
mov    $0x20,%r11b
jmp    1183 <number+0x73>
neg    %rsi
add    $0xffffffff,%r14d
mov    $0x2d,%r11b
jmp    1183 <number+0x73>
add    $0xffffffff,%r14d
mov    $0x2b,%r11b
xor    %r10d,%r10d
test   $0x40,%bl
je     11a1 <number+0x91>
cmp    $0x8,%r9d
je     119d <number+0x8d>
cmp    $0x10,%r9d
jne    11a1 <number+0x91>
add    $0xfffffffe,%r14d
jmp    11a1 <number+0x91>
add    $0xffffffff,%r14d
and    $0x20,%bpl
test   %rsi,%rsi
je     11f1 <number+0xe1>
mov    %r9d,%ecx
xor    %r15d,%r15d
lea    0xe49(%rip),%rdi
jmp    11e0 <number+0xd0>
nopl   0x0(%rax)
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     11fc <number+0xec>
mov    %rsi,%rax
shr    $0x20,%rax
jne    11c0 <number+0xb0>
mov    %esi,%eax
xor    %edx,%edx
div    %ecx
jmp    11c8 <number+0xb8>
movb   $0x30,0x20(%rsp)
mov    $0x1,%r15d
cmp    %r8d,%r15d
mov    %r8d,%r12d
cmovg  %r15d,%r12d
sub    %r12d,%r14d
test   $0x11,%bl
je     121a <number+0x10a>
test   %r10b,%r10b
je     1275 <number+0x165>
test   $0x40,%bl
jne    1282 <number+0x172>
jmp    1297 <number+0x187>
lea    -0x1(%r14),%eax
test   %r14d,%r14d
jle    1487 <number+0x377>
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    1213 <number+0x103>
mov    %r11b,0x0(%r13)
add    $0x1,%r13
test   $0x40,%bl
je     1297 <number+0x187>
cmp    $0x10,%r9d
je     12d8 <number+0x1c8>
cmp    $0x8,%r9d
jne    1297 <number+0x187>
movb   $0x30,0x0(%r13)
add    $0x1,%r13
test   $0x10,%bl
jne    12ee <number+0x1de>
lea    -0x1(%r14),%ebp
test   %r14d,%r14d
jle    12d3 <number+0x1c3>
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    12ee <number+0x1de>
mov    %ebp,%r14d
jmp    12ee <number+0x1de>
movb   $0x30,0x0(%r13)
or     $0x58,%bpl
mov    %bpl,0x1(%r13)
add    $0x2,%r13
test   $0x10,%bl
je     129c <number+0x18c>
cmp    %r8d,%r15d
jge    1314 <number+0x204>
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     1368 <number+0x258>
test   %r15d,%r15d
cmovle %r15d,%edx
lea    -0x1(%r15),%esi
lea    0x20(%rsp),%rdi
add    %rsi,%rdi
add    $0x1,%rdi
cmp    %rdi,%r13
jae    13c7 <number+0x2b7>
sub    %edx,%r15d
lea    (%r15,%r13,1),%rdx
add    $0x1,%rdx
sub    %r15,%rsi
add    %rsp,%rsi
add    $0x20,%rsi
cmp    %rdx,%rsi
jae    13c7 <number+0x2b7>
mov    %rax,%rdx
mov    %r13,%rbx
lea    0x1(%rdx),%eax
add    $0xffffffff,%edx
lea    (%rsp,%rdx,1),%rcx
add    $0x20,%rcx
nopl   0x0(%rax)
movzbl (%rcx),%edx
mov    %dl,(%rbx)
add    $0x1,%rbx
add    $0xffffffff,%eax
add    $0xffffffffffffffff,%rcx
cmp    $0x1,%eax
jg     1380 <number+0x270>
test   %r14d,%r14d
jle    13b5 <number+0x2a5>
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    13f0 <number+0x2e0>
cmp    %rsi,%rcx
jne    136e <number+0x25e>
jmp    1395 <number+0x285>
mov    %eax,%r14d
test   %r10b,%r10b
jne    1213 <number+0x103>
jmp    1275 <number+0x165>

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

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