; 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.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.1 = external hidden unnamed_addr constant [63 x i8], align 1
@cellnum = external global [4 x i32], align 16
@boxDimension = external global [4 x double], align 16
@connectionMap = external global ptr, align 8
@.str.17 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.21 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [45 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [41 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [51 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [6 x i8], align 1

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

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

104:                                              ; preds = %199, %5
  %105 = load i32, ptr %27, align 4, !tbaa !9
  %106 = icmp sle i32 %105, 3
  br i1 %106, label %108, label %107

107:                                              ; preds = %104
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #8
  br label %202

108:                                              ; preds = %104
  %109 = load ptr, ptr %6, align 8, !tbaa !5
  %110 = getelementptr inbounds %struct.AtomStr, ptr %109, i32 0, i32 1
  %111 = load ptr, ptr %110, align 8, !tbaa !11
  %112 = getelementptr inbounds %struct.DynamicStr, ptr %111, i32 0, i32 0
  %113 = load i32, ptr %27, 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 = load ptr, ptr %7, align 8, !tbaa !5
  %118 = getelementptr inbounds %struct.AtomStr, ptr %117, i32 0, i32 1
  %119 = load ptr, ptr %118, align 8, !tbaa !11
  %120 = getelementptr inbounds %struct.DynamicStr, ptr %119, i32 0, i32 0
  %121 = load i32, ptr %27, align 4, !tbaa !9
  %122 = sext i32 %121 to i64
  %123 = getelementptr inbounds [4 x i32], ptr %120, i64 0, i64 %122
  %124 = load i32, ptr %123, align 4, !tbaa !9
  %125 = icmp ne i32 %116, %124
  br i1 %125, label %126, label %198

126:                                              ; preds = %108
  %127 = load ptr, ptr %6, align 8, !tbaa !5
  %128 = getelementptr inbounds %struct.AtomStr, ptr %127, i32 0, i32 1
  %129 = load ptr, ptr %128, align 8, !tbaa !11
  %130 = getelementptr inbounds %struct.DynamicStr, ptr %129, i32 0, i32 0
  %131 = load i32, ptr %27, align 4, !tbaa !9
  %132 = sext i32 %131 to i64
  %133 = getelementptr inbounds [4 x i32], ptr %130, i64 0, i64 %132
  %134 = load i32, ptr %133, align 4, !tbaa !9
  %135 = icmp eq i32 %134, 0
  br i1 %135, label %136, label %161

136:                                              ; preds = %126
  %137 = load ptr, ptr %7, align 8, !tbaa !5
  %138 = getelementptr inbounds %struct.AtomStr, ptr %137, i32 0, i32 1
  %139 = load ptr, ptr %138, align 8, !tbaa !11
  %140 = getelementptr inbounds %struct.DynamicStr, ptr %139, i32 0, i32 0
  %141 = load i32, ptr %27, align 4, !tbaa !9
  %142 = sext i32 %141 to i64
  %143 = getelementptr inbounds [4 x i32], ptr %140, i64 0, i64 %142
  %144 = load i32, ptr %143, align 4, !tbaa !9
  %145 = load i32, ptr %27, align 4, !tbaa !9
  %146 = sext i32 %145 to i64
  %147 = getelementptr inbounds [4 x i32], ptr @cellnum, i64 0, i64 %146
  %148 = load i32, ptr %147, align 4, !tbaa !9
  %149 = sub nsw i32 %148, 1
  %150 = icmp eq i32 %144, %149
  br i1 %150, label %151, label %161

151:                                              ; preds = %136
  %152 = load i32, ptr %27, align 4, !tbaa !9
  %153 = sext i32 %152 to i64
  %154 = getelementptr inbounds [4 x double], ptr @boxDimension, i64 0, i64 %153
  %155 = load double, ptr %154, align 8, !tbaa !13
  %156 = load i32, ptr %27, align 4, !tbaa !9
  %157 = sext i32 %156 to i64
  %158 = getelementptr inbounds [4 x double], ptr %24, i64 0, i64 %157
  %159 = load double, ptr %158, align 8, !tbaa !13
  %160 = fsub double %159, %155
  store double %160, ptr %158, align 8, !tbaa !13
  br label %197

161:                                              ; preds = %136, %126
  %162 = load ptr, ptr %6, align 8, !tbaa !5
  %163 = getelementptr inbounds %struct.AtomStr, ptr %162, i32 0, i32 1
  %164 = load ptr, ptr %163, align 8, !tbaa !11
  %165 = getelementptr inbounds %struct.DynamicStr, ptr %164, i32 0, i32 0
  %166 = load i32, ptr %27, align 4, !tbaa !9
  %167 = sext i32 %166 to i64
  %168 = getelementptr inbounds [4 x i32], ptr %165, i64 0, i64 %167
  %169 = load i32, ptr %168, align 4, !tbaa !9
  %170 = load i32, ptr %27, align 4, !tbaa !9
  %171 = sext i32 %170 to i64
  %172 = getelementptr inbounds [4 x i32], ptr @cellnum, i64 0, i64 %171
  %173 = load i32, ptr %172, align 4, !tbaa !9
  %174 = sub nsw i32 %173, 1
  %175 = icmp eq i32 %169, %174
  br i1 %175, label %176, label %196

176:                                              ; preds = %161
  %177 = load ptr, ptr %7, align 8, !tbaa !5
  %178 = getelementptr inbounds %struct.AtomStr, ptr %177, i32 0, i32 1
  %179 = load ptr, ptr %178, align 8, !tbaa !11
  %180 = getelementptr inbounds %struct.DynamicStr, ptr %179, i32 0, i32 0
  %181 = load i32, ptr %27, align 4, !tbaa !9
  %182 = sext i32 %181 to i64
  %183 = getelementptr inbounds [4 x i32], ptr %180, i64 0, i64 %182
  %184 = load i32, ptr %183, align 4, !tbaa !9
  %185 = icmp eq i32 %184, 0
  br i1 %185, label %186, label %196

186:                                              ; preds = %176
  %187 = load i32, ptr %27, align 4, !tbaa !9
  %188 = sext i32 %187 to i64
  %189 = getelementptr inbounds [4 x double], ptr @boxDimension, i64 0, i64 %188
  %190 = load double, ptr %189, align 8, !tbaa !13
  %191 = load i32, ptr %27, align 4, !tbaa !9
  %192 = sext i32 %191 to i64
  %193 = getelementptr inbounds [4 x double], ptr %24, i64 0, i64 %192
  %194 = load double, ptr %193, align 8, !tbaa !13
  %195 = fadd double %194, %190
  store double %195, ptr %193, align 8, !tbaa !13
  br label %196

196:                                              ; preds = %186, %176, %161
  br label %197

197:                                              ; preds = %196, %151
  br label %198

198:                                              ; preds = %197, %108
  br label %199

199:                                              ; preds = %198
  %200 = load i32, ptr %27, align 4, !tbaa !9
  %201 = add nsw i32 %200, 1
  store i32 %201, ptr %27, align 4, !tbaa !9
  br label %104, !llvm.loop !15

202:                                              ; preds = %107
  %203 = getelementptr inbounds [4 x double], ptr %23, i64 0, i64 1
  %204 = load double, ptr %203, align 8, !tbaa !13
  %205 = getelementptr inbounds [4 x double], ptr %24, i64 0, i64 1
  %206 = load double, ptr %205, align 8, !tbaa !13
  %207 = fsub double %204, %206
  %208 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 1
  store double %207, ptr %208, align 8, !tbaa !13
  %209 = getelementptr inbounds [4 x double], ptr %23, i64 0, i64 2
  %210 = load double, ptr %209, align 16, !tbaa !13
  %211 = getelementptr inbounds [4 x double], ptr %24, i64 0, i64 2
  %212 = load double, ptr %211, align 16, !tbaa !13
  %213 = fsub double %210, %212
  %214 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 2
  store double %213, ptr %214, align 16, !tbaa !13
  %215 = getelementptr inbounds [4 x double], ptr %23, i64 0, i64 3
  %216 = load double, ptr %215, align 8, !tbaa !13
  %217 = getelementptr inbounds [4 x double], ptr %24, i64 0, i64 3
  %218 = load double, ptr %217, align 8, !tbaa !13
  %219 = fsub double %216, %218
  %220 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 3
  store double %219, ptr %220, align 8, !tbaa !13
  %221 = load ptr, ptr %21, align 8, !tbaa !5
  %222 = getelementptr inbounds double, ptr %221, i64 1
  %223 = load double, ptr %222, align 8, !tbaa !13
  %224 = load ptr, ptr %22, align 8, !tbaa !5
  %225 = getelementptr inbounds double, ptr %224, i64 1
  %226 = load double, ptr %225, align 8, !tbaa !13
  %227 = fsub double %223, %226
  %228 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 1
  store double %227, ptr %228, align 8, !tbaa !13
  %229 = load ptr, ptr %21, align 8, !tbaa !5
  %230 = getelementptr inbounds double, ptr %229, i64 2
  %231 = load double, ptr %230, align 8, !tbaa !13
  %232 = load ptr, ptr %22, align 8, !tbaa !5
  %233 = getelementptr inbounds double, ptr %232, i64 2
  %234 = load double, ptr %233, align 8, !tbaa !13
  %235 = fsub double %231, %234
  %236 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 2
  store double %235, ptr %236, align 16, !tbaa !13
  %237 = load ptr, ptr %21, align 8, !tbaa !5
  %238 = getelementptr inbounds double, ptr %237, i64 3
  %239 = load double, ptr %238, align 8, !tbaa !13
  %240 = load ptr, ptr %22, align 8, !tbaa !5
  %241 = getelementptr inbounds double, ptr %240, i64 3
  %242 = load double, ptr %241, align 8, !tbaa !13
  %243 = fsub double %239, %242
  %244 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  store double %243, ptr %244, align 8, !tbaa !13
  %245 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 1
  %246 = load double, ptr %245, align 8, !tbaa !13
  %247 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 1
  %248 = load double, ptr %247, align 8, !tbaa !13
  %249 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 2
  %250 = load double, ptr %249, align 16, !tbaa !13
  %251 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 2
  %252 = load double, ptr %251, align 16, !tbaa !13
  %253 = fmul double %250, %252
  %254 = call double @llvm.fmuladd.f64(double %246, double %248, double %253)
  %255 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 3
  %256 = load double, ptr %255, align 8, !tbaa !13
  %257 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 3
  %258 = load double, ptr %257, align 8, !tbaa !13
  %259 = call double @llvm.fmuladd.f64(double %256, double %258, double %254)
  store double %259, ptr %20, align 8, !tbaa !13
  %260 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 1
  %261 = load double, ptr %260, align 8, !tbaa !13
  %262 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 1
  %263 = load double, ptr %262, align 8, !tbaa !13
  %264 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 2
  %265 = load double, ptr %264, align 16, !tbaa !13
  %266 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 2
  %267 = load double, ptr %266, align 16, !tbaa !13
  %268 = fmul double %265, %267
  %269 = call double @llvm.fmuladd.f64(double %261, double %263, double %268)
  %270 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 3
  %271 = load double, ptr %270, align 8, !tbaa !13
  %272 = getelementptr inbounds [4 x double], ptr %12, i64 0, i64 3
  %273 = load double, ptr %272, align 8, !tbaa !13
  %274 = call double @llvm.fmuladd.f64(double %271, double %273, double %269)
  store double %274, ptr %13, align 8, !tbaa !13
  %275 = load ptr, ptr %6, align 8, !tbaa !5
  %276 = getelementptr inbounds %struct.AtomStr, ptr %275, i32 0, i32 0
  %277 = load ptr, ptr %276, align 8, !tbaa !17
  %278 = getelementptr inbounds %struct.PropertyStr, ptr %277, i32 0, i32 7
  %279 = load double, ptr %278, align 8, !tbaa !18
  %280 = load ptr, ptr %7, align 8, !tbaa !5
  %281 = getelementptr inbounds %struct.AtomStr, ptr %280, i32 0, i32 0
  %282 = load ptr, ptr %281, align 8, !tbaa !17
  %283 = getelementptr inbounds %struct.PropertyStr, ptr %282, i32 0, i32 7
  %284 = load double, ptr %283, align 8, !tbaa !18
  %285 = fmul double %279, %284
  %286 = load ptr, ptr %6, align 8, !tbaa !5
  %287 = getelementptr inbounds %struct.AtomStr, ptr %286, i32 0, i32 0
  %288 = load ptr, ptr %287, align 8, !tbaa !17
  %289 = getelementptr inbounds %struct.PropertyStr, ptr %288, i32 0, i32 7
  %290 = load double, ptr %289, align 8, !tbaa !18
  %291 = load ptr, ptr %7, align 8, !tbaa !5
  %292 = getelementptr inbounds %struct.AtomStr, ptr %291, i32 0, i32 0
  %293 = load ptr, ptr %292, align 8, !tbaa !17
  %294 = getelementptr inbounds %struct.PropertyStr, ptr %293, i32 0, i32 7
  %295 = load double, ptr %294, align 8, !tbaa !18
  %296 = fadd double %290, %295
  %297 = fdiv double %285, %296
  store double %297, ptr %19, align 8, !tbaa !13
  %298 = load ptr, ptr %6, align 8, !tbaa !5
  %299 = getelementptr inbounds %struct.AtomStr, ptr %298, i32 0, i32 1
  %300 = load ptr, ptr %299, align 8, !tbaa !11
  %301 = getelementptr inbounds %struct.DynamicStr, ptr %300, i32 0, i32 5
  %302 = getelementptr inbounds %struct.InteractionEventStr, ptr %301, i32 0, i32 4
  %303 = load double, ptr %302, align 8, !tbaa !21
  store double %303, ptr %18, align 8, !tbaa !13
  %304 = load ptr, ptr %6, align 8, !tbaa !5
  %305 = getelementptr inbounds %struct.AtomStr, ptr %304, i32 0, i32 1
  %306 = load ptr, ptr %305, align 8, !tbaa !11
  %307 = getelementptr inbounds %struct.DynamicStr, ptr %306, i32 0, i32 5
  %308 = getelementptr inbounds %struct.InteractionEventStr, ptr %307, i32 0, i32 5
  %309 = load i32, ptr %308, align 8, !tbaa !27
  %310 = icmp eq i32 %309, 2
  br i1 %310, label %311, label %329

311:                                              ; preds = %202
  %312 = load ptr, ptr %6, align 8, !tbaa !5
  %313 = getelementptr inbounds %struct.AtomStr, ptr %312, i32 0, i32 1
  %314 = load ptr, ptr %313, align 8, !tbaa !11
  %315 = getelementptr inbounds %struct.DynamicStr, ptr %314, i32 0, i32 5
  %316 = getelementptr inbounds %struct.InteractionEventStr, ptr %315, i32 0, i32 6
  %317 = load i32, ptr %316, align 4, !tbaa !28
  %318 = icmp eq i32 %317, 6
  br i1 %318, label %327, label %319

319:                                              ; preds = %311
  %320 = load ptr, ptr %6, align 8, !tbaa !5
  %321 = getelementptr inbounds %struct.AtomStr, ptr %320, i32 0, i32 1
  %322 = load ptr, ptr %321, align 8, !tbaa !11
  %323 = getelementptr inbounds %struct.DynamicStr, ptr %322, i32 0, i32 5
  %324 = getelementptr inbounds %struct.InteractionEventStr, ptr %323, i32 0, i32 6
  %325 = load i32, ptr %324, align 4, !tbaa !28
  %326 = icmp eq i32 %325, 7
  br label %327

327:                                              ; preds = %319, %311
  %328 = phi i1 [ true, %311 ], [ %326, %319 ]
  br label %329

329:                                              ; preds = %327, %202
  %330 = phi i1 [ false, %202 ], [ %328, %327 ]
  %331 = xor i1 %330, true
  %332 = xor i1 %331, true
  %333 = zext i1 %332 to i32
  %334 = sext i32 %333 to i64
  %335 = call i64 @llvm.expect.i64(i64 %334, i64 0)
  %336 = icmp ne i64 %335, 0
  br i1 %336, label %337, label %951

337:                                              ; preds = %329
  call void @llvm.lifetime.start.p0(i64 32, ptr %28) #8
  call void @llvm.lifetime.start.p0(i64 32, ptr %29) #8
  call void @llvm.lifetime.start.p0(i64 32, ptr %30) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %31) #8
  call void @llvm.lifetime.start.p0(i64 32, ptr %32) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #8
  call void @llvm.lifetime.start.p0(i64 48, ptr %34) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #8
  store double 0.000000e+00, ptr %35, align 8, !tbaa !13
  %338 = load ptr, ptr @connectionMap, align 8, !tbaa !5
  %339 = load ptr, ptr %6, align 8, !tbaa !5
  %340 = getelementptr inbounds %struct.AtomStr, ptr %339, i32 0, i32 0
  %341 = load ptr, ptr %340, align 8, !tbaa !17
  %342 = getelementptr inbounds %struct.PropertyStr, ptr %341, i32 0, i32 3
  %343 = load i32, ptr %342, align 8, !tbaa !29
  %344 = sext i32 %343 to i64
  %345 = getelementptr inbounds ptr, ptr %338, i64 %344
  %346 = load ptr, ptr %345, align 8, !tbaa !5
  %347 = load ptr, ptr %9, align 8, !tbaa !5
  %348 = getelementptr inbounds %struct.AtomStr, ptr %347, i32 0, i32 0
  %349 = load ptr, ptr %348, align 8, !tbaa !17
  %350 = getelementptr inbounds %struct.PropertyStr, ptr %349, i32 0, i32 3
  %351 = load i32, ptr %350, align 8, !tbaa !29
  %352 = sext i32 %351 to i64
  %353 = getelementptr inbounds i32, ptr %346, i64 %352
  %354 = load i32, ptr %353, align 4, !tbaa !9
  %355 = and i32 %354, 8
  %356 = icmp ne i32 %355, 0
  br i1 %356, label %377, label %357

357:                                              ; preds = %337
  %358 = load ptr, ptr @connectionMap, align 8, !tbaa !5
  %359 = load ptr, ptr %7, align 8, !tbaa !5
  %360 = getelementptr inbounds %struct.AtomStr, ptr %359, i32 0, i32 0
  %361 = load ptr, ptr %360, align 8, !tbaa !17
  %362 = getelementptr inbounds %struct.PropertyStr, ptr %361, i32 0, i32 3
  %363 = load i32, ptr %362, align 8, !tbaa !29
  %364 = sext i32 %363 to i64
  %365 = getelementptr inbounds ptr, ptr %358, i64 %364
  %366 = load ptr, ptr %365, align 8, !tbaa !5
  %367 = load ptr, ptr %8, align 8, !tbaa !5
  %368 = getelementptr inbounds %struct.AtomStr, ptr %367, i32 0, i32 0
  %369 = load ptr, ptr %368, align 8, !tbaa !17
  %370 = getelementptr inbounds %struct.PropertyStr, ptr %369, i32 0, i32 3
  %371 = load i32, ptr %370, align 8, !tbaa !29
  %372 = sext i32 %371 to i64
  %373 = getelementptr inbounds i32, ptr %366, i64 %372
  %374 = load i32, ptr %373, align 4, !tbaa !9
  %375 = and i32 %374, 8
  %376 = icmp ne i32 %375, 0
  br i1 %376, label %377, label %391

377:                                              ; preds = %357, %337
  %378 = load ptr, ptr %6, align 8, !tbaa !5
  %379 = getelementptr inbounds %struct.AtomStr, ptr %378, i32 0, i32 1
  %380 = load ptr, ptr %379, align 8, !tbaa !11
  %381 = getelementptr inbounds %struct.DynamicStr, ptr %380, i32 0, i32 5
  %382 = getelementptr inbounds %struct.InteractionEventStr, ptr %381, i32 0, i32 6
  %383 = load i32, ptr %382, align 4, !tbaa !28
  %384 = icmp eq i32 %383, 6
  br i1 %384, label %385, label %391

385:                                              ; preds = %377
  %386 = load ptr, ptr %6, align 8, !tbaa !5
  %387 = getelementptr inbounds %struct.AtomStr, ptr %386, i32 0, i32 1
  %388 = load ptr, ptr %387, align 8, !tbaa !11
  %389 = getelementptr inbounds %struct.DynamicStr, ptr %388, i32 0, i32 3
  %390 = getelementptr inbounds %struct.HBStr, ptr %389, i32 0, i32 3
  store i32 3, ptr %390, align 4, !tbaa !30
  store i32 1, ptr %36, align 4
  br label %948

391:                                              ; preds = %377, %357
  %392 = load ptr, ptr %8, align 8, !tbaa !5
  %393 = getelementptr inbounds %struct.AtomStr, ptr %392, i32 0, i32 1
  %394 = load ptr, ptr %393, align 8, !tbaa !11
  %395 = getelementptr inbounds %struct.DynamicStr, ptr %394, i32 0, i32 1
  %396 = getelementptr inbounds [4 x double], ptr %395, i64 0, i64 0
  %397 = load double, ptr %396, align 8, !tbaa !13
  %398 = getelementptr inbounds [4 x double], ptr %28, i64 0, i64 0
  store double %397, ptr %398, align 16, !tbaa !13
  %399 = load ptr, ptr %8, align 8, !tbaa !5
  %400 = getelementptr inbounds %struct.AtomStr, ptr %399, i32 0, i32 1
  %401 = load ptr, ptr %400, align 8, !tbaa !11
  %402 = getelementptr inbounds %struct.DynamicStr, ptr %401, i32 0, i32 1
  %403 = getelementptr inbounds [4 x double], ptr %402, i64 0, i64 1
  %404 = load double, ptr %403, align 8, !tbaa !13
  %405 = getelementptr inbounds [4 x double], ptr %28, i64 0, i64 1
  store double %404, ptr %405, align 8, !tbaa !13
  %406 = load ptr, ptr %8, align 8, !tbaa !5
  %407 = getelementptr inbounds %struct.AtomStr, ptr %406, i32 0, i32 1
  %408 = load ptr, ptr %407, align 8, !tbaa !11
  %409 = getelementptr inbounds %struct.DynamicStr, ptr %408, i32 0, i32 1
  %410 = getelementptr inbounds [4 x double], ptr %409, i64 0, i64 2
  %411 = load double, ptr %410, align 8, !tbaa !13
  %412 = getelementptr inbounds [4 x double], ptr %28, i64 0, i64 2
  store double %411, ptr %412, align 16, !tbaa !13
  %413 = load ptr, ptr %8, align 8, !tbaa !5
  %414 = getelementptr inbounds %struct.AtomStr, ptr %413, i32 0, i32 1
  %415 = load ptr, ptr %414, align 8, !tbaa !11
  %416 = getelementptr inbounds %struct.DynamicStr, ptr %415, i32 0, i32 1
  %417 = getelementptr inbounds [4 x double], ptr %416, i64 0, i64 3
  %418 = load double, ptr %417, align 8, !tbaa !13
  %419 = getelementptr inbounds [4 x double], ptr %28, i64 0, i64 3
  store double %418, ptr %419, align 8, !tbaa !13
  %420 = load ptr, ptr %9, align 8, !tbaa !5
  %421 = getelementptr inbounds %struct.AtomStr, ptr %420, i32 0, i32 1
  %422 = load ptr, ptr %421, align 8, !tbaa !11
  %423 = getelementptr inbounds %struct.DynamicStr, ptr %422, i32 0, i32 1
  %424 = getelementptr inbounds [4 x double], ptr %423, i64 0, i64 0
  %425 = load double, ptr %424, align 8, !tbaa !13
  %426 = getelementptr inbounds [4 x double], ptr %29, i64 0, i64 0
  store double %425, ptr %426, align 16, !tbaa !13
  %427 = load ptr, ptr %9, align 8, !tbaa !5
  %428 = getelementptr inbounds %struct.AtomStr, ptr %427, i32 0, i32 1
  %429 = load ptr, ptr %428, align 8, !tbaa !11
  %430 = getelementptr inbounds %struct.DynamicStr, ptr %429, i32 0, i32 1
  %431 = getelementptr inbounds [4 x double], ptr %430, i64 0, i64 1
  %432 = load double, ptr %431, align 8, !tbaa !13
  %433 = getelementptr inbounds [4 x double], ptr %29, i64 0, i64 1
  store double %432, ptr %433, align 8, !tbaa !13
  %434 = load ptr, ptr %9, align 8, !tbaa !5
  %435 = getelementptr inbounds %struct.AtomStr, ptr %434, i32 0, i32 1
  %436 = load ptr, ptr %435, align 8, !tbaa !11
  %437 = getelementptr inbounds %struct.DynamicStr, ptr %436, i32 0, i32 1
  %438 = getelementptr inbounds [4 x double], ptr %437, i64 0, i64 2
  %439 = load double, ptr %438, align 8, !tbaa !13
  %440 = getelementptr inbounds [4 x double], ptr %29, i64 0, i64 2
  store double %439, ptr %440, align 16, !tbaa !13
  %441 = load ptr, ptr %9, align 8, !tbaa !5
  %442 = getelementptr inbounds %struct.AtomStr, ptr %441, i32 0, i32 1
  %443 = load ptr, ptr %442, align 8, !tbaa !11
  %444 = getelementptr inbounds %struct.DynamicStr, ptr %443, i32 0, i32 1
  %445 = getelementptr inbounds [4 x double], ptr %444, i64 0, i64 3
  %446 = load double, ptr %445, align 8, !tbaa !13
  %447 = getelementptr inbounds [4 x double], ptr %29, i64 0, i64 3
  store double %446, ptr %447, align 8, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #8
  store i32 1, ptr %37, align 4, !tbaa !9
  br label %448

448:                                              ; preds = %633, %391
  %449 = load i32, ptr %37, align 4, !tbaa !9
  %450 = icmp sle i32 %449, 3
  br i1 %450, label %452, label %451

451:                                              ; preds = %448
  store i32 5, ptr %36, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #8
  br label %636

452:                                              ; preds = %448
  %453 = load ptr, ptr %6, align 8, !tbaa !5
  %454 = getelementptr inbounds %struct.AtomStr, ptr %453, i32 0, i32 1
  %455 = load ptr, ptr %454, align 8, !tbaa !11
  %456 = getelementptr inbounds %struct.DynamicStr, ptr %455, i32 0, i32 0
  %457 = load i32, ptr %37, align 4, !tbaa !9
  %458 = sext i32 %457 to i64
  %459 = getelementptr inbounds [4 x i32], ptr %456, i64 0, i64 %458
  %460 = load i32, ptr %459, align 4, !tbaa !9
  %461 = load ptr, ptr %8, align 8, !tbaa !5
  %462 = getelementptr inbounds %struct.AtomStr, ptr %461, i32 0, i32 1
  %463 = load ptr, ptr %462, align 8, !tbaa !11
  %464 = getelementptr inbounds %struct.DynamicStr, ptr %463, i32 0, i32 0
  %465 = load i32, ptr %37, align 4, !tbaa !9
  %466 = sext i32 %465 to i64
  %467 = getelementptr inbounds [4 x i32], ptr %464, i64 0, i64 %466
  %468 = load i32, ptr %467, align 4, !tbaa !9
  %469 = icmp ne i32 %460, %468
  br i1 %469, label %470, label %542

470:                                              ; preds = %452
  %471 = load ptr, ptr %6, align 8, !tbaa !5
  %472 = getelementptr inbounds %struct.AtomStr, ptr %471, i32 0, i32 1
  %473 = load ptr, ptr %472, align 8, !tbaa !11
  %474 = getelementptr inbounds %struct.DynamicStr, ptr %473, i32 0, i32 0
  %475 = load i32, ptr %37, align 4, !tbaa !9
  %476 = sext i32 %475 to i64
  %477 = getelementptr inbounds [4 x i32], ptr %474, i64 0, i64 %476
  %478 = load i32, ptr %477, align 4, !tbaa !9
  %479 = icmp eq i32 %478, 0
  br i1 %479, label %480, label %505

480:                                              ; preds = %470
  %481 = load ptr, ptr %8, align 8, !tbaa !5
  %482 = getelementptr inbounds %struct.AtomStr, ptr %481, i32 0, i32 1
  %483 = load ptr, ptr %482, align 8, !tbaa !11
  %484 = getelementptr inbounds %struct.DynamicStr, ptr %483, i32 0, i32 0
  %485 = load i32, ptr %37, align 4, !tbaa !9
  %486 = sext i32 %485 to i64
  %487 = getelementptr inbounds [4 x i32], ptr %484, i64 0, i64 %486
  %488 = load i32, ptr %487, align 4, !tbaa !9
  %489 = load i32, ptr %37, align 4, !tbaa !9
  %490 = sext i32 %489 to i64
  %491 = getelementptr inbounds [4 x i32], ptr @cellnum, i64 0, i64 %490
  %492 = load i32, ptr %491, align 4, !tbaa !9
  %493 = sub nsw i32 %492, 1
  %494 = icmp eq i32 %488, %493
  br i1 %494, label %495, label %505

495:                                              ; preds = %480
  %496 = load i32, ptr %37, align 4, !tbaa !9
  %497 = sext i32 %496 to i64
  %498 = getelementptr inbounds [4 x double], ptr @boxDimension, i64 0, i64 %497
  %499 = load double, ptr %498, align 8, !tbaa !13
  %500 = load i32, ptr %37, align 4, !tbaa !9
  %501 = sext i32 %500 to i64
  %502 = getelementptr inbounds [4 x double], ptr %28, i64 0, i64 %501
  %503 = load double, ptr %502, align 8, !tbaa !13
  %504 = fsub double %503, %499
  store double %504, ptr %502, align 8, !tbaa !13
  br label %541

505:                                              ; preds = %480, %470
  %506 = load ptr, ptr %6, align 8, !tbaa !5
  %507 = getelementptr inbounds %struct.AtomStr, ptr %506, i32 0, i32 1
  %508 = load ptr, ptr %507, align 8, !tbaa !11
  %509 = getelementptr inbounds %struct.DynamicStr, ptr %508, i32 0, i32 0
  %510 = load i32, ptr %37, align 4, !tbaa !9
  %511 = sext i32 %510 to i64
  %512 = getelementptr inbounds [4 x i32], ptr %509, i64 0, i64 %511
  %513 = load i32, ptr %512, align 4, !tbaa !9
  %514 = load i32, ptr %37, align 4, !tbaa !9
  %515 = sext i32 %514 to i64
  %516 = getelementptr inbounds [4 x i32], ptr @cellnum, i64 0, i64 %515
  %517 = load i32, ptr %516, align 4, !tbaa !9
  %518 = sub nsw i32 %517, 1
  %519 = icmp eq i32 %513, %518
  br i1 %519, label %520, label %540

520:                                              ; preds = %505
  %521 = load ptr, ptr %8, align 8, !tbaa !5
  %522 = getelementptr inbounds %struct.AtomStr, ptr %521, i32 0, i32 1
  %523 = load ptr, ptr %522, align 8, !tbaa !11
  %524 = getelementptr inbounds %struct.DynamicStr, ptr %523, i32 0, i32 0
  %525 = load i32, ptr %37, align 4, !tbaa !9
  %526 = sext i32 %525 to i64
  %527 = getelementptr inbounds [4 x i32], ptr %524, i64 0, i64 %526
  %528 = load i32, ptr %527, align 4, !tbaa !9
  %529 = icmp eq i32 %528, 0
  br i1 %529, label %530, label %540

530:                                              ; preds = %520
  %531 = load i32, ptr %37, align 4, !tbaa !9
  %532 = sext i32 %531 to i64
  %533 = getelementptr inbounds [4 x double], ptr @boxDimension, i64 0, i64 %532
  %534 = load double, ptr %533, align 8, !tbaa !13
  %535 = load i32, ptr %37, align 4, !tbaa !9
  %536 = sext i32 %535 to i64
  %537 = getelementptr inbounds [4 x double], ptr %28, i64 0, i64 %536
  %538 = load double, ptr %537, align 8, !tbaa !13
  %539 = fadd double %538, %534
  store double %539, ptr %537, align 8, !tbaa !13
  br label %540

540:                                              ; preds = %530, %520, %505
  br label %541

541:                                              ; preds = %540, %495
  br label %542

542:                                              ; preds = %541, %452
  %543 = load ptr, ptr %6, align 8, !tbaa !5
  %544 = getelementptr inbounds %struct.AtomStr, ptr %543, i32 0, i32 1
  %545 = load ptr, ptr %544, align 8, !tbaa !11
  %546 = getelementptr inbounds %struct.DynamicStr, ptr %545, i32 0, i32 0
  %547 = load i32, ptr %37, align 4, !tbaa !9
  %548 = sext i32 %547 to i64
  %549 = getelementptr inbounds [4 x i32], ptr %546, i64 0, i64 %548
  %550 = load i32, ptr %549, align 4, !tbaa !9
  %551 = load ptr, ptr %9, align 8, !tbaa !5
  %552 = getelementptr inbounds %struct.AtomStr, ptr %551, i32 0, i32 1
  %553 = load ptr, ptr %552, align 8, !tbaa !11
  %554 = getelementptr inbounds %struct.DynamicStr, ptr %553, i32 0, i32 0
  %555 = load i32, ptr %37, align 4, !tbaa !9
  %556 = sext i32 %555 to i64
  %557 = getelementptr inbounds [4 x i32], ptr %554, i64 0, i64 %556
  %558 = load i32, ptr %557, align 4, !tbaa !9
  %559 = icmp ne i32 %550, %558
  br i1 %559, label %560, label %632

560:                                              ; preds = %542
  %561 = load ptr, ptr %6, align 8, !tbaa !5
  %562 = getelementptr inbounds %struct.AtomStr, ptr %561, i32 0, i32 1
  %563 = load ptr, ptr %562, align 8, !tbaa !11
  %564 = getelementptr inbounds %struct.DynamicStr, ptr %563, i32 0, i32 0
  %565 = load i32, ptr %37, align 4, !tbaa !9
  %566 = sext i32 %565 to i64
  %567 = getelementptr inbounds [4 x i32], ptr %564, i64 0, i64 %566
  %568 = load i32, ptr %567, align 4, !tbaa !9
  %569 = icmp eq i32 %568, 0
  br i1 %569, label %570, label %595

570:                                              ; preds = %560
  %571 = load ptr, ptr %9, align 8, !tbaa !5
  %572 = getelementptr inbounds %struct.AtomStr, ptr %571, i32 0, i32 1
  %573 = load ptr, ptr %572, align 8, !tbaa !11
  %574 = getelementptr inbounds %struct.DynamicStr, ptr %573, i32 0, i32 0
  %575 = load i32, ptr %37, align 4, !tbaa !9
  %576 = sext i32 %575 to i64
  %577 = getelementptr inbounds [4 x i32], ptr %574, i64 0, i64 %576
  %578 = load i32, ptr %577, align 4, !tbaa !9
  %579 = load i32, ptr %37, align 4, !tbaa !9
  %580 = sext i32 %579 to i64
  %581 = getelementptr inbounds [4 x i32], ptr @cellnum, i64 0, i64 %580
  %582 = load i32, ptr %581, align 4, !tbaa !9
  %583 = sub nsw i32 %582, 1
  %584 = icmp eq i32 %578, %583
  br i1 %584, label %585, label %595

585:                                              ; preds = %570
  %586 = load i32, ptr %37, align 4, !tbaa !9
  %587 = sext i32 %586 to i64
  %588 = getelementptr inbounds [4 x double], ptr @boxDimension, i64 0, i64 %587
  %589 = load double, ptr %588, align 8, !tbaa !13
  %590 = load i32, ptr %37, align 4, !tbaa !9
  %591 = sext i32 %590 to i64
  %592 = getelementptr inbounds [4 x double], ptr %29, i64 0, i64 %591
  %593 = load double, ptr %592, align 8, !tbaa !13
  %594 = fsub double %593, %589
  store double %594, ptr %592, align 8, !tbaa !13
  br label %631

595:                                              ; preds = %570, %560
  %596 = load ptr, ptr %6, align 8, !tbaa !5
  %597 = getelementptr inbounds %struct.AtomStr, ptr %596, i32 0, i32 1
  %598 = load ptr, ptr %597, align 8, !tbaa !11
  %599 = getelementptr inbounds %struct.DynamicStr, ptr %598, i32 0, i32 0
  %600 = load i32, ptr %37, align 4, !tbaa !9
  %601 = sext i32 %600 to i64
  %602 = getelementptr inbounds [4 x i32], ptr %599, i64 0, i64 %601
  %603 = load i32, ptr %602, align 4, !tbaa !9
  %604 = load i32, ptr %37, align 4, !tbaa !9
  %605 = sext i32 %604 to i64
  %606 = getelementptr inbounds [4 x i32], ptr @cellnum, i64 0, i64 %605
  %607 = load i32, ptr %606, align 4, !tbaa !9
  %608 = sub nsw i32 %607, 1
  %609 = icmp eq i32 %603, %608
  br i1 %609, label %610, label %630

610:                                              ; preds = %595
  %611 = load ptr, ptr %9, align 8, !tbaa !5
  %612 = getelementptr inbounds %struct.AtomStr, ptr %611, i32 0, i32 1
  %613 = load ptr, ptr %612, align 8, !tbaa !11
  %614 = getelementptr inbounds %struct.DynamicStr, ptr %613, i32 0, i32 0
  %615 = load i32, ptr %37, align 4, !tbaa !9
  %616 = sext i32 %615 to i64
  %617 = getelementptr inbounds [4 x i32], ptr %614, i64 0, i64 %616
  %618 = load i32, ptr %617, align 4, !tbaa !9
  %619 = icmp eq i32 %618, 0
  br i1 %619, label %620, label %630

620:                                              ; preds = %610
  %621 = load i32, ptr %37, align 4, !tbaa !9
  %622 = sext i32 %621 to i64
  %623 = getelementptr inbounds [4 x double], ptr @boxDimension, i64 0, i64 %622
  %624 = load double, ptr %623, align 8, !tbaa !13
  %625 = load i32, ptr %37, align 4, !tbaa !9
  %626 = sext i32 %625 to i64
  %627 = getelementptr inbounds [4 x double], ptr %29, i64 0, i64 %626
  %628 = load double, ptr %627, align 8, !tbaa !13
  %629 = fadd double %628, %624
  store double %629, ptr %627, align 8, !tbaa !13
  br label %630

630:                                              ; preds = %620, %610, %595
  br label %631

631:                                              ; preds = %630, %585
  br label %632

632:                                              ; preds = %631, %542
  br label %633

633:                                              ; preds = %632
  %634 = load i32, ptr %37, align 4, !tbaa !9
  %635 = add nsw i32 %634, 1
  store i32 %635, ptr %37, align 4, !tbaa !9
  br label %448, !llvm.loop !31

636:                                              ; preds = %451
  %637 = getelementptr inbounds [4 x double], ptr %23, i64 0, i64 1
  %638 = load double, ptr %637, align 8, !tbaa !13
  %639 = getelementptr inbounds [4 x double], ptr %29, i64 0, i64 1
  %640 = load double, ptr %639, align 8, !tbaa !13
  %641 = fsub double %638, %640
  %642 = getelementptr inbounds [4 x double], ptr %30, i64 0, i64 1
  store double %641, ptr %642, align 8, !tbaa !13
  %643 = getelementptr inbounds [4 x double], ptr %23, i64 0, i64 2
  %644 = load double, ptr %643, align 16, !tbaa !13
  %645 = getelementptr inbounds [4 x double], ptr %29, i64 0, i64 2
  %646 = load double, ptr %645, align 16, !tbaa !13
  %647 = fsub double %644, %646
  %648 = getelementptr inbounds [4 x double], ptr %30, i64 0, i64 2
  store double %647, ptr %648, align 16, !tbaa !13
  %649 = getelementptr inbounds [4 x double], ptr %23, i64 0, i64 3
  %650 = load double, ptr %649, align 8, !tbaa !13
  %651 = getelementptr inbounds [4 x double], ptr %29, i64 0, i64 3
  %652 = load double, ptr %651, align 8, !tbaa !13
  %653 = fsub double %650, %652
  %654 = getelementptr inbounds [4 x double], ptr %30, i64 0, i64 3
  store double %653, ptr %654, align 8, !tbaa !13
  %655 = getelementptr inbounds [4 x double], ptr %24, i64 0, i64 1
  %656 = load double, ptr %655, align 8, !tbaa !13
  %657 = getelementptr inbounds [4 x double], ptr %28, i64 0, i64 1
  %658 = load double, ptr %657, align 8, !tbaa !13
  %659 = fsub double %656, %658
  %660 = getelementptr inbounds [4 x double], ptr %32, i64 0, i64 1
  store double %659, ptr %660, align 8, !tbaa !13
  %661 = getelementptr inbounds [4 x double], ptr %24, i64 0, i64 2
  %662 = load double, ptr %661, align 16, !tbaa !13
  %663 = getelementptr inbounds [4 x double], ptr %28, i64 0, i64 2
  %664 = load double, ptr %663, align 16, !tbaa !13
  %665 = fsub double %662, %664
  %666 = getelementptr inbounds [4 x double], ptr %32, i64 0, i64 2
  store double %665, ptr %666, align 16, !tbaa !13
  %667 = getelementptr inbounds [4 x double], ptr %24, i64 0, i64 3
  %668 = load double, ptr %667, align 8, !tbaa !13
  %669 = getelementptr inbounds [4 x double], ptr %28, i64 0, i64 3
  %670 = load double, ptr %669, align 8, !tbaa !13
  %671 = fsub double %668, %670
  %672 = getelementptr inbounds [4 x double], ptr %32, i64 0, i64 3
  store double %671, ptr %672, align 8, !tbaa !13
  %673 = getelementptr inbounds [4 x double], ptr %30, i64 0, i64 1
  %674 = load double, ptr %673, align 8, !tbaa !13
  %675 = getelementptr inbounds [4 x double], ptr %30, i64 0, i64 1
  %676 = load double, ptr %675, align 8, !tbaa !13
  %677 = getelementptr inbounds [4 x double], ptr %30, i64 0, i64 2
  %678 = load double, ptr %677, align 16, !tbaa !13
  %679 = getelementptr inbounds [4 x double], ptr %30, i64 0, i64 2
  %680 = load double, ptr %679, align 16, !tbaa !13
  %681 = fmul double %678, %680
  %682 = call double @llvm.fmuladd.f64(double %674, double %676, double %681)
  %683 = getelementptr inbounds [4 x double], ptr %30, i64 0, i64 3
  %684 = load double, ptr %683, align 8, !tbaa !13
  %685 = getelementptr inbounds [4 x double], ptr %30, i64 0, i64 3
  %686 = load double, ptr %685, align 8, !tbaa !13
  %687 = call double @llvm.fmuladd.f64(double %684, double %686, double %682)
  store double %687, ptr %31, align 8, !tbaa !13
  %688 = getelementptr inbounds [4 x double], ptr %32, i64 0, i64 1
  %689 = load double, ptr %688, align 8, !tbaa !13
  %690 = getelementptr inbounds [4 x double], ptr %32, i64 0, i64 1
  %691 = load double, ptr %690, align 8, !tbaa !13
  %692 = getelementptr inbounds [4 x double], ptr %32, i64 0, i64 2
  %693 = load double, ptr %692, align 16, !tbaa !13
  %694 = getelementptr inbounds [4 x double], ptr %32, i64 0, i64 2
  %695 = load double, ptr %694, align 16, !tbaa !13
  %696 = fmul double %693, %695
  %697 = call double @llvm.fmuladd.f64(double %689, double %691, double %696)
  %698 = getelementptr inbounds [4 x double], ptr %32, i64 0, i64 3
  %699 = load double, ptr %698, align 8, !tbaa !13
  %700 = getelementptr inbounds [4 x double], ptr %32, i64 0, i64 3
  %701 = load double, ptr %700, align 8, !tbaa !13
  %702 = call double @llvm.fmuladd.f64(double %699, double %701, double %697)
  store double %702, ptr %33, align 8, !tbaa !13
  %703 = load ptr, ptr %6, align 8, !tbaa !5
  %704 = load ptr, ptr %7, align 8, !tbaa !5
  %705 = getelementptr inbounds %struct.AtomStr, ptr %704, i32 0, i32 0
  %706 = load ptr, ptr %705, align 8, !tbaa !17
  %707 = getelementptr inbounds %struct.PropertyStr, ptr %706, i32 0, i32 3
  %708 = load i32, ptr %707, align 8, !tbaa !29
  %709 = load ptr, ptr %10, align 8, !tbaa !5
  %710 = call double @HBEnergyChange(ptr noundef %703, i32 noundef %708, ptr noundef @.str.21, ptr noundef %709)
  %711 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 0
  store double %710, ptr %711, align 16, !tbaa !13
  %712 = load ptr, ptr %7, align 8, !tbaa !5
  %713 = load ptr, ptr %6, align 8, !tbaa !5
  %714 = getelementptr inbounds %struct.AtomStr, ptr %713, i32 0, i32 0
  %715 = load ptr, ptr %714, align 8, !tbaa !17
  %716 = getelementptr inbounds %struct.PropertyStr, ptr %715, i32 0, i32 3
  %717 = load i32, ptr %716, align 8, !tbaa !29
  %718 = load ptr, ptr %10, align 8, !tbaa !5
  %719 = call double @HBEnergyChange(ptr noundef %712, i32 noundef %717, ptr noundef @.str.21, ptr noundef %718)
  %720 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 1
  store double %719, ptr %720, align 8, !tbaa !13
  %721 = load ptr, ptr %6, align 8, !tbaa !5
  %722 = load ptr, ptr %7, align 8, !tbaa !5
  %723 = getelementptr inbounds %struct.AtomStr, ptr %722, i32 0, i32 0
  %724 = load ptr, ptr %723, align 8, !tbaa !17
  %725 = getelementptr inbounds %struct.PropertyStr, ptr %724, i32 0, i32 3
  %726 = load i32, ptr %725, align 8, !tbaa !29
  %727 = load ptr, ptr %10, align 8, !tbaa !5
  %728 = call double @HBEnergyChange(ptr noundef %721, i32 noundef %726, ptr noundef @.str.22, ptr noundef %727)
  %729 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 2
  store double %728, ptr %729, align 16, !tbaa !13
  %730 = load ptr, ptr %7, align 8, !tbaa !5
  %731 = load ptr, ptr %6, align 8, !tbaa !5
  %732 = getelementptr inbounds %struct.AtomStr, ptr %731, i32 0, i32 0
  %733 = load ptr, ptr %732, align 8, !tbaa !17
  %734 = getelementptr inbounds %struct.PropertyStr, ptr %733, i32 0, i32 3
  %735 = load i32, ptr %734, align 8, !tbaa !29
  %736 = load ptr, ptr %10, align 8, !tbaa !5
  %737 = call double @HBEnergyChange(ptr noundef %730, i32 noundef %735, ptr noundef @.str.22, ptr noundef %736)
  %738 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 3
  store double %737, ptr %738, align 8, !tbaa !13
  %739 = load ptr, ptr %9, align 8, !tbaa !5
  %740 = load ptr, ptr %6, align 8, !tbaa !5
  %741 = load double, ptr %35, align 8, !tbaa !13
  %742 = load double, ptr %31, align 8, !tbaa !13
  %743 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 4
  %744 = load ptr, ptr %7, align 8, !tbaa !5
  %745 = call i32 @FindPair(ptr noundef %739, ptr noundef %740, ptr noundef @.str.23, double noundef %741, double noundef %742, ptr noundef %16, ptr noundef %16, ptr noundef %25, ptr noundef %26, ptr noundef %743, ptr noundef %744, i32 noundef 0)
  %746 = load ptr, ptr %8, align 8, !tbaa !5
  %747 = load ptr, ptr %7, align 8, !tbaa !5
  %748 = load double, ptr %35, align 8, !tbaa !13
  %749 = load double, ptr %33, align 8, !tbaa !13
  %750 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 5
  %751 = load ptr, ptr %6, align 8, !tbaa !5
  %752 = call i32 @FindPair(ptr noundef %746, ptr noundef %747, ptr noundef @.str.23, double noundef %748, double noundef %749, ptr noundef %16, ptr noundef %16, ptr noundef %25, ptr noundef %26, ptr noundef %750, ptr noundef %751, i32 noundef 0)
  %753 = load ptr, ptr %6, align 8, !tbaa !5
  %754 = getelementptr inbounds %struct.AtomStr, ptr %753, i32 0, i32 1
  %755 = load ptr, ptr %754, align 8, !tbaa !11
  %756 = getelementptr inbounds %struct.DynamicStr, ptr %755, i32 0, i32 5
  %757 = getelementptr inbounds %struct.InteractionEventStr, ptr %756, i32 0, i32 6
  %758 = load i32, ptr %757, align 4, !tbaa !28
  %759 = icmp eq i32 %758, 6
  br i1 %759, label %760, label %785

760:                                              ; preds = %636
  %761 = load ptr, ptr %6, align 8, !tbaa !5
  %762 = load ptr, ptr %7, align 8, !tbaa !5
  %763 = call double @HBBarrier(ptr noundef %761, ptr noundef %762)
  %764 = load double, ptr %18, align 8, !tbaa !13
  %765 = fsub double %764, %763
  store double %765, ptr %18, align 8, !tbaa !13
  %766 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 2
  %767 = load double, ptr %766, align 16, !tbaa !13
  %768 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 0
  %769 = load double, ptr %768, align 16, !tbaa !13
  %770 = fsub double %767, %769
  %771 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 3
  %772 = load double, ptr %771, align 8, !tbaa !13
  %773 = fadd double %770, %772
  %774 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 1
  %775 = load double, ptr %774, align 8, !tbaa !13
  %776 = fsub double %773, %775
  %777 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 4
  %778 = load double, ptr %777, align 16, !tbaa !13
  %779 = fadd double %776, %778
  %780 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 5
  %781 = load double, ptr %780, align 8, !tbaa !13
  %782 = fadd double %779, %781
  %783 = load double, ptr %18, align 8, !tbaa !13
  %784 = fadd double %783, %782
  store double %784, ptr %18, align 8, !tbaa !13
  br label %821

785:                                              ; preds = %636
  %786 = load ptr, ptr %6, align 8, !tbaa !5
  %787 = getelementptr inbounds %struct.AtomStr, ptr %786, i32 0, i32 1
  %788 = load ptr, ptr %787, align 8, !tbaa !11
  %789 = getelementptr inbounds %struct.DynamicStr, ptr %788, i32 0, i32 5
  %790 = getelementptr inbounds %struct.InteractionEventStr, ptr %789, i32 0, i32 6
  %791 = load i32, ptr %790, align 4, !tbaa !28
  %792 = icmp eq i32 %791, 7
  br i1 %792, label %793, label %818

793:                                              ; preds = %785
  %794 = load ptr, ptr %6, align 8, !tbaa !5
  %795 = load ptr, ptr %7, align 8, !tbaa !5
  %796 = call double @HBBarrier(ptr noundef %794, ptr noundef %795)
  %797 = load double, ptr %18, align 8, !tbaa !13
  %798 = fadd double %797, %796
  store double %798, ptr %18, align 8, !tbaa !13
  %799 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 0
  %800 = load double, ptr %799, align 16, !tbaa !13
  %801 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 2
  %802 = load double, ptr %801, align 16, !tbaa !13
  %803 = fsub double %800, %802
  %804 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 1
  %805 = load double, ptr %804, align 8, !tbaa !13
  %806 = fadd double %803, %805
  %807 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 3
  %808 = load double, ptr %807, align 8, !tbaa !13
  %809 = fsub double %806, %808
  %810 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 4
  %811 = load double, ptr %810, align 16, !tbaa !13
  %812 = fsub double %809, %811
  %813 = getelementptr inbounds [6 x double], ptr %34, i64 0, i64 5
  %814 = load double, ptr %813, align 8, !tbaa !13
  %815 = fsub double %812, %814
  %816 = load double, ptr %18, align 8, !tbaa !13
  %817 = fadd double %816, %815
  store double %817, ptr %18, align 8, !tbaa !13
  br label %820

818:                                              ; preds = %785
  %819 = call i32 (ptr, ...) @printf(ptr noundef @.str.24)
  call void @exit(i32 noundef 1) #9
  unreachable

820:                                              ; preds = %793
  br label %821

821:                                              ; preds = %820, %760
  %822 = load double, ptr %18, align 8, !tbaa !13
  %823 = fcmp olt double %822, -5.000000e+07
  br i1 %823, label %824, label %838

824:                                              ; preds = %821
  %825 = load ptr, ptr %6, align 8, !tbaa !5
  %826 = getelementptr inbounds %struct.AtomStr, ptr %825, i32 0, i32 1
  %827 = load ptr, ptr %826, align 8, !tbaa !11
  %828 = getelementptr inbounds %struct.DynamicStr, ptr %827, i32 0, i32 5
  %829 = getelementptr inbounds %struct.InteractionEventStr, ptr %828, i32 0, i32 6
  %830 = load i32, ptr %829, align 4, !tbaa !28
  %831 = icmp eq i32 %830, 7
  br i1 %831, label %832, label %838

832:                                              ; preds = %824
  %833 = load ptr, ptr %6, align 8, !tbaa !5
  %834 = getelementptr inbounds %struct.AtomStr, ptr %833, i32 0, i32 1
  %835 = load ptr, ptr %834, align 8, !tbaa !11
  %836 = getelementptr inbounds %struct.DynamicStr, ptr %835, i32 0, i32 3
  %837 = getelementptr inbounds %struct.HBStr, ptr %836, i32 0, i32 3
  store i32 3, ptr %837, align 4, !tbaa !30
  store i32 1, ptr %36, align 4
  br label %948

838:                                              ; preds = %824, %821
  %839 = load double, ptr %18, align 8, !tbaa !13
  %840 = fcmp ogt double %839, 5.000000e+07
  br i1 %840, label %841, label %855

841:                                              ; preds = %838
  %842 = load ptr, ptr %6, align 8, !tbaa !5
  %843 = getelementptr inbounds %struct.AtomStr, ptr %842, i32 0, i32 1
  %844 = load ptr, ptr %843, align 8, !tbaa !11
  %845 = getelementptr inbounds %struct.DynamicStr, ptr %844, i32 0, i32 5
  %846 = getelementptr inbounds %struct.InteractionEventStr, ptr %845, i32 0, i32 6
  %847 = load i32, ptr %846, align 4, !tbaa !28
  %848 = icmp eq i32 %847, 6
  br i1 %848, label %849, label %855

849:                                              ; preds = %841
  %850 = load ptr, ptr %6, align 8, !tbaa !5
  %851 = getelementptr inbounds %struct.AtomStr, ptr %850, i32 0, i32 1
  %852 = load ptr, ptr %851, align 8, !tbaa !11
  %853 = getelementptr inbounds %struct.DynamicStr, ptr %852, i32 0, i32 3
  %854 = getelementptr inbounds %struct.HBStr, ptr %853, i32 0, i32 3
  store i32 3, ptr %854, align 4, !tbaa !30
  store i32 1, ptr %36, align 4
  br label %948

855:                                              ; preds = %841, %838
  br label %856

856:                                              ; preds = %855
  %857 = load double, ptr %13, align 8, !tbaa !13
  %858 = load double, ptr %13, align 8, !tbaa !13
  %859 = load double, ptr %20, align 8, !tbaa !13
  %860 = fmul double 2.000000e+00, %859
  %861 = load double, ptr %18, align 8, !tbaa !13
  %862 = fmul double %860, %861
  %863 = load double, ptr %19, align 8, !tbaa !13
  %864 = fdiv double %862, %863
  %865 = fneg double %864
  %866 = call double @llvm.fmuladd.f64(double %857, double %858, double %865)
  %867 = fcmp ogt double %866, 0.000000e+00
  br i1 %867, label %868, label %910

868:                                              ; preds = %856
  %869 = load ptr, ptr %6, align 8, !tbaa !5
  %870 = getelementptr inbounds %struct.AtomStr, ptr %869, i32 0, i32 1
  %871 = load ptr, ptr %870, align 8, !tbaa !11
  %872 = getelementptr inbounds %struct.DynamicStr, ptr %871, i32 0, i32 5
  %873 = getelementptr inbounds %struct.InteractionEventStr, ptr %872, i32 0, i32 6
  %874 = load i32, ptr %873, align 4, !tbaa !28
  %875 = icmp eq i32 %874, 6
  br i1 %875, label %876, label %887

876:                                              ; preds = %868
  %877 = load ptr, ptr %6, align 8, !tbaa !5
  %878 = getelementptr inbounds %struct.AtomStr, ptr %877, i32 0, i32 1
  %879 = load ptr, ptr %878, align 8, !tbaa !11
  %880 = getelementptr inbounds %struct.DynamicStr, ptr %879, i32 0, i32 5
  %881 = getelementptr inbounds %struct.InteractionEventStr, ptr %880, i32 0, i32 6
  store i32 2, ptr %881, align 4, !tbaa !28
  %882 = load ptr, ptr %6, align 8, !tbaa !5
  %883 = getelementptr inbounds %struct.AtomStr, ptr %882, i32 0, i32 1
  %884 = load ptr, ptr %883, align 8, !tbaa !11
  %885 = getelementptr inbounds %struct.DynamicStr, ptr %884, i32 0, i32 3
  %886 = getelementptr inbounds %struct.HBStr, ptr %885, i32 0, i32 3
  store i32 1, ptr %886, align 4, !tbaa !30
  br label %909

887:                                              ; preds = %868
  %888 = load ptr, ptr %6, align 8, !tbaa !5
  %889 = getelementptr inbounds %struct.AtomStr, ptr %888, i32 0, i32 1
  %890 = load ptr, ptr %889, align 8, !tbaa !11
  %891 = getelementptr inbounds %struct.DynamicStr, ptr %890, i32 0, i32 5
  %892 = getelementptr inbounds %struct.InteractionEventStr, ptr %891, i32 0, i32 6
  %893 = load i32, ptr %892, align 4, !tbaa !28
  %894 = icmp eq i32 %893, 7
  br i1 %894, label %895, label %906

895:                                              ; preds = %887
  %896 = load ptr, ptr %6, align 8, !tbaa !5
  %897 = getelementptr inbounds %struct.AtomStr, ptr %896, i32 0, i32 1
  %898 = load ptr, ptr %897, align 8, !tbaa !11
  %899 = getelementptr inbounds %struct.DynamicStr, ptr %898, i32 0, i32 5
  %900 = getelementptr inbounds %struct.InteractionEventStr, ptr %899, i32 0, i32 6
  store i32 3, ptr %900, align 4, !tbaa !28
  %901 = load ptr, ptr %6, align 8, !tbaa !5
  %902 = getelementptr inbounds %struct.AtomStr, ptr %901, i32 0, i32 1
  %903 = load ptr, ptr %902, align 8, !tbaa !11
  %904 = getelementptr inbounds %struct.DynamicStr, ptr %903, i32 0, i32 3
  %905 = getelementptr inbounds %struct.HBStr, ptr %904, i32 0, i32 3
  store i32 2, ptr %905, align 4, !tbaa !30
  br label %908

906:                                              ; preds = %887
  %907 = call i32 (ptr, ...) @printf(ptr noundef @.str.25, ptr noundef @.str.1, i32 noundef 924)
  call void @exit(i32 noundef 1) #9
  unreachable

908:                                              ; preds = %895
  br label %909

909:                                              ; preds = %908, %876
  br label %947

910:                                              ; preds = %856
  %911 = load ptr, ptr %6, align 8, !tbaa !5
  %912 = getelementptr inbounds %struct.AtomStr, ptr %911, i32 0, i32 1
  %913 = load ptr, ptr %912, align 8, !tbaa !11
  %914 = getelementptr inbounds %struct.DynamicStr, ptr %913, i32 0, i32 5
  %915 = getelementptr inbounds %struct.InteractionEventStr, ptr %914, i32 0, i32 6
  %916 = load i32, ptr %915, align 4, !tbaa !28
  %917 = icmp eq i32 %916, 6
  br i1 %917, label %918, label %924

918:                                              ; preds = %910
  %919 = load ptr, ptr %6, align 8, !tbaa !5
  %920 = getelementptr inbounds %struct.AtomStr, ptr %919, i32 0, i32 1
  %921 = load ptr, ptr %920, align 8, !tbaa !11
  %922 = getelementptr inbounds %struct.DynamicStr, ptr %921, i32 0, i32 3
  %923 = getelementptr inbounds %struct.HBStr, ptr %922, i32 0, i32 3
  store i32 3, ptr %923, align 4, !tbaa !30
  store i32 1, ptr %36, align 4
  br label %948

924:                                              ; preds = %910
  %925 = load ptr, ptr %6, align 8, !tbaa !5
  %926 = getelementptr inbounds %struct.AtomStr, ptr %925, i32 0, i32 1
  %927 = load ptr, ptr %926, align 8, !tbaa !11
  %928 = getelementptr inbounds %struct.DynamicStr, ptr %927, i32 0, i32 5
  %929 = getelementptr inbounds %struct.InteractionEventStr, ptr %928, i32 0, i32 6
  %930 = load i32, ptr %929, align 4, !tbaa !28
  %931 = icmp eq i32 %930, 7
  br i1 %931, label %932, label %943

932:                                              ; preds = %924
  store double 0.000000e+00, ptr %18, align 8, !tbaa !13
  %933 = load ptr, ptr %6, align 8, !tbaa !5
  %934 = getelementptr inbounds %struct.AtomStr, ptr %933, i32 0, i32 1
  %935 = load ptr, ptr %934, align 8, !tbaa !11
  %936 = getelementptr inbounds %struct.DynamicStr, ptr %935, i32 0, i32 5
  %937 = getelementptr inbounds %struct.InteractionEventStr, ptr %936, i32 0, i32 6
  store i32 1, ptr %937, align 4, !tbaa !28
  %938 = load ptr, ptr %6, align 8, !tbaa !5
  %939 = getelementptr inbounds %struct.AtomStr, ptr %938, i32 0, i32 1
  %940 = load ptr, ptr %939, align 8, !tbaa !11
  %941 = getelementptr inbounds %struct.DynamicStr, ptr %940, i32 0, i32 3
  %942 = getelementptr inbounds %struct.HBStr, ptr %941, i32 0, i32 3
  store i32 0, ptr %942, align 4, !tbaa !30
  br label %945

943:                                              ; preds = %924
  %944 = call i32 (ptr, ...) @printf(ptr noundef @.str.25, ptr noundef @.str.1, i32 noundef 939)
  call void @exit(i32 noundef 1) #9
  unreachable

945:                                              ; preds = %932
  br label %946

946:                                              ; preds = %945
  br label %947

947:                                              ; preds = %946, %909
  store i32 0, ptr %36, align 4
  br label %948

948:                                              ; preds = %947, %918, %849, %832, %385
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #8
  call void @llvm.lifetime.end.p0(i64 48, ptr %34) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #8
  call void @llvm.lifetime.end.p0(i64 32, ptr %32) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %31) #8
  call void @llvm.lifetime.end.p0(i64 32, ptr %30) #8
  call void @llvm.lifetime.end.p0(i64 32, ptr %29) #8
  call void @llvm.lifetime.end.p0(i64 32, ptr %28) #8
  %949 = load i32, ptr %36, align 4
  switch i32 %949, label %1208 [
    i32 0, label %950
  ]

950:                                              ; preds = %948
  br label %951

951:                                              ; preds = %950, %329
  %952 = load ptr, ptr %6, align 8, !tbaa !5
  %953 = getelementptr inbounds %struct.AtomStr, ptr %952, i32 0, i32 1
  %954 = load ptr, ptr %953, align 8, !tbaa !11
  %955 = getelementptr inbounds %struct.DynamicStr, ptr %954, i32 0, i32 5
  %956 = getelementptr inbounds %struct.InteractionEventStr, ptr %955, i32 0, i32 6
  %957 = load i32, ptr %956, align 4, !tbaa !28
  switch i32 %957, label %1012 [
    i32 0, label %958
    i32 1, label %959
    i32 2, label %965
    i32 3, label %966
    i32 4, label %972
    i32 5, label %987
  ]

958:                                              ; preds = %951
  store i32 1, ptr %11, align 4, !tbaa !9
  store double 0.000000e+00, ptr %18, align 8, !tbaa !13
  br label %1014

959:                                              ; preds = %951
  %960 = load double, ptr %13, align 8, !tbaa !13
  %961 = fcmp olt double %960, 0.000000e+00
  br i1 %961, label %962, label %963

962:                                              ; preds = %959
  store i32 1, ptr %11, align 4, !tbaa !9
  br label %964

963:                                              ; preds = %959
  store i32 -1, ptr %11, align 4, !tbaa !9
  br label %964

964:                                              ; preds = %963, %962
  store double 0.000000e+00, ptr %18, align 8, !tbaa !13
  br label %1014

965:                                              ; preds = %951
  store i32 -1, ptr %11, align 4, !tbaa !9
  br label %1014

966:                                              ; preds = %951
  %967 = load double, ptr %13, align 8, !tbaa !13
  %968 = fcmp olt double %967, 0.000000e+00
  br i1 %968, label %969, label %970

969:                                              ; preds = %966
  store i32 -1, ptr %11, align 4, !tbaa !9
  br label %971

970:                                              ; preds = %966
  store i32 1, ptr %11, align 4, !tbaa !9
  br label %971

971:                                              ; preds = %970, %969
  br label %1014

972:                                              ; preds = %951
  %973 = load double, ptr %13, align 8, !tbaa !13
  %974 = load double, ptr %13, align 8, !tbaa !13
  %975 = load double, ptr %20, align 8, !tbaa !13
  %976 = fmul double 2.000000e+00, %975
  %977 = load double, ptr %18, align 8, !tbaa !13
  %978 = fmul double %976, %977
  %979 = load double, ptr %19, align 8, !tbaa !13
  %980 = fdiv double %978, %979
  %981 = fneg double %980
  %982 = call double @llvm.fmuladd.f64(double %973, double %974, double %981)
  %983 = fcmp ole double %982, 0.000000e+00
  br i1 %983, label %984, label %985

984:                                              ; preds = %972
  store double 0.000000e+00, ptr %18, align 8, !tbaa !13
  store i32 1, ptr %11, align 4, !tbaa !9
  br label %986

985:                                              ; preds = %972
  store i32 -1, ptr %11, align 4, !tbaa !9
  br label %986

986:                                              ; preds = %985, %984
  br label %1014

987:                                              ; preds = %951
  %988 = load double, ptr %13, align 8, !tbaa !13
  %989 = load double, ptr %13, align 8, !tbaa !13
  %990 = load double, ptr %20, align 8, !tbaa !13
  %991 = fmul double 2.000000e+00, %990
  %992 = load double, ptr %18, align 8, !tbaa !13
  %993 = fmul double %991, %992
  %994 = load double, ptr %19, align 8, !tbaa !13
  %995 = fdiv double %993, %994
  %996 = fneg double %995
  %997 = call double @llvm.fmuladd.f64(double %988, double %989, double %996)
  %998 = fcmp ole double %997, 0.000000e+00
  br i1 %998, label %999, label %1005

999:                                              ; preds = %987
  store double 0.000000e+00, ptr %18, align 8, !tbaa !13
  %1000 = load double, ptr %13, align 8, !tbaa !13
  %1001 = fcmp olt double %1000, 0.000000e+00
  br i1 %1001, label %1002, label %1003

1002:                                             ; preds = %999
  store i32 1, ptr %11, align 4, !tbaa !9
  br label %1004

1003:                                             ; preds = %999
  store i32 -1, ptr %11, align 4, !tbaa !9
  br label %1004

1004:                                             ; preds = %1003, %1002
  br label %1011

1005:                                             ; preds = %987
  %1006 = load double, ptr %13, align 8, !tbaa !13
  %1007 = fcmp olt double %1006, 0.000000e+00
  br i1 %1007, label %1008, label %1009

1008:                                             ; preds = %1005
  store i32 -1, ptr %11, align 4, !tbaa !9
  br label %1010

1009:                                             ; preds = %1005
  store i32 1, ptr %11, align 4, !tbaa !9
  br label %1010

1010:                                             ; preds = %1009, %1008
  br label %1011

1011:                                             ; preds = %1010, %1004
  br label %1014

1012:                                             ; preds = %951
  %1013 = call i32 (ptr, ...) @printf(ptr noundef @.str.26)
  call void @exit(i32 noundef 1) #9
  unreachable

1014:                                             ; preds = %1011, %986, %971, %965, %964, %958
  %1015 = load double, ptr %13, align 8, !tbaa !13
  %1016 = load i32, ptr %11, align 4, !tbaa !9
  %1017 = sitofp i32 %1016 to double
  %1018 = load double, ptr %13, align 8, !tbaa !13
  %1019 = load double, ptr %13, align 8, !tbaa !13
  %1020 = load double, ptr %20, align 8, !tbaa !13
  %1021 = fmul double 2.000000e+00, %1020
  %1022 = load double, ptr %18, align 8, !tbaa !13
  %1023 = fmul double %1021, %1022
  %1024 = load double, ptr %19, align 8, !tbaa !13
  %1025 = fdiv double %1023, %1024
  %1026 = fneg double %1025
  %1027 = call double @llvm.fmuladd.f64(double %1018, double %1019, double %1026)
  %1028 = call double @sqrt(double noundef %1027) #8
  %1029 = fmul double %1017, %1028
  %1030 = call double @llvm.fmuladd.f64(double -1.000000e+00, double %1015, double %1029)
  %1031 = load ptr, ptr %6, align 8, !tbaa !5
  %1032 = getelementptr inbounds %struct.AtomStr, ptr %1031, i32 0, i32 0
  %1033 = load ptr, ptr %1032, align 8, !tbaa !17
  %1034 = getelementptr inbounds %struct.PropertyStr, ptr %1033, i32 0, i32 7
  %1035 = load double, ptr %1034, align 8, !tbaa !18
  %1036 = load ptr, ptr %7, align 8, !tbaa !5
  %1037 = getelementptr inbounds %struct.AtomStr, ptr %1036, i32 0, i32 0
  %1038 = load ptr, ptr %1037, align 8, !tbaa !17
  %1039 = getelementptr inbounds %struct.PropertyStr, ptr %1038, i32 0, i32 7
  %1040 = load double, ptr %1039, align 8, !tbaa !18
  %1041 = fadd double %1035, %1040
  %1042 = load double, ptr %20, align 8, !tbaa !13
  %1043 = fmul double %1041, %1042
  %1044 = fdiv double %1030, %1043
  store double %1044, ptr %17, align 8, !tbaa !13
  %1045 = load double, ptr %17, align 8, !tbaa !13
  %1046 = call i1 @llvm.is.fpclass.f64(double %1045, i32 3)
  %1047 = xor i1 %1046, true
  %1048 = xor i1 %1047, true
  %1049 = zext i1 %1048 to i32
  %1050 = sext i32 %1049 to i64
  %1051 = call i64 @llvm.expect.i64(i64 %1050, i64 0)
  %1052 = icmp ne i64 %1051, 0
  br i1 %1052, label %1053, label %1055

1053:                                             ; preds = %1014
  %1054 = call i32 (ptr, ...) @printf(ptr noundef @.str.17, ptr noundef @.str.1, i32 noundef 1009)
  call void @exit(i32 noundef 1) #9
  unreachable

1055:                                             ; preds = %1014
  %1056 = load ptr, ptr %6, align 8, !tbaa !5
  %1057 = getelementptr inbounds %struct.AtomStr, ptr %1056, i32 0, i32 0
  %1058 = load ptr, ptr %1057, align 8, !tbaa !17
  %1059 = getelementptr inbounds %struct.PropertyStr, ptr %1058, i32 0, i32 1
  %1060 = getelementptr inbounds [2 x [16 x i8]], ptr %1059, i64 0, i64 1
  %1061 = getelementptr inbounds [16 x i8], ptr %1060, i64 0, i64 0
  %1062 = call i32 @strcmp(ptr noundef %1061, ptr noundef @.str.27) #10
  %1063 = icmp ne i32 %1062, 0
  br i1 %1063, label %1064, label %1131

1064:                                             ; preds = %1055
  %1065 = load ptr, ptr %7, align 8, !tbaa !5
  %1066 = getelementptr inbounds %struct.AtomStr, ptr %1065, i32 0, i32 0
  %1067 = load ptr, ptr %1066, align 8, !tbaa !17
  %1068 = getelementptr inbounds %struct.PropertyStr, ptr %1067, i32 0, i32 7
  %1069 = load double, ptr %1068, align 8, !tbaa !18
  %1070 = load double, ptr %17, align 8, !tbaa !13
  %1071 = fmul double %1069, %1070
  %1072 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 1
  %1073 = load double, ptr %1072, align 8, !tbaa !13
  %1074 = fmul double %1071, %1073
  %1075 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 1
  store double %1074, ptr %1075, align 8, !tbaa !13
  %1076 = load ptr, ptr %7, align 8, !tbaa !5
  %1077 = getelementptr inbounds %struct.AtomStr, ptr %1076, i32 0, i32 0
  %1078 = load ptr, ptr %1077, align 8, !tbaa !17
  %1079 = getelementptr inbounds %struct.PropertyStr, ptr %1078, i32 0, i32 7
  %1080 = load double, ptr %1079, align 8, !tbaa !18
  %1081 = load double, ptr %17, align 8, !tbaa !13
  %1082 = fmul double %1080, %1081
  %1083 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 2
  %1084 = load double, ptr %1083, align 16, !tbaa !13
  %1085 = fmul double %1082, %1084
  %1086 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 2
  store double %1085, ptr %1086, align 16, !tbaa !13
  %1087 = load ptr, ptr %7, align 8, !tbaa !5
  %1088 = getelementptr inbounds %struct.AtomStr, ptr %1087, i32 0, i32 0
  %1089 = load ptr, ptr %1088, align 8, !tbaa !17
  %1090 = getelementptr inbounds %struct.PropertyStr, ptr %1089, i32 0, i32 7
  %1091 = load double, ptr %1090, align 8, !tbaa !18
  %1092 = load double, ptr %17, align 8, !tbaa !13
  %1093 = fmul double %1091, %1092
  %1094 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 3
  %1095 = load double, ptr %1094, align 8, !tbaa !13
  %1096 = fmul double %1093, %1095
  %1097 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 3
  store double %1096, ptr %1097, align 8, !tbaa !13
  %1098 = load ptr, ptr %21, align 8, !tbaa !5
  %1099 = getelementptr inbounds double, ptr %1098, i64 1
  %1100 = load double, ptr %1099, align 8, !tbaa !13
  %1101 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 1
  %1102 = load double, ptr %1101, align 8, !tbaa !13
  %1103 = fadd double %1100, %1102
  %1104 = load ptr, ptr %6, align 8, !tbaa !5
  %1105 = getelementptr inbounds %struct.AtomStr, ptr %1104, i32 0, i32 1
  %1106 = load ptr, ptr %1105, align 8, !tbaa !11
  %1107 = getelementptr inbounds %struct.DynamicStr, ptr %1106, i32 0, i32 2
  %1108 = getelementptr inbounds [4 x double], ptr %1107, i64 0, i64 1
  store double %1103, ptr %1108, align 8, !tbaa !13
  %1109 = load ptr, ptr %21, align 8, !tbaa !5
  %1110 = getelementptr inbounds double, ptr %1109, i64 2
  %1111 = load double, ptr %1110, align 8, !tbaa !13
  %1112 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 2
  %1113 = load double, ptr %1112, align 16, !tbaa !13
  %1114 = fadd double %1111, %1113
  %1115 = load ptr, ptr %6, align 8, !tbaa !5
  %1116 = getelementptr inbounds %struct.AtomStr, ptr %1115, i32 0, i32 1
  %1117 = load ptr, ptr %1116, align 8, !tbaa !11
  %1118 = getelementptr inbounds %struct.DynamicStr, ptr %1117, i32 0, i32 2
  %1119 = getelementptr inbounds [4 x double], ptr %1118, i64 0, i64 2
  store double %1114, ptr %1119, align 8, !tbaa !13
  %1120 = load ptr, ptr %21, align 8, !tbaa !5
  %1121 = getelementptr inbounds double, ptr %1120, i64 3
  %1122 = load double, ptr %1121, align 8, !tbaa !13
  %1123 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 3
  %1124 = load double, ptr %1123, align 8, !tbaa !13
  %1125 = fadd double %1122, %1124
  %1126 = load ptr, ptr %6, align 8, !tbaa !5
  %1127 = getelementptr inbounds %struct.AtomStr, ptr %1126, i32 0, i32 1
  %1128 = load ptr, ptr %1127, align 8, !tbaa !11
  %1129 = getelementptr inbounds %struct.DynamicStr, ptr %1128, i32 0, i32 2
  %1130 = getelementptr inbounds [4 x double], ptr %1129, i64 0, i64 3
  store double %1125, ptr %1130, align 8, !tbaa !13
  br label %1131

1131:                                             ; preds = %1064, %1055
  %1132 = load ptr, ptr %7, align 8, !tbaa !5
  %1133 = getelementptr inbounds %struct.AtomStr, ptr %1132, i32 0, i32 0
  %1134 = load ptr, ptr %1133, align 8, !tbaa !17
  %1135 = getelementptr inbounds %struct.PropertyStr, ptr %1134, i32 0, i32 1
  %1136 = getelementptr inbounds [2 x [16 x i8]], ptr %1135, i64 0, i64 1
  %1137 = getelementptr inbounds [16 x i8], ptr %1136, i64 0, i64 0
  %1138 = call i32 @strcmp(ptr noundef %1137, ptr noundef @.str.27) #10
  %1139 = icmp ne i32 %1138, 0
  br i1 %1139, label %1140, label %1207

1140:                                             ; preds = %1131
  %1141 = load ptr, ptr %6, align 8, !tbaa !5
  %1142 = getelementptr inbounds %struct.AtomStr, ptr %1141, i32 0, i32 0
  %1143 = load ptr, ptr %1142, align 8, !tbaa !17
  %1144 = getelementptr inbounds %struct.PropertyStr, ptr %1143, i32 0, i32 7
  %1145 = load double, ptr %1144, align 8, !tbaa !18
  %1146 = load double, ptr %17, align 8, !tbaa !13
  %1147 = fmul double %1145, %1146
  %1148 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 1
  %1149 = load double, ptr %1148, align 8, !tbaa !13
  %1150 = fmul double %1147, %1149
  %1151 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 1
  store double %1150, ptr %1151, align 8, !tbaa !13
  %1152 = load ptr, ptr %6, align 8, !tbaa !5
  %1153 = getelementptr inbounds %struct.AtomStr, ptr %1152, i32 0, i32 0
  %1154 = load ptr, ptr %1153, align 8, !tbaa !17
  %1155 = getelementptr inbounds %struct.PropertyStr, ptr %1154, i32 0, i32 7
  %1156 = load double, ptr %1155, align 8, !tbaa !18
  %1157 = load double, ptr %17, align 8, !tbaa !13
  %1158 = fmul double %1156, %1157
  %1159 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 2
  %1160 = load double, ptr %1159, align 16, !tbaa !13
  %1161 = fmul double %1158, %1160
  %1162 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 2
  store double %1161, ptr %1162, align 16, !tbaa !13
  %1163 = load ptr, ptr %6, align 8, !tbaa !5
  %1164 = getelementptr inbounds %struct.AtomStr, ptr %1163, i32 0, i32 0
  %1165 = load ptr, ptr %1164, align 8, !tbaa !17
  %1166 = getelementptr inbounds %struct.PropertyStr, ptr %1165, i32 0, i32 7
  %1167 = load double, ptr %1166, align 8, !tbaa !18
  %1168 = load double, ptr %17, align 8, !tbaa !13
  %1169 = fmul double %1167, %1168
  %1170 = getelementptr inbounds [4 x double], ptr %14, i64 0, i64 3
  %1171 = load double, ptr %1170, align 8, !tbaa !13
  %1172 = fmul double %1169, %1171
  %1173 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 3
  store double %1172, ptr %1173, align 8, !tbaa !13
  %1174 = load ptr, ptr %22, align 8, !tbaa !5
  %1175 = getelementptr inbounds double, ptr %1174, i64 1
  %1176 = load double, ptr %1175, align 8, !tbaa !13
  %1177 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 1
  %1178 = load double, ptr %1177, align 8, !tbaa !13
  %1179 = fsub double %1176, %1178
  %1180 = load ptr, ptr %7, align 8, !tbaa !5
  %1181 = getelementptr inbounds %struct.AtomStr, ptr %1180, i32 0, i32 1
  %1182 = load ptr, ptr %1181, align 8, !tbaa !11
  %1183 = getelementptr inbounds %struct.DynamicStr, ptr %1182, i32 0, i32 2
  %1184 = getelementptr inbounds [4 x double], ptr %1183, i64 0, i64 1
  store double %1179, ptr %1184, align 8, !tbaa !13
  %1185 = load ptr, ptr %22, align 8, !tbaa !5
  %1186 = getelementptr inbounds double, ptr %1185, i64 2
  %1187 = load double, ptr %1186, align 8, !tbaa !13
  %1188 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 2
  %1189 = load double, ptr %1188, align 16, !tbaa !13
  %1190 = fsub double %1187, %1189
  %1191 = load ptr, ptr %7, align 8, !tbaa !5
  %1192 = getelementptr inbounds %struct.AtomStr, ptr %1191, i32 0, i32 1
  %1193 = load ptr, ptr %1192, align 8, !tbaa !11
  %1194 = getelementptr inbounds %struct.DynamicStr, ptr %1193, i32 0, i32 2
  %1195 = getelementptr inbounds [4 x double], ptr %1194, i64 0, i64 2
  store double %1190, ptr %1195, align 8, !tbaa !13
  %1196 = load ptr, ptr %22, align 8, !tbaa !5
  %1197 = getelementptr inbounds double, ptr %1196, i64 3
  %1198 = load double, ptr %1197, align 8, !tbaa !13
  %1199 = getelementptr inbounds [4 x double], ptr %15, i64 0, i64 3
  %1200 = load double, ptr %1199, align 8, !tbaa !13
  %1201 = fsub double %1198, %1200
  %1202 = load ptr, ptr %7, align 8, !tbaa !5
  %1203 = getelementptr inbounds %struct.AtomStr, ptr %1202, i32 0, i32 1
  %1204 = load ptr, ptr %1203, align 8, !tbaa !11
  %1205 = getelementptr inbounds %struct.DynamicStr, ptr %1204, i32 0, i32 2
  %1206 = getelementptr inbounds [4 x double], ptr %1205, i64 0, i64 3
  store double %1201, ptr %1206, align 8, !tbaa !13
  br label %1207

1207:                                             ; preds = %1140, %1131
  store i32 1, ptr %36, align 4
  br label %1208

1208:                                             ; preds = %1207, %948
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #8
  call void @llvm.lifetime.end.p0(i64 32, ptr %24) #8
  call void @llvm.lifetime.end.p0(i64 32, ptr %23) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %17) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %16) #8
  call void @llvm.lifetime.end.p0(i64 32, ptr %15) #8
  call void @llvm.lifetime.end.p0(i64 32, ptr %14) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #8
  call void @llvm.lifetime.end.p0(i64 32, ptr %12) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %11) #8
  ret void
}

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

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

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

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

