; LLVM IR from caryll/otfcc :: lib/table/otl/subtables/chaining (classifier)

; 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._otl_lookup = type { ptr, i32, i32, i16, %struct.otl_SubtableList }
%struct.otl_SubtableList = type { i64, i64, ptr }
%struct.subtable_chaining = type { i32, %union.anon }
%union.anon = type { %struct.anon }
%struct.anon = type { i16, ptr, ptr, ptr, ptr }
%struct.otl_ChainingRule = type { i16, i16, i16, ptr, i16, ptr }
%struct.classifier_hash = type { i32, ptr, i32, %struct.UT_hash_handle }
%struct.UT_hash_handle = type { ptr, ptr, ptr, ptr, ptr, ptr, i32, i32 }
%struct.UT_hash_table = type { ptr, i32, i32, i32, ptr, i64, i32, i32, i32, i32, i32 }
%struct.UT_hash_bucket = type { ptr, i32, i32 }

; Function Attrs: nounwind uwtable
define dso_local zeroext i16 @tryClassifyAround(ptr noundef %0, i16 noundef zeroext %1, ptr noundef %2) #0 {
  %4 = alloca i16, align 2
  %5 = alloca ptr, align 8
  %6 = alloca i16, align 2
  %7 = alloca ptr, align 8
  %8 = alloca i16, align 2
  %9 = alloca ptr, align 8
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca ptr, align 8
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca ptr, align 8
  %17 = alloca i16, align 2
  %18 = alloca i32, align 4
  %19 = alloca i32, align 4
  %20 = alloca i16, align 2
  %21 = alloca ptr, align 8
  %22 = alloca i8, align 1
  %23 = alloca i16, align 2
  %24 = alloca i32, align 4
  %25 = alloca i16, align 2
  %26 = alloca i16, align 2
  %27 = alloca ptr, align 8
  %28 = alloca ptr, align 8
  %29 = alloca ptr, align 8
  %30 = alloca ptr, align 8
  %31 = alloca i32, align 4
  %32 = alloca ptr, align 8
  %33 = alloca ptr, align 8
  %34 = alloca ptr, align 8
  %35 = alloca ptr, align 8
  %36 = alloca i32, align 4
  %37 = alloca ptr, align 8
  %38 = alloca ptr, align 8
  %39 = alloca ptr, align 8
  %40 = alloca ptr, align 8
  %41 = alloca i32, align 4
  %42 = alloca ptr, align 8
  store ptr %0, ptr %5, align 8, !tbaa !5
  store i16 %1, ptr %6, align 2, !tbaa !9
  store ptr %2, ptr %7, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2, ptr %8) #4
  store i16 0, ptr %8, align 2, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #4
  store ptr null, ptr %9, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #4
  store ptr null, ptr %10, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #4
  store ptr null, ptr %11, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #4
  %43 = load ptr, ptr %5, align 8, !tbaa !5
  %44 = getelementptr inbounds %struct._otl_lookup, ptr %43, i32 0, i32 4
  %45 = getelementptr inbounds %struct.otl_SubtableList, ptr %44, i32 0, i32 2
  %46 = load ptr, ptr %45, align 8, !tbaa !11
  %47 = load i16, ptr %6, align 2, !tbaa !9
  %48 = zext i16 %47 to i64
  %49 = getelementptr inbounds ptr, ptr %46, i64 %48
  %50 = load ptr, ptr %49, align 8, !tbaa !5
  store ptr %50, ptr %12, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #4
  store i32 0, ptr %13, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #4
  store i32 0, ptr %14, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #4
  store i32 0, ptr %15, align 4, !tbaa !16
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #4
  %51 = load ptr, ptr %12, align 8, !tbaa !5
  %52 = getelementptr inbounds %struct.subtable_chaining, ptr %51, i32 0, i32 1
  store ptr %52, ptr %16, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2, ptr %17) #4
  store i16 0, ptr %17, align 2, !tbaa !9
  br label %53

53:                                               ; preds = %114, %3
  %54 = load i16, ptr %17, align 2, !tbaa !9
  %55 = zext i16 %54 to i32
  %56 = load ptr, ptr %16, align 8, !tbaa !5
  %57 = getelementptr inbounds %struct.otl_ChainingRule, ptr %56, i32 0, i32 0
  %58 = load i16, ptr %57, align 8, !tbaa !17
  %59 = zext i16 %58 to i32
  %60 = icmp slt i32 %55, %59
  br i1 %60, label %62, label %61

61:                                               ; preds = %53
  store i32 2, ptr %18, align 4
  br label %117

62:                                               ; preds = %53
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #4
  store i32 0, ptr %19, align 4, !tbaa !16
  %63 = load i16, ptr %17, align 2, !tbaa !9
  %64 = zext i16 %63 to i32
  %65 = load ptr, ptr %16, align 8, !tbaa !5
  %66 = getelementptr inbounds %struct.otl_ChainingRule, ptr %65, i32 0, i32 1
  %67 = load i16, ptr %66, align 2, !tbaa !19
  %68 = zext i16 %67 to i32
  %69 = icmp slt i32 %64, %68
  br i1 %69, label %70, label %79

70:                                               ; preds = %62
  %71 = load ptr, ptr %16, align 8, !tbaa !5
  %72 = getelementptr inbounds %struct.otl_ChainingRule, ptr %71, i32 0, i32 3
  %73 = load ptr, ptr %72, align 8, !tbaa !20
  %74 = load i16, ptr %17, align 2, !tbaa !9
  %75 = zext i16 %74 to i64
  %76 = getelementptr inbounds ptr, ptr %73, i64 %75
  %77 = load ptr, ptr %76, align 8, !tbaa !5
  %78 = call i32 @classCompatible(ptr noundef %9, ptr noundef %77, ptr noundef %13)
  store i32 %78, ptr %19, align 4, !tbaa !16
  br label %106

79:                                               ; preds = %62
  %80 = load i16, ptr %17, align 2, !tbaa !9
  %81 = zext i16 %80 to i32
  %82 = load ptr, ptr %16, align 8, !tbaa !5
  %83 = getelementptr inbounds %struct.otl_ChainingRule, ptr %82, i32 0, i32 2
  %84 = load i16, ptr %83, align 4, !tbaa !21
  %85 = zext i16 %84 to i32
  %86 = icmp slt i32 %81, %85
  br i1 %86, label %87, label %96

87:                                               ; preds = %79
  %88 = load ptr, ptr %16, align 8, !tbaa !5
  %89 = getelementptr inbounds %struct.otl_ChainingRule, ptr %88, i32 0, i32 3
  %90 = load ptr, ptr %89, align 8, !tbaa !20
  %91 = load i16, ptr %17, align 2, !tbaa !9
  %92 = zext i16 %91 to i64
  %93 = getelementptr inbounds ptr, ptr %90, i64 %92
  %94 = load ptr, ptr %93, align 8, !tbaa !5
  %95 = call i32 @classCompatible(ptr noundef %10, ptr noundef %94, ptr noundef %14)
  store i32 %95, ptr %19, align 4, !tbaa !16
  br label %105

96:                                               ; preds = %79
  %97 = load ptr, ptr %16, align 8, !tbaa !5
  %98 = getelementptr inbounds %struct.otl_ChainingRule, ptr %97, i32 0, i32 3
  %99 = load ptr, ptr %98, align 8, !tbaa !20
  %100 = load i16, ptr %17, align 2, !tbaa !9
  %101 = zext i16 %100 to i64
  %102 = getelementptr inbounds ptr, ptr %99, i64 %101
  %103 = load ptr, ptr %102, align 8, !tbaa !5
  %104 = call i32 @classCompatible(ptr noundef %11, ptr noundef %103, ptr noundef %15)
  store i32 %104, ptr %19, align 4, !tbaa !16
  br label %105

105:                                              ; preds = %96, %87
  br label %106

106:                                              ; preds = %105, %70
  %107 = load i32, ptr %19, align 4, !tbaa !16
  %108 = icmp ne i32 %107, 0
  br i1 %108, label %110, label %109

109:                                              ; preds = %106
  store i32 5, ptr %18, align 4
  br label %111

110:                                              ; preds = %106
  store i32 0, ptr %18, align 4
  br label %111

111:                                              ; preds = %110, %109
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #4
  %112 = load i32, ptr %18, align 4
  switch i32 %112, label %117 [
    i32 0, label %113
  ]

113:                                              ; preds = %111
  br label %114

114:                                              ; preds = %113
  %115 = load i16, ptr %17, align 2, !tbaa !9
  %116 = add i16 %115, 1
  store i16 %116, ptr %17, align 2, !tbaa !9
  br label %53, !llvm.loop !22

117:                                              ; preds = %111, %61
  call void @llvm.lifetime.end.p0(i64 2, ptr %17) #4
  %118 = load i32, ptr %18, align 4
  switch i32 %118, label %954 [
    i32 2, label %119
    i32 5, label %326
  ]

119:                                              ; preds = %117
  call void @llvm.lifetime.start.p0(i64 2, ptr %20) #4
  %120 = load i16, ptr %6, align 2, !tbaa !9
  %121 = zext i16 %120 to i32
  %122 = add nsw i32 %121, 1
  %123 = trunc i32 %122 to i16
  store i16 %123, ptr %20, align 2, !tbaa !9
  br label %124

124:                                              ; preds = %221, %119
  %125 = load i16, ptr %20, align 2, !tbaa !9
  %126 = zext i16 %125 to i64
  %127 = load ptr, ptr %5, align 8, !tbaa !5
  %128 = getelementptr inbounds %struct._otl_lookup, ptr %127, i32 0, i32 4
  %129 = getelementptr inbounds %struct.otl_SubtableList, ptr %128, i32 0, i32 0
  %130 = load i64, ptr %129, align 8, !tbaa !24
  %131 = icmp ult i64 %126, %130
  br i1 %131, label %133, label %132

132:                                              ; preds = %124
  store i32 6, ptr %18, align 4
  br label %224

133:                                              ; preds = %124
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #4
  %134 = load ptr, ptr %5, align 8, !tbaa !5
  %135 = getelementptr inbounds %struct._otl_lookup, ptr %134, i32 0, i32 4
  %136 = getelementptr inbounds %struct.otl_SubtableList, ptr %135, i32 0, i32 2
  %137 = load ptr, ptr %136, align 8, !tbaa !11
  %138 = load i16, ptr %20, align 2, !tbaa !9
  %139 = zext i16 %138 to i64
  %140 = getelementptr inbounds ptr, ptr %137, i64 %139
  %141 = load ptr, ptr %140, align 8, !tbaa !5
  %142 = getelementptr inbounds %struct.subtable_chaining, ptr %141, i32 0, i32 1
  store ptr %142, ptr %21, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 1, ptr %22) #4
  store i8 1, ptr %22, align 1, !tbaa !25
  call void @llvm.lifetime.start.p0(i64 2, ptr %23) #4
  store i16 0, ptr %23, align 2, !tbaa !9
  br label %143

143:                                              ; preds = %204, %133
  %144 = load i16, ptr %23, align 2, !tbaa !9
  %145 = zext i16 %144 to i32
  %146 = load ptr, ptr %21, align 8, !tbaa !5
  %147 = getelementptr inbounds %struct.otl_ChainingRule, ptr %146, i32 0, i32 0
  %148 = load i16, ptr %147, align 8, !tbaa !17
  %149 = zext i16 %148 to i32
  %150 = icmp slt i32 %145, %149
  br i1 %150, label %152, label %151

151:                                              ; preds = %143
  store i32 9, ptr %18, align 4
  br label %207

152:                                              ; preds = %143
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #4
  store i32 0, ptr %24, align 4, !tbaa !16
  %153 = load i16, ptr %23, align 2, !tbaa !9
  %154 = zext i16 %153 to i32
  %155 = load ptr, ptr %21, align 8, !tbaa !5
  %156 = getelementptr inbounds %struct.otl_ChainingRule, ptr %155, i32 0, i32 1
  %157 = load i16, ptr %156, align 2, !tbaa !19
  %158 = zext i16 %157 to i32
  %159 = icmp slt i32 %154, %158
  br i1 %159, label %160, label %169

160:                                              ; preds = %152
  %161 = load ptr, ptr %21, align 8, !tbaa !5
  %162 = getelementptr inbounds %struct.otl_ChainingRule, ptr %161, i32 0, i32 3
  %163 = load ptr, ptr %162, align 8, !tbaa !20
  %164 = load i16, ptr %23, align 2, !tbaa !9
  %165 = zext i16 %164 to i64
  %166 = getelementptr inbounds ptr, ptr %163, i64 %165
  %167 = load ptr, ptr %166, align 8, !tbaa !5
  %168 = call i32 @classCompatible(ptr noundef %9, ptr noundef %167, ptr noundef %13)
  store i32 %168, ptr %24, align 4, !tbaa !16
  br label %196

169:                                              ; preds = %152
  %170 = load i16, ptr %23, align 2, !tbaa !9
  %171 = zext i16 %170 to i32
  %172 = load ptr, ptr %21, align 8, !tbaa !5
  %173 = getelementptr inbounds %struct.otl_ChainingRule, ptr %172, i32 0, i32 2
  %174 = load i16, ptr %173, align 4, !tbaa !21
  %175 = zext i16 %174 to i32
  %176 = icmp slt i32 %171, %175
  br i1 %176, label %177, label %186

177:                                              ; preds = %169
  %178 = load ptr, ptr %21, align 8, !tbaa !5
  %179 = getelementptr inbounds %struct.otl_ChainingRule, ptr %178, i32 0, i32 3
  %180 = load ptr, ptr %179, align 8, !tbaa !20
  %181 = load i16, ptr %23, align 2, !tbaa !9
  %182 = zext i16 %181 to i64
  %183 = getelementptr inbounds ptr, ptr %180, i64 %182
  %184 = load ptr, ptr %183, align 8, !tbaa !5
  %185 = call i32 @classCompatible(ptr noundef %10, ptr noundef %184, ptr noundef %14)
  store i32 %185, ptr %24, align 4, !tbaa !16
  br label %195

186:                                              ; preds = %169
  %187 = load ptr, ptr %21, align 8, !tbaa !5
  %188 = getelementptr inbounds %struct.otl_ChainingRule, ptr %187, i32 0, i32 3
  %189 = load ptr, ptr %188, align 8, !tbaa !20
  %190 = load i16, ptr %23, align 2, !tbaa !9
  %191 = zext i16 %190 to i64
  %192 = getelementptr inbounds ptr, ptr %189, i64 %191
  %193 = load ptr, ptr %192, align 8, !tbaa !5
  %194 = call i32 @classCompatible(ptr noundef %11, ptr noundef %193, ptr noundef %15)
  store i32 %194, ptr %24, align 4, !tbaa !16
  br label %195

195:                                              ; preds = %186, %177
  br label %196

196:                                              ; preds = %195, %160
  %197 = load i32, ptr %24, align 4, !tbaa !16
  %198 = icmp ne i32 %197, 0
  br i1 %198, label %200, label %199

199:                                              ; preds = %196
  store i8 0, ptr %22, align 1, !tbaa !25
  store i32 12, ptr %18, align 4
  br label %201

200:                                              ; preds = %196
  store i32 0, ptr %18, align 4
  br label %201

201:                                              ; preds = %200, %199
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #4
  %202 = load i32, ptr %18, align 4
  switch i32 %202, label %207 [
    i32 0, label %203
  ]

203:                                              ; preds = %201
  br label %204

204:                                              ; preds = %203
  %205 = load i16, ptr %23, align 2, !tbaa !9
  %206 = add i16 %205, 1
  store i16 %206, ptr %23, align 2, !tbaa !9
  br label %143, !llvm.loop !27

207:                                              ; preds = %201, %151
  call void @llvm.lifetime.end.p0(i64 2, ptr %23) #4
  %208 = load i32, ptr %18, align 4
  switch i32 %208, label %218 [
    i32 9, label %209
  ]

209:                                              ; preds = %207
  %210 = load i8, ptr %22, align 1, !tbaa !25, !range !28, !noundef !29
  %211 = trunc i8 %210 to i1
  br i1 %211, label %212, label %217

212:                                              ; preds = %209
  %213 = load i16, ptr %8, align 2, !tbaa !9
  %214 = zext i16 %213 to i32
  %215 = add nsw i32 %214, 1
  %216 = trunc i32 %215 to i16
  store i16 %216, ptr %8, align 2, !tbaa !9
  br label %217

217:                                              ; preds = %212, %209
  store i32 0, ptr %18, align 4
  br label %218

218:                                              ; preds = %217, %207
  call void @llvm.lifetime.end.p0(i64 1, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #4
  %219 = load i32, ptr %18, align 4
  switch i32 %219, label %224 [
    i32 0, label %220
  ]

220:                                              ; preds = %218
  br label %221

221:                                              ; preds = %220
  %222 = load i16, ptr %20, align 2, !tbaa !9
  %223 = add i16 %222, 1
  store i16 %223, ptr %20, align 2, !tbaa !9
  br label %124, !llvm.loop !30

224:                                              ; preds = %218, %132
  call void @llvm.lifetime.end.p0(i64 2, ptr %20) #4
  %225 = load i32, ptr %18, align 4
  switch i32 %225, label %954 [
    i32 6, label %226
    i32 12, label %227
  ]

226:                                              ; preds = %224
  br label %227

227:                                              ; preds = %226, %224
  %228 = load i16, ptr %8, align 2, !tbaa !9
  %229 = zext i16 %228 to i32
  %230 = icmp sgt i32 %229, 1
  br i1 %230, label %231, label %325

231:                                              ; preds = %227
  %232 = call ptr @__caryll_allocate_clean(i64 noundef 48, i64 noundef 170)
  store ptr %232, ptr %12, align 8, !tbaa !5
  %233 = load i16, ptr %8, align 2, !tbaa !9
  %234 = zext i16 %233 to i32
  %235 = add nsw i32 %234, 1
  %236 = trunc i32 %235 to i16
  %237 = load ptr, ptr %12, align 8, !tbaa !5
  %238 = getelementptr inbounds %struct.subtable_chaining, ptr %237, i32 0, i32 1
  %239 = getelementptr inbounds %struct.anon, ptr %238, i32 0, i32 0
  store i16 %236, ptr %239, align 8, !tbaa !31
  %240 = load i16, ptr %8, align 2, !tbaa !9
  %241 = zext i16 %240 to i32
  %242 = add nsw i32 %241, 1
  %243 = sext i32 %242 to i64
  %244 = mul i64 8, %243
  %245 = call ptr @__caryll_allocate_clean(i64 noundef %244, i64 noundef 172)
  %246 = load ptr, ptr %12, align 8, !tbaa !5
  %247 = getelementptr inbounds %struct.subtable_chaining, ptr %246, i32 0, i32 1
  %248 = getelementptr inbounds %struct.anon, ptr %247, i32 0, i32 1
  store ptr %245, ptr %248, align 8, !tbaa !31
  %249 = load ptr, ptr %16, align 8, !tbaa !5
  %250 = load ptr, ptr %9, align 8, !tbaa !5
  %251 = load ptr, ptr %10, align 8, !tbaa !5
  %252 = load ptr, ptr %11, align 8, !tbaa !5
  %253 = call ptr @buildRule(ptr noundef %249, ptr noundef %250, ptr noundef %251, ptr noundef %252)
  %254 = load ptr, ptr %12, align 8, !tbaa !5
  %255 = getelementptr inbounds %struct.subtable_chaining, ptr %254, i32 0, i32 1
  %256 = getelementptr inbounds %struct.anon, ptr %255, i32 0, i32 1
  %257 = load ptr, ptr %256, align 8, !tbaa !31
  %258 = getelementptr inbounds ptr, ptr %257, i64 0
  store ptr %253, ptr %258, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 2, ptr %25) #4
  store i16 1, ptr %25, align 2, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 2, ptr %26) #4
  %259 = load i16, ptr %6, align 2, !tbaa !9
  %260 = zext i16 %259 to i32
  %261 = add nsw i32 %260, 1
  %262 = trunc i32 %261 to i16
  store i16 %262, ptr %26, align 2, !tbaa !9
  br label %263

263:                                              ; preds = %305, %231
  %264 = load i16, ptr %26, align 2, !tbaa !9
  %265 = zext i16 %264 to i64
  %266 = load ptr, ptr %5, align 8, !tbaa !5
  %267 = getelementptr inbounds %struct._otl_lookup, ptr %266, i32 0, i32 4
  %268 = getelementptr inbounds %struct.otl_SubtableList, ptr %267, i32 0, i32 0
  %269 = load i64, ptr %268, align 8, !tbaa !24
  %270 = icmp ult i64 %265, %269
  br i1 %270, label %271, label %278

271:                                              ; preds = %263
  %272 = load i16, ptr %25, align 2, !tbaa !9
  %273 = zext i16 %272 to i32
  %274 = load i16, ptr %8, align 2, !tbaa !9
  %275 = zext i16 %274 to i32
  %276 = add nsw i32 %275, 1
  %277 = icmp slt i32 %273, %276
  br label %278

278:                                              ; preds = %271, %263
  %279 = phi i1 [ false, %263 ], [ %277, %271 ]
  br i1 %279, label %281, label %280

280:                                              ; preds = %278
  store i32 13, ptr %18, align 4
  call void @llvm.lifetime.end.p0(i64 2, ptr %26) #4
  br label %308

281:                                              ; preds = %278
  call void @llvm.lifetime.start.p0(i64 8, ptr %27) #4
  %282 = load ptr, ptr %5, align 8, !tbaa !5
  %283 = getelementptr inbounds %struct._otl_lookup, ptr %282, i32 0, i32 4
  %284 = getelementptr inbounds %struct.otl_SubtableList, ptr %283, i32 0, i32 2
  %285 = load ptr, ptr %284, align 8, !tbaa !11
  %286 = load i16, ptr %26, align 2, !tbaa !9
  %287 = zext i16 %286 to i64
  %288 = getelementptr inbounds ptr, ptr %285, i64 %287
  %289 = load ptr, ptr %288, align 8, !tbaa !5
  %290 = getelementptr inbounds %struct.subtable_chaining, ptr %289, i32 0, i32 1
  store ptr %290, ptr %27, align 8, !tbaa !5
  %291 = load ptr, ptr %27, align 8, !tbaa !5
  %292 = load ptr, ptr %9, align 8, !tbaa !5
  %293 = load ptr, ptr %10, align 8, !tbaa !5
  %294 = load ptr, ptr %11, align 8, !tbaa !5
  %295 = call ptr @buildRule(ptr noundef %291, ptr noundef %292, ptr noundef %293, ptr noundef %294)
  %296 = load ptr, ptr %12, align 8, !tbaa !5
  %297 = getelementptr inbounds %struct.subtable_chaining, ptr %296, i32 0, i32 1
  %298 = getelementptr inbounds %struct.anon, ptr %297, i32 0, i32 1
  %299 = load ptr, ptr %298, align 8, !tbaa !31
  %300 = load i16, ptr %25, align 2, !tbaa !9
  %301 = zext i16 %300 to i64
  %302 = getelementptr inbounds ptr, ptr %299, i64 %301
  store ptr %295, ptr %302, align 8, !tbaa !5
  %303 = load i16, ptr %25, align 2, !tbaa !9
  %304 = add i16 %303, 1
  store i16 %304, ptr %25, align 2, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %27) #4
  br label %305

305:                                              ; preds = %281
  %306 = load i16, ptr %26, align 2, !tbaa !9
  %307 = add i16 %306, 1
  store i16 %307, ptr %26, align 2, !tbaa !9
  br label %263, !llvm.loop !32

308:                                              ; preds = %280
  %309 = load ptr, ptr %12, align 8, !tbaa !5
  %310 = getelementptr inbounds %struct.subtable_chaining, ptr %309, i32 0, i32 0
  store i32 2, ptr %310, align 8, !tbaa !33
  %311 = call ptr @toClass(ptr noundef %9)
  %312 = load ptr, ptr %12, align 8, !tbaa !5
  %313 = getelementptr inbounds %struct.subtable_chaining, ptr %312, i32 0, i32 1
  %314 = getelementptr inbounds %struct.anon, ptr %313, i32 0, i32 2
  store ptr %311, ptr %314, align 8, !tbaa !31
  %315 = call ptr @toClass(ptr noundef %10)
  %316 = load ptr, ptr %12, align 8, !tbaa !5
  %317 = getelementptr inbounds %struct.subtable_chaining, ptr %316, i32 0, i32 1
  %318 = getelementptr inbounds %struct.anon, ptr %317, i32 0, i32 3
  store ptr %315, ptr %318, align 8, !tbaa !31
  %319 = call ptr @toClass(ptr noundef %11)
  %320 = load ptr, ptr %12, align 8, !tbaa !5
  %321 = getelementptr inbounds %struct.subtable_chaining, ptr %320, i32 0, i32 1
  %322 = getelementptr inbounds %struct.anon, ptr %321, i32 0, i32 4
  store ptr %319, ptr %322, align 8, !tbaa !31
  %323 = load ptr, ptr %12, align 8, !tbaa !5
  %324 = load ptr, ptr %7, align 8, !tbaa !5
  store ptr %323, ptr %324, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 2, ptr %25) #4
  br label %325

325:                                              ; preds = %308, %227
  br label %326

326:                                              ; preds = %325, %117
  %327 = load ptr, ptr %9, align 8, !tbaa !5
  %328 = icmp ne ptr %327, null
  br i1 %328, label %329, label %533

329:                                              ; preds = %326
  call void @llvm.lifetime.start.p0(i64 8, ptr %28) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #4
  %330 = load ptr, ptr %9, align 8, !tbaa !5
  store ptr %330, ptr %28, align 8, !tbaa !5
  %331 = load ptr, ptr %9, align 8, !tbaa !5
  %332 = icmp ne ptr %331, null
  br i1 %332, label %333, label %338

333:                                              ; preds = %329
  %334 = load ptr, ptr %9, align 8, !tbaa !5
  %335 = getelementptr inbounds %struct.classifier_hash, ptr %334, i32 0, i32 3
  %336 = getelementptr inbounds %struct.UT_hash_handle, ptr %335, i32 0, i32 2
  %337 = load ptr, ptr %336, align 8, !tbaa !35
  br label %339

338:                                              ; preds = %329
  br label %339

339:                                              ; preds = %338, %333
  %340 = phi ptr [ %337, %333 ], [ null, %338 ]
  store ptr %340, ptr %29, align 8, !tbaa !5
  br label %341

341:                                              ; preds = %530, %339
  %342 = load ptr, ptr %28, align 8, !tbaa !5
  %343 = icmp ne ptr %342, null
  br i1 %343, label %344, label %532

344:                                              ; preds = %341
  br label %345

345:                                              ; preds = %344
  call void @llvm.lifetime.start.p0(i64 8, ptr %30) #4
  %346 = load ptr, ptr %28, align 8, !tbaa !5
  %347 = getelementptr inbounds %struct.classifier_hash, ptr %346, i32 0, i32 3
  store ptr %347, ptr %30, align 8, !tbaa !5
  %348 = load ptr, ptr %30, align 8, !tbaa !5
  %349 = getelementptr inbounds %struct.UT_hash_handle, ptr %348, i32 0, i32 1
  %350 = load ptr, ptr %349, align 8, !tbaa !38
  %351 = icmp eq ptr %350, null
  br i1 %351, label %352, label %368

352:                                              ; preds = %345
  %353 = load ptr, ptr %30, align 8, !tbaa !5
  %354 = getelementptr inbounds %struct.UT_hash_handle, ptr %353, i32 0, i32 2
  %355 = load ptr, ptr %354, align 8, !tbaa !39
  %356 = icmp eq ptr %355, null
  br i1 %356, label %357, label %368

357:                                              ; preds = %352
  %358 = load ptr, ptr %9, align 8, !tbaa !5
  %359 = getelementptr inbounds %struct.classifier_hash, ptr %358, i32 0, i32 3
  %360 = getelementptr inbounds %struct.UT_hash_handle, ptr %359, i32 0, i32 0
  %361 = load ptr, ptr %360, align 8, !tbaa !40
  %362 = getelementptr inbounds %struct.UT_hash_table, ptr %361, i32 0, i32 0
  %363 = load ptr, ptr %362, align 8, !tbaa !41
  call void @free(ptr noundef %363) #4
  %364 = load ptr, ptr %9, align 8, !tbaa !5
  %365 = getelementptr inbounds %struct.classifier_hash, ptr %364, i32 0, i32 3
  %366 = getelementptr inbounds %struct.UT_hash_handle, ptr %365, i32 0, i32 0
  %367 = load ptr, ptr %366, align 8, !tbaa !40
  call void @free(ptr noundef %367) #4
  store ptr null, ptr %9, align 8, !tbaa !5
  br label %516

368:                                              ; preds = %352, %345
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #4
  %369 = load ptr, ptr %30, align 8, !tbaa !5
  %370 = load ptr, ptr %9, align 8, !tbaa !5
  %371 = getelementptr inbounds %struct.classifier_hash, ptr %370, i32 0, i32 3
  %372 = getelementptr inbounds %struct.UT_hash_handle, ptr %371, i32 0, i32 0
  %373 = load ptr, ptr %372, align 8, !tbaa !40
  %374 = getelementptr inbounds %struct.UT_hash_table, ptr %373, i32 0, i32 4
  %375 = load ptr, ptr %374, align 8, !tbaa !43
  %376 = icmp eq ptr %369, %375
  br i1 %376, label %377, label %393

