#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 */
const char *json_decode_utf8_to_codepoint(const char *p, unsigned *hex) {
  *hex = 0;
  if ((*p & 0x80) == 0)
    *hex = (unsigned)*p;
  else if ((*p & 0xE0) == 0xC0) {
    *hex |= (*p++ & 0x1F) << 6;
    if ((*p & 0xC0) != 0x80)
      return NULL;
    *hex |= (*p & 0x3F);
  } else if ((*p & 0xF0) == 0xE0) {
    *hex |= (*p++ & 0x0F) << 12;
    if ((*p & 0xC0) != 0x80)
      return NULL;
    *hex |= (*p++ & 0x3F) << 6;
    if ((*p & 0xC0) != 0x80)
      return NULL;
    *hex |= (*p & 0x3F);
  } else if ((*p & 0xF8) == 0xF0) {
    *hex |= (*p++ & 0x07) << 18;
    if ((*p & 0xC0) != 0x80)
      return NULL;
    *hex |= (*p++ & 0x3F) << 12;
    if ((*p & 0xC0) != 0x80)
      return NULL;
    *hex |= (*p++ & 0x3F) << 6;
    if ((*p & 0xC0) != 0x80)
      return NULL;
    *hex |= (*p & 0x3F);
  } else
    return NULL;
  return p;
}


