; LLVM IR from alexzheng42/sDMD :: src (Events)

; 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.AtomListStr = type { i32, [27 x i32], [27 x i32], [27 x i32], double, ptr, ptr, ptr }
%struct.AtomStr = type { ptr, ptr }
%struct.DynamicStr = type { [4 x i32], [4 x double], [4 x double], %struct.HBStr, %struct.HBNeighborStr, %struct.InteractionEventStr }
%struct.HBStr = type { i32, i32, i8, i32 }
%struct.HBNeighborStr = type { [5 x i32], i32, i32 }
%struct.InteractionEventStr = type { i32, i64, i64, double, double, i32, i32 }
%struct.PropertyStr = type { [8 x i8], [2 x [16 x i8]], [8 x i8], i32, i32, i32, double, double, [3 x double], %struct.AtomSeqStr, ptr, ptr }
%struct.AtomSeqStr = type { i32, i32, i32 }

@.str.2 = external hidden unnamed_addr constant [5 x i8], align 1
@atomnum = external global i32, align 4
@cellnum = external global [4 x i32], align 16
@celllist = external global ptr, align 8
@cellsize = external global [4 x double], align 16
@.str.3 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [34 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [28 x i8], align 1

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

declare i32 @printf(ptr noundef, ...) #1

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

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

19:                                               ; preds = %4
  %20 = load ptr, ptr %6, align 8, !tbaa !5
  %21 = icmp eq ptr %20, null
  br label %22

22:                                               ; preds = %19, %4
  %23 = phi i1 [ false, %4 ], [ %21, %19 ]
  %24 = xor i1 %23, true
  %25 = xor i1 %24, true
  %26 = zext i1 %25 to i32
  %27 = sext i32 %26 to i64
  %28 = call i64 @llvm.expect.i64(i64 %27, i64 0)
  %29 = icmp ne i64 %28, 0
  br i1 %29, label %30, label %190

30:                                               ; preds = %22
  %31 = load i32, ptr @atomnum, align 4, !tbaa !9
  %32 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 1), align 4, !tbaa !9
  %33 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 2), align 8, !tbaa !9
  %34 = mul nsw i32 %32, %33
  %35 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 3), align 4, !tbaa !9
  %36 = mul nsw i32 %34, %35
  %37 = add nsw i32 %31, %36
  %38 = add nsw i32 %37, 1
  %39 = sext i32 %38 to i64
  %40 = call noalias ptr @calloc(i64 noundef %39, i64 noundef 4) #8
  store ptr %40, ptr @celllist, align 8, !tbaa !5
  store i32 1, ptr %9, align 4, !tbaa !9
  br label %41

41:                                               ; preds = %186, %30
  %42 = load i32, ptr %9, align 4, !tbaa !9
  %43 = load i32, ptr @atomnum, align 4, !tbaa !9
  %44 = icmp sle i32 %42, %43
  br i1 %44, label %45, label %189

45:                                               ; preds = %41
  store i32 1, ptr %10, align 4, !tbaa !9
  br label %46

46:                                               ; preds = %119, %45
  %47 = load i32, ptr %10, align 4, !tbaa !9
  %48 = icmp sle i32 %47, 3
  br i1 %48, label %49, label %122

49:                                               ; preds = %46
  %50 = load ptr, ptr %8, align 8, !tbaa !5
  %51 = getelementptr inbounds %struct.AtomListStr, ptr %50, i32 0, i32 7
  %52 = load ptr, ptr %51, align 8, !tbaa !11
  %53 = load i32, ptr %9, align 4, !tbaa !9
  %54 = sext i32 %53 to i64
  %55 = getelementptr inbounds ptr, ptr %52, i64 %54
  %56 = load ptr, ptr %55, align 8, !tbaa !5
  %57 = getelementptr inbounds %struct.AtomStr, ptr %56, i32 0, i32 1
  %58 = load ptr, ptr %57, align 8, !tbaa !14
  %59 = getelementptr inbounds %struct.DynamicStr, ptr %58, i32 0, i32 1
  %60 = load i32, ptr %10, align 4, !tbaa !9
  %61 = sext i32 %60 to i64
  %62 = getelementptr inbounds [4 x double], ptr %59, i64 0, i64 %61
  %63 = load double, ptr %62, align 8, !tbaa !16
  %64 = load i32, ptr %10, align 4, !tbaa !9
  %65 = sext i32 %64 to i64
  %66 = getelementptr inbounds [4 x double], ptr @cellsize, i64 0, i64 %65
  %67 = load double, ptr %66, align 8, !tbaa !16
  %68 = fdiv double %63, %67
  %69 = fptosi double %68 to i32
  %70 = load ptr, ptr %8, align 8, !tbaa !5
  %71 = getelementptr inbounds %struct.AtomListStr, ptr %70, i32 0, i32 7
  %72 = load ptr, ptr %71, align 8, !tbaa !11
  %73 = load i32, ptr %9, align 4, !tbaa !9
  %74 = sext i32 %73 to i64
  %75 = getelementptr inbounds ptr, ptr %72, i64 %74
  %76 = load ptr, ptr %75, align 8, !tbaa !5
  %77 = getelementptr inbounds %struct.AtomStr, ptr %76, i32 0, i32 1
  %78 = load ptr, ptr %77, align 8, !tbaa !14
  %79 = getelementptr inbounds %struct.DynamicStr, ptr %78, i32 0, i32 0
  %80 = load i32, ptr %10, align 4, !tbaa !9
  %81 = sext i32 %80 to i64
  %82 = getelementptr inbounds [4 x i32], ptr %79, i64 0, i64 %81
  store i32 %69, ptr %82, align 4, !tbaa !9
  %83 = load ptr, ptr %8, align 8, !tbaa !5
  %84 = getelementptr inbounds %struct.AtomListStr, ptr %83, i32 0, i32 7
  %85 = load ptr, ptr %84, align 8, !tbaa !11
  %86 = load i32, ptr %9, align 4, !tbaa !9
  %87 = sext i32 %86 to i64
  %88 = getelementptr inbounds ptr, ptr %85, i64 %87
  %89 = load ptr, ptr %88, align 8, !tbaa !5
  %90 = getelementptr inbounds %struct.AtomStr, ptr %89, i32 0, i32 1
  %91 = load ptr, ptr %90, align 8, !tbaa !14
  %92 = getelementptr inbounds %struct.DynamicStr, ptr %91, i32 0, i32 0
  %93 = load i32, ptr %10, align 4, !tbaa !9
  %94 = sext i32 %93 to i64
  %95 = getelementptr inbounds [4 x i32], ptr %92, i64 0, i64 %94
  %96 = load i32, ptr %95, align 4, !tbaa !9
  %97 = load i32, ptr %10, align 4, !tbaa !9
  %98 = sext i32 %97 to i64
  %99 = getelementptr inbounds [4 x i32], ptr @cellnum, i64 0, i64 %98
  %100 = load i32, ptr %99, align 4, !tbaa !9
  %101 = icmp eq i32 %96, %100
  br i1 %101, label %102, label %118

