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

; 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.REMDStr = type { i32, i32, i32, [50 x i8], [50 x i8], %struct.REMDTempStr }
%struct.REMDTempStr = type { i32, double }
%struct.ConstraintStr = type { i32, double, ptr, double, ptr }
%struct.FileStr = type { i32, [256 x i8], ptr }
%struct.AtomListStr = type { i32, [27 x i32], [27 x i32], [27 x i32], double, ptr, ptr, ptr }
%struct.AtomStr = type { ptr, ptr }
%struct.DynamicStr = type { [4 x i32], [4 x double], [4 x double], %struct.HBStr, %struct.HBNeighborStr, %struct.InteractionEventStr }
%struct.HBStr = type { i32, i32, i8, i32 }
%struct.HBNeighborStr = type { [5 x i32], i32, i32 }
%struct.InteractionEventStr = type { i32, i64, i64, double, double, i32, i32 }
%struct.interStr = type { [512 x i32], [4 x double], [512 x double], [512 x double], [512 x double] }
%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 }

@REMDInfo = external global %struct.REMDStr, align 8
@atomnum = external global i32, align 4
@atom = external global ptr, align 8
@.str.2 = external hidden unnamed_addr constant [70 x i8], align 1
@potentialPairCollision = external global [33 x [33 x %struct.ConstraintStr]], align 16
@.str.19 = external hidden unnamed_addr constant [20 x i8], align 1
@datadir = external global [1024 x i8], align 16
@.str.20 = external hidden unnamed_addr constant [2 x i8], align 1
@connectionMap = external global ptr, align 8
@.str.21 = external hidden unnamed_addr constant [105 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [98 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [8 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: 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 speculatable willreturn memory(none)
declare double @llvm.fmuladd.f64(double, double, double) #1

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @SDEnergyMin(i64 noundef %0, ptr noundef %1) #5 {
  %3 = alloca i64, align 8
  %4 = alloca ptr, align 8
  %5 = alloca i64, align 8
  %6 = alloca i64, align 8
  %7 = alloca double, align 8
  %8 = alloca double, align 8
  %9 = alloca double, align 8
  %10 = alloca [4 x double], align 16
  %11 = alloca double, align 8
  %12 = alloca [100 x i8], align 16
  %13 = alloca ptr, align 8
  %14 = alloca %struct.FileStr, align 8
  %15 = alloca i32, align 4
  %16 = alloca i32, align 4
  %17 = alloca i32, align 4
  %18 = alloca ptr, align 8
  %19 = alloca ptr, align 8
  %20 = alloca i32, align 4
  %21 = alloca i32, align 4
  %22 = alloca i32, align 4
  %23 = alloca i32, align 4
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca [4 x double], align 16
  %27 = alloca i32, align 4
  %28 = alloca i32, align 4
  store i64 %0, ptr %3, align 8, !tbaa !5
  store ptr %1, ptr %4, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #8
  store i64 0, ptr %5, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #8
  store i64 10000000000000000, ptr %6, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #8
  store double 1.000000e-01, ptr %7, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %9) #8
  call void @llvm.lifetime.start.p0(i64 32, ptr %10) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #8
  call void @llvm.lifetime.start.p0(i64 100, ptr %12) #8
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #8
  call void @llvm.lifetime.start.p0(i64 272, ptr %14) #8
  %29 = load i32, ptr @atomnum, align 4, !tbaa !13
  %30 = add nsw i32 %29, 1
  %31 = sext i32 %30 to i64
  %32 = call noalias ptr @calloc(i64 noundef %31, i64 noundef 14368) #9
  store ptr %32, ptr %13, align 8, !tbaa !9
  %33 = getelementptr inbounds [100 x i8], ptr %12, i64 0, i64 0
  %34 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %33, ptr noundef @.str.19, ptr noundef @datadir, ptr noundef getelementptr inbounds (%struct.REMDStr, ptr @REMDInfo, i32 0, i32 4)) #8
  %35 = getelementptr inbounds [100 x i8], ptr %12, i64 0, i64 0
  %36 = call noalias ptr @fopen(ptr noundef %35, ptr noundef @.str.20)
  %37 = getelementptr inbounds %struct.FileStr, ptr %14, i32 0, i32 2
  store ptr %36, ptr %37, align 8, !tbaa !15
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #8
  store i32 1, ptr %15, align 4, !tbaa !13
  br label %38

38:                                               ; preds = %521, %2
  %39 = load i32, ptr %15, align 4, !tbaa !13
  %40 = load i32, ptr @atomnum, align 4, !tbaa !13
  %41 = icmp sle i32 %39, %40
  br i1 %41, label %43, label %42

42:                                               ; preds = %38
  store i32 2, ptr %16, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #8
  br label %524

43:                                               ; preds = %38
  %44 = load ptr, ptr %4, align 8, !tbaa !9
  %45 = getelementptr inbounds %struct.AtomListStr, ptr %44, i32 0, i32 7
  %46 = load ptr, ptr %45, align 8, !tbaa !17
  %47 = load i32, ptr %15, align 4, !tbaa !13
  %48 = sext i32 %47 to i64
  %49 = getelementptr inbounds ptr, ptr %46, i64 %48
  %50 = load ptr, ptr %49, align 8, !tbaa !9
  %51 = getelementptr inbounds %struct.AtomStr, ptr %50, i32 0, i32 1
  %52 = load ptr, ptr %51, align 8, !tbaa !19
  %53 = getelementptr inbounds %struct.DynamicStr, ptr %52, i32 0, i32 1
  %54 = getelementptr inbounds [4 x double], ptr %53, i64 0, i64 0
  %55 = load double, ptr %54, align 8, !tbaa !11
  %56 = load ptr, ptr %13, align 8, !tbaa !9
  %57 = load i32, ptr %15, align 4, !tbaa !13
  %58 = sext i32 %57 to i64
  %59 = getelementptr inbounds %struct.interStr, ptr %56, i64 %58
  %60 = getelementptr inbounds %struct.interStr, ptr %59, i32 0, i32 1
  %61 = getelementptr inbounds [4 x double], ptr %60, i64 0, i64 0
  store double %55, ptr %61, align 8, !tbaa !11
  %62 = load ptr, ptr %4, align 8, !tbaa !9
  %63 = getelementptr inbounds %struct.AtomListStr, ptr %62, i32 0, i32 7
  %64 = load ptr, ptr %63, align 8, !tbaa !17
  %65 = load i32, ptr %15, align 4, !tbaa !13
  %66 = sext i32 %65 to i64
  %67 = getelementptr inbounds ptr, ptr %64, i64 %66
  %68 = load ptr, ptr %67, align 8, !tbaa !9
  %69 = getelementptr inbounds %struct.AtomStr, ptr %68, i32 0, i32 1
  %70 = load ptr, ptr %69, align 8, !tbaa !19
  %71 = getelementptr inbounds %struct.DynamicStr, ptr %70, i32 0, i32 1
  %72 = getelementptr inbounds [4 x double], ptr %71, i64 0, i64 1
  %73 = load double, ptr %72, align 8, !tbaa !11
  %74 = load ptr, ptr %13, align 8, !tbaa !9
  %75 = load i32, ptr %15, align 4, !tbaa !13
  %76 = sext i32 %75 to i64
  %77 = getelementptr inbounds %struct.interStr, ptr %74, i64 %76
  %78 = getelementptr inbounds %struct.interStr, ptr %77, i32 0, i32 1
  %79 = getelementptr inbounds [4 x double], ptr %78, i64 0, i64 1
  store double %73, ptr %79, align 8, !tbaa !11
  %80 = load ptr, ptr %4, align 8, !tbaa !9
  %81 = getelementptr inbounds %struct.AtomListStr, ptr %80, i32 0, i32 7
  %82 = load ptr, ptr %81, align 8, !tbaa !17
  %83 = load i32, ptr %15, align 4, !tbaa !13
  %84 = sext i32 %83 to i64
  %85 = getelementptr inbounds ptr, ptr %82, i64 %84
  %86 = load ptr, ptr %85, align 8, !tbaa !9
  %87 = getelementptr inbounds %struct.AtomStr, ptr %86, i32 0, i32 1
  %88 = load ptr, ptr %87, align 8, !tbaa !19
  %89 = getelementptr inbounds %struct.DynamicStr, ptr %88, i32 0, i32 1
  %90 = getelementptr inbounds [4 x double], ptr %89, i64 0, i64 2
  %91 = load double, ptr %90, align 8, !tbaa !11
  %92 = load ptr, ptr %13, align 8, !tbaa !9
  %93 = load i32, ptr %15, align 4, !tbaa !13
  %94 = sext i32 %93 to i64
  %95 = getelementptr inbounds %struct.interStr, ptr %92, i64 %94
  %96 = getelementptr inbounds %struct.interStr, ptr %95, i32 0, i32 1
  %97 = getelementptr inbounds [4 x double], ptr %96, i64 0, i64 2
  store double %91, ptr %97, align 8, !tbaa !11
  %98 = load ptr, ptr %4, align 8, !tbaa !9
  %99 = getelementptr inbounds %struct.AtomListStr, ptr %98, i32 0, i32 7
  %100 = load ptr, ptr %99, align 8, !tbaa !17
  %101 = load i32, ptr %15, align 4, !tbaa !13
  %102 = sext i32 %101 to i64
  %103 = getelementptr inbounds ptr, ptr %100, i64 %102
  %104 = load ptr, ptr %103, align 8, !tbaa !9
  %105 = getelementptr inbounds %struct.AtomStr, ptr %104, i32 0, i32 1
  %106 = load ptr, ptr %105, align 8, !tbaa !19
  %107 = getelementptr inbounds %struct.DynamicStr, ptr %106, i32 0, i32 1
  %108 = getelementptr inbounds [4 x double], ptr %107, i64 0, i64 3
  %109 = load double, ptr %108, align 8, !tbaa !11
  %110 = load ptr, ptr %13, align 8, !tbaa !9
  %111 = load i32, ptr %15, align 4, !tbaa !13
  %112 = sext i32 %111 to i64
  %113 = getelementptr inbounds %struct.interStr, ptr %110, i64 %112
  %114 = getelementptr inbounds %struct.interStr, ptr %113, i32 0, i32 1
  %115 = getelementptr inbounds [4 x double], ptr %114, i64 0, i64 3
  store double %109, ptr %115, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #8
  store i32 0, ptr %17, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #8
  %116 = load ptr, ptr %4, align 8, !tbaa !9
  %117 = getelementptr inbounds %struct.AtomListStr, ptr %116, i32 0, i32 7
  %118 = load ptr, ptr %117, align 8, !tbaa !17
  %119 = load i32, ptr %15, align 4, !tbaa !13
  %120 = sext i32 %119 to i64
  %121 = getelementptr inbounds ptr, ptr %118, i64 %120
  %122 = load ptr, ptr %121, align 8, !tbaa !9
  %123 = getelementptr inbounds %struct.AtomStr, ptr %122, i32 0, i32 0
  %124 = load ptr, ptr %123, align 8, !tbaa !21
  %125 = getelementptr inbounds %struct.PropertyStr, ptr %124, i32 0, i32 10
  %126 = load ptr, ptr %125, align 8, !tbaa !22
  store ptr %126, ptr %18, align 8, !tbaa !9
  br label %127

127:                                              ; preds = %130, %43
  %128 = load ptr, ptr %18, align 8, !tbaa !9
  %129 = icmp ne ptr %128, null
  br i1 %129, label %130, label %199

130:                                              ; preds = %127
  %131 = load i32, ptr %17, align 4, !tbaa !13
  %132 = add nsw i32 %131, 1
  store i32 %132, ptr %17, align 4, !tbaa !13
  %133 = load ptr, ptr %18, align 8, !tbaa !9
  %134 = getelementptr inbounds %struct.ConstraintStr, ptr %133, i32 0, i32 0
  %135 = load i32, ptr %134, align 8, !tbaa !25
  %136 = load ptr, ptr %13, align 8, !tbaa !9
  %137 = load i32, ptr %15, align 4, !tbaa !13
  %138 = sext i32 %137 to i64
  %139 = getelementptr inbounds %struct.interStr, ptr %136, i64 %138
  %140 = getelementptr inbounds %struct.interStr, ptr %139, i32 0, i32 0
  %141 = load i32, ptr %17, align 4, !tbaa !13
  %142 = sext i32 %141 to i64
  %143 = getelementptr inbounds [512 x i32], ptr %140, i64 0, i64 %142
  store i32 %135, ptr %143, align 4, !tbaa !13
  %144 = load ptr, ptr %18, align 8, !tbaa !9
  %145 = getelementptr inbounds %struct.ConstraintStr, ptr %144, i32 0, i32 3
  %146 = load double, ptr %145, align 8, !tbaa !27
  %147 = call double @sqrt(double noundef %146) #8
  %148 = load ptr, ptr %13, align 8, !tbaa !9
  %149 = load i32, ptr %15, align 4, !tbaa !13
  %150 = sext i32 %149 to i64
  %151 = getelementptr inbounds %struct.interStr, ptr %148, i64 %150
  %152 = getelementptr inbounds %struct.interStr, ptr %151, i32 0, i32 2
  %153 = load i32, ptr %17, align 4, !tbaa !13
  %154 = sext i32 %153 to i64
  %155 = getelementptr inbounds [512 x double], ptr %152, i64 0, i64 %154
  store double %147, ptr %155, align 8, !tbaa !11
  %156 = load ptr, ptr %18, align 8, !tbaa !9
  %157 = getelementptr inbounds %struct.ConstraintStr, ptr %156, i32 0, i32 1
  %158 = load double, ptr %157, align 8, !tbaa !28
  %159 = call double @sqrt(double noundef %158) #8
  %160 = load ptr, ptr %13, align 8, !tbaa !9
  %161 = load i32, ptr %15, align 4, !tbaa !13
  %162 = sext i32 %161 to i64
  %163 = getelementptr inbounds %struct.interStr, ptr %160, i64 %162
  %164 = getelementptr inbounds %struct.interStr, ptr %163, i32 0, i32 3
  %165 = load i32, ptr %17, align 4, !tbaa !13
  %166 = sext i32 %165 to i64
  %167 = getelementptr inbounds [512 x double], ptr %164, i64 0, i64 %166
  store double %159, ptr %167, align 8, !tbaa !11
  %168 = load ptr, ptr %13, align 8, !tbaa !9
  %169 = load i32, ptr %15, align 4, !tbaa !13
  %170 = sext i32 %169 to i64
  %171 = getelementptr inbounds %struct.interStr, ptr %168, i64 %170
  %172 = getelementptr inbounds %struct.interStr, ptr %171, i32 0, i32 2
  %173 = load i32, ptr %17, align 4, !tbaa !13
  %174 = sext i32 %173 to i64
  %175 = getelementptr inbounds [512 x double], ptr %172, i64 0, i64 %174
  %176 = load double, ptr %175, align 8, !tbaa !11
  %177 = load ptr, ptr %13, align 8, !tbaa !9
  %178 = load i32, ptr %15, align 4, !tbaa !13
  %179 = sext i32 %178 to i64
  %180 = getelementptr inbounds %struct.interStr, ptr %177, i64 %179
  %181 = getelementptr inbounds %struct.interStr, ptr %180, i32 0, i32 3
  %182 = load i32, ptr %17, align 4, !tbaa !13
  %183 = sext i32 %182 to i64
  %184 = getelementptr inbounds [512 x double], ptr %181, i64 0, i64 %183
  %185 = load double, ptr %184, align 8, !tbaa !11
  %186 = fadd double %176, %185
  %187 = fmul double 5.000000e-01, %186
  %188 = load ptr, ptr %13, align 8, !tbaa !9
  %189 = load i32, ptr %15, align 4, !tbaa !13
  %190 = sext i32 %189 to i64
  %191 = getelementptr inbounds %struct.interStr, ptr %188, i64 %190
  %192 = getelementptr inbounds %struct.interStr, ptr %191, i32 0, i32 4
  %193 = load i32, ptr %17, align 4, !tbaa !13
  %194 = sext i32 %193 to i64
  %195 = getelementptr inbounds [512 x double], ptr %192, i64 0, i64 %194
  store double %187, ptr %195, align 8, !tbaa !11
  %196 = load ptr, ptr %18, align 8, !tbaa !9
  %197 = getelementptr inbounds %struct.ConstraintStr, ptr %196, i32 0, i32 4
  %198 = load ptr, ptr %197, align 8, !tbaa !29
  store ptr %198, ptr %18, align 8, !tbaa !9
  br label %127, !llvm.loop !30

199:                                              ; preds = %127
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #8
  %200 = load ptr, ptr %4, align 8, !tbaa !9
  %201 = getelementptr inbounds %struct.AtomListStr, ptr %200, i32 0, i32 7
  %202 = load ptr, ptr %201, align 8, !tbaa !17
  %203 = load i32, ptr %15, align 4, !tbaa !13
  %204 = sext i32 %203 to i64
  %205 = getelementptr inbounds ptr, ptr %202, i64 %204
  %206 = load ptr, ptr %205, align 8, !tbaa !9
  %207 = getelementptr inbounds %struct.AtomStr, ptr %206, i32 0, i32 0
  %208 = load ptr, ptr %207, align 8, !tbaa !21
  %209 = getelementptr inbounds %struct.PropertyStr, ptr %208, i32 0, i32 11
  %210 = load ptr, ptr %209, align 8, !tbaa !32
  store ptr %210, ptr %19, align 8, !tbaa !9
  br label %211

211:                                              ; preds = %214, %199
  %212 = load ptr, ptr %19, align 8, !tbaa !9
  %213 = icmp ne ptr %212, null
  br i1 %213, label %214, label %283

214:                                              ; preds = %211
  %215 = load i32, ptr %17, align 4, !tbaa !13
  %216 = add nsw i32 %215, 1
  store i32 %216, ptr %17, align 4, !tbaa !13
  %217 = load ptr, ptr %19, align 8, !tbaa !9
  %218 = getelementptr inbounds %struct.ConstraintStr, ptr %217, i32 0, i32 0
  %219 = load i32, ptr %218, align 8, !tbaa !25
  %220 = load ptr, ptr %13, align 8, !tbaa !9
  %221 = load i32, ptr %15, align 4, !tbaa !13
  %222 = sext i32 %221 to i64
  %223 = getelementptr inbounds %struct.interStr, ptr %220, i64 %222
  %224 = getelementptr inbounds %struct.interStr, ptr %223, i32 0, i32 0
  %225 = load i32, ptr %17, align 4, !tbaa !13
  %226 = sext i32 %225 to i64
  %227 = getelementptr inbounds [512 x i32], ptr %224, i64 0, i64 %226
  store i32 %219, ptr %227, align 4, !tbaa !13
  %228 = load ptr, ptr %19, align 8, !tbaa !9
  %229 = getelementptr inbounds %struct.ConstraintStr, ptr %228, i32 0, i32 3
  %230 = load double, ptr %229, align 8, !tbaa !27
  %231 = call double @sqrt(double noundef %230) #8
  %232 = load ptr, ptr %13, align 8, !tbaa !9
  %233 = load i32, ptr %15, align 4, !tbaa !13
  %234 = sext i32 %233 to i64
  %235 = getelementptr inbounds %struct.interStr, ptr %232, i64 %234
  %236 = getelementptr inbounds %struct.interStr, ptr %235, i32 0, i32 2
  %237 = load i32, ptr %17, align 4, !tbaa !13
  %238 = sext i32 %237 to i64
  %239 = getelementptr inbounds [512 x double], ptr %236, i64 0, i64 %238
  store double %231, ptr %239, align 8, !tbaa !11
  %240 = load ptr, ptr %19, align 8, !tbaa !9
  %241 = getelementptr inbounds %struct.ConstraintStr, ptr %240, i32 0, i32 1
  %242 = load double, ptr %241, align 8, !tbaa !28
  %243 = call double @sqrt(double noundef %242) #8
  %244 = load ptr, ptr %13, align 8, !tbaa !9
  %245 = load i32, ptr %15, align 4, !tbaa !13
  %246 = sext i32 %245 to i64
  %247 = getelementptr inbounds %struct.interStr, ptr %244, i64 %246
  %248 = getelementptr inbounds %struct.interStr, ptr %247, i32 0, i32 3
  %249 = load i32, ptr %17, align 4, !tbaa !13
  %250 = sext i32 %249 to i64
  %251 = getelementptr inbounds [512 x double], ptr %248, i64 0, i64 %250
  store double %243, ptr %251, align 8, !tbaa !11
  %252 = load ptr, ptr %13, align 8, !tbaa !9
  %253 = load i32, ptr %15, align 4, !tbaa !13
  %254 = sext i32 %253 to i64
  %255 = getelementptr inbounds %struct.interStr, ptr %252, i64 %254
  %256 = getelementptr inbounds %struct.interStr, ptr %255, i32 0, i32 2
  %257 = load i32, ptr %17, align 4, !tbaa !13
  %258 = sext i32 %257 to i64
  %259 = getelementptr inbounds [512 x double], ptr %256, i64 0, i64 %258
  %260 = load double, ptr %259, align 8, !tbaa !11
  %261 = load ptr, ptr %13, align 8, !tbaa !9
  %262 = load i32, ptr %15, align 4, !tbaa !13
  %263 = sext i32 %262 to i64
  %264 = getelementptr inbounds %struct.interStr, ptr %261, i64 %263
  %265 = getelementptr inbounds %struct.interStr, ptr %264, i32 0, i32 3
  %266 = load i32, ptr %17, align 4, !tbaa !13
  %267 = sext i32 %266 to i64
  %268 = getelementptr inbounds [512 x double], ptr %265, i64 0, i64 %267
  %269 = load double, ptr %268, align 8, !tbaa !11
  %270 = fadd double %260, %269
  %271 = fmul double 5.000000e-01, %270
  %272 = load ptr, ptr %13, align 8, !tbaa !9
  %273 = load i32, ptr %15, align 4, !tbaa !13
  %274 = sext i32 %273 to i64
  %275 = getelementptr inbounds %struct.interStr, ptr %272, i64 %274
  %276 = getelementptr inbounds %struct.interStr, ptr %275, i32 0, i32 4
  %277 = load i32, ptr %17, align 4, !tbaa !13
  %278 = sext i32 %277 to i64
  %279 = getelementptr inbounds [512 x double], ptr %276, i64 0, i64 %278
  store double %271, ptr %279, align 8, !tbaa !11
  %280 = load ptr, ptr %19, align 8, !tbaa !9
  %281 = getelementptr inbounds %struct.ConstraintStr, ptr %280, i32 0, i32 4
  %282 = load ptr, ptr %281, align 8, !tbaa !29
  store ptr %282, ptr %19, align 8, !tbaa !9
  br label %211, !llvm.loop !33

283:                                              ; preds = %211
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #8
  store i32 1, ptr %20, align 4, !tbaa !13
  br label %284

284:                                              ; preds = %510, %283
  %285 = load i32, ptr %20, align 4, !tbaa !13
  %286 = load i32, ptr @atomnum, align 4, !tbaa !13
  %287 = icmp sle i32 %285, %286
  br i1 %287, label %289, label %288

288:                                              ; preds = %284
  store i32 9, ptr %16, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #8
  br label %513

289:                                              ; preds = %284
  %290 = load ptr, ptr %4, align 8, !tbaa !9
  %291 = getelementptr inbounds %struct.AtomListStr, ptr %290, i32 0, i32 7
  %292 = load ptr, ptr %291, align 8, !tbaa !17
  %293 = load i32, ptr %20, align 4, !tbaa !13
  %294 = sext i32 %293 to i64
  %295 = getelementptr inbounds ptr, ptr %292, i64 %294
  %296 = load ptr, ptr %295, align 8, !tbaa !9
  %297 = getelementptr inbounds %struct.AtomStr, ptr %296, i32 0, i32 1
  %298 = load ptr, ptr %297, align 8, !tbaa !19
  %299 = getelementptr inbounds %struct.DynamicStr, ptr %298, i32 0, i32 1
  %300 = getelementptr inbounds [4 x double], ptr %299, i64 0, i64 1
  %301 = load double, ptr %300, align 8, !tbaa !11
  %302 = load ptr, ptr %4, align 8, !tbaa !9
  %303 = getelementptr inbounds %struct.AtomListStr, ptr %302, i32 0, i32 7
  %304 = load ptr, ptr %303, align 8, !tbaa !17
  %305 = load i32, ptr %15, align 4, !tbaa !13
  %306 = sext i32 %305 to i64
  %307 = getelementptr inbounds ptr, ptr %304, i64 %306
  %308 = load ptr, ptr %307, align 8, !tbaa !9
  %309 = getelementptr inbounds %struct.AtomStr, ptr %308, i32 0, i32 1
  %310 = load ptr, ptr %309, align 8, !tbaa !19
  %311 = getelementptr inbounds %struct.DynamicStr, ptr %310, i32 0, i32 1
  %312 = getelementptr inbounds [4 x double], ptr %311, i64 0, i64 1
  %313 = load double, ptr %312, align 8, !tbaa !11
  %314 = fsub double %301, %313
  %315 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  store double %314, ptr %315, align 8, !tbaa !11
  %316 = load ptr, ptr %4, align 8, !tbaa !9
  %317 = getelementptr inbounds %struct.AtomListStr, ptr %316, i32 0, i32 7
  %318 = load ptr, ptr %317, align 8, !tbaa !17
  %319 = load i32, ptr %20, align 4, !tbaa !13
  %320 = sext i32 %319 to i64
  %321 = getelementptr inbounds ptr, ptr %318, i64 %320
  %322 = load ptr, ptr %321, align 8, !tbaa !9
  %323 = getelementptr inbounds %struct.AtomStr, ptr %322, i32 0, i32 1
  %324 = load ptr, ptr %323, align 8, !tbaa !19
  %325 = getelementptr inbounds %struct.DynamicStr, ptr %324, i32 0, i32 1
  %326 = getelementptr inbounds [4 x double], ptr %325, i64 0, i64 2
  %327 = load double, ptr %326, align 8, !tbaa !11
  %328 = load ptr, ptr %4, align 8, !tbaa !9
  %329 = getelementptr inbounds %struct.AtomListStr, ptr %328, i32 0, i32 7
  %330 = load ptr, ptr %329, align 8, !tbaa !17
  %331 = load i32, ptr %15, align 4, !tbaa !13
  %332 = sext i32 %331 to i64
  %333 = getelementptr inbounds ptr, ptr %330, i64 %332
  %334 = load ptr, ptr %333, align 8, !tbaa !9
  %335 = getelementptr inbounds %struct.AtomStr, ptr %334, i32 0, i32 1
  %336 = load ptr, ptr %335, align 8, !tbaa !19
  %337 = getelementptr inbounds %struct.DynamicStr, ptr %336, i32 0, i32 1
  %338 = getelementptr inbounds [4 x double], ptr %337, i64 0, i64 2
  %339 = load double, ptr %338, align 8, !tbaa !11
  %340 = fsub double %327, %339
  %341 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  store double %340, ptr %341, align 16, !tbaa !11
  %342 = load ptr, ptr %4, align 8, !tbaa !9
  %343 = getelementptr inbounds %struct.AtomListStr, ptr %342, i32 0, i32 7
  %344 = load ptr, ptr %343, align 8, !tbaa !17
  %345 = load i32, ptr %20, align 4, !tbaa !13
  %346 = sext i32 %345 to i64
  %347 = getelementptr inbounds ptr, ptr %344, i64 %346
  %348 = load ptr, ptr %347, align 8, !tbaa !9
  %349 = getelementptr inbounds %struct.AtomStr, ptr %348, i32 0, i32 1
  %350 = load ptr, ptr %349, align 8, !tbaa !19
  %351 = getelementptr inbounds %struct.DynamicStr, ptr %350, i32 0, i32 1
  %352 = getelementptr inbounds [4 x double], ptr %351, i64 0, i64 3
  %353 = load double, ptr %352, align 8, !tbaa !11
  %354 = load ptr, ptr %4, align 8, !tbaa !9
  %355 = getelementptr inbounds %struct.AtomListStr, ptr %354, i32 0, i32 7
  %356 = load ptr, ptr %355, align 8, !tbaa !17
  %357 = load i32, ptr %15, align 4, !tbaa !13
  %358 = sext i32 %357 to i64
  %359 = getelementptr inbounds ptr, ptr %356, i64 %358
  %360 = load ptr, ptr %359, align 8, !tbaa !9
  %361 = getelementptr inbounds %struct.AtomStr, ptr %360, i32 0, i32 1
  %362 = load ptr, ptr %361, align 8, !tbaa !19
  %363 = getelementptr inbounds %struct.DynamicStr, ptr %362, i32 0, i32 1
  %364 = getelementptr inbounds [4 x double], ptr %363, i64 0, i64 3
  %365 = load double, ptr %364, align 8, !tbaa !11
  %366 = fsub double %353, %365
  %367 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  store double %366, ptr %367, align 8, !tbaa !11
  %368 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  %369 = load double, ptr %368, align 8, !tbaa !11
  %370 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  %371 = load double, ptr %370, align 8, !tbaa !11
  %372 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  %373 = load double, ptr %372, align 16, !tbaa !11
  %374 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  %375 = load double, ptr %374, align 16, !tbaa !11
  %376 = fmul double %373, %375
  %377 = call double @llvm.fmuladd.f64(double %369, double %371, double %376)
  %378 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  %379 = load double, ptr %378, align 8, !tbaa !11
  %380 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  %381 = load double, ptr %380, align 8, !tbaa !11
  %382 = call double @llvm.fmuladd.f64(double %379, double %381, double %377)
  store double %382, ptr %11, align 8, !tbaa !11
  %383 = load double, ptr %11, align 8, !tbaa !11
  %384 = fcmp ole double %383, 1.440000e+02
  br i1 %384, label %385, label %509

385:                                              ; preds = %289
  %386 = load ptr, ptr @connectionMap, align 8, !tbaa !9
  %387 = load i32, ptr %15, align 4, !tbaa !13
  %388 = sext i32 %387 to i64
  %389 = getelementptr inbounds ptr, ptr %386, i64 %388
  %390 = load ptr, ptr %389, align 8, !tbaa !9
  %391 = load i32, ptr %20, align 4, !tbaa !13
  %392 = sext i32 %391 to i64
  %393 = getelementptr inbounds i32, ptr %390, i64 %392
  %394 = load i32, ptr %393, align 4, !tbaa !13
  %395 = and i32 %394, 1
  %396 = icmp ne i32 %395, 0
  br i1 %396, label %509, label %397

397:                                              ; preds = %385
  %398 = load ptr, ptr @connectionMap, align 8, !tbaa !9
  %399 = load i32, ptr %15, align 4, !tbaa !13
  %400 = sext i32 %399 to i64
  %401 = getelementptr inbounds ptr, ptr %398, i64 %400
  %402 = load ptr, ptr %401, align 8, !tbaa !9
  %403 = load i32, ptr %20, align 4, !tbaa !13
  %404 = sext i32 %403 to i64
  %405 = getelementptr inbounds i32, ptr %402, i64 %404
  %406 = load i32, ptr %405, align 4, !tbaa !13
  %407 = and i32 %406, 2
  %408 = icmp ne i32 %407, 0
  br i1 %408, label %509, label %409

409:                                              ; preds = %397
  %410 = load i32, ptr %15, align 4, !tbaa !13
  %411 = load i32, ptr %20, align 4, !tbaa !13
  %412 = icmp ne i32 %410, %411
  br i1 %412, label %413, label %508

413:                                              ; preds = %409
  %414 = load ptr, ptr %13, align 8, !tbaa !9
  %415 = load i32, ptr %15, align 4, !tbaa !13
  %416 = sext i32 %415 to i64
  %417 = getelementptr inbounds %struct.interStr, ptr %414, i64 %416
  %418 = getelementptr inbounds %struct.interStr, ptr %417, i32 0, i32 0
  %419 = getelementptr inbounds [512 x i32], ptr %418, i64 0, i64 0
  %420 = load i32, ptr %20, align 4, !tbaa !13
  %421 = call i32 @FindElemInList(ptr noundef %419, i32 noundef %420, i32 noundef -1, i32 noundef -1, i32 noundef 0)
  %422 = icmp ne i32 %421, 0
  br i1 %422, label %508, label %423

423:                                              ; preds = %413
  %424 = load i32, ptr %17, align 4, !tbaa !13
  %425 = add nsw i32 %424, 1
  store i32 %425, ptr %17, align 4, !tbaa !13
  %426 = load i32, ptr %20, align 4, !tbaa !13
  %427 = load ptr, ptr %13, align 8, !tbaa !9
  %428 = load i32, ptr %15, align 4, !tbaa !13
  %429 = sext i32 %428 to i64
  %430 = getelementptr inbounds %struct.interStr, ptr %427, i64 %429
  %431 = getelementptr inbounds %struct.interStr, ptr %430, i32 0, i32 0
  %432 = load i32, ptr %17, align 4, !tbaa !13
  %433 = sext i32 %432 to i64
  %434 = getelementptr inbounds [512 x i32], ptr %431, i64 0, i64 %433
  store i32 %426, ptr %434, align 4, !tbaa !13
  %435 = load ptr, ptr %13, align 8, !tbaa !9
  %436 = load i32, ptr %15, align 4, !tbaa !13
  %437 = sext i32 %436 to i64
  %438 = getelementptr inbounds %struct.interStr, ptr %435, i64 %437
  %439 = getelementptr inbounds %struct.interStr, ptr %438, i32 0, i32 2
  %440 = load i32, ptr %17, align 4, !tbaa !13
  %441 = sext i32 %440 to i64
  %442 = getelementptr inbounds [512 x double], ptr %439, i64 0, i64 %441
  store double 1.000000e+08, ptr %442, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 4, ptr %21) #8
  %443 = load ptr, ptr %4, align 8, !tbaa !9
  %444 = getelementptr inbounds %struct.AtomListStr, ptr %443, i32 0, i32 7
  %445 = load ptr, ptr %444, align 8, !tbaa !17
  %446 = load i32, ptr %15, align 4, !tbaa !13
  %447 = sext i32 %446 to i64
  %448 = getelementptr inbounds ptr, ptr %445, i64 %447
  %449 = load ptr, ptr %448, align 8, !tbaa !9
  %450 = getelementptr inbounds %struct.AtomStr, ptr %449, i32 0, i32 0
  %451 = load ptr, ptr %450, align 8, !tbaa !21
  %452 = getelementptr inbounds %struct.PropertyStr, ptr %451, i32 0, i32 4
  %453 = load i32, ptr %452, align 4, !tbaa !34
  store i32 %453, ptr %21, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 4, ptr %22) #8
  %454 = load ptr, ptr %4, align 8, !tbaa !9
  %455 = getelementptr inbounds %struct.AtomListStr, ptr %454, i32 0, i32 7
  %456 = load ptr, ptr %455, align 8, !tbaa !17
  %457 = load i32, ptr %20, align 4, !tbaa !13
  %458 = sext i32 %457 to i64
  %459 = getelementptr inbounds ptr, ptr %456, i64 %458
  %460 = load ptr, ptr %459, align 8, !tbaa !9
  %461 = getelementptr inbounds %struct.AtomStr, ptr %460, i32 0, i32 0
  %462 = load ptr, ptr %461, align 8, !tbaa !21
  %463 = getelementptr inbounds %struct.PropertyStr, ptr %462, i32 0, i32 4
  %464 = load i32, ptr %463, align 4, !tbaa !34
  store i32 %464, ptr %22, align 4, !tbaa !13
  %465 = load i32, ptr %21, align 4, !tbaa !13
  %466 = load i32, ptr %22, align 4, !tbaa !13
  %467 = icmp sgt i32 %465, %466
  br i1 %467, label %468, label %472

