#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 utf8_char_int(char const *);
int utf8_is_valid(const char *string, char **error) {
  int code_point;
  while (string && string[0]) {
    if (((unsigned char)(string[0]) & 0xE0) == 0xC0) {
      if (!string[1] || (((unsigned char)(string[1]) & 0xC0) != 0x80))
        goto invalid;
      code_point = utf8_char_int(string);
      if ((code_point < 0x0080) || (code_point > 0x07FF))
        goto invalid;
      string += 2;
    } else if (((unsigned char)(string[0]) & 0xF0) == 0xE0) {
      if (!string[1] || !string[2] ||
          (((unsigned char)(string[1]) & 0xC0) != 0x80) ||
          (((unsigned char)(string[2]) & 0xC0) != 0x80)) {
        goto invalid;
      }
      code_point = utf8_char_int(string);
      if ((code_point < 0x0800) || (code_point > 0xFFFF) ||
          ((code_point >= 0xD800) && (code_point <= 0xDFFF))) {
        goto invalid;
      }
      string += 3;
    } else if (((unsigned char)(string[0]) & 0xF8) == 0xF0) {
      if (!string[1] || !string[2] || !string[3] ||
          (((unsigned char)(string[1]) & 0xC0) != 0x80) ||
          (((unsigned char)(string[2]) & 0xC0) != 0x80) ||
          (((unsigned char)(string[3]) & 0xC0) != 0x80)) {
        goto invalid;
      }
      code_point = utf8_char_int(string);
      if ((code_point < 0x10000) || (code_point > 0x1FFFFF))
        goto invalid;
      string += 4;
    } else if ((unsigned char)(string[0]) >= 0x80)
      goto invalid;
    else
      string++;
  }
  if (error)
    *error = NULL;
  return 1;
invalid:
  if (error)
    *error = (char *)string;
  return 0;
}


