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

/* Variables and functions */
int /*<<< orphan*/ assert(int);
scalar_t__ get_val_utf82uni(int *);
uint8_t *get_utf8_value(uint8_t *pstart, wchar_t *pval) {
  uint32_t val = 0;
  uint8_t *p = pstart;
  assert(NULL != pstart);
  if (0 == (0x80 & *p)) {
    val = (size_t)*p;
    p++;
  } else if (0xC0 == (0xE0 & *p)) {
    val = *p & 0x1F;
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    p++;
    assert((wchar_t)val == get_val_utf82uni(pstart));
  } else if (0xE0 == (0xF0 & *p)) {
    val = *p & 0x0F;
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    p++;
    assert((wchar_t)val == get_val_utf82uni(pstart));
  } else if (0xF0 == (0xF8 & *p)) {
    val = *p & 0x07;
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    p++;
    assert((wchar_t)val == get_val_utf82uni(pstart));
  } else if (0xF8 == (0xFC & *p)) {
    val = *p & 0x03;
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    p++;
    assert((wchar_t)val == get_val_utf82uni(pstart));
  } else if (0xFC == (0xFE & *p)) {
    val = *p & 0x01;
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    val <<= 6;
    p++;
    val |= (*p & 0x3F);
    p++;
    assert((wchar_t)val == get_val_utf82uni(pstart));
  } else if (0x80 == (0xC0 & *p)) {
    for (; 0x80 == (0xC0 & *p); p++)
      ;
  } else {
    for (; ((0xFE & *p) > 0xFC); p++)
      ;
  }
  if (pval)
    *pval = val;
  return p;
}