; Function Attrs: nounwind willreturn memory(read)
declare i32 @strcmp(ptr noundef, ptr noundef) #5

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #6

; Function Attrs: nounwind
declare double @sqrt(double noundef) #7

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i1 @llvm.is.fpclass.f64(double, i32 immarg) #6

; Function Attrs: nounwind uwtable
declare dso_local double @HBEnergyChange(ptr noundef, i32 noundef, ptr noundef, ptr noundef) #1

declare i32 @FindPair(ptr noundef, ptr noundef, ptr noundef, double noundef, double noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, i32 noundef) #2

; Function Attrs: nounwind uwtable
declare dso_local double @HBBarrier(ptr noundef, ptr noundef) #1

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

!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 8}
!12 = !{!"AtomStr", !6, i64 0, !6, i64 8}
!13 = !{!14, !14, i64 0}
!14 = !{!"double", !7, i64 0}
!15 = distinct !{!15, !16}
!16 = !{!"llvm.loop.mustprogress"}
!17 = !{!12, !6, i64 0}
!18 = !{!19, !14, i64 72}
!19 = !{!"PropertyStr", !7, i64 0, !7, i64 8, !7, i64 40, !10, i64 48, !10, i64 52, !10, i64 56, !14, i64 64, !14, i64 72, !7, i64 80, !20, i64 104, !6, i64 120, !6, i64 128}
!20 = !{!"AtomSeqStr", !10, i64 0, !10, i64 4, !10, i64 8}
!21 = !{!22, !14, i64 160}
!22 = !{!"DynamicStr", !7, i64 0, !7, i64 16, !7, i64 48, !23, i64 80, !24, i64 96, !25, i64 128}
!23 = !{!"HBStr", !10, i64 0, !10, i64 4, !7, i64 8, !10, i64 12}
!24 = !{!"HBNeighborStr", !7, i64 0, !10, i64 20, !10, i64 24}
!25 = !{!"InteractionEventStr", !10, i64 0, !26, i64 8, !26, i64 16, !14, i64 24, !14, i64 32, !10, i64 40, !10, i64 44}
!26 = !{!"long", !7, i64 0}
!27 = !{!22, !10, i64 168}
!28 = !{!22, !10, i64 172}
!29 = !{!19, !10, i64 48}
!30 = !{!22, !10, i64 92}
!31 = distinct !{!31, !16}


; 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.1 = external hidden unnamed_addr constant [63 x i8], align 1
@cellnum = external local_unnamed_addr global [4 x i32], align 16
@boxDimension = external local_unnamed_addr global [4 x double], align 16
@connectionMap = external local_unnamed_addr global ptr, align 8
@.str.17 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.21 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [45 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [41 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [51 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [6 x i8], align 1

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

; Function Attrs: nounwind uwtable
define dso_local void @InteractionEvent(ptr noundef %0, ptr noundef %1, ptr noundef %2, ptr noundef %3, ptr noundef %4) local_unnamed_addr #1 {
  %6 = alloca double, align 8
  %7 = alloca double, align 8
  %8 = alloca double, align 8
  %9 = alloca [6 x double], align 16
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %6) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %7) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %8) #8
  %10 = getelementptr inbounds i8, ptr %0, i64 8
  %11 = load ptr, ptr %10, align 8, !tbaa !5
  %12 = getelementptr inbounds i8, ptr %11, i64 24
  %13 = load double, ptr %12, align 8, !tbaa !10
  %14 = getelementptr inbounds i8, ptr %11, i64 32
  %15 = load double, ptr %14, align 8, !tbaa !10
  %16 = getelementptr inbounds i8, ptr %11, i64 40
  %17 = load double, ptr %16, align 8, !tbaa !10
  %18 = getelementptr inbounds i8, ptr %1, i64 8
  %19 = load ptr, ptr %18, align 8, !tbaa !5
  %20 = getelementptr inbounds i8, ptr %19, i64 24
  %21 = load double, ptr %20, align 8, !tbaa !10
  %22 = getelementptr inbounds i8, ptr %19, i64 32
  %23 = load double, ptr %22, align 8, !tbaa !10
  %24 = getelementptr inbounds i8, ptr %19, i64 40
  %25 = load double, ptr %24, align 8, !tbaa !10
  %26 = getelementptr inbounds i8, ptr %11, i64 4
  %27 = load i32, ptr %26, align 4, !tbaa !12
  %28 = getelementptr inbounds i8, ptr %19, i64 4
  %29 = load i32, ptr %28, align 4, !tbaa !12
  %.not260 = icmp eq i32 %27, %29
  br i1 %.not260, label %42, label %30

