; LLVM IR from sylefeb/Silixel :: src/fstapi (fstapi)

; 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.fstReaderContext = type { ptr, ptr, i64, i64, i64, i64, i64, i32, i64, i64, ptr, ptr, ptr, i32, ptr, i8, i8, i8, [129 x i8], [120 x i8], i64, ptr, ptr, i64, i32, ptr, ptr, i64, i64, i8, ptr, i64, i64, ptr, i64, ptr, ptr, i64, i64, ptr, i32, i32, ptr, i32, i32, i32, i64, i8, %struct.fstHier, ptr, i32, ptr, i32, i8, [513 x i8], [513 x i8], ptr, i8, i32, i32, [65536 x i8], ptr, ptr }
%struct.fstHier = type { i8, %union.anon }
%union.anon = type { %struct.fstHierAttr }
%struct.fstHierAttr = type { i8, i8, ptr, i64, i64, i32 }

@stderr = external global ptr, align 8
@.str.55 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.56 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.57 = external hidden unnamed_addr constant [82 x i8], align 1
@.str.58 = external hidden unnamed_addr constant [82 x i8], align 1
@.str.59 = external hidden unnamed_addr constant [91 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 allocsize(0,1)
declare noalias ptr @calloc(i64 noundef, i64 noundef) #1

; Function Attrs: nounwind
declare void @free(ptr noundef) #2

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #3

; Function Attrs: nounwind allocsize(0)
declare noalias ptr @malloc(i64 noundef) #4

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

declare i64 @ftello(ptr noundef) #5

; Function Attrs: nounwind uwtable
declare hidden i64 @fstFread(ptr noundef, i64 noundef, i64 noundef, ptr noundef) #6

; Function Attrs: nounwind
declare i32 @snprintf(ptr noundef, i64 noundef, ptr noundef, ...) #2

; Function Attrs: nounwind
declare i32 @fprintf(ptr noundef, ptr noundef, ...) #2

; Function Attrs: noreturn nounwind
declare void @exit(i32 noundef) #7

; Function Attrs: nounwind uwtable
declare dso_local i32 @fstReaderFseeko(ptr noundef, ptr noundef, i64 noundef, i32 noundef) #6

declare i32 @fgetc(ptr noundef) #5

; Function Attrs: nounwind uwtable
declare hidden i64 @fstReaderVarint64(ptr noundef) #6

; Function Attrs: nounwind uwtable
declare hidden i64 @fstGetVarint64(ptr noundef, ptr noundef) #6

; Function Attrs: nounwind uwtable
declare hidden i64 @fstReaderUint64(ptr noundef) #6

declare i32 @uncompress(ptr noundef, ptr noundef, ptr noundef, i64 noundef) #5

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

; Function Attrs: nounwind uwtable
declare hidden void @fstReaderDeallocateRvatData(ptr noundef) #6

; Function Attrs: nounwind uwtable
declare hidden i64 @fstGetSVarint64(ptr noundef, ptr noundef) #6

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

declare i32 @LZ4_decompress_safe_partial(ptr noundef, ptr noundef, i32 noundef, i32 noundef, i32 noundef) #5

declare i32 @fastlz_decompress(ptr noundef, i32 noundef, ptr noundef, i32 noundef) #5

; Function Attrs: nounwind uwtable
define dso_local ptr @fstReaderGetValueFromHandleAtTime(ptr noundef %0, i64 noundef %1, i32 noundef %2, ptr noundef %3) #6 {
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca i64, align 8
  %8 = alloca i32, align 4
  %9 = alloca ptr, align 8
  %10 = alloca i64, align 8
  %11 = alloca i64, align 8
  %12 = alloca i64, align 8
  %13 = alloca i64, align 8
  %14 = alloca i64, align 8
  %15 = alloca i64, align 8
  %16 = alloca i32, align 4
  %17 = alloca i64, align 8
  %18 = alloca i64, align 8
  %19 = alloca i64, align 8
  %20 = alloca i64, align 8
  %21 = alloca i64, align 8
  %22 = alloca i64, align 8
  %23 = alloca i64, align 8
  %24 = alloca i64, align 8
  %25 = alloca i64, align 8
  %26 = alloca ptr, align 8
  %27 = alloca ptr, align 8
  %28 = alloca i32, align 4
  %29 = alloca i32, align 4
  %30 = alloca i32, align 4
  %31 = alloca i64, align 8
  %32 = alloca i32, align 4
  %33 = alloca i32, align 4
  %34 = alloca i64, align 8
  %35 = alloca ptr, align 8
  %36 = alloca ptr, align 8
  %37 = alloca i64, align 8
  %38 = alloca i64, align 8
  %39 = alloca i32, align 4
  %40 = alloca ptr, align 8
  %41 = alloca i64, align 8
  %42 = alloca i32, align 4
  %43 = alloca i32, align 4
  %44 = alloca i64, align 8
  %45 = alloca ptr, align 8
  %46 = alloca i32, align 4
  %47 = alloca i64, align 8
  %48 = alloca i64, align 8
  %49 = alloca i32, align 4
  %50 = alloca i32, align 4
  %51 = alloca i64, align 8
  %52 = alloca i64, align 8
  %53 = alloca i32, align 4
  %54 = alloca i32, align 4
  %55 = alloca i64, align 8
  %56 = alloca i32, align 4
  %57 = alloca i32, align 4
  %58 = alloca i32, align 4
  %59 = alloca ptr, align 8
  %60 = alloca ptr, align 8
  %61 = alloca i64, align 8
  %62 = alloca i64, align 8
  %63 = alloca i32, align 4
  %64 = alloca i32, align 4
  %65 = alloca ptr, align 8
  %66 = alloca i32, align 4
  %67 = alloca i32, align 4
  %68 = alloca i32, align 4
  %69 = alloca i32, align 4
  %70 = alloca i32, align 4
  %71 = alloca i32, align 4
  %72 = alloca i32, align 4
  %73 = alloca i32, align 4
  %74 = alloca i32, align 4
  %75 = alloca i32, align 4
  %76 = alloca ptr, align 8
  %77 = alloca i32, align 4
  %78 = alloca i32, align 4
  %79 = alloca i32, align 4
  %80 = alloca i8, align 1
  %81 = alloca double, align 8
  %82 = alloca ptr, align 8
  %83 = alloca [8 x i8], align 1
  %84 = alloca ptr, align 8
  %85 = alloca i32, align 4
  %86 = alloca i32, align 4
  %87 = alloca i8, align 1
  %88 = alloca i32, align 4
  store ptr %0, ptr %6, align 8, !tbaa !5
  store i64 %1, ptr %7, align 8, !tbaa !9
  store i32 %2, ptr %8, align 4, !tbaa !11
  store ptr %3, ptr %9, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #8
  store i64 0, ptr %10, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %17) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #8
  store i64 0, ptr %18, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #8
  store i64 0, ptr %19, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #8
  store i32 0, ptr %29, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #8
  %89 = load ptr, ptr %6, align 8, !tbaa !5
  %90 = icmp ne ptr %89, null
  br i1 %90, label %91, label %113

91:                                               ; preds = %4
  %92 = load i32, ptr %8, align 4, !tbaa !11
  %93 = icmp ne i32 %92, 0
  br i1 %93, label %94, label %113

94:                                               ; preds = %91
  %95 = load i32, ptr %8, align 4, !tbaa !11
  %96 = load ptr, ptr %6, align 8, !tbaa !5
  %97 = getelementptr inbounds %struct.fstReaderContext, ptr %96, i32 0, i32 7
  %98 = load i32, ptr %97, align 8, !tbaa !13
  %99 = icmp ugt i32 %95, %98
  br i1 %99, label %113, label %100

100:                                              ; preds = %94
  %101 = load ptr, ptr %9, align 8, !tbaa !5
  %102 = icmp ne ptr %101, null
  br i1 %102, label %103, label %113

103:                                              ; preds = %100
  %104 = load ptr, ptr %6, align 8, !tbaa !5
  %105 = getelementptr inbounds %struct.fstReaderContext, ptr %104, i32 0, i32 10
  %106 = load ptr, ptr %105, align 8, !tbaa !16
  %107 = load i32, ptr %8, align 4, !tbaa !11
  %108 = sub i32 %107, 1
  %109 = zext i32 %108 to i64
  %110 = getelementptr inbounds i32, ptr %106, i64 %109
  %111 = load i32, ptr %110, align 4, !tbaa !11
  %112 = icmp ne i32 %111, 0
  br i1 %112, label %114, label %113

113:                                              ; preds = %103, %100, %94, %91, %4
  store ptr null, ptr %5, align 8
  store i32 1, ptr %32, align 4
  br label %1465

114:                                              ; preds = %103
  %115 = load ptr, ptr %6, align 8, !tbaa !5
  %116 = getelementptr inbounds %struct.fstReaderContext, ptr %115, i32 0, i32 39
  %117 = load ptr, ptr %116, align 8, !tbaa !17
  %118 = icmp ne ptr %117, null
  br i1 %118, label %154, label %119

119:                                              ; preds = %114
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #8
  store i32 0, ptr %33, align 4, !tbaa !11
  %120 = load ptr, ptr %6, align 8, !tbaa !5
  %121 = getelementptr inbounds %struct.fstReaderContext, ptr %120, i32 0, i32 7
  %122 = load i32, ptr %121, align 8, !tbaa !13
  %123 = zext i32 %122 to i64
  %124 = call noalias ptr @calloc(i64 noundef %123, i64 noundef 4) #9
  %125 = load ptr, ptr %6, align 8, !tbaa !5
  %126 = getelementptr inbounds %struct.fstReaderContext, ptr %125, i32 0, i32 39
  store ptr %124, ptr %126, align 8, !tbaa !17
  store i32 0, ptr %30, align 4, !tbaa !11
  br label %127

127:                                              ; preds = %150, %119
  %128 = load i32, ptr %30, align 4, !tbaa !11
  %129 = load ptr, ptr %6, align 8, !tbaa !5
  %130 = getelementptr inbounds %struct.fstReaderContext, ptr %129, i32 0, i32 7
  %131 = load i32, ptr %130, align 8, !tbaa !13
  %132 = icmp ult i32 %128, %131
  br i1 %132, label %133, label %153

133:                                              ; preds = %127
  %134 = load i32, ptr %33, align 4, !tbaa !11
  %135 = load ptr, ptr %6, align 8, !tbaa !5
  %136 = getelementptr inbounds %struct.fstReaderContext, ptr %135, i32 0, i32 39
  %137 = load ptr, ptr %136, align 8, !tbaa !17
  %138 = load i32, ptr %30, align 4, !tbaa !11
  %139 = zext i32 %138 to i64
  %140 = getelementptr inbounds i32, ptr %137, i64 %139
  store i32 %134, ptr %140, align 4, !tbaa !11
  %141 = load ptr, ptr %6, align 8, !tbaa !5
  %142 = getelementptr inbounds %struct.fstReaderContext, ptr %141, i32 0, i32 10
  %143 = load ptr, ptr %142, align 8, !tbaa !16
  %144 = load i32, ptr %30, align 4, !tbaa !11
  %145 = zext i32 %144 to i64
  %146 = getelementptr inbounds i32, ptr %143, i64 %145
  %147 = load i32, ptr %146, align 4, !tbaa !11
  %148 = load i32, ptr %33, align 4, !tbaa !11
  %149 = add i32 %148, %147
  store i32 %149, ptr %33, align 4, !tbaa !11
  br label %150

150:                                              ; preds = %133
  %151 = load i32, ptr %30, align 4, !tbaa !11
  %152 = add i32 %151, 1
  store i32 %152, ptr %30, align 4, !tbaa !11
  br label %127, !llvm.loop !18

153:                                              ; preds = %127
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #8
  br label %154

154:                                              ; preds = %153, %114
  %155 = load ptr, ptr %6, align 8, !tbaa !5
  %156 = getelementptr inbounds %struct.fstReaderContext, ptr %155, i32 0, i32 29
  %157 = load i8, ptr %156, align 8
  %158 = and i8 %157, 1
  %159 = zext i8 %158 to i32
  %160 = icmp ne i32 %159, 0
  br i1 %160, label %161, label %176

161:                                              ; preds = %154
  %162 = load ptr, ptr %6, align 8, !tbaa !5
  %163 = getelementptr inbounds %struct.fstReaderContext, ptr %162, i32 0, i32 31
  %164 = load i64, ptr %163, align 8, !tbaa !20
  %165 = load i64, ptr %7, align 8, !tbaa !9
  %166 = icmp ule i64 %164, %165
  br i1 %166, label %167, label %174

167:                                              ; preds = %161
  %168 = load i64, ptr %7, align 8, !tbaa !9
  %169 = load ptr, ptr %6, align 8, !tbaa !5
  %170 = getelementptr inbounds %struct.fstReaderContext, ptr %169, i32 0, i32 32
  %171 = load i64, ptr %170, align 8, !tbaa !21
  %172 = icmp ule i64 %168, %171
  br i1 %172, label %173, label %174

173:                                              ; preds = %167
  br label %870

174:                                              ; preds = %167, %161
  %175 = load ptr, ptr %6, align 8, !tbaa !5
  call void @fstReaderDeallocateRvatData(ptr noundef %175)
  br label %176

176:                                              ; preds = %174, %154
  %177 = load ptr, ptr %6, align 8, !tbaa !5
  %178 = getelementptr inbounds %struct.fstReaderContext, ptr %177, i32 0, i32 47
  %179 = load i8, ptr %178, align 8
  %180 = and i8 %179, -2
  %181 = or i8 %180, 0
  store i8 %181, ptr %178, align 8
  br label %182

182:                                              ; preds = %304, %217, %176
  %183 = load ptr, ptr %6, align 8, !tbaa !5
  %184 = load ptr, ptr %6, align 8, !tbaa !5
  %185 = getelementptr inbounds %struct.fstReaderContext, ptr %184, i32 0, i32 0
  %186 = load ptr, ptr %185, align 8, !tbaa !22
  %187 = load i64, ptr %10, align 8, !tbaa !9
  store i64 %187, ptr %11, align 8, !tbaa !9
  %188 = call i32 @fstReaderFseeko(ptr noundef %183, ptr noundef %186, i64 noundef %187, i32 noundef 0)
  %189 = load ptr, ptr %6, align 8, !tbaa !5
  %190 = getelementptr inbounds %struct.fstReaderContext, ptr %189, i32 0, i32 0
  %191 = load ptr, ptr %190, align 8, !tbaa !22
  %192 = call i32 @fgetc(ptr noundef %191)
  store i32 %192, ptr %16, align 4, !tbaa !11
  %193 = load ptr, ptr %6, align 8, !tbaa !5
  %194 = getelementptr inbounds %struct.fstReaderContext, ptr %193, i32 0, i32 0
  %195 = load ptr, ptr %194, align 8, !tbaa !22
  %196 = call i64 @fstReaderUint64(ptr noundef %195)
  store i64 %196, ptr %17, align 8, !tbaa !9
  %197 = load i32, ptr %16, align 4, !tbaa !11
  %198 = icmp eq i32 %197, -1
  br i1 %198, label %205, label %199

199:                                              ; preds = %182
  %200 = load i32, ptr %16, align 4, !tbaa !11
  %201 = icmp eq i32 %200, 255
  br i1 %201, label %205, label %202

202:                                              ; preds = %199
  %203 = load i64, ptr %17, align 8, !tbaa !9
  %204 = icmp ne i64 %203, 0
  br i1 %204, label %206, label %205

205:                                              ; preds = %202, %199, %182
  store ptr null, ptr %5, align 8
  store i32 1, ptr %32, align 4
  br label %1465

206:                                              ; preds = %202
  %207 = load i64, ptr %10, align 8, !tbaa !9
  %208 = add nsw i64 %207, 1
  store i64 %208, ptr %10, align 8, !tbaa !9
  %209 = load i32, ptr %16, align 4, !tbaa !11
  %210 = icmp ne i32 %209, 1
  br i1 %210, label %211, label %221

211:                                              ; preds = %206
  %212 = load i32, ptr %16, align 4, !tbaa !11
  %213 = icmp ne i32 %212, 5
  br i1 %213, label %214, label %221

214:                                              ; preds = %211
  %215 = load i32, ptr %16, align 4, !tbaa !11
  %216 = icmp ne i32 %215, 8
  br i1 %216, label %217, label %221

217:                                              ; preds = %214
  %218 = load i64, ptr %17, align 8, !tbaa !9
  %219 = load i64, ptr %10, align 8, !tbaa !9
  %220 = add i64 %219, %218
  store i64 %220, ptr %10, align 8, !tbaa !9
  br label %182

221:                                              ; preds = %214, %211, %206
  %222 = load ptr, ptr %6, align 8, !tbaa !5
  %223 = getelementptr inbounds %struct.fstReaderContext, ptr %222, i32 0, i32 0
  %224 = load ptr, ptr %223, align 8, !tbaa !22
  %225 = call i64 @fstReaderUint64(ptr noundef %224)
  store i64 %225, ptr %12, align 8, !tbaa !9
  %226 = load ptr, ptr %6, align 8, !tbaa !5
  %227 = getelementptr inbounds %struct.fstReaderContext, ptr %226, i32 0, i32 0
  %228 = load ptr, ptr %227, align 8, !tbaa !22
  %229 = call i64 @fstReaderUint64(ptr noundef %228)
  store i64 %229, ptr %13, align 8, !tbaa !9
  %230 = load i64, ptr %12, align 8, !tbaa !9
  %231 = load i64, ptr %7, align 8, !tbaa !9
  %232 = icmp ule i64 %230, %231
  br i1 %232, label %233, label %304

233:                                              ; preds = %221
  %234 = load i64, ptr %7, align 8, !tbaa !9
  %235 = load i64, ptr %13, align 8, !tbaa !9
  %236 = icmp ule i64 %234, %235
  br i1 %236, label %237, label %304

237:                                              ; preds = %233
  %238 = load i64, ptr %7, align 8, !tbaa !9
  %239 = load i64, ptr %13, align 8, !tbaa !9
  %240 = icmp eq i64 %238, %239
  br i1 %240, label %241, label %303

241:                                              ; preds = %237
  %242 = load i64, ptr %7, align 8, !tbaa !9
  %243 = load ptr, ptr %6, align 8, !tbaa !5
  %244 = getelementptr inbounds %struct.fstReaderContext, ptr %243, i32 0, i32 3
  %245 = load i64, ptr %244, align 8, !tbaa !23
  %246 = icmp ne i64 %242, %245
  br i1 %246, label %247, label %303

247:                                              ; preds = %241
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #8
  %248 = load ptr, ptr %6, align 8, !tbaa !5
  %249 = getelementptr inbounds %struct.fstReaderContext, ptr %248, i32 0, i32 0
  %250 = load ptr, ptr %249, align 8, !tbaa !22
  %251 = call i64 @ftello(ptr noundef %250)
  store i64 %251, ptr %34, align 8, !tbaa !9
  %252 = load ptr, ptr %6, align 8, !tbaa !5
  %253 = load ptr, ptr %6, align 8, !tbaa !5
  %254 = getelementptr inbounds %struct.fstReaderContext, ptr %253, i32 0, i32 0
  %255 = load ptr, ptr %254, align 8, !tbaa !22
  %256 = load i64, ptr %10, align 8, !tbaa !9
  %257 = call i32 @fstReaderFseeko(ptr noundef %252, ptr noundef %255, i64 noundef %256, i32 noundef 0)
  %258 = load ptr, ptr %6, align 8, !tbaa !5
  %259 = getelementptr inbounds %struct.fstReaderContext, ptr %258, i32 0, i32 0
  %260 = load ptr, ptr %259, align 8, !tbaa !22
  %261 = call i32 @fgetc(ptr noundef %260)
  store i32 %261, ptr %16, align 4, !tbaa !11
  %262 = load ptr, ptr %6, align 8, !tbaa !5
  %263 = getelementptr inbounds %struct.fstReaderContext, ptr %262, i32 0, i32 0
  %264 = load ptr, ptr %263, align 8, !tbaa !22
  %265 = call i64 @fstReaderUint64(ptr noundef %264)
  store i64 %265, ptr %17, align 8, !tbaa !9
  %266 = load ptr, ptr %6, align 8, !tbaa !5
  %267 = getelementptr inbounds %struct.fstReaderContext, ptr %266, i32 0, i32 0
  %268 = load ptr, ptr %267, align 8, !tbaa !22
  %269 = call i64 @fstReaderUint64(ptr noundef %268)
  store i64 %269, ptr %14, align 8, !tbaa !9
  %270 = load ptr, ptr %6, align 8, !tbaa !5
  %271 = getelementptr inbounds %struct.fstReaderContext, ptr %270, i32 0, i32 0
  %272 = load ptr, ptr %271, align 8, !tbaa !22
  %273 = call i64 @fstReaderUint64(ptr noundef %272)
  store i64 %273, ptr %15, align 8, !tbaa !9
  %274 = load i32, ptr %16, align 4, !tbaa !11
  %275 = icmp ne i32 %274, 1
  br i1 %275, label %276, label %282

276:                                              ; preds = %247
  %277 = load i32, ptr %16, align 4, !tbaa !11
  %278 = icmp ne i32 %277, 5
  br i1 %278, label %279, label %282

279:                                              ; preds = %276
  %280 = load i32, ptr %16, align 4, !tbaa !11
  %281 = icmp ne i32 %280, 8
  br i1 %281, label %289, label %282

282:                                              ; preds = %279, %276, %247
  %283 = load i64, ptr %17, align 8, !tbaa !9
  %284 = icmp ne i64 %283, 0
  br i1 %284, label %285, label %289

285:                                              ; preds = %282
  %286 = load i64, ptr %14, align 8, !tbaa !9
  %287 = load i64, ptr %7, align 8, !tbaa !9
  %288 = icmp ne i64 %286, %287
  br i1 %288, label %289, label %291

289:                                              ; preds = %285, %282, %279
  %290 = load i64, ptr %11, align 8, !tbaa !9
  store i64 %290, ptr %10, align 8, !tbaa !9
  store i32 6, ptr %32, align 4
  br label %300

291:                                              ; preds = %285
  %292 = load i64, ptr %14, align 8, !tbaa !9
  store i64 %292, ptr %12, align 8, !tbaa !9
  %293 = load i64, ptr %15, align 8, !tbaa !9
  store i64 %293, ptr %13, align 8, !tbaa !9
  %294 = load ptr, ptr %6, align 8, !tbaa !5
  %295 = load ptr, ptr %6, align 8, !tbaa !5
  %296 = getelementptr inbounds %struct.fstReaderContext, ptr %295, i32 0, i32 0
  %297 = load ptr, ptr %296, align 8, !tbaa !22
  %298 = load i64, ptr %34, align 8, !tbaa !9
  %299 = call i32 @fstReaderFseeko(ptr noundef %294, ptr noundef %297, i64 noundef %298, i32 noundef 0)
  store i32 0, ptr %32, align 4
  br label %300

300:                                              ; preds = %291, %289
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #8
  %301 = load i32, ptr %32, align 4
  switch i32 %301, label %1467 [
    i32 0, label %302
    i32 6, label %308
  ]

302:                                              ; preds = %300
  br label %303

303:                                              ; preds = %302, %241, %237
  br label %308

304:                                              ; preds = %233, %221
  %305 = load i64, ptr %17, align 8, !tbaa !9
  %306 = load i64, ptr %10, align 8, !tbaa !9
  %307 = add i64 %306, %305
  store i64 %307, ptr %10, align 8, !tbaa !9
  br label %182

308:                                              ; preds = %303, %300
  %309 = load i64, ptr %12, align 8, !tbaa !9
  %310 = load ptr, ptr %6, align 8, !tbaa !5
  %311 = getelementptr inbounds %struct.fstReaderContext, ptr %310, i32 0, i32 31
  store i64 %309, ptr %311, align 8, !tbaa !20
  %312 = load i64, ptr %13, align 8, !tbaa !9
  %313 = load ptr, ptr %6, align 8, !tbaa !5
  %314 = getelementptr inbounds %struct.fstReaderContext, ptr %313, i32 0, i32 32
  store i64 %312, ptr %314, align 8, !tbaa !21
  %315 = load ptr, ptr %6, align 8, !tbaa !5
  %316 = getelementptr inbounds %struct.fstReaderContext, ptr %315, i32 0, i32 0
  %317 = load ptr, ptr %316, align 8, !tbaa !22
  %318 = call i64 @fstReaderUint64(ptr noundef %317)
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %36) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %41) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %42) #8
  %319 = load ptr, ptr %6, align 8, !tbaa !5
  %320 = load ptr, ptr %6, align 8, !tbaa !5
  %321 = getelementptr inbounds %struct.fstReaderContext, ptr %320, i32 0, i32 0
  %322 = load ptr, ptr %321, align 8, !tbaa !22
  %323 = load i64, ptr %10, align 8, !tbaa !9
  %324 = load i64, ptr %17, align 8, !tbaa !9
  %325 = add i64 %323, %324
  %326 = sub i64 %325, 24
  %327 = call i32 @fstReaderFseeko(ptr noundef %319, ptr noundef %322, i64 noundef %326, i32 noundef 0)
  %328 = load ptr, ptr %6, align 8, !tbaa !5
  %329 = getelementptr inbounds %struct.fstReaderContext, ptr %328, i32 0, i32 0
  %330 = load ptr, ptr %329, align 8, !tbaa !22
  %331 = call i64 @fstReaderUint64(ptr noundef %330)
  store i64 %331, ptr %18, align 8, !tbaa !9
  %332 = load ptr, ptr %6, align 8, !tbaa !5
  %333 = getelementptr inbounds %struct.fstReaderContext, ptr %332, i32 0, i32 0
  %334 = load ptr, ptr %333, align 8, !tbaa !22
  %335 = call i64 @fstReaderUint64(ptr noundef %334)
  store i64 %335, ptr %19, align 8, !tbaa !9
  %336 = load ptr, ptr %6, align 8, !tbaa !5
  %337 = getelementptr inbounds %struct.fstReaderContext, ptr %336, i32 0, i32 0
  %338 = load ptr, ptr %337, align 8, !tbaa !22
  %339 = call i64 @fstReaderUint64(ptr noundef %338)
  store i64 %339, ptr %20, align 8, !tbaa !9
  %340 = load i64, ptr %18, align 8, !tbaa !9
  %341 = call noalias ptr @malloc(i64 noundef %340) #10
  store ptr %341, ptr %35, align 8, !tbaa !5
  %342 = load i64, ptr %18, align 8, !tbaa !9
  store i64 %342, ptr %37, align 8, !tbaa !9
  %343 = load i64, ptr %19, align 8, !tbaa !9
  store i64 %343, ptr %38, align 8, !tbaa !9
  %344 = load ptr, ptr %6, align 8, !tbaa !5
  %345 = load ptr, ptr %6, align 8, !tbaa !5
  %346 = getelementptr inbounds %struct.fstReaderContext, ptr %345, i32 0, i32 0
  %347 = load ptr, ptr %346, align 8, !tbaa !22
  %348 = load i64, ptr %19, align 8, !tbaa !9
  %349 = sub nsw i64 -24, %348
  %350 = call i32 @fstReaderFseeko(ptr noundef %344, ptr noundef %347, i64 noundef %349, i32 noundef 1)
  %351 = load i64, ptr %18, align 8, !tbaa !9
  %352 = load i64, ptr %19, align 8, !tbaa !9
  %353 = icmp ne i64 %351, %352
  br i1 %353, label %354, label %375

