; LLVM IR from freddiev4/dailyprogrammerchallenges :: Easy Challenges/Challenge 0022 Easy/solutions (solution)

; 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.my_struct = type { i32, i16, %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 }

@users = external dso_local global ptr, align 8
@.str = external hidden unnamed_addr constant [10 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [126 x i8], align 1
@__PRETTY_FUNCTION__.add_element = external hidden unnamed_addr constant [27 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @add_element(i32 noundef %0, i32 noundef %1) #0 {
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca ptr, align 8
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca ptr, align 8
  %12 = alloca i32, align 4
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca ptr, align 8
  %17 = alloca i32, align 4
  %18 = alloca i32, align 4
  %19 = alloca ptr, align 8
  %20 = alloca ptr, align 8
  %21 = alloca ptr, align 8
  %22 = alloca ptr, align 8
  store i32 %0, ptr %3, align 4, !tbaa !5
  store i32 %1, ptr %4, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #7
  br label %23

23:                                               ; preds = %2
  store ptr null, ptr %5, align 8, !tbaa !9
  %24 = load ptr, ptr @users, align 8, !tbaa !9
  %25 = icmp ne ptr %24, null
  br i1 %25, label %26, label %480

26:                                               ; preds = %23
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #7
  br label %27

27:                                               ; preds = %26
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %10) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #7
  store ptr %3, ptr %11, align 8, !tbaa !9
  store i32 -17973521, ptr %7, align 4, !tbaa !5
  store i32 -1640531527, ptr %9, align 4, !tbaa !5
  store i32 -1640531527, ptr %8, align 4, !tbaa !5
  store i32 4, ptr %10, align 4, !tbaa !5
  br label %28

28:                                               ; preds = %196, %27
  %29 = load i32, ptr %10, align 4, !tbaa !5
  %30 = icmp uge i32 %29, 12
  br i1 %30, label %31, label %201

31:                                               ; preds = %28
  %32 = load ptr, ptr %11, align 8, !tbaa !9
  %33 = getelementptr inbounds i8, ptr %32, i64 0
  %34 = load i8, ptr %33, align 1, !tbaa !11
  %35 = zext i8 %34 to i32
  %36 = load ptr, ptr %11, align 8, !tbaa !9
  %37 = getelementptr inbounds i8, ptr %36, i64 1
  %38 = load i8, ptr %37, align 1, !tbaa !11
  %39 = zext i8 %38 to i32
  %40 = shl i32 %39, 8
  %41 = add i32 %35, %40
  %42 = load ptr, ptr %11, align 8, !tbaa !9
  %43 = getelementptr inbounds i8, ptr %42, i64 2
  %44 = load i8, ptr %43, align 1, !tbaa !11
  %45 = zext i8 %44 to i32
  %46 = shl i32 %45, 16
  %47 = add i32 %41, %46
  %48 = load ptr, ptr %11, align 8, !tbaa !9
  %49 = getelementptr inbounds i8, ptr %48, i64 3
  %50 = load i8, ptr %49, align 1, !tbaa !11
  %51 = zext i8 %50 to i32
  %52 = shl i32 %51, 24
  %53 = add i32 %47, %52
  %54 = load i32, ptr %8, align 4, !tbaa !5
  %55 = add i32 %54, %53
  store i32 %55, ptr %8, align 4, !tbaa !5
  %56 = load ptr, ptr %11, align 8, !tbaa !9
  %57 = getelementptr inbounds i8, ptr %56, i64 4
  %58 = load i8, ptr %57, align 1, !tbaa !11
  %59 = zext i8 %58 to i32
  %60 = load ptr, ptr %11, align 8, !tbaa !9
  %61 = getelementptr inbounds i8, ptr %60, i64 5
  %62 = load i8, ptr %61, align 1, !tbaa !11
  %63 = zext i8 %62 to i32
  %64 = shl i32 %63, 8
  %65 = add i32 %59, %64
  %66 = load ptr, ptr %11, align 8, !tbaa !9
  %67 = getelementptr inbounds i8, ptr %66, i64 6
  %68 = load i8, ptr %67, align 1, !tbaa !11
  %69 = zext i8 %68 to i32
  %70 = shl i32 %69, 16
  %71 = add i32 %65, %70
  %72 = load ptr, ptr %11, align 8, !tbaa !9
  %73 = getelementptr inbounds i8, ptr %72, i64 7
  %74 = load i8, ptr %73, align 1, !tbaa !11
  %75 = zext i8 %74 to i32
  %76 = shl i32 %75, 24
  %77 = add i32 %71, %76
  %78 = load i32, ptr %9, align 4, !tbaa !5
  %79 = add i32 %78, %77
  store i32 %79, ptr %9, align 4, !tbaa !5
  %80 = load ptr, ptr %11, align 8, !tbaa !9
  %81 = getelementptr inbounds i8, ptr %80, i64 8
  %82 = load i8, ptr %81, align 1, !tbaa !11
  %83 = zext i8 %82 to i32
  %84 = load ptr, ptr %11, align 8, !tbaa !9
  %85 = getelementptr inbounds i8, ptr %84, i64 9
  %86 = load i8, ptr %85, align 1, !tbaa !11
  %87 = zext i8 %86 to i32
  %88 = shl i32 %87, 8
  %89 = add i32 %83, %88
  %90 = load ptr, ptr %11, align 8, !tbaa !9
  %91 = getelementptr inbounds i8, ptr %90, i64 10
  %92 = load i8, ptr %91, align 1, !tbaa !11
  %93 = zext i8 %92 to i32
  %94 = shl i32 %93, 16
  %95 = add i32 %89, %94
  %96 = load ptr, ptr %11, align 8, !tbaa !9
  %97 = getelementptr inbounds i8, ptr %96, i64 11
  %98 = load i8, ptr %97, align 1, !tbaa !11
  %99 = zext i8 %98 to i32
  %100 = shl i32 %99, 24
  %101 = add i32 %95, %100
  %102 = load i32, ptr %7, align 4, !tbaa !5
  %103 = add i32 %102, %101
  store i32 %103, ptr %7, align 4, !tbaa !5
  br label %104

104:                                              ; preds = %31
  %105 = load i32, ptr %9, align 4, !tbaa !5
  %106 = load i32, ptr %8, align 4, !tbaa !5
  %107 = sub i32 %106, %105
  store i32 %107, ptr %8, align 4, !tbaa !5
  %108 = load i32, ptr %7, align 4, !tbaa !5
  %109 = load i32, ptr %8, align 4, !tbaa !5
  %110 = sub i32 %109, %108
  store i32 %110, ptr %8, align 4, !tbaa !5
  %111 = load i32, ptr %7, align 4, !tbaa !5
  %112 = lshr i32 %111, 13
  %113 = load i32, ptr %8, align 4, !tbaa !5
  %114 = xor i32 %113, %112
  store i32 %114, ptr %8, align 4, !tbaa !5
  %115 = load i32, ptr %7, align 4, !tbaa !5
  %116 = load i32, ptr %9, align 4, !tbaa !5
  %117 = sub i32 %116, %115
  store i32 %117, ptr %9, align 4, !tbaa !5
  %118 = load i32, ptr %8, align 4, !tbaa !5
  %119 = load i32, ptr %9, align 4, !tbaa !5
  %120 = sub i32 %119, %118
  store i32 %120, ptr %9, align 4, !tbaa !5
  %121 = load i32, ptr %8, align 4, !tbaa !5
  %122 = shl i32 %121, 8
  %123 = load i32, ptr %9, align 4, !tbaa !5
  %124 = xor i32 %123, %122
  store i32 %124, ptr %9, align 4, !tbaa !5
  %125 = load i32, ptr %8, align 4, !tbaa !5
  %126 = load i32, ptr %7, align 4, !tbaa !5
  %127 = sub i32 %126, %125
  store i32 %127, ptr %7, align 4, !tbaa !5
  %128 = load i32, ptr %9, align 4, !tbaa !5
  %129 = load i32, ptr %7, align 4, !tbaa !5
  %130 = sub i32 %129, %128
  store i32 %130, ptr %7, align 4, !tbaa !5
  %131 = load i32, ptr %9, align 4, !tbaa !5
  %132 = lshr i32 %131, 13
  %133 = load i32, ptr %7, align 4, !tbaa !5
  %134 = xor i32 %133, %132
  store i32 %134, ptr %7, align 4, !tbaa !5
  %135 = load i32, ptr %9, align 4, !tbaa !5
  %136 = load i32, ptr %8, align 4, !tbaa !5
  %137 = sub i32 %136, %135
  store i32 %137, ptr %8, align 4, !tbaa !5
  %138 = load i32, ptr %7, align 4, !tbaa !5
  %139 = load i32, ptr %8, align 4, !tbaa !5
  %140 = sub i32 %139, %138
  store i32 %140, ptr %8, align 4, !tbaa !5
  %141 = load i32, ptr %7, align 4, !tbaa !5
  %142 = lshr i32 %141, 12
  %143 = load i32, ptr %8, align 4, !tbaa !5
  %144 = xor i32 %143, %142
  store i32 %144, ptr %8, align 4, !tbaa !5
  %145 = load i32, ptr %7, align 4, !tbaa !5
  %146 = load i32, ptr %9, align 4, !tbaa !5
  %147 = sub i32 %146, %145
  store i32 %147, ptr %9, align 4, !tbaa !5
  %148 = load i32, ptr %8, align 4, !tbaa !5
  %149 = load i32, ptr %9, align 4, !tbaa !5
  %150 = sub i32 %149, %148
  store i32 %150, ptr %9, align 4, !tbaa !5
  %151 = load i32, ptr %8, align 4, !tbaa !5
  %152 = shl i32 %151, 16
  %153 = load i32, ptr %9, align 4, !tbaa !5
  %154 = xor i32 %153, %152
  store i32 %154, ptr %9, align 4, !tbaa !5
  %155 = load i32, ptr %8, align 4, !tbaa !5
  %156 = load i32, ptr %7, align 4, !tbaa !5
  %157 = sub i32 %156, %155
  store i32 %157, ptr %7, align 4, !tbaa !5
  %158 = load i32, ptr %9, align 4, !tbaa !5
  %159 = load i32, ptr %7, align 4, !tbaa !5
  %160 = sub i32 %159, %158
  store i32 %160, ptr %7, align 4, !tbaa !5
  %161 = load i32, ptr %9, align 4, !tbaa !5
  %162 = lshr i32 %161, 5
  %163 = load i32, ptr %7, align 4, !tbaa !5
  %164 = xor i32 %163, %162
  store i32 %164, ptr %7, align 4, !tbaa !5
  %165 = load i32, ptr %9, align 4, !tbaa !5
  %166 = load i32, ptr %8, align 4, !tbaa !5
  %167 = sub i32 %166, %165
  store i32 %167, ptr %8, align 4, !tbaa !5
  %168 = load i32, ptr %7, align 4, !tbaa !5
  %169 = load i32, ptr %8, align 4, !tbaa !5
  %170 = sub i32 %169, %168
  store i32 %170, ptr %8, align 4, !tbaa !5
  %171 = load i32, ptr %7, align 4, !tbaa !5
  %172 = lshr i32 %171, 3
  %173 = load i32, ptr %8, align 4, !tbaa !5
  %174 = xor i32 %173, %172
  store i32 %174, ptr %8, align 4, !tbaa !5
  %175 = load i32, ptr %7, align 4, !tbaa !5
  %176 = load i32, ptr %9, align 4, !tbaa !5
  %177 = sub i32 %176, %175
  store i32 %177, ptr %9, align 4, !tbaa !5
  %178 = load i32, ptr %8, align 4, !tbaa !5
  %179 = load i32, ptr %9, align 4, !tbaa !5
  %180 = sub i32 %179, %178
  store i32 %180, ptr %9, align 4, !tbaa !5
  %181 = load i32, ptr %8, align 4, !tbaa !5
  %182 = shl i32 %181, 10
  %183 = load i32, ptr %9, align 4, !tbaa !5
  %184 = xor i32 %183, %182
  store i32 %184, ptr %9, align 4, !tbaa !5
  %185 = load i32, ptr %8, align 4, !tbaa !5
  %186 = load i32, ptr %7, align 4, !tbaa !5
  %187 = sub i32 %186, %185
  store i32 %187, ptr %7, align 4, !tbaa !5
  %188 = load i32, ptr %9, align 4, !tbaa !5
  %189 = load i32, ptr %7, align 4, !tbaa !5
  %190 = sub i32 %189, %188
  store i32 %190, ptr %7, align 4, !tbaa !5
  %191 = load i32, ptr %9, align 4, !tbaa !5
  %192 = lshr i32 %191, 15
  %193 = load i32, ptr %7, align 4, !tbaa !5
  %194 = xor i32 %193, %192
  store i32 %194, ptr %7, align 4, !tbaa !5
  br label %195

195:                                              ; preds = %104
  br label %196

196:                                              ; preds = %195
  %197 = load ptr, ptr %11, align 8, !tbaa !9
  %198 = getelementptr inbounds i8, ptr %197, i64 12
  store ptr %198, ptr %11, align 8, !tbaa !9
  %199 = load i32, ptr %10, align 4, !tbaa !5
  %200 = sub i32 %199, 12
  store i32 %200, ptr %10, align 4, !tbaa !5
  br label %28, !llvm.loop !12

201:                                              ; preds = %28
  %202 = load i32, ptr %7, align 4, !tbaa !5
  %203 = add i32 %202, 4
  store i32 %203, ptr %7, align 4, !tbaa !5
  %204 = load i32, ptr %10, align 4, !tbaa !5
  switch i32 %204, label %291 [
    i32 11, label %205
    i32 10, label %213
    i32 9, label %221
    i32 8, label %229
    i32 7, label %237
    i32 6, label %245
    i32 5, label %253
    i32 4, label %260
    i32 3, label %268
    i32 2, label %276
    i32 1, label %284
  ]

205:                                              ; preds = %201
  %206 = load ptr, ptr %11, align 8, !tbaa !9
  %207 = getelementptr inbounds i8, ptr %206, i64 10
  %208 = load i8, ptr %207, align 1, !tbaa !11
  %209 = zext i8 %208 to i32
  %210 = shl i32 %209, 24
  %211 = load i32, ptr %7, align 4, !tbaa !5
  %212 = add i32 %211, %210
  store i32 %212, ptr %7, align 4, !tbaa !5
  br label %213

213:                                              ; preds = %205, %201
  %214 = load ptr, ptr %11, align 8, !tbaa !9
  %215 = getelementptr inbounds i8, ptr %214, i64 9
  %216 = load i8, ptr %215, align 1, !tbaa !11
  %217 = zext i8 %216 to i32
  %218 = shl i32 %217, 16
  %219 = load i32, ptr %7, align 4, !tbaa !5
  %220 = add i32 %219, %218
  store i32 %220, ptr %7, align 4, !tbaa !5
  br label %221

221:                                              ; preds = %213, %201
  %222 = load ptr, ptr %11, align 8, !tbaa !9
  %223 = getelementptr inbounds i8, ptr %222, i64 8
  %224 = load i8, ptr %223, align 1, !tbaa !11
  %225 = zext i8 %224 to i32
  %226 = shl i32 %225, 8
  %227 = load i32, ptr %7, align 4, !tbaa !5
  %228 = add i32 %227, %226
  store i32 %228, ptr %7, align 4, !tbaa !5
  br label %229

229:                                              ; preds = %221, %201
  %230 = load ptr, ptr %11, align 8, !tbaa !9
  %231 = getelementptr inbounds i8, ptr %230, i64 7
  %232 = load i8, ptr %231, align 1, !tbaa !11
  %233 = zext i8 %232 to i32
  %234 = shl i32 %233, 24
  %235 = load i32, ptr %9, align 4, !tbaa !5
  %236 = add i32 %235, %234
  store i32 %236, ptr %9, align 4, !tbaa !5
  br label %237

237:                                              ; preds = %229, %201
  %238 = load ptr, ptr %11, align 8, !tbaa !9
  %239 = getelementptr inbounds i8, ptr %238, i64 6
  %240 = load i8, ptr %239, align 1, !tbaa !11
  %241 = zext i8 %240 to i32
  %242 = shl i32 %241, 16
  %243 = load i32, ptr %9, align 4, !tbaa !5
  %244 = add i32 %243, %242
  store i32 %244, ptr %9, align 4, !tbaa !5
  br label %245

245:                                              ; preds = %237, %201
  %246 = load ptr, ptr %11, align 8, !tbaa !9
  %247 = getelementptr inbounds i8, ptr %246, i64 5
  %248 = load i8, ptr %247, align 1, !tbaa !11
  %249 = zext i8 %248 to i32
  %250 = shl i32 %249, 8
  %251 = load i32, ptr %9, align 4, !tbaa !5
  %252 = add i32 %251, %250
  store i32 %252, ptr %9, align 4, !tbaa !5
  br label %253

253:                                              ; preds = %245, %201
  %254 = load ptr, ptr %11, align 8, !tbaa !9
  %255 = getelementptr inbounds i8, ptr %254, i64 4
  %256 = load i8, ptr %255, align 1, !tbaa !11
  %257 = zext i8 %256 to i32
  %258 = load i32, ptr %9, align 4, !tbaa !5
  %259 = add i32 %258, %257
  store i32 %259, ptr %9, align 4, !tbaa !5
  br label %260

260:                                              ; preds = %253, %201
  %261 = load ptr, ptr %11, align 8, !tbaa !9
  %262 = getelementptr inbounds i8, ptr %261, i64 3
  %263 = load i8, ptr %262, align 1, !tbaa !11
  %264 = zext i8 %263 to i32
  %265 = shl i32 %264, 24
  %266 = load i32, ptr %8, align 4, !tbaa !5
  %267 = add i32 %266, %265
  store i32 %267, ptr %8, align 4, !tbaa !5
  br label %268

268:                                              ; preds = %260, %201
  %269 = load ptr, ptr %11, align 8, !tbaa !9
  %270 = getelementptr inbounds i8, ptr %269, i64 2
  %271 = load i8, ptr %270, align 1, !tbaa !11
  %272 = zext i8 %271 to i32
  %273 = shl i32 %272, 16
  %274 = load i32, ptr %8, align 4, !tbaa !5
  %275 = add i32 %274, %273
  store i32 %275, ptr %8, align 4, !tbaa !5
  br label %276

276:                                              ; preds = %268, %201
  %277 = load ptr, ptr %11, align 8, !tbaa !9
  %278 = getelementptr inbounds i8, ptr %277, i64 1
  %279 = load i8, ptr %278, align 1, !tbaa !11
  %280 = zext i8 %279 to i32
  %281 = shl i32 %280, 8
  %282 = load i32, ptr %8, align 4, !tbaa !5
  %283 = add i32 %282, %281
  store i32 %283, ptr %8, align 4, !tbaa !5
  br label %284

284:                                              ; preds = %276, %201
  %285 = load ptr, ptr %11, align 8, !tbaa !9
  %286 = getelementptr inbounds i8, ptr %285, i64 0
  %287 = load i8, ptr %286, align 1, !tbaa !11
  %288 = zext i8 %287 to i32
  %289 = load i32, ptr %8, align 4, !tbaa !5
  %290 = add i32 %289, %288
  store i32 %290, ptr %8, align 4, !tbaa !5
  br label %291

291:                                              ; preds = %284, %201
  br label %292

292:                                              ; preds = %291
  %293 = load i32, ptr %9, align 4, !tbaa !5
  %294 = load i32, ptr %8, align 4, !tbaa !5
  %295 = sub i32 %294, %293
  store i32 %295, ptr %8, align 4, !tbaa !5
  %296 = load i32, ptr %7, align 4, !tbaa !5
  %297 = load i32, ptr %8, align 4, !tbaa !5
  %298 = sub i32 %297, %296
  store i32 %298, ptr %8, align 4, !tbaa !5
  %299 = load i32, ptr %7, align 4, !tbaa !5
  %300 = lshr i32 %299, 13
  %301 = load i32, ptr %8, align 4, !tbaa !5
  %302 = xor i32 %301, %300
  store i32 %302, ptr %8, align 4, !tbaa !5
  %303 = load i32, ptr %7, align 4, !tbaa !5
  %304 = load i32, ptr %9, align 4, !tbaa !5
  %305 = sub i32 %304, %303
  store i32 %305, ptr %9, align 4, !tbaa !5
  %306 = load i32, ptr %8, align 4, !tbaa !5
  %307 = load i32, ptr %9, align 4, !tbaa !5
  %308 = sub i32 %307, %306
  store i32 %308, ptr %9, align 4, !tbaa !5
  %309 = load i32, ptr %8, align 4, !tbaa !5
  %310 = shl i32 %309, 8
  %311 = load i32, ptr %9, align 4, !tbaa !5
  %312 = xor i32 %311, %310
  store i32 %312, ptr %9, align 4, !tbaa !5
  %313 = load i32, ptr %8, align 4, !tbaa !5
  %314 = load i32, ptr %7, align 4, !tbaa !5
  %315 = sub i32 %314, %313
  store i32 %315, ptr %7, align 4, !tbaa !5
  %316 = load i32, ptr %9, align 4, !tbaa !5
  %317 = load i32, ptr %7, align 4, !tbaa !5
  %318 = sub i32 %317, %316
  store i32 %318, ptr %7, align 4, !tbaa !5
  %319 = load i32, ptr %9, align 4, !tbaa !5
  %320 = lshr i32 %319, 13
  %321 = load i32, ptr %7, align 4, !tbaa !5
  %322 = xor i32 %321, %320
  store i32 %322, ptr %7, align 4, !tbaa !5
  %323 = load i32, ptr %9, align 4, !tbaa !5
  %324 = load i32, ptr %8, align 4, !tbaa !5
  %325 = sub i32 %324, %323
  store i32 %325, ptr %8, align 4, !tbaa !5
  %326 = load i32, ptr %7, align 4, !tbaa !5
  %327 = load i32, ptr %8, align 4, !tbaa !5
  %328 = sub i32 %327, %326
  store i32 %328, ptr %8, align 4, !tbaa !5
  %329 = load i32, ptr %7, align 4, !tbaa !5
  %330 = lshr i32 %329, 12
  %331 = load i32, ptr %8, align 4, !tbaa !5
  %332 = xor i32 %331, %330
  store i32 %332, ptr %8, align 4, !tbaa !5
  %333 = load i32, ptr %7, align 4, !tbaa !5
  %334 = load i32, ptr %9, align 4, !tbaa !5
  %335 = sub i32 %334, %333
  store i32 %335, ptr %9, align 4, !tbaa !5
  %336 = load i32, ptr %8, align 4, !tbaa !5
  %337 = load i32, ptr %9, align 4, !tbaa !5
  %338 = sub i32 %337, %336
  store i32 %338, ptr %9, align 4, !tbaa !5
  %339 = load i32, ptr %8, align 4, !tbaa !5
  %340 = shl i32 %339, 16
  %341 = load i32, ptr %9, align 4, !tbaa !5
  %342 = xor i32 %341, %340
  store i32 %342, ptr %9, align 4, !tbaa !5
  %343 = load i32, ptr %8, align 4, !tbaa !5
  %344 = load i32, ptr %7, align 4, !tbaa !5
  %345 = sub i32 %344, %343
  store i32 %345, ptr %7, align 4, !tbaa !5
  %346 = load i32, ptr %9, align 4, !tbaa !5
  %347 = load i32, ptr %7, align 4, !tbaa !5
  %348 = sub i32 %347, %346
  store i32 %348, ptr %7, align 4, !tbaa !5
  %349 = load i32, ptr %9, align 4, !tbaa !5
  %350 = lshr i32 %349, 5
  %351 = load i32, ptr %7, align 4, !tbaa !5
  %352 = xor i32 %351, %350
  store i32 %352, ptr %7, align 4, !tbaa !5
  %353 = load i32, ptr %9, align 4, !tbaa !5
  %354 = load i32, ptr %8, align 4, !tbaa !5
  %355 = sub i32 %354, %353
  store i32 %355, ptr %8, align 4, !tbaa !5
  %356 = load i32, ptr %7, align 4, !tbaa !5
  %357 = load i32, ptr %8, align 4, !tbaa !5
  %358 = sub i32 %357, %356
  store i32 %358, ptr %8, align 4, !tbaa !5
  %359 = load i32, ptr %7, align 4, !tbaa !5
  %360 = lshr i32 %359, 3
  %361 = load i32, ptr %8, align 4, !tbaa !5
  %362 = xor i32 %361, %360
  store i32 %362, ptr %8, align 4, !tbaa !5
  %363 = load i32, ptr %7, align 4, !tbaa !5
  %364 = load i32, ptr %9, align 4, !tbaa !5
  %365 = sub i32 %364, %363
  store i32 %365, ptr %9, align 4, !tbaa !5
  %366 = load i32, ptr %8, align 4, !tbaa !5
  %367 = load i32, ptr %9, align 4, !tbaa !5
  %368 = sub i32 %367, %366
  store i32 %368, ptr %9, align 4, !tbaa !5
  %369 = load i32, ptr %8, align 4, !tbaa !5
  %370 = shl i32 %369, 10
  %371 = load i32, ptr %9, align 4, !tbaa !5
  %372 = xor i32 %371, %370
  store i32 %372, ptr %9, align 4, !tbaa !5
  %373 = load i32, ptr %8, align 4, !tbaa !5
  %374 = load i32, ptr %7, align 4, !tbaa !5
  %375 = sub i32 %374, %373
  store i32 %375, ptr %7, align 4, !tbaa !5
  %376 = load i32, ptr %9, align 4, !tbaa !5
  %377 = load i32, ptr %7, align 4, !tbaa !5
  %378 = sub i32 %377, %376
  store i32 %378, ptr %7, align 4, !tbaa !5
  %379 = load i32, ptr %9, align 4, !tbaa !5
  %380 = lshr i32 %379, 15
  %381 = load i32, ptr %7, align 4, !tbaa !5
  %382 = xor i32 %381, %380
  store i32 %382, ptr %7, align 4, !tbaa !5
  br label %383

383:                                              ; preds = %292
  br label %384

384:                                              ; preds = %383
  %385 = load i32, ptr %7, align 4, !tbaa !5
  %386 = load ptr, ptr @users, align 8, !tbaa !9
  %387 = getelementptr inbounds %struct.my_struct, ptr %386, i32 0, i32 2
  %388 = getelementptr inbounds %struct.UT_hash_handle, ptr %387, i32 0, i32 0
  %389 = load ptr, ptr %388, align 8, !tbaa !14
  %390 = getelementptr inbounds %struct.UT_hash_table, ptr %389, i32 0, i32 1
  %391 = load i32, ptr %390, align 8, !tbaa !18
  %392 = sub i32 %391, 1
  %393 = and i32 %385, %392
  store i32 %393, ptr %6, align 4, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #7
  br label %394

394:                                              ; preds = %384
  br label %395

395:                                              ; preds = %394
  br label %396

396:                                              ; preds = %395
  %397 = load ptr, ptr @users, align 8, !tbaa !9
  %398 = getelementptr inbounds %struct.my_struct, ptr %397, i32 0, i32 2
  %399 = getelementptr inbounds %struct.UT_hash_handle, ptr %398, i32 0, i32 0
  %400 = load ptr, ptr %399, align 8, !tbaa !14
  %401 = getelementptr inbounds %struct.UT_hash_table, ptr %400, i32 0, i32 0
  %402 = load ptr, ptr %401, align 8, !tbaa !21
  %403 = load i32, ptr %6, align 4, !tbaa !5
  %404 = zext i32 %403 to i64
  %405 = getelementptr inbounds %struct.UT_hash_bucket, ptr %402, i64 %404
  %406 = getelementptr inbounds %struct.UT_hash_bucket, ptr %405, i32 0, i32 0
  %407 = load ptr, ptr %406, align 8, !tbaa !22
  %408 = icmp ne ptr %407, null
  br i1 %408, label %409, label %432

409:                                              ; preds = %396
  br label %410

410:                                              ; preds = %409
  %411 = load ptr, ptr @users, align 8, !tbaa !9
  %412 = getelementptr inbounds %struct.my_struct, ptr %411, i32 0, i32 2
  %413 = getelementptr inbounds %struct.UT_hash_handle, ptr %412, i32 0, i32 0
  %414 = load ptr, ptr %413, align 8, !tbaa !14
  %415 = getelementptr inbounds %struct.UT_hash_table, ptr %414, i32 0, i32 0
  %416 = load ptr, ptr %415, align 8, !tbaa !21
  %417 = load i32, ptr %6, align 4, !tbaa !5
  %418 = zext i32 %417 to i64
  %419 = getelementptr inbounds %struct.UT_hash_bucket, ptr %416, i64 %418
  %420 = getelementptr inbounds %struct.UT_hash_bucket, ptr %419, i32 0, i32 0
  %421 = load ptr, ptr %420, align 8, !tbaa !22
  %422 = load ptr, ptr @users, align 8, !tbaa !9
  %423 = getelementptr inbounds %struct.my_struct, ptr %422, i32 0, i32 2
  %424 = getelementptr inbounds %struct.UT_hash_handle, ptr %423, i32 0, i32 0
  %425 = load ptr, ptr %424, align 8, !tbaa !14
  %426 = getelementptr inbounds %struct.UT_hash_table, ptr %425, i32 0, i32 5
  %427 = load i64, ptr %426, align 8, !tbaa !24
  %428 = sub i64 0, %427
  %429 = getelementptr inbounds i8, ptr %421, i64 %428
  store ptr %429, ptr %5, align 8, !tbaa !9
  br label %430

430:                                              ; preds = %410
  br label %431

431:                                              ; preds = %430
  br label %433

432:                                              ; preds = %396
  store ptr null, ptr %5, align 8, !tbaa !9
  br label %433

433:                                              ; preds = %432, %431
  br label %434

434:                                              ; preds = %476, %433
  %435 = load ptr, ptr %5, align 8, !tbaa !9
  %436 = icmp ne ptr %435, null
  br i1 %436, label %437, label %477

437:                                              ; preds = %434
  %438 = load ptr, ptr %5, align 8, !tbaa !9
  %439 = getelementptr inbounds %struct.my_struct, ptr %438, i32 0, i32 2
  %440 = getelementptr inbounds %struct.UT_hash_handle, ptr %439, i32 0, i32 6
  %441 = load i32, ptr %440, align 8, !tbaa !25
  %442 = zext i32 %441 to i64
  %443 = icmp eq i64 %442, 4
  br i1 %443, label %444, label %453

444:                                              ; preds = %437
  %445 = load ptr, ptr %5, align 8, !tbaa !9
  %446 = getelementptr inbounds %struct.my_struct, ptr %445, i32 0, i32 2
  %447 = getelementptr inbounds %struct.UT_hash_handle, ptr %446, i32 0, i32 5
  %448 = load ptr, ptr %447, align 8, !tbaa !26
  %449 = call i32 @memcmp(ptr noundef %448, ptr noundef %3, i64 noundef 4) #8
  %450 = icmp eq i32 %449, 0
  br i1 %450, label %451, label %452

451:                                              ; preds = %444
  br label %477

452:                                              ; preds = %444
  br label %453

453:                                              ; preds = %452, %437
  %454 = load ptr, ptr %5, align 8, !tbaa !9
  %455 = getelementptr inbounds %struct.my_struct, ptr %454, i32 0, i32 2
  %456 = getelementptr inbounds %struct.UT_hash_handle, ptr %455, i32 0, i32 4
  %457 = load ptr, ptr %456, align 8, !tbaa !27
  %458 = icmp ne ptr %457, null
  br i1 %458, label %459, label %475

459:                                              ; preds = %453
  br label %460

460:                                              ; preds = %459
  %461 = load ptr, ptr %5, align 8, !tbaa !9
  %462 = getelementptr inbounds %struct.my_struct, ptr %461, i32 0, i32 2
  %463 = getelementptr inbounds %struct.UT_hash_handle, ptr %462, i32 0, i32 4
  %464 = load ptr, ptr %463, align 8, !tbaa !27
  %465 = load ptr, ptr @users, align 8, !tbaa !9
  %466 = getelementptr inbounds %struct.my_struct, ptr %465, i32 0, i32 2
  %467 = getelementptr inbounds %struct.UT_hash_handle, ptr %466, i32 0, i32 0
  %468 = load ptr, ptr %467, align 8, !tbaa !14
  %469 = getelementptr inbounds %struct.UT_hash_table, ptr %468, i32 0, i32 5
  %470 = load i64, ptr %469, align 8, !tbaa !24
  %471 = sub i64 0, %470
  %472 = getelementptr inbounds i8, ptr %464, i64 %471
  store ptr %472, ptr %5, align 8, !tbaa !9
  br label %473

473:                                              ; preds = %460
  br label %474

474:                                              ; preds = %473
  br label %476

475:                                              ; preds = %453
  store ptr null, ptr %5, align 8, !tbaa !9
  br label %476

476:                                              ; preds = %475, %474
  br label %434, !llvm.loop !28

477:                                              ; preds = %451, %434
  br label %478

478:                                              ; preds = %477
  br label %479

479:                                              ; preds = %478
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #7
  br label %480

480:                                              ; preds = %479, %23
  br label %481

481:                                              ; preds = %480
  br label %482

482:                                              ; preds = %481
  %483 = load ptr, ptr %5, align 8, !tbaa !9
  %484 = icmp eq ptr %483, null
  br i1 %484, label %485, label %1489

485:                                              ; preds = %482
  %486 = call noalias ptr @malloc(i64 noundef 64) #9
  store ptr %486, ptr %5, align 8, !tbaa !9
  %487 = load ptr, ptr %5, align 8, !tbaa !9
  %488 = icmp ne ptr %487, null
  br i1 %488, label %489, label %490

489:                                              ; preds = %485
  br label %491

490:                                              ; preds = %485
  call void @__assert_fail(ptr noundef @.str, ptr noundef @.str.1, i32 noundef 43, ptr noundef @__PRETTY_FUNCTION__.add_element) #10
  unreachable

491:                                              ; preds = %489
  %492 = load i32, ptr %3, align 4, !tbaa !5
  %493 = load ptr, ptr %5, align 8, !tbaa !9
  %494 = getelementptr inbounds %struct.my_struct, ptr %493, i32 0, i32 0
  store i32 %492, ptr %494, align 8, !tbaa !29
  br label %495

495:                                              ; preds = %491
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #7
  %496 = load ptr, ptr %5, align 8, !tbaa !9
  %497 = getelementptr inbounds %struct.my_struct, ptr %496, i32 0, i32 2
  %498 = getelementptr inbounds %struct.UT_hash_handle, ptr %497, i32 0, i32 2
  store ptr null, ptr %498, align 8, !tbaa !30
  %499 = load ptr, ptr %5, align 8, !tbaa !9
  %500 = getelementptr inbounds %struct.my_struct, ptr %499, i32 0, i32 0
  %501 = load ptr, ptr %5, align 8, !tbaa !9
  %502 = getelementptr inbounds %struct.my_struct, ptr %501, i32 0, i32 2
  %503 = getelementptr inbounds %struct.UT_hash_handle, ptr %502, i32 0, i32 5
  store ptr %500, ptr %503, align 8, !tbaa !26
  %504 = load ptr, ptr %5, align 8, !tbaa !9
  %505 = getelementptr inbounds %struct.my_struct, ptr %504, i32 0, i32 2
  %506 = getelementptr inbounds %struct.UT_hash_handle, ptr %505, i32 0, i32 6
  store i32 4, ptr %506, align 8, !tbaa !25
  %507 = load ptr, ptr @users, align 8, !tbaa !9
  %508 = icmp ne ptr %507, null
  br i1 %508, label %586, label %509

509:                                              ; preds = %495
  %510 = load ptr, ptr %5, align 8, !tbaa !9
  store ptr %510, ptr @users, align 8, !tbaa !9
  %511 = load ptr, ptr @users, align 8, !tbaa !9
  %512 = getelementptr inbounds %struct.my_struct, ptr %511, i32 0, i32 2
  %513 = getelementptr inbounds %struct.UT_hash_handle, ptr %512, i32 0, i32 1
  store ptr null, ptr %513, align 8, !tbaa !31
  br label %514

514:                                              ; preds = %509
  %515 = call noalias ptr @malloc(i64 noundef 64) #9
  %516 = load ptr, ptr @users, align 8, !tbaa !9
  %517 = getelementptr inbounds %struct.my_struct, ptr %516, i32 0, i32 2
  %518 = getelementptr inbounds %struct.UT_hash_handle, ptr %517, i32 0, i32 0
  store ptr %515, ptr %518, align 8, !tbaa !14
  %519 = load ptr, ptr @users, align 8, !tbaa !9
  %520 = getelementptr inbounds %struct.my_struct, ptr %519, i32 0, i32 2
  %521 = getelementptr inbounds %struct.UT_hash_handle, ptr %520, i32 0, i32 0
  %522 = load ptr, ptr %521, align 8, !tbaa !14
  %523 = icmp ne ptr %522, null
  br i1 %523, label %525, label %524

524:                                              ; preds = %514
  call void @exit(i32 noundef -1) #10
  unreachable

525:                                              ; preds = %514
  %526 = load ptr, ptr @users, align 8, !tbaa !9
  %527 = getelementptr inbounds %struct.my_struct, ptr %526, i32 0, i32 2
  %528 = getelementptr inbounds %struct.UT_hash_handle, ptr %527, i32 0, i32 0
  %529 = load ptr, ptr %528, align 8, !tbaa !14
  call void @llvm.memset.p0.i64(ptr align 8 %529, i8 0, i64 64, i1 false)
  %530 = load ptr, ptr @users, align 8, !tbaa !9
  %531 = getelementptr inbounds %struct.my_struct, ptr %530, i32 0, i32 2
  %532 = load ptr, ptr @users, align 8, !tbaa !9
  %533 = getelementptr inbounds %struct.my_struct, ptr %532, i32 0, i32 2
  %534 = getelementptr inbounds %struct.UT_hash_handle, ptr %533, i32 0, i32 0
  %535 = load ptr, ptr %534, align 8, !tbaa !14
  %536 = getelementptr inbounds %struct.UT_hash_table, ptr %535, i32 0, i32 4
  store ptr %531, ptr %536, align 8, !tbaa !32
  %537 = load ptr, ptr @users, align 8, !tbaa !9
  %538 = getelementptr inbounds %struct.my_struct, ptr %537, i32 0, i32 2
  %539 = getelementptr inbounds %struct.UT_hash_handle, ptr %538, i32 0, i32 0
  %540 = load ptr, ptr %539, align 8, !tbaa !14
  %541 = getelementptr inbounds %struct.UT_hash_table, ptr %540, i32 0, i32 1
  store i32 32, ptr %541, align 8, !tbaa !18
  %542 = load ptr, ptr @users, align 8, !tbaa !9
  %543 = getelementptr inbounds %struct.my_struct, ptr %542, i32 0, i32 2
  %544 = getelementptr inbounds %struct.UT_hash_handle, ptr %543, i32 0, i32 0
  %545 = load ptr, ptr %544, align 8, !tbaa !14
  %546 = getelementptr inbounds %struct.UT_hash_table, ptr %545, i32 0, i32 2
  store i32 5, ptr %546, align 4, !tbaa !33
  %547 = load ptr, ptr @users, align 8, !tbaa !9
  %548 = getelementptr inbounds %struct.my_struct, ptr %547, i32 0, i32 2
  %549 = load ptr, ptr @users, align 8, !tbaa !9
  %550 = ptrtoint ptr %548 to i64
  %551 = ptrtoint ptr %549 to i64
  %552 = sub i64 %550, %551
  %553 = load ptr, ptr @users, align 8, !tbaa !9
  %554 = getelementptr inbounds %struct.my_struct, ptr %553, i32 0, i32 2
  %555 = getelementptr inbounds %struct.UT_hash_handle, ptr %554, i32 0, i32 0
  %556 = load ptr, ptr %555, align 8, !tbaa !14
  %557 = getelementptr inbounds %struct.UT_hash_table, ptr %556, i32 0, i32 5
  store i64 %552, ptr %557, align 8, !tbaa !24
  %558 = call noalias ptr @malloc(i64 noundef 512) #9
  %559 = load ptr, ptr @users, align 8, !tbaa !9
  %560 = getelementptr inbounds %struct.my_struct, ptr %559, i32 0, i32 2
  %561 = getelementptr inbounds %struct.UT_hash_handle, ptr %560, i32 0, i32 0
  %562 = load ptr, ptr %561, align 8, !tbaa !14
  %563 = getelementptr inbounds %struct.UT_hash_table, ptr %562, i32 0, i32 0
  store ptr %558, ptr %563, align 8, !tbaa !21
  %564 = load ptr, ptr @users, align 8, !tbaa !9
  %565 = getelementptr inbounds %struct.my_struct, ptr %564, i32 0, i32 2
  %566 = getelementptr inbounds %struct.UT_hash_handle, ptr %565, i32 0, i32 0
  %567 = load ptr, ptr %566, align 8, !tbaa !14
  %568 = getelementptr inbounds %struct.UT_hash_table, ptr %567, i32 0, i32 0
  %569 = load ptr, ptr %568, align 8, !tbaa !21
  %570 = icmp ne ptr %569, null
  br i1 %570, label %572, label %571

571:                                              ; preds = %525
  call void @exit(i32 noundef -1) #10
  unreachable

572:                                              ; preds = %525
  %573 = load ptr, ptr @users, align 8, !tbaa !9
  %574 = getelementptr inbounds %struct.my_struct, ptr %573, i32 0, i32 2
  %575 = getelementptr inbounds %struct.UT_hash_handle, ptr %574, i32 0, i32 0
  %576 = load ptr, ptr %575, align 8, !tbaa !14
  %577 = getelementptr inbounds %struct.UT_hash_table, ptr %576, i32 0, i32 0
  %578 = load ptr, ptr %577, align 8, !tbaa !21
  call void @llvm.memset.p0.i64(ptr align 8 %578, i8 0, i64 512, i1 false)
  %579 = load ptr, ptr @users, align 8, !tbaa !9
  %580 = getelementptr inbounds %struct.my_struct, ptr %579, i32 0, i32 2
  %581 = getelementptr inbounds %struct.UT_hash_handle, ptr %580, i32 0, i32 0
  %582 = load ptr, ptr %581, align 8, !tbaa !14
  %583 = getelementptr inbounds %struct.UT_hash_table, ptr %582, i32 0, i32 10
  store i32 -1609490463, ptr %583, align 8, !tbaa !34
  br label %584

584:                                              ; preds = %572
  br label %585

585:                                              ; preds = %584
  br label %619

586:                                              ; preds = %495
  %587 = load ptr, ptr %5, align 8, !tbaa !9
  %588 = load ptr, ptr @users, align 8, !tbaa !9
  %589 = getelementptr inbounds %struct.my_struct, ptr %588, i32 0, i32 2
  %590 = getelementptr inbounds %struct.UT_hash_handle, ptr %589, i32 0, i32 0
  %591 = load ptr, ptr %590, align 8, !tbaa !14
  %592 = getelementptr inbounds %struct.UT_hash_table, ptr %591, i32 0, i32 4
  %593 = load ptr, ptr %592, align 8, !tbaa !32
  %594 = getelementptr inbounds %struct.UT_hash_handle, ptr %593, i32 0, i32 2
  store ptr %587, ptr %594, align 8, !tbaa !35
  %595 = load ptr, ptr @users, align 8, !tbaa !9
  %596 = getelementptr inbounds %struct.my_struct, ptr %595, i32 0, i32 2
  %597 = getelementptr inbounds %struct.UT_hash_handle, ptr %596, i32 0, i32 0
  %598 = load ptr, ptr %597, align 8, !tbaa !14
  %599 = getelementptr inbounds %struct.UT_hash_table, ptr %598, i32 0, i32 4
  %600 = load ptr, ptr %599, align 8, !tbaa !32
  %601 = load ptr, ptr @users, align 8, !tbaa !9
  %602 = getelementptr inbounds %struct.my_struct, ptr %601, i32 0, i32 2
  %603 = getelementptr inbounds %struct.UT_hash_handle, ptr %602, i32 0, i32 0
  %604 = load ptr, ptr %603, align 8, !tbaa !14
  %605 = getelementptr inbounds %struct.UT_hash_table, ptr %604, i32 0, i32 5
  %606 = load i64, ptr %605, align 8, !tbaa !24
  %607 = sub i64 0, %606
  %608 = getelementptr inbounds i8, ptr %600, i64 %607
  %609 = load ptr, ptr %5, align 8, !tbaa !9
  %610 = getelementptr inbounds %struct.my_struct, ptr %609, i32 0, i32 2
  %611 = getelementptr inbounds %struct.UT_hash_handle, ptr %610, i32 0, i32 1
  store ptr %608, ptr %611, align 8, !tbaa !31
  %612 = load ptr, ptr %5, align 8, !tbaa !9
  %613 = getelementptr inbounds %struct.my_struct, ptr %612, i32 0, i32 2
  %614 = load ptr, ptr @users, align 8, !tbaa !9
  %615 = getelementptr inbounds %struct.my_struct, ptr %614, i32 0, i32 2
  %616 = getelementptr inbounds %struct.UT_hash_handle, ptr %615, i32 0, i32 0
  %617 = load ptr, ptr %616, align 8, !tbaa !14
  %618 = getelementptr inbounds %struct.UT_hash_table, ptr %617, i32 0, i32 4
  store ptr %613, ptr %618, align 8, !tbaa !32
  br label %619

619:                                              ; preds = %586, %585
  %620 = load ptr, ptr @users, align 8, !tbaa !9
  %621 = getelementptr inbounds %struct.my_struct, ptr %620, i32 0, i32 2
  %622 = getelementptr inbounds %struct.UT_hash_handle, ptr %621, i32 0, i32 0
  %623 = load ptr, ptr %622, align 8, !tbaa !14
  %624 = getelementptr inbounds %struct.UT_hash_table, ptr %623, i32 0, i32 3
  %625 = load i32, ptr %624, align 8, !tbaa !36
  %626 = add i32 %625, 1
  store i32 %626, ptr %624, align 8, !tbaa !36
  %627 = load ptr, ptr @users, align 8, !tbaa !9
  %628 = getelementptr inbounds %struct.my_struct, ptr %627, i32 0, i32 2
  %629 = getelementptr inbounds %struct.UT_hash_handle, ptr %628, i32 0, i32 0
  %630 = load ptr, ptr %629, align 8, !tbaa !14
  %631 = load ptr, ptr %5, align 8, !tbaa !9
  %632 = getelementptr inbounds %struct.my_struct, ptr %631, i32 0, i32 2
  %633 = getelementptr inbounds %struct.UT_hash_handle, ptr %632, i32 0, i32 0
  store ptr %630, ptr %633, align 8, !tbaa !14
  br label %634

634:                                              ; preds = %619
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %16) #7
  %635 = load ptr, ptr %5, align 8, !tbaa !9
  %636 = getelementptr inbounds %struct.my_struct, ptr %635, i32 0, i32 0
  store ptr %636, ptr %16, align 8, !tbaa !9
  %637 = load ptr, ptr %5, align 8, !tbaa !9
  %638 = getelementptr inbounds %struct.my_struct, ptr %637, i32 0, i32 2
  %639 = getelementptr inbounds %struct.UT_hash_handle, ptr %638, i32 0, i32 7
  store i32 -17973521, ptr %639, align 4, !tbaa !37
  store i32 -1640531527, ptr %14, align 4, !tbaa !5
  store i32 -1640531527, ptr %13, align 4, !tbaa !5
  store i32 4, ptr %15, align 4, !tbaa !5
  br label %640

640:                                              ; preds = %865, %634
  %641 = load i32, ptr %15, align 4, !tbaa !5
  %642 = icmp uge i32 %641, 12
  br i1 %642, label %643, label %870

643:                                              ; preds = %640
  %644 = load ptr, ptr %16, align 8, !tbaa !9
  %645 = getelementptr inbounds i8, ptr %644, i64 0
  %646 = load i8, ptr %645, align 1, !tbaa !11
  %647 = zext i8 %646 to i32
  %648 = load ptr, ptr %16, align 8, !tbaa !9
  %649 = getelementptr inbounds i8, ptr %648, i64 1
  %650 = load i8, ptr %649, align 1, !tbaa !11
  %651 = zext i8 %650 to i32
  %652 = shl i32 %651, 8
  %653 = add i32 %647, %652
  %654 = load ptr, ptr %16, align 8, !tbaa !9
  %655 = getelementptr inbounds i8, ptr %654, i64 2
  %656 = load i8, ptr %655, align 1, !tbaa !11
  %657 = zext i8 %656 to i32
  %658 = shl i32 %657, 16
  %659 = add i32 %653, %658
  %660 = load ptr, ptr %16, align 8, !tbaa !9
  %661 = getelementptr inbounds i8, ptr %660, i64 3
  %662 = load i8, ptr %661, align 1, !tbaa !11
  %663 = zext i8 %662 to i32
  %664 = shl i32 %663, 24
  %665 = add i32 %659, %664
  %666 = load i32, ptr %13, align 4, !tbaa !5
  %667 = add i32 %666, %665
  store i32 %667, ptr %13, align 4, !tbaa !5
  %668 = load ptr, ptr %16, align 8, !tbaa !9
  %669 = getelementptr inbounds i8, ptr %668, i64 4
  %670 = load i8, ptr %669, align 1, !tbaa !11
  %671 = zext i8 %670 to i32
  %672 = load ptr, ptr %16, align 8, !tbaa !9
  %673 = getelementptr inbounds i8, ptr %672, i64 5
  %674 = load i8, ptr %673, align 1, !tbaa !11
  %675 = zext i8 %674 to i32
  %676 = shl i32 %675, 8
  %677 = add i32 %671, %676
  %678 = load ptr, ptr %16, align 8, !tbaa !9
  %679 = getelementptr inbounds i8, ptr %678, i64 6
  %680 = load i8, ptr %679, align 1, !tbaa !11
  %681 = zext i8 %680 to i32
  %682 = shl i32 %681, 16
  %683 = add i32 %677, %682
  %684 = load ptr, ptr %16, align 8, !tbaa !9
  %685 = getelementptr inbounds i8, ptr %684, i64 7
  %686 = load i8, ptr %685, align 1, !tbaa !11
  %687 = zext i8 %686 to i32
  %688 = shl i32 %687, 24
  %689 = add i32 %683, %688
  %690 = load i32, ptr %14, align 4, !tbaa !5
  %691 = add i32 %690, %689
  store i32 %691, ptr %14, align 4, !tbaa !5
  %692 = load ptr, ptr %16, align 8, !tbaa !9
  %693 = getelementptr inbounds i8, ptr %692, i64 8
  %694 = load i8, ptr %693, align 1, !tbaa !11
  %695 = zext i8 %694 to i32
  %696 = load ptr, ptr %16, align 8, !tbaa !9
  %697 = getelementptr inbounds i8, ptr %696, i64 9
  %698 = load i8, ptr %697, align 1, !tbaa !11
  %699 = zext i8 %698 to i32
  %700 = shl i32 %699, 8
  %701 = add i32 %695, %700
  %702 = load ptr, ptr %16, align 8, !tbaa !9
  %703 = getelementptr inbounds i8, ptr %702, i64 10
  %704 = load i8, ptr %703, align 1, !tbaa !11
  %705 = zext i8 %704 to i32
  %706 = shl i32 %705, 16
  %707 = add i32 %701, %706
  %708 = load ptr, ptr %16, align 8, !tbaa !9
  %709 = getelementptr inbounds i8, ptr %708, i64 11
  %710 = load i8, ptr %709, align 1, !tbaa !11
  %711 = zext i8 %710 to i32
  %712 = shl i32 %711, 24
  %713 = add i32 %707, %712
  %714 = load ptr, ptr %5, align 8, !tbaa !9
  %715 = getelementptr inbounds %struct.my_struct, ptr %714, i32 0, i32 2
  %716 = getelementptr inbounds %struct.UT_hash_handle, ptr %715, i32 0, i32 7
  %717 = load i32, ptr %716, align 4, !tbaa !37
  %718 = add i32 %717, %713
  store i32 %718, ptr %716, align 4, !tbaa !37
  br label %719

