; LLVM IR from cruppstahl/upscaledb :: 3rdparty/json (JSON_parser)

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.JSON_value_struct = type { %union.anon }
%union.anon = type { %struct.anon }
%struct.anon = type { ptr, i64 }
%struct.JSON_parser_struct = type { ptr, ptr, i8, i8, i8, i8, i8, i8, i8, i8, i16, i64, i64, ptr, i64, i8, ptr, i64, i64, i64, [128 x i8], [3500 x i8] }

@ascii_class = external hidden constant [128 x i8], align 16
@state_transition_table = external hidden constant [36 x [32 x i8]], align 16
@.str = external hidden unnamed_addr constant [25 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [82 x i8], align 1
@__PRETTY_FUNCTION__.JSON_parser_char = external hidden unnamed_addr constant [39 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [26 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [50 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [26 x i8], align 1

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: nounwind uwtable
declare hidden i32 @push(ptr noundef, i32 noundef) #1

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: nounwind uwtable
define dso_local i32 @JSON_parser_char(ptr noundef %0, i32 noundef %1) #1 {
  %3 = alloca i32, align 4
  %4 = alloca ptr, align 8
  %5 = alloca i32, align 4
  %6 = alloca i8, align 1
  %7 = alloca i8, align 1
  %8 = alloca i32, align 4
  %9 = alloca %struct.JSON_value_struct, align 8
  store ptr %0, ptr %4, align 8, !tbaa !5
  store i32 %1, ptr %5, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 1, ptr %6) #3
  call void @llvm.lifetime.start.p0(i64 1, ptr %7) #3
  %10 = load i32, ptr %5, align 4, !tbaa !9
  %11 = icmp slt i32 %10, 0
  br i1 %11, label %12, label %13

12:                                               ; preds = %2
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

13:                                               ; preds = %2
  %14 = load i32, ptr %5, align 4, !tbaa !9
  %15 = icmp sge i32 %14, 128
  br i1 %15, label %16, label %17

16:                                               ; preds = %13
  store i8 30, ptr %6, align 1, !tbaa !11
  br label %27

17:                                               ; preds = %13
  %18 = load i32, ptr %5, align 4, !tbaa !9
  %19 = sext i32 %18 to i64
  %20 = getelementptr inbounds [128 x i8], ptr @ascii_class, i64 0, i64 %19
  %21 = load i8, ptr %20, align 1, !tbaa !11
  store i8 %21, ptr %6, align 1, !tbaa !11
  %22 = load i8, ptr %6, align 1, !tbaa !11
  %23 = sext i8 %22 to i32
  %24 = icmp sle i32 %23, -1
  br i1 %24, label %25, label %26

25:                                               ; preds = %17
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

26:                                               ; preds = %17
  br label %27

27:                                               ; preds = %26, %16
  br label %28

28:                                               ; preds = %27
  %29 = load ptr, ptr %4, align 8, !tbaa !5
  %30 = getelementptr inbounds %struct.JSON_parser_struct, ptr %29, i32 0, i32 5
  %31 = load i8, ptr %30, align 1, !tbaa !12
  %32 = icmp ne i8 %31, 0
  br i1 %32, label %33, label %40

33:                                               ; preds = %28
  %34 = load ptr, ptr %4, align 8, !tbaa !5
  %35 = load i32, ptr %5, align 4, !tbaa !9
  %36 = call i32 @add_escaped_char_to_parse_buffer(ptr noundef %34, i32 noundef %35)
  %37 = icmp ne i32 %36, 0
  br i1 %37, label %39, label %38

38:                                               ; preds = %33
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

39:                                               ; preds = %33
  br label %100

40:                                               ; preds = %28
  %41 = load ptr, ptr %4, align 8, !tbaa !5
  %42 = getelementptr inbounds %struct.JSON_parser_struct, ptr %41, i32 0, i32 6
  %43 = load i8, ptr %42, align 4, !tbaa !16
  %44 = icmp ne i8 %43, 0
  br i1 %44, label %99, label %45

45:                                               ; preds = %40
  %46 = load ptr, ptr %4, align 8, !tbaa !5
  %47 = getelementptr inbounds %struct.JSON_parser_struct, ptr %46, i32 0, i32 4
  %48 = load i8, ptr %47, align 2, !tbaa !17
  %49 = sext i8 %48 to i32
  %50 = icmp ne i32 %49, 0
  %51 = zext i1 %50 to i32
  %52 = load i8, ptr %6, align 1, !tbaa !11
  %53 = sext i8 %52 to i32
  %54 = icmp eq i32 %53, 0
  %55 = zext i1 %54 to i32
  %56 = load i8, ptr %6, align 1, !tbaa !11
  %57 = sext i8 %56 to i32
  %58 = icmp eq i32 %57, 1
  %59 = zext i1 %58 to i32
  %60 = or i32 %55, %59
  %61 = icmp ne i32 %60, 0
  %62 = xor i1 %61, true
  %63 = zext i1 %62 to i32
  %64 = or i32 %51, %63
  %65 = icmp ne i32 %64, 0
  br i1 %65, label %66, label %98

66:                                               ; preds = %45
  br label %67

67:                                               ; preds = %66
  %68 = load ptr, ptr %4, align 8, !tbaa !5
  %69 = getelementptr inbounds %struct.JSON_parser_struct, ptr %68, i32 0, i32 18
  %70 = load i64, ptr %69, align 8, !tbaa !18
  %71 = add i64 %70, 1
  %72 = load ptr, ptr %4, align 8, !tbaa !5
  %73 = getelementptr inbounds %struct.JSON_parser_struct, ptr %72, i32 0, i32 17
  %74 = load i64, ptr %73, align 8, !tbaa !19
  %75 = icmp uge i64 %71, %74
  br i1 %75, label %76, label %78

76:                                               ; preds = %67
  %77 = load ptr, ptr %4, align 8, !tbaa !5
  call void @grow_parse_buffer(ptr noundef %77)
  br label %78

78:                                               ; preds = %76, %67
  %79 = load i32, ptr %5, align 4, !tbaa !9
  %80 = trunc i32 %79 to i8
  %81 = load ptr, ptr %4, align 8, !tbaa !5
  %82 = getelementptr inbounds %struct.JSON_parser_struct, ptr %81, i32 0, i32 16
  %83 = load ptr, ptr %82, align 8, !tbaa !20
  %84 = load ptr, ptr %4, align 8, !tbaa !5
  %85 = getelementptr inbounds %struct.JSON_parser_struct, ptr %84, i32 0, i32 18
  %86 = load i64, ptr %85, align 8, !tbaa !18
  %87 = add i64 %86, 1
  store i64 %87, ptr %85, align 8, !tbaa !18
  %88 = getelementptr inbounds i8, ptr %83, i64 %86
  store i8 %80, ptr %88, align 1, !tbaa !11
  %89 = load ptr, ptr %4, align 8, !tbaa !5
  %90 = getelementptr inbounds %struct.JSON_parser_struct, ptr %89, i32 0, i32 16
  %91 = load ptr, ptr %90, align 8, !tbaa !20
  %92 = load ptr, ptr %4, align 8, !tbaa !5
  %93 = getelementptr inbounds %struct.JSON_parser_struct, ptr %92, i32 0, i32 18
  %94 = load i64, ptr %93, align 8, !tbaa !18
  %95 = getelementptr inbounds i8, ptr %91, i64 %94
  store i8 0, ptr %95, align 1, !tbaa !11
  br label %96

96:                                               ; preds = %78
  br label %97

97:                                               ; preds = %96
  br label %98

98:                                               ; preds = %97, %45
  br label %99

99:                                               ; preds = %98, %40
  br label %100

100:                                              ; preds = %99, %39
  br label %101

101:                                              ; preds = %100
  br label %102

102:                                              ; preds = %101
  %103 = load ptr, ptr %4, align 8, !tbaa !5
  %104 = getelementptr inbounds %struct.JSON_parser_struct, ptr %103, i32 0, i32 2
  %105 = load i8, ptr %104, align 8, !tbaa !21
  %106 = sext i8 %105 to i64
  %107 = getelementptr inbounds [36 x [32 x i8]], ptr @state_transition_table, i64 0, i64 %106
  %108 = load i8, ptr %6, align 1, !tbaa !11
  %109 = sext i8 %108 to i64
  %110 = getelementptr inbounds [32 x i8], ptr %107, i64 0, i64 %109
  %111 = load i8, ptr %110, align 1, !tbaa !11
  store i8 %111, ptr %7, align 1, !tbaa !11
  %112 = load i8, ptr %7, align 1, !tbaa !11
  %113 = sext i8 %112 to i32
  %114 = icmp sge i32 %113, 0
  br i1 %114, label %115, label %119

115:                                              ; preds = %102
  %116 = load i8, ptr %7, align 1, !tbaa !11
  %117 = load ptr, ptr %4, align 8, !tbaa !5
  %118 = getelementptr inbounds %struct.JSON_parser_struct, ptr %117, i32 0, i32 2
  store i8 %116, ptr %118, align 8, !tbaa !21
  br label %889

119:                                              ; preds = %102
  %120 = load i8, ptr %7, align 1, !tbaa !11
  %121 = sext i8 %120 to i32
  switch i32 %121, label %887 [
    i32 -22, label %122
    i32 -21, label %139
    i32 -18, label %144
    i32 -19, label %149
    i32 -20, label %154
    i32 -15, label %159
    i32 -16, label %196
    i32 -17, label %264
    i32 -14, label %286
    i32 -12, label %299
    i32 -13, label %312
    i32 -11, label %325
    i32 -10, label %348
    i32 -9, label %433
    i32 -8, label %465
    i32 -7, label %516
    i32 -6, label %567
    i32 -5, label %619
    i32 -4, label %671
    i32 -3, label %773
    i32 -2, label %846
  ]

122:                                              ; preds = %119
  %123 = load ptr, ptr %4, align 8, !tbaa !5
  %124 = call i32 @decode_unicode_char(ptr noundef %123)
  %125 = icmp ne i32 %124, 0
  br i1 %125, label %127, label %126

126:                                              ; preds = %122
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

127:                                              ; preds = %122
  %128 = load ptr, ptr %4, align 8, !tbaa !5
  %129 = getelementptr inbounds %struct.JSON_parser_struct, ptr %128, i32 0, i32 10
  %130 = load i16, ptr %129, align 8, !tbaa !22
  %131 = icmp ne i16 %130, 0
  br i1 %131, label %132, label %135

132:                                              ; preds = %127
  %133 = load ptr, ptr %4, align 8, !tbaa !5
  %134 = getelementptr inbounds %struct.JSON_parser_struct, ptr %133, i32 0, i32 2
  store i8 34, ptr %134, align 8, !tbaa !21
  br label %138

135:                                              ; preds = %127
  %136 = load ptr, ptr %4, align 8, !tbaa !5
  %137 = getelementptr inbounds %struct.JSON_parser_struct, ptr %136, i32 0, i32 2
  store i8 7, ptr %137, align 8, !tbaa !21
  br label %138

138:                                              ; preds = %135, %132
  br label %888

139:                                              ; preds = %119
  %140 = load ptr, ptr %4, align 8, !tbaa !5
  %141 = getelementptr inbounds %struct.JSON_parser_struct, ptr %140, i32 0, i32 5
  store i8 1, ptr %141, align 1, !tbaa !12
  %142 = load ptr, ptr %4, align 8, !tbaa !5
  %143 = getelementptr inbounds %struct.JSON_parser_struct, ptr %142, i32 0, i32 2
  store i8 8, ptr %143, align 8, !tbaa !21
  br label %888

144:                                              ; preds = %119
  %145 = load ptr, ptr %4, align 8, !tbaa !5
  %146 = getelementptr inbounds %struct.JSON_parser_struct, ptr %145, i32 0, i32 4
  store i8 5, ptr %146, align 2, !tbaa !17
  %147 = load ptr, ptr %4, align 8, !tbaa !5
  %148 = getelementptr inbounds %struct.JSON_parser_struct, ptr %147, i32 0, i32 2
  store i8 13, ptr %148, align 8, !tbaa !21
  br label %888

149:                                              ; preds = %119
  %150 = load ptr, ptr %4, align 8, !tbaa !5
  %151 = getelementptr inbounds %struct.JSON_parser_struct, ptr %150, i32 0, i32 4
  store i8 5, ptr %151, align 2, !tbaa !17
  %152 = load ptr, ptr %4, align 8, !tbaa !5
  %153 = getelementptr inbounds %struct.JSON_parser_struct, ptr %152, i32 0, i32 2
  store i8 14, ptr %153, align 8, !tbaa !21
  br label %888

154:                                              ; preds = %119
  %155 = load ptr, ptr %4, align 8, !tbaa !5
  %156 = getelementptr inbounds %struct.JSON_parser_struct, ptr %155, i32 0, i32 4
  store i8 5, ptr %156, align 2, !tbaa !17
  %157 = load ptr, ptr %4, align 8, !tbaa !5
  %158 = getelementptr inbounds %struct.JSON_parser_struct, ptr %157, i32 0, i32 2
  store i8 15, ptr %158, align 8, !tbaa !21
  br label %888

159:                                              ; preds = %119
  %160 = load ptr, ptr %4, align 8, !tbaa !5
  %161 = getelementptr inbounds %struct.JSON_parser_struct, ptr %160, i32 0, i32 4
  %162 = load i8, ptr %161, align 2, !tbaa !17
  %163 = sext i8 %162 to i32
  %164 = icmp ne i32 %163, 9
  br i1 %164, label %165, label %166

165:                                              ; preds = %159
  br label %167

166:                                              ; preds = %159
  call void @__assert_fail(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 756, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

167:                                              ; preds = %165
  %168 = load ptr, ptr %4, align 8, !tbaa !5
  %169 = getelementptr inbounds %struct.JSON_parser_struct, ptr %168, i32 0, i32 4
  %170 = load i8, ptr %169, align 2, !tbaa !17
  %171 = sext i8 %170 to i32
  %172 = icmp ne i32 %171, 8
  br i1 %172, label %173, label %174

173:                                              ; preds = %167
  br label %175

174:                                              ; preds = %167
  call void @__assert_fail(ptr noundef @.str.2, ptr noundef @.str.1, i32 noundef 756, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

175:                                              ; preds = %173
  %176 = load ptr, ptr %4, align 8, !tbaa !5
  %177 = getelementptr inbounds %struct.JSON_parser_struct, ptr %176, i32 0, i32 4
  %178 = load i8, ptr %177, align 2, !tbaa !17
  %179 = sext i8 %178 to i32
  %180 = icmp ne i32 %179, 7
  br i1 %180, label %181, label %182

181:                                              ; preds = %175
  br label %183

182:                                              ; preds = %175
  call void @__assert_fail(ptr noundef @.str.3, ptr noundef @.str.1, i32 noundef 756, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

183:                                              ; preds = %181
  %184 = load ptr, ptr %4, align 8, !tbaa !5
  %185 = getelementptr inbounds %struct.JSON_parser_struct, ptr %184, i32 0, i32 4
  %186 = load i8, ptr %185, align 2, !tbaa !17
  %187 = sext i8 %186 to i32
  %188 = icmp ne i32 %187, 10
  br i1 %188, label %189, label %190

189:                                              ; preds = %183
  br label %191

190:                                              ; preds = %183
  call void @__assert_fail(ptr noundef @.str.4, ptr noundef @.str.1, i32 noundef 756, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

191:                                              ; preds = %189
  %192 = load ptr, ptr %4, align 8, !tbaa !5
  %193 = getelementptr inbounds %struct.JSON_parser_struct, ptr %192, i32 0, i32 4
  store i8 6, ptr %193, align 2, !tbaa !17
  %194 = load ptr, ptr %4, align 8, !tbaa !5
  %195 = getelementptr inbounds %struct.JSON_parser_struct, ptr %194, i32 0, i32 2
  store i8 17, ptr %195, align 8, !tbaa !21
  br label %888

196:                                              ; preds = %119
  %197 = load ptr, ptr %4, align 8, !tbaa !5
  %198 = getelementptr inbounds %struct.JSON_parser_struct, ptr %197, i32 0, i32 4
  %199 = load i8, ptr %198, align 2, !tbaa !17
  %200 = sext i8 %199 to i32
  %201 = icmp ne i32 %200, 9
  br i1 %201, label %202, label %203

202:                                              ; preds = %196
  br label %204

203:                                              ; preds = %196
  call void @__assert_fail(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 763, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

204:                                              ; preds = %202
  %205 = load ptr, ptr %4, align 8, !tbaa !5
  %206 = getelementptr inbounds %struct.JSON_parser_struct, ptr %205, i32 0, i32 4
  %207 = load i8, ptr %206, align 2, !tbaa !17
  %208 = sext i8 %207 to i32
  %209 = icmp ne i32 %208, 8
  br i1 %209, label %210, label %211

210:                                              ; preds = %204
  br label %212

211:                                              ; preds = %204
  call void @__assert_fail(ptr noundef @.str.2, ptr noundef @.str.1, i32 noundef 763, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

212:                                              ; preds = %210
  %213 = load ptr, ptr %4, align 8, !tbaa !5
  %214 = getelementptr inbounds %struct.JSON_parser_struct, ptr %213, i32 0, i32 4
  %215 = load i8, ptr %214, align 2, !tbaa !17
  %216 = sext i8 %215 to i32
  %217 = icmp ne i32 %216, 7
  br i1 %217, label %218, label %219

218:                                              ; preds = %212
  br label %220

219:                                              ; preds = %212
  call void @__assert_fail(ptr noundef @.str.3, ptr noundef @.str.1, i32 noundef 763, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

220:                                              ; preds = %218
  %221 = load ptr, ptr %4, align 8, !tbaa !5
  %222 = getelementptr inbounds %struct.JSON_parser_struct, ptr %221, i32 0, i32 4
  %223 = load i8, ptr %222, align 2, !tbaa !17
  %224 = sext i8 %223 to i32
  %225 = icmp ne i32 %224, 10
  br i1 %225, label %226, label %227

226:                                              ; preds = %220
  br label %228

227:                                              ; preds = %220
  call void @__assert_fail(ptr noundef @.str.4, ptr noundef @.str.1, i32 noundef 763, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

228:                                              ; preds = %226
  %229 = load ptr, ptr %4, align 8, !tbaa !5
  %230 = getelementptr inbounds %struct.JSON_parser_struct, ptr %229, i32 0, i32 8
  %231 = load i8, ptr %230, align 2, !tbaa !23
  %232 = icmp ne i8 %231, 0
  br i1 %232, label %259, label %233

233:                                              ; preds = %228
  %234 = load ptr, ptr %4, align 8, !tbaa !5
  %235 = getelementptr inbounds %struct.JSON_parser_struct, ptr %234, i32 0, i32 16
  %236 = load ptr, ptr %235, align 8, !tbaa !20
  %237 = load ptr, ptr %4, align 8, !tbaa !5
  %238 = getelementptr inbounds %struct.JSON_parser_struct, ptr %237, i32 0, i32 18
  %239 = load i64, ptr %238, align 8, !tbaa !18
  %240 = sub i64 %239, 1
  %241 = getelementptr inbounds i8, ptr %236, i64 %240
  %242 = load i8, ptr %241, align 1, !tbaa !11
  %243 = sext i8 %242 to i32
  %244 = icmp eq i32 %243, 46
  br i1 %244, label %245, label %246

245:                                              ; preds = %233
  br label %247

246:                                              ; preds = %233
  call void @__assert_fail(ptr noundef @.str.5, ptr noundef @.str.1, i32 noundef 771, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

247:                                              ; preds = %245
  %248 = load ptr, ptr %4, align 8, !tbaa !5
  %249 = getelementptr inbounds %struct.JSON_parser_struct, ptr %248, i32 0, i32 15
  %250 = load i8, ptr %249, align 8, !tbaa !24
  %251 = load ptr, ptr %4, align 8, !tbaa !5
  %252 = getelementptr inbounds %struct.JSON_parser_struct, ptr %251, i32 0, i32 16
  %253 = load ptr, ptr %252, align 8, !tbaa !20
  %254 = load ptr, ptr %4, align 8, !tbaa !5
  %255 = getelementptr inbounds %struct.JSON_parser_struct, ptr %254, i32 0, i32 18
  %256 = load i64, ptr %255, align 8, !tbaa !18
  %257 = sub i64 %256, 1
  %258 = getelementptr inbounds i8, ptr %253, i64 %257
  store i8 %250, ptr %258, align 1, !tbaa !11
  br label %259

259:                                              ; preds = %247, %228
  %260 = load ptr, ptr %4, align 8, !tbaa !5
  %261 = getelementptr inbounds %struct.JSON_parser_struct, ptr %260, i32 0, i32 4
  store i8 6, ptr %261, align 2, !tbaa !17
  %262 = load ptr, ptr %4, align 8, !tbaa !5
  %263 = getelementptr inbounds %struct.JSON_parser_struct, ptr %262, i32 0, i32 2
  store i8 33, ptr %263, align 8, !tbaa !21
  br label %888

264:                                              ; preds = %119
  br label %265

265:                                              ; preds = %264
  %266 = load ptr, ptr %4, align 8, !tbaa !5
  %267 = getelementptr inbounds %struct.JSON_parser_struct, ptr %266, i32 0, i32 18
  store i64 0, ptr %267, align 8, !tbaa !18
  %268 = load ptr, ptr %4, align 8, !tbaa !5
  %269 = getelementptr inbounds %struct.JSON_parser_struct, ptr %268, i32 0, i32 16
  %270 = load ptr, ptr %269, align 8, !tbaa !20
  %271 = getelementptr inbounds i8, ptr %270, i64 0
  store i8 0, ptr %271, align 1, !tbaa !11
  br label %272

272:                                              ; preds = %265
  br label %273

273:                                              ; preds = %272
  %274 = load ptr, ptr %4, align 8, !tbaa !5
  %275 = getelementptr inbounds %struct.JSON_parser_struct, ptr %274, i32 0, i32 4
  %276 = load i8, ptr %275, align 2, !tbaa !17
  %277 = sext i8 %276 to i32
  %278 = icmp eq i32 %277, 0
  br i1 %278, label %279, label %280

279:                                              ; preds = %273
  br label %281

280:                                              ; preds = %273
  call void @__assert_fail(ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 780, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

281:                                              ; preds = %279
  %282 = load ptr, ptr %4, align 8, !tbaa !5
  %283 = getelementptr inbounds %struct.JSON_parser_struct, ptr %282, i32 0, i32 4
  store i8 10, ptr %283, align 2, !tbaa !17
  %284 = load ptr, ptr %4, align 8, !tbaa !5
  %285 = getelementptr inbounds %struct.JSON_parser_struct, ptr %284, i32 0, i32 2
  store i8 7, ptr %285, align 8, !tbaa !21
  br label %888

286:                                              ; preds = %119
  %287 = load ptr, ptr %4, align 8, !tbaa !5
  %288 = getelementptr inbounds %struct.JSON_parser_struct, ptr %287, i32 0, i32 4
  %289 = load i8, ptr %288, align 2, !tbaa !17
  %290 = sext i8 %289 to i32
  %291 = icmp eq i32 %290, 0
  br i1 %291, label %292, label %293

292:                                              ; preds = %286
  br label %294

293:                                              ; preds = %286
  call void @__assert_fail(ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 787, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

294:                                              ; preds = %292
  %295 = load ptr, ptr %4, align 8, !tbaa !5
  %296 = getelementptr inbounds %struct.JSON_parser_struct, ptr %295, i32 0, i32 4
  store i8 7, ptr %296, align 2, !tbaa !17
  %297 = load ptr, ptr %4, align 8, !tbaa !5
  %298 = getelementptr inbounds %struct.JSON_parser_struct, ptr %297, i32 0, i32 2
  store i8 27, ptr %298, align 8, !tbaa !21
  br label %888

299:                                              ; preds = %119
  %300 = load ptr, ptr %4, align 8, !tbaa !5
  %301 = getelementptr inbounds %struct.JSON_parser_struct, ptr %300, i32 0, i32 4
  %302 = load i8, ptr %301, align 2, !tbaa !17
  %303 = sext i8 %302 to i32
  %304 = icmp eq i32 %303, 0
  br i1 %304, label %305, label %306

305:                                              ; preds = %299
  br label %307

306:                                              ; preds = %299
  call void @__assert_fail(ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 793, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

307:                                              ; preds = %305
  %308 = load ptr, ptr %4, align 8, !tbaa !5
  %309 = getelementptr inbounds %struct.JSON_parser_struct, ptr %308, i32 0, i32 4
  store i8 9, ptr %309, align 2, !tbaa !17
  %310 = load ptr, ptr %4, align 8, !tbaa !5
  %311 = getelementptr inbounds %struct.JSON_parser_struct, ptr %310, i32 0, i32 2
  store i8 23, ptr %311, align 8, !tbaa !21
  br label %888

312:                                              ; preds = %119
  %313 = load ptr, ptr %4, align 8, !tbaa !5
  %314 = getelementptr inbounds %struct.JSON_parser_struct, ptr %313, i32 0, i32 4
  %315 = load i8, ptr %314, align 2, !tbaa !17
  %316 = sext i8 %315 to i32
  %317 = icmp eq i32 %316, 0
  br i1 %317, label %318, label %319

318:                                              ; preds = %312
  br label %320

319:                                              ; preds = %312
  call void @__assert_fail(ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 799, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

320:                                              ; preds = %318
  %321 = load ptr, ptr %4, align 8, !tbaa !5
  %322 = getelementptr inbounds %struct.JSON_parser_struct, ptr %321, i32 0, i32 4
  store i8 8, ptr %322, align 2, !tbaa !17
  %323 = load ptr, ptr %4, align 8, !tbaa !5
  %324 = getelementptr inbounds %struct.JSON_parser_struct, ptr %323, i32 0, i32 2
  store i8 20, ptr %324, align 8, !tbaa !21
  br label %888

325:                                              ; preds = %119
  %326 = load ptr, ptr %4, align 8, !tbaa !5
  %327 = getelementptr inbounds %struct.JSON_parser_struct, ptr %326, i32 0, i32 6
  store i8 0, ptr %327, align 4, !tbaa !16
  %328 = load ptr, ptr %4, align 8, !tbaa !5
  %329 = getelementptr inbounds %struct.JSON_parser_struct, ptr %328, i32 0, i32 18
  %330 = load i64, ptr %329, align 8, !tbaa !18
  %331 = icmp eq i64 %330, 0
  br i1 %331, label %332, label %333

332:                                              ; preds = %325
  br label %334

333:                                              ; preds = %325
  call void @__assert_fail(ptr noundef @.str.7, ptr noundef @.str.1, i32 noundef 807, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

334:                                              ; preds = %332
  %335 = load ptr, ptr %4, align 8, !tbaa !5
  %336 = getelementptr inbounds %struct.JSON_parser_struct, ptr %335, i32 0, i32 4
  %337 = load i8, ptr %336, align 2, !tbaa !17
  %338 = sext i8 %337 to i32
  %339 = icmp eq i32 %338, 0
  br i1 %339, label %340, label %341

340:                                              ; preds = %334
  br label %342

341:                                              ; preds = %334
  call void @__assert_fail(ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 808, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

342:                                              ; preds = %340
  %343 = load ptr, ptr %4, align 8, !tbaa !5
  %344 = getelementptr inbounds %struct.JSON_parser_struct, ptr %343, i32 0, i32 3
  %345 = load i8, ptr %344, align 1, !tbaa !25
  %346 = load ptr, ptr %4, align 8, !tbaa !5
  %347 = getelementptr inbounds %struct.JSON_parser_struct, ptr %346, i32 0, i32 2
  store i8 %345, ptr %347, align 8, !tbaa !21
  br label %888

348:                                              ; preds = %119
  %349 = load ptr, ptr %4, align 8, !tbaa !5
  %350 = getelementptr inbounds %struct.JSON_parser_struct, ptr %349, i32 0, i32 7
  %351 = load i8, ptr %350, align 1, !tbaa !26
  %352 = icmp ne i8 %351, 0
  br i1 %352, label %354, label %353

353:                                              ; preds = %348
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

354:                                              ; preds = %348
  br label %355

355:                                              ; preds = %354
  %356 = load ptr, ptr %4, align 8, !tbaa !5
  %357 = getelementptr inbounds %struct.JSON_parser_struct, ptr %356, i32 0, i32 18
  %358 = load i64, ptr %357, align 8, !tbaa !18
  %359 = icmp uge i64 %358, 1
  br i1 %359, label %360, label %361

360:                                              ; preds = %355
  br label %362

361:                                              ; preds = %355
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 817, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

362:                                              ; preds = %360
  %363 = load ptr, ptr %4, align 8, !tbaa !5
  %364 = getelementptr inbounds %struct.JSON_parser_struct, ptr %363, i32 0, i32 18
  %365 = load i64, ptr %364, align 8, !tbaa !18
  %366 = add i64 %365, -1
  store i64 %366, ptr %364, align 8, !tbaa !18
  %367 = load ptr, ptr %4, align 8, !tbaa !5
  %368 = getelementptr inbounds %struct.JSON_parser_struct, ptr %367, i32 0, i32 16
  %369 = load ptr, ptr %368, align 8, !tbaa !20
  %370 = load ptr, ptr %4, align 8, !tbaa !5
  %371 = getelementptr inbounds %struct.JSON_parser_struct, ptr %370, i32 0, i32 18
  %372 = load i64, ptr %371, align 8, !tbaa !18
  %373 = getelementptr inbounds i8, ptr %369, i64 %372
  store i8 0, ptr %373, align 1, !tbaa !11
  br label %374

374:                                              ; preds = %362
  br label %375

375:                                              ; preds = %374
  %376 = load ptr, ptr %4, align 8, !tbaa !5
  %377 = call i32 @parse_parse_buffer(ptr noundef %376)
  %378 = icmp ne i32 %377, 0
  br i1 %378, label %380, label %379

379:                                              ; preds = %375
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

380:                                              ; preds = %375
  %381 = load ptr, ptr %4, align 8, !tbaa !5
  %382 = getelementptr inbounds %struct.JSON_parser_struct, ptr %381, i32 0, i32 18
  %383 = load i64, ptr %382, align 8, !tbaa !18
  %384 = icmp eq i64 %383, 0
  br i1 %384, label %385, label %386

385:                                              ; preds = %380
  br label %387

386:                                              ; preds = %380
  call void @__assert_fail(ptr noundef @.str.7, ptr noundef @.str.1, i32 noundef 821, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

387:                                              ; preds = %385
  %388 = load ptr, ptr %4, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.JSON_parser_struct, ptr %388, i32 0, i32 4
  %390 = load i8, ptr %389, align 2, !tbaa !17
  %391 = sext i8 %390 to i32
  %392 = icmp ne i32 %391, 10
  br i1 %392, label %393, label %394

393:                                              ; preds = %387
  br label %395

394:                                              ; preds = %387
  call void @__assert_fail(ptr noundef @.str.4, ptr noundef @.str.1, i32 noundef 822, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

395:                                              ; preds = %393
  %396 = load ptr, ptr %4, align 8, !tbaa !5
  %397 = getelementptr inbounds %struct.JSON_parser_struct, ptr %396, i32 0, i32 13
  %398 = load ptr, ptr %397, align 8, !tbaa !27
  %399 = load ptr, ptr %4, align 8, !tbaa !5
  %400 = getelementptr inbounds %struct.JSON_parser_struct, ptr %399, i32 0, i32 12
  %401 = load i64, ptr %400, align 8, !tbaa !28
  %402 = getelementptr inbounds i8, ptr %398, i64 %401
  %403 = load i8, ptr %402, align 1, !tbaa !11
  %404 = sext i8 %403 to i32
  switch i32 %404, label %420 [
    i32 1, label %405
    i32 4, label %405
  ]

405:                                              ; preds = %395, %395
  %406 = load ptr, ptr %4, align 8, !tbaa !5
  %407 = getelementptr inbounds %struct.JSON_parser_struct, ptr %406, i32 0, i32 2
  %408 = load i8, ptr %407, align 8, !tbaa !21
  %409 = sext i8 %408 to i32
  switch i32 %409, label %416 [
    i32 5, label %410
    i32 6, label %410
  ]

410:                                              ; preds = %405, %405
  %411 = load ptr, ptr %4, align 8, !tbaa !5
  %412 = getelementptr inbounds %struct.JSON_parser_struct, ptr %411, i32 0, i32 2
  %413 = load i8, ptr %412, align 8, !tbaa !21
  %414 = load ptr, ptr %4, align 8, !tbaa !5
  %415 = getelementptr inbounds %struct.JSON_parser_struct, ptr %414, i32 0, i32 3
  store i8 %413, ptr %415, align 1, !tbaa !25
  br label %419

416:                                              ; preds = %405
  %417 = load ptr, ptr %4, align 8, !tbaa !5
  %418 = getelementptr inbounds %struct.JSON_parser_struct, ptr %417, i32 0, i32 3
  store i8 1, ptr %418, align 1, !tbaa !25
  br label %419

419:                                              ; preds = %416, %410
  br label %426

420:                                              ; preds = %395
  %421 = load ptr, ptr %4, align 8, !tbaa !5
  %422 = getelementptr inbounds %struct.JSON_parser_struct, ptr %421, i32 0, i32 2
  %423 = load i8, ptr %422, align 8, !tbaa !21
  %424 = load ptr, ptr %4, align 8, !tbaa !5
  %425 = getelementptr inbounds %struct.JSON_parser_struct, ptr %424, i32 0, i32 3
  store i8 %423, ptr %425, align 1, !tbaa !25
  br label %426

426:                                              ; preds = %420, %419
  %427 = load ptr, ptr %4, align 8, !tbaa !5
  %428 = getelementptr inbounds %struct.JSON_parser_struct, ptr %427, i32 0, i32 4
  store i8 0, ptr %428, align 2, !tbaa !17
  %429 = load ptr, ptr %4, align 8, !tbaa !5
  %430 = getelementptr inbounds %struct.JSON_parser_struct, ptr %429, i32 0, i32 2
  store i8 30, ptr %430, align 8, !tbaa !21
  %431 = load ptr, ptr %4, align 8, !tbaa !5
  %432 = getelementptr inbounds %struct.JSON_parser_struct, ptr %431, i32 0, i32 6
  store i8 1, ptr %432, align 4, !tbaa !16
  br label %888

433:                                              ; preds = %119
  br label %434

434:                                              ; preds = %433
  %435 = load ptr, ptr %4, align 8, !tbaa !5
  %436 = getelementptr inbounds %struct.JSON_parser_struct, ptr %435, i32 0, i32 18
  store i64 0, ptr %436, align 8, !tbaa !18
  %437 = load ptr, ptr %4, align 8, !tbaa !5
  %438 = getelementptr inbounds %struct.JSON_parser_struct, ptr %437, i32 0, i32 16
  %439 = load ptr, ptr %438, align 8, !tbaa !20
  %440 = getelementptr inbounds i8, ptr %439, i64 0
  store i8 0, ptr %440, align 1, !tbaa !11
  br label %441

441:                                              ; preds = %434
  br label %442

442:                                              ; preds = %441
  %443 = load ptr, ptr %4, align 8, !tbaa !5
  %444 = getelementptr inbounds %struct.JSON_parser_struct, ptr %443, i32 0, i32 0
  %445 = load ptr, ptr %444, align 8, !tbaa !29
  %446 = icmp ne ptr %445, null
  br i1 %446, label %447, label %457

447:                                              ; preds = %442
  %448 = load ptr, ptr %4, align 8, !tbaa !5
  %449 = getelementptr inbounds %struct.JSON_parser_struct, ptr %448, i32 0, i32 0
  %450 = load ptr, ptr %449, align 8, !tbaa !29
  %451 = load ptr, ptr %4, align 8, !tbaa !5
  %452 = getelementptr inbounds %struct.JSON_parser_struct, ptr %451, i32 0, i32 1
  %453 = load ptr, ptr %452, align 8, !tbaa !30
  %454 = call i32 %450(ptr noundef %453, i32 noundef 4, ptr noundef null)
  %455 = icmp ne i32 %454, 0
  br i1 %455, label %457, label %456

456:                                              ; preds = %447
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

457:                                              ; preds = %447, %442
  %458 = load ptr, ptr %4, align 8, !tbaa !5
  %459 = call i32 @pop(ptr noundef %458, i32 noundef 3)
  %460 = icmp ne i32 %459, 0
  br i1 %460, label %462, label %461

461:                                              ; preds = %457
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

462:                                              ; preds = %457
  %463 = load ptr, ptr %4, align 8, !tbaa !5
  %464 = getelementptr inbounds %struct.JSON_parser_struct, ptr %463, i32 0, i32 2
  store i8 1, ptr %464, align 8, !tbaa !21
  br label %888

465:                                              ; preds = %119
  br label %466

466:                                              ; preds = %465
  %467 = load ptr, ptr %4, align 8, !tbaa !5
  %468 = getelementptr inbounds %struct.JSON_parser_struct, ptr %467, i32 0, i32 18
  %469 = load i64, ptr %468, align 8, !tbaa !18
  %470 = icmp uge i64 %469, 1
  br i1 %470, label %471, label %472

471:                                              ; preds = %466
  br label %473

472:                                              ; preds = %466
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 857, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

473:                                              ; preds = %471
  %474 = load ptr, ptr %4, align 8, !tbaa !5
  %475 = getelementptr inbounds %struct.JSON_parser_struct, ptr %474, i32 0, i32 18
  %476 = load i64, ptr %475, align 8, !tbaa !18
  %477 = add i64 %476, -1
  store i64 %477, ptr %475, align 8, !tbaa !18
  %478 = load ptr, ptr %4, align 8, !tbaa !5
  %479 = getelementptr inbounds %struct.JSON_parser_struct, ptr %478, i32 0, i32 16
  %480 = load ptr, ptr %479, align 8, !tbaa !20
  %481 = load ptr, ptr %4, align 8, !tbaa !5
  %482 = getelementptr inbounds %struct.JSON_parser_struct, ptr %481, i32 0, i32 18
  %483 = load i64, ptr %482, align 8, !tbaa !18
  %484 = getelementptr inbounds i8, ptr %480, i64 %483
  store i8 0, ptr %484, align 1, !tbaa !11
  br label %485

485:                                              ; preds = %473
  br label %486

486:                                              ; preds = %485
  %487 = load ptr, ptr %4, align 8, !tbaa !5
  %488 = call i32 @parse_parse_buffer(ptr noundef %487)
  %489 = icmp ne i32 %488, 0
  br i1 %489, label %491, label %490

490:                                              ; preds = %486
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

491:                                              ; preds = %486
  %492 = load ptr, ptr %4, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.JSON_parser_struct, ptr %492, i32 0, i32 0
  %494 = load ptr, ptr %493, align 8, !tbaa !29
  %495 = icmp ne ptr %494, null
  br i1 %495, label %496, label %506

496:                                              ; preds = %491
  %497 = load ptr, ptr %4, align 8, !tbaa !5
  %498 = getelementptr inbounds %struct.JSON_parser_struct, ptr %497, i32 0, i32 0
  %499 = load ptr, ptr %498, align 8, !tbaa !29
  %500 = load ptr, ptr %4, align 8, !tbaa !5
  %501 = getelementptr inbounds %struct.JSON_parser_struct, ptr %500, i32 0, i32 1
  %502 = load ptr, ptr %501, align 8, !tbaa !30
  %503 = call i32 %499(ptr noundef %502, i32 noundef 4, ptr noundef null)
  %504 = icmp ne i32 %503, 0
  br i1 %504, label %506, label %505

505:                                              ; preds = %496
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

506:                                              ; preds = %496, %491
  %507 = load ptr, ptr %4, align 8, !tbaa !5
  %508 = call i32 @pop(ptr noundef %507, i32 noundef 4)
  %509 = icmp ne i32 %508, 0
  br i1 %509, label %511, label %510

510:                                              ; preds = %506
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

511:                                              ; preds = %506
  %512 = load ptr, ptr %4, align 8, !tbaa !5
  %513 = getelementptr inbounds %struct.JSON_parser_struct, ptr %512, i32 0, i32 4
  store i8 0, ptr %513, align 2, !tbaa !17
  %514 = load ptr, ptr %4, align 8, !tbaa !5
  %515 = getelementptr inbounds %struct.JSON_parser_struct, ptr %514, i32 0, i32 2
  store i8 1, ptr %515, align 8, !tbaa !21
  br label %888

516:                                              ; preds = %119
  br label %517

517:                                              ; preds = %516
  %518 = load ptr, ptr %4, align 8, !tbaa !5
  %519 = getelementptr inbounds %struct.JSON_parser_struct, ptr %518, i32 0, i32 18
  %520 = load i64, ptr %519, align 8, !tbaa !18
  %521 = icmp uge i64 %520, 1
  br i1 %521, label %522, label %523

522:                                              ; preds = %517
  br label %524

523:                                              ; preds = %517
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 872, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

524:                                              ; preds = %522
  %525 = load ptr, ptr %4, align 8, !tbaa !5
  %526 = getelementptr inbounds %struct.JSON_parser_struct, ptr %525, i32 0, i32 18
  %527 = load i64, ptr %526, align 8, !tbaa !18
  %528 = add i64 %527, -1
  store i64 %528, ptr %526, align 8, !tbaa !18
  %529 = load ptr, ptr %4, align 8, !tbaa !5
  %530 = getelementptr inbounds %struct.JSON_parser_struct, ptr %529, i32 0, i32 16
  %531 = load ptr, ptr %530, align 8, !tbaa !20
  %532 = load ptr, ptr %4, align 8, !tbaa !5
  %533 = getelementptr inbounds %struct.JSON_parser_struct, ptr %532, i32 0, i32 18
  %534 = load i64, ptr %533, align 8, !tbaa !18
  %535 = getelementptr inbounds i8, ptr %531, i64 %534
  store i8 0, ptr %535, align 1, !tbaa !11
  br label %536

536:                                              ; preds = %524
  br label %537

537:                                              ; preds = %536
  %538 = load ptr, ptr %4, align 8, !tbaa !5
  %539 = call i32 @parse_parse_buffer(ptr noundef %538)
  %540 = icmp ne i32 %539, 0
  br i1 %540, label %542, label %541

541:                                              ; preds = %537
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

542:                                              ; preds = %537
  %543 = load ptr, ptr %4, align 8, !tbaa !5
  %544 = getelementptr inbounds %struct.JSON_parser_struct, ptr %543, i32 0, i32 0
  %545 = load ptr, ptr %544, align 8, !tbaa !29
  %546 = icmp ne ptr %545, null
  br i1 %546, label %547, label %557

547:                                              ; preds = %542
  %548 = load ptr, ptr %4, align 8, !tbaa !5
  %549 = getelementptr inbounds %struct.JSON_parser_struct, ptr %548, i32 0, i32 0
  %550 = load ptr, ptr %549, align 8, !tbaa !29
  %551 = load ptr, ptr %4, align 8, !tbaa !5
  %552 = getelementptr inbounds %struct.JSON_parser_struct, ptr %551, i32 0, i32 1
  %553 = load ptr, ptr %552, align 8, !tbaa !30
  %554 = call i32 %550(ptr noundef %553, i32 noundef 2, ptr noundef null)
  %555 = icmp ne i32 %554, 0
  br i1 %555, label %557, label %556

556:                                              ; preds = %547
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

557:                                              ; preds = %547, %542
  %558 = load ptr, ptr %4, align 8, !tbaa !5
  %559 = call i32 @pop(ptr noundef %558, i32 noundef 1)
  %560 = icmp ne i32 %559, 0
  br i1 %560, label %562, label %561

561:                                              ; preds = %557
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

562:                                              ; preds = %557
  %563 = load ptr, ptr %4, align 8, !tbaa !5
  %564 = getelementptr inbounds %struct.JSON_parser_struct, ptr %563, i32 0, i32 4
  store i8 0, ptr %564, align 2, !tbaa !17
  %565 = load ptr, ptr %4, align 8, !tbaa !5
  %566 = getelementptr inbounds %struct.JSON_parser_struct, ptr %565, i32 0, i32 2
  store i8 1, ptr %566, align 8, !tbaa !21
  br label %888

567:                                              ; preds = %119
  br label %568

568:                                              ; preds = %567
  %569 = load ptr, ptr %4, align 8, !tbaa !5
  %570 = getelementptr inbounds %struct.JSON_parser_struct, ptr %569, i32 0, i32 18
  %571 = load i64, ptr %570, align 8, !tbaa !18
  %572 = icmp uge i64 %571, 1
  br i1 %572, label %573, label %574

573:                                              ; preds = %568
  br label %575

574:                                              ; preds = %568
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 888, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

575:                                              ; preds = %573
  %576 = load ptr, ptr %4, align 8, !tbaa !5
  %577 = getelementptr inbounds %struct.JSON_parser_struct, ptr %576, i32 0, i32 18
  %578 = load i64, ptr %577, align 8, !tbaa !18
  %579 = add i64 %578, -1
  store i64 %579, ptr %577, align 8, !tbaa !18
  %580 = load ptr, ptr %4, align 8, !tbaa !5
  %581 = getelementptr inbounds %struct.JSON_parser_struct, ptr %580, i32 0, i32 16
  %582 = load ptr, ptr %581, align 8, !tbaa !20
  %583 = load ptr, ptr %4, align 8, !tbaa !5
  %584 = getelementptr inbounds %struct.JSON_parser_struct, ptr %583, i32 0, i32 18
  %585 = load i64, ptr %584, align 8, !tbaa !18
  %586 = getelementptr inbounds i8, ptr %582, i64 %585
  store i8 0, ptr %586, align 1, !tbaa !11
  br label %587

587:                                              ; preds = %575
  br label %588

588:                                              ; preds = %587
  %589 = load ptr, ptr %4, align 8, !tbaa !5
  %590 = getelementptr inbounds %struct.JSON_parser_struct, ptr %589, i32 0, i32 0
  %591 = load ptr, ptr %590, align 8, !tbaa !29
  %592 = icmp ne ptr %591, null
  br i1 %592, label %593, label %603

593:                                              ; preds = %588
  %594 = load ptr, ptr %4, align 8, !tbaa !5
  %595 = getelementptr inbounds %struct.JSON_parser_struct, ptr %594, i32 0, i32 0
  %596 = load ptr, ptr %595, align 8, !tbaa !29
  %597 = load ptr, ptr %4, align 8, !tbaa !5
  %598 = getelementptr inbounds %struct.JSON_parser_struct, ptr %597, i32 0, i32 1
  %599 = load ptr, ptr %598, align 8, !tbaa !30
  %600 = call i32 %596(ptr noundef %599, i32 noundef 3, ptr noundef null)
  %601 = icmp ne i32 %600, 0
  br i1 %601, label %603, label %602

602:                                              ; preds = %593
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

603:                                              ; preds = %593, %588
  %604 = load ptr, ptr %4, align 8, !tbaa !5
  %605 = call i32 @push(ptr noundef %604, i32 noundef 3)
  %606 = icmp ne i32 %605, 0
  br i1 %606, label %608, label %607

607:                                              ; preds = %603
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

608:                                              ; preds = %603
  %609 = load ptr, ptr %4, align 8, !tbaa !5
  %610 = getelementptr inbounds %struct.JSON_parser_struct, ptr %609, i32 0, i32 4
  %611 = load i8, ptr %610, align 2, !tbaa !17
  %612 = sext i8 %611 to i32
  %613 = icmp eq i32 %612, 0
  br i1 %613, label %614, label %615

614:                                              ; preds = %608
  br label %616

615:                                              ; preds = %608
  call void @__assert_fail(ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 895, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

616:                                              ; preds = %614
  %617 = load ptr, ptr %4, align 8, !tbaa !5
  %618 = getelementptr inbounds %struct.JSON_parser_struct, ptr %617, i32 0, i32 2
  store i8 2, ptr %618, align 8, !tbaa !21
  br label %888

619:                                              ; preds = %119
  br label %620

620:                                              ; preds = %619
  %621 = load ptr, ptr %4, align 8, !tbaa !5
  %622 = getelementptr inbounds %struct.JSON_parser_struct, ptr %621, i32 0, i32 18
  %623 = load i64, ptr %622, align 8, !tbaa !18
  %624 = icmp uge i64 %623, 1
  br i1 %624, label %625, label %626

625:                                              ; preds = %620
  br label %627

626:                                              ; preds = %620
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 900, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

627:                                              ; preds = %625
  %628 = load ptr, ptr %4, align 8, !tbaa !5
  %629 = getelementptr inbounds %struct.JSON_parser_struct, ptr %628, i32 0, i32 18
  %630 = load i64, ptr %629, align 8, !tbaa !18
  %631 = add i64 %630, -1
  store i64 %631, ptr %629, align 8, !tbaa !18
  %632 = load ptr, ptr %4, align 8, !tbaa !5
  %633 = getelementptr inbounds %struct.JSON_parser_struct, ptr %632, i32 0, i32 16
  %634 = load ptr, ptr %633, align 8, !tbaa !20
  %635 = load ptr, ptr %4, align 8, !tbaa !5
  %636 = getelementptr inbounds %struct.JSON_parser_struct, ptr %635, i32 0, i32 18
  %637 = load i64, ptr %636, align 8, !tbaa !18
  %638 = getelementptr inbounds i8, ptr %634, i64 %637
  store i8 0, ptr %638, align 1, !tbaa !11
  br label %639

639:                                              ; preds = %627
  br label %640

640:                                              ; preds = %639
  %641 = load ptr, ptr %4, align 8, !tbaa !5
  %642 = getelementptr inbounds %struct.JSON_parser_struct, ptr %641, i32 0, i32 0
  %643 = load ptr, ptr %642, align 8, !tbaa !29
  %644 = icmp ne ptr %643, null
  br i1 %644, label %645, label %655

645:                                              ; preds = %640
  %646 = load ptr, ptr %4, align 8, !tbaa !5
  %647 = getelementptr inbounds %struct.JSON_parser_struct, ptr %646, i32 0, i32 0
  %648 = load ptr, ptr %647, align 8, !tbaa !29
  %649 = load ptr, ptr %4, align 8, !tbaa !5
  %650 = getelementptr inbounds %struct.JSON_parser_struct, ptr %649, i32 0, i32 1
  %651 = load ptr, ptr %650, align 8, !tbaa !30
  %652 = call i32 %648(ptr noundef %651, i32 noundef 1, ptr noundef null)
  %653 = icmp ne i32 %652, 0
  br i1 %653, label %655, label %654

654:                                              ; preds = %645
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

655:                                              ; preds = %645, %640
  %656 = load ptr, ptr %4, align 8, !tbaa !5
  %657 = call i32 @push(ptr noundef %656, i32 noundef 1)
  %658 = icmp ne i32 %657, 0
  br i1 %658, label %660, label %659

659:                                              ; preds = %655
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

660:                                              ; preds = %655
  %661 = load ptr, ptr %4, align 8, !tbaa !5
  %662 = getelementptr inbounds %struct.JSON_parser_struct, ptr %661, i32 0, i32 4
  %663 = load i8, ptr %662, align 2, !tbaa !17
  %664 = sext i8 %663 to i32
  %665 = icmp eq i32 %664, 0
  br i1 %665, label %666, label %667

666:                                              ; preds = %660
  br label %668

667:                                              ; preds = %660
  call void @__assert_fail(ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 907, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

668:                                              ; preds = %666
  %669 = load ptr, ptr %4, align 8, !tbaa !5
  %670 = getelementptr inbounds %struct.JSON_parser_struct, ptr %669, i32 0, i32 2
  store i8 6, ptr %670, align 8, !tbaa !21
  br label %888

671:                                              ; preds = %119
  br label %672

672:                                              ; preds = %671
  %673 = load ptr, ptr %4, align 8, !tbaa !5
  %674 = getelementptr inbounds %struct.JSON_parser_struct, ptr %673, i32 0, i32 18
  %675 = load i64, ptr %674, align 8, !tbaa !18
  %676 = icmp uge i64 %675, 1
  br i1 %676, label %677, label %678

677:                                              ; preds = %672
  br label %679

678:                                              ; preds = %672
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 912, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

679:                                              ; preds = %677
  %680 = load ptr, ptr %4, align 8, !tbaa !5
  %681 = getelementptr inbounds %struct.JSON_parser_struct, ptr %680, i32 0, i32 18
  %682 = load i64, ptr %681, align 8, !tbaa !18
  %683 = add i64 %682, -1
  store i64 %683, ptr %681, align 8, !tbaa !18
  %684 = load ptr, ptr %4, align 8, !tbaa !5
  %685 = getelementptr inbounds %struct.JSON_parser_struct, ptr %684, i32 0, i32 16
  %686 = load ptr, ptr %685, align 8, !tbaa !20
  %687 = load ptr, ptr %4, align 8, !tbaa !5
  %688 = getelementptr inbounds %struct.JSON_parser_struct, ptr %687, i32 0, i32 18
  %689 = load i64, ptr %688, align 8, !tbaa !18
  %690 = getelementptr inbounds i8, ptr %686, i64 %689
  store i8 0, ptr %690, align 1, !tbaa !11
  br label %691

691:                                              ; preds = %679
  br label %692

692:                                              ; preds = %691
  %693 = load ptr, ptr %4, align 8, !tbaa !5
  %694 = getelementptr inbounds %struct.JSON_parser_struct, ptr %693, i32 0, i32 13
  %695 = load ptr, ptr %694, align 8, !tbaa !27
  %696 = load ptr, ptr %4, align 8, !tbaa !5
  %697 = getelementptr inbounds %struct.JSON_parser_struct, ptr %696, i32 0, i32 12
  %698 = load i64, ptr %697, align 8, !tbaa !28
  %699 = getelementptr inbounds i8, ptr %695, i64 %698
  %700 = load i8, ptr %699, align 1, !tbaa !11
  %701 = sext i8 %700 to i32
  switch i32 %701, label %771 [
    i32 3, label %702
    i32 1, label %753
    i32 4, label %753
  ]

702:                                              ; preds = %692
  %703 = load ptr, ptr %4, align 8, !tbaa !5
  %704 = getelementptr inbounds %struct.JSON_parser_struct, ptr %703, i32 0, i32 4
  %705 = load i8, ptr %704, align 2, !tbaa !17
  %706 = sext i8 %705 to i32
  %707 = icmp eq i32 %706, 10
  br i1 %707, label %708, label %709

708:                                              ; preds = %702
  br label %710

709:                                              ; preds = %702
  call void @__assert_fail(ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 915, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

710:                                              ; preds = %708
  %711 = load ptr, ptr %4, align 8, !tbaa !5
  %712 = getelementptr inbounds %struct.JSON_parser_struct, ptr %711, i32 0, i32 4
  store i8 0, ptr %712, align 2, !tbaa !17
  %713 = load ptr, ptr %4, align 8, !tbaa !5
  %714 = getelementptr inbounds %struct.JSON_parser_struct, ptr %713, i32 0, i32 2
  store i8 4, ptr %714, align 8, !tbaa !21
  %715 = load ptr, ptr %4, align 8, !tbaa !5
  %716 = getelementptr inbounds %struct.JSON_parser_struct, ptr %715, i32 0, i32 0
  %717 = load ptr, ptr %716, align 8, !tbaa !29
  %718 = icmp ne ptr %717, null
  br i1 %718, label %719, label %743

719:                                              ; preds = %710
  call void @llvm.lifetime.start.p0(i64 16, ptr %9) #3
  %720 = load ptr, ptr %4, align 8, !tbaa !5
  %721 = getelementptr inbounds %struct.JSON_parser_struct, ptr %720, i32 0, i32 16
  %722 = load ptr, ptr %721, align 8, !tbaa !20
  %723 = getelementptr inbounds %struct.JSON_value_struct, ptr %9, i32 0, i32 0
  %724 = getelementptr inbounds %struct.anon, ptr %723, i32 0, i32 0
  store ptr %722, ptr %724, align 8, !tbaa !11
  %725 = load ptr, ptr %4, align 8, !tbaa !5
  %726 = getelementptr inbounds %struct.JSON_parser_struct, ptr %725, i32 0, i32 18
  %727 = load i64, ptr %726, align 8, !tbaa !18
  %728 = getelementptr inbounds %struct.JSON_value_struct, ptr %9, i32 0, i32 0
  %729 = getelementptr inbounds %struct.anon, ptr %728, i32 0, i32 1
  store i64 %727, ptr %729, align 8, !tbaa !11
  %730 = load ptr, ptr %4, align 8, !tbaa !5
  %731 = getelementptr inbounds %struct.JSON_parser_struct, ptr %730, i32 0, i32 0
  %732 = load ptr, ptr %731, align 8, !tbaa !29
  %733 = load ptr, ptr %4, align 8, !tbaa !5
  %734 = getelementptr inbounds %struct.JSON_parser_struct, ptr %733, i32 0, i32 1
  %735 = load ptr, ptr %734, align 8, !tbaa !30
  %736 = call i32 %732(ptr noundef %735, i32 noundef 11, ptr noundef %9)
  %737 = icmp ne i32 %736, 0
  br i1 %737, label %739, label %738

738:                                              ; preds = %719
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %740

739:                                              ; preds = %719
  store i32 0, ptr %8, align 4
  br label %740

740:                                              ; preds = %739, %738
  call void @llvm.lifetime.end.p0(i64 16, ptr %9) #3
  %741 = load i32, ptr %8, align 4
  switch i32 %741, label %890 [
    i32 0, label %742
  ]

742:                                              ; preds = %740
  br label %743

743:                                              ; preds = %742, %710
  br label %744

744:                                              ; preds = %743
  %745 = load ptr, ptr %4, align 8, !tbaa !5
  %746 = getelementptr inbounds %struct.JSON_parser_struct, ptr %745, i32 0, i32 18
  store i64 0, ptr %746, align 8, !tbaa !18
  %747 = load ptr, ptr %4, align 8, !tbaa !5
  %748 = getelementptr inbounds %struct.JSON_parser_struct, ptr %747, i32 0, i32 16
  %749 = load ptr, ptr %748, align 8, !tbaa !20
  %750 = getelementptr inbounds i8, ptr %749, i64 0
  store i8 0, ptr %750, align 1, !tbaa !11
  br label %751

751:                                              ; preds = %744
  br label %752

752:                                              ; preds = %751
  br label %772

753:                                              ; preds = %692, %692
  %754 = load ptr, ptr %4, align 8, !tbaa !5
  %755 = getelementptr inbounds %struct.JSON_parser_struct, ptr %754, i32 0, i32 4
  %756 = load i8, ptr %755, align 2, !tbaa !17
  %757 = sext i8 %756 to i32
  %758 = icmp eq i32 %757, 10
  br i1 %758, label %759, label %760

759:                                              ; preds = %753
  br label %761

760:                                              ; preds = %753
  call void @__assert_fail(ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 931, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

761:                                              ; preds = %759
  %762 = load ptr, ptr %4, align 8, !tbaa !5
  %763 = call i32 @parse_parse_buffer(ptr noundef %762)
  %764 = icmp ne i32 %763, 0
  br i1 %764, label %766, label %765

765:                                              ; preds = %761
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

766:                                              ; preds = %761
  %767 = load ptr, ptr %4, align 8, !tbaa !5
  %768 = getelementptr inbounds %struct.JSON_parser_struct, ptr %767, i32 0, i32 4
  store i8 0, ptr %768, align 2, !tbaa !17
  %769 = load ptr, ptr %4, align 8, !tbaa !5
  %770 = getelementptr inbounds %struct.JSON_parser_struct, ptr %769, i32 0, i32 2
  store i8 1, ptr %770, align 8, !tbaa !21
  br label %772

771:                                              ; preds = %692
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

772:                                              ; preds = %766, %752
  br label %888

773:                                              ; preds = %119
  br label %774

774:                                              ; preds = %773
  %775 = load ptr, ptr %4, align 8, !tbaa !5
  %776 = getelementptr inbounds %struct.JSON_parser_struct, ptr %775, i32 0, i32 18
  %777 = load i64, ptr %776, align 8, !tbaa !18
  %778 = icmp uge i64 %777, 1
  br i1 %778, label %779, label %780

779:                                              ; preds = %774
  br label %781

780:                                              ; preds = %774
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 944, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

781:                                              ; preds = %779
  %782 = load ptr, ptr %4, align 8, !tbaa !5
  %783 = getelementptr inbounds %struct.JSON_parser_struct, ptr %782, i32 0, i32 18
  %784 = load i64, ptr %783, align 8, !tbaa !18
  %785 = add i64 %784, -1
  store i64 %785, ptr %783, align 8, !tbaa !18
  %786 = load ptr, ptr %4, align 8, !tbaa !5
  %787 = getelementptr inbounds %struct.JSON_parser_struct, ptr %786, i32 0, i32 16
  %788 = load ptr, ptr %787, align 8, !tbaa !20
  %789 = load ptr, ptr %4, align 8, !tbaa !5
  %790 = getelementptr inbounds %struct.JSON_parser_struct, ptr %789, i32 0, i32 18
  %791 = load i64, ptr %790, align 8, !tbaa !18
  %792 = getelementptr inbounds i8, ptr %788, i64 %791
  store i8 0, ptr %792, align 1, !tbaa !11
  br label %793

793:                                              ; preds = %781
  br label %794

794:                                              ; preds = %793
  %795 = load ptr, ptr %4, align 8, !tbaa !5
  %796 = call i32 @parse_parse_buffer(ptr noundef %795)
  %797 = icmp ne i32 %796, 0
  br i1 %797, label %799, label %798

798:                                              ; preds = %794
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

799:                                              ; preds = %794
  %800 = load ptr, ptr %4, align 8, !tbaa !5
  %801 = getelementptr inbounds %struct.JSON_parser_struct, ptr %800, i32 0, i32 13
  %802 = load ptr, ptr %801, align 8, !tbaa !27
  %803 = load ptr, ptr %4, align 8, !tbaa !5
  %804 = getelementptr inbounds %struct.JSON_parser_struct, ptr %803, i32 0, i32 12
  %805 = load i64, ptr %804, align 8, !tbaa !28
  %806 = getelementptr inbounds i8, ptr %802, i64 %805
  %807 = load i8, ptr %806, align 1, !tbaa !11
  %808 = sext i8 %807 to i32
  switch i32 %808, label %844 [
    i32 4, label %809
    i32 1, label %831
  ]

809:                                              ; preds = %799
  %810 = load ptr, ptr %4, align 8, !tbaa !5
  %811 = call i32 @pop(ptr noundef %810, i32 noundef 4)
  %812 = icmp ne i32 %811, 0
  br i1 %812, label %813, label %817

813:                                              ; preds = %809
  %814 = load ptr, ptr %4, align 8, !tbaa !5
  %815 = call i32 @push(ptr noundef %814, i32 noundef 3)
  %816 = icmp ne i32 %815, 0
  br i1 %816, label %818, label %817

817:                                              ; preds = %813, %809
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

818:                                              ; preds = %813
  %819 = load ptr, ptr %4, align 8, !tbaa !5
  %820 = getelementptr inbounds %struct.JSON_parser_struct, ptr %819, i32 0, i32 4
  %821 = load i8, ptr %820, align 2, !tbaa !17
  %822 = sext i8 %821 to i32
  %823 = icmp ne i32 %822, 10
  br i1 %823, label %824, label %825

824:                                              ; preds = %818
  br label %826

825:                                              ; preds = %818
  call void @__assert_fail(ptr noundef @.str.4, ptr noundef @.str.1, i32 noundef 956, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

826:                                              ; preds = %824
  %827 = load ptr, ptr %4, align 8, !tbaa !5
  %828 = getelementptr inbounds %struct.JSON_parser_struct, ptr %827, i32 0, i32 4
  store i8 0, ptr %828, align 2, !tbaa !17
  %829 = load ptr, ptr %4, align 8, !tbaa !5
  %830 = getelementptr inbounds %struct.JSON_parser_struct, ptr %829, i32 0, i32 2
  store i8 3, ptr %830, align 8, !tbaa !21
  br label %845

831:                                              ; preds = %799
  %832 = load ptr, ptr %4, align 8, !tbaa !5
  %833 = getelementptr inbounds %struct.JSON_parser_struct, ptr %832, i32 0, i32 4
  %834 = load i8, ptr %833, align 2, !tbaa !17
  %835 = sext i8 %834 to i32
  %836 = icmp ne i32 %835, 10
  br i1 %836, label %837, label %838

837:                                              ; preds = %831
  br label %839

838:                                              ; preds = %831
  call void @__assert_fail(ptr noundef @.str.4, ptr noundef @.str.1, i32 noundef 961, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

839:                                              ; preds = %837
  %840 = load ptr, ptr %4, align 8, !tbaa !5
  %841 = getelementptr inbounds %struct.JSON_parser_struct, ptr %840, i32 0, i32 4
  store i8 0, ptr %841, align 2, !tbaa !17
  %842 = load ptr, ptr %4, align 8, !tbaa !5
  %843 = getelementptr inbounds %struct.JSON_parser_struct, ptr %842, i32 0, i32 2
  store i8 5, ptr %843, align 8, !tbaa !21
  br label %845

844:                                              ; preds = %799
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

845:                                              ; preds = %839, %826
  br label %888

846:                                              ; preds = %119
  br label %847

847:                                              ; preds = %846
  %848 = load ptr, ptr %4, align 8, !tbaa !5
  %849 = getelementptr inbounds %struct.JSON_parser_struct, ptr %848, i32 0, i32 18
  %850 = load i64, ptr %849, align 8, !tbaa !18
  %851 = icmp uge i64 %850, 1
  br i1 %851, label %852, label %853

852:                                              ; preds = %847
  br label %854

853:                                              ; preds = %847
  call void @__assert_fail(ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 974, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

854:                                              ; preds = %852
  %855 = load ptr, ptr %4, align 8, !tbaa !5
  %856 = getelementptr inbounds %struct.JSON_parser_struct, ptr %855, i32 0, i32 18
  %857 = load i64, ptr %856, align 8, !tbaa !18
  %858 = add i64 %857, -1
  store i64 %858, ptr %856, align 8, !tbaa !18
  %859 = load ptr, ptr %4, align 8, !tbaa !5
  %860 = getelementptr inbounds %struct.JSON_parser_struct, ptr %859, i32 0, i32 16
  %861 = load ptr, ptr %860, align 8, !tbaa !20
  %862 = load ptr, ptr %4, align 8, !tbaa !5
  %863 = getelementptr inbounds %struct.JSON_parser_struct, ptr %862, i32 0, i32 18
  %864 = load i64, ptr %863, align 8, !tbaa !18
  %865 = getelementptr inbounds i8, ptr %861, i64 %864
  store i8 0, ptr %865, align 1, !tbaa !11
  br label %866

866:                                              ; preds = %854
  br label %867

867:                                              ; preds = %866
  %868 = load ptr, ptr %4, align 8, !tbaa !5
  %869 = call i32 @pop(ptr noundef %868, i32 noundef 3)
  %870 = icmp ne i32 %869, 0
  br i1 %870, label %871, label %875

871:                                              ; preds = %867
  %872 = load ptr, ptr %4, align 8, !tbaa !5
  %873 = call i32 @push(ptr noundef %872, i32 noundef 4)
  %874 = icmp ne i32 %873, 0
  br i1 %874, label %876, label %875

875:                                              ; preds = %871, %867
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

876:                                              ; preds = %871
  %877 = load ptr, ptr %4, align 8, !tbaa !5
  %878 = getelementptr inbounds %struct.JSON_parser_struct, ptr %877, i32 0, i32 4
  %879 = load i8, ptr %878, align 2, !tbaa !17
  %880 = sext i8 %879 to i32
  %881 = icmp eq i32 %880, 0
  br i1 %881, label %882, label %883

882:                                              ; preds = %876
  br label %884

883:                                              ; preds = %876
  call void @__assert_fail(ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 978, ptr noundef @__PRETTY_FUNCTION__.JSON_parser_char) #4
  unreachable

884:                                              ; preds = %882
  %885 = load ptr, ptr %4, align 8, !tbaa !5
  %886 = getelementptr inbounds %struct.JSON_parser_struct, ptr %885, i32 0, i32 2
  store i8 5, ptr %886, align 8, !tbaa !21
  br label %888

887:                                              ; preds = %119
  store i32 0, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

888:                                              ; preds = %884, %845, %772, %668, %616, %562, %511, %462, %426, %342, %320, %307, %294, %281, %259, %191, %154, %149, %144, %139, %138
  br label %889

889:                                              ; preds = %888, %115
  store i32 1, ptr %3, align 4
  store i32 1, ptr %8, align 4
  br label %890

890:                                              ; preds = %889, %887, %875, %844, %817, %798, %771, %765, %740, %659, %654, %607, %602, %561, %556, %541, %510, %505, %490, %461, %456, %379, %353, %126, %38, %25, %12
  call void @llvm.lifetime.end.p0(i64 1, ptr %7) #3
  call void @llvm.lifetime.end.p0(i64 1, ptr %6) #3
  %891 = load i32, ptr %3, align 4
  ret i32 %891
}

; Function Attrs: nounwind uwtable
declare hidden i32 @add_escaped_char_to_parse_buffer(ptr noundef, i32 noundef) #1

; Function Attrs: nounwind uwtable
declare hidden void @grow_parse_buffer(ptr noundef) #1

; Function Attrs: nounwind uwtable
declare hidden i32 @decode_unicode_char(ptr noundef) #1

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #2

; Function Attrs: nounwind uwtable
declare hidden i32 @parse_parse_buffer(ptr noundef) #1

; Function Attrs: nounwind uwtable
declare hidden i32 @pop(ptr noundef, i32 noundef) #1

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { nounwind }
attributes #4 = { noreturn nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!7, !7, i64 0}
!12 = !{!13, !7, i64 19}
!13 = !{!"JSON_parser_struct", !6, i64 0, !6, i64 8, !7, i64 16, !7, i64 17, !7, i64 18, !7, i64 19, !7, i64 20, !7, i64 21, !7, i64 22, !7, i64 23, !14, i64 24, !15, i64 32, !15, i64 40, !6, i64 48, !15, i64 56, !7, i64 64, !6, i64 72, !15, i64 80, !15, i64 88, !15, i64 96, !7, i64 104, !7, i64 232}
!14 = !{!"short", !7, i64 0}
!15 = !{!"long", !7, i64 0}
!16 = !{!13, !7, i64 20}
!17 = !{!13, !7, i64 18}
!18 = !{!13, !15, i64 88}
!19 = !{!13, !15, i64 80}
!20 = !{!13, !6, i64 72}
!21 = !{!13, !7, i64 16}
!22 = !{!13, !14, i64 24}
!23 = !{!13, !7, i64 22}
!24 = !{!13, !7, i64 64}
!25 = !{!13, !7, i64 17}
!26 = !{!13, !7, i64 21}
!27 = !{!13, !6, i64 48}
!28 = !{!13, !15, i64 40}
!29 = !{!13, !6, i64 0}
!30 = !{!13, !6, i64 8}


; Optimized IR (opt -passes='default<O3>'):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.JSON_value_struct = type { %union.anon }
%union.anon = type { %struct.anon }
%struct.anon = type { ptr, i64 }

@ascii_class = external hidden local_unnamed_addr constant [128 x i8], align 16
@state_transition_table = external hidden local_unnamed_addr constant [36 x [32 x i8]], align 16
@.str = external hidden unnamed_addr constant [25 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [82 x i8], align 1
@__PRETTY_FUNCTION__.JSON_parser_char = external hidden unnamed_addr constant [39 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [26 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [50 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [26 x i8], align 1

; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.start.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: nounwind uwtable
declare hidden i32 @push(ptr noundef, i32 noundef) local_unnamed_addr #1

; Function Attrs: mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite)
declare void @llvm.lifetime.end.p0(i64 immarg, ptr nocapture) #0

; Function Attrs: nounwind uwtable
define dso_local range(i32 0, 2) i32 @JSON_parser_char(ptr noundef %0, i32 noundef %1) local_unnamed_addr #1 {
  %3 = alloca %struct.JSON_value_struct, align 8
  %4 = icmp slt i32 %1, 0
  br i1 %4, label %361, label %5

5:                                                ; preds = %2
  %6 = icmp ugt i32 %1, 127
  br i1 %6, label %12, label %7

7:                                                ; preds = %5
  %8 = zext nneg i32 %1 to i64
  %9 = getelementptr inbounds [128 x i8], ptr @ascii_class, i64 0, i64 %8
  %10 = load i8, ptr %9, align 1, !tbaa !5
  %11 = icmp slt i8 %10, 0
  br i1 %11, label %361, label %12

12:                                               ; preds = %5, %7
  %.0187 = phi i8 [ %10, %7 ], [ 30, %5 ]
  %13 = getelementptr inbounds i8, ptr %0, i64 19
  %14 = load i8, ptr %13, align 1, !tbaa !8
  %.not = icmp eq i8 %14, 0
  br i1 %.not, label %17, label %15

15:                                               ; preds = %12
  %16 = tail call i32 @add_escaped_char_to_parse_buffer(ptr noundef nonnull %0, i32 noundef %1)
  %.not207 = icmp eq i32 %16, 0
  br i1 %.not207, label %361, label %42

17:                                               ; preds = %12
  %18 = getelementptr inbounds i8, ptr %0, i64 20
  %19 = load i8, ptr %18, align 4, !tbaa !13
  %.not205 = icmp eq i8 %19, 0
  br i1 %.not205, label %20, label %42

20:                                               ; preds = %17
  %21 = getelementptr inbounds i8, ptr %0, i64 18
  %22 = load i8, ptr %21, align 2, !tbaa !14
  %23 = icmp ne i8 %22, 0
  %24 = icmp ugt i8 %.0187, 1
  %25 = or i1 %24, %23
  br i1 %25, label %26, label %42

26:                                               ; preds = %20
  %27 = getelementptr inbounds i8, ptr %0, i64 88
  %28 = load i64, ptr %27, align 8, !tbaa !15
  %29 = add i64 %28, 1
  %30 = getelementptr inbounds i8, ptr %0, i64 80
  %31 = load i64, ptr %30, align 8, !tbaa !16
  %.not206 = icmp ult i64 %29, %31
  br i1 %.not206, label %33, label %32

32:                                               ; preds = %26
  tail call void @grow_parse_buffer(ptr noundef nonnull %0)
  %.pre = load i64, ptr %27, align 8, !tbaa !15
  %.pre257 = add i64 %.pre, 1
  br label %33

33:                                               ; preds = %32, %26
  %.pre-phi = phi i64 [ %.pre257, %32 ], [ %29, %26 ]
  %34 = phi i64 [ %.pre, %32 ], [ %28, %26 ]
  %35 = trunc i32 %1 to i8
  %36 = getelementptr inbounds i8, ptr %0, i64 72
  %37 = load ptr, ptr %36, align 8, !tbaa !17
  store i64 %.pre-phi, ptr %27, align 8, !tbaa !15
  %38 = getelementptr inbounds i8, ptr %37, i64 %34
  store i8 %35, ptr %38, align 1, !tbaa !5
  %39 = load ptr, ptr %36, align 8, !tbaa !17
  %40 = load i64, ptr %27, align 8, !tbaa !15
  %41 = getelementptr inbounds i8, ptr %39, i64 %40
  store i8 0, ptr %41, align 1, !tbaa !5
  br label %42

42:                                               ; preds = %17, %33, %20, %15
  %43 = getelementptr inbounds i8, ptr %0, i64 16
  %44 = load i8, ptr %43, align 8, !tbaa !18
  %45 = sext i8 %44 to i64
  %46 = zext nneg i8 %.0187 to i64
  %47 = getelementptr inbounds [36 x [32 x i8]], ptr @state_transition_table, i64 0, i64 %45, i64 %46
  %48 = load i8, ptr %47, align 1, !tbaa !5
  %49 = icmp sgt i8 %48, -1
  br i1 %49, label %50, label %51

50:                                               ; preds = %42
  store i8 %48, ptr %43, align 8, !tbaa !18
  br label %361

51:                                               ; preds = %42
  switch i8 %48, label %361 [
    i8 -22, label %52
    i8 -21, label %59
    i8 -18, label %60
    i8 -19, label %62
    i8 -20, label %64
    i8 -15, label %66
    i8 -16, label %74
    i8 -17, label %98
    i8 -14, label %107
    i8 -12, label %113
    i8 -13, label %119
    i8 -11, label %125
    i8 -10, label %139
    i8 -9, label %177
    i8 -8, label %189
    i8 -7, label %209
    i8 -6, label %229
    i8 -5, label %251
    i8 -4, label %273
    i8 -3, label %312
    i8 -2, label %343
  ]

52:                                               ; preds = %51
  %53 = tail call i32 @decode_unicode_char(ptr noundef nonnull %0)
  %.not255 = icmp eq i32 %53, 0
  br i1 %.not255, label %361, label %54

54:                                               ; preds = %52
  %55 = getelementptr inbounds i8, ptr %0, i64 24
  %56 = load i16, ptr %55, align 8, !tbaa !19
  %.not256 = icmp eq i16 %56, 0
  br i1 %.not256, label %58, label %57

57:                                               ; preds = %54
  store i8 34, ptr %43, align 8, !tbaa !18
  br label %361

58:                                               ; preds = %54
  store i8 7, ptr %43, align 8, !tbaa !18
  br label %361

59:                                               ; preds = %51
  store i8 1, ptr %13, align 1, !tbaa !8
  store i8 8, ptr %43, align 8, !tbaa !18
  br label %361

60:                                               ; preds = %51
  %61 = getelementptr inbounds i8, ptr %0, i64 18
  store i8 5, ptr %61, align 2, !tbaa !14
  store i8 13, ptr %43, align 8, !tbaa !18
  br label %361

62:                                               ; preds = %51
  %63 = getelementptr inbounds i8, ptr %0, i64 18
  store i8 5, ptr %63, align 2, !tbaa !14
  store i8 14, ptr %43, align 8, !tbaa !18
  br label %361

64:                                               ; preds = %51
  %65 = getelementptr inbounds i8, ptr %0, i64 18
  store i8 5, ptr %65, align 2, !tbaa !14
  store i8 15, ptr %43, align 8, !tbaa !18
  br label %361

66:                                               ; preds = %51
  %67 = getelementptr inbounds i8, ptr %0, i64 18
  %68 = load i8, ptr %67, align 2, !tbaa !14
  switch i8 %68, label %73 [
    i8 9, label %69
    i8 8, label %70
    i8 7, label %71
    i8 10, label %72
  ]

69:                                               ; preds = %66
  tail call void @__assert_fail(ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, i32 noundef 756, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

70:                                               ; preds = %66
  tail call void @__assert_fail(ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.1, i32 noundef 756, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

71:                                               ; preds = %66
  tail call void @__assert_fail(ptr noundef nonnull @.str.3, ptr noundef nonnull @.str.1, i32 noundef 756, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

72:                                               ; preds = %66
  tail call void @__assert_fail(ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.1, i32 noundef 756, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

73:                                               ; preds = %66
  store i8 6, ptr %67, align 2, !tbaa !14
  store i8 17, ptr %43, align 8, !tbaa !18
  br label %361

74:                                               ; preds = %51
  %75 = getelementptr inbounds i8, ptr %0, i64 18
  %76 = load i8, ptr %75, align 2, !tbaa !14
  switch i8 %76, label %81 [
    i8 9, label %77
    i8 8, label %78
    i8 7, label %79
    i8 10, label %80
  ]

77:                                               ; preds = %74
  tail call void @__assert_fail(ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, i32 noundef 763, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

78:                                               ; preds = %74
  tail call void @__assert_fail(ptr noundef nonnull @.str.2, ptr noundef nonnull @.str.1, i32 noundef 763, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

79:                                               ; preds = %74
  tail call void @__assert_fail(ptr noundef nonnull @.str.3, ptr noundef nonnull @.str.1, i32 noundef 763, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

80:                                               ; preds = %74
  tail call void @__assert_fail(ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.1, i32 noundef 763, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

81:                                               ; preds = %74
  %82 = getelementptr inbounds i8, ptr %0, i64 22
  %83 = load i8, ptr %82, align 2, !tbaa !20
  %.not250 = icmp eq i8 %83, 0
  br i1 %.not250, label %84, label %97

84:                                               ; preds = %81
  %85 = getelementptr inbounds i8, ptr %0, i64 72
  %86 = load ptr, ptr %85, align 8, !tbaa !17
  %87 = getelementptr inbounds i8, ptr %0, i64 88
  %88 = load i64, ptr %87, align 8, !tbaa !15
  %89 = getelementptr i8, ptr %86, i64 %88
  %90 = getelementptr i8, ptr %89, i64 -1
  %91 = load i8, ptr %90, align 1, !tbaa !5
  %92 = icmp eq i8 %91, 46
  br i1 %92, label %94, label %93

93:                                               ; preds = %84
  tail call void @__assert_fail(ptr noundef nonnull @.str.5, ptr noundef nonnull @.str.1, i32 noundef 771, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

94:                                               ; preds = %84
  %95 = getelementptr inbounds i8, ptr %0, i64 64
  %96 = load i8, ptr %95, align 8, !tbaa !21
  store i8 %96, ptr %90, align 1, !tbaa !5
  br label %97

97:                                               ; preds = %94, %81
  store i8 6, ptr %75, align 2, !tbaa !14
  store i8 33, ptr %43, align 8, !tbaa !18
  br label %361

98:                                               ; preds = %51
  %99 = getelementptr inbounds i8, ptr %0, i64 88
  store i64 0, ptr %99, align 8, !tbaa !15
  %100 = getelementptr inbounds i8, ptr %0, i64 72
  %101 = load ptr, ptr %100, align 8, !tbaa !17
  store i8 0, ptr %101, align 1, !tbaa !5
  %102 = getelementptr inbounds i8, ptr %0, i64 18
  %103 = load i8, ptr %102, align 2, !tbaa !14
  %104 = icmp eq i8 %103, 0
  br i1 %104, label %106, label %105

105:                                              ; preds = %98
  tail call void @__assert_fail(ptr noundef nonnull @.str.6, ptr noundef nonnull @.str.1, i32 noundef 780, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

106:                                              ; preds = %98
  store i8 10, ptr %102, align 2, !tbaa !14
  store i8 7, ptr %43, align 8, !tbaa !18
  br label %361

107:                                              ; preds = %51
  %108 = getelementptr inbounds i8, ptr %0, i64 18
  %109 = load i8, ptr %108, align 2, !tbaa !14
  %110 = icmp eq i8 %109, 0
  br i1 %110, label %112, label %111

111:                                              ; preds = %107
  tail call void @__assert_fail(ptr noundef nonnull @.str.6, ptr noundef nonnull @.str.1, i32 noundef 787, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

112:                                              ; preds = %107
  store i8 7, ptr %108, align 2, !tbaa !14
  store i8 27, ptr %43, align 8, !tbaa !18
  br label %361

113:                                              ; preds = %51
  %114 = getelementptr inbounds i8, ptr %0, i64 18
  %115 = load i8, ptr %114, align 2, !tbaa !14
  %116 = icmp eq i8 %115, 0
  br i1 %116, label %118, label %117

117:                                              ; preds = %113
  tail call void @__assert_fail(ptr noundef nonnull @.str.6, ptr noundef nonnull @.str.1, i32 noundef 793, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

118:                                              ; preds = %113
  store i8 9, ptr %114, align 2, !tbaa !14
  store i8 23, ptr %43, align 8, !tbaa !18
  br label %361

119:                                              ; preds = %51
  %120 = getelementptr inbounds i8, ptr %0, i64 18
  %121 = load i8, ptr %120, align 2, !tbaa !14
  %122 = icmp eq i8 %121, 0
  br i1 %122, label %124, label %123

123:                                              ; preds = %119
  tail call void @__assert_fail(ptr noundef nonnull @.str.6, ptr noundef nonnull @.str.1, i32 noundef 799, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

124:                                              ; preds = %119
  store i8 8, ptr %120, align 2, !tbaa !14
  store i8 20, ptr %43, align 8, !tbaa !18
  br label %361

125:                                              ; preds = %51
  %126 = getelementptr inbounds i8, ptr %0, i64 20
  store i8 0, ptr %126, align 4, !tbaa !13
  %127 = getelementptr inbounds i8, ptr %0, i64 88
  %128 = load i64, ptr %127, align 8, !tbaa !15
  %129 = icmp eq i64 %128, 0
  br i1 %129, label %131, label %130

130:                                              ; preds = %125
  tail call void @__assert_fail(ptr noundef nonnull @.str.7, ptr noundef nonnull @.str.1, i32 noundef 807, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

131:                                              ; preds = %125
  %132 = getelementptr inbounds i8, ptr %0, i64 18
  %133 = load i8, ptr %132, align 2, !tbaa !14
  %134 = icmp eq i8 %133, 0
  br i1 %134, label %136, label %135

135:                                              ; preds = %131
  tail call void @__assert_fail(ptr noundef nonnull @.str.6, ptr noundef nonnull @.str.1, i32 noundef 808, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

136:                                              ; preds = %131
  %137 = getelementptr inbounds i8, ptr %0, i64 17
  %138 = load i8, ptr %137, align 1, !tbaa !22
  store i8 %138, ptr %43, align 8, !tbaa !18
  br label %361

139:                                              ; preds = %51
  %140 = getelementptr inbounds i8, ptr %0, i64 21
  %141 = load i8, ptr %140, align 1, !tbaa !23
  %.not242 = icmp eq i8 %141, 0
  br i1 %.not242, label %361, label %142

142:                                              ; preds = %139
  %143 = getelementptr inbounds i8, ptr %0, i64 88
  %144 = load i64, ptr %143, align 8, !tbaa !15
  %.not243 = icmp eq i64 %144, 0
  br i1 %.not243, label %145, label %146

145:                                              ; preds = %142
  tail call void @__assert_fail(ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 817, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

146:                                              ; preds = %142
  %147 = add i64 %144, -1
  store i64 %147, ptr %143, align 8, !tbaa !15
  %148 = getelementptr inbounds i8, ptr %0, i64 72
  %149 = load ptr, ptr %148, align 8, !tbaa !17
  %150 = getelementptr inbounds i8, ptr %149, i64 %147
  store i8 0, ptr %150, align 1, !tbaa !5
  %151 = tail call i32 @parse_parse_buffer(ptr noundef nonnull %0)
  %.not244 = icmp eq i32 %151, 0
  br i1 %.not244, label %361, label %152

152:                                              ; preds = %146
  %153 = load i64, ptr %143, align 8, !tbaa !15
  %154 = icmp eq i64 %153, 0
  br i1 %154, label %156, label %155

155:                                              ; preds = %152
  tail call void @__assert_fail(ptr noundef nonnull @.str.7, ptr noundef nonnull @.str.1, i32 noundef 821, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

156:                                              ; preds = %152
  %157 = getelementptr inbounds i8, ptr %0, i64 18
  %158 = load i8, ptr %157, align 2, !tbaa !14
  %.not245 = icmp eq i8 %158, 10
  br i1 %.not245, label %159, label %160

159:                                              ; preds = %156
  tail call void @__assert_fail(ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.1, i32 noundef 822, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

160:                                              ; preds = %156
  %161 = getelementptr inbounds i8, ptr %0, i64 48
  %162 = load ptr, ptr %161, align 8, !tbaa !24
  %163 = getelementptr inbounds i8, ptr %0, i64 40
  %164 = load i64, ptr %163, align 8, !tbaa !25
  %165 = getelementptr inbounds i8, ptr %162, i64 %164
  %166 = load i8, ptr %165, align 1, !tbaa !5
  switch i8 %166, label %172 [
    i8 1, label %167
    i8 4, label %167
  ]

167:                                              ; preds = %160, %160
  %168 = load i8, ptr %43, align 8, !tbaa !18
  %.off = add i8 %168, -5
  %switch = icmp ult i8 %.off, 2
  %169 = getelementptr inbounds i8, ptr %0, i64 17
  br i1 %switch, label %170, label %171

170:                                              ; preds = %167
  store i8 %168, ptr %169, align 1, !tbaa !22
  br label %175

171:                                              ; preds = %167
  store i8 1, ptr %169, align 1, !tbaa !22
  br label %175

172:                                              ; preds = %160
  %173 = load i8, ptr %43, align 8, !tbaa !18
  %174 = getelementptr inbounds i8, ptr %0, i64 17
  store i8 %173, ptr %174, align 1, !tbaa !22
  br label %175

175:                                              ; preds = %170, %171, %172
  store i8 0, ptr %157, align 2, !tbaa !14
  store i8 30, ptr %43, align 8, !tbaa !18
  %176 = getelementptr inbounds i8, ptr %0, i64 20
  store i8 1, ptr %176, align 4, !tbaa !13
  br label %361

177:                                              ; preds = %51
  %178 = getelementptr inbounds i8, ptr %0, i64 88
  store i64 0, ptr %178, align 8, !tbaa !15
  %179 = getelementptr inbounds i8, ptr %0, i64 72
  %180 = load ptr, ptr %179, align 8, !tbaa !17
  store i8 0, ptr %180, align 1, !tbaa !5
  %181 = load ptr, ptr %0, align 8, !tbaa !26
  %.not239 = icmp eq ptr %181, null
  br i1 %.not239, label %186, label %182

182:                                              ; preds = %177
  %183 = getelementptr inbounds i8, ptr %0, i64 8
  %184 = load ptr, ptr %183, align 8, !tbaa !27
  %185 = tail call i32 %181(ptr noundef %184, i32 noundef 4, ptr noundef null) #4
  %.not240 = icmp eq i32 %185, 0
  br i1 %.not240, label %361, label %186

186:                                              ; preds = %182, %177
  %187 = tail call i32 @pop(ptr noundef nonnull %0, i32 noundef 3)
  %.not241 = icmp eq i32 %187, 0
  br i1 %.not241, label %361, label %188

188:                                              ; preds = %186
  store i8 1, ptr %43, align 8, !tbaa !18
  br label %361

189:                                              ; preds = %51
  %190 = getelementptr inbounds i8, ptr %0, i64 88
  %191 = load i64, ptr %190, align 8, !tbaa !15
  %.not234 = icmp eq i64 %191, 0
  br i1 %.not234, label %192, label %193

192:                                              ; preds = %189
  tail call void @__assert_fail(ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 857, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

193:                                              ; preds = %189
  %194 = add i64 %191, -1
  store i64 %194, ptr %190, align 8, !tbaa !15
  %195 = getelementptr inbounds i8, ptr %0, i64 72
  %196 = load ptr, ptr %195, align 8, !tbaa !17
  %197 = getelementptr inbounds i8, ptr %196, i64 %194
  store i8 0, ptr %197, align 1, !tbaa !5
  %198 = tail call i32 @parse_parse_buffer(ptr noundef nonnull %0)
  %.not235 = icmp eq i32 %198, 0
  br i1 %.not235, label %361, label %199

199:                                              ; preds = %193
  %200 = load ptr, ptr %0, align 8, !tbaa !26
  %.not236 = icmp eq ptr %200, null
  br i1 %.not236, label %205, label %201

201:                                              ; preds = %199
  %202 = getelementptr inbounds i8, ptr %0, i64 8
  %203 = load ptr, ptr %202, align 8, !tbaa !27
  %204 = tail call i32 %200(ptr noundef %203, i32 noundef 4, ptr noundef null) #4
  %.not237 = icmp eq i32 %204, 0
  br i1 %.not237, label %361, label %205

205:                                              ; preds = %201, %199
  %206 = tail call i32 @pop(ptr noundef nonnull %0, i32 noundef 4)
  %.not238 = icmp eq i32 %206, 0
  br i1 %.not238, label %361, label %207

207:                                              ; preds = %205
  %208 = getelementptr inbounds i8, ptr %0, i64 18
  store i8 0, ptr %208, align 2, !tbaa !14
  store i8 1, ptr %43, align 8, !tbaa !18
  br label %361

209:                                              ; preds = %51
  %210 = getelementptr inbounds i8, ptr %0, i64 88
  %211 = load i64, ptr %210, align 8, !tbaa !15
  %.not229 = icmp eq i64 %211, 0
  br i1 %.not229, label %212, label %213

212:                                              ; preds = %209
  tail call void @__assert_fail(ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 872, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

213:                                              ; preds = %209
  %214 = add i64 %211, -1
  store i64 %214, ptr %210, align 8, !tbaa !15
  %215 = getelementptr inbounds i8, ptr %0, i64 72
  %216 = load ptr, ptr %215, align 8, !tbaa !17
  %217 = getelementptr inbounds i8, ptr %216, i64 %214
  store i8 0, ptr %217, align 1, !tbaa !5
  %218 = tail call i32 @parse_parse_buffer(ptr noundef nonnull %0)
  %.not230 = icmp eq i32 %218, 0
  br i1 %.not230, label %361, label %219

219:                                              ; preds = %213
  %220 = load ptr, ptr %0, align 8, !tbaa !26
  %.not231 = icmp eq ptr %220, null
  br i1 %.not231, label %225, label %221

221:                                              ; preds = %219
  %222 = getelementptr inbounds i8, ptr %0, i64 8
  %223 = load ptr, ptr %222, align 8, !tbaa !27
  %224 = tail call i32 %220(ptr noundef %223, i32 noundef 2, ptr noundef null) #4
  %.not232 = icmp eq i32 %224, 0
  br i1 %.not232, label %361, label %225

225:                                              ; preds = %221, %219
  %226 = tail call i32 @pop(ptr noundef nonnull %0, i32 noundef 1)
  %.not233 = icmp eq i32 %226, 0
  br i1 %.not233, label %361, label %227

227:                                              ; preds = %225
  %228 = getelementptr inbounds i8, ptr %0, i64 18
  store i8 0, ptr %228, align 2, !tbaa !14
  store i8 1, ptr %43, align 8, !tbaa !18
  br label %361

229:                                              ; preds = %51
  %230 = getelementptr inbounds i8, ptr %0, i64 88
  %231 = load i64, ptr %230, align 8, !tbaa !15
  %.not225 = icmp eq i64 %231, 0
  br i1 %.not225, label %232, label %233

232:                                              ; preds = %229
  tail call void @__assert_fail(ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 888, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

233:                                              ; preds = %229
  %234 = add i64 %231, -1
  store i64 %234, ptr %230, align 8, !tbaa !15
  %235 = getelementptr inbounds i8, ptr %0, i64 72
  %236 = load ptr, ptr %235, align 8, !tbaa !17
  %237 = getelementptr inbounds i8, ptr %236, i64 %234
  store i8 0, ptr %237, align 1, !tbaa !5
  %238 = load ptr, ptr %0, align 8, !tbaa !26
  %.not226 = icmp eq ptr %238, null
  br i1 %.not226, label %243, label %239

239:                                              ; preds = %233
  %240 = getelementptr inbounds i8, ptr %0, i64 8
  %241 = load ptr, ptr %240, align 8, !tbaa !27
  %242 = tail call i32 %238(ptr noundef %241, i32 noundef 3, ptr noundef null) #4
  %.not227 = icmp eq i32 %242, 0
  br i1 %.not227, label %361, label %243

243:                                              ; preds = %239, %233
  %244 = tail call i32 @push(ptr noundef nonnull %0, i32 noundef 3)
  %.not228 = icmp eq i32 %244, 0
  br i1 %.not228, label %361, label %245

245:                                              ; preds = %243
  %246 = getelementptr inbounds i8, ptr %0, i64 18
  %247 = load i8, ptr %246, align 2, !tbaa !14
  %248 = icmp eq i8 %247, 0
  br i1 %248, label %250, label %249

249:                                              ; preds = %245
  tail call void @__assert_fail(ptr noundef nonnull @.str.6, ptr noundef nonnull @.str.1, i32 noundef 895, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

250:                                              ; preds = %245
  store i8 2, ptr %43, align 8, !tbaa !18
  br label %361

251:                                              ; preds = %51
  %252 = getelementptr inbounds i8, ptr %0, i64 88
  %253 = load i64, ptr %252, align 8, !tbaa !15
  %.not221 = icmp eq i64 %253, 0
  br i1 %.not221, label %254, label %255

254:                                              ; preds = %251
  tail call void @__assert_fail(ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 900, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

255:                                              ; preds = %251
  %256 = add i64 %253, -1
  store i64 %256, ptr %252, align 8, !tbaa !15
  %257 = getelementptr inbounds i8, ptr %0, i64 72
  %258 = load ptr, ptr %257, align 8, !tbaa !17
  %259 = getelementptr inbounds i8, ptr %258, i64 %256
  store i8 0, ptr %259, align 1, !tbaa !5
  %260 = load ptr, ptr %0, align 8, !tbaa !26
  %.not222 = icmp eq ptr %260, null
  br i1 %.not222, label %265, label %261

261:                                              ; preds = %255
  %262 = getelementptr inbounds i8, ptr %0, i64 8
  %263 = load ptr, ptr %262, align 8, !tbaa !27
  %264 = tail call i32 %260(ptr noundef %263, i32 noundef 1, ptr noundef null) #4
  %.not223 = icmp eq i32 %264, 0
  br i1 %.not223, label %361, label %265

265:                                              ; preds = %261, %255
  %266 = tail call i32 @push(ptr noundef nonnull %0, i32 noundef 1)
  %.not224 = icmp eq i32 %266, 0
  br i1 %.not224, label %361, label %267

267:                                              ; preds = %265
  %268 = getelementptr inbounds i8, ptr %0, i64 18
  %269 = load i8, ptr %268, align 2, !tbaa !14
  %270 = icmp eq i8 %269, 0
  br i1 %270, label %272, label %271

271:                                              ; preds = %267
  tail call void @__assert_fail(ptr noundef nonnull @.str.6, ptr noundef nonnull @.str.1, i32 noundef 907, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

272:                                              ; preds = %267
  store i8 6, ptr %43, align 8, !tbaa !18
  br label %361

273:                                              ; preds = %51
  %274 = getelementptr inbounds i8, ptr %0, i64 88
  %275 = load i64, ptr %274, align 8, !tbaa !15
  %.not217 = icmp eq i64 %275, 0
  br i1 %.not217, label %276, label %277

276:                                              ; preds = %273
  tail call void @__assert_fail(ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 912, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

277:                                              ; preds = %273
  %278 = add i64 %275, -1
  store i64 %278, ptr %274, align 8, !tbaa !15
  %279 = getelementptr inbounds i8, ptr %0, i64 72
  %280 = load ptr, ptr %279, align 8, !tbaa !17
  %281 = getelementptr inbounds i8, ptr %280, i64 %278
  store i8 0, ptr %281, align 1, !tbaa !5
  %282 = getelementptr inbounds i8, ptr %0, i64 48
  %283 = load ptr, ptr %282, align 8, !tbaa !24
  %284 = getelementptr inbounds i8, ptr %0, i64 40
  %285 = load i64, ptr %284, align 8, !tbaa !25
  %286 = getelementptr inbounds i8, ptr %283, i64 %285
  %287 = load i8, ptr %286, align 1, !tbaa !5
  switch i8 %287, label %361 [
    i8 3, label %288
    i8 1, label %304
    i8 4, label %304
  ]

288:                                              ; preds = %277
  %289 = getelementptr inbounds i8, ptr %0, i64 18
  %290 = load i8, ptr %289, align 2, !tbaa !14
  %291 = icmp eq i8 %290, 10
  br i1 %291, label %293, label %292

292:                                              ; preds = %288
  tail call void @__assert_fail(ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 915, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

293:                                              ; preds = %288
  store i8 0, ptr %289, align 2, !tbaa !14
  store i8 4, ptr %43, align 8, !tbaa !18
  %294 = load ptr, ptr %0, align 8, !tbaa !26
  %.not219 = icmp eq ptr %294, null
  br i1 %.not219, label %302, label %295

295:                                              ; preds = %293
  call void @llvm.lifetime.start.p0(i64 16, ptr nonnull %3) #4
  %296 = load ptr, ptr %279, align 8, !tbaa !17
  store ptr %296, ptr %3, align 8, !tbaa !5
  %297 = load i64, ptr %274, align 8, !tbaa !15
  %298 = getelementptr inbounds i8, ptr %3, i64 8
  store i64 %297, ptr %298, align 8, !tbaa !5
  %299 = getelementptr inbounds i8, ptr %0, i64 8
  %300 = load ptr, ptr %299, align 8, !tbaa !27
  %301 = call i32 %294(ptr noundef %300, i32 noundef 11, ptr noundef nonnull %3) #4
  %.not220.not = icmp eq i32 %301, 0
  call void @llvm.lifetime.end.p0(i64 16, ptr nonnull %3) #4
  br i1 %.not220.not, label %361, label %302

302:                                              ; preds = %293, %295
  store i64 0, ptr %274, align 8, !tbaa !15
  %303 = load ptr, ptr %279, align 8, !tbaa !17
  store i8 0, ptr %303, align 1, !tbaa !5
  br label %361

304:                                              ; preds = %277, %277
  %305 = getelementptr inbounds i8, ptr %0, i64 18
  %306 = load i8, ptr %305, align 2, !tbaa !14
  %307 = icmp eq i8 %306, 10
  br i1 %307, label %309, label %308

308:                                              ; preds = %304
  tail call void @__assert_fail(ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 931, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

309:                                              ; preds = %304
  %310 = tail call i32 @parse_parse_buffer(ptr noundef nonnull %0)
  %.not218 = icmp eq i32 %310, 0
  br i1 %.not218, label %361, label %311

311:                                              ; preds = %309
  store i8 0, ptr %305, align 2, !tbaa !14
  store i8 1, ptr %43, align 8, !tbaa !18
  br label %361

312:                                              ; preds = %51
  %313 = getelementptr inbounds i8, ptr %0, i64 88
  %314 = load i64, ptr %313, align 8, !tbaa !15
  %.not211 = icmp eq i64 %314, 0
  br i1 %.not211, label %315, label %316

315:                                              ; preds = %312
  tail call void @__assert_fail(ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 944, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

316:                                              ; preds = %312
  %317 = add i64 %314, -1
  store i64 %317, ptr %313, align 8, !tbaa !15
  %318 = getelementptr inbounds i8, ptr %0, i64 72
  %319 = load ptr, ptr %318, align 8, !tbaa !17
  %320 = getelementptr inbounds i8, ptr %319, i64 %317
  store i8 0, ptr %320, align 1, !tbaa !5
  %321 = tail call i32 @parse_parse_buffer(ptr noundef nonnull %0)
  %.not212 = icmp eq i32 %321, 0
  br i1 %.not212, label %361, label %322

322:                                              ; preds = %316
  %323 = getelementptr inbounds i8, ptr %0, i64 48
  %324 = load ptr, ptr %323, align 8, !tbaa !24
  %325 = getelementptr inbounds i8, ptr %0, i64 40
  %326 = load i64, ptr %325, align 8, !tbaa !25
  %327 = getelementptr inbounds i8, ptr %324, i64 %326
  %328 = load i8, ptr %327, align 1, !tbaa !5
  switch i8 %328, label %361 [
    i8 4, label %329
    i8 1, label %338
  ]

329:                                              ; preds = %322
  %330 = tail call i32 @pop(ptr noundef nonnull %0, i32 noundef 4)
  %.not214 = icmp eq i32 %330, 0
  br i1 %.not214, label %361, label %331

331:                                              ; preds = %329
  %332 = tail call i32 @push(ptr noundef nonnull %0, i32 noundef 3)
  %.not215 = icmp eq i32 %332, 0
  br i1 %.not215, label %361, label %333

333:                                              ; preds = %331
  %334 = getelementptr inbounds i8, ptr %0, i64 18
  %335 = load i8, ptr %334, align 2, !tbaa !14
  %.not216 = icmp eq i8 %335, 10
  br i1 %.not216, label %336, label %337

336:                                              ; preds = %333
  tail call void @__assert_fail(ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.1, i32 noundef 956, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

337:                                              ; preds = %333
  store i8 0, ptr %334, align 2, !tbaa !14
  store i8 3, ptr %43, align 8, !tbaa !18
  br label %361

338:                                              ; preds = %322
  %339 = getelementptr inbounds i8, ptr %0, i64 18
  %340 = load i8, ptr %339, align 2, !tbaa !14
  %.not213 = icmp eq i8 %340, 10
  br i1 %.not213, label %341, label %342

341:                                              ; preds = %338
  tail call void @__assert_fail(ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.1, i32 noundef 961, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

342:                                              ; preds = %338
  store i8 0, ptr %339, align 2, !tbaa !14
  store i8 5, ptr %43, align 8, !tbaa !18
  br label %361

343:                                              ; preds = %51
  %344 = getelementptr inbounds i8, ptr %0, i64 88
  %345 = load i64, ptr %344, align 8, !tbaa !15
  %.not208 = icmp eq i64 %345, 0
  br i1 %.not208, label %346, label %347

346:                                              ; preds = %343
  tail call void @__assert_fail(ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 974, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

347:                                              ; preds = %343
  %348 = add i64 %345, -1
  store i64 %348, ptr %344, align 8, !tbaa !15
  %349 = getelementptr inbounds i8, ptr %0, i64 72
  %350 = load ptr, ptr %349, align 8, !tbaa !17
  %351 = getelementptr inbounds i8, ptr %350, i64 %348
  store i8 0, ptr %351, align 1, !tbaa !5
  %352 = tail call i32 @pop(ptr noundef nonnull %0, i32 noundef 3)
  %.not209 = icmp eq i32 %352, 0
  br i1 %.not209, label %361, label %353

353:                                              ; preds = %347
  %354 = tail call i32 @push(ptr noundef nonnull %0, i32 noundef 4)
  %.not210 = icmp eq i32 %354, 0
  br i1 %.not210, label %361, label %355

355:                                              ; preds = %353
  %356 = getelementptr inbounds i8, ptr %0, i64 18
  %357 = load i8, ptr %356, align 2, !tbaa !14
  %358 = icmp eq i8 %357, 0
  br i1 %358, label %360, label %359

359:                                              ; preds = %355
  tail call void @__assert_fail(ptr noundef nonnull @.str.6, ptr noundef nonnull @.str.1, i32 noundef 978, ptr noundef nonnull @__PRETTY_FUNCTION__.JSON_parser_char) #3
  unreachable

360:                                              ; preds = %355
  store i8 5, ptr %43, align 8, !tbaa !18
  br label %361

361:                                              ; preds = %50, %337, %342, %302, %311, %57, %58, %360, %272, %250, %227, %207, %188, %175, %136, %124, %118, %112, %106, %97, %73, %64, %62, %60, %59, %51, %347, %353, %322, %329, %331, %316, %277, %309, %265, %261, %243, %239, %225, %221, %213, %205, %201, %193, %186, %182, %146, %139, %52, %15, %7, %2, %295
  %.1 = phi i32 [ 0, %295 ], [ 0, %2 ], [ 0, %7 ], [ 0, %15 ], [ 0, %52 ], [ 0, %139 ], [ 0, %146 ], [ 0, %182 ], [ 0, %186 ], [ 0, %193 ], [ 0, %201 ], [ 0, %205 ], [ 0, %213 ], [ 0, %221 ], [ 0, %225 ], [ 0, %239 ], [ 0, %243 ], [ 0, %261 ], [ 0, %265 ], [ 0, %309 ], [ 0, %277 ], [ 0, %316 ], [ 0, %331 ], [ 0, %329 ], [ 0, %322 ], [ 0, %353 ], [ 0, %347 ], [ 0, %51 ], [ 1, %59 ], [ 1, %60 ], [ 1, %62 ], [ 1, %64 ], [ 1, %73 ], [ 1, %97 ], [ 1, %106 ], [ 1, %112 ], [ 1, %118 ], [ 1, %124 ], [ 1, %136 ], [ 1, %175 ], [ 1, %188 ], [ 1, %207 ], [ 1, %227 ], [ 1, %250 ], [ 1, %272 ], [ 1, %360 ], [ 1, %58 ], [ 1, %57 ], [ 1, %311 ], [ 1, %302 ], [ 1, %342 ], [ 1, %337 ], [ 1, %50 ]
  ret i32 %.1
}

; Function Attrs: nounwind uwtable
declare hidden i32 @add_escaped_char_to_parse_buffer(ptr noundef, i32 noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
declare hidden void @grow_parse_buffer(ptr noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
declare hidden i32 @decode_unicode_char(ptr noundef) local_unnamed_addr #1

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare hidden i32 @parse_parse_buffer(ptr noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
declare hidden i32 @pop(ptr noundef, i32 noundef) local_unnamed_addr #1

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nounwind uwtable "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { noreturn nounwind }
attributes #4 = { nounwind }

!llvm.module.flags = !{!0, !1, !2, !3}
!llvm.ident = !{!4}

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"omnipotent char", !7, i64 0}
!7 = !{!"Simple C/C++ TBAA"}
!8 = !{!9, !6, i64 19}
!9 = !{!"JSON_parser_struct", !10, i64 0, !10, i64 8, !6, i64 16, !6, i64 17, !6, i64 18, !6, i64 19, !6, i64 20, !6, i64 21, !6, i64 22, !6, i64 23, !11, i64 24, !12, i64 32, !12, i64 40, !10, i64 48, !12, i64 56, !6, i64 64, !10, i64 72, !12, i64 80, !12, i64 88, !12, i64 96, !6, i64 104, !6, i64 232}
!10 = !{!"any pointer", !6, i64 0}
!11 = !{!"short", !6, i64 0}
!12 = !{!"long", !6, i64 0}
!13 = !{!9, !6, i64 20}
!14 = !{!9, !6, i64 18}
!15 = !{!9, !12, i64 88}
!16 = !{!9, !12, i64 80}
!17 = !{!9, !10, i64 72}
!18 = !{!9, !6, i64 16}
!19 = !{!9, !11, i64 24}
!20 = !{!9, !6, i64 22}
!21 = !{!9, !6, i64 64}
!22 = !{!9, !6, i64 17}
!23 = !{!9, !6, i64 21}
!24 = !{!9, !10, i64 48}
!25 = !{!9, !12, i64 40}
!26 = !{!9, !10, i64 0}
!27 = !{!9, !10, i64 8}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,InferFunctionAttrsPass,InstCombinePass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass