#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 */
int /*<<< orphan*/ _write_to_conv_buf(char *, int);
void _number(long long n, int base, int upper, int precision, int alzr) {
  int i, j;
  char buf[32], buf2[32];
  char *digits;
  if (precision > 32)
    precision = 32;
  else if (precision == 0 && n == 0)
    return;
  i = j = 0;
  digits = upper ? "0123456789ABCDEF" : "0123456789abcdef";
  do {
    buf[i++] = digits[n % (unsigned long long)base];
    n /= (unsigned long long)base;
  } while (n != 0);
  if (alzr && precision <= i)
    precision = i + 1;
  while (i < precision)
    buf[i++] = '0';
  do
    buf2[j++] = buf[--i];
  while (i != 0);
  _write_to_conv_buf(buf2, j);
}


x86 assembly (clang, -O0):
<_number>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
cmpl   $0x20,-0x14(%rbp)
jle    113f <_number+0x2f>
movl   $0x20,-0x14(%rbp)
jmp    115e <_number+0x4e>
cmpl   $0x0,-0x14(%rbp)
jne    1159 <_number+0x49>
cmpq   $0x0,-0x8(%rbp)
jne    1159 <_number+0x49>
jmp    1253 <_number+0x143>
jmp    115e <_number+0x4e>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x10(%rbp),%edx
lea    0xe9b(%rip),%rax
lea    0xe83(%rip),%rcx
cmp    $0x0,%edx
cmovne %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
xor    %edx,%edx
div    %rcx
mov    -0x70(%rbp),%rax
mov    (%rax,%rdx,1),%cl
mov    -0x1c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
cltq
mov    %cl,-0x40(%rbp,%rax,1)
movslq -0xc(%rbp),%rcx
mov    -0x8(%rbp),%rax
xor    %edx,%edx
div    %rcx
mov    %rax,-0x8(%rbp)
cmpq   $0x0,-0x8(%rbp)
jne    1188 <_number+0x78>
cmpl   $0x0,-0x18(%rbp)
je     11f0 <_number+0xe0>
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     11f0 <_number+0xe0>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11f5 <_number+0xe5>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1218 <_number+0x108>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x1c(%rbp)
cltq
movb   $0x30,-0x40(%rbp,%rax,1)
jmp    11f5 <_number+0xe5>
jmp    121d <_number+0x10d>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cltq
mov    -0x40(%rbp,%rax,1),%cl
mov    -0x20(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
cltq
mov    %cl,-0x60(%rbp,%rax,1)
cmpl   $0x0,-0x1c(%rbp)
jne    121d <_number+0x10d>
lea    -0x60(%rbp),%rdi
mov    -0x20(%rbp),%esi
call   1030 <_write_to_conv_buf@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_number>:
mov    $0x20,%r9d
cmp    $0x20,%ecx
jg     113b <_number+0x1b>
test   %rdi,%rdi
jne    1138 <_number+0x18>
mov    %ecx,%r9d
test   %ecx,%ecx
jne    113b <_number+0x1b>
ret
mov    %ecx,%r9d
push   %rbx
sub    $0x40,%rsp
test   %edx,%edx
lea    0xec8(%rip),%rax
lea    0xeb0(%rip),%r10
cmove  %rax,%r10
movslq %esi,%r11
xor    %ecx,%ecx
jmp    117d <_number+0x5d>
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rax
xor    %edx,%edx
div    %r11
movzbl (%r10,%rdx,1),%edx
mov    %dl,0x20(%rsp,%rcx,1)
add    $0x1,%rcx
cmp    %r11,%rdi
mov    %rax,%rdi
jb     1191 <_number+0x71>
mov    %rdi,%rax
or     %r11,%rax
shr    $0x20,%rax
jne    1160 <_number+0x40>
mov    %edi,%eax
xor    %edx,%edx
div    %esi
jmp    1168 <_number+0x48>
lea    0x1(%rcx),%ebx
cmp    %ecx,%r9d
cmovg  %r9d,%ebx
test   %r8d,%r8d
cmove  %r9d,%ebx
cmp    %ecx,%ebx
jle    11c7 <_number+0xa7>
mov    %ecx,%eax
lea    (%rsp,%rax,1),%rdi
add    $0x20,%rdi
not    %ecx
add    %ebx,%ecx
add    $0x1,%rcx
mov    $0x30,%esi
mov    %rcx,%rdx
call   1030 <memset@plt>
mov    %ebx,%ecx
movslq %ecx,%rcx
cmp    $0x20,%ecx
jae    11d9 <_number+0xb9>
xor    %esi,%esi
mov    %rcx,%rax
jmp    1282 <_number+0x162>
mov    %rcx,%rsi
and    $0xffffffffffffffe0,%rsi
mov    %ecx,%eax
and    $0x1f,%eax
lea    0x20(%rsp),%rdx
add    %rcx,%rdx
add    $0xfffffffffffffff0,%rdx
xor    %edi,%edi
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdx),%xmm1
movdqu (%rdx),%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
movdqa %xmm2,(%rsp,%rdi,1)
movdqa %xmm1,0x10(%rsp,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rdx
cmp    %rdi,%rsi
jne    1200 <_number+0xe0>
cmp    %rcx,%rsi
je     12a5 <_number+0x185>
mov    %rsi,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rcx),%rsi
movzbl 0x1f(%rsp,%rax,1),%edx
mov    %dl,(%rsp,%rcx,1)
mov    %rsi,%rcx
add    $0xffffffffffffffff,%rax
jne    1290 <_number+0x170>
mov    %rsp,%rdi
call   1040 <_write_to_conv_buf@plt>
add    $0x40,%rsp
pop    %rbx
ret

