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

; 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.DynamicWallStr = type { [16 x i8], i32, i32, double, double, double, double, [4 x double] }
%struct.ObstructionStr = type { i32, i32, ptr, ptr, ptr }
%struct.CGGovStr = type { [2 x [16 x i8]], i32, i32, ptr, ptr }
%struct.TunnelStr = type { i32, i32, ptr, ptr, %struct.AtomStr }
%struct.AtomStr = type { ptr, ptr }
%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 }
%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 }

@.str.2 = external hidden unnamed_addr constant [71 x i8], align 1
@datadir = external global [1024 x i8], align 16
@.str.3 = external hidden unnamed_addr constant [3 x i8], align 1
@boxDimension = external global [4 x double], align 16
@wallDyn = external global %struct.DynamicWallStr, align 8
@wallExist = external global [20 x i8], align 16
@.str.88 = external hidden unnamed_addr constant [3 x i8], align 1
@obstObj = external global %struct.ObstructionStr, align 8
@CG = external global %struct.CGGovStr, align 8
@.str.94 = external hidden unnamed_addr constant [2 x i8], align 1
@currenttime = external global double, align 8
@Methodtype = external global [20 x i8], align 16
@.str.107 = external hidden unnamed_addr constant [41 x i8], align 1
@wallType = external global [20 x i8], align 16
@tunlObj = external global %struct.TunnelStr, align 8
@.str.239 = external hidden unnamed_addr constant [23 x i8], align 1
@.str.240 = external hidden unnamed_addr constant [57 x i8], align 1
@.str.241 = external hidden unnamed_addr constant [7 x i8], align 1
@wall = external global ptr, align 8
@.str.242 = external hidden unnamed_addr constant [14 x i8], align 1
@.str.243 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.244 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.245 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.246 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.247 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.248 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.249 = external hidden unnamed_addr constant [80 x i8], align 1
@.str.250 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.251 = external hidden unnamed_addr constant [73 x i8], align 1

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

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

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

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @ReadWall() #6 {
  %1 = alloca [20 x i8], align 16
  %2 = alloca [1024 x i8], align 16
  %3 = alloca [1024 x i8], align 16
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca ptr, align 8
  %7 = alloca ptr, align 8
  %8 = alloca ptr, align 8
  %9 = alloca i32, align 4
  %10 = alloca ptr, align 8
  %11 = alloca ptr, align 8
  %12 = alloca i32, align 4
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  call void @llvm.lifetime.start.p0(i64 20, ptr %1) #7
  call void @llvm.lifetime.start.p0(i64 1024, ptr %2) #7
  call void @llvm.lifetime.start.p0(i64 1024, ptr %3) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %4) #7
  %15 = getelementptr inbounds [1024 x i8], ptr %2, i64 0, i64 0
  %16 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %15, ptr noundef @.str.239, ptr noundef @datadir, ptr noundef @Methodtype) #7
  %17 = getelementptr inbounds [1024 x i8], ptr %2, i64 0, i64 0
  %18 = call noalias ptr @fopen(ptr noundef %17, ptr noundef @.str.94)
  store ptr %18, ptr %4, align 8, !tbaa !5
  %19 = load ptr, ptr %4, align 8, !tbaa !5
  %20 = icmp eq ptr %19, null
  br i1 %20, label %21, label %24

21:                                               ; preds = %0
  %22 = call i32 (ptr, ...) @printf(ptr noundef @.str.240, ptr noundef @datadir, ptr noundef @Methodtype)
  %23 = call i32 (ptr, ...) @printf(ptr noundef @.str.107)
  call void @exit(i32 noundef 1) #8
  unreachable

24:                                               ; preds = %0
  %25 = call i32 @strcmp(ptr noundef @wallExist, ptr noundef @.str.241) #9
  %26 = icmp eq i32 %25, 0
  br i1 %26, label %27, label %279

27:                                               ; preds = %24
  %28 = call noalias ptr @calloc(i64 noundef 1, i64 noundef 16) #10
  store ptr %28, ptr @wall, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #7
  %29 = call noalias ptr @calloc(i64 noundef 1, i64 noundef 136) #10
  store ptr %29, ptr %5, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %6) #7
  %30 = call noalias ptr @calloc(i64 noundef 1, i64 noundef 176) #10
  store ptr %30, ptr %6, align 8, !tbaa !5
  %31 = load ptr, ptr %5, align 8, !tbaa !5
  %32 = load ptr, ptr @wall, align 8, !tbaa !5
  %33 = getelementptr inbounds %struct.AtomStr, ptr %32, i64 0
  %34 = getelementptr inbounds %struct.AtomStr, ptr %33, i32 0, i32 0
  store ptr %31, ptr %34, align 8, !tbaa !9
  %35 = load ptr, ptr %6, align 8, !tbaa !5
  %36 = load ptr, ptr @wall, align 8, !tbaa !5
  %37 = getelementptr inbounds %struct.AtomStr, ptr %36, i64 0
  %38 = getelementptr inbounds %struct.AtomStr, ptr %37, i32 0, i32 1
  store ptr %35, ptr %38, align 8, !tbaa !11
  %39 = getelementptr inbounds [1024 x i8], ptr %3, i64 0, i64 0
  %40 = load ptr, ptr %4, align 8, !tbaa !5
  %41 = call ptr @fgets(ptr noundef %39, i32 noundef 1024, ptr noundef %40)
  %42 = load ptr, ptr %4, align 8, !tbaa !5
  %43 = getelementptr inbounds [1024 x i8], ptr %3, i64 0, i64 0
  %44 = load ptr, ptr @wall, align 8, !tbaa !5
  %45 = getelementptr inbounds %struct.AtomStr, ptr %44, i64 0
  %46 = getelementptr inbounds %struct.AtomStr, ptr %45, i32 0, i32 0
  %47 = load ptr, ptr %46, align 8, !tbaa !9
  %48 = getelementptr inbounds %struct.PropertyStr, ptr %47, i32 0, i32 0
  %49 = getelementptr inbounds [8 x i8], ptr %48, i64 0, i64 0
  %50 = getelementptr inbounds [20 x i8], ptr %1, i64 0, i64 0
  %51 = load ptr, ptr @wall, align 8, !tbaa !5
  %52 = getelementptr inbounds %struct.AtomStr, ptr %51, i64 0
  %53 = getelementptr inbounds %struct.AtomStr, ptr %52, i32 0, i32 0
  %54 = load ptr, ptr %53, align 8, !tbaa !9
  %55 = getelementptr inbounds %struct.PropertyStr, ptr %54, i32 0, i32 7
  %56 = load ptr, ptr @wall, align 8, !tbaa !5
  %57 = getelementptr inbounds %struct.AtomStr, ptr %56, i64 0
  %58 = getelementptr inbounds %struct.AtomStr, ptr %57, i32 0, i32 0
  %59 = load ptr, ptr %58, align 8, !tbaa !9
  %60 = getelementptr inbounds %struct.PropertyStr, ptr %59, i32 0, i32 1
  %61 = getelementptr inbounds [2 x [16 x i8]], ptr %60, i64 0, i64 0
  %62 = getelementptr inbounds [16 x i8], ptr %61, i64 0, i64 0
  %63 = load ptr, ptr @wall, align 8, !tbaa !5
  %64 = getelementptr inbounds %struct.AtomStr, ptr %63, i64 0
  %65 = getelementptr inbounds %struct.AtomStr, ptr %64, i32 0, i32 0
  %66 = load ptr, ptr %65, align 8, !tbaa !9
  %67 = getelementptr inbounds %struct.PropertyStr, ptr %66, i32 0, i32 1
  %68 = getelementptr inbounds [2 x [16 x i8]], ptr %67, i64 0, i64 1
  %69 = getelementptr inbounds [16 x i8], ptr %68, i64 0, i64 0
  %70 = call i32 (ptr, ptr, ...) @__isoc99_fscanf(ptr noundef %42, ptr noundef @.str.242, ptr noundef %43, ptr noundef %49, ptr noundef %50, ptr noundef %55, ptr noundef %62, ptr noundef %69)
  %71 = getelementptr inbounds [20 x i8], ptr %1, i64 0, i64 0
  %72 = call i32 @AtomModel(ptr noundef %71)
  %73 = load ptr, ptr @wall, align 8, !tbaa !5
  %74 = getelementptr inbounds %struct.AtomStr, ptr %73, i64 0
  %75 = getelementptr inbounds %struct.AtomStr, ptr %74, i32 0, i32 0
  %76 = load ptr, ptr %75, align 8, !tbaa !9
  %77 = getelementptr inbounds %struct.PropertyStr, ptr %76, i32 0, i32 4
  store i32 %72, ptr %77, align 4, !tbaa !12
  %78 = load ptr, ptr @wall, align 8, !tbaa !5
  %79 = getelementptr inbounds %struct.AtomStr, ptr %78, i64 0
  %80 = getelementptr inbounds %struct.AtomStr, ptr %79, i32 0, i32 0
  %81 = load ptr, ptr %80, align 8, !tbaa !9
  %82 = getelementptr inbounds %struct.PropertyStr, ptr %81, i32 0, i32 2
  %83 = getelementptr inbounds [8 x i8], ptr %82, i64 0, i64 0
  %84 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %83, ptr noundef @.str.243) #7
  %85 = load double, ptr getelementptr inbounds ([4 x double], ptr @boxDimension, i64 0, i64 1), align 8, !tbaa !17
  %86 = fdiv double %85, 2.000000e+00
  %87 = load ptr, ptr @wall, align 8, !tbaa !5
  %88 = getelementptr inbounds %struct.AtomStr, ptr %87, i64 0
  %89 = getelementptr inbounds %struct.AtomStr, ptr %88, i32 0, i32 1
  %90 = load ptr, ptr %89, align 8, !tbaa !11
  %91 = getelementptr inbounds %struct.DynamicStr, ptr %90, i32 0, i32 1
  %92 = getelementptr inbounds [4 x double], ptr %91, i64 0, i64 1
  store double %86, ptr %92, align 8, !tbaa !17
  %93 = load double, ptr getelementptr inbounds ([4 x double], ptr @boxDimension, i64 0, i64 2), align 16, !tbaa !17
  %94 = fdiv double %93, 2.000000e+00
  %95 = load ptr, ptr @wall, align 8, !tbaa !5
  %96 = getelementptr inbounds %struct.AtomStr, ptr %95, i64 0
  %97 = getelementptr inbounds %struct.AtomStr, ptr %96, i32 0, i32 1
  %98 = load ptr, ptr %97, align 8, !tbaa !11
  %99 = getelementptr inbounds %struct.DynamicStr, ptr %98, i32 0, i32 1
  %100 = getelementptr inbounds [4 x double], ptr %99, i64 0, i64 2
  store double %94, ptr %100, align 8, !tbaa !17
  %101 = load double, ptr getelementptr inbounds ([4 x double], ptr @boxDimension, i64 0, i64 3), align 8, !tbaa !17
  %102 = fdiv double %101, 2.000000e+00
  %103 = load ptr, ptr @wall, align 8, !tbaa !5
  %104 = getelementptr inbounds %struct.AtomStr, ptr %103, i64 0
  %105 = getelementptr inbounds %struct.AtomStr, ptr %104, i32 0, i32 1
  %106 = load ptr, ptr %105, align 8, !tbaa !11
  %107 = getelementptr inbounds %struct.DynamicStr, ptr %106, i32 0, i32 1
  %108 = getelementptr inbounds [4 x double], ptr %107, i64 0, i64 3
  store double %102, ptr %108, align 8, !tbaa !17
  %109 = load ptr, ptr @wall, align 8, !tbaa !5
  %110 = getelementptr inbounds %struct.AtomStr, ptr %109, i64 0
  %111 = getelementptr inbounds %struct.AtomStr, ptr %110, i32 0, i32 1
  %112 = load ptr, ptr %111, align 8, !tbaa !11
  %113 = getelementptr inbounds %struct.DynamicStr, ptr %112, i32 0, i32 5
  %114 = getelementptr inbounds %struct.InteractionEventStr, ptr %113, i32 0, i32 0
  store i32 -111, ptr %114, align 8, !tbaa !18
  %115 = load ptr, ptr @wall, align 8, !tbaa !5
  %116 = getelementptr inbounds %struct.AtomStr, ptr %115, i64 0
  %117 = getelementptr inbounds %struct.AtomStr, ptr %116, i32 0, i32 1
  %118 = load ptr, ptr %117, align 8, !tbaa !11
  %119 = getelementptr inbounds %struct.DynamicStr, ptr %118, i32 0, i32 5
  %120 = getelementptr inbounds %struct.InteractionEventStr, ptr %119, i32 0, i32 6
  store i32 8, ptr %120, align 4, !tbaa !24
  %121 = load ptr, ptr @wall, align 8, !tbaa !5
  %122 = getelementptr inbounds %struct.AtomStr, ptr %121, i64 0
  %123 = getelementptr inbounds %struct.AtomStr, ptr %122, i32 0, i32 1
  %124 = load ptr, ptr %123, align 8, !tbaa !11
  %125 = getelementptr inbounds %struct.DynamicStr, ptr %124, i32 0, i32 5
  %126 = getelementptr inbounds %struct.InteractionEventStr, ptr %125, i32 0, i32 5
  store i32 15, ptr %126, align 8, !tbaa !25
  %127 = call i32 @strncmp(ptr noundef @wallType, ptr noundef @.str.244, i64 noundef 1) #9
  %128 = icmp eq i32 %127, 0
  br i1 %128, label %129, label %142

