long utilAry2Str(unsigned char *byAry, unsigned long lAryCnt, char *sBuf) {
  unsigned long lCnt;
  unsigned char iHex;
  char *pPtr;
  if (byAry == (0) || sBuf == (0))
    return (-1);
  for (lCnt = 0, pPtr = sBuf; lCnt < lAryCnt; lCnt++) {
    iHex = (byAry[lCnt] & 0xf0) >> 4;
    if (iHex <= 9)
      *pPtr++ = iHex + '0';
    else
      *pPtr++ = iHex - 0 + 'a';
    iHex = byAry[lCnt] & 0x0f;
    if (iHex <= 9)
      *pPtr++ = iHex + '0';
    else
      *pPtr++ = iHex - 0 + 'a';
  }
  *pPtr = '\0';
  return (0);
}


x86 assembly (clang, -O0):
<utilAry2Str>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1126 <utilAry2Str+0x26>
cmpq   $0x0,-0x20(%rbp)
jne    1133 <utilAry2Str+0x33>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
jmp    1231 <utilAry2Str+0x131>
movq   $0x0,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1222 <utilAry2Str+0x122>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xf0,%eax
sar    $0x4,%eax
mov    %al,-0x29(%rbp)
movzbl -0x29(%rbp),%eax
cmp    $0x9,%eax
jg     1194 <utilAry2Str+0x94>
movzbl -0x29(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    11b1 <utilAry2Str+0xb1>
movzbl -0x29(%rbp),%eax
sub    $0x0,%eax
add    $0x61,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xf,%eax
mov    %al,-0x29(%rbp)
movzbl -0x29(%rbp),%eax
cmp    $0x9,%eax
jg     11ef <utilAry2Str+0xef>
movzbl -0x29(%rbp),%eax
add    $0x30,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    120c <utilAry2Str+0x10c>
movzbl -0x29(%rbp),%eax
sub    $0x0,%eax
add    $0x61,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    1211 <utilAry2Str+0x111>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1143 <utilAry2Str+0x43>
mov    -0x38(%rbp),%rax
movb   $0x0,(%rax)
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<utilAry2Str>:
mov    $0xffffffffffffffff,%rax
test   %rdi,%rdi
je     1263 <utilAry2Str+0x163>
test   %rdx,%rdx
je     1263 <utilAry2Str+0x163>
test   %rsi,%rsi
je     118c <utilAry2Str+0x8c>
cmp    $0x8,%rsi
jb     1136 <utilAry2Str+0x36>
lea    (%rdi,%rsi,1),%rax
cmp    %rdx,%rax
jbe    1194 <utilAry2Str+0x94>
lea    (%rdx,%rsi,2),%rax
cmp    %rdi,%rax
jbe    1194 <utilAry2Str+0x94>
xor    %r10d,%r10d
mov    %rdx,%r9
nopl   0x0(%rax)
movzbl (%rdi,%r10,1),%edx
mov    %edx,%eax
shr    $0x4,%al
lea    0x61(%rax),%ecx
or     $0x30,%al
cmp    $0xa0,%dl
movzbl %al,%eax
movzbl %cl,%ecx
cmovb  %eax,%ecx
mov    %cl,(%r9)
movzbl (%rdi,%r10,1),%eax
and    $0xf,%al
lea    0x61(%rax),%ecx
lea    0x30(%rax),%edx
cmp    $0xa,%al
movzbl %dl,%eax
movzbl %cl,%ecx
cmovb  %eax,%ecx
mov    %cl,0x1(%r9)
add    $0x2,%r9
add    $0x1,%r10
cmp    %r10,%rsi
jne    1140 <utilAry2Str+0x40>
jmp    125d <utilAry2Str+0x15d>
mov    %rdx,%r9
jmp    125d <utilAry2Str+0x15d>
mov    %rsi,%r10
and    $0xfffffffffffffff8,%r10
lea    (%rdx,%r10,2),%r9
xor    %r8d,%r8d
movdqa 0xe55(%rip),%xmm8
movdqa 0xe5c(%rip),%xmm9
movdqa 0xe64(%rip),%xmm2
movdqa 0xe6c(%rip),%xmm3
movdqa 0xe74(%rip),%xmm4
movdqa 0xe7c(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   (%rdi,%r8,1),%xmm0
movdqa %xmm0,%xmm7
psrlw  $0x4,%xmm7
pand   %xmm8,%xmm7
movdqa %xmm0,%xmm6
pmaxub %xmm9,%xmm6
pcmpeqb %xmm0,%xmm6
movdqa %xmm7,%xmm1
paddb  %xmm2,%xmm1
por    %xmm3,%xmm7
pand   %xmm6,%xmm1
pandn  %xmm7,%xmm6
por    %xmm1,%xmm6
pand   %xmm4,%xmm0
movdqa %xmm0,%xmm1
pmaxub %xmm5,%xmm1
pcmpeqb %xmm0,%xmm1
movdqa %xmm0,%xmm7
paddb  %xmm2,%xmm7
por    %xmm3,%xmm0
pand   %xmm1,%xmm7
pandn  %xmm0,%xmm1
por    %xmm7,%xmm1
punpcklbw %xmm1,%xmm6
movdqu %xmm6,(%rdx,%r8,2)
add    $0x8,%r8
cmp    %r8,%r10
jne    11e0 <utilAry2Str+0xe0>
cmp    %rsi,%r10
jne    1140 <utilAry2Str+0x40>
movb   $0x0,(%r9)
xor    %eax,%eax
ret

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

LLVM IR (-O2):
define i64 @utilAry2Str(i8* %0, i64 %1, i8* writeonly %2) {
%4 = icmp eq i8* %0, null
%5 = icmp eq i8* %2, null
%6 = or i1 %4, %5
br i1 %6, label %72, label %7
7: ; preds = %3
%8 = icmp eq i64 %1, 0
br i1 %8, label %70, label %9
9: ; preds = %7
%10 = icmp ult i64 %1, 8
br i1 %10, label %47, label %11
11: ; preds = %9
%12 = shl i64 %1, 1
%13 = getelementptr i8, i8* %2, i64 %12
%14 = getelementptr i8, i8* %0, i64 %1
%15 = icmp ugt i8* %14, %2
%16 = icmp ugt i8* %13, %0
%17 = and i1 %15, %16
br i1 %17, label %47, label %18
18: ; preds = %11
%19 = and i64 %1, -8
%20 = shl i64 %19, 1
%21 = getelementptr i8, i8* %2, 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 = add nuw nsw <8 x i8> %28, <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
%31 = or <8 x i8> %28, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%32 = select <8 x i1> %29, <8 x i8> %31, <8 x i8> %30
%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 = add nuw nsw <8 x i8> %35, <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
%38 = or <8 x i8> %35, <i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48, i8 48>
%39 = select <8 x i1> %36, <8 x i8> %38, <8 x i8> %37
%40 = getelementptr inbounds i8, i8* %2, 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, %1
br i1 %46, label %70, label %47
47: ; preds = %11, %9, %45
%48 = phi i8* [ %2, %11 ], [ %2, %9 ], [ %21, %45 ]
%49 = phi i64 [ 0, %11 ], [ 0, %9 ], [ %19, %45 ]
br label %50
50: ; preds = %47, %50
%51 = phi i8* [ %67, %50 ], [ %48, %47 ]
%52 = phi i64 [ %68, %50 ], [ %49, %47 ]
%53 = getelementptr inbounds i8, i8* %0, i64 %52
%54 = load i8, i8* %53
%55 = lshr i8 %54, 4
%56 = icmp ult i8 %54, -96
%57 = add nuw nsw i8 %55, 97
%58 = or i8 %55, 48
%59 = select i1 %56, i8 %58, i8 %57
%60 = getelementptr inbounds i8, i8* %51, i64 1
store i8 %59, i8* %51
%61 = load i8, i8* %53
%62 = and i8 %61, 15
%63 = icmp ult i8 %62, 10
%64 = add nuw nsw i8 %62, 97
%65 = or i8 %62, 48
%66 = select i1 %63, i8 %65, i8 %64
%67 = getelementptr inbounds i8, i8* %51, i64 2
store i8 %66, i8* %60
%68 = add nuw i64 %52, 1
%69 = icmp eq i64 %68, %1
br i1 %69, label %70, label %50
70: ; preds = %50, %45, %7
%71 = phi i8* [ %2, %7 ], [ %21, %45 ], [ %67, %50 ]
store i8 0, i8* %71
br label %72
72: ; preds = %3, %70
%73 = phi i64 [ 0, %70 ], [ -1, %3 ]
ret i64 %73
}