102:                                              ; preds = %49
  %103 = load ptr, ptr %8, align 8, !tbaa !5
  %104 = getelementptr inbounds %struct.AtomListStr, ptr %103, i32 0, i32 7
  %105 = load ptr, ptr %104, align 8, !tbaa !11
  %106 = load i32, ptr %9, align 4, !tbaa !9
  %107 = sext i32 %106 to i64
  %108 = getelementptr inbounds ptr, ptr %105, i64 %107
  %109 = load ptr, ptr %108, align 8, !tbaa !5
  %110 = getelementptr inbounds %struct.AtomStr, ptr %109, i32 0, i32 1
  %111 = load ptr, ptr %110, align 8, !tbaa !14
  %112 = getelementptr inbounds %struct.DynamicStr, ptr %111, i32 0, i32 0
  %113 = load i32, ptr %10, align 4, !tbaa !9
  %114 = sext i32 %113 to i64
  %115 = getelementptr inbounds [4 x i32], ptr %112, i64 0, i64 %114
  %116 = load i32, ptr %115, align 4, !tbaa !9
  %117 = add nsw i32 %116, -1
  store i32 %117, ptr %115, align 4, !tbaa !9
  br label %118

118:                                              ; preds = %102, %49
  br label %119

119:                                              ; preds = %118
  %120 = load i32, ptr %10, align 4, !tbaa !9
  %121 = add nsw i32 %120, 1
  store i32 %121, ptr %10, align 4, !tbaa !9
  br label %46, !llvm.loop !17

122:                                              ; preds = %46
  %123 = load ptr, ptr %8, align 8, !tbaa !5
  %124 = getelementptr inbounds %struct.AtomListStr, ptr %123, i32 0, i32 7
  %125 = load ptr, ptr %124, align 8, !tbaa !11
  %126 = load i32, ptr %9, align 4, !tbaa !9
  %127 = sext i32 %126 to i64
  %128 = getelementptr inbounds ptr, ptr %125, i64 %127
  %129 = load ptr, ptr %128, align 8, !tbaa !5
  %130 = getelementptr inbounds %struct.AtomStr, ptr %129, i32 0, i32 1
  %131 = load ptr, ptr %130, align 8, !tbaa !14
  %132 = getelementptr inbounds %struct.DynamicStr, ptr %131, i32 0, i32 0
  %133 = getelementptr inbounds [4 x i32], ptr %132, i64 0, i64 3
  %134 = load i32, ptr %133, align 4, !tbaa !9
  %135 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 1), align 4, !tbaa !9
  %136 = mul nsw i32 %134, %135
  %137 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 2), align 8, !tbaa !9
  %138 = mul nsw i32 %136, %137
  %139 = load ptr, ptr %8, align 8, !tbaa !5
  %140 = getelementptr inbounds %struct.AtomListStr, ptr %139, i32 0, i32 7
  %141 = load ptr, ptr %140, align 8, !tbaa !11
  %142 = load i32, ptr %9, align 4, !tbaa !9
  %143 = sext i32 %142 to i64
  %144 = getelementptr inbounds ptr, ptr %141, i64 %143
  %145 = load ptr, ptr %144, align 8, !tbaa !5
  %146 = getelementptr inbounds %struct.AtomStr, ptr %145, i32 0, i32 1
  %147 = load ptr, ptr %146, align 8, !tbaa !14
  %148 = getelementptr inbounds %struct.DynamicStr, ptr %147, i32 0, i32 0
  %149 = getelementptr inbounds [4 x i32], ptr %148, i64 0, i64 2
  %150 = load i32, ptr %149, align 8, !tbaa !9
  %151 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 1), align 4, !tbaa !9
  %152 = mul nsw i32 %150, %151
  %153 = add nsw i32 %138, %152
  %154 = load ptr, ptr %8, align 8, !tbaa !5
  %155 = getelementptr inbounds %struct.AtomListStr, ptr %154, i32 0, i32 7
  %156 = load ptr, ptr %155, align 8, !tbaa !11
  %157 = load i32, ptr %9, align 4, !tbaa !9
  %158 = sext i32 %157 to i64
  %159 = getelementptr inbounds ptr, ptr %156, i64 %158
  %160 = load ptr, ptr %159, align 8, !tbaa !5
  %161 = getelementptr inbounds %struct.AtomStr, ptr %160, i32 0, i32 1
  %162 = load ptr, ptr %161, align 8, !tbaa !14
  %163 = getelementptr inbounds %struct.DynamicStr, ptr %162, i32 0, i32 0
  %164 = getelementptr inbounds [4 x i32], ptr %163, i64 0, i64 1
  %165 = load i32, ptr %164, align 4, !tbaa !9
  %166 = add nsw i32 %153, %165
  %167 = add nsw i32 %166, 1
  store i32 %167, ptr %11, align 4, !tbaa !9
  %168 = load ptr, ptr @celllist, align 8, !tbaa !5
  %169 = load i32, ptr @atomnum, align 4, !tbaa !9
  %170 = load i32, ptr %11, align 4, !tbaa !9
  %171 = add nsw i32 %169, %170
  %172 = sext i32 %171 to i64
  %173 = getelementptr inbounds i32, ptr %168, i64 %172
  %174 = load i32, ptr %173, align 4, !tbaa !9
  %175 = load ptr, ptr @celllist, align 8, !tbaa !5
  %176 = load i32, ptr %9, align 4, !tbaa !9
  %177 = sext i32 %176 to i64
  %178 = getelementptr inbounds i32, ptr %175, i64 %177
  store i32 %174, ptr %178, align 4, !tbaa !9
  %179 = load i32, ptr %9, align 4, !tbaa !9
  %180 = load ptr, ptr @celllist, align 8, !tbaa !5
  %181 = load i32, ptr @atomnum, align 4, !tbaa !9
  %182 = load i32, ptr %11, align 4, !tbaa !9
  %183 = add nsw i32 %181, %182
  %184 = sext i32 %183 to i64
  %185 = getelementptr inbounds i32, ptr %180, i64 %184
  store i32 %179, ptr %185, align 4, !tbaa !9
  br label %186