129:                                              ; preds = %27
  %130 = load ptr, ptr @wall, align 8, !tbaa !5
  %131 = getelementptr inbounds %struct.AtomStr, ptr %130, i64 0
  %132 = getelementptr inbounds %struct.AtomStr, ptr %131, i32 0, i32 1
  %133 = load ptr, ptr %132, align 8, !tbaa !11
  %134 = getelementptr inbounds %struct.DynamicStr, ptr %133, i32 0, i32 1
  %135 = getelementptr inbounds [4 x double], ptr %134, i64 0, i64 3
  store double 0.000000e+00, ptr %135, align 8, !tbaa !17
  %136 = load ptr, ptr @wall, align 8, !tbaa !5
  %137 = getelementptr inbounds %struct.AtomStr, ptr %136, i64 0
  %138 = getelementptr inbounds %struct.AtomStr, ptr %137, i32 0, i32 1
  %139 = load ptr, ptr %138, align 8, !tbaa !11
  %140 = getelementptr inbounds %struct.DynamicStr, ptr %139, i32 0, i32 1
  %141 = getelementptr inbounds [4 x double], ptr %140, i64 0, i64 1
  store double 0.000000e+00, ptr %141, align 8, !tbaa !17
  br label %153

142:                                              ; preds = %27
  %143 = call i32 @strncmp(ptr noundef @wallType, ptr noundef @.str.245, i64 noundef 1) #9
  %144 = icmp eq i32 %143, 0
  br i1 %144, label %145, label %152

145:                                              ; preds = %142
  %146 = load ptr, ptr @wall, align 8, !tbaa !5
  %147 = getelementptr inbounds %struct.AtomStr, ptr %146, i64 0
  %148 = getelementptr inbounds %struct.AtomStr, ptr %147, i32 0, i32 1
  %149 = load ptr, ptr %148, align 8, !tbaa !11
  %150 = getelementptr inbounds %struct.DynamicStr, ptr %149, i32 0, i32 1
  %151 = getelementptr inbounds [4 x double], ptr %150, i64 0, i64 1
  store double 0.000000e+00, ptr %151, align 8, !tbaa !17
  br label %152

152:                                              ; preds = %145, %142
  br label %153

153:                                              ; preds = %152, %129
  %154 = call i32 @strcmp(ptr noundef @wallDyn, ptr noundef @.str.88) #9
  %155 = icmp ne i32 %154, 0
  br i1 %155, label %156, label %278

156:                                              ; preds = %153
  %157 = call i32 @strcmp(ptr noundef @wallDyn, ptr noundef @.str.246) #9
  %158 = icmp ne i32 %157, 0
  br i1 %158, label %159, label %167

159:                                              ; preds = %156
  %160 = call i32 @strcmp(ptr noundef @wallDyn, ptr noundef @.str.247) #9
  %161 = icmp ne i32 %160, 0
  br i1 %161, label %162, label %167

162:                                              ; preds = %159
  %163 = call i32 @strcmp(ptr noundef @wallDyn, ptr noundef @.str.248) #9
  %164 = icmp ne i32 %163, 0
  br i1 %164, label %165, label %167

165:                                              ; preds = %162
  %166 = call i32 (ptr, ...) @printf(ptr noundef @.str.249, ptr noundef @.str.2, i32 noundef 1941)
  call void @exit(i32 noundef 1) #8
  unreachable

167:                                              ; preds = %162, %159, %156
  %168 = load i32, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 1), align 8, !tbaa !26
  %169 = icmp ne i32 %168, 0
  br i1 %169, label %171, label %170

170:                                              ; preds = %167
  store i32 1, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 1), align 8, !tbaa !26
  br label %171

171:                                              ; preds = %170, %167
  %172 = load double, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 3), align 8, !tbaa !28
  %173 = fcmp une double %172, 0.000000e+00
  br i1 %173, label %175, label %174

174:                                              ; preds = %171
  store double 5.000000e+00, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 3), align 8, !tbaa !28
  br label %175

175:                                              ; preds = %174, %171
  %176 = call i32 @strcmp(ptr noundef @wallDyn, ptr noundef @.str.246) #9
  %177 = icmp eq i32 %176, 0
  br i1 %177, label %178, label %179

178:                                              ; preds = %175
  store i32 -1, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 1), align 8, !tbaa !26
  br label %179

179:                                              ; preds = %178, %175
  %180 = call i32 @strcmp(ptr noundef @wallDyn, ptr noundef @.str.247) #9
  %181 = icmp eq i32 %180, 0
  br i1 %181, label %182, label %183

182:                                              ; preds = %179
  store i32 1, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 1), align 8, !tbaa !26
  br label %183

183:                                              ; preds = %182, %179
  %184 = load double, ptr @currenttime, align 8, !tbaa !17
  %185 = load double, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 6), align 8, !tbaa !29
  %186 = fsub double %184, %185
  %187 = fcmp ogt double %186, 1.000000e+00
  br i1 %187, label %188, label %193

188:                                              ; preds = %183
  %189 = load double, ptr @currenttime, align 8, !tbaa !17
  %190 = fptosi double %189 to i64
  %191 = add nsw i64 %190, 1
  %192 = sitofp i64 %191 to double
  store double %192, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 6), align 8, !tbaa !29
  br label %193

193:                                              ; preds = %188, %183
  %194 = load double, ptr getelementptr inbounds ([4 x double], ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), i64 0, i64 1), align 8, !tbaa !17
  %195 = fcmp une double %194, 0.000000e+00
  br i1 %195, label %196, label %202

196:                                              ; preds = %193
  %197 = load double, ptr getelementptr inbounds ([4 x double], ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), i64 0, i64 2), align 8, !tbaa !17
  %198 = fcmp une double %197, 0.000000e+00
  br i1 %198, label %199, label %202

199:                                              ; preds = %196
  %200 = load double, ptr getelementptr inbounds ([4 x double], ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), i64 0, i64 3), align 8, !tbaa !17
  %201 = fcmp une double %200, 0.000000e+00
  br i1 %201, label %207, label %202

202:                                              ; preds = %199, %196, %193
  %203 = load double, ptr @boxDimension, align 16, !tbaa !17
  store double %203, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), align 8, !tbaa !17
  %204 = load double, ptr getelementptr inbounds ([4 x double], ptr @boxDimension, i64 0, i64 1), align 8, !tbaa !17
  store double %204, ptr getelementptr inbounds ([4 x double], ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), i64 0, i64 1), align 8, !tbaa !17
  %205 = load double, ptr getelementptr inbounds ([4 x double], ptr @boxDimension, i64 0, i64 2), align 16, !tbaa !17
  store double %205, ptr getelementptr inbounds ([4 x double], ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), i64 0, i64 2), align 8, !tbaa !17
  %206 = load double, ptr getelementptr inbounds ([4 x double], ptr @boxDimension, i64 0, i64 3), align 8, !tbaa !17
  store double %206, ptr getelementptr inbounds ([4 x double], ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), i64 0, i64 3), align 8, !tbaa !17
  br label %207

207:                                              ; preds = %202, %199
  %208 = call i32 @strncmp(ptr noundef @wallType, ptr noundef @.str.244, i64 noundef 1) #9
  %209 = icmp eq i32 %208, 0
  br i1 %209, label %210, label %219

210:                                              ; preds = %207
  %211 = load double, ptr getelementptr inbounds ([4 x double], ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), i64 0, i64 2), align 8, !tbaa !17
  %212 = fdiv double %211, 2.000000e+00
  %213 = load ptr, ptr @wall, align 8, !tbaa !5
  %214 = getelementptr inbounds %struct.AtomStr, ptr %213, i64 0
  %215 = getelementptr inbounds %struct.AtomStr, ptr %214, i32 0, i32 1
  %216 = load ptr, ptr %215, align 8, !tbaa !11
  %217 = getelementptr inbounds %struct.DynamicStr, ptr %216, i32 0, i32 1
  %218 = getelementptr inbounds [4 x double], ptr %217, i64 0, i64 2
  store double %212, ptr %218, align 8, !tbaa !17
  br label %263

219:                                              ; preds = %207
  %220 = call i32 @strncmp(ptr noundef @wallType, ptr noundef @.str.245, i64 noundef 1) #9
  %221 = icmp eq i32 %220, 0
  br i1 %221, label %222, label %237

222:                                              ; preds = %219
  %223 = load double, ptr getelementptr inbounds ([4 x double], ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), i64 0, i64 2), align 8, !tbaa !17
  %224 = fdiv double %223, 2.000000e+00
  %225 = load ptr, ptr @wall, align 8, !tbaa !5
  %226 = getelementptr inbounds %struct.AtomStr, ptr %225, i64 0
  %227 = getelementptr inbounds %struct.AtomStr, ptr %226, i32 0, i32 1
  %228 = load ptr, ptr %227, align 8, !tbaa !11
  %229 = getelementptr inbounds %struct.DynamicStr, ptr %228, i32 0, i32 1
  %230 = getelementptr inbounds [4 x double], ptr %229, i64 0, i64 3
  store double %224, ptr %230, align 8, !tbaa !17
  %231 = load ptr, ptr @wall, align 8, !tbaa !5
  %232 = getelementptr inbounds %struct.AtomStr, ptr %231, i64 0
  %233 = getelementptr inbounds %struct.AtomStr, ptr %232, i32 0, i32 1
  %234 = load ptr, ptr %233, align 8, !tbaa !11
  %235 = getelementptr inbounds %struct.DynamicStr, ptr %234, i32 0, i32 1
  %236 = getelementptr inbounds [4 x double], ptr %235, i64 0, i64 2
  store double %224, ptr %236, align 8, !tbaa !17
  br label %262

237:                                              ; preds = %219
  %238 = call i32 @strncmp(ptr noundef @wallType, ptr noundef @.str.250, i64 noundef 1) #9
  %239 = icmp eq i32 %238, 0
  br i1 %239, label %240, label %261

