#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 */
typedef int uint32_t;

/* Variables and functions */
int convert(char *buf, char *end, uint32_t flags, uint32_t width,
            uint32_t num) {
  static const char digits[16] = "0123456789ABCDEF";
  char tmp[20];
  int i = 0, length = 0;
  char sign = 0;
  if (width > 20) {
    width = 20;
  }
  if (flags & (1 << 1)) {
    if (width) {
      width--;
    }
    if ((signed long)num < 0) {
      sign = '-';
      num = -(signed long)num;
    }
  }
  if (num == 0) {
    tmp[i++] = '0';
  } else if (flags & (1 << 7)) {
    uint32_t low_case = (flags & (1 << 5)) ? 0x20 : 0;
    do {
      tmp[i++] = (digits[num & 0x0F] | low_case);
      num = (num >> 4);
    } while (num);
  } else {
    while (num) {
      tmp[i++] = (num % 10) + '0';
      num = num / 10;
    }
  }
  if (flags & (1 << 0)) {
    while (i < width) {
      tmp[i++] = '0';
    }
  }
  if (sign) {
    tmp[i++] = sign;
  } else if (flags & (1 << 2)) {
    tmp[i++] = '+';
  } else if (flags & (1 << 3)) {
    tmp[i++] = ' ';
  } else if (flags & (1 << 6)) {
    tmp[i++] = 'x';
    tmp[i++] = '0';
  }
  while (i < width) {
    tmp[i++] = ' ';
  }
  length = i;
  while (i && (buf < end)) {
    i--;
    *(buf++) = tmp[i];
  }
  if (i)
    return -i;
  return length;
}