30:                                               ; preds = %5
  %31 = icmp eq i32 %27, 0
  %.pre = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 4), align 4, !tbaa !12
  %32 = add nsw i32 %.pre, -1
  %33 = icmp eq i32 %29, %32
  %or.cond345 = select i1 %31, i1 %33, i1 false
  br i1 %or.cond345, label %34, label %._crit_edge

34:                                               ; preds = %30
  %35 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 8), align 8, !tbaa !10
  %36 = fsub double %21, %35
  br label %42

._crit_edge:                                      ; preds = %30
  %37 = icmp eq i32 %27, %32
  %38 = icmp eq i32 %29, 0
  %or.cond = and i1 %38, %37
  br i1 %or.cond, label %39, label %42

39:                                               ; preds = %._crit_edge
  %40 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 8), align 8, !tbaa !10
  %41 = fadd double %40, %21
  br label %42

42:                                               ; preds = %5, %._crit_edge, %39, %34
  %.sroa.3.0 = phi double [ %21, %5 ], [ %36, %34 ], [ %41, %39 ], [ %21, %._crit_edge ]
  %43 = getelementptr inbounds i8, ptr %11, i64 8
  %44 = load i32, ptr %43, align 4, !tbaa !12
  %45 = getelementptr inbounds i8, ptr %19, i64 8
  %46 = load i32, ptr %45, align 4, !tbaa !12
  %.not260.1 = icmp eq i32 %44, %46
  br i1 %.not260.1, label %59, label %47