240:                                              ; preds = %237
  %241 = load double, ptr getelementptr inbounds ([4 x double], ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), i64 0, i64 2), align 8, !tbaa !17
  %242 = fdiv double %241, 2.000000e+00
  %243 = load ptr, ptr @wall, align 8, !tbaa !5
  %244 = getelementptr inbounds %struct.AtomStr, ptr %243, i64 0
  %245 = getelementptr inbounds %struct.AtomStr, ptr %244, i32 0, i32 1
  %246 = load ptr, ptr %245, align 8, !tbaa !11
  %247 = getelementptr inbounds %struct.DynamicStr, ptr %246, i32 0, i32 1
  %248 = getelementptr inbounds [4 x double], ptr %247, i64 0, i64 3
  store double %242, ptr %248, align 8, !tbaa !17
  %249 = load ptr, ptr @wall, align 8, !tbaa !5
  %250 = getelementptr inbounds %struct.AtomStr, ptr %249, i64 0
  %251 = getelementptr inbounds %struct.AtomStr, ptr %250, i32 0, i32 1
  %252 = load ptr, ptr %251, align 8, !tbaa !11
  %253 = getelementptr inbounds %struct.DynamicStr, ptr %252, i32 0, i32 1
  %254 = getelementptr inbounds [4 x double], ptr %253, i64 0, i64 2
  store double %242, ptr %254, align 8, !tbaa !17
  %255 = load ptr, ptr @wall, align 8, !tbaa !5
  %256 = getelementptr inbounds %struct.AtomStr, ptr %255, i64 0
  %257 = getelementptr inbounds %struct.AtomStr, ptr %256, i32 0, i32 1
  %258 = load ptr, ptr %257, align 8, !tbaa !11
  %259 = getelementptr inbounds %struct.DynamicStr, ptr %258, i32 0, i32 1
  %260 = getelementptr inbounds [4 x double], ptr %259, i64 0, i64 1
  store double %242, ptr %260, align 8, !tbaa !17
  br label %261

261:                                              ; preds = %240, %237
  br label %262

262:                                              ; preds = %261, %222
  br label %263

263:                                              ; preds = %262, %210
  %264 = load double, ptr getelementptr inbounds ([4 x double], ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 7), i64 0, i64 2), align 8, !tbaa !17
  %265 = load double, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 3), align 8, !tbaa !28
  %266 = fsub double %264, %265
  %267 = fcmp ole double %266, 1.300000e+01
  br i1 %267, label %268, label %270

268:                                              ; preds = %263
  %269 = call i32 (ptr, ...) @printf(ptr noundef @.str.251, ptr noundef @.str.2, i32 noundef 1972)
  call void @exit(i32 noundef 1) #8
  unreachable

270:                                              ; preds = %263
  %271 = load double, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 4), align 8, !tbaa !30
  %272 = fcmp une double %271, 0.000000e+00
  br i1 %272, label %274, label %273

273:                                              ; preds = %270
  store double 2.000000e+02, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 4), align 8, !tbaa !30
  br label %274

274:                                              ; preds = %273, %270
  %275 = load double, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 3), align 8, !tbaa !28
  %276 = load double, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 4), align 8, !tbaa !30
  %277 = fdiv double %275, %276
  store double %277, ptr getelementptr inbounds (%struct.DynamicWallStr, ptr @wallDyn, i32 0, i32 5), align 8, !tbaa !31
  br label %278

278:                                              ; preds = %274, %153
  call void @llvm.lifetime.end.p0(i64 8, ptr %6) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #7
  br label %279

279:                                              ; preds = %278, %24
  %280 = load i32, ptr @obstObj, align 8, !tbaa !32
  %281 = icmp ne i32 %280, 0
  br i1 %281, label %282, label %476

282:                                              ; preds = %279
  %283 = load i32, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 1), align 4, !tbaa !34
  %284 = sext i32 %283 to i64
  %285 = call noalias ptr @calloc(i64 noundef %284, i64 noundef 16) #10
  store ptr %285, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %286 = load i32, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 1), align 4, !tbaa !34
  %287 = sext i32 %286 to i64
  %288 = call noalias ptr @calloc(i64 noundef %287, i64 noundef 4) #10
  store ptr %288, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 2), align 8, !tbaa !36
  call void @llvm.lifetime.start.p0(i64 8, ptr %7) #7
  %289 = load i32, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 1), align 4, !tbaa !34
  %290 = sext i32 %289 to i64
  %291 = call noalias ptr @calloc(i64 noundef %290, i64 noundef 136) #10
  store ptr %291, ptr %7, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %8) #7
  %292 = load i32, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 1), align 4, !tbaa !34
  %293 = sext i32 %292 to i64
  %294 = call noalias ptr @calloc(i64 noundef %293, i64 noundef 176) #10
  store ptr %294, ptr %8, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #7
  store i32 0, ptr %9, align 4, !tbaa !37
  br label %295

295:                                              ; preds = %472, %282
  %296 = load i32, ptr %9, align 4, !tbaa !37
  %297 = load i32, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 1), align 4, !tbaa !34
  %298 = icmp slt i32 %296, %297
  br i1 %298, label %300, label %299

299:                                              ; preds = %295
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #7
  br label %475

300:                                              ; preds = %295
  %301 = load ptr, ptr %7, align 8, !tbaa !5
  %302 = load i32, ptr %9, align 4, !tbaa !37
  %303 = sext i32 %302 to i64
  %304 = getelementptr inbounds %struct.PropertyStr, ptr %301, i64 %303
  %305 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %306 = load i32, ptr %9, align 4, !tbaa !37
  %307 = sext i32 %306 to i64
  %308 = getelementptr inbounds %struct.AtomStr, ptr %305, i64 %307
  %309 = getelementptr inbounds %struct.AtomStr, ptr %308, i32 0, i32 0
  store ptr %304, ptr %309, align 8, !tbaa !9
  %310 = load ptr, ptr %8, align 8, !tbaa !5
  %311 = load i32, ptr %9, align 4, !tbaa !37
  %312 = sext i32 %311 to i64
  %313 = getelementptr inbounds %struct.DynamicStr, ptr %310, i64 %312
  %314 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %315 = load i32, ptr %9, align 4, !tbaa !37
  %316 = sext i32 %315 to i64
  %317 = getelementptr inbounds %struct.AtomStr, ptr %314, i64 %316
  %318 = getelementptr inbounds %struct.AtomStr, ptr %317, i32 0, i32 1
  store ptr %313, ptr %318, align 8, !tbaa !11
  %319 = load ptr, ptr %4, align 8, !tbaa !5
  %320 = call i32 @fseek(ptr noundef %319, i64 noundef 0, i32 noundef 0)
  %321 = getelementptr inbounds [1024 x i8], ptr %3, i64 0, i64 0
  %322 = load ptr, ptr %4, align 8, !tbaa !5
  %323 = call ptr @fgets(ptr noundef %321, i32 noundef 1024, ptr noundef %322)
  %324 = load ptr, ptr %4, align 8, !tbaa !5
  %325 = getelementptr inbounds [1024 x i8], ptr %3, i64 0, i64 0
  %326 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %327 = load i32, ptr %9, align 4, !tbaa !37
  %328 = sext i32 %327 to i64
  %329 = getelementptr inbounds %struct.AtomStr, ptr %326, i64 %328
  %330 = getelementptr inbounds %struct.AtomStr, ptr %329, i32 0, i32 0
  %331 = load ptr, ptr %330, align 8, !tbaa !9
  %332 = getelementptr inbounds %struct.PropertyStr, ptr %331, i32 0, i32 0
  %333 = getelementptr inbounds [8 x i8], ptr %332, i64 0, i64 0
  %334 = getelementptr inbounds [20 x i8], ptr %1, i64 0, i64 0
  %335 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %336 = load i32, ptr %9, align 4, !tbaa !37
  %337 = sext i32 %336 to i64
  %338 = getelementptr inbounds %struct.AtomStr, ptr %335, i64 %337
  %339 = getelementptr inbounds %struct.AtomStr, ptr %338, i32 0, i32 0
  %340 = load ptr, ptr %339, align 8, !tbaa !9
  %341 = getelementptr inbounds %struct.PropertyStr, ptr %340, i32 0, i32 7
  %342 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %343 = load i32, ptr %9, align 4, !tbaa !37
  %344 = sext i32 %343 to i64
  %345 = getelementptr inbounds %struct.AtomStr, ptr %342, i64 %344
  %346 = getelementptr inbounds %struct.AtomStr, ptr %345, i32 0, i32 0
  %347 = load ptr, ptr %346, align 8, !tbaa !9
  %348 = getelementptr inbounds %struct.PropertyStr, ptr %347, i32 0, i32 1
  %349 = getelementptr inbounds [2 x [16 x i8]], ptr %348, i64 0, i64 0
  %350 = getelementptr inbounds [16 x i8], ptr %349, i64 0, i64 0
  %351 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %352 = load i32, ptr %9, align 4, !tbaa !37
  %353 = sext i32 %352 to i64
  %354 = getelementptr inbounds %struct.AtomStr, ptr %351, i64 %353
  %355 = getelementptr inbounds %struct.AtomStr, ptr %354, i32 0, i32 0
  %356 = load ptr, ptr %355, align 8, !tbaa !9
  %357 = getelementptr inbounds %struct.PropertyStr, ptr %356, i32 0, i32 1
  %358 = getelementptr inbounds [2 x [16 x i8]], ptr %357, i64 0, i64 1
  %359 = getelementptr inbounds [16 x i8], ptr %358, i64 0, i64 0
  %360 = call i32 (ptr, ptr, ...) @__isoc99_fscanf(ptr noundef %324, ptr noundef @.str.242, ptr noundef %325, ptr noundef %333, ptr noundef %334, ptr noundef %341, ptr noundef %350, ptr noundef %359)
  %361 = load i32, ptr getelementptr inbounds (%struct.CGGovStr, ptr @CG, i32 0, i32 1), align 8, !tbaa !38
  %362 = icmp eq i32 %361, 2
  br i1 %362, label %363, label %383

363:                                              ; preds = %300
  %364 = getelementptr inbounds [20 x i8], ptr %1, i64 0, i64 0
  %365 = call i32 @AAModel(ptr noundef %364)
  %366 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %367 = load i32, ptr %9, align 4, !tbaa !37
  %368 = sext i32 %367 to i64
  %369 = getelementptr inbounds %struct.AtomStr, ptr %366, i64 %368
  %370 = getelementptr inbounds %struct.AtomStr, ptr %369, i32 0, i32 0
  %371 = load ptr, ptr %370, align 8, !tbaa !9
  %372 = getelementptr inbounds %struct.PropertyStr, ptr %371, i32 0, i32 4
  store i32 %365, ptr %372, align 4, !tbaa !12
  %373 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %374 = load i32, ptr %9, align 4, !tbaa !37
  %375 = sext i32 %374 to i64
  %376 = getelementptr inbounds %struct.AtomStr, ptr %373, i64 %375
  %377 = getelementptr inbounds %struct.AtomStr, ptr %376, i32 0, i32 0
  %378 = load ptr, ptr %377, align 8, !tbaa !9
  %379 = getelementptr inbounds %struct.PropertyStr, ptr %378, i32 0, i32 2
  %380 = getelementptr inbounds [8 x i8], ptr %379, i64 0, i64 0
  %381 = getelementptr inbounds [20 x i8], ptr %1, i64 0, i64 0
  %382 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %380, ptr noundef @.str.3, ptr noundef %381) #7
  br label %402

