#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 */
scalar_t__ malloc(int);
char *bin2hex(unsigned char *data, int size) {
  int i = 0;
  int v = 0;
  char *p = NULL;
  char *buf = NULL;
  char base_char = 'A';
  buf = p = (char *)malloc(size * 2 + 1);
  for (i = 0; i < size; i++) {
    v = data[i] >> 4;
    *p++ = v < 10 ? v + '0' : v - 10 + base_char;
    v = data[i] & 0x0f;
    *p++ = v < 10 ? v + '0' : v - 10 + base_char;
  }
  *p = '\0';
  return buf;
}


x86 assembly (clang, -O0):
<bin2hex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movb   $0x41,-0x29(%rbp)
mov    -0xc(%rbp),%edi
shl    $0x1,%edi
add    $0x1,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1216 <bin2hex+0x106>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
sar    $0x4,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0xa,-0x14(%rbp)
jge    1194 <bin2hex+0x84>
mov    -0x14(%rbp),%eax
add    $0x30,%eax
mov    %eax,-0x30(%rbp)
jmp    11a3 <bin2hex+0x93>
mov    -0x14(%rbp),%eax
sub    $0xa,%eax
movsbl -0x29(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xf,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0xa,-0x14(%rbp)
jge    11e3 <bin2hex+0xd3>
mov    -0x14(%rbp),%eax
add    $0x30,%eax
mov    %eax,-0x34(%rbp)
jmp    11f2 <bin2hex+0xe2>
mov    -0x14(%rbp),%eax
sub    $0xa,%eax
movsbl -0x29(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    115e <bin2hex+0x4e>
mov    -0x20(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x28(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bin2hex>:
push   %r15
push   %r14
push   %rbx
mov    %esi,%r14d
mov    %rdi,%r15
lea    (%r14,%r14,1),%edi
add    $0x1,%edi
call   1030 <malloc@plt>
test   %r14d,%r14d
jle    11a3 <bin2hex+0x93>
mov    %r14d,%r8d
cmp    $0x8,%r14d
jb     1147 <bin2hex+0x37>
lea    (%r15,%r8,1),%rdx
cmp    %rax,%rdx
jbe    11ab <bin2hex+0x9b>
lea    (%rax,%r8,2),%rdx
cmp    %r15,%rdx
jbe    11ab <bin2hex+0x9b>
xor    %edx,%edx
mov    %rax,%rsi
nopl   0x0(%rax)
movzbl (%r15,%rdx,1),%ecx
mov    %ecx,%edi
shr    $0x4,%dil
lea    0x30(%rdi),%ebx
add    $0x37,%dil
cmp    $0xa0,%cl
movzbl %bl,%ecx
movzbl %dil,%edi
cmovb  %ecx,%edi
mov    %dil,(%rsi)
movzbl (%r15,%rdx,1),%ecx
and    $0xf,%cl
lea    0x30(%rcx),%edi
lea    0x37(%rcx),%ebx
cmp    $0xa,%cl
movzbl %dil,%ecx
movzbl %bl,%edi
cmovb  %ecx,%edi
mov    %dil,0x1(%rsi)
add    $0x2,%rsi
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1150 <bin2hex+0x40>
jmp    126c <bin2hex+0x15c>
mov    %rax,%rsi
jmp    126c <bin2hex+0x15c>
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    (%rax,%rdx,2),%rsi
xor    %edi,%edi
movdqa 0xe40(%rip),%xmm8
movdqa 0xe47(%rip),%xmm9
movdqa 0xe4f(%rip),%xmm2
movdqa 0xe57(%rip),%xmm3
movdqa 0xe5f(%rip),%xmm4
movdqa 0xe67(%rip),%xmm5
nopl   0x0(%rax)
movq   (%r15,%rdi,1),%xmm6
movdqa %xmm6,%xmm7
psrlw  $0x4,%xmm7
pand   %xmm8,%xmm7
movdqa %xmm6,%xmm0
pmaxub %xmm9,%xmm0
pcmpeqb %xmm6,%xmm0
movdqa %xmm7,%xmm1
por    %xmm2,%xmm1
paddb  %xmm3,%xmm7
pand   %xmm0,%xmm7
pandn  %xmm1,%xmm0
por    %xmm7,%xmm0
pand   %xmm4,%xmm6
movdqa %xmm6,%xmm1
pmaxub %xmm5,%xmm1
pcmpeqb %xmm6,%xmm1
movdqa %xmm6,%xmm7
por    %xmm2,%xmm7
paddb  %xmm3,%xmm6
pand   %xmm1,%xmm6
pandn  %xmm7,%xmm1
por    %xmm6,%xmm1
punpcklbw %xmm1,%xmm0
movdqu %xmm0,(%rax,%rdi,2)
add    $0x8,%rdi
cmp    %rdi,%rdx
jne    11f0 <bin2hex+0xe0>
cmp    %r8,%rdx
jne    1150 <bin2hex+0x40>
movb   $0x0,(%rsi)
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define i8* @bin2hex(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8
store i8* %0, i8** %3
store i32 %1, i32* %4
store i32 0, i32* %5
store i32 0, i32* %6
store i8* null, i8** %7
store i8* null, i8** %8
store i8 65, i8* %9
%10 = load i32, i32* %4
%11 = mul nsw i32 %10, 2
%12 = add nsw i32 %11, 1
%13 = call i64 @malloc(i32 %12)
%14 = inttoptr i64 %13 to i8*
store i8* %14, i8** %7
store i8* %14, i8** %8
store i32 0, i32* %5
br label %15
15: ; preds = %66, %2
%16 = load i32, i32* %5
%17 = load i32, i32* %4
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %69
19: ; preds = %15
%20 = load i8*, i8** %3
%21 = load i32, i32* %5
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %20, i64 %22
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
%26 = ashr i32 %25, 4
store i32 %26, i32* %6
%27 = load i32, i32* %6
%28 = icmp slt i32 %27, 10
br i1 %28, label %29, label %32
29: ; preds = %19
%30 = load i32, i32* %6
%31 = add nsw i32 %30, 48
br label %38
32: ; preds = %19
%33 = load i32, i32* %6
%34 = sub nsw i32 %33, 10
%35 = load i8, i8* %9
%36 = sext i8 %35 to i32
%37 = add nsw i32 %34, %36
br label %38
38: ; preds = %32, %29
%39 = phi i32 [ %31, %29 ], [ %37, %32 ]
%40 = trunc i32 %39 to i8
%41 = load i8*, i8** %7
%42 = getelementptr inbounds i8, i8* %41, i32 1
store i8* %42, i8** %7
store i8 %40, i8* %41
%43 = load i8*, i8** %3
%44 = load i32, i32* %5
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %43, i64 %45
%47 = load i8, i8* %46
%48 = zext i8 %47 to i32
%49 = and i32 %48, 15
store i32 %49, i32* %6
%50 = load i32, i32* %6
%51 = icmp slt i32 %50, 10
br i1 %51, label %52, label %55
52: ; preds = %38
%53 = load i32, i32* %6
%54 = add nsw i32 %53, 48
br label %61
55: ; preds = %38
%56 = load i32, i32* %6
%57 = sub nsw i32 %56, 10
%58 = load i8, i8* %9
%59 = sext i8 %58 to i32
%60 = add nsw i32 %57, %59
br label %61
61: ; preds = %55, %52
%62 = phi i32 [ %54, %52 ], [ %60, %55 ]
%63 = trunc i32 %62 to i8
%64 = load i8*, i8** %7
%65 = getelementptr inbounds i8, i8* %64, i32 1
store i8* %65, i8** %7
store i8 %63, i8* %64
br label %66
66: ; preds = %61
%67 = load i32, i32* %5
%68 = add nsw i32 %67, 1
store i32 %68, i32* %5
br label %15
69: ; preds = %15
%70 = load i8*, i8** %7
store i8 0, i8* %70
%71 = load i8*, i8** %8
ret i8* %71
}

LLVM IR (-O2):
define i8* @bin2hex(i8* nocapture %0, i32 %1) {
%3 = shl nsw i32 %1, 1
%4 = or i32 %3, 1
%5 = tail call i64 @malloc(i32 %4)
%6 = inttoptr i64 %5 to i8*
%7 = icmp sgt i32 %1, 0
br i1 %7, label %8, label %70
8: ; preds = %2
%9 = zext i32 %1 to i64
%10 = icmp ult i32 %1, 8
br i1 %10, label %47, label %11
11: ; preds = %8
%12 = shl nuw nsw i64 %9, 1
%13 = getelementptr i8, i8* %6, i64 %12
%14 = getelementptr i8, i8* %0, i64 %9
%15 = icmp ugt i8* %14, %6
%16 = icmp ugt i8* %13, %0
%17 = and i1 %15, %16
br i1 %17, label %47, label %18
18: ; preds = %11
%19 = and i64 %9, 4294967288
%20 = shl nuw nsw i64 %19, 1
%21 = getelementptr i8, i8* %6, i64 %20
br label %22
22: ; preds = %22, %18
%23 = phi i64 [ 0, %18 ], [ %43, %22 ]
%24 = shl i64 %23, 1
%25 = getelementptr inbounds i8, i8* %0, i64 %23
%26 = bitcast i8* %25 to <8 x i8>*
%27 = load <8 x i8>, <8 x i8>* %26
%28 = lshr <8 x i8> %27, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%29 = icmp ult <8 x i8> %27, <i8 -96, i8 -96, i8 -96, i8 -96, i8 -96, i8 -96, i8 -96, i8 -96>
%30 = or <8 x i8> %28, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%31 = add nuw nsw <8 x i8> %28, <i8 55, i8 55, i8 55, i8 55, i8 55, i8 55, i8 55, i8 55>
%32 = select <8 x i1> %29, <8 x i8> %30, <8 x i8> %31
%33 = bitcast i8* %25 to <8 x i8>*
%34 = load <8 x i8>, <8 x i8>* %33
%35 = and <8 x i8> %34, <i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15, i8 15>
%36 = icmp ult <8 x i8> %35, <i8 10, i8 10, i8 10, i8 10, i8 10, i8 10, i8 10, i8 10>
%37 = or <8 x i8> %35, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%38 = add nuw nsw <8 x i8> %35, <i8 55, i8 55, i8 55, i8 55, i8 55, i8 55, i8 55, i8 55>
%39 = select <8 x i1> %36, <8 x i8> %37, <8 x i8> %38
%40 = getelementptr inbounds i8, i8* %6, i64 %24
%41 = bitcast i8* %40 to <16 x i8>*
%42 = shufflevector <8 x i8> %32, <8 x i8> %39, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
store <16 x i8> %42, <16 x i8>* %41
%43 = add nuw i64 %23, 8
%44 = icmp eq i64 %43, %19
br i1 %44, label %45, label %22
45: ; preds = %22
%46 = icmp eq i64 %19, %9
br i1 %46, label %70, label %47
47: ; preds = %11, %8, %45
%48 = phi i64 [ 0, %11 ], [ 0, %8 ], [ %19, %45 ]
%49 = phi i8* [ %6, %11 ], [ %6, %8 ], [ %21, %45 ]
br label %50
50: ; preds = %47, %50
%51 = phi i64 [ %68, %50 ], [ %48, %47 ]
%52 = phi i8* [ %67, %50 ], [ %49, %47 ]
%53 = getelementptr inbounds i8, i8* %0, i64 %51
%54 = load i8, i8* %53
%55 = lshr i8 %54, 4
%56 = icmp ult i8 %54, -96
%57 = or i8 %55, 48
%58 = add nuw nsw i8 %55, 55
%59 = select i1 %56, i8 %57, i8 %58
%60 = getelementptr inbounds i8, i8* %52, i64 1
store i8 %59, i8* %52
%61 = load i8, i8* %53
%62 = and i8 %61, 15
%63 = icmp ult i8 %62, 10
%64 = or i8 %62, 48
%65 = add nuw nsw i8 %62, 55
%66 = select i1 %63, i8 %64, i8 %65
%67 = getelementptr inbounds i8, i8* %52, i64 2
store i8 %66, i8* %60
%68 = add nuw nsw i64 %51, 1
%69 = icmp eq i64 %68, %9
br i1 %69, label %70, label %50
70: ; preds = %50, %45, %2
%71 = phi i8* [ %6, %2 ], [ %21, %45 ], [ %67, %50 ]
store i8 0, i8* %71
ret i8* %6
}