468:                                              ; preds = %423
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #8
  %469 = load i32, ptr %22, align 4, !tbaa !13
  store i32 %469, ptr %23, align 4, !tbaa !13
  %470 = load i32, ptr %21, align 4, !tbaa !13
  store i32 %470, ptr %22, align 4, !tbaa !13
  %471 = load i32, ptr %23, align 4, !tbaa !13
  store i32 %471, ptr %21, align 4, !tbaa !13
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #8
  br label %472

472:                                              ; preds = %468, %423
  %473 = load i32, ptr %21, align 4, !tbaa !13
  %474 = sext i32 %473 to i64
  %475 = getelementptr inbounds [33 x [33 x %struct.ConstraintStr]], ptr @potentialPairCollision, i64 0, i64 %474
  %476 = load i32, ptr %22, align 4, !tbaa !13
  %477 = sext i32 %476 to i64
  %478 = getelementptr inbounds [33 x %struct.ConstraintStr], ptr %475, i64 0, i64 %477
  %479 = getelementptr inbounds %struct.ConstraintStr, ptr %478, i32 0, i32 1
  %480 = load double, ptr %479, align 8, !tbaa !28
  %481 = call double @sqrt(double noundef %480) #8
  %482 = load ptr, ptr %13, align 8, !tbaa !9
  %483 = load i32, ptr %15, align 4, !tbaa !13
  %484 = sext i32 %483 to i64
  %485 = getelementptr inbounds %struct.interStr, ptr %482, i64 %484
  %486 = getelementptr inbounds %struct.interStr, ptr %485, i32 0, i32 3
  %487 = load i32, ptr %17, align 4, !tbaa !13
  %488 = sext i32 %487 to i64
  %489 = getelementptr inbounds [512 x double], ptr %486, i64 0, i64 %488
  store double %481, ptr %489, align 8, !tbaa !11
  %490 = load ptr, ptr %13, align 8, !tbaa !9
  %491 = load i32, ptr %15, align 4, !tbaa !13
  %492 = sext i32 %491 to i64
  %493 = getelementptr inbounds %struct.interStr, ptr %490, i64 %492
  %494 = getelementptr inbounds %struct.interStr, ptr %493, i32 0, i32 3
  %495 = load i32, ptr %17, align 4, !tbaa !13
  %496 = sext i32 %495 to i64
  %497 = getelementptr inbounds [512 x double], ptr %494, i64 0, i64 %496
  %498 = load double, ptr %497, align 8, !tbaa !11
  %499 = fadd double %498, 1.000000e-03
  %500 = load ptr, ptr %13, align 8, !tbaa !9
  %501 = load i32, ptr %15, align 4, !tbaa !13
  %502 = sext i32 %501 to i64
  %503 = getelementptr inbounds %struct.interStr, ptr %500, i64 %502
  %504 = getelementptr inbounds %struct.interStr, ptr %503, i32 0, i32 4
  %505 = load i32, ptr %17, align 4, !tbaa !13
  %506 = sext i32 %505 to i64
  %507 = getelementptr inbounds [512 x double], ptr %504, i64 0, i64 %506
  store double %499, ptr %507, align 8, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %22) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %21) #8
  br label %508