383:                                              ; preds = %300
  %384 = getelementptr inbounds [20 x i8], ptr %1, i64 0, i64 0
  %385 = call i32 @AtomModel(ptr noundef %384)
  %386 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %387 = load i32, ptr %9, align 4, !tbaa !37
  %388 = sext i32 %387 to i64
  %389 = getelementptr inbounds %struct.AtomStr, ptr %386, i64 %388
  %390 = getelementptr inbounds %struct.AtomStr, ptr %389, i32 0, i32 0
  %391 = load ptr, ptr %390, align 8, !tbaa !9
  %392 = getelementptr inbounds %struct.PropertyStr, ptr %391, i32 0, i32 4
  store i32 %385, ptr %392, align 4, !tbaa !12
  %393 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %394 = load i32, ptr %9, align 4, !tbaa !37
  %395 = sext i32 %394 to i64
  %396 = getelementptr inbounds %struct.AtomStr, ptr %393, i64 %395
  %397 = getelementptr inbounds %struct.AtomStr, ptr %396, i32 0, i32 0
  %398 = load ptr, ptr %397, align 8, !tbaa !9
  %399 = getelementptr inbounds %struct.PropertyStr, ptr %398, i32 0, i32 2
  %400 = getelementptr inbounds [8 x i8], ptr %399, i64 0, i64 0
  %401 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %400, ptr noundef @.str.243) #7
  br label %402

402:                                              ; preds = %383, %363
  %403 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 3), align 8, !tbaa !40
  %404 = load i32, ptr %9, align 4, !tbaa !37
  %405 = sext i32 %404 to i64
  %406 = getelementptr inbounds ptr, ptr %403, i64 %405
  %407 = load ptr, ptr %406, align 8, !tbaa !5
  %408 = getelementptr inbounds double, ptr %407, i64 1
  %409 = load double, ptr %408, align 8, !tbaa !17
  %410 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %411 = load i32, ptr %9, align 4, !tbaa !37
  %412 = sext i32 %411 to i64
  %413 = getelementptr inbounds %struct.AtomStr, ptr %410, i64 %412
  %414 = getelementptr inbounds %struct.AtomStr, ptr %413, i32 0, i32 1
  %415 = load ptr, ptr %414, align 8, !tbaa !11
  %416 = getelementptr inbounds %struct.DynamicStr, ptr %415, i32 0, i32 1
  %417 = getelementptr inbounds [4 x double], ptr %416, i64 0, i64 1
  store double %409, ptr %417, align 8, !tbaa !17
  %418 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 3), align 8, !tbaa !40
  %419 = load i32, ptr %9, align 4, !tbaa !37
  %420 = sext i32 %419 to i64
  %421 = getelementptr inbounds ptr, ptr %418, i64 %420
  %422 = load ptr, ptr %421, align 8, !tbaa !5
  %423 = getelementptr inbounds double, ptr %422, i64 2
  %424 = load double, ptr %423, align 8, !tbaa !17
  %425 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %426 = load i32, ptr %9, align 4, !tbaa !37
  %427 = sext i32 %426 to i64
  %428 = getelementptr inbounds %struct.AtomStr, ptr %425, i64 %427
  %429 = getelementptr inbounds %struct.AtomStr, ptr %428, i32 0, i32 1
  %430 = load ptr, ptr %429, align 8, !tbaa !11
  %431 = getelementptr inbounds %struct.DynamicStr, ptr %430, i32 0, i32 1
  %432 = getelementptr inbounds [4 x double], ptr %431, i64 0, i64 2
  store double %424, ptr %432, align 8, !tbaa !17
  %433 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 3), align 8, !tbaa !40
  %434 = load i32, ptr %9, align 4, !tbaa !37
  %435 = sext i32 %434 to i64
  %436 = getelementptr inbounds ptr, ptr %433, i64 %435
  %437 = load ptr, ptr %436, align 8, !tbaa !5
  %438 = getelementptr inbounds double, ptr %437, i64 3
  %439 = load double, ptr %438, align 8, !tbaa !17
  %440 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %441 = load i32, ptr %9, align 4, !tbaa !37
  %442 = sext i32 %441 to i64
  %443 = getelementptr inbounds %struct.AtomStr, ptr %440, i64 %442
  %444 = getelementptr inbounds %struct.AtomStr, ptr %443, i32 0, i32 1
  %445 = load ptr, ptr %444, align 8, !tbaa !11
  %446 = getelementptr inbounds %struct.DynamicStr, ptr %445, i32 0, i32 1
  %447 = getelementptr inbounds [4 x double], ptr %446, i64 0, i64 3
  store double %439, ptr %447, align 8, !tbaa !17
  %448 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %449 = load i32, ptr %9, align 4, !tbaa !37
  %450 = sext i32 %449 to i64
  %451 = getelementptr inbounds %struct.AtomStr, ptr %448, i64 %450
  %452 = getelementptr inbounds %struct.AtomStr, ptr %451, i32 0, i32 1
  %453 = load ptr, ptr %452, align 8, !tbaa !11
  %454 = getelementptr inbounds %struct.DynamicStr, ptr %453, i32 0, i32 5
  %455 = getelementptr inbounds %struct.InteractionEventStr, ptr %454, i32 0, i32 0
  store i32 -111, ptr %455, align 8, !tbaa !18
  %456 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %457 = load i32, ptr %9, align 4, !tbaa !37
  %458 = sext i32 %457 to i64
  %459 = getelementptr inbounds %struct.AtomStr, ptr %456, i64 %458
  %460 = getelementptr inbounds %struct.AtomStr, ptr %459, i32 0, i32 1
  %461 = load ptr, ptr %460, align 8, !tbaa !11
  %462 = getelementptr inbounds %struct.DynamicStr, ptr %461, i32 0, i32 5
  %463 = getelementptr inbounds %struct.InteractionEventStr, ptr %462, i32 0, i32 6
  store i32 8, ptr %463, align 4, !tbaa !24
  %464 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 4), align 8, !tbaa !35
  %465 = load i32, ptr %9, align 4, !tbaa !37
  %466 = sext i32 %465 to i64
  %467 = getelementptr inbounds %struct.AtomStr, ptr %464, i64 %466
  %468 = getelementptr inbounds %struct.AtomStr, ptr %467, i32 0, i32 1
  %469 = load ptr, ptr %468, align 8, !tbaa !11
  %470 = getelementptr inbounds %struct.DynamicStr, ptr %469, i32 0, i32 5
  %471 = getelementptr inbounds %struct.InteractionEventStr, ptr %470, i32 0, i32 5
  store i32 15, ptr %471, align 8, !tbaa !25
  br label %472

472:                                              ; preds = %402
  %473 = load i32, ptr %9, align 4, !tbaa !37
  %474 = add nsw i32 %473, 1
  store i32 %474, ptr %9, align 4, !tbaa !37
  br label %295, !llvm.loop !41

475:                                              ; preds = %299
  call void @llvm.lifetime.end.p0(i64 8, ptr %8) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %7) #7
  br label %476

476:                                              ; preds = %475, %279
  %477 = load i32, ptr @tunlObj, align 8, !tbaa !43
  %478 = icmp ne i32 %477, 0
  br i1 %478, label %479, label %676

479:                                              ; preds = %476
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #7
  %480 = call noalias ptr @calloc(i64 noundef 1, i64 noundef 136) #10
  store ptr %480, ptr %10, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #7
  %481 = call noalias ptr @calloc(i64 noundef 1, i64 noundef 176) #10
  store ptr %481, ptr %11, align 8, !tbaa !5
  %482 = load ptr, ptr %10, align 8, !tbaa !5
  store ptr %482, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), align 8, !tbaa !45
  %483 = load ptr, ptr %11, align 8, !tbaa !5
  store ptr %483, ptr getelementptr inbounds (%struct.AtomStr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), i32 0, i32 1), align 8, !tbaa !46
  %484 = load ptr, ptr %4, align 8, !tbaa !5
  %485 = call i32 @fseek(ptr noundef %484, i64 noundef 0, i32 noundef 0)
  %486 = getelementptr inbounds [1024 x i8], ptr %3, i64 0, i64 0
  %487 = load ptr, ptr %4, align 8, !tbaa !5
  %488 = call ptr @fgets(ptr noundef %486, i32 noundef 1024, ptr noundef %487)
  %489 = load ptr, ptr %4, align 8, !tbaa !5
  %490 = getelementptr inbounds [1024 x i8], ptr %3, i64 0, i64 0
  %491 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), align 8, !tbaa !45
  %492 = getelementptr inbounds %struct.PropertyStr, ptr %491, i32 0, i32 0
  %493 = getelementptr inbounds [8 x i8], ptr %492, i64 0, i64 0
  %494 = getelementptr inbounds [20 x i8], ptr %1, i64 0, i64 0
  %495 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), align 8, !tbaa !45
  %496 = getelementptr inbounds %struct.PropertyStr, ptr %495, i32 0, i32 7
  %497 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), align 8, !tbaa !45
  %498 = getelementptr inbounds %struct.PropertyStr, ptr %497, i32 0, i32 1
  %499 = getelementptr inbounds [2 x [16 x i8]], ptr %498, i64 0, i64 0
  %500 = getelementptr inbounds [16 x i8], ptr %499, i64 0, i64 0
  %501 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), align 8, !tbaa !45
  %502 = getelementptr inbounds %struct.PropertyStr, ptr %501, i32 0, i32 1
  %503 = getelementptr inbounds [2 x [16 x i8]], ptr %502, i64 0, i64 1
  %504 = getelementptr inbounds [16 x i8], ptr %503, i64 0, i64 0
  %505 = call i32 (ptr, ptr, ...) @__isoc99_fscanf(ptr noundef %489, ptr noundef @.str.242, ptr noundef %490, ptr noundef %493, ptr noundef %494, ptr noundef %496, ptr noundef %500, ptr noundef %504)
  %506 = getelementptr inbounds [20 x i8], ptr %1, i64 0, i64 0
  %507 = call i32 @AtomModel(ptr noundef %506)
  %508 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), align 8, !tbaa !45
  %509 = getelementptr inbounds %struct.PropertyStr, ptr %508, i32 0, i32 4
  store i32 %507, ptr %509, align 4, !tbaa !12
  %510 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), align 8, !tbaa !45
  %511 = getelementptr inbounds %struct.PropertyStr, ptr %510, i32 0, i32 2
  %512 = getelementptr inbounds [8 x i8], ptr %511, i64 0, i64 0
  %513 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %512, ptr noundef @.str.243) #7
  %514 = load ptr, ptr getelementptr inbounds (%struct.AtomStr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), i32 0, i32 1), align 8, !tbaa !46
  %515 = getelementptr inbounds %struct.DynamicStr, ptr %514, i32 0, i32 1
  %516 = getelementptr inbounds [4 x double], ptr %515, i64 0, i64 1
  store double 0.000000e+00, ptr %516, align 8, !tbaa !17
  %517 = load double, ptr getelementptr inbounds ([4 x double], ptr @boxDimension, i64 0, i64 2), align 16, !tbaa !17
  %518 = fdiv double %517, 2.000000e+00
  %519 = load ptr, ptr getelementptr inbounds (%struct.AtomStr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), i32 0, i32 1), align 8, !tbaa !46
  %520 = getelementptr inbounds %struct.DynamicStr, ptr %519, i32 0, i32 1
  %521 = getelementptr inbounds [4 x double], ptr %520, i64 0, i64 2
  store double %518, ptr %521, align 8, !tbaa !17
  %522 = load double, ptr getelementptr inbounds ([4 x double], ptr @boxDimension, i64 0, i64 3), align 8, !tbaa !17
  %523 = fdiv double %522, 2.000000e+00
  %524 = load ptr, ptr getelementptr inbounds (%struct.AtomStr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), i32 0, i32 1), align 8, !tbaa !46
  %525 = getelementptr inbounds %struct.DynamicStr, ptr %524, i32 0, i32 1
  %526 = getelementptr inbounds [4 x double], ptr %525, i64 0, i64 3
  store double %523, ptr %526, align 8, !tbaa !17
  %527 = load ptr, ptr getelementptr inbounds (%struct.AtomStr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), i32 0, i32 1), align 8, !tbaa !46
  %528 = getelementptr inbounds %struct.DynamicStr, ptr %527, i32 0, i32 5
  %529 = getelementptr inbounds %struct.InteractionEventStr, ptr %528, i32 0, i32 0
  store i32 -111, ptr %529, align 8, !tbaa !18
  %530 = load ptr, ptr getelementptr inbounds (%struct.AtomStr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), i32 0, i32 1), align 8, !tbaa !46
  %531 = getelementptr inbounds %struct.DynamicStr, ptr %530, i32 0, i32 5
  %532 = getelementptr inbounds %struct.InteractionEventStr, ptr %531, i32 0, i32 6
  store i32 8, ptr %532, align 4, !tbaa !24
  %533 = load ptr, ptr getelementptr inbounds (%struct.AtomStr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 4), i32 0, i32 1), align 8, !tbaa !46
  %534 = getelementptr inbounds %struct.DynamicStr, ptr %533, i32 0, i32 5
  %535 = getelementptr inbounds %struct.InteractionEventStr, ptr %534, i32 0, i32 5
  store i32 15, ptr %535, align 8, !tbaa !25
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #7
  store i32 0, ptr %12, align 4, !tbaa !37
  br label %536

536:                                              ; preds = %672, %479
  %537 = load i32, ptr %12, align 4, !tbaa !37
  %538 = load i32, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 1), align 4, !tbaa !34
  %539 = icmp slt i32 %537, %538
  br i1 %539, label %541, label %540

540:                                              ; preds = %536
  store i32 5, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #7
  br label %675

541:                                              ; preds = %536
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #7
  store i32 0, ptr %14, align 4, !tbaa !37
  br label %542

542:                                              ; preds = %668, %541
  %543 = load i32, ptr %14, align 4, !tbaa !37
  %544 = load i32, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 1), align 4, !tbaa !47
  %545 = icmp slt i32 %543, %544
  br i1 %545, label %547, label %546

546:                                              ; preds = %542
  store i32 8, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #7
  br label %671

547:                                              ; preds = %542
  %548 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 3), align 8, !tbaa !40
  %549 = load i32, ptr %12, align 4, !tbaa !37
  %550 = sext i32 %549 to i64
  %551 = getelementptr inbounds ptr, ptr %548, i64 %550
  %552 = load ptr, ptr %551, align 8, !tbaa !5
  %553 = getelementptr inbounds double, ptr %552, i64 1
  %554 = load double, ptr %553, align 8, !tbaa !17
  %555 = fcmp ogt double %554, 0.000000e+00
  br i1 %555, label %556, label %667

556:                                              ; preds = %547
  %557 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 3), align 8, !tbaa !40
  %558 = load i32, ptr %12, align 4, !tbaa !37
  %559 = sext i32 %558 to i64
  %560 = getelementptr inbounds ptr, ptr %557, i64 %559
  %561 = load ptr, ptr %560, align 8, !tbaa !5
  %562 = getelementptr inbounds double, ptr %561, i64 1
  %563 = load double, ptr %562, align 8, !tbaa !17
  %564 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 2), align 8, !tbaa !48
  %565 = load i32, ptr %14, align 4, !tbaa !37
  %566 = sext i32 %565 to i64
  %567 = getelementptr inbounds ptr, ptr %564, i64 %566
  %568 = load ptr, ptr %567, align 8, !tbaa !5
  %569 = getelementptr inbounds double, ptr %568, i64 0
  %570 = load double, ptr %569, align 8, !tbaa !17
  %571 = fsub double %563, %570
  %572 = fcmp olt double %571, 0.000000e+00
  br i1 %572, label %573, label %590

573:                                              ; preds = %556
  %574 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 3), align 8, !tbaa !40
  %575 = load i32, ptr %12, align 4, !tbaa !37
  %576 = sext i32 %575 to i64
  %577 = getelementptr inbounds ptr, ptr %574, i64 %576
  %578 = load ptr, ptr %577, align 8, !tbaa !5
  %579 = getelementptr inbounds double, ptr %578, i64 1
  %580 = load double, ptr %579, align 8, !tbaa !17
  %581 = fneg double %580
  %582 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 2), align 8, !tbaa !48
  %583 = load i32, ptr %14, align 4, !tbaa !37
  %584 = sext i32 %583 to i64
  %585 = getelementptr inbounds ptr, ptr %582, i64 %584
  %586 = load ptr, ptr %585, align 8, !tbaa !5
  %587 = getelementptr inbounds double, ptr %586, i64 0
  %588 = load double, ptr %587, align 8, !tbaa !17
  %589 = fsub double %581, %588
  br label %606

590:                                              ; preds = %556
  %591 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 3), align 8, !tbaa !40
  %592 = load i32, ptr %12, align 4, !tbaa !37
  %593 = sext i32 %592 to i64
  %594 = getelementptr inbounds ptr, ptr %591, i64 %593
  %595 = load ptr, ptr %594, align 8, !tbaa !5
  %596 = getelementptr inbounds double, ptr %595, i64 1
  %597 = load double, ptr %596, align 8, !tbaa !17
  %598 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 2), align 8, !tbaa !48
  %599 = load i32, ptr %14, align 4, !tbaa !37
  %600 = sext i32 %599 to i64
  %601 = getelementptr inbounds ptr, ptr %598, i64 %600
  %602 = load ptr, ptr %601, align 8, !tbaa !5
  %603 = getelementptr inbounds double, ptr %602, i64 0
  %604 = load double, ptr %603, align 8, !tbaa !17
  %605 = fsub double %597, %604
  br label %606

606:                                              ; preds = %590, %573
  %607 = phi double [ %589, %573 ], [ %605, %590 ]
  %608 = fcmp ole double %607, 1.000000e-08
  br i1 %608, label %662, label %609

609:                                              ; preds = %606
  %610 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 3), align 8, !tbaa !40
  %611 = load i32, ptr %12, align 4, !tbaa !37
  %612 = sext i32 %611 to i64
  %613 = getelementptr inbounds ptr, ptr %610, i64 %612
  %614 = load ptr, ptr %613, align 8, !tbaa !5
  %615 = getelementptr inbounds double, ptr %614, i64 1
  %616 = load double, ptr %615, align 8, !tbaa !17
  %617 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 2), align 8, !tbaa !48
  %618 = load i32, ptr %14, align 4, !tbaa !37
  %619 = sext i32 %618 to i64
  %620 = getelementptr inbounds ptr, ptr %617, i64 %619
  %621 = load ptr, ptr %620, align 8, !tbaa !5
  %622 = getelementptr inbounds double, ptr %621, i64 1
  %623 = load double, ptr %622, align 8, !tbaa !17
  %624 = fsub double %616, %623
  %625 = fcmp olt double %624, 0.000000e+00
  br i1 %625, label %626, label %643

626:                                              ; preds = %609
  %627 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 3), align 8, !tbaa !40
  %628 = load i32, ptr %12, align 4, !tbaa !37
  %629 = sext i32 %628 to i64
  %630 = getelementptr inbounds ptr, ptr %627, i64 %629
  %631 = load ptr, ptr %630, align 8, !tbaa !5
  %632 = getelementptr inbounds double, ptr %631, i64 1
  %633 = load double, ptr %632, align 8, !tbaa !17
  %634 = fneg double %633
  %635 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 2), align 8, !tbaa !48
  %636 = load i32, ptr %14, align 4, !tbaa !37
  %637 = sext i32 %636 to i64
  %638 = getelementptr inbounds ptr, ptr %635, i64 %637
  %639 = load ptr, ptr %638, align 8, !tbaa !5
  %640 = getelementptr inbounds double, ptr %639, i64 1
  %641 = load double, ptr %640, align 8, !tbaa !17
  %642 = fsub double %634, %641
  br label %659

643:                                              ; preds = %609
  %644 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 3), align 8, !tbaa !40
  %645 = load i32, ptr %12, align 4, !tbaa !37
  %646 = sext i32 %645 to i64
  %647 = getelementptr inbounds ptr, ptr %644, i64 %646
  %648 = load ptr, ptr %647, align 8, !tbaa !5
  %649 = getelementptr inbounds double, ptr %648, i64 1
  %650 = load double, ptr %649, align 8, !tbaa !17
  %651 = load ptr, ptr getelementptr inbounds (%struct.TunnelStr, ptr @tunlObj, i32 0, i32 2), align 8, !tbaa !48
  %652 = load i32, ptr %14, align 4, !tbaa !37
  %653 = sext i32 %652 to i64
  %654 = getelementptr inbounds ptr, ptr %651, i64 %653
  %655 = load ptr, ptr %654, align 8, !tbaa !5
  %656 = getelementptr inbounds double, ptr %655, i64 1
  %657 = load double, ptr %656, align 8, !tbaa !17
  %658 = fsub double %650, %657
  br label %659

659:                                              ; preds = %643, %626
  %660 = phi double [ %642, %626 ], [ %658, %643 ]
  %661 = fcmp ole double %660, 1.000000e-08
  br i1 %661, label %662, label %667

662:                                              ; preds = %659, %606
  %663 = load ptr, ptr getelementptr inbounds (%struct.ObstructionStr, ptr @obstObj, i32 0, i32 2), align 8, !tbaa !36
  %664 = load i32, ptr %12, align 4, !tbaa !37
  %665 = sext i32 %664 to i64
  %666 = getelementptr inbounds i32, ptr %663, i64 %665
  store i32 1, ptr %666, align 4, !tbaa !37
  br label %667

667:                                              ; preds = %662, %659, %547
  br label %668

668:                                              ; preds = %667
  %669 = load i32, ptr %14, align 4, !tbaa !37
  %670 = add nsw i32 %669, 1
  store i32 %670, ptr %14, align 4, !tbaa !37
  br label %542, !llvm.loop !49

671:                                              ; preds = %546
  br label %672

672:                                              ; preds = %671
  %673 = load i32, ptr %12, align 4, !tbaa !37
  %674 = add nsw i32 %673, 1
  store i32 %674, ptr %12, align 4, !tbaa !37
  br label %536, !llvm.loop !50

675:                                              ; preds = %540
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #7
  br label %676

676:                                              ; preds = %675, %476
  %677 = load ptr, ptr %4, align 8, !tbaa !5
  %678 = call i32 @fclose(ptr noundef %677)
  store i32 1, ptr %13, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #7
  call void @llvm.lifetime.end.p0(i64 1024, ptr %3) #7
  call void @llvm.lifetime.end.p0(i64 1024, ptr %2) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr %1) #7
  ret void
}

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

declare i32 @fclose(ptr noundef) #3

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

declare i32 @__isoc99_fscanf(ptr noundef, ptr noundef, ...) #3

declare ptr @fgets(ptr noundef, i32 noundef, ptr noundef) #3

declare i32 @AAModel(ptr noundef) #3

declare i32 @AtomModel(ptr noundef) #3