377:                                              ; preds = %368
  %378 = load ptr, ptr %30, align 8, !tbaa !5
  %379 = getelementptr inbounds %struct.UT_hash_handle, ptr %378, i32 0, i32 1
  %380 = load ptr, ptr %379, align 8, !tbaa !38
  %381 = load ptr, ptr %9, align 8, !tbaa !5
  %382 = getelementptr inbounds %struct.classifier_hash, ptr %381, i32 0, i32 3
  %383 = getelementptr inbounds %struct.UT_hash_handle, ptr %382, i32 0, i32 0
  %384 = load ptr, ptr %383, align 8, !tbaa !40
  %385 = getelementptr inbounds %struct.UT_hash_table, ptr %384, i32 0, i32 5
  %386 = load i64, ptr %385, align 8, !tbaa !44
  %387 = getelementptr inbounds i8, ptr %380, i64 %386
  %388 = load ptr, ptr %9, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.classifier_hash, ptr %388, i32 0, i32 3
  %390 = getelementptr inbounds %struct.UT_hash_handle, ptr %389, i32 0, i32 0
  %391 = load ptr, ptr %390, align 8, !tbaa !40
  %392 = getelementptr inbounds %struct.UT_hash_table, ptr %391, i32 0, i32 4
  store ptr %387, ptr %392, align 8, !tbaa !43
  br label %393

393:                                              ; preds = %377, %368
  %394 = load ptr, ptr %30, align 8, !tbaa !5
  %395 = getelementptr inbounds %struct.UT_hash_handle, ptr %394, i32 0, i32 1
  %396 = load ptr, ptr %395, align 8, !tbaa !38
  %397 = icmp ne ptr %396, null
  br i1 %397, label %398, label %413

398:                                              ; preds = %393
  %399 = load ptr, ptr %30, align 8, !tbaa !5
  %400 = getelementptr inbounds %struct.UT_hash_handle, ptr %399, i32 0, i32 2
  %401 = load ptr, ptr %400, align 8, !tbaa !39
  %402 = load ptr, ptr %30, align 8, !tbaa !5
  %403 = getelementptr inbounds %struct.UT_hash_handle, ptr %402, i32 0, i32 1
  %404 = load ptr, ptr %403, align 8, !tbaa !38
  %405 = load ptr, ptr %9, align 8, !tbaa !5
  %406 = getelementptr inbounds %struct.classifier_hash, ptr %405, i32 0, i32 3
  %407 = getelementptr inbounds %struct.UT_hash_handle, ptr %406, i32 0, i32 0
  %408 = load ptr, ptr %407, align 8, !tbaa !40
  %409 = getelementptr inbounds %struct.UT_hash_table, ptr %408, i32 0, i32 5
  %410 = load i64, ptr %409, align 8, !tbaa !44
  %411 = getelementptr inbounds i8, ptr %404, i64 %410
  %412 = getelementptr inbounds %struct.UT_hash_handle, ptr %411, i32 0, i32 2
  store ptr %401, ptr %412, align 8, !tbaa !39
  br label %420

413:                                              ; preds = %393
  br label %414

414:                                              ; preds = %413
  %415 = load ptr, ptr %30, align 8, !tbaa !5
  %416 = getelementptr inbounds %struct.UT_hash_handle, ptr %415, i32 0, i32 2
  %417 = load ptr, ptr %416, align 8, !tbaa !39
  store ptr %417, ptr %9, align 8, !tbaa !5
  br label %418

418:                                              ; preds = %414
  br label %419

419:                                              ; preds = %418
  br label %420

420:                                              ; preds = %419, %398
  %421 = load ptr, ptr %30, align 8, !tbaa !5
  %422 = getelementptr inbounds %struct.UT_hash_handle, ptr %421, i32 0, i32 2
  %423 = load ptr, ptr %422, align 8, !tbaa !39
  %424 = icmp ne ptr %423, null
  br i1 %424, label %425, label %440

425:                                              ; preds = %420
  %426 = load ptr, ptr %30, align 8, !tbaa !5
  %427 = getelementptr inbounds %struct.UT_hash_handle, ptr %426, i32 0, i32 1
  %428 = load ptr, ptr %427, align 8, !tbaa !38
  %429 = load ptr, ptr %30, align 8, !tbaa !5
  %430 = getelementptr inbounds %struct.UT_hash_handle, ptr %429, i32 0, i32 2
  %431 = load ptr, ptr %430, align 8, !tbaa !39
  %432 = load ptr, ptr %9, align 8, !tbaa !5
  %433 = getelementptr inbounds %struct.classifier_hash, ptr %432, i32 0, i32 3
  %434 = getelementptr inbounds %struct.UT_hash_handle, ptr %433, i32 0, i32 0
  %435 = load ptr, ptr %434, align 8, !tbaa !40
  %436 = getelementptr inbounds %struct.UT_hash_table, ptr %435, i32 0, i32 5
  %437 = load i64, ptr %436, align 8, !tbaa !44
  %438 = getelementptr inbounds i8, ptr %431, i64 %437
  %439 = getelementptr inbounds %struct.UT_hash_handle, ptr %438, i32 0, i32 1
  store ptr %428, ptr %439, align 8, !tbaa !38
  br label %440

440:                                              ; preds = %425, %420
  br label %441

441:                                              ; preds = %440
  %442 = load ptr, ptr %30, align 8, !tbaa !5
  %443 = getelementptr inbounds %struct.UT_hash_handle, ptr %442, i32 0, i32 7
  %444 = load i32, ptr %443, align 4, !tbaa !45
  %445 = load ptr, ptr %9, align 8, !tbaa !5
  %446 = getelementptr inbounds %struct.classifier_hash, ptr %445, i32 0, i32 3
  %447 = getelementptr inbounds %struct.UT_hash_handle, ptr %446, i32 0, i32 0
  %448 = load ptr, ptr %447, align 8, !tbaa !40
  %449 = getelementptr inbounds %struct.UT_hash_table, ptr %448, i32 0, i32 1
  %450 = load i32, ptr %449, align 8, !tbaa !46
  %451 = sub i32 %450, 1
  %452 = and i32 %444, %451
  store i32 %452, ptr %31, align 4, !tbaa !16
  br label %453

453:                                              ; preds = %441
  br label %454

454:                                              ; preds = %453
  br label %455

455:                                              ; preds = %454
  call void @llvm.lifetime.start.p0(i64 8, ptr %32) #4
  %456 = load ptr, ptr %9, align 8, !tbaa !5
  %457 = getelementptr inbounds %struct.classifier_hash, ptr %456, i32 0, i32 3
  %458 = getelementptr inbounds %struct.UT_hash_handle, ptr %457, i32 0, i32 0
  %459 = load ptr, ptr %458, align 8, !tbaa !40
  %460 = getelementptr inbounds %struct.UT_hash_table, ptr %459, i32 0, i32 0
  %461 = load ptr, ptr %460, align 8, !tbaa !41
  %462 = load i32, ptr %31, align 4, !tbaa !16
  %463 = zext i32 %462 to i64
  %464 = getelementptr inbounds %struct.UT_hash_bucket, ptr %461, i64 %463
  store ptr %464, ptr %32, align 8, !tbaa !5
  %465 = load ptr, ptr %32, align 8, !tbaa !5
  %466 = getelementptr inbounds %struct.UT_hash_bucket, ptr %465, i32 0, i32 1
  %467 = load i32, ptr %466, align 8, !tbaa !47
  %468 = add i32 %467, -1
  store i32 %468, ptr %466, align 8, !tbaa !47
  %469 = load ptr, ptr %32, align 8, !tbaa !5
  %470 = getelementptr inbounds %struct.UT_hash_bucket, ptr %469, i32 0, i32 0
  %471 = load ptr, ptr %470, align 8, !tbaa !49
  %472 = load ptr, ptr %30, align 8, !tbaa !5
  %473 = icmp eq ptr %471, %472
  br i1 %473, label %474, label %480

474:                                              ; preds = %455
  %475 = load ptr, ptr %30, align 8, !tbaa !5
  %476 = getelementptr inbounds %struct.UT_hash_handle, ptr %475, i32 0, i32 4
  %477 = load ptr, ptr %476, align 8, !tbaa !50
  %478 = load ptr, ptr %32, align 8, !tbaa !5
  %479 = getelementptr inbounds %struct.UT_hash_bucket, ptr %478, i32 0, i32 0
  store ptr %477, ptr %479, align 8, !tbaa !49
  br label %480

480:                                              ; preds = %474, %455
  %481 = load ptr, ptr %30, align 8, !tbaa !5
  %482 = getelementptr inbounds %struct.UT_hash_handle, ptr %481, i32 0, i32 3
  %483 = load ptr, ptr %482, align 8, !tbaa !51
  %484 = icmp ne ptr %483, null
  br i1 %484, label %485, label %493

485:                                              ; preds = %480
  %486 = load ptr, ptr %30, align 8, !tbaa !5
  %487 = getelementptr inbounds %struct.UT_hash_handle, ptr %486, i32 0, i32 4
  %488 = load ptr, ptr %487, align 8, !tbaa !50
  %489 = load ptr, ptr %30, align 8, !tbaa !5
  %490 = getelementptr inbounds %struct.UT_hash_handle, ptr %489, i32 0, i32 3
  %491 = load ptr, ptr %490, align 8, !tbaa !51
  %492 = getelementptr inbounds %struct.UT_hash_handle, ptr %491, i32 0, i32 4
  store ptr %488, ptr %492, align 8, !tbaa !50
  br label %493

493:                                              ; preds = %485, %480
  %494 = load ptr, ptr %30, align 8, !tbaa !5
  %495 = getelementptr inbounds %struct.UT_hash_handle, ptr %494, i32 0, i32 4
  %496 = load ptr, ptr %495, align 8, !tbaa !50
  %497 = icmp ne ptr %496, null
  br i1 %497, label %498, label %506

498:                                              ; preds = %493
  %499 = load ptr, ptr %30, align 8, !tbaa !5
  %500 = getelementptr inbounds %struct.UT_hash_handle, ptr %499, i32 0, i32 3
  %501 = load ptr, ptr %500, align 8, !tbaa !51
  %502 = load ptr, ptr %30, align 8, !tbaa !5
  %503 = getelementptr inbounds %struct.UT_hash_handle, ptr %502, i32 0, i32 4
  %504 = load ptr, ptr %503, align 8, !tbaa !50
  %505 = getelementptr inbounds %struct.UT_hash_handle, ptr %504, i32 0, i32 3
  store ptr %501, ptr %505, align 8, !tbaa !51
  br label %506

506:                                              ; preds = %498, %493
  call void @llvm.lifetime.end.p0(i64 8, ptr %32) #4
  br label %507

507:                                              ; preds = %506
  br label %508

508:                                              ; preds = %507
  %509 = load ptr, ptr %9, align 8, !tbaa !5
  %510 = getelementptr inbounds %struct.classifier_hash, ptr %509, i32 0, i32 3
  %511 = getelementptr inbounds %struct.UT_hash_handle, ptr %510, i32 0, i32 0
  %512 = load ptr, ptr %511, align 8, !tbaa !40
  %513 = getelementptr inbounds %struct.UT_hash_table, ptr %512, i32 0, i32 3
  %514 = load i32, ptr %513, align 8, !tbaa !52
  %515 = add i32 %514, -1
  store i32 %515, ptr %513, align 8, !tbaa !52
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #4
  br label %516

516:                                              ; preds = %508, %357
  call void @llvm.lifetime.end.p0(i64 8, ptr %30) #4
  br label %517

517:                                              ; preds = %516
  br label %518

518:                                              ; preds = %517
  %519 = load ptr, ptr %28, align 8, !tbaa !5
  call void @free(ptr noundef %519) #4
  store ptr null, ptr %28, align 8, !tbaa !5
  br label %520

520:                                              ; preds = %518
  %521 = load ptr, ptr %29, align 8, !tbaa !5
  store ptr %521, ptr %28, align 8, !tbaa !5
  %522 = load ptr, ptr %29, align 8, !tbaa !5
  %523 = icmp ne ptr %522, null
  br i1 %523, label %524, label %529

524:                                              ; preds = %520
  %525 = load ptr, ptr %29, align 8, !tbaa !5
  %526 = getelementptr inbounds %struct.classifier_hash, ptr %525, i32 0, i32 3
  %527 = getelementptr inbounds %struct.UT_hash_handle, ptr %526, i32 0, i32 2
  %528 = load ptr, ptr %527, align 8, !tbaa !35
  br label %530

529:                                              ; preds = %520
  br label %530

530:                                              ; preds = %529, %524
  %531 = phi ptr [ %528, %524 ], [ null, %529 ]
  store ptr %531, ptr %29, align 8, !tbaa !5
  br label %341, !llvm.loop !53

532:                                              ; preds = %341
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %28) #4
  br label %533

533:                                              ; preds = %532, %326
  %534 = load ptr, ptr %10, align 8, !tbaa !5
  %535 = icmp ne ptr %534, null
  br i1 %535, label %536, label %740

536:                                              ; preds = %533
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #4
  %537 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %537, ptr %33, align 8, !tbaa !5
  %538 = load ptr, ptr %10, align 8, !tbaa !5
  %539 = icmp ne ptr %538, null
  br i1 %539, label %540, label %545

540:                                              ; preds = %536
  %541 = load ptr, ptr %10, align 8, !tbaa !5
  %542 = getelementptr inbounds %struct.classifier_hash, ptr %541, i32 0, i32 3
  %543 = getelementptr inbounds %struct.UT_hash_handle, ptr %542, i32 0, i32 2
  %544 = load ptr, ptr %543, align 8, !tbaa !35
  br label %546

545:                                              ; preds = %536
  br label %546

546:                                              ; preds = %545, %540
  %547 = phi ptr [ %544, %540 ], [ null, %545 ]
  store ptr %547, ptr %34, align 8, !tbaa !5
  br label %548

548:                                              ; preds = %737, %546
  %549 = load ptr, ptr %33, align 8, !tbaa !5
  %550 = icmp ne ptr %549, null
  br i1 %550, label %551, label %739

551:                                              ; preds = %548
  br label %552

552:                                              ; preds = %551
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #4
  %553 = load ptr, ptr %33, align 8, !tbaa !5
  %554 = getelementptr inbounds %struct.classifier_hash, ptr %553, i32 0, i32 3
  store ptr %554, ptr %35, align 8, !tbaa !5
  %555 = load ptr, ptr %35, align 8, !tbaa !5
  %556 = getelementptr inbounds %struct.UT_hash_handle, ptr %555, i32 0, i32 1
  %557 = load ptr, ptr %556, align 8, !tbaa !38
  %558 = icmp eq ptr %557, null
  br i1 %558, label %559, label %575

559:                                              ; preds = %552
  %560 = load ptr, ptr %35, align 8, !tbaa !5
  %561 = getelementptr inbounds %struct.UT_hash_handle, ptr %560, i32 0, i32 2
  %562 = load ptr, ptr %561, align 8, !tbaa !39
  %563 = icmp eq ptr %562, null
  br i1 %563, label %564, label %575

