#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 */
int /*<<< orphan*/ assert(int);
void hex2binary(const char *hex_str, int h_size, char *byte_str) {
  int size = h_size / 2;
  char h, l;
  assert((h_size % 2) == 0);
  for (int i = 0; i < size; ++i) {
    char c = hex_str[i * 2];
    if (c >= '0' && c <= '9')
      h = c - 48;
    else
      h = c + 10 - 65;
    c = hex_str[i * 2 + 1];
    if ((c >= '0') && (c <= '9'))
      l = c - 48;
    else
      l = c + 10 - 65;
    byte_str[i] = (h << 4) + l;
  }
}


x86 assembly (clang, -O0):
<hex2binary>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    121c <hex2binary+0x10c>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x25(%rbp)
movsbl -0x25(%rbp),%eax
cmp    $0x30,%eax
jl     119b <hex2binary+0x8b>
movsbl -0x25(%rbp),%eax
cmp    $0x39,%eax
jg     119b <hex2binary+0x8b>
movsbl -0x25(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x1d(%rbp)
jmp    11a8 <hex2binary+0x98>
movsbl -0x25(%rbp),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %al,-0x1d(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x25(%rbp)
movsbl -0x25(%rbp),%eax
cmp    $0x30,%eax
jl     11e7 <hex2binary+0xd7>
movsbl -0x25(%rbp),%eax
cmp    $0x39,%eax
jg     11e7 <hex2binary+0xd7>
movsbl -0x25(%rbp),%eax
sub    $0x30,%eax
mov    %al,-0x1e(%rbp)
jmp    11f4 <hex2binary+0xe4>
movsbl -0x25(%rbp),%eax
add    $0xa,%eax
sub    $0x41,%eax
mov    %al,-0x1e(%rbp)
movsbl -0x1d(%rbp),%eax
shl    $0x4,%eax
movsbl -0x1e(%rbp),%ecx
add    %ecx,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1153 <hex2binary+0x43>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hex2binary>:
push   %rbp
push   %r14
push   %rbx
mov    %rdx,%r14
mov    %esi,%ebp
mov    %rdi,%rbx
mov    %esi,%edi
not    %edi
and    $0x1,%edi
call   1030 <assert@plt>
cmp    $0x2,%ebp
jl     1366 <hex2binary+0x256>
mov    %ebp,%eax
shr    %eax
cmp    $0x10,%ebp
jae    1141 <hex2binary+0x31>
xor    %ecx,%ecx
jmp    1320 <hex2binary+0x210>
lea    (%rbx,%rax,2),%rcx
cmp    %r14,%rcx
jbe    115a <hex2binary+0x4a>
lea    (%r14,%rax,1),%rcx
cmp    %rbx,%rcx
jbe    115a <hex2binary+0x4a>
xor    %ecx,%ecx
jmp    1320 <hex2binary+0x210>
cmp    $0x20,%ebp
jae    1166 <hex2binary+0x56>
xor    %ecx,%ecx
jmp    1247 <hex2binary+0x137>
mov    %eax,%ecx
and    $0xfffffff0,%ecx
xor    %edx,%edx
movdqa 0xe8b(%rip),%xmm0
movdqa 0xe93(%rip),%xmm1
movdqa 0xe9b(%rip),%xmm2
movdqa 0xea2(%rip),%xmm8
movdqa 0xeaa(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
movdqu (%rbx,%rdx,2),%xmm3
movdqu 0x10(%rbx,%rdx,2),%xmm6
movdqa %xmm6,%xmm7
pand   %xmm0,%xmm7
movdqa %xmm3,%xmm5
pand   %xmm0,%xmm5
packuswb %xmm7,%xmm5
psrlw  $0x8,%xmm6
psrlw  $0x8,%xmm3
packuswb %xmm6,%xmm3
movdqa %xmm5,%xmm6
paddb  %xmm1,%xmm6
movdqa %xmm6,%xmm7
pminub %xmm2,%xmm7
pcmpeqb %xmm6,%xmm7
paddb  %xmm2,%xmm5
pand   %xmm7,%xmm6
pandn  %xmm5,%xmm7
por    %xmm6,%xmm7
movdqa %xmm3,%xmm5
paddb  %xmm1,%xmm5
movdqa %xmm5,%xmm6
pminub %xmm2,%xmm6
pcmpeqb %xmm5,%xmm6
paddb  %xmm8,%xmm3
pand   %xmm6,%xmm5
pandn  %xmm3,%xmm6
por    %xmm5,%xmm6
psllw  $0x4,%xmm7
pand   %xmm4,%xmm7
paddb  %xmm6,%xmm7
movdqu %xmm7,(%r14,%rdx,1)
add    $0x10,%rdx
cmp    %rdx,%rcx
jne    11a0 <hex2binary+0x90>
cmp    %rax,%rcx
je     1366 <hex2binary+0x256>
test   $0x8,%al
je     1320 <hex2binary+0x210>
mov    %rcx,%rdx
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movdqa 0xda8(%rip),%xmm8
movdqa 0xdf0(%rip),%xmm1
movdqa 0xdf8(%rip),%xmm2
movdqa 0xdff(%rip),%xmm9
movdqa 0xe07(%rip),%xmm4
movdqa 0xdbf(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%rbx,%rdx,2),%xmm6
movdqa %xmm6,%xmm7
pand   %xmm8,%xmm7
packuswb %xmm7,%xmm7
psrlw  $0x8,%xmm6
packuswb %xmm6,%xmm6
movdqa %xmm7,%xmm3
paddb  %xmm1,%xmm3
movdqa %xmm3,%xmm0
pmaxub %xmm2,%xmm0
pcmpeqb %xmm3,%xmm0
paddb  %xmm9,%xmm7
pand   %xmm0,%xmm7
pandn  %xmm3,%xmm0
por    %xmm7,%xmm0
movdqa %xmm6,%xmm3
paddb  %xmm1,%xmm3
movdqa %xmm3,%xmm7
pmaxub %xmm2,%xmm7
pcmpeqb %xmm3,%xmm7
paddb  %xmm4,%xmm6
pand   %xmm7,%xmm6
pandn  %xmm3,%xmm7
por    %xmm6,%xmm7
psllw  $0x4,%xmm0
pand   %xmm5,%xmm0
paddb  %xmm7,%xmm0
movq   %xmm0,(%r14,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1290 <hex2binary+0x180>
cmp    %rax,%rcx
je     1366 <hex2binary+0x256>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rbx,%rcx,2),%edx
movzbl 0x1(%rbx,%rcx,2),%esi
lea    -0x30(%rdx),%edi
add    $0x9,%dl
cmp    $0xa,%dil
movzbl %dil,%edi
movzbl %dl,%edx
cmovb  %edi,%edx
lea    -0x30(%rsi),%edi
add    $0xc9,%sil
cmp    $0xa,%dil
movzbl %dil,%edi
movzbl %sil,%esi
cmovb  %edi,%esi
shl    $0x4,%dl
add    %sil,%dl
mov    %dl,(%r14,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1320 <hex2binary+0x210>
pop    %rbx
pop    %r14
pop    %rbp
ret

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

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