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

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int32_t decode_unicode_escape(const char *str) {
  int i;
  int32_t value = 0;
  assert(str[0] == 'u');
  for (i = 1; i <= 4; i++) {
    char c = str[i];
    value <<= 4;
    if (('0' <= (c) && (c) <= '9'))
      value += c - '0';
    else if (('a' <= (c) && (c) <= 'z'))
      value += c - 'a' + 10;
    else if (('A' <= (c) && (c) <= 'Z'))
      value += c - 'A' + 10;
    else
      assert(0);
  }
  return value;
}


x86 assembly (clang, -O0):
<decode_unicode_escape>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x75,%eax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x1,-0xc(%rbp)
cmpl   $0x4,-0xc(%rbp)
jg     121c <decode_unicode_escape+0x10c>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x11(%rbp)
mov    -0x10(%rbp),%eax
shl    $0x4,%eax
mov    %eax,-0x10(%rbp)
movsbl -0x11(%rbp),%ecx
mov    $0x30,%eax
cmp    %ecx,%eax
jg     1192 <decode_unicode_escape+0x82>
movsbl -0x11(%rbp),%eax
cmp    $0x39,%eax
jg     1192 <decode_unicode_escape+0x82>
movsbl -0x11(%rbp),%eax
sub    $0x30,%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    1209 <decode_unicode_escape+0xf9>
movsbl -0x11(%rbp),%ecx
mov    $0x61,%eax
cmp    %ecx,%eax
jg     11c5 <decode_unicode_escape+0xb5>
movsbl -0x11(%rbp),%eax
cmp    $0x7a,%eax
jg     11c5 <decode_unicode_escape+0xb5>
movsbl -0x11(%rbp),%eax
sub    $0x61,%eax
add    $0xa,%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    1204 <decode_unicode_escape+0xf4>
movsbl -0x11(%rbp),%ecx
mov    $0x41,%eax
cmp    %ecx,%eax
jg     11f8 <decode_unicode_escape+0xe8>
movsbl -0x11(%rbp),%eax
cmp    $0x5a,%eax
jg     11f8 <decode_unicode_escape+0xe8>
movsbl -0x11(%rbp),%eax
sub    $0x41,%eax
add    $0xa,%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x10(%rbp)
jmp    11ff <decode_unicode_escape+0xef>
xor    %edi,%edi
call   1030 <assert@plt>
jmp    1204 <decode_unicode_escape+0xf4>
jmp    1209 <decode_unicode_escape+0xf9>
jmp    120e <decode_unicode_escape+0xfe>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1141 <decode_unicode_escape+0x31>
mov    -0x10(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decode_unicode_escape>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%r14
xor    %edi,%edi
cmpb   $0x75,(%r14)
sete   %dil
call   1030 <assert@plt>
movsbl 0x1(%r14),%ebx
lea    -0x30(%rbx),%eax
cmp    $0x9,%al
ja     1137 <decode_unicode_escape+0x27>
add    $0xffffffd0,%ebx
jmp    1158 <decode_unicode_escape+0x48>
lea    -0x61(%rbx),%eax
cmp    $0x19,%al
ja     1143 <decode_unicode_escape+0x33>
add    $0xffffffa9,%ebx
jmp    1158 <decode_unicode_escape+0x48>
lea    -0x41(%rbx),%eax
cmp    $0x19,%al
ja     114f <decode_unicode_escape+0x3f>
add    $0xffffffc9,%ebx
jmp    1158 <decode_unicode_escape+0x48>
xor    %ebx,%ebx
xor    %edi,%edi
call   1030 <assert@plt>
movsbl 0x2(%r14),%eax
shl    $0x4,%ebx
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jae    116f <decode_unicode_escape+0x5f>
add    %eax,%ebx
add    $0xffffffd0,%ebx
jmp    1194 <decode_unicode_escape+0x84>
lea    -0x61(%rax),%ecx
cmp    $0x1a,%cl
jae    117e <decode_unicode_escape+0x6e>
add    %eax,%ebx
add    $0xffffffa9,%ebx
jmp    1194 <decode_unicode_escape+0x84>
lea    -0x41(%rax),%ecx
cmp    $0x1a,%cl
jae    118d <decode_unicode_escape+0x7d>
add    %eax,%ebx
add    $0xffffffc9,%ebx
jmp    1194 <decode_unicode_escape+0x84>
xor    %edi,%edi
call   1030 <assert@plt>
movsbl 0x3(%r14),%eax
shl    $0x4,%ebx
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jae    11ab <decode_unicode_escape+0x9b>
add    %eax,%ebx
add    $0xffffffd0,%ebx
jmp    11d0 <decode_unicode_escape+0xc0>
lea    -0x61(%rax),%ecx
cmp    $0x1a,%cl
jae    11ba <decode_unicode_escape+0xaa>
add    %eax,%ebx
add    $0xffffffa9,%ebx
jmp    11d0 <decode_unicode_escape+0xc0>
lea    -0x41(%rax),%ecx
cmp    $0x1a,%cl
jae    11c9 <decode_unicode_escape+0xb9>
add    %eax,%ebx
add    $0xffffffc9,%ebx
jmp    11d0 <decode_unicode_escape+0xc0>
xor    %edi,%edi
call   1030 <assert@plt>
movsbl 0x4(%r14),%eax
shl    $0x4,%ebx
lea    -0x30(%rax),%ecx
cmp    $0xa,%cl
jae    11e7 <decode_unicode_escape+0xd7>
add    %eax,%ebx
add    $0xffffffd0,%ebx
jmp    120c <decode_unicode_escape+0xfc>
lea    -0x61(%rax),%ecx
cmp    $0x1a,%cl
jae    11f6 <decode_unicode_escape+0xe6>
add    %eax,%ebx
add    $0xffffffa9,%ebx
jmp    120c <decode_unicode_escape+0xfc>
lea    -0x41(%rax),%ecx
cmp    $0x1a,%cl
jae    1205 <decode_unicode_escape+0xf5>
add    %eax,%ebx
add    $0xffffffc9,%ebx
jmp    120c <decode_unicode_escape+0xfc>
xor    %edi,%edi
call   1030 <assert@plt>
mov    %ebx,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

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