564:                                              ; preds = %559
  %565 = load ptr, ptr %10, align 8, !tbaa !5
  %566 = getelementptr inbounds %struct.classifier_hash, ptr %565, i32 0, i32 3
  %567 = getelementptr inbounds %struct.UT_hash_handle, ptr %566, i32 0, i32 0
  %568 = load ptr, ptr %567, align 8, !tbaa !40
  %569 = getelementptr inbounds %struct.UT_hash_table, ptr %568, i32 0, i32 0
  %570 = load ptr, ptr %569, align 8, !tbaa !41
  call void @free(ptr noundef %570) #4
  %571 = load ptr, ptr %10, align 8, !tbaa !5
  %572 = getelementptr inbounds %struct.classifier_hash, ptr %571, i32 0, i32 3
  %573 = getelementptr inbounds %struct.UT_hash_handle, ptr %572, i32 0, i32 0
  %574 = load ptr, ptr %573, align 8, !tbaa !40
  call void @free(ptr noundef %574) #4
  store ptr null, ptr %10, align 8, !tbaa !5
  br label %723

575:                                              ; preds = %559, %552
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #4
  %576 = load ptr, ptr %35, align 8, !tbaa !5
  %577 = load ptr, ptr %10, align 8, !tbaa !5
  %578 = getelementptr inbounds %struct.classifier_hash, ptr %577, i32 0, i32 3
  %579 = getelementptr inbounds %struct.UT_hash_handle, ptr %578, i32 0, i32 0
  %580 = load ptr, ptr %579, align 8, !tbaa !40
  %581 = getelementptr inbounds %struct.UT_hash_table, ptr %580, i32 0, i32 4
  %582 = load ptr, ptr %581, align 8, !tbaa !43
  %583 = icmp eq ptr %576, %582
  br i1 %583, label %584, label %600

584:                                              ; preds = %575
  %585 = load ptr, ptr %35, align 8, !tbaa !5
  %586 = getelementptr inbounds %struct.UT_hash_handle, ptr %585, i32 0, i32 1
  %587 = load ptr, ptr %586, align 8, !tbaa !38
  %588 = load ptr, ptr %10, align 8, !tbaa !5
  %589 = getelementptr inbounds %struct.classifier_hash, ptr %588, i32 0, i32 3
  %590 = getelementptr inbounds %struct.UT_hash_handle, ptr %589, i32 0, i32 0
  %591 = load ptr, ptr %590, align 8, !tbaa !40
  %592 = getelementptr inbounds %struct.UT_hash_table, ptr %591, i32 0, i32 5
  %593 = load i64, ptr %592, align 8, !tbaa !44
  %594 = getelementptr inbounds i8, ptr %587, i64 %593
  %595 = load ptr, ptr %10, align 8, !tbaa !5
  %596 = getelementptr inbounds %struct.classifier_hash, ptr %595, i32 0, i32 3
  %597 = getelementptr inbounds %struct.UT_hash_handle, ptr %596, i32 0, i32 0
  %598 = load ptr, ptr %597, align 8, !tbaa !40
  %599 = getelementptr inbounds %struct.UT_hash_table, ptr %598, i32 0, i32 4
  store ptr %594, ptr %599, align 8, !tbaa !43
  br label %600

600:                                              ; preds = %584, %575
  %601 = load ptr, ptr %35, align 8, !tbaa !5
  %602 = getelementptr inbounds %struct.UT_hash_handle, ptr %601, i32 0, i32 1
  %603 = load ptr, ptr %602, align 8, !tbaa !38
  %604 = icmp ne ptr %603, null
  br i1 %604, label %605, label %620

605:                                              ; preds = %600
  %606 = load ptr, ptr %35, align 8, !tbaa !5
  %607 = getelementptr inbounds %struct.UT_hash_handle, ptr %606, i32 0, i32 2
  %608 = load ptr, ptr %607, align 8, !tbaa !39
  %609 = load ptr, ptr %35, align 8, !tbaa !5
  %610 = getelementptr inbounds %struct.UT_hash_handle, ptr %609, i32 0, i32 1
  %611 = load ptr, ptr %610, align 8, !tbaa !38
  %612 = load ptr, ptr %10, align 8, !tbaa !5
  %613 = getelementptr inbounds %struct.classifier_hash, ptr %612, i32 0, i32 3
  %614 = getelementptr inbounds %struct.UT_hash_handle, ptr %613, i32 0, i32 0
  %615 = load ptr, ptr %614, align 8, !tbaa !40
  %616 = getelementptr inbounds %struct.UT_hash_table, ptr %615, i32 0, i32 5
  %617 = load i64, ptr %616, align 8, !tbaa !44
  %618 = getelementptr inbounds i8, ptr %611, i64 %617
  %619 = getelementptr inbounds %struct.UT_hash_handle, ptr %618, i32 0, i32 2
  store ptr %608, ptr %619, align 8, !tbaa !39
  br label %627

620:                                              ; preds = %600
  br label %621

621:                                              ; preds = %620
  %622 = load ptr, ptr %35, align 8, !tbaa !5
  %623 = getelementptr inbounds %struct.UT_hash_handle, ptr %622, i32 0, i32 2
  %624 = load ptr, ptr %623, align 8, !tbaa !39
  store ptr %624, ptr %10, align 8, !tbaa !5
  br label %625

625:                                              ; preds = %621
  br label %626

626:                                              ; preds = %625
  br label %627

627:                                              ; preds = %626, %605
  %628 = load ptr, ptr %35, align 8, !tbaa !5
  %629 = getelementptr inbounds %struct.UT_hash_handle, ptr %628, i32 0, i32 2
  %630 = load ptr, ptr %629, align 8, !tbaa !39
  %631 = icmp ne ptr %630, null
  br i1 %631, label %632, label %647

632:                                              ; preds = %627
  %633 = load ptr, ptr %35, align 8, !tbaa !5
  %634 = getelementptr inbounds %struct.UT_hash_handle, ptr %633, i32 0, i32 1
  %635 = load ptr, ptr %634, align 8, !tbaa !38
  %636 = load ptr, ptr %35, align 8, !tbaa !5
  %637 = getelementptr inbounds %struct.UT_hash_handle, ptr %636, i32 0, i32 2
  %638 = load ptr, ptr %637, align 8, !tbaa !39
  %639 = load ptr, ptr %10, align 8, !tbaa !5
  %640 = getelementptr inbounds %struct.classifier_hash, ptr %639, i32 0, i32 3
  %641 = getelementptr inbounds %struct.UT_hash_handle, ptr %640, i32 0, i32 0
  %642 = load ptr, ptr %641, align 8, !tbaa !40
  %643 = getelementptr inbounds %struct.UT_hash_table, ptr %642, i32 0, i32 5
  %644 = load i64, ptr %643, align 8, !tbaa !44
  %645 = getelementptr inbounds i8, ptr %638, i64 %644
  %646 = getelementptr inbounds %struct.UT_hash_handle, ptr %645, i32 0, i32 1
  store ptr %635, ptr %646, align 8, !tbaa !38
  br label %647

647:                                              ; preds = %632, %627
  br label %648

648:                                              ; preds = %647
  %649 = load ptr, ptr %35, align 8, !tbaa !5
  %650 = getelementptr inbounds %struct.UT_hash_handle, ptr %649, i32 0, i32 7
  %651 = load i32, ptr %650, align 4, !tbaa !45
  %652 = load ptr, ptr %10, align 8, !tbaa !5
  %653 = getelementptr inbounds %struct.classifier_hash, ptr %652, i32 0, i32 3
  %654 = getelementptr inbounds %struct.UT_hash_handle, ptr %653, i32 0, i32 0
  %655 = load ptr, ptr %654, align 8, !tbaa !40
  %656 = getelementptr inbounds %struct.UT_hash_table, ptr %655, i32 0, i32 1
  %657 = load i32, ptr %656, align 8, !tbaa !46
  %658 = sub i32 %657, 1
  %659 = and i32 %651, %658
  store i32 %659, ptr %36, align 4, !tbaa !16
  br label %660

660:                                              ; preds = %648
  br label %661

661:                                              ; preds = %660
  br label %662

662:                                              ; preds = %661
  call void @llvm.lifetime.start.p0(i64 8, ptr %37) #4
  %663 = load ptr, ptr %10, align 8, !tbaa !5
  %664 = getelementptr inbounds %struct.classifier_hash, ptr %663, i32 0, i32 3
  %665 = getelementptr inbounds %struct.UT_hash_handle, ptr %664, i32 0, i32 0
  %666 = load ptr, ptr %665, align 8, !tbaa !40
  %667 = getelementptr inbounds %struct.UT_hash_table, ptr %666, i32 0, i32 0
  %668 = load ptr, ptr %667, align 8, !tbaa !41
  %669 = load i32, ptr %36, align 4, !tbaa !16
  %670 = zext i32 %669 to i64
  %671 = getelementptr inbounds %struct.UT_hash_bucket, ptr %668, i64 %670
  store ptr %671, ptr %37, align 8, !tbaa !5
  %672 = load ptr, ptr %37, align 8, !tbaa !5
  %673 = getelementptr inbounds %struct.UT_hash_bucket, ptr %672, i32 0, i32 1
  %674 = load i32, ptr %673, align 8, !tbaa !47
  %675 = add i32 %674, -1
  store i32 %675, ptr %673, align 8, !tbaa !47
  %676 = load ptr, ptr %37, align 8, !tbaa !5
  %677 = getelementptr inbounds %struct.UT_hash_bucket, ptr %676, i32 0, i32 0
  %678 = load ptr, ptr %677, align 8, !tbaa !49
  %679 = load ptr, ptr %35, align 8, !tbaa !5
  %680 = icmp eq ptr %678, %679
  br i1 %680, label %681, label %687

681:                                              ; preds = %662
  %682 = load ptr, ptr %35, align 8, !tbaa !5
  %683 = getelementptr inbounds %struct.UT_hash_handle, ptr %682, i32 0, i32 4
  %684 = load ptr, ptr %683, align 8, !tbaa !50
  %685 = load ptr, ptr %37, align 8, !tbaa !5
  %686 = getelementptr inbounds %struct.UT_hash_bucket, ptr %685, i32 0, i32 0
  store ptr %684, ptr %686, align 8, !tbaa !49
  br label %687

687:                                              ; preds = %681, %662
  %688 = load ptr, ptr %35, align 8, !tbaa !5
  %689 = getelementptr inbounds %struct.UT_hash_handle, ptr %688, i32 0, i32 3
  %690 = load ptr, ptr %689, align 8, !tbaa !51
  %691 = icmp ne ptr %690, null
  br i1 %691, label %692, label %700

692:                                              ; preds = %687
  %693 = load ptr, ptr %35, align 8, !tbaa !5
  %694 = getelementptr inbounds %struct.UT_hash_handle, ptr %693, i32 0, i32 4
  %695 = load ptr, ptr %694, align 8, !tbaa !50
  %696 = load ptr, ptr %35, align 8, !tbaa !5
  %697 = getelementptr inbounds %struct.UT_hash_handle, ptr %696, i32 0, i32 3
  %698 = load ptr, ptr %697, align 8, !tbaa !51
  %699 = getelementptr inbounds %struct.UT_hash_handle, ptr %698, i32 0, i32 4
  store ptr %695, ptr %699, align 8, !tbaa !50
  br label %700

700:                                              ; preds = %692, %687
  %701 = load ptr, ptr %35, align 8, !tbaa !5
  %702 = getelementptr inbounds %struct.UT_hash_handle, ptr %701, i32 0, i32 4
  %703 = load ptr, ptr %702, align 8, !tbaa !50
  %704 = icmp ne ptr %703, null
  br i1 %704, label %705, label %713

705:                                              ; preds = %700
  %706 = load ptr, ptr %35, align 8, !tbaa !5
  %707 = getelementptr inbounds %struct.UT_hash_handle, ptr %706, i32 0, i32 3
  %708 = load ptr, ptr %707, align 8, !tbaa !51
  %709 = load ptr, ptr %35, align 8, !tbaa !5
  %710 = getelementptr inbounds %struct.UT_hash_handle, ptr %709, i32 0, i32 4
  %711 = load ptr, ptr %710, align 8, !tbaa !50
  %712 = getelementptr inbounds %struct.UT_hash_handle, ptr %711, i32 0, i32 3
  store ptr %708, ptr %712, align 8, !tbaa !51
  br label %713

713:                                              ; preds = %705, %700
  call void @llvm.lifetime.end.p0(i64 8, ptr %37) #4
  br label %714

714:                                              ; preds = %713
  br label %715

715:                                              ; preds = %714
  %716 = load ptr, ptr %10, align 8, !tbaa !5
  %717 = getelementptr inbounds %struct.classifier_hash, ptr %716, i32 0, i32 3
  %718 = getelementptr inbounds %struct.UT_hash_handle, ptr %717, i32 0, i32 0
  %719 = load ptr, ptr %718, align 8, !tbaa !40
  %720 = getelementptr inbounds %struct.UT_hash_table, ptr %719, i32 0, i32 3
  %721 = load i32, ptr %720, align 8, !tbaa !52
  %722 = add i32 %721, -1
  store i32 %722, ptr %720, align 8, !tbaa !52
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #4
  br label %723

723:                                              ; preds = %715, %564
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #4
  br label %724

724:                                              ; preds = %723
  br label %725

725:                                              ; preds = %724
  %726 = load ptr, ptr %33, align 8, !tbaa !5
  call void @free(ptr noundef %726) #4
  store ptr null, ptr %33, align 8, !tbaa !5
  br label %727

727:                                              ; preds = %725
  %728 = load ptr, ptr %34, align 8, !tbaa !5
  store ptr %728, ptr %33, align 8, !tbaa !5
  %729 = load ptr, ptr %34, align 8, !tbaa !5
  %730 = icmp ne ptr %729, null
  br i1 %730, label %731, label %736

731:                                              ; preds = %727
  %732 = load ptr, ptr %34, align 8, !tbaa !5
  %733 = getelementptr inbounds %struct.classifier_hash, ptr %732, i32 0, i32 3
  %734 = getelementptr inbounds %struct.UT_hash_handle, ptr %733, i32 0, i32 2
  %735 = load ptr, ptr %734, align 8, !tbaa !35
  br label %737

736:                                              ; preds = %727
  br label %737

737:                                              ; preds = %736, %731
  %738 = phi ptr [ %735, %731 ], [ null, %736 ]
  store ptr %738, ptr %34, align 8, !tbaa !5
  br label %548, !llvm.loop !54

739:                                              ; preds = %548
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #4
  br label %740

740:                                              ; preds = %739, %533
  %741 = load ptr, ptr %11, align 8, !tbaa !5
  %742 = icmp ne ptr %741, null
  br i1 %742, label %743, label %947