354:                                              ; preds = %308
  %355 = load i64, ptr %19, align 8, !tbaa !9
  %356 = call noalias ptr @malloc(i64 noundef %355) #10
  store ptr %356, ptr %36, align 8, !tbaa !5
  %357 = load ptr, ptr %36, align 8, !tbaa !5
  %358 = load i64, ptr %19, align 8, !tbaa !9
  %359 = load ptr, ptr %6, align 8, !tbaa !5
  %360 = getelementptr inbounds %struct.fstReaderContext, ptr %359, i32 0, i32 0
  %361 = load ptr, ptr %360, align 8, !tbaa !22
  %362 = call i64 @fstFread(ptr noundef %357, i64 noundef %358, i64 noundef 1, ptr noundef %361)
  %363 = load ptr, ptr %35, align 8, !tbaa !5
  %364 = load ptr, ptr %36, align 8, !tbaa !5
  %365 = load i64, ptr %38, align 8, !tbaa !9
  %366 = call i32 @uncompress(ptr noundef %363, ptr noundef %37, ptr noundef %364, i64 noundef %365)
  store i32 %366, ptr %39, align 4, !tbaa !11
  %367 = load i32, ptr %39, align 4, !tbaa !11
  %368 = icmp ne i32 %367, 0
  br i1 %368, label %369, label %373

369:                                              ; preds = %354
  %370 = load ptr, ptr @stderr, align 8, !tbaa !5
  %371 = load i32, ptr %39, align 4, !tbaa !11
  %372 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %370, ptr noundef @.str.57, i32 noundef %371) #8
  call void @exit(i32 noundef 255) #11
  unreachable

373:                                              ; preds = %354
  %374 = load ptr, ptr %36, align 8, !tbaa !5
  call void @free(ptr noundef %374) #8
  br label %382

375:                                              ; preds = %308
  %376 = load ptr, ptr %35, align 8, !tbaa !5
  %377 = load i64, ptr %18, align 8, !tbaa !9
  %378 = load ptr, ptr %6, align 8, !tbaa !5
  %379 = getelementptr inbounds %struct.fstReaderContext, ptr %378, i32 0, i32 0
  %380 = load ptr, ptr %379, align 8, !tbaa !22
  %381 = call i64 @fstFread(ptr noundef %376, i64 noundef %377, i64 noundef 1, ptr noundef %380)
  br label %382

382:                                              ; preds = %375, %373
  %383 = load i64, ptr %20, align 8, !tbaa !9
  %384 = call noalias ptr @calloc(i64 noundef %383, i64 noundef 8) #9
  %385 = load ptr, ptr %6, align 8, !tbaa !5
  %386 = getelementptr inbounds %struct.fstReaderContext, ptr %385, i32 0, i32 30
  store ptr %384, ptr %386, align 8, !tbaa !24
  %387 = load ptr, ptr %35, align 8, !tbaa !5
  store ptr %387, ptr %40, align 8, !tbaa !5
  store i64 0, ptr %41, align 8, !tbaa !9
  store i32 0, ptr %42, align 4, !tbaa !11
  br label %388

388:                                              ; preds = %409, %382
  %389 = load i32, ptr %42, align 4, !tbaa !11
  %390 = zext i32 %389 to i64
  %391 = load i64, ptr %20, align 8, !tbaa !9
  %392 = icmp ult i64 %390, %391
  br i1 %392, label %393, label %412

393:                                              ; preds = %388
  call void @llvm.lifetime.start.p0(i64 4, ptr %43) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %44) #8
  %394 = load ptr, ptr %40, align 8, !tbaa !5
  %395 = call i64 @fstGetVarint64(ptr noundef %394, ptr noundef %43)
  store i64 %395, ptr %44, align 8, !tbaa !9
  %396 = load i64, ptr %41, align 8, !tbaa !9
  %397 = load i64, ptr %44, align 8, !tbaa !9
  %398 = add i64 %396, %397
  %399 = load ptr, ptr %6, align 8, !tbaa !5
  %400 = getelementptr inbounds %struct.fstReaderContext, ptr %399, i32 0, i32 30
  %401 = load ptr, ptr %400, align 8, !tbaa !24
  %402 = load i32, ptr %42, align 4, !tbaa !11
  %403 = zext i32 %402 to i64
  %404 = getelementptr inbounds i64, ptr %401, i64 %403
  store i64 %398, ptr %404, align 8, !tbaa !9
  store i64 %398, ptr %41, align 8, !tbaa !9
  %405 = load i32, ptr %43, align 4, !tbaa !11
  %406 = load ptr, ptr %40, align 8, !tbaa !5
  %407 = sext i32 %405 to i64
  %408 = getelementptr inbounds i8, ptr %406, i64 %407
  store ptr %408, ptr %40, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 8, ptr %44) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %43) #8
  br label %409

409:                                              ; preds = %393
  %410 = load i32, ptr %42, align 4, !tbaa !11
  %411 = add i32 %410, 1
  store i32 %411, ptr %42, align 4, !tbaa !11
  br label %388, !llvm.loop !25

412:                                              ; preds = %388
  %413 = load ptr, ptr %35, align 8, !tbaa !5
  call void @free(ptr noundef %413) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %42) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %41) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %36) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #8
  %414 = load ptr, ptr %6, align 8, !tbaa !5
  %415 = load ptr, ptr %6, align 8, !tbaa !5
  %416 = getelementptr inbounds %struct.fstReaderContext, ptr %415, i32 0, i32 0
  %417 = load ptr, ptr %416, align 8, !tbaa !22
  %418 = load i64, ptr %10, align 8, !tbaa !9
  %419 = add nsw i64 %418, 32
  %420 = call i32 @fstReaderFseeko(ptr noundef %414, ptr noundef %417, i64 noundef %419, i32 noundef 0)
  %421 = load ptr, ptr %6, align 8, !tbaa !5
  %422 = getelementptr inbounds %struct.fstReaderContext, ptr %421, i32 0, i32 0
  %423 = load ptr, ptr %422, align 8, !tbaa !22
  %424 = call i64 @fstReaderVarint64(ptr noundef %423)
  store i64 %424, ptr %21, align 8, !tbaa !9
  %425 = load ptr, ptr %6, align 8, !tbaa !5
  %426 = getelementptr inbounds %struct.fstReaderContext, ptr %425, i32 0, i32 0
  %427 = load ptr, ptr %426, align 8, !tbaa !22
  %428 = call i64 @fstReaderVarint64(ptr noundef %427)
  store i64 %428, ptr %22, align 8, !tbaa !9
  %429 = load ptr, ptr %6, align 8, !tbaa !5
  %430 = getelementptr inbounds %struct.fstReaderContext, ptr %429, i32 0, i32 0
  %431 = load ptr, ptr %430, align 8, !tbaa !22
  %432 = call i64 @fstReaderVarint64(ptr noundef %431)
  %433 = load ptr, ptr %6, align 8, !tbaa !5
  %434 = getelementptr inbounds %struct.fstReaderContext, ptr %433, i32 0, i32 34
  store i64 %432, ptr %434, align 8, !tbaa !26
  %435 = load i64, ptr %21, align 8, !tbaa !9
  %436 = call noalias ptr @malloc(i64 noundef %435) #10
  %437 = load ptr, ptr %6, align 8, !tbaa !5
  %438 = getelementptr inbounds %struct.fstReaderContext, ptr %437, i32 0, i32 33
  store ptr %436, ptr %438, align 8, !tbaa !27
  %439 = load i64, ptr %21, align 8, !tbaa !9
  %440 = load i64, ptr %22, align 8, !tbaa !9
  %441 = icmp eq i64 %439, %440
  br i1 %441, label %442, label %451

442:                                              ; preds = %412
  %443 = load ptr, ptr %6, align 8, !tbaa !5
  %444 = getelementptr inbounds %struct.fstReaderContext, ptr %443, i32 0, i32 33
  %445 = load ptr, ptr %444, align 8, !tbaa !27
  %446 = load i64, ptr %21, align 8, !tbaa !9
  %447 = load ptr, ptr %6, align 8, !tbaa !5
  %448 = getelementptr inbounds %struct.fstReaderContext, ptr %447, i32 0, i32 0
  %449 = load ptr, ptr %448, align 8, !tbaa !22
  %450 = call i64 @fstFread(ptr noundef %445, i64 noundef %446, i64 noundef 1, ptr noundef %449)
  br label %476

451:                                              ; preds = %412
  call void @llvm.lifetime.start.p0(i64 8, ptr %45) #8
  %452 = load i64, ptr %22, align 8, !tbaa !9
  %453 = call noalias ptr @malloc(i64 noundef %452) #10
  store ptr %453, ptr %45, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %46) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %47) #8
  %454 = load i64, ptr %21, align 8, !tbaa !9
  store i64 %454, ptr %47, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %48) #8
  %455 = load i64, ptr %22, align 8, !tbaa !9
  store i64 %455, ptr %48, align 8, !tbaa !9
  %456 = load ptr, ptr %45, align 8, !tbaa !5
  %457 = load i64, ptr %48, align 8, !tbaa !9
  %458 = load ptr, ptr %6, align 8, !tbaa !5
  %459 = getelementptr inbounds %struct.fstReaderContext, ptr %458, i32 0, i32 0
  %460 = load ptr, ptr %459, align 8, !tbaa !22
  %461 = call i64 @fstFread(ptr noundef %456, i64 noundef %457, i64 noundef 1, ptr noundef %460)
  %462 = load ptr, ptr %6, align 8, !tbaa !5
  %463 = getelementptr inbounds %struct.fstReaderContext, ptr %462, i32 0, i32 33
  %464 = load ptr, ptr %463, align 8, !tbaa !27
  %465 = load ptr, ptr %45, align 8, !tbaa !5
  %466 = load i64, ptr %48, align 8, !tbaa !9
  %467 = call i32 @uncompress(ptr noundef %464, ptr noundef %47, ptr noundef %465, i64 noundef %466)
  store i32 %467, ptr %46, align 4, !tbaa !11
  %468 = load i32, ptr %46, align 4, !tbaa !11
  %469 = icmp ne i32 %468, 0
  br i1 %469, label %470, label %474

470:                                              ; preds = %451
  %471 = load ptr, ptr @stderr, align 8, !tbaa !5
  %472 = load i32, ptr %46, align 4, !tbaa !11
  %473 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %471, ptr noundef @.str.58, i32 noundef %472) #8
  call void @exit(i32 noundef 255) #11
  unreachable

474:                                              ; preds = %451
  %475 = load ptr, ptr %45, align 8, !tbaa !5
  call void @free(ptr noundef %475) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %48) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %47) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %46) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %45) #8
  br label %476

476:                                              ; preds = %474, %442
  %477 = load ptr, ptr %6, align 8, !tbaa !5
  %478 = getelementptr inbounds %struct.fstReaderContext, ptr %477, i32 0, i32 0
  %479 = load ptr, ptr %478, align 8, !tbaa !22
  %480 = call i64 @fstReaderVarint64(ptr noundef %479)
  %481 = load ptr, ptr %6, align 8, !tbaa !5
  %482 = getelementptr inbounds %struct.fstReaderContext, ptr %481, i32 0, i32 37
  store i64 %480, ptr %482, align 8, !tbaa !28
  %483 = load ptr, ptr %6, align 8, !tbaa !5
  %484 = getelementptr inbounds %struct.fstReaderContext, ptr %483, i32 0, i32 0
  %485 = load ptr, ptr %484, align 8, !tbaa !22
  %486 = call i64 @ftello(ptr noundef %485)
  %487 = load ptr, ptr %6, align 8, !tbaa !5
  %488 = getelementptr inbounds %struct.fstReaderContext, ptr %487, i32 0, i32 38
  store i64 %486, ptr %488, align 8, !tbaa !29
  %489 = load ptr, ptr %6, align 8, !tbaa !5
  %490 = getelementptr inbounds %struct.fstReaderContext, ptr %489, i32 0, i32 0
  %491 = load ptr, ptr %490, align 8, !tbaa !22
  %492 = call i32 @fgetc(ptr noundef %491)
  %493 = load ptr, ptr %6, align 8, !tbaa !5
  %494 = getelementptr inbounds %struct.fstReaderContext, ptr %493, i32 0, i32 40
  store i32 %492, ptr %494, align 8, !tbaa !30
  %495 = load i64, ptr %10, align 8, !tbaa !9
  %496 = load i64, ptr %17, align 8, !tbaa !9
  %497 = add i64 %495, %496
  %498 = sub i64 %497, 24
  %499 = load i64, ptr %19, align 8, !tbaa !9
  %500 = sub i64 %498, %499
  %501 = sub i64 %500, 8
  store i64 %501, ptr %23, align 8, !tbaa !9
  %502 = load ptr, ptr %6, align 8, !tbaa !5
  %503 = load ptr, ptr %6, align 8, !tbaa !5
  %504 = getelementptr inbounds %struct.fstReaderContext, ptr %503, i32 0, i32 0
  %505 = load ptr, ptr %504, align 8, !tbaa !22
  %506 = load i64, ptr %23, align 8, !tbaa !9
  %507 = call i32 @fstReaderFseeko(ptr noundef %502, ptr noundef %505, i64 noundef %506, i32 noundef 0)
  %508 = load ptr, ptr %6, align 8, !tbaa !5
  %509 = getelementptr inbounds %struct.fstReaderContext, ptr %508, i32 0, i32 0
  %510 = load ptr, ptr %509, align 8, !tbaa !22
  %511 = call i64 @fstReaderUint64(ptr noundef %510)
  store i64 %511, ptr %25, align 8, !tbaa !9
  %512 = load i64, ptr %23, align 8, !tbaa !9
  %513 = load i64, ptr %25, align 8, !tbaa !9
  %514 = sub nsw i64 %512, %513
  store i64 %514, ptr %24, align 8, !tbaa !9
  %515 = load i64, ptr %25, align 8, !tbaa !9
  %516 = call noalias ptr @malloc(i64 noundef %515) #10
  store ptr %516, ptr %26, align 8, !tbaa !5
  %517 = load ptr, ptr %6, align 8, !tbaa !5
  %518 = load ptr, ptr %6, align 8, !tbaa !5
  %519 = getelementptr inbounds %struct.fstReaderContext, ptr %518, i32 0, i32 0
  %520 = load ptr, ptr %519, align 8, !tbaa !22
  %521 = load i64, ptr %24, align 8, !tbaa !9
  %522 = call i32 @fstReaderFseeko(ptr noundef %517, ptr noundef %520, i64 noundef %521, i32 noundef 0)
  %523 = load ptr, ptr %26, align 8, !tbaa !5
  %524 = load i64, ptr %25, align 8, !tbaa !9
  %525 = load ptr, ptr %6, align 8, !tbaa !5
  %526 = getelementptr inbounds %struct.fstReaderContext, ptr %525, i32 0, i32 0
  %527 = load ptr, ptr %526, align 8, !tbaa !22
  %528 = call i64 @fstFread(ptr noundef %523, i64 noundef %524, i64 noundef 1, ptr noundef %527)
  %529 = load ptr, ptr %6, align 8, !tbaa !5
  %530 = getelementptr inbounds %struct.fstReaderContext, ptr %529, i32 0, i32 37
  %531 = load i64, ptr %530, align 8, !tbaa !28
  %532 = add i64 %531, 1
  %533 = call noalias ptr @calloc(i64 noundef %532, i64 noundef 8) #9
  %534 = load ptr, ptr %6, align 8, !tbaa !5
  %535 = getelementptr inbounds %struct.fstReaderContext, ptr %534, i32 0, i32 35
  store ptr %533, ptr %535, align 8, !tbaa !31
  %536 = load ptr, ptr %6, align 8, !tbaa !5
  %537 = getelementptr inbounds %struct.fstReaderContext, ptr %536, i32 0, i32 37
  %538 = load i64, ptr %537, align 8, !tbaa !28
  %539 = add i64 %538, 1
  %540 = call noalias ptr @calloc(i64 noundef %539, i64 noundef 4) #9
  %541 = load ptr, ptr %6, align 8, !tbaa !5
  %542 = getelementptr inbounds %struct.fstReaderContext, ptr %541, i32 0, i32 36
  store ptr %540, ptr %542, align 8, !tbaa !32
  %543 = load ptr, ptr %26, align 8, !tbaa !5
  store ptr %543, ptr %27, align 8, !tbaa !5
  store i32 0, ptr %28, align 4, !tbaa !11
  store i64 0, ptr %31, align 8, !tbaa !9
  %544 = load i32, ptr %16, align 4, !tbaa !11
  %545 = icmp eq i32 %544, 8
  br i1 %545, label %546, label %664

546:                                              ; preds = %476
  call void @llvm.lifetime.start.p0(i64 4, ptr %49) #8
  store i32 0, ptr %49, align 4, !tbaa !11
  br label %547

547:                                              ; preds = %657, %546
  call void @llvm.lifetime.start.p0(i64 4, ptr %50) #8
  %548 = load ptr, ptr %27, align 8, !tbaa !5
  %549 = load i8, ptr %548, align 1, !tbaa !33
  %550 = zext i8 %549 to i32
  %551 = and i32 %550, 1
  %552 = icmp ne i32 %551, 0
  br i1 %552, label %553, label %629

553:                                              ; preds = %547
  call void @llvm.lifetime.start.p0(i64 8, ptr %51) #8
  %554 = load ptr, ptr %27, align 8, !tbaa !5
  %555 = call i64 @fstGetSVarint64(ptr noundef %554, ptr noundef %50)
  %556 = ashr i64 %555, 1
  store i64 %556, ptr %51, align 8, !tbaa !9
  %557 = load i64, ptr %51, align 8, !tbaa !9
  %558 = icmp sgt i64 %557, 0
  br i1 %558, label %559, label %591

559:                                              ; preds = %553
  %560 = load i64, ptr %31, align 8, !tbaa !9
  %561 = load i64, ptr %51, align 8, !tbaa !9
  %562 = add i64 %560, %561
  %563 = load ptr, ptr %6, align 8, !tbaa !5
  %564 = getelementptr inbounds %struct.fstReaderContext, ptr %563, i32 0, i32 35
  %565 = load ptr, ptr %564, align 8, !tbaa !31
  %566 = load i32, ptr %28, align 4, !tbaa !11
  %567 = zext i32 %566 to i64
  %568 = getelementptr inbounds i64, ptr %565, i64 %567
  store i64 %562, ptr %568, align 8, !tbaa !9
  store i64 %562, ptr %31, align 8, !tbaa !9
  %569 = load i32, ptr %28, align 4, !tbaa !11
  %570 = icmp ne i32 %569, 0
  br i1 %570, label %571, label %588

571:                                              ; preds = %559
  %572 = load i64, ptr %31, align 8, !tbaa !9
  %573 = load ptr, ptr %6, align 8, !tbaa !5
  %574 = getelementptr inbounds %struct.fstReaderContext, ptr %573, i32 0, i32 35
  %575 = load ptr, ptr %574, align 8, !tbaa !31
  %576 = load i32, ptr %29, align 4, !tbaa !11
  %577 = zext i32 %576 to i64
  %578 = getelementptr inbounds i64, ptr %575, i64 %577
  %579 = load i64, ptr %578, align 8, !tbaa !9
  %580 = sub i64 %572, %579
  %581 = trunc i64 %580 to i32
  %582 = load ptr, ptr %6, align 8, !tbaa !5
  %583 = getelementptr inbounds %struct.fstReaderContext, ptr %582, i32 0, i32 36
  %584 = load ptr, ptr %583, align 8, !tbaa !32
  %585 = load i32, ptr %29, align 4, !tbaa !11
  %586 = zext i32 %585 to i64
  %587 = getelementptr inbounds i32, ptr %584, i64 %586
  store i32 %581, ptr %587, align 4, !tbaa !11
  br label %588

588:                                              ; preds = %571, %559
  %589 = load i32, ptr %28, align 4, !tbaa !11
  %590 = add i32 %589, 1
  store i32 %590, ptr %28, align 4, !tbaa !11
  store i32 %589, ptr %29, align 4, !tbaa !11
  br label %628

591:                                              ; preds = %553
  %592 = load i64, ptr %51, align 8, !tbaa !9
  %593 = icmp slt i64 %592, 0
  br i1 %593, label %594, label %611

594:                                              ; preds = %591
  %595 = load ptr, ptr %6, align 8, !tbaa !5
  %596 = getelementptr inbounds %struct.fstReaderContext, ptr %595, i32 0, i32 35
  %597 = load ptr, ptr %596, align 8, !tbaa !31
  %598 = load i32, ptr %28, align 4, !tbaa !11
  %599 = zext i32 %598 to i64
  %600 = getelementptr inbounds i64, ptr %597, i64 %599
  store i64 0, ptr %600, align 8, !tbaa !9
  %601 = load i64, ptr %51, align 8, !tbaa !9
  %602 = trunc i64 %601 to i32
  store i32 %602, ptr %49, align 4, !tbaa !11
  %603 = load ptr, ptr %6, align 8, !tbaa !5
  %604 = getelementptr inbounds %struct.fstReaderContext, ptr %603, i32 0, i32 36
  %605 = load ptr, ptr %604, align 8, !tbaa !32
  %606 = load i32, ptr %28, align 4, !tbaa !11
  %607 = zext i32 %606 to i64
  %608 = getelementptr inbounds i32, ptr %605, i64 %607
  store i32 %602, ptr %608, align 4, !tbaa !11
  %609 = load i32, ptr %28, align 4, !tbaa !11
  %610 = add i32 %609, 1
  store i32 %610, ptr %28, align 4, !tbaa !11
  br label %627

611:                                              ; preds = %591
  %612 = load ptr, ptr %6, align 8, !tbaa !5
  %613 = getelementptr inbounds %struct.fstReaderContext, ptr %612, i32 0, i32 35
  %614 = load ptr, ptr %613, align 8, !tbaa !31
  %615 = load i32, ptr %28, align 4, !tbaa !11
  %616 = zext i32 %615 to i64
  %617 = getelementptr inbounds i64, ptr %614, i64 %616
  store i64 0, ptr %617, align 8, !tbaa !9
  %618 = load i32, ptr %49, align 4, !tbaa !11
  %619 = load ptr, ptr %6, align 8, !tbaa !5
  %620 = getelementptr inbounds %struct.fstReaderContext, ptr %619, i32 0, i32 36
  %621 = load ptr, ptr %620, align 8, !tbaa !32
  %622 = load i32, ptr %28, align 4, !tbaa !11
  %623 = zext i32 %622 to i64
  %624 = getelementptr inbounds i32, ptr %621, i64 %623
  store i32 %618, ptr %624, align 4, !tbaa !11
  %625 = load i32, ptr %28, align 4, !tbaa !11
  %626 = add i32 %625, 1
  store i32 %626, ptr %28, align 4, !tbaa !11
  br label %627

627:                                              ; preds = %611, %594
  br label %628

628:                                              ; preds = %627, %588
  call void @llvm.lifetime.end.p0(i64 8, ptr %51) #8
  br label %652

629:                                              ; preds = %547
  call void @llvm.lifetime.start.p0(i64 8, ptr %52) #8
  %630 = load ptr, ptr %27, align 8, !tbaa !5
  %631 = call i32 @fstGetVarint32(ptr noundef %630, ptr noundef %50)
  %632 = zext i32 %631 to i64
  store i64 %632, ptr %52, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %53) #8
  %633 = load i64, ptr %52, align 8, !tbaa !9
  %634 = lshr i64 %633, 1
  %635 = trunc i64 %634 to i32
  store i32 %635, ptr %53, align 4, !tbaa !11
  store i32 0, ptr %30, align 4, !tbaa !11
  br label %636

636:                                              ; preds = %648, %629
  %637 = load i32, ptr %30, align 4, !tbaa !11
  %638 = load i32, ptr %53, align 4, !tbaa !11
  %639 = icmp ult i32 %637, %638
  br i1 %639, label %640, label %651