719:                                              ; preds = %643
  %720 = load i32, ptr %14, align 4, !tbaa !5
  %721 = load i32, ptr %13, align 4, !tbaa !5
  %722 = sub i32 %721, %720
  store i32 %722, ptr %13, align 4, !tbaa !5
  %723 = load ptr, ptr %5, align 8, !tbaa !9
  %724 = getelementptr inbounds %struct.my_struct, ptr %723, i32 0, i32 2
  %725 = getelementptr inbounds %struct.UT_hash_handle, ptr %724, i32 0, i32 7
  %726 = load i32, ptr %725, align 4, !tbaa !37
  %727 = load i32, ptr %13, align 4, !tbaa !5
  %728 = sub i32 %727, %726
  store i32 %728, ptr %13, align 4, !tbaa !5
  %729 = load ptr, ptr %5, align 8, !tbaa !9
  %730 = getelementptr inbounds %struct.my_struct, ptr %729, i32 0, i32 2
  %731 = getelementptr inbounds %struct.UT_hash_handle, ptr %730, i32 0, i32 7
  %732 = load i32, ptr %731, align 4, !tbaa !37
  %733 = lshr i32 %732, 13
  %734 = load i32, ptr %13, align 4, !tbaa !5
  %735 = xor i32 %734, %733
  store i32 %735, ptr %13, align 4, !tbaa !5
  %736 = load ptr, ptr %5, align 8, !tbaa !9
  %737 = getelementptr inbounds %struct.my_struct, ptr %736, i32 0, i32 2
  %738 = getelementptr inbounds %struct.UT_hash_handle, ptr %737, i32 0, i32 7
  %739 = load i32, ptr %738, align 4, !tbaa !37
  %740 = load i32, ptr %14, align 4, !tbaa !5
  %741 = sub i32 %740, %739
  store i32 %741, ptr %14, align 4, !tbaa !5
  %742 = load i32, ptr %13, align 4, !tbaa !5
  %743 = load i32, ptr %14, align 4, !tbaa !5
  %744 = sub i32 %743, %742
  store i32 %744, ptr %14, align 4, !tbaa !5
  %745 = load i32, ptr %13, align 4, !tbaa !5
  %746 = shl i32 %745, 8
  %747 = load i32, ptr %14, align 4, !tbaa !5
  %748 = xor i32 %747, %746
  store i32 %748, ptr %14, align 4, !tbaa !5
  %749 = load i32, ptr %13, align 4, !tbaa !5
  %750 = load ptr, ptr %5, align 8, !tbaa !9
  %751 = getelementptr inbounds %struct.my_struct, ptr %750, i32 0, i32 2
  %752 = getelementptr inbounds %struct.UT_hash_handle, ptr %751, i32 0, i32 7
  %753 = load i32, ptr %752, align 4, !tbaa !37
  %754 = sub i32 %753, %749
  store i32 %754, ptr %752, align 4, !tbaa !37
  %755 = load i32, ptr %14, align 4, !tbaa !5
  %756 = load ptr, ptr %5, align 8, !tbaa !9
  %757 = getelementptr inbounds %struct.my_struct, ptr %756, i32 0, i32 2
  %758 = getelementptr inbounds %struct.UT_hash_handle, ptr %757, i32 0, i32 7
  %759 = load i32, ptr %758, align 4, !tbaa !37
  %760 = sub i32 %759, %755
  store i32 %760, ptr %758, align 4, !tbaa !37
  %761 = load i32, ptr %14, align 4, !tbaa !5
  %762 = lshr i32 %761, 13
  %763 = load ptr, ptr %5, align 8, !tbaa !9
  %764 = getelementptr inbounds %struct.my_struct, ptr %763, i32 0, i32 2
  %765 = getelementptr inbounds %struct.UT_hash_handle, ptr %764, i32 0, i32 7
  %766 = load i32, ptr %765, align 4, !tbaa !37
  %767 = xor i32 %766, %762
  store i32 %767, ptr %765, align 4, !tbaa !37
  %768 = load i32, ptr %14, align 4, !tbaa !5
  %769 = load i32, ptr %13, align 4, !tbaa !5
  %770 = sub i32 %769, %768
  store i32 %770, ptr %13, align 4, !tbaa !5
  %771 = load ptr, ptr %5, align 8, !tbaa !9
  %772 = getelementptr inbounds %struct.my_struct, ptr %771, i32 0, i32 2
  %773 = getelementptr inbounds %struct.UT_hash_handle, ptr %772, i32 0, i32 7
  %774 = load i32, ptr %773, align 4, !tbaa !37
  %775 = load i32, ptr %13, align 4, !tbaa !5
  %776 = sub i32 %775, %774
  store i32 %776, ptr %13, align 4, !tbaa !5
  %777 = load ptr, ptr %5, align 8, !tbaa !9
  %778 = getelementptr inbounds %struct.my_struct, ptr %777, i32 0, i32 2
  %779 = getelementptr inbounds %struct.UT_hash_handle, ptr %778, i32 0, i32 7
  %780 = load i32, ptr %779, align 4, !tbaa !37
  %781 = lshr i32 %780, 12
  %782 = load i32, ptr %13, align 4, !tbaa !5
  %783 = xor i32 %782, %781
  store i32 %783, ptr %13, align 4, !tbaa !5
  %784 = load ptr, ptr %5, align 8, !tbaa !9
  %785 = getelementptr inbounds %struct.my_struct, ptr %784, i32 0, i32 2
  %786 = getelementptr inbounds %struct.UT_hash_handle, ptr %785, i32 0, i32 7
  %787 = load i32, ptr %786, align 4, !tbaa !37
  %788 = load i32, ptr %14, align 4, !tbaa !5
  %789 = sub i32 %788, %787
  store i32 %789, ptr %14, align 4, !tbaa !5
  %790 = load i32, ptr %13, align 4, !tbaa !5
  %791 = load i32, ptr %14, align 4, !tbaa !5
  %792 = sub i32 %791, %790
  store i32 %792, ptr %14, align 4, !tbaa !5
  %793 = load i32, ptr %13, align 4, !tbaa !5
  %794 = shl i32 %793, 16
  %795 = load i32, ptr %14, align 4, !tbaa !5
  %796 = xor i32 %795, %794
  store i32 %796, ptr %14, align 4, !tbaa !5
  %797 = load i32, ptr %13, align 4, !tbaa !5
  %798 = load ptr, ptr %5, align 8, !tbaa !9
  %799 = getelementptr inbounds %struct.my_struct, ptr %798, i32 0, i32 2
  %800 = getelementptr inbounds %struct.UT_hash_handle, ptr %799, i32 0, i32 7
  %801 = load i32, ptr %800, align 4, !tbaa !37
  %802 = sub i32 %801, %797
  store i32 %802, ptr %800, align 4, !tbaa !37
  %803 = load i32, ptr %14, align 4, !tbaa !5
  %804 = load ptr, ptr %5, align 8, !tbaa !9
  %805 = getelementptr inbounds %struct.my_struct, ptr %804, i32 0, i32 2
  %806 = getelementptr inbounds %struct.UT_hash_handle, ptr %805, i32 0, i32 7
  %807 = load i32, ptr %806, align 4, !tbaa !37
  %808 = sub i32 %807, %803
  store i32 %808, ptr %806, align 4, !tbaa !37
  %809 = load i32, ptr %14, align 4, !tbaa !5
  %810 = lshr i32 %809, 5
  %811 = load ptr, ptr %5, align 8, !tbaa !9
  %812 = getelementptr inbounds %struct.my_struct, ptr %811, i32 0, i32 2
  %813 = getelementptr inbounds %struct.UT_hash_handle, ptr %812, i32 0, i32 7
  %814 = load i32, ptr %813, align 4, !tbaa !37
  %815 = xor i32 %814, %810
  store i32 %815, ptr %813, align 4, !tbaa !37
  %816 = load i32, ptr %14, align 4, !tbaa !5
  %817 = load i32, ptr %13, align 4, !tbaa !5
  %818 = sub i32 %817, %816
  store i32 %818, ptr %13, align 4, !tbaa !5
  %819 = load ptr, ptr %5, align 8, !tbaa !9
  %820 = getelementptr inbounds %struct.my_struct, ptr %819, i32 0, i32 2
  %821 = getelementptr inbounds %struct.UT_hash_handle, ptr %820, i32 0, i32 7
  %822 = load i32, ptr %821, align 4, !tbaa !37
  %823 = load i32, ptr %13, align 4, !tbaa !5
  %824 = sub i32 %823, %822
  store i32 %824, ptr %13, align 4, !tbaa !5
  %825 = load ptr, ptr %5, align 8, !tbaa !9
  %826 = getelementptr inbounds %struct.my_struct, ptr %825, i32 0, i32 2
  %827 = getelementptr inbounds %struct.UT_hash_handle, ptr %826, i32 0, i32 7
  %828 = load i32, ptr %827, align 4, !tbaa !37
  %829 = lshr i32 %828, 3
  %830 = load i32, ptr %13, align 4, !tbaa !5
  %831 = xor i32 %830, %829
  store i32 %831, ptr %13, align 4, !tbaa !5
  %832 = load ptr, ptr %5, align 8, !tbaa !9
  %833 = getelementptr inbounds %struct.my_struct, ptr %832, i32 0, i32 2
  %834 = getelementptr inbounds %struct.UT_hash_handle, ptr %833, i32 0, i32 7
  %835 = load i32, ptr %834, align 4, !tbaa !37
  %836 = load i32, ptr %14, align 4, !tbaa !5
  %837 = sub i32 %836, %835
  store i32 %837, ptr %14, align 4, !tbaa !5
  %838 = load i32, ptr %13, align 4, !tbaa !5
  %839 = load i32, ptr %14, align 4, !tbaa !5
  %840 = sub i32 %839, %838
  store i32 %840, ptr %14, align 4, !tbaa !5
  %841 = load i32, ptr %13, align 4, !tbaa !5
  %842 = shl i32 %841, 10
  %843 = load i32, ptr %14, align 4, !tbaa !5
  %844 = xor i32 %843, %842
  store i32 %844, ptr %14, align 4, !tbaa !5
  %845 = load i32, ptr %13, align 4, !tbaa !5
  %846 = load ptr, ptr %5, align 8, !tbaa !9
  %847 = getelementptr inbounds %struct.my_struct, ptr %846, i32 0, i32 2
  %848 = getelementptr inbounds %struct.UT_hash_handle, ptr %847, i32 0, i32 7
  %849 = load i32, ptr %848, align 4, !tbaa !37
  %850 = sub i32 %849, %845
  store i32 %850, ptr %848, align 4, !tbaa !37
  %851 = load i32, ptr %14, align 4, !tbaa !5
  %852 = load ptr, ptr %5, align 8, !tbaa !9
  %853 = getelementptr inbounds %struct.my_struct, ptr %852, i32 0, i32 2
  %854 = getelementptr inbounds %struct.UT_hash_handle, ptr %853, i32 0, i32 7
  %855 = load i32, ptr %854, align 4, !tbaa !37
  %856 = sub i32 %855, %851
  store i32 %856, ptr %854, align 4, !tbaa !37
  %857 = load i32, ptr %14, align 4, !tbaa !5
  %858 = lshr i32 %857, 15
  %859 = load ptr, ptr %5, align 8, !tbaa !9
  %860 = getelementptr inbounds %struct.my_struct, ptr %859, i32 0, i32 2
  %861 = getelementptr inbounds %struct.UT_hash_handle, ptr %860, i32 0, i32 7
  %862 = load i32, ptr %861, align 4, !tbaa !37
  %863 = xor i32 %862, %858
  store i32 %863, ptr %861, align 4, !tbaa !37
  br label %864