508:                                              ; preds = %472, %413, %409
  br label %509

509:                                              ; preds = %508, %397, %385, %289
  br label %510

510:                                              ; preds = %509
  %511 = load i32, ptr %20, align 4, !tbaa !13
  %512 = add nsw i32 %511, 1
  store i32 %512, ptr %20, align 4, !tbaa !13
  br label %284, !llvm.loop !35

513:                                              ; preds = %288
  %514 = load i32, ptr %17, align 4, !tbaa !13
  %515 = icmp sgt i32 %514, 510
  br i1 %515, label %516, label %520

516:                                              ; preds = %513
  %517 = load i32, ptr %15, align 4, !tbaa !13
  %518 = load i32, ptr %17, align 4, !tbaa !13
  %519 = call i32 (ptr, ...) @printf(ptr noundef @.str.21, i32 noundef %517, i32 noundef %518, ptr noundef @.str.2, i32 noundef 407)
  call void @exit(i32 noundef 1) #10
  unreachable

520:                                              ; preds = %513
  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 4, ptr %17) #8
  br label %521

521:                                              ; preds = %520
  %522 = load i32, ptr %15, align 4, !tbaa !13
  %523 = add nsw i32 %522, 1
  store i32 %523, ptr %15, align 4, !tbaa !13
  br label %38, !llvm.loop !36

524:                                              ; preds = %42
  %525 = call i32 (ptr, ...) @printf(ptr noundef @.str.22)
  br label %526

526:                                              ; preds = %1126, %524
  %527 = load i64, ptr %6, align 8, !tbaa !5
  %528 = icmp sgt i64 %527, 0
  br i1 %528, label %529, label %1127

529:                                              ; preds = %526
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #8
  store i32 1, ptr %24, align 4, !tbaa !13
  br label %530

530:                                              ; preds = %762, %529
  %531 = load i32, ptr %24, align 4, !tbaa !13
  %532 = load i32, ptr @atomnum, align 4, !tbaa !13
  %533 = icmp sle i32 %531, %532
  br i1 %533, label %535, label %534

534:                                              ; preds = %530
  store i32 14, ptr %16, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #8
  br label %765

535:                                              ; preds = %530
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #8
  store i32 1, ptr %25, align 4, !tbaa !13
  call void @llvm.lifetime.start.p0(i64 32, ptr %26) #8
  call void @llvm.memset.p0.i64(ptr align 16 %26, i8 0, i64 32, i1 false)
  br label %536

536:                                              ; preds = %728, %535
  %537 = load ptr, ptr %13, align 8, !tbaa !9
  %538 = load i32, ptr %24, align 4, !tbaa !13
  %539 = sext i32 %538 to i64
  %540 = getelementptr inbounds %struct.interStr, ptr %537, i64 %539
  %541 = getelementptr inbounds %struct.interStr, ptr %540, i32 0, i32 0
  %542 = load i32, ptr %25, align 4, !tbaa !13
  %543 = sext i32 %542 to i64
  %544 = getelementptr inbounds [512 x i32], ptr %541, i64 0, i64 %543
  %545 = load i32, ptr %544, align 4, !tbaa !13
  %546 = icmp ne i32 %545, 0
  br i1 %546, label %547, label %731

547:                                              ; preds = %536
  %548 = load ptr, ptr %13, align 8, !tbaa !9
  %549 = load ptr, ptr %13, align 8, !tbaa !9
  %550 = load i32, ptr %24, align 4, !tbaa !13
  %551 = sext i32 %550 to i64
  %552 = getelementptr inbounds %struct.interStr, ptr %549, i64 %551
  %553 = getelementptr inbounds %struct.interStr, ptr %552, i32 0, i32 0
  %554 = load i32, ptr %25, align 4, !tbaa !13
  %555 = sext i32 %554 to i64
  %556 = getelementptr inbounds [512 x i32], ptr %553, i64 0, i64 %555
  %557 = load i32, ptr %556, align 4, !tbaa !13
  %558 = sext i32 %557 to i64
  %559 = getelementptr inbounds %struct.interStr, ptr %548, i64 %558
  %560 = getelementptr inbounds %struct.interStr, ptr %559, i32 0, i32 1
  %561 = getelementptr inbounds [4 x double], ptr %560, i64 0, i64 1
  %562 = load double, ptr %561, align 8, !tbaa !11
  %563 = load ptr, ptr %13, align 8, !tbaa !9
  %564 = load i32, ptr %24, align 4, !tbaa !13
  %565 = sext i32 %564 to i64
  %566 = getelementptr inbounds %struct.interStr, ptr %563, i64 %565
  %567 = getelementptr inbounds %struct.interStr, ptr %566, i32 0, i32 1
  %568 = getelementptr inbounds [4 x double], ptr %567, i64 0, i64 1
  %569 = load double, ptr %568, align 8, !tbaa !11
  %570 = fsub double %562, %569
  %571 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  store double %570, ptr %571, align 8, !tbaa !11
  %572 = load ptr, ptr %13, align 8, !tbaa !9
  %573 = load ptr, ptr %13, align 8, !tbaa !9
  %574 = load i32, ptr %24, align 4, !tbaa !13
  %575 = sext i32 %574 to i64
  %576 = getelementptr inbounds %struct.interStr, ptr %573, i64 %575
  %577 = getelementptr inbounds %struct.interStr, ptr %576, i32 0, i32 0
  %578 = load i32, ptr %25, align 4, !tbaa !13
  %579 = sext i32 %578 to i64
  %580 = getelementptr inbounds [512 x i32], ptr %577, i64 0, i64 %579
  %581 = load i32, ptr %580, align 4, !tbaa !13
  %582 = sext i32 %581 to i64
  %583 = getelementptr inbounds %struct.interStr, ptr %572, i64 %582
  %584 = getelementptr inbounds %struct.interStr, ptr %583, i32 0, i32 1
  %585 = getelementptr inbounds [4 x double], ptr %584, i64 0, i64 2
  %586 = load double, ptr %585, align 8, !tbaa !11
  %587 = load ptr, ptr %13, align 8, !tbaa !9
  %588 = load i32, ptr %24, align 4, !tbaa !13
  %589 = sext i32 %588 to i64
  %590 = getelementptr inbounds %struct.interStr, ptr %587, i64 %589
  %591 = getelementptr inbounds %struct.interStr, ptr %590, i32 0, i32 1
  %592 = getelementptr inbounds [4 x double], ptr %591, i64 0, i64 2
  %593 = load double, ptr %592, align 8, !tbaa !11
  %594 = fsub double %586, %593
  %595 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  store double %594, ptr %595, align 16, !tbaa !11
  %596 = load ptr, ptr %13, align 8, !tbaa !9
  %597 = load ptr, ptr %13, align 8, !tbaa !9
  %598 = load i32, ptr %24, align 4, !tbaa !13
  %599 = sext i32 %598 to i64
  %600 = getelementptr inbounds %struct.interStr, ptr %597, i64 %599
  %601 = getelementptr inbounds %struct.interStr, ptr %600, i32 0, i32 0
  %602 = load i32, ptr %25, align 4, !tbaa !13
  %603 = sext i32 %602 to i64
  %604 = getelementptr inbounds [512 x i32], ptr %601, i64 0, i64 %603
  %605 = load i32, ptr %604, align 4, !tbaa !13
  %606 = sext i32 %605 to i64
  %607 = getelementptr inbounds %struct.interStr, ptr %596, i64 %606
  %608 = getelementptr inbounds %struct.interStr, ptr %607, i32 0, i32 1
  %609 = getelementptr inbounds [4 x double], ptr %608, i64 0, i64 3
  %610 = load double, ptr %609, align 8, !tbaa !11
  %611 = load ptr, ptr %13, align 8, !tbaa !9
  %612 = load i32, ptr %24, align 4, !tbaa !13
  %613 = sext i32 %612 to i64
  %614 = getelementptr inbounds %struct.interStr, ptr %611, i64 %613
  %615 = getelementptr inbounds %struct.interStr, ptr %614, i32 0, i32 1
  %616 = getelementptr inbounds [4 x double], ptr %615, i64 0, i64 3
  %617 = load double, ptr %616, align 8, !tbaa !11
  %618 = fsub double %610, %617
  %619 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  store double %618, ptr %619, align 8, !tbaa !11
  %620 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  %621 = load double, ptr %620, align 8, !tbaa !11
  %622 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  %623 = load double, ptr %622, align 8, !tbaa !11
  %624 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  %625 = load double, ptr %624, align 16, !tbaa !11
  %626 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  %627 = load double, ptr %626, align 16, !tbaa !11
  %628 = fmul double %625, %627
  %629 = call double @llvm.fmuladd.f64(double %621, double %623, double %628)
  %630 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  %631 = load double, ptr %630, align 8, !tbaa !11
  %632 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  %633 = load double, ptr %632, align 8, !tbaa !11
  %634 = call double @llvm.fmuladd.f64(double %631, double %633, double %629)
  store double %634, ptr %11, align 8, !tbaa !11
  %635 = load double, ptr %11, align 8, !tbaa !11
  %636 = call double @sqrt(double noundef %635) #8
  store double %636, ptr %11, align 8, !tbaa !11
  %637 = load double, ptr %11, align 8, !tbaa !11
  %638 = load ptr, ptr %13, align 8, !tbaa !9
  %639 = load i32, ptr %24, align 4, !tbaa !13
  %640 = sext i32 %639 to i64
  %641 = getelementptr inbounds %struct.interStr, ptr %638, i64 %640
  %642 = getelementptr inbounds %struct.interStr, ptr %641, i32 0, i32 2
  %643 = load i32, ptr %25, align 4, !tbaa !13
  %644 = sext i32 %643 to i64
  %645 = getelementptr inbounds [512 x double], ptr %642, i64 0, i64 %644
  %646 = load double, ptr %645, align 8, !tbaa !11
  %647 = fcmp oge double %637, %646
  br i1 %647, label %660, label %648

648:                                              ; preds = %547
  %649 = load double, ptr %11, align 8, !tbaa !11
  %650 = load ptr, ptr %13, align 8, !tbaa !9
  %651 = load i32, ptr %24, align 4, !tbaa !13
  %652 = sext i32 %651 to i64
  %653 = getelementptr inbounds %struct.interStr, ptr %650, i64 %652
  %654 = getelementptr inbounds %struct.interStr, ptr %653, i32 0, i32 3
  %655 = load i32, ptr %25, align 4, !tbaa !13
  %656 = sext i32 %655 to i64
  %657 = getelementptr inbounds [512 x double], ptr %654, i64 0, i64 %656
  %658 = load double, ptr %657, align 8, !tbaa !11
  %659 = fcmp ole double %649, %658
  br i1 %659, label %660, label %728

660:                                              ; preds = %648, %547
  %661 = load ptr, ptr %13, align 8, !tbaa !9
  %662 = load i32, ptr %24, align 4, !tbaa !13
  %663 = sext i32 %662 to i64
  %664 = getelementptr inbounds %struct.interStr, ptr %661, i64 %663
  %665 = getelementptr inbounds %struct.interStr, ptr %664, i32 0, i32 4
  %666 = load i32, ptr %25, align 4, !tbaa !13
  %667 = sext i32 %666 to i64
  %668 = getelementptr inbounds [512 x double], ptr %665, i64 0, i64 %667
  %669 = load double, ptr %668, align 8, !tbaa !11
  %670 = load double, ptr %11, align 8, !tbaa !11
  %671 = fsub double %669, %670
  store double %671, ptr %8, align 8, !tbaa !11
  %672 = call double @RandomValue(i32 noundef 0, i32 noundef 1)
  %673 = load double, ptr %7, align 8, !tbaa !11
  %674 = fmul double %672, %673
  %675 = load double, ptr %8, align 8, !tbaa !11
  %676 = fmul double %674, %675
  store double %676, ptr %9, align 8, !tbaa !11
  %677 = load double, ptr %9, align 8, !tbaa !11
  %678 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  %679 = load double, ptr %678, align 8, !tbaa !11
  %680 = fmul double %677, %679
  %681 = load ptr, ptr %13, align 8, !tbaa !9
  %682 = load i32, ptr %24, align 4, !tbaa !13
  %683 = sext i32 %682 to i64
  %684 = getelementptr inbounds %struct.interStr, ptr %681, i64 %683
  %685 = getelementptr inbounds %struct.interStr, ptr %684, i32 0, i32 4
  %686 = load i32, ptr %25, align 4, !tbaa !13
  %687 = sext i32 %686 to i64
  %688 = getelementptr inbounds [512 x double], ptr %685, i64 0, i64 %687
  %689 = load double, ptr %688, align 8, !tbaa !11
  %690 = fdiv double %680, %689
  %691 = getelementptr inbounds [4 x double], ptr %26, i64 0, i64 1
  %692 = load double, ptr %691, align 8, !tbaa !11
  %693 = fsub double %692, %690
  store double %693, ptr %691, align 8, !tbaa !11
  %694 = load double, ptr %9, align 8, !tbaa !11
  %695 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  %696 = load double, ptr %695, align 16, !tbaa !11
  %697 = fmul double %694, %696
  %698 = load ptr, ptr %13, align 8, !tbaa !9
  %699 = load i32, ptr %24, align 4, !tbaa !13
  %700 = sext i32 %699 to i64
  %701 = getelementptr inbounds %struct.interStr, ptr %698, i64 %700
  %702 = getelementptr inbounds %struct.interStr, ptr %701, i32 0, i32 4
  %703 = load i32, ptr %25, align 4, !tbaa !13
  %704 = sext i32 %703 to i64
  %705 = getelementptr inbounds [512 x double], ptr %702, i64 0, i64 %704
  %706 = load double, ptr %705, align 8, !tbaa !11
  %707 = fdiv double %697, %706
  %708 = getelementptr inbounds [4 x double], ptr %26, i64 0, i64 2
  %709 = load double, ptr %708, align 16, !tbaa !11
  %710 = fsub double %709, %707
  store double %710, ptr %708, align 16, !tbaa !11
  %711 = load double, ptr %9, align 8, !tbaa !11
  %712 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  %713 = load double, ptr %712, align 8, !tbaa !11
  %714 = fmul double %711, %713
  %715 = load ptr, ptr %13, align 8, !tbaa !9
  %716 = load i32, ptr %24, align 4, !tbaa !13
  %717 = sext i32 %716 to i64
  %718 = getelementptr inbounds %struct.interStr, ptr %715, i64 %717
  %719 = getelementptr inbounds %struct.interStr, ptr %718, i32 0, i32 4
  %720 = load i32, ptr %25, align 4, !tbaa !13
  %721 = sext i32 %720 to i64
  %722 = getelementptr inbounds [512 x double], ptr %719, i64 0, i64 %721
  %723 = load double, ptr %722, align 8, !tbaa !11
  %724 = fdiv double %714, %723
  %725 = getelementptr inbounds [4 x double], ptr %26, i64 0, i64 3
  %726 = load double, ptr %725, align 8, !tbaa !11
  %727 = fsub double %726, %724
  store double %727, ptr %725, align 8, !tbaa !11
  br label %728

728:                                              ; preds = %660, %648
  %729 = load i32, ptr %25, align 4, !tbaa !13
  %730 = add nsw i32 %729, 1
  store i32 %730, ptr %25, align 4, !tbaa !13
  br label %536, !llvm.loop !37

731:                                              ; preds = %536
  %732 = getelementptr inbounds [4 x double], ptr %26, i64 0, i64 1
  %733 = load double, ptr %732, align 8, !tbaa !11
  %734 = load ptr, ptr %13, align 8, !tbaa !9
  %735 = load i32, ptr %24, align 4, !tbaa !13
  %736 = sext i32 %735 to i64
  %737 = getelementptr inbounds %struct.interStr, ptr %734, i64 %736
  %738 = getelementptr inbounds %struct.interStr, ptr %737, i32 0, i32 1
  %739 = getelementptr inbounds [4 x double], ptr %738, i64 0, i64 1
  %740 = load double, ptr %739, align 8, !tbaa !11
  %741 = fadd double %740, %733
  store double %741, ptr %739, align 8, !tbaa !11
  %742 = getelementptr inbounds [4 x double], ptr %26, i64 0, i64 2
  %743 = load double, ptr %742, align 16, !tbaa !11
  %744 = load ptr, ptr %13, align 8, !tbaa !9
  %745 = load i32, ptr %24, align 4, !tbaa !13
  %746 = sext i32 %745 to i64
  %747 = getelementptr inbounds %struct.interStr, ptr %744, i64 %746
  %748 = getelementptr inbounds %struct.interStr, ptr %747, i32 0, i32 1
  %749 = getelementptr inbounds [4 x double], ptr %748, i64 0, i64 2
  %750 = load double, ptr %749, align 8, !tbaa !11
  %751 = fadd double %750, %743
  store double %751, ptr %749, align 8, !tbaa !11
  %752 = getelementptr inbounds [4 x double], ptr %26, i64 0, i64 3
  %753 = load double, ptr %752, align 8, !tbaa !11
  %754 = load ptr, ptr %13, align 8, !tbaa !9
  %755 = load i32, ptr %24, align 4, !tbaa !13
  %756 = sext i32 %755 to i64
  %757 = getelementptr inbounds %struct.interStr, ptr %754, i64 %756
  %758 = getelementptr inbounds %struct.interStr, ptr %757, i32 0, i32 1
  %759 = getelementptr inbounds [4 x double], ptr %758, i64 0, i64 3
  %760 = load double, ptr %759, align 8, !tbaa !11
  %761 = fadd double %760, %753
  store double %761, ptr %759, align 8, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 32, ptr %26) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #8
  br label %762

762:                                              ; preds = %731
  %763 = load i32, ptr %24, align 4, !tbaa !13
  %764 = add nsw i32 %763, 1
  store i32 %764, ptr %24, align 4, !tbaa !13
  br label %530, !llvm.loop !38

765:                                              ; preds = %534
  store i64 0, ptr %6, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #8
  store i32 1, ptr %27, align 4, !tbaa !13
  br label %766

766:                                              ; preds = %1099, %765
  %767 = load i32, ptr %27, align 4, !tbaa !13
  %768 = load i32, ptr @atomnum, align 4, !tbaa !13
  %769 = icmp sle i32 %767, %768
  br i1 %769, label %771, label %770

770:                                              ; preds = %766
  store i32 19, ptr %16, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #8
  br label %1102

771:                                              ; preds = %766
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #8
  store i32 1, ptr %28, align 4, !tbaa !13
  br label %772

772:                                              ; preds = %1023, %795, %771
  %773 = load ptr, ptr %13, align 8, !tbaa !9
  %774 = load i32, ptr %27, align 4, !tbaa !13
  %775 = sext i32 %774 to i64
  %776 = getelementptr inbounds %struct.interStr, ptr %773, i64 %775
  %777 = getelementptr inbounds %struct.interStr, ptr %776, i32 0, i32 0
  %778 = load i32, ptr %28, align 4, !tbaa !13
  %779 = sext i32 %778 to i64
  %780 = getelementptr inbounds [512 x i32], ptr %777, i64 0, i64 %779
  %781 = load i32, ptr %780, align 4, !tbaa !13
  %782 = icmp ne i32 %781, 0
  br i1 %782, label %783, label %1026

783:                                              ; preds = %772
  %784 = load ptr, ptr %13, align 8, !tbaa !9
  %785 = load i32, ptr %27, align 4, !tbaa !13
  %786 = sext i32 %785 to i64
  %787 = getelementptr inbounds %struct.interStr, ptr %784, i64 %786
  %788 = getelementptr inbounds %struct.interStr, ptr %787, i32 0, i32 0
  %789 = load i32, ptr %28, align 4, !tbaa !13
  %790 = sext i32 %789 to i64
  %791 = getelementptr inbounds [512 x i32], ptr %788, i64 0, i64 %790
  %792 = load i32, ptr %791, align 4, !tbaa !13
  %793 = load i32, ptr %27, align 4, !tbaa !13
  %794 = icmp slt i32 %792, %793
  br i1 %794, label %795, label %798

795:                                              ; preds = %783
  %796 = load i32, ptr %28, align 4, !tbaa !13
  %797 = add nsw i32 %796, 1
  store i32 %797, ptr %28, align 4, !tbaa !13
  br label %772, !llvm.loop !39

798:                                              ; preds = %783
  %799 = load ptr, ptr %13, align 8, !tbaa !9
  %800 = load ptr, ptr %13, align 8, !tbaa !9
  %801 = load i32, ptr %27, align 4, !tbaa !13
  %802 = sext i32 %801 to i64
  %803 = getelementptr inbounds %struct.interStr, ptr %800, i64 %802
  %804 = getelementptr inbounds %struct.interStr, ptr %803, i32 0, i32 0
  %805 = load i32, ptr %28, align 4, !tbaa !13
  %806 = sext i32 %805 to i64
  %807 = getelementptr inbounds [512 x i32], ptr %804, i64 0, i64 %806
  %808 = load i32, ptr %807, align 4, !tbaa !13
  %809 = sext i32 %808 to i64
  %810 = getelementptr inbounds %struct.interStr, ptr %799, i64 %809
  %811 = getelementptr inbounds %struct.interStr, ptr %810, i32 0, i32 1
  %812 = getelementptr inbounds [4 x double], ptr %811, i64 0, i64 1
  %813 = load double, ptr %812, align 8, !tbaa !11
  %814 = load ptr, ptr %13, align 8, !tbaa !9
  %815 = load i32, ptr %27, align 4, !tbaa !13
  %816 = sext i32 %815 to i64
  %817 = getelementptr inbounds %struct.interStr, ptr %814, i64 %816
  %818 = getelementptr inbounds %struct.interStr, ptr %817, i32 0, i32 1
  %819 = getelementptr inbounds [4 x double], ptr %818, i64 0, i64 1
  %820 = load double, ptr %819, align 8, !tbaa !11
  %821 = fsub double %813, %820
  %822 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  store double %821, ptr %822, align 8, !tbaa !11
  %823 = load ptr, ptr %13, align 8, !tbaa !9
  %824 = load ptr, ptr %13, align 8, !tbaa !9
  %825 = load i32, ptr %27, align 4, !tbaa !13
  %826 = sext i32 %825 to i64
  %827 = getelementptr inbounds %struct.interStr, ptr %824, i64 %826
  %828 = getelementptr inbounds %struct.interStr, ptr %827, i32 0, i32 0
  %829 = load i32, ptr %28, align 4, !tbaa !13
  %830 = sext i32 %829 to i64
  %831 = getelementptr inbounds [512 x i32], ptr %828, i64 0, i64 %830
  %832 = load i32, ptr %831, align 4, !tbaa !13
  %833 = sext i32 %832 to i64
  %834 = getelementptr inbounds %struct.interStr, ptr %823, i64 %833
  %835 = getelementptr inbounds %struct.interStr, ptr %834, i32 0, i32 1
  %836 = getelementptr inbounds [4 x double], ptr %835, i64 0, i64 2
  %837 = load double, ptr %836, align 8, !tbaa !11
  %838 = load ptr, ptr %13, align 8, !tbaa !9
  %839 = load i32, ptr %27, align 4, !tbaa !13
  %840 = sext i32 %839 to i64
  %841 = getelementptr inbounds %struct.interStr, ptr %838, i64 %840
  %842 = getelementptr inbounds %struct.interStr, ptr %841, i32 0, i32 1
  %843 = getelementptr inbounds [4 x double], ptr %842, i64 0, i64 2
  %844 = load double, ptr %843, align 8, !tbaa !11
  %845 = fsub double %837, %844
  %846 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  store double %845, ptr %846, align 16, !tbaa !11
  %847 = load ptr, ptr %13, align 8, !tbaa !9
  %848 = load ptr, ptr %13, align 8, !tbaa !9
  %849 = load i32, ptr %27, align 4, !tbaa !13
  %850 = sext i32 %849 to i64
  %851 = getelementptr inbounds %struct.interStr, ptr %848, i64 %850
  %852 = getelementptr inbounds %struct.interStr, ptr %851, i32 0, i32 0
  %853 = load i32, ptr %28, align 4, !tbaa !13
  %854 = sext i32 %853 to i64
  %855 = getelementptr inbounds [512 x i32], ptr %852, i64 0, i64 %854
  %856 = load i32, ptr %855, align 4, !tbaa !13
  %857 = sext i32 %856 to i64
  %858 = getelementptr inbounds %struct.interStr, ptr %847, i64 %857
  %859 = getelementptr inbounds %struct.interStr, ptr %858, i32 0, i32 1
  %860 = getelementptr inbounds [4 x double], ptr %859, i64 0, i64 3
  %861 = load double, ptr %860, align 8, !tbaa !11
  %862 = load ptr, ptr %13, align 8, !tbaa !9
  %863 = load i32, ptr %27, align 4, !tbaa !13
  %864 = sext i32 %863 to i64
  %865 = getelementptr inbounds %struct.interStr, ptr %862, i64 %864
  %866 = getelementptr inbounds %struct.interStr, ptr %865, i32 0, i32 1
  %867 = getelementptr inbounds [4 x double], ptr %866, i64 0, i64 3
  %868 = load double, ptr %867, align 8, !tbaa !11
  %869 = fsub double %861, %868
  %870 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  store double %869, ptr %870, align 8, !tbaa !11
  %871 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  %872 = load double, ptr %871, align 8, !tbaa !11
  %873 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 1
  %874 = load double, ptr %873, align 8, !tbaa !11
  %875 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  %876 = load double, ptr %875, align 16, !tbaa !11
  %877 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 2
  %878 = load double, ptr %877, align 16, !tbaa !11
  %879 = fmul double %876, %878
  %880 = call double @llvm.fmuladd.f64(double %872, double %874, double %879)
  %881 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  %882 = load double, ptr %881, align 8, !tbaa !11
  %883 = getelementptr inbounds [4 x double], ptr %10, i64 0, i64 3
  %884 = load double, ptr %883, align 8, !tbaa !11
  %885 = call double @llvm.fmuladd.f64(double %882, double %884, double %880)
  store double %885, ptr %11, align 8, !tbaa !11
  %886 = load double, ptr %11, align 8, !tbaa !11
  %887 = call double @sqrt(double noundef %886) #8
  store double %887, ptr %11, align 8, !tbaa !11
  %888 = load double, ptr %11, align 8, !tbaa !11
  %889 = load ptr, ptr %13, align 8, !tbaa !9
  %890 = load i32, ptr %27, align 4, !tbaa !13
  %891 = sext i32 %890 to i64
  %892 = getelementptr inbounds %struct.interStr, ptr %889, i64 %891
  %893 = getelementptr inbounds %struct.interStr, ptr %892, i32 0, i32 2
  %894 = load i32, ptr %28, align 4, !tbaa !13
  %895 = sext i32 %894 to i64
  %896 = getelementptr inbounds [512 x double], ptr %893, i64 0, i64 %895
  %897 = load double, ptr %896, align 8, !tbaa !11
  %898 = fcmp oge double %888, %897
  br i1 %898, label %911, label %899