640:                                              ; preds = %636
  %641 = load ptr, ptr %6, align 8, !tbaa !5
  %642 = getelementptr inbounds %struct.fstReaderContext, ptr %641, i32 0, i32 35
  %643 = load ptr, ptr %642, align 8, !tbaa !31
  %644 = load i32, ptr %28, align 4, !tbaa !11
  %645 = add i32 %644, 1
  store i32 %645, ptr %28, align 4, !tbaa !11
  %646 = zext i32 %644 to i64
  %647 = getelementptr inbounds i64, ptr %643, i64 %646
  store i64 0, ptr %647, align 8, !tbaa !9
  br label %648

648:                                              ; preds = %640
  %649 = load i32, ptr %30, align 4, !tbaa !11
  %650 = add i32 %649, 1
  store i32 %650, ptr %30, align 4, !tbaa !11
  br label %636, !llvm.loop !34

651:                                              ; preds = %636
  call void @llvm.lifetime.end.p0(i64 4, ptr %53) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %52) #8
  br label %652

652:                                              ; preds = %651, %628
  %653 = load i32, ptr %50, align 4, !tbaa !11
  %654 = load ptr, ptr %27, align 8, !tbaa !5
  %655 = sext i32 %653 to i64
  %656 = getelementptr inbounds i8, ptr %654, i64 %655
  store ptr %656, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 4, ptr %50) #8
  br label %657

657:                                              ; preds = %652
  %658 = load ptr, ptr %27, align 8, !tbaa !5
  %659 = load ptr, ptr %26, align 8, !tbaa !5
  %660 = load i64, ptr %25, align 8, !tbaa !9
  %661 = getelementptr inbounds i8, ptr %659, i64 %660
  %662 = icmp ne ptr %658, %661
  br i1 %662, label %547, label %663, !llvm.loop !35

663:                                              ; preds = %657
  call void @llvm.lifetime.end.p0(i64 4, ptr %49) #8
  br label %766

664:                                              ; preds = %476
  br label %665

665:                                              ; preds = %759, %664
  call void @llvm.lifetime.start.p0(i64 4, ptr %54) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %55) #8
  %666 = load ptr, ptr %27, align 8, !tbaa !5
  %667 = call i32 @fstGetVarint32(ptr noundef %666, ptr noundef %54)
  %668 = zext i32 %667 to i64
  store i64 %668, ptr %55, align 8, !tbaa !9
  %669 = load i64, ptr %55, align 8, !tbaa !9
  %670 = icmp ne i64 %669, 0
  br i1 %670, label %696, label %671

671:                                              ; preds = %665
  %672 = load i32, ptr %54, align 4, !tbaa !11
  %673 = load ptr, ptr %27, align 8, !tbaa !5
  %674 = sext i32 %672 to i64
  %675 = getelementptr inbounds i8, ptr %673, i64 %674
  store ptr %675, ptr %27, align 8, !tbaa !5
  %676 = load ptr, ptr %27, align 8, !tbaa !5
  %677 = call i32 @fstGetVarint32(ptr noundef %676, ptr noundef %54)
  %678 = zext i32 %677 to i64
  store i64 %678, ptr %55, align 8, !tbaa !9
  %679 = load ptr, ptr %6, align 8, !tbaa !5
  %680 = getelementptr inbounds %struct.fstReaderContext, ptr %679, i32 0, i32 35
  %681 = load ptr, ptr %680, align 8, !tbaa !31
  %682 = load i32, ptr %28, align 4, !tbaa !11
  %683 = zext i32 %682 to i64
  %684 = getelementptr inbounds i64, ptr %681, i64 %683
  store i64 0, ptr %684, align 8, !tbaa !9
  %685 = load i64, ptr %55, align 8, !tbaa !9
  %686 = sub i64 0, %685
  %687 = trunc i64 %686 to i32
  %688 = load ptr, ptr %6, align 8, !tbaa !5
  %689 = getelementptr inbounds %struct.fstReaderContext, ptr %688, i32 0, i32 36
  %690 = load ptr, ptr %689, align 8, !tbaa !32
  %691 = load i32, ptr %28, align 4, !tbaa !11
  %692 = zext i32 %691 to i64
  %693 = getelementptr inbounds i32, ptr %690, i64 %692
  store i32 %687, ptr %693, align 4, !tbaa !11
  %694 = load i32, ptr %28, align 4, !tbaa !11
  %695 = add i32 %694, 1
  store i32 %695, ptr %28, align 4, !tbaa !11
  br label %754

696:                                              ; preds = %665
  %697 = load i64, ptr %55, align 8, !tbaa !9
  %698 = and i64 %697, 1
  %699 = icmp ne i64 %698, 0
  br i1 %699, label %700, label %733

700:                                              ; preds = %696
  %701 = load i64, ptr %31, align 8, !tbaa !9
  %702 = load i64, ptr %55, align 8, !tbaa !9
  %703 = lshr i64 %702, 1
  %704 = add i64 %701, %703
  %705 = load ptr, ptr %6, align 8, !tbaa !5
  %706 = getelementptr inbounds %struct.fstReaderContext, ptr %705, i32 0, i32 35
  %707 = load ptr, ptr %706, align 8, !tbaa !31
  %708 = load i32, ptr %28, align 4, !tbaa !11
  %709 = zext i32 %708 to i64
  %710 = getelementptr inbounds i64, ptr %707, i64 %709
  store i64 %704, ptr %710, align 8, !tbaa !9
  store i64 %704, ptr %31, align 8, !tbaa !9
  %711 = load i32, ptr %28, align 4, !tbaa !11
  %712 = icmp ne i32 %711, 0
  br i1 %712, label %713, label %730

713:                                              ; preds = %700
  %714 = load i64, ptr %31, align 8, !tbaa !9
  %715 = load ptr, ptr %6, align 8, !tbaa !5
  %716 = getelementptr inbounds %struct.fstReaderContext, ptr %715, i32 0, i32 35
  %717 = load ptr, ptr %716, align 8, !tbaa !31
  %718 = load i32, ptr %29, align 4, !tbaa !11
  %719 = zext i32 %718 to i64
  %720 = getelementptr inbounds i64, ptr %717, i64 %719
  %721 = load i64, ptr %720, align 8, !tbaa !9
  %722 = sub i64 %714, %721
  %723 = trunc i64 %722 to i32
  %724 = load ptr, ptr %6, align 8, !tbaa !5
  %725 = getelementptr inbounds %struct.fstReaderContext, ptr %724, i32 0, i32 36
  %726 = load ptr, ptr %725, align 8, !tbaa !32
  %727 = load i32, ptr %29, align 4, !tbaa !11
  %728 = zext i32 %727 to i64
  %729 = getelementptr inbounds i32, ptr %726, i64 %728
  store i32 %723, ptr %729, align 4, !tbaa !11
  br label %730

730:                                              ; preds = %713, %700
  %731 = load i32, ptr %28, align 4, !tbaa !11
  %732 = add i32 %731, 1
  store i32 %732, ptr %28, align 4, !tbaa !11
  store i32 %731, ptr %29, align 4, !tbaa !11
  br label %753

733:                                              ; preds = %696
  call void @llvm.lifetime.start.p0(i64 4, ptr %56) #8
  %734 = load i64, ptr %55, align 8, !tbaa !9
  %735 = lshr i64 %734, 1
  %736 = trunc i64 %735 to i32
  store i32 %736, ptr %56, align 4, !tbaa !11
  store i32 0, ptr %30, align 4, !tbaa !11
  br label %737

737:                                              ; preds = %749, %733
  %738 = load i32, ptr %30, align 4, !tbaa !11
  %739 = load i32, ptr %56, align 4, !tbaa !11
  %740 = icmp ult i32 %738, %739
  br i1 %740, label %741, label %752

741:                                              ; preds = %737
  %742 = load ptr, ptr %6, align 8, !tbaa !5
  %743 = getelementptr inbounds %struct.fstReaderContext, ptr %742, i32 0, i32 35
  %744 = load ptr, ptr %743, align 8, !tbaa !31
  %745 = load i32, ptr %28, align 4, !tbaa !11
  %746 = add i32 %745, 1
  store i32 %746, ptr %28, align 4, !tbaa !11
  %747 = zext i32 %745 to i64
  %748 = getelementptr inbounds i64, ptr %744, i64 %747
  store i64 0, ptr %748, align 8, !tbaa !9
  br label %749

749:                                              ; preds = %741
  %750 = load i32, ptr %30, align 4, !tbaa !11
  %751 = add i32 %750, 1
  store i32 %751, ptr %30, align 4, !tbaa !11
  br label %737, !llvm.loop !36

752:                                              ; preds = %737
  call void @llvm.lifetime.end.p0(i64 4, ptr %56) #8
  br label %753

753:                                              ; preds = %752, %730
  br label %754

754:                                              ; preds = %753, %671
  %755 = load i32, ptr %54, align 4, !tbaa !11
  %756 = load ptr, ptr %27, align 8, !tbaa !5
  %757 = sext i32 %755 to i64
  %758 = getelementptr inbounds i8, ptr %756, i64 %757
  store ptr %758, ptr %27, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 8, ptr %55) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %54) #8
  br label %759

759:                                              ; preds = %754
  %760 = load ptr, ptr %27, align 8, !tbaa !5
  %761 = load ptr, ptr %26, align 8, !tbaa !5
  %762 = load i64, ptr %25, align 8, !tbaa !9
  %763 = getelementptr inbounds i8, ptr %761, i64 %762
  %764 = icmp ne ptr %760, %763
  br i1 %764, label %665, label %765, !llvm.loop !37

765:                                              ; preds = %759
  br label %766

766:                                              ; preds = %765, %663
  %767 = load ptr, ptr %26, align 8, !tbaa !5
  call void @free(ptr noundef %767) #8
  %768 = load i64, ptr %24, align 8, !tbaa !9
  %769 = load ptr, ptr %6, align 8, !tbaa !5
  %770 = getelementptr inbounds %struct.fstReaderContext, ptr %769, i32 0, i32 38
  %771 = load i64, ptr %770, align 8, !tbaa !29
  %772 = sub nsw i64 %768, %771
  %773 = load ptr, ptr %6, align 8, !tbaa !5
  %774 = getelementptr inbounds %struct.fstReaderContext, ptr %773, i32 0, i32 35
  %775 = load ptr, ptr %774, align 8, !tbaa !31
  %776 = load i32, ptr %28, align 4, !tbaa !11
  %777 = zext i32 %776 to i64
  %778 = getelementptr inbounds i64, ptr %775, i64 %777
  store i64 %772, ptr %778, align 8, !tbaa !9
  %779 = load ptr, ptr %6, align 8, !tbaa !5
  %780 = getelementptr inbounds %struct.fstReaderContext, ptr %779, i32 0, i32 35
  %781 = load ptr, ptr %780, align 8, !tbaa !31
  %782 = load i32, ptr %28, align 4, !tbaa !11
  %783 = zext i32 %782 to i64
  %784 = getelementptr inbounds i64, ptr %781, i64 %783
  %785 = load i64, ptr %784, align 8, !tbaa !9
  %786 = load ptr, ptr %6, align 8, !tbaa !5
  %787 = getelementptr inbounds %struct.fstReaderContext, ptr %786, i32 0, i32 35
  %788 = load ptr, ptr %787, align 8, !tbaa !31
  %789 = load i32, ptr %29, align 4, !tbaa !11
  %790 = zext i32 %789 to i64
  %791 = getelementptr inbounds i64, ptr %788, i64 %790
  %792 = load i64, ptr %791, align 8, !tbaa !9
  %793 = sub nsw i64 %785, %792
  %794 = trunc i64 %793 to i32
  %795 = load ptr, ptr %6, align 8, !tbaa !5
  %796 = getelementptr inbounds %struct.fstReaderContext, ptr %795, i32 0, i32 36
  %797 = load ptr, ptr %796, align 8, !tbaa !32
  %798 = load i32, ptr %29, align 4, !tbaa !11
  %799 = zext i32 %798 to i64
  %800 = getelementptr inbounds i32, ptr %797, i64 %799
  store i32 %794, ptr %800, align 4, !tbaa !11
  store i32 0, ptr %30, align 4, !tbaa !11
  br label %801

801:                                              ; preds = %861, %766
  %802 = load i32, ptr %30, align 4, !tbaa !11
  %803 = load i32, ptr %28, align 4, !tbaa !11
  %804 = icmp ult i32 %802, %803
  br i1 %804, label %805, label %864

805:                                              ; preds = %801
  call void @llvm.lifetime.start.p0(i64 4, ptr %57) #8
  %806 = load ptr, ptr %6, align 8, !tbaa !5
  %807 = getelementptr inbounds %struct.fstReaderContext, ptr %806, i32 0, i32 36
  %808 = load ptr, ptr %807, align 8, !tbaa !32
  %809 = load i32, ptr %30, align 4, !tbaa !11
  %810 = zext i32 %809 to i64
  %811 = getelementptr inbounds i32, ptr %808, i64 %810
  %812 = load i32, ptr %811, align 4, !tbaa !11
  store i32 %812, ptr %57, align 4, !tbaa !11
  %813 = load i32, ptr %57, align 4, !tbaa !11
  %814 = icmp slt i32 %813, 0
  br i1 %814, label %815, label %860

815:                                              ; preds = %805
  %816 = load ptr, ptr %6, align 8, !tbaa !5
  %817 = getelementptr inbounds %struct.fstReaderContext, ptr %816, i32 0, i32 35
  %818 = load ptr, ptr %817, align 8, !tbaa !31
  %819 = load i32, ptr %30, align 4, !tbaa !11
  %820 = zext i32 %819 to i64
  %821 = getelementptr inbounds i64, ptr %818, i64 %820
  %822 = load i64, ptr %821, align 8, !tbaa !9
  %823 = icmp ne i64 %822, 0
  br i1 %823, label %860, label %824

824:                                              ; preds = %815
  %825 = load i32, ptr %57, align 4, !tbaa !11
  %826 = sub nsw i32 0, %825
  store i32 %826, ptr %57, align 4, !tbaa !11
  %827 = load i32, ptr %57, align 4, !tbaa !11
  %828 = add nsw i32 %827, -1
  store i32 %828, ptr %57, align 4, !tbaa !11
  %829 = load i32, ptr %57, align 4, !tbaa !11
  %830 = load i32, ptr %30, align 4, !tbaa !11
  %831 = icmp ult i32 %829, %830
  br i1 %831, label %832, label %859

832:                                              ; preds = %824
  %833 = load ptr, ptr %6, align 8, !tbaa !5
  %834 = getelementptr inbounds %struct.fstReaderContext, ptr %833, i32 0, i32 35
  %835 = load ptr, ptr %834, align 8, !tbaa !31
  %836 = load i32, ptr %57, align 4, !tbaa !11
  %837 = sext i32 %836 to i64
  %838 = getelementptr inbounds i64, ptr %835, i64 %837
  %839 = load i64, ptr %838, align 8, !tbaa !9
  %840 = load ptr, ptr %6, align 8, !tbaa !5
  %841 = getelementptr inbounds %struct.fstReaderContext, ptr %840, i32 0, i32 35
  %842 = load ptr, ptr %841, align 8, !tbaa !31
  %843 = load i32, ptr %30, align 4, !tbaa !11
  %844 = zext i32 %843 to i64
  %845 = getelementptr inbounds i64, ptr %842, i64 %844
  store i64 %839, ptr %845, align 8, !tbaa !9
  %846 = load ptr, ptr %6, align 8, !tbaa !5
  %847 = getelementptr inbounds %struct.fstReaderContext, ptr %846, i32 0, i32 36
  %848 = load ptr, ptr %847, align 8, !tbaa !32
  %849 = load i32, ptr %57, align 4, !tbaa !11
  %850 = sext i32 %849 to i64
  %851 = getelementptr inbounds i32, ptr %848, i64 %850
  %852 = load i32, ptr %851, align 4, !tbaa !11
  %853 = load ptr, ptr %6, align 8, !tbaa !5
  %854 = getelementptr inbounds %struct.fstReaderContext, ptr %853, i32 0, i32 36
  %855 = load ptr, ptr %854, align 8, !tbaa !32
  %856 = load i32, ptr %30, align 4, !tbaa !11
  %857 = zext i32 %856 to i64
  %858 = getelementptr inbounds i32, ptr %855, i64 %857
  store i32 %852, ptr %858, align 4, !tbaa !11
  br label %859

859:                                              ; preds = %832, %824
  br label %860

860:                                              ; preds = %859, %815, %805
  call void @llvm.lifetime.end.p0(i64 4, ptr %57) #8
  br label %861

861:                                              ; preds = %860
  %862 = load i32, ptr %30, align 4, !tbaa !11
  %863 = add i32 %862, 1
  store i32 %863, ptr %30, align 4, !tbaa !11
  br label %801, !llvm.loop !38

864:                                              ; preds = %801
  %865 = load ptr, ptr %6, align 8, !tbaa !5
  %866 = getelementptr inbounds %struct.fstReaderContext, ptr %865, i32 0, i32 29
  %867 = load i8, ptr %866, align 8
  %868 = and i8 %867, -2
  %869 = or i8 %868, 1
  store i8 %869, ptr %866, align 8
  br label %870

870:                                              ; preds = %864, %173
  %871 = load i32, ptr %8, align 4, !tbaa !11
  %872 = zext i32 %871 to i64
  %873 = load ptr, ptr %6, align 8, !tbaa !5
  %874 = getelementptr inbounds %struct.fstReaderContext, ptr %873, i32 0, i32 37
  %875 = load i64, ptr %874, align 8, !tbaa !28
  %876 = icmp ugt i64 %872, %875
  br i1 %876, label %877, label %878

877:                                              ; preds = %870
  store ptr null, ptr %5, align 8
  store i32 1, ptr %32, align 4
  br label %1465

878:                                              ; preds = %870
  %879 = load i32, ptr %8, align 4, !tbaa !11
  %880 = add i32 %879, -1
  store i32 %880, ptr %8, align 4, !tbaa !11
  %881 = load i64, ptr %7, align 8, !tbaa !9
  %882 = load ptr, ptr %6, align 8, !tbaa !5
  %883 = getelementptr inbounds %struct.fstReaderContext, ptr %882, i32 0, i32 31
  %884 = load i64, ptr %883, align 8, !tbaa !20
  %885 = icmp eq i64 %881, %884
  br i1 %885, label %886, label %895

886:                                              ; preds = %878
  %887 = load ptr, ptr %6, align 8, !tbaa !5
  %888 = getelementptr inbounds %struct.fstReaderContext, ptr %887, i32 0, i32 35
  %889 = load ptr, ptr %888, align 8, !tbaa !31
  %890 = load i32, ptr %8, align 4, !tbaa !11
  %891 = zext i32 %890 to i64
  %892 = getelementptr inbounds i64, ptr %889, i64 %891
  %893 = load i64, ptr %892, align 8, !tbaa !9
  %894 = icmp ne i64 %893, 0
  br i1 %894, label %895, label %904

895:                                              ; preds = %886, %878
  %896 = load ptr, ptr %6, align 8, !tbaa !5
  %897 = getelementptr inbounds %struct.fstReaderContext, ptr %896, i32 0, i32 35
  %898 = load ptr, ptr %897, align 8, !tbaa !31
  %899 = load i32, ptr %8, align 4, !tbaa !11
  %900 = zext i32 %899 to i64
  %901 = getelementptr inbounds i64, ptr %898, i64 %900
  %902 = load i64, ptr %901, align 8, !tbaa !9
  %903 = icmp ne i64 %902, 0
  br i1 %903, label %909, label %904

904:                                              ; preds = %895, %886
  %905 = load ptr, ptr %6, align 8, !tbaa !5
  %906 = load i32, ptr %8, align 4, !tbaa !11
  %907 = load ptr, ptr %9, align 8, !tbaa !5
  %908 = call ptr @fstExtractRvatDataFromFrame(ptr noundef %905, i32 noundef %906, ptr noundef %907)
  store ptr %908, ptr %5, align 8
  store i32 1, ptr %32, align 4
  br label %1465

909:                                              ; preds = %895
  %910 = load i32, ptr %8, align 4, !tbaa !11
  %911 = load ptr, ptr %6, align 8, !tbaa !5
  %912 = getelementptr inbounds %struct.fstReaderContext, ptr %911, i32 0, i32 43
  %913 = load i32, ptr %912, align 8, !tbaa !39
  %914 = icmp ne i32 %910, %913
  br i1 %914, label %915, label %932

915:                                              ; preds = %909
  %916 = load ptr, ptr %6, align 8, !tbaa !5
  %917 = getelementptr inbounds %struct.fstReaderContext, ptr %916, i32 0, i32 42
  %918 = load ptr, ptr %917, align 8, !tbaa !40
  %919 = icmp ne ptr %918, null
  br i1 %919, label %920, label %931

920:                                              ; preds = %915
  %921 = load ptr, ptr %6, align 8, !tbaa !5
  %922 = getelementptr inbounds %struct.fstReaderContext, ptr %921, i32 0, i32 42
  %923 = load ptr, ptr %922, align 8, !tbaa !40
  call void @free(ptr noundef %923) #8
  %924 = load ptr, ptr %6, align 8, !tbaa !5
  %925 = getelementptr inbounds %struct.fstReaderContext, ptr %924, i32 0, i32 42
  store ptr null, ptr %925, align 8, !tbaa !40
  %926 = load ptr, ptr %6, align 8, !tbaa !5
  %927 = getelementptr inbounds %struct.fstReaderContext, ptr %926, i32 0, i32 47
  %928 = load i8, ptr %927, align 8
  %929 = and i8 %928, -2
  %930 = or i8 %929, 0
  store i8 %930, ptr %927, align 8
  br label %931

931:                                              ; preds = %920, %915
  br label %932

932:                                              ; preds = %931, %909
  %933 = load ptr, ptr %6, align 8, !tbaa !5
  %934 = getelementptr inbounds %struct.fstReaderContext, ptr %933, i32 0, i32 42
  %935 = load ptr, ptr %934, align 8, !tbaa !40
  %936 = icmp ne ptr %935, null
  br i1 %936, label %1079, label %937

937:                                              ; preds = %932
  call void @llvm.lifetime.start.p0(i64 4, ptr %58) #8
  %938 = load ptr, ptr %6, align 8, !tbaa !5
  %939 = load ptr, ptr %6, align 8, !tbaa !5
  %940 = getelementptr inbounds %struct.fstReaderContext, ptr %939, i32 0, i32 0
  %941 = load ptr, ptr %940, align 8, !tbaa !22
  %942 = load ptr, ptr %6, align 8, !tbaa !5
  %943 = getelementptr inbounds %struct.fstReaderContext, ptr %942, i32 0, i32 38
  %944 = load i64, ptr %943, align 8, !tbaa !29
  %945 = load ptr, ptr %6, align 8, !tbaa !5
  %946 = getelementptr inbounds %struct.fstReaderContext, ptr %945, i32 0, i32 35
  %947 = load ptr, ptr %946, align 8, !tbaa !31
  %948 = load i32, ptr %8, align 4, !tbaa !11
  %949 = zext i32 %948 to i64
  %950 = getelementptr inbounds i64, ptr %947, i64 %949
  %951 = load i64, ptr %950, align 8, !tbaa !9
  %952 = add nsw i64 %944, %951
  %953 = call i32 @fstReaderFseeko(ptr noundef %938, ptr noundef %941, i64 noundef %952, i32 noundef 0)
  %954 = load ptr, ptr %6, align 8, !tbaa !5
  %955 = getelementptr inbounds %struct.fstReaderContext, ptr %954, i32 0, i32 0
  %956 = load ptr, ptr %955, align 8, !tbaa !22
  %957 = call i32 @fstReaderVarint32WithSkip(ptr noundef %956, ptr noundef %58)
  %958 = load ptr, ptr %6, align 8, !tbaa !5
  %959 = getelementptr inbounds %struct.fstReaderContext, ptr %958, i32 0, i32 41
  store i32 %957, ptr %959, align 4, !tbaa !41
  %960 = load ptr, ptr %6, align 8, !tbaa !5
  %961 = getelementptr inbounds %struct.fstReaderContext, ptr %960, i32 0, i32 41
  %962 = load i32, ptr %961, align 4, !tbaa !41
  %963 = icmp ne i32 %962, 0
  br i1 %963, label %964, label %1050