47:                                               ; preds = %42
  %48 = icmp eq i32 %44, 0
  %.pre302 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 8), align 8, !tbaa !12
  %49 = add nsw i32 %.pre302, -1
  %50 = icmp eq i32 %46, %49
  %or.cond347 = select i1 %48, i1 %50, i1 false
  br i1 %or.cond347, label %56, label %._crit_edge318

._crit_edge318:                                   ; preds = %47
  %51 = icmp eq i32 %44, %49
  %52 = icmp eq i32 %46, 0
  %or.cond.1 = and i1 %52, %51
  br i1 %or.cond.1, label %53, label %59

53:                                               ; preds = %._crit_edge318
  %54 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 16), align 16, !tbaa !10
  %55 = fadd double %54, %23
  br label %59

56:                                               ; preds = %47
  %57 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 16), align 16, !tbaa !10
  %58 = fsub double %23, %57
  br label %59

59:                                               ; preds = %56, %53, %._crit_edge318, %42
  %.sroa.9.0 = phi double [ %23, %42 ], [ %58, %56 ], [ %55, %53 ], [ %23, %._crit_edge318 ]
  %60 = getelementptr inbounds i8, ptr %11, i64 12
  %61 = load i32, ptr %60, align 4, !tbaa !12
  %62 = getelementptr inbounds i8, ptr %19, i64 12
  %63 = load i32, ptr %62, align 4, !tbaa !12
  %.not260.2 = icmp eq i32 %61, %63
  br i1 %.not260.2, label %76, label %64