899:                                              ; preds = %798
  %900 = load double, ptr %11, align 8, !tbaa !11
  %901 = load ptr, ptr %13, align 8, !tbaa !9
  %902 = load i32, ptr %27, align 4, !tbaa !13
  %903 = sext i32 %902 to i64
  %904 = getelementptr inbounds %struct.interStr, ptr %901, i64 %903
  %905 = getelementptr inbounds %struct.interStr, ptr %904, i32 0, i32 3
  %906 = load i32, ptr %28, align 4, !tbaa !13
  %907 = sext i32 %906 to i64
  %908 = getelementptr inbounds [512 x double], ptr %905, i64 0, i64 %907
  %909 = load double, ptr %908, align 8, !tbaa !11
  %910 = fcmp ole double %900, %909
  br i1 %910, label %911, label %1023

911:                                              ; preds = %899, %798
  %912 = load i64, ptr %5, align 8, !tbaa !5
  %913 = load i64, ptr %3, align 8, !tbaa !5
  %914 = icmp eq i64 %912, %913
  br i1 %914, label %915, label %1020

915:                                              ; preds = %911
  %916 = load i32, ptr %27, align 4, !tbaa !13
  %917 = load ptr, ptr @atom, align 8, !tbaa !9
  %918 = load i32, ptr %27, align 4, !tbaa !13
  %919 = sext i32 %918 to i64
  %920 = getelementptr inbounds %struct.AtomStr, ptr %917, i64 %919
  %921 = getelementptr inbounds %struct.AtomStr, ptr %920, i32 0, i32 0
  %922 = load ptr, ptr %921, align 8, !tbaa !21
  %923 = getelementptr inbounds %struct.PropertyStr, ptr %922, i32 0, i32 2
  %924 = getelementptr inbounds [8 x i8], ptr %923, i64 0, i64 0
  %925 = load ptr, ptr @atom, align 8, !tbaa !9
  %926 = load i32, ptr %27, align 4, !tbaa !13
  %927 = sext i32 %926 to i64
  %928 = getelementptr inbounds %struct.AtomStr, ptr %925, i64 %927
  %929 = getelementptr inbounds %struct.AtomStr, ptr %928, i32 0, i32 0
  %930 = load ptr, ptr %929, align 8, !tbaa !21
  %931 = getelementptr inbounds %struct.PropertyStr, ptr %930, i32 0, i32 9
  %932 = getelementptr inbounds %struct.AtomSeqStr, ptr %931, i32 0, i32 2
  %933 = load i32, ptr %932, align 8, !tbaa !40
  %934 = load ptr, ptr @atom, align 8, !tbaa !9
  %935 = load i32, ptr %27, align 4, !tbaa !13
  %936 = sext i32 %935 to i64
  %937 = getelementptr inbounds %struct.AtomStr, ptr %934, i64 %936
  %938 = getelementptr inbounds %struct.AtomStr, ptr %937, i32 0, i32 0
  %939 = load ptr, ptr %938, align 8, !tbaa !21
  %940 = getelementptr inbounds %struct.PropertyStr, ptr %939, i32 0, i32 0
  %941 = getelementptr inbounds [8 x i8], ptr %940, i64 0, i64 0
  %942 = load ptr, ptr %13, align 8, !tbaa !9
  %943 = load i32, ptr %27, align 4, !tbaa !13
  %944 = sext i32 %943 to i64
  %945 = getelementptr inbounds %struct.interStr, ptr %942, i64 %944
  %946 = getelementptr inbounds %struct.interStr, ptr %945, i32 0, i32 0
  %947 = load i32, ptr %28, align 4, !tbaa !13
  %948 = sext i32 %947 to i64
  %949 = getelementptr inbounds [512 x i32], ptr %946, i64 0, i64 %948
  %950 = load i32, ptr %949, align 4, !tbaa !13
  %951 = load ptr, ptr @atom, align 8, !tbaa !9
  %952 = load ptr, ptr %13, align 8, !tbaa !9
  %953 = load i32, ptr %27, align 4, !tbaa !13
  %954 = sext i32 %953 to i64
  %955 = getelementptr inbounds %struct.interStr, ptr %952, i64 %954
  %956 = getelementptr inbounds %struct.interStr, ptr %955, i32 0, i32 0
  %957 = load i32, ptr %28, align 4, !tbaa !13
  %958 = sext i32 %957 to i64
  %959 = getelementptr inbounds [512 x i32], ptr %956, i64 0, i64 %958
  %960 = load i32, ptr %959, align 4, !tbaa !13
  %961 = sext i32 %960 to i64
  %962 = getelementptr inbounds %struct.AtomStr, ptr %951, i64 %961
  %963 = getelementptr inbounds %struct.AtomStr, ptr %962, i32 0, i32 0
  %964 = load ptr, ptr %963, align 8, !tbaa !21
  %965 = getelementptr inbounds %struct.PropertyStr, ptr %964, i32 0, i32 2
  %966 = getelementptr inbounds [8 x i8], ptr %965, i64 0, i64 0
  %967 = load ptr, ptr @atom, align 8, !tbaa !9
  %968 = load ptr, ptr %13, align 8, !tbaa !9
  %969 = load i32, ptr %27, align 4, !tbaa !13
  %970 = sext i32 %969 to i64
  %971 = getelementptr inbounds %struct.interStr, ptr %968, i64 %970
  %972 = getelementptr inbounds %struct.interStr, ptr %971, i32 0, i32 0
  %973 = load i32, ptr %28, align 4, !tbaa !13
  %974 = sext i32 %973 to i64
  %975 = getelementptr inbounds [512 x i32], ptr %972, i64 0, i64 %974
  %976 = load i32, ptr %975, align 4, !tbaa !13
  %977 = sext i32 %976 to i64
  %978 = getelementptr inbounds %struct.AtomStr, ptr %967, i64 %977
  %979 = getelementptr inbounds %struct.AtomStr, ptr %978, i32 0, i32 0
  %980 = load ptr, ptr %979, align 8, !tbaa !21
  %981 = getelementptr inbounds %struct.PropertyStr, ptr %980, i32 0, i32 9
  %982 = getelementptr inbounds %struct.AtomSeqStr, ptr %981, i32 0, i32 2
  %983 = load i32, ptr %982, align 8, !tbaa !40
  %984 = load ptr, ptr @atom, align 8, !tbaa !9
  %985 = load ptr, ptr %13, align 8, !tbaa !9
  %986 = load i32, ptr %27, align 4, !tbaa !13
  %987 = sext i32 %986 to i64
  %988 = getelementptr inbounds %struct.interStr, ptr %985, i64 %987
  %989 = getelementptr inbounds %struct.interStr, ptr %988, i32 0, i32 0
  %990 = load i32, ptr %28, align 4, !tbaa !13
  %991 = sext i32 %990 to i64
  %992 = getelementptr inbounds [512 x i32], ptr %989, i64 0, i64 %991
  %993 = load i32, ptr %992, align 4, !tbaa !13
  %994 = sext i32 %993 to i64
  %995 = getelementptr inbounds %struct.AtomStr, ptr %984, i64 %994
  %996 = getelementptr inbounds %struct.AtomStr, ptr %995, i32 0, i32 0
  %997 = load ptr, ptr %996, align 8, !tbaa !21
  %998 = getelementptr inbounds %struct.PropertyStr, ptr %997, i32 0, i32 0
  %999 = getelementptr inbounds [8 x i8], ptr %998, i64 0, i64 0
  %1000 = load double, ptr %11, align 8, !tbaa !11
  %1001 = load ptr, ptr %13, align 8, !tbaa !9
  %1002 = load i32, ptr %27, align 4, !tbaa !13
  %1003 = sext i32 %1002 to i64
  %1004 = getelementptr inbounds %struct.interStr, ptr %1001, i64 %1003
  %1005 = getelementptr inbounds %struct.interStr, ptr %1004, i32 0, i32 3
  %1006 = load i32, ptr %28, align 4, !tbaa !13
  %1007 = sext i32 %1006 to i64
  %1008 = getelementptr inbounds [512 x double], ptr %1005, i64 0, i64 %1007
  %1009 = load double, ptr %1008, align 8, !tbaa !11
  %1010 = load ptr, ptr %13, align 8, !tbaa !9
  %1011 = load i32, ptr %27, align 4, !tbaa !13
  %1012 = sext i32 %1011 to i64
  %1013 = getelementptr inbounds %struct.interStr, ptr %1010, i64 %1012
  %1014 = getelementptr inbounds %struct.interStr, ptr %1013, i32 0, i32 2
  %1015 = load i32, ptr %28, align 4, !tbaa !13
  %1016 = sext i32 %1015 to i64
  %1017 = getelementptr inbounds [512 x double], ptr %1014, i64 0, i64 %1016
  %1018 = load double, ptr %1017, align 8, !tbaa !11
  %1019 = call i32 (ptr, ...) @printf(ptr noundef @.str.23, i32 noundef %916, ptr noundef %924, i32 noundef %933, ptr noundef %941, i32 noundef %950, ptr noundef %966, i32 noundef %983, ptr noundef %999, double noundef %1000, double noundef %1009, double noundef %1018)
  br label %1020

1020:                                             ; preds = %915, %911
  %1021 = load i64, ptr %6, align 8, !tbaa !5
  %1022 = add nsw i64 %1021, 1
  store i64 %1022, ptr %6, align 8, !tbaa !5
  br label %1023

1023:                                             ; preds = %1020, %899
  %1024 = load i32, ptr %28, align 4, !tbaa !13
  %1025 = add nsw i32 %1024, 1
  store i32 %1025, ptr %28, align 4, !tbaa !13
  br label %772, !llvm.loop !39

1026:                                             ; preds = %772
  %1027 = load ptr, ptr %13, align 8, !tbaa !9
  %1028 = load i32, ptr %27, align 4, !tbaa !13
  %1029 = sext i32 %1028 to i64
  %1030 = getelementptr inbounds %struct.interStr, ptr %1027, i64 %1029
  %1031 = getelementptr inbounds %struct.interStr, ptr %1030, i32 0, i32 1
  %1032 = getelementptr inbounds [4 x double], ptr %1031, i64 0, i64 0
  %1033 = load double, ptr %1032, align 8, !tbaa !11
  %1034 = load ptr, ptr %4, align 8, !tbaa !9
  %1035 = getelementptr inbounds %struct.AtomListStr, ptr %1034, i32 0, i32 7
  %1036 = load ptr, ptr %1035, align 8, !tbaa !17
  %1037 = load i32, ptr %27, align 4, !tbaa !13
  %1038 = sext i32 %1037 to i64
  %1039 = getelementptr inbounds ptr, ptr %1036, i64 %1038
  %1040 = load ptr, ptr %1039, align 8, !tbaa !9
  %1041 = getelementptr inbounds %struct.AtomStr, ptr %1040, i32 0, i32 1
  %1042 = load ptr, ptr %1041, align 8, !tbaa !19
  %1043 = getelementptr inbounds %struct.DynamicStr, ptr %1042, i32 0, i32 1
  %1044 = getelementptr inbounds [4 x double], ptr %1043, i64 0, i64 0
  store double %1033, ptr %1044, align 8, !tbaa !11
  %1045 = load ptr, ptr %13, align 8, !tbaa !9
  %1046 = load i32, ptr %27, align 4, !tbaa !13
  %1047 = sext i32 %1046 to i64
  %1048 = getelementptr inbounds %struct.interStr, ptr %1045, i64 %1047
  %1049 = getelementptr inbounds %struct.interStr, ptr %1048, i32 0, i32 1
  %1050 = getelementptr inbounds [4 x double], ptr %1049, i64 0, i64 1
  %1051 = load double, ptr %1050, align 8, !tbaa !11
  %1052 = load ptr, ptr %4, align 8, !tbaa !9
  %1053 = getelementptr inbounds %struct.AtomListStr, ptr %1052, i32 0, i32 7
  %1054 = load ptr, ptr %1053, align 8, !tbaa !17
  %1055 = load i32, ptr %27, align 4, !tbaa !13
  %1056 = sext i32 %1055 to i64
  %1057 = getelementptr inbounds ptr, ptr %1054, i64 %1056
  %1058 = load ptr, ptr %1057, align 8, !tbaa !9
  %1059 = getelementptr inbounds %struct.AtomStr, ptr %1058, i32 0, i32 1
  %1060 = load ptr, ptr %1059, align 8, !tbaa !19
  %1061 = getelementptr inbounds %struct.DynamicStr, ptr %1060, i32 0, i32 1
  %1062 = getelementptr inbounds [4 x double], ptr %1061, i64 0, i64 1
  store double %1051, ptr %1062, align 8, !tbaa !11
  %1063 = load ptr, ptr %13, align 8, !tbaa !9
  %1064 = load i32, ptr %27, align 4, !tbaa !13
  %1065 = sext i32 %1064 to i64
  %1066 = getelementptr inbounds %struct.interStr, ptr %1063, i64 %1065
  %1067 = getelementptr inbounds %struct.interStr, ptr %1066, i32 0, i32 1
  %1068 = getelementptr inbounds [4 x double], ptr %1067, i64 0, i64 2
  %1069 = load double, ptr %1068, align 8, !tbaa !11
  %1070 = load ptr, ptr %4, align 8, !tbaa !9
  %1071 = getelementptr inbounds %struct.AtomListStr, ptr %1070, i32 0, i32 7
  %1072 = load ptr, ptr %1071, align 8, !tbaa !17
  %1073 = load i32, ptr %27, align 4, !tbaa !13
  %1074 = sext i32 %1073 to i64
  %1075 = getelementptr inbounds ptr, ptr %1072, i64 %1074
  %1076 = load ptr, ptr %1075, align 8, !tbaa !9
  %1077 = getelementptr inbounds %struct.AtomStr, ptr %1076, i32 0, i32 1
  %1078 = load ptr, ptr %1077, align 8, !tbaa !19
  %1079 = getelementptr inbounds %struct.DynamicStr, ptr %1078, i32 0, i32 1
  %1080 = getelementptr inbounds [4 x double], ptr %1079, i64 0, i64 2
  store double %1069, ptr %1080, align 8, !tbaa !11
  %1081 = load ptr, ptr %13, align 8, !tbaa !9
  %1082 = load i32, ptr %27, align 4, !tbaa !13
  %1083 = sext i32 %1082 to i64
  %1084 = getelementptr inbounds %struct.interStr, ptr %1081, i64 %1083
  %1085 = getelementptr inbounds %struct.interStr, ptr %1084, i32 0, i32 1
  %1086 = getelementptr inbounds [4 x double], ptr %1085, i64 0, i64 3
  %1087 = load double, ptr %1086, align 8, !tbaa !11
  %1088 = load ptr, ptr %4, align 8, !tbaa !9
  %1089 = getelementptr inbounds %struct.AtomListStr, ptr %1088, i32 0, i32 7
  %1090 = load ptr, ptr %1089, align 8, !tbaa !17
  %1091 = load i32, ptr %27, align 4, !tbaa !13
  %1092 = sext i32 %1091 to i64
  %1093 = getelementptr inbounds ptr, ptr %1090, i64 %1092
  %1094 = load ptr, ptr %1093, align 8, !tbaa !9
  %1095 = getelementptr inbounds %struct.AtomStr, ptr %1094, i32 0, i32 1
  %1096 = load ptr, ptr %1095, align 8, !tbaa !19
  %1097 = getelementptr inbounds %struct.DynamicStr, ptr %1096, i32 0, i32 1
  %1098 = getelementptr inbounds [4 x double], ptr %1097, i64 0, i64 3
  store double %1087, ptr %1098, align 8, !tbaa !11
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #8
  br label %1099

1099:                                             ; preds = %1026
  %1100 = load i32, ptr %27, align 4, !tbaa !13
  %1101 = add nsw i32 %1100, 1
  store i32 %1101, ptr %27, align 4, !tbaa !13
  br label %766, !llvm.loop !41

1102:                                             ; preds = %770
  %1103 = load i64, ptr %5, align 8, !tbaa !5
  %1104 = add nsw i64 %1103, 1
  store i64 %1104, ptr %5, align 8, !tbaa !5
  %1105 = load i64, ptr %6, align 8, !tbaa !5
  %1106 = call i32 (ptr, ...) @printf(ptr noundef @.str.24, i64 noundef %1104, i64 noundef %1105)
  %1107 = load i64, ptr %5, align 8, !tbaa !5
  %1108 = srem i64 %1107, 1000
  %1109 = icmp eq i64 %1108, 0
  br i1 %1109, label %1110, label %1111

1110:                                             ; preds = %1102
  call void @SaveGRO(ptr noundef %14)
  br label %1111

1111:                                             ; preds = %1110, %1102
  %1112 = load i64, ptr %5, align 8, !tbaa !5
  %1113 = srem i64 %1112, 1000
  %1114 = icmp eq i64 %1113, 0
  br i1 %1114, label %1115, label %1121

1115:                                             ; preds = %1111
  %1116 = load double, ptr %7, align 8, !tbaa !11
  %1117 = fcmp ogt double %1116, 5.000000e-02
  br i1 %1117, label %1118, label %1121

1118:                                             ; preds = %1115
  %1119 = load double, ptr %7, align 8, !tbaa !11
  %1120 = fsub double %1119, 1.000000e-02
  store double %1120, ptr %7, align 8, !tbaa !11
  br label %1121

1121:                                             ; preds = %1118, %1115, %1111
  %1122 = load i64, ptr %5, align 8, !tbaa !5
  %1123 = load i64, ptr %3, align 8, !tbaa !5
  %1124 = icmp sgt i64 %1122, %1123
  br i1 %1124, label %1125, label %1126

1125:                                             ; preds = %1121
  br label %1127

1126:                                             ; preds = %1121
  br label %526, !llvm.loop !42

1127:                                             ; preds = %1125, %526
  call void @SaveGRO(ptr noundef %14)
  %1128 = load ptr, ptr %13, align 8, !tbaa !9
  call void @free(ptr noundef %1128) #8
  %1129 = getelementptr inbounds %struct.FileStr, ptr %14, i32 0, i32 2
  %1130 = load ptr, ptr %1129, align 8, !tbaa !15
  %1131 = call i32 @fclose(ptr noundef %1130)
  %1132 = call i32 (ptr, ...) @printf(ptr noundef @.str.25)
  call void @llvm.lifetime.end.p0(i64 272, ptr %14) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #8
  call void @llvm.lifetime.end.p0(i64 100, ptr %12) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #8
  call void @llvm.lifetime.end.p0(i64 32, ptr %10) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %9) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #8
  ret void
}

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

; Function Attrs: nounwind
declare i32 @sprintf(ptr noundef, ptr noundef, ...) #4

declare noalias ptr @fopen(ptr noundef, ptr noundef) #2

; Function Attrs: nounwind uwtable
declare dso_local i32 @FindElemInList(ptr noundef, i32 noundef, i32 noundef, i32 noundef, i32 noundef) #5

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

; Function Attrs: nounwind uwtable
declare dso_local double @RandomValue(i32 noundef, i32 noundef) #5

declare void @SaveGRO(ptr noundef) #2

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

declare i32 @fclose(ptr noundef) #2

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

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

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


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

%struct.REMDStr = type { i32, i32, i32, [50 x i8], [50 x i8], %struct.REMDTempStr }
%struct.REMDTempStr = type { i32, double }
%struct.ConstraintStr = type { i32, double, ptr, double, ptr }
%struct.FileStr = type { i32, [256 x i8], ptr }
%struct.interStr = type { [512 x i32], [4 x double], [512 x double], [512 x double], [512 x double] }
%struct.AtomStr = type { ptr, ptr }

@REMDInfo = external global %struct.REMDStr, align 8
@atomnum = external local_unnamed_addr global i32, align 4
@atom = external local_unnamed_addr global ptr, align 8
@.str.2 = external hidden unnamed_addr constant [70 x i8], align 1
@potentialPairCollision = external local_unnamed_addr global [33 x [33 x %struct.ConstraintStr]], align 16
@.str.19 = external hidden unnamed_addr constant [20 x i8], align 1
@datadir = external global [1024 x i8], align 16
@.str.20 = external hidden unnamed_addr constant [2 x i8], align 1
@connectionMap = external local_unnamed_addr global ptr, align 8
@.str.21 = external hidden unnamed_addr constant [105 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [98 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [8 x i8], align 1

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

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

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

; 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 nofree nounwind willreturn memory(write)
declare double @sqrt(double noundef) local_unnamed_addr #4

; Function Attrs: nounwind uwtable
define dso_local void @SDEnergyMin(i64 noundef %0, ptr nocapture noundef readonly %1) local_unnamed_addr #5 {
  %3 = alloca [100 x i8], align 16
  %4 = alloca %struct.FileStr, align 8
  call void @llvm.lifetime.start.p0(i64 100, ptr nonnull %3) #10
  call void @llvm.lifetime.start.p0(i64 272, ptr nonnull %4) #10
  %5 = load i32, ptr @atomnum, align 4, !tbaa !5
  %6 = add nsw i32 %5, 1
  %7 = sext i32 %6 to i64
  %8 = tail call noalias ptr @calloc(i64 noundef %7, i64 noundef 14368) #11
  %9 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %3, ptr noundef nonnull dereferenceable(1) @.str.19, ptr noundef nonnull @datadir, ptr noundef nonnull getelementptr inbounds (i8, ptr @REMDInfo, i64 62)) #10
  %10 = call noalias ptr @fopen(ptr noundef nonnull %3, ptr noundef nonnull @.str.20)
  %11 = getelementptr inbounds i8, ptr %4, i64 264
  store ptr %10, ptr %11, align 8, !tbaa !9
  %12 = load i32, ptr @atomnum, align 4, !tbaa !5
  %.not369 = icmp slt i32 %12, 1
  br i1 %.not369, label %._crit_edge373, label %.lr.ph372

.lr.ph372:                                        ; preds = %2
  %13 = getelementptr inbounds i8, ptr %1, i64 352
  br label %16

._crit_edge373:                                   ; preds = %155, %2
  %14 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.22)
  %15 = getelementptr inbounds i8, ptr %1, i64 352
  br label %157

16:                                               ; preds = %.lr.ph372, %155
  %indvars.iv450 = phi i64 [ 1, %.lr.ph372 ], [ %indvars.iv.next451, %155 ]
  %17 = load ptr, ptr %13, align 8, !tbaa !12
  %18 = getelementptr inbounds ptr, ptr %17, i64 %indvars.iv450
  %19 = load ptr, ptr %18, align 8, !tbaa !15
  %20 = getelementptr inbounds i8, ptr %19, i64 8
  %21 = load ptr, ptr %20, align 8, !tbaa !16
  %22 = getelementptr inbounds i8, ptr %21, i64 16
  %23 = load double, ptr %22, align 8, !tbaa !18
  %24 = getelementptr inbounds %struct.interStr, ptr %8, i64 %indvars.iv450
  %25 = getelementptr inbounds i8, ptr %24, i64 2048
  store double %23, ptr %25, align 8, !tbaa !18
  %26 = getelementptr inbounds i8, ptr %21, i64 24
  %27 = load double, ptr %26, align 8, !tbaa !18
  %28 = getelementptr inbounds i8, ptr %24, i64 2056
  store double %27, ptr %28, align 8, !tbaa !18
  %29 = getelementptr inbounds i8, ptr %21, i64 32
  %30 = load double, ptr %29, align 8, !tbaa !18
  %31 = getelementptr inbounds i8, ptr %24, i64 2064
  store double %30, ptr %31, align 8, !tbaa !18
  %32 = getelementptr inbounds i8, ptr %21, i64 40
  %33 = load double, ptr %32, align 8, !tbaa !18
  %34 = getelementptr inbounds i8, ptr %24, i64 2072
  store double %33, ptr %34, align 8, !tbaa !18
  %35 = load ptr, ptr %19, align 8, !tbaa !19
  %36 = getelementptr inbounds i8, ptr %35, i64 120
  %.0306352 = load ptr, ptr %36, align 8, !tbaa !15
  %.not326353 = icmp eq ptr %.0306352, null
  br i1 %.not326353, label %._crit_edge, label %.lr.ph

.lr.ph:                                           ; preds = %16
  %37 = getelementptr inbounds i8, ptr %24, i64 2080
  %38 = getelementptr inbounds i8, ptr %24, i64 6176
  %39 = getelementptr inbounds i8, ptr %24, i64 10272
  br label %40

40:                                               ; preds = %.lr.ph, %40
  %indvars.iv = phi i64 [ 0, %.lr.ph ], [ %indvars.iv.next, %40 ]
  %.0306355 = phi ptr [ %.0306352, %.lr.ph ], [ %.0306, %40 ]
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %41 = load i32, ptr %.0306355, align 8, !tbaa !20
  %42 = getelementptr inbounds [512 x i32], ptr %24, i64 0, i64 %indvars.iv.next
  store i32 %41, ptr %42, align 4, !tbaa !5
  %43 = getelementptr inbounds i8, ptr %.0306355, i64 24
  %44 = load double, ptr %43, align 8, !tbaa !22
  %45 = tail call double @sqrt(double noundef %44) #10
  %46 = getelementptr inbounds [512 x double], ptr %37, i64 0, i64 %indvars.iv.next
  store double %45, ptr %46, align 8, !tbaa !18
  %47 = getelementptr inbounds i8, ptr %.0306355, i64 8
  %48 = load double, ptr %47, align 8, !tbaa !23
  %49 = tail call double @sqrt(double noundef %48) #10
  %50 = getelementptr inbounds [512 x double], ptr %38, i64 0, i64 %indvars.iv.next
  store double %49, ptr %50, align 8, !tbaa !18
  %51 = load double, ptr %46, align 8, !tbaa !18
  %52 = fadd double %49, %51
  %53 = fmul double %52, 5.000000e-01
  %54 = getelementptr inbounds [512 x double], ptr %39, i64 0, i64 %indvars.iv.next
  store double %53, ptr %54, align 8, !tbaa !18
  %55 = getelementptr inbounds i8, ptr %.0306355, i64 32
  %.0306 = load ptr, ptr %55, align 8, !tbaa !15
  %.not326 = icmp eq ptr %.0306, null
  br i1 %.not326, label %._crit_edge.loopexit, label %40, !llvm.loop !24

._crit_edge.loopexit:                             ; preds = %40
  %56 = trunc nuw nsw i64 %indvars.iv.next to i32
  %.pre = load ptr, ptr %13, align 8, !tbaa !12
  %.phi.trans.insert = getelementptr inbounds ptr, ptr %.pre, i64 %indvars.iv450
  %.pre471 = load ptr, ptr %.phi.trans.insert, align 8, !tbaa !15
  %.pre472 = load ptr, ptr %.pre471, align 8, !tbaa !19
  br label %._crit_edge

._crit_edge:                                      ; preds = %._crit_edge.loopexit, %16
  %57 = phi ptr [ %35, %16 ], [ %.pre472, %._crit_edge.loopexit ]
  %.0307.lcssa = phi i32 [ 0, %16 ], [ %56, %._crit_edge.loopexit ]
  %58 = getelementptr inbounds i8, ptr %57, i64 128
  %.0305356 = load ptr, ptr %58, align 8, !tbaa !15
  %.not327357 = icmp eq ptr %.0305356, null
  br i1 %.not327357, label %.preheader339, label %.lr.ph361

.lr.ph361:                                        ; preds = %._crit_edge
  %59 = getelementptr inbounds i8, ptr %24, i64 2080
  %60 = getelementptr inbounds i8, ptr %24, i64 6176
  %61 = getelementptr inbounds i8, ptr %24, i64 10272
  %62 = zext nneg i32 %.0307.lcssa to i64
  br label %68

.preheader339.loopexit:                           ; preds = %68
  %63 = trunc nuw i64 %indvars.iv.next445 to i32
  br label %.preheader339

.preheader339:                                    ; preds = %.preheader339.loopexit, %._crit_edge
  %.1308.lcssa = phi i32 [ %.0307.lcssa, %._crit_edge ], [ %63, %.preheader339.loopexit ]
  %64 = load i32, ptr @atomnum, align 4, !tbaa !5
  %.not328363 = icmp slt i32 %64, 1
  br i1 %.not328363, label %._crit_edge367, label %.lr.ph366

.lr.ph366:                                        ; preds = %.preheader339
  %65 = getelementptr inbounds i8, ptr %24, i64 2080
  %66 = getelementptr inbounds i8, ptr %24, i64 6176
  %67 = getelementptr inbounds i8, ptr %24, i64 10272
  br label %86

68:                                               ; preds = %.lr.ph361, %68
  %indvars.iv444 = phi i64 [ %62, %.lr.ph361 ], [ %indvars.iv.next445, %68 ]
  %.0305359 = phi ptr [ %.0305356, %.lr.ph361 ], [ %.0305, %68 ]
  %indvars.iv.next445 = add nuw nsw i64 %indvars.iv444, 1
  %69 = load i32, ptr %.0305359, align 8, !tbaa !20
  %70 = getelementptr inbounds [512 x i32], ptr %24, i64 0, i64 %indvars.iv.next445
  store i32 %69, ptr %70, align 4, !tbaa !5
  %71 = getelementptr inbounds i8, ptr %.0305359, i64 24
  %72 = load double, ptr %71, align 8, !tbaa !22
  %73 = tail call double @sqrt(double noundef %72) #10
  %74 = getelementptr inbounds [512 x double], ptr %59, i64 0, i64 %indvars.iv.next445
  store double %73, ptr %74, align 8, !tbaa !18
  %75 = getelementptr inbounds i8, ptr %.0305359, i64 8
  %76 = load double, ptr %75, align 8, !tbaa !23
  %77 = tail call double @sqrt(double noundef %76) #10
  %78 = getelementptr inbounds [512 x double], ptr %60, i64 0, i64 %indvars.iv.next445
  store double %77, ptr %78, align 8, !tbaa !18
  %79 = load double, ptr %74, align 8, !tbaa !18
  %80 = fadd double %77, %79
  %81 = fmul double %80, 5.000000e-01
  %82 = getelementptr inbounds [512 x double], ptr %61, i64 0, i64 %indvars.iv.next445
  store double %81, ptr %82, align 8, !tbaa !18
  %83 = getelementptr inbounds i8, ptr %.0305359, i64 32
  %.0305 = load ptr, ptr %83, align 8, !tbaa !15
  %.not327 = icmp eq ptr %.0305, null
  br i1 %.not327, label %.preheader339.loopexit, label %68, !llvm.loop !26

._crit_edge367:                                   ; preds = %149, %.preheader339
  %84 = phi i32 [ %64, %.preheader339 ], [ %150, %149 ]
  %.2309.lcssa = phi i32 [ %.1308.lcssa, %.preheader339 ], [ %.3, %149 ]
  %85 = icmp sgt i32 %.2309.lcssa, 510
  br i1 %85, label %152, label %155

86:                                               ; preds = %.lr.ph366, %149
  %indvars.iv447 = phi i64 [ 1, %.lr.ph366 ], [ %indvars.iv.next448, %149 ]
  %.2309364 = phi i32 [ %.1308.lcssa, %.lr.ph366 ], [ %.3, %149 ]
  %87 = load ptr, ptr %13, align 8, !tbaa !12
  %88 = getelementptr inbounds ptr, ptr %87, i64 %indvars.iv447
  %89 = load ptr, ptr %88, align 8, !tbaa !15
  %90 = getelementptr inbounds i8, ptr %89, i64 8
  %91 = load ptr, ptr %90, align 8, !tbaa !16
  %92 = getelementptr inbounds i8, ptr %91, i64 24
  %93 = load double, ptr %92, align 8, !tbaa !18
  %94 = getelementptr inbounds ptr, ptr %87, i64 %indvars.iv450
  %95 = load ptr, ptr %94, align 8, !tbaa !15
  %96 = getelementptr inbounds i8, ptr %95, i64 8
  %97 = load ptr, ptr %96, align 8, !tbaa !16
  %98 = getelementptr inbounds i8, ptr %97, i64 24
  %99 = load double, ptr %98, align 8, !tbaa !18
  %100 = fsub double %93, %99
  %101 = getelementptr inbounds i8, ptr %91, i64 32
  %102 = load double, ptr %101, align 8, !tbaa !18
  %103 = getelementptr inbounds i8, ptr %97, i64 32
  %104 = load double, ptr %103, align 8, !tbaa !18
  %105 = fsub double %102, %104
  %106 = getelementptr inbounds i8, ptr %91, i64 40
  %107 = load double, ptr %106, align 8, !tbaa !18
  %108 = getelementptr inbounds i8, ptr %97, i64 40
  %109 = load double, ptr %108, align 8, !tbaa !18
  %110 = fsub double %107, %109
  %111 = fmul double %105, %105
  %112 = tail call double @llvm.fmuladd.f64(double %100, double %100, double %111)
  %113 = tail call double @llvm.fmuladd.f64(double %110, double %110, double %112)
  %114 = fcmp ugt double %113, 1.440000e+02
  br i1 %114, label %149, label %115