964:                                              ; preds = %937
  call void @llvm.lifetime.start.p0(i64 8, ptr %59) #8
  %965 = load ptr, ptr %6, align 8, !tbaa !5
  %966 = getelementptr inbounds %struct.fstReaderContext, ptr %965, i32 0, i32 41
  %967 = load i32, ptr %966, align 4, !tbaa !41
  %968 = zext i32 %967 to i64
  %969 = call noalias ptr @malloc(i64 noundef %968) #10
  store ptr %969, ptr %59, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %60) #8
  %970 = load ptr, ptr %6, align 8, !tbaa !5
  %971 = getelementptr inbounds %struct.fstReaderContext, ptr %970, i32 0, i32 36
  %972 = load ptr, ptr %971, align 8, !tbaa !32
  %973 = load i32, ptr %8, align 4, !tbaa !11
  %974 = zext i32 %973 to i64
  %975 = getelementptr inbounds i32, ptr %972, i64 %974
  %976 = load i32, ptr %975, align 4, !tbaa !11
  %977 = zext i32 %976 to i64
  %978 = call noalias ptr @malloc(i64 noundef %977) #10
  store ptr %978, ptr %60, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %61) #8
  %979 = load ptr, ptr %6, align 8, !tbaa !5
  %980 = getelementptr inbounds %struct.fstReaderContext, ptr %979, i32 0, i32 41
  %981 = load i32, ptr %980, align 4, !tbaa !41
  %982 = zext i32 %981 to i64
  store i64 %982, ptr %61, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %62) #8
  %983 = load ptr, ptr %6, align 8, !tbaa !5
  %984 = getelementptr inbounds %struct.fstReaderContext, ptr %983, i32 0, i32 36
  %985 = load ptr, ptr %984, align 8, !tbaa !32
  %986 = load i32, ptr %8, align 4, !tbaa !11
  %987 = zext i32 %986 to i64
  %988 = getelementptr inbounds i32, ptr %985, i64 %987
  %989 = load i32, ptr %988, align 4, !tbaa !11
  %990 = zext i32 %989 to i64
  store i64 %990, ptr %62, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %63) #8
  store i32 0, ptr %63, align 4, !tbaa !11
  %991 = load ptr, ptr %60, align 8, !tbaa !5
  %992 = load ptr, ptr %6, align 8, !tbaa !5
  %993 = getelementptr inbounds %struct.fstReaderContext, ptr %992, i32 0, i32 36
  %994 = load ptr, ptr %993, align 8, !tbaa !32
  %995 = load i32, ptr %8, align 4, !tbaa !11
  %996 = zext i32 %995 to i64
  %997 = getelementptr inbounds i32, ptr %994, i64 %996
  %998 = load i32, ptr %997, align 4, !tbaa !11
  %999 = zext i32 %998 to i64
  %1000 = load ptr, ptr %6, align 8, !tbaa !5
  %1001 = getelementptr inbounds %struct.fstReaderContext, ptr %1000, i32 0, i32 0
  %1002 = load ptr, ptr %1001, align 8, !tbaa !22
  %1003 = call i64 @fstFread(ptr noundef %991, i64 noundef %999, i64 noundef 1, ptr noundef %1002)
  %1004 = load ptr, ptr %6, align 8, !tbaa !5
  %1005 = getelementptr inbounds %struct.fstReaderContext, ptr %1004, i32 0, i32 40
  %1006 = load i32, ptr %1005, align 8, !tbaa !30
  switch i32 %1006, label %1030 [
    i32 52, label %1007
    i32 70, label %1022
  ]

1007:                                             ; preds = %964
  %1008 = load i64, ptr %61, align 8, !tbaa !9
  %1009 = load ptr, ptr %60, align 8, !tbaa !5
  %1010 = load ptr, ptr %59, align 8, !tbaa !5
  %1011 = load i64, ptr %62, align 8, !tbaa !9
  %1012 = trunc i64 %1011 to i32
  %1013 = load i64, ptr %61, align 8, !tbaa !9
  %1014 = trunc i64 %1013 to i32
  %1015 = load i64, ptr %61, align 8, !tbaa !9
  %1016 = trunc i64 %1015 to i32
  %1017 = call i32 @LZ4_decompress_safe_partial(ptr noundef %1009, ptr noundef %1010, i32 noundef %1012, i32 noundef %1014, i32 noundef %1016)
  %1018 = sext i32 %1017 to i64
  %1019 = icmp eq i64 %1008, %1018
  %1020 = zext i1 %1019 to i64
  %1021 = select i1 %1019, i32 0, i32 -3
  store i32 %1021, ptr %63, align 4, !tbaa !11
  br label %1035

1022:                                             ; preds = %964
  %1023 = load ptr, ptr %60, align 8, !tbaa !5
  %1024 = load i64, ptr %62, align 8, !tbaa !9
  %1025 = trunc i64 %1024 to i32
  %1026 = load ptr, ptr %59, align 8, !tbaa !5
  %1027 = load i64, ptr %61, align 8, !tbaa !9
  %1028 = trunc i64 %1027 to i32
  %1029 = call i32 @fastlz_decompress(ptr noundef %1023, i32 noundef %1025, ptr noundef %1026, i32 noundef %1028)
  br label %1035

1030:                                             ; preds = %964
  %1031 = load ptr, ptr %59, align 8, !tbaa !5
  %1032 = load ptr, ptr %60, align 8, !tbaa !5
  %1033 = load i64, ptr %62, align 8, !tbaa !9
  %1034 = call i32 @uncompress(ptr noundef %1031, ptr noundef %61, ptr noundef %1032, i64 noundef %1033)
  store i32 %1034, ptr %63, align 4, !tbaa !11
  br label %1035

1035:                                             ; preds = %1030, %1022, %1007
  %1036 = load ptr, ptr %60, align 8, !tbaa !5
  call void @free(ptr noundef %1036) #8
  %1037 = load i32, ptr %63, align 4, !tbaa !11
  %1038 = icmp ne i32 %1037, 0
  br i1 %1038, label %1039, label %1046

1039:                                             ; preds = %1035
  %1040 = load ptr, ptr @stderr, align 8, !tbaa !5
  %1041 = load ptr, ptr %6, align 8, !tbaa !5
  %1042 = getelementptr inbounds %struct.fstReaderContext, ptr %1041, i32 0, i32 41
  %1043 = load i32, ptr %1042, align 4, !tbaa !41
  %1044 = load i32, ptr %63, align 4, !tbaa !11
  %1045 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %1040, ptr noundef @.str.59, i32 noundef %1043, i32 noundef %1044) #8
  call void @exit(i32 noundef 255) #11
  unreachable

1046:                                             ; preds = %1035
  %1047 = load ptr, ptr %59, align 8, !tbaa !5
  %1048 = load ptr, ptr %6, align 8, !tbaa !5
  %1049 = getelementptr inbounds %struct.fstReaderContext, ptr %1048, i32 0, i32 42
  store ptr %1047, ptr %1049, align 8, !tbaa !40
  call void @llvm.lifetime.end.p0(i64 4, ptr %63) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %62) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %61) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %60) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %59) #8
  br label %1075

1050:                                             ; preds = %937
  call void @llvm.lifetime.start.p0(i64 4, ptr %64) #8
  %1051 = load ptr, ptr %6, align 8, !tbaa !5
  %1052 = getelementptr inbounds %struct.fstReaderContext, ptr %1051, i32 0, i32 36
  %1053 = load ptr, ptr %1052, align 8, !tbaa !32
  %1054 = load i32, ptr %8, align 4, !tbaa !11
  %1055 = zext i32 %1054 to i64
  %1056 = getelementptr inbounds i32, ptr %1053, i64 %1055
  %1057 = load i32, ptr %1056, align 4, !tbaa !11
  %1058 = load i32, ptr %58, align 4, !tbaa !11
  %1059 = sub i32 %1057, %1058
  store i32 %1059, ptr %64, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %65) #8
  %1060 = load i32, ptr %64, align 4, !tbaa !11
  %1061 = load ptr, ptr %6, align 8, !tbaa !5
  %1062 = getelementptr inbounds %struct.fstReaderContext, ptr %1061, i32 0, i32 41
  store i32 %1060, ptr %1062, align 4, !tbaa !41
  %1063 = zext i32 %1060 to i64
  %1064 = call noalias ptr @malloc(i64 noundef %1063) #10
  store ptr %1064, ptr %65, align 8, !tbaa !5
  %1065 = load ptr, ptr %65, align 8, !tbaa !5
  %1066 = load i32, ptr %64, align 4, !tbaa !11
  %1067 = sext i32 %1066 to i64
  %1068 = load ptr, ptr %6, align 8, !tbaa !5
  %1069 = getelementptr inbounds %struct.fstReaderContext, ptr %1068, i32 0, i32 0
  %1070 = load ptr, ptr %1069, align 8, !tbaa !22
  %1071 = call i64 @fstFread(ptr noundef %1065, i64 noundef %1067, i64 noundef 1, ptr noundef %1070)
  %1072 = load ptr, ptr %65, align 8, !tbaa !5
  %1073 = load ptr, ptr %6, align 8, !tbaa !5
  %1074 = getelementptr inbounds %struct.fstReaderContext, ptr %1073, i32 0, i32 42
  store ptr %1072, ptr %1074, align 8, !tbaa !40
  call void @llvm.lifetime.end.p0(i64 8, ptr %65) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %64) #8
  br label %1075

1075:                                             ; preds = %1050, %1046
  %1076 = load i32, ptr %8, align 4, !tbaa !11
  %1077 = load ptr, ptr %6, align 8, !tbaa !5
  %1078 = getelementptr inbounds %struct.fstReaderContext, ptr %1077, i32 0, i32 43
  store i32 %1076, ptr %1078, align 8, !tbaa !39
  call void @llvm.lifetime.end.p0(i64 4, ptr %58) #8
  br label %1079

1079:                                             ; preds = %1075, %932
  call void @llvm.lifetime.start.p0(i64 4, ptr %66) #8
  store i32 0, ptr %66, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %67) #8
  store i32 0, ptr %67, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %68) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %69) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %70) #8
  %1080 = load ptr, ptr %6, align 8, !tbaa !5
  %1081 = getelementptr inbounds %struct.fstReaderContext, ptr %1080, i32 0, i32 41
  %1082 = load i32, ptr %1081, align 4, !tbaa !41
  store i32 %1082, ptr %70, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %71) #8
  store i32 0, ptr %71, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %72) #8
  store i32 0, ptr %72, align 4, !tbaa !11
  %1083 = load ptr, ptr %6, align 8, !tbaa !5
  %1084 = getelementptr inbounds %struct.fstReaderContext, ptr %1083, i32 0, i32 47
  %1085 = load i8, ptr %1084, align 8
  %1086 = and i8 %1085, 1
  %1087 = zext i8 %1086 to i32
  %1088 = icmp ne i32 %1087, 0
  br i1 %1088, label %1089, label %1102

1089:                                             ; preds = %1079
  %1090 = load i64, ptr %7, align 8, !tbaa !9
  %1091 = load ptr, ptr %6, align 8, !tbaa !5
  %1092 = getelementptr inbounds %struct.fstReaderContext, ptr %1091, i32 0, i32 46
  %1093 = load i64, ptr %1092, align 8, !tbaa !42
  %1094 = icmp uge i64 %1090, %1093
  br i1 %1094, label %1095, label %1102

1095:                                             ; preds = %1089
  %1096 = load ptr, ptr %6, align 8, !tbaa !5
  %1097 = getelementptr inbounds %struct.fstReaderContext, ptr %1096, i32 0, i32 45
  %1098 = load i32, ptr %1097, align 8, !tbaa !43
  store i32 %1098, ptr %30, align 4, !tbaa !11
  %1099 = load ptr, ptr %6, align 8, !tbaa !5
  %1100 = getelementptr inbounds %struct.fstReaderContext, ptr %1099, i32 0, i32 44
  %1101 = load i32, ptr %1100, align 4, !tbaa !44
  store i32 %1101, ptr %66, align 4, !tbaa !11
  br label %1108

1102:                                             ; preds = %1089, %1079
  store i32 0, ptr %30, align 4, !tbaa !11
  store i32 0, ptr %66, align 4, !tbaa !11
  %1103 = load ptr, ptr %6, align 8, !tbaa !5
  %1104 = getelementptr inbounds %struct.fstReaderContext, ptr %1103, i32 0, i32 31
  %1105 = load i64, ptr %1104, align 8, !tbaa !20
  %1106 = load ptr, ptr %6, align 8, !tbaa !5
  %1107 = getelementptr inbounds %struct.fstReaderContext, ptr %1106, i32 0, i32 46
  store i64 %1105, ptr %1107, align 8, !tbaa !42
  br label %1108

1108:                                             ; preds = %1102, %1095
  %1109 = load ptr, ptr %6, align 8, !tbaa !5
  %1110 = getelementptr inbounds %struct.fstReaderContext, ptr %1109, i32 0, i32 10
  %1111 = load ptr, ptr %1110, align 8, !tbaa !16
  %1112 = load i32, ptr %8, align 4, !tbaa !11
  %1113 = zext i32 %1112 to i64
  %1114 = getelementptr inbounds i32, ptr %1111, i64 %1113
  %1115 = load i32, ptr %1114, align 4, !tbaa !11
  %1116 = icmp eq i32 %1115, 1
  br i1 %1116, label %1117, label %1214

1117:                                             ; preds = %1108
  br label %1118

1118:                                             ; preds = %1163, %1117
  %1119 = load i32, ptr %30, align 4, !tbaa !11
  %1120 = load ptr, ptr %6, align 8, !tbaa !5
  %1121 = getelementptr inbounds %struct.fstReaderContext, ptr %1120, i32 0, i32 41
  %1122 = load i32, ptr %1121, align 4, !tbaa !41
  %1123 = icmp ult i32 %1119, %1122
  br i1 %1123, label %1124, label %1164

1124:                                             ; preds = %1118
  call void @llvm.lifetime.start.p0(i64 4, ptr %73) #8
  %1125 = load ptr, ptr %6, align 8, !tbaa !5
  %1126 = getelementptr inbounds %struct.fstReaderContext, ptr %1125, i32 0, i32 42
  %1127 = load ptr, ptr %1126, align 8, !tbaa !40
  %1128 = load i32, ptr %30, align 4, !tbaa !11
  %1129 = zext i32 %1128 to i64
  %1130 = getelementptr inbounds i8, ptr %1127, i64 %1129
  %1131 = call i32 @fstGetVarint32(ptr noundef %1130, ptr noundef %69)
  store i32 %1131, ptr %73, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %74) #8
  %1132 = load i32, ptr %73, align 4, !tbaa !11
  %1133 = and i32 %1132, 1
  %1134 = shl i32 2, %1133
  store i32 %1134, ptr %74, align 4, !tbaa !11
  %1135 = load i32, ptr %73, align 4, !tbaa !11
  %1136 = load i32, ptr %74, align 4, !tbaa !11
  %1137 = lshr i32 %1135, %1136
  store i32 %1137, ptr %68, align 4, !tbaa !11
  %1138 = load ptr, ptr %6, align 8, !tbaa !5
  %1139 = getelementptr inbounds %struct.fstReaderContext, ptr %1138, i32 0, i32 30
  %1140 = load ptr, ptr %1139, align 8, !tbaa !24
  %1141 = load i32, ptr %66, align 4, !tbaa !11
  %1142 = load i32, ptr %68, align 4, !tbaa !11
  %1143 = add i32 %1141, %1142
  %1144 = zext i32 %1143 to i64
  %1145 = getelementptr inbounds i64, ptr %1140, i64 %1144
  %1146 = load i64, ptr %1145, align 8, !tbaa !9
  %1147 = load i64, ptr %7, align 8, !tbaa !9
  %1148 = icmp ule i64 %1146, %1147
  br i1 %1148, label %1149, label %1159

1149:                                             ; preds = %1124
  %1150 = load i32, ptr %30, align 4, !tbaa !11
  store i32 %1150, ptr %70, align 4, !tbaa !11
  %1151 = load i32, ptr %73, align 4, !tbaa !11
  store i32 %1151, ptr %71, align 4, !tbaa !11
  %1152 = load i32, ptr %66, align 4, !tbaa !11
  store i32 %1152, ptr %67, align 4, !tbaa !11
  %1153 = load i32, ptr %68, align 4, !tbaa !11
  %1154 = load i32, ptr %66, align 4, !tbaa !11
  %1155 = add i32 %1154, %1153
  store i32 %1155, ptr %66, align 4, !tbaa !11
  %1156 = load i32, ptr %69, align 4, !tbaa !11
  %1157 = load i32, ptr %30, align 4, !tbaa !11
  %1158 = add i32 %1157, %1156
  store i32 %1158, ptr %30, align 4, !tbaa !11
  br label %1160

1159:                                             ; preds = %1124
  store i32 26, ptr %32, align 4
  br label %1161

1160:                                             ; preds = %1149
  store i32 0, ptr %32, align 4
  br label %1161

1161:                                             ; preds = %1160, %1159
  call void @llvm.lifetime.end.p0(i64 4, ptr %74) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %73) #8
  %1162 = load i32, ptr %32, align 4
  switch i32 %1162, label %1467 [
    i32 0, label %1163
    i32 26, label %1164
  ]

1163:                                             ; preds = %1161
  br label %1118, !llvm.loop !45

1164:                                             ; preds = %1161, %1118
  %1165 = load i32, ptr %70, align 4, !tbaa !11
  %1166 = load ptr, ptr %6, align 8, !tbaa !5
  %1167 = getelementptr inbounds %struct.fstReaderContext, ptr %1166, i32 0, i32 41
  %1168 = load i32, ptr %1167, align 4, !tbaa !41
  %1169 = icmp ne i32 %1165, %1168
  br i1 %1169, label %1170, label %1209

1170:                                             ; preds = %1164
  %1171 = load i32, ptr %67, align 4, !tbaa !11
  %1172 = load ptr, ptr %6, align 8, !tbaa !5
  %1173 = getelementptr inbounds %struct.fstReaderContext, ptr %1172, i32 0, i32 44
  store i32 %1171, ptr %1173, align 4, !tbaa !44
  %1174 = load i32, ptr %70, align 4, !tbaa !11
  %1175 = load ptr, ptr %6, align 8, !tbaa !5
  %1176 = getelementptr inbounds %struct.fstReaderContext, ptr %1175, i32 0, i32 45
  store i32 %1174, ptr %1176, align 8, !tbaa !43
  %1177 = load i64, ptr %7, align 8, !tbaa !9
  %1178 = load ptr, ptr %6, align 8, !tbaa !5
  %1179 = getelementptr inbounds %struct.fstReaderContext, ptr %1178, i32 0, i32 46
  store i64 %1177, ptr %1179, align 8, !tbaa !42
  %1180 = load ptr, ptr %6, align 8, !tbaa !5
  %1181 = getelementptr inbounds %struct.fstReaderContext, ptr %1180, i32 0, i32 47
  %1182 = load i8, ptr %1181, align 8
  %1183 = and i8 %1182, -2
  %1184 = or i8 %1183, 1
  store i8 %1184, ptr %1181, align 8
  %1185 = load i32, ptr %71, align 4, !tbaa !11
  %1186 = and i32 %1185, 1
  %1187 = icmp ne i32 %1186, 0
  br i1 %1187, label %1196, label %1188

1188:                                             ; preds = %1170
  %1189 = load i32, ptr %71, align 4, !tbaa !11
  %1190 = lshr i32 %1189, 1
  %1191 = and i32 %1190, 1
  %1192 = or i32 %1191, 48
  %1193 = trunc i32 %1192 to i8
  %1194 = load ptr, ptr %9, align 8, !tbaa !5
  %1195 = getelementptr inbounds i8, ptr %1194, i64 0
  store i8 %1193, ptr %1195, align 1, !tbaa !33
  br label %1205

1196:                                             ; preds = %1170
  %1197 = load i32, ptr %71, align 4, !tbaa !11
  %1198 = lshr i32 %1197, 1
  %1199 = and i32 %1198, 7
  %1200 = zext i32 %1199 to i64
  %1201 = getelementptr inbounds [9 x i8], ptr @.str.55, i64 0, i64 %1200
  %1202 = load i8, ptr %1201, align 1, !tbaa !33
  %1203 = load ptr, ptr %9, align 8, !tbaa !5
  %1204 = getelementptr inbounds i8, ptr %1203, i64 0
  store i8 %1202, ptr %1204, align 1, !tbaa !33
  br label %1205

1205:                                             ; preds = %1196, %1188
  %1206 = load ptr, ptr %9, align 8, !tbaa !5
  %1207 = getelementptr inbounds i8, ptr %1206, i64 1
  store i8 0, ptr %1207, align 1, !tbaa !33
  %1208 = load ptr, ptr %9, align 8, !tbaa !5
  store ptr %1208, ptr %5, align 8
  store i32 1, ptr %32, align 4
  br label %1464

1209:                                             ; preds = %1164
  %1210 = load ptr, ptr %6, align 8, !tbaa !5
  %1211 = load i32, ptr %8, align 4, !tbaa !11
  %1212 = load ptr, ptr %9, align 8, !tbaa !5
  %1213 = call ptr @fstExtractRvatDataFromFrame(ptr noundef %1210, i32 noundef %1211, ptr noundef %1212)
  store ptr %1213, ptr %5, align 8
  store i32 1, ptr %32, align 4
  br label %1464

1214:                                             ; preds = %1108
  br label %1215

1215:                                             ; preds = %1283, %1214
  %1216 = load i32, ptr %30, align 4, !tbaa !11
  %1217 = load ptr, ptr %6, align 8, !tbaa !5
  %1218 = getelementptr inbounds %struct.fstReaderContext, ptr %1217, i32 0, i32 41
  %1219 = load i32, ptr %1218, align 4, !tbaa !41
  %1220 = icmp ult i32 %1216, %1219
  br i1 %1220, label %1221, label %1284

1221:                                             ; preds = %1215
  call void @llvm.lifetime.start.p0(i64 4, ptr %75) #8
  %1222 = load ptr, ptr %6, align 8, !tbaa !5
  %1223 = getelementptr inbounds %struct.fstReaderContext, ptr %1222, i32 0, i32 42
  %1224 = load ptr, ptr %1223, align 8, !tbaa !40
  %1225 = load i32, ptr %30, align 4, !tbaa !11
  %1226 = zext i32 %1225 to i64
  %1227 = getelementptr inbounds i8, ptr %1224, i64 %1226
  %1228 = call i32 @fstGetVarint32(ptr noundef %1227, ptr noundef %69)
  store i32 %1228, ptr %75, align 4, !tbaa !11
  %1229 = load i32, ptr %75, align 4, !tbaa !11
  %1230 = lshr i32 %1229, 1
  store i32 %1230, ptr %68, align 4, !tbaa !11
  %1231 = load ptr, ptr %6, align 8, !tbaa !5
  %1232 = getelementptr inbounds %struct.fstReaderContext, ptr %1231, i32 0, i32 30
  %1233 = load ptr, ptr %1232, align 8, !tbaa !24
  %1234 = load i32, ptr %66, align 4, !tbaa !11
  %1235 = load i32, ptr %68, align 4, !tbaa !11
  %1236 = add i32 %1234, %1235
  %1237 = zext i32 %1236 to i64
  %1238 = getelementptr inbounds i64, ptr %1233, i64 %1237
  %1239 = load i64, ptr %1238, align 8, !tbaa !9
  %1240 = load i64, ptr %7, align 8, !tbaa !9
  %1241 = icmp ule i64 %1239, %1240
  br i1 %1241, label %1242, label %1279

1242:                                             ; preds = %1221
  %1243 = load i32, ptr %30, align 4, !tbaa !11
  store i32 %1243, ptr %70, align 4, !tbaa !11
  %1244 = load i32, ptr %75, align 4, !tbaa !11
  store i32 %1244, ptr %71, align 4, !tbaa !11
  %1245 = load i32, ptr %66, align 4, !tbaa !11
  store i32 %1245, ptr %67, align 4, !tbaa !11
  %1246 = load i32, ptr %69, align 4, !tbaa !11
  store i32 %1246, ptr %72, align 4, !tbaa !11
  %1247 = load i32, ptr %68, align 4, !tbaa !11
  %1248 = load i32, ptr %66, align 4, !tbaa !11
  %1249 = add i32 %1248, %1247
  store i32 %1249, ptr %66, align 4, !tbaa !11
  %1250 = load i32, ptr %69, align 4, !tbaa !11
  %1251 = load i32, ptr %30, align 4, !tbaa !11
  %1252 = add i32 %1251, %1250
  store i32 %1252, ptr %30, align 4, !tbaa !11
  %1253 = load i32, ptr %71, align 4, !tbaa !11
  %1254 = and i32 %1253, 1
  %1255 = icmp ne i32 %1254, 0
  br i1 %1255, label %1268, label %1256

1256:                                             ; preds = %1242
  %1257 = load ptr, ptr %6, align 8, !tbaa !5
  %1258 = getelementptr inbounds %struct.fstReaderContext, ptr %1257, i32 0, i32 10
  %1259 = load ptr, ptr %1258, align 8, !tbaa !16
  %1260 = load i32, ptr %8, align 4, !tbaa !11
  %1261 = zext i32 %1260 to i64
  %1262 = getelementptr inbounds i32, ptr %1259, i64 %1261
  %1263 = load i32, ptr %1262, align 4, !tbaa !11
  %1264 = add i32 %1263, 7
  %1265 = udiv i32 %1264, 8
  %1266 = load i32, ptr %30, align 4, !tbaa !11
  %1267 = add i32 %1266, %1265
  store i32 %1267, ptr %30, align 4, !tbaa !11
  br label %1278

1268:                                             ; preds = %1242
  %1269 = load ptr, ptr %6, align 8, !tbaa !5
  %1270 = getelementptr inbounds %struct.fstReaderContext, ptr %1269, i32 0, i32 10
  %1271 = load ptr, ptr %1270, align 8, !tbaa !16
  %1272 = load i32, ptr %8, align 4, !tbaa !11
  %1273 = zext i32 %1272 to i64
  %1274 = getelementptr inbounds i32, ptr %1271, i64 %1273
  %1275 = load i32, ptr %1274, align 4, !tbaa !11
  %1276 = load i32, ptr %30, align 4, !tbaa !11
  %1277 = add i32 %1276, %1275
  store i32 %1277, ptr %30, align 4, !tbaa !11
  br label %1278

1278:                                             ; preds = %1268, %1256
  br label %1280

1279:                                             ; preds = %1221
  store i32 28, ptr %32, align 4
  br label %1281

1280:                                             ; preds = %1278
  store i32 0, ptr %32, align 4
  br label %1281

1281:                                             ; preds = %1280, %1279
  call void @llvm.lifetime.end.p0(i64 4, ptr %75) #8
  %1282 = load i32, ptr %32, align 4
  switch i32 %1282, label %1467 [
    i32 0, label %1283
    i32 28, label %1284
  ]

1283:                                             ; preds = %1281
  br label %1215, !llvm.loop !46

1284:                                             ; preds = %1281, %1215
  %1285 = load i32, ptr %70, align 4, !tbaa !11
  %1286 = load ptr, ptr %6, align 8, !tbaa !5
  %1287 = getelementptr inbounds %struct.fstReaderContext, ptr %1286, i32 0, i32 41
  %1288 = load i32, ptr %1287, align 4, !tbaa !41
  %1289 = icmp ne i32 %1285, %1288
  br i1 %1289, label %1290, label %1459