743:                                              ; preds = %740
  call void @llvm.lifetime.start.p0(i64 8, ptr %38) #4
  call void @llvm.lifetime.start.p0(i64 8, ptr %39) #4
  %744 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %744, ptr %38, align 8, !tbaa !5
  %745 = load ptr, ptr %11, align 8, !tbaa !5
  %746 = icmp ne ptr %745, null
  br i1 %746, label %747, label %752

747:                                              ; preds = %743
  %748 = load ptr, ptr %11, align 8, !tbaa !5
  %749 = getelementptr inbounds %struct.classifier_hash, ptr %748, i32 0, i32 3
  %750 = getelementptr inbounds %struct.UT_hash_handle, ptr %749, i32 0, i32 2
  %751 = load ptr, ptr %750, align 8, !tbaa !35
  br label %753

752:                                              ; preds = %743
  br label %753

753:                                              ; preds = %752, %747
  %754 = phi ptr [ %751, %747 ], [ null, %752 ]
  store ptr %754, ptr %39, align 8, !tbaa !5
  br label %755

755:                                              ; preds = %944, %753
  %756 = load ptr, ptr %38, align 8, !tbaa !5
  %757 = icmp ne ptr %756, null
  br i1 %757, label %758, label %946

758:                                              ; preds = %755
  br label %759

759:                                              ; preds = %758
  call void @llvm.lifetime.start.p0(i64 8, ptr %40) #4
  %760 = load ptr, ptr %38, align 8, !tbaa !5
  %761 = getelementptr inbounds %struct.classifier_hash, ptr %760, i32 0, i32 3
  store ptr %761, ptr %40, align 8, !tbaa !5
  %762 = load ptr, ptr %40, align 8, !tbaa !5
  %763 = getelementptr inbounds %struct.UT_hash_handle, ptr %762, i32 0, i32 1
  %764 = load ptr, ptr %763, align 8, !tbaa !38
  %765 = icmp eq ptr %764, null
  br i1 %765, label %766, label %782

766:                                              ; preds = %759
  %767 = load ptr, ptr %40, align 8, !tbaa !5
  %768 = getelementptr inbounds %struct.UT_hash_handle, ptr %767, i32 0, i32 2
  %769 = load ptr, ptr %768, align 8, !tbaa !39
  %770 = icmp eq ptr %769, null
  br i1 %770, label %771, label %782

771:                                              ; preds = %766
  %772 = load ptr, ptr %11, align 8, !tbaa !5
  %773 = getelementptr inbounds %struct.classifier_hash, ptr %772, i32 0, i32 3
  %774 = getelementptr inbounds %struct.UT_hash_handle, ptr %773, i32 0, i32 0
  %775 = load ptr, ptr %774, align 8, !tbaa !40
  %776 = getelementptr inbounds %struct.UT_hash_table, ptr %775, i32 0, i32 0
  %777 = load ptr, ptr %776, align 8, !tbaa !41
  call void @free(ptr noundef %777) #4
  %778 = load ptr, ptr %11, align 8, !tbaa !5
  %779 = getelementptr inbounds %struct.classifier_hash, ptr %778, i32 0, i32 3
  %780 = getelementptr inbounds %struct.UT_hash_handle, ptr %779, i32 0, i32 0
  %781 = load ptr, ptr %780, align 8, !tbaa !40
  call void @free(ptr noundef %781) #4
  store ptr null, ptr %11, align 8, !tbaa !5
  br label %930

782:                                              ; preds = %766, %759
  call void @llvm.lifetime.start.p0(i64 4, ptr %41) #4
  %783 = load ptr, ptr %40, align 8, !tbaa !5
  %784 = load ptr, ptr %11, align 8, !tbaa !5
  %785 = getelementptr inbounds %struct.classifier_hash, ptr %784, i32 0, i32 3
  %786 = getelementptr inbounds %struct.UT_hash_handle, ptr %785, i32 0, i32 0
  %787 = load ptr, ptr %786, align 8, !tbaa !40
  %788 = getelementptr inbounds %struct.UT_hash_table, ptr %787, i32 0, i32 4
  %789 = load ptr, ptr %788, align 8, !tbaa !43
  %790 = icmp eq ptr %783, %789
  br i1 %790, label %791, label %807

791:                                              ; preds = %782
  %792 = load ptr, ptr %40, align 8, !tbaa !5
  %793 = getelementptr inbounds %struct.UT_hash_handle, ptr %792, i32 0, i32 1
  %794 = load ptr, ptr %793, align 8, !tbaa !38
  %795 = load ptr, ptr %11, align 8, !tbaa !5
  %796 = getelementptr inbounds %struct.classifier_hash, ptr %795, i32 0, i32 3
  %797 = getelementptr inbounds %struct.UT_hash_handle, ptr %796, i32 0, i32 0
  %798 = load ptr, ptr %797, align 8, !tbaa !40
  %799 = getelementptr inbounds %struct.UT_hash_table, ptr %798, i32 0, i32 5
  %800 = load i64, ptr %799, align 8, !tbaa !44
  %801 = getelementptr inbounds i8, ptr %794, i64 %800
  %802 = load ptr, ptr %11, align 8, !tbaa !5
  %803 = getelementptr inbounds %struct.classifier_hash, ptr %802, i32 0, i32 3
  %804 = getelementptr inbounds %struct.UT_hash_handle, ptr %803, i32 0, i32 0
  %805 = load ptr, ptr %804, align 8, !tbaa !40
  %806 = getelementptr inbounds %struct.UT_hash_table, ptr %805, i32 0, i32 4
  store ptr %801, ptr %806, align 8, !tbaa !43
  br label %807

807:                                              ; preds = %791, %782
  %808 = load ptr, ptr %40, align 8, !tbaa !5
  %809 = getelementptr inbounds %struct.UT_hash_handle, ptr %808, i32 0, i32 1
  %810 = load ptr, ptr %809, align 8, !tbaa !38
  %811 = icmp ne ptr %810, null
  br i1 %811, label %812, label %827

812:                                              ; preds = %807
  %813 = load ptr, ptr %40, align 8, !tbaa !5
  %814 = getelementptr inbounds %struct.UT_hash_handle, ptr %813, i32 0, i32 2
  %815 = load ptr, ptr %814, align 8, !tbaa !39
  %816 = load ptr, ptr %40, align 8, !tbaa !5
  %817 = getelementptr inbounds %struct.UT_hash_handle, ptr %816, i32 0, i32 1
  %818 = load ptr, ptr %817, align 8, !tbaa !38
  %819 = load ptr, ptr %11, align 8, !tbaa !5
  %820 = getelementptr inbounds %struct.classifier_hash, ptr %819, i32 0, i32 3
  %821 = getelementptr inbounds %struct.UT_hash_handle, ptr %820, i32 0, i32 0
  %822 = load ptr, ptr %821, align 8, !tbaa !40
  %823 = getelementptr inbounds %struct.UT_hash_table, ptr %822, i32 0, i32 5
  %824 = load i64, ptr %823, align 8, !tbaa !44
  %825 = getelementptr inbounds i8, ptr %818, i64 %824
  %826 = getelementptr inbounds %struct.UT_hash_handle, ptr %825, i32 0, i32 2
  store ptr %815, ptr %826, align 8, !tbaa !39
  br label %834

827:                                              ; preds = %807
  br label %828

828:                                              ; preds = %827
  %829 = load ptr, ptr %40, align 8, !tbaa !5
  %830 = getelementptr inbounds %struct.UT_hash_handle, ptr %829, i32 0, i32 2
  %831 = load ptr, ptr %830, align 8, !tbaa !39
  store ptr %831, ptr %11, align 8, !tbaa !5
  br label %832

832:                                              ; preds = %828
  br label %833

833:                                              ; preds = %832
  br label %834

834:                                              ; preds = %833, %812
  %835 = load ptr, ptr %40, align 8, !tbaa !5
  %836 = getelementptr inbounds %struct.UT_hash_handle, ptr %835, i32 0, i32 2
  %837 = load ptr, ptr %836, align 8, !tbaa !39
  %838 = icmp ne ptr %837, null
  br i1 %838, label %839, label %854

839:                                              ; preds = %834
  %840 = load ptr, ptr %40, align 8, !tbaa !5
  %841 = getelementptr inbounds %struct.UT_hash_handle, ptr %840, i32 0, i32 1
  %842 = load ptr, ptr %841, align 8, !tbaa !38
  %843 = load ptr, ptr %40, align 8, !tbaa !5
  %844 = getelementptr inbounds %struct.UT_hash_handle, ptr %843, i32 0, i32 2
  %845 = load ptr, ptr %844, align 8, !tbaa !39
  %846 = load ptr, ptr %11, align 8, !tbaa !5
  %847 = getelementptr inbounds %struct.classifier_hash, ptr %846, i32 0, i32 3
  %848 = getelementptr inbounds %struct.UT_hash_handle, ptr %847, i32 0, i32 0
  %849 = load ptr, ptr %848, align 8, !tbaa !40
  %850 = getelementptr inbounds %struct.UT_hash_table, ptr %849, i32 0, i32 5
  %851 = load i64, ptr %850, align 8, !tbaa !44
  %852 = getelementptr inbounds i8, ptr %845, i64 %851
  %853 = getelementptr inbounds %struct.UT_hash_handle, ptr %852, i32 0, i32 1
  store ptr %842, ptr %853, align 8, !tbaa !38
  br label %854

854:                                              ; preds = %839, %834
  br label %855

855:                                              ; preds = %854
  %856 = load ptr, ptr %40, align 8, !tbaa !5
  %857 = getelementptr inbounds %struct.UT_hash_handle, ptr %856, i32 0, i32 7
  %858 = load i32, ptr %857, align 4, !tbaa !45
  %859 = load ptr, ptr %11, align 8, !tbaa !5
  %860 = getelementptr inbounds %struct.classifier_hash, ptr %859, i32 0, i32 3
  %861 = getelementptr inbounds %struct.UT_hash_handle, ptr %860, i32 0, i32 0
  %862 = load ptr, ptr %861, align 8, !tbaa !40
  %863 = getelementptr inbounds %struct.UT_hash_table, ptr %862, i32 0, i32 1
  %864 = load i32, ptr %863, align 8, !tbaa !46
  %865 = sub i32 %864, 1
  %866 = and i32 %858, %865
  store i32 %866, ptr %41, align 4, !tbaa !16
  br label %867

867:                                              ; preds = %855
  br label %868

868:                                              ; preds = %867
  br label %869

869:                                              ; preds = %868
  call void @llvm.lifetime.start.p0(i64 8, ptr %42) #4
  %870 = load ptr, ptr %11, align 8, !tbaa !5
  %871 = getelementptr inbounds %struct.classifier_hash, ptr %870, i32 0, i32 3
  %872 = getelementptr inbounds %struct.UT_hash_handle, ptr %871, i32 0, i32 0
  %873 = load ptr, ptr %872, align 8, !tbaa !40
  %874 = getelementptr inbounds %struct.UT_hash_table, ptr %873, i32 0, i32 0
  %875 = load ptr, ptr %874, align 8, !tbaa !41
  %876 = load i32, ptr %41, align 4, !tbaa !16
  %877 = zext i32 %876 to i64
  %878 = getelementptr inbounds %struct.UT_hash_bucket, ptr %875, i64 %877
  store ptr %878, ptr %42, align 8, !tbaa !5
  %879 = load ptr, ptr %42, align 8, !tbaa !5
  %880 = getelementptr inbounds %struct.UT_hash_bucket, ptr %879, i32 0, i32 1
  %881 = load i32, ptr %880, align 8, !tbaa !47
  %882 = add i32 %881, -1
  store i32 %882, ptr %880, align 8, !tbaa !47
  %883 = load ptr, ptr %42, align 8, !tbaa !5
  %884 = getelementptr inbounds %struct.UT_hash_bucket, ptr %883, i32 0, i32 0
  %885 = load ptr, ptr %884, align 8, !tbaa !49
  %886 = load ptr, ptr %40, align 8, !tbaa !5
  %887 = icmp eq ptr %885, %886
  br i1 %887, label %888, label %894

888:                                              ; preds = %869
  %889 = load ptr, ptr %40, align 8, !tbaa !5
  %890 = getelementptr inbounds %struct.UT_hash_handle, ptr %889, i32 0, i32 4
  %891 = load ptr, ptr %890, align 8, !tbaa !50
  %892 = load ptr, ptr %42, align 8, !tbaa !5
  %893 = getelementptr inbounds %struct.UT_hash_bucket, ptr %892, i32 0, i32 0
  store ptr %891, ptr %893, align 8, !tbaa !49
  br label %894

894:                                              ; preds = %888, %869
  %895 = load ptr, ptr %40, align 8, !tbaa !5
  %896 = getelementptr inbounds %struct.UT_hash_handle, ptr %895, i32 0, i32 3
  %897 = load ptr, ptr %896, align 8, !tbaa !51
  %898 = icmp ne ptr %897, null
  br i1 %898, label %899, label %907

899:                                              ; preds = %894
  %900 = load ptr, ptr %40, align 8, !tbaa !5
  %901 = getelementptr inbounds %struct.UT_hash_handle, ptr %900, i32 0, i32 4
  %902 = load ptr, ptr %901, align 8, !tbaa !50
  %903 = load ptr, ptr %40, align 8, !tbaa !5
  %904 = getelementptr inbounds %struct.UT_hash_handle, ptr %903, i32 0, i32 3
  %905 = load ptr, ptr %904, align 8, !tbaa !51
  %906 = getelementptr inbounds %struct.UT_hash_handle, ptr %905, i32 0, i32 4
  store ptr %902, ptr %906, align 8, !tbaa !50
  br label %907

907:                                              ; preds = %899, %894
  %908 = load ptr, ptr %40, align 8, !tbaa !5
  %909 = getelementptr inbounds %struct.UT_hash_handle, ptr %908, i32 0, i32 4
  %910 = load ptr, ptr %909, align 8, !tbaa !50
  %911 = icmp ne ptr %910, null
  br i1 %911, label %912, label %920

912:                                              ; preds = %907
  %913 = load ptr, ptr %40, align 8, !tbaa !5
  %914 = getelementptr inbounds %struct.UT_hash_handle, ptr %913, i32 0, i32 3
  %915 = load ptr, ptr %914, align 8, !tbaa !51
  %916 = load ptr, ptr %40, align 8, !tbaa !5
  %917 = getelementptr inbounds %struct.UT_hash_handle, ptr %916, i32 0, i32 4
  %918 = load ptr, ptr %917, align 8, !tbaa !50
  %919 = getelementptr inbounds %struct.UT_hash_handle, ptr %918, i32 0, i32 3
  store ptr %915, ptr %919, align 8, !tbaa !51
  br label %920

920:                                              ; preds = %912, %907
  call void @llvm.lifetime.end.p0(i64 8, ptr %42) #4
  br label %921

921:                                              ; preds = %920
  br label %922