115:                                              ; preds = %86
  %116 = load ptr, ptr @connectionMap, align 8, !tbaa !15
  %117 = getelementptr inbounds ptr, ptr %116, i64 %indvars.iv450
  %118 = load ptr, ptr %117, align 8, !tbaa !15
  %119 = getelementptr inbounds i32, ptr %118, i64 %indvars.iv447
  %120 = load i32, ptr %119, align 4, !tbaa !5
  %121 = and i32 %120, 3
  %or.cond333 = icmp ne i32 %121, 0
  %.not331 = icmp eq i64 %indvars.iv450, %indvars.iv447
  %or.cond334 = or i1 %.not331, %or.cond333
  br i1 %or.cond334, label %149, label %122

122:                                              ; preds = %115
  %123 = trunc nuw nsw i64 %indvars.iv447 to i32
  %124 = tail call i32 @FindElemInList(ptr noundef nonnull %24, i32 noundef %123, i32 noundef -1, i32 noundef -1, i32 noundef 0)
  %.not332 = icmp eq i32 %124, 0
  br i1 %.not332, label %125, label %149

125:                                              ; preds = %122
  %126 = add nsw i32 %.2309364, 1
  %127 = sext i32 %126 to i64
  %128 = getelementptr inbounds [512 x i32], ptr %24, i64 0, i64 %127
  store i32 %123, ptr %128, align 4, !tbaa !5
  %129 = getelementptr inbounds [512 x double], ptr %65, i64 0, i64 %127
  store double 1.000000e+08, ptr %129, align 8, !tbaa !18
  %130 = load ptr, ptr %13, align 8, !tbaa !12
  %131 = getelementptr inbounds ptr, ptr %130, i64 %indvars.iv450
  %132 = load ptr, ptr %131, align 8, !tbaa !15
  %133 = load ptr, ptr %132, align 8, !tbaa !19
  %134 = getelementptr inbounds i8, ptr %133, i64 52
  %135 = load i32, ptr %134, align 4, !tbaa !27
  %136 = getelementptr inbounds ptr, ptr %130, i64 %indvars.iv447
  %137 = load ptr, ptr %136, align 8, !tbaa !15
  %138 = load ptr, ptr %137, align 8, !tbaa !19
  %139 = getelementptr inbounds i8, ptr %138, i64 52
  %140 = load i32, ptr %139, align 4, !tbaa !27
  %spec.select = tail call i32 @llvm.smin.i32(i32 %135, i32 %140)
  %spec.select335 = tail call i32 @llvm.smax.i32(i32 %135, i32 %140)
  %141 = sext i32 %spec.select to i64
  %142 = sext i32 %spec.select335 to i64
  %143 = getelementptr inbounds [33 x [33 x %struct.ConstraintStr]], ptr @potentialPairCollision, i64 0, i64 %141, i64 %142, i32 1
  %144 = load double, ptr %143, align 8, !tbaa !23
  %145 = tail call double @sqrt(double noundef %144) #10
  %146 = getelementptr inbounds [512 x double], ptr %66, i64 0, i64 %127
  store double %145, ptr %146, align 8, !tbaa !18
  %147 = fadd double %145, 1.000000e-03
  %148 = getelementptr inbounds [512 x double], ptr %67, i64 0, i64 %127
  store double %147, ptr %148, align 8, !tbaa !18
  br label %149

149:                                              ; preds = %86, %115, %125, %122
  %.3 = phi i32 [ %.2309364, %115 ], [ %.2309364, %122 ], [ %126, %125 ], [ %.2309364, %86 ]
  %indvars.iv.next448 = add nuw nsw i64 %indvars.iv447, 1
  %150 = load i32, ptr @atomnum, align 4, !tbaa !5
  %151 = sext i32 %150 to i64
  %.not328.not = icmp slt i64 %indvars.iv447, %151
  br i1 %.not328.not, label %86, label %._crit_edge367, !llvm.loop !30

152:                                              ; preds = %._crit_edge367
  %153 = trunc nuw nsw i64 %indvars.iv450 to i32
  %154 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.21, i32 noundef %153, i32 noundef %.2309.lcssa, ptr noundef nonnull @.str.2, i32 noundef 407)
  tail call void @exit(i32 noundef 1) #12
  unreachable

155:                                              ; preds = %._crit_edge367
  %indvars.iv.next451 = add nuw nsw i64 %indvars.iv450, 1
  %156 = sext i32 %84 to i64
  %.not.not = icmp slt i64 %indvars.iv450, %156
  br i1 %.not.not, label %16, label %._crit_edge373, !llvm.loop !31

157:                                              ; preds = %._crit_edge373, %377
  %.0311 = phi double [ 1.000000e-01, %._crit_edge373 ], [ %.1312, %377 ]
  %.0298 = phi i64 [ 0, %._crit_edge373 ], [ %316, %377 ]
  %158 = load i32, ptr @atomnum, align 4, !tbaa !5
  %.not322385 = icmp slt i32 %158, 1
  br i1 %.not322385, label %._crit_edge421, label %.preheader337

.preheader338:                                    ; preds = %._crit_edge380
  %.not323416 = icmp slt i32 %299, 1
  br i1 %.not323416, label %._crit_edge421, label %.preheader.lr.ph

.preheader.lr.ph:                                 ; preds = %.preheader338
  %159 = icmp eq i64 %.0298, %0
  br i1 %159, label %.preheader.us, label %.preheader.lr.ph.split

.preheader.us:                                    ; preds = %.preheader.lr.ph, %.outer._crit_edge.us
  %indvars.iv468 = phi i64 [ %indvars.iv.next469, %.outer._crit_edge.us ], [ 1, %.preheader.lr.ph ]
  %.0301417.us = phi i64 [ %.1.ph.lcssa.us, %.outer._crit_edge.us ], [ 0, %.preheader.lr.ph ]
  %160 = getelementptr inbounds %struct.interStr, ptr %8, i64 %indvars.iv468
  %161 = getelementptr inbounds i8, ptr %160, i64 4
  %162 = load i32, ptr %161, align 4, !tbaa !5
  %.not324388398.us = icmp eq i32 %162, 0
  br i1 %.not324388398.us, label %.outer._crit_edge.us, label %.lr.ph390.lr.ph.us

.outer._crit_edge.us:                             ; preds = %.outer.us.us, %.lr.ph410.us, %.preheader.us
  %.1.ph.lcssa.us = phi i64 [ %.0301417.us, %.preheader.us ], [ %.1.ph399.us.us, %.lr.ph410.us ], [ %.2.us.us, %.outer.us.us ]
  %163 = getelementptr inbounds i8, ptr %160, i64 2048
  %164 = load double, ptr %163, align 8, !tbaa !18
  %165 = load ptr, ptr %15, align 8, !tbaa !12
  %166 = getelementptr inbounds ptr, ptr %165, i64 %indvars.iv468
  %167 = load ptr, ptr %166, align 8, !tbaa !15
  %168 = getelementptr inbounds i8, ptr %167, i64 8
  %169 = load ptr, ptr %168, align 8, !tbaa !16
  %170 = getelementptr inbounds i8, ptr %169, i64 16
  store double %164, ptr %170, align 8, !tbaa !18
  %171 = getelementptr inbounds i8, ptr %160, i64 2056
  %172 = load double, ptr %171, align 8, !tbaa !18
  %173 = getelementptr inbounds i8, ptr %169, i64 24
  store double %172, ptr %173, align 8, !tbaa !18
  %174 = getelementptr inbounds i8, ptr %160, i64 2064
  %175 = load double, ptr %174, align 8, !tbaa !18
  %176 = getelementptr inbounds i8, ptr %169, i64 32
  store double %175, ptr %176, align 8, !tbaa !18
  %177 = getelementptr inbounds i8, ptr %160, i64 2072
  %178 = load double, ptr %177, align 8, !tbaa !18
  %179 = getelementptr inbounds i8, ptr %169, i64 40
  store double %178, ptr %179, align 8, !tbaa !18
  %indvars.iv.next469 = add nuw nsw i64 %indvars.iv468, 1
  %180 = load i32, ptr @atomnum, align 4, !tbaa !5
  %181 = sext i32 %180 to i64
  %.not323.us.not = icmp slt i64 %indvars.iv468, %181
  br i1 %.not323.us.not, label %.preheader.us, label %._crit_edge421, !llvm.loop !32

.lr.ph390.lr.ph.us:                               ; preds = %.preheader.us
  %182 = getelementptr inbounds i8, ptr %160, i64 2056
  %183 = getelementptr inbounds i8, ptr %160, i64 2064
  %184 = getelementptr inbounds i8, ptr %160, i64 2072
  %185 = getelementptr inbounds i8, ptr %160, i64 2080
  %186 = getelementptr inbounds i8, ptr %160, i64 6176
  %187 = trunc nuw nsw i64 %indvars.iv468 to i32
  br label %.lr.ph390.us.us

.lr.ph390.us.us:                                  ; preds = %.outer.us.us, %.lr.ph390.lr.ph.us
  %188 = phi i32 [ %162, %.lr.ph390.lr.ph.us ], [ %238, %.outer.us.us ]
  %189 = phi i64 [ 1, %.lr.ph390.lr.ph.us ], [ %236, %.outer.us.us ]
  %.0.ph400.us.us = phi i32 [ 1, %.lr.ph390.lr.ph.us ], [ %235, %.outer.us.us ]
  %.1.ph399.us.us = phi i64 [ %.0301417.us, %.lr.ph390.lr.ph.us ], [ %.2.us.us, %.outer.us.us ]
  %190 = sext i32 %188 to i64
  %191 = icmp sgt i64 %indvars.iv468, %190
  br i1 %191, label %.lr.ph410.us.preheader, label %._crit_edge411.us

.lr.ph410.us.preheader:                           ; preds = %.lr.ph390.us.us
  %192 = sext i32 %.0.ph400.us.us to i64
  br label %.lr.ph410.us

193:                                              ; preds = %.lr.ph410.us
  %194 = sext i32 %240 to i64
  %195 = icmp sgt i64 %indvars.iv468, %194
  br i1 %195, label %.lr.ph410.us, label %._crit_edge411.us.loopexit, !llvm.loop !33

._crit_edge411.us.loopexit:                       ; preds = %193
  %196 = trunc nsw i64 %indvars.iv.next466 to i32
  br label %._crit_edge411.us

._crit_edge411.us:                                ; preds = %._crit_edge411.us.loopexit, %.lr.ph390.us.us
  %.pre-phi = phi i64 [ %194, %._crit_edge411.us.loopexit ], [ %190, %.lr.ph390.us.us ]
  %.lcssa387.us.us = phi i64 [ %indvars.iv.next466, %._crit_edge411.us.loopexit ], [ %189, %.lr.ph390.us.us ]
  %.0.lcssa350.us.us = phi i32 [ %196, %._crit_edge411.us.loopexit ], [ %.0.ph400.us.us, %.lr.ph390.us.us ]
  %197 = getelementptr inbounds %struct.interStr, ptr %8, i64 %.pre-phi, i32 1
  %198 = getelementptr inbounds i8, ptr %197, i64 8
  %199 = load double, ptr %198, align 8, !tbaa !18
  %200 = load double, ptr %182, align 8, !tbaa !18
  %201 = fsub double %199, %200
  %202 = getelementptr inbounds i8, ptr %197, i64 16
  %203 = load double, ptr %202, align 8, !tbaa !18
  %204 = load double, ptr %183, align 8, !tbaa !18
  %205 = fsub double %203, %204
  %206 = getelementptr inbounds i8, ptr %197, i64 24
  %207 = load double, ptr %206, align 8, !tbaa !18
  %208 = load double, ptr %184, align 8, !tbaa !18
  %209 = fsub double %207, %208
  %210 = fmul double %205, %205
  %211 = call double @llvm.fmuladd.f64(double %201, double %201, double %210)
  %212 = call double @llvm.fmuladd.f64(double %209, double %209, double %211)
  %sqrt336.us.us = call double @llvm.sqrt.f64(double %212)
  %213 = getelementptr inbounds [512 x double], ptr %185, i64 0, i64 %.lcssa387.us.us
  %214 = load double, ptr %213, align 8, !tbaa !18
  %215 = fcmp ult double %sqrt336.us.us, %214
  %216 = getelementptr inbounds [512 x double], ptr %186, i64 0, i64 %.lcssa387.us.us
  %217 = load double, ptr %216, align 8, !tbaa !18
  %218 = fcmp ugt double %sqrt336.us.us, %217
  %or.cond492 = select i1 %215, i1 %218, i1 false
  br i1 %or.cond492, label %.outer.us.us, label %._crit_edge411.us._crit_edge

._crit_edge411.us._crit_edge:                     ; preds = %._crit_edge411.us
  %219 = getelementptr inbounds [512 x i32], ptr %160, i64 0, i64 %.lcssa387.us.us
  %220 = load ptr, ptr @atom, align 8, !tbaa !15
  %221 = getelementptr inbounds %struct.AtomStr, ptr %220, i64 %indvars.iv468
  %222 = load ptr, ptr %221, align 8, !tbaa !19
  %223 = getelementptr inbounds i8, ptr %222, i64 40
  %224 = getelementptr inbounds i8, ptr %222, i64 112
  %225 = load i32, ptr %224, align 8, !tbaa !34
  %226 = load i32, ptr %219, align 4, !tbaa !5
  %227 = sext i32 %226 to i64
  %228 = getelementptr inbounds %struct.AtomStr, ptr %220, i64 %227
  %229 = load ptr, ptr %228, align 8, !tbaa !19
  %230 = getelementptr inbounds i8, ptr %229, i64 40
  %231 = getelementptr inbounds i8, ptr %229, i64 112
  %232 = load i32, ptr %231, align 8, !tbaa !34
  %233 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.23, i32 noundef %187, ptr noundef nonnull %223, i32 noundef %225, ptr noundef %222, i32 noundef %226, ptr noundef nonnull %230, i32 noundef %232, ptr noundef %229, double noundef %sqrt336.us.us, double noundef %217, double noundef %214)
  %234 = add nsw i64 %.1.ph399.us.us, 1
  br label %.outer.us.us

.outer.us.us:                                     ; preds = %._crit_edge411.us, %._crit_edge411.us._crit_edge
  %.2.us.us = phi i64 [ %234, %._crit_edge411.us._crit_edge ], [ %.1.ph399.us.us, %._crit_edge411.us ]
  %235 = add nsw i32 %.0.lcssa350.us.us, 1
  %236 = sext i32 %235 to i64
  %237 = getelementptr inbounds [512 x i32], ptr %160, i64 0, i64 %236
  %238 = load i32, ptr %237, align 4, !tbaa !5
  %.not324388.us.us = icmp eq i32 %238, 0
  br i1 %.not324388.us.us, label %.outer._crit_edge.us, label %.lr.ph390.us.us, !llvm.loop !33

.lr.ph410.us:                                     ; preds = %.lr.ph410.us.preheader, %193
  %indvars.iv465 = phi i64 [ %192, %.lr.ph410.us.preheader ], [ %indvars.iv.next466, %193 ]
  %indvars.iv.next466 = add nsw i64 %indvars.iv465, 1
  %239 = getelementptr inbounds [512 x i32], ptr %160, i64 0, i64 %indvars.iv.next466
  %240 = load i32, ptr %239, align 4, !tbaa !5
  %.not324.us.us = icmp eq i32 %240, 0
  br i1 %.not324.us.us, label %.outer._crit_edge.us, label %193, !llvm.loop !33

.preheader.lr.ph.split:                           ; preds = %.preheader.lr.ph
  %241 = load ptr, ptr %15, align 8, !tbaa !12
  %242 = add nuw i32 %299, 1
  %wide.trip.count = zext i32 %242 to i64
  br label %.preheader

.preheader337:                                    ; preds = %157, %._crit_edge380
  %243 = phi i32 [ %299, %._crit_edge380 ], [ %158, %157 ]
  %indvars.iv456 = phi i64 [ %indvars.iv.next457, %._crit_edge380 ], [ 1, %157 ]
  %244 = getelementptr inbounds %struct.interStr, ptr %8, i64 %indvars.iv456
  %245 = getelementptr inbounds i8, ptr %244, i64 4
  %246 = load i32, ptr %245, align 4, !tbaa !5
  %.not325374 = icmp eq i32 %246, 0
  br i1 %.not325374, label %._crit_edge380, label %.lr.ph379