LLVM IR (-O0):
@.str = [17 x i8] c"0123456789ABCDEF\00"
@.str.1 = [17 x i8] c"0123456789abcdef\00"
define void @_number(i64 %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i64
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca [32 x i8]
%14 = alloca [32 x i8]
%15 = alloca i8*
store i64 %0, i64* %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
%16 = load i32, i32* %9
%17 = icmp sgt i32 %16, 32
br i1 %17, label %18, label %19
18: ; preds = %5
store i32 32, i32* %9
br label %27
19: ; preds = %5
%20 = load i32, i32* %9
%21 = icmp eq i32 %20, 0
br i1 %21, label %22, label %26
22: ; preds = %19
%23 = load i64, i64* %6
%24 = icmp eq i64 %23, 0
br i1 %24, label %25, label %26
25: ; preds = %22
br label %89
26: ; preds = %22, %19
br label %27
27: ; preds = %26, %18
store i32 0, i32* %12
store i32 0, i32* %11
%28 = load i32, i32* %8
%29 = icmp ne i32 %28, 0
%30 = zext i1 %29 to i64
%31 = select i1 %29, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0)
store i8* %31, i8** %15
br label %32
32: ; preds = %48, %27
%33 = load i8*, i8** %15
%34 = load i64, i64* %6
%35 = load i32, i32* %7
%36 = sext i32 %35 to i64
%37 = urem i64 %34, %36
%38 = getelementptr inbounds i8, i8* %33, i64 %37
%39 = load i8, i8* %38
%40 = load i32, i32* %11
%41 = add nsw i32 %40, 1
store i32 %41, i32* %11
%42 = sext i32 %40 to i64
%43 = getelementptr inbounds [32 x i8], [32 x i8]* %13, i64 0, i64 %42
store i8 %39, i8* %43
%44 = load i32, i32* %7
%45 = sext i32 %44 to i64
%46 = load i64, i64* %6
%47 = udiv i64 %46, %45
store i64 %47, i64* %6
br label %48
48: ; preds = %32
%49 = load i64, i64* %6
%50 = icmp ne i64 %49, 0
br i1 %50, label %32, label %51
51: ; preds = %48
%52 = load i32, i32* %10
%53 = icmp ne i32 %52, 0
br i1 %53, label %54, label %61
54: ; preds = %51
%55 = load i32, i32* %9
%56 = load i32, i32* %11
%57 = icmp sle i32 %55, %56
br i1 %57, label %58, label %61
58: ; preds = %54
%59 = load i32, i32* %11
%60 = add nsw i32 %59, 1
store i32 %60, i32* %9
br label %61
61: ; preds = %58, %54, %51
br label %62
62: ; preds = %66, %61
%63 = load i32, i32* %11
%64 = load i32, i32* %9
%65 = icmp slt i32 %63, %64
br i1 %65, label %66, label %71
66: ; preds = %62
%67 = load i32, i32* %11
%68 = add nsw i32 %67, 1
store i32 %68, i32* %11
%69 = sext i32 %67 to i64
%70 = getelementptr inbounds [32 x i8], [32 x i8]* %13, i64 0, i64 %69
store i8 48, i8* %70
br label %62
71: ; preds = %62
br label %72
72: ; preds = %82, %71
%73 = load i32, i32* %11
%74 = add nsw i32 %73, -1
store i32 %74, i32* %11
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [32 x i8], [32 x i8]* %13, i64 0, i64 %75
%77 = load i8, i8* %76
%78 = load i32, i32* %12
%79 = add nsw i32 %78, 1
store i32 %79, i32* %12
%80 = sext i32 %78 to i64
%81 = getelementptr inbounds [32 x i8], [32 x i8]* %14, i64 0, i64 %80
store i8 %77, i8* %81
br label %82
82: ; preds = %72
%83 = load i32, i32* %11
%84 = icmp ne i32 %83, 0
br i1 %84, label %72, label %85
85: ; preds = %82
%86 = getelementptr inbounds [32 x i8], [32 x i8]* %14, i64 0, i64 0
%87 = load i32, i32* %12
%88 = call i32 @_write_to_conv_buf(i8* %86, i32 %87)
br label %89
89: ; preds = %85, %25
ret void
}