x86 assembly (clang, -O0):
<get_utf8_value>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
xor    %eax,%eax
cmp    -0x8(%rbp),%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
and    $0x80,%ecx
xor    %eax,%eax
cmp    %ecx,%eax
jne    1183 <get_utf8_value+0x63>
mov    -0x20(%rbp),%rax
movslq (%rax),%rax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
jmp    161b <get_utf8_value+0x4fb>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
and    $0xe0,%ecx
mov    $0xc0,%eax
cmp    %ecx,%eax
jne    1205 <get_utf8_value+0xe5>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x1f,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <get_val_utf82uni@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
jmp    1616 <get_utf8_value+0x4f6>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
and    $0xf0,%ecx
mov    $0xe0,%eax
cmp    %ecx,%eax
jne    12ab <get_utf8_value+0x18b>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0xf,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <get_val_utf82uni@plt>
mov    %rax,%rcx
mov    -0x30(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
jmp    1611 <get_utf8_value+0x4f1>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
and    $0xf8,%ecx
mov    $0xf0,%eax
cmp    %ecx,%eax
jne    1375 <get_utf8_value+0x255>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x7,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <get_val_utf82uni@plt>
mov    %rax,%rcx
mov    -0x38(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
jmp    160c <get_utf8_value+0x4ec>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
and    $0xfc,%ecx
mov    $0xf8,%eax
cmp    %ecx,%eax
jne    1463 <get_utf8_value+0x343>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <get_val_utf82uni@plt>
mov    %rax,%rcx
mov    -0x40(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
jmp    1607 <get_utf8_value+0x4e7>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
and    $0xfe,%ecx
mov    $0xfc,%eax
cmp    %ecx,%eax
jne    1575 <get_utf8_value+0x455>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0x3f,%eax
or     -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
movslq -0x14(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <get_val_utf82uni@plt>
mov    %rax,%rcx
mov    -0x48(%rbp),%rax
cmp    %rcx,%rax
sete   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
jmp    1602 <get_utf8_value+0x4e2>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
and    $0xc0,%ecx
mov    $0x80,%eax
cmp    %ecx,%eax
jne    15c7 <get_utf8_value+0x4a7>
jmp    1593 <get_utf8_value+0x473>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
and    $0xc0,%ecx
mov    $0x80,%eax
cmp    %ecx,%eax
jne    15c2 <get_utf8_value+0x4a2>
jmp    15b1 <get_utf8_value+0x491>
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
jmp    1593 <get_utf8_value+0x473>
jmp    15fd <get_utf8_value+0x4dd>
jmp    15cc <get_utf8_value+0x4ac>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
and    $0xfe,%eax
cmp    $0xfc,%eax
jle    15f8 <get_utf8_value+0x4d8>
jmp    15e7 <get_utf8_value+0x4c7>
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
jmp    15cc <get_utf8_value+0x4ac>
jmp    15fd <get_utf8_value+0x4dd>
jmp    1602 <get_utf8_value+0x4e2>
jmp    1607 <get_utf8_value+0x4e7>
jmp    160c <get_utf8_value+0x4ec>
jmp    1611 <get_utf8_value+0x4f1>
jmp    1616 <get_utf8_value+0x4f6>
jmp    161b <get_utf8_value+0x4fb>
cmpq   $0x0,-0x10(%rbp)
je     1631 <get_utf8_value+0x511>
movslq -0x14(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_utf8_value>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,%r14
mov    %rdi,%r15
xor    %edi,%edi
test   %r15,%r15
setne  %dil
call   1040 <assert@plt>
mov    (%r15),%r13d
test   $0x80,%r13b
jne    114f <get_utf8_value+0x2f>
add    $0x4,%r15
jmp    12fc <get_utf8_value+0x1dc>
mov    %r13d,%eax
and    $0xe0,%eax
cmp    $0xc0,%eax
jne    1195 <get_utf8_value+0x75>
and    $0x1f,%r13d
shl    $0x6,%r13
mov    0x4(%r15),%ebx
and    $0x3f,%ebx
or     %r13,%rbx
lea    0x8(%r15),%r12
mov    %r15,%rdi
call   1030 <get_val_utf82uni@plt>
xor    %edi,%edi
cmp    %rbx,%rax
sete   %dil
call   1040 <assert@plt>
mov    %ebx,%r13d
mov    %r12,%r15
jmp    12fc <get_utf8_value+0x1dc>
mov    %r13d,%eax
and    $0xf0,%eax
cmp    $0xe0,%eax
jne    11e7 <get_utf8_value+0xc7>
and    $0xf,%r13d
shl    $0x6,%r13
mov    0x4(%r15),%eax
mov    0x8(%r15),%r12d
and    $0x3f,%eax
or     %r13,%rax
shl    $0x6,%rax
and    $0x3f,%r12d
or     %rax,%r12
lea    0xc(%r15),%rbx
mov    %r15,%rdi
call   1030 <get_val_utf82uni@plt>
xor    %edi,%edi
cmp    %r12,%rax
sete   %dil
call   1040 <assert@plt>
mov    %r12d,%r13d
jmp    12f9 <get_utf8_value+0x1d9>
mov    %r13d,%eax
and    $0xf8,%eax
cmp    $0xf0,%eax
jne    122e <get_utf8_value+0x10e>
and    $0x7,%r13d
shl    $0x6,%r13
mov    0x4(%r15),%eax
mov    0x8(%r15),%ecx
and    $0x3f,%eax
or     %r13,%rax
shl    $0xc,%rax
and    $0x3f,%ecx
shl    $0x6,%rcx
or     %rax,%rcx
mov    0xc(%r15),%r13d
and    $0x3f,%r13d
or     %rcx,%r13
lea    0x10(%r15),%rbx
jmp    12e3 <get_utf8_value+0x1c3>
mov    %r13d,%eax
and    $0xfc,%eax
cmp    $0xf8,%eax
jne    1280 <get_utf8_value+0x160>
shl    $0x6,%r13d
movzbl %r13b,%eax
mov    0x4(%r15),%ecx
mov    0x8(%r15),%edx
and    $0x3f,%ecx
or     %rax,%rcx
shl    $0xc,%rcx
and    $0x3f,%edx
shl    $0x6,%rdx
or     %rcx,%rdx
mov    0xc(%r15),%eax
and    $0x3f,%eax
or     %rdx,%rax
shl    $0x6,%rax
mov    0x10(%r15),%r13d
and    $0x3f,%r13d
or     %rax,%r13
lea    0x14(%r15),%rbx
jmp    12e3 <get_utf8_value+0x1c3>
mov    %r13d,%eax
and    $0xfe,%eax
cmp    $0xfc,%eax
jne    1314 <get_utf8_value+0x1f4>
movslq %r13d,%rax
shl    $0x6,%eax
and    $0x40,%eax
mov    0x4(%r15),%ecx
mov    0x8(%r15),%edx
and    $0x3f,%ecx
or     %rax,%rcx
shl    $0xc,%rcx
and    $0x3f,%edx
shl    $0x6,%rdx
or     %rcx,%rdx
mov    0xc(%r15),%eax
and    $0x3f,%eax
or     %rdx,%rax
mov    0x10(%r15),%ecx
shl    $0xc,%rax
and    $0x3f,%ecx
shl    $0x6,%rcx
or     %rax,%rcx
mov    0x14(%r15),%r13d
and    $0x3f,%r13d
or     %rcx,%r13
lea    0x18(%r15),%rbx
mov    %r15,%rdi
call   1030 <get_val_utf82uni@plt>
xor    %edi,%edi
cmp    %r13,%rax
sete   %dil
call   1040 <assert@plt>
mov    %rbx,%r15
test   %r14,%r14
je     1307 <get_utf8_value+0x1e7>
movslq %r13d,%rax
mov    %rax,(%r14)
mov    %r15,%rax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
and    $0xc0,%r13d
cmp    $0x80,%r13d
jne    1349 <get_utf8_value+0x229>
cmp    $0x80,%r13d
jne    1344 <get_utf8_value+0x224>
mov    $0xc0,%eax
mov    0x4(%r15),%ecx
and    %eax,%ecx
add    $0x4,%r15
cmp    $0x80,%ecx
je     1332 <get_utf8_value+0x212>
xor    %r13d,%r13d
jmp    12fc <get_utf8_value+0x1dc>
xor    %r13d,%r13d
cmp    $0xfd,%eax
jb     12fc <get_utf8_value+0x1dc>
mov    $0xfe,%eax
mov    0x4(%r15),%ecx
and    %eax,%ecx
add    $0x4,%r15
cmp    $0xfc,%ecx
ja     1358 <get_utf8_value+0x238>
jmp    12fc <get_utf8_value+0x1dc>

LLVM IR (-O0):
define i32* @get_utf8_value(i32* %0, i64* %1) {
%3 = alloca i32*
%4 = alloca i64*
%5 = alloca i32
%6 = alloca i32*
store i32* %0, i32** %3
store i64* %1, i64** %4
store i32 0, i32* %5
%7 = load i32*, i32** %3
store i32* %7, i32** %6
%8 = load i32*, i32** %3
%9 = icmp ne i32* null, %8
%10 = zext i1 %9 to i32
%11 = call i32 @assert(i32 %10)
%12 = load i32*, i32** %6
%13 = load i32, i32* %12
%14 = and i32 128, %13
%15 = icmp eq i32 0, %14
br i1 %15, label %16, label %23
16: ; preds = %2
%17 = load i32*, i32** %6
%18 = load i32, i32* %17
%19 = sext i32 %18 to i64
%20 = trunc i64 %19 to i32
store i32 %20, i32* %5
%21 = load i32*, i32** %6
%22 = getelementptr inbounds i32, i32* %21, i32 1
store i32* %22, i32** %6
br label %281
23: ; preds = %2
%24 = load i32*, i32** %6
%25 = load i32, i32* %24
%26 = and i32 224, %25
%27 = icmp eq i32 192, %26
br i1 %27, label %28, label %50
28: ; preds = %23
%29 = load i32*, i32** %6
%30 = load i32, i32* %29
%31 = and i32 %30, 31
store i32 %31, i32* %5
%32 = load i32, i32* %5
%33 = shl i32 %32, 6
store i32 %33, i32* %5
%34 = load i32*, i32** %6
%35 = getelementptr inbounds i32, i32* %34, i32 1
store i32* %35, i32** %6
%36 = load i32*, i32** %6
%37 = load i32, i32* %36
%38 = and i32 %37, 63
%39 = load i32, i32* %5
%40 = or i32 %39, %38
store i32 %40, i32* %5
%41 = load i32*, i32** %6
%42 = getelementptr inbounds i32, i32* %41, i32 1
store i32* %42, i32** %6
%43 = load i32, i32* %5
%44 = sext i32 %43 to i64
%45 = load i32*, i32** %3
%46 = call i64 @get_val_utf82uni(i32* %45)
%47 = icmp eq i64 %44, %46
%48 = zext i1 %47 to i32
%49 = call i32 @assert(i32 %48)
br label %280
50: ; preds = %23
%51 = load i32*, i32** %6
%52 = load i32, i32* %51
%53 = and i32 240, %52
%54 = icmp eq i32 224, %53
br i1 %54, label %55, label %86
55: ; preds = %50
%56 = load i32*, i32** %6
%57 = load i32, i32* %56
%58 = and i32 %57, 15
store i32 %58, i32* %5
%59 = load i32, i32* %5
%60 = shl i32 %59, 6
store i32 %60, i32* %5
%61 = load i32*, i32** %6
%62 = getelementptr inbounds i32, i32* %61, i32 1
store i32* %62, i32** %6
%63 = load i32*, i32** %6
%64 = load i32, i32* %63
%65 = and i32 %64, 63
%66 = load i32, i32* %5
%67 = or i32 %66, %65
store i32 %67, i32* %5
%68 = load i32, i32* %5
%69 = shl i32 %68, 6
store i32 %69, i32* %5
%70 = load i32*, i32** %6
%71 = getelementptr inbounds i32, i32* %70, i32 1
store i32* %71, i32** %6
%72 = load i32*, i32** %6
%73 = load i32, i32* %72
%74 = and i32 %73, 63
%75 = load i32, i32* %5
%76 = or i32 %75, %74
store i32 %76, i32* %5
%77 = load i32*, i32** %6
%78 = getelementptr inbounds i32, i32* %77, i32 1
store i32* %78, i32** %6
%79 = load i32, i32* %5
%80 = sext i32 %79 to i64
%81 = load i32*, i32** %3
%82 = call i64 @get_val_utf82uni(i32* %81)
%83 = icmp eq i64 %80, %82
%84 = zext i1 %83 to i32
%85 = call i32 @assert(i32 %84)
br label %279
86: ; preds = %50
%87 = load i32*, i32** %6
%88 = load i32, i32* %87
%89 = and i32 248, %88
%90 = icmp eq i32 240, %89
br i1 %90, label %91, label %131
91: ; preds = %86
%92 = load i32*, i32** %6
%93 = load i32, i32* %92
%94 = and i32 %93, 7
store i32 %94, i32* %5
%95 = load i32, i32* %5
%96 = shl i32 %95, 6
store i32 %96, i32* %5
%97 = load i32*, i32** %6
%98 = getelementptr inbounds i32, i32* %97, i32 1
store i32* %98, i32** %6
%99 = load i32*, i32** %6
%100 = load i32, i32* %99
%101 = and i32 %100, 63
%102 = load i32, i32* %5
%103 = or i32 %102, %101
store i32 %103, i32* %5
%104 = load i32, i32* %5
%105 = shl i32 %104, 6
store i32 %105, i32* %5
%106 = load i32*, i32** %6
%107 = getelementptr inbounds i32, i32* %106, i32 1
store i32* %107, i32** %6
%108 = load i32*, i32** %6
%109 = load i32, i32* %108
%110 = and i32 %109, 63
%111 = load i32, i32* %5
%112 = or i32 %111, %110
store i32 %112, i32* %5
%113 = load i32, i32* %5
%114 = shl i32 %113, 6
store i32 %114, i32* %5
%115 = load i32*, i32** %6
%116 = getelementptr inbounds i32, i32* %115, i32 1
store i32* %116, i32** %6
%117 = load i32*, i32** %6
%118 = load i32, i32* %117
%119 = and i32 %118, 63
%120 = load i32, i32* %5
%121 = or i32 %120, %119
store i32 %121, i32* %5
%122 = load i32*, i32** %6
%123 = getelementptr inbounds i32, i32* %122, i32 1
store i32* %123, i32** %6
%124 = load i32, i32* %5
%125 = sext i32 %124 to i64
%126 = load i32*, i32** %3
%127 = call i64 @get_val_utf82uni(i32* %126)
%128 = icmp eq i64 %125, %127
%129 = zext i1 %128 to i32
%130 = call i32 @assert(i32 %129)
br label %278
131: ; preds = %86
%132 = load i32*, i32** %6
%133 = load i32, i32* %132
%134 = and i32 252, %133
%135 = icmp eq i32 248, %134
br i1 %135, label %136, label %185
136: ; preds = %131
%137 = load i32*, i32** %6
%138 = load i32, i32* %137
%139 = and i32 %138, 3
store i32 %139, i32* %5
%140 = load i32, i32* %5
%141 = shl i32 %140, 6
store i32 %141, i32* %5
%142 = load i32*, i32** %6
%143 = getelementptr inbounds i32, i32* %142, i32 1
store i32* %143, i32** %6
%144 = load i32*, i32** %6
%145 = load i32, i32* %144
%146 = and i32 %145, 63
%147 = load i32, i32* %5
%148 = or i32 %147, %146
store i32 %148, i32* %5
%149 = load i32, i32* %5
%150 = shl i32 %149, 6
store i32 %150, i32* %5
%151 = load i32*, i32** %6
%152 = getelementptr inbounds i32, i32* %151, i32 1
store i32* %152, i32** %6
%153 = load i32*, i32** %6
%154 = load i32, i32* %153
%155 = and i32 %154, 63
%156 = load i32, i32* %5
%157 = or i32 %156, %155
store i32 %157, i32* %5
%158 = load i32, i32* %5
%159 = shl i32 %158, 6
store i32 %159, i32* %5
%160 = load i32*, i32** %6
%161 = getelementptr inbounds i32, i32* %160, i32 1
store i32* %161, i32** %6
%162 = load i32*, i32** %6
%163 = load i32, i32* %162
%164 = and i32 %163, 63
%165 = load i32, i32* %5
%166 = or i32 %165, %164
store i32 %166, i32* %5
%167 = load i32, i32* %5
%168 = shl i32 %167, 6
store i32 %168, i32* %5
%169 = load i32*, i32** %6
%170 = getelementptr inbounds i32, i32* %169, i32 1
store i32* %170, i32** %6
%171 = load i32*, i32** %6
%172 = load i32, i32* %171
%173 = and i32 %172, 63
%174 = load i32, i32* %5
%175 = or i32 %174, %173
store i32 %175, i32* %5
%176 = load i32*, i32** %6
%177 = getelementptr inbounds i32, i32* %176, i32 1
store i32* %177, i32** %6
%178 = load i32, i32* %5
%179 = sext i32 %178 to i64
%180 = load i32*, i32** %3
%181 = call i64 @get_val_utf82uni(i32* %180)
%182 = icmp eq i64 %179, %181
%183 = zext i1 %182 to i32
%184 = call i32 @assert(i32 %183)
br label %277
185: ; preds = %131
%186 = load i32*, i32** %6
%187 = load i32, i32* %186
%188 = and i32 254, %187
%189 = icmp eq i32 252, %188
br i1 %189, label %190, label %248
190: ; preds = %185
%191 = load i32*, i32** %6
%192 = load i32, i32* %191
%193 = and i32 %192, 1
store i32 %193, i32* %5
%194 = load i32, i32* %5
%195 = shl i32 %194, 6
store i32 %195, i32* %5
%196 = load i32*, i32** %6
%197 = getelementptr inbounds i32, i32* %196, i32 1
store i32* %197, i32** %6
%198 = load i32*, i32** %6
%199 = load i32, i32* %198
%200 = and i32 %199, 63
%201 = load i32, i32* %5
%202 = or i32 %201, %200
store i32 %202, i32* %5
%203 = load i32, i32* %5
%204 = shl i32 %203, 6
store i32 %204, i32* %5
%205 = load i32*, i32** %6
%206 = getelementptr inbounds i32, i32* %205, i32 1
store i32* %206, i32** %6
%207 = load i32*, i32** %6
%208 = load i32, i32* %207
%209 = and i32 %208, 63
%210 = load i32, i32* %5
%211 = or i32 %210, %209
store i32 %211, i32* %5
%212 = load i32, i32* %5
%213 = shl i32 %212, 6
store i32 %213, i32* %5
%214 = load i32*, i32** %6
%215 = getelementptr inbounds i32, i32* %214, i32 1
store i32* %215, i32** %6
%216 = load i32*, i32** %6
%217 = load i32, i32* %216
%218 = and i32 %217, 63
%219 = load i32, i32* %5
%220 = or i32 %219, %218
store i32 %220, i32* %5
%221 = load i32, i32* %5
%222 = shl i32 %221, 6
store i32 %222, i32* %5
%223 = load i32*, i32** %6
%224 = getelementptr inbounds i32, i32* %223, i32 1
store i32* %224, i32** %6
%225 = load i32*, i32** %6
%226 = load i32, i32* %225
%227 = and i32 %226, 63
%228 = load i32, i32* %5
%229 = or i32 %228, %227
store i32 %229, i32* %5
%230 = load i32, i32* %5
%231 = shl i32 %230, 6
store i32 %231, i32* %5
%232 = load i32*, i32** %6
%233 = getelementptr inbounds i32, i32* %232, i32 1
store i32* %233, i32** %6
%234 = load i32*, i32** %6
%235 = load i32, i32* %234
%236 = and i32 %235, 63
%237 = load i32, i32* %5
%238 = or i32 %237, %236
store i32 %238, i32* %5
%239 = load i32*, i32** %6
%240 = getelementptr inbounds i32, i32* %239, i32 1
store i32* %240, i32** %6
%241 = load i32, i32* %5
%242 = sext i32 %241 to i64
%243 = load i32*, i32** %3
%244 = call i64 @get_val_utf82uni(i32* %243)
%245 = icmp eq i64 %242, %244
%246 = zext i1 %245 to i32
%247 = call i32 @assert(i32 %246)
br label %276
248: ; preds = %185
%249 = load i32*, i32** %6
%250 = load i32, i32* %249
%251 = and i32 192, %250
%252 = icmp eq i32 128, %251
br i1 %252, label %253, label %264
253: ; preds = %248
br label %254
254: ; preds = %260, %253
%255 = load i32*, i32** %6
%256 = load i32, i32* %255
%257 = and i32 192, %256
%258 = icmp eq i32 128, %257
br i1 %258, label %259, label %263
259: ; preds = %254
br label %260
260: ; preds = %259
%261 = load i32*, i32** %6
%262 = getelementptr inbounds i32, i32* %261, i32 1
store i32* %262, i32** %6
br label %254
263: ; preds = %254
br label %275
264: ; preds = %248
br label %265
265: ; preds = %271, %264
%266 = load i32*, i32** %6
%267 = load i32, i32* %266
%268 = and i32 254, %267
%269 = icmp sgt i32 %268, 252
br i1 %269, label %270, label %274
270: ; preds = %265
br label %271
271: ; preds = %270
%272 = load i32*, i32** %6
%273 = getelementptr inbounds i32, i32* %272, i32 1
store i32* %273, i32** %6
br label %265
274: ; preds = %265
br label %275
275: ; preds = %274, %263
br label %276
276: ; preds = %275, %190
br label %277
277: ; preds = %276, %136
br label %278
278: ; preds = %277, %91
br label %279
279: ; preds = %278, %55
br label %280
280: ; preds = %279, %28
br label %281
281: ; preds = %280, %16
%282 = load i64*, i64** %4
%283 = icmp ne i64* %282, null
br i1 %283, label %284, label %288
284: ; preds = %281
%285 = load i32, i32* %5
%286 = sext i32 %285 to i64
%287 = load i64*, i64** %4
store i64 %286, i64* %287
br label %288
288: ; preds = %284, %281
%289 = load i32*, i32** %6
ret i32* %289
}

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