1290:                                             ; preds = %1284
  call void @llvm.lifetime.start.p0(i64 8, ptr %76) #8
  %1291 = load ptr, ptr %6, align 8, !tbaa !5
  %1292 = getelementptr inbounds %struct.fstReaderContext, ptr %1291, i32 0, i32 42
  %1293 = load ptr, ptr %1292, align 8, !tbaa !40
  %1294 = load i32, ptr %70, align 4, !tbaa !11
  %1295 = zext i32 %1294 to i64
  %1296 = getelementptr inbounds i8, ptr %1293, i64 %1295
  %1297 = load i32, ptr %72, align 4, !tbaa !11
  %1298 = sext i32 %1297 to i64
  %1299 = getelementptr inbounds i8, ptr %1296, i64 %1298
  store ptr %1299, ptr %76, align 8, !tbaa !5
  %1300 = load i32, ptr %67, align 4, !tbaa !11
  %1301 = load ptr, ptr %6, align 8, !tbaa !5
  %1302 = getelementptr inbounds %struct.fstReaderContext, ptr %1301, i32 0, i32 44
  store i32 %1300, ptr %1302, align 4, !tbaa !44
  %1303 = load i32, ptr %70, align 4, !tbaa !11
  %1304 = load ptr, ptr %6, align 8, !tbaa !5
  %1305 = getelementptr inbounds %struct.fstReaderContext, ptr %1304, i32 0, i32 45
  store i32 %1303, ptr %1305, align 8, !tbaa !43
  %1306 = load i64, ptr %7, align 8, !tbaa !9
  %1307 = load ptr, ptr %6, align 8, !tbaa !5
  %1308 = getelementptr inbounds %struct.fstReaderContext, ptr %1307, i32 0, i32 46
  store i64 %1306, ptr %1308, align 8, !tbaa !42
  %1309 = load ptr, ptr %6, align 8, !tbaa !5
  %1310 = getelementptr inbounds %struct.fstReaderContext, ptr %1309, i32 0, i32 47
  %1311 = load i8, ptr %1310, align 8
  %1312 = and i8 %1311, -2
  %1313 = or i8 %1312, 1
  store i8 %1313, ptr %1310, align 8
  %1314 = load ptr, ptr %6, align 8, !tbaa !5
  %1315 = getelementptr inbounds %struct.fstReaderContext, ptr %1314, i32 0, i32 11
  %1316 = load ptr, ptr %1315, align 8, !tbaa !47
  %1317 = load i32, ptr %8, align 4, !tbaa !11
  %1318 = zext i32 %1317 to i64
  %1319 = getelementptr inbounds i8, ptr %1316, i64 %1318
  %1320 = load i8, ptr %1319, align 1, !tbaa !33
  %1321 = zext i8 %1320 to i32
  %1322 = icmp ne i32 %1321, 3
  br i1 %1322, label %1323, label %1391

1323:                                             ; preds = %1290
  %1324 = load i32, ptr %71, align 4, !tbaa !11
  %1325 = and i32 %1324, 1
  %1326 = icmp ne i32 %1325, 0
  br i1 %1326, label %1369, label %1327

1327:                                             ; preds = %1323
  call void @llvm.lifetime.start.p0(i64 4, ptr %77) #8
  store i32 0, ptr %77, align 4, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %78) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %79) #8
  store i32 0, ptr %79, align 4, !tbaa !11
  br label %1328

1328:                                             ; preds = %1360, %1327
  %1329 = load i32, ptr %79, align 4, !tbaa !11
  %1330 = load ptr, ptr %6, align 8, !tbaa !5
  %1331 = getelementptr inbounds %struct.fstReaderContext, ptr %1330, i32 0, i32 10
  %1332 = load ptr, ptr %1331, align 8, !tbaa !16
  %1333 = load i32, ptr %8, align 4, !tbaa !11
  %1334 = zext i32 %1333 to i64
  %1335 = getelementptr inbounds i32, ptr %1332, i64 %1334
  %1336 = load i32, ptr %1335, align 4, !tbaa !11
  %1337 = icmp ult i32 %1329, %1336
  br i1 %1337, label %1338, label %1363

1338:                                             ; preds = %1328
  call void @llvm.lifetime.start.p0(i64 1, ptr %80) #8
  %1339 = load i32, ptr %79, align 4, !tbaa !11
  %1340 = udiv i32 %1339, 8
  store i32 %1340, ptr %77, align 4, !tbaa !11
  %1341 = load i32, ptr %79, align 4, !tbaa !11
  %1342 = and i32 %1341, 7
  %1343 = sub i32 7, %1342
  store i32 %1343, ptr %78, align 4, !tbaa !11
  %1344 = load ptr, ptr %76, align 8, !tbaa !5
  %1345 = load i32, ptr %77, align 4, !tbaa !11
  %1346 = sext i32 %1345 to i64
  %1347 = getelementptr inbounds i8, ptr %1344, i64 %1346
  %1348 = load i8, ptr %1347, align 1, !tbaa !33
  %1349 = zext i8 %1348 to i32
  %1350 = load i32, ptr %78, align 4, !tbaa !11
  %1351 = ashr i32 %1349, %1350
  %1352 = and i32 %1351, 1
  %1353 = or i32 %1352, 48
  %1354 = trunc i32 %1353 to i8
  store i8 %1354, ptr %80, align 1, !tbaa !33
  %1355 = load i8, ptr %80, align 1, !tbaa !33
  %1356 = load ptr, ptr %9, align 8, !tbaa !5
  %1357 = load i32, ptr %79, align 4, !tbaa !11
  %1358 = zext i32 %1357 to i64
  %1359 = getelementptr inbounds i8, ptr %1356, i64 %1358
  store i8 %1355, ptr %1359, align 1, !tbaa !33
  call void @llvm.lifetime.end.p0(i64 1, ptr %80) #8
  br label %1360

1360:                                             ; preds = %1338
  %1361 = load i32, ptr %79, align 4, !tbaa !11
  %1362 = add i32 %1361, 1
  store i32 %1362, ptr %79, align 4, !tbaa !11
  br label %1328, !llvm.loop !48

1363:                                             ; preds = %1328
  %1364 = load ptr, ptr %9, align 8, !tbaa !5
  %1365 = load i32, ptr %79, align 4, !tbaa !11
  %1366 = zext i32 %1365 to i64
  %1367 = getelementptr inbounds i8, ptr %1364, i64 %1366
  store i8 0, ptr %1367, align 1, !tbaa !33
  %1368 = load ptr, ptr %9, align 8, !tbaa !5
  store ptr %1368, ptr %5, align 8
  store i32 1, ptr %32, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %79) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %78) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %77) #8
  br label %1458

1369:                                             ; preds = %1323
  %1370 = load ptr, ptr %9, align 8, !tbaa !5
  %1371 = load ptr, ptr %76, align 8, !tbaa !5
  %1372 = load ptr, ptr %6, align 8, !tbaa !5
  %1373 = getelementptr inbounds %struct.fstReaderContext, ptr %1372, i32 0, i32 10
  %1374 = load ptr, ptr %1373, align 8, !tbaa !16
  %1375 = load i32, ptr %8, align 4, !tbaa !11
  %1376 = zext i32 %1375 to i64
  %1377 = getelementptr inbounds i32, ptr %1374, i64 %1376
  %1378 = load i32, ptr %1377, align 4, !tbaa !11
  %1379 = zext i32 %1378 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %1370, ptr align 1 %1371, i64 %1379, i1 false)
  %1380 = load ptr, ptr %9, align 8, !tbaa !5
  %1381 = load ptr, ptr %6, align 8, !tbaa !5
  %1382 = getelementptr inbounds %struct.fstReaderContext, ptr %1381, i32 0, i32 10
  %1383 = load ptr, ptr %1382, align 8, !tbaa !16
  %1384 = load i32, ptr %8, align 4, !tbaa !11
  %1385 = zext i32 %1384 to i64
  %1386 = getelementptr inbounds i32, ptr %1383, i64 %1385
  %1387 = load i32, ptr %1386, align 4, !tbaa !11
  %1388 = zext i32 %1387 to i64
  %1389 = getelementptr inbounds i8, ptr %1380, i64 %1388
  store i8 0, ptr %1389, align 1, !tbaa !33
  %1390 = load ptr, ptr %9, align 8, !tbaa !5
  store ptr %1390, ptr %5, align 8
  store i32 1, ptr %32, align 4
  br label %1458

1391:                                             ; preds = %1290
  call void @llvm.lifetime.start.p0(i64 8, ptr %81) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %82) #8
  store ptr %81, ptr %82, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %83) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %84) #8
  %1392 = load i32, ptr %71, align 4, !tbaa !11
  %1393 = and i32 %1392, 1
  %1394 = icmp ne i32 %1393, 0
  br i1 %1394, label %1421, label %1395

1395:                                             ; preds = %1391
  call void @llvm.lifetime.start.p0(i64 4, ptr %85) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %86) #8
  store i32 0, ptr %86, align 4, !tbaa !11
  br label %1396

1396:                                             ; preds = %1416, %1395
  %1397 = load i32, ptr %86, align 4, !tbaa !11
  %1398 = icmp slt i32 %1397, 8
  br i1 %1398, label %1399, label %1419

1399:                                             ; preds = %1396
  call void @llvm.lifetime.start.p0(i64 1, ptr %87) #8
  %1400 = load i32, ptr %86, align 4, !tbaa !11
  %1401 = and i32 %1400, 7
  %1402 = sub nsw i32 7, %1401
  store i32 %1402, ptr %85, align 4, !tbaa !11
  %1403 = load ptr, ptr %76, align 8, !tbaa !5
  %1404 = getelementptr inbounds i8, ptr %1403, i64 0
  %1405 = load i8, ptr %1404, align 1, !tbaa !33
  %1406 = zext i8 %1405 to i32
  %1407 = load i32, ptr %85, align 4, !tbaa !11
  %1408 = ashr i32 %1406, %1407
  %1409 = and i32 %1408, 1
  %1410 = or i32 %1409, 48
  %1411 = trunc i32 %1410 to i8
  store i8 %1411, ptr %87, align 1, !tbaa !33
  %1412 = load i8, ptr %87, align 1, !tbaa !33
  %1413 = load i32, ptr %86, align 4, !tbaa !11
  %1414 = sext i32 %1413 to i64
  %1415 = getelementptr inbounds [8 x i8], ptr %83, i64 0, i64 %1414
  store i8 %1412, ptr %1415, align 1, !tbaa !33
  call void @llvm.lifetime.end.p0(i64 1, ptr %87) #8
  br label %1416

1416:                                             ; preds = %1399
  %1417 = load i32, ptr %86, align 4, !tbaa !11
  %1418 = add nsw i32 %1417, 1
  store i32 %1418, ptr %86, align 4, !tbaa !11
  br label %1396, !llvm.loop !49

1419:                                             ; preds = %1396
  %1420 = getelementptr inbounds [8 x i8], ptr %83, i64 0, i64 0
  store ptr %1420, ptr %84, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 4, ptr %86) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %85) #8
  br label %1423

1421:                                             ; preds = %1391
  %1422 = load ptr, ptr %76, align 8, !tbaa !5
  store ptr %1422, ptr %84, align 8, !tbaa !5
  br label %1423

1423:                                             ; preds = %1421, %1419
  %1424 = load ptr, ptr %6, align 8, !tbaa !5
  %1425 = getelementptr inbounds %struct.fstReaderContext, ptr %1424, i32 0, i32 17
  %1426 = load i8, ptr %1425, align 2
  %1427 = lshr i8 %1426, 1
  %1428 = and i8 %1427, 1
  %1429 = zext i8 %1428 to i32
  %1430 = icmp ne i32 %1429, 0
  br i1 %1430, label %1431, label %1434

1431:                                             ; preds = %1423
  %1432 = load ptr, ptr %82, align 8, !tbaa !5
  %1433 = load ptr, ptr %84, align 8, !tbaa !5
  call void @llvm.memcpy.p0.p0.i64(ptr align 1 %1432, ptr align 1 %1433, i64 8, i1 false)
  br label %1453

1434:                                             ; preds = %1423
  call void @llvm.lifetime.start.p0(i64 4, ptr %88) #8
  store i32 0, ptr %88, align 4, !tbaa !11
  br label %1435

1435:                                             ; preds = %1449, %1434
  %1436 = load i32, ptr %88, align 4, !tbaa !11
  %1437 = icmp slt i32 %1436, 8
  br i1 %1437, label %1438, label %1452

1438:                                             ; preds = %1435
  %1439 = load ptr, ptr %84, align 8, !tbaa !5
  %1440 = load i32, ptr %88, align 4, !tbaa !11
  %1441 = sub nsw i32 7, %1440
  %1442 = sext i32 %1441 to i64
  %1443 = getelementptr inbounds i8, ptr %1439, i64 %1442
  %1444 = load i8, ptr %1443, align 1, !tbaa !33
  %1445 = load ptr, ptr %82, align 8, !tbaa !5
  %1446 = load i32, ptr %88, align 4, !tbaa !11
  %1447 = sext i32 %1446 to i64
  %1448 = getelementptr inbounds i8, ptr %1445, i64 %1447
  store i8 %1444, ptr %1448, align 1, !tbaa !33
  br label %1449

1449:                                             ; preds = %1438
  %1450 = load i32, ptr %88, align 4, !tbaa !11
  %1451 = add nsw i32 %1450, 1
  store i32 %1451, ptr %88, align 4, !tbaa !11
  br label %1435, !llvm.loop !50

1452:                                             ; preds = %1435
  call void @llvm.lifetime.end.p0(i64 4, ptr %88) #8
  br label %1453

1453:                                             ; preds = %1452, %1431
  %1454 = load ptr, ptr %9, align 8, !tbaa !5
  %1455 = load double, ptr %81, align 8, !tbaa !51
  %1456 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr noundef %1454, i64 noundef 32, ptr noundef @.str.56, double noundef %1455) #8
  %1457 = load ptr, ptr %9, align 8, !tbaa !5
  store ptr %1457, ptr %5, align 8
  store i32 1, ptr %32, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %84) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %83) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %82) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %81) #8
  br label %1458

1458:                                             ; preds = %1453, %1369, %1363
  call void @llvm.lifetime.end.p0(i64 8, ptr %76) #8
  br label %1464

1459:                                             ; preds = %1284
  %1460 = load ptr, ptr %6, align 8, !tbaa !5
  %1461 = load i32, ptr %8, align 4, !tbaa !11
  %1462 = load ptr, ptr %9, align 8, !tbaa !5
  %1463 = call ptr @fstExtractRvatDataFromFrame(ptr noundef %1460, i32 noundef %1461, ptr noundef %1462)
  store ptr %1463, ptr %5, align 8
  store i32 1, ptr %32, align 4
  br label %1464

1464:                                             ; preds = %1459, %1458, %1209, %1205
  call void @llvm.lifetime.end.p0(i64 4, ptr %72) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %71) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %70) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %69) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %68) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %67) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %66) #8
  br label %1465

1465:                                             ; preds = %1464, %904, %877, %205, %113
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #8
  %1466 = load ptr, ptr %5, align 8
  ret ptr %1466

1467:                                             ; preds = %1281, %1161, %300
  unreachable
}

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

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nounwind allocsize(0,1) "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 = { 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 = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { nounwind allocsize(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 #5 = { "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 #6 = { 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 #7 = { 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 #8 = { nounwind }
attributes #9 = { nounwind allocsize(0,1) }
attributes #10 = { nounwind allocsize(0) }
attributes #11 = { 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 = !{!"long", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"int", !7, i64 0}
!13 = !{!14, !12, i64 56}
!14 = !{!"fstReaderContext", !6, i64 0, !6, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !12, i64 56, !10, i64 64, !10, i64 72, !6, i64 80, !6, i64 88, !6, i64 96, !12, i64 104, !6, i64 112, !7, i64 120, !7, i64 121, !12, i64 122, !12, i64 122, !12, i64 122, !12, i64 122, !12, i64 122, !12, i64 122, !12, i64 122, !12, i64 122, !7, i64 123, !7, i64 252, !10, i64 376, !6, i64 384, !6, i64 392, !10, i64 400, !12, i64 408, !6, i64 416, !6, i64 424, !10, i64 432, !10, i64 440, !12, i64 448, !6, i64 456, !10, i64 464, !10, i64 472, !6, i64 480, !10, i64 488, !6, i64 496, !6, i64 504, !10, i64 512, !10, i64 520, !6, i64 528, !12, i64 536, !12, i64 540, !6, i64 544, !12, i64 552, !12, i64 556, !12, i64 560, !10, i64 568, !12, i64 576, !15, i64 584, !6, i64 632, !12, i64 640, !6, i64 648, !12, i64 656, !12, i64 660, !7, i64 661, !7, i64 1174, !6, i64 1688, !12, i64 1696, !12, i64 1700, !12, i64 1704, !7, i64 1708, !6, i64 67248, !6, i64 67256}
!15 = !{!"fstHier", !7, i64 0, !7, i64 8}
!16 = !{!14, !6, i64 80}
!17 = !{!14, !6, i64 528}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.mustprogress"}
!20 = !{!14, !10, i64 464}
!21 = !{!14, !10, i64 472}
!22 = !{!14, !6, i64 0}
!23 = !{!14, !10, i64 24}
!24 = !{!14, !6, i64 456}
!25 = distinct !{!25, !19}
!26 = !{!14, !10, i64 488}
!27 = !{!14, !6, i64 480}
!28 = !{!14, !10, i64 512}
!29 = !{!14, !10, i64 520}
!30 = !{!14, !12, i64 536}
!31 = !{!14, !6, i64 496}
!32 = !{!14, !6, i64 504}
!33 = !{!7, !7, i64 0}
!34 = distinct !{!34, !19}
!35 = distinct !{!35, !19}
!36 = distinct !{!36, !19}
!37 = distinct !{!37, !19}
!38 = distinct !{!38, !19}
!39 = !{!14, !12, i64 552}
!40 = !{!14, !6, i64 544}
!41 = !{!14, !12, i64 540}
!42 = !{!14, !10, i64 568}
!43 = !{!14, !12, i64 560}
!44 = !{!14, !12, i64 556}
!45 = distinct !{!45, !19}
!46 = distinct !{!46, !19}
!47 = !{!14, !6, i64 88}
!48 = distinct !{!48, !19}
!49 = distinct !{!49, !19}
!50 = distinct !{!50, !19}
!51 = !{!52, !52, i64 0}
!52 = !{!"double", !7, i64 0}


; 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"

@stderr = external local_unnamed_addr global ptr, align 8
@.str.55 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.56 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.57 = external hidden unnamed_addr constant [82 x i8], align 1
@.str.58 = external hidden unnamed_addr constant [82 x i8], align 1
@.str.59 = external hidden unnamed_addr constant [91 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: mustprogress nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite)
declare noalias noundef ptr @calloc(i64 noundef, i64 noundef) local_unnamed_addr #1

; Function Attrs: mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite)
declare void @free(ptr allocptr nocapture noundef) local_unnamed_addr #2

; Function Attrs: mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite)
declare void @llvm.memcpy.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64, i1 immarg) #3

; Function Attrs: mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite)
declare noalias noundef ptr @malloc(i64 noundef) local_unnamed_addr #4

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

; Function Attrs: nofree nounwind
declare noundef i64 @ftello(ptr nocapture noundef) local_unnamed_addr #5

; Function Attrs: nounwind uwtable
declare hidden i64 @fstFread(ptr noundef, i64 noundef, i64 noundef, ptr noundef) local_unnamed_addr #6

; Function Attrs: nofree nounwind
declare noundef i32 @snprintf(ptr noalias nocapture noundef writeonly, i64 noundef, ptr nocapture noundef readonly, ...) local_unnamed_addr #5

; Function Attrs: nofree nounwind
declare noundef i32 @fprintf(ptr nocapture noundef, ptr nocapture noundef readonly, ...) local_unnamed_addr #5

; Function Attrs: noreturn nounwind
declare void @exit(i32 noundef) local_unnamed_addr #7

; Function Attrs: nounwind uwtable
declare dso_local i32 @fstReaderFseeko(ptr noundef, ptr noundef, i64 noundef, i32 noundef) local_unnamed_addr #6

; Function Attrs: nofree nounwind
declare noundef i32 @fgetc(ptr nocapture noundef) local_unnamed_addr #5

; Function Attrs: nounwind uwtable
declare hidden i64 @fstReaderVarint64(ptr noundef) local_unnamed_addr #6

; Function Attrs: nounwind uwtable
declare hidden i64 @fstGetVarint64(ptr noundef, ptr noundef) local_unnamed_addr #6

; Function Attrs: nounwind uwtable
declare hidden i64 @fstReaderUint64(ptr noundef) local_unnamed_addr #6

declare i32 @uncompress(ptr noundef, ptr noundef, ptr noundef, i64 noundef) local_unnamed_addr #8

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

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

; Function Attrs: nounwind uwtable
declare hidden i64 @fstGetSVarint64(ptr noundef, ptr noundef) local_unnamed_addr #6

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

declare i32 @LZ4_decompress_safe_partial(ptr noundef, ptr noundef, i32 noundef, i32 noundef, i32 noundef) local_unnamed_addr #8

declare i32 @fastlz_decompress(ptr noundef, i32 noundef, ptr noundef, i32 noundef) local_unnamed_addr #8

; Function Attrs: nounwind uwtable
define dso_local ptr @fstReaderGetValueFromHandleAtTime(ptr noundef %0, i64 noundef %1, i32 noundef %2, ptr noundef %3) local_unnamed_addr #6 {
  %5 = alloca i64, align 8
  %6 = alloca i32, align 4
  %7 = alloca i64, align 8
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca i64, align 8
  %12 = alloca i32, align 4
  %13 = alloca [8 x i8], align 1
  %14 = icmp ne ptr %0, null
  %15 = icmp ne i32 %2, 0
  %or.cond = and i1 %14, %15
  br i1 %or.cond, label %16, label %.loopexit669

16:                                               ; preds = %4
  %17 = getelementptr inbounds i8, ptr %0, i64 56
  %18 = load i32, ptr %17, align 8, !tbaa !5
  %19 = icmp uge i32 %18, %2
  %20 = icmp ne ptr %3, null
  %or.cond3 = and i1 %20, %19
  br i1 %or.cond3, label %21, label %.loopexit669

21:                                               ; preds = %16
  %22 = getelementptr inbounds i8, ptr %0, i64 80
  %23 = load ptr, ptr %22, align 8, !tbaa !13
  %24 = add i32 %2, -1
  %25 = zext i32 %24 to i64
  %26 = getelementptr inbounds i32, ptr %23, i64 %25
  %27 = load i32, ptr %26, align 4, !tbaa !14
  %.not = icmp eq i32 %27, 0
  br i1 %.not, label %.loopexit669, label %28

28:                                               ; preds = %21
  %29 = getelementptr inbounds i8, ptr %0, i64 528
  %30 = load ptr, ptr %29, align 8, !tbaa !15
  %.not587 = icmp eq ptr %30, null
  br i1 %.not587, label %.lr.ph.preheader, label %.loopexit670

.lr.ph.preheader:                                 ; preds = %28
  %31 = zext i32 %18 to i64
  %32 = tail call noalias ptr @calloc(i64 noundef %31, i64 noundef 4) #9
  store ptr %32, ptr %29, align 8, !tbaa !15
  %33 = add nsw i64 %31, -1
  %xtraiter = and i64 %31, 3
  %34 = icmp ult i64 %33, 3
  br i1 %34, label %.loopexit670.loopexit.unr-lcssa, label %.lr.ph.preheader.new

.lr.ph.preheader.new:                             ; preds = %.lr.ph.preheader
  %unroll_iter = and i64 %31, 4294967292
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph, %.lr.ph.preheader.new
  %indvars.iv = phi i64 [ 0, %.lr.ph.preheader.new ], [ %indvars.iv.next.3, %.lr.ph ]
  %.0553677 = phi i32 [ 0, %.lr.ph.preheader.new ], [ %50, %.lr.ph ]
  %niter = phi i64 [ 0, %.lr.ph.preheader.new ], [ %niter.next.3, %.lr.ph ]
  %35 = getelementptr inbounds i32, ptr %32, i64 %indvars.iv
  store i32 %.0553677, ptr %35, align 4, !tbaa !14
  %36 = getelementptr inbounds i32, ptr %23, i64 %indvars.iv
  %37 = load i32, ptr %36, align 4, !tbaa !14
  %38 = add i32 %37, %.0553677
  %indvars.iv.next = or disjoint i64 %indvars.iv, 1
  %39 = getelementptr inbounds i32, ptr %32, i64 %indvars.iv.next
  store i32 %38, ptr %39, align 4, !tbaa !14
  %40 = getelementptr inbounds i32, ptr %23, i64 %indvars.iv.next
  %41 = load i32, ptr %40, align 4, !tbaa !14
  %42 = add i32 %41, %38
  %indvars.iv.next.1 = or disjoint i64 %indvars.iv, 2
  %43 = getelementptr inbounds i32, ptr %32, i64 %indvars.iv.next.1
  store i32 %42, ptr %43, align 4, !tbaa !14
  %44 = getelementptr inbounds i32, ptr %23, i64 %indvars.iv.next.1
  %45 = load i32, ptr %44, align 4, !tbaa !14
  %46 = add i32 %45, %42
  %indvars.iv.next.2 = or disjoint i64 %indvars.iv, 3
  %47 = getelementptr inbounds i32, ptr %32, i64 %indvars.iv.next.2
  store i32 %46, ptr %47, align 4, !tbaa !14
  %48 = getelementptr inbounds i32, ptr %23, i64 %indvars.iv.next.2
  %49 = load i32, ptr %48, align 4, !tbaa !14
  %50 = add i32 %49, %46
  %indvars.iv.next.3 = add nuw nsw i64 %indvars.iv, 4
  %niter.next.3 = add i64 %niter, 4
  %niter.ncmp.3 = icmp eq i64 %niter.next.3, %unroll_iter
  br i1 %niter.ncmp.3, label %.loopexit670.loopexit.unr-lcssa, label %.lr.ph, !llvm.loop !16