64:                                               ; preds = %59
  %65 = icmp eq i32 %61, 0
  %.pre303 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 12), align 4, !tbaa !12
  %66 = add nsw i32 %.pre303, -1
  %67 = icmp eq i32 %63, %66
  %or.cond349 = select i1 %65, i1 %67, i1 false
  br i1 %or.cond349, label %73, label %._crit_edge319

._crit_edge319:                                   ; preds = %64
  %68 = icmp eq i32 %61, %66
  %69 = icmp eq i32 %63, 0
  %or.cond.2 = and i1 %69, %68
  br i1 %or.cond.2, label %70, label %76

70:                                               ; preds = %._crit_edge319
  %71 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 24), align 8, !tbaa !10
  %72 = fadd double %71, %25
  br label %76

73:                                               ; preds = %64
  %74 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 24), align 8, !tbaa !10
  %75 = fsub double %25, %74
  br label %76

76:                                               ; preds = %73, %70, %._crit_edge319, %59
  %.sroa.15.0 = phi double [ %25, %59 ], [ %75, %73 ], [ %72, %70 ], [ %25, %._crit_edge319 ]
  %77 = fsub double %13, %.sroa.3.0
  %78 = fsub double %15, %.sroa.9.0
  %79 = fsub double %17, %.sroa.15.0
  %80 = getelementptr inbounds i8, ptr %11, i64 56
  %81 = load double, ptr %80, align 8, !tbaa !10
  %82 = getelementptr inbounds i8, ptr %19, i64 56
  %83 = load double, ptr %82, align 8, !tbaa !10
  %84 = fsub double %81, %83
  %85 = getelementptr inbounds i8, ptr %11, i64 64
  %86 = load double, ptr %85, align 8, !tbaa !10
  %87 = getelementptr inbounds i8, ptr %19, i64 64
  %88 = load double, ptr %87, align 8, !tbaa !10
  %89 = fsub double %86, %88
  %90 = getelementptr inbounds i8, ptr %11, i64 72
  %91 = load double, ptr %90, align 8, !tbaa !10
  %92 = getelementptr inbounds i8, ptr %19, i64 72
  %93 = load double, ptr %92, align 8, !tbaa !10
  %94 = fsub double %91, %93
  %95 = fmul double %78, %78
  %96 = tail call double @llvm.fmuladd.f64(double %77, double %77, double %95)
  %97 = tail call double @llvm.fmuladd.f64(double %79, double %79, double %96)
  %98 = fmul double %78, %89
  %99 = tail call double @llvm.fmuladd.f64(double %77, double %84, double %98)
  %100 = tail call double @llvm.fmuladd.f64(double %79, double %94, double %99)
  %101 = load ptr, ptr %0, align 8, !tbaa !14
  %102 = getelementptr inbounds i8, ptr %101, i64 72
  %103 = load double, ptr %102, align 8, !tbaa !15
  %104 = load ptr, ptr %1, align 8, !tbaa !14
  %105 = getelementptr inbounds i8, ptr %104, i64 72
  %106 = load double, ptr %105, align 8, !tbaa !15
  %107 = fmul double %103, %106
  %108 = fadd double %103, %106
  %109 = fdiv double %107, %108
  %110 = getelementptr inbounds i8, ptr %11, i64 160
  %111 = load double, ptr %110, align 8, !tbaa !18
  %112 = getelementptr inbounds i8, ptr %11, i64 168
  %113 = load i32, ptr %112, align 8, !tbaa !24
  %114 = icmp eq i32 %113, 2
  br i1 %114, label %115, label %.critedge

115:                                              ; preds = %76
  %116 = getelementptr inbounds i8, ptr %11, i64 172
  %117 = load i32, ptr %116, align 4, !tbaa !25
  %118 = and i32 %117, -2
  %switch = icmp eq i32 %118, 6
  br i1 %switch, label %119, label %.critedge

119:                                              ; preds = %115
  call void @llvm.lifetime.start.p0(i64 48, ptr nonnull %9) #8
  %120 = load ptr, ptr @connectionMap, align 8, !tbaa !26
  %121 = getelementptr inbounds i8, ptr %101, i64 48
  %122 = load i32, ptr %121, align 8, !tbaa !27
  %123 = sext i32 %122 to i64
  %124 = getelementptr inbounds ptr, ptr %120, i64 %123
  %125 = load ptr, ptr %124, align 8, !tbaa !26
  %126 = load ptr, ptr %3, align 8, !tbaa !14
  %127 = getelementptr inbounds i8, ptr %126, i64 48
  %128 = load i32, ptr %127, align 8, !tbaa !27
  %129 = sext i32 %128 to i64
  %130 = getelementptr inbounds i32, ptr %125, i64 %129
  %131 = load i32, ptr %130, align 4, !tbaa !12
  %132 = and i32 %131, 8
  %.not = icmp eq i32 %132, 0
  br i1 %.not, label %133, label %147