.lr.ph379:                                        ; preds = %.preheader337
  %247 = getelementptr inbounds i8, ptr %244, i64 2056
  %248 = getelementptr inbounds i8, ptr %244, i64 2072
  %249 = getelementptr inbounds i8, ptr %244, i64 2080
  %250 = getelementptr inbounds i8, ptr %244, i64 6176
  %251 = getelementptr inbounds i8, ptr %244, i64 10272
  br label %252

252:                                              ; preds = %.lr.ph379, %295
  %indvars.iv453 = phi i64 [ 1, %.lr.ph379 ], [ %indvars.iv.next454, %295 ]
  %253 = phi i32 [ %246, %.lr.ph379 ], [ %298, %295 ]
  %.sroa.9.2378 = phi double [ 0.000000e+00, %.lr.ph379 ], [ %.sroa.9.3, %295 ]
  %254 = phi <2 x double> [ zeroinitializer, %.lr.ph379 ], [ %296, %295 ]
  %255 = sext i32 %253 to i64
  %256 = getelementptr inbounds %struct.interStr, ptr %8, i64 %255, i32 1
  %257 = getelementptr inbounds i8, ptr %256, i64 8
  %258 = load <2 x double>, ptr %257, align 8, !tbaa !18
  %259 = load <2 x double>, ptr %247, align 8, !tbaa !18
  %260 = fsub <2 x double> %258, %259
  %261 = getelementptr inbounds i8, ptr %256, i64 24
  %262 = load double, ptr %261, align 8, !tbaa !18
  %263 = load double, ptr %248, align 8, !tbaa !18
  %264 = fsub double %262, %263
  %265 = fmul <2 x double> %260, %260
  %266 = extractelement <2 x double> %265, i64 1
  %267 = extractelement <2 x double> %260, i64 0
  %268 = call double @llvm.fmuladd.f64(double %267, double %267, double %266)
  %269 = call double @llvm.fmuladd.f64(double %264, double %264, double %268)
  %sqrt = call double @llvm.sqrt.f64(double %269)
  %270 = getelementptr inbounds [512 x double], ptr %249, i64 0, i64 %indvars.iv453
  %271 = load double, ptr %270, align 8, !tbaa !18
  %272 = fcmp ult double %sqrt, %271
  br i1 %272, label %273, label %277

273:                                              ; preds = %252
  %274 = getelementptr inbounds [512 x double], ptr %250, i64 0, i64 %indvars.iv453
  %275 = load double, ptr %274, align 8, !tbaa !18
  %276 = fcmp ugt double %sqrt, %275
  br i1 %276, label %295, label %277

277:                                              ; preds = %273, %252
  %278 = getelementptr inbounds [512 x double], ptr %251, i64 0, i64 %indvars.iv453
  %279 = load double, ptr %278, align 8, !tbaa !18
  %280 = fsub double %279, %sqrt
  %281 = call double @RandomValue(i32 noundef 0, i32 noundef 1)
  %282 = fmul double %.0311, %281
  %283 = fmul double %280, %282
  %284 = load double, ptr %278, align 8, !tbaa !18
  %285 = insertelement <2 x double> poison, double %283, i64 0
  %286 = shufflevector <2 x double> %285, <2 x double> poison, <2 x i32> zeroinitializer
  %287 = fmul <2 x double> %260, %286
  %288 = insertelement <2 x double> poison, double %284, i64 0
  %289 = shufflevector <2 x double> %288, <2 x double> poison, <2 x i32> zeroinitializer
  %290 = fdiv <2 x double> %287, %289
  %291 = fsub <2 x double> %254, %290
  %292 = fmul double %264, %283
  %293 = fdiv double %292, %284
  %294 = fsub double %.sroa.9.2378, %293
  br label %295

295:                                              ; preds = %277, %273
  %.sroa.9.3 = phi double [ %294, %277 ], [ %.sroa.9.2378, %273 ]
  %296 = phi <2 x double> [ %291, %277 ], [ %254, %273 ]
  %indvars.iv.next454 = add nuw nsw i64 %indvars.iv453, 1
  %297 = getelementptr inbounds [512 x i32], ptr %244, i64 0, i64 %indvars.iv.next454
  %298 = load i32, ptr %297, align 4, !tbaa !5
  %.not325 = icmp eq i32 %298, 0
  br i1 %.not325, label %._crit_edge380.loopexit, label %252, !llvm.loop !35

._crit_edge380.loopexit:                          ; preds = %295
  %.pre473 = load i32, ptr @atomnum, align 4, !tbaa !5
  br label %._crit_edge380

._crit_edge380:                                   ; preds = %._crit_edge380.loopexit, %.preheader337
  %299 = phi i32 [ %243, %.preheader337 ], [ %.pre473, %._crit_edge380.loopexit ]
  %.sroa.9.2.lcssa = phi double [ 0.000000e+00, %.preheader337 ], [ %.sroa.9.3, %._crit_edge380.loopexit ]
  %300 = phi <2 x double> [ zeroinitializer, %.preheader337 ], [ %296, %._crit_edge380.loopexit ]
  %301 = getelementptr inbounds i8, ptr %244, i64 2056
  %302 = load <2 x double>, ptr %301, align 8, !tbaa !18
  %303 = fadd <2 x double> %300, %302
  store <2 x double> %303, ptr %301, align 8, !tbaa !18
  %304 = getelementptr inbounds i8, ptr %244, i64 2072
  %305 = load double, ptr %304, align 8, !tbaa !18
  %306 = fadd double %.sroa.9.2.lcssa, %305
  store double %306, ptr %304, align 8, !tbaa !18
  %indvars.iv.next457 = add nuw nsw i64 %indvars.iv456, 1
  %307 = sext i32 %299 to i64
  %.not322.not = icmp slt i64 %indvars.iv456, %307
  br i1 %.not322.not, label %.preheader337, label %.preheader338, !llvm.loop !36

.preheader:                                       ; preds = %.preheader.lr.ph.split, %.outer._crit_edge
  %indvars.iv462 = phi i64 [ 1, %.preheader.lr.ph.split ], [ %indvars.iv.next463, %.outer._crit_edge ]
  %.0301417 = phi i64 [ 0, %.preheader.lr.ph.split ], [ %.1.ph.lcssa, %.outer._crit_edge ]
  %308 = getelementptr inbounds %struct.interStr, ptr %8, i64 %indvars.iv462
  %309 = getelementptr inbounds i8, ptr %308, i64 4
  %310 = load i32, ptr %309, align 4, !tbaa !5
  %.not324388398 = icmp eq i32 %310, 0
  br i1 %.not324388398, label %.outer._crit_edge, label %.lr.ph390.lr.ph

.lr.ph390.lr.ph:                                  ; preds = %.preheader
  %311 = getelementptr inbounds i8, ptr %308, i64 2056
  %312 = getelementptr inbounds i8, ptr %308, i64 2064
  %313 = getelementptr inbounds i8, ptr %308, i64 2072
  %314 = getelementptr inbounds i8, ptr %308, i64 2080
  %315 = getelementptr inbounds i8, ptr %308, i64 6176
  br label %.lr.ph390

._crit_edge421:                                   ; preds = %.outer._crit_edge, %.outer._crit_edge.us, %157, %.preheader338
  %.0301.lcssa = phi i64 [ 0, %.preheader338 ], [ 0, %157 ], [ %.1.ph.lcssa.us, %.outer._crit_edge.us ], [ %.1.ph.lcssa, %.outer._crit_edge ]
  %316 = add nuw nsw i64 %.0298, 1
  %317 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.24, i64 noundef %316, i64 noundef %.0301.lcssa)
  %318 = urem i64 %316, 1000
  %319 = icmp eq i64 %318, 0
  br i1 %319, label %376, label %377

320:                                              ; preds = %.lr.ph509
  %321 = sext i32 %324 to i64
  %322 = icmp sgt i64 %indvars.iv462, %321
  br i1 %322, label %.lr.ph509, label %._crit_edge510, !llvm.loop !33

.lr.ph509:                                        ; preds = %.lr.ph390, %320
  %indvars.iv459508 = phi i64 [ %indvars.iv.next460, %320 ], [ %357, %.lr.ph390 ]
  %indvars.iv.next460 = add nsw i64 %indvars.iv459508, 1
  %323 = getelementptr inbounds [512 x i32], ptr %308, i64 0, i64 %indvars.iv.next460
  %324 = load i32, ptr %323, align 4, !tbaa !5
  %.not324 = icmp eq i32 %324, 0
  br i1 %.not324, label %.outer._crit_edge, label %320, !llvm.loop !33

._crit_edge510:                                   ; preds = %320, %.lr.ph390
  %indvars.iv459.lcssa = phi i64 [ %357, %.lr.ph390 ], [ %indvars.iv.next460, %320 ]
  %.lcssa498 = phi i64 [ %356, %.lr.ph390 ], [ %indvars.iv.next460, %320 ]
  %.lcssa496 = phi i64 [ %358, %.lr.ph390 ], [ %321, %320 ]
  %325 = trunc nsw i64 %indvars.iv459.lcssa to i32
  %326 = getelementptr inbounds %struct.interStr, ptr %8, i64 %.lcssa496, i32 1
  %327 = getelementptr inbounds i8, ptr %326, i64 8
  %328 = load double, ptr %327, align 8, !tbaa !18
  %329 = load double, ptr %311, align 8, !tbaa !18
  %330 = fsub double %328, %329
  %331 = getelementptr inbounds i8, ptr %326, i64 16
  %332 = load double, ptr %331, align 8, !tbaa !18
  %333 = load double, ptr %312, align 8, !tbaa !18
  %334 = fsub double %332, %333
  %335 = getelementptr inbounds i8, ptr %326, i64 24
  %336 = load double, ptr %335, align 8, !tbaa !18
  %337 = load double, ptr %313, align 8, !tbaa !18
  %338 = fsub double %336, %337
  %339 = fmul double %334, %334
  %340 = call double @llvm.fmuladd.f64(double %330, double %330, double %339)
  %341 = call double @llvm.fmuladd.f64(double %338, double %338, double %340)
  %sqrt336 = call double @llvm.sqrt.f64(double %341)
  %342 = getelementptr inbounds [512 x double], ptr %314, i64 0, i64 %.lcssa498
  %343 = load double, ptr %342, align 8, !tbaa !18
  %344 = fcmp ult double %sqrt336, %343
  br i1 %344, label %345, label %349

345:                                              ; preds = %._crit_edge510
  %346 = getelementptr inbounds [512 x double], ptr %315, i64 0, i64 %.lcssa498
  %347 = load double, ptr %346, align 8, !tbaa !18
  %348 = fcmp ugt double %sqrt336, %347
  br i1 %348, label %.outer, label %349

349:                                              ; preds = %345, %._crit_edge510
  %350 = add nsw i64 %.1.ph399, 1
  br label %.outer

.outer:                                           ; preds = %349, %345
  %.2 = phi i64 [ %350, %349 ], [ %.1.ph399, %345 ]
  %351 = add nsw i32 %325, 1
  %352 = sext i32 %351 to i64
  %353 = getelementptr inbounds [512 x i32], ptr %308, i64 0, i64 %352
  %354 = load i32, ptr %353, align 4, !tbaa !5
  %.not324388 = icmp eq i32 %354, 0
  br i1 %.not324388, label %.outer._crit_edge, label %.lr.ph390, !llvm.loop !33

.lr.ph390:                                        ; preds = %.lr.ph390.lr.ph, %.outer
  %355 = phi i32 [ %310, %.lr.ph390.lr.ph ], [ %354, %.outer ]
  %356 = phi i64 [ 1, %.lr.ph390.lr.ph ], [ %352, %.outer ]
  %.0.ph400 = phi i32 [ 1, %.lr.ph390.lr.ph ], [ %351, %.outer ]
  %.1.ph399 = phi i64 [ %.0301417, %.lr.ph390.lr.ph ], [ %.2, %.outer ]
  %357 = sext i32 %.0.ph400 to i64
  %358 = sext i32 %355 to i64
  %359 = icmp sgt i64 %indvars.iv462, %358
  br i1 %359, label %.lr.ph509, label %._crit_edge510

.outer._crit_edge:                                ; preds = %.outer, %.lr.ph509, %.preheader
  %.1.ph.lcssa = phi i64 [ %.0301417, %.preheader ], [ %.1.ph399, %.lr.ph509 ], [ %.2, %.outer ]
  %360 = getelementptr inbounds i8, ptr %308, i64 2048
  %361 = load double, ptr %360, align 8, !tbaa !18
  %362 = getelementptr inbounds ptr, ptr %241, i64 %indvars.iv462
  %363 = load ptr, ptr %362, align 8, !tbaa !15
  %364 = getelementptr inbounds i8, ptr %363, i64 8
  %365 = load ptr, ptr %364, align 8, !tbaa !16
  %366 = getelementptr inbounds i8, ptr %365, i64 16
  store double %361, ptr %366, align 8, !tbaa !18
  %367 = getelementptr inbounds i8, ptr %308, i64 2056
  %368 = load double, ptr %367, align 8, !tbaa !18
  %369 = getelementptr inbounds i8, ptr %365, i64 24
  store double %368, ptr %369, align 8, !tbaa !18
  %370 = getelementptr inbounds i8, ptr %308, i64 2064
  %371 = load double, ptr %370, align 8, !tbaa !18
  %372 = getelementptr inbounds i8, ptr %365, i64 32
  store double %371, ptr %372, align 8, !tbaa !18
  %373 = getelementptr inbounds i8, ptr %308, i64 2072
  %374 = load double, ptr %373, align 8, !tbaa !18
  %375 = getelementptr inbounds i8, ptr %365, i64 40
  store double %374, ptr %375, align 8, !tbaa !18
  %indvars.iv.next463 = add nuw nsw i64 %indvars.iv462, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next463, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge421, label %.preheader, !llvm.loop !32

376:                                              ; preds = %._crit_edge421
  call void @SaveGRO(ptr noundef nonnull %4) #10
  br label %377

377:                                              ; preds = %376, %._crit_edge421
  %378 = fcmp ogt double %.0311, 5.000000e-02
  %or.cond = select i1 %319, i1 %378, i1 false
  %379 = fadd double %.0311, -1.000000e-02
  %.1312 = select i1 %or.cond, double %379, double %.0311
  %380 = icmp slt i64 %.0298, %0
  %381 = icmp sgt i64 %.0301.lcssa, 0
  %or.cond3 = and i1 %380, %381
  br i1 %or.cond3, label %157, label %382, !llvm.loop !37

382:                                              ; preds = %377
  call void @SaveGRO(ptr noundef nonnull %4) #10
  call void @free(ptr noundef %8) #10
  %383 = load ptr, ptr %11, align 8, !tbaa !9
  %384 = call i32 @fclose(ptr noundef %383)
  %385 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.25)
  call void @llvm.lifetime.end.p0(i64 272, ptr nonnull %4) #10
  call void @llvm.lifetime.end.p0(i64 100, ptr nonnull %3) #10
  ret void
}

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

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

; Function Attrs: nofree nounwind
declare noalias noundef ptr @fopen(ptr nocapture noundef readonly, ptr nocapture noundef readonly) local_unnamed_addr #2

; Function Attrs: nounwind uwtable
declare dso_local i32 @FindElemInList(ptr noundef, i32 noundef, i32 noundef, i32 noundef, i32 noundef) local_unnamed_addr #5

; Function Attrs: nounwind uwtable
declare dso_local double @RandomValue(i32 noundef, i32 noundef) local_unnamed_addr #5

declare void @SaveGRO(ptr noundef) local_unnamed_addr #7

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

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.smin.i32(i32, i32) #9

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare i32 @llvm.smax.i32(i32, i32) #9

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

attributes #0 = { mustprogress nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { mustprogress nocallback nofree nosync nounwind speculatable willreturn memory(none) }
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(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 #5 = { 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 #6 = { mustprogress nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite) "alloc-family"="malloc" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #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 = { mustprogress nounwind willreturn allockind("free") memory(argmem: readwrite, inaccessiblemem: readwrite) "alloc-family"="malloc" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #9 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }
attributes #10 = { nounwind }
attributes #11 = { nounwind allocsize(0,1) }
attributes #12 = { noreturn nounwind }

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

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


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