#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 /*<<< orphan*/ string;

/* Variables and functions */
int num_bytes_in_utf8_sequence(unsigned char const);
int verify_utf8_sequence(const unsigned char *string, int *len) {
  unsigned int cp = 0;
  *len = num_bytes_in_utf8_sequence(string[0]);
  if (*len == 1) {
    cp = string[0];
  } else if (*len == 2 && (((unsigned char)(string[1]) & 0xC0) == 0x80)) {
    cp = string[0] & 0x1F;
    cp = (cp << 6) | (string[1] & 0x3F);
  } else if (*len == 3 && (((unsigned char)(string[1]) & 0xC0) == 0x80) &&
             (((unsigned char)(string[2]) & 0xC0) == 0x80)) {
    cp = ((unsigned char)string[0]) & 0xF;
    cp = (cp << 6) | (string[1] & 0x3F);
    cp = (cp << 6) | (string[2] & 0x3F);
  } else if (*len == 4 && (((unsigned char)(string[1]) & 0xC0) == 0x80) &&
             (((unsigned char)(string[2]) & 0xC0) == 0x80) &&
             (((unsigned char)(string[3]) & 0xC0) == 0x80)) {
    cp = string[0] & 0x7;
    cp = (cp << 6) | (string[1] & 0x3F);
    cp = (cp << 6) | (string[2] & 0x3F);
    cp = (cp << 6) | (string[3] & 0x3F);
  } else {
    return 0;
  }
  if ((cp < 0x80 && *len > 1) || (cp < 0x800 && *len > 2) ||
      (cp < 0x10000 && *len > 3)) {
    return 0;
  }
  if (cp > 0x10FFFF) {
    return 0;
  }
  if (cp >= 0xD800 && cp <= 0xDFFF) {
    return 0;
  }
  return 1;
}