133:                                              ; preds = %119
  %134 = getelementptr inbounds i8, ptr %104, i64 48
  %135 = load i32, ptr %134, align 8, !tbaa !27
  %136 = sext i32 %135 to i64
  %137 = getelementptr inbounds ptr, ptr %120, i64 %136
  %138 = load ptr, ptr %137, align 8, !tbaa !26
  %139 = load ptr, ptr %2, align 8, !tbaa !14
  %140 = getelementptr inbounds i8, ptr %139, i64 48
  %141 = load i32, ptr %140, align 8, !tbaa !27
  %142 = sext i32 %141 to i64
  %143 = getelementptr inbounds i32, ptr %138, i64 %142
  %144 = load i32, ptr %143, align 4, !tbaa !12
  %145 = and i32 %144, 8
  %.not255 = icmp ne i32 %145, 0
  %146 = icmp eq i32 %117, 6
  %or.cond270 = and i1 %146, %.not255
  br i1 %or.cond270, label %.thread267, label %148

147:                                              ; preds = %119
  %.old = icmp eq i32 %117, 6
  br i1 %.old, label %.thread267, label %148

148:                                              ; preds = %147, %133
  %149 = getelementptr inbounds i8, ptr %2, i64 8
  %150 = load ptr, ptr %149, align 8, !tbaa !5
  %151 = getelementptr inbounds i8, ptr %150, i64 24
  %152 = load double, ptr %151, align 8, !tbaa !10
  %153 = getelementptr inbounds i8, ptr %150, i64 32
  %154 = load double, ptr %153, align 8, !tbaa !10
  %155 = getelementptr inbounds i8, ptr %150, i64 40
  %156 = load double, ptr %155, align 8, !tbaa !10
  %157 = getelementptr inbounds i8, ptr %3, i64 8
  %158 = load ptr, ptr %157, align 8, !tbaa !5
  %159 = getelementptr inbounds i8, ptr %158, i64 24
  %160 = load double, ptr %159, align 8, !tbaa !10
  %161 = getelementptr inbounds i8, ptr %158, i64 32
  %162 = load double, ptr %161, align 8, !tbaa !10
  %163 = getelementptr inbounds i8, ptr %158, i64 40
  %164 = load double, ptr %163, align 8, !tbaa !10
  %165 = getelementptr inbounds i8, ptr %150, i64 4
  %166 = load i32, ptr %165, align 4, !tbaa !12
  %.not256 = icmp eq i32 %27, %166
  br i1 %.not256, label %176, label %167

167:                                              ; preds = %148
  %168 = icmp eq i32 %27, 0
  %.pre304 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 4), align 4, !tbaa !12
  %169 = add nsw i32 %.pre304, -1
  %170 = icmp eq i32 %166, %169
  %or.cond351 = select i1 %168, i1 %170, i1 false
  br i1 %or.cond351, label %.thread, label %._crit_edge320

._crit_edge320:                                   ; preds = %167
  %171 = icmp eq i32 %27, %169
  %172 = icmp eq i32 %166, 0
  %or.cond272 = and i1 %172, %171
  br i1 %or.cond272, label %173, label %176

173:                                              ; preds = %._crit_edge320
  %174 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 8), align 8, !tbaa !10
  %175 = fadd double %174, %152
  br label %176

176:                                              ; preds = %173, %._crit_edge320, %148
  %.sroa.4286.0 = phi double [ %152, %148 ], [ %175, %173 ], [ %152, %._crit_edge320 ]
  %177 = getelementptr inbounds i8, ptr %158, i64 4
  %178 = load i32, ptr %177, align 4, !tbaa !12
  %.not257 = icmp eq i32 %27, %178
  br i1 %.not257, label %196, label %183

.thread:                                          ; preds = %167
  %179 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 8), align 8, !tbaa !10
  %180 = fsub double %152, %179
  %181 = getelementptr inbounds i8, ptr %158, i64 4
  %182 = load i32, ptr %181, align 4, !tbaa !12
  %.not257265 = icmp eq i32 %182, 0
  br i1 %.not257265, label %196, label %.thread266

183:                                              ; preds = %176
  %184 = icmp eq i32 %27, 0
  %.pre306 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 4), align 4, !tbaa !12
  %.pre316 = add nsw i32 %.pre306, -1
  br i1 %184, label %.thread266, label %._crit_edge321

.thread266:                                       ; preds = %183, %.thread
  %.pre-phi317 = phi i32 [ %169, %.thread ], [ %.pre316, %183 ]
  %.sroa.4286.1 = phi double [ %180, %.thread ], [ %.sroa.4286.0, %183 ]
  %185 = phi i32 [ %182, %.thread ], [ %178, %183 ]
  %186 = icmp eq i32 %185, %.pre-phi317
  br i1 %186, label %187, label %._crit_edge321

187:                                              ; preds = %.thread266
  %188 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 8), align 8, !tbaa !10
  %189 = fsub double %160, %188
  br label %196

._crit_edge321:                                   ; preds = %183, %.thread266
  %.pre-phi335 = phi i32 [ %.pre-phi317, %.thread266 ], [ %.pre316, %183 ]
  %.sroa.4286.2 = phi double [ %.sroa.4286.1, %.thread266 ], [ %.sroa.4286.0, %183 ]
  %190 = phi i32 [ %185, %.thread266 ], [ %178, %183 ]
  %191 = icmp eq i32 %27, %.pre-phi335
  %192 = icmp eq i32 %190, 0
  %or.cond274 = and i1 %192, %191
  br i1 %or.cond274, label %193, label %196

193:                                              ; preds = %._crit_edge321
  %194 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 8), align 8, !tbaa !10
  %195 = fadd double %194, %160
  br label %196

196:                                              ; preds = %.thread, %176, %._crit_edge321, %193, %187
  %.sroa.4286.3 = phi double [ %.sroa.4286.0, %176 ], [ %.sroa.4286.1, %187 ], [ %.sroa.4286.2, %193 ], [ %.sroa.4286.2, %._crit_edge321 ], [ %180, %.thread ]
  %.sroa.4.0 = phi double [ %160, %176 ], [ %189, %187 ], [ %195, %193 ], [ %160, %._crit_edge321 ], [ %160, %.thread ]
  %197 = getelementptr inbounds i8, ptr %150, i64 8
  %198 = load i32, ptr %197, align 4, !tbaa !12
  %.not256.1 = icmp eq i32 %44, %198
  br i1 %.not256.1, label %212, label %199

199:                                              ; preds = %196
  %200 = icmp eq i32 %44, 0
  %.pre307 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 8), align 8, !tbaa !12
  %201 = add nsw i32 %.pre307, -1
  %202 = icmp eq i32 %198, %201
  %or.cond353 = select i1 %200, i1 %202, i1 false
  br i1 %or.cond353, label %.thread.1, label %._crit_edge322

._crit_edge322:                                   ; preds = %199
  %203 = icmp eq i32 %44, %201
  %204 = icmp eq i32 %198, 0
  %or.cond272.1 = and i1 %204, %203
  br i1 %or.cond272.1, label %205, label %212

205:                                              ; preds = %._crit_edge322
  %206 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 16), align 16, !tbaa !10
  %207 = fadd double %206, %154
  br label %212

.thread.1:                                        ; preds = %199
  %208 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 16), align 16, !tbaa !10
  %209 = fsub double %154, %208
  %210 = getelementptr inbounds i8, ptr %158, i64 8
  %211 = load i32, ptr %210, align 4, !tbaa !12
  %.not257265.1 = icmp eq i32 %211, 0
  br i1 %.not257265.1, label %228, label %.thread266.1

212:                                              ; preds = %205, %._crit_edge322, %196
  %.sroa.10289.0 = phi double [ %154, %196 ], [ %207, %205 ], [ %154, %._crit_edge322 ]
  %213 = getelementptr inbounds i8, ptr %158, i64 8
  %214 = load i32, ptr %213, align 4, !tbaa !12
  %.not257.1 = icmp eq i32 %44, %214
  br i1 %.not257.1, label %228, label %215

215:                                              ; preds = %212
  %216 = icmp eq i32 %44, 0
  %.pre309 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 8), align 8, !tbaa !12
  %.pre314 = add nsw i32 %.pre309, -1
  br i1 %216, label %.thread266.1, label %._crit_edge323

.thread266.1:                                     ; preds = %215, %.thread.1
  %.pre-phi315 = phi i32 [ %201, %.thread.1 ], [ %.pre314, %215 ]
  %.sroa.10289.1 = phi double [ %209, %.thread.1 ], [ %.sroa.10289.0, %215 ]
  %217 = phi i32 [ %211, %.thread.1 ], [ %214, %215 ]
  %218 = icmp eq i32 %217, %.pre-phi315
  br i1 %218, label %225, label %._crit_edge323

._crit_edge323:                                   ; preds = %215, %.thread266.1
  %.pre-phi331 = phi i32 [ %.pre-phi315, %.thread266.1 ], [ %.pre314, %215 ]
  %.sroa.10289.2 = phi double [ %.sroa.10289.1, %.thread266.1 ], [ %.sroa.10289.0, %215 ]
  %219 = phi i32 [ %217, %.thread266.1 ], [ %214, %215 ]
  %220 = icmp eq i32 %44, %.pre-phi331
  %221 = icmp eq i32 %219, 0
  %or.cond274.1 = and i1 %221, %220
  br i1 %or.cond274.1, label %222, label %228

222:                                              ; preds = %._crit_edge323
  %223 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 16), align 16, !tbaa !10
  %224 = fadd double %223, %162
  br label %228

225:                                              ; preds = %.thread266.1
  %226 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 16), align 16, !tbaa !10
  %227 = fsub double %162, %226
  br label %228

228:                                              ; preds = %225, %222, %._crit_edge323, %212, %.thread.1
  %.sroa.10289.3 = phi double [ %.sroa.10289.0, %212 ], [ %.sroa.10289.1, %225 ], [ %.sroa.10289.2, %222 ], [ %.sroa.10289.2, %._crit_edge323 ], [ %209, %.thread.1 ]
  %.sroa.10.0 = phi double [ %162, %212 ], [ %227, %225 ], [ %224, %222 ], [ %162, %._crit_edge323 ], [ %162, %.thread.1 ]
  %229 = getelementptr inbounds i8, ptr %150, i64 12
  %230 = load i32, ptr %229, align 4, !tbaa !12
  %.not256.2 = icmp eq i32 %61, %230
  br i1 %.not256.2, label %244, label %231

231:                                              ; preds = %228
  %232 = icmp eq i32 %61, 0
  %.pre310 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 12), align 4, !tbaa !12
  %233 = add nsw i32 %.pre310, -1
  %234 = icmp eq i32 %230, %233
  %or.cond355 = select i1 %232, i1 %234, i1 false
  br i1 %or.cond355, label %.thread.2, label %._crit_edge324

._crit_edge324:                                   ; preds = %231
  %235 = icmp eq i32 %61, %233
  %236 = icmp eq i32 %230, 0
  %or.cond272.2 = and i1 %236, %235
  br i1 %or.cond272.2, label %237, label %244

237:                                              ; preds = %._crit_edge324
  %238 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 24), align 8, !tbaa !10
  %239 = fadd double %238, %156
  br label %244

.thread.2:                                        ; preds = %231
  %240 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 24), align 8, !tbaa !10
  %241 = fsub double %156, %240
  %242 = getelementptr inbounds i8, ptr %158, i64 12
  %243 = load i32, ptr %242, align 4, !tbaa !12
  %.not257265.2 = icmp eq i32 %243, 0
  br i1 %.not257265.2, label %260, label %.thread266.2

244:                                              ; preds = %237, %._crit_edge324, %228
  %.sroa.16292.0 = phi double [ %156, %228 ], [ %239, %237 ], [ %156, %._crit_edge324 ]
  %245 = getelementptr inbounds i8, ptr %158, i64 12
  %246 = load i32, ptr %245, align 4, !tbaa !12
  %.not257.2 = icmp eq i32 %61, %246
  br i1 %.not257.2, label %260, label %247

247:                                              ; preds = %244
  %248 = icmp eq i32 %61, 0
  %.pre312 = load i32, ptr getelementptr inbounds (i8, ptr @cellnum, i64 12), align 4, !tbaa !12
  %.pre313 = add nsw i32 %.pre312, -1
  br i1 %248, label %.thread266.2, label %._crit_edge325

.thread266.2:                                     ; preds = %247, %.thread.2
  %.pre-phi = phi i32 [ %233, %.thread.2 ], [ %.pre313, %247 ]
  %.sroa.16292.1 = phi double [ %241, %.thread.2 ], [ %.sroa.16292.0, %247 ]
  %249 = phi i32 [ %243, %.thread.2 ], [ %246, %247 ]
  %250 = icmp eq i32 %249, %.pre-phi
  br i1 %250, label %257, label %._crit_edge325

._crit_edge325:                                   ; preds = %247, %.thread266.2
  %.pre-phi327 = phi i32 [ %.pre-phi, %.thread266.2 ], [ %.pre313, %247 ]
  %.sroa.16292.2 = phi double [ %.sroa.16292.1, %.thread266.2 ], [ %.sroa.16292.0, %247 ]
  %251 = phi i32 [ %249, %.thread266.2 ], [ %246, %247 ]
  %252 = icmp eq i32 %61, %.pre-phi327
  %253 = icmp eq i32 %251, 0
  %or.cond274.2 = and i1 %253, %252
  br i1 %or.cond274.2, label %254, label %260

254:                                              ; preds = %._crit_edge325
  %255 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 24), align 8, !tbaa !10
  %256 = fadd double %255, %164
  br label %260

257:                                              ; preds = %.thread266.2
  %258 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 24), align 8, !tbaa !10
  %259 = fsub double %164, %258
  br label %260

260:                                              ; preds = %257, %254, %._crit_edge325, %244, %.thread.2
  %.sroa.16292.3 = phi double [ %.sroa.16292.0, %244 ], [ %.sroa.16292.1, %257 ], [ %.sroa.16292.2, %254 ], [ %.sroa.16292.2, %._crit_edge325 ], [ %241, %.thread.2 ]
  %.sroa.16.0 = phi double [ %164, %244 ], [ %259, %257 ], [ %256, %254 ], [ %164, %._crit_edge325 ], [ %164, %.thread.2 ]
  %261 = fsub double %13, %.sroa.4.0
  %262 = fsub double %15, %.sroa.10.0
  %263 = fsub double %17, %.sroa.16.0
  %264 = fsub double %.sroa.3.0, %.sroa.4286.3
  %265 = fsub double %.sroa.9.0, %.sroa.10289.3
  %266 = fsub double %.sroa.15.0, %.sroa.16292.3
  %267 = fmul double %262, %262
  %268 = tail call double @llvm.fmuladd.f64(double %261, double %261, double %267)
  %269 = tail call double @llvm.fmuladd.f64(double %263, double %263, double %268)
  %270 = fmul double %265, %265
  %271 = tail call double @llvm.fmuladd.f64(double %264, double %264, double %270)
  %272 = tail call double @llvm.fmuladd.f64(double %266, double %266, double %271)
  %273 = getelementptr inbounds i8, ptr %104, i64 48
  %274 = load i32, ptr %273, align 8, !tbaa !27
  %275 = tail call double @HBEnergyChange(ptr noundef nonnull %0, i32 noundef %274, ptr noundef nonnull @.str.21, ptr noundef %4)
  store double %275, ptr %9, align 16, !tbaa !10
  %276 = load ptr, ptr %0, align 8, !tbaa !14
  %277 = getelementptr inbounds i8, ptr %276, i64 48
  %278 = load i32, ptr %277, align 8, !tbaa !27
  %279 = tail call double @HBEnergyChange(ptr noundef nonnull %1, i32 noundef %278, ptr noundef nonnull @.str.21, ptr noundef %4)
  %280 = getelementptr inbounds i8, ptr %9, i64 8
  store double %279, ptr %280, align 8, !tbaa !10
  %281 = load ptr, ptr %1, align 8, !tbaa !14
  %282 = getelementptr inbounds i8, ptr %281, i64 48
  %283 = load i32, ptr %282, align 8, !tbaa !27
  %284 = tail call double @HBEnergyChange(ptr noundef nonnull %0, i32 noundef %283, ptr noundef nonnull @.str.22, ptr noundef %4)
  %285 = getelementptr inbounds i8, ptr %9, i64 16
  store double %284, ptr %285, align 16, !tbaa !10
  %286 = load ptr, ptr %0, align 8, !tbaa !14
  %287 = getelementptr inbounds i8, ptr %286, i64 48
  %288 = load i32, ptr %287, align 8, !tbaa !27
  %289 = tail call double @HBEnergyChange(ptr noundef nonnull %1, i32 noundef %288, ptr noundef nonnull @.str.22, ptr noundef %4)
  %290 = getelementptr inbounds i8, ptr %9, i64 24
  store double %289, ptr %290, align 8, !tbaa !10
  %291 = getelementptr inbounds i8, ptr %9, i64 32
  %292 = call i32 @FindPair(ptr noundef nonnull %3, ptr noundef nonnull %0, ptr noundef nonnull @.str.23, double noundef 0.000000e+00, double noundef %269, ptr noundef nonnull %6, ptr noundef nonnull %6, ptr noundef nonnull %7, ptr noundef nonnull %8, ptr noundef nonnull %291, ptr noundef nonnull %1, i32 noundef 0) #8
  %293 = getelementptr inbounds i8, ptr %9, i64 40
  %294 = call i32 @FindPair(ptr noundef nonnull %2, ptr noundef nonnull %1, ptr noundef nonnull @.str.23, double noundef 0.000000e+00, double noundef %272, ptr noundef nonnull %6, ptr noundef nonnull %6, ptr noundef nonnull %7, ptr noundef nonnull %8, ptr noundef nonnull %293, ptr noundef nonnull %0, i32 noundef 0) #8
  %295 = load ptr, ptr %10, align 8, !tbaa !5
  %296 = getelementptr inbounds i8, ptr %295, i64 172
  %297 = load i32, ptr %296, align 4, !tbaa !25
  switch i32 %297, label %328 [
    i32 6, label %298
    i32 7, label %313
  ]