.loopexit670.loopexit.unr-lcssa:                  ; preds = %.lr.ph, %.lr.ph.preheader
  %indvars.iv.unr = phi i64 [ 0, %.lr.ph.preheader ], [ %indvars.iv.next.3, %.lr.ph ]
  %.0553677.unr = phi i32 [ 0, %.lr.ph.preheader ], [ %50, %.lr.ph ]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %.loopexit670, label %.lr.ph.epil

.lr.ph.epil:                                      ; preds = %.loopexit670.loopexit.unr-lcssa, %.lr.ph.epil
  %indvars.iv.epil = phi i64 [ %indvars.iv.next.epil, %.lr.ph.epil ], [ %indvars.iv.unr, %.loopexit670.loopexit.unr-lcssa ]
  %.0553677.epil = phi i32 [ %54, %.lr.ph.epil ], [ %.0553677.unr, %.loopexit670.loopexit.unr-lcssa ]
  %epil.iter = phi i64 [ %epil.iter.next, %.lr.ph.epil ], [ 0, %.loopexit670.loopexit.unr-lcssa ]
  %51 = getelementptr inbounds i32, ptr %32, i64 %indvars.iv.epil
  store i32 %.0553677.epil, ptr %51, align 4, !tbaa !14
  %52 = getelementptr inbounds i32, ptr %23, i64 %indvars.iv.epil
  %53 = load i32, ptr %52, align 4, !tbaa !14
  %54 = add i32 %53, %.0553677.epil
  %indvars.iv.next.epil = add nuw nsw i64 %indvars.iv.epil, 1
  %epil.iter.next = add i64 %epil.iter, 1
  %epil.iter.cmp.not = icmp eq i64 %epil.iter.next, %xtraiter
  br i1 %epil.iter.cmp.not, label %.loopexit670, label %.lr.ph.epil, !llvm.loop !18

.loopexit670:                                     ; preds = %.loopexit670.loopexit.unr-lcssa, %.lr.ph.epil, %28
  %55 = getelementptr inbounds i8, ptr %0, i64 448
  %56 = load i8, ptr %55, align 8
  %57 = and i8 %56, 1
  %.not588 = icmp eq i8 %57, 0
  br i1 %.not588, label %65, label %58

58:                                               ; preds = %.loopexit670
  %59 = getelementptr inbounds i8, ptr %0, i64 464
  %60 = load i64, ptr %59, align 8, !tbaa !20
  %.not589 = icmp ugt i64 %60, %1
  br i1 %.not589, label %64, label %61

61:                                               ; preds = %58
  %62 = getelementptr inbounds i8, ptr %0, i64 472
  %63 = load i64, ptr %62, align 8, !tbaa !21
  %.not590 = icmp ult i64 %63, %1
  br i1 %.not590, label %64, label %391

64:                                               ; preds = %61, %58
  tail call void @fstReaderDeallocateRvatData(ptr noundef nonnull %0)
  br label %65

65:                                               ; preds = %64, %.loopexit670
  %66 = getelementptr inbounds i8, ptr %0, i64 576
  %67 = load i8, ptr %66, align 8
  %68 = and i8 %67, -2
  store i8 %68, ptr %66, align 8
  %69 = load ptr, ptr %0, align 8, !tbaa !22
  %70 = tail call i32 @fstReaderFseeko(ptr noundef nonnull %0, ptr noundef %69, i64 noundef 0, i32 noundef 0)
  %71 = load ptr, ptr %0, align 8, !tbaa !22
  %72 = tail call i32 @fgetc(ptr noundef %71)
  %73 = load ptr, ptr %0, align 8, !tbaa !22
  %74 = tail call i64 @fstReaderUint64(ptr noundef %73)
  %.fr679 = freeze i64 %74
  %.not657680 = icmp eq i64 %.fr679, 0
  br i1 %.not657680, label %.loopexit669, label %switch.early.test

switch.early.test:                                ; preds = %65, %.backedge
  %.fr682 = phi i64 [ %.fr, %.backedge ], [ %.fr679, %65 ]
  %75 = phi i32 [ %81, %.backedge ], [ %72, %65 ]
  %.0489681 = phi i64 [ %.0489.be, %.backedge ], [ 0, %65 ]
  switch i32 %75, label %76 [
    i32 -1, label %.loopexit669
    i32 255, label %.loopexit669
  ]

76:                                               ; preds = %switch.early.test
  %77 = add nsw i64 %.0489681, 1
  switch i32 %75, label %.backedge [
    i32 8, label %84
    i32 5, label %84
    i32 1, label %84
  ]

.backedge:                                        ; preds = %84, %76
  %.0489.be = add i64 %.fr682, %77
  %78 = load ptr, ptr %0, align 8, !tbaa !22
  %79 = tail call i32 @fstReaderFseeko(ptr noundef nonnull %0, ptr noundef %78, i64 noundef %.0489.be, i32 noundef 0)
  %80 = load ptr, ptr %0, align 8, !tbaa !22
  %81 = tail call i32 @fgetc(ptr noundef %80)
  %82 = load ptr, ptr %0, align 8, !tbaa !22
  %83 = tail call i64 @fstReaderUint64(ptr noundef %82)
  %.fr = freeze i64 %83
  %.not657 = icmp eq i64 %.fr, 0
  br i1 %.not657, label %.loopexit669, label %switch.early.test

84:                                               ; preds = %76, %76, %76
  %85 = load ptr, ptr %0, align 8, !tbaa !22
  %86 = tail call i64 @fstReaderUint64(ptr noundef %85)
  %87 = load ptr, ptr %0, align 8, !tbaa !22
  %88 = tail call i64 @fstReaderUint64(ptr noundef %87)
  %.not594 = icmp ugt i64 %86, %1
  %.not595 = icmp ult i64 %88, %1
  %or.cond630 = select i1 %.not594, i1 true, i1 %.not595
  br i1 %or.cond630, label %.backedge, label %89

89:                                               ; preds = %84
  %90 = icmp eq i64 %88, %1
  br i1 %90, label %91, label %113

91:                                               ; preds = %89
  %92 = getelementptr inbounds i8, ptr %0, i64 24
  %93 = load i64, ptr %92, align 8, !tbaa !23
  %.not596 = icmp eq i64 %93, %1
  br i1 %.not596, label %113, label %94

94:                                               ; preds = %91
  %95 = load ptr, ptr %0, align 8, !tbaa !22
  %96 = tail call i64 @ftello(ptr noundef %95)
  %97 = load ptr, ptr %0, align 8, !tbaa !22
  %98 = tail call i32 @fstReaderFseeko(ptr noundef nonnull %0, ptr noundef %97, i64 noundef %77, i32 noundef 0)
  %99 = load ptr, ptr %0, align 8, !tbaa !22
  %100 = tail call i32 @fgetc(ptr noundef %99)
  %101 = load ptr, ptr %0, align 8, !tbaa !22
  %102 = tail call i64 @fstReaderUint64(ptr noundef %101)
  %103 = load ptr, ptr %0, align 8, !tbaa !22
  %104 = tail call i64 @fstReaderUint64(ptr noundef %103)
  %105 = load ptr, ptr %0, align 8, !tbaa !22
  %106 = tail call i64 @fstReaderUint64(ptr noundef %105)
  %107 = and i32 %100, -5
  %or.cond13 = icmp eq i32 %107, 1
  %108 = icmp eq i32 %100, 8
  %or.cond15.not598 = or i1 %108, %or.cond13
  %109 = icmp ne i64 %102, 0
  %or.cond17 = select i1 %or.cond15.not598, i1 %109, i1 false
  %.not599 = icmp eq i64 %104, %1
  %or.cond631 = select i1 %or.cond17, i1 %.not599, i1 false
  br i1 %or.cond631, label %110, label %113

110:                                              ; preds = %94
  %111 = load ptr, ptr %0, align 8, !tbaa !22
  %112 = tail call i32 @fstReaderFseeko(ptr noundef nonnull %0, ptr noundef %111, i64 noundef %96, i32 noundef 0)
  br label %113

113:                                              ; preds = %110, %94, %89, %91
  %.0498 = phi i64 [ %.fr682, %91 ], [ %.fr682, %89 ], [ %102, %94 ], [ %102, %110 ]
  %.0497 = phi i32 [ %75, %91 ], [ %75, %89 ], [ %100, %94 ], [ %100, %110 ]
  %.1496 = phi i64 [ %1, %91 ], [ %88, %89 ], [ %1, %94 ], [ %106, %110 ]
  %.1493 = phi i64 [ %86, %91 ], [ %86, %89 ], [ %86, %94 ], [ %1, %110 ]
  %.2491 = phi i64 [ %77, %91 ], [ %77, %89 ], [ %.0489681, %94 ], [ %77, %110 ]
  %114 = getelementptr inbounds i8, ptr %0, i64 464
  store i64 %.1493, ptr %114, align 8, !tbaa !20
  %115 = getelementptr inbounds i8, ptr %0, i64 472
  store i64 %.1496, ptr %115, align 8, !tbaa !21
  %116 = load ptr, ptr %0, align 8, !tbaa !22
  %117 = tail call i64 @fstReaderUint64(ptr noundef %116)
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %5) #10
  %118 = load ptr, ptr %0, align 8, !tbaa !22
  %119 = add i64 %.0498, -24
  %120 = add i64 %119, %.2491
  %121 = tail call i32 @fstReaderFseeko(ptr noundef nonnull %0, ptr noundef %118, i64 noundef %120, i32 noundef 0)
  %122 = load ptr, ptr %0, align 8, !tbaa !22
  %123 = tail call i64 @fstReaderUint64(ptr noundef %122)
  %124 = load ptr, ptr %0, align 8, !tbaa !22
  %125 = tail call i64 @fstReaderUint64(ptr noundef %124)
  %126 = load ptr, ptr %0, align 8, !tbaa !22
  %127 = tail call i64 @fstReaderUint64(ptr noundef %126)
  %128 = tail call noalias ptr @malloc(i64 noundef %123) #11
  store i64 %123, ptr %5, align 8, !tbaa !24
  %129 = load ptr, ptr %0, align 8, !tbaa !22
  %130 = sub nsw i64 -24, %125
  %131 = tail call i32 @fstReaderFseeko(ptr noundef nonnull %0, ptr noundef %129, i64 noundef %130, i32 noundef 1)
  %.not600 = icmp eq i64 %123, %125
  br i1 %.not600, label %141, label %132

132:                                              ; preds = %113
  %133 = tail call noalias ptr @malloc(i64 noundef %125) #11
  %134 = load ptr, ptr %0, align 8, !tbaa !22
  %135 = tail call i64 @fstFread(ptr noundef %133, i64 noundef %125, i64 noundef 1, ptr noundef %134)
  %136 = call i32 @uncompress(ptr noundef %128, ptr noundef nonnull %5, ptr noundef %133, i64 noundef %125) #10
  %.not601 = icmp eq i32 %136, 0
  br i1 %.not601, label %140, label %137

137:                                              ; preds = %132
  %138 = load ptr, ptr @stderr, align 8, !tbaa !25
  %139 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %138, ptr noundef nonnull @.str.57, i32 noundef %136) #12
  call void @exit(i32 noundef 255) #13
  unreachable

140:                                              ; preds = %132
  call void @free(ptr noundef %133) #10
  br label %144

141:                                              ; preds = %113
  %142 = load ptr, ptr %0, align 8, !tbaa !22
  %143 = tail call i64 @fstFread(ptr noundef %128, i64 noundef %123, i64 noundef 1, ptr noundef %142)
  br label %144

144:                                              ; preds = %141, %140
  %145 = call noalias ptr @calloc(i64 noundef %127, i64 noundef 8) #9
  %146 = getelementptr inbounds i8, ptr %0, i64 456
  store ptr %145, ptr %146, align 8, !tbaa !26
  %.not737 = icmp eq i64 %127, 0
  br i1 %.not737, label %._crit_edge, label %.lr.ph687

.lr.ph687:                                        ; preds = %144, %.lr.ph687
  %147 = phi i64 [ %156, %.lr.ph687 ], [ 0, %144 ]
  %.0554686 = phi ptr [ %154, %.lr.ph687 ], [ %128, %144 ]
  %.0555685 = phi i64 [ %149, %.lr.ph687 ], [ 0, %144 ]
  %.0559684 = phi i32 [ %155, %.lr.ph687 ], [ 0, %144 ]
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %6) #10
  %148 = call i64 @fstGetVarint64(ptr noundef %.0554686, ptr noundef nonnull %6)
  %149 = add i64 %148, %.0555685
  %150 = load ptr, ptr %146, align 8, !tbaa !26
  %151 = getelementptr inbounds i64, ptr %150, i64 %147
  store i64 %149, ptr %151, align 8, !tbaa !24
  %152 = load i32, ptr %6, align 4, !tbaa !14
  %153 = sext i32 %152 to i64
  %154 = getelementptr inbounds i8, ptr %.0554686, i64 %153
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %6) #10
  %155 = add i32 %.0559684, 1
  %156 = zext i32 %155 to i64
  %157 = icmp ugt i64 %127, %156
  br i1 %157, label %.lr.ph687, label %._crit_edge, !llvm.loop !27

._crit_edge:                                      ; preds = %.lr.ph687, %144
  call void @free(ptr noundef %128) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %5) #10
  %158 = load ptr, ptr %0, align 8, !tbaa !22
  %159 = add nsw i64 %.2491, 32
  %160 = call i32 @fstReaderFseeko(ptr noundef nonnull %0, ptr noundef %158, i64 noundef %159, i32 noundef 0)
  %161 = load ptr, ptr %0, align 8, !tbaa !22
  %162 = call i64 @fstReaderVarint64(ptr noundef %161)
  %163 = load ptr, ptr %0, align 8, !tbaa !22
  %164 = call i64 @fstReaderVarint64(ptr noundef %163)
  %165 = load ptr, ptr %0, align 8, !tbaa !22
  %166 = call i64 @fstReaderVarint64(ptr noundef %165)
  %167 = getelementptr inbounds i8, ptr %0, i64 488
  store i64 %166, ptr %167, align 8, !tbaa !28
  %168 = call noalias ptr @malloc(i64 noundef %162) #11
  %169 = getelementptr inbounds i8, ptr %0, i64 480
  store ptr %168, ptr %169, align 8, !tbaa !29
  %170 = icmp eq i64 %162, %164
  br i1 %170, label %171, label %174

171:                                              ; preds = %._crit_edge
  %172 = load ptr, ptr %0, align 8, !tbaa !22
  %173 = call i64 @fstFread(ptr noundef %168, i64 noundef %162, i64 noundef 1, ptr noundef %172)
  br label %184

174:                                              ; preds = %._crit_edge
  %175 = call noalias ptr @malloc(i64 noundef %164) #11
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %7) #10
  store i64 %162, ptr %7, align 8, !tbaa !24
  %176 = load ptr, ptr %0, align 8, !tbaa !22
  %177 = call i64 @fstFread(ptr noundef %175, i64 noundef %164, i64 noundef 1, ptr noundef %176)
  %178 = load ptr, ptr %169, align 8, !tbaa !29
  %179 = call i32 @uncompress(ptr noundef %178, ptr noundef nonnull %7, ptr noundef %175, i64 noundef %164) #10
  %.not602 = icmp eq i32 %179, 0
  br i1 %.not602, label %183, label %180

180:                                              ; preds = %174
  %181 = load ptr, ptr @stderr, align 8, !tbaa !25
  %182 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %181, ptr noundef nonnull @.str.58, i32 noundef %179) #12
  call void @exit(i32 noundef 255) #13
  unreachable

183:                                              ; preds = %174
  call void @free(ptr noundef %175) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %7) #10
  br label %184

184:                                              ; preds = %183, %171
  %185 = load ptr, ptr %0, align 8, !tbaa !22
  %186 = call i64 @fstReaderVarint64(ptr noundef %185)
  %187 = getelementptr inbounds i8, ptr %0, i64 512
  store i64 %186, ptr %187, align 8, !tbaa !30
  %188 = load ptr, ptr %0, align 8, !tbaa !22
  %189 = call i64 @ftello(ptr noundef %188)
  %190 = getelementptr inbounds i8, ptr %0, i64 520
  store i64 %189, ptr %190, align 8, !tbaa !31
  %191 = load ptr, ptr %0, align 8, !tbaa !22
  %192 = call i32 @fgetc(ptr noundef %191)
  %193 = getelementptr inbounds i8, ptr %0, i64 536
  store i32 %192, ptr %193, align 8, !tbaa !32
  %194 = sub i64 %120, %125
  %195 = add i64 %194, -8
  %196 = load ptr, ptr %0, align 8, !tbaa !22
  %197 = call i32 @fstReaderFseeko(ptr noundef nonnull %0, ptr noundef %196, i64 noundef %195, i32 noundef 0)
  %198 = load ptr, ptr %0, align 8, !tbaa !22
  %199 = call i64 @fstReaderUint64(ptr noundef %198)
  %200 = sub nsw i64 %195, %199
  %201 = call noalias ptr @malloc(i64 noundef %199) #11
  %202 = load ptr, ptr %0, align 8, !tbaa !22
  %203 = call i32 @fstReaderFseeko(ptr noundef nonnull %0, ptr noundef %202, i64 noundef %200, i32 noundef 0)
  %204 = load ptr, ptr %0, align 8, !tbaa !22
  %205 = call i64 @fstFread(ptr noundef %201, i64 noundef %199, i64 noundef 1, ptr noundef %204)
  %206 = load i64, ptr %187, align 8, !tbaa !30
  %207 = add i64 %206, 1
  %208 = call noalias ptr @calloc(i64 noundef %207, i64 noundef 8) #9
  %209 = getelementptr inbounds i8, ptr %0, i64 496
  store ptr %208, ptr %209, align 8, !tbaa !33
  %210 = call noalias ptr @calloc(i64 noundef %207, i64 noundef 4) #9
  %211 = getelementptr inbounds i8, ptr %0, i64 504
  store ptr %210, ptr %211, align 8, !tbaa !34
  %212 = icmp eq i32 %.0497, 8
  %213 = getelementptr inbounds i8, ptr %201, i64 %199
  br i1 %212, label %.preheader664, label %.preheader667

.preheader664:                                    ; preds = %184, %.loopexit663
  %.0556 = phi i32 [ %.2558, %.loopexit663 ], [ 0, %184 ]
  %.0546 = phi i64 [ %.2548, %.loopexit663 ], [ 0, %184 ]
  %.0532 = phi i32 [ %.2534, %.loopexit663 ], [ 0, %184 ]
  %.0525 = phi i32 [ %.3528, %.loopexit663 ], [ 0, %184 ]
  %.0522 = phi ptr [ %282, %.loopexit663 ], [ %201, %184 ]
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %8) #10
  %214 = load i8, ptr %.0522, align 1, !tbaa !35
  %215 = and i8 %214, 1
  %.not607 = icmp eq i8 %215, 0
  br i1 %.not607, label %236, label %216

216:                                              ; preds = %.preheader664
  %217 = call i64 @fstGetSVarint64(ptr noundef nonnull %.0522, ptr noundef nonnull %8)
  %218 = ashr i64 %217, 1
  %219 = icmp sgt i64 %218, 0
  %220 = load ptr, ptr %209, align 8, !tbaa !33
  %221 = zext i32 %.0525 to i64
  %222 = getelementptr inbounds i64, ptr %220, i64 %221
  br i1 %219, label %223, label %231

223:                                              ; preds = %216
  %224 = add i64 %218, %.0546
  store i64 %224, ptr %222, align 8, !tbaa !24
  %.not608 = icmp eq i32 %.0525, 0
  br i1 %.not608, label %235, label %225

225:                                              ; preds = %223
  %226 = zext i32 %.0532 to i64
  %227 = getelementptr inbounds i64, ptr %220, i64 %226
  %228 = load i64, ptr %227, align 8, !tbaa !24
  %229 = sub i64 %224, %228
  %230 = trunc i64 %229 to i32
  br label %.sink.split

231:                                              ; preds = %216
  %.not813 = icmp ult i64 %217, 2
  store i64 0, ptr %222, align 8, !tbaa !24
  %232 = trunc i64 %218 to i32
  %spec.select = select i1 %.not813, i32 %.0556, i32 %232
  %spec.select812 = select i1 %.not813, i32 %.0556, i32 %232
  br label %.sink.split

.sink.split:                                      ; preds = %231, %225
  %.sink811 = phi i64 [ %226, %225 ], [ %221, %231 ]
  %.sink = phi i32 [ %230, %225 ], [ %spec.select, %231 ]
  %.1557.ph = phi i32 [ %.0556, %225 ], [ %spec.select812, %231 ]
  %.1547.ph = phi i64 [ %224, %225 ], [ %.0546, %231 ]
  %.1533.ph = phi i32 [ %.0525, %225 ], [ %.0532, %231 ]
  %233 = load ptr, ptr %211, align 8, !tbaa !34
  %234 = getelementptr inbounds i32, ptr %233, i64 %.sink811
  store i32 %.sink, ptr %234, align 4, !tbaa !14
  br label %235

235:                                              ; preds = %.sink.split, %223
  %.1557 = phi i32 [ %.0556, %223 ], [ %.1557.ph, %.sink.split ]
  %.1547 = phi i64 [ %224, %223 ], [ %.1547.ph, %.sink.split ]
  %.1533 = phi i32 [ 0, %223 ], [ %.1533.ph, %.sink.split ]
  %.1526 = add i32 %.0525, 1
  br label %.loopexit663

236:                                              ; preds = %.preheader664
  %237 = call i32 @fstGetVarint32(ptr noundef nonnull %.0522, ptr noundef nonnull %8)
  %.not739 = icmp ult i32 %237, 2
  br i1 %.not739, label %.loopexit663, label %.lr.ph695

.lr.ph695:                                        ; preds = %236
  %238 = lshr i32 %237, 1
  %239 = load ptr, ptr %209, align 8, !tbaa !33
  %240 = add i32 %.0525, %238
  %min.iters.check855 = icmp ult i32 %237, 20
  %241 = sub nsw i32 0, %238
  %242 = icmp ugt i32 %.0525, %241
  %or.cond867 = select i1 %min.iters.check855, i1 true, i1 %242
  br i1 %or.cond867, label %scalar.ph854.preheader, label %vector.ph856

vector.ph856:                                     ; preds = %.lr.ph695
  %n.vec858 = and i32 %238, 2147483644
  %ind.end859 = add i32 %.0525, %n.vec858
  br label %vector.body861

vector.body861:                                   ; preds = %vector.body861, %vector.ph856
  %index862 = phi i32 [ 0, %vector.ph856 ], [ %index.next864, %vector.body861 ]
  %offset.idx863 = add i32 %.0525, %index862
  %243 = zext i32 %offset.idx863 to i64
  %244 = getelementptr inbounds i64, ptr %239, i64 %243
  %245 = getelementptr inbounds i8, ptr %244, i64 16
  store <2 x i64> zeroinitializer, ptr %244, align 8, !tbaa !24
  store <2 x i64> zeroinitializer, ptr %245, align 8, !tbaa !24
  %index.next864 = add nuw i32 %index862, 4
  %246 = icmp eq i32 %index.next864, %n.vec858
  br i1 %246, label %middle.block853, label %vector.body861, !llvm.loop !36

middle.block853:                                  ; preds = %vector.body861
  %cmp.n865 = icmp eq i32 %238, %n.vec858
  br i1 %cmp.n865, label %.loopexit663, label %scalar.ph854.preheader

scalar.ph854.preheader:                           ; preds = %middle.block853, %.lr.ph695
  %.2527693.ph = phi i32 [ %.0525, %.lr.ph695 ], [ %ind.end859, %middle.block853 ]
  %247 = add i32 %.0525, %238
  %248 = sub i32 %247, %.2527693.ph
  %249 = add i32 %.0525, -1
  %250 = add i32 %249, %238
  %251 = sub i32 %250, %.2527693.ph
  %xtraiter888 = and i32 %248, 7
  %lcmp.mod889.not = icmp eq i32 %xtraiter888, 0
  br i1 %lcmp.mod889.not, label %scalar.ph854.prol.loopexit, label %scalar.ph854.prol

scalar.ph854.prol:                                ; preds = %scalar.ph854.preheader, %scalar.ph854.prol
  %.2527693.prol = phi i32 [ %252, %scalar.ph854.prol ], [ %.2527693.ph, %scalar.ph854.preheader ]
  %prol.iter890 = phi i32 [ %prol.iter890.next, %scalar.ph854.prol ], [ 0, %scalar.ph854.preheader ]
  %252 = add i32 %.2527693.prol, 1
  %253 = zext i32 %.2527693.prol to i64
  %254 = getelementptr inbounds i64, ptr %239, i64 %253
  store i64 0, ptr %254, align 8, !tbaa !24
  %prol.iter890.next = add i32 %prol.iter890, 1
  %prol.iter890.cmp.not = icmp eq i32 %prol.iter890.next, %xtraiter888
  br i1 %prol.iter890.cmp.not, label %scalar.ph854.prol.loopexit, label %scalar.ph854.prol, !llvm.loop !39

scalar.ph854.prol.loopexit:                       ; preds = %scalar.ph854.prol, %scalar.ph854.preheader
  %.2527693.unr = phi i32 [ %.2527693.ph, %scalar.ph854.preheader ], [ %252, %scalar.ph854.prol ]
  %255 = icmp ult i32 %251, 7
  br i1 %255, label %.loopexit663, label %scalar.ph854

scalar.ph854:                                     ; preds = %scalar.ph854.prol.loopexit, %scalar.ph854
  %.2527693 = phi i32 [ %277, %scalar.ph854 ], [ %.2527693.unr, %scalar.ph854.prol.loopexit ]
  %256 = add i32 %.2527693, 1
  %257 = zext i32 %.2527693 to i64
  %258 = getelementptr inbounds i64, ptr %239, i64 %257
  store i64 0, ptr %258, align 8, !tbaa !24
  %259 = add i32 %.2527693, 2
  %260 = zext i32 %256 to i64
  %261 = getelementptr inbounds i64, ptr %239, i64 %260
  store i64 0, ptr %261, align 8, !tbaa !24
  %262 = add i32 %.2527693, 3
  %263 = zext i32 %259 to i64
  %264 = getelementptr inbounds i64, ptr %239, i64 %263
  store i64 0, ptr %264, align 8, !tbaa !24
  %265 = add i32 %.2527693, 4
  %266 = zext i32 %262 to i64
  %267 = getelementptr inbounds i64, ptr %239, i64 %266
  store i64 0, ptr %267, align 8, !tbaa !24
  %268 = add i32 %.2527693, 5
  %269 = zext i32 %265 to i64
  %270 = getelementptr inbounds i64, ptr %239, i64 %269
  store i64 0, ptr %270, align 8, !tbaa !24
  %271 = add i32 %.2527693, 6
  %272 = zext i32 %268 to i64
  %273 = getelementptr inbounds i64, ptr %239, i64 %272
  store i64 0, ptr %273, align 8, !tbaa !24
  %274 = add i32 %.2527693, 7
  %275 = zext i32 %271 to i64
  %276 = getelementptr inbounds i64, ptr %239, i64 %275
  store i64 0, ptr %276, align 8, !tbaa !24
  %277 = add i32 %.2527693, 8
  %278 = zext i32 %274 to i64
  %279 = getelementptr inbounds i64, ptr %239, i64 %278
  store i64 0, ptr %279, align 8, !tbaa !24
  %exitcond754.not.7 = icmp eq i32 %277, %240
  br i1 %exitcond754.not.7, label %.loopexit663, label %scalar.ph854, !llvm.loop !40

.loopexit663:                                     ; preds = %scalar.ph854.prol.loopexit, %scalar.ph854, %middle.block853, %236, %235
  %.2558 = phi i32 [ %.1557, %235 ], [ %.0556, %236 ], [ %.0556, %middle.block853 ], [ %.0556, %scalar.ph854 ], [ %.0556, %scalar.ph854.prol.loopexit ]
  %.2548 = phi i64 [ %.1547, %235 ], [ %.0546, %236 ], [ %.0546, %middle.block853 ], [ %.0546, %scalar.ph854 ], [ %.0546, %scalar.ph854.prol.loopexit ]
  %.2534 = phi i32 [ %.1533, %235 ], [ %.0532, %236 ], [ %.0532, %middle.block853 ], [ %.0532, %scalar.ph854 ], [ %.0532, %scalar.ph854.prol.loopexit ]
  %.3528 = phi i32 [ %.1526, %235 ], [ %.0525, %236 ], [ %240, %middle.block853 ], [ %240, %scalar.ph854 ], [ %240, %scalar.ph854.prol.loopexit ]
  %280 = load i32, ptr %8, align 4, !tbaa !14
  %281 = sext i32 %280 to i64
  %282 = getelementptr inbounds i8, ptr %.0522, i64 %281
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %8) #10
  %.not609 = icmp eq ptr %282, %213
  br i1 %.not609, label %.loopexit665, label %.preheader664, !llvm.loop !41

.preheader667:                                    ; preds = %184, %.loopexit666
  %.3549 = phi i64 [ %.4550, %.loopexit666 ], [ 0, %184 ]
  %.3535 = phi i32 [ %.4536, %.loopexit666 ], [ 0, %184 ]
  %.4529 = phi i32 [ %.6, %.loopexit666 ], [ 0, %184 ]
  %.1523 = phi ptr [ %360, %.loopexit666 ], [ %201, %184 ]
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %9) #10
  %283 = call i32 @fstGetVarint32(ptr noundef %.1523, ptr noundef nonnull %9)
  %284 = zext i32 %283 to i64
  %.not603 = icmp eq i32 %283, 0
  br i1 %.not603, label %285, label %297

285:                                              ; preds = %.preheader667
  %286 = load i32, ptr %9, align 4, !tbaa !14
  %287 = sext i32 %286 to i64
  %288 = getelementptr inbounds i8, ptr %.1523, i64 %287
  %289 = call i32 @fstGetVarint32(ptr noundef %288, ptr noundef nonnull %9)
  %290 = load ptr, ptr %209, align 8, !tbaa !33
  %291 = zext i32 %.4529 to i64
  %292 = getelementptr inbounds i64, ptr %290, i64 %291
  store i64 0, ptr %292, align 8, !tbaa !24
  %293 = sub i32 0, %289
  %294 = load ptr, ptr %211, align 8, !tbaa !34
  %295 = getelementptr inbounds i32, ptr %294, i64 %291
  store i32 %293, ptr %295, align 4, !tbaa !14
  %296 = add i32 %.4529, 1
  br label %.loopexit666

297:                                              ; preds = %.preheader667
  %298 = and i64 %284, 1
  %.not604 = icmp eq i64 %298, 0
  br i1 %.not604, label %315, label %299

299:                                              ; preds = %297
  %300 = lshr i64 %284, 1
  %301 = add i64 %300, %.3549
  %302 = load ptr, ptr %209, align 8, !tbaa !33
  %303 = zext i32 %.4529 to i64
  %304 = getelementptr inbounds i64, ptr %302, i64 %303
  store i64 %301, ptr %304, align 8, !tbaa !24
  %.not605 = icmp eq i32 %.4529, 0
  br i1 %.not605, label %313, label %305

305:                                              ; preds = %299
  %306 = zext i32 %.3535 to i64
  %307 = getelementptr inbounds i64, ptr %302, i64 %306
  %308 = load i64, ptr %307, align 8, !tbaa !24
  %309 = sub i64 %301, %308
  %310 = trunc i64 %309 to i32
  %311 = load ptr, ptr %211, align 8, !tbaa !34
  %312 = getelementptr inbounds i32, ptr %311, i64 %306
  store i32 %310, ptr %312, align 4, !tbaa !14
  br label %313

313:                                              ; preds = %305, %299
  %314 = add i32 %.4529, 1
  br label %.loopexit666

315:                                              ; preds = %297
  %.not738 = icmp eq i32 %283, 1
  br i1 %.not738, label %.loopexit666, label %.lr.ph691

.lr.ph691:                                        ; preds = %315
  %316 = lshr i32 %283, 1
  %317 = load ptr, ptr %209, align 8, !tbaa !33
  %318 = add i32 %.4529, %316
  %min.iters.check = icmp ult i32 %283, 20
  %319 = sub nsw i32 0, %316
  %320 = icmp ugt i32 %.4529, %319
  %or.cond869 = select i1 %min.iters.check, i1 true, i1 %320
  br i1 %or.cond869, label %scalar.ph.preheader, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph691
  %n.vec = and i32 %316, 2147483644
  %ind.end = add i32 %.4529, %n.vec
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i32 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %offset.idx = add i32 %.4529, %index
  %321 = zext i32 %offset.idx to i64
  %322 = getelementptr inbounds i64, ptr %317, i64 %321
  %323 = getelementptr inbounds i8, ptr %322, i64 16
  store <2 x i64> zeroinitializer, ptr %322, align 8, !tbaa !24
  store <2 x i64> zeroinitializer, ptr %323, align 8, !tbaa !24
  %index.next = add nuw i32 %index, 4
  %324 = icmp eq i32 %index.next, %n.vec
  br i1 %324, label %middle.block, label %vector.body, !llvm.loop !42

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i32 %316, %n.vec
  br i1 %cmp.n, label %.loopexit666, label %scalar.ph.preheader

scalar.ph.preheader:                              ; preds = %middle.block, %.lr.ph691
  %.5530689.ph = phi i32 [ %.4529, %.lr.ph691 ], [ %ind.end, %middle.block ]
  %325 = add i32 %.4529, %316
  %326 = sub i32 %325, %.5530689.ph
  %327 = add i32 %.4529, -1
  %328 = add i32 %327, %316
  %329 = sub i32 %328, %.5530689.ph
  %xtraiter886 = and i32 %326, 7
  %lcmp.mod887.not = icmp eq i32 %xtraiter886, 0
  br i1 %lcmp.mod887.not, label %scalar.ph.prol.loopexit, label %scalar.ph.prol

scalar.ph.prol:                                   ; preds = %scalar.ph.preheader, %scalar.ph.prol
  %.5530689.prol = phi i32 [ %330, %scalar.ph.prol ], [ %.5530689.ph, %scalar.ph.preheader ]
  %prol.iter = phi i32 [ %prol.iter.next, %scalar.ph.prol ], [ 0, %scalar.ph.preheader ]
  %330 = add i32 %.5530689.prol, 1
  %331 = zext i32 %.5530689.prol to i64
  %332 = getelementptr inbounds i64, ptr %317, i64 %331
  store i64 0, ptr %332, align 8, !tbaa !24
  %prol.iter.next = add i32 %prol.iter, 1
  %prol.iter.cmp.not = icmp eq i32 %prol.iter.next, %xtraiter886
  br i1 %prol.iter.cmp.not, label %scalar.ph.prol.loopexit, label %scalar.ph.prol, !llvm.loop !43

scalar.ph.prol.loopexit:                          ; preds = %scalar.ph.prol, %scalar.ph.preheader
  %.5530689.unr = phi i32 [ %.5530689.ph, %scalar.ph.preheader ], [ %330, %scalar.ph.prol ]
  %333 = icmp ult i32 %329, 7
  br i1 %333, label %.loopexit666, label %scalar.ph

scalar.ph:                                        ; preds = %scalar.ph.prol.loopexit, %scalar.ph
  %.5530689 = phi i32 [ %355, %scalar.ph ], [ %.5530689.unr, %scalar.ph.prol.loopexit ]
  %334 = add i32 %.5530689, 1
  %335 = zext i32 %.5530689 to i64
  %336 = getelementptr inbounds i64, ptr %317, i64 %335
  store i64 0, ptr %336, align 8, !tbaa !24
  %337 = add i32 %.5530689, 2
  %338 = zext i32 %334 to i64
  %339 = getelementptr inbounds i64, ptr %317, i64 %338
  store i64 0, ptr %339, align 8, !tbaa !24
  %340 = add i32 %.5530689, 3
  %341 = zext i32 %337 to i64
  %342 = getelementptr inbounds i64, ptr %317, i64 %341
  store i64 0, ptr %342, align 8, !tbaa !24
  %343 = add i32 %.5530689, 4
  %344 = zext i32 %340 to i64
  %345 = getelementptr inbounds i64, ptr %317, i64 %344
  store i64 0, ptr %345, align 8, !tbaa !24
  %346 = add i32 %.5530689, 5
  %347 = zext i32 %343 to i64
  %348 = getelementptr inbounds i64, ptr %317, i64 %347
  store i64 0, ptr %348, align 8, !tbaa !24
  %349 = add i32 %.5530689, 6
  %350 = zext i32 %346 to i64
  %351 = getelementptr inbounds i64, ptr %317, i64 %350
  store i64 0, ptr %351, align 8, !tbaa !24
  %352 = add i32 %.5530689, 7
  %353 = zext i32 %349 to i64
  %354 = getelementptr inbounds i64, ptr %317, i64 %353
  store i64 0, ptr %354, align 8, !tbaa !24
  %355 = add i32 %.5530689, 8
  %356 = zext i32 %352 to i64
  %357 = getelementptr inbounds i64, ptr %317, i64 %356
  store i64 0, ptr %357, align 8, !tbaa !24
  %exitcond753.not.7 = icmp eq i32 %355, %318
  br i1 %exitcond753.not.7, label %.loopexit666, label %scalar.ph, !llvm.loop !44

.loopexit666:                                     ; preds = %scalar.ph.prol.loopexit, %scalar.ph, %middle.block, %315, %313, %285
  %.4550 = phi i64 [ %301, %313 ], [ %.3549, %285 ], [ %.3549, %315 ], [ %.3549, %middle.block ], [ %.3549, %scalar.ph ], [ %.3549, %scalar.ph.prol.loopexit ]
  %.4536 = phi i32 [ %.4529, %313 ], [ %.3535, %285 ], [ %.3535, %315 ], [ %.3535, %middle.block ], [ %.3535, %scalar.ph ], [ %.3535, %scalar.ph.prol.loopexit ]
  %.6 = phi i32 [ %314, %313 ], [ %296, %285 ], [ %.4529, %315 ], [ %318, %middle.block ], [ %318, %scalar.ph ], [ %318, %scalar.ph.prol.loopexit ]
  %.2524 = phi ptr [ %.1523, %313 ], [ %288, %285 ], [ %.1523, %315 ], [ %.1523, %middle.block ], [ %.1523, %scalar.ph ], [ %.1523, %scalar.ph.prol.loopexit ]
  %358 = load i32, ptr %9, align 4, !tbaa !14
  %359 = sext i32 %358 to i64
  %360 = getelementptr inbounds i8, ptr %.2524, i64 %359
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %9) #10
  %.not606 = icmp eq ptr %360, %213
  br i1 %.not606, label %.loopexit665, label %.preheader667, !llvm.loop !45

.loopexit665:                                     ; preds = %.loopexit666, %.loopexit663
  %.5537 = phi i32 [ %.2534, %.loopexit663 ], [ %.4536, %.loopexit666 ]
  %.7 = phi i32 [ %.3528, %.loopexit663 ], [ %.6, %.loopexit666 ]
  call void @free(ptr noundef %201) #10
  %361 = load i64, ptr %190, align 8, !tbaa !31
  %362 = sub nsw i64 %200, %361
  %363 = load ptr, ptr %209, align 8, !tbaa !33
  %364 = zext i32 %.7 to i64
  %365 = getelementptr inbounds i64, ptr %363, i64 %364
  store i64 %362, ptr %365, align 8, !tbaa !24
  %366 = zext i32 %.5537 to i64
  %367 = getelementptr inbounds i64, ptr %363, i64 %366
  %368 = load i64, ptr %367, align 8, !tbaa !24
  %369 = sub nsw i64 %362, %368
  %370 = trunc i64 %369 to i32
  %371 = load ptr, ptr %211, align 8, !tbaa !34
  %372 = getelementptr inbounds i32, ptr %371, i64 %366
  store i32 %370, ptr %372, align 4, !tbaa !14
  %.not740 = icmp eq i32 %.7, 0
  br i1 %.not740, label %._crit_edge700, label %.lr.ph699

.lr.ph699:                                        ; preds = %.loopexit665, %388
  %indvars.iv755 = phi i64 [ %indvars.iv.next756, %388 ], [ 0, %.loopexit665 ]
  %373 = getelementptr inbounds i32, ptr %371, i64 %indvars.iv755
  %374 = load i32, ptr %373, align 4, !tbaa !14
  %375 = icmp slt i32 %374, 0
  br i1 %375, label %376, label %388

376:                                              ; preds = %.lr.ph699
  %377 = getelementptr inbounds i64, ptr %363, i64 %indvars.iv755
  %378 = load i64, ptr %377, align 8, !tbaa !24
  %.not610 = icmp eq i64 %378, 0
  br i1 %.not610, label %379, label %388

379:                                              ; preds = %376
  %380 = xor i32 %374, -1
  %381 = zext nneg i32 %380 to i64
  %382 = icmp ugt i64 %indvars.iv755, %381
  br i1 %382, label %383, label %388

383:                                              ; preds = %379
  %384 = getelementptr inbounds i64, ptr %363, i64 %381
  %385 = load i64, ptr %384, align 8, !tbaa !24
  store i64 %385, ptr %377, align 8, !tbaa !24
  %386 = getelementptr inbounds i32, ptr %371, i64 %381
  %387 = load i32, ptr %386, align 4, !tbaa !14
  store i32 %387, ptr %373, align 4, !tbaa !14
  br label %388

388:                                              ; preds = %379, %383, %376, %.lr.ph699
  %indvars.iv.next756 = add nuw nsw i64 %indvars.iv755, 1
  %exitcond759.not = icmp eq i64 %indvars.iv.next756, %364
  br i1 %exitcond759.not, label %._crit_edge700, label %.lr.ph699, !llvm.loop !46

._crit_edge700:                                   ; preds = %388, %.loopexit665
  %389 = load i8, ptr %55, align 8
  %390 = or i8 %389, 1
  store i8 %390, ptr %55, align 8
  br label %391

391:                                              ; preds = %61, %._crit_edge700
  %392 = zext i32 %2 to i64
  %393 = getelementptr inbounds i8, ptr %0, i64 512
  %394 = load i64, ptr %393, align 8, !tbaa !30
  %395 = icmp ult i64 %394, %392
  br i1 %395, label %.loopexit669, label %396

396:                                              ; preds = %391
  %397 = getelementptr inbounds i8, ptr %0, i64 464
  %398 = getelementptr inbounds i8, ptr %0, i64 496
  %399 = load ptr, ptr %398, align 8, !tbaa !33
  %400 = getelementptr inbounds i64, ptr %399, i64 %25
  %401 = load i64, ptr %400, align 8, !tbaa !24
  %.not611 = icmp eq i64 %401, 0
  br i1 %.not611, label %402, label %.thread780

402:                                              ; preds = %396
  %403 = call ptr @fstExtractRvatDataFromFrame(ptr noundef nonnull %0, i32 noundef %24, ptr noundef nonnull %3)
  br label %.loopexit669

.thread780:                                       ; preds = %396
  %404 = getelementptr inbounds i8, ptr %0, i64 496
  %405 = getelementptr inbounds i8, ptr %0, i64 552
  %406 = load i32, ptr %405, align 8, !tbaa !47
  %.not613 = icmp eq i32 %24, %406
  %.phi.trans.insert775 = getelementptr inbounds i8, ptr %0, i64 544
  %.pre776 = load ptr, ptr %.phi.trans.insert775, align 8, !tbaa !48
  br i1 %.not613, label %413, label %407

407:                                              ; preds = %.thread780
  %.not614 = icmp eq ptr %.pre776, null
  br i1 %.not614, label %.thread782, label %408

408:                                              ; preds = %407
  call void @free(ptr noundef nonnull %.pre776) #10
  store ptr null, ptr %.phi.trans.insert775, align 8, !tbaa !48
  %409 = getelementptr inbounds i8, ptr %0, i64 576
  %410 = load i8, ptr %409, align 8
  %411 = and i8 %410, -2
  store i8 %411, ptr %409, align 8
  br label %.thread782

.thread782:                                       ; preds = %407, %408
  %412 = getelementptr inbounds i8, ptr %0, i64 544
  br label %415

413:                                              ; preds = %.thread780
  %414 = getelementptr inbounds i8, ptr %0, i64 544
  %.not615 = icmp eq ptr %.pre776, null
  br i1 %.not615, label %415, label %471

415:                                              ; preds = %.thread782, %413
  %416 = phi ptr [ %412, %.thread782 ], [ %414, %413 ]
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %10) #10
  %417 = load ptr, ptr %0, align 8, !tbaa !22
  %418 = getelementptr inbounds i8, ptr %0, i64 520
  %419 = load i64, ptr %418, align 8, !tbaa !31
  %420 = load ptr, ptr %404, align 8, !tbaa !33
  %421 = getelementptr inbounds i64, ptr %420, i64 %25
  %422 = load i64, ptr %421, align 8, !tbaa !24
  %423 = add nsw i64 %422, %419
  %424 = call i32 @fstReaderFseeko(ptr noundef nonnull %0, ptr noundef %417, i64 noundef %423, i32 noundef 0)
  %425 = load ptr, ptr %0, align 8, !tbaa !22
  %426 = call i32 @fstReaderVarint32WithSkip(ptr noundef %425, ptr noundef nonnull %10)
  %427 = getelementptr inbounds i8, ptr %0, i64 540
  store i32 %426, ptr %427, align 4, !tbaa !49
  %.not616 = icmp eq i32 %426, 0
  br i1 %.not616, label %458, label %428

428:                                              ; preds = %415
  %429 = zext i32 %426 to i64
  %430 = call noalias ptr @malloc(i64 noundef %429) #11
  %431 = getelementptr inbounds i8, ptr %0, i64 504
  %432 = load ptr, ptr %431, align 8, !tbaa !34
  %433 = getelementptr inbounds i32, ptr %432, i64 %25
  %434 = load i32, ptr %433, align 4, !tbaa !14
  %435 = zext i32 %434 to i64
  %436 = call noalias ptr @malloc(i64 noundef %435) #11
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %11) #10
  store i64 %429, ptr %11, align 8, !tbaa !24
  %437 = load ptr, ptr %0, align 8, !tbaa !22
  %438 = call i64 @fstFread(ptr noundef %436, i64 noundef %435, i64 noundef 1, ptr noundef %437)
  %439 = getelementptr inbounds i8, ptr %0, i64 536
  %440 = load i32, ptr %439, align 8, !tbaa !32
  switch i32 %440, label %451 [
    i32 52, label %441
    i32 70, label %447
  ]

441:                                              ; preds = %428
  %442 = load i64, ptr %11, align 8, !tbaa !24
  %443 = trunc i64 %442 to i32
  %444 = call i32 @LZ4_decompress_safe_partial(ptr noundef %436, ptr noundef %430, i32 noundef %434, i32 noundef %443, i32 noundef %443) #10
  %445 = sext i32 %444 to i64
  %446 = icmp eq i64 %442, %445
  br i1 %446, label %.thread, label %.thread636

.thread636:                                       ; preds = %441
  call void @free(ptr noundef %436) #10
  br label %453

447:                                              ; preds = %428
  %448 = load i64, ptr %11, align 8, !tbaa !24
  %449 = trunc i64 %448 to i32
  %450 = call i32 @fastlz_decompress(ptr noundef %436, i32 noundef %434, ptr noundef %430, i32 noundef %449) #10
  br label %.thread

.thread:                                          ; preds = %447, %441
  call void @free(ptr noundef %436) #10
  br label %457

451:                                              ; preds = %428
  %452 = call i32 @uncompress(ptr noundef %430, ptr noundef nonnull %11, ptr noundef %436, i64 noundef %435) #10
  call void @free(ptr noundef %436) #10
  %.not617 = icmp eq i32 %452, 0
  br i1 %.not617, label %457, label %453

453:                                              ; preds = %.thread636, %451
  %.0531639 = phi i32 [ -3, %.thread636 ], [ %452, %451 ]
  %454 = load ptr, ptr @stderr, align 8, !tbaa !25
  %455 = load i32, ptr %427, align 4, !tbaa !49
  %456 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %454, ptr noundef nonnull @.str.59, i32 noundef %455, i32 noundef %.0531639) #12
  call void @exit(i32 noundef 255) #13
  unreachable

457:                                              ; preds = %.thread, %451
  store ptr %430, ptr %416, align 8, !tbaa !48
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %11) #10
  br label %470

458:                                              ; preds = %415
  %459 = getelementptr inbounds i8, ptr %0, i64 504
  %460 = load ptr, ptr %459, align 8, !tbaa !34
  %461 = getelementptr inbounds i32, ptr %460, i64 %25
  %462 = load i32, ptr %461, align 4, !tbaa !14
  %463 = load i32, ptr %10, align 4, !tbaa !14
  %464 = sub i32 %462, %463
  store i32 %464, ptr %427, align 4, !tbaa !49
  %465 = zext i32 %464 to i64
  %466 = call noalias ptr @malloc(i64 noundef %465) #11
  %467 = sext i32 %464 to i64
  %468 = load ptr, ptr %0, align 8, !tbaa !22
  %469 = call i64 @fstFread(ptr noundef %466, i64 noundef %467, i64 noundef 1, ptr noundef %468)
  store ptr %466, ptr %416, align 8, !tbaa !48
  br label %470

470:                                              ; preds = %458, %457
  store i32 %24, ptr %405, align 8, !tbaa !47
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %10) #10
  br label %471

471:                                              ; preds = %470, %413
  %472 = phi ptr [ %416, %470 ], [ %414, %413 ]
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %12) #10
  %473 = getelementptr inbounds i8, ptr %0, i64 540
  %474 = load i32, ptr %473, align 4, !tbaa !49
  %475 = getelementptr inbounds i8, ptr %0, i64 576
  %476 = load i8, ptr %475, align 8
  %477 = and i8 %476, 1
  %.not618 = icmp eq i8 %477, 0
  br i1 %.not618, label %486, label %478

478:                                              ; preds = %471
  %479 = getelementptr inbounds i8, ptr %0, i64 568
  %480 = load i64, ptr %479, align 8, !tbaa !50
  %.not619 = icmp ugt i64 %480, %1
  br i1 %.not619, label %486, label %481

481:                                              ; preds = %478
  %482 = getelementptr inbounds i8, ptr %0, i64 560
  %483 = load i32, ptr %482, align 8, !tbaa !51
  %484 = getelementptr inbounds i8, ptr %0, i64 556
  %485 = load i32, ptr %484, align 4, !tbaa !52
  br label %489

486:                                              ; preds = %478, %471
  %487 = load i64, ptr %397, align 8, !tbaa !20
  %488 = getelementptr inbounds i8, ptr %0, i64 568
  store i64 %487, ptr %488, align 8, !tbaa !50
  br label %489

489:                                              ; preds = %486, %481
  %.4542 = phi i32 [ %483, %481 ], [ 0, %486 ]
  %.0517 = phi i32 [ %485, %481 ], [ 0, %486 ]
  %490 = load ptr, ptr %22, align 8, !tbaa !13
  %491 = getelementptr inbounds i32, ptr %490, i64 %25
  %492 = load i32, ptr %491, align 4, !tbaa !14
  %493 = icmp eq i32 %492, 1
  %494 = icmp ult i32 %.4542, %474
  br i1 %493, label %.preheader, label %.preheader662

.preheader662:                                    ; preds = %489
  br i1 %494, label %.lr.ph707, label %.thread648.thread

.lr.ph707:                                        ; preds = %.preheader662
  %495 = getelementptr inbounds i8, ptr %0, i64 456
  %496 = load ptr, ptr %472, align 8, !tbaa !48
  %497 = zext i32 %.4542 to i64
  %498 = getelementptr inbounds i8, ptr %496, i64 %497
  %499 = call i32 @fstGetVarint32(ptr noundef %498, ptr noundef nonnull %12)
  %500 = lshr i32 %499, 1
  %501 = load ptr, ptr %495, align 8, !tbaa !26
  %502 = add i32 %500, %.0517
  %503 = zext i32 %502 to i64
  %504 = getelementptr inbounds i64, ptr %501, i64 %503
  %505 = load i64, ptr %504, align 8, !tbaa !24
  %.not620830 = icmp ugt i64 %505, %1
  br i1 %.not620830, label %..thread648.loopexit_crit_edge, label %.lr.ph833

.preheader:                                       ; preds = %489
  br i1 %494, label %.lr.ph728, label %.thread640.thread

.lr.ph728:                                        ; preds = %.preheader
  %506 = getelementptr inbounds i8, ptr %0, i64 456
  %507 = load ptr, ptr %472, align 8, !tbaa !48
  %508 = zext i32 %.4542 to i64
  %509 = getelementptr inbounds i8, ptr %507, i64 %508
  %510 = call i32 @fstGetVarint32(ptr noundef %509, ptr noundef nonnull %12)
  %511 = and i32 %510, 1
  %512 = shl nuw nsw i32 2, %511
  %513 = lshr i32 %510, %512
  %514 = load ptr, ptr %506, align 8, !tbaa !26
  %515 = add i32 %513, %.0517
  %516 = zext i32 %515 to i64
  %517 = getelementptr inbounds i64, ptr %514, i64 %516
  %518 = load i64, ptr %517, align 8, !tbaa !24
  %.not627837 = icmp ugt i64 %518, %1
  %.pre778.pre838 = load i32, ptr %473, align 4, !tbaa !49
  br i1 %.not627837, label %.thread640, label %.lr.ph842

519:                                              ; preds = %.lr.ph842
  %520 = load ptr, ptr %472, align 8, !tbaa !48
  %521 = zext i32 %535 to i64
  %522 = getelementptr inbounds i8, ptr %520, i64 %521
  %523 = call i32 @fstGetVarint32(ptr noundef %522, ptr noundef nonnull %12)
  %524 = and i32 %523, 1
  %525 = shl nuw nsw i32 2, %524
  %526 = lshr i32 %523, %525
  %527 = load ptr, ptr %506, align 8, !tbaa !26
  %528 = add i32 %526, %532
  %529 = zext i32 %528 to i64
  %530 = getelementptr inbounds i64, ptr %527, i64 %529
  %531 = load i64, ptr %530, align 8, !tbaa !24
  %.not627 = icmp ugt i64 %531, %1
  %.pre778.pre = load i32, ptr %473, align 4, !tbaa !49
  br i1 %.not627, label %.thread640, label %.lr.ph842

.lr.ph842:                                        ; preds = %.lr.ph728, %519
  %.pre778.pre841 = phi i32 [ %.pre778.pre, %519 ], [ %.pre778.pre838, %.lr.ph728 ]
  %532 = phi i32 [ %528, %519 ], [ %515, %.lr.ph728 ]
  %533 = phi i32 [ %523, %519 ], [ %510, %.lr.ph728 ]
  %.5543723840 = phi i32 [ %535, %519 ], [ %.4542, %.lr.ph728 ]
  %.1518724839 = phi i32 [ %532, %519 ], [ %.0517, %.lr.ph728 ]
  %534 = load i32, ptr %12, align 4, !tbaa !14
  %535 = add i32 %534, %.5543723840
  %536 = icmp ult i32 %535, %.pre778.pre841
  br i1 %536, label %519, label %.thread640

.thread640:                                       ; preds = %519, %.lr.ph842, %.lr.ph728
  %.pre778.pre.lcssa = phi i32 [ %.pre778.pre838, %.lr.ph728 ], [ %.pre778.pre, %519 ], [ %.pre778.pre841, %.lr.ph842 ]
  %.0511.lcssa = phi i32 [ 0, %.lr.ph728 ], [ %.1518724839, %.lr.ph842 ], [ %.1518724839, %519 ]
  %.0505.lcssa = phi i32 [ %474, %.lr.ph728 ], [ %.5543723840, %.lr.ph842 ], [ %.5543723840, %519 ]
  %.0502.lcssa = phi i32 [ 0, %.lr.ph728 ], [ %533, %.lr.ph842 ], [ %533, %519 ]
  %.not628 = icmp eq i32 %.0505.lcssa, %.pre778.pre.lcssa
  br i1 %.not628, label %.thread640.thread, label %537

537:                                              ; preds = %.thread640
  %538 = getelementptr inbounds i8, ptr %0, i64 556
  store i32 %.0511.lcssa, ptr %538, align 4, !tbaa !52
  %539 = getelementptr inbounds i8, ptr %0, i64 560
  store i32 %.0505.lcssa, ptr %539, align 8, !tbaa !51
  %540 = getelementptr inbounds i8, ptr %0, i64 568
  store i64 %1, ptr %540, align 8, !tbaa !50
  %541 = load i8, ptr %475, align 8
  %542 = or i8 %541, 1
  store i8 %542, ptr %475, align 8
  %543 = and i32 %.0502.lcssa, 1
  %.not629 = icmp eq i32 %543, 0
  br i1 %.not629, label %544, label %549

544:                                              ; preds = %537
  %545 = trunc i32 %.0502.lcssa to i8
  %546 = lshr exact i8 %545, 1
  %547 = and i8 %546, 1
  %548 = or disjoint i8 %547, 48
  br label %555

549:                                              ; preds = %537
  %550 = lshr i32 %.0502.lcssa, 1
  %551 = and i32 %550, 7
  %552 = zext nneg i32 %551 to i64
  %553 = getelementptr inbounds [9 x i8], ptr @.str.55, i64 0, i64 %552
  %554 = load i8, ptr %553, align 1, !tbaa !35
  br label %555

555:                                              ; preds = %549, %544
  %storemerge = phi i8 [ %548, %544 ], [ %554, %549 ]
  store i8 %storemerge, ptr %3, align 1, !tbaa !35
  %556 = getelementptr inbounds i8, ptr %3, i64 1
  store i8 0, ptr %556, align 1, !tbaa !35
  br label %674

.thread640.thread:                                ; preds = %.preheader, %.thread640
  %557 = call ptr @fstExtractRvatDataFromFrame(ptr noundef nonnull %0, i32 noundef %24, ptr noundef nonnull %3)
  br label %674

558:                                              ; preds = %.lr.ph833
  %559 = load ptr, ptr %472, align 8, !tbaa !48
  %560 = zext i32 %.8 to i64
  %561 = getelementptr inbounds i8, ptr %559, i64 %560
  %562 = call i32 @fstGetVarint32(ptr noundef %561, ptr noundef nonnull %12)
  %563 = lshr i32 %562, 1
  %564 = load ptr, ptr %495, align 8, !tbaa !26
  %565 = add i32 %563, %569
  %566 = zext i32 %565 to i64
  %567 = getelementptr inbounds i64, ptr %564, i64 %566
  %568 = load i64, ptr %567, align 8, !tbaa !24
  %.not620 = icmp ugt i64 %568, %1
  br i1 %.not620, label %..thread648.loopexit_crit_edge, label %.lr.ph833

..thread648.loopexit_crit_edge:                   ; preds = %558, %.lr.ph707
  %.0499706.lcssa = phi i32 [ 0, %.lr.ph707 ], [ %571, %558 ]
  %.3705.lcssa = phi i32 [ 0, %.lr.ph707 ], [ %570, %558 ]
  %.3508704.lcssa = phi i32 [ %474, %.lr.ph707 ], [ %.7545701832, %558 ]
  %.3514703.lcssa = phi i32 [ 0, %.lr.ph707 ], [ %.3520702831, %558 ]
  %.pre777.pre = load i32, ptr %473, align 4, !tbaa !49
  br label %.thread648

.lr.ph833:                                        ; preds = %.lr.ph707, %558
  %569 = phi i32 [ %565, %558 ], [ %502, %.lr.ph707 ]
  %570 = phi i32 [ %562, %558 ], [ %499, %.lr.ph707 ]
  %.7545701832 = phi i32 [ %.8, %558 ], [ %.4542, %.lr.ph707 ]
  %.3520702831 = phi i32 [ %569, %558 ], [ %.0517, %.lr.ph707 ]
  %571 = load i32, ptr %12, align 4, !tbaa !14
  %572 = add i32 %571, %.7545701832
  %573 = and i32 %570, 1
  %.not621 = icmp eq i32 %573, 0
  %574 = load ptr, ptr %22, align 8, !tbaa !13
  %575 = getelementptr inbounds i32, ptr %574, i64 %25
  %576 = load i32, ptr %575, align 4, !tbaa !14
  %577 = add i32 %576, 7
  %578 = lshr i32 %577, 3
  %.pn = select i1 %.not621, i32 %578, i32 %576
  %.8 = add i32 %572, %.pn
  %579 = load i32, ptr %473, align 4, !tbaa !49
  %580 = icmp ult i32 %.8, %579
  br i1 %580, label %558, label %.thread648

.thread648:                                       ; preds = %.lr.ph833, %..thread648.loopexit_crit_edge
  %.pre777 = phi i32 [ %.pre777.pre, %..thread648.loopexit_crit_edge ], [ %579, %.lr.ph833 ]
  %.3514.lcssa.ph = phi i32 [ %.3514703.lcssa, %..thread648.loopexit_crit_edge ], [ %.3520702831, %.lr.ph833 ]
  %.3508.lcssa.ph = phi i32 [ %.3508704.lcssa, %..thread648.loopexit_crit_edge ], [ %.7545701832, %.lr.ph833 ]
  %.3.lcssa.ph = phi i32 [ %.3705.lcssa, %..thread648.loopexit_crit_edge ], [ %570, %.lr.ph833 ]
  %.0499.lcssa.ph = phi i32 [ %.0499706.lcssa, %..thread648.loopexit_crit_edge ], [ %571, %.lr.ph833 ]
  %581 = and i32 %.3.lcssa.ph, 1
  %582 = icmp eq i32 %581, 0
  %.not622 = icmp eq i32 %.3508.lcssa.ph, %.pre777
  br i1 %.not622, label %.thread648.thread, label %583

583:                                              ; preds = %.thread648
  %584 = sext i32 %.0499.lcssa.ph to i64
  %585 = load ptr, ptr %472, align 8, !tbaa !48
  %586 = zext i32 %.3508.lcssa.ph to i64
  %587 = getelementptr inbounds i8, ptr %585, i64 %586
  %588 = getelementptr inbounds i8, ptr %587, i64 %584
  %589 = getelementptr inbounds i8, ptr %0, i64 556
  store i32 %.3514.lcssa.ph, ptr %589, align 4, !tbaa !52
  %590 = getelementptr inbounds i8, ptr %0, i64 560
  store i32 %.3508.lcssa.ph, ptr %590, align 8, !tbaa !51
  %591 = getelementptr inbounds i8, ptr %0, i64 568
  store i64 %1, ptr %591, align 8, !tbaa !50
  %592 = load i8, ptr %475, align 8
  %593 = or i8 %592, 1
  store i8 %593, ptr %475, align 8
  %594 = getelementptr inbounds i8, ptr %0, i64 88
  %595 = load ptr, ptr %594, align 8, !tbaa !53
  %596 = getelementptr inbounds i8, ptr %595, i64 %25
  %597 = load i8, ptr %596, align 1, !tbaa !35
  %.not623 = icmp eq i8 %597, 3
  br i1 %.not623, label %625, label %598

598:                                              ; preds = %583
  %599 = load ptr, ptr %22, align 8, !tbaa !13
  %600 = getelementptr inbounds i32, ptr %599, i64 %25
  %601 = load i32, ptr %600, align 4, !tbaa !14
  br i1 %582, label %.preheader661, label %618

.preheader661:                                    ; preds = %598
  %.not741 = icmp eq i32 %601, 0
  br i1 %.not741, label %._crit_edge719, label %.lr.ph718

.lr.ph718:                                        ; preds = %.preheader661, %.lr.ph718
  %indvars.iv760 = phi i64 [ %indvars.iv.next761, %.lr.ph718 ], [ 0, %.preheader661 ]
  %602 = trunc i64 %indvars.iv760 to i8
  %603 = lshr i64 %indvars.iv760, 3
  %604 = and i8 %602, 7
  %605 = xor i8 %604, 7
  %606 = getelementptr inbounds i8, ptr %588, i64 %603
  %607 = load i8, ptr %606, align 1, !tbaa !35
  %608 = lshr i8 %607, %605
  %609 = and i8 %608, 1
  %610 = or disjoint i8 %609, 48
  %611 = getelementptr inbounds i8, ptr %3, i64 %indvars.iv760
  store i8 %610, ptr %611, align 1, !tbaa !35
  %indvars.iv.next761 = add nuw nsw i64 %indvars.iv760, 1
  %612 = load ptr, ptr %22, align 8, !tbaa !13
  %613 = getelementptr inbounds i32, ptr %612, i64 %25
  %614 = load i32, ptr %613, align 4, !tbaa !14
  %615 = zext i32 %614 to i64
  %616 = icmp ult i64 %indvars.iv.next761, %615
  br i1 %616, label %.lr.ph718, label %._crit_edge719, !llvm.loop !54

._crit_edge719:                                   ; preds = %.lr.ph718, %.preheader661
  %.0494.lcssa = phi i64 [ 0, %.preheader661 ], [ %indvars.iv.next761, %.lr.ph718 ]
  %617 = getelementptr inbounds i8, ptr %3, i64 %.0494.lcssa
  store i8 0, ptr %617, align 1, !tbaa !35
  br label %674

618:                                              ; preds = %598
  %619 = zext i32 %601 to i64
  call void @llvm.memcpy.p0.p0.i64(ptr nonnull align 1 %3, ptr align 1 %588, i64 %619, i1 false)
  %620 = load ptr, ptr %22, align 8, !tbaa !13
  %621 = getelementptr inbounds i32, ptr %620, i64 %25
  %622 = load i32, ptr %621, align 4, !tbaa !14
  %623 = zext i32 %622 to i64
  %624 = getelementptr inbounds i8, ptr %3, i64 %623
  store i8 0, ptr %624, align 1, !tbaa !35
  br label %674

625:                                              ; preds = %583
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %13) #10
  br i1 %582, label %.preheader659, label %.loopexit660

.preheader659:                                    ; preds = %625
  %626 = load i8, ptr %588, align 1, !tbaa !35
  %627 = lshr i8 %626, 7
  %628 = or disjoint i8 %627, 48
  store i8 %628, ptr %13, align 1, !tbaa !35
  %629 = lshr i8 %626, 6
  %630 = and i8 %629, 1
  %631 = or disjoint i8 %630, 48
  %632 = getelementptr inbounds i8, ptr %13, i64 1
  store i8 %631, ptr %632, align 1, !tbaa !35
  %633 = lshr i8 %626, 5
  %634 = and i8 %633, 1
  %635 = or disjoint i8 %634, 48
  %636 = getelementptr inbounds i8, ptr %13, i64 2
  store i8 %635, ptr %636, align 1, !tbaa !35
  %637 = lshr i8 %626, 4
  %638 = and i8 %637, 1
  %639 = or disjoint i8 %638, 48
  %640 = getelementptr inbounds i8, ptr %13, i64 3
  store i8 %639, ptr %640, align 1, !tbaa !35
  %641 = lshr i8 %626, 3
  %642 = getelementptr inbounds i8, ptr %13, i64 4
  %643 = lshr i8 %626, 2
  %644 = lshr i8 %626, 1
  %645 = insertelement <4 x i8> poison, i8 %641, i64 0
  %646 = insertelement <4 x i8> %645, i8 %643, i64 1
  %647 = insertelement <4 x i8> %646, i8 %644, i64 2
  %648 = insertelement <4 x i8> %647, i8 %626, i64 3
  %649 = and <4 x i8> %648, <i8 1, i8 1, i8 1, i8 1>
  %650 = or disjoint <4 x i8> %649, <i8 48, i8 48, i8 48, i8 48>
  store <4 x i8> %650, ptr %642, align 1, !tbaa !35
  br label %.loopexit660

.loopexit660:                                     ; preds = %.preheader659, %625
  %.0488 = phi ptr [ %588, %625 ], [ %13, %.preheader659 ]
  %651 = getelementptr inbounds i8, ptr %0, i64 122
  %652 = load i8, ptr %651, align 2
  %653 = and i8 %652, 2
  %.not625 = icmp eq i8 %653, 0
  br i1 %.not625, label %.preheader658.preheader, label %670

.preheader658.preheader:                          ; preds = %.loopexit660
  %654 = getelementptr inbounds i8, ptr %.0488, i64 7
  %655 = load i8, ptr %654, align 1, !tbaa !35
  %.0.insert.ext = zext i8 %655 to i64
  %656 = getelementptr inbounds i8, ptr %.0488, i64 6
  %657 = load i8, ptr %656, align 1, !tbaa !35
  %.1.insert.ext = zext i8 %657 to i64
  %.1.insert.shift = shl nuw nsw i64 %.1.insert.ext, 8
  %.1.insert.insert = or disjoint i64 %.1.insert.shift, %.0.insert.ext
  %658 = getelementptr inbounds i8, ptr %.0488, i64 5
  %659 = load i8, ptr %658, align 1, !tbaa !35
  %.2.insert.ext = zext i8 %659 to i64
  %.2.insert.shift = shl nuw nsw i64 %.2.insert.ext, 16
  %.2.insert.insert = or disjoint i64 %.1.insert.insert, %.2.insert.shift
  %660 = getelementptr inbounds i8, ptr %.0488, i64 4
  %661 = load i8, ptr %660, align 1, !tbaa !35
  %.3.insert.ext = zext i8 %661 to i64
  %.3.insert.shift = shl nuw nsw i64 %.3.insert.ext, 24
  %.3.insert.insert = or disjoint i64 %.2.insert.insert, %.3.insert.shift
  %662 = getelementptr inbounds i8, ptr %.0488, i64 3
  %663 = load i8, ptr %662, align 1, !tbaa !35
  %.4.insert.ext = zext i8 %663 to i64
  %.4.insert.shift = shl nuw nsw i64 %.4.insert.ext, 32
  %664 = getelementptr inbounds i8, ptr %.0488, i64 2
  %665 = load i8, ptr %664, align 1, !tbaa !35
  %.5.insert.ext = zext i8 %665 to i64
  %.5.insert.shift = shl nuw nsw i64 %.5.insert.ext, 40
  %.5.insert.mask = or disjoint i64 %.3.insert.insert, %.4.insert.shift
  %666 = getelementptr inbounds i8, ptr %.0488, i64 1
  %667 = load i8, ptr %666, align 1, !tbaa !35
  %.6.insert.ext = zext i8 %667 to i64
  %.6.insert.shift = shl nuw nsw i64 %.6.insert.ext, 48
  %668 = load i8, ptr %.0488, align 1, !tbaa !35
  %.7.insert.ext = zext i8 %668 to i64
  %.7.insert.shift = shl nuw i64 %.7.insert.ext, 56
  %.6.insert.mask.masked = or i64 %.5.insert.mask, %.5.insert.shift
  %.7.insert.mask = or i64 %.6.insert.mask.masked, %.6.insert.shift
  %.7.insert.insert = or i64 %.7.insert.mask, %.7.insert.shift
  %669 = bitcast i64 %.7.insert.insert to double
  br label %.loopexit

670:                                              ; preds = %.loopexit660
  %671 = load double, ptr %.0488, align 1
  br label %.loopexit

.loopexit:                                        ; preds = %.preheader658.preheader, %670
  %.0 = phi double [ %669, %.preheader658.preheader ], [ %671, %670 ]
  %672 = call i32 (ptr, i64, ptr, ...) @snprintf(ptr noundef nonnull dereferenceable(1) %3, i64 noundef 32, ptr noundef nonnull @.str.56, double noundef %.0) #10
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %13) #10
  br label %674

.thread648.thread:                                ; preds = %.preheader662, %.thread648
  %673 = call ptr @fstExtractRvatDataFromFrame(ptr noundef nonnull %0, i32 noundef %24, ptr noundef nonnull %3)
  br label %674

674:                                              ; preds = %._crit_edge719, %618, %.loopexit, %.thread648.thread, %.thread640.thread, %555
  %.1 = phi ptr [ %3, %555 ], [ %557, %.thread640.thread ], [ %673, %.thread648.thread ], [ %3, %.loopexit ], [ %3, %618 ], [ %3, %._crit_edge719 ]
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %12) #10
  br label %.loopexit669

.loopexit669:                                     ; preds = %switch.early.test, %switch.early.test, %.backedge, %65, %391, %4, %16, %21, %674, %402
  %.2 = phi ptr [ %.1, %674 ], [ %403, %402 ], [ null, %21 ], [ null, %16 ], [ null, %4 ], [ null, %391 ], [ null, %65 ], [ null, %.backedge ], [ null, %switch.early.test ], [ null, %switch.early.test ]
  ret ptr %.2
}

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

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { mustprogress nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" "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 = { mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" "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 = { mustprogress nocallback nofree nounwind willreturn memory(argmem: readwrite) }
attributes #4 = { mustprogress nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" "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 #5 = { nofree 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 #6 = { 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 #7 = { 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 #8 = { "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 #9 = { nounwind allocsize(0,1) }
attributes #10 = { nounwind }
attributes #11 = { nounwind allocsize(0) }
attributes #12 = { cold nounwind }
attributes #13 = { 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, !11, i64 56}
!6 = !{!"fstReaderContext", !7, i64 0, !7, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !11, i64 56, !10, i64 64, !10, i64 72, !7, i64 80, !7, i64 88, !7, i64 96, !11, i64 104, !7, i64 112, !8, i64 120, !8, i64 121, !11, i64 122, !11, i64 122, !11, i64 122, !11, i64 122, !11, i64 122, !11, i64 122, !11, i64 122, !11, i64 122, !8, i64 123, !8, i64 252, !10, i64 376, !7, i64 384, !7, i64 392, !10, i64 400, !11, i64 408, !7, i64 416, !7, i64 424, !10, i64 432, !10, i64 440, !11, i64 448, !7, i64 456, !10, i64 464, !10, i64 472, !7, i64 480, !10, i64 488, !7, i64 496, !7, i64 504, !10, i64 512, !10, i64 520, !7, i64 528, !11, i64 536, !11, i64 540, !7, i64 544, !11, i64 552, !11, i64 556, !11, i64 560, !10, i64 568, !11, i64 576, !12, i64 584, !7, i64 632, !11, i64 640, !7, i64 648, !11, i64 656, !11, i64 660, !8, i64 661, !8, i64 1174, !7, i64 1688, !11, i64 1696, !11, i64 1700, !11, i64 1704, !8, i64 1708, !7, i64 67248, !7, i64 67256}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"long", !8, i64 0}
!11 = !{!"int", !8, i64 0}
!12 = !{!"fstHier", !8, i64 0, !8, i64 8}
!13 = !{!6, !7, i64 80}
!14 = !{!11, !11, i64 0}
!15 = !{!6, !7, i64 528}
!16 = distinct !{!16, !17}
!17 = !{!"llvm.loop.mustprogress"}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.unroll.disable"}
!20 = !{!6, !10, i64 464}
!21 = !{!6, !10, i64 472}
!22 = !{!6, !7, i64 0}
!23 = !{!6, !10, i64 24}
!24 = !{!10, !10, i64 0}
!25 = !{!7, !7, i64 0}
!26 = !{!6, !7, i64 456}
!27 = distinct !{!27, !17}
!28 = !{!6, !10, i64 488}
!29 = !{!6, !7, i64 480}
!30 = !{!6, !10, i64 512}
!31 = !{!6, !10, i64 520}
!32 = !{!6, !11, i64 536}
!33 = !{!6, !7, i64 496}
!34 = !{!6, !7, i64 504}
!35 = !{!8, !8, i64 0}
!36 = distinct !{!36, !17, !37, !38}
!37 = !{!"llvm.loop.isvectorized", i32 1}
!38 = !{!"llvm.loop.unroll.runtime.disable"}
!39 = distinct !{!39, !19}
!40 = distinct !{!40, !17, !37}
!41 = distinct !{!41, !17}
!42 = distinct !{!42, !17, !37, !38}
!43 = distinct !{!43, !19}
!44 = distinct !{!44, !17, !37}
!45 = distinct !{!45, !17}
!46 = distinct !{!46, !17}
!47 = !{!6, !11, i64 552}
!48 = !{!6, !7, i64 544}
!49 = !{!6, !11, i64 540}
!50 = !{!6, !10, i64 568}
!51 = !{!6, !11, i64 560}
!52 = !{!6, !11, i64 556}
!53 = !{!6, !7, i64 88}
!54 = distinct !{!54, !17}


; Effective O3 passes: BDCEPass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopLoadEliminationPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,LoopVectorizePass,ReassociatePass,SCCPPass,SLPVectorizerPass,SROAPass,SimplifyCFGPass,TailCallElimPass