186:                                              ; preds = %122
  %187 = load i32, ptr %9, align 4, !tbaa !9
  %188 = add nsw i32 %187, 1
  store i32 %188, ptr %9, align 4, !tbaa !9
  br label %41, !llvm.loop !19

189:                                              ; preds = %41
  br label %400

190:                                              ; preds = %22
  %191 = load ptr, ptr %5, align 8, !tbaa !5
  %192 = call i32 @strncmp(ptr noundef %191, ptr noundef @.str.3, i64 noundef 1) #7
  %193 = icmp eq i32 %192, 0
  br i1 %193, label %194, label %197

194:                                              ; preds = %190
  %195 = load ptr, ptr %6, align 8, !tbaa !5
  %196 = icmp ne ptr %195, null
  br label %197

197:                                              ; preds = %194, %190
  %198 = phi i1 [ false, %190 ], [ %196, %194 ]
  %199 = xor i1 %198, true
  %200 = xor i1 %199, true
  %201 = zext i1 %200 to i32
  %202 = sext i32 %201 to i64
  %203 = call i64 @llvm.expect.i64(i64 %202, i64 1)
  %204 = icmp ne i64 %203, 0
  br i1 %204, label %205, label %397

205:                                              ; preds = %197
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #6
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #6
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #6
  %206 = load ptr, ptr @celllist, align 8, !tbaa !5
  store ptr %206, ptr %15, align 8, !tbaa !5
  %207 = load ptr, ptr %7, align 8, !tbaa !5
  %208 = getelementptr inbounds i32, ptr %207, i64 3
  %209 = load i32, ptr %208, align 4, !tbaa !9
  %210 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 1), align 4, !tbaa !9
  %211 = mul nsw i32 %209, %210
  %212 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 2), align 8, !tbaa !9
  %213 = mul nsw i32 %211, %212
  %214 = load ptr, ptr %7, align 8, !tbaa !5
  %215 = getelementptr inbounds i32, ptr %214, i64 2
  %216 = load i32, ptr %215, align 4, !tbaa !9
  %217 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 1), align 4, !tbaa !9
  %218 = mul nsw i32 %216, %217
  %219 = add nsw i32 %213, %218
  %220 = load ptr, ptr %7, align 8, !tbaa !5
  %221 = getelementptr inbounds i32, ptr %220, i64 1
  %222 = load i32, ptr %221, align 4, !tbaa !9
  %223 = add nsw i32 %219, %222
  %224 = add nsw i32 %223, 1
  store i32 %224, ptr %13, align 4, !tbaa !9
  store i32 1, ptr %10, align 4, !tbaa !9
  br label %225

225:                                              ; preds = %280, %205
  %226 = load i32, ptr %10, align 4, !tbaa !9
  %227 = icmp sle i32 %226, 3
  br i1 %227, label %228, label %283