922:                                              ; preds = %921
  %923 = load ptr, ptr %11, align 8, !tbaa !5
  %924 = getelementptr inbounds %struct.classifier_hash, ptr %923, i32 0, i32 3
  %925 = getelementptr inbounds %struct.UT_hash_handle, ptr %924, i32 0, i32 0
  %926 = load ptr, ptr %925, align 8, !tbaa !40
  %927 = getelementptr inbounds %struct.UT_hash_table, ptr %926, i32 0, i32 3
  %928 = load i32, ptr %927, align 8, !tbaa !52
  %929 = add i32 %928, -1
  store i32 %929, ptr %927, align 8, !tbaa !52
  call void @llvm.lifetime.end.p0(i64 4, ptr %41) #4
  br label %930

930:                                              ; preds = %922, %771
  call void @llvm.lifetime.end.p0(i64 8, ptr %40) #4
  br label %931

931:                                              ; preds = %930
  br label %932

932:                                              ; preds = %931
  %933 = load ptr, ptr %38, align 8, !tbaa !5
  call void @free(ptr noundef %933) #4
  store ptr null, ptr %38, align 8, !tbaa !5
  br label %934

934:                                              ; preds = %932
  %935 = load ptr, ptr %39, align 8, !tbaa !5
  store ptr %935, ptr %38, align 8, !tbaa !5
  %936 = load ptr, ptr %39, align 8, !tbaa !5
  %937 = icmp ne ptr %936, null
  br i1 %937, label %938, label %943

938:                                              ; preds = %934
  %939 = load ptr, ptr %39, align 8, !tbaa !5
  %940 = getelementptr inbounds %struct.classifier_hash, ptr %939, i32 0, i32 3
  %941 = getelementptr inbounds %struct.UT_hash_handle, ptr %940, i32 0, i32 2
  %942 = load ptr, ptr %941, align 8, !tbaa !35
  br label %944

943:                                              ; preds = %934
  br label %944

944:                                              ; preds = %943, %938
  %945 = phi ptr [ %942, %938 ], [ null, %943 ]
  store ptr %945, ptr %39, align 8, !tbaa !5
  br label %755, !llvm.loop !55

946:                                              ; preds = %755
  call void @llvm.lifetime.end.p0(i64 8, ptr %39) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %38) #4
  br label %947

947:                                              ; preds = %946, %740
  %948 = load i16, ptr %8, align 2, !tbaa !9
  %949 = zext i16 %948 to i32
  %950 = icmp sgt i32 %949, 1
  br i1 %950, label %951, label %953

951:                                              ; preds = %947
  %952 = load i16, ptr %8, align 2, !tbaa !9
  store i16 %952, ptr %4, align 2
  store i32 1, ptr %18, align 4
  br label %954

953:                                              ; preds = %947
  store i16 0, ptr %4, align 2
  store i32 1, ptr %18, align 4
  br label %954

954:                                              ; preds = %953, %951, %224, %117
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #4
  call void @llvm.lifetime.end.p0(i64 2, ptr %8) #4
  %955 = load i16, ptr %4, align 2
  ret i16 %955
}

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

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @__caryll_allocate_clean(i64 noundef, i64 noundef) #2

; Function Attrs: nounwind uwtable
declare hidden ptr @buildRule(ptr noundef, ptr noundef, ptr noundef, ptr noundef) #0

; Function Attrs: nounwind uwtable
declare hidden ptr @toClass(ptr noundef) #0

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

attributes #0 = { 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 #1 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { inlinehint 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 #3 = { 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 #4 = { nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"short", !7, i64 0}
!11 = !{!12, !6, i64 40}
!12 = !{!"_otl_lookup", !6, i64 0, !13, i64 8, !13, i64 12, !10, i64 16, !14, i64 24}
!13 = !{!"int", !7, i64 0}
!14 = !{!"", !15, i64 0, !15, i64 8, !6, i64 16}
!15 = !{!"long", !7, i64 0}
!16 = !{!13, !13, i64 0}
!17 = !{!18, !10, i64 0}
!18 = !{!"", !10, i64 0, !10, i64 2, !10, i64 4, !6, i64 8, !10, i64 16, !6, i64 24}
!19 = !{!18, !10, i64 2}
!20 = !{!18, !6, i64 8}
!21 = !{!18, !10, i64 4}
!22 = distinct !{!22, !23}
!23 = !{!"llvm.loop.mustprogress"}
!24 = !{!12, !15, i64 24}
!25 = !{!26, !26, i64 0}
!26 = !{!"_Bool", !7, i64 0}
!27 = distinct !{!27, !23}
!28 = !{i8 0, i8 2}
!29 = !{}
!30 = distinct !{!30, !23}
!31 = !{!7, !7, i64 0}
!32 = distinct !{!32, !23}
!33 = !{!34, !13, i64 0}
!34 = !{!"", !13, i64 0, !7, i64 8}
!35 = !{!36, !6, i64 40}
!36 = !{!"", !13, i64 0, !6, i64 8, !13, i64 16, !37, i64 24}
!37 = !{!"UT_hash_handle", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !13, i64 48, !13, i64 52}
!38 = !{!37, !6, i64 8}
!39 = !{!37, !6, i64 16}
!40 = !{!36, !6, i64 24}
!41 = !{!42, !6, i64 0}
!42 = !{!"UT_hash_table", !6, i64 0, !13, i64 8, !13, i64 12, !13, i64 16, !6, i64 24, !15, i64 32, !13, i64 40, !13, i64 44, !13, i64 48, !13, i64 52, !13, i64 56}
!43 = !{!42, !6, i64 24}
!44 = !{!42, !15, i64 32}
!45 = !{!37, !13, i64 52}
!46 = !{!42, !13, i64 8}
!47 = !{!48, !13, i64 8}
!48 = !{!"UT_hash_bucket", !6, i64 0, !13, i64 8, !13, i64 12}
!49 = !{!48, !6, i64 0}
!50 = !{!37, !6, i64 32}
!51 = !{!37, !6, i64 24}
!52 = !{!42, !13, i64 16}
!53 = distinct !{!53, !23}
!54 = distinct !{!54, !23}
!55 = distinct !{!55, !23}


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

%struct.UT_hash_bucket = type { ptr, i32, i32 }

; Function Attrs: nounwind uwtable
define dso_local zeroext i16 @tryClassifyAround(ptr nocapture noundef readonly %0, i16 noundef zeroext %1, ptr nocapture noundef writeonly %2) local_unnamed_addr #0 {
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %4) #4
  store ptr null, ptr %4, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %5) #4
  store ptr null, ptr %5, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %6) #4
  store ptr null, ptr %6, align 8, !tbaa !5
  %10 = getelementptr inbounds i8, ptr %0, i64 24
  %11 = getelementptr inbounds i8, ptr %0, i64 40
  %12 = load ptr, ptr %11, align 8, !tbaa !9
  %13 = zext i16 %1 to i64
  %14 = getelementptr inbounds ptr, ptr %12, i64 %13
  %15 = load ptr, ptr %14, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %7) #4
  store i32 0, ptr %7, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %8) #4
  store i32 0, ptr %8, align 4, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr nonnull %9) #4
  store i32 0, ptr %9, align 4, !tbaa !15
  %16 = getelementptr inbounds i8, ptr %15, i64 8
  %17 = load i16, ptr %16, align 8, !tbaa !16
  %.not268 = icmp eq i16 %17, 0
  br i1 %.not268, label %.thread, label %.lr.ph

.lr.ph:                                           ; preds = %3
  %18 = getelementptr inbounds i8, ptr %15, i64 10
  %19 = getelementptr inbounds i8, ptr %15, i64 12
  %20 = getelementptr inbounds i8, ptr %15, i64 16
  br label %25

21:                                               ; preds = %45
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %22 = load i16, ptr %16, align 8, !tbaa !16
  %23 = zext i16 %22 to i64
  %24 = icmp ult i64 %indvars.iv.next, %23
  br i1 %24, label %25, label %.thread, !llvm.loop !18

25:                                               ; preds = %.lr.ph, %21
  %indvars.iv = phi i64 [ 0, %.lr.ph ], [ %indvars.iv.next, %21 ]
  %26 = load i16, ptr %18, align 2, !tbaa !20
  %27 = zext i16 %26 to i64
  %28 = icmp ult i64 %indvars.iv, %27
  br i1 %28, label %29, label %34

29:                                               ; preds = %25
  %30 = load ptr, ptr %20, align 8, !tbaa !21
  %31 = getelementptr inbounds ptr, ptr %30, i64 %indvars.iv
  %32 = load ptr, ptr %31, align 8, !tbaa !5
  %33 = call i32 @classCompatible(ptr noundef nonnull %4, ptr noundef %32, ptr noundef nonnull %7)
  br label %45

34:                                               ; preds = %25
  %35 = load i16, ptr %19, align 4, !tbaa !22
  %36 = zext i16 %35 to i64
  %37 = icmp ult i64 %indvars.iv, %36
  %38 = load ptr, ptr %20, align 8, !tbaa !21
  %39 = getelementptr inbounds ptr, ptr %38, i64 %indvars.iv
  %40 = load ptr, ptr %39, align 8, !tbaa !5
  br i1 %37, label %41, label %43

41:                                               ; preds = %34
  %42 = call i32 @classCompatible(ptr noundef nonnull %5, ptr noundef %40, ptr noundef nonnull %8)
  br label %45

43:                                               ; preds = %34
  %44 = call i32 @classCompatible(ptr noundef nonnull %6, ptr noundef %40, ptr noundef nonnull %9)
  br label %45

45:                                               ; preds = %41, %43, %29
  %.0174 = phi i32 [ %33, %29 ], [ %42, %41 ], [ %44, %43 ]
  %.not.not = icmp eq i32 %.0174, 0
  br i1 %.not.not, label %.loopexit250, label %21

.thread:                                          ; preds = %21, %3
  %46 = add i16 %1, 1
  %47 = zext i16 %46 to i64
  %48 = load i64, ptr %10, align 8, !tbaa !23
  %49 = icmp ugt i64 %48, %47
  br i1 %49, label %.lr.ph258, label %.loopexit250

.lr.ph258:                                        ; preds = %.thread, %.thread233
  %50 = phi i64 [ %64, %.thread233 ], [ %48, %.thread ]
  %51 = phi i64 [ %67, %.thread233 ], [ %47, %.thread ]
  %.0165257 = phi i16 [ %65, %.thread233 ], [ 0, %.thread ]
  %.0177256 = phi i16 [ %66, %.thread233 ], [ %46, %.thread ]
  %52 = load ptr, ptr %11, align 8, !tbaa !9
  %53 = getelementptr inbounds ptr, ptr %52, i64 %51
  %54 = load ptr, ptr %53, align 8, !tbaa !5
  %55 = getelementptr inbounds i8, ptr %54, i64 8
  %56 = load i16, ptr %55, align 8, !tbaa !16
  %.not269 = icmp eq i16 %56, 0
  br i1 %.not269, label %.thread233, label %.lr.ph255

.lr.ph255:                                        ; preds = %.lr.ph258
  %57 = getelementptr inbounds i8, ptr %54, i64 10
  %58 = getelementptr inbounds i8, ptr %54, i64 12
  %59 = getelementptr inbounds i8, ptr %54, i64 16
  br label %69

60:                                               ; preds = %89
  %indvars.iv.next274 = add nuw nsw i64 %indvars.iv273, 1
  %61 = load i16, ptr %55, align 8, !tbaa !16
  %62 = zext i16 %61 to i64
  %63 = icmp ult i64 %indvars.iv.next274, %62
  br i1 %63, label %69, label %.thread233.loopexit, !llvm.loop !24

.thread233.loopexit:                              ; preds = %60
  %.pre = load i64, ptr %10, align 8, !tbaa !23
  br label %.thread233

.thread233:                                       ; preds = %.thread233.loopexit, %.lr.ph258
  %64 = phi i64 [ %.pre, %.thread233.loopexit ], [ %50, %.lr.ph258 ]
  %65 = add i16 %.0165257, 1
  %66 = add i16 %.0177256, 1
  %67 = zext i16 %66 to i64
  %68 = icmp ugt i64 %64, %67
  br i1 %68, label %.lr.ph258, label %.thread242, !llvm.loop !25

69:                                               ; preds = %.lr.ph255, %60
  %indvars.iv273 = phi i64 [ 0, %.lr.ph255 ], [ %indvars.iv.next274, %60 ]
  %70 = load i16, ptr %57, align 2, !tbaa !20
  %71 = zext i16 %70 to i64
  %72 = icmp ult i64 %indvars.iv273, %71
  br i1 %72, label %73, label %78

73:                                               ; preds = %69
  %74 = load ptr, ptr %59, align 8, !tbaa !21
  %75 = getelementptr inbounds ptr, ptr %74, i64 %indvars.iv273
  %76 = load ptr, ptr %75, align 8, !tbaa !5
  %77 = call i32 @classCompatible(ptr noundef nonnull %4, ptr noundef %76, ptr noundef nonnull %7)
  br label %89

78:                                               ; preds = %69
  %79 = load i16, ptr %58, align 4, !tbaa !22
  %80 = zext i16 %79 to i64
  %81 = icmp ult i64 %indvars.iv273, %80
  %82 = load ptr, ptr %59, align 8, !tbaa !21
  %83 = getelementptr inbounds ptr, ptr %82, i64 %indvars.iv273
  %84 = load ptr, ptr %83, align 8, !tbaa !5
  br i1 %81, label %85, label %87

85:                                               ; preds = %78
  %86 = call i32 @classCompatible(ptr noundef nonnull %5, ptr noundef %84, ptr noundef nonnull %8)
  br label %89

87:                                               ; preds = %78
  %88 = call i32 @classCompatible(ptr noundef nonnull %6, ptr noundef %84, ptr noundef nonnull %9)
  br label %89

89:                                               ; preds = %85, %87, %73
  %.0184 = phi i32 [ %77, %73 ], [ %86, %85 ], [ %88, %87 ]
  %.not.not210 = icmp eq i32 %.0184, 0
  br i1 %.not.not210, label %.thread242, label %60

.thread242:                                       ; preds = %.thread233, %89
  %.0165252 = phi i16 [ %.0165257, %89 ], [ %65, %.thread233 ]
  %90 = icmp ugt i16 %.0165252, 1
  br i1 %90, label %91, label %.loopexit250