864:                                              ; preds = %719
  br label %865

865:                                              ; preds = %864
  %866 = load ptr, ptr %16, align 8, !tbaa !9
  %867 = getelementptr inbounds i8, ptr %866, i64 12
  store ptr %867, ptr %16, align 8, !tbaa !9
  %868 = load i32, ptr %15, align 4, !tbaa !5
  %869 = sub i32 %868, 12
  store i32 %869, ptr %15, align 4, !tbaa !5
  br label %640, !llvm.loop !38

870:                                              ; preds = %640
  %871 = load ptr, ptr %5, align 8, !tbaa !9
  %872 = getelementptr inbounds %struct.my_struct, ptr %871, i32 0, i32 2
  %873 = getelementptr inbounds %struct.UT_hash_handle, ptr %872, i32 0, i32 7
  %874 = load i32, ptr %873, align 4, !tbaa !37
  %875 = add i32 %874, 4
  store i32 %875, ptr %873, align 4, !tbaa !37
  %876 = load i32, ptr %15, align 4, !tbaa !5
  switch i32 %876, label %972 [
    i32 11, label %877
    i32 10, label %888
    i32 9, label %899
    i32 8, label %910
    i32 7, label %918
    i32 6, label %926
    i32 5, label %934
    i32 4, label %941
    i32 3, label %949
    i32 2, label %957
    i32 1, label %965
  ]

877:                                              ; preds = %870
  %878 = load ptr, ptr %16, align 8, !tbaa !9
  %879 = getelementptr inbounds i8, ptr %878, i64 10
  %880 = load i8, ptr %879, align 1, !tbaa !11
  %881 = zext i8 %880 to i32
  %882 = shl i32 %881, 24
  %883 = load ptr, ptr %5, align 8, !tbaa !9
  %884 = getelementptr inbounds %struct.my_struct, ptr %883, i32 0, i32 2
  %885 = getelementptr inbounds %struct.UT_hash_handle, ptr %884, i32 0, i32 7
  %886 = load i32, ptr %885, align 4, !tbaa !37
  %887 = add i32 %886, %882
  store i32 %887, ptr %885, align 4, !tbaa !37
  br label %888

888:                                              ; preds = %877, %870
  %889 = load ptr, ptr %16, align 8, !tbaa !9
  %890 = getelementptr inbounds i8, ptr %889, i64 9
  %891 = load i8, ptr %890, align 1, !tbaa !11
  %892 = zext i8 %891 to i32
  %893 = shl i32 %892, 16
  %894 = load ptr, ptr %5, align 8, !tbaa !9
  %895 = getelementptr inbounds %struct.my_struct, ptr %894, i32 0, i32 2
  %896 = getelementptr inbounds %struct.UT_hash_handle, ptr %895, i32 0, i32 7
  %897 = load i32, ptr %896, align 4, !tbaa !37
  %898 = add i32 %897, %893
  store i32 %898, ptr %896, align 4, !tbaa !37
  br label %899

899:                                              ; preds = %888, %870
  %900 = load ptr, ptr %16, align 8, !tbaa !9
  %901 = getelementptr inbounds i8, ptr %900, i64 8
  %902 = load i8, ptr %901, align 1, !tbaa !11
  %903 = zext i8 %902 to i32
  %904 = shl i32 %903, 8
  %905 = load ptr, ptr %5, align 8, !tbaa !9
  %906 = getelementptr inbounds %struct.my_struct, ptr %905, i32 0, i32 2
  %907 = getelementptr inbounds %struct.UT_hash_handle, ptr %906, i32 0, i32 7
  %908 = load i32, ptr %907, align 4, !tbaa !37
  %909 = add i32 %908, %904
  store i32 %909, ptr %907, align 4, !tbaa !37
  br label %910

910:                                              ; preds = %899, %870
  %911 = load ptr, ptr %16, align 8, !tbaa !9
  %912 = getelementptr inbounds i8, ptr %911, i64 7
  %913 = load i8, ptr %912, align 1, !tbaa !11
  %914 = zext i8 %913 to i32
  %915 = shl i32 %914, 24
  %916 = load i32, ptr %14, align 4, !tbaa !5
  %917 = add i32 %916, %915
  store i32 %917, ptr %14, align 4, !tbaa !5
  br label %918

918:                                              ; preds = %910, %870
  %919 = load ptr, ptr %16, align 8, !tbaa !9
  %920 = getelementptr inbounds i8, ptr %919, i64 6
  %921 = load i8, ptr %920, align 1, !tbaa !11
  %922 = zext i8 %921 to i32
  %923 = shl i32 %922, 16
  %924 = load i32, ptr %14, align 4, !tbaa !5
  %925 = add i32 %924, %923
  store i32 %925, ptr %14, align 4, !tbaa !5
  br label %926

926:                                              ; preds = %918, %870
  %927 = load ptr, ptr %16, align 8, !tbaa !9
  %928 = getelementptr inbounds i8, ptr %927, i64 5
  %929 = load i8, ptr %928, align 1, !tbaa !11
  %930 = zext i8 %929 to i32
  %931 = shl i32 %930, 8
  %932 = load i32, ptr %14, align 4, !tbaa !5
  %933 = add i32 %932, %931
  store i32 %933, ptr %14, align 4, !tbaa !5
  br label %934

934:                                              ; preds = %926, %870
  %935 = load ptr, ptr %16, align 8, !tbaa !9
  %936 = getelementptr inbounds i8, ptr %935, i64 4
  %937 = load i8, ptr %936, align 1, !tbaa !11
  %938 = zext i8 %937 to i32
  %939 = load i32, ptr %14, align 4, !tbaa !5
  %940 = add i32 %939, %938
  store i32 %940, ptr %14, align 4, !tbaa !5
  br label %941

941:                                              ; preds = %934, %870
  %942 = load ptr, ptr %16, align 8, !tbaa !9
  %943 = getelementptr inbounds i8, ptr %942, i64 3
  %944 = load i8, ptr %943, align 1, !tbaa !11
  %945 = zext i8 %944 to i32
  %946 = shl i32 %945, 24
  %947 = load i32, ptr %13, align 4, !tbaa !5
  %948 = add i32 %947, %946
  store i32 %948, ptr %13, align 4, !tbaa !5
  br label %949

949:                                              ; preds = %941, %870
  %950 = load ptr, ptr %16, align 8, !tbaa !9
  %951 = getelementptr inbounds i8, ptr %950, i64 2
  %952 = load i8, ptr %951, align 1, !tbaa !11
  %953 = zext i8 %952 to i32
  %954 = shl i32 %953, 16
  %955 = load i32, ptr %13, align 4, !tbaa !5
  %956 = add i32 %955, %954
  store i32 %956, ptr %13, align 4, !tbaa !5
  br label %957

957:                                              ; preds = %949, %870
  %958 = load ptr, ptr %16, align 8, !tbaa !9
  %959 = getelementptr inbounds i8, ptr %958, i64 1
  %960 = load i8, ptr %959, align 1, !tbaa !11
  %961 = zext i8 %960 to i32
  %962 = shl i32 %961, 8
  %963 = load i32, ptr %13, align 4, !tbaa !5
  %964 = add i32 %963, %962
  store i32 %964, ptr %13, align 4, !tbaa !5
  br label %965

965:                                              ; preds = %957, %870
  %966 = load ptr, ptr %16, align 8, !tbaa !9
  %967 = getelementptr inbounds i8, ptr %966, i64 0
  %968 = load i8, ptr %967, align 1, !tbaa !11
  %969 = zext i8 %968 to i32
  %970 = load i32, ptr %13, align 4, !tbaa !5
  %971 = add i32 %970, %969
  store i32 %971, ptr %13, align 4, !tbaa !5
  br label %972

972:                                              ; preds = %965, %870
  br label %973

973:                                              ; preds = %972
  %974 = load i32, ptr %14, align 4, !tbaa !5
  %975 = load i32, ptr %13, align 4, !tbaa !5
  %976 = sub i32 %975, %974
  store i32 %976, ptr %13, align 4, !tbaa !5
  %977 = load ptr, ptr %5, align 8, !tbaa !9
  %978 = getelementptr inbounds %struct.my_struct, ptr %977, i32 0, i32 2
  %979 = getelementptr inbounds %struct.UT_hash_handle, ptr %978, i32 0, i32 7
  %980 = load i32, ptr %979, align 4, !tbaa !37
  %981 = load i32, ptr %13, align 4, !tbaa !5
  %982 = sub i32 %981, %980
  store i32 %982, ptr %13, align 4, !tbaa !5
  %983 = load ptr, ptr %5, align 8, !tbaa !9
  %984 = getelementptr inbounds %struct.my_struct, ptr %983, i32 0, i32 2
  %985 = getelementptr inbounds %struct.UT_hash_handle, ptr %984, i32 0, i32 7
  %986 = load i32, ptr %985, align 4, !tbaa !37
  %987 = lshr i32 %986, 13
  %988 = load i32, ptr %13, align 4, !tbaa !5
  %989 = xor i32 %988, %987
  store i32 %989, ptr %13, align 4, !tbaa !5
  %990 = load ptr, ptr %5, align 8, !tbaa !9
  %991 = getelementptr inbounds %struct.my_struct, ptr %990, i32 0, i32 2
  %992 = getelementptr inbounds %struct.UT_hash_handle, ptr %991, i32 0, i32 7
  %993 = load i32, ptr %992, align 4, !tbaa !37
  %994 = load i32, ptr %14, align 4, !tbaa !5
  %995 = sub i32 %994, %993
  store i32 %995, ptr %14, align 4, !tbaa !5
  %996 = load i32, ptr %13, align 4, !tbaa !5
  %997 = load i32, ptr %14, align 4, !tbaa !5
  %998 = sub i32 %997, %996
  store i32 %998, ptr %14, align 4, !tbaa !5
  %999 = load i32, ptr %13, align 4, !tbaa !5
  %1000 = shl i32 %999, 8
  %1001 = load i32, ptr %14, align 4, !tbaa !5
  %1002 = xor i32 %1001, %1000
  store i32 %1002, ptr %14, align 4, !tbaa !5
  %1003 = load i32, ptr %13, align 4, !tbaa !5
  %1004 = load ptr, ptr %5, align 8, !tbaa !9
  %1005 = getelementptr inbounds %struct.my_struct, ptr %1004, i32 0, i32 2
  %1006 = getelementptr inbounds %struct.UT_hash_handle, ptr %1005, i32 0, i32 7
  %1007 = load i32, ptr %1006, align 4, !tbaa !37
  %1008 = sub i32 %1007, %1003
  store i32 %1008, ptr %1006, align 4, !tbaa !37
  %1009 = load i32, ptr %14, align 4, !tbaa !5
  %1010 = load ptr, ptr %5, align 8, !tbaa !9
  %1011 = getelementptr inbounds %struct.my_struct, ptr %1010, i32 0, i32 2
  %1012 = getelementptr inbounds %struct.UT_hash_handle, ptr %1011, i32 0, i32 7
  %1013 = load i32, ptr %1012, align 4, !tbaa !37
  %1014 = sub i32 %1013, %1009
  store i32 %1014, ptr %1012, align 4, !tbaa !37
  %1015 = load i32, ptr %14, align 4, !tbaa !5
  %1016 = lshr i32 %1015, 13
  %1017 = load ptr, ptr %5, align 8, !tbaa !9
  %1018 = getelementptr inbounds %struct.my_struct, ptr %1017, i32 0, i32 2
  %1019 = getelementptr inbounds %struct.UT_hash_handle, ptr %1018, i32 0, i32 7
  %1020 = load i32, ptr %1019, align 4, !tbaa !37
  %1021 = xor i32 %1020, %1016
  store i32 %1021, ptr %1019, align 4, !tbaa !37
  %1022 = load i32, ptr %14, align 4, !tbaa !5
  %1023 = load i32, ptr %13, align 4, !tbaa !5
  %1024 = sub i32 %1023, %1022
  store i32 %1024, ptr %13, align 4, !tbaa !5
  %1025 = load ptr, ptr %5, align 8, !tbaa !9
  %1026 = getelementptr inbounds %struct.my_struct, ptr %1025, i32 0, i32 2
  %1027 = getelementptr inbounds %struct.UT_hash_handle, ptr %1026, i32 0, i32 7
  %1028 = load i32, ptr %1027, align 4, !tbaa !37
  %1029 = load i32, ptr %13, align 4, !tbaa !5
  %1030 = sub i32 %1029, %1028
  store i32 %1030, ptr %13, align 4, !tbaa !5
  %1031 = load ptr, ptr %5, align 8, !tbaa !9
  %1032 = getelementptr inbounds %struct.my_struct, ptr %1031, i32 0, i32 2
  %1033 = getelementptr inbounds %struct.UT_hash_handle, ptr %1032, i32 0, i32 7
  %1034 = load i32, ptr %1033, align 4, !tbaa !37
  %1035 = lshr i32 %1034, 12
  %1036 = load i32, ptr %13, align 4, !tbaa !5
  %1037 = xor i32 %1036, %1035
  store i32 %1037, ptr %13, align 4, !tbaa !5
  %1038 = load ptr, ptr %5, align 8, !tbaa !9
  %1039 = getelementptr inbounds %struct.my_struct, ptr %1038, i32 0, i32 2
  %1040 = getelementptr inbounds %struct.UT_hash_handle, ptr %1039, i32 0, i32 7
  %1041 = load i32, ptr %1040, align 4, !tbaa !37
  %1042 = load i32, ptr %14, align 4, !tbaa !5
  %1043 = sub i32 %1042, %1041
  store i32 %1043, ptr %14, align 4, !tbaa !5
  %1044 = load i32, ptr %13, align 4, !tbaa !5
  %1045 = load i32, ptr %14, align 4, !tbaa !5
  %1046 = sub i32 %1045, %1044
  store i32 %1046, ptr %14, align 4, !tbaa !5
  %1047 = load i32, ptr %13, align 4, !tbaa !5
  %1048 = shl i32 %1047, 16
  %1049 = load i32, ptr %14, align 4, !tbaa !5
  %1050 = xor i32 %1049, %1048
  store i32 %1050, ptr %14, align 4, !tbaa !5
  %1051 = load i32, ptr %13, align 4, !tbaa !5
  %1052 = load ptr, ptr %5, align 8, !tbaa !9
  %1053 = getelementptr inbounds %struct.my_struct, ptr %1052, i32 0, i32 2
  %1054 = getelementptr inbounds %struct.UT_hash_handle, ptr %1053, i32 0, i32 7
  %1055 = load i32, ptr %1054, align 4, !tbaa !37
  %1056 = sub i32 %1055, %1051
  store i32 %1056, ptr %1054, align 4, !tbaa !37
  %1057 = load i32, ptr %14, align 4, !tbaa !5
  %1058 = load ptr, ptr %5, align 8, !tbaa !9
  %1059 = getelementptr inbounds %struct.my_struct, ptr %1058, i32 0, i32 2
  %1060 = getelementptr inbounds %struct.UT_hash_handle, ptr %1059, i32 0, i32 7
  %1061 = load i32, ptr %1060, align 4, !tbaa !37
  %1062 = sub i32 %1061, %1057
  store i32 %1062, ptr %1060, align 4, !tbaa !37
  %1063 = load i32, ptr %14, align 4, !tbaa !5
  %1064 = lshr i32 %1063, 5
  %1065 = load ptr, ptr %5, align 8, !tbaa !9
  %1066 = getelementptr inbounds %struct.my_struct, ptr %1065, i32 0, i32 2
  %1067 = getelementptr inbounds %struct.UT_hash_handle, ptr %1066, i32 0, i32 7
  %1068 = load i32, ptr %1067, align 4, !tbaa !37
  %1069 = xor i32 %1068, %1064
  store i32 %1069, ptr %1067, align 4, !tbaa !37
  %1070 = load i32, ptr %14, align 4, !tbaa !5
  %1071 = load i32, ptr %13, align 4, !tbaa !5
  %1072 = sub i32 %1071, %1070
  store i32 %1072, ptr %13, align 4, !tbaa !5
  %1073 = load ptr, ptr %5, align 8, !tbaa !9
  %1074 = getelementptr inbounds %struct.my_struct, ptr %1073, i32 0, i32 2
  %1075 = getelementptr inbounds %struct.UT_hash_handle, ptr %1074, i32 0, i32 7
  %1076 = load i32, ptr %1075, align 4, !tbaa !37
  %1077 = load i32, ptr %13, align 4, !tbaa !5
  %1078 = sub i32 %1077, %1076
  store i32 %1078, ptr %13, align 4, !tbaa !5
  %1079 = load ptr, ptr %5, align 8, !tbaa !9
  %1080 = getelementptr inbounds %struct.my_struct, ptr %1079, i32 0, i32 2
  %1081 = getelementptr inbounds %struct.UT_hash_handle, ptr %1080, i32 0, i32 7
  %1082 = load i32, ptr %1081, align 4, !tbaa !37
  %1083 = lshr i32 %1082, 3
  %1084 = load i32, ptr %13, align 4, !tbaa !5
  %1085 = xor i32 %1084, %1083
  store i32 %1085, ptr %13, align 4, !tbaa !5
  %1086 = load ptr, ptr %5, align 8, !tbaa !9
  %1087 = getelementptr inbounds %struct.my_struct, ptr %1086, i32 0, i32 2
  %1088 = getelementptr inbounds %struct.UT_hash_handle, ptr %1087, i32 0, i32 7
  %1089 = load i32, ptr %1088, align 4, !tbaa !37
  %1090 = load i32, ptr %14, align 4, !tbaa !5
  %1091 = sub i32 %1090, %1089
  store i32 %1091, ptr %14, align 4, !tbaa !5
  %1092 = load i32, ptr %13, align 4, !tbaa !5
  %1093 = load i32, ptr %14, align 4, !tbaa !5
  %1094 = sub i32 %1093, %1092
  store i32 %1094, ptr %14, align 4, !tbaa !5
  %1095 = load i32, ptr %13, align 4, !tbaa !5
  %1096 = shl i32 %1095, 10
  %1097 = load i32, ptr %14, align 4, !tbaa !5
  %1098 = xor i32 %1097, %1096
  store i32 %1098, ptr %14, align 4, !tbaa !5
  %1099 = load i32, ptr %13, align 4, !tbaa !5
  %1100 = load ptr, ptr %5, align 8, !tbaa !9
  %1101 = getelementptr inbounds %struct.my_struct, ptr %1100, i32 0, i32 2
  %1102 = getelementptr inbounds %struct.UT_hash_handle, ptr %1101, i32 0, i32 7
  %1103 = load i32, ptr %1102, align 4, !tbaa !37
  %1104 = sub i32 %1103, %1099
  store i32 %1104, ptr %1102, align 4, !tbaa !37
  %1105 = load i32, ptr %14, align 4, !tbaa !5
  %1106 = load ptr, ptr %5, align 8, !tbaa !9
  %1107 = getelementptr inbounds %struct.my_struct, ptr %1106, i32 0, i32 2
  %1108 = getelementptr inbounds %struct.UT_hash_handle, ptr %1107, i32 0, i32 7
  %1109 = load i32, ptr %1108, align 4, !tbaa !37
  %1110 = sub i32 %1109, %1105
  store i32 %1110, ptr %1108, align 4, !tbaa !37
  %1111 = load i32, ptr %14, align 4, !tbaa !5
  %1112 = lshr i32 %1111, 15
  %1113 = load ptr, ptr %5, align 8, !tbaa !9
  %1114 = getelementptr inbounds %struct.my_struct, ptr %1113, i32 0, i32 2
  %1115 = getelementptr inbounds %struct.UT_hash_handle, ptr %1114, i32 0, i32 7
  %1116 = load i32, ptr %1115, align 4, !tbaa !37
  %1117 = xor i32 %1116, %1112
  store i32 %1117, ptr %1115, align 4, !tbaa !37
  br label %1118

1118:                                             ; preds = %973
  br label %1119

1119:                                             ; preds = %1118
  %1120 = load ptr, ptr %5, align 8, !tbaa !9
  %1121 = getelementptr inbounds %struct.my_struct, ptr %1120, i32 0, i32 2
  %1122 = getelementptr inbounds %struct.UT_hash_handle, ptr %1121, i32 0, i32 7
  %1123 = load i32, ptr %1122, align 4, !tbaa !37
  %1124 = load ptr, ptr @users, align 8, !tbaa !9
  %1125 = getelementptr inbounds %struct.my_struct, ptr %1124, i32 0, i32 2
  %1126 = getelementptr inbounds %struct.UT_hash_handle, ptr %1125, i32 0, i32 0
  %1127 = load ptr, ptr %1126, align 8, !tbaa !14
  %1128 = getelementptr inbounds %struct.UT_hash_table, ptr %1127, i32 0, i32 1
  %1129 = load i32, ptr %1128, align 8, !tbaa !18
  %1130 = sub i32 %1129, 1
  %1131 = and i32 %1123, %1130
  store i32 %1131, ptr %12, align 4, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #7
  br label %1132

1132:                                             ; preds = %1119
  br label %1133

1133:                                             ; preds = %1132
  br label %1134

1134:                                             ; preds = %1133
  %1135 = load ptr, ptr @users, align 8, !tbaa !9
  %1136 = getelementptr inbounds %struct.my_struct, ptr %1135, i32 0, i32 2
  %1137 = getelementptr inbounds %struct.UT_hash_handle, ptr %1136, i32 0, i32 0
  %1138 = load ptr, ptr %1137, align 8, !tbaa !14
  %1139 = getelementptr inbounds %struct.UT_hash_table, ptr %1138, i32 0, i32 0
  %1140 = load ptr, ptr %1139, align 8, !tbaa !21
  %1141 = load i32, ptr %12, align 4, !tbaa !5
  %1142 = zext i32 %1141 to i64
  %1143 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1140, i64 %1142
  %1144 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1143, i32 0, i32 1
  %1145 = load i32, ptr %1144, align 8, !tbaa !39
  %1146 = add i32 %1145, 1
  store i32 %1146, ptr %1144, align 8, !tbaa !39
  %1147 = load ptr, ptr @users, align 8, !tbaa !9
  %1148 = getelementptr inbounds %struct.my_struct, ptr %1147, i32 0, i32 2
  %1149 = getelementptr inbounds %struct.UT_hash_handle, ptr %1148, i32 0, i32 0
  %1150 = load ptr, ptr %1149, align 8, !tbaa !14
  %1151 = getelementptr inbounds %struct.UT_hash_table, ptr %1150, i32 0, i32 0
  %1152 = load ptr, ptr %1151, align 8, !tbaa !21
  %1153 = load i32, ptr %12, align 4, !tbaa !5
  %1154 = zext i32 %1153 to i64
  %1155 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1152, i64 %1154
  %1156 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1155, i32 0, i32 0
  %1157 = load ptr, ptr %1156, align 8, !tbaa !22
  %1158 = load ptr, ptr %5, align 8, !tbaa !9
  %1159 = getelementptr inbounds %struct.my_struct, ptr %1158, i32 0, i32 2
  %1160 = getelementptr inbounds %struct.UT_hash_handle, ptr %1159, i32 0, i32 4
  store ptr %1157, ptr %1160, align 8, !tbaa !27
  %1161 = load ptr, ptr %5, align 8, !tbaa !9
  %1162 = getelementptr inbounds %struct.my_struct, ptr %1161, i32 0, i32 2
  %1163 = getelementptr inbounds %struct.UT_hash_handle, ptr %1162, i32 0, i32 3
  store ptr null, ptr %1163, align 8, !tbaa !40
  %1164 = load ptr, ptr @users, align 8, !tbaa !9
  %1165 = getelementptr inbounds %struct.my_struct, ptr %1164, i32 0, i32 2
  %1166 = getelementptr inbounds %struct.UT_hash_handle, ptr %1165, i32 0, i32 0
  %1167 = load ptr, ptr %1166, align 8, !tbaa !14
  %1168 = getelementptr inbounds %struct.UT_hash_table, ptr %1167, i32 0, i32 0
  %1169 = load ptr, ptr %1168, align 8, !tbaa !21
  %1170 = load i32, ptr %12, align 4, !tbaa !5
  %1171 = zext i32 %1170 to i64
  %1172 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1169, i64 %1171
  %1173 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1172, i32 0, i32 0
  %1174 = load ptr, ptr %1173, align 8, !tbaa !22
  %1175 = icmp ne ptr %1174, null
  br i1 %1175, label %1176, label %1191