228:                                              ; preds = %225
  %229 = load ptr, ptr %6, align 8, !tbaa !5
  %230 = getelementptr inbounds %struct.AtomStr, ptr %229, i32 0, i32 1
  %231 = load ptr, ptr %230, align 8, !tbaa !14
  %232 = getelementptr inbounds %struct.DynamicStr, ptr %231, i32 0, i32 1
  %233 = load i32, ptr %10, align 4, !tbaa !9
  %234 = sext i32 %233 to i64
  %235 = getelementptr inbounds [4 x double], ptr %232, i64 0, i64 %234
  %236 = load double, ptr %235, align 8, !tbaa !16
  %237 = load i32, ptr %10, align 4, !tbaa !9
  %238 = sext i32 %237 to i64
  %239 = getelementptr inbounds [4 x double], ptr @cellsize, i64 0, i64 %238
  %240 = load double, ptr %239, align 8, !tbaa !16
  %241 = fdiv double %236, %240
  %242 = fptosi double %241 to i32
  %243 = load ptr, ptr %6, align 8, !tbaa !5
  %244 = getelementptr inbounds %struct.AtomStr, ptr %243, i32 0, i32 1
  %245 = load ptr, ptr %244, align 8, !tbaa !14
  %246 = getelementptr inbounds %struct.DynamicStr, ptr %245, i32 0, i32 0
  %247 = load i32, ptr %10, align 4, !tbaa !9
  %248 = sext i32 %247 to i64
  %249 = getelementptr inbounds [4 x i32], ptr %246, i64 0, i64 %248
  store i32 %242, ptr %249, align 4, !tbaa !9
  %250 = load ptr, ptr %6, align 8, !tbaa !5
  %251 = getelementptr inbounds %struct.AtomStr, ptr %250, i32 0, i32 1
  %252 = load ptr, ptr %251, align 8, !tbaa !14
  %253 = getelementptr inbounds %struct.DynamicStr, ptr %252, i32 0, i32 0
  %254 = load i32, ptr %10, align 4, !tbaa !9
  %255 = sext i32 %254 to i64
  %256 = getelementptr inbounds [4 x i32], ptr %253, i64 0, i64 %255
  %257 = load i32, ptr %256, align 4, !tbaa !9
  %258 = load i32, ptr %10, align 4, !tbaa !9
  %259 = sext i32 %258 to i64
  %260 = getelementptr inbounds [4 x i32], ptr @cellnum, i64 0, i64 %259
  %261 = load i32, ptr %260, align 4, !tbaa !9
  %262 = icmp eq i32 %257, %261
  %263 = xor i1 %262, true
  %264 = xor i1 %263, true
  %265 = zext i1 %264 to i32
  %266 = sext i32 %265 to i64
  %267 = call i64 @llvm.expect.i64(i64 %266, i64 0)
  %268 = icmp ne i64 %267, 0
  br i1 %268, label %269, label %279

269:                                              ; preds = %228
  %270 = load ptr, ptr %6, align 8, !tbaa !5
  %271 = getelementptr inbounds %struct.AtomStr, ptr %270, i32 0, i32 1
  %272 = load ptr, ptr %271, align 8, !tbaa !14
  %273 = getelementptr inbounds %struct.DynamicStr, ptr %272, i32 0, i32 0
  %274 = load i32, ptr %10, align 4, !tbaa !9
  %275 = sext i32 %274 to i64
  %276 = getelementptr inbounds [4 x i32], ptr %273, i64 0, i64 %275
  %277 = load i32, ptr %276, align 4, !tbaa !9
  %278 = add nsw i32 %277, -1
  store i32 %278, ptr %276, align 4, !tbaa !9
  br label %279

279:                                              ; preds = %269, %228
  br label %280

280:                                              ; preds = %279
  %281 = load i32, ptr %10, align 4, !tbaa !9
  %282 = add nsw i32 %281, 1
  store i32 %282, ptr %10, align 4, !tbaa !9
  br label %225, !llvm.loop !20

283:                                              ; preds = %225
  %284 = load ptr, ptr %6, align 8, !tbaa !5
  %285 = getelementptr inbounds %struct.AtomStr, ptr %284, i32 0, i32 1
  %286 = load ptr, ptr %285, align 8, !tbaa !14
  %287 = getelementptr inbounds %struct.DynamicStr, ptr %286, i32 0, i32 0
  %288 = getelementptr inbounds [4 x i32], ptr %287, i64 0, i64 3
  %289 = load i32, ptr %288, align 4, !tbaa !9
  %290 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 1), align 4, !tbaa !9
  %291 = mul nsw i32 %289, %290
  %292 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 2), align 8, !tbaa !9
  %293 = mul nsw i32 %291, %292
  %294 = load ptr, ptr %6, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct.AtomStr, ptr %294, i32 0, i32 1
  %296 = load ptr, ptr %295, align 8, !tbaa !14
  %297 = getelementptr inbounds %struct.DynamicStr, ptr %296, i32 0, i32 0
  %298 = getelementptr inbounds [4 x i32], ptr %297, i64 0, i64 2
  %299 = load i32, ptr %298, align 8, !tbaa !9
  %300 = load i32, ptr getelementptr inbounds ([4 x i32], ptr @cellnum, i64 0, i64 1), align 4, !tbaa !9
  %301 = mul nsw i32 %299, %300
  %302 = add nsw i32 %293, %301
  %303 = load ptr, ptr %6, align 8, !tbaa !5
  %304 = getelementptr inbounds %struct.AtomStr, ptr %303, i32 0, i32 1
  %305 = load ptr, ptr %304, align 8, !tbaa !14
  %306 = getelementptr inbounds %struct.DynamicStr, ptr %305, i32 0, i32 0
  %307 = getelementptr inbounds [4 x i32], ptr %306, i64 0, i64 1
  %308 = load i32, ptr %307, align 4, !tbaa !9
  %309 = add nsw i32 %302, %308
  %310 = add nsw i32 %309, 1
  store i32 %310, ptr %12, align 4, !tbaa !9
  %311 = load i32, ptr %13, align 4, !tbaa !9
  %312 = load i32, ptr @atomnum, align 4, !tbaa !9
  %313 = add nsw i32 %311, %312
  store i32 %313, ptr %14, align 4, !tbaa !9
  %314 = load ptr, ptr %15, align 8, !tbaa !5
  %315 = load i32, ptr %14, align 4, !tbaa !9
  %316 = sext i32 %315 to i64
  %317 = getelementptr inbounds i32, ptr %314, i64 %316
  %318 = load i32, ptr %317, align 4, !tbaa !9
  %319 = icmp eq i32 %318, 0
  %320 = xor i1 %319, true
  %321 = xor i1 %320, true
  %322 = zext i1 %321 to i32
  %323 = sext i32 %322 to i64
  %324 = call i64 @llvm.expect.i64(i64 %323, i64 0)
  %325 = icmp ne i64 %324, 0
  br i1 %325, label %326, label %328