91:                                               ; preds = %.thread242
  %92 = zext i16 %.0165252 to i32
  %93 = call ptr @__caryll_allocate_clean(i64 noundef 48, i64 noundef 170)
  %94 = add nuw nsw i32 %92, 1
  %95 = trunc i32 %94 to i16
  %96 = getelementptr inbounds i8, ptr %93, i64 8
  store i16 %95, ptr %96, align 8, !tbaa !26
  %97 = shl nuw nsw i32 %94, 3
  %98 = zext nneg i32 %97 to i64
  %99 = call ptr @__caryll_allocate_clean(i64 noundef %98, i64 noundef 172)
  %100 = getelementptr inbounds i8, ptr %93, i64 16
  store ptr %99, ptr %100, align 8, !tbaa !26
  %101 = load ptr, ptr %4, align 8, !tbaa !5
  %102 = load ptr, ptr %5, align 8, !tbaa !5
  %103 = load ptr, ptr %6, align 8, !tbaa !5
  %104 = call ptr @buildRule(ptr noundef nonnull %16, ptr noundef %101, ptr noundef %102, ptr noundef %103)
  %105 = load ptr, ptr %100, align 8, !tbaa !26
  store ptr %104, ptr %105, align 8, !tbaa !5
  %106 = load i64, ptr %10, align 8, !tbaa !23
  %107 = icmp ugt i64 %106, %47
  br i1 %107, label %.lr.ph261, label %._crit_edge

._crit_edge:                                      ; preds = %.lr.ph261, %91
  store i32 2, ptr %93, align 8, !tbaa !27
  %108 = call ptr @toClass(ptr noundef nonnull %4)
  %109 = getelementptr inbounds i8, ptr %93, i64 24
  store ptr %108, ptr %109, align 8, !tbaa !26
  %110 = call ptr @toClass(ptr noundef nonnull %5)
  %111 = getelementptr inbounds i8, ptr %93, i64 32
  store ptr %110, ptr %111, align 8, !tbaa !26
  %112 = call ptr @toClass(ptr noundef nonnull %6)
  %113 = getelementptr inbounds i8, ptr %93, i64 40
  store ptr %112, ptr %113, align 8, !tbaa !26
  store ptr %93, ptr %2, align 8, !tbaa !5
  br label %.loopexit250

.lr.ph261:                                        ; preds = %91, %.lr.ph261
  %114 = phi i64 [ %128, %.lr.ph261 ], [ %47, %91 ]
  %.0185260 = phi i16 [ %127, %.lr.ph261 ], [ %46, %91 ]
  %.0186259 = phi i16 [ %126, %.lr.ph261 ], [ 1, %91 ]
  %115 = load ptr, ptr %11, align 8, !tbaa !9
  %116 = getelementptr inbounds ptr, ptr %115, i64 %114
  %117 = load ptr, ptr %116, align 8, !tbaa !5
  %118 = getelementptr inbounds i8, ptr %117, i64 8
  %119 = load ptr, ptr %4, align 8, !tbaa !5
  %120 = load ptr, ptr %5, align 8, !tbaa !5
  %121 = load ptr, ptr %6, align 8, !tbaa !5
  %122 = call ptr @buildRule(ptr noundef nonnull %118, ptr noundef %119, ptr noundef %120, ptr noundef %121)
  %123 = load ptr, ptr %100, align 8, !tbaa !26
  %124 = zext i16 %.0186259 to i64
  %125 = getelementptr inbounds ptr, ptr %123, i64 %124
  store ptr %122, ptr %125, align 8, !tbaa !5
  %126 = add i16 %.0186259, 1
  %127 = add i16 %.0185260, 1
  %128 = zext i16 %127 to i64
  %129 = load i64, ptr %10, align 8, !tbaa !23
  %130 = icmp ugt i64 %129, %128
  %131 = icmp uge i16 %.0165252, %126
  %132 = select i1 %130, i1 %131, i1 false
  br i1 %132, label %.lr.ph261, label %._crit_edge, !llvm.loop !29

.loopexit250:                                     ; preds = %45, %.thread, %.thread242, %._crit_edge
  %.4 = phi i16 [ %.0165252, %._crit_edge ], [ %.0165252, %.thread242 ], [ 0, %.thread ], [ 0, %45 ]
  %133 = load ptr, ptr %4, align 8, !tbaa !5
  %.not = icmp eq ptr %133, null
  br i1 %.not, label %.loopexit248, label %.preheader312

.preheader312:                                    ; preds = %.loopexit250, %214
  %.sink308 = phi ptr [ %135, %214 ], [ %133, %.loopexit250 ]
  %134 = getelementptr inbounds i8, ptr %.sink308, i64 40
  %135 = load ptr, ptr %134, align 8, !tbaa !30
  %136 = getelementptr inbounds i8, ptr %.sink308, i64 24
  %137 = getelementptr inbounds i8, ptr %.sink308, i64 32
  %138 = load ptr, ptr %137, align 8, !tbaa !33
  %139 = icmp eq ptr %138, null
  br i1 %139, label %140, label %._crit_edge276

._crit_edge276:                                   ; preds = %.preheader312
  %.pre277 = load ptr, ptr %4, align 8, !tbaa !5
  br label %151

140:                                              ; preds = %.preheader312
  %141 = getelementptr inbounds i8, ptr %.sink308, i64 40
  %142 = load ptr, ptr %141, align 8, !tbaa !34
  %143 = icmp eq ptr %142, null
  %.pre278 = load ptr, ptr %4, align 8, !tbaa !5
  br i1 %143, label %144, label %151

144:                                              ; preds = %140
  %145 = getelementptr inbounds i8, ptr %.pre278, i64 24
  %146 = load ptr, ptr %145, align 8, !tbaa !35
  %147 = load ptr, ptr %146, align 8, !tbaa !36
  call void @free(ptr noundef %147) #4
  %148 = load ptr, ptr %4, align 8, !tbaa !5
  %149 = getelementptr inbounds i8, ptr %148, i64 24
  %150 = load ptr, ptr %149, align 8, !tbaa !35
  call void @free(ptr noundef %150) #4
  store ptr null, ptr %4, align 8, !tbaa !5
  br label %214

151:                                              ; preds = %._crit_edge276, %140
  %152 = phi ptr [ %.pre277, %._crit_edge276 ], [ %.pre278, %140 ]
  %153 = getelementptr inbounds i8, ptr %152, i64 24
  %154 = load ptr, ptr %153, align 8, !tbaa !35
  %155 = getelementptr inbounds i8, ptr %154, i64 24
  %156 = load ptr, ptr %155, align 8, !tbaa !38
  %157 = icmp eq ptr %136, %156
  br i1 %157, label %158, label %162

158:                                              ; preds = %151
  %159 = getelementptr inbounds i8, ptr %154, i64 32
  %160 = load i64, ptr %159, align 8, !tbaa !39
  %161 = getelementptr inbounds i8, ptr %138, i64 %160
  store ptr %161, ptr %155, align 8, !tbaa !38
  br label %162

162:                                              ; preds = %158, %151
  %163 = getelementptr inbounds i8, ptr %.sink308, i64 40
  %164 = load ptr, ptr %163, align 8, !tbaa !34
  br i1 %139, label %170, label %165

165:                                              ; preds = %162
  %166 = getelementptr inbounds i8, ptr %154, i64 32
  %167 = load i64, ptr %166, align 8, !tbaa !39
  %168 = getelementptr inbounds i8, ptr %138, i64 %167
  %169 = getelementptr inbounds i8, ptr %168, i64 16
  store ptr %164, ptr %169, align 8, !tbaa !34
  %.pre280.pre = load ptr, ptr %4, align 8, !tbaa !5
  br label %171

170:                                              ; preds = %162
  store ptr %164, ptr %4, align 8, !tbaa !5
  br label %171

171:                                              ; preds = %170, %165
  %.pre280 = phi ptr [ %164, %170 ], [ %.pre280.pre, %165 ]
  %.not227 = icmp eq ptr %164, null
  br i1 %.not227, label %179, label %172

172:                                              ; preds = %171
  %173 = getelementptr inbounds i8, ptr %.pre280, i64 24
  %174 = load ptr, ptr %173, align 8, !tbaa !35
  %175 = getelementptr inbounds i8, ptr %174, i64 32
  %176 = load i64, ptr %175, align 8, !tbaa !39
  %177 = getelementptr inbounds i8, ptr %164, i64 %176
  %178 = getelementptr inbounds i8, ptr %177, i64 8
  store ptr %138, ptr %178, align 8, !tbaa !33
  %.pre279 = load ptr, ptr %4, align 8, !tbaa !5
  br label %179

179:                                              ; preds = %171, %172
  %180 = phi ptr [ %.pre280, %171 ], [ %.pre279, %172 ]
  %181 = getelementptr inbounds i8, ptr %.sink308, i64 76
  %182 = load i32, ptr %181, align 4, !tbaa !40
  %183 = getelementptr inbounds i8, ptr %180, i64 24
  %184 = load ptr, ptr %183, align 8, !tbaa !35
  %185 = getelementptr inbounds i8, ptr %184, i64 8
  %186 = load i32, ptr %185, align 8, !tbaa !41
  %187 = add i32 %186, -1
  %188 = and i32 %187, %182
  %189 = load ptr, ptr %184, align 8, !tbaa !36
  %190 = zext i32 %188 to i64
  %191 = getelementptr inbounds %struct.UT_hash_bucket, ptr %189, i64 %190
  %192 = getelementptr inbounds i8, ptr %191, i64 8
  %193 = load i32, ptr %192, align 8, !tbaa !42
  %194 = add i32 %193, -1
  store i32 %194, ptr %192, align 8, !tbaa !42
  %195 = load ptr, ptr %191, align 8, !tbaa !44
  %196 = icmp eq ptr %195, %136
  br i1 %196, label %197, label %200

197:                                              ; preds = %179
  %198 = getelementptr inbounds i8, ptr %.sink308, i64 56
  %199 = load ptr, ptr %198, align 8, !tbaa !45
  store ptr %199, ptr %191, align 8, !tbaa !44
  br label %200

200:                                              ; preds = %197, %179
  %201 = getelementptr inbounds i8, ptr %.sink308, i64 48
  %202 = load ptr, ptr %201, align 8, !tbaa !46
  %.not228 = icmp eq ptr %202, null
  %.phi.trans.insert = getelementptr inbounds i8, ptr %.sink308, i64 56
  %.pre282 = load ptr, ptr %.phi.trans.insert, align 8, !tbaa !45
  br i1 %.not228, label %._crit_edge281, label %203

203:                                              ; preds = %200
  %204 = getelementptr inbounds i8, ptr %202, i64 32
  store ptr %.pre282, ptr %204, align 8, !tbaa !45
  br label %._crit_edge281

._crit_edge281:                                   ; preds = %200, %203
  %.not229 = icmp eq ptr %.pre282, null
  br i1 %.not229, label %207, label %205

205:                                              ; preds = %._crit_edge281
  %206 = getelementptr inbounds i8, ptr %.pre282, i64 24
  store ptr %202, ptr %206, align 8, !tbaa !46
  br label %207

207:                                              ; preds = %205, %._crit_edge281
  %208 = load ptr, ptr %4, align 8, !tbaa !5
  %209 = getelementptr inbounds i8, ptr %208, i64 24
  %210 = load ptr, ptr %209, align 8, !tbaa !35
  %211 = getelementptr inbounds i8, ptr %210, i64 16
  %212 = load i32, ptr %211, align 8, !tbaa !47
  %213 = add i32 %212, -1
  store i32 %213, ptr %211, align 8, !tbaa !47
  br label %214

214:                                              ; preds = %207, %144
  call void @free(ptr noundef nonnull %.sink308) #4
  %.not230 = icmp eq ptr %135, null
  br i1 %.not230, label %.loopexit248, label %.preheader312, !llvm.loop !48

.loopexit248:                                     ; preds = %214, %.loopexit250
  %215 = load ptr, ptr %5, align 8, !tbaa !5
  %.not212 = icmp eq ptr %215, null
  br i1 %.not212, label %.loopexit247, label %.preheader311

.preheader311:                                    ; preds = %.loopexit248, %296
  %.sink309 = phi ptr [ %217, %296 ], [ %215, %.loopexit248 ]
  %216 = getelementptr inbounds i8, ptr %.sink309, i64 40
  %217 = load ptr, ptr %216, align 8, !tbaa !30
  %218 = getelementptr inbounds i8, ptr %.sink309, i64 24
  %219 = getelementptr inbounds i8, ptr %.sink309, i64 32
  %220 = load ptr, ptr %219, align 8, !tbaa !33
  %221 = icmp eq ptr %220, null
  br i1 %221, label %222, label %._crit_edge283

._crit_edge283:                                   ; preds = %.preheader311
  %.pre284 = load ptr, ptr %5, align 8, !tbaa !5
  br label %233

222:                                              ; preds = %.preheader311
  %223 = getelementptr inbounds i8, ptr %.sink309, i64 40
  %224 = load ptr, ptr %223, align 8, !tbaa !34
  %225 = icmp eq ptr %224, null
  %.pre285 = load ptr, ptr %5, align 8, !tbaa !5
  br i1 %225, label %226, label %233

226:                                              ; preds = %222
  %227 = getelementptr inbounds i8, ptr %.pre285, i64 24
  %228 = load ptr, ptr %227, align 8, !tbaa !35
  %229 = load ptr, ptr %228, align 8, !tbaa !36
  call void @free(ptr noundef %229) #4
  %230 = load ptr, ptr %5, align 8, !tbaa !5
  %231 = getelementptr inbounds i8, ptr %230, i64 24
  %232 = load ptr, ptr %231, align 8, !tbaa !35
  call void @free(ptr noundef %232) #4
  store ptr null, ptr %5, align 8, !tbaa !5
  br label %296

233:                                              ; preds = %._crit_edge283, %222
  %234 = phi ptr [ %.pre284, %._crit_edge283 ], [ %.pre285, %222 ]
  %235 = getelementptr inbounds i8, ptr %234, i64 24
  %236 = load ptr, ptr %235, align 8, !tbaa !35
  %237 = getelementptr inbounds i8, ptr %236, i64 24
  %238 = load ptr, ptr %237, align 8, !tbaa !38
  %239 = icmp eq ptr %218, %238
  br i1 %239, label %240, label %244

240:                                              ; preds = %233
  %241 = getelementptr inbounds i8, ptr %236, i64 32
  %242 = load i64, ptr %241, align 8, !tbaa !39
  %243 = getelementptr inbounds i8, ptr %220, i64 %242
  store ptr %243, ptr %237, align 8, !tbaa !38
  br label %244

244:                                              ; preds = %240, %233
  %245 = getelementptr inbounds i8, ptr %.sink309, i64 40
  %246 = load ptr, ptr %245, align 8, !tbaa !34
  br i1 %221, label %252, label %247

247:                                              ; preds = %244
  %248 = getelementptr inbounds i8, ptr %236, i64 32
  %249 = load i64, ptr %248, align 8, !tbaa !39
  %250 = getelementptr inbounds i8, ptr %220, i64 %249
  %251 = getelementptr inbounds i8, ptr %250, i64 16
  store ptr %246, ptr %251, align 8, !tbaa !34
  %.pre287.pre = load ptr, ptr %5, align 8, !tbaa !5
  br label %253

252:                                              ; preds = %244
  store ptr %246, ptr %5, align 8, !tbaa !5
  br label %253

253:                                              ; preds = %252, %247
  %.pre287 = phi ptr [ %246, %252 ], [ %.pre287.pre, %247 ]
  %.not222 = icmp eq ptr %246, null
  br i1 %.not222, label %261, label %254