x86 assembly (clang, -O0):
<convert>:
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)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movb   $0x0,-0x49(%rbp)
cmpl   $0x14,-0x20(%rbp)
jle    1139 <convert+0x39>
movl   $0x14,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
and    $0x2,%eax
cmp    $0x0,%eax
je     117e <convert+0x7e>
cmpl   $0x0,-0x20(%rbp)
je     115b <convert+0x5b>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
movslq -0x24(%rbp),%rax
cmp    $0x0,%rax
jge    1179 <convert+0x79>
movb   $0x2d,-0x49(%rbp)
movslq -0x24(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
mov    %eax,-0x24(%rbp)
jmp    117e <convert+0x7e>
cmpl   $0x0,-0x24(%rbp)
jne    119f <convert+0x9f>
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x44(%rbp)
cltq
movb   $0x30,-0x40(%rbp,%rax,1)
jmp    1255 <convert+0x155>
mov    -0x1c(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     1208 <convert+0x108>
mov    -0x1c(%rbp),%edx
and    $0x20,%edx
xor    %eax,%eax
mov    $0x20,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x24(%rbp),%eax
and    $0xf,%eax
movslq %eax,%rcx
lea    0xe2a(%rip),%rax
movsbl (%rax,%rcx,1),%eax
or     -0x50(%rbp),%eax
mov    %al,%cl
mov    -0x44(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x44(%rbp)
cltq
mov    %cl,-0x40(%rbp,%rax,1)
mov    -0x24(%rbp),%eax
sar    $0x4,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jne    11c6 <convert+0xc6>
jmp    1250 <convert+0x150>
jmp    120d <convert+0x10d>
cmpl   $0x0,-0x24(%rbp)
je     124b <convert+0x14b>
mov    -0x24(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
add    $0x30,%edx
mov    %dl,%cl
mov    -0x44(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x44(%rbp)
cltq
mov    %cl,-0x40(%rbp,%rax,1)
mov    -0x24(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
jmp    120d <convert+0x10d>
jmp    1250 <convert+0x150>
jmp    1255 <convert+0x155>
mov    -0x1c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1291 <convert+0x191>
jmp    1269 <convert+0x169>
mov    -0x44(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    128c <convert+0x18c>
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x44(%rbp)
cltq
movb   $0x30,-0x40(%rbp,%rax,1)
jmp    1269 <convert+0x169>
jmp    1291 <convert+0x191>
cmpb   $0x0,-0x49(%rbp)
je     12b4 <convert+0x1b4>
mov    -0x49(%rbp),%cl
mov    -0x44(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x44(%rbp)
cltq
mov    %cl,-0x40(%rbp,%rax,1)
jmp    1342 <convert+0x242>
mov    -0x1c(%rbp),%eax
and    $0x4,%eax
cmp    $0x0,%eax
je     12da <convert+0x1da>
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x44(%rbp)
cltq
movb   $0x2b,-0x40(%rbp,%rax,1)
jmp    133d <convert+0x23d>
mov    -0x1c(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1300 <convert+0x200>
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x44(%rbp)
cltq
movb   $0x20,-0x40(%rbp,%rax,1)
jmp    1338 <convert+0x238>
mov    -0x1c(%rbp),%eax
and    $0x40,%eax
cmp    $0x0,%eax
je     1333 <convert+0x233>
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x44(%rbp)
cltq
movb   $0x78,-0x40(%rbp,%rax,1)
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x44(%rbp)
cltq
movb   $0x30,-0x40(%rbp,%rax,1)
jmp    1338 <convert+0x238>
jmp    133d <convert+0x23d>
jmp    1342 <convert+0x242>
jmp    1347 <convert+0x247>
mov    -0x44(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    136a <convert+0x26a>
mov    -0x44(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x44(%rbp)
cltq
movb   $0x20,-0x40(%rbp,%rax,1)
jmp    1347 <convert+0x247>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x44(%rbp)
mov    %al,-0x51(%rbp)
je     138d <convert+0x28d>
mov    -0x10(%rbp),%rax
cmp    -0x18(%rbp),%rax
setb   %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    139d <convert+0x29d>
jmp    13c4 <convert+0x2c4>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
movslq -0x44(%rbp),%rax
mov    -0x40(%rbp,%rax,1),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    1370 <convert+0x270>
cmpl   $0x0,-0x44(%rbp)
je     13db <convert+0x2db>
xor    %eax,%eax
sub    -0x44(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    13e1 <convert+0x2e1>
mov    -0x48(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<convert>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edx,%ebp
mov    %rsi,%r14
mov    %rdi,%rbx
cmp    $0x14,%ecx
mov    $0x14,%r15d
cmovl  %ecx,%r15d
test   $0x2,%bpl
je     1148 <convert+0x38>
xor    %eax,%eax
sub    $0x1,%r15d
cmovb  %eax,%r15d
test   %r8d,%r8d
js     11aa <convert+0x9a>
test   %r8d,%r8d
je     1199 <convert+0x89>
mov    $0x1,%r13b
xor    %r12d,%r12d
test   $0x80,%bpl
jne    11b9 <convert+0xa9>
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movslq %r8d,%rax
imul   $0x66666667,%rax,%r8
mov    %r8,%rcx
shr    $0x3f,%rcx
sar    $0x22,%r8
add    %ecx,%r8d
lea    (%r8,%r8,1),%ecx
lea    (%rcx,%rcx,4),%ecx
mov    %eax,%esi
sub    %ecx,%esi
add    $0x30,%sil
mov    %sil,(%rsp,%rdx,1)
add    $0x1,%rdx
add    $0x9,%eax
cmp    $0x12,%eax
ja     1160 <convert+0x50>
jmp    11f2 <convert+0xe2>
movb   $0x30,(%rsp)
mov    $0x1,%edx
mov    $0x1,%r13b
xor    %r12d,%r12d
jmp    11f2 <convert+0xe2>
neg    %r8d
mov    $0x2d,%r12b
xor    %r13d,%r13d
test   $0x80,%bpl
je     1159 <convert+0x49>
mov    %ebp,%eax
and    $0x20,%al
xor    %edx,%edx
lea    0xe3a(%rip),%rdi
cs nopw 0x0(%rax,%rax,1)
mov    %r8d,%esi
and    $0xf,%esi
movzbl (%rsi,%rdi,1),%ecx
or     %al,%cl
mov    %cl,(%rsp,%rdx,1)
add    $0x1,%rdx
mov    %r8d,%ecx
sar    $0x4,%ecx
cmp    $0x10,%r8d
mov    %ecx,%r8d
jae    11d0 <convert+0xc0>
test   $0x1,%bpl
je     121a <convert+0x10a>
cmp    %r15d,%edx
jge    121a <convert+0x10a>
movslq %edx,%rax
lea    (%rsp,%rax,1),%rdi
not    %edx
add    %r15d,%edx
add    $0x1,%rdx
mov    $0x30,%esi
call   1030 <memset@plt>
mov    %r15d,%edx
mov    $0x1,%eax
test   %r13b,%r13b
je     1252 <convert+0x142>
mov    $0x2b,%r12b
test   $0x4,%bpl
jne    1252 <convert+0x142>
mov    $0x20,%r12b
mov    %edx,%ecx
test   $0x8,%bpl
jne    1254 <convert+0x144>
test   $0x40,%bpl
je     125d <convert+0x14d>
lea    0x1(%rdx),%ecx
movslq %edx,%rax
movb   $0x78,(%rsp,%rax,1)
mov    $0x30,%r12b
mov    $0x2,%eax
jmp    1254 <convert+0x144>
mov    %edx,%ecx
add    %eax,%edx
movslq %ecx,%rax
mov    %r12b,(%rsp,%rax,1)
cmp    %r15d,%edx
jge    127e <convert+0x16e>
movslq %edx,%rax
lea    (%rsp,%rax,1),%rdi
not    %edx
add    %r15d,%edx
add    $0x1,%rdx
mov    $0x20,%esi
call   1030 <memset@plt>
jmp    1281 <convert+0x171>
mov    %edx,%r15d
test   %r15d,%r15d
setne  %dl
mov    %r15d,%eax
je     1383 <convert+0x273>
cmp    %r14,%rbx
jae    1383 <convert+0x273>
movslq %r15d,%rax
lea    -0x1(%r15),%ecx
mov    %rbx,%rdx
not    %rdx
add    %r14,%rdx
cmp    %rcx,%rdx
cmovae %rcx,%rdx
add    $0x1,%rdx
test   %ecx,%ecx
mov    $0x1,%edi
cmovne %rdx,%rdi
cmp    $0x10,%rdi
jae    12cd <convert+0x1bd>
mov    %rbx,%rcx
jmp    134f <convert+0x23f>
movabs $0x1fffffff0,%r8
and    %rdi,%r8
lea    (%rbx,%r8,1),%rcx
mov    %rdi,%rdx
and    $0xfffffffffffffff0,%rdx
neg    %rdx
mov    %rsp,%rsi
add    %rax,%rsi
add    $0xfffffffffffffff0,%rsi
sub    %r8,%rax
xor    %ebp,%ebp
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu (%rsi,%rbp,1),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqu %xmm1,(%rbx)
add    $0x10,%rbx
add    $0xfffffffffffffff0,%rbp
cmp    %rbp,%rdx
jne    1300 <convert+0x1f0>
add    %r15d,%ebp
setne  %dl
cmp    %r8,%rdi
je     1383 <convert+0x273>
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rax,%rdx
movzbl -0x1(%rsp,%rax,1),%ebx
add    $0xffffffffffffffff,%rax
mov    %bl,-0x1(%rcx)
cmp    $0x1,%edx
setne  %dl
je     1383 <convert+0x273>
lea    0x1(%rcx),%rsi
cmp    %r14,%rcx
mov    %rsi,%rcx
jb     1360 <convert+0x250>
neg    %eax
test   %dl,%dl
cmovne %eax,%r15d
mov    %r15d,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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