#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 int uint32_t;
typedef scalar_t__ int32_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int32_t ReadHexUint32(const char *buf, int32_t max_length, uint32_t *value) {
  assert(buf != NULL);
  assert(max_length >= 0);
  assert(value != NULL);
  if (max_length > 8) {
    max_length = 8;
  }
  int32_t length;
  *value = 0U;
  for (length = 0; length < max_length; ++length) {
    if ('0' <= buf[length] && buf[length] <= '9') {
      *value *= 16U;
      *value += (uint32_t)(buf[length] - '0');
    } else if ('a' <= buf[length] && buf[length] <= 'f') {
      *value *= 16U;
      *value += (uint32_t)(10 + (buf[length] - 'a'));
    } else if ('A' <= buf[length] && buf[length] <= 'F') {
      *value *= 16U;
      *value += (uint32_t)(10 + (buf[length] - 'A'));
    } else {
      break;
    }
  }
  return length;
}


x86 assembly (clang, -O0):
<ReadHexUint32>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
cmpq   $0x0,-0x8(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpq   $0x0,-0x10(%rbp)
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpq   $0x0,-0x18(%rbp)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cmpq   $0x8,-0x10(%rbp)
jle    116d <ReadHexUint32+0x5d>
movq   $0x8,-0x10(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    12b7 <ReadHexUint32+0x1a7>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x30,%eax
cmp    %ecx,%eax
jg     11e2 <ReadHexUint32+0xd2>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x39,%eax
jg     11e2 <ReadHexUint32+0xd2>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
shl    $0x4,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
sub    $0x30,%ecx
mov    -0x18(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
jmp    12a1 <ReadHexUint32+0x191>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x61,%eax
cmp    %ecx,%eax
jg     123a <ReadHexUint32+0x12a>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x66,%eax
jg     123a <ReadHexUint32+0x12a>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
shl    $0x4,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
sub    $0x61,%ecx
add    $0xa,%ecx
mov    -0x18(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
jmp    129c <ReadHexUint32+0x18c>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    $0x41,%eax
cmp    %ecx,%eax
jg     1292 <ReadHexUint32+0x182>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x46,%eax
jg     1292 <ReadHexUint32+0x182>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
shl    $0x4,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
sub    $0x41,%ecx
add    $0xa,%ecx
mov    -0x18(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
jmp    1297 <ReadHexUint32+0x187>
jmp    12b7 <ReadHexUint32+0x1a7>
jmp    129c <ReadHexUint32+0x18c>
jmp    12a1 <ReadHexUint32+0x191>
jmp    12a6 <ReadHexUint32+0x196>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    117f <ReadHexUint32+0x6f>
mov    -0x20(%rbp),%rax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ReadHexUint32>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%rbx
mov    %rsi,%r15
mov    %rdi,%r14
xor    %edi,%edi
test   %r14,%r14
setne  %dil
call   1030 <assert@plt>
mov    %r15,%rdi
shr    $0x3f,%rdi
xor    $0x1,%edi
call   1030 <assert@plt>
xor    %edi,%edi
test   %rbx,%rbx
setne  %dil
call   1030 <assert@plt>
movl   $0x0,(%rbx)
xor    %ecx,%ecx
test   %r15,%r15
jle    11e0 <ReadHexUint32+0xd0>
cmp    $0x8,%r15
mov    $0x8,%edx
cmovb  %r15,%rdx
xor    %eax,%eax
jmp    118a <ReadHexUint32+0x7a>
nopl   0x0(%rax,%rax,1)
shl    $0x4,%ecx
mov    %ecx,(%rbx)
movsbl (%r14,%rax,1),%esi
add    %esi,%ecx
add    $0xffffffd0,%ecx
mov    %ecx,(%rbx)
add    $0x1,%rax
cmp    %rax,%rdx
je     11db <ReadHexUint32+0xcb>
movzbl (%r14,%rax,1),%esi
lea    -0x30(%rsi),%edi
cmp    $0x9,%dil
jbe    1170 <ReadHexUint32+0x60>
lea    -0x61(%rsi),%edi
cmp    $0x5,%dil
ja     11c0 <ReadHexUint32+0xb0>
shl    $0x4,%ecx
mov    %ecx,(%rbx)
movsbl (%r14,%rax,1),%esi
add    %esi,%ecx
add    $0xffffffa9,%ecx
jmp    117f <ReadHexUint32+0x6f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xbf,%sil
cmp    $0x5,%sil
ja     11e2 <ReadHexUint32+0xd2>
shl    $0x4,%ecx
mov    %ecx,(%rbx)
movsbl (%r14,%rax,1),%esi
add    %esi,%ecx
add    $0xffffffc9,%ecx
jmp    117f <ReadHexUint32+0x6f>
mov    %rdx,%rax
jmp    11e2 <ReadHexUint32+0xd2>
xor    %eax,%eax
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define i64 @ReadHexUint32(i8* %0, i64 %1, i32* %2) {
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i32*
%7 = alloca i64
store i8* %0, i8** %4
store i64 %1, i64* %5
store i32* %2, i32** %6
%8 = load i8*, i8** %4
%9 = icmp ne i8* %8, null
%10 = zext i1 %9 to i32
%11 = call i32 @assert(i32 %10)
%12 = load i64, i64* %5
%13 = icmp sge i64 %12, 0
%14 = zext i1 %13 to i32
%15 = call i32 @assert(i32 %14)
%16 = load i32*, i32** %6
%17 = icmp ne i32* %16, null
%18 = zext i1 %17 to i32
%19 = call i32 @assert(i32 %18)
%20 = load i64, i64* %5
%21 = icmp sgt i64 %20, 8
br i1 %21, label %22, label %23
22: ; preds = %3
store i64 8, i64* %5
br label %23
23: ; preds = %22, %3
%24 = load i32*, i32** %6
store i32 0, i32* %24
store i64 0, i64* %7
br label %25
25: ; preds = %116, %23
%26 = load i64, i64* %7
%27 = load i64, i64* %5
%28 = icmp slt i64 %26, %27
br i1 %28, label %29, label %119
29: ; preds = %25
%30 = load i8*, i8** %4
%31 = load i64, i64* %7
%32 = getelementptr inbounds i8, i8* %30, i64 %31
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = icmp sle i32 48, %34
br i1 %35, label %36, label %56
36: ; preds = %29
%37 = load i8*, i8** %4
%38 = load i64, i64* %7
%39 = getelementptr inbounds i8, i8* %37, i64 %38
%40 = load i8, i8* %39
%41 = sext i8 %40 to i32
%42 = icmp sle i32 %41, 57
br i1 %42, label %43, label %56
43: ; preds = %36
%44 = load i32*, i32** %6
%45 = load i32, i32* %44
%46 = mul i32 %45, 16
store i32 %46, i32* %44
%47 = load i8*, i8** %4
%48 = load i64, i64* %7
%49 = getelementptr inbounds i8, i8* %47, i64 %48
%50 = load i8, i8* %49
%51 = sext i8 %50 to i32
%52 = sub nsw i32 %51, 48
%53 = load i32*, i32** %6
%54 = load i32, i32* %53
%55 = add i32 %54, %52
store i32 %55, i32* %53
br label %115
56: ; preds = %36, %29
%57 = load i8*, i8** %4
%58 = load i64, i64* %7
%59 = getelementptr inbounds i8, i8* %57, i64 %58
%60 = load i8, i8* %59
%61 = sext i8 %60 to i32
%62 = icmp sle i32 97, %61
br i1 %62, label %63, label %84
63: ; preds = %56
%64 = load i8*, i8** %4
%65 = load i64, i64* %7
%66 = getelementptr inbounds i8, i8* %64, i64 %65
%67 = load i8, i8* %66
%68 = sext i8 %67 to i32
%69 = icmp sle i32 %68, 102
br i1 %69, label %70, label %84
70: ; preds = %63
%71 = load i32*, i32** %6
%72 = load i32, i32* %71
%73 = mul i32 %72, 16
store i32 %73, i32* %71
%74 = load i8*, i8** %4
%75 = load i64, i64* %7
%76 = getelementptr inbounds i8, i8* %74, i64 %75
%77 = load i8, i8* %76
%78 = sext i8 %77 to i32
%79 = sub nsw i32 %78, 97
%80 = add nsw i32 10, %79
%81 = load i32*, i32** %6
%82 = load i32, i32* %81
%83 = add i32 %82, %80
store i32 %83, i32* %81
br label %114
84: ; preds = %63, %56
%85 = load i8*, i8** %4
%86 = load i64, i64* %7
%87 = getelementptr inbounds i8, i8* %85, i64 %86
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = icmp sle i32 65, %89
br i1 %90, label %91, label %112
91: ; preds = %84
%92 = load i8*, i8** %4
%93 = load i64, i64* %7
%94 = getelementptr inbounds i8, i8* %92, i64 %93
%95 = load i8, i8* %94
%96 = sext i8 %95 to i32
%97 = icmp sle i32 %96, 70
br i1 %97, label %98, label %112
98: ; preds = %91
%99 = load i32*, i32** %6
%100 = load i32, i32* %99
%101 = mul i32 %100, 16
store i32 %101, i32* %99
%102 = load i8*, i8** %4
%103 = load i64, i64* %7
%104 = getelementptr inbounds i8, i8* %102, i64 %103
%105 = load i8, i8* %104
%106 = sext i8 %105 to i32
%107 = sub nsw i32 %106, 65
%108 = add nsw i32 10, %107
%109 = load i32*, i32** %6
%110 = load i32, i32* %109
%111 = add i32 %110, %108
store i32 %111, i32* %109
br label %113
112: ; preds = %91, %84
br label %119
113: ; preds = %98
br label %114
114: ; preds = %113, %70
br label %115
115: ; preds = %114, %43
br label %116
116: ; preds = %115
%117 = load i64, i64* %7
%118 = add nsw i64 %117, 1
store i64 %118, i64* %7
br label %25
119: ; preds = %112, %25
%120 = load i64, i64* %7
ret i64 %120
}

LLVM IR (-O2):
define i64 @ReadHexUint32(i8* %0, i64 %1, i32* %2) {
%4 = icmp ne i8* %0, null
%5 = zext i1 %4 to i32
%6 = tail call i32 @assert(i32 %5)
%7 = lshr i64 %1, 63
%8 = trunc i64 %7 to i32
%9 = xor i32 %8, 1
%10 = tail call i32 @assert(i32 %9)
%11 = icmp ne i32* %2, null
%12 = zext i1 %11 to i32
%13 = tail call i32 @assert(i32 %12)
store i32 0, i32* %2
%14 = icmp sgt i64 %1, 0
br i1 %14, label %15, label %53
15: ; preds = %3
%16 = icmp ult i64 %1, 8
%17 = select i1 %16, i64 %1, i64 8
br label %18
18: ; preds = %15, %49
%19 = phi i32 [ %50, %49 ], [ 0, %15 ]
%20 = phi i64 [ %51, %49 ], [ 0, %15 ]
%21 = getelementptr inbounds i8, i8* %0, i64 %20
%22 = load i8, i8* %21
%23 = add i8 %22, -48
%24 = icmp ult i8 %23, 10
br i1 %24, label %25, label %31
25: ; preds = %18
%26 = shl i32 %19, 4
store i32 %26, i32* %2
%27 = load i8, i8* %21
%28 = sext i8 %27 to i32
%29 = add i32 %26, -48
%30 = add i32 %29, %28
br label %49
31: ; preds = %18
%32 = add i8 %22, -97
%33 = icmp ult i8 %32, 6
br i1 %33, label %34, label %40
34: ; preds = %31
%35 = shl i32 %19, 4
store i32 %35, i32* %2
%36 = load i8, i8* %21
%37 = sext i8 %36 to i32
%38 = add i32 %35, -87
%39 = add i32 %38, %37
br label %49
40: ; preds = %31
%41 = add i8 %22, -65
%42 = icmp ult i8 %41, 6
br i1 %42, label %43, label %53
43: ; preds = %40
%44 = shl i32 %19, 4
store i32 %44, i32* %2
%45 = load i8, i8* %21
%46 = sext i8 %45 to i32
%47 = add i32 %44, -55
%48 = add i32 %47, %46
br label %49
49: ; preds = %25, %43, %34
%50 = phi i32 [ %30, %25 ], [ %48, %43 ], [ %39, %34 ]
store i32 %50, i32* %2
%51 = add nuw nsw i64 %20, 1
%52 = icmp eq i64 %51, %17
br i1 %52, label %53, label %18
53: ; preds = %49, %40, %3
%54 = phi i64 [ 0, %3 ], [ %20, %40 ], [ %17, %49 ]
ret i64 %54
}