#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 */
void hex2bin(char *dst, const char *src, size_t count) {
  for (; count; count--, dst++, src += 2)
    *dst = (src[0] - (src[0] <= '9' ? '0' : 87)) * 16 +
           (src[1] - (src[1] <= '9' ? '0' : 87));
}


x86 assembly (clang, -O0):
<hex2bin>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1193 <hex2bin+0x93>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
mov    -0x10(%rbp),%rcx
movsbl (%rcx),%esi
mov    $0x57,%ecx
mov    $0x30,%edx
cmp    $0x39,%esi
cmovle %edx,%ecx
sub    %ecx,%eax
shl    $0x4,%eax
mov    -0x10(%rbp),%rcx
movsbl 0x1(%rcx),%ecx
mov    -0x10(%rbp),%rdx
movsbl 0x1(%rdx),%edi
mov    $0x57,%edx
mov    $0x30,%esi
cmp    $0x39,%edi
cmovle %esi,%edx
sub    %edx,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
jmp    1110 <hex2bin+0x10>
pop    %rbp
ret

x86 assembly (clang, -O2):
<hex2bin>:
test   %rdx,%rdx
je     120d <hex2bin+0x10d>
cmp    $0x8,%rdx
jb     1129 <hex2bin+0x29>
lea    (%rsi,%rdx,2),%rax
cmp    %rdi,%rax
jbe    120e <hex2bin+0x10e>
lea    (%rdi,%rdx,1),%rax
cmp    %rsi,%rax
jbe    120e <hex2bin+0x10e>
mov    %rdx,%r9
mov    %rsi,%r11
mov    %rdi,%r8
test   $0x1,%r9b
jne    1146 <hex2bin+0x46>
mov    %r9,%r10
cmp    $0x1,%r9
jne    118f <hex2bin+0x8f>
jmp    120d <hex2bin+0x10d>
mov    (%r11),%cl
mov    0x1(%r11),%dl
xor    %esi,%esi
cmp    $0x3a,%cl
setge  %sil
lea    (%rsi,%rsi,8),%esi
add    %cl,%sil
shl    $0x4,%sil
cmp    $0x3a,%dl
mov    $0xd0,%ecx
mov    $0xa9,%edi
cmovl  %ecx,%edi
add    %dl,%dil
add    %sil,%dil
mov    %dil,(%r8)
lea    -0x1(%r9),%r10
add    $0x1,%r8
add    $0x2,%r11
cmp    $0x1,%r9
je     120d <hex2bin+0x10d>
xor    %edx,%edx
mov    $0xd0,%esi
cs nopw 0x0(%rax,%rax,1)
movzbl (%r11,%rdx,2),%ecx
movzbl 0x1(%r11,%rdx,2),%eax
xor    %edi,%edi
cmp    $0x3a,%cl
setge  %dil
lea    (%rdi,%rdi,8),%edi
add    %cl,%dil
shl    $0x4,%dil
cmp    $0x3a,%al
mov    $0xa9,%ecx
cmovl  %esi,%ecx
add    %al,%cl
add    %dil,%cl
mov    %cl,(%r8,%rdx,1)
movzbl 0x2(%r11,%rdx,2),%eax
movzbl 0x3(%r11,%rdx,2),%ecx
xor    %edi,%edi
cmp    $0x3a,%al
setge  %dil
lea    (%rdi,%rdi,8),%edi
add    %al,%dil
shl    $0x4,%dil
cmp    $0x3a,%cl
mov    $0xa9,%eax
cmovl  %esi,%eax
add    %cl,%al
add    %dil,%al
mov    %al,0x1(%r8,%rdx,1)
add    $0x2,%rdx
cmp    %rdx,%r10
jne    11a0 <hex2bin+0xa0>
ret
cmp    $0x10,%rdx
jae    121b <hex2bin+0x11b>
xor    %ecx,%ecx
jmp    12f6 <hex2bin+0x1f6>
mov    %rdx,%rcx
and    $0xfffffffffffffff0,%rcx
xor    %eax,%eax
movdqa 0xdd4(%rip),%xmm0
movdqa 0xddc(%rip),%xmm1
movdqa 0xde3(%rip),%xmm8
movdqa 0xdea(%rip),%xmm9
movdqa 0xdf2(%rip),%xmm4
movdqa 0xdfa(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
movdqu (%rsi,%rax,2),%xmm3
movdqu 0x10(%rsi,%rax,2),%xmm7
movdqa %xmm7,%xmm2
pand   %xmm0,%xmm2
movdqa %xmm3,%xmm6
pand   %xmm0,%xmm6
packuswb %xmm2,%xmm6
psrlw  $0x8,%xmm7
psrlw  $0x8,%xmm3
packuswb %xmm7,%xmm3
movdqa %xmm1,%xmm2
pcmpgtb %xmm6,%xmm2
pandn  %xmm8,%xmm2
paddb  %xmm6,%xmm2
psllw  $0x4,%xmm2
pand   %xmm9,%xmm2
movdqa %xmm1,%xmm6
pcmpgtb %xmm3,%xmm6
movdqa %xmm6,%xmm7
pandn  %xmm4,%xmm7
pand   %xmm5,%xmm6
por    %xmm7,%xmm6
paddb  %xmm3,%xmm6
paddb  %xmm2,%xmm6
movdqu %xmm6,(%rdi,%rax,1)
add    $0x10,%rax
cmp    %rax,%rcx
jne    1260 <hex2bin+0x160>
cmp    %rdx,%rcx
je     120d <hex2bin+0x10d>
test   $0x8,%dl
jne    12f6 <hex2bin+0x1f6>
add    %rcx,%rdi
lea    (%rsi,%rcx,2),%r11
and    $0xf,%edx
mov    %rdx,%r9
jmp    112f <hex2bin+0x2f>
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
mov    %edx,%r9d
and    $0x7,%r9d
lea    (%rsi,%r10,2),%r11
lea    (%rdi,%r10,1),%r8
movdqa 0xceb(%rip),%xmm8
movdqa 0xd43(%rip),%xmm0
movdqa 0xd4a(%rip),%xmm9
movdqa 0xd02(%rip),%xmm3
movdqa 0xd4a(%rip),%xmm4
movdqa 0xd52(%rip),%xmm5
xchg   %ax,%ax
movdqu (%rsi,%rcx,2),%xmm6
movdqa %xmm6,%xmm7
pand   %xmm8,%xmm7
packuswb %xmm7,%xmm7
psrlw  $0x8,%xmm6
packuswb %xmm6,%xmm6
movdqa %xmm0,%xmm1
pcmpgtb %xmm7,%xmm1
pandn  %xmm9,%xmm1
paddb  %xmm7,%xmm1
psllw  $0x4,%xmm1
pand   %xmm3,%xmm1
movdqa %xmm0,%xmm7
pcmpgtb %xmm6,%xmm7
movdqa %xmm7,%xmm2
pandn  %xmm4,%xmm2
pand   %xmm5,%xmm7
por    %xmm2,%xmm7
paddb  %xmm6,%xmm7
paddb  %xmm1,%xmm7
movq   %xmm7,(%rdi,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%r10
jne    1340 <hex2bin+0x240>
cmp    %rdx,%r10
jne    1132 <hex2bin+0x32>
jmp    120d <hex2bin+0x10d>

LLVM IR (-O0):
define void @hex2bin(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 %2, i64* %6
br label %7
7: ; preds = %39, %3
%8 = load i64, i64* %6
%9 = icmp ne i64 %8, 0
br i1 %9, label %10, label %46
10: ; preds = %7
%11 = load i8*, i8** %5
%12 = getelementptr inbounds i8, i8* %11, i64 0
%13 = load i8, i8* %12
%14 = sext i8 %13 to i32
%15 = load i8*, i8** %5
%16 = getelementptr inbounds i8, i8* %15, i64 0
%17 = load i8, i8* %16
%18 = sext i8 %17 to i32
%19 = icmp sle i32 %18, 57
%20 = zext i1 %19 to i64
%21 = select i1 %19, i32 48, i32 87
%22 = sub nsw i32 %14, %21
%23 = mul nsw i32 %22, 16
%24 = load i8*, i8** %5
%25 = getelementptr inbounds i8, i8* %24, i64 1
%26 = load i8, i8* %25
%27 = sext i8 %26 to i32
%28 = load i8*, i8** %5
%29 = getelementptr inbounds i8, i8* %28, i64 1
%30 = load i8, i8* %29
%31 = sext i8 %30 to i32
%32 = icmp sle i32 %31, 57
%33 = zext i1 %32 to i64
%34 = select i1 %32, i32 48, i32 87
%35 = sub nsw i32 %27, %34
%36 = add nsw i32 %23, %35
%37 = trunc i32 %36 to i8
%38 = load i8*, i8** %4
store i8 %37, i8* %38
br label %39
39: ; preds = %10
%40 = load i64, i64* %6
%41 = add i64 %40, -1
store i64 %41, i64* %6
%42 = load i8*, i8** %4
%43 = getelementptr inbounds i8, i8* %42, i32 1
store i8* %43, i8** %4
%44 = load i8*, i8** %5
%45 = getelementptr inbounds i8, i8* %44, i64 2
store i8* %45, i8** %5
br label %7
46: ; preds = %7
ret void
}

LLVM IR (-O2):
define void @hex2bin(i8* nocapture writeonly %0, i8* nocapture %1, i64 %2) {
%4 = icmp eq i64 %2, 0
br i1 %4, label %134, label %5
5: ; preds = %3
%6 = icmp ult i64 %2, 8
br i1 %6, label %76, label %7
7: ; preds = %5
%8 = getelementptr i8, i8* %0, i64 %2
%9 = shl i64 %2, 1
%10 = getelementptr i8, i8* %1, i64 %9
%11 = icmp ugt i8* %10, %0
%12 = icmp ugt i8* %8, %1
%13 = and i1 %11, %12
br i1 %13, label %76, label %14
14: ; preds = %7
%15 = icmp ult i64 %2, 16
br i1 %15, label %47, label %16
16: ; preds = %14
%17 = and i64 %2, -16
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %36, %18 ]
%20 = shl i64 %19, 1
%21 = getelementptr i8, i8* %1, i64 %20
%22 = getelementptr i8, i8* %0, i64 %19
%23 = bitcast i8* %21 to <32 x i8>*
%24 = load <32 x i8>, <32 x i8>* %23
%25 = shufflevector <32 x i8> %24, <32 x i8> poison, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
%26 = shufflevector <32 x i8> %24, <32 x i8> poison, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
%27 = icmp slt <16 x i8> %25, <i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58>
%28 = select <16 x i1> %27, <16 x i8> zeroinitializer, <16 x i8> <i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9>
%29 = add <16 x i8> %28, %25
%30 = shl <16 x i8> %29, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%31 = icmp slt <16 x i8> %26, <i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58>
%32 = select <16 x i1> %31, <16 x i8> <i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48>, <16 x i8> <i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87>
%33 = add <16 x i8> %32, %26
%34 = add <16 x i8> %33, %30
%35 = bitcast i8* %22 to <16 x i8>*
store <16 x i8> %34, <16 x i8>* %35
%36 = add nuw i64 %19, 16
%37 = icmp eq i64 %36, %17
br i1 %37, label %38, label %18
38: ; preds = %18
%39 = icmp eq i64 %17, %2
br i1 %39, label %134, label %40
40: ; preds = %38
%41 = getelementptr i8, i8* %0, i64 %17
%42 = shl i64 %17, 1
%43 = getelementptr i8, i8* %1, i64 %42
%44 = and i64 %2, 15
%45 = and i64 %2, 8
%46 = icmp eq i64 %45, 0
br i1 %46, label %76, label %47
47: ; preds = %14, %40
%48 = phi i64 [ %17, %40 ], [ 0, %14 ]
%49 = and i64 %2, -8
%50 = and i64 %2, 7
%51 = shl i64 %49, 1
%52 = getelementptr i8, i8* %1, i64 %51
%53 = getelementptr i8, i8* %0, i64 %49
br label %54
54: ; preds = %54, %47
%55 = phi i64 [ %48, %47 ], [ %72, %54 ]
%56 = shl i64 %55, 1
%57 = getelementptr i8, i8* %1, i64 %56
%58 = getelementptr i8, i8* %0, i64 %55
%59 = bitcast i8* %57 to <16 x i8>*
%60 = load <16 x i8>, <16 x i8>* %59
%61 = shufflevector <16 x i8> %60, <16 x i8> poison, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
%62 = shufflevector <16 x i8> %60, <16 x i8> poison, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
%63 = icmp slt <8 x i8> %61, <i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58>
%64 = select <8 x i1> %63, <8 x i8> zeroinitializer, <8 x i8> <i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9, i8 9>
%65 = add <8 x i8> %64, %61
%66 = shl <8 x i8> %65, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%67 = icmp slt <8 x i8> %62, <i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58, i8 58>
%68 = select <8 x i1> %67, <8 x i8> <i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48, i8 -48>, <8 x i8> <i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87, i8 -87>
%69 = add <8 x i8> %68, %62
%70 = add <8 x i8> %69, %66
%71 = bitcast i8* %58 to <8 x i8>*
store <8 x i8> %70, <8 x i8>* %71
%72 = add nuw i64 %55, 8
%73 = icmp eq i64 %72, %49
br i1 %73, label %74, label %54
74: ; preds = %54
%75 = icmp eq i64 %49, %2
br i1 %75, label %134, label %76
76: ; preds = %7, %5, %40, %74
%77 = phi i64 [ %2, %5 ], [ %2, %7 ], [ %44, %40 ], [ %50, %74 ]
%78 = phi i8* [ %1, %5 ], [ %1, %7 ], [ %43, %40 ], [ %52, %74 ]
%79 = phi i8* [ %0, %5 ], [ %0, %7 ], [ %41, %40 ], [ %53, %74 ]
%80 = and i64 %77, 1
%81 = icmp eq i64 %80, 0
br i1 %81, label %97, label %82
82: ; preds = %76
%83 = load i8, i8* %78
%84 = icmp slt i8 %83, 58
%85 = select i1 %84, i8 0, i8 9
%86 = add i8 %85, %83
%87 = shl i8 %86, 4
%88 = getelementptr inbounds i8, i8* %78, i64 1
%89 = load i8, i8* %88
%90 = icmp slt i8 %89, 58
%91 = select i1 %90, i8 -48, i8 -87
%92 = add i8 %91, %89
%93 = add i8 %92, %87
store i8 %93, i8* %79
%94 = add i64 %77, -1
%95 = getelementptr inbounds i8, i8* %79, i64 1
%96 = getelementptr inbounds i8, i8* %78, i64 2
br label %97
97: ; preds = %82, %76
%98 = phi i64 [ %77, %76 ], [ %94, %82 ]
%99 = phi i8* [ %78, %76 ], [ %96, %82 ]
%100 = phi i8* [ %79, %76 ], [ %95, %82 ]
%101 = icmp eq i64 %77, 1
br i1 %101, label %134, label %102
102: ; preds = %97, %102
%103 = phi i64 [ %130, %102 ], [ %98, %97 ]
%104 = phi i8* [ %132, %102 ], [ %99, %97 ]
%105 = phi i8* [ %131, %102 ], [ %100, %97 ]
%106 = load i8, i8* %104
%107 = icmp slt i8 %106, 58
%108 = select i1 %107, i8 0, i8 9
%109 = add i8 %108, %106
%110 = shl i8 %109, 4
%111 = getelementptr inbounds i8, i8* %104, i64 1
%112 = load i8, i8* %111
%113 = icmp slt i8 %112, 58
%114 = select i1 %113, i8 -48, i8 -87
%115 = add i8 %114, %112
%116 = add i8 %115, %110
store i8 %116, i8* %105
%117 = getelementptr inbounds i8, i8* %105, i64 1
%118 = getelementptr inbounds i8, i8* %104, i64 2
%119 = load i8, i8* %118
%120 = icmp slt i8 %119, 58
%121 = select i1 %120, i8 0, i8 9
%122 = add i8 %121, %119
%123 = shl i8 %122, 4
%124 = getelementptr inbounds i8, i8* %104, i64 3
%125 = load i8, i8* %124
%126 = icmp slt i8 %125, 58
%127 = select i1 %126, i8 -48, i8 -87
%128 = add i8 %127, %125
%129 = add i8 %128, %123
store i8 %129, i8* %117
%130 = add i64 %103, -2
%131 = getelementptr inbounds i8, i8* %105, i64 2
%132 = getelementptr inbounds i8, i8* %104, i64 4
%133 = icmp eq i64 %130, 0
br i1 %133, label %134, label %102
134: ; preds = %97, %102, %38, %74, %3
ret void
}