LLVM IR (-O2):
@.str = [17 x i8] c"0123456789ABCDEF\00"
@.str.1 = [17 x i8] c"0123456789abcdef\00"
define void @_number(i64 %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca [32 x i8]
%7 = alloca [32 x i8]
%8 = getelementptr inbounds [32 x i8], [32 x i8]* %6, i64 0, i64 0
%9 = getelementptr inbounds [32 x i8], [32 x i8]* %7, i64 0, i64 0
%10 = icmp sgt i32 %3, 32
br i1 %10, label %15, label %11
11: ; preds = %5
%12 = icmp eq i32 %3, 0
%13 = icmp eq i64 %0, 0
%14 = and i1 %13, %12
br i1 %14, label %90, label %15
15: ; preds = %5, %11
%16 = phi i32 [ %3, %11 ], [ 32, %5 ]
%17 = icmp eq i32 %2, 0
%18 = select i1 %17, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0)
%19 = sext i32 %1 to i64
br label %20
20: ; preds = %20, %15
%21 = phi i64 [ %26, %20 ], [ 0, %15 ]
%22 = phi i64 [ %28, %20 ], [ %0, %15 ]
%23 = urem i64 %22, %19
%24 = getelementptr inbounds i8, i8* %18, i64 %23
%25 = load i8, i8* %24
%26 = add nuw i64 %21, 1
%27 = getelementptr inbounds [32 x i8], [32 x i8]* %6, i64 0, i64 %21
store i8 %25, i8* %27
%28 = udiv i64 %22, %19
%29 = icmp ult i64 %22, %19
br i1 %29, label %30, label %20
30: ; preds = %20
%31 = trunc i64 %21 to i32
%32 = trunc i64 %26 to i32
%33 = icmp eq i32 %4, 0
%34 = icmp sgt i32 %16, %32
%35 = select i1 %33, i1 true, i1 %34
%36 = add nuw nsw i32 %31, 2
%37 = select i1 %35, i32 %16, i32 %36
%38 = icmp sgt i32 %37, %32
br i1 %38, label %39, label %46
39: ; preds = %30
%40 = and i64 %26, 4294967295
%41 = getelementptr [32 x i8], [32 x i8]* %6, i64 0, i64 %40
%42 = xor i32 %32, -1
%43 = add i32 %37, %42
%44 = zext i32 %43 to i64
%45 = add nuw nsw i64 %44, 1
br label %46
46: ; preds = %39, %30
%47 = phi i32 [ %32, %30 ], [ %37, %39 ]
%48 = sext i32 %47 to i64
%49 = icmp ult i32 %47, 32
br i1 %49, label %74, label %50
50: ; preds = %46
%51 = and i64 %48, -32
%52 = and i64 %48, 31
br label %53
53: ; preds = %53, %50
%54 = phi i64 [ 0, %50 ], [ %70, %53 ]
%55 = xor i64 %54, -1
%56 = add i64 %55, %48
%57 = getelementptr inbounds [32 x i8], [32 x i8]* %6, i64 0, i64 %56
%58 = getelementptr inbounds i8, i8* %57, i64 -15
%59 = bitcast i8* %58 to <16 x i8>*
%60 = load <16 x i8>, <16 x i8>* %59
%61 = shufflevector <16 x i8> %60, <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>
%62 = getelementptr inbounds i8, i8* %57, i64 -31
%63 = bitcast i8* %62 to <16 x i8>*
%64 = load <16 x i8>, <16 x i8>* %63
%65 = shufflevector <16 x i8> %64, <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>
%66 = getelementptr inbounds [32 x i8], [32 x i8]* %7, i64 0, i64 %54
%67 = bitcast i8* %66 to <16 x i8>*
store <16 x i8> %61, <16 x i8>* %67
%68 = getelementptr inbounds i8, i8* %66, i64 16
%69 = bitcast i8* %68 to <16 x i8>*
store <16 x i8> %65, <16 x i8>* %69
%70 = add nuw i64 %54, 32
%71 = icmp eq i64 %70, %51
br i1 %71, label %72, label %53
72: ; preds = %53
%73 = icmp eq i64 %51, %48
br i1 %73, label %86, label %74
74: ; preds = %46, %72
%75 = phi i64 [ 0, %46 ], [ %51, %72 ]
%76 = phi i64 [ %48, %46 ], [ %52, %72 ]
br label %77
77: ; preds = %74, %77
%78 = phi i64 [ %83, %77 ], [ %75, %74 ]
%79 = phi i64 [ %80, %77 ], [ %76, %74 ]
%80 = add nsw i64 %79, -1
%81 = getelementptr inbounds [32 x i8], [32 x i8]* %6, i64 0, i64 %80
%82 = load i8, i8* %81
%83 = add nuw nsw i64 %78, 1
%84 = getelementptr inbounds [32 x i8], [32 x i8]* %7, i64 0, i64 %78
store i8 %82, i8* %84
%85 = icmp eq i64 %80, 0
br i1 %85, label %86, label %77
86: ; preds = %77, %72
%87 = phi i64 [ %51, %72 ], [ %83, %77 ]
%88 = trunc i64 %87 to i32
%89 = call i32 @_write_to_conv_buf(i8* %9, i32 %88)
br label %90
90: ; preds = %11, %86
ret void
}