x86 assembly (clang, -O0):
<verify_utf8_sequence>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%edi
call   1030 <num_bytes_in_utf8_sequence@plt>
mov    %eax,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1157 <verify_utf8_sequence+0x47>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,-0x1c(%rbp)
jmp    12e3 <verify_utf8_sequence+0x1d3>
mov    -0x18(%rbp),%rax
cmpl   $0x2,(%rax)
jne    11a4 <verify_utf8_sequence+0x94>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    11a4 <verify_utf8_sequence+0x94>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
and    $0x1f,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x6,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0x3f,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    12de <verify_utf8_sequence+0x1ce>
mov    -0x18(%rbp),%rax
cmpl   $0x3,(%rax)
jne    121f <verify_utf8_sequence+0x10f>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    121f <verify_utf8_sequence+0x10f>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    121f <verify_utf8_sequence+0x10f>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
and    $0xf,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x6,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0x3f,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x6,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0x3f,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    12d9 <verify_utf8_sequence+0x1c9>
mov    -0x18(%rbp),%rax
cmpl   $0x4,(%rax)
jne    12c8 <verify_utf8_sequence+0x1b8>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    12c8 <verify_utf8_sequence+0x1b8>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    12c8 <verify_utf8_sequence+0x1b8>
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    12c8 <verify_utf8_sequence+0x1b8>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
and    $0x7,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x6,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    $0x3f,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x6,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    $0x3f,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x6,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
and    $0x3f,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    12d4 <verify_utf8_sequence+0x1c4>
movl   $0x0,-0x4(%rbp)
jmp    1383 <verify_utf8_sequence+0x273>
jmp    12d9 <verify_utf8_sequence+0x1c9>
jmp    12de <verify_utf8_sequence+0x1ce>
jmp    12e3 <verify_utf8_sequence+0x1d3>
cmpl   $0x80,-0x1c(%rbp)
jae    12fd <verify_utf8_sequence+0x1ed>
mov    -0x18(%rbp),%rax
cmpl   $0x1,(%rax)
jg     1331 <verify_utf8_sequence+0x221>
cmpl   $0x800,-0x1c(%rbp)
jae    1317 <verify_utf8_sequence+0x207>
mov    -0x18(%rbp),%rax
cmpl   $0x2,(%rax)
jg     1331 <verify_utf8_sequence+0x221>
cmpl   $0x10000,-0x1c(%rbp)
jae    133d <verify_utf8_sequence+0x22d>
mov    -0x18(%rbp),%rax
cmpl   $0x3,(%rax)
jle    133d <verify_utf8_sequence+0x22d>
movl   $0x0,-0x4(%rbp)
jmp    1383 <verify_utf8_sequence+0x273>
cmpl   $0x10ffff,-0x1c(%rbp)
jbe    1356 <verify_utf8_sequence+0x246>
movl   $0x0,-0x4(%rbp)
jmp    1383 <verify_utf8_sequence+0x273>
cmpl   $0xd800,-0x1c(%rbp)
jb     137c <verify_utf8_sequence+0x26c>
cmpl   $0xdfff,-0x1c(%rbp)
ja     137c <verify_utf8_sequence+0x26c>
movl   $0x0,-0x4(%rbp)
jmp    1383 <verify_utf8_sequence+0x273>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<verify_utf8_sequence>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%rbx
mov    %rdi,%r14
movzbl (%rdi),%edi
call   1030 <num_bytes_in_utf8_sequence@plt>
mov    %eax,%ecx
mov    %eax,(%rbx)
xor    %eax,%eax
lea    -0x1(%rcx),%edx
cmp    $0x3,%edx
ja     124d <verify_utf8_sequence+0x13d>
lea    0xec5(%rip),%rsi
movslq (%rsi,%rdx,4),%rdi
add    %rsi,%rdi
xor    %ebx,%ebx
jmp    *%rdi
and    $0x1ff800,%ebx
xor    %eax,%eax
cmp    $0xd800,%ebx
setne  %al
jmp    124d <verify_utf8_sequence+0x13d>
movzbl 0x1(%r14),%ebx
mov    %ebx,%esi
and    $0xffffffc0,%esi
cmp    $0x80,%esi
jne    124d <verify_utf8_sequence+0x13d>
movzbl (%r14),%esi
and    $0x1f,%esi
jmp    120b <verify_utf8_sequence+0xfb>
movzbl 0x1(%r14),%esi
mov    %esi,%edx
and    $0xffffffc0,%edx
cmp    $0x80,%edx
jne    124d <verify_utf8_sequence+0x13d>
movzbl 0x2(%r14),%ebx
mov    %ebx,%edi
and    $0xffffffc0,%edi
cmp    $0x80,%edi
jne    124d <verify_utf8_sequence+0x13d>
movzbl (%r14),%edi
and    $0xf,%edi
shl    $0xc,%edi
and    $0x3f,%esi
shl    $0x6,%esi
or     %edi,%esi
jmp    120e <verify_utf8_sequence+0xfe>
movzbl 0x1(%r14),%edi
mov    %edi,%edx
and    $0xffffffc0,%edx
cmp    $0x80,%edx
jne    124d <verify_utf8_sequence+0x13d>
movzbl 0x2(%r14),%esi
mov    %esi,%edx
and    $0xffffffc0,%edx
cmp    $0x80,%edx
jne    124d <verify_utf8_sequence+0x13d>
movzbl 0x3(%r14),%ebx
mov    %ebx,%edx
and    $0xffffffc0,%edx
cmp    $0x80,%edx
jne    124d <verify_utf8_sequence+0x13d>
movzbl (%r14),%edx
and    $0x7,%edx
shl    $0xc,%edx
and    $0x3f,%edi
shl    $0x6,%edi
or     %edx,%edi
and    $0x3f,%esi
or     %edi,%esi
shl    $0x6,%esi
and    $0x3f,%ebx
or     %esi,%ebx
cmp    $0x80,%ebx
jb     124d <verify_utf8_sequence+0x13d>
cmp    $0x7ff,%ebx
ja     122e <verify_utf8_sequence+0x11e>
cmp    $0x2,%ecx
jbe    1146 <verify_utf8_sequence+0x36>
jmp    124d <verify_utf8_sequence+0x13d>
cmp    $0xffff,%ebx
ja     1241 <verify_utf8_sequence+0x131>
cmp    $0x3,%ecx
jbe    1146 <verify_utf8_sequence+0x36>
jmp    124d <verify_utf8_sequence+0x13d>
cmp    $0x10ffff,%ebx
jbe    1146 <verify_utf8_sequence+0x36>
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define i32 @verify_utf8_sequence(i8* nocapture %0, i32* nocapture %1) {
%3 = load i8, i8* %0
%4 = tail call i32 @num_bytes_in_utf8_sequence(i8 zeroext %3)
store i32 %4, i32* %1
switch i32 %4, label %86 [
i32 1, label %81
i32 2, label %5
i32 3, label %16
i32 4, label %36
]
5: ; preds = %2
%6 = getelementptr inbounds i8, i8* %0, i64 1
%7 = load i8, i8* %6
%8 = zext i8 %7 to i32
%9 = and i32 %8, 192
%10 = icmp eq i32 %9, 128
br i1 %10, label %11, label %86
11: ; preds = %5
%12 = load i8, i8* %0
%13 = and i8 %12, 31
%14 = zext i8 %13 to i32
%15 = shl nuw nsw i32 %14, 6
br label %65
16: ; preds = %2
%17 = getelementptr inbounds i8, i8* %0, i64 1
%18 = load i8, i8* %17
%19 = zext i8 %18 to i32
%20 = and i32 %19, 192
%21 = icmp eq i32 %20, 128
br i1 %21, label %22, label %86
22: ; preds = %16
%23 = getelementptr inbounds i8, i8* %0, i64 2
%24 = load i8, i8* %23
%25 = zext i8 %24 to i32
%26 = and i32 %25, 192
%27 = icmp eq i32 %26, 128
br i1 %27, label %28, label %86
28: ; preds = %22
%29 = load i8, i8* %0
%30 = and i8 %29, 15
%31 = zext i8 %30 to i32
%32 = shl nuw nsw i32 %31, 12
%33 = shl nuw nsw i32 %19, 6
%34 = and i32 %33, 4032
%35 = or i32 %32, %34
br label %65
36: ; preds = %2
%37 = getelementptr inbounds i8, i8* %0, i64 1
%38 = load i8, i8* %37
%39 = zext i8 %38 to i32
%40 = and i32 %39, 192
%41 = icmp eq i32 %40, 128
br i1 %41, label %42, label %86
42: ; preds = %36
%43 = getelementptr inbounds i8, i8* %0, i64 2
%44 = load i8, i8* %43
%45 = zext i8 %44 to i32
%46 = and i32 %45, 192
%47 = icmp eq i32 %46, 128
br i1 %47, label %48, label %86
48: ; preds = %42
%49 = getelementptr inbounds i8, i8* %0, i64 3
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
%52 = and i32 %51, 192
%53 = icmp eq i32 %52, 128
br i1 %53, label %54, label %86
54: ; preds = %48
%55 = load i8, i8* %0
%56 = and i8 %55, 7
%57 = zext i8 %56 to i32
%58 = shl nuw nsw i32 %57, 12
%59 = shl nuw nsw i32 %39, 6
%60 = and i32 %59, 4032
%61 = or i32 %58, %60
%62 = and i32 %45, 63
%63 = or i32 %61, %62
%64 = shl nuw nsw i32 %63, 6
br label %65
65: ; preds = %11, %54, %28
%66 = phi i32 [ %8, %11 ], [ %51, %54 ], [ %25, %28 ]
%67 = phi i32 [ %15, %11 ], [ %64, %54 ], [ %35, %28 ]
%68 = and i32 %66, 63
%69 = or i32 %67, %68
%70 = icmp ult i32 %69, 128
br i1 %70, label %86, label %71
71: ; preds = %65
%72 = icmp ult i32 %69, 2048
br i1 %72, label %73, label %75
73: ; preds = %71
%74 = icmp ugt i32 %4, 2
br i1 %74, label %86, label %81
75: ; preds = %71
%76 = icmp ult i32 %69, 65536
br i1 %76, label %77, label %79
77: ; preds = %75
%78 = icmp ugt i32 %4, 3
br i1 %78, label %86, label %81
79: ; preds = %75
%80 = icmp ugt i32 %69, 1114111
br i1 %80, label %86, label %81
81: ; preds = %73, %2, %77, %79
%82 = phi i32 [ %69, %77 ], [ %69, %79 ], [ 0, %2 ], [ %69, %73 ]
%83 = and i32 %82, -2048
%84 = icmp ne i32 %83, 55296
%85 = zext i1 %84 to i32
br label %86
86: ; preds = %65, %2, %5, %16, %22, %81, %79, %73, %77, %36, %42, %48
%87 = phi i32 [ 0, %48 ], [ 0, %42 ], [ 0, %36 ], [ 0, %77 ], [ 0, %73 ], [ 0, %79 ], [ %85, %81 ], [ 0, %22 ], [ 0, %16 ], [ 0, %5 ], [ 0, %2 ], [ 0, %65 ]
ret i32 %87
}