declare i32 @fseek(ptr noundef, i64 noundef, i32 noundef) #3

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !6, i64 0}
!10 = !{!"AtomStr", !6, i64 0, !6, i64 8}
!11 = !{!10, !6, i64 8}
!12 = !{!13, !14, i64 52}
!13 = !{!"PropertyStr", !7, i64 0, !7, i64 8, !7, i64 40, !14, i64 48, !14, i64 52, !14, i64 56, !15, i64 64, !15, i64 72, !7, i64 80, !16, i64 104, !6, i64 120, !6, i64 128}
!14 = !{!"int", !7, i64 0}
!15 = !{!"double", !7, i64 0}
!16 = !{!"AtomSeqStr", !14, i64 0, !14, i64 4, !14, i64 8}
!17 = !{!15, !15, i64 0}
!18 = !{!19, !14, i64 128}
!19 = !{!"DynamicStr", !7, i64 0, !7, i64 16, !7, i64 48, !20, i64 80, !21, i64 96, !22, i64 128}
!20 = !{!"HBStr", !14, i64 0, !14, i64 4, !7, i64 8, !14, i64 12}
!21 = !{!"HBNeighborStr", !7, i64 0, !14, i64 20, !14, i64 24}
!22 = !{!"InteractionEventStr", !14, i64 0, !23, i64 8, !23, i64 16, !15, i64 24, !15, i64 32, !14, i64 40, !14, i64 44}
!23 = !{!"long", !7, i64 0}
!24 = !{!19, !14, i64 172}
!25 = !{!19, !14, i64 168}
!26 = !{!27, !14, i64 16}
!27 = !{!"DynamicWallStr", !7, i64 0, !14, i64 16, !14, i64 20, !15, i64 24, !15, i64 32, !15, i64 40, !15, i64 48, !7, i64 56}
!28 = !{!27, !15, i64 24}
!29 = !{!27, !15, i64 48}
!30 = !{!27, !15, i64 32}
!31 = !{!27, !15, i64 40}
!32 = !{!33, !14, i64 0}
!33 = !{!"ObstructionStr", !14, i64 0, !14, i64 4, !6, i64 8, !6, i64 16, !6, i64 24}
!34 = !{!33, !14, i64 4}
!35 = !{!33, !6, i64 24}
!36 = !{!33, !6, i64 8}
!37 = !{!14, !14, i64 0}
!38 = !{!39, !14, i64 32}
!39 = !{!"CGGovStr", !7, i64 0, !14, i64 32, !14, i64 36, !6, i64 40, !6, i64 48}
!40 = !{!33, !6, i64 16}
!41 = distinct !{!41, !42}
!42 = !{!"llvm.loop.mustprogress"}
!43 = !{!44, !14, i64 0}
!44 = !{!"TunnelStr", !14, i64 0, !14, i64 4, !6, i64 8, !6, i64 16, !10, i64 24}
!45 = !{!44, !6, i64 24}
!46 = !{!44, !6, i64 32}
!47 = !{!44, !14, i64 4}
!48 = !{!44, !6, i64 8}
!49 = distinct !{!49, !42}
!50 = distinct !{!50, !42}


; 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.DynamicWallStr = type { [16 x i8], i32, i32, double, double, double, double, [4 x double] }
%struct.ObstructionStr = type { i32, i32, ptr, ptr, ptr }
%struct.CGGovStr = type { [2 x [16 x i8]], i32, i32, ptr, ptr }
%struct.TunnelStr = type { i32, i32, ptr, ptr, %struct.AtomStr }
%struct.AtomStr = type { ptr, ptr }
%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 }
%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 }

@.str.2 = external hidden unnamed_addr constant [71 x i8], align 1
@datadir = external global [1024 x i8], align 16
@.str.3 = external hidden unnamed_addr constant [3 x i8], align 1
@boxDimension = external local_unnamed_addr global [4 x double], align 16
@wallDyn = external global %struct.DynamicWallStr, align 8
@wallExist = external global [20 x i8], align 16
@.str.88 = external hidden unnamed_addr constant [3 x i8], align 1
@obstObj = external local_unnamed_addr global %struct.ObstructionStr, align 8
@CG = external local_unnamed_addr global %struct.CGGovStr, align 8
@.str.94 = external hidden unnamed_addr constant [2 x i8], align 1
@currenttime = external local_unnamed_addr global double, align 8
@Methodtype = external global [20 x i8], align 16
@.str.107 = external hidden unnamed_addr constant [41 x i8], align 1
@wallType = external local_unnamed_addr global [20 x i8], align 16
@tunlObj = external local_unnamed_addr global %struct.TunnelStr, align 8
@.str.239 = external hidden unnamed_addr constant [23 x i8], align 1
@.str.240 = external hidden unnamed_addr constant [57 x i8], align 1
@.str.241 = external hidden unnamed_addr constant [7 x i8], align 1
@wall = external local_unnamed_addr global ptr, align 8
@.str.242 = external hidden unnamed_addr constant [14 x i8], align 1
@.str.243 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.244 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.245 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.246 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.247 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.248 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.249 = external hidden unnamed_addr constant [80 x i8], align 1
@.str.250 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.251 = external hidden unnamed_addr constant [73 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 nofree nounwind willreturn allockind("alloc,zeroed") allocsize(0,1) memory(inaccessiblemem: readwrite)
declare noalias noundef ptr @calloc(i64 noundef, i64 noundef) local_unnamed_addr #1

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @ReadWall() local_unnamed_addr #5 {
  %1 = alloca [20 x i8], align 16
  %2 = alloca [1024 x i8], align 16
  %3 = alloca [1024 x i8], align 16
  call void @llvm.lifetime.start.p0(i64 20, ptr nonnull %1) #7
  call void @llvm.lifetime.start.p0(i64 1024, ptr nonnull %2) #7
  call void @llvm.lifetime.start.p0(i64 1024, ptr nonnull %3) #7
  %4 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %2, ptr noundef nonnull dereferenceable(1) @.str.239, ptr noundef nonnull @datadir, ptr noundef nonnull @Methodtype) #7
  %5 = call noalias ptr @fopen(ptr noundef nonnull %2, ptr noundef nonnull @.str.94)
  %6 = icmp eq ptr %5, null
  br i1 %6, label %7, label %10

7:                                                ; preds = %0
  %8 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.240, ptr noundef nonnull @datadir, ptr noundef nonnull @Methodtype)
  %9 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.107)
  tail call void @exit(i32 noundef 1) #8
  unreachable

10:                                               ; preds = %0
  %11 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) @wallExist, ptr noundef nonnull dereferenceable(1) @.str.241) #9
  %12 = icmp eq i32 %11, 0
  br i1 %12, label %13, label %120

13:                                               ; preds = %10
  %14 = tail call noalias dereferenceable_or_null(16) ptr @calloc(i64 noundef 1, i64 noundef 16) #10
  store ptr %14, ptr @wall, align 8, !tbaa !5
  %15 = tail call noalias dereferenceable_or_null(136) ptr @calloc(i64 noundef 1, i64 noundef 136) #10
  %16 = tail call noalias dereferenceable_or_null(176) ptr @calloc(i64 noundef 1, i64 noundef 176) #10
  store ptr %15, ptr %14, align 8, !tbaa !9
  %17 = getelementptr inbounds i8, ptr %14, i64 8
  store ptr %16, ptr %17, align 8, !tbaa !11
  %18 = call ptr @fgets(ptr noundef nonnull %3, i32 noundef 1024, ptr noundef nonnull %5)
  %19 = load ptr, ptr @wall, align 8, !tbaa !5
  %20 = load ptr, ptr %19, align 8, !tbaa !9
  %21 = getelementptr inbounds i8, ptr %20, i64 72
  %22 = getelementptr inbounds i8, ptr %20, i64 8
  %23 = getelementptr inbounds i8, ptr %20, i64 24
  %24 = call i32 (ptr, ptr, ...) @__isoc99_fscanf(ptr noundef nonnull %5, ptr noundef nonnull @.str.242, ptr noundef nonnull %3, ptr noundef %20, ptr noundef nonnull %1, ptr noundef nonnull %21, ptr noundef nonnull %22, ptr noundef nonnull %23) #7
  %25 = call i32 @AtomModel(ptr noundef nonnull %1) #7
  %26 = load ptr, ptr @wall, align 8, !tbaa !5
  %27 = load ptr, ptr %26, align 8, !tbaa !9
  %28 = getelementptr inbounds i8, ptr %27, i64 52
  store i32 %25, ptr %28, align 4, !tbaa !12
  %29 = getelementptr inbounds i8, ptr %27, i64 40
  %30 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %29, ptr noundef nonnull dereferenceable(1) @.str.243) #7
  %31 = load ptr, ptr @wall, align 8, !tbaa !5
  %32 = getelementptr inbounds i8, ptr %31, i64 8
  %33 = load ptr, ptr %32, align 8, !tbaa !11
  %34 = getelementptr inbounds i8, ptr %33, i64 24
  %35 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 8), align 8, !tbaa !17
  %36 = getelementptr inbounds i8, ptr %33, i64 32
  %37 = fmul <2 x double> %35, <double 5.000000e-01, double 5.000000e-01>
  store <2 x double> %37, ptr %34, align 8, !tbaa !17
  %38 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 24), align 8, !tbaa !17
  %39 = fmul double %38, 5.000000e-01
  %40 = getelementptr inbounds i8, ptr %33, i64 40
  store double %39, ptr %40, align 8, !tbaa !17
  %41 = getelementptr inbounds i8, ptr %33, i64 128
  store i32 -111, ptr %41, align 8, !tbaa !18
  %42 = getelementptr inbounds i8, ptr %33, i64 172
  store i32 8, ptr %42, align 4, !tbaa !24
  %43 = getelementptr inbounds i8, ptr %33, i64 168
  store i32 15, ptr %43, align 8, !tbaa !25
  %lhsc = load i8, ptr @wallType, align 16
  %rhsc = load i8, ptr @.str.244, align 1
  %44 = icmp eq i8 %lhsc, %rhsc
  br i1 %44, label %45, label %46

45:                                               ; preds = %13
  store double 0.000000e+00, ptr %40, align 8, !tbaa !17
  br label %.sink.split

46:                                               ; preds = %13
  %rhsc66 = load i8, ptr @.str.245, align 1
  %47 = icmp eq i8 %lhsc, %rhsc66
  br i1 %47, label %.sink.split, label %48

.sink.split:                                      ; preds = %46, %45
  store double 0.000000e+00, ptr %34, align 8, !tbaa !17
  br label %48

48:                                               ; preds = %.sink.split, %46
  %49 = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) @wallDyn, ptr noundef nonnull dereferenceable(1) @.str.88) #9
  %.not = icmp eq i32 %49, 0
  br i1 %.not, label %120, label %50

50:                                               ; preds = %48
  %51 = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) @wallDyn, ptr noundef nonnull dereferenceable(1) @.str.246) #9
  %.not67 = icmp eq i32 %51, 0
  br i1 %.not67, label %58, label %52

52:                                               ; preds = %50
  %53 = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) @wallDyn, ptr noundef nonnull dereferenceable(1) @.str.247) #9
  %.not68 = icmp eq i32 %53, 0
  br i1 %.not68, label %58, label %54

54:                                               ; preds = %52
  %55 = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) @wallDyn, ptr noundef nonnull dereferenceable(1) @.str.248) #9
  %.not69 = icmp eq i32 %55, 0
  br i1 %.not69, label %58, label %56

56:                                               ; preds = %54
  %57 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.249, ptr noundef nonnull @.str.2, i32 noundef 1941)
  call void @exit(i32 noundef 1) #8
  unreachable

58:                                               ; preds = %54, %52, %50
  %59 = load i32, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 16), align 8, !tbaa !26
  %.not70 = icmp eq i32 %59, 0
  br i1 %.not70, label %60, label %61

60:                                               ; preds = %58
  store i32 1, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 16), align 8, !tbaa !26
  br label %61

61:                                               ; preds = %60, %58
  %62 = load double, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 24), align 8, !tbaa !28
  %63 = fcmp une double %62, 0.000000e+00
  br i1 %63, label %65, label %64

64:                                               ; preds = %61
  store double 5.000000e+00, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 24), align 8, !tbaa !28
  br label %65

65:                                               ; preds = %64, %61
  %66 = phi double [ 5.000000e+00, %64 ], [ %62, %61 ]
  %67 = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) @wallDyn, ptr noundef nonnull dereferenceable(1) @.str.246) #9
  %68 = icmp eq i32 %67, 0
  br i1 %68, label %69, label %70

69:                                               ; preds = %65
  store i32 -1, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 16), align 8, !tbaa !26
  br label %70

70:                                               ; preds = %69, %65
  %71 = call i32 @strcmp(ptr noundef nonnull dereferenceable(1) @wallDyn, ptr noundef nonnull dereferenceable(1) @.str.247) #9
  %72 = icmp eq i32 %71, 0
  br i1 %72, label %73, label %74

73:                                               ; preds = %70
  store i32 1, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 16), align 8, !tbaa !26
  br label %74

74:                                               ; preds = %73, %70
  %75 = load double, ptr @currenttime, align 8, !tbaa !17
  %76 = load double, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 48), align 8, !tbaa !29
  %77 = fsub double %75, %76
  %78 = fcmp ogt double %77, 1.000000e+00
  br i1 %78, label %79, label %83

79:                                               ; preds = %74
  %80 = fptosi double %75 to i64
  %81 = add nsw i64 %80, 1
  %82 = sitofp i64 %81 to double
  store double %82, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 48), align 8, !tbaa !29
  br label %83

83:                                               ; preds = %79, %74
  %84 = load double, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 64), align 8, !tbaa !17
  %85 = fcmp une double %84, 0.000000e+00
  %86 = load double, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 72), align 8
  %87 = fcmp une double %86, 0.000000e+00
  %or.cond = select i1 %85, i1 %87, i1 false
  %88 = load double, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 80), align 8
  %89 = fcmp une double %88, 0.000000e+00
  %or.cond3 = select i1 %or.cond, i1 %89, i1 false
  br i1 %or.cond3, label %94, label %90

90:                                               ; preds = %83
  %91 = load double, ptr @boxDimension, align 16, !tbaa !17
  store double %91, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 56), align 8, !tbaa !17
  store <2 x double> %35, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 64), align 8, !tbaa !17
  %92 = load double, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 24), align 8, !tbaa !17
  store double %92, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 80), align 8, !tbaa !17
  %93 = extractelement <2 x double> %35, i64 1
  br label %94

94:                                               ; preds = %83, %90
  %95 = phi double [ %86, %83 ], [ %93, %90 ]
  br i1 %44, label %96, label %98

96:                                               ; preds = %94
  %97 = fmul double %95, 5.000000e-01
  store double %97, ptr %36, align 8, !tbaa !17
  br label %106

98:                                               ; preds = %94
  %rhsc74 = load i8, ptr @.str.245, align 1
  %99 = icmp eq i8 %lhsc, %rhsc74
  br i1 %99, label %100, label %102

100:                                              ; preds = %98
  %101 = fmul double %95, 5.000000e-01
  store double %101, ptr %40, align 8, !tbaa !17
  store double %101, ptr %36, align 8, !tbaa !17
  br label %106

102:                                              ; preds = %98
  %rhsc76 = load i8, ptr @.str.250, align 1
  %103 = icmp eq i8 %lhsc, %rhsc76
  br i1 %103, label %104, label %106

104:                                              ; preds = %102
  %105 = fmul double %95, 5.000000e-01
  store double %105, ptr %40, align 8, !tbaa !17
  store double %105, ptr %36, align 8, !tbaa !17
  store double %105, ptr %34, align 8, !tbaa !17
  %.pre = load double, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 24), align 8, !tbaa !28
  br label %106

106:                                              ; preds = %100, %104, %102, %96
  %107 = phi double [ %66, %100 ], [ %.pre, %104 ], [ %66, %102 ], [ %66, %96 ]
  %108 = load double, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 72), align 8, !tbaa !17
  %109 = fsub double %108, %107
  %110 = fcmp ugt double %109, 1.300000e+01
  br i1 %110, label %113, label %111

111:                                              ; preds = %106
  %112 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.251, ptr noundef nonnull @.str.2, i32 noundef 1972)
  call void @exit(i32 noundef 1) #8
  unreachable

113:                                              ; preds = %106
  %114 = load double, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 32), align 8, !tbaa !30
  %115 = fcmp une double %114, 0.000000e+00
  br i1 %115, label %117, label %116

116:                                              ; preds = %113
  store double 2.000000e+02, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 32), align 8, !tbaa !30
  br label %117

117:                                              ; preds = %116, %113
  %118 = phi double [ 2.000000e+02, %116 ], [ %114, %113 ]
  %119 = fdiv double %107, %118
  store double %119, ptr getelementptr inbounds (i8, ptr @wallDyn, i64 40), align 8, !tbaa !31
  br label %120

120:                                              ; preds = %48, %117, %10
  %121 = load i32, ptr @obstObj, align 8, !tbaa !32
  %.not77 = icmp eq i32 %121, 0
  br i1 %.not77, label %.loopexit79, label %122

122:                                              ; preds = %120
  %123 = load i32, ptr getelementptr inbounds (i8, ptr @obstObj, i64 4), align 4, !tbaa !34
  %124 = sext i32 %123 to i64
  %125 = call noalias ptr @calloc(i64 noundef %124, i64 noundef 16) #10
  store ptr %125, ptr getelementptr inbounds (i8, ptr @obstObj, i64 24), align 8, !tbaa !35
  %126 = call noalias ptr @calloc(i64 noundef %124, i64 noundef 4) #10
  store ptr %126, ptr getelementptr inbounds (i8, ptr @obstObj, i64 8), align 8, !tbaa !36
  %127 = call noalias ptr @calloc(i64 noundef %124, i64 noundef 136) #10
  %128 = call noalias ptr @calloc(i64 noundef %124, i64 noundef 176) #10
  %129 = icmp sgt i32 %123, 0
  br i1 %129, label %.lr.ph, label %.loopexit79

.lr.ph:                                           ; preds = %122, %162
  %130 = phi ptr [ %168, %162 ], [ %125, %122 ]
  %indvars.iv = phi i64 [ %indvars.iv.next, %162 ], [ 0, %122 ]
  %131 = getelementptr inbounds %struct.PropertyStr, ptr %127, i64 %indvars.iv
  %132 = getelementptr inbounds %struct.AtomStr, ptr %130, i64 %indvars.iv
  store ptr %131, ptr %132, align 8, !tbaa !9
  %133 = getelementptr inbounds %struct.DynamicStr, ptr %128, i64 %indvars.iv
  %134 = getelementptr inbounds %struct.AtomStr, ptr %130, i64 %indvars.iv, i32 1
  store ptr %133, ptr %134, align 8, !tbaa !11
  %135 = call i32 @fseek(ptr noundef nonnull %5, i64 noundef 0, i32 noundef 0)
  %136 = call ptr @fgets(ptr noundef nonnull %3, i32 noundef 1024, ptr noundef nonnull %5)
  %137 = load ptr, ptr getelementptr inbounds (i8, ptr @obstObj, i64 24), align 8, !tbaa !35
  %138 = getelementptr inbounds %struct.AtomStr, ptr %137, i64 %indvars.iv
  %139 = load ptr, ptr %138, align 8, !tbaa !9
  %140 = getelementptr inbounds i8, ptr %139, i64 72
  %141 = getelementptr inbounds i8, ptr %139, i64 8
  %142 = getelementptr inbounds i8, ptr %139, i64 24
  %143 = call i32 (ptr, ptr, ...) @__isoc99_fscanf(ptr noundef nonnull %5, ptr noundef nonnull @.str.242, ptr noundef nonnull %3, ptr noundef %139, ptr noundef nonnull %1, ptr noundef nonnull %140, ptr noundef nonnull %141, ptr noundef nonnull %142) #7
  %144 = load i32, ptr getelementptr inbounds (i8, ptr @CG, i64 32), align 8, !tbaa !37
  %145 = icmp eq i32 %144, 2
  br i1 %145, label %146, label %154

146:                                              ; preds = %.lr.ph
  %147 = call i32 @AAModel(ptr noundef nonnull %1) #7
  %148 = load ptr, ptr getelementptr inbounds (i8, ptr @obstObj, i64 24), align 8, !tbaa !35
  %149 = getelementptr inbounds %struct.AtomStr, ptr %148, i64 %indvars.iv
  %150 = load ptr, ptr %149, align 8, !tbaa !9
  %151 = getelementptr inbounds i8, ptr %150, i64 52
  store i32 %147, ptr %151, align 4, !tbaa !12
  %152 = getelementptr inbounds i8, ptr %150, i64 40
  %153 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %152, ptr noundef nonnull dereferenceable(1) @.str.3, ptr noundef nonnull %1) #7
  br label %162

154:                                              ; preds = %.lr.ph
  %155 = call i32 @AtomModel(ptr noundef nonnull %1) #7
  %156 = load ptr, ptr getelementptr inbounds (i8, ptr @obstObj, i64 24), align 8, !tbaa !35
  %157 = getelementptr inbounds %struct.AtomStr, ptr %156, i64 %indvars.iv
  %158 = load ptr, ptr %157, align 8, !tbaa !9
  %159 = getelementptr inbounds i8, ptr %158, i64 52
  store i32 %155, ptr %159, align 4, !tbaa !12
  %160 = getelementptr inbounds i8, ptr %158, i64 40
  %161 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %160, ptr noundef nonnull dereferenceable(1) @.str.243) #7
  br label %162

162:                                              ; preds = %154, %146
  %163 = load ptr, ptr getelementptr inbounds (i8, ptr @obstObj, i64 16), align 8, !tbaa !39
  %164 = getelementptr inbounds ptr, ptr %163, i64 %indvars.iv
  %165 = load ptr, ptr %164, align 8, !tbaa !5
  %166 = getelementptr inbounds i8, ptr %165, i64 8
  %167 = load double, ptr %166, align 8, !tbaa !17
  %168 = load ptr, ptr getelementptr inbounds (i8, ptr @obstObj, i64 24), align 8, !tbaa !35
  %169 = getelementptr inbounds %struct.AtomStr, ptr %168, i64 %indvars.iv, i32 1
  %170 = load ptr, ptr %169, align 8, !tbaa !11
  %171 = getelementptr inbounds i8, ptr %170, i64 24
  store double %167, ptr %171, align 8, !tbaa !17
  %172 = getelementptr inbounds i8, ptr %165, i64 16
  %173 = load double, ptr %172, align 8, !tbaa !17
  %174 = getelementptr inbounds i8, ptr %170, i64 32
  store double %173, ptr %174, align 8, !tbaa !17
  %175 = getelementptr inbounds i8, ptr %165, i64 24
  %176 = load double, ptr %175, align 8, !tbaa !17
  %177 = getelementptr inbounds i8, ptr %170, i64 40
  store double %176, ptr %177, align 8, !tbaa !17
  %178 = getelementptr inbounds i8, ptr %170, i64 128
  store i32 -111, ptr %178, align 8, !tbaa !18
  %179 = getelementptr inbounds i8, ptr %170, i64 172
  store i32 8, ptr %179, align 4, !tbaa !24
  %180 = getelementptr inbounds i8, ptr %170, i64 168
  store i32 15, ptr %180, align 8, !tbaa !25
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %181 = load i32, ptr getelementptr inbounds (i8, ptr @obstObj, i64 4), align 4, !tbaa !34
  %182 = sext i32 %181 to i64
  %183 = icmp slt i64 %indvars.iv.next, %182
  br i1 %183, label %.lr.ph, label %.loopexit79, !llvm.loop !40

.loopexit79:                                      ; preds = %162, %122, %120
  %184 = load i32, ptr @tunlObj, align 8, !tbaa !42
  %.not78 = icmp eq i32 %184, 0
  br i1 %.not78, label %.loopexit, label %185