1176:                                             ; preds = %1134
  %1177 = load ptr, ptr %5, align 8, !tbaa !9
  %1178 = getelementptr inbounds %struct.my_struct, ptr %1177, i32 0, i32 2
  %1179 = load ptr, ptr @users, align 8, !tbaa !9
  %1180 = getelementptr inbounds %struct.my_struct, ptr %1179, i32 0, i32 2
  %1181 = getelementptr inbounds %struct.UT_hash_handle, ptr %1180, i32 0, i32 0
  %1182 = load ptr, ptr %1181, align 8, !tbaa !14
  %1183 = getelementptr inbounds %struct.UT_hash_table, ptr %1182, i32 0, i32 0
  %1184 = load ptr, ptr %1183, align 8, !tbaa !21
  %1185 = load i32, ptr %12, align 4, !tbaa !5
  %1186 = zext i32 %1185 to i64
  %1187 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1184, i64 %1186
  %1188 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1187, i32 0, i32 0
  %1189 = load ptr, ptr %1188, align 8, !tbaa !22
  %1190 = getelementptr inbounds %struct.UT_hash_handle, ptr %1189, i32 0, i32 3
  store ptr %1178, ptr %1190, align 8, !tbaa !41
  br label %1191

1191:                                             ; preds = %1176, %1134
  %1192 = load ptr, ptr %5, align 8, !tbaa !9
  %1193 = getelementptr inbounds %struct.my_struct, ptr %1192, i32 0, i32 2
  %1194 = load ptr, ptr @users, align 8, !tbaa !9
  %1195 = getelementptr inbounds %struct.my_struct, ptr %1194, i32 0, i32 2
  %1196 = getelementptr inbounds %struct.UT_hash_handle, ptr %1195, i32 0, i32 0
  %1197 = load ptr, ptr %1196, align 8, !tbaa !14
  %1198 = getelementptr inbounds %struct.UT_hash_table, ptr %1197, i32 0, i32 0
  %1199 = load ptr, ptr %1198, align 8, !tbaa !21
  %1200 = load i32, ptr %12, align 4, !tbaa !5
  %1201 = zext i32 %1200 to i64
  %1202 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1199, i64 %1201
  %1203 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1202, i32 0, i32 0
  store ptr %1193, ptr %1203, align 8, !tbaa !22
  %1204 = load ptr, ptr @users, align 8, !tbaa !9
  %1205 = getelementptr inbounds %struct.my_struct, ptr %1204, i32 0, i32 2
  %1206 = getelementptr inbounds %struct.UT_hash_handle, ptr %1205, i32 0, i32 0
  %1207 = load ptr, ptr %1206, align 8, !tbaa !14
  %1208 = getelementptr inbounds %struct.UT_hash_table, ptr %1207, i32 0, i32 0
  %1209 = load ptr, ptr %1208, align 8, !tbaa !21
  %1210 = load i32, ptr %12, align 4, !tbaa !5
  %1211 = zext i32 %1210 to i64
  %1212 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1209, i64 %1211
  %1213 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1212, i32 0, i32 1
  %1214 = load i32, ptr %1213, align 8, !tbaa !39
  %1215 = load ptr, ptr @users, align 8, !tbaa !9
  %1216 = getelementptr inbounds %struct.my_struct, ptr %1215, i32 0, i32 2
  %1217 = getelementptr inbounds %struct.UT_hash_handle, ptr %1216, i32 0, i32 0
  %1218 = load ptr, ptr %1217, align 8, !tbaa !14
  %1219 = getelementptr inbounds %struct.UT_hash_table, ptr %1218, i32 0, i32 0
  %1220 = load ptr, ptr %1219, align 8, !tbaa !21
  %1221 = load i32, ptr %12, align 4, !tbaa !5
  %1222 = zext i32 %1221 to i64
  %1223 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1220, i64 %1222
  %1224 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1223, i32 0, i32 2
  %1225 = load i32, ptr %1224, align 4, !tbaa !42
  %1226 = add i32 %1225, 1
  %1227 = mul i32 %1226, 10
  %1228 = icmp uge i32 %1214, %1227
  br i1 %1228, label %1229, label %1484

1229:                                             ; preds = %1191
  %1230 = load ptr, ptr %5, align 8, !tbaa !9
  %1231 = getelementptr inbounds %struct.my_struct, ptr %1230, i32 0, i32 2
  %1232 = getelementptr inbounds %struct.UT_hash_handle, ptr %1231, i32 0, i32 0
  %1233 = load ptr, ptr %1232, align 8, !tbaa !14
  %1234 = getelementptr inbounds %struct.UT_hash_table, ptr %1233, i32 0, i32 9
  %1235 = load i32, ptr %1234, align 4, !tbaa !43
  %1236 = icmp ne i32 %1235, 1
  br i1 %1236, label %1237, label %1484

1237:                                             ; preds = %1229
  br label %1238

1238:                                             ; preds = %1237
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #7
  %1239 = load ptr, ptr %5, align 8, !tbaa !9
  %1240 = getelementptr inbounds %struct.my_struct, ptr %1239, i32 0, i32 2
  %1241 = getelementptr inbounds %struct.UT_hash_handle, ptr %1240, i32 0, i32 0
  %1242 = load ptr, ptr %1241, align 8, !tbaa !14
  %1243 = getelementptr inbounds %struct.UT_hash_table, ptr %1242, i32 0, i32 1
  %1244 = load i32, ptr %1243, align 8, !tbaa !18
  %1245 = zext i32 %1244 to i64
  %1246 = mul i64 2, %1245
  %1247 = mul i64 %1246, 16
  %1248 = call noalias ptr @malloc(i64 noundef %1247) #9
  store ptr %1248, ptr %21, align 8, !tbaa !9
  %1249 = load ptr, ptr %21, align 8, !tbaa !9
  %1250 = icmp ne ptr %1249, null
  br i1 %1250, label %1252, label %1251

1251:                                             ; preds = %1238
  call void @exit(i32 noundef -1) #10
  unreachable

1252:                                             ; preds = %1238
  %1253 = load ptr, ptr %21, align 8, !tbaa !9
  %1254 = load ptr, ptr %5, align 8, !tbaa !9
  %1255 = getelementptr inbounds %struct.my_struct, ptr %1254, i32 0, i32 2
  %1256 = getelementptr inbounds %struct.UT_hash_handle, ptr %1255, i32 0, i32 0
  %1257 = load ptr, ptr %1256, align 8, !tbaa !14
  %1258 = getelementptr inbounds %struct.UT_hash_table, ptr %1257, i32 0, i32 1
  %1259 = load i32, ptr %1258, align 8, !tbaa !18
  %1260 = zext i32 %1259 to i64
  %1261 = mul i64 2, %1260
  %1262 = mul i64 %1261, 16
  call void @llvm.memset.p0.i64(ptr align 8 %1253, i8 0, i64 %1262, i1 false)
  %1263 = load ptr, ptr %5, align 8, !tbaa !9
  %1264 = getelementptr inbounds %struct.my_struct, ptr %1263, i32 0, i32 2
  %1265 = getelementptr inbounds %struct.UT_hash_handle, ptr %1264, i32 0, i32 0
  %1266 = load ptr, ptr %1265, align 8, !tbaa !14
  %1267 = getelementptr inbounds %struct.UT_hash_table, ptr %1266, i32 0, i32 3
  %1268 = load i32, ptr %1267, align 8, !tbaa !36
  %1269 = load ptr, ptr %5, align 8, !tbaa !9
  %1270 = getelementptr inbounds %struct.my_struct, ptr %1269, i32 0, i32 2
  %1271 = getelementptr inbounds %struct.UT_hash_handle, ptr %1270, i32 0, i32 0
  %1272 = load ptr, ptr %1271, align 8, !tbaa !14
  %1273 = getelementptr inbounds %struct.UT_hash_table, ptr %1272, i32 0, i32 2
  %1274 = load i32, ptr %1273, align 4, !tbaa !33
  %1275 = add i32 %1274, 1
  %1276 = lshr i32 %1268, %1275
  %1277 = load ptr, ptr %5, align 8, !tbaa !9
  %1278 = getelementptr inbounds %struct.my_struct, ptr %1277, i32 0, i32 2
  %1279 = getelementptr inbounds %struct.UT_hash_handle, ptr %1278, i32 0, i32 0
  %1280 = load ptr, ptr %1279, align 8, !tbaa !14
  %1281 = getelementptr inbounds %struct.UT_hash_table, ptr %1280, i32 0, i32 3
  %1282 = load i32, ptr %1281, align 8, !tbaa !36
  %1283 = load ptr, ptr %5, align 8, !tbaa !9
  %1284 = getelementptr inbounds %struct.my_struct, ptr %1283, i32 0, i32 2
  %1285 = getelementptr inbounds %struct.UT_hash_handle, ptr %1284, i32 0, i32 0
  %1286 = load ptr, ptr %1285, align 8, !tbaa !14
  %1287 = getelementptr inbounds %struct.UT_hash_table, ptr %1286, i32 0, i32 1
  %1288 = load i32, ptr %1287, align 8, !tbaa !18
  %1289 = mul i32 %1288, 2
  %1290 = sub i32 %1289, 1
  %1291 = and i32 %1282, %1290
  %1292 = icmp ne i32 %1291, 0
  %1293 = zext i1 %1292 to i64
  %1294 = select i1 %1292, i32 1, i32 0
  %1295 = add i32 %1276, %1294
  %1296 = load ptr, ptr %5, align 8, !tbaa !9
  %1297 = getelementptr inbounds %struct.my_struct, ptr %1296, i32 0, i32 2
  %1298 = getelementptr inbounds %struct.UT_hash_handle, ptr %1297, i32 0, i32 0
  %1299 = load ptr, ptr %1298, align 8, !tbaa !14
  %1300 = getelementptr inbounds %struct.UT_hash_table, ptr %1299, i32 0, i32 6
  store i32 %1295, ptr %1300, align 8, !tbaa !44
  %1301 = load ptr, ptr %5, align 8, !tbaa !9
  %1302 = getelementptr inbounds %struct.my_struct, ptr %1301, i32 0, i32 2
  %1303 = getelementptr inbounds %struct.UT_hash_handle, ptr %1302, i32 0, i32 0
  %1304 = load ptr, ptr %1303, align 8, !tbaa !14
  %1305 = getelementptr inbounds %struct.UT_hash_table, ptr %1304, i32 0, i32 7
  store i32 0, ptr %1305, align 4, !tbaa !45
  store i32 0, ptr %18, align 4, !tbaa !5
  br label %1306

1306:                                             ; preds = %1408, %1252
  %1307 = load i32, ptr %18, align 4, !tbaa !5
  %1308 = load ptr, ptr %5, align 8, !tbaa !9
  %1309 = getelementptr inbounds %struct.my_struct, ptr %1308, i32 0, i32 2
  %1310 = getelementptr inbounds %struct.UT_hash_handle, ptr %1309, i32 0, i32 0
  %1311 = load ptr, ptr %1310, align 8, !tbaa !14
  %1312 = getelementptr inbounds %struct.UT_hash_table, ptr %1311, i32 0, i32 1
  %1313 = load i32, ptr %1312, align 8, !tbaa !18
  %1314 = icmp ult i32 %1307, %1313
  br i1 %1314, label %1315, label %1411

1315:                                             ; preds = %1306
  %1316 = load ptr, ptr %5, align 8, !tbaa !9
  %1317 = getelementptr inbounds %struct.my_struct, ptr %1316, i32 0, i32 2
  %1318 = getelementptr inbounds %struct.UT_hash_handle, ptr %1317, i32 0, i32 0
  %1319 = load ptr, ptr %1318, align 8, !tbaa !14
  %1320 = getelementptr inbounds %struct.UT_hash_table, ptr %1319, i32 0, i32 0
  %1321 = load ptr, ptr %1320, align 8, !tbaa !21
  %1322 = load i32, ptr %18, align 4, !tbaa !5
  %1323 = zext i32 %1322 to i64
  %1324 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1321, i64 %1323
  %1325 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1324, i32 0, i32 0
  %1326 = load ptr, ptr %1325, align 8, !tbaa !22
  store ptr %1326, ptr %19, align 8, !tbaa !9
  br label %1327

1327:                                             ; preds = %1402, %1315
  %1328 = load ptr, ptr %19, align 8, !tbaa !9
  %1329 = icmp ne ptr %1328, null
  br i1 %1329, label %1330, label %1407

1330:                                             ; preds = %1327
  %1331 = load ptr, ptr %19, align 8, !tbaa !9
  %1332 = getelementptr inbounds %struct.UT_hash_handle, ptr %1331, i32 0, i32 4
  %1333 = load ptr, ptr %1332, align 8, !tbaa !46
  store ptr %1333, ptr %20, align 8, !tbaa !9
  br label %1334

1334:                                             ; preds = %1330
  %1335 = load ptr, ptr %19, align 8, !tbaa !9
  %1336 = getelementptr inbounds %struct.UT_hash_handle, ptr %1335, i32 0, i32 7
  %1337 = load i32, ptr %1336, align 4, !tbaa !47
  %1338 = load ptr, ptr %5, align 8, !tbaa !9
  %1339 = getelementptr inbounds %struct.my_struct, ptr %1338, i32 0, i32 2
  %1340 = getelementptr inbounds %struct.UT_hash_handle, ptr %1339, i32 0, i32 0
  %1341 = load ptr, ptr %1340, align 8, !tbaa !14
  %1342 = getelementptr inbounds %struct.UT_hash_table, ptr %1341, i32 0, i32 1
  %1343 = load i32, ptr %1342, align 8, !tbaa !18
  %1344 = mul i32 %1343, 2
  %1345 = sub i32 %1344, 1
  %1346 = and i32 %1337, %1345
  store i32 %1346, ptr %17, align 4, !tbaa !5
  br label %1347

1347:                                             ; preds = %1334
  br label %1348

1348:                                             ; preds = %1347
  %1349 = load ptr, ptr %21, align 8, !tbaa !9
  %1350 = load i32, ptr %17, align 4, !tbaa !5
  %1351 = zext i32 %1350 to i64
  %1352 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1349, i64 %1351
  store ptr %1352, ptr %22, align 8, !tbaa !9
  %1353 = load ptr, ptr %22, align 8, !tbaa !9
  %1354 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1353, i32 0, i32 1
  %1355 = load i32, ptr %1354, align 8, !tbaa !39
  %1356 = add i32 %1355, 1
  store i32 %1356, ptr %1354, align 8, !tbaa !39
  %1357 = load ptr, ptr %5, align 8, !tbaa !9
  %1358 = getelementptr inbounds %struct.my_struct, ptr %1357, i32 0, i32 2
  %1359 = getelementptr inbounds %struct.UT_hash_handle, ptr %1358, i32 0, i32 0
  %1360 = load ptr, ptr %1359, align 8, !tbaa !14
  %1361 = getelementptr inbounds %struct.UT_hash_table, ptr %1360, i32 0, i32 6
  %1362 = load i32, ptr %1361, align 8, !tbaa !44
  %1363 = icmp ugt i32 %1356, %1362
  br i1 %1363, label %1364, label %1384

