void HexToAsciiString(unsigned char *pHex, unsigned char *pAscii,
                      unsigned int size) {
  unsigned int i;
  unsigned char vNible;
  for (i = 0; i < size; i++) {
    vNible = ((*pHex) & 0xF0) >> 4;
    if (vNible > 9) {
      vNible = vNible - 0x0A;
      vNible = vNible + 0x41;
    } else {
      vNible = vNible + 0x30;
    }
    *pAscii++ = vNible;
    vNible = ((*pHex) & 0x0F);
    if (vNible > 9) {
      vNible = vNible - 0x0A;
      vNible = vNible + 0x41;
    } else {
      vNible = vNible + 0x30;
    }
    *pAscii++ = vNible;
    pHex++;
  }
}


x86 assembly (clang, -O0):
<HexToAsciiString>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    11e3 <HexToAsciiString+0xe3>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
and    $0xf0,%eax
sar    $0x4,%eax
mov    %al,-0x19(%rbp)
movzbl -0x19(%rbp),%eax
cmp    $0x9,%eax
jle    115a <HexToAsciiString+0x5a>
movzbl -0x19(%rbp),%eax
sub    $0xa,%eax
mov    %al,-0x19(%rbp)
movzbl -0x19(%rbp),%eax
add    $0x41,%eax
mov    %al,-0x19(%rbp)
jmp    1164 <HexToAsciiString+0x64>
movzbl -0x19(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
and    $0xf,%eax
mov    %al,-0x19(%rbp)
movzbl -0x19(%rbp),%eax
cmp    $0x9,%eax
jle    11ab <HexToAsciiString+0xab>
movzbl -0x19(%rbp),%eax
sub    $0xa,%eax
mov    %al,-0x19(%rbp)
movzbl -0x19(%rbp),%eax
add    $0x41,%eax
mov    %al,-0x19(%rbp)
jmp    11b5 <HexToAsciiString+0xb5>
movzbl -0x19(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1116 <HexToAsciiString+0x16>
pop    %rbp
ret

x86 assembly (clang, -O2):
<HexToAsciiString>:
test   %edx,%edx
je     118d <HexToAsciiString+0x8d>
lea    -0x1(%rdx),%r9d
xor    %r8d,%r8d
cmp    $0x7,%r9d
jb     112f <HexToAsciiString+0x2f>
lea    (%r9,%rdi,1),%rax
add    $0x1,%rax
cmp    %rsi,%rax
jbe    118e <HexToAsciiString+0x8e>
lea    (%rsi,%r9,2),%rax
add    $0x2,%rax
cmp    %rdi,%rax
jbe    118e <HexToAsciiString+0x8e>
mov    %rdi,%r10
mov    %rsi,%r11
sub    %r8d,%edx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movzbl (%r10,%rax,1),%ecx
mov    %ecx,%esi
shr    $0x4,%sil
lea    0x37(%rsi),%edi
or     $0x30,%sil
cmp    $0xa0,%cl
movzbl %dil,%ecx
movzbl %sil,%esi
cmovae %ecx,%esi
mov    %sil,(%r11,%rax,2)
movzbl (%r10,%rax,1),%ecx
and    $0xf,%cl
lea    0x37(%rcx),%esi
lea    0x30(%rcx),%edi
cmp    $0xa,%cl
movzbl %sil,%ecx
movzbl %dil,%esi
cmovae %ecx,%esi
mov    %sil,0x1(%r11,%rax,2)
add    $0x1,%rax
cmp    %eax,%edx
jne    1140 <HexToAsciiString+0x40>
ret
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    (%rdi,%r8,1),%r10
lea    (%rsi,%r8,2),%r11
xor    %eax,%eax
movdqa 0xe54(%rip),%xmm8
movdqa 0xe5b(%rip),%xmm9
movdqa 0xe63(%rip),%xmm2
movdqa 0xe6b(%rip),%xmm3
movdqa 0xe73(%rip),%xmm4
movdqa 0xe7b(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
nop
movq   (%rdi,%rax,1),%xmm6
movdqa %xmm6,%xmm7
psrlw  $0x4,%xmm7
pand   %xmm8,%xmm7
movdqa %xmm6,%xmm0
pminub %xmm9,%xmm0
pcmpeqb %xmm6,%xmm0
movdqa %xmm7,%xmm1
paddb  %xmm2,%xmm1
por    %xmm3,%xmm7
pand   %xmm0,%xmm7
pandn  %xmm1,%xmm0
por    %xmm7,%xmm0
pand   %xmm4,%xmm6
movdqa %xmm6,%xmm1
pminub %xmm5,%xmm1
pcmpeqb %xmm6,%xmm1
movdqa %xmm6,%xmm7
paddb  %xmm2,%xmm7
por    %xmm3,%xmm6
pand   %xmm1,%xmm6
pandn  %xmm7,%xmm1
por    %xmm6,%xmm1
punpcklbw %xmm1,%xmm0
movdqu %xmm0,(%rsi,%rax,2)
add    $0x8,%rax
cmp    %rax,%r8
jne    11e0 <HexToAsciiString+0xe0>
cmp    %r8,%r9
jne    1135 <HexToAsciiString+0x35>
jmp    118d <HexToAsciiString+0x8d>

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

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