x86 assembly (clang, -O0):
<json_decode_utf8_to_codepoint>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
and    $0x80,%eax
cmp    $0x0,%eax
jne    113d <json_decode_utf8_to_codepoint+0x3d>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
jmp    137b <json_decode_utf8_to_codepoint+0x27b>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
and    $0xe0,%eax
cmp    $0xc0,%eax
jne    11af <json_decode_utf8_to_codepoint+0xaf>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%ecx
and    $0x1f,%ecx
shl    $0x6,%ecx
mov    -0x18(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
je     1198 <json_decode_utf8_to_codepoint+0x98>
movq   $0x0,-0x8(%rbp)
jmp    1383 <json_decode_utf8_to_codepoint+0x283>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
and    $0x3f,%ecx
mov    -0x18(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
jmp    1376 <json_decode_utf8_to_codepoint+0x276>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
and    $0xf0,%eax
cmp    $0xe0,%eax
jne    1265 <json_decode_utf8_to_codepoint+0x165>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%ecx
and    $0xf,%ecx
shl    $0xc,%ecx
mov    -0x18(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
je     120a <json_decode_utf8_to_codepoint+0x10a>
movq   $0x0,-0x8(%rbp)
jmp    1383 <json_decode_utf8_to_codepoint+0x283>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%ecx
and    $0x3f,%ecx
shl    $0x6,%ecx
mov    -0x18(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
je     124e <json_decode_utf8_to_codepoint+0x14e>
movq   $0x0,-0x8(%rbp)
jmp    1383 <json_decode_utf8_to_codepoint+0x283>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
and    $0x3f,%ecx
mov    -0x18(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
jmp    1371 <json_decode_utf8_to_codepoint+0x271>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
and    $0xf8,%eax
cmp    $0xf0,%eax
jne    135f <json_decode_utf8_to_codepoint+0x25f>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%ecx
and    $0x7,%ecx
shl    $0x12,%ecx
mov    -0x18(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
je     12c0 <json_decode_utf8_to_codepoint+0x1c0>
movq   $0x0,-0x8(%rbp)
jmp    1383 <json_decode_utf8_to_codepoint+0x283>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%ecx
and    $0x3f,%ecx
shl    $0xc,%ecx
mov    -0x18(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
je     1304 <json_decode_utf8_to_codepoint+0x204>
movq   $0x0,-0x8(%rbp)
jmp    1383 <json_decode_utf8_to_codepoint+0x283>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%ecx
and    $0x3f,%ecx
shl    $0x6,%ecx
mov    -0x18(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
je     1348 <json_decode_utf8_to_codepoint+0x248>
movq   $0x0,-0x8(%rbp)
jmp    1383 <json_decode_utf8_to_codepoint+0x283>
mov    -0x10(%rbp),%rax
movsbl (%rax),%ecx
and    $0x3f,%ecx
mov    -0x18(%rbp),%rax
or     (%rax),%ecx
mov    %ecx,(%rax)
jmp    136c <json_decode_utf8_to_codepoint+0x26c>
movq   $0x0,-0x8(%rbp)
jmp    1383 <json_decode_utf8_to_codepoint+0x283>
jmp    1371 <json_decode_utf8_to_codepoint+0x271>
jmp    1376 <json_decode_utf8_to_codepoint+0x276>
jmp    137b <json_decode_utf8_to_codepoint+0x27b>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<json_decode_utf8_to_codepoint>:
mov    %rdi,%rax
movl   $0x0,(%rsi)
movsbl (%rdi),%ecx
test   $0x80,%cl
jne    1114 <json_decode_utf8_to_codepoint+0x14>
mov    %ecx,(%rsi)
ret
mov    %ecx,%edx
and    $0xe0,%edx
cmp    $0xc0,%edx
jne    114d <json_decode_utf8_to_codepoint+0x4d>
and    $0x1f,%ecx
shl    $0x6,%ecx
mov    %ecx,(%rsi)
movzbl 0x1(%rax),%edx
mov    %edx,%edi
and    $0xffffffc0,%edi
cmp    $0x80,%edi
jne    1212 <json_decode_utf8_to_codepoint+0x112>
add    $0x1,%rax
and    $0x3f,%edx
or     %edx,%ecx
mov    %ecx,(%rsi)
ret
mov    %ecx,%edx
and    $0xf0,%edx
cmp    $0xe0,%edx
jne    11a1 <json_decode_utf8_to_codepoint+0xa1>
shl    $0xc,%ecx
movzwl %cx,%ecx
mov    %ecx,(%rsi)
movsbl 0x1(%rax),%edx
mov    %edx,%edi
and    $0xc0,%edi
cmp    $0x80,%edi
jne    1212 <json_decode_utf8_to_codepoint+0x112>
and    $0x3f,%edx
shl    $0x6,%edx
or     %ecx,%edx
mov    %edx,(%rsi)
movzbl 0x2(%rax),%ecx
mov    %ecx,%edi
and    $0xffffffc0,%edi
cmp    $0x80,%edi
jne    1212 <json_decode_utf8_to_codepoint+0x112>
add    $0x2,%rax
and    $0x3f,%ecx
jmp    1148 <json_decode_utf8_to_codepoint+0x48>
mov    %ecx,%edx
and    $0xf8,%edx
cmp    $0xf0,%edx
jne    1212 <json_decode_utf8_to_codepoint+0x112>
and    $0x7,%ecx
shl    $0x12,%ecx
mov    %ecx,(%rsi)
movsbl 0x1(%rax),%edx
mov    %edx,%edi
and    $0xc0,%edi
cmp    $0x80,%edi
jne    1212 <json_decode_utf8_to_codepoint+0x112>
and    $0x3f,%edx
shl    $0xc,%edx
or     %ecx,%edx
mov    %edx,(%rsi)
movsbl 0x2(%rax),%edi
mov    %edi,%ecx
and    $0xc0,%ecx
cmp    $0x80,%ecx
jne    1212 <json_decode_utf8_to_codepoint+0x112>
and    $0x3f,%edi
shl    $0x6,%edi
or     %edx,%edi
mov    %edi,(%rsi)
movzbl 0x3(%rax),%ecx
mov    %ecx,%edx
and    $0xffffffc0,%edx
cmp    $0x80,%edx
jne    1212 <json_decode_utf8_to_codepoint+0x112>
add    $0x3,%rax
and    $0x3f,%ecx
or     %edi,%ecx
mov    %ecx,(%rsi)
ret
xor    %eax,%eax
ret

LLVM IR (-O0):
define i8* @json_decode_utf8_to_codepoint(i8* %0, i32* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i32*
store i8* %0, i8** %4
store i32* %1, i32** %5
%6 = load i32*, i32** %5
store i32 0, i32* %6
%7 = load i8*, i8** %4
%8 = load i8, i8* %7
%9 = sext i8 %8 to i32
%10 = and i32 %9, 128
%11 = icmp eq i32 %10, 0
br i1 %11, label %12, label %17
12: ; preds = %2
%13 = load i8*, i8** %4
%14 = load i8, i8* %13
%15 = sext i8 %14 to i32
%16 = load i32*, i32** %5
store i32 %15, i32* %16
br label %159
17: ; preds = %2
%18 = load i8*, i8** %4
%19 = load i8, i8* %18
%20 = sext i8 %19 to i32
%21 = and i32 %20, 224
%22 = icmp eq i32 %21, 192
br i1 %22, label %23, label %47
23: ; preds = %17
%24 = load i8*, i8** %4
%25 = getelementptr inbounds i8, i8* %24, i32 1
store i8* %25, i8** %4
%26 = load i8, i8* %24
%27 = sext i8 %26 to i32
%28 = and i32 %27, 31
%29 = shl i32 %28, 6
%30 = load i32*, i32** %5
%31 = load i32, i32* %30
%32 = or i32 %31, %29
store i32 %32, i32* %30
%33 = load i8*, i8** %4
%34 = load i8, i8* %33
%35 = sext i8 %34 to i32
%36 = and i32 %35, 192
%37 = icmp ne i32 %36, 128
br i1 %37, label %38, label %39
38: ; preds = %23
store i8* null, i8** %3
br label %161
39: ; preds = %23
%40 = load i8*, i8** %4
%41 = load i8, i8* %40
%42 = sext i8 %41 to i32
%43 = and i32 %42, 63
%44 = load i32*, i32** %5
%45 = load i32, i32* %44
%46 = or i32 %45, %43
store i32 %46, i32* %44
br label %158
47: ; preds = %17
%48 = load i8*, i8** %4
%49 = load i8, i8* %48
%50 = sext i8 %49 to i32
%51 = and i32 %50, 240
%52 = icmp eq i32 %51, 224
br i1 %52, label %53, label %93
53: ; preds = %47
%54 = load i8*, i8** %4
%55 = getelementptr inbounds i8, i8* %54, i32 1
store i8* %55, i8** %4
%56 = load i8, i8* %54
%57 = sext i8 %56 to i32
%58 = and i32 %57, 15
%59 = shl i32 %58, 12
%60 = load i32*, i32** %5
%61 = load i32, i32* %60
%62 = or i32 %61, %59
store i32 %62, i32* %60
%63 = load i8*, i8** %4
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = and i32 %65, 192
%67 = icmp ne i32 %66, 128
br i1 %67, label %68, label %69
68: ; preds = %53
store i8* null, i8** %3
br label %161
69: ; preds = %53
%70 = load i8*, i8** %4
%71 = getelementptr inbounds i8, i8* %70, i32 1
store i8* %71, i8** %4
%72 = load i8, i8* %70
%73 = sext i8 %72 to i32
%74 = and i32 %73, 63
%75 = shl i32 %74, 6
%76 = load i32*, i32** %5
%77 = load i32, i32* %76
%78 = or i32 %77, %75
store i32 %78, i32* %76
%79 = load i8*, i8** %4
%80 = load i8, i8* %79
%81 = sext i8 %80 to i32
%82 = and i32 %81, 192
%83 = icmp ne i32 %82, 128
br i1 %83, label %84, label %85
84: ; preds = %69
store i8* null, i8** %3
br label %161
85: ; preds = %69
%86 = load i8*, i8** %4
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = and i32 %88, 63
%90 = load i32*, i32** %5
%91 = load i32, i32* %90
%92 = or i32 %91, %89
store i32 %92, i32* %90
br label %157
93: ; preds = %47
%94 = load i8*, i8** %4
%95 = load i8, i8* %94
%96 = sext i8 %95 to i32
%97 = and i32 %96, 248
%98 = icmp eq i32 %97, 240
br i1 %98, label %99, label %155
99: ; preds = %93
%100 = load i8*, i8** %4
%101 = getelementptr inbounds i8, i8* %100, i32 1
store i8* %101, i8** %4
%102 = load i8, i8* %100
%103 = sext i8 %102 to i32
%104 = and i32 %103, 7
%105 = shl i32 %104, 18
%106 = load i32*, i32** %5
%107 = load i32, i32* %106
%108 = or i32 %107, %105
store i32 %108, i32* %106
%109 = load i8*, i8** %4
%110 = load i8, i8* %109
%111 = sext i8 %110 to i32
%112 = and i32 %111, 192
%113 = icmp ne i32 %112, 128
br i1 %113, label %114, label %115
114: ; preds = %99
store i8* null, i8** %3
br label %161
115: ; preds = %99
%116 = load i8*, i8** %4
%117 = getelementptr inbounds i8, i8* %116, i32 1
store i8* %117, i8** %4
%118 = load i8, i8* %116
%119 = sext i8 %118 to i32
%120 = and i32 %119, 63
%121 = shl i32 %120, 12
%122 = load i32*, i32** %5
%123 = load i32, i32* %122
%124 = or i32 %123, %121
store i32 %124, i32* %122
%125 = load i8*, i8** %4
%126 = load i8, i8* %125
%127 = sext i8 %126 to i32
%128 = and i32 %127, 192
%129 = icmp ne i32 %128, 128
br i1 %129, label %130, label %131
130: ; preds = %115
store i8* null, i8** %3
br label %161
131: ; preds = %115
%132 = load i8*, i8** %4
%133 = getelementptr inbounds i8, i8* %132, i32 1
store i8* %133, i8** %4
%134 = load i8, i8* %132
%135 = sext i8 %134 to i32
%136 = and i32 %135, 63
%137 = shl i32 %136, 6
%138 = load i32*, i32** %5
%139 = load i32, i32* %138
%140 = or i32 %139, %137
store i32 %140, i32* %138
%141 = load i8*, i8** %4
%142 = load i8, i8* %141
%143 = sext i8 %142 to i32
%144 = and i32 %143, 192
%145 = icmp ne i32 %144, 128
br i1 %145, label %146, label %147
146: ; preds = %131
store i8* null, i8** %3
br label %161
147: ; preds = %131
%148 = load i8*, i8** %4
%149 = load i8, i8* %148
%150 = sext i8 %149 to i32
%151 = and i32 %150, 63
%152 = load i32*, i32** %5
%153 = load i32, i32* %152
%154 = or i32 %153, %151
store i32 %154, i32* %152
br label %156
155: ; preds = %93
store i8* null, i8** %3
br label %161
156: ; preds = %147
br label %157
157: ; preds = %156, %85
br label %158
158: ; preds = %157, %39
br label %159
159: ; preds = %158, %12
%160 = load i8*, i8** %4
store i8* %160, i8** %3
br label %161
161: ; preds = %159, %155, %146, %130, %114, %84, %68, %38
%162 = load i8*, i8** %3
ret i8* %162
}

LLVM IR (-O2):
define i8* @json_decode_utf8_to_codepoint(i8* %0, i32* nocapture writeonly %1) {
store i32 0, i32* %1
%3 = load i8, i8* %0
%4 = sext i8 %3 to i32
%5 = and i32 %4, 128
%6 = icmp eq i32 %5, 0
br i1 %6, label %76, label %7
7: ; preds = %2
%8 = and i32 %4, 224
%9 = icmp eq i32 %8, 192
br i1 %9, label %10, label %21
10: ; preds = %7
%11 = getelementptr inbounds i8, i8* %0, i64 1
%12 = shl nsw i32 %4, 6
%13 = and i32 %12, 1984
store i32 %13, i32* %1
%14 = load i8, i8* %11
%15 = zext i8 %14 to i32
%16 = and i32 %15, 192
%17 = icmp eq i32 %16, 128
br i1 %17, label %18, label %79
18: ; preds = %10
%19 = and i32 %15, 63
%20 = or i32 %19, %13
br label %76
21: ; preds = %7
%22 = and i32 %4, 240
%23 = icmp eq i32 %22, 224
br i1 %23, label %24, label %44
24: ; preds = %21
%25 = getelementptr inbounds i8, i8* %0, i64 1
%26 = shl nsw i32 %4, 12
%27 = and i32 %26, 61440
store i32 %27, i32* %1
%28 = load i8, i8* %25
%29 = sext i8 %28 to i32
%30 = and i32 %29, 192
%31 = icmp eq i32 %30, 128
br i1 %31, label %32, label %79
32: ; preds = %24
%33 = getelementptr inbounds i8, i8* %0, i64 2
%34 = shl nsw i32 %29, 6
%35 = and i32 %34, 4032
%36 = or i32 %35, %27
store i32 %36, i32* %1
%37 = load i8, i8* %33
%38 = zext i8 %37 to i32
%39 = and i32 %38, 192
%40 = icmp eq i32 %39, 128
br i1 %40, label %41, label %79
41: ; preds = %32
%42 = and i32 %38, 63
%43 = or i32 %42, %36
br label %76
44: ; preds = %21
%45 = and i32 %4, 248
%46 = icmp eq i32 %45, 240
br i1 %46, label %47, label %79
47: ; preds = %44
%48 = getelementptr inbounds i8, i8* %0, i64 1
%49 = shl nsw i32 %4, 18
%50 = and i32 %49, 1835008
store i32 %50, i32* %1
%51 = load i8, i8* %48
%52 = sext i8 %51 to i32
%53 = and i32 %52, 192
%54 = icmp eq i32 %53, 128
br i1 %54, label %55, label %79
55: ; preds = %47
%56 = getelementptr inbounds i8, i8* %0, i64 2
%57 = shl nsw i32 %52, 12
%58 = and i32 %57, 258048
%59 = or i32 %58, %50
store i32 %59, i32* %1
%60 = load i8, i8* %56
%61 = sext i8 %60 to i32
%62 = and i32 %61, 192
%63 = icmp eq i32 %62, 128
br i1 %63, label %64, label %79
64: ; preds = %55
%65 = getelementptr inbounds i8, i8* %0, i64 3
%66 = shl nsw i32 %61, 6
%67 = and i32 %66, 4032
%68 = or i32 %67, %59
store i32 %68, i32* %1
%69 = load i8, i8* %65
%70 = zext i8 %69 to i32
%71 = and i32 %70, 192
%72 = icmp eq i32 %71, 128
br i1 %72, label %73, label %79
73: ; preds = %64
%74 = and i32 %70, 63
%75 = or i32 %74, %68
br label %76
76: ; preds = %2, %18, %73, %41
%77 = phi i32 [ %43, %41 ], [ %75, %73 ], [ %20, %18 ], [ %4, %2 ]
%78 = phi i8* [ %33, %41 ], [ %65, %73 ], [ %11, %18 ], [ %0, %2 ]
store i32 %77, i32* %1
br label %79
79: ; preds = %76, %44, %64, %55, %47, %32, %24, %10
%80 = phi i8* [ null, %10 ], [ null, %24 ], [ null, %32 ], [ null, %47 ], [ null, %55 ], [ null, %64 ], [ null, %44 ], [ %78, %76 ]
ret i8* %80
}