1364:                                             ; preds = %1348
  %1365 = load ptr, ptr %5, align 8, !tbaa !9
  %1366 = getelementptr inbounds %struct.my_struct, ptr %1365, i32 0, i32 2
  %1367 = getelementptr inbounds %struct.UT_hash_handle, ptr %1366, i32 0, i32 0
  %1368 = load ptr, ptr %1367, align 8, !tbaa !14
  %1369 = getelementptr inbounds %struct.UT_hash_table, ptr %1368, i32 0, i32 7
  %1370 = load i32, ptr %1369, align 4, !tbaa !45
  %1371 = add i32 %1370, 1
  store i32 %1371, ptr %1369, align 4, !tbaa !45
  %1372 = load ptr, ptr %22, align 8, !tbaa !9
  %1373 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1372, i32 0, i32 1
  %1374 = load i32, ptr %1373, align 8, !tbaa !39
  %1375 = load ptr, ptr %5, align 8, !tbaa !9
  %1376 = getelementptr inbounds %struct.my_struct, ptr %1375, i32 0, i32 2
  %1377 = getelementptr inbounds %struct.UT_hash_handle, ptr %1376, i32 0, i32 0
  %1378 = load ptr, ptr %1377, align 8, !tbaa !14
  %1379 = getelementptr inbounds %struct.UT_hash_table, ptr %1378, i32 0, i32 6
  %1380 = load i32, ptr %1379, align 8, !tbaa !44
  %1381 = udiv i32 %1374, %1380
  %1382 = load ptr, ptr %22, align 8, !tbaa !9
  %1383 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1382, i32 0, i32 2
  store i32 %1381, ptr %1383, align 4, !tbaa !42
  br label %1384

1384:                                             ; preds = %1364, %1348
  %1385 = load ptr, ptr %19, align 8, !tbaa !9
  %1386 = getelementptr inbounds %struct.UT_hash_handle, ptr %1385, i32 0, i32 3
  store ptr null, ptr %1386, align 8, !tbaa !41
  %1387 = load ptr, ptr %22, align 8, !tbaa !9
  %1388 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1387, i32 0, i32 0
  %1389 = load ptr, ptr %1388, align 8, !tbaa !22
  %1390 = load ptr, ptr %19, align 8, !tbaa !9
  %1391 = getelementptr inbounds %struct.UT_hash_handle, ptr %1390, i32 0, i32 4
  store ptr %1389, ptr %1391, align 8, !tbaa !46
  %1392 = load ptr, ptr %22, align 8, !tbaa !9
  %1393 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1392, i32 0, i32 0
  %1394 = load ptr, ptr %1393, align 8, !tbaa !22
  %1395 = icmp ne ptr %1394, null
  br i1 %1395, label %1396, label %1402

1396:                                             ; preds = %1384
  %1397 = load ptr, ptr %19, align 8, !tbaa !9
  %1398 = load ptr, ptr %22, align 8, !tbaa !9
  %1399 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1398, i32 0, i32 0
  %1400 = load ptr, ptr %1399, align 8, !tbaa !22
  %1401 = getelementptr inbounds %struct.UT_hash_handle, ptr %1400, i32 0, i32 3
  store ptr %1397, ptr %1401, align 8, !tbaa !41
  br label %1402

1402:                                             ; preds = %1396, %1384
  %1403 = load ptr, ptr %19, align 8, !tbaa !9
  %1404 = load ptr, ptr %22, align 8, !tbaa !9
  %1405 = getelementptr inbounds %struct.UT_hash_bucket, ptr %1404, i32 0, i32 0
  store ptr %1403, ptr %1405, align 8, !tbaa !22
  %1406 = load ptr, ptr %20, align 8, !tbaa !9
  store ptr %1406, ptr %19, align 8, !tbaa !9
  br label %1327, !llvm.loop !48

1407:                                             ; preds = %1327
  br label %1408

1408:                                             ; preds = %1407
  %1409 = load i32, ptr %18, align 4, !tbaa !5
  %1410 = add i32 %1409, 1
  store i32 %1410, ptr %18, align 4, !tbaa !5
  br label %1306, !llvm.loop !49

1411:                                             ; preds = %1306
  %1412 = load ptr, ptr %5, align 8, !tbaa !9
  %1413 = getelementptr inbounds %struct.my_struct, ptr %1412, i32 0, i32 2
  %1414 = getelementptr inbounds %struct.UT_hash_handle, ptr %1413, i32 0, i32 0
  %1415 = load ptr, ptr %1414, align 8, !tbaa !14
  %1416 = getelementptr inbounds %struct.UT_hash_table, ptr %1415, i32 0, i32 0
  %1417 = load ptr, ptr %1416, align 8, !tbaa !21
  call void @free(ptr noundef %1417) #7
  %1418 = load ptr, ptr %5, align 8, !tbaa !9
  %1419 = getelementptr inbounds %struct.my_struct, ptr %1418, i32 0, i32 2
  %1420 = getelementptr inbounds %struct.UT_hash_handle, ptr %1419, i32 0, i32 0
  %1421 = load ptr, ptr %1420, align 8, !tbaa !14
  %1422 = getelementptr inbounds %struct.UT_hash_table, ptr %1421, i32 0, i32 1
  %1423 = load i32, ptr %1422, align 8, !tbaa !18
  %1424 = mul i32 %1423, 2
  store i32 %1424, ptr %1422, align 8, !tbaa !18
  %1425 = load ptr, ptr %5, align 8, !tbaa !9
  %1426 = getelementptr inbounds %struct.my_struct, ptr %1425, i32 0, i32 2
  %1427 = getelementptr inbounds %struct.UT_hash_handle, ptr %1426, i32 0, i32 0
  %1428 = load ptr, ptr %1427, align 8, !tbaa !14
  %1429 = getelementptr inbounds %struct.UT_hash_table, ptr %1428, i32 0, i32 2
  %1430 = load i32, ptr %1429, align 4, !tbaa !33
  %1431 = add i32 %1430, 1
  store i32 %1431, ptr %1429, align 4, !tbaa !33
  %1432 = load ptr, ptr %21, align 8, !tbaa !9
  %1433 = load ptr, ptr %5, align 8, !tbaa !9
  %1434 = getelementptr inbounds %struct.my_struct, ptr %1433, i32 0, i32 2
  %1435 = getelementptr inbounds %struct.UT_hash_handle, ptr %1434, i32 0, i32 0
  %1436 = load ptr, ptr %1435, align 8, !tbaa !14
  %1437 = getelementptr inbounds %struct.UT_hash_table, ptr %1436, i32 0, i32 0
  store ptr %1432, ptr %1437, align 8, !tbaa !21
  %1438 = load ptr, ptr %5, align 8, !tbaa !9
  %1439 = getelementptr inbounds %struct.my_struct, ptr %1438, i32 0, i32 2
  %1440 = getelementptr inbounds %struct.UT_hash_handle, ptr %1439, i32 0, i32 0
  %1441 = load ptr, ptr %1440, align 8, !tbaa !14
  %1442 = getelementptr inbounds %struct.UT_hash_table, ptr %1441, i32 0, i32 7
  %1443 = load i32, ptr %1442, align 4, !tbaa !45
  %1444 = load ptr, ptr %5, align 8, !tbaa !9
  %1445 = getelementptr inbounds %struct.my_struct, ptr %1444, i32 0, i32 2
  %1446 = getelementptr inbounds %struct.UT_hash_handle, ptr %1445, i32 0, i32 0
  %1447 = load ptr, ptr %1446, align 8, !tbaa !14
  %1448 = getelementptr inbounds %struct.UT_hash_table, ptr %1447, i32 0, i32 3
  %1449 = load i32, ptr %1448, align 8, !tbaa !36
  %1450 = lshr i32 %1449, 1
  %1451 = icmp ugt i32 %1443, %1450
  br i1 %1451, label %1452, label %1460

1452:                                             ; preds = %1411
  %1453 = load ptr, ptr %5, align 8, !tbaa !9
  %1454 = getelementptr inbounds %struct.my_struct, ptr %1453, i32 0, i32 2
  %1455 = getelementptr inbounds %struct.UT_hash_handle, ptr %1454, i32 0, i32 0
  %1456 = load ptr, ptr %1455, align 8, !tbaa !14
  %1457 = getelementptr inbounds %struct.UT_hash_table, ptr %1456, i32 0, i32 8
  %1458 = load i32, ptr %1457, align 8, !tbaa !50
  %1459 = add i32 %1458, 1
  br label %1461

1460:                                             ; preds = %1411
  br label %1461

1461:                                             ; preds = %1460, %1452
  %1462 = phi i32 [ %1459, %1452 ], [ 0, %1460 ]
  %1463 = load ptr, ptr %5, align 8, !tbaa !9
  %1464 = getelementptr inbounds %struct.my_struct, ptr %1463, i32 0, i32 2
  %1465 = getelementptr inbounds %struct.UT_hash_handle, ptr %1464, i32 0, i32 0
  %1466 = load ptr, ptr %1465, align 8, !tbaa !14
  %1467 = getelementptr inbounds %struct.UT_hash_table, ptr %1466, i32 0, i32 8
  store i32 %1462, ptr %1467, align 8, !tbaa !50
  %1468 = load ptr, ptr %5, align 8, !tbaa !9
  %1469 = getelementptr inbounds %struct.my_struct, ptr %1468, i32 0, i32 2
  %1470 = getelementptr inbounds %struct.UT_hash_handle, ptr %1469, i32 0, i32 0
  %1471 = load ptr, ptr %1470, align 8, !tbaa !14
  %1472 = getelementptr inbounds %struct.UT_hash_table, ptr %1471, i32 0, i32 8
  %1473 = load i32, ptr %1472, align 8, !tbaa !50
  %1474 = icmp ugt i32 %1473, 1
  br i1 %1474, label %1475, label %1481

1475:                                             ; preds = %1461
  %1476 = load ptr, ptr %5, align 8, !tbaa !9
  %1477 = getelementptr inbounds %struct.my_struct, ptr %1476, i32 0, i32 2
  %1478 = getelementptr inbounds %struct.UT_hash_handle, ptr %1477, i32 0, i32 0
  %1479 = load ptr, ptr %1478, align 8, !tbaa !14
  %1480 = getelementptr inbounds %struct.UT_hash_table, ptr %1479, i32 0, i32 9
  store i32 1, ptr %1480, align 4, !tbaa !43
  br label %1481

1481:                                             ; preds = %1475, %1461
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #7
  br label %1482

1482:                                             ; preds = %1481
  br label %1483

1483:                                             ; preds = %1482
  br label %1484

1484:                                             ; preds = %1483, %1229, %1191
  br label %1485

1485:                                             ; preds = %1484
  br label %1486

1486:                                             ; preds = %1485
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #7
  br label %1487

1487:                                             ; preds = %1486
  br label %1488

1488:                                             ; preds = %1487
  br label %1489

1489:                                             ; preds = %1488, %482
  %1490 = load i32, ptr %4, align 4, !tbaa !5
  %1491 = trunc i32 %1490 to i16
  %1492 = load ptr, ptr %5, align 8, !tbaa !9
  %1493 = getelementptr inbounds %struct.my_struct, ptr %1492, i32 0, i32 1
  store i16 %1491, ptr %1493, align 4, !tbaa !51
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #7
  ret void
}

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

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

; Function Attrs: nounwind willreturn memory(read)
declare i32 @memcmp(ptr noundef, ptr noundef, i64 noundef) #2

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

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

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