185:                                              ; preds = %.loopexit79
  %186 = call noalias dereferenceable_or_null(136) ptr @calloc(i64 noundef 1, i64 noundef 136) #10
  %187 = call noalias dereferenceable_or_null(176) ptr @calloc(i64 noundef 1, i64 noundef 176) #10
  store ptr %186, ptr getelementptr inbounds (i8, ptr @tunlObj, i64 24), align 8, !tbaa !44
  store ptr %187, ptr getelementptr inbounds (i8, ptr @tunlObj, i64 32), align 8, !tbaa !45
  %188 = call i32 @fseek(ptr noundef nonnull %5, i64 noundef 0, i32 noundef 0)
  %189 = call ptr @fgets(ptr noundef nonnull %3, i32 noundef 1024, ptr noundef nonnull %5)
  %190 = load ptr, ptr getelementptr inbounds (i8, ptr @tunlObj, i64 24), align 8, !tbaa !44
  %191 = getelementptr inbounds i8, ptr %190, i64 72
  %192 = getelementptr inbounds i8, ptr %190, i64 8
  %193 = getelementptr inbounds i8, ptr %190, i64 24
  %194 = call i32 (ptr, ptr, ...) @__isoc99_fscanf(ptr noundef nonnull %5, ptr noundef nonnull @.str.242, ptr noundef nonnull %3, ptr noundef %190, ptr noundef nonnull %1, ptr noundef nonnull %191, ptr noundef nonnull %192, ptr noundef nonnull %193) #7
  %195 = call i32 @AtomModel(ptr noundef nonnull %1) #7
  %196 = load ptr, ptr getelementptr inbounds (i8, ptr @tunlObj, i64 24), align 8, !tbaa !44
  %197 = getelementptr inbounds i8, ptr %196, i64 52
  store i32 %195, ptr %197, align 4, !tbaa !12
  %198 = getelementptr inbounds i8, ptr %196, i64 40
  %199 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %198, ptr noundef nonnull dereferenceable(1) @.str.243) #7
  %200 = load ptr, ptr getelementptr inbounds (i8, ptr @tunlObj, i64 32), align 8, !tbaa !45
  %201 = getelementptr inbounds i8, ptr %200, i64 24
  store double 0.000000e+00, ptr %201, align 8, !tbaa !17
  %202 = getelementptr inbounds i8, ptr %200, i64 32
  %203 = load <2 x double>, ptr getelementptr inbounds (i8, ptr @boxDimension, i64 16), align 16, !tbaa !17
  %204 = fmul <2 x double> %203, <double 5.000000e-01, double 5.000000e-01>
  store <2 x double> %204, ptr %202, align 8, !tbaa !17
  %205 = getelementptr inbounds i8, ptr %200, i64 128
  store i32 -111, ptr %205, align 8, !tbaa !18
  %206 = getelementptr inbounds i8, ptr %200, i64 172
  store i32 8, ptr %206, align 4, !tbaa !24
  %207 = getelementptr inbounds i8, ptr %200, i64 168
  store i32 15, ptr %207, align 8, !tbaa !25
  %208 = load i32, ptr getelementptr inbounds (i8, ptr @obstObj, i64 4), align 4, !tbaa !34
  %209 = icmp sgt i32 %208, 0
  br i1 %209, label %.preheader.lr.ph, label %.loopexit

.preheader.lr.ph:                                 ; preds = %185
  %210 = load ptr, ptr getelementptr inbounds (i8, ptr @obstObj, i64 16), align 8
  %211 = load i32, ptr getelementptr inbounds (i8, ptr @tunlObj, i64 4), align 4, !tbaa !46
  %212 = icmp sgt i32 %211, 0
  br i1 %212, label %.preheader, label %.loopexit

.preheader:                                       ; preds = %.preheader.lr.ph, %._crit_edge
  %213 = phi i32 [ %248, %._crit_edge ], [ %208, %.preheader.lr.ph ]
  %214 = phi i32 [ %249, %._crit_edge ], [ %211, %.preheader.lr.ph ]
  %215 = phi i32 [ %250, %._crit_edge ], [ %211, %.preheader.lr.ph ]
  %indvars.iv90 = phi i64 [ %indvars.iv.next91, %._crit_edge ], [ 0, %.preheader.lr.ph ]
  %216 = icmp sgt i32 %215, 0
  br i1 %216, label %.lr.ph82, label %._crit_edge

.lr.ph82:                                         ; preds = %.preheader
  %217 = getelementptr inbounds ptr, ptr %210, i64 %indvars.iv90
  %218 = load ptr, ptr %217, align 8, !tbaa !5
  %219 = getelementptr inbounds i8, ptr %218, i64 8
  %220 = load double, ptr %219, align 8, !tbaa !17
  %221 = fcmp ogt double %220, 0.000000e+00
  %222 = load ptr, ptr getelementptr inbounds (i8, ptr @tunlObj, i64 8), align 8
  %223 = fneg double %220
  %224 = load ptr, ptr getelementptr inbounds (i8, ptr @obstObj, i64 8), align 8
  %225 = getelementptr inbounds i32, ptr %224, i64 %indvars.iv90
  br i1 %221, label %.lr.ph82.split.us, label %._crit_edge

.lr.ph82.split.us:                                ; preds = %.lr.ph82, %244
  %226 = phi i32 [ %245, %244 ], [ %214, %.lr.ph82 ]
  %indvars.iv87 = phi i64 [ %indvars.iv.next88, %244 ], [ 0, %.lr.ph82 ]
  %227 = getelementptr inbounds ptr, ptr %222, i64 %indvars.iv87
  %228 = load ptr, ptr %227, align 8, !tbaa !5
  %229 = load double, ptr %228, align 8, !tbaa !17
  %230 = fsub double %220, %229
  %231 = fcmp olt double %230, 0.000000e+00
  %232 = fsub double %223, %229
  %233 = select i1 %231, double %232, double %230
  %234 = fcmp ugt double %233, 1.000000e-08
  br i1 %234, label %235, label %243

235:                                              ; preds = %.lr.ph82.split.us
  %236 = getelementptr inbounds i8, ptr %228, i64 8
  %237 = load double, ptr %236, align 8, !tbaa !17
  %238 = fsub double %220, %237
  %239 = fcmp olt double %238, 0.000000e+00
  %240 = fsub double %223, %237
  %241 = select i1 %239, double %240, double %238
  %242 = fcmp ugt double %241, 1.000000e-08
  br i1 %242, label %244, label %243

243:                                              ; preds = %235, %.lr.ph82.split.us
  store i32 1, ptr %225, align 4, !tbaa !47
  %.pre93 = load i32, ptr getelementptr inbounds (i8, ptr @tunlObj, i64 4), align 4, !tbaa !46
  br label %244

244:                                              ; preds = %243, %235
  %245 = phi i32 [ %.pre93, %243 ], [ %226, %235 ]
  %indvars.iv.next88 = add nuw nsw i64 %indvars.iv87, 1
  %246 = sext i32 %245 to i64
  %247 = icmp slt i64 %indvars.iv.next88, %246
  br i1 %247, label %.lr.ph82.split.us, label %._crit_edge.loopexit, !llvm.loop !48

._crit_edge.loopexit:                             ; preds = %244
  %.pre94 = load i32, ptr getelementptr inbounds (i8, ptr @obstObj, i64 4), align 4, !tbaa !34
  br label %._crit_edge

._crit_edge:                                      ; preds = %.lr.ph82, %._crit_edge.loopexit, %.preheader
  %248 = phi i32 [ %.pre94, %._crit_edge.loopexit ], [ %213, %.preheader ], [ %213, %.lr.ph82 ]
  %249 = phi i32 [ %245, %._crit_edge.loopexit ], [ %214, %.preheader ], [ %214, %.lr.ph82 ]
  %250 = phi i32 [ %245, %._crit_edge.loopexit ], [ %215, %.preheader ], [ %215, %.lr.ph82 ]
  %indvars.iv.next91 = add nuw nsw i64 %indvars.iv90, 1
  %251 = sext i32 %248 to i64
  %252 = icmp slt i64 %indvars.iv.next91, %251
  br i1 %252, label %.preheader, label %.loopexit, !llvm.loop !49

.loopexit:                                        ; preds = %._crit_edge, %.preheader.lr.ph, %185, %.loopexit79
  %253 = call i32 @fclose(ptr noundef nonnull %5)
  call void @llvm.lifetime.end.p0(i64 1024, ptr nonnull %3) #7
  call void @llvm.lifetime.end.p0(i64 1024, ptr nonnull %2) #7
  call void @llvm.lifetime.end.p0(i64 20, ptr nonnull %1) #7
  ret void
}

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

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

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

declare i32 @__isoc99_fscanf(ptr noundef, ptr noundef, ...) local_unnamed_addr #6

; Function Attrs: nofree nounwind
declare noundef ptr @fgets(ptr noundef, i32 noundef, ptr nocapture noundef) local_unnamed_addr #3

declare i32 @AAModel(ptr noundef) local_unnamed_addr #6

declare i32 @AtomModel(ptr noundef) local_unnamed_addr #6

; Function Attrs: nofree nounwind
declare noundef i32 @fseek(ptr nocapture noundef, i64 noundef, i32 noundef) local_unnamed_addr #3

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !6, i64 0}
!10 = !{!"AtomStr", !6, i64 0, !6, i64 8}
!11 = !{!10, !6, i64 8}
!12 = !{!13, !14, i64 52}
!13 = !{!"PropertyStr", !7, i64 0, !7, i64 8, !7, i64 40, !14, i64 48, !14, i64 52, !14, i64 56, !15, i64 64, !15, i64 72, !7, i64 80, !16, i64 104, !6, i64 120, !6, i64 128}
!14 = !{!"int", !7, i64 0}
!15 = !{!"double", !7, i64 0}
!16 = !{!"AtomSeqStr", !14, i64 0, !14, i64 4, !14, i64 8}
!17 = !{!15, !15, i64 0}
!18 = !{!19, !14, i64 128}
!19 = !{!"DynamicStr", !7, i64 0, !7, i64 16, !7, i64 48, !20, i64 80, !21, i64 96, !22, i64 128}
!20 = !{!"HBStr", !14, i64 0, !14, i64 4, !7, i64 8, !14, i64 12}
!21 = !{!"HBNeighborStr", !7, i64 0, !14, i64 20, !14, i64 24}
!22 = !{!"InteractionEventStr", !14, i64 0, !23, i64 8, !23, i64 16, !15, i64 24, !15, i64 32, !14, i64 40, !14, i64 44}
!23 = !{!"long", !7, i64 0}
!24 = !{!19, !14, i64 172}
!25 = !{!19, !14, i64 168}
!26 = !{!27, !14, i64 16}
!27 = !{!"DynamicWallStr", !7, i64 0, !14, i64 16, !14, i64 20, !15, i64 24, !15, i64 32, !15, i64 40, !15, i64 48, !7, i64 56}
!28 = !{!27, !15, i64 24}
!29 = !{!27, !15, i64 48}
!30 = !{!27, !15, i64 32}
!31 = !{!27, !15, i64 40}
!32 = !{!33, !14, i64 0}
!33 = !{!"ObstructionStr", !14, i64 0, !14, i64 4, !6, i64 8, !6, i64 16, !6, i64 24}
!34 = !{!33, !14, i64 4}
!35 = !{!33, !6, i64 24}
!36 = !{!33, !6, i64 8}
!37 = !{!38, !14, i64 32}
!38 = !{!"CGGovStr", !7, i64 0, !14, i64 32, !14, i64 36, !6, i64 40, !6, i64 48}
!39 = !{!33, !6, i64 16}
!40 = distinct !{!40, !41}
!41 = !{!"llvm.loop.mustprogress"}
!42 = !{!43, !14, i64 0}
!43 = !{!"TunnelStr", !14, i64 0, !14, i64 4, !6, i64 8, !6, i64 16, !10, i64 24}
!44 = !{!43, !6, i64 24}
!45 = !{!43, !6, i64 32}
!46 = !{!43, !14, i64 4}
!47 = !{!14, !14, i64 0}
!48 = distinct !{!48, !41}
!49 = distinct !{!49, !41, !50}
!50 = !{!"llvm.loop.unswitch.partial.disable"}


; Effective O3 passes: EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferAlignmentPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,JumpThreadingPass,LCSSAPass,LICMPass,LoopRotatePass,LoopSimplifyCFGPass,LoopSimplifyPass,LoopUnrollPass,SLPVectorizerPass,SROAPass,SimpleLoopUnswitchPass,SimplifyCFGPass,TailCallElimPass