#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 */
size_t do_div(unsigned long long *, unsigned int);
char *number(char *str, long long num, unsigned 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 (num < 0) {
      sign = '-';
      num = -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[do_div((unsigned long long *)&num, base)];
  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)
jb     1182 <number+0x72>
cmpl   $0x24,-0x1c(%rbp)
jbe    118f <number+0x7f>
movq   $0x0,-0x8(%rbp)
jmp    14be <number+0x3ae>
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    12ea <number+0x1da>
jmp    12a0 <number+0x190>
cmpq   $0x0,-0x18(%rbp)
je     12e5 <number+0x1d5>
mov    -0x78(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x1c(%rbp),%esi
lea    -0x18(%rbp),%rdi
call   1030 <do_div@plt>
mov    %rax,%rcx
mov    -0x88(%rbp),%rax
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    12ea <number+0x1da>
mov    -0x7c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    12fc <number+0x1ec>
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    134b <number+0x23b>
jmp    131b <number+0x20b>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    1346 <number+0x236>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x20,(%rax)
jmp    131b <number+0x20b>
jmp    134b <number+0x23b>
cmpb   $0x0,-0x2a(%rbp)
je     1369 <number+0x259>
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     13d7 <number+0x2c7>
cmpl   $0x8,-0x1c(%rbp)
jne    1399 <number+0x289>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
jmp    13d2 <number+0x2c2>
cmpl   $0x10,-0x1c(%rbp)
jne    13cd <number+0x2bd>
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    13d2 <number+0x2c2>
jmp    13d7 <number+0x2c7>
mov    -0x28(%rbp),%eax
and    $0x10,%eax
cmp    $0x0,%eax
jne    141d <number+0x30d>
jmp    13eb <number+0x2db>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    1418 <number+0x308>
mov    -0x29(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    13eb <number+0x2db>
jmp    141d <number+0x30d>
jmp    1422 <number+0x312>
mov    -0x7c(%rbp),%eax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x24(%rbp)
cmp    %ecx,%eax
jge    144f <number+0x33f>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x30,(%rax)
jmp    1422 <number+0x312>
jmp    1454 <number+0x344>
mov    -0x7c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x7c(%rbp)
cmp    $0x0,%eax
jle    1486 <number+0x376>
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    1454 <number+0x344>
jmp    148b <number+0x37b>
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
cmp    $0x0,%eax
jle    14b6 <number+0x3a6>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movb   $0x20,(%rax)
jmp    148b <number+0x37b>
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    $0x78,%rsp
mov    %edx,%ebp
mov    %rsi,0x18(%rsp)
test   $0x40,%r9b
lea    0xec0(%rip),%rax
lea    0xede(%rip),%r15
cmove  %rax,%r15
mov    %r9d,%r12d
and    $0xfffffffe,%r12d
test   $0x10,%r9b
cmove  %r9d,%r12d
lea    -0x25(%rbp),%eax
cmp    $0xffffffdd,%eax
jae    1169 <number+0x49>
xor    %ebx,%ebx
jmp    13e5 <number+0x2c5>
mov    %rdi,%r13
mov    $0x1,%dl
test   $0x2,%r12b
jne    1184 <number+0x64>
movl   $0x0,0xc(%rsp)
test   $0x20,%r12b
je     11ce <number+0xae>
jmp    11bc <number+0x9c>
test   %rsi,%rsi
js     119c <number+0x7c>
test   $0x4,%r12b
jne    11ab <number+0x8b>
test   $0x8,%r12b
je     1174 <number+0x54>
add    $0xffffffff,%ecx
mov    $0x20,%al
jmp    11b0 <number+0x90>
neg    %rsi
mov    %rsi,0x18(%rsp)
add    $0xffffffff,%ecx
mov    $0x2d,%al
jmp    11b0 <number+0x90>
add    $0xffffffff,%ecx
mov    $0x2b,%al
mov    %eax,0xc(%rsp)
xor    %edx,%edx
test   $0x20,%r12b
je     11ce <number+0xae>
cmp    $0x8,%ebp
je     11cb <number+0xab>
cmp    $0x10,%ebp
jne    11ce <number+0xae>
add    $0xfffffffe,%ecx
jmp    11ce <number+0xae>
add    $0xffffffff,%ecx
test   %rsi,%rsi
mov    %r9d,0x24(%rsp)
je     1220 <number+0x100>
mov    %edx,0x10(%rsp)
mov    %r8d,0x14(%rsp)
mov    %rcx,0x28(%rsp)
xor    %r14d,%r14d
lea    0x18(%rsp),%rbx
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %ebp,%esi
call   1040 <do_div@plt>
movzbl (%r15,%rax,1),%eax
mov    %al,0x30(%rsp,%r14,1)
add    $0x1,%r14
cmpq   $0x0,0x18(%rsp)
jne    11f0 <number+0xd0>
mov    0x28(%rsp),%rcx
mov    0x14(%rsp),%r8d
mov    0x10(%rsp),%edx
jmp    122b <number+0x10b>
movb   $0x30,0x30(%rsp)
mov    $0x1,%r14d
cmp    %r8d,%r14d
mov    %r8d,%ebx
cmovg  %r14d,%ebx
sub    %ebx,%ecx
test   $0x11,%r12b
je     1249 <number+0x129>
test   %dl,%dl
je     128a <number+0x16a>
test   $0x20,%r12b
jne    129c <number+0x17c>
jmp    12af <number+0x18f>
lea    -0x1(%rcx),%eax
test   %ecx,%ecx
jle    14b7 <number+0x397>
mov    %eax,%r15d
mov    %edx,0x10(%rsp)
lea    0x1(%r15),%rdx
mov    %r13,%rdi
mov    $0x20,%esi
mov    %r8d,0x14(%rsp)
call   1030 <memset@plt>
mov    0x10(%rsp),%edx
mov    0x14(%rsp),%r8d
add    %r15,%r13
add    $0x1,%r13
mov    $0xffffffff,%ecx
test   %dl,%dl
jne    1241 <number+0x121>
mov    0xc(%rsp),%eax
mov    %al,0x0(%r13)
add    $0x1,%r13
test   $0x20,%r12b
je     12af <number+0x18f>
cmp    $0x10,%ebp
je     12f3 <number+0x1d3>
cmp    $0x8,%ebp
jne    12af <number+0x18f>
movb   $0x30,0x0(%r13)
add    $0x1,%r13
test   $0x10,%r12b
jne    1313 <number+0x1f3>
lea    -0x1(%rcx),%r15d
test   %ecx,%ecx
jle    12ee <number+0x1ce>
and    $0x1,%r12b
shl    $0x4,%r12b
or     $0x20,%r12b
mov    %ecx,%edx
movzbl %r12b,%esi
mov    %r13,%rdi
mov    %r8d,%ebp
call   1030 <memset@plt>
mov    %ebp,%r8d
mov    %r15d,%eax
add    %rax,%r13
add    $0x1,%r13
mov    $0xffffffff,%ecx
jmp    1313 <number+0x1f3>
mov    %r15d,%ecx
jmp    1313 <number+0x1f3>
testb  $0x40,0x24(%rsp)
sete   %al
movb   $0x30,0x0(%r13)
shl    $0x5,%al
or     $0x58,%al
mov    %al,0x1(%r13)
add    $0x2,%r13
test   $0x10,%r12b
je     12b5 <number+0x195>
cmp    %r8d,%r14d
jge    133d <number+0x21d>
mov    %r14d,%eax
not    %eax
add    %eax,%ebx
lea    0x1(%rbx),%rdx
mov    %r13,%rdi
mov    $0x30,%esi
mov    %rcx,%rbp
call   1030 <memset@plt>
mov    %rbp,%rcx
add    %rbx,%r13
add    $0x1,%r13
mov    %r14d,%eax
test   %r14d,%r14d
mov    $0x1,%edx
mov    $0x1,%esi
cmovle %r14d,%esi
mov    %r14d,%r8d
sub    %esi,%r8d
cmp    $0x1f,%r8d
jb     1397 <number+0x277>
test   %r14d,%r14d
cmovle %r14d,%edx
lea    -0x1(%r14),%esi
lea    0x30(%rsp),%rdi
add    %rsi,%rdi
add    $0x1,%rdi
cmp    %rdi,%r13
jae    13f7 <number+0x2d7>
sub    %edx,%r14d
lea    (%r14,%r13,1),%rdx
add    $0x1,%rdx
sub    %r14,%rsi
add    %rsp,%rsi
add    $0x30,%rsi
cmp    %rdx,%rsi
jae    13f7 <number+0x2d7>
mov    %rax,%rdx
mov    %r13,%rbx
lea    0x1(%rdx),%eax
add    $0xffffffff,%edx
lea    (%rsp,%rdx,1),%rsi
add    $0x30,%rsi
nopl   0x0(%rax,%rax,1)
movzbl (%rsi),%edx
mov    %dl,(%rbx)
add    $0x1,%rbx
add    $0xffffffff,%eax
add    $0xffffffffffffffff,%rsi
cmp    $0x1,%eax
jg     13b0 <number+0x290>
test   %ecx,%ecx
jle    13e5 <number+0x2c5>
mov    %ecx,%edx
mov    %rbx,%rdi
mov    $0x20,%esi
mov    %rcx,%rbp
call   1030 <memset@plt>
add    $0xffffffff,%ebp
add    %rbp,%rbx
add    $0x1,%rbx
mov    %rbx,%rax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%r8
mov    %r8,%rsi
and    $0xffffffffffffffe0,%rsi
mov    %rax,%rdx
sub    %rsi,%rdx
lea    (%rsi,%r13,1),%rbx
add    $0xffffffffffffffff,%rax
xor    %edi,%edi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%ebp
movdqu 0x11(%rsp,%rbp,1),%xmm1
movdqu 0x21(%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    1420 <number+0x300>
cmp    %rsi,%r8
jne    139d <number+0x27d>
jmp    13c5 <number+0x2a5>
mov    %eax,%ecx
test   %dl,%dl
jne    1241 <number+0x121>
jmp    128a <number+0x16a>

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
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
%19 = load i32, i32* %13
%20 = and i32 %19, 64
%21 = icmp ne i32 %20, 0
br i1 %21, label %22, label %23
22: ; preds = %6
store i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0), i8** %17
br label %23
23: ; preds = %22, %6
%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 = %23
%28 = load i32, i32* %13
%29 = and i32 %28, -2
store i32 %29, i32* %13
br label %30
30: ; preds = %27, %23
%31 = load i32, i32* %10
%32 = icmp ult i32 %31, 2
br i1 %32, label %36, label %33
33: ; preds = %30
%34 = load i32, i32* %10
%35 = icmp ugt i32 %34, 36
br i1 %35, label %36, label %37
36: ; preds = %33, %30
store i8* null, i8** %7
br label %210
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* %14
store i8 0, i8* %15
%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* %15
%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* %15
%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* %15
%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, 32
%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]* %16, i64 0, i64 %96
store i8 48, i8* %97
br label %113
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 %112
102: ; preds = %99
%103 = load i8*, i8** %17
%104 = load i32, i32* %10
%105 = call i64 @do_div(i64* %9, i32 %104)
%106 = getelementptr inbounds i8, i8* %103, i64 %105
%107 = load i8, i8* %106
%108 = load i32, i32* %18
%109 = add nsw i32 %108, 1
store i32 %109, i32* %18
%110 = sext i32 %108 to i64
%111 = getelementptr inbounds [66 x i8], [66 x i8]* %16, i64 0, i64 %110
store i8 %107, i8* %111
br label %99
112: ; preds = %99
br label %113
113: ; preds = %112, %93
%114 = load i32, i32* %18
%115 = load i32, i32* %12
%116 = icmp sgt i32 %114, %115
br i1 %116, label %117, label %119
117: ; preds = %113
%118 = load i32, i32* %18
store i32 %118, i32* %12
br label %119
119: ; preds = %117, %113
%120 = load i32, i32* %12
%121 = load i32, i32* %11
%122 = sub nsw i32 %121, %120
store i32 %122, i32* %11
%123 = load i32, i32* %13
%124 = and i32 %123, 17
%125 = icmp ne i32 %124, 0
br i1 %125, label %135, label %126
126: ; preds = %119
br label %127
127: ; preds = %131, %126
%128 = load i32, i32* %11
%129 = add nsw i32 %128, -1
store i32 %129, i32* %11
%130 = icmp sgt i32 %128, 0
br i1 %130, label %131, label %134
131: ; preds = %127
%132 = load i8*, i8** %8
%133 = getelementptr inbounds i8, i8* %132, i32 1
store i8* %133, i8** %8
store i8 32, i8* %132
br label %127
134: ; preds = %127
br label %135
135: ; preds = %134, %119
%136 = load i8, i8* %15
%137 = icmp ne i8 %136, 0
br i1 %137, label %138, label %142
138: ; preds = %135
%139 = load i8, i8* %15
%140 = load i8*, i8** %8
%141 = getelementptr inbounds i8, i8* %140, i32 1
store i8* %141, i8** %8
store i8 %139, i8* %140
br label %142
142: ; preds = %138, %135
%143 = load i32, i32* %13
%144 = and i32 %143, 32
%145 = icmp ne i32 %144, 0
br i1 %145, label %146, label %165
146: ; preds = %142
%147 = load i32, i32* %10
%148 = icmp eq i32 %147, 8
br i1 %148, label %149, label %152
149: ; preds = %146
%150 = load i8*, i8** %8
%151 = getelementptr inbounds i8, i8* %150, i32 1
store i8* %151, i8** %8
store i8 48, i8* %150
br label %164
152: ; preds = %146
%153 = load i32, i32* %10
%154 = icmp eq i32 %153, 16
br i1 %154, label %155, label %163
155: ; preds = %152
%156 = load i8*, i8** %8
%157 = getelementptr inbounds i8, i8* %156, i32 1
store i8* %157, i8** %8
store i8 48, i8* %156
%158 = load i8*, i8** %17
%159 = getelementptr inbounds i8, i8* %158, i64 33
%160 = load i8, i8* %159
%161 = load i8*, i8** %8
%162 = getelementptr inbounds i8, i8* %161, i32 1
store i8* %162, i8** %8
store i8 %160, i8* %161
br label %163
163: ; preds = %155, %152
br label %164
164: ; preds = %163, %149
br label %165
165: ; preds = %164, %142
%166 = load i32, i32* %13
%167 = and i32 %166, 16
%168 = icmp ne i32 %167, 0
br i1 %168, label %179, label %169
169: ; preds = %165
br label %170
170: ; preds = %174, %169
%171 = load i32, i32* %11
%172 = add nsw i32 %171, -1
store i32 %172, i32* %11
%173 = icmp sgt i32 %171, 0
br i1 %173, label %174, label %178
174: ; preds = %170
%175 = load i8, i8* %14
%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 %170
178: ; preds = %170
br label %179
179: ; preds = %178, %165
br label %180
180: ; preds = %185, %179
%181 = load i32, i32* %18
%182 = load i32, i32* %12
%183 = add nsw i32 %182, -1
store i32 %183, i32* %12
%184 = icmp slt i32 %181, %182
br i1 %184, label %185, label %188
185: ; preds = %180
%186 = load i8*, i8** %8
%187 = getelementptr inbounds i8, i8* %186, i32 1
store i8* %187, i8** %8
store i8 48, i8* %186
br label %180
188: ; preds = %180
br label %189
189: ; preds = %193, %188
%190 = load i32, i32* %18
%191 = add nsw i32 %190, -1
store i32 %191, i32* %18
%192 = icmp sgt i32 %190, 0
br i1 %192, label %193, label %200
193: ; preds = %189
%194 = load i32, i32* %18
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [66 x i8], [66 x i8]* %16, i64 0, i64 %195
%197 = load i8, i8* %196
%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 %189
200: ; preds = %189
br label %201
201: ; preds = %205, %200
%202 = load i32, i32* %11
%203 = add nsw i32 %202, -1
store i32 %203, i32* %11
%204 = icmp sgt i32 %202, 0
br i1 %204, label %205, label %208
205: ; preds = %201
%206 = load i8*, i8** %8
%207 = getelementptr inbounds i8, i8* %206, i32 1
store i8* %207, i8** %8
store i8 32, i8* %206
br label %201
208: ; preds = %201
%209 = load i8*, i8** %8
store i8* %209, i8** %7
br label %210
210: ; preds = %208, %36
%211 = load i8*, i8** %7
ret i8* %211
}

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