; Function Attrs: nocallback nofree nounwind willreturn memory(argmem: write)
declare void @llvm.memset.p0.i64(ptr nocapture writeonly, i8, i64, i1 immarg) #5

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

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 = { nounwind willreturn memory(read) "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 allocsize(0) "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #5 = { nocallback nofree nounwind willreturn memory(argmem: write) }
attributes #6 = { 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 #7 = { nounwind }
attributes #8 = { nounwind willreturn memory(read) }
attributes #9 = { nounwind allocsize(0) }
attributes #10 = { noreturn nounwind }

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

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


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

@users = external dso_local local_unnamed_addr global ptr, align 8
@.str = external hidden unnamed_addr constant [10 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [126 x i8], align 1
@__PRETTY_FUNCTION__.add_element = external hidden unnamed_addr constant [27 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @add_element(i32 noundef %0, i32 noundef %1) local_unnamed_addr #0 {
  %3 = alloca i32, align 4
  store i32 %0, ptr %3, align 4, !tbaa !5
  %4 = load ptr, ptr @users, align 8, !tbaa !9
  %.not = icmp eq ptr %4, null
  br i1 %.not, label %.loopexit, label %5

5:                                                ; preds = %2
  %6 = and i32 %0, -16777216
  %7 = and i32 %0, 16711680
  %8 = and i32 %0, 65280
  %9 = and i32 %0, 255
  %10 = add i32 %6, 17973517
  %11 = add i32 %10, %7
  %12 = add i32 %11, %8
  %13 = add i32 %12, %9
  %14 = xor i32 %13, 522093
  %15 = sub i32 -1622558010, %14
  %16 = shl i32 %14, 8
  %17 = xor i32 %15, %16
  %18 = add i32 %14, %17
  %19 = sub i32 -17973517, %18
  %20 = lshr i32 %17, 13
  %21 = xor i32 %19, %20
  %22 = add i32 %17, %21
  %23 = sub i32 %14, %22
  %24 = lshr i32 %21, 12
  %25 = xor i32 %23, %24
  %26 = add i32 %21, %25
  %27 = sub i32 %17, %26
  %28 = shl i32 %25, 16
  %29 = xor i32 %27, %28
  %30 = add i32 %25, %29
  %31 = sub i32 %21, %30
  %32 = lshr i32 %29, 5
  %33 = xor i32 %31, %32
  %34 = add i32 %29, %33
  %35 = sub i32 %25, %34
  %36 = lshr i32 %33, 3
  %37 = xor i32 %35, %36
  %38 = add i32 %33, %37
  %39 = sub i32 %29, %38
  %40 = shl i32 %37, 10
  %41 = xor i32 %39, %40
  %42 = add i32 %37, %41
  %43 = sub i32 %33, %42
  %44 = lshr i32 %41, 15
  %45 = xor i32 %43, %44
  %46 = getelementptr inbounds i8, ptr %4, i64 8
  %47 = load ptr, ptr %46, align 8, !tbaa !11
  %48 = getelementptr inbounds i8, ptr %47, i64 8
  %49 = load i32, ptr %48, align 8, !tbaa !15
  %50 = add i32 %49, -1
  %51 = and i32 %45, %50
  %52 = load ptr, ptr %47, align 8, !tbaa !18
  %53 = zext i32 %51 to i64
  %54 = getelementptr inbounds %struct.UT_hash_bucket, ptr %52, i64 %53
  %55 = load ptr, ptr %54, align 8, !tbaa !19
  %.not431 = icmp eq ptr %55, null
  br i1 %.not431, label %.loopexit, label %.lr.ph

.lr.ph:                                           ; preds = %5
  %56 = getelementptr inbounds i8, ptr %47, i64 32
  %57 = load i64, ptr %56, align 8, !tbaa !21
  %58 = sub i64 0, %57
  %59 = getelementptr inbounds i8, ptr %55, i64 %58
  %60 = getelementptr inbounds i8, ptr %47, i64 32
  br label %61

61:                                               ; preds = %72, %.lr.ph
  %.1479 = phi ptr [ %59, %.lr.ph ], [ %75, %72 ]
  %62 = getelementptr inbounds i8, ptr %.1479, i64 56
  %63 = load i32, ptr %62, align 8, !tbaa !22
  %64 = icmp eq i32 %63, 4
  br i1 %64, label %65, label %69

65:                                               ; preds = %61
  %66 = getelementptr inbounds i8, ptr %.1479, i64 48
  %67 = load ptr, ptr %66, align 8, !tbaa !23
  %bcmp = call i32 @bcmp(ptr noundef nonnull dereferenceable(4) %67, ptr noundef nonnull dereferenceable(4) %3, i64 4)
  %68 = icmp eq i32 %bcmp, 0
  br i1 %68, label %.loopexit476, label %69

69:                                               ; preds = %65, %61
  %70 = getelementptr inbounds i8, ptr %.1479, i64 40
  %71 = load ptr, ptr %70, align 8, !tbaa !24
  %.not433 = icmp eq ptr %71, null
  br i1 %.not433, label %.loopexit, label %72

72:                                               ; preds = %69
  %73 = load i64, ptr %60, align 8, !tbaa !21
  %74 = sub i64 0, %73
  %75 = getelementptr inbounds i8, ptr %71, i64 %74
  br label %61, !llvm.loop !25

.loopexit:                                        ; preds = %69, %5, %2
  %76 = tail call noalias dereferenceable_or_null(64) ptr @malloc(i64 noundef 64) #6
  %.not434 = icmp eq ptr %76, null
  br i1 %.not434, label %77, label %78

77:                                               ; preds = %.loopexit
  tail call void @__assert_fail(ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, i32 noundef 43, ptr noundef nonnull @__PRETTY_FUNCTION__.add_element) #7
  unreachable

78:                                               ; preds = %.loopexit
  store i32 %0, ptr %76, align 8, !tbaa !27
  %79 = getelementptr inbounds i8, ptr %76, i64 8
  %80 = getelementptr inbounds i8, ptr %76, i64 24
  store ptr null, ptr %80, align 8, !tbaa !28
  %81 = getelementptr inbounds i8, ptr %76, i64 48
  store ptr %76, ptr %81, align 8, !tbaa !23
  %82 = getelementptr inbounds i8, ptr %76, i64 56
  store i32 4, ptr %82, align 8, !tbaa !22
  br i1 %.not, label %83, label %94

83:                                               ; preds = %78
  store ptr %76, ptr @users, align 8, !tbaa !9
  %84 = getelementptr inbounds i8, ptr %76, i64 16
  store ptr null, ptr %84, align 8, !tbaa !29
  %calloc496 = tail call dereferenceable_or_null(64) ptr @calloc(i64 1, i64 64)
  store ptr %calloc496, ptr %79, align 8, !tbaa !11
  %.not436 = icmp eq ptr %calloc496, null
  br i1 %.not436, label %85, label %86

85:                                               ; preds = %83
  tail call void @exit(i32 noundef -1) #7
  unreachable

86:                                               ; preds = %83
  %87 = getelementptr inbounds i8, ptr %calloc496, i64 24
  store ptr %79, ptr %87, align 8, !tbaa !30
  %88 = getelementptr inbounds i8, ptr %calloc496, i64 8
  store i32 32, ptr %88, align 8, !tbaa !15
  %89 = getelementptr inbounds i8, ptr %calloc496, i64 12
  store i32 5, ptr %89, align 4, !tbaa !31
  %90 = getelementptr inbounds i8, ptr %calloc496, i64 32
  store i64 8, ptr %90, align 8, !tbaa !21
  %calloc495 = tail call dereferenceable_or_null(512) ptr @calloc(i64 1, i64 512)
  store ptr %calloc495, ptr %calloc496, align 8, !tbaa !18
  %.not437 = icmp eq ptr %calloc495, null
  br i1 %.not437, label %91, label %92

91:                                               ; preds = %86
  tail call void @exit(i32 noundef -1) #7
  unreachable

92:                                               ; preds = %86
  %93 = getelementptr inbounds i8, ptr %calloc496, i64 56
  store i32 -1609490463, ptr %93, align 8, !tbaa !32
  br label %105

94:                                               ; preds = %78
  %95 = getelementptr inbounds i8, ptr %4, i64 8
  %96 = load ptr, ptr %95, align 8, !tbaa !11
  %97 = getelementptr inbounds i8, ptr %96, i64 24
  %98 = load ptr, ptr %97, align 8, !tbaa !30
  %99 = getelementptr inbounds i8, ptr %98, i64 16
  store ptr %76, ptr %99, align 8, !tbaa !33
  %100 = getelementptr inbounds i8, ptr %96, i64 32
  %101 = load i64, ptr %100, align 8, !tbaa !21
  %102 = sub i64 0, %101
  %103 = getelementptr inbounds i8, ptr %98, i64 %102
  %104 = getelementptr inbounds i8, ptr %76, i64 16
  store ptr %103, ptr %104, align 8, !tbaa !29
  store ptr %79, ptr %97, align 8, !tbaa !30
  br label %105

105:                                              ; preds = %94, %92
  %106 = phi ptr [ %96, %94 ], [ %calloc496, %92 ]
  %107 = phi ptr [ %4, %94 ], [ %76, %92 ]
  %108 = getelementptr inbounds i8, ptr %107, i64 8
  %109 = getelementptr inbounds i8, ptr %106, i64 16
  %110 = load i32, ptr %109, align 8, !tbaa !34
  %111 = add i32 %110, 1
  store i32 %111, ptr %109, align 8, !tbaa !34
  store ptr %106, ptr %79, align 8, !tbaa !11
  %112 = getelementptr inbounds i8, ptr %76, i64 60
  %113 = getelementptr inbounds i8, ptr %76, i64 3
  %114 = load i8, ptr %113, align 1, !tbaa !35
  %115 = zext i8 %114 to i32
  %116 = shl nuw i32 %115, 24
  %117 = getelementptr inbounds i8, ptr %76, i64 2
  %118 = load i8, ptr %117, align 1, !tbaa !35
  %119 = zext i8 %118 to i32
  %120 = shl nuw nsw i32 %119, 16
  %121 = getelementptr inbounds i8, ptr %76, i64 1
  %122 = load i8, ptr %121, align 1, !tbaa !35
  %123 = zext i8 %122 to i32
  %124 = shl nuw nsw i32 %123, 8
  %125 = load i8, ptr %76, align 1, !tbaa !35
  %126 = zext i8 %125 to i32
  %127 = add i32 %116, 17973517
  %128 = add i32 %127, %120
  %129 = add i32 %128, %124
  %130 = add i32 %129, %126
  %131 = xor i32 %130, 522093
  %132 = sub i32 -1622558010, %131
  %133 = shl i32 %131, 8
  %134 = xor i32 %132, %133
  %135 = add i32 %131, %134
  %136 = sub i32 -17973517, %135
  %137 = lshr i32 %134, 13
  %138 = xor i32 %136, %137
  %139 = add i32 %134, %138
  %140 = sub i32 %131, %139
  %141 = lshr i32 %138, 12
  %142 = xor i32 %140, %141
  %143 = add i32 %138, %142
  %144 = sub i32 %134, %143
  %145 = shl i32 %142, 16
  %146 = xor i32 %144, %145
  %147 = add i32 %142, %146
  %148 = sub i32 %138, %147
  %149 = lshr i32 %146, 5
  %150 = xor i32 %148, %149
  %151 = add i32 %146, %150
  %152 = sub i32 %142, %151
  %153 = lshr i32 %150, 3
  %154 = xor i32 %152, %153
  %155 = add i32 %150, %154
  %156 = sub i32 %146, %155
  %157 = shl i32 %154, 10
  %158 = xor i32 %156, %157
  %159 = add i32 %154, %158
  %160 = sub i32 %150, %159
  %161 = lshr i32 %158, 15
  %162 = xor i32 %160, %161
  store i32 %162, ptr %112, align 4, !tbaa !36
  %163 = load ptr, ptr %108, align 8, !tbaa !11
  %164 = getelementptr inbounds i8, ptr %163, i64 8
  %165 = load i32, ptr %164, align 8, !tbaa !15
  %166 = add i32 %165, -1
  %167 = and i32 %162, %166
  %168 = load ptr, ptr %163, align 8, !tbaa !18
  %169 = zext i32 %167 to i64
  %170 = getelementptr inbounds %struct.UT_hash_bucket, ptr %168, i64 %169, i32 1
  %171 = load i32, ptr %170, align 8, !tbaa !37
  %172 = add i32 %171, 1
  store i32 %172, ptr %170, align 8, !tbaa !37
  %173 = getelementptr inbounds %struct.UT_hash_bucket, ptr %168, i64 %169
  %174 = load ptr, ptr %173, align 8, !tbaa !19
  %175 = getelementptr inbounds i8, ptr %76, i64 40
  store ptr %174, ptr %175, align 8, !tbaa !24
  %176 = getelementptr inbounds i8, ptr %76, i64 32
  store ptr null, ptr %176, align 8, !tbaa !38
  %.not438 = icmp eq ptr %174, null
  br i1 %.not438, label %179, label %177

177:                                              ; preds = %105
  %178 = getelementptr inbounds i8, ptr %174, i64 24
  store ptr %79, ptr %178, align 8, !tbaa !39
  br label %179

179:                                              ; preds = %177, %105
  store ptr %79, ptr %173, align 8, !tbaa !19
  %180 = load ptr, ptr @users, align 8, !tbaa !9
  %181 = getelementptr inbounds i8, ptr %180, i64 8
  %182 = load ptr, ptr %181, align 8, !tbaa !11
  %183 = load ptr, ptr %182, align 8, !tbaa !18
  %184 = getelementptr inbounds %struct.UT_hash_bucket, ptr %183, i64 %169
  %185 = getelementptr inbounds i8, ptr %184, i64 8
  %186 = load i32, ptr %185, align 8, !tbaa !37
  %187 = getelementptr inbounds i8, ptr %184, i64 12
  %188 = load i32, ptr %187, align 4, !tbaa !40
  %189 = mul i32 %188, 10
  %190 = add i32 %189, 10
  %.not439 = icmp ult i32 %186, %190
  br i1 %.not439, label %.loopexit476, label %191

191:                                              ; preds = %179
  %192 = getelementptr inbounds i8, ptr %106, i64 52
  %193 = load i32, ptr %192, align 4, !tbaa !41
  %.not440 = icmp eq i32 %193, 1
  br i1 %.not440, label %.loopexit476, label %194

194:                                              ; preds = %191
  %195 = getelementptr inbounds i8, ptr %106, i64 8
  %196 = load i32, ptr %195, align 8, !tbaa !15
  %197 = zext i32 %196 to i64
  %198 = shl nuw nsw i64 %197, 5
  %calloc = tail call ptr @calloc(i64 1, i64 %198)
  %.not441 = icmp eq ptr %calloc, null
  br i1 %.not441, label %199, label %200

199:                                              ; preds = %194
  tail call void @exit(i32 noundef -1) #7
  unreachable

200:                                              ; preds = %194
  %201 = getelementptr inbounds i8, ptr %106, i64 12
  %202 = load i32, ptr %201, align 4, !tbaa !31
  %203 = add i32 %202, 1
  %204 = lshr i32 %111, %203
  %205 = shl i32 %196, 1
  %206 = add i32 %205, -1
  %207 = and i32 %206, %111
  %.not442 = icmp ne i32 %207, 0
  %208 = zext i1 %.not442 to i32
  %209 = add i32 %204, %208
  %210 = getelementptr inbounds i8, ptr %106, i64 40
  store i32 %209, ptr %210, align 8, !tbaa !42
  %211 = getelementptr inbounds i8, ptr %106, i64 44
  store i32 0, ptr %211, align 4, !tbaa !43
  %.not487 = icmp eq i32 %196, 0
  %.pre = load ptr, ptr %106, align 8, !tbaa !18
  br i1 %.not487, label %._crit_edge486, label %.lr.ph485

.lr.ph485:                                        ; preds = %200, %._crit_edge
  %212 = phi i32 [ %238, %._crit_edge ], [ 0, %200 ]
  %indvars.iv = phi i64 [ %indvars.iv.next, %._crit_edge ], [ 0, %200 ]
  %213 = getelementptr inbounds %struct.UT_hash_bucket, ptr %.pre, i64 %indvars.iv
  %214 = load ptr, ptr %213, align 8, !tbaa !19
  %.not443480 = icmp eq ptr %214, null
  br i1 %.not443480, label %._crit_edge, label %.lr.ph482

.lr.ph482:                                        ; preds = %.lr.ph485, %237
  %215 = phi i32 [ %232, %237 ], [ %212, %.lr.ph485 ]
  %.0393481 = phi ptr [ %217, %237 ], [ %214, %.lr.ph485 ]
  %216 = getelementptr inbounds i8, ptr %.0393481, i64 32
  %217 = load ptr, ptr %216, align 8, !tbaa !44
  %218 = getelementptr inbounds i8, ptr %.0393481, i64 52
  %219 = load i32, ptr %218, align 4, !tbaa !45
  %220 = and i32 %219, %206
  %221 = zext i32 %220 to i64
  %222 = getelementptr inbounds %struct.UT_hash_bucket, ptr %calloc, i64 %221
  %223 = getelementptr inbounds i8, ptr %222, i64 8
  %224 = load i32, ptr %223, align 8, !tbaa !37
  %225 = add i32 %224, 1
  store i32 %225, ptr %223, align 8, !tbaa !37
  %226 = icmp ugt i32 %225, %209
  br i1 %226, label %227, label %231

227:                                              ; preds = %.lr.ph482
  %228 = add i32 %215, 1
  store i32 %228, ptr %211, align 4, !tbaa !43
  %229 = udiv i32 %225, %209
  %230 = getelementptr inbounds i8, ptr %222, i64 12
  store i32 %229, ptr %230, align 4, !tbaa !40
  br label %231

231:                                              ; preds = %227, %.lr.ph482
  %232 = phi i32 [ %228, %227 ], [ %215, %.lr.ph482 ]
  %233 = getelementptr inbounds i8, ptr %.0393481, i64 24
  store ptr null, ptr %233, align 8, !tbaa !39
  %234 = load ptr, ptr %222, align 8, !tbaa !19
  store ptr %234, ptr %216, align 8, !tbaa !44
  %.not444 = icmp eq ptr %234, null
  br i1 %.not444, label %237, label %235

235:                                              ; preds = %231
  %236 = getelementptr inbounds i8, ptr %234, i64 24
  store ptr %.0393481, ptr %236, align 8, !tbaa !39
  br label %237

237:                                              ; preds = %235, %231
  store ptr %.0393481, ptr %222, align 8, !tbaa !19
  %.not443 = icmp eq ptr %217, null
  br i1 %.not443, label %._crit_edge, label %.lr.ph482, !llvm.loop !46

._crit_edge:                                      ; preds = %237, %.lr.ph485
  %238 = phi i32 [ %212, %.lr.ph485 ], [ %232, %237 ]
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %197
  br i1 %exitcond.not, label %._crit_edge486, label %.lr.ph485, !llvm.loop !47

._crit_edge486:                                   ; preds = %._crit_edge, %200
  tail call void @free(ptr noundef %.pre) #8
  %239 = load ptr, ptr %79, align 8, !tbaa !11
  %240 = getelementptr inbounds i8, ptr %239, i64 8
  %241 = load i32, ptr %240, align 8, !tbaa !15
  %242 = shl i32 %241, 1
  store i32 %242, ptr %240, align 8, !tbaa !15
  %243 = getelementptr inbounds i8, ptr %239, i64 12
  %244 = load i32, ptr %243, align 4, !tbaa !31
  %245 = add i32 %244, 1
  store i32 %245, ptr %243, align 4, !tbaa !31
  store ptr %calloc, ptr %239, align 8, !tbaa !18
  %246 = getelementptr inbounds i8, ptr %239, i64 44
  %247 = load i32, ptr %246, align 4, !tbaa !43
  %248 = getelementptr inbounds i8, ptr %239, i64 16
  %249 = load i32, ptr %248, align 8, !tbaa !34
  %250 = lshr i32 %249, 1
  %251 = icmp ugt i32 %247, %250
  %252 = getelementptr inbounds i8, ptr %239, i64 48
  br i1 %251, label %253, label %.thread446

.thread446:                                       ; preds = %._crit_edge486
  store i32 0, ptr %252, align 8, !tbaa !48
  br label %.loopexit476

253:                                              ; preds = %._crit_edge486
  %254 = load i32, ptr %252, align 8, !tbaa !48
  %255 = add i32 %254, 1
  store i32 %255, ptr %252, align 8, !tbaa !48
  %256 = icmp ugt i32 %255, 1
  br i1 %256, label %257, label %.loopexit476

257:                                              ; preds = %253
  %258 = getelementptr inbounds i8, ptr %239, i64 52
  store i32 1, ptr %258, align 4, !tbaa !41
  br label %.loopexit476

.loopexit476:                                     ; preds = %65, %.thread446, %179, %191, %257, %253
  %.4 = phi ptr [ %76, %253 ], [ %76, %257 ], [ %76, %191 ], [ %76, %179 ], [ %76, %.thread446 ], [ %.1479, %65 ]
  %259 = trunc i32 %1 to i16
  %260 = getelementptr inbounds i8, ptr %.4, i64 4
  store i16 %259, ptr %260, align 4, !tbaa !49
  ret void
}

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

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

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

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

; Function Attrs: nofree nounwind willreturn memory(argmem: read)
declare i32 @bcmp(ptr nocapture, ptr nocapture, i64) local_unnamed_addr #4

; Function Attrs: nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite)
declare noalias noundef ptr @calloc(i64 noundef, i64 noundef) local_unnamed_addr #5

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 nofree nounwind willreturn allockind("alloc,uninitialized") allocsize(0) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { 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 = { nofree nounwind willreturn memory(argmem: read) }
attributes #5 = { nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" }
attributes #6 = { nounwind allocsize(0) }
attributes #7 = { noreturn nounwind }
attributes #8 = { 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 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"any pointer", !7, i64 0}
!11 = !{!12, !10, i64 8}
!12 = !{!"my_struct", !6, i64 0, !13, i64 4, !14, i64 8}
!13 = !{!"short", !7, i64 0}
!14 = !{!"UT_hash_handle", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !6, i64 48, !6, i64 52}
!15 = !{!16, !6, i64 8}
!16 = !{!"UT_hash_table", !10, i64 0, !6, i64 8, !6, i64 12, !6, i64 16, !10, i64 24, !17, i64 32, !6, i64 40, !6, i64 44, !6, i64 48, !6, i64 52, !6, i64 56}
!17 = !{!"long", !7, i64 0}
!18 = !{!16, !10, i64 0}
!19 = !{!20, !10, i64 0}
!20 = !{!"UT_hash_bucket", !10, i64 0, !6, i64 8, !6, i64 12}
!21 = !{!16, !17, i64 32}
!22 = !{!12, !6, i64 56}
!23 = !{!12, !10, i64 48}
!24 = !{!12, !10, i64 40}
!25 = distinct !{!25, !26}
!26 = !{!"llvm.loop.mustprogress"}
!27 = !{!12, !6, i64 0}
!28 = !{!12, !10, i64 24}
!29 = !{!12, !10, i64 16}
!30 = !{!16, !10, i64 24}
!31 = !{!16, !6, i64 12}
!32 = !{!16, !6, i64 56}
!33 = !{!14, !10, i64 16}
!34 = !{!16, !6, i64 16}
!35 = !{!7, !7, i64 0}
!36 = !{!12, !6, i64 60}
!37 = !{!20, !6, i64 8}
!38 = !{!12, !10, i64 32}
!39 = !{!14, !10, i64 24}
!40 = !{!20, !6, i64 12}
!41 = !{!16, !6, i64 52}
!42 = !{!16, !6, i64 40}
!43 = !{!16, !6, i64 44}
!44 = !{!14, !10, i64 32}
!45 = !{!14, !6, i64 52}
!46 = distinct !{!46, !26}
!47 = distinct !{!47, !26}
!48 = !{!16, !6, i64 48}
!49 = !{!12, !13, i64 4}


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