254:                                              ; preds = %253
  %255 = getelementptr inbounds i8, ptr %.pre287, i64 24
  %256 = load ptr, ptr %255, align 8, !tbaa !35
  %257 = getelementptr inbounds i8, ptr %256, i64 32
  %258 = load i64, ptr %257, align 8, !tbaa !39
  %259 = getelementptr inbounds i8, ptr %246, i64 %258
  %260 = getelementptr inbounds i8, ptr %259, i64 8
  store ptr %220, ptr %260, align 8, !tbaa !33
  %.pre286 = load ptr, ptr %5, align 8, !tbaa !5
  br label %261

261:                                              ; preds = %253, %254
  %262 = phi ptr [ %.pre287, %253 ], [ %.pre286, %254 ]
  %263 = getelementptr inbounds i8, ptr %.sink309, i64 76
  %264 = load i32, ptr %263, align 4, !tbaa !40
  %265 = getelementptr inbounds i8, ptr %262, i64 24
  %266 = load ptr, ptr %265, align 8, !tbaa !35
  %267 = getelementptr inbounds i8, ptr %266, i64 8
  %268 = load i32, ptr %267, align 8, !tbaa !41
  %269 = add i32 %268, -1
  %270 = and i32 %269, %264
  %271 = load ptr, ptr %266, align 8, !tbaa !36
  %272 = zext i32 %270 to i64
  %273 = getelementptr inbounds %struct.UT_hash_bucket, ptr %271, i64 %272
  %274 = getelementptr inbounds i8, ptr %273, i64 8
  %275 = load i32, ptr %274, align 8, !tbaa !42
  %276 = add i32 %275, -1
  store i32 %276, ptr %274, align 8, !tbaa !42
  %277 = load ptr, ptr %273, align 8, !tbaa !44
  %278 = icmp eq ptr %277, %218
  br i1 %278, label %279, label %282

279:                                              ; preds = %261
  %280 = getelementptr inbounds i8, ptr %.sink309, i64 56
  %281 = load ptr, ptr %280, align 8, !tbaa !45
  store ptr %281, ptr %273, align 8, !tbaa !44
  br label %282

282:                                              ; preds = %279, %261
  %283 = getelementptr inbounds i8, ptr %.sink309, i64 48
  %284 = load ptr, ptr %283, align 8, !tbaa !46
  %.not223 = icmp eq ptr %284, null
  %.phi.trans.insert289 = getelementptr inbounds i8, ptr %.sink309, i64 56
  %.pre290 = load ptr, ptr %.phi.trans.insert289, align 8, !tbaa !45
  br i1 %.not223, label %._crit_edge288, label %285

285:                                              ; preds = %282
  %286 = getelementptr inbounds i8, ptr %284, i64 32
  store ptr %.pre290, ptr %286, align 8, !tbaa !45
  br label %._crit_edge288

._crit_edge288:                                   ; preds = %282, %285
  %.not224 = icmp eq ptr %.pre290, null
  br i1 %.not224, label %289, label %287

287:                                              ; preds = %._crit_edge288
  %288 = getelementptr inbounds i8, ptr %.pre290, i64 24
  store ptr %284, ptr %288, align 8, !tbaa !46
  br label %289

289:                                              ; preds = %287, %._crit_edge288
  %290 = load ptr, ptr %5, align 8, !tbaa !5
  %291 = getelementptr inbounds i8, ptr %290, i64 24
  %292 = load ptr, ptr %291, align 8, !tbaa !35
  %293 = getelementptr inbounds i8, ptr %292, i64 16
  %294 = load i32, ptr %293, align 8, !tbaa !47
  %295 = add i32 %294, -1
  store i32 %295, ptr %293, align 8, !tbaa !47
  br label %296

296:                                              ; preds = %289, %226
  call void @free(ptr noundef nonnull %.sink309) #4
  %.not225 = icmp eq ptr %217, null
  br i1 %.not225, label %.loopexit247, label %.preheader311, !llvm.loop !49

.loopexit247:                                     ; preds = %296, %.loopexit248
  %297 = load ptr, ptr %6, align 8, !tbaa !5
  %.not214 = icmp eq ptr %297, null
  br i1 %.not214, label %.loopexit, label %.preheader

.preheader:                                       ; preds = %.loopexit247, %378
  %.sink310 = phi ptr [ %299, %378 ], [ %297, %.loopexit247 ]
  %298 = getelementptr inbounds i8, ptr %.sink310, i64 40
  %299 = load ptr, ptr %298, align 8, !tbaa !30
  %300 = getelementptr inbounds i8, ptr %.sink310, i64 24
  %301 = getelementptr inbounds i8, ptr %.sink310, i64 32
  %302 = load ptr, ptr %301, align 8, !tbaa !33
  %303 = icmp eq ptr %302, null
  br i1 %303, label %304, label %._crit_edge291

._crit_edge291:                                   ; preds = %.preheader
  %.pre292 = load ptr, ptr %6, align 8, !tbaa !5
  br label %315

304:                                              ; preds = %.preheader
  %305 = getelementptr inbounds i8, ptr %.sink310, i64 40
  %306 = load ptr, ptr %305, align 8, !tbaa !34
  %307 = icmp eq ptr %306, null
  %.pre293 = load ptr, ptr %6, align 8, !tbaa !5
  br i1 %307, label %308, label %315

308:                                              ; preds = %304
  %309 = getelementptr inbounds i8, ptr %.pre293, i64 24
  %310 = load ptr, ptr %309, align 8, !tbaa !35
  %311 = load ptr, ptr %310, align 8, !tbaa !36
  call void @free(ptr noundef %311) #4
  %312 = load ptr, ptr %6, align 8, !tbaa !5
  %313 = getelementptr inbounds i8, ptr %312, i64 24
  %314 = load ptr, ptr %313, align 8, !tbaa !35
  call void @free(ptr noundef %314) #4
  store ptr null, ptr %6, align 8, !tbaa !5
  br label %378

315:                                              ; preds = %._crit_edge291, %304
  %316 = phi ptr [ %.pre292, %._crit_edge291 ], [ %.pre293, %304 ]
  %317 = getelementptr inbounds i8, ptr %316, i64 24
  %318 = load ptr, ptr %317, align 8, !tbaa !35
  %319 = getelementptr inbounds i8, ptr %318, i64 24
  %320 = load ptr, ptr %319, align 8, !tbaa !38
  %321 = icmp eq ptr %300, %320
  br i1 %321, label %322, label %326

322:                                              ; preds = %315
  %323 = getelementptr inbounds i8, ptr %318, i64 32
  %324 = load i64, ptr %323, align 8, !tbaa !39
  %325 = getelementptr inbounds i8, ptr %302, i64 %324
  store ptr %325, ptr %319, align 8, !tbaa !38
  br label %326

326:                                              ; preds = %322, %315
  %327 = getelementptr inbounds i8, ptr %.sink310, i64 40
  %328 = load ptr, ptr %327, align 8, !tbaa !34
  br i1 %303, label %334, label %329

329:                                              ; preds = %326
  %330 = getelementptr inbounds i8, ptr %318, i64 32
  %331 = load i64, ptr %330, align 8, !tbaa !39
  %332 = getelementptr inbounds i8, ptr %302, i64 %331
  %333 = getelementptr inbounds i8, ptr %332, i64 16
  store ptr %328, ptr %333, align 8, !tbaa !34
  %.pre295.pre = load ptr, ptr %6, align 8, !tbaa !5
  br label %335

334:                                              ; preds = %326
  store ptr %328, ptr %6, align 8, !tbaa !5
  br label %335

335:                                              ; preds = %334, %329
  %.pre295 = phi ptr [ %328, %334 ], [ %.pre295.pre, %329 ]
  %.not217 = icmp eq ptr %328, null
  br i1 %.not217, label %343, label %336

336:                                              ; preds = %335
  %337 = getelementptr inbounds i8, ptr %.pre295, i64 24
  %338 = load ptr, ptr %337, align 8, !tbaa !35
  %339 = getelementptr inbounds i8, ptr %338, i64 32
  %340 = load i64, ptr %339, align 8, !tbaa !39
  %341 = getelementptr inbounds i8, ptr %328, i64 %340
  %342 = getelementptr inbounds i8, ptr %341, i64 8
  store ptr %302, ptr %342, align 8, !tbaa !33
  %.pre294 = load ptr, ptr %6, align 8, !tbaa !5
  br label %343

343:                                              ; preds = %335, %336
  %344 = phi ptr [ %.pre295, %335 ], [ %.pre294, %336 ]
  %345 = getelementptr inbounds i8, ptr %.sink310, i64 76
  %346 = load i32, ptr %345, align 4, !tbaa !40
  %347 = getelementptr inbounds i8, ptr %344, i64 24
  %348 = load ptr, ptr %347, align 8, !tbaa !35
  %349 = getelementptr inbounds i8, ptr %348, i64 8
  %350 = load i32, ptr %349, align 8, !tbaa !41
  %351 = add i32 %350, -1
  %352 = and i32 %351, %346
  %353 = load ptr, ptr %348, align 8, !tbaa !36
  %354 = zext i32 %352 to i64
  %355 = getelementptr inbounds %struct.UT_hash_bucket, ptr %353, i64 %354
  %356 = getelementptr inbounds i8, ptr %355, i64 8
  %357 = load i32, ptr %356, align 8, !tbaa !42
  %358 = add i32 %357, -1
  store i32 %358, ptr %356, align 8, !tbaa !42
  %359 = load ptr, ptr %355, align 8, !tbaa !44
  %360 = icmp eq ptr %359, %300
  br i1 %360, label %361, label %364

361:                                              ; preds = %343
  %362 = getelementptr inbounds i8, ptr %.sink310, i64 56
  %363 = load ptr, ptr %362, align 8, !tbaa !45
  store ptr %363, ptr %355, align 8, !tbaa !44
  br label %364

364:                                              ; preds = %361, %343
  %365 = getelementptr inbounds i8, ptr %.sink310, i64 48
  %366 = load ptr, ptr %365, align 8, !tbaa !46
  %.not218 = icmp eq ptr %366, null
  %.phi.trans.insert297 = getelementptr inbounds i8, ptr %.sink310, i64 56
  %.pre298 = load ptr, ptr %.phi.trans.insert297, align 8, !tbaa !45
  br i1 %.not218, label %._crit_edge296, label %367

367:                                              ; preds = %364
  %368 = getelementptr inbounds i8, ptr %366, i64 32
  store ptr %.pre298, ptr %368, align 8, !tbaa !45
  br label %._crit_edge296

._crit_edge296:                                   ; preds = %364, %367
  %.not219 = icmp eq ptr %.pre298, null
  br i1 %.not219, label %371, label %369

369:                                              ; preds = %._crit_edge296
  %370 = getelementptr inbounds i8, ptr %.pre298, i64 24
  store ptr %366, ptr %370, align 8, !tbaa !46
  br label %371

371:                                              ; preds = %369, %._crit_edge296
  %372 = load ptr, ptr %6, align 8, !tbaa !5
  %373 = getelementptr inbounds i8, ptr %372, i64 24
  %374 = load ptr, ptr %373, align 8, !tbaa !35
  %375 = getelementptr inbounds i8, ptr %374, i64 16
  %376 = load i32, ptr %375, align 8, !tbaa !47
  %377 = add i32 %376, -1
  store i32 %377, ptr %375, align 8, !tbaa !47
  br label %378

378:                                              ; preds = %371, %308
  call void @free(ptr noundef nonnull %.sink310) #4
  %.not220 = icmp eq ptr %299, null
  br i1 %.not220, label %.loopexit, label %.preheader, !llvm.loop !50

.loopexit:                                        ; preds = %378, %.loopexit247
  %379 = icmp ugt i16 %.4, 1
  %.4. = select i1 %379, i16 %.4, i16 0
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %9) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %8) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr nonnull %7) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %6) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %5) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %4) #4
  ret i16 %.4.
}

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

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

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

; Function Attrs: inlinehint nounwind uwtable
declare hidden ptr @__caryll_allocate_clean(i64 noundef, i64 noundef) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare hidden ptr @buildRule(ptr noundef, ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare hidden ptr @toClass(ptr noundef) local_unnamed_addr #0

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

attributes #0 = { 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 #1 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #2 = { inlinehint 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 #3 = { 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 #4 = { nounwind }

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !6, i64 40}
!10 = !{!"_otl_lookup", !6, i64 0, !11, i64 8, !11, i64 12, !12, i64 16, !13, i64 24}
!11 = !{!"int", !7, i64 0}
!12 = !{!"short", !7, i64 0}
!13 = !{!"", !14, i64 0, !14, i64 8, !6, i64 16}
!14 = !{!"long", !7, i64 0}
!15 = !{!11, !11, i64 0}
!16 = !{!17, !12, i64 0}
!17 = !{!"", !12, i64 0, !12, i64 2, !12, i64 4, !6, i64 8, !12, i64 16, !6, i64 24}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.mustprogress"}
!20 = !{!17, !12, i64 2}
!21 = !{!17, !6, i64 8}
!22 = !{!17, !12, i64 4}
!23 = !{!10, !14, i64 24}
!24 = distinct !{!24, !19}
!25 = distinct !{!25, !19}
!26 = !{!7, !7, i64 0}
!27 = !{!28, !11, i64 0}
!28 = !{!"", !11, i64 0, !7, i64 8}
!29 = distinct !{!29, !19}
!30 = !{!31, !6, i64 40}
!31 = !{!"", !11, i64 0, !6, i64 8, !11, i64 16, !32, i64 24}
!32 = !{!"UT_hash_handle", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !11, i64 48, !11, i64 52}
!33 = !{!32, !6, i64 8}
!34 = !{!32, !6, i64 16}
!35 = !{!31, !6, i64 24}
!36 = !{!37, !6, i64 0}
!37 = !{!"UT_hash_table", !6, i64 0, !11, i64 8, !11, i64 12, !11, i64 16, !6, i64 24, !14, i64 32, !11, i64 40, !11, i64 44, !11, i64 48, !11, i64 52, !11, i64 56}
!38 = !{!37, !6, i64 24}
!39 = !{!37, !14, i64 32}
!40 = !{!32, !11, i64 52}
!41 = !{!37, !11, i64 8}
!42 = !{!43, !11, i64 8}
!43 = !{!"UT_hash_bucket", !6, i64 0, !11, i64 8, !11, i64 12}
!44 = !{!43, !6, i64 0}
!45 = !{!32, !6, i64 32}
!46 = !{!32, !6, i64 24}
!47 = !{!37, !11, i64 16}
!48 = distinct !{!48, !19}
!49 = distinct !{!49, !19}
!50 = distinct !{!50, !19}


; Effective O3 passes: BDCEPass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopInstSimplifyPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,PostOrderFunctionAttrsPass,ReassociatePass,SROAPass,SimplifyCFGPass