326:                                              ; preds = %283
  %327 = call i32 (ptr, ...) @printf(ptr noundef @.str.4)
  br label %328

328:                                              ; preds = %326, %283
  br label %329

329:                                              ; preds = %357, %328
  %330 = load ptr, ptr %15, align 8, !tbaa !5
  %331 = load i32, ptr %14, align 4, !tbaa !9
  %332 = sext i32 %331 to i64
  %333 = getelementptr inbounds i32, ptr %330, i64 %332
  %334 = load i32, ptr %333, align 4, !tbaa !9
  %335 = load ptr, ptr %6, align 8, !tbaa !5
  %336 = getelementptr inbounds %struct.AtomStr, ptr %335, i32 0, i32 0
  %337 = load ptr, ptr %336, align 8, !tbaa !21
  %338 = getelementptr inbounds %struct.PropertyStr, ptr %337, i32 0, i32 3
  %339 = load i32, ptr %338, align 8, !tbaa !22
  %340 = icmp ne i32 %334, %339
  br i1 %340, label %341, label %358

341:                                              ; preds = %329
  %342 = load ptr, ptr %15, align 8, !tbaa !5
  %343 = load i32, ptr %14, align 4, !tbaa !9
  %344 = sext i32 %343 to i64
  %345 = getelementptr inbounds i32, ptr %342, i64 %344
  %346 = load i32, ptr %345, align 4, !tbaa !9
  store i32 %346, ptr %14, align 4, !tbaa !9
  %347 = load i32, ptr %14, align 4, !tbaa !9
  %348 = icmp eq i32 %347, 0
  %349 = xor i1 %348, true
  %350 = xor i1 %349, true
  %351 = zext i1 %350 to i32
  %352 = sext i32 %351 to i64
  %353 = call i64 @llvm.expect.i64(i64 %352, i64 0)
  %354 = icmp ne i64 %353, 0
  br i1 %354, label %355, label %357

355:                                              ; preds = %341
  %356 = call i32 (ptr, ...) @printf(ptr noundef @.str.4)
  br label %357

357:                                              ; preds = %355, %341
  br label %329, !llvm.loop !25

358:                                              ; preds = %329
  %359 = load ptr, ptr %15, align 8, !tbaa !5
  %360 = load ptr, ptr %6, align 8, !tbaa !5
  %361 = getelementptr inbounds %struct.AtomStr, ptr %360, i32 0, i32 0
  %362 = load ptr, ptr %361, align 8, !tbaa !21
  %363 = getelementptr inbounds %struct.PropertyStr, ptr %362, i32 0, i32 3
  %364 = load i32, ptr %363, align 8, !tbaa !22
  %365 = sext i32 %364 to i64
  %366 = getelementptr inbounds i32, ptr %359, i64 %365
  %367 = load i32, ptr %366, align 4, !tbaa !9
  %368 = load ptr, ptr %15, align 8, !tbaa !5
  %369 = load i32, ptr %14, align 4, !tbaa !9
  %370 = sext i32 %369 to i64
  %371 = getelementptr inbounds i32, ptr %368, i64 %370
  store i32 %367, ptr %371, align 4, !tbaa !9
  %372 = load i32, ptr %12, align 4, !tbaa !9
  %373 = load i32, ptr @atomnum, align 4, !tbaa !9
  %374 = add nsw i32 %372, %373
  store i32 %374, ptr %14, align 4, !tbaa !9
  %375 = load ptr, ptr %15, align 8, !tbaa !5
  %376 = load i32, ptr %14, align 4, !tbaa !9
  %377 = sext i32 %376 to i64
  %378 = getelementptr inbounds i32, ptr %375, i64 %377
  %379 = load i32, ptr %378, align 4, !tbaa !9
  %380 = load ptr, ptr %15, align 8, !tbaa !5
  %381 = load ptr, ptr %6, align 8, !tbaa !5
  %382 = getelementptr inbounds %struct.AtomStr, ptr %381, i32 0, i32 0
  %383 = load ptr, ptr %382, align 8, !tbaa !21
  %384 = getelementptr inbounds %struct.PropertyStr, ptr %383, i32 0, i32 3
  %385 = load i32, ptr %384, align 8, !tbaa !22
  %386 = sext i32 %385 to i64
  %387 = getelementptr inbounds i32, ptr %380, i64 %386
  store i32 %379, ptr %387, align 4, !tbaa !9
  %388 = load ptr, ptr %6, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.AtomStr, ptr %388, i32 0, i32 0
  %390 = load ptr, ptr %389, align 8, !tbaa !21
  %391 = getelementptr inbounds %struct.PropertyStr, ptr %390, i32 0, i32 3
  %392 = load i32, ptr %391, align 8, !tbaa !22
  %393 = load ptr, ptr %15, align 8, !tbaa !5
  %394 = load i32, ptr %14, align 4, !tbaa !9
  %395 = sext i32 %394 to i64
  %396 = getelementptr inbounds i32, ptr %393, i64 %395
  store i32 %392, ptr %396, align 4, !tbaa !9
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #6
  br label %399

397:                                              ; preds = %197
  %398 = call i32 (ptr, ...) @printf(ptr noundef @.str.5)
  br label %399

399:                                              ; preds = %397, %358
  br label %400

400:                                              ; preds = %399, %189
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %10) #6
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #6
  ret void
}

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

; Function Attrs: nocallback nofree nosync nounwind willreturn memory(none)
declare i64 @llvm.expect.i64(i64, i64) #4

; Function Attrs: nounwind allocsize(0,1)
declare noalias ptr @calloc(i64 noundef, i64 noundef) #5

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"int", !7, i64 0}
!11 = !{!12, !6, i64 352}
!12 = !{!"AtomListStr", !10, i64 0, !7, i64 4, !7, i64 112, !7, i64 220, !13, i64 328, !6, i64 336, !6, i64 344, !6, i64 352}
!13 = !{!"double", !7, i64 0}
!14 = !{!15, !6, i64 8}
!15 = !{!"AtomStr", !6, i64 0, !6, i64 8}
!16 = !{!13, !13, i64 0}
!17 = distinct !{!17, !18}
!18 = !{!"llvm.loop.mustprogress"}
!19 = distinct !{!19, !18}
!20 = distinct !{!20, !18}
!21 = !{!15, !6, i64 0}
!22 = !{!23, !10, i64 48}
!23 = !{!"PropertyStr", !7, i64 0, !7, i64 8, !7, i64 40, !10, i64 48, !10, i64 52, !10, i64 56, !13, i64 64, !13, i64 72, !7, i64 80, !24, i64 104, !6, i64 120, !6, i64 128}
!24 = !{!"AtomSeqStr", !10, i64 0, !10, i64 4, !10, i64 8}
!25 = distinct !{!25, !18}


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

@.str.2 = external hidden unnamed_addr constant [5 x i8], align 1
@atomnum = external local_unnamed_addr global i32, align 4
@cellnum = external local_unnamed_addr global [4 x i32], align 16
@celllist = external local_unnamed_addr global ptr, align 8
@cellsize = external local_unnamed_addr global [4 x double], align 16
@.str.3 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [34 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [28 x i8], align 1

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

; Function Attrs: nofree nounwind uwtable
define dso_local void @LinkList(ptr nocapture noundef readonly %0, ptr noundef readonly %1, ptr nocapture noundef readonly %2, ptr nocapture noundef readonly %3) local_unnamed_addr #1 {
  %lhsc = load i8, ptr %0, align 1
  %rhsc = load i8, ptr @.str.2, align 1
  %5 = icmp eq i8 %lhsc, %rhsc
  %6 = icmp eq ptr %1, null
  %7 = and i1 %6, %5
  br i1 %7, label %8, label %72, !prof !5

8:                                                ; preds = %4
  %9 = load i32, ptr @atomnum, align 4, !tbaa !6
  %10 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 4), align 4, !tbaa !6
  %11 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 8), align 8, !tbaa !6
  %12 = mul nsw i32 %11, %10
  %13 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 12), align 4, !tbaa !6
  %14 = mul nsw i32 %12, %13
  %15 = add i32 %9, 1
  %16 = add i32 %15, %14
  %17 = sext i32 %16 to i64
  %18 = tail call noalias ptr @calloc(i64 noundef %17, i64 noundef 4) #3
  store ptr %18, ptr @celllist, align 8, !tbaa !10
  %.not7993 = icmp slt i32 %9, 1
  br i1 %.not7993, label %.loopexit, label %.preheader.lr.ph

.preheader.lr.ph:                                 ; preds = %8
  %19 = getelementptr inbounds i8, ptr %3, i64 352
  %20 = load ptr, ptr %19, align 8, !tbaa !12
  %.pre102 = load double, ptr getelementptr inbounds (i8, ptr @cellsize, i64 8), align 8, !tbaa !15
  %21 = load double, ptr getelementptr inbounds (i8, ptr @cellsize, i64 16), align 16, !tbaa !15
  %22 = load double, ptr getelementptr inbounds (i8, ptr @cellsize, i64 24), align 8, !tbaa !15
  %23 = zext nneg i32 %9 to i64
  br label %.preheader

.preheader:                                       ; preds = %.preheader.lr.ph, %59
  %indvars.iv = phi i64 [ 1, %.preheader.lr.ph ], [ %indvars.iv.next, %59 ]
  %24 = getelementptr inbounds ptr, ptr %20, i64 %indvars.iv
  %25 = load ptr, ptr %24, align 8, !tbaa !10
  %26 = getelementptr inbounds i8, ptr %25, i64 8
  %27 = load ptr, ptr %26, align 8, !tbaa !16
  %28 = getelementptr inbounds i8, ptr %27, i64 24
  %29 = load double, ptr %28, align 8, !tbaa !15
  %30 = fdiv double %29, %.pre102
  %31 = fptosi double %30 to i32
  %32 = getelementptr inbounds i8, ptr %27, i64 4
  store i32 %31, ptr %32, align 4, !tbaa !6
  %33 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 4), align 4, !tbaa !6
  %34 = icmp eq i32 %33, %31
  br i1 %34, label %35, label %37

35:                                               ; preds = %.preheader
  %36 = add nsw i32 %31, -1
  store i32 %36, ptr %32, align 4, !tbaa !6
  br label %37

37:                                               ; preds = %.preheader, %35
  %38 = phi i32 [ %31, %.preheader ], [ %36, %35 ]
  %39 = getelementptr inbounds i8, ptr %27, i64 32
  %40 = load double, ptr %39, align 8, !tbaa !15
  %41 = fdiv double %40, %21
  %42 = fptosi double %41 to i32
  %43 = getelementptr inbounds i8, ptr %27, i64 8
  store i32 %42, ptr %43, align 4, !tbaa !6
  %44 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 8), align 8, !tbaa !6
  %45 = icmp eq i32 %44, %42
  br i1 %45, label %46, label %48

46:                                               ; preds = %37
  %47 = add nsw i32 %42, -1
  store i32 %47, ptr %43, align 4, !tbaa !6
  br label %48

48:                                               ; preds = %46, %37
  %49 = phi i32 [ %47, %46 ], [ %42, %37 ]
  %50 = getelementptr inbounds i8, ptr %27, i64 40
  %51 = load double, ptr %50, align 8, !tbaa !15
  %52 = fdiv double %51, %22
  %53 = fptosi double %52 to i32
  %54 = getelementptr inbounds i8, ptr %27, i64 12
  store i32 %53, ptr %54, align 4, !tbaa !6
  %55 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 12), align 4, !tbaa !6
  %56 = icmp eq i32 %55, %53
  br i1 %56, label %57, label %59

57:                                               ; preds = %48
  %58 = add nsw i32 %53, -1
  store i32 %58, ptr %54, align 4, !tbaa !6
  br label %59

59:                                               ; preds = %57, %48
  %60 = phi i32 [ %58, %57 ], [ %53, %48 ]
  %61 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 4), align 4, !tbaa !6
  %62 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 8), align 8, !tbaa !6
  %63 = mul i32 %62, %60
  %reass.add82 = add i32 %49, %63
  %reass.mul83 = mul i32 %reass.add82, %61
  %64 = add i32 %38, 1
  %65 = add i32 %64, %9
  %66 = add i32 %65, %reass.mul83
  %67 = sext i32 %66 to i64
  %68 = getelementptr inbounds i32, ptr %18, i64 %67
  %69 = load i32, ptr %68, align 4, !tbaa !6
  %70 = getelementptr inbounds i32, ptr %18, i64 %indvars.iv
  store i32 %69, ptr %70, align 4, !tbaa !6
  %71 = trunc nuw nsw i64 %indvars.iv to i32
  store i32 %71, ptr %68, align 4, !tbaa !6
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %.not79.not = icmp ult i64 %indvars.iv, %23
  br i1 %.not79.not, label %.preheader, label %.loopexit, !llvm.loop !18

72:                                               ; preds = %4
  %rhsc78 = load i8, ptr @.str.3, align 1
  %73 = icmp eq i8 %lhsc, %rhsc78
  %74 = icmp ne ptr %1, null
  %75 = and i1 %74, %73
  br i1 %75, label %76, label %171, !prof !20

76:                                               ; preds = %72
  %77 = load ptr, ptr @celllist, align 8, !tbaa !10
  %78 = getelementptr inbounds i8, ptr %2, i64 12
  %79 = load i32, ptr %78, align 4, !tbaa !6
  %80 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 4), align 4, !tbaa !6
  %81 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 8), align 8, !tbaa !6
  %82 = getelementptr inbounds i8, ptr %2, i64 8
  %83 = load i32, ptr %82, align 4, !tbaa !6
  %84 = getelementptr inbounds i8, ptr %2, i64 4
  %85 = load i32, ptr %84, align 4, !tbaa !6
  %86 = getelementptr inbounds i8, ptr %1, i64 8
  %87 = load ptr, ptr %86, align 8, !tbaa !16
  %88 = getelementptr inbounds i8, ptr %87, i64 24
  %89 = load double, ptr %88, align 8, !tbaa !15
  %90 = load double, ptr getelementptr inbounds (i8, ptr @cellsize, i64 8), align 8, !tbaa !15
  %91 = fdiv double %89, %90
  %92 = fptosi double %91 to i32
  %93 = getelementptr inbounds i8, ptr %87, i64 4
  store i32 %92, ptr %93, align 4, !tbaa !6
  %94 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 4), align 4, !tbaa !6
  %95 = icmp eq i32 %94, %92
  br i1 %95, label %96, label %98, !prof !5

96:                                               ; preds = %76
  %97 = add nsw i32 %92, -1
  store i32 %97, ptr %93, align 4, !tbaa !6
  br label %98

98:                                               ; preds = %76, %96
  %99 = phi i32 [ %92, %76 ], [ %97, %96 ]
  %100 = getelementptr inbounds i8, ptr %87, i64 32
  %101 = load double, ptr %100, align 8, !tbaa !15
  %102 = load double, ptr getelementptr inbounds (i8, ptr @cellsize, i64 16), align 16, !tbaa !15
  %103 = fdiv double %101, %102
  %104 = fptosi double %103 to i32
  %105 = getelementptr inbounds i8, ptr %87, i64 8
  store i32 %104, ptr %105, align 4, !tbaa !6
  %106 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 8), align 8, !tbaa !6
  %107 = icmp eq i32 %106, %104
  br i1 %107, label %108, label %110, !prof !5

108:                                              ; preds = %98
  %109 = add nsw i32 %104, -1
  store i32 %109, ptr %105, align 4, !tbaa !6
  br label %110

110:                                              ; preds = %108, %98
  %111 = phi i32 [ %109, %108 ], [ %104, %98 ]
  %112 = getelementptr inbounds i8, ptr %87, i64 40
  %113 = load double, ptr %112, align 8, !tbaa !15
  %114 = load double, ptr getelementptr inbounds (i8, ptr @cellsize, i64 24), align 8, !tbaa !15
  %115 = fdiv double %113, %114
  %116 = fptosi double %115 to i32
  %117 = getelementptr inbounds i8, ptr %87, i64 12
  store i32 %116, ptr %117, align 4, !tbaa !6
  %118 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 12), align 4, !tbaa !6
  %119 = icmp eq i32 %118, %116
  br i1 %119, label %120, label %122, !prof !5

120:                                              ; preds = %110
  %121 = add nsw i32 %116, -1
  store i32 %121, ptr %117, align 4, !tbaa !6
  br label %122

122:                                              ; preds = %120, %110
  %123 = phi i32 [ %121, %120 ], [ %116, %110 ]
  %124 = mul i32 %81, %79
  %125 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 4), align 4, !tbaa !6
  %126 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 8), align 8, !tbaa !6
  %127 = mul i32 %126, %123
  %128 = load i32, ptr @atomnum, align 4, !tbaa !6
  %reass.add = add i32 %83, %124
  %reass.mul = mul i32 %reass.add, %80
  %129 = add i32 %85, 1
  %130 = add i32 %129, %128
  %131 = add i32 %130, %reass.mul
  %132 = sext i32 %131 to i64
  %133 = getelementptr inbounds i32, ptr %77, i64 %132
  %134 = load i32, ptr %133, align 4, !tbaa !6
  %135 = icmp eq i32 %134, 0
  br i1 %135, label %136, label %138, !prof !5

136:                                              ; preds = %122
  %137 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.4)
  %.pre = load i32, ptr %133, align 4, !tbaa !6
  br label %138

138:                                              ; preds = %136, %122
  %139 = phi i32 [ %.pre, %136 ], [ %134, %122 ]
  %140 = load ptr, ptr %1, align 8, !tbaa !21
  %141 = getelementptr inbounds i8, ptr %140, i64 48
  %142 = load i32, ptr %141, align 8, !tbaa !22
  %.not89 = icmp eq i32 %139, %142
  br i1 %.not89, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %138, %148
  %143 = phi ptr [ %149, %148 ], [ %140, %138 ]
  %144 = phi i32 [ %152, %148 ], [ %139, %138 ]
  %145 = icmp eq i32 %144, 0
  br i1 %145, label %146, label %148, !prof !5

146:                                              ; preds = %.lr.ph
  %147 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.4)
  %.pre101 = load ptr, ptr %1, align 8, !tbaa !21
  br label %148

148:                                              ; preds = %146, %.lr.ph
  %149 = phi ptr [ %.pre101, %146 ], [ %143, %.lr.ph ]
  %150 = sext i32 %144 to i64
  %151 = getelementptr inbounds i32, ptr %77, i64 %150
  %152 = load i32, ptr %151, align 4, !tbaa !6
  %153 = getelementptr inbounds i8, ptr %149, i64 48
  %154 = load i32, ptr %153, align 8, !tbaa !22
  %.not = icmp eq i32 %152, %154
  br i1 %.not, label %._crit_edge, label %.lr.ph, !llvm.loop !25

._crit_edge:                                      ; preds = %148, %138
  %.lcssa88 = phi i64 [ %132, %138 ], [ %150, %148 ]
  %.lcssa87 = phi ptr [ %140, %138 ], [ %149, %148 ]
  %.lcssa = phi i32 [ %139, %138 ], [ %152, %148 ]
  %155 = getelementptr inbounds i32, ptr %77, i64 %.lcssa88
  %156 = getelementptr inbounds i8, ptr %.lcssa87, i64 48
  %157 = sext i32 %.lcssa to i64
  %158 = getelementptr inbounds i32, ptr %77, i64 %157
  %159 = load i32, ptr %158, align 4, !tbaa !6
  store i32 %159, ptr %155, align 4, !tbaa !6
  %160 = load i32, ptr @atomnum, align 4, !tbaa !6
  %reass.add80 = add i32 %111, %127
  %reass.mul81 = mul i32 %reass.add80, %125
  %161 = add i32 %99, 1
  %162 = add i32 %161, %160
  %163 = add i32 %162, %reass.mul81
  %164 = sext i32 %163 to i64
  %165 = getelementptr inbounds i32, ptr %77, i64 %164
  %166 = load i32, ptr %165, align 4, !tbaa !6
  %167 = load i32, ptr %156, align 8, !tbaa !22
  %168 = sext i32 %167 to i64
  %169 = getelementptr inbounds i32, ptr %77, i64 %168
  store i32 %166, ptr %169, align 4, !tbaa !6
  %170 = load i32, ptr %156, align 8, !tbaa !22
  store i32 %170, ptr %165, align 4, !tbaa !6
  br label %.loopexit

171:                                              ; preds = %72
  %172 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.5)
  br label %.loopexit

.loopexit:                                        ; preds = %59, %8, %._crit_edge, %171
  ret void
}

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

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

!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 = !{!"branch_weights", !"expected", i32 1, i32 2000}
!6 = !{!7, !7, i64 0}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!11, !11, i64 0}
!11 = !{!"any pointer", !8, i64 0}
!12 = !{!13, !11, i64 352}
!13 = !{!"AtomListStr", !7, i64 0, !8, i64 4, !8, i64 112, !8, i64 220, !14, i64 328, !11, i64 336, !11, i64 344, !11, i64 352}
!14 = !{!"double", !8, i64 0}
!15 = !{!14, !14, i64 0}
!16 = !{!17, !11, i64 8}
!17 = !{!"AtomStr", !11, i64 0, !11, i64 8}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.mustprogress"}
!20 = !{!"branch_weights", !"expected", i32 2000, i32 1}
!21 = !{!17, !11, i64 0}
!22 = !{!23, !7, i64 48}
!23 = !{!"PropertyStr", !8, i64 0, !8, i64 8, !8, i64 40, !7, i64 48, !7, i64 52, !7, i64 56, !14, i64 64, !14, i64 72, !8, i64 80, !24, i64 104, !11, i64 120, !11, i64 128}
!24 = !{!"AtomSeqStr", !7, i64 0, !7, i64 4, !7, i64 8}
!25 = distinct !{!25, !19}


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