298:                                              ; preds = %260
  %299 = call double @HBBarrier(ptr noundef nonnull %0, ptr noundef nonnull %1)
  %300 = fsub double %111, %299
  %301 = load double, ptr %285, align 16, !tbaa !10
  %302 = load double, ptr %9, align 16, !tbaa !10
  %303 = fsub double %301, %302
  %304 = load double, ptr %290, align 8, !tbaa !10
  %305 = fadd double %303, %304
  %306 = load double, ptr %280, align 8, !tbaa !10
  %307 = fsub double %305, %306
  %308 = load double, ptr %291, align 16, !tbaa !10
  %309 = fadd double %307, %308
  %310 = load double, ptr %293, align 8, !tbaa !10
  %311 = fadd double %309, %310
  %312 = fadd double %300, %311
  br label %330

313:                                              ; preds = %260
  %314 = call double @HBBarrier(ptr noundef nonnull %0, ptr noundef nonnull %1)
  %315 = fadd double %111, %314
  %316 = load double, ptr %9, align 16, !tbaa !10
  %317 = load double, ptr %285, align 16, !tbaa !10
  %318 = fsub double %316, %317
  %319 = load double, ptr %280, align 8, !tbaa !10
  %320 = fadd double %318, %319
  %321 = load double, ptr %290, align 8, !tbaa !10
  %322 = fsub double %320, %321
  %323 = load double, ptr %291, align 16, !tbaa !10
  %324 = fsub double %322, %323
  %325 = load double, ptr %293, align 8, !tbaa !10
  %326 = fsub double %324, %325
  %327 = fadd double %315, %326
  br label %330

328:                                              ; preds = %260
  %329 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.24)
  call void @exit(i32 noundef 1) #9
  unreachable

330:                                              ; preds = %313, %298
  %.0242 = phi double [ %312, %298 ], [ %327, %313 ]
  %331 = fcmp olt double %.0242, -5.000000e+07
  br i1 %331, label %332, label %337

332:                                              ; preds = %330
  %333 = load ptr, ptr %10, align 8, !tbaa !5
  %334 = getelementptr inbounds i8, ptr %333, i64 172
  %335 = load i32, ptr %334, align 4, !tbaa !25
  %336 = icmp eq i32 %335, 7
  br i1 %336, label %.thread267, label %337

337:                                              ; preds = %332, %330
  %338 = fcmp ogt double %.0242, 5.000000e+07
  br i1 %338, label %339, label %344

339:                                              ; preds = %337
  %340 = load ptr, ptr %10, align 8, !tbaa !5
  %341 = getelementptr inbounds i8, ptr %340, i64 172
  %342 = load i32, ptr %341, align 4, !tbaa !25
  %343 = icmp eq i32 %342, 6
  br i1 %343, label %.thread267, label %344

344:                                              ; preds = %337, %339
  %345 = fmul double %97, -2.000000e+00
  %346 = fmul double %345, %.0242
  %347 = fdiv double %346, %109
  %348 = call double @llvm.fmuladd.f64(double %100, double %100, double %347)
  %349 = fcmp ogt double %348, 0.000000e+00
  %350 = load ptr, ptr %10, align 8, !tbaa !5
  %351 = getelementptr inbounds i8, ptr %350, i64 172
  %352 = load i32, ptr %351, align 4, !tbaa !25
  br i1 %349, label %353, label %357

353:                                              ; preds = %344
  switch i32 %352, label %355 [
    i32 6, label %361
    i32 7, label %354
  ]

354:                                              ; preds = %353
  br label %361

355:                                              ; preds = %353
  %356 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.25, ptr noundef nonnull @.str.1, i32 noundef 924)
  call void @exit(i32 noundef 1) #9
  unreachable

357:                                              ; preds = %344
  switch i32 %352, label %358 [
    i32 6, label %.thread267
    i32 7, label %361
  ]

358:                                              ; preds = %357
  %359 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.25, ptr noundef nonnull @.str.1, i32 noundef 939)
  call void @exit(i32 noundef 1) #9
  unreachable

.thread267:                                       ; preds = %357, %339, %332, %147, %133
  %.sink356 = phi ptr [ %11, %133 ], [ %11, %147 ], [ %333, %332 ], [ %340, %339 ], [ %350, %357 ]
  %360 = getelementptr inbounds i8, ptr %.sink356, i64 92
  store i32 3, ptr %360, align 4, !tbaa !28
  call void @llvm.lifetime.end.p0(i64 48, ptr nonnull %9) #8
  br label %445

361:                                              ; preds = %357, %353, %354
  %.sink358 = phi i32 [ 3, %354 ], [ 2, %353 ], [ 1, %357 ]
  %.sink = phi i32 [ 2, %354 ], [ 1, %353 ], [ 0, %357 ]
  %.2 = phi double [ %.0242, %354 ], [ %.0242, %353 ], [ 0.000000e+00, %357 ]
  store i32 %.sink358, ptr %351, align 4, !tbaa !25
  %362 = getelementptr inbounds i8, ptr %350, i64 92
  store i32 %.sink, ptr %362, align 4, !tbaa !28
  call void @llvm.lifetime.end.p0(i64 48, ptr nonnull %9) #8
  br label %.critedge

.critedge:                                        ; preds = %361, %115, %76
  %363 = phi ptr [ %350, %361 ], [ %11, %115 ], [ %11, %76 ]
  %.3 = phi double [ %.2, %361 ], [ %111, %115 ], [ %111, %76 ]
  %364 = getelementptr inbounds i8, ptr %363, i64 172
  %365 = load i32, ptr %364, align 4, !tbaa !25
  switch i32 %365, label %386 [
    i32 0, label %388
    i32 1, label %366
    i32 2, label %368
    i32 3, label %369
    i32 4, label %371
    i32 5, label %377
  ]

366:                                              ; preds = %.critedge
  %367 = fcmp olt double %100, 0.000000e+00
  %. = select i1 %367, double 1.000000e+00, double -1.000000e+00
  br label %388

368:                                              ; preds = %.critedge
  br label %388

369:                                              ; preds = %.critedge
  %370 = fcmp olt double %100, 0.000000e+00
  %.261 = select i1 %370, double -1.000000e+00, double 1.000000e+00
  br label %388

371:                                              ; preds = %.critedge
  %372 = fmul double %97, -2.000000e+00
  %373 = fmul double %372, %.3
  %374 = fdiv double %373, %109
  %375 = call double @llvm.fmuladd.f64(double %100, double %100, double %374)
  %376 = fcmp ugt double %375, 0.000000e+00
  %.3. = select i1 %376, double %.3, double 0.000000e+00
  %.262 = select i1 %376, double -1.000000e+00, double 1.000000e+00
  br label %388

377:                                              ; preds = %.critedge
  %378 = fmul double %97, -2.000000e+00
  %379 = fmul double %378, %.3
  %380 = fdiv double %379, %109
  %381 = call double @llvm.fmuladd.f64(double %100, double %100, double %380)
  %382 = fcmp ugt double %381, 0.000000e+00
  %383 = fcmp olt double %100, 0.000000e+00
  br i1 %382, label %385, label %384

384:                                              ; preds = %377
  %.263 = select i1 %383, double 1.000000e+00, double -1.000000e+00
  br label %388

385:                                              ; preds = %377
  %.264 = select i1 %383, double -1.000000e+00, double 1.000000e+00
  br label %388

386:                                              ; preds = %.critedge
  %387 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.26)
  call void @exit(i32 noundef 1) #9
  unreachable

388:                                              ; preds = %385, %384, %371, %369, %.critedge, %368, %366
  %.4 = phi double [ %.3, %368 ], [ 0.000000e+00, %366 ], [ 0.000000e+00, %.critedge ], [ %.3, %369 ], [ %.3., %371 ], [ 0.000000e+00, %384 ], [ %.3, %385 ]
  %.1 = phi double [ -1.000000e+00, %368 ], [ %., %366 ], [ 1.000000e+00, %.critedge ], [ %.261, %369 ], [ %.262, %371 ], [ %.263, %384 ], [ %.264, %385 ]
  %389 = fmul double %97, -2.000000e+00
  %390 = fmul double %389, %.4
  %391 = fdiv double %390, %109
  %392 = call double @llvm.fmuladd.f64(double %100, double %100, double %391)
  %393 = call double @sqrt(double noundef %392) #8
  %394 = fmul double %.1, %393
  %395 = call double @llvm.fmuladd.f64(double %100, double -1.000000e+00, double %394)
  %396 = load ptr, ptr %0, align 8, !tbaa !14
  %397 = getelementptr inbounds i8, ptr %396, i64 72
  %398 = load double, ptr %397, align 8, !tbaa !15
  %399 = load ptr, ptr %1, align 8, !tbaa !14
  %400 = getelementptr inbounds i8, ptr %399, i64 72
  %401 = load double, ptr %400, align 8, !tbaa !15
  %402 = fadd double %398, %401
  %403 = fmul double %97, %402
  %404 = fdiv double %395, %403
  %405 = fcmp uno double %404, 0.000000e+00
  br i1 %405, label %406, label %408, !prof !29

406:                                              ; preds = %388
  %407 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.17, ptr noundef nonnull @.str.1, i32 noundef 1009)
  call void @exit(i32 noundef 1) #9
  unreachable

408:                                              ; preds = %388
  %409 = getelementptr inbounds i8, ptr %396, i64 24
  %410 = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %409, ptr noundef nonnull dereferenceable(1) @.str.27) #10
  %.not258 = icmp eq i32 %410, 0
  br i1 %.not258, label %426, label %411

411:                                              ; preds = %408
  %412 = fmul double %401, %404
  %413 = fmul double %77, %412
  %414 = fmul double %78, %412
  %415 = fmul double %79, %412
  %416 = load double, ptr %80, align 8, !tbaa !10
  %417 = fadd double %413, %416
  %418 = load ptr, ptr %10, align 8, !tbaa !5
  %419 = getelementptr inbounds i8, ptr %418, i64 56
  store double %417, ptr %419, align 8, !tbaa !10
  %420 = load double, ptr %85, align 8, !tbaa !10
  %421 = fadd double %414, %420
  %422 = getelementptr inbounds i8, ptr %418, i64 64
  store double %421, ptr %422, align 8, !tbaa !10
  %423 = load double, ptr %90, align 8, !tbaa !10
  %424 = fadd double %415, %423
  %425 = getelementptr inbounds i8, ptr %418, i64 72
  store double %424, ptr %425, align 8, !tbaa !10
  br label %426

426:                                              ; preds = %411, %408
  %427 = getelementptr inbounds i8, ptr %399, i64 24
  %428 = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %427, ptr noundef nonnull dereferenceable(1) @.str.27) #10
  %.not259 = icmp eq i32 %428, 0
  br i1 %.not259, label %445, label %429

429:                                              ; preds = %426
  %430 = load double, ptr %397, align 8, !tbaa !15
  %431 = fmul double %404, %430
  %432 = fmul double %77, %431
  %433 = fmul double %78, %431
  %434 = fmul double %79, %431
  %435 = load double, ptr %82, align 8, !tbaa !10
  %436 = fsub double %435, %432
  %437 = load ptr, ptr %18, align 8, !tbaa !5
  %438 = getelementptr inbounds i8, ptr %437, i64 56
  store double %436, ptr %438, align 8, !tbaa !10
  %439 = load double, ptr %87, align 8, !tbaa !10
  %440 = fsub double %439, %433
  %441 = getelementptr inbounds i8, ptr %437, i64 64
  store double %440, ptr %441, align 8, !tbaa !10
  %442 = load double, ptr %92, align 8, !tbaa !10
  %443 = fsub double %442, %434
  %444 = getelementptr inbounds i8, ptr %437, i64 72
  store double %443, ptr %444, align 8, !tbaa !10
  br label %445

445:                                              ; preds = %.thread267, %426, %429
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %8) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %7) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %6) #8
  ret void
}

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

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

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

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

; Function Attrs: mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #5

; Function Attrs: mustprogress nofree nounwind willreturn memory(write)
declare double @sqrt(double noundef) local_unnamed_addr #6

; Function Attrs: nounwind uwtable
declare dso_local double @HBEnergyChange(ptr noundef, i32 noundef, ptr noundef, ptr noundef) local_unnamed_addr #1

declare i32 @FindPair(ptr noundef, ptr noundef, ptr noundef, double noundef, double noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, ptr noundef, i32 noundef) local_unnamed_addr #7

; Function Attrs: nounwind uwtable
declare dso_local double @HBBarrier(ptr noundef, ptr noundef) local_unnamed_addr #1

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

!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, !7, i64 8}
!6 = !{!"AtomStr", !7, i64 0, !7, i64 8}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!11, !11, i64 0}
!11 = !{!"double", !8, i64 0}
!12 = !{!13, !13, i64 0}
!13 = !{!"int", !8, i64 0}
!14 = !{!6, !7, i64 0}
!15 = !{!16, !11, i64 72}
!16 = !{!"PropertyStr", !8, i64 0, !8, i64 8, !8, i64 40, !13, i64 48, !13, i64 52, !13, i64 56, !11, i64 64, !11, i64 72, !8, i64 80, !17, i64 104, !7, i64 120, !7, i64 128}
!17 = !{!"AtomSeqStr", !13, i64 0, !13, i64 4, !13, i64 8}
!18 = !{!19, !11, i64 160}
!19 = !{!"DynamicStr", !8, i64 0, !8, i64 16, !8, i64 48, !20, i64 80, !21, i64 96, !22, i64 128}
!20 = !{!"HBStr", !13, i64 0, !13, i64 4, !8, i64 8, !13, i64 12}
!21 = !{!"HBNeighborStr", !8, i64 0, !13, i64 20, !13, i64 24}
!22 = !{!"InteractionEventStr", !13, i64 0, !23, i64 8, !23, i64 16, !11, i64 24, !11, i64 32, !13, i64 40, !13, i64 44}
!23 = !{!"long", !8, i64 0}
!24 = !{!19, !13, i64 168}
!25 = !{!19, !13, i64 172}
!26 = !{!7, !7, i64 0}
!27 = !{!16, !13, i64 48}
!28 = !{!19, !13, i64 92}
!29 = !{!"branch_weights", !"expected", i32 1, i32 2000}


; Effective O3 passes: BDCEPass,CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LoopRotatePass,LowerExpectIntrinsicPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass