#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 */
typedef unsigned char uint8_t;
typedef int ssize_t;

/* Variables and functions */
int EINVAL;
int ENOMEM;
size_t strlen(char const *);
ssize_t str2hex(uint8_t *out, size_t outlen, const char *str) {
  uint8_t *start = out;
  size_t n = strlen(str);
  if (outlen < ((n + 1) / 2))
    return -ENOMEM;
  uint8_t byte = 0;
  int shift = 4;
  while (n--) {
    unsigned char nybble = *str++;
    switch (nybble) {
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
      byte |= (nybble - '0') << shift;
      break;
    case 'a':
    case 'b':
    case 'c':
    case 'd':
    case 'e':
    case 'f':
      byte |= (nybble - 'a' + 10) << shift;
      break;
    case 'A':
    case 'B':
    case 'C':
    case 'D':
    case 'E':
    case 'F':
      byte |= (nybble - 'A' + 10) << shift;
      break;
    default:
      return -EINVAL;
    }
    if ((shift -= 4) == -4) {
      *out++ = byte;
      byte = 0x00;
      shift = 4;
    }
  }
  if (shift != 4)
    *out++ = byte;
  return out - start;
}


x86 assembly (clang, -O0):
<str2hex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    $0x1,%rcx
shr    $0x1,%rcx
cmp    %rcx,%rax
jae    1165 <str2hex+0x55>
xor    %eax,%eax
mov    0x2e85(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    12ac <str2hex+0x19c>
movb   $0x0,-0x31(%rbp)
movl   $0x4,-0x38(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x30(%rbp)
cmp    $0x0,%rax
je     1280 <str2hex+0x170>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%al
mov    %al,-0x39(%rbp)
movzbl -0x39(%rbp),%eax
mov    %eax,-0x40(%rbp)
add    $0xffffffd0,%eax
sub    $0xa,%eax
jb     11dd <str2hex+0xcd>
jmp    11b5 <str2hex+0xa5>
mov    -0x40(%rbp),%eax
add    $0xffffffbf,%eax
sub    $0x6,%eax
jb     1218 <str2hex+0x108>
jmp    11c9 <str2hex+0xb9>
mov    -0x40(%rbp),%eax
add    $0xffffff9f,%eax
sub    $0x6,%eax
jb     11f9 <str2hex+0xe9>
jmp    1237 <str2hex+0x127>
movzbl -0x39(%rbp),%eax
sub    $0x30,%eax
mov    -0x38(%rbp),%ecx
shl    %cl,%eax
mov    %eax,%ecx
movzbl -0x31(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x31(%rbp)
jmp    124a <str2hex+0x13a>
movzbl -0x39(%rbp),%eax
sub    $0x61,%eax
add    $0xa,%eax
mov    -0x38(%rbp),%ecx
shl    %cl,%eax
mov    %eax,%ecx
movzbl -0x31(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x31(%rbp)
jmp    124a <str2hex+0x13a>
movzbl -0x39(%rbp),%eax
sub    $0x41,%eax
add    $0xa,%eax
mov    -0x38(%rbp),%ecx
shl    %cl,%eax
mov    %eax,%ecx
movzbl -0x31(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x31(%rbp)
jmp    124a <str2hex+0x13a>
xor    %eax,%eax
mov    0x2d98(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4(%rbp)
jmp    12ac <str2hex+0x19c>
mov    -0x38(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x38(%rbp)
cmp    $0xfffffffc,%eax
jne    127b <str2hex+0x16b>
mov    -0x31(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
movb   $0x0,-0x31(%rbp)
movl   $0x4,-0x38(%rbp)
jmp    1170 <str2hex+0x60>
cmpl   $0x4,-0x38(%rbp)
je     129e <str2hex+0x18e>
mov    -0x31(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<str2hex>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%r14
mov    %rdx,%rdi
call   1030 <strlen@plt>
mov    %rax,%r10
add    $0x1,%rax
shr    %rax
cmp    %rbx,%rax
jbe    113e <str2hex+0x2e>
mov    0x2ea4(%rip),%rcx
jmp    11bb <str2hex+0xab>
mov    %r14,%rax
test   %r10,%r10
je     11cd <str2hex+0xbd>
mov    $0x4,%ecx
xor    %esi,%esi
movabs $0x7e0000007e03ff,%r9
lea    0xe9e(%rip),%r8
xor    %r11d,%r11d
mov    %r14,%rax
jmp    117c <str2hex+0x6c>
nopw   0x0(%rax,%rax,1)
add    $0xfffffffc,%ecx
add    $0x1,%rsi
cmp    %rsi,%r10
je     11c1 <str2hex+0xb1>
movzbl (%r15,%rsi,1),%edi
lea    -0x30(%rdi),%edx
cmp    $0x37,%dl
jae    11b4 <str2hex+0xa4>
movzbl %dl,%ebx
bt     %rbx,%r9
jae    11b4 <str2hex+0xa4>
movsbq %dl,%rdx
add    (%r8,%rdx,4),%edi
shl    %cl,%edi
or     %dil,%r11b
test   %ecx,%ecx
jne    1170 <str2hex+0x60>
mov    %r11b,(%rax)
add    $0x1,%rax
mov    $0x4,%ecx
xor    %r11d,%r11d
jmp    1173 <str2hex+0x63>
mov    0x2e1d(%rip),%rcx
xor    %eax,%eax
sub    (%rcx),%eax
jmp    11d0 <str2hex+0xc0>
cmp    $0x4,%ecx
je     11cd <str2hex+0xbd>
mov    %r11b,(%rax)
add    $0x1,%rax
sub    %r14d,%eax
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@ENOMEM = global i32 0
@EINVAL = global i32 0
define i32 @str2hex(i8* %0, i64 %1, i8* %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i8
%11 = alloca i32
%12 = alloca i8
store i8* %0, i8** %5
store i64 %1, i64* %6
store i8* %2, i8** %7
%13 = load i8*, i8** %5
store i8* %13, i8** %8
%14 = load i8*, i8** %7
%15 = call i64 @strlen(i8* %14)
store i64 %15, i64* %9
%16 = load i64, i64* %6
%17 = load i64, i64* %9
%18 = add i64 %17, 1
%19 = udiv i64 %18, 2
%20 = icmp ult i64 %16, %19
br i1 %20, label %21, label %24
21: ; preds = %3
%22 = load i32, i32* @ENOMEM
%23 = sub nsw i32 0, %22
store i32 %23, i32* %4
br label %93
24: ; preds = %3
store i8 0, i8* %10
store i32 4, i32* %11
br label %25
25: ; preds = %78, %24
%26 = load i64, i64* %9
%27 = add i64 %26, -1
store i64 %27, i64* %9
%28 = icmp ne i64 %26, 0
br i1 %28, label %29, label %79
29: ; preds = %25
%30 = load i8*, i8** %7
%31 = getelementptr inbounds i8, i8* %30, i32 1
store i8* %31, i8** %7
%32 = load i8, i8* %30
store i8 %32, i8* %12
%33 = load i8, i8* %12
%34 = zext i8 %33 to i32
switch i32 %34, label %67 [
i32 48, label %35
i32 49, label %35
i32 50, label %35
i32 51, label %35
i32 52, label %35
i32 53, label %35
i32 54, label %35
i32 55, label %35
i32 56, label %35
i32 57, label %35
i32 97, label %45
i32 98, label %45
i32 99, label %45
i32 100, label %45
i32 101, label %45
i32 102, label %45
i32 65, label %56
i32 66, label %56
i32 67, label %56
i32 68, label %56
i32 69, label %56
i32 70, label %56
]
35: ; preds = %29, %29, %29, %29, %29, %29, %29, %29, %29, %29
%36 = load i8, i8* %12
%37 = zext i8 %36 to i32
%38 = sub nsw i32 %37, 48
%39 = load i32, i32* %11
%40 = shl i32 %38, %39
%41 = load i8, i8* %10
%42 = zext i8 %41 to i32
%43 = or i32 %42, %40
%44 = trunc i32 %43 to i8
store i8 %44, i8* %10
br label %70
45: ; preds = %29, %29, %29, %29, %29, %29
%46 = load i8, i8* %12
%47 = zext i8 %46 to i32
%48 = sub nsw i32 %47, 97
%49 = add nsw i32 %48, 10
%50 = load i32, i32* %11
%51 = shl i32 %49, %50
%52 = load i8, i8* %10
%53 = zext i8 %52 to i32
%54 = or i32 %53, %51
%55 = trunc i32 %54 to i8
store i8 %55, i8* %10
br label %70
56: ; preds = %29, %29, %29, %29, %29, %29
%57 = load i8, i8* %12
%58 = zext i8 %57 to i32
%59 = sub nsw i32 %58, 65
%60 = add nsw i32 %59, 10
%61 = load i32, i32* %11
%62 = shl i32 %60, %61
%63 = load i8, i8* %10
%64 = zext i8 %63 to i32
%65 = or i32 %64, %62
%66 = trunc i32 %65 to i8
store i8 %66, i8* %10
br label %70
67: ; preds = %29
%68 = load i32, i32* @EINVAL
%69 = sub nsw i32 0, %68
store i32 %69, i32* %4
br label %93
70: ; preds = %56, %45, %35
%71 = load i32, i32* %11
%72 = sub nsw i32 %71, 4
store i32 %72, i32* %11
%73 = icmp eq i32 %72, -4
br i1 %73, label %74, label %78
74: ; preds = %70
%75 = load i8, i8* %10
%76 = load i8*, i8** %5
%77 = getelementptr inbounds i8, i8* %76, i32 1
store i8* %77, i8** %5
store i8 %75, i8* %76
store i8 0, i8* %10
store i32 4, i32* %11
br label %78
78: ; preds = %74, %70
br label %25
79: ; preds = %25
%80 = load i32, i32* %11
%81 = icmp ne i32 %80, 4
br i1 %81, label %82, label %86
82: ; preds = %79
%83 = load i8, i8* %10
%84 = load i8*, i8** %5
%85 = getelementptr inbounds i8, i8* %84, i32 1
store i8* %85, i8** %5
store i8 %83, i8* %84
br label %86
86: ; preds = %82, %79
%87 = load i8*, i8** %5
%88 = load i8*, i8** %8
%89 = ptrtoint i8* %87 to i64
%90 = ptrtoint i8* %88 to i64
%91 = sub i64 %89, %90
%92 = trunc i64 %91 to i32
store i32 %92, i32* %4
br label %93
93: ; preds = %86, %67, %21
%94 = load i32, i32* %4
ret i32 %94
}

LLVM IR (-O2):
@ENOMEM = global i32 0
@EINVAL = global i32 0
@switch.table.str2hex = [55 x i32] [i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 201, i32 201, i32 201, i32 201, i32 201, i32 201, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 208, i32 169, i32 169, i32 169, i32 169, i32 169, i32 169]
define i32 @str2hex(i8* %0, i64 %1, i8* nocapture %2) {
%4 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%5 = add i64 %4, 1
%6 = lshr i64 %5, 1
%7 = icmp ugt i64 %6, %1
br i1 %7, label %10, label %8
8: ; preds = %3
%9 = icmp eq i64 %4, 0
br i1 %9, label %54, label %13
10: ; preds = %3
%11 = load i32, i32* @ENOMEM
%12 = sub nsw i32 0, %11
br label %60
13: ; preds = %8, %45
%14 = phi i64 [ %19, %45 ], [ %4, %8 ]
%15 = phi i32 [ %48, %45 ], [ 4, %8 ]
%16 = phi i8 [ %47, %45 ], [ 0, %8 ]
%17 = phi i8* [ %46, %45 ], [ %0, %8 ]
%18 = phi i8* [ %20, %45 ], [ %2, %8 ]
%19 = add i64 %14, -1
%20 = getelementptr inbounds i8, i8* %18, i64 1
%21 = load i8, i8* %18
%22 = zext i8 %21 to i32
%23 = add i8 %21, -48
%24 = icmp ult i8 %23, 55
br i1 %24, label %28, label %25
25: ; preds = %28, %13
%26 = load i32, i32* @EINVAL
%27 = sub nsw i32 0, %26
br label %60
28: ; preds = %13
%29 = zext i8 %23 to i64
%30 = lshr i64 35465847073801215, %29
%31 = and i64 %30, 1
%32 = icmp eq i64 %31, 0
br i1 %32, label %25, label %33
33: ; preds = %28
%34 = sext i8 %23 to i64
%35 = getelementptr inbounds [55 x i32], [55 x i32]* @switch.table.str2hex, i64 0, i64 %34
%36 = load i32, i32* %35
%37 = add nuw nsw i32 %36, %22
%38 = shl i32 %37, %15
%39 = trunc i32 %38 to i8
%40 = or i8 %16, %39
%41 = add nsw i32 %15, -4
%42 = icmp eq i32 %15, 0
br i1 %42, label %43, label %45
43: ; preds = %33
%44 = getelementptr inbounds i8, i8* %17, i64 1
store i8 %40, i8* %17
br label %45
45: ; preds = %33, %43
%46 = phi i8* [ %44, %43 ], [ %17, %33 ]
%47 = phi i8 [ 0, %43 ], [ %40, %33 ]
%48 = phi i32 [ 4, %43 ], [ %41, %33 ]
%49 = icmp eq i64 %19, 0
br i1 %49, label %50, label %13
50: ; preds = %45
%51 = icmp eq i32 %48, 4
br i1 %51, label %54, label %52
52: ; preds = %50
%53 = getelementptr inbounds i8, i8* %46, i64 1
store i8 %47, i8* %46
br label %54
54: ; preds = %8, %52, %50
%55 = phi i8* [ %53, %52 ], [ %46, %50 ], [ %0, %8 ]
%56 = ptrtoint i8* %55 to i64
%57 = ptrtoint i8* %0 to i64
%58 = sub i64 %56, %57
%59 = trunc i64 %58 to i32
br label %60
60: ; preds = %25, %54, %10
%61 = phi i32 [ %12, %10 ], [ %59, %54 ], [ %27, %25 ]
ret i32 %61
}