int bin2hex(const unsigned char *in, int len, char *out) {
  int n1, n2;
  unsigned char ch;
  for (n1 = 0, n2 = 0; n1 < len; ++n1) {
    ch = in[n1] >> 4;
    if (ch <= 0x09)
      out[n2++] = ch + '0';
    else
      out[n2++] = ch - 10 + 'a';
    ch = in[n1] & 0x0f;
    if (ch <= 0x09)
      out[n2++] = ch + '0';
    else
      out[n2++] = ch - 10 + 'a';
  }
  out[n2] = '\0';
  return n2;
}


x86 assembly (clang, -O0):
<bin2hex>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1202 <bin2hex+0x102>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
sar    $0x4,%eax
mov    %al,-0x21(%rbp)
movzbl -0x21(%rbp),%eax
cmp    $0x9,%eax
jg     116b <bin2hex+0x6b>
movzbl -0x21(%rbp),%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    118c <bin2hex+0x8c>
movzbl -0x21(%rbp),%eax
sub    $0xa,%eax
add    $0x61,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xf,%eax
mov    %al,-0x21(%rbp)
movzbl -0x21(%rbp),%eax
cmp    $0x9,%eax
jg     11ce <bin2hex+0xce>
movzbl -0x21(%rbp),%eax
add    $0x30,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    11ef <bin2hex+0xef>
movzbl -0x21(%rbp),%eax
sub    $0xa,%eax
add    $0x61,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
jmp    11f4 <bin2hex+0xf4>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    111d <bin2hex+0x1d>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<bin2hex>:
test   %esi,%esi
jle    1189 <bin2hex+0x89>
mov    %esi,%r8d
cmp    $0x8,%esi
jb     1122 <bin2hex+0x22>
lea    (%rdi,%r8,1),%rax
cmp    %rdx,%rax
jbe    1190 <bin2hex+0x90>
lea    (%rdx,%r8,2),%rax
cmp    %rdi,%rax
jbe    1190 <bin2hex+0x90>
xor    %r9d,%r9d
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movzbl (%rdi,%r9,1),%ecx
mov    %ecx,%esi
shr    $0x4,%sil
lea    0x30(%rsi),%r10d
add    $0x57,%sil
cmp    $0xa0,%cl
movzbl %r10b,%ecx
movzbl %sil,%esi
cmovb  %ecx,%esi
mov    %sil,(%rdx,%rax,1)
movzbl (%rdi,%r9,1),%ecx
and    $0xf,%cl
lea    0x30(%rcx),%r10d
lea    0x57(%rcx),%esi
cmp    $0xa,%cl
movzbl %r10b,%ecx
movzbl %sil,%esi
cmovb  %ecx,%esi
mov    %sil,0x1(%rdx,%rax,1)
add    $0x2,%rax
add    $0x1,%r9
cmp    %r9,%r8
jne    1130 <bin2hex+0x30>
jmp    124b <bin2hex+0x14b>
xor    %eax,%eax
jmp    124b <bin2hex+0x14b>
mov    %r8d,%r9d
and    $0xfffffff8,%r9d
lea    (%r9,%r9,1),%rax
xor    %ecx,%ecx
movdqa 0xe5a(%rip),%xmm8
movdqa 0xe61(%rip),%xmm9
movdqa 0xe69(%rip),%xmm2
movdqa 0xe71(%rip),%xmm3
movdqa 0xe79(%rip),%xmm4
movdqa 0xe81(%rip),%xmm5
nop
movq   (%rdi,%rcx,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,(%rdx,%rcx,2)
add    $0x8,%rcx
cmp    %rcx,%r9
jne    11d0 <bin2hex+0xd0>
cmp    %r8,%r9
jne    1130 <bin2hex+0x30>
mov    %eax,%ecx
movb   $0x0,(%rdx,%rcx,1)
ret

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

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