x86 assembly (clang, -O0):
<utf8_is_valid>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x10(%rbp)
mov    %al,-0x1d(%rbp)
je     1140 <utf8_is_valid+0x30>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
test   $0x1,%al
jne    1150 <utf8_is_valid+0x40>
jmp    138d <utf8_is_valid+0x27d>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
and    $0xe0,%eax
cmp    $0xc0,%eax
jne    11ce <utf8_is_valid+0xbe>
mov    -0x10(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     118d <utf8_is_valid+0x7d>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
je     1192 <utf8_is_valid+0x82>
jmp    13af <utf8_is_valid+0x29f>
mov    -0x10(%rbp),%rdi
call   1030 <utf8_char_int@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x80,-0x1c(%rbp)
jl     11b8 <utf8_is_valid+0xa8>
cmpl   $0x7ff,-0x1c(%rbp)
jle    11bd <utf8_is_valid+0xad>
jmp    13af <utf8_is_valid+0x29f>
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
jmp    1388 <utf8_is_valid+0x278>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
and    $0xf0,%eax
cmp    $0xe0,%eax
jne    128c <utf8_is_valid+0x17c>
mov    -0x10(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     1231 <utf8_is_valid+0x121>
mov    -0x10(%rbp),%rax
cmpb   $0x0,0x2(%rax)
je     1231 <utf8_is_valid+0x121>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    1231 <utf8_is_valid+0x121>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
je     1236 <utf8_is_valid+0x126>
jmp    13af <utf8_is_valid+0x29f>
mov    -0x10(%rbp),%rdi
call   1030 <utf8_char_int@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x800,-0x1c(%rbp)
jl     1276 <utf8_is_valid+0x166>
cmpl   $0xffff,-0x1c(%rbp)
jg     1276 <utf8_is_valid+0x166>
cmpl   $0xd800,-0x1c(%rbp)
jl     127b <utf8_is_valid+0x16b>
cmpl   $0xdfff,-0x1c(%rbp)
jg     127b <utf8_is_valid+0x16b>
jmp    13af <utf8_is_valid+0x29f>
mov    -0x10(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x10(%rbp)
jmp    1383 <utf8_is_valid+0x273>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
and    $0xf8,%eax
cmp    $0xf0,%eax
jne    1356 <utf8_is_valid+0x246>
mov    -0x10(%rbp),%rax
cmpb   $0x0,0x1(%rax)
je     1315 <utf8_is_valid+0x205>
mov    -0x10(%rbp),%rax
cmpb   $0x0,0x2(%rax)
je     1315 <utf8_is_valid+0x205>
mov    -0x10(%rbp),%rax
cmpb   $0x0,0x3(%rax)
je     1315 <utf8_is_valid+0x205>
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    1315 <utf8_is_valid+0x205>
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
jne    1315 <utf8_is_valid+0x205>
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
and    $0xc0,%eax
cmp    $0x80,%eax
je     131a <utf8_is_valid+0x20a>
jmp    13af <utf8_is_valid+0x29f>
mov    -0x10(%rbp),%rdi
call   1030 <utf8_char_int@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x10000,-0x1c(%rbp)
jl     1340 <utf8_is_valid+0x230>
cmpl   $0x1fffff,-0x1c(%rbp)
jle    1345 <utf8_is_valid+0x235>
jmp    13af <utf8_is_valid+0x29f>
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
jmp    137e <utf8_is_valid+0x26e>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
cmp    $0x80,%eax
jl     136d <utf8_is_valid+0x25d>
jmp    13af <utf8_is_valid+0x29f>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    137e <utf8_is_valid+0x26e>
jmp    1383 <utf8_is_valid+0x273>
jmp    1388 <utf8_is_valid+0x278>
jmp    1120 <utf8_is_valid+0x10>
cmpq   $0x0,-0x18(%rbp)
je     13a3 <utf8_is_valid+0x293>
mov    -0x18(%rbp),%rax
movq   $0x0,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    13cc <utf8_is_valid+0x2bc>
cmpq   $0x0,-0x18(%rbp)
je     13c5 <utf8_is_valid+0x2b5>
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<utf8_is_valid>:
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
test   %rdi,%rdi
je     1263 <utf8_is_valid+0x153>
mov    %rdi,%rbx
mov    (%rdi),%al
jmp    1147 <utf8_is_valid+0x37>
mov    $0x1,%ecx
test   %al,%al
js     125a <utf8_is_valid+0x14a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rbx,%rcx,1),%eax
add    %rcx,%rbx
test   %al,%al
je     1263 <utf8_is_valid+0x153>
movzbl %al,%ecx
mov    %ecx,%edx
and    $0xffffffe0,%edx
cmp    $0xc0,%edx
jne    1190 <utf8_is_valid+0x80>
movzbl 0x1(%rbx),%eax
and    $0xc0,%al
cmp    $0x80,%al
jne    125a <utf8_is_valid+0x14a>
mov    %rbx,%rdi
call   1030 <utf8_char_int@plt>
add    $0xfffff800,%eax
mov    $0x2,%ecx
cmp    $0xfffff880,%eax
jae    1140 <utf8_is_valid+0x30>
jmp    125a <utf8_is_valid+0x14a>
nopl   0x0(%rax,%rax,1)
mov    %ecx,%edx
and    $0xfffffff0,%edx
cmp    $0xe0,%edx
jne    1200 <utf8_is_valid+0xf0>
movzbl 0x1(%rbx),%ecx
test   %cl,%cl
je     125a <utf8_is_valid+0x14a>
movzbl 0x2(%rbx),%eax
test   %al,%al
je     125a <utf8_is_valid+0x14a>
and    $0xc0,%cl
cmp    $0x80,%cl
jne    125a <utf8_is_valid+0x14a>
and    $0xc0,%al
cmp    $0x80,%al
jne    125a <utf8_is_valid+0x14a>
mov    %rbx,%rdi
call   1030 <utf8_char_int@plt>
lea    -0x10000(%rax),%ecx
cmp    $0xffff0800,%ecx
jb     125a <utf8_is_valid+0x14a>
and    $0xfffff800,%eax
mov    $0x3,%ecx
cmp    $0xd800,%eax
jne    1140 <utf8_is_valid+0x30>
jmp    125a <utf8_is_valid+0x14a>
nopl   0x0(%rax,%rax,1)
and    $0xfffffff8,%ecx
cmp    $0xf0,%ecx
jne    1127 <utf8_is_valid+0x17>
movzbl 0x1(%rbx),%edx
test   %dl,%dl
je     125a <utf8_is_valid+0x14a>
movzbl 0x2(%rbx),%ecx
test   %cl,%cl
je     125a <utf8_is_valid+0x14a>
movzbl 0x3(%rbx),%eax
test   %al,%al
je     125a <utf8_is_valid+0x14a>
and    $0xc0,%dl
cmp    $0x80,%dl
jne    125a <utf8_is_valid+0x14a>
and    $0xc0,%cl
cmp    $0x80,%cl
jne    125a <utf8_is_valid+0x14a>
and    $0xc0,%al
cmp    $0x80,%al
jne    125a <utf8_is_valid+0x14a>
mov    %rbx,%rdi
call   1030 <utf8_char_int@plt>
add    $0xffe00000,%eax
mov    $0x4,%ecx
cmp    $0xffe10000,%eax
jae    1140 <utf8_is_valid+0x30>
xor    %eax,%eax
test   %r14,%r14
jne    126f <utf8_is_valid+0x15f>
jmp    1272 <utf8_is_valid+0x162>
mov    $0x1,%eax
test   %r14,%r14
je     1272 <utf8_is_valid+0x162>
xor    %ebx,%ebx
mov    %rbx,(%r14)
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

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