; LLVM IR from alexzheng42/sDMD :: analysis (HBRamach)

; 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.HBType = type { i32, i32, i32, i32, i32, i32, i32 }
%struct.PepStr = type { i32, i32, i32, i32, double }
%struct.FileStr = type { i32, [256 x i8] }
%struct.FileListStr = type { i32, [128 x [64 x i8]] }
%struct.SectionStr = type { i64, double, double, double, double, [20 x i8], %struct.WallStr, %struct.DynamicWallStr, %struct.ObstructionStr, %struct.TunnelStr, %struct.FlowStr }
%struct.WallStr = type { [20 x i8], [20 x i8], %struct.AtomStr }
%struct.AtomStr = type { ptr, ptr }
%struct.DynamicWallStr = type { [16 x i8], i32, i32, double, double, double, double, [4 x double] }
%struct.ObstructionStr = type { i32, i32, ptr, ptr, ptr }
%struct.TunnelStr = type { i32, double, double, double, %struct.AtomStr }
%struct.FlowStr = type { i32, %struct.ConstVStr, %struct.ForceStr, %struct.ChargeStr }
%struct.ConstVStr = type { [4 x double] }
%struct.ForceStr = type { [4 x double], ptr, ptr }
%struct.ChargeStr = type { i32, i32, ptr, ptr, 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 }

@AAName = external dso_local global [21 x [4 x i8]], align 16
@numofprotein = external global i32, align 4
@atomnum = external global i32, align 4
@nPP = external global i32, align 4
@protein = external global ptr, align 8
@.str = external hidden unnamed_addr constant [29 x i8], align 1
@stdout = external global ptr, align 8
@.str.1 = external hidden unnamed_addr constant [5 x i8], align 1
@path = external global [1024 x i8], align 16
@files = external global ptr, align 8
@.str.2 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [26 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [10 x i8], align 1
@analysisList = external global ptr, align 8
@.str.17 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [49 x i8], align 1
@.str.20 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.21 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [29 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [23 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.28 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.29 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.30 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.31 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.32 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.33 = external hidden unnamed_addr constant [116 x i8], align 1
@.str.34 = external hidden unnamed_addr constant [70 x i8], align 1
@.str.35 = external hidden unnamed_addr constant [79 x i8], align 1
@fileList = external global ptr, align 8
@.str.36 = external hidden unnamed_addr constant [88 x i8], align 1
@sectInfo = external global ptr, align 8
@step = external hidden global i64, align 8
@.str.37 = external hidden unnamed_addr constant [13 x i8], align 1
@atom = external global ptr, align 8
@.str.38 = external hidden unnamed_addr constant [18 x i8], align 1
@HBSum = external dso_local global %struct.HBType, align 4
@.str.39 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.40 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.41 = external hidden unnamed_addr constant [13 x i8], align 1
@.str.42 = external hidden unnamed_addr constant [8 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @HBInfo(i32 noundef %0) #0 {
  %2 = alloca i32, align 4
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  %5 = alloca i32, align 4
  %6 = alloca i32, align 4
  %7 = alloca i32, align 4
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca ptr, align 8
  %11 = alloca i64, align 8
  %12 = alloca double, align 8
  %13 = alloca double, align 8
  %14 = alloca double, align 8
  %15 = alloca double, align 8
  %16 = alloca [1024 x i8], align 16
  %17 = alloca [1024 x i8], align 16
  %18 = alloca ptr, align 8
  %19 = alloca ptr, align 8
  %20 = alloca ptr, align 8
  %21 = alloca ptr, align 8
  %22 = alloca ptr, align 8
  %23 = alloca ptr, align 8
  %24 = alloca ptr, align 8
  %25 = alloca ptr, align 8
  %26 = alloca i32, align 4
  %27 = alloca i32, align 4
  %28 = alloca i32, align 4
  %29 = alloca i32, align 4
  %30 = alloca i32, align 4
  %31 = alloca i32, align 4
  %32 = alloca i32, align 4
  %33 = alloca i32, align 4
  %34 = alloca i32, align 4
  %35 = alloca i32, align 4
  %36 = alloca i32, align 4
  %37 = alloca i32, align 4
  %38 = alloca i32, align 4
  %39 = alloca i32, align 4
  %40 = alloca i32, align 4
  store i32 %0, ptr %2, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %3) #7
  store i32 0, ptr %3, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %4) #7
  store i32 0, ptr %4, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %5) #7
  store i32 0, ptr %5, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #7
  store i32 1, ptr %6, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #7
  %41 = load i32, ptr @numofprotein, align 4, !tbaa !5
  store i32 %41, ptr %7, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #7
  %42 = load i32, ptr @atomnum, align 4, !tbaa !5
  store i32 %42, ptr %8, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #7
  store i32 0, ptr %9, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %10) #7
  store ptr null, ptr %10, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %12) #7
  store double 0.000000e+00, ptr %12, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %13) #7
  store double 0.000000e+00, ptr %13, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %14) #7
  store double 0.000000e+00, ptr %14, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #7
  store double 0.000000e+00, ptr %15, align 8, !tbaa !11
  call void @llvm.lifetime.start.p0(i64 1024, ptr %16) #7
  call void @llvm.lifetime.start.p0(i64 1024, ptr %17) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %18) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %19) #7
  store ptr null, ptr %19, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %20) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #7
  store ptr null, ptr %21, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #7
  store ptr null, ptr %22, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %23) #7
  store ptr null, ptr %23, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %24) #7
  call void @llvm.lifetime.start.p0(i64 8, ptr %25) #7
  %43 = load i32, ptr @nPP, align 4, !tbaa !5
  %44 = icmp ne i32 %43, 0
  br i1 %44, label %45, label %68

45:                                               ; preds = %1
  %46 = load i32, ptr @nPP, align 4, !tbaa !5
  store i32 %46, ptr %7, align 4, !tbaa !5
  store i32 %46, ptr %6, align 4, !tbaa !5
  %47 = load ptr, ptr @protein, align 8, !tbaa !9
  %48 = load i32, ptr @nPP, align 4, !tbaa !5
  %49 = sext i32 %48 to i64
  %50 = getelementptr inbounds %struct.PepStr, ptr %47, i64 %49
  %51 = getelementptr inbounds %struct.PepStr, ptr %50, i32 0, i32 1
  %52 = load i32, ptr %51, align 4, !tbaa !13
  %53 = load ptr, ptr @protein, align 8, !tbaa !9
  %54 = load i32, ptr @nPP, align 4, !tbaa !5
  %55 = sext i32 %54 to i64
  %56 = getelementptr inbounds %struct.PepStr, ptr %53, i64 %55
  %57 = getelementptr inbounds %struct.PepStr, ptr %56, i32 0, i32 0
  %58 = load i32, ptr %57, align 8, !tbaa !15
  %59 = sub nsw i32 %52, %58
  %60 = add nsw i32 %59, 1
  store i32 %60, ptr %8, align 4, !tbaa !5
  %61 = load ptr, ptr @protein, align 8, !tbaa !9
  %62 = load i32, ptr @nPP, align 4, !tbaa !5
  %63 = sext i32 %62 to i64
  %64 = getelementptr inbounds %struct.PepStr, ptr %61, i64 %63
  %65 = getelementptr inbounds %struct.PepStr, ptr %64, i32 0, i32 0
  %66 = load i32, ptr %65, align 8, !tbaa !15
  %67 = sub nsw i32 %66, 1
  store i32 %67, ptr %9, align 4, !tbaa !5
  br label %68

68:                                               ; preds = %45, %1
  %69 = call i32 (ptr, ...) @printf(ptr noundef @.str)
  %70 = load ptr, ptr @stdout, align 8, !tbaa !9
  %71 = call i32 @fflush(ptr noundef %70)
  %72 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %73 = load ptr, ptr @files, align 8, !tbaa !9
  %74 = getelementptr inbounds ptr, ptr %73, i64 10
  %75 = load ptr, ptr %74, align 8, !tbaa !9
  %76 = load i32, ptr %2, align 4, !tbaa !5
  %77 = sext i32 %76 to i64
  %78 = getelementptr inbounds %struct.FileStr, ptr %75, i64 %77
  %79 = getelementptr inbounds %struct.FileStr, ptr %78, i32 0, i32 1
  %80 = getelementptr inbounds [256 x i8], ptr %79, i64 0, i64 0
  %81 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %72, ptr noundef @.str.1, ptr noundef @path, ptr noundef %80) #7
  %82 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %83 = call noalias ptr @fopen(ptr noundef %82, ptr noundef @.str.2)
  store ptr %83, ptr %20, align 8, !tbaa !9
  %84 = load ptr, ptr %20, align 8, !tbaa !9
  %85 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %84, ptr noundef @.str.3, ptr noundef @.str.4, ptr noundef @.str.5, ptr noundef @.str.6, ptr noundef @.str.7, ptr noundef @.str.8, ptr noundef @.str.9, ptr noundef @.str.10, ptr noundef @.str.11) #7
  %86 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %87 = icmp eq i32 %86, 1
  br i1 %87, label %88, label %154

88:                                               ; preds = %68
  %89 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %90 = load ptr, ptr @files, align 8, !tbaa !9
  %91 = getelementptr inbounds ptr, ptr %90, i64 11
  %92 = load ptr, ptr %91, align 8, !tbaa !9
  %93 = load i32, ptr %2, align 4, !tbaa !5
  %94 = sext i32 %93 to i64
  %95 = getelementptr inbounds %struct.FileStr, ptr %92, i64 %94
  %96 = getelementptr inbounds %struct.FileStr, ptr %95, i32 0, i32 1
  %97 = getelementptr inbounds [256 x i8], ptr %96, i64 0, i64 0
  %98 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %89, ptr noundef @.str.1, ptr noundef @path, ptr noundef %97) #7
  %99 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %100 = call noalias ptr @fopen(ptr noundef %99, ptr noundef @.str.2)
  store ptr %100, ptr %21, align 8, !tbaa !9
  %101 = load ptr, ptr %21, align 8, !tbaa !9
  %102 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %101, ptr noundef @.str.12) #7
  %103 = load ptr, ptr %21, align 8, !tbaa !9
  %104 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %103, ptr noundef @.str.13) #7
  %105 = load ptr, ptr %21, align 8, !tbaa !9
  %106 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %105, ptr noundef @.str.14) #7
  %107 = load ptr, ptr %21, align 8, !tbaa !9
  %108 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %107, ptr noundef @.str.15) #7
  %109 = load ptr, ptr %21, align 8, !tbaa !9
  %110 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %109, ptr noundef @.str.16) #7
  call void @llvm.lifetime.start.p0(i64 4, ptr %26) #7
  %111 = load ptr, ptr @protein, align 8, !tbaa !9
  %112 = getelementptr inbounds %struct.PepStr, ptr %111, i64 1
  %113 = getelementptr inbounds %struct.PepStr, ptr %112, i32 0, i32 3
  %114 = load i32, ptr %113, align 4, !tbaa !16
  %115 = load ptr, ptr @protein, align 8, !tbaa !9
  %116 = getelementptr inbounds %struct.PepStr, ptr %115, i64 1
  %117 = getelementptr inbounds %struct.PepStr, ptr %116, i32 0, i32 2
  %118 = load i32, ptr %117, align 8, !tbaa !17
  %119 = sub nsw i32 %114, %118
  %120 = add nsw i32 %119, 1
  store i32 %120, ptr %26, align 4, !tbaa !5
  %121 = load i32, ptr %26, align 4, !tbaa !5
  %122 = add nsw i32 %121, 1
  %123 = sext i32 %122 to i64
  %124 = call noalias ptr @calloc(i64 noundef %123, i64 noundef 8) #8
  store ptr %124, ptr %10, align 8, !tbaa !9
  %125 = load i32, ptr %26, align 4, !tbaa !5
  %126 = add nsw i32 %125, 1
  %127 = mul nsw i32 %126, 2
  %128 = sext i32 %127 to i64
  %129 = call noalias ptr @calloc(i64 noundef %128, i64 noundef 8) #8
  %130 = load ptr, ptr %10, align 8, !tbaa !9
  %131 = getelementptr inbounds ptr, ptr %130, i64 0
  store ptr %129, ptr %131, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #7
  store i32 1, ptr %27, align 4, !tbaa !5
  br label %132

132:                                              ; preds = %150, %88
  %133 = load i32, ptr %27, align 4, !tbaa !5
  %134 = load i32, ptr %26, align 4, !tbaa !5
  %135 = add nsw i32 %134, 1
  %136 = icmp slt i32 %133, %135
  br i1 %136, label %138, label %137

137:                                              ; preds = %132
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #7
  br label %153

138:                                              ; preds = %132
  %139 = load ptr, ptr %10, align 8, !tbaa !9
  %140 = getelementptr inbounds ptr, ptr %139, i64 0
  %141 = load ptr, ptr %140, align 8, !tbaa !9
  %142 = load i32, ptr %27, align 4, !tbaa !5
  %143 = mul nsw i32 %142, 2
  %144 = sext i32 %143 to i64
  %145 = getelementptr inbounds i64, ptr %141, i64 %144
  %146 = load ptr, ptr %10, align 8, !tbaa !9
  %147 = load i32, ptr %27, align 4, !tbaa !5
  %148 = sext i32 %147 to i64
  %149 = getelementptr inbounds ptr, ptr %146, i64 %148
  store ptr %145, ptr %149, align 8, !tbaa !9
  br label %150

150:                                              ; preds = %138
  %151 = load i32, ptr %27, align 4, !tbaa !5
  %152 = add nsw i32 %151, 1
  store i32 %152, ptr %27, align 4, !tbaa !5
  br label %132, !llvm.loop !18

153:                                              ; preds = %137
  call void @llvm.lifetime.end.p0(i64 4, ptr %26) #7
  br label %154

154:                                              ; preds = %153, %68
  %155 = load ptr, ptr @analysisList, align 8, !tbaa !9
  %156 = getelementptr inbounds i32, ptr %155, i64 5
  %157 = load i32, ptr %156, align 4, !tbaa !5
  %158 = icmp ne i32 %157, 0
  br i1 %158, label %159, label %327

159:                                              ; preds = %154
  %160 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %161 = sext i32 %160 to i64
  %162 = call noalias ptr @calloc(i64 noundef %161, i64 noundef 8) #8
  store ptr %162, ptr %19, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #7
  store i32 0, ptr %28, align 4, !tbaa !5
  br label %163

163:                                              ; preds = %174, %159
  %164 = load i32, ptr %28, align 4, !tbaa !5
  %165 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %166 = icmp slt i32 %164, %165
  br i1 %166, label %168, label %167

167:                                              ; preds = %163
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #7
  br label %177

168:                                              ; preds = %163
  %169 = call noalias ptr @calloc(i64 noundef 21, i64 noundef 8) #8
  %170 = load ptr, ptr %19, align 8, !tbaa !9
  %171 = load i32, ptr %28, align 4, !tbaa !5
  %172 = sext i32 %171 to i64
  %173 = getelementptr inbounds ptr, ptr %170, i64 %172
  store ptr %169, ptr %173, align 8, !tbaa !9
  br label %174

174:                                              ; preds = %168
  %175 = load i32, ptr %28, align 4, !tbaa !5
  %176 = add nsw i32 %175, 1
  store i32 %176, ptr %28, align 4, !tbaa !5
  br label %163, !llvm.loop !20

177:                                              ; preds = %167
  call void @llvm.lifetime.start.p0(i64 4, ptr %29) #7
  %178 = load i32, ptr %6, align 4, !tbaa !5
  %179 = sub nsw i32 %178, 1
  store i32 %179, ptr %29, align 4, !tbaa !5
  br label %180

180:                                              ; preds = %323, %177
  %181 = load i32, ptr %29, align 4, !tbaa !5
  %182 = load i32, ptr %7, align 4, !tbaa !5
  %183 = icmp slt i32 %181, %182
  br i1 %183, label %185, label %184

184:                                              ; preds = %180
  store i32 8, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %29) #7
  br label %326

185:                                              ; preds = %180
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #7
  store i32 0, ptr %31, align 4, !tbaa !5
  br label %186

186:                                              ; preds = %319, %185
  %187 = load i32, ptr %31, align 4, !tbaa !5
  %188 = icmp slt i32 %187, 21
  br i1 %188, label %190, label %189

189:                                              ; preds = %186
  store i32 11, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #7
  br label %322

190:                                              ; preds = %186
  %191 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %192 = load i32, ptr %29, align 4, !tbaa !5
  %193 = add nsw i32 %192, 1
  %194 = load i32, ptr %31, align 4, !tbaa !5
  %195 = sext i32 %194 to i64
  %196 = getelementptr inbounds [21 x [4 x i8]], ptr @AAName, i64 0, i64 %195
  %197 = getelementptr inbounds [4 x i8], ptr %196, i64 0, i64 0
  %198 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %191, ptr noundef @.str.17, ptr noundef @path, i32 noundef %193, ptr noundef %197) #7
  %199 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %200 = call noalias ptr @fopen(ptr noundef %199, ptr noundef @.str.2)
  %201 = load ptr, ptr %19, align 8, !tbaa !9
  %202 = load i32, ptr %29, align 4, !tbaa !5
  %203 = sext i32 %202 to i64
  %204 = getelementptr inbounds ptr, ptr %201, i64 %203
  %205 = load ptr, ptr %204, align 8, !tbaa !9
  %206 = load i32, ptr %31, align 4, !tbaa !5
  %207 = sext i32 %206 to i64
  %208 = getelementptr inbounds ptr, ptr %205, i64 %207
  store ptr %200, ptr %208, align 8, !tbaa !9
  %209 = load ptr, ptr %19, align 8, !tbaa !9
  %210 = load i32, ptr %29, align 4, !tbaa !5
  %211 = sext i32 %210 to i64
  %212 = getelementptr inbounds ptr, ptr %209, i64 %211
  %213 = load ptr, ptr %212, align 8, !tbaa !9
  %214 = load i32, ptr %31, align 4, !tbaa !5
  %215 = sext i32 %214 to i64
  %216 = getelementptr inbounds ptr, ptr %213, i64 %215
  %217 = load ptr, ptr %216, align 8, !tbaa !9
  %218 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %217, ptr noundef @.str.18, ptr noundef @.str.19) #7
  %219 = load ptr, ptr %19, align 8, !tbaa !9
  %220 = load i32, ptr %29, align 4, !tbaa !5
  %221 = sext i32 %220 to i64
  %222 = getelementptr inbounds ptr, ptr %219, i64 %221
  %223 = load ptr, ptr %222, align 8, !tbaa !9
  %224 = load i32, ptr %31, align 4, !tbaa !5
  %225 = sext i32 %224 to i64
  %226 = getelementptr inbounds ptr, ptr %223, i64 %225
  %227 = load ptr, ptr %226, align 8, !tbaa !9
  %228 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %227, ptr noundef @.str.18, ptr noundef @.str.20) #7
  %229 = load ptr, ptr %19, align 8, !tbaa !9
  %230 = load i32, ptr %29, align 4, !tbaa !5
  %231 = sext i32 %230 to i64
  %232 = getelementptr inbounds ptr, ptr %229, i64 %231
  %233 = load ptr, ptr %232, align 8, !tbaa !9
  %234 = load i32, ptr %31, align 4, !tbaa !5
  %235 = sext i32 %234 to i64
  %236 = getelementptr inbounds ptr, ptr %233, i64 %235
  %237 = load ptr, ptr %236, align 8, !tbaa !9
  %238 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %237, ptr noundef @.str.18, ptr noundef @.str.21) #7
  %239 = load ptr, ptr %19, align 8, !tbaa !9
  %240 = load i32, ptr %29, align 4, !tbaa !5
  %241 = sext i32 %240 to i64
  %242 = getelementptr inbounds ptr, ptr %239, i64 %241
  %243 = load ptr, ptr %242, align 8, !tbaa !9
  %244 = load i32, ptr %31, align 4, !tbaa !5
  %245 = sext i32 %244 to i64
  %246 = getelementptr inbounds ptr, ptr %243, i64 %245
  %247 = load ptr, ptr %246, align 8, !tbaa !9
  %248 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %247, ptr noundef @.str.18, ptr noundef @.str.22) #7
  %249 = load ptr, ptr %19, align 8, !tbaa !9
  %250 = load i32, ptr %29, align 4, !tbaa !5
  %251 = sext i32 %250 to i64
  %252 = getelementptr inbounds ptr, ptr %249, i64 %251
  %253 = load ptr, ptr %252, align 8, !tbaa !9
  %254 = load i32, ptr %31, align 4, !tbaa !5
  %255 = sext i32 %254 to i64
  %256 = getelementptr inbounds ptr, ptr %253, i64 %255
  %257 = load ptr, ptr %256, align 8, !tbaa !9
  %258 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %257, ptr noundef @.str.18, ptr noundef @.str.23) #7
  %259 = load ptr, ptr %19, align 8, !tbaa !9
  %260 = load i32, ptr %29, align 4, !tbaa !5
  %261 = sext i32 %260 to i64
  %262 = getelementptr inbounds ptr, ptr %259, i64 %261
  %263 = load ptr, ptr %262, align 8, !tbaa !9
  %264 = load i32, ptr %31, align 4, !tbaa !5
  %265 = sext i32 %264 to i64
  %266 = getelementptr inbounds ptr, ptr %263, i64 %265
  %267 = load ptr, ptr %266, align 8, !tbaa !9
  %268 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %267, ptr noundef @.str.18, ptr noundef @.str.24) #7
  %269 = load ptr, ptr %19, align 8, !tbaa !9
  %270 = load i32, ptr %29, align 4, !tbaa !5
  %271 = sext i32 %270 to i64
  %272 = getelementptr inbounds ptr, ptr %269, i64 %271
  %273 = load ptr, ptr %272, align 8, !tbaa !9
  %274 = load i32, ptr %31, align 4, !tbaa !5
  %275 = sext i32 %274 to i64
  %276 = getelementptr inbounds ptr, ptr %273, i64 %275
  %277 = load ptr, ptr %276, align 8, !tbaa !9
  %278 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %277, ptr noundef @.str.18, ptr noundef @.str.25) #7
  %279 = load ptr, ptr %19, align 8, !tbaa !9
  %280 = load i32, ptr %29, align 4, !tbaa !5
  %281 = sext i32 %280 to i64
  %282 = getelementptr inbounds ptr, ptr %279, i64 %281
  %283 = load ptr, ptr %282, align 8, !tbaa !9
  %284 = load i32, ptr %31, align 4, !tbaa !5
  %285 = sext i32 %284 to i64
  %286 = getelementptr inbounds ptr, ptr %283, i64 %285
  %287 = load ptr, ptr %286, align 8, !tbaa !9
  %288 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %287, ptr noundef @.str.18, ptr noundef @.str.26) #7
  %289 = load ptr, ptr %19, align 8, !tbaa !9
  %290 = load i32, ptr %29, align 4, !tbaa !5
  %291 = sext i32 %290 to i64
  %292 = getelementptr inbounds ptr, ptr %289, i64 %291
  %293 = load ptr, ptr %292, align 8, !tbaa !9
  %294 = load i32, ptr %31, align 4, !tbaa !5
  %295 = sext i32 %294 to i64
  %296 = getelementptr inbounds ptr, ptr %293, i64 %295
  %297 = load ptr, ptr %296, align 8, !tbaa !9
  %298 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %297, ptr noundef @.str.18, ptr noundef @.str.27) #7
  %299 = load ptr, ptr %19, align 8, !tbaa !9
  %300 = load i32, ptr %29, align 4, !tbaa !5
  %301 = sext i32 %300 to i64
  %302 = getelementptr inbounds ptr, ptr %299, i64 %301
  %303 = load ptr, ptr %302, align 8, !tbaa !9
  %304 = load i32, ptr %31, align 4, !tbaa !5
  %305 = sext i32 %304 to i64
  %306 = getelementptr inbounds ptr, ptr %303, i64 %305
  %307 = load ptr, ptr %306, align 8, !tbaa !9
  %308 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %307, ptr noundef @.str.18, ptr noundef @.str.28) #7
  %309 = load ptr, ptr %19, align 8, !tbaa !9
  %310 = load i32, ptr %29, align 4, !tbaa !5
  %311 = sext i32 %310 to i64
  %312 = getelementptr inbounds ptr, ptr %309, i64 %311
  %313 = load ptr, ptr %312, align 8, !tbaa !9
  %314 = load i32, ptr %31, align 4, !tbaa !5
  %315 = sext i32 %314 to i64
  %316 = getelementptr inbounds ptr, ptr %313, i64 %315
  %317 = load ptr, ptr %316, align 8, !tbaa !9
  %318 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %317, ptr noundef @.str.18, ptr noundef @.str.29) #7
  br label %319

319:                                              ; preds = %190
  %320 = load i32, ptr %31, align 4, !tbaa !5
  %321 = add nsw i32 %320, 1
  store i32 %321, ptr %31, align 4, !tbaa !5
  br label %186, !llvm.loop !21

322:                                              ; preds = %189
  br label %323

323:                                              ; preds = %322
  %324 = load i32, ptr %29, align 4, !tbaa !5
  %325 = add nsw i32 %324, 1
  store i32 %325, ptr %29, align 4, !tbaa !5
  br label %180, !llvm.loop !22

326:                                              ; preds = %184
  br label %327

327:                                              ; preds = %326, %154
  %328 = load ptr, ptr @analysisList, align 8, !tbaa !9
  %329 = getelementptr inbounds i32, ptr %328, i64 6
  %330 = load i32, ptr %329, align 4, !tbaa !5
  %331 = icmp ne i32 %330, 0
  br i1 %331, label %332, label %371

332:                                              ; preds = %327
  %333 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %334 = sext i32 %333 to i64
  %335 = call noalias ptr @calloc(i64 noundef %334, i64 noundef 8) #8
  store ptr %335, ptr %22, align 8, !tbaa !9
  %336 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %337 = sext i32 %336 to i64
  %338 = call noalias ptr @calloc(i64 noundef %337, i64 noundef 8) #8
  store ptr %338, ptr %23, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #7
  %339 = load i32, ptr %6, align 4, !tbaa !5
  %340 = sub nsw i32 %339, 1
  store i32 %340, ptr %32, align 4, !tbaa !5
  br label %341

341:                                              ; preds = %367, %332
  %342 = load i32, ptr %32, align 4, !tbaa !5
  %343 = load i32, ptr %7, align 4, !tbaa !5
  %344 = icmp slt i32 %342, %343
  br i1 %344, label %346, label %345

345:                                              ; preds = %341
  store i32 14, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #7
  br label %370

346:                                              ; preds = %341
  %347 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %348 = load i32, ptr %32, align 4, !tbaa !5
  %349 = add nsw i32 %348, 1
  %350 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %347, ptr noundef @.str.30, ptr noundef @path, i32 noundef %349) #7
  %351 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %352 = call noalias ptr @fopen(ptr noundef %351, ptr noundef @.str.2)
  %353 = load ptr, ptr %22, align 8, !tbaa !9
  %354 = load i32, ptr %32, align 4, !tbaa !5
  %355 = sext i32 %354 to i64
  %356 = getelementptr inbounds ptr, ptr %353, i64 %355
  store ptr %352, ptr %356, align 8, !tbaa !9
  %357 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %358 = load i32, ptr %32, align 4, !tbaa !5
  %359 = add nsw i32 %358, 1
  %360 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %357, ptr noundef @.str.31, ptr noundef @path, i32 noundef %359) #7
  %361 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %362 = call noalias ptr @fopen(ptr noundef %361, ptr noundef @.str.2)
  %363 = load ptr, ptr %23, align 8, !tbaa !9
  %364 = load i32, ptr %32, align 4, !tbaa !5
  %365 = sext i32 %364 to i64
  %366 = getelementptr inbounds ptr, ptr %363, i64 %365
  store ptr %362, ptr %366, align 8, !tbaa !9
  br label %367

367:                                              ; preds = %346
  %368 = load i32, ptr %32, align 4, !tbaa !5
  %369 = add nsw i32 %368, 1
  store i32 %369, ptr %32, align 4, !tbaa !5
  br label %341, !llvm.loop !23

370:                                              ; preds = %345
  br label %371

371:                                              ; preds = %370, %327
  %372 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %373 = load ptr, ptr @files, align 8, !tbaa !9
  %374 = getelementptr inbounds ptr, ptr %373, i64 8
  %375 = load ptr, ptr %374, align 8, !tbaa !9
  %376 = load i32, ptr %2, align 4, !tbaa !5
  %377 = sext i32 %376 to i64
  %378 = getelementptr inbounds %struct.FileStr, ptr %375, i64 %377
  %379 = getelementptr inbounds %struct.FileStr, ptr %378, i32 0, i32 1
  %380 = getelementptr inbounds [256 x i8], ptr %379, i64 0, i64 0
  %381 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %372, ptr noundef @.str.1, ptr noundef @path, ptr noundef %380) #7
  %382 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %383 = call noalias ptr @fopen(ptr noundef %382, ptr noundef @.str.32)
  store ptr %383, ptr %24, align 8, !tbaa !9
  %384 = load ptr, ptr %24, align 8, !tbaa !9
  %385 = icmp eq ptr %384, null
  br i1 %385, label %386, label %397

386:                                              ; preds = %371
  %387 = load ptr, ptr @files, align 8, !tbaa !9
  %388 = getelementptr inbounds ptr, ptr %387, i64 8
  %389 = load ptr, ptr %388, align 8, !tbaa !9
  %390 = load i32, ptr %2, align 4, !tbaa !5
  %391 = sext i32 %390 to i64
  %392 = getelementptr inbounds %struct.FileStr, ptr %389, i64 %391
  %393 = getelementptr inbounds %struct.FileStr, ptr %392, i32 0, i32 1
  %394 = getelementptr inbounds [256 x i8], ptr %393, i64 0, i64 0
  %395 = call i32 (ptr, ...) @printf(ptr noundef @.str.33, ptr noundef %394, ptr noundef @path, ptr noundef @.str.34, i32 noundef 115)
  %396 = call i32 (ptr, ...) @printf(ptr noundef @.str.35)
  call void @exit(i32 noundef 1) #9
  unreachable

397:                                              ; preds = %371
  call void @llvm.lifetime.start.p0(i64 4, ptr %33) #7
  store i32 0, ptr %33, align 4, !tbaa !5
  br label %398

398:                                              ; preds = %864, %397
  %399 = load i32, ptr %33, align 4, !tbaa !5
  %400 = load ptr, ptr @fileList, align 8, !tbaa !9
  %401 = load i32, ptr %2, align 4, !tbaa !5
  %402 = sext i32 %401 to i64
  %403 = getelementptr inbounds %struct.FileListStr, ptr %400, i64 %402
  %404 = getelementptr inbounds %struct.FileListStr, ptr %403, i32 0, i32 0
  %405 = load i32, ptr %404, align 4, !tbaa !24
  %406 = icmp slt i32 %399, %405
  br i1 %406, label %408, label %407

407:                                              ; preds = %398
  store i32 17, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %33) #7
  br label %867

408:                                              ; preds = %398
  %409 = getelementptr inbounds [1024 x i8], ptr %17, i64 0, i64 0
  call void @llvm.memset.p0.i64(ptr align 16 %409, i8 0, i64 1024, i1 false)
  %410 = load ptr, ptr @files, align 8, !tbaa !9
  %411 = getelementptr inbounds ptr, ptr %410, i64 5
  %412 = load ptr, ptr %411, align 8, !tbaa !9
  %413 = load i32, ptr %2, align 4, !tbaa !5
  %414 = sext i32 %413 to i64
  %415 = getelementptr inbounds %struct.FileStr, ptr %412, i64 %414
  %416 = getelementptr inbounds %struct.FileStr, ptr %415, i32 0, i32 1
  %417 = getelementptr inbounds [256 x i8], ptr %416, i64 0, i64 0
  %418 = load ptr, ptr @fileList, align 8, !tbaa !9
  %419 = load i32, ptr %2, align 4, !tbaa !5
  %420 = sext i32 %419 to i64
  %421 = getelementptr inbounds %struct.FileListStr, ptr %418, i64 %420
  %422 = getelementptr inbounds %struct.FileListStr, ptr %421, i32 0, i32 1
  %423 = load i32, ptr %33, align 4, !tbaa !5
  %424 = add nsw i32 %423, 1
  %425 = sext i32 %424 to i64
  %426 = getelementptr inbounds [128 x [64 x i8]], ptr %422, i64 0, i64 %425
  %427 = getelementptr inbounds [64 x i8], ptr %426, i64 0, i64 0
  %428 = getelementptr inbounds [1024 x i8], ptr %17, i64 0, i64 0
  call void @FindTargetFile(ptr noundef %417, ptr noundef %427, ptr noundef %428)
  %429 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %430 = getelementptr inbounds [1024 x i8], ptr %17, i64 0, i64 0
  %431 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef %429, ptr noundef @.str.1, ptr noundef @path, ptr noundef %430) #7
  %432 = getelementptr inbounds [1024 x i8], ptr %16, i64 0, i64 0
  %433 = call noalias ptr @fopen(ptr noundef %432, ptr noundef @.str.32)
  store ptr %433, ptr %25, align 8, !tbaa !9
  %434 = load ptr, ptr %25, align 8, !tbaa !9
  %435 = icmp eq ptr %434, null
  br i1 %435, label %436, label %447

436:                                              ; preds = %408
  %437 = load ptr, ptr @files, align 8, !tbaa !9
  %438 = getelementptr inbounds ptr, ptr %437, i64 5
  %439 = load ptr, ptr %438, align 8, !tbaa !9
  %440 = load i32, ptr %2, align 4, !tbaa !5
  %441 = sext i32 %440 to i64
  %442 = getelementptr inbounds %struct.FileStr, ptr %439, i64 %441
  %443 = getelementptr inbounds %struct.FileStr, ptr %442, i32 0, i32 1
  %444 = getelementptr inbounds [256 x i8], ptr %443, i64 0, i64 0
  %445 = call i32 (ptr, ...) @printf(ptr noundef @.str.33, ptr noundef %444, ptr noundef @path, ptr noundef @.str.34, i32 noundef 127)
  %446 = call i32 (ptr, ...) @printf(ptr noundef @.str.36)
  call void @exit(i32 noundef 1) #9
  unreachable

447:                                              ; preds = %408
  %448 = load ptr, ptr @sectInfo, align 8, !tbaa !9
  %449 = load i32, ptr %33, align 4, !tbaa !5
  %450 = sext i32 %449 to i64
  %451 = getelementptr inbounds %struct.SectionStr, ptr %448, i64 %450
  %452 = getelementptr inbounds %struct.SectionStr, ptr %451, i32 0, i32 1
  %453 = load double, ptr %452, align 8, !tbaa !26
  %454 = load ptr, ptr @sectInfo, align 8, !tbaa !9
  %455 = load i32, ptr %33, align 4, !tbaa !5
  %456 = sext i32 %455 to i64
  %457 = getelementptr inbounds %struct.SectionStr, ptr %454, i64 %456
  %458 = getelementptr inbounds %struct.SectionStr, ptr %457, i32 0, i32 0
  %459 = load i64, ptr %458, align 8, !tbaa !38
  %460 = sitofp i64 %459 to double
  %461 = fadd double %453, %460
  %462 = load ptr, ptr @sectInfo, align 8, !tbaa !9
  %463 = load i32, ptr %33, align 4, !tbaa !5
  %464 = sext i32 %463 to i64
  %465 = getelementptr inbounds %struct.SectionStr, ptr %462, i64 %464
  %466 = getelementptr inbounds %struct.SectionStr, ptr %465, i32 0, i32 4
  %467 = load double, ptr %466, align 8, !tbaa !39
  %468 = fdiv double %461, %467
  %469 = fadd double %468, 1.000000e+00
  %470 = fptosi double %469 to i64
  store i64 %470, ptr %11, align 8, !tbaa !40
  %471 = load ptr, ptr @sectInfo, align 8, !tbaa !9
  %472 = load i32, ptr %33, align 4, !tbaa !5
  %473 = sext i32 %472 to i64
  %474 = getelementptr inbounds %struct.SectionStr, ptr %471, i64 %473
  %475 = getelementptr inbounds %struct.SectionStr, ptr %474, i32 0, i32 1
  %476 = load double, ptr %475, align 8, !tbaa !26
  %477 = load ptr, ptr @sectInfo, align 8, !tbaa !9
  %478 = load i32, ptr %33, align 4, !tbaa !5
  %479 = sext i32 %478 to i64
  %480 = getelementptr inbounds %struct.SectionStr, ptr %477, i64 %479
  %481 = getelementptr inbounds %struct.SectionStr, ptr %480, i32 0, i32 4
  %482 = load double, ptr %481, align 8, !tbaa !39
  %483 = fdiv double %476, %482
  %484 = fptosi double %483 to i64
  store i64 %484, ptr @step, align 8, !tbaa !40
  br label %485

485:                                              ; preds = %858, %447
  %486 = load i64, ptr @step, align 8, !tbaa !40
  %487 = load i64, ptr %11, align 8, !tbaa !40
  %488 = icmp slt i64 %486, %487
  br i1 %488, label %489, label %861

489:                                              ; preds = %485
  %490 = load ptr, ptr %24, align 8, !tbaa !9
  %491 = call i32 @ReadGro(ptr noundef %490)
  %492 = icmp ne i32 %491, 0
  br i1 %492, label %497, label %493

493:                                              ; preds = %489
  %494 = load ptr, ptr %25, align 8, !tbaa !9
  %495 = call i32 @ReadConnectionMap(ptr noundef %494)
  %496 = icmp ne i32 %495, 0
  br i1 %496, label %497, label %498

497:                                              ; preds = %493, %489
  br label %861

498:                                              ; preds = %493
  %499 = load i64, ptr @step, align 8, !tbaa !40
  call void @PrintProcess(i64 noundef %499)
  %500 = load ptr, ptr @sectInfo, align 8, !tbaa !9
  %501 = load i32, ptr %33, align 4, !tbaa !5
  %502 = sext i32 %501 to i64
  %503 = getelementptr inbounds %struct.SectionStr, ptr %500, i64 %502
  store ptr %503, ptr %18, align 8, !tbaa !9
  call void @ResetHBNum()
  %504 = load ptr, ptr @analysisList, align 8, !tbaa !9
  %505 = getelementptr inbounds i32, ptr %504, i64 6
  %506 = load i32, ptr %505, align 4, !tbaa !5
  %507 = icmp ne i32 %506, 0
  br i1 %507, label %508, label %545

508:                                              ; preds = %498
  call void @llvm.lifetime.start.p0(i64 4, ptr %34) #7
  %509 = load i32, ptr %6, align 4, !tbaa !5
  %510 = sub nsw i32 %509, 1
  store i32 %510, ptr %34, align 4, !tbaa !5
  br label %511

511:                                              ; preds = %541, %508
  %512 = load i32, ptr %34, align 4, !tbaa !5
  %513 = load i32, ptr %7, align 4, !tbaa !5
  %514 = icmp slt i32 %512, %513
  br i1 %514, label %516, label %515

515:                                              ; preds = %511
  store i32 23, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %34) #7
  br label %544

516:                                              ; preds = %511
  %517 = load ptr, ptr %22, align 8, !tbaa !9
  %518 = load i32, ptr %34, align 4, !tbaa !5
  %519 = sext i32 %518 to i64
  %520 = getelementptr inbounds ptr, ptr %517, i64 %519
  %521 = load ptr, ptr %520, align 8, !tbaa !9
  %522 = load i64, ptr @step, align 8, !tbaa !40
  %523 = load ptr, ptr %18, align 8, !tbaa !9
  %524 = getelementptr inbounds %struct.SectionStr, ptr %523, i32 0, i32 4
  %525 = load double, ptr %524, align 8, !tbaa !39
  %526 = fptosi double %525 to i64
  %527 = mul nsw i64 %522, %526
  %528 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %521, ptr noundef @.str.37, i64 noundef %527) #7
  %529 = load ptr, ptr %23, align 8, !tbaa !9
  %530 = load i32, ptr %34, align 4, !tbaa !5
  %531 = sext i32 %530 to i64
  %532 = getelementptr inbounds ptr, ptr %529, i64 %531
  %533 = load ptr, ptr %532, align 8, !tbaa !9
  %534 = load i64, ptr @step, align 8, !tbaa !40
  %535 = load ptr, ptr %18, align 8, !tbaa !9
  %536 = getelementptr inbounds %struct.SectionStr, ptr %535, i32 0, i32 4
  %537 = load double, ptr %536, align 8, !tbaa !39
  %538 = fptosi double %537 to i64
  %539 = mul nsw i64 %534, %538
  %540 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %533, ptr noundef @.str.37, i64 noundef %539) #7
  br label %541

541:                                              ; preds = %516
  %542 = load i32, ptr %34, align 4, !tbaa !5
  %543 = add nsw i32 %542, 1
  store i32 %543, ptr %34, align 4, !tbaa !5
  br label %511, !llvm.loop !41

544:                                              ; preds = %515
  br label %545

545:                                              ; preds = %544, %498
  store i32 0, ptr %5, align 4, !tbaa !5
  store i32 0, ptr %4, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %35) #7
  %546 = load i32, ptr %9, align 4, !tbaa !5
  %547 = add nsw i32 %546, 1
  store i32 %547, ptr %35, align 4, !tbaa !5
  br label %548

548:                                              ; preds = %852, %545
  %549 = load i32, ptr %35, align 4, !tbaa !5
  %550 = load i32, ptr %9, align 4, !tbaa !5
  %551 = load i32, ptr %8, align 4, !tbaa !5
  %552 = add nsw i32 %550, %551
  %553 = icmp sle i32 %549, %552
  br i1 %553, label %555, label %554

554:                                              ; preds = %548
  store i32 26, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %35) #7
  br label %855

555:                                              ; preds = %548
  %556 = load ptr, ptr @atom, align 8, !tbaa !9
  %557 = load i32, ptr %35, align 4, !tbaa !5
  %558 = sext i32 %557 to i64
  %559 = getelementptr inbounds %struct.AtomStr, ptr %556, i64 %558
  %560 = getelementptr inbounds %struct.AtomStr, ptr %559, i32 0, i32 0
  %561 = load ptr, ptr %560, align 8, !tbaa !42
  %562 = getelementptr inbounds %struct.PropertyStr, ptr %561, i32 0, i32 4
  %563 = load i32, ptr %562, align 4, !tbaa !43
  %564 = icmp eq i32 %563, 18
  br i1 %564, label %565, label %608

565:                                              ; preds = %555
  %566 = load i32, ptr %35, align 4, !tbaa !5
  call void @RamachandranPlot(i32 noundef %566, ptr noundef %12, ptr noundef %13)
  %567 = load double, ptr %12, align 8, !tbaa !11
  %568 = fcmp une double %567, 0.000000e+00
  br i1 %568, label %569, label %607

569:                                              ; preds = %565
  %570 = load double, ptr %13, align 8, !tbaa !11
  %571 = fcmp une double %570, 0.000000e+00
  br i1 %571, label %572, label %607

572:                                              ; preds = %569
  %573 = load ptr, ptr @analysisList, align 8, !tbaa !9
  %574 = getelementptr inbounds i32, ptr %573, i64 5
  %575 = load i32, ptr %574, align 4, !tbaa !5
  %576 = icmp ne i32 %575, 0
  br i1 %576, label %577, label %607

577:                                              ; preds = %572
  %578 = load ptr, ptr %19, align 8, !tbaa !9
  %579 = load ptr, ptr @atom, align 8, !tbaa !9
  %580 = load i32, ptr %35, align 4, !tbaa !5
  %581 = sext i32 %580 to i64
  %582 = getelementptr inbounds %struct.AtomStr, ptr %579, i64 %581
  %583 = getelementptr inbounds %struct.AtomStr, ptr %582, i32 0, i32 0
  %584 = load ptr, ptr %583, align 8, !tbaa !42
  %585 = getelementptr inbounds %struct.PropertyStr, ptr %584, i32 0, i32 9
  %586 = getelementptr inbounds %struct.AtomSeqStr, ptr %585, i32 0, i32 1
  %587 = load i32, ptr %586, align 4, !tbaa !46
  %588 = sub nsw i32 %587, 1
  %589 = sext i32 %588 to i64
  %590 = getelementptr inbounds ptr, ptr %578, i64 %589
  %591 = load ptr, ptr %590, align 8, !tbaa !9
  %592 = load ptr, ptr @atom, align 8, !tbaa !9
  %593 = load i32, ptr %35, align 4, !tbaa !5
  %594 = sext i32 %593 to i64
  %595 = getelementptr inbounds %struct.AtomStr, ptr %592, i64 %594
  %596 = getelementptr inbounds %struct.AtomStr, ptr %595, i32 0, i32 0
  %597 = load ptr, ptr %596, align 8, !tbaa !42
  %598 = getelementptr inbounds %struct.PropertyStr, ptr %597, i32 0, i32 2
  %599 = getelementptr inbounds [8 x i8], ptr %598, i64 0, i64 0
  %600 = call i32 @FindAANum(ptr noundef %599)
  %601 = sext i32 %600 to i64
  %602 = getelementptr inbounds ptr, ptr %591, i64 %601
  %603 = load ptr, ptr %602, align 8, !tbaa !9
  %604 = load double, ptr %12, align 8, !tbaa !11
  %605 = load double, ptr %13, align 8, !tbaa !11
  %606 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %603, ptr noundef @.str.38, double noundef %604, double noundef %605) #7
  br label %607

607:                                              ; preds = %577, %572, %569, %565
  br label %608

608:                                              ; preds = %607, %555
  %609 = load i32, ptr %35, align 4, !tbaa !5
  %610 = call i32 @CheckHBConnection(i32 noundef %609)
  store i32 %610, ptr %3, align 4, !tbaa !5
  %611 = load i32, ptr %3, align 4, !tbaa !5
  %612 = icmp sgt i32 %611, 0
  br i1 %612, label %613, label %759

613:                                              ; preds = %608
  %614 = load i32, ptr %3, align 4, !tbaa !5
  %615 = load i32, ptr %35, align 4, !tbaa !5
  %616 = icmp sgt i32 %614, %615
  br i1 %616, label %617, label %643

617:                                              ; preds = %613
  %618 = load i32, ptr getelementptr inbounds (%struct.HBType, ptr @HBSum, i32 0, i32 6), align 4, !tbaa !47
  %619 = add nsw i32 %618, 1
  store i32 %619, ptr getelementptr inbounds (%struct.HBType, ptr @HBSum, i32 0, i32 6), align 4, !tbaa !47
  %620 = load ptr, ptr @atom, align 8, !tbaa !9
  %621 = load i32, ptr %35, align 4, !tbaa !5
  %622 = sext i32 %621 to i64
  %623 = getelementptr inbounds %struct.AtomStr, ptr %620, i64 %622
  %624 = getelementptr inbounds %struct.AtomStr, ptr %623, i32 0, i32 0
  %625 = load ptr, ptr %624, align 8, !tbaa !42
  %626 = getelementptr inbounds %struct.PropertyStr, ptr %625, i32 0, i32 4
  %627 = load i32, ptr %626, align 4, !tbaa !43
  %628 = icmp eq i32 %627, 31
  br i1 %628, label %629, label %642

629:                                              ; preds = %617
  %630 = load ptr, ptr @atom, align 8, !tbaa !9
  %631 = load i32, ptr %3, align 4, !tbaa !5
  %632 = sext i32 %631 to i64
  %633 = getelementptr inbounds %struct.AtomStr, ptr %630, i64 %632
  %634 = getelementptr inbounds %struct.AtomStr, ptr %633, i32 0, i32 0
  %635 = load ptr, ptr %634, align 8, !tbaa !42
  %636 = getelementptr inbounds %struct.PropertyStr, ptr %635, i32 0, i32 4
  %637 = load i32, ptr %636, align 4, !tbaa !43
  %638 = icmp eq i32 %637, 31
  br i1 %638, label %639, label %642

639:                                              ; preds = %629
  %640 = load i32, ptr getelementptr inbounds (%struct.HBType, ptr @HBSum, i32 0, i32 4), align 4, !tbaa !49
  %641 = add nsw i32 %640, 1
  store i32 %641, ptr getelementptr inbounds (%struct.HBType, ptr @HBSum, i32 0, i32 4), align 4, !tbaa !49
  br label %642

642:                                              ; preds = %639, %629, %617
  br label %643

643:                                              ; preds = %642, %613
  %644 = load ptr, ptr @atom, align 8, !tbaa !9
  %645 = load i32, ptr %35, align 4, !tbaa !5
  %646 = sext i32 %645 to i64
  %647 = getelementptr inbounds %struct.AtomStr, ptr %644, i64 %646
  %648 = getelementptr inbounds %struct.AtomStr, ptr %647, i32 0, i32 0
  %649 = load ptr, ptr %648, align 8, !tbaa !42
  %650 = getelementptr inbounds %struct.PropertyStr, ptr %649, i32 0, i32 4
  %651 = load i32, ptr %650, align 4, !tbaa !43
  %652 = icmp eq i32 %651, 2
  br i1 %652, label %663, label %653

653:                                              ; preds = %643
  %654 = load ptr, ptr @atom, align 8, !tbaa !9
  %655 = load i32, ptr %35, align 4, !tbaa !5
  %656 = sext i32 %655 to i64
  %657 = getelementptr inbounds %struct.AtomStr, ptr %654, i64 %656
  %658 = getelementptr inbounds %struct.AtomStr, ptr %657, i32 0, i32 0
  %659 = load ptr, ptr %658, align 8, !tbaa !42
  %660 = getelementptr inbounds %struct.PropertyStr, ptr %659, i32 0, i32 4
  %661 = load i32, ptr %660, align 4, !tbaa !43
  %662 = icmp eq i32 %661, 4
  br i1 %662, label %663, label %758

663:                                              ; preds = %653, %643
  %664 = load i32, ptr %35, align 4, !tbaa !5
  %665 = load i32, ptr %3, align 4, !tbaa !5
  %666 = load double, ptr %12, align 8, !tbaa !11
  %667 = load double, ptr %13, align 8, !tbaa !11
  call void @CheckHelixHB(i32 noundef %664, i32 noundef %665, double noundef %666, double noundef %667)
  %668 = load i32, ptr %35, align 4, !tbaa !5
  %669 = load i32, ptr %3, align 4, !tbaa !5
  %670 = load double, ptr %12, align 8, !tbaa !11
  %671 = load double, ptr %13, align 8, !tbaa !11
  call void @CheckBetaHB(i32 noundef %668, i32 noundef %669, double noundef %670, double noundef %671)
  %672 = load double, ptr %13, align 8, !tbaa !11
  store double %672, ptr %15, align 8, !tbaa !11
  %673 = load double, ptr %12, align 8, !tbaa !11
  store double %673, ptr %14, align 8, !tbaa !11
  %674 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %675 = icmp eq i32 %674, 1
  br i1 %675, label %676, label %757

676:                                              ; preds = %663
  %677 = load i32, ptr %4, align 4, !tbaa !5
  %678 = load i32, ptr @HBSum, align 4, !tbaa !50
  %679 = icmp ne i32 %677, %678
  br i1 %679, label %684, label %680

680:                                              ; preds = %676
  %681 = load i32, ptr %5, align 4, !tbaa !5
  %682 = load i32, ptr getelementptr inbounds (%struct.HBType, ptr @HBSum, i32 0, i32 3), align 4, !tbaa !51
  %683 = icmp ne i32 %681, %682
  br i1 %683, label %684, label %757

684:                                              ; preds = %680, %676
  %685 = load i32, ptr %4, align 4, !tbaa !5
  %686 = load i32, ptr @HBSum, align 4, !tbaa !50
  %687 = icmp ne i32 %685, %686
  br i1 %687, label %688, label %721

688:                                              ; preds = %684
  %689 = load ptr, ptr %10, align 8, !tbaa !9
  %690 = load ptr, ptr @atom, align 8, !tbaa !9
  %691 = load i32, ptr %35, align 4, !tbaa !5
  %692 = sext i32 %691 to i64
  %693 = getelementptr inbounds %struct.AtomStr, ptr %690, i64 %692
  %694 = getelementptr inbounds %struct.AtomStr, ptr %693, i32 0, i32 0
  %695 = load ptr, ptr %694, align 8, !tbaa !42
  %696 = getelementptr inbounds %struct.PropertyStr, ptr %695, i32 0, i32 9
  %697 = getelementptr inbounds %struct.AtomSeqStr, ptr %696, i32 0, i32 2
  %698 = load i32, ptr %697, align 8, !tbaa !52
  %699 = sext i32 %698 to i64
  %700 = getelementptr inbounds ptr, ptr %689, i64 %699
  %701 = load ptr, ptr %700, align 8, !tbaa !9
  %702 = getelementptr inbounds i64, ptr %701, i64 0
  %703 = load i64, ptr %702, align 8, !tbaa !40
  %704 = add nsw i64 %703, 1
  store i64 %704, ptr %702, align 8, !tbaa !40
  %705 = load ptr, ptr %10, align 8, !tbaa !9
  %706 = load ptr, ptr @atom, align 8, !tbaa !9
  %707 = load i32, ptr %3, align 4, !tbaa !5
  %708 = sext i32 %707 to i64
  %709 = getelementptr inbounds %struct.AtomStr, ptr %706, i64 %708
  %710 = getelementptr inbounds %struct.AtomStr, ptr %709, i32 0, i32 0
  %711 = load ptr, ptr %710, align 8, !tbaa !42
  %712 = getelementptr inbounds %struct.PropertyStr, ptr %711, i32 0, i32 9
  %713 = getelementptr inbounds %struct.AtomSeqStr, ptr %712, i32 0, i32 2
  %714 = load i32, ptr %713, align 8, !tbaa !52
  %715 = sext i32 %714 to i64
  %716 = getelementptr inbounds ptr, ptr %705, i64 %715
  %717 = load ptr, ptr %716, align 8, !tbaa !9
  %718 = getelementptr inbounds i64, ptr %717, i64 0
  %719 = load i64, ptr %718, align 8, !tbaa !40
  %720 = add nsw i64 %719, 1
  store i64 %720, ptr %718, align 8, !tbaa !40
  br label %754

721:                                              ; preds = %684
  %722 = load ptr, ptr %10, align 8, !tbaa !9
  %723 = load ptr, ptr @atom, align 8, !tbaa !9
  %724 = load i32, ptr %35, align 4, !tbaa !5
  %725 = sext i32 %724 to i64
  %726 = getelementptr inbounds %struct.AtomStr, ptr %723, i64 %725
  %727 = getelementptr inbounds %struct.AtomStr, ptr %726, i32 0, i32 0
  %728 = load ptr, ptr %727, align 8, !tbaa !42
  %729 = getelementptr inbounds %struct.PropertyStr, ptr %728, i32 0, i32 9
  %730 = getelementptr inbounds %struct.AtomSeqStr, ptr %729, i32 0, i32 2
  %731 = load i32, ptr %730, align 8, !tbaa !52
  %732 = sext i32 %731 to i64
  %733 = getelementptr inbounds ptr, ptr %722, i64 %732
  %734 = load ptr, ptr %733, align 8, !tbaa !9
  %735 = getelementptr inbounds i64, ptr %734, i64 1
  %736 = load i64, ptr %735, align 8, !tbaa !40
  %737 = add nsw i64 %736, 1
  store i64 %737, ptr %735, align 8, !tbaa !40
  %738 = load ptr, ptr %10, align 8, !tbaa !9
  %739 = load ptr, ptr @atom, align 8, !tbaa !9
  %740 = load i32, ptr %3, align 4, !tbaa !5
  %741 = sext i32 %740 to i64
  %742 = getelementptr inbounds %struct.AtomStr, ptr %739, i64 %741
  %743 = getelementptr inbounds %struct.AtomStr, ptr %742, i32 0, i32 0
  %744 = load ptr, ptr %743, align 8, !tbaa !42
  %745 = getelementptr inbounds %struct.PropertyStr, ptr %744, i32 0, i32 9
  %746 = getelementptr inbounds %struct.AtomSeqStr, ptr %745, i32 0, i32 2
  %747 = load i32, ptr %746, align 8, !tbaa !52
  %748 = sext i32 %747 to i64
  %749 = getelementptr inbounds ptr, ptr %738, i64 %748
  %750 = load ptr, ptr %749, align 8, !tbaa !9
  %751 = getelementptr inbounds i64, ptr %750, i64 1
  %752 = load i64, ptr %751, align 8, !tbaa !40
  %753 = add nsw i64 %752, 1
  store i64 %753, ptr %751, align 8, !tbaa !40
  br label %754

754:                                              ; preds = %721, %688
  %755 = load i32, ptr @HBSum, align 4, !tbaa !50
  store i32 %755, ptr %4, align 4, !tbaa !5
  %756 = load i32, ptr getelementptr inbounds (%struct.HBType, ptr @HBSum, i32 0, i32 3), align 4, !tbaa !51
  store i32 %756, ptr %5, align 4, !tbaa !5
  br label %757

757:                                              ; preds = %754, %680, %663
  br label %758

758:                                              ; preds = %757, %653
  br label %759

759:                                              ; preds = %758, %608
  %760 = load ptr, ptr @analysisList, align 8, !tbaa !9
  %761 = getelementptr inbounds i32, ptr %760, i64 6
  %762 = load i32, ptr %761, align 4, !tbaa !5
  %763 = icmp ne i32 %762, 0
  br i1 %763, label %764, label %851

764:                                              ; preds = %759
  %765 = load ptr, ptr @atom, align 8, !tbaa !9
  %766 = load i32, ptr %35, align 4, !tbaa !5
  %767 = sext i32 %766 to i64
  %768 = getelementptr inbounds %struct.AtomStr, ptr %765, i64 %767
  %769 = getelementptr inbounds %struct.AtomStr, ptr %768, i32 0, i32 0
  %770 = load ptr, ptr %769, align 8, !tbaa !42
  %771 = getelementptr inbounds %struct.PropertyStr, ptr %770, i32 0, i32 9
  %772 = getelementptr inbounds %struct.AtomSeqStr, ptr %771, i32 0, i32 1
  %773 = load i32, ptr %772, align 4, !tbaa !46
  %774 = load ptr, ptr @atom, align 8, !tbaa !9
  %775 = load i32, ptr %3, align 4, !tbaa !5
  %776 = sext i32 %775 to i64
  %777 = getelementptr inbounds %struct.AtomStr, ptr %774, i64 %776
  %778 = getelementptr inbounds %struct.AtomStr, ptr %777, i32 0, i32 0
  %779 = load ptr, ptr %778, align 8, !tbaa !42
  %780 = getelementptr inbounds %struct.PropertyStr, ptr %779, i32 0, i32 9
  %781 = getelementptr inbounds %struct.AtomSeqStr, ptr %780, i32 0, i32 1
  %782 = load i32, ptr %781, align 4, !tbaa !46
  %783 = icmp eq i32 %773, %782
  br i1 %783, label %784, label %851

784:                                              ; preds = %764
  %785 = load ptr, ptr %22, align 8, !tbaa !9
  %786 = load ptr, ptr @atom, align 8, !tbaa !9
  %787 = load i32, ptr %35, align 4, !tbaa !5
  %788 = sext i32 %787 to i64
  %789 = getelementptr inbounds %struct.AtomStr, ptr %786, i64 %788
  %790 = getelementptr inbounds %struct.AtomStr, ptr %789, i32 0, i32 0
  %791 = load ptr, ptr %790, align 8, !tbaa !42
  %792 = getelementptr inbounds %struct.PropertyStr, ptr %791, i32 0, i32 9
  %793 = getelementptr inbounds %struct.AtomSeqStr, ptr %792, i32 0, i32 1
  %794 = load i32, ptr %793, align 4, !tbaa !46
  %795 = sub nsw i32 %794, 1
  %796 = sext i32 %795 to i64
  %797 = getelementptr inbounds ptr, ptr %785, i64 %796
  %798 = load ptr, ptr %797, align 8, !tbaa !9
  %799 = load i32, ptr %35, align 4, !tbaa !5
  %800 = load i32, ptr %3, align 4, !tbaa !5
  %801 = load ptr, ptr @atom, align 8, !tbaa !9
  %802 = load i32, ptr %35, align 4, !tbaa !5
  %803 = sext i32 %802 to i64
  %804 = getelementptr inbounds %struct.AtomStr, ptr %801, i64 %803
  %805 = getelementptr inbounds %struct.AtomStr, ptr %804, i32 0, i32 0
  %806 = load ptr, ptr %805, align 8, !tbaa !42
  %807 = getelementptr inbounds %struct.PropertyStr, ptr %806, i32 0, i32 2
  %808 = getelementptr inbounds [8 x i8], ptr %807, i64 0, i64 0
  %809 = load ptr, ptr @atom, align 8, !tbaa !9
  %810 = load i32, ptr %3, align 4, !tbaa !5
  %811 = sext i32 %810 to i64
  %812 = getelementptr inbounds %struct.AtomStr, ptr %809, i64 %811
  %813 = getelementptr inbounds %struct.AtomStr, ptr %812, i32 0, i32 0
  %814 = load ptr, ptr %813, align 8, !tbaa !42
  %815 = getelementptr inbounds %struct.PropertyStr, ptr %814, i32 0, i32 2
  %816 = getelementptr inbounds [8 x i8], ptr %815, i64 0, i64 0
  %817 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %798, ptr noundef @.str.39, i32 noundef %799, i32 noundef %800, ptr noundef %808, ptr noundef %816) #7
  %818 = load ptr, ptr %23, align 8, !tbaa !9
  %819 = load ptr, ptr @atom, align 8, !tbaa !9
  %820 = load i32, ptr %35, align 4, !tbaa !5
  %821 = sext i32 %820 to i64
  %822 = getelementptr inbounds %struct.AtomStr, ptr %819, i64 %821
  %823 = getelementptr inbounds %struct.AtomStr, ptr %822, i32 0, i32 0
  %824 = load ptr, ptr %823, align 8, !tbaa !42
  %825 = getelementptr inbounds %struct.PropertyStr, ptr %824, i32 0, i32 9
  %826 = getelementptr inbounds %struct.AtomSeqStr, ptr %825, i32 0, i32 1
  %827 = load i32, ptr %826, align 4, !tbaa !46
  %828 = sub nsw i32 %827, 1
  %829 = sext i32 %828 to i64
  %830 = getelementptr inbounds ptr, ptr %818, i64 %829
  %831 = load ptr, ptr %830, align 8, !tbaa !9
  %832 = load ptr, ptr @atom, align 8, !tbaa !9
  %833 = load i32, ptr %35, align 4, !tbaa !5
  %834 = sext i32 %833 to i64
  %835 = getelementptr inbounds %struct.AtomStr, ptr %832, i64 %834
  %836 = getelementptr inbounds %struct.AtomStr, ptr %835, i32 0, i32 0
  %837 = load ptr, ptr %836, align 8, !tbaa !42
  %838 = getelementptr inbounds %struct.PropertyStr, ptr %837, i32 0, i32 9
  %839 = getelementptr inbounds %struct.AtomSeqStr, ptr %838, i32 0, i32 2
  %840 = load i32, ptr %839, align 8, !tbaa !52
  %841 = load ptr, ptr @atom, align 8, !tbaa !9
  %842 = load i32, ptr %3, align 4, !tbaa !5
  %843 = sext i32 %842 to i64
  %844 = getelementptr inbounds %struct.AtomStr, ptr %841, i64 %843
  %845 = getelementptr inbounds %struct.AtomStr, ptr %844, i32 0, i32 0
  %846 = load ptr, ptr %845, align 8, !tbaa !42
  %847 = getelementptr inbounds %struct.PropertyStr, ptr %846, i32 0, i32 9
  %848 = getelementptr inbounds %struct.AtomSeqStr, ptr %847, i32 0, i32 2
  %849 = load i32, ptr %848, align 8, !tbaa !52
  %850 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %831, ptr noundef @.str.40, i32 noundef %840, i32 noundef %849) #7
  br label %851

851:                                              ; preds = %784, %764, %759
  br label %852

852:                                              ; preds = %851
  %853 = load i32, ptr %35, align 4, !tbaa !5
  %854 = add nsw i32 %853, 1
  store i32 %854, ptr %35, align 4, !tbaa !5
  br label %548, !llvm.loop !53

855:                                              ; preds = %554
  %856 = load ptr, ptr %18, align 8, !tbaa !9
  %857 = load ptr, ptr %20, align 8, !tbaa !9
  call void @SaveHBInfo(ptr noundef %856, ptr noundef %857)
  br label %858

858:                                              ; preds = %855
  %859 = load i64, ptr @step, align 8, !tbaa !40
  %860 = add nsw i64 %859, 1
  store i64 %860, ptr @step, align 8, !tbaa !40
  br label %485, !llvm.loop !54

861:                                              ; preds = %497, %485
  %862 = load ptr, ptr %25, align 8, !tbaa !9
  %863 = call i32 @fclose(ptr noundef %862)
  br label %864

864:                                              ; preds = %861
  %865 = load i32, ptr %33, align 4, !tbaa !5
  %866 = add nsw i32 %865, 1
  store i32 %866, ptr %33, align 4, !tbaa !5
  br label %398, !llvm.loop !55

867:                                              ; preds = %407
  %868 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %869 = icmp eq i32 %868, 1
  br i1 %869, label %870, label %907

870:                                              ; preds = %867
  call void @llvm.lifetime.start.p0(i64 4, ptr %36) #7
  store i32 1, ptr %36, align 4, !tbaa !5
  br label %871

871:                                              ; preds = %903, %870
  %872 = load i32, ptr %36, align 4, !tbaa !5
  %873 = load ptr, ptr @protein, align 8, !tbaa !9
  %874 = getelementptr inbounds %struct.PepStr, ptr %873, i64 1
  %875 = getelementptr inbounds %struct.PepStr, ptr %874, i32 0, i32 3
  %876 = load i32, ptr %875, align 4, !tbaa !16
  %877 = load ptr, ptr @protein, align 8, !tbaa !9
  %878 = getelementptr inbounds %struct.PepStr, ptr %877, i64 1
  %879 = getelementptr inbounds %struct.PepStr, ptr %878, i32 0, i32 2
  %880 = load i32, ptr %879, align 8, !tbaa !17
  %881 = sub nsw i32 %876, %880
  %882 = add nsw i32 %881, 1
  %883 = icmp sle i32 %872, %882
  br i1 %883, label %885, label %884

884:                                              ; preds = %871
  store i32 29, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %36) #7
  br label %906

885:                                              ; preds = %871
  %886 = load ptr, ptr %21, align 8, !tbaa !9
  %887 = load i32, ptr %36, align 4, !tbaa !5
  %888 = load ptr, ptr %10, align 8, !tbaa !9
  %889 = load i32, ptr %36, align 4, !tbaa !5
  %890 = sext i32 %889 to i64
  %891 = getelementptr inbounds ptr, ptr %888, i64 %890
  %892 = load ptr, ptr %891, align 8, !tbaa !9
  %893 = getelementptr inbounds i64, ptr %892, i64 0
  %894 = load i64, ptr %893, align 8, !tbaa !40
  %895 = load ptr, ptr %10, align 8, !tbaa !9
  %896 = load i32, ptr %36, align 4, !tbaa !5
  %897 = sext i32 %896 to i64
  %898 = getelementptr inbounds ptr, ptr %895, i64 %897
  %899 = load ptr, ptr %898, align 8, !tbaa !9
  %900 = getelementptr inbounds i64, ptr %899, i64 1
  %901 = load i64, ptr %900, align 8, !tbaa !40
  %902 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %886, ptr noundef @.str.41, i32 noundef %887, i64 noundef %894, i64 noundef %901) #7
  br label %903

903:                                              ; preds = %885
  %904 = load i32, ptr %36, align 4, !tbaa !5
  %905 = add nsw i32 %904, 1
  store i32 %905, ptr %36, align 4, !tbaa !5
  br label %871, !llvm.loop !56

906:                                              ; preds = %884
  br label %907

907:                                              ; preds = %906, %867
  %908 = load ptr, ptr %24, align 8, !tbaa !9
  %909 = call i32 @fclose(ptr noundef %908)
  %910 = load ptr, ptr %20, align 8, !tbaa !9
  %911 = call i32 @fclose(ptr noundef %910)
  %912 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %913 = icmp eq i32 %912, 1
  br i1 %913, label %914, label %921

914:                                              ; preds = %907
  %915 = load ptr, ptr %21, align 8, !tbaa !9
  %916 = call i32 @fclose(ptr noundef %915)
  %917 = load ptr, ptr %10, align 8, !tbaa !9
  %918 = getelementptr inbounds ptr, ptr %917, i64 0
  %919 = load ptr, ptr %918, align 8, !tbaa !9
  call void @free(ptr noundef %919) #7
  %920 = load ptr, ptr %10, align 8, !tbaa !9
  call void @free(ptr noundef %920) #7
  store ptr null, ptr %10, align 8, !tbaa !9
  br label %921

921:                                              ; preds = %914, %907
  %922 = load ptr, ptr @analysisList, align 8, !tbaa !9
  %923 = getelementptr inbounds i32, ptr %922, i64 5
  %924 = load i32, ptr %923, align 4, !tbaa !5
  %925 = icmp ne i32 %924, 0
  br i1 %925, label %926, label %974

926:                                              ; preds = %921
  call void @llvm.lifetime.start.p0(i64 4, ptr %37) #7
  %927 = load i32, ptr %6, align 4, !tbaa !5
  %928 = sub nsw i32 %927, 1
  store i32 %928, ptr %37, align 4, !tbaa !5
  br label %929

929:                                              ; preds = %954, %926
  %930 = load i32, ptr %37, align 4, !tbaa !5
  %931 = load i32, ptr %7, align 4, !tbaa !5
  %932 = icmp slt i32 %930, %931
  br i1 %932, label %934, label %933

933:                                              ; preds = %929
  store i32 32, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %37) #7
  br label %957

934:                                              ; preds = %929
  call void @llvm.lifetime.start.p0(i64 4, ptr %38) #7
  store i32 0, ptr %38, align 4, !tbaa !5
  br label %935

935:                                              ; preds = %950, %934
  %936 = load i32, ptr %38, align 4, !tbaa !5
  %937 = icmp slt i32 %936, 21
  br i1 %937, label %939, label %938

938:                                              ; preds = %935
  store i32 35, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %38) #7
  br label %953

939:                                              ; preds = %935
  %940 = load ptr, ptr %19, align 8, !tbaa !9
  %941 = load i32, ptr %37, align 4, !tbaa !5
  %942 = sext i32 %941 to i64
  %943 = getelementptr inbounds ptr, ptr %940, i64 %942
  %944 = load ptr, ptr %943, align 8, !tbaa !9
  %945 = load i32, ptr %38, align 4, !tbaa !5
  %946 = sext i32 %945 to i64
  %947 = getelementptr inbounds ptr, ptr %944, i64 %946
  %948 = load ptr, ptr %947, align 8, !tbaa !9
  %949 = call i32 @fclose(ptr noundef %948)
  br label %950

950:                                              ; preds = %939
  %951 = load i32, ptr %38, align 4, !tbaa !5
  %952 = add nsw i32 %951, 1
  store i32 %952, ptr %38, align 4, !tbaa !5
  br label %935, !llvm.loop !57

953:                                              ; preds = %938
  br label %954

954:                                              ; preds = %953
  %955 = load i32, ptr %37, align 4, !tbaa !5
  %956 = add nsw i32 %955, 1
  store i32 %956, ptr %37, align 4, !tbaa !5
  br label %929, !llvm.loop !58

957:                                              ; preds = %933
  call void @llvm.lifetime.start.p0(i64 4, ptr %39) #7
  store i32 0, ptr %39, align 4, !tbaa !5
  br label %958

958:                                              ; preds = %969, %957
  %959 = load i32, ptr %39, align 4, !tbaa !5
  %960 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %961 = icmp slt i32 %959, %960
  br i1 %961, label %963, label %962

962:                                              ; preds = %958
  store i32 38, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %39) #7
  br label %972

963:                                              ; preds = %958
  %964 = load ptr, ptr %19, align 8, !tbaa !9
  %965 = load i32, ptr %39, align 4, !tbaa !5
  %966 = sext i32 %965 to i64
  %967 = getelementptr inbounds ptr, ptr %964, i64 %966
  %968 = load ptr, ptr %967, align 8, !tbaa !9
  call void @free(ptr noundef %968) #7
  br label %969

969:                                              ; preds = %963
  %970 = load i32, ptr %39, align 4, !tbaa !5
  %971 = add nsw i32 %970, 1
  store i32 %971, ptr %39, align 4, !tbaa !5
  br label %958, !llvm.loop !59

972:                                              ; preds = %962
  %973 = load ptr, ptr %19, align 8, !tbaa !9
  call void @free(ptr noundef %973) #7
  store ptr null, ptr %19, align 8, !tbaa !9
  br label %974

974:                                              ; preds = %972, %921
  %975 = load ptr, ptr @analysisList, align 8, !tbaa !9
  %976 = getelementptr inbounds i32, ptr %975, i64 6
  %977 = load i32, ptr %976, align 4, !tbaa !5
  %978 = icmp ne i32 %977, 0
  br i1 %978, label %979, label %1006

979:                                              ; preds = %974
  call void @llvm.lifetime.start.p0(i64 4, ptr %40) #7
  %980 = load i32, ptr %6, align 4, !tbaa !5
  %981 = sub nsw i32 %980, 1
  store i32 %981, ptr %40, align 4, !tbaa !5
  br label %982

982:                                              ; preds = %1000, %979
  %983 = load i32, ptr %40, align 4, !tbaa !5
  %984 = load i32, ptr %7, align 4, !tbaa !5
  %985 = icmp slt i32 %983, %984
  br i1 %985, label %987, label %986

986:                                              ; preds = %982
  store i32 41, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %40) #7
  br label %1003

987:                                              ; preds = %982
  %988 = load ptr, ptr %22, align 8, !tbaa !9
  %989 = load i32, ptr %40, align 4, !tbaa !5
  %990 = sext i32 %989 to i64
  %991 = getelementptr inbounds ptr, ptr %988, i64 %990
  %992 = load ptr, ptr %991, align 8, !tbaa !9
  %993 = call i32 @fclose(ptr noundef %992)
  %994 = load ptr, ptr %23, align 8, !tbaa !9
  %995 = load i32, ptr %40, align 4, !tbaa !5
  %996 = sext i32 %995 to i64
  %997 = getelementptr inbounds ptr, ptr %994, i64 %996
  %998 = load ptr, ptr %997, align 8, !tbaa !9
  %999 = call i32 @fclose(ptr noundef %998)
  br label %1000

1000:                                             ; preds = %987
  %1001 = load i32, ptr %40, align 4, !tbaa !5
  %1002 = add nsw i32 %1001, 1
  store i32 %1002, ptr %40, align 4, !tbaa !5
  br label %982, !llvm.loop !60

1003:                                             ; preds = %986
  %1004 = load ptr, ptr %22, align 8, !tbaa !9
  call void @free(ptr noundef %1004) #7
  store ptr null, ptr %22, align 8, !tbaa !9
  %1005 = load ptr, ptr %23, align 8, !tbaa !9
  call void @free(ptr noundef %1005) #7
  store ptr null, ptr %23, align 8, !tbaa !9
  br label %1006

1006:                                             ; preds = %1003, %974
  %1007 = call i32 (ptr, ...) @printf(ptr noundef @.str.42)
  %1008 = load ptr, ptr @stdout, align 8, !tbaa !9
  %1009 = call i32 @fflush(ptr noundef %1008)
  store i32 1, ptr %30, align 4
  call void @llvm.lifetime.end.p0(i64 8, ptr %25) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %24) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %23) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %20) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %19) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %18) #7
  call void @llvm.lifetime.end.p0(i64 1024, ptr %17) #7
  call void @llvm.lifetime.end.p0(i64 1024, ptr %16) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %14) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %13) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %12) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #7
  call void @llvm.lifetime.end.p0(i64 8, ptr %10) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %5) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %4) #7
  call void @llvm.lifetime.end.p0(i64 4, ptr %3) #7
  ret void
}

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

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

declare i32 @fflush(ptr noundef) #2

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

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

; Function Attrs: nounwind
declare i32 @fprintf(ptr noundef, ptr noundef, ...) #3

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

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

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

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

declare void @FindTargetFile(ptr noundef, ptr noundef, ptr noundef) #2

declare i32 @ReadGro(ptr noundef) #2

; Function Attrs: nounwind uwtable
declare dso_local i32 @ReadConnectionMap(ptr noundef) #0

declare void @PrintProcess(i64 noundef) #2

; Function Attrs: nounwind uwtable
declare hidden void @ResetHBNum() #0

; Function Attrs: nounwind uwtable
declare hidden void @RamachandranPlot(i32 noundef, ptr noundef, ptr noundef) #0

; Function Attrs: nounwind uwtable
declare hidden i32 @FindAANum(ptr noundef) #0

; Function Attrs: nounwind uwtable
declare dso_local i32 @CheckHBConnection(i32 noundef) #0

; Function Attrs: nounwind uwtable
declare hidden void @CheckHelixHB(i32 noundef, i32 noundef, double noundef, double noundef) #0

; Function Attrs: nounwind uwtable
declare hidden void @CheckBetaHB(i32 noundef, i32 noundef, double noundef, double noundef) #0

; Function Attrs: nounwind uwtable
declare hidden void @SaveHBInfo(ptr noundef, ptr noundef) #0

declare i32 @fclose(ptr noundef) #2

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"any pointer", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"double", !7, i64 0}
!13 = !{!14, !6, i64 4}
!14 = !{!"PepStr", !6, i64 0, !6, i64 4, !6, i64 8, !6, i64 12, !12, i64 16}
!15 = !{!14, !6, i64 0}
!16 = !{!14, !6, i64 12}
!17 = !{!14, !6, i64 8}
!18 = distinct !{!18, !19}
!19 = !{!"llvm.loop.mustprogress"}
!20 = distinct !{!20, !19}
!21 = distinct !{!21, !19}
!22 = distinct !{!22, !19}
!23 = distinct !{!23, !19}
!24 = !{!25, !6, i64 0}
!25 = !{!"FileListStr", !6, i64 0, !7, i64 4}
!26 = !{!27, !12, i64 8}
!27 = !{!"SectionStr", !28, i64 0, !12, i64 8, !12, i64 16, !12, i64 24, !12, i64 32, !7, i64 40, !29, i64 64, !31, i64 120, !32, i64 208, !33, i64 240, !34, i64 288}
!28 = !{!"long", !7, i64 0}
!29 = !{!"WallStr", !7, i64 0, !7, i64 20, !30, i64 40}
!30 = !{!"AtomStr", !10, i64 0, !10, i64 8}
!31 = !{!"DynamicWallStr", !7, i64 0, !6, i64 16, !6, i64 20, !12, i64 24, !12, i64 32, !12, i64 40, !12, i64 48, !7, i64 56}
!32 = !{!"ObstructionStr", !6, i64 0, !6, i64 4, !10, i64 8, !10, i64 16, !10, i64 24}
!33 = !{!"TunnelStr", !6, i64 0, !12, i64 8, !12, i64 16, !12, i64 24, !30, i64 32}
!34 = !{!"FlowStr", !6, i64 0, !35, i64 8, !36, i64 40, !37, i64 88}
!35 = !{!"ConstVStr", !7, i64 0}
!36 = !{!"ForceStr", !7, i64 0, !10, i64 32, !10, i64 40}
!37 = !{!"ChargeStr", !6, i64 0, !6, i64 4, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32}
!38 = !{!27, !28, i64 0}
!39 = !{!27, !12, i64 32}
!40 = !{!28, !28, i64 0}
!41 = distinct !{!41, !19}
!42 = !{!30, !10, i64 0}
!43 = !{!44, !6, i64 52}
!44 = !{!"PropertyStr", !7, i64 0, !7, i64 8, !7, i64 40, !6, i64 48, !6, i64 52, !6, i64 56, !12, i64 64, !12, i64 72, !7, i64 80, !45, i64 104, !10, i64 120, !10, i64 128}
!45 = !{!"AtomSeqStr", !6, i64 0, !6, i64 4, !6, i64 8}
!46 = !{!44, !6, i64 108}
!47 = !{!48, !6, i64 24}
!48 = !{!"HBType", !6, i64 0, !6, i64 4, !6, i64 8, !6, i64 12, !6, i64 16, !6, i64 20, !6, i64 24}
!49 = !{!48, !6, i64 16}
!50 = !{!48, !6, i64 0}
!51 = !{!48, !6, i64 12}
!52 = !{!44, !6, i64 112}
!53 = distinct !{!53, !19}
!54 = distinct !{!54, !19}
!55 = distinct !{!55, !19}
!56 = distinct !{!56, !19}
!57 = distinct !{!57, !19}
!58 = distinct !{!58, !19}
!59 = distinct !{!59, !19}
!60 = distinct !{!60, !19}


; 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.HBType = type { i32, i32, i32, i32, i32, i32, i32 }
%struct.PepStr = type { i32, i32, i32, i32, double }
%struct.FileStr = type { i32, [256 x i8] }
%struct.FileListStr = type { i32, [128 x [64 x i8]] }
%struct.SectionStr = type { i64, double, double, double, double, [20 x i8], %struct.WallStr, %struct.DynamicWallStr, %struct.ObstructionStr, %struct.TunnelStr, %struct.FlowStr }
%struct.WallStr = type { [20 x i8], [20 x i8], %struct.AtomStr }
%struct.AtomStr = type { ptr, ptr }
%struct.DynamicWallStr = type { [16 x i8], i32, i32, double, double, double, double, [4 x double] }
%struct.ObstructionStr = type { i32, i32, ptr, ptr, ptr }
%struct.TunnelStr = type { i32, double, double, double, %struct.AtomStr }
%struct.FlowStr = type { i32, %struct.ConstVStr, %struct.ForceStr, %struct.ChargeStr }
%struct.ConstVStr = type { [4 x double] }
%struct.ForceStr = type { [4 x double], ptr, ptr }
%struct.ChargeStr = type { i32, i32, ptr, ptr, ptr, ptr }

@AAName = external dso_local global [21 x [4 x i8]], align 16
@numofprotein = external local_unnamed_addr global i32, align 4
@atomnum = external local_unnamed_addr global i32, align 4
@nPP = external local_unnamed_addr global i32, align 4
@protein = external local_unnamed_addr global ptr, align 8
@.str = external hidden unnamed_addr constant [29 x i8], align 1
@stdout = external local_unnamed_addr global ptr, align 8
@.str.1 = external hidden unnamed_addr constant [5 x i8], align 1
@path = external global [1024 x i8], align 16
@files = external local_unnamed_addr global ptr, align 8
@.str.2 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [43 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [26 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [10 x i8], align 1
@analysisList = external local_unnamed_addr global ptr, align 8
@.str.17 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [49 x i8], align 1
@.str.20 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.21 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [29 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [23 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [25 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.28 = external hidden unnamed_addr constant [30 x i8], align 1
@.str.29 = external hidden unnamed_addr constant [20 x i8], align 1
@.str.30 = external hidden unnamed_addr constant [22 x i8], align 1
@.str.31 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.32 = external hidden unnamed_addr constant [2 x i8], align 1
@.str.33 = external hidden unnamed_addr constant [116 x i8], align 1
@.str.34 = external hidden unnamed_addr constant [70 x i8], align 1
@.str.35 = external hidden unnamed_addr constant [79 x i8], align 1
@fileList = external local_unnamed_addr global ptr, align 8
@.str.36 = external hidden unnamed_addr constant [88 x i8], align 1
@sectInfo = external local_unnamed_addr global ptr, align 8
@step = external hidden local_unnamed_addr global i64, align 8
@.str.37 = external hidden unnamed_addr constant [13 x i8], align 1
@atom = external local_unnamed_addr global ptr, align 8
@.str.38 = external hidden unnamed_addr constant [18 x i8], align 1
@HBSum = external dso_local local_unnamed_addr global %struct.HBType, align 4
@.str.39 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.40 = external hidden unnamed_addr constant [8 x i8], align 1
@.str.41 = external hidden unnamed_addr constant [13 x i8], align 1
@.str.42 = external hidden unnamed_addr constant [8 x i8], align 1

; Function Attrs: nounwind uwtable
define dso_local void @HBInfo(i32 noundef %0) local_unnamed_addr #0 {
  %2 = alloca double, align 8
  %3 = alloca double, align 8
  %4 = alloca [1024 x i8], align 16
  %5 = alloca [1024 x i8], align 16
  %6 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %7 = load i32, ptr @atomnum, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %2) #8
  store double 0.000000e+00, ptr %2, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr nonnull %3) #8
  store double 0.000000e+00, ptr %3, align 8, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 1024, ptr nonnull %4) #8
  call void @llvm.lifetime.start.p0(i64 1024, ptr nonnull %5) #8
  %8 = load i32, ptr @nPP, align 4, !tbaa !5
  %.not = icmp eq i32 %8, 0
  br i1 %.not, label %19, label %9

9:                                                ; preds = %1
  %10 = load ptr, ptr @protein, align 8, !tbaa !11
  %11 = sext i32 %8 to i64
  %12 = getelementptr inbounds %struct.PepStr, ptr %10, i64 %11
  %13 = getelementptr inbounds i8, ptr %12, i64 4
  %14 = load i32, ptr %13, align 4, !tbaa !13
  %15 = load i32, ptr %12, align 8, !tbaa !15
  %16 = add i32 %14, 1
  %17 = sub i32 %16, %15
  %18 = add nsw i32 %15, -1
  br label %19

19:                                               ; preds = %9, %1
  %.0214 = phi i32 [ %18, %9 ], [ 0, %1 ]
  %.0212 = phi i32 [ %17, %9 ], [ %7, %1 ]
  %.0211 = phi i32 [ %8, %9 ], [ %6, %1 ]
  %.0209 = phi i32 [ %8, %9 ], [ 1, %1 ]
  %20 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str)
  %21 = load ptr, ptr @stdout, align 8, !tbaa !11
  %22 = tail call i32 @fflush(ptr noundef %21)
  %23 = load ptr, ptr @files, align 8, !tbaa !11
  %24 = getelementptr inbounds i8, ptr %23, i64 80
  %25 = load ptr, ptr %24, align 8, !tbaa !11
  %26 = sext i32 %0 to i64
  %27 = getelementptr inbounds %struct.FileStr, ptr %25, i64 %26, i32 1
  %28 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %4, ptr noundef nonnull dereferenceable(1) @.str.1, ptr noundef nonnull @path, ptr noundef nonnull %27) #8
  %29 = call noalias ptr @fopen(ptr noundef nonnull %4, ptr noundef nonnull @.str.2)
  %30 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %29, ptr noundef nonnull @.str.3, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.5, ptr noundef nonnull @.str.6, ptr noundef nonnull @.str.7, ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.10, ptr noundef nonnull @.str.11) #8
  %31 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %32 = icmp eq i32 %31, 1
  br i1 %32, label %33, label %.loopexit244

33:                                               ; preds = %19
  %34 = load ptr, ptr @files, align 8, !tbaa !11
  %35 = getelementptr inbounds i8, ptr %34, i64 88
  %36 = load ptr, ptr %35, align 8, !tbaa !11
  %37 = getelementptr inbounds %struct.FileStr, ptr %36, i64 %26, i32 1
  %38 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %4, ptr noundef nonnull dereferenceable(1) @.str.1, ptr noundef nonnull @path, ptr noundef nonnull %37) #8
  %39 = call noalias ptr @fopen(ptr noundef nonnull %4, ptr noundef nonnull @.str.2)
  %40 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %39, ptr noundef nonnull @.str.12) #8
  %41 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %39, ptr noundef nonnull @.str.13) #8
  %42 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %39, ptr noundef nonnull @.str.14) #8
  %43 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %39, ptr noundef nonnull @.str.15) #8
  %44 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %39, ptr noundef nonnull @.str.16) #8
  %45 = load ptr, ptr @protein, align 8, !tbaa !11
  %46 = getelementptr inbounds i8, ptr %45, i64 36
  %47 = load i32, ptr %46, align 4, !tbaa !16
  %48 = getelementptr inbounds i8, ptr %45, i64 32
  %49 = load i32, ptr %48, align 8, !tbaa !17
  %50 = sub nsw i32 %47, %49
  %51 = add nsw i32 %50, 2
  %52 = sext i32 %51 to i64
  %53 = tail call noalias ptr @calloc(i64 noundef %52, i64 noundef 8) #9
  %54 = shl nsw i32 %51, 1
  %55 = sext i32 %54 to i64
  %56 = tail call noalias ptr @calloc(i64 noundef %55, i64 noundef 8) #9
  store ptr %56, ptr %53, align 8, !tbaa !11
  %57 = icmp sgt i32 %50, -1
  br i1 %57, label %.lr.ph.preheader, label %.loopexit244

.lr.ph.preheader:                                 ; preds = %33
  %wide.trip.count = zext nneg i32 %51 to i64
  %58 = add nsw i64 %wide.trip.count, -1
  %min.iters.check = icmp ult i32 %51, 5
  br i1 %min.iters.check, label %.lr.ph.preheader349, label %vector.ph

vector.ph:                                        ; preds = %.lr.ph.preheader
  %n.vec = and i64 %58, -4
  %ind.end = or disjoint i64 %n.vec, 1
  br label %vector.body

vector.body:                                      ; preds = %vector.body, %vector.ph
  %index = phi i64 [ 0, %vector.ph ], [ %index.next, %vector.body ]
  %vec.ind = phi <2 x i64> [ <i64 1, i64 2>, %vector.ph ], [ %vec.ind.next, %vector.body ]
  %offset.idx = or disjoint i64 %index, 1
  %59 = shl nsw <2 x i64> %vec.ind, <i64 4, i64 4>
  %step.add = shl <2 x i64> %vec.ind, <i64 4, i64 4>
  %60 = add <2 x i64> %step.add, <i64 32, i64 32>
  %61 = getelementptr inbounds i8, ptr %56, <2 x i64> %59
  %62 = getelementptr inbounds i8, ptr %56, <2 x i64> %60
  %63 = getelementptr inbounds ptr, ptr %53, i64 %offset.idx
  %64 = getelementptr inbounds i8, ptr %63, i64 16
  store <2 x ptr> %61, ptr %63, align 8, !tbaa !11
  store <2 x ptr> %62, ptr %64, align 8, !tbaa !11
  %index.next = add nuw i64 %index, 4
  %vec.ind.next = add <2 x i64> %vec.ind, <i64 4, i64 4>
  %65 = icmp eq i64 %index.next, %n.vec
  br i1 %65, label %middle.block, label %vector.body, !llvm.loop !18

middle.block:                                     ; preds = %vector.body
  %cmp.n = icmp eq i64 %58, %n.vec
  br i1 %cmp.n, label %.loopexit244, label %.lr.ph.preheader349

.lr.ph.preheader349:                              ; preds = %middle.block, %.lr.ph.preheader
  %indvars.iv.ph = phi i64 [ 1, %.lr.ph.preheader ], [ %ind.end, %middle.block ]
  br label %.lr.ph

.lr.ph:                                           ; preds = %.lr.ph.preheader349, %.lr.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph ], [ %indvars.iv.ph, %.lr.ph.preheader349 ]
  %.idx = shl nsw i64 %indvars.iv, 4
  %66 = getelementptr inbounds i8, ptr %56, i64 %.idx
  %67 = getelementptr inbounds ptr, ptr %53, i64 %indvars.iv
  store ptr %66, ptr %67, align 8, !tbaa !11
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %.loopexit244, label %.lr.ph, !llvm.loop !22

.loopexit244:                                     ; preds = %.lr.ph, %middle.block, %33, %19
  %.0213 = phi ptr [ null, %19 ], [ %53, %33 ], [ %53, %middle.block ], [ %53, %.lr.ph ]
  %.0208 = phi ptr [ null, %19 ], [ %39, %33 ], [ %39, %middle.block ], [ %39, %.lr.ph ]
  %68 = load ptr, ptr @analysisList, align 8, !tbaa !11
  %69 = getelementptr inbounds i8, ptr %68, i64 20
  %70 = load i32, ptr %69, align 4, !tbaa !5
  %.not221 = icmp eq i32 %70, 0
  br i1 %.not221, label %.loopexit243, label %71

71:                                               ; preds = %.loopexit244
  %72 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %73 = sext i32 %72 to i64
  %74 = tail call noalias ptr @calloc(i64 noundef %73, i64 noundef 8) #9
  %75 = icmp sgt i32 %72, 0
  br i1 %75, label %.lr.ph247.preheader, label %._crit_edge

.lr.ph247.preheader:                              ; preds = %71
  %wide.trip.count295 = zext nneg i32 %72 to i64
  br label %.lr.ph247

._crit_edge:                                      ; preds = %.lr.ph247, %71
  %.not286 = icmp sgt i32 %.0209, %.0211
  br i1 %.not286, label %.loopexit243, label %.preheader242.preheader

.preheader242.preheader:                          ; preds = %._crit_edge
  %76 = add i32 %.0209, -1
  %77 = sext i32 %76 to i64
  br label %.preheader242

.lr.ph247:                                        ; preds = %.lr.ph247.preheader, %.lr.ph247
  %indvars.iv292 = phi i64 [ 0, %.lr.ph247.preheader ], [ %indvars.iv.next293, %.lr.ph247 ]
  %78 = tail call noalias dereferenceable_or_null(168) ptr @calloc(i64 noundef 21, i64 noundef 8) #9
  %79 = getelementptr inbounds ptr, ptr %74, i64 %indvars.iv292
  store ptr %78, ptr %79, align 8, !tbaa !11
  %indvars.iv.next293 = add nuw nsw i64 %indvars.iv292, 1
  %exitcond296.not = icmp eq i64 %indvars.iv.next293, %wide.trip.count295
  br i1 %exitcond296.not, label %._crit_edge, label %.lr.ph247, !llvm.loop !23

.preheader242:                                    ; preds = %.preheader242.preheader, %82
  %indvars.iv301 = phi i64 [ %77, %.preheader242.preheader ], [ %indvars.iv.next302, %82 ]
  %indvars.iv.next302 = add nsw i64 %indvars.iv301, 1
  %80 = getelementptr inbounds ptr, ptr %74, i64 %indvars.iv301
  %81 = trunc i64 %indvars.iv.next302 to i32
  br label %83

82:                                               ; preds = %83
  %exitcond304.not = icmp eq i32 %.0211, %81
  br i1 %exitcond304.not, label %.loopexit243.loopexit, label %.preheader242, !llvm.loop !24

83:                                               ; preds = %.preheader242, %83
  %indvars.iv297 = phi i64 [ 0, %.preheader242 ], [ %indvars.iv.next298, %83 ]
  %84 = getelementptr inbounds [21 x [4 x i8]], ptr @AAName, i64 0, i64 %indvars.iv297
  %85 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %4, ptr noundef nonnull dereferenceable(1) @.str.17, ptr noundef nonnull @path, i32 noundef %81, ptr noundef nonnull %84) #8
  %86 = call noalias ptr @fopen(ptr noundef nonnull %4, ptr noundef nonnull @.str.2)
  %87 = load ptr, ptr %80, align 8, !tbaa !11
  %88 = getelementptr inbounds ptr, ptr %87, i64 %indvars.iv297
  store ptr %86, ptr %88, align 8, !tbaa !11
  %89 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %86, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.19) #8
  %90 = load ptr, ptr %88, align 8, !tbaa !11
  %91 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %90, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.20) #8
  %92 = load ptr, ptr %88, align 8, !tbaa !11
  %93 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %92, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.21) #8
  %94 = load ptr, ptr %88, align 8, !tbaa !11
  %95 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %94, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.22) #8
  %96 = load ptr, ptr %88, align 8, !tbaa !11
  %97 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %96, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.23) #8
  %98 = load ptr, ptr %88, align 8, !tbaa !11
  %99 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %98, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.24) #8
  %100 = load ptr, ptr %88, align 8, !tbaa !11
  %101 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %100, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.25) #8
  %102 = load ptr, ptr %88, align 8, !tbaa !11
  %103 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %102, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.26) #8
  %104 = load ptr, ptr %88, align 8, !tbaa !11
  %105 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %104, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.27) #8
  %106 = load ptr, ptr %88, align 8, !tbaa !11
  %107 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %106, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.28) #8
  %108 = load ptr, ptr %88, align 8, !tbaa !11
  %109 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %108, ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.29) #8
  %indvars.iv.next298 = add nuw nsw i64 %indvars.iv297, 1
  %exitcond300.not = icmp eq i64 %indvars.iv.next298, 21
  br i1 %exitcond300.not, label %82, label %83, !llvm.loop !25

.loopexit243.loopexit:                            ; preds = %82
  %.pre = load ptr, ptr @analysisList, align 8, !tbaa !11
  br label %.loopexit243

.loopexit243:                                     ; preds = %.loopexit243.loopexit, %._crit_edge, %.loopexit244
  %110 = phi ptr [ %68, %.loopexit244 ], [ %68, %._crit_edge ], [ %.pre, %.loopexit243.loopexit ]
  %.0210 = phi ptr [ null, %.loopexit244 ], [ %74, %._crit_edge ], [ %74, %.loopexit243.loopexit ]
  %111 = getelementptr inbounds i8, ptr %110, i64 24
  %112 = load i32, ptr %111, align 4, !tbaa !5
  %.not222 = icmp eq i32 %112, 0
  br i1 %.not222, label %.loopexit241, label %113

113:                                              ; preds = %.loopexit243
  %114 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %115 = sext i32 %114 to i64
  %116 = tail call noalias ptr @calloc(i64 noundef %115, i64 noundef 8) #9
  %117 = tail call noalias ptr @calloc(i64 noundef %115, i64 noundef 8) #9
  %.not287 = icmp sgt i32 %.0209, %.0211
  br i1 %.not287, label %.loopexit241, label %.lr.ph252.preheader

.lr.ph252.preheader:                              ; preds = %113
  %118 = add i32 %.0209, -1
  %119 = sext i32 %118 to i64
  br label %.lr.ph252

.lr.ph252:                                        ; preds = %.lr.ph252.preheader, %.lr.ph252
  %indvars.iv305 = phi i64 [ %119, %.lr.ph252.preheader ], [ %indvars.iv.next306, %.lr.ph252 ]
  %indvars.iv.next306 = add nsw i64 %indvars.iv305, 1
  %120 = trunc i64 %indvars.iv.next306 to i32
  %121 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %4, ptr noundef nonnull dereferenceable(1) @.str.30, ptr noundef nonnull @path, i32 noundef %120) #8
  %122 = call noalias ptr @fopen(ptr noundef nonnull %4, ptr noundef nonnull @.str.2)
  %123 = getelementptr inbounds ptr, ptr %116, i64 %indvars.iv305
  store ptr %122, ptr %123, align 8, !tbaa !11
  %124 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %4, ptr noundef nonnull dereferenceable(1) @.str.31, ptr noundef nonnull @path, i32 noundef %120) #8
  %125 = call noalias ptr @fopen(ptr noundef nonnull %4, ptr noundef nonnull @.str.2)
  %126 = getelementptr inbounds ptr, ptr %117, i64 %indvars.iv305
  store ptr %125, ptr %126, align 8, !tbaa !11
  %exitcond309.not = icmp eq i32 %.0211, %120
  br i1 %exitcond309.not, label %.loopexit241, label %.lr.ph252, !llvm.loop !26

.loopexit241:                                     ; preds = %.lr.ph252, %113, %.loopexit243
  %.0207 = phi ptr [ null, %.loopexit243 ], [ %116, %113 ], [ %116, %.lr.ph252 ]
  %.0206 = phi ptr [ null, %.loopexit243 ], [ %117, %113 ], [ %117, %.lr.ph252 ]
  %127 = load ptr, ptr @files, align 8, !tbaa !11
  %128 = getelementptr inbounds i8, ptr %127, i64 64
  %129 = load ptr, ptr %128, align 8, !tbaa !11
  %130 = getelementptr inbounds %struct.FileStr, ptr %129, i64 %26, i32 1
  %131 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %4, ptr noundef nonnull dereferenceable(1) @.str.1, ptr noundef nonnull @path, ptr noundef nonnull %130) #8
  %132 = call noalias ptr @fopen(ptr noundef nonnull %4, ptr noundef nonnull @.str.32)
  %133 = icmp eq ptr %132, null
  br i1 %133, label %143, label %.preheader240

.preheader240:                                    ; preds = %.loopexit241
  %134 = load ptr, ptr @fileList, align 8, !tbaa !11
  %135 = getelementptr inbounds %struct.FileListStr, ptr %134, i64 %26
  %136 = load i32, ptr %135, align 4, !tbaa !27
  %137 = icmp sgt i32 %136, 0
  br i1 %137, label %.lr.ph270, label %._crit_edge271

.lr.ph270:                                        ; preds = %.preheader240
  %138 = add i32 %.0209, -1
  %.not288 = icmp sgt i32 %.0209, %.0211
  %139 = add nsw i32 %.0212, %.0214
  %.not229.not257 = icmp sgt i32 %.0212, 0
  %140 = sext i32 %138 to i64
  %141 = sext i32 %.0214 to i64
  %142 = sext i32 %139 to i64
  br label %159

143:                                              ; preds = %.loopexit241
  %144 = load ptr, ptr @files, align 8, !tbaa !11
  %145 = getelementptr inbounds i8, ptr %144, i64 64
  %146 = load ptr, ptr %145, align 8, !tbaa !11
  %147 = getelementptr inbounds %struct.FileStr, ptr %146, i64 %26, i32 1
  %148 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.33, ptr noundef nonnull %147, ptr noundef nonnull @path, ptr noundef nonnull @.str.34, i32 noundef 115)
  %149 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.35)
  tail call void @exit(i32 noundef 1) #10
  unreachable

._crit_edge271:                                   ; preds = %._crit_edge266, %.preheader240
  %150 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %151 = icmp eq i32 %150, 1
  br i1 %151, label %.preheader238, label %.loopexit

.preheader238:                                    ; preds = %._crit_edge271
  %152 = load ptr, ptr @protein, align 8, !tbaa !11
  %153 = getelementptr inbounds i8, ptr %152, i64 36
  %154 = load i32, ptr %153, align 4, !tbaa !16
  %155 = getelementptr inbounds i8, ptr %152, i64 32
  %156 = load i32, ptr %155, align 8, !tbaa !17
  %157 = add i32 %154, 1
  %158 = sub i32 %157, %156
  %.not223273 = icmp slt i32 %158, 1
  br i1 %.not223273, label %.loopexit, label %.lr.ph275

159:                                              ; preds = %.lr.ph270, %._crit_edge266
  %indvars.iv318 = phi i64 [ 0, %.lr.ph270 ], [ %indvars.iv.next319, %._crit_edge266 ]
  %160 = phi ptr [ %134, %.lr.ph270 ], [ %368, %._crit_edge266 ]
  call void @llvm.memset.p0.i64(ptr noundef nonnull align 16 dereferenceable(1024) %5, i8 0, i64 1024, i1 false)
  %161 = load ptr, ptr @files, align 8, !tbaa !11
  %162 = getelementptr inbounds i8, ptr %161, i64 40
  %163 = load ptr, ptr %162, align 8, !tbaa !11
  %164 = getelementptr inbounds %struct.FileStr, ptr %163, i64 %26, i32 1
  %indvars.iv.next319 = add nuw nsw i64 %indvars.iv318, 1
  %165 = getelementptr inbounds %struct.FileListStr, ptr %160, i64 %26, i32 1, i64 %indvars.iv.next319
  call void @FindTargetFile(ptr noundef nonnull %164, ptr noundef nonnull %165, ptr noundef nonnull %5) #8
  %166 = call i32 (ptr, ptr, ...) @sprintf(ptr noundef nonnull dereferenceable(1) %4, ptr noundef nonnull dereferenceable(1) @.str.1, ptr noundef nonnull @path, ptr noundef nonnull %5) #8
  %167 = call noalias ptr @fopen(ptr noundef nonnull %4, ptr noundef nonnull @.str.32)
  %168 = icmp eq ptr %167, null
  br i1 %168, label %169, label %176

169:                                              ; preds = %159
  %170 = load ptr, ptr @files, align 8, !tbaa !11
  %171 = getelementptr inbounds i8, ptr %170, i64 40
  %172 = load ptr, ptr %171, align 8, !tbaa !11
  %173 = getelementptr inbounds %struct.FileStr, ptr %172, i64 %26, i32 1
  %174 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.33, ptr noundef nonnull %173, ptr noundef nonnull @path, ptr noundef nonnull @.str.34, i32 noundef 127)
  %175 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.36)
  call void @exit(i32 noundef 1) #10
  unreachable

176:                                              ; preds = %159
  %177 = load ptr, ptr @sectInfo, align 8, !tbaa !11
  %178 = getelementptr inbounds %struct.SectionStr, ptr %177, i64 %indvars.iv318
  %179 = getelementptr inbounds i8, ptr %178, i64 8
  %180 = load double, ptr %179, align 8, !tbaa !29
  %181 = load i64, ptr %178, align 8, !tbaa !41
  %182 = sitofp i64 %181 to double
  %183 = fadd double %180, %182
  %184 = getelementptr inbounds i8, ptr %178, i64 32
  %185 = load double, ptr %184, align 8, !tbaa !42
  %186 = fdiv double %183, %185
  %187 = fadd double %186, 1.000000e+00
  %188 = fptosi double %187 to i64
  %189 = fdiv double %180, %185
  %190 = fptosi double %189 to i64
  store i64 %190, ptr @step, align 8, !tbaa !43
  %191 = icmp slt i64 %190, %188
  br i1 %191, label %.lr.ph265, label %._crit_edge266

.lr.ph265:                                        ; preds = %176, %._crit_edge263
  %192 = call i32 @ReadGro(ptr noundef nonnull %132) #8
  %.not226 = icmp eq i32 %192, 0
  br i1 %.not226, label %193, label %._crit_edge266

193:                                              ; preds = %.lr.ph265
  %194 = call i32 @ReadConnectionMap(ptr noundef nonnull %167)
  %.not227 = icmp eq i32 %194, 0
  br i1 %.not227, label %195, label %._crit_edge266

195:                                              ; preds = %193
  %196 = load i64, ptr @step, align 8, !tbaa !43
  call void @PrintProcess(i64 noundef %196) #8
  %197 = load ptr, ptr @sectInfo, align 8, !tbaa !11
  %198 = getelementptr inbounds %struct.SectionStr, ptr %197, i64 %indvars.iv318
  call void @ResetHBNum()
  %199 = load ptr, ptr @analysisList, align 8, !tbaa !11
  %200 = getelementptr inbounds i8, ptr %199, i64 24
  %201 = load i32, ptr %200, align 4, !tbaa !5
  %.not228 = icmp eq i32 %201, 0
  %brmerge = select i1 %.not228, i1 true, i1 %.not288
  br i1 %brmerge, label %.loopexit239, label %.lr.ph255

.lr.ph255:                                        ; preds = %195
  %202 = getelementptr inbounds i8, ptr %198, i64 32
  br label %203

203:                                              ; preds = %.lr.ph255, %203
  %indvars.iv310 = phi i64 [ %140, %.lr.ph255 ], [ %indvars.iv.next311, %203 ]
  %204 = getelementptr inbounds ptr, ptr %.0207, i64 %indvars.iv310
  %205 = load ptr, ptr %204, align 8, !tbaa !11
  %206 = load i64, ptr @step, align 8, !tbaa !43
  %207 = load double, ptr %202, align 8, !tbaa !42
  %208 = fptosi double %207 to i64
  %209 = mul nsw i64 %206, %208
  %210 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %205, ptr noundef nonnull @.str.37, i64 noundef %209) #8
  %211 = getelementptr inbounds ptr, ptr %.0206, i64 %indvars.iv310
  %212 = load ptr, ptr %211, align 8, !tbaa !11
  %213 = load i64, ptr @step, align 8, !tbaa !43
  %214 = load double, ptr %202, align 8, !tbaa !42
  %215 = fptosi double %214 to i64
  %216 = mul nsw i64 %213, %215
  %217 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %212, ptr noundef nonnull @.str.37, i64 noundef %216) #8
  %indvars.iv.next311 = add nsw i64 %indvars.iv310, 1
  %lftr.wideiv313 = trunc i64 %indvars.iv.next311 to i32
  %exitcond314.not = icmp eq i32 %.0211, %lftr.wideiv313
  br i1 %exitcond314.not, label %.loopexit239, label %203, !llvm.loop !44

.loopexit239:                                     ; preds = %203, %195
  br i1 %.not229.not257, label %.lr.ph262, label %._crit_edge263

._crit_edge263:                                   ; preds = %366, %.loopexit239
  call void @SaveHBInfo(ptr noundef %198, ptr noundef %29)
  %218 = load i64, ptr @step, align 8, !tbaa !43
  %219 = add nsw i64 %218, 1
  store i64 %219, ptr @step, align 8, !tbaa !43
  %220 = icmp slt i64 %219, %188
  br i1 %220, label %.lr.ph265, label %._crit_edge266, !llvm.loop !45

.lr.ph262:                                        ; preds = %.loopexit239, %366
  %indvars.iv315 = phi i64 [ %indvars.iv.next316, %366 ], [ %141, %.loopexit239 ]
  %.0203259 = phi i32 [ %.1, %366 ], [ 0, %.loopexit239 ]
  %.0204258 = phi i32 [ %.1205, %366 ], [ 0, %.loopexit239 ]
  %indvars.iv.next316 = add nsw i64 %indvars.iv315, 1
  %221 = load ptr, ptr @atom, align 8, !tbaa !11
  %222 = getelementptr inbounds %struct.AtomStr, ptr %221, i64 %indvars.iv.next316
  %223 = load ptr, ptr %222, align 8, !tbaa !46
  %224 = getelementptr inbounds i8, ptr %223, i64 52
  %225 = load i32, ptr %224, align 4, !tbaa !47
  %226 = icmp eq i32 %225, 18
  %227 = trunc nsw i64 %indvars.iv.next316 to i32
  br i1 %226, label %228, label %.lr.ph262._crit_edge

228:                                              ; preds = %.lr.ph262
  call void @RamachandranPlot(i32 noundef %227, ptr noundef nonnull %2, ptr noundef nonnull %3)
  %229 = load double, ptr %2, align 8, !tbaa !9
  %230 = fcmp une double %229, 0.000000e+00
  %231 = load double, ptr %3, align 8
  %232 = fcmp une double %231, 0.000000e+00
  %or.cond = select i1 %230, i1 %232, i1 false
  br i1 %or.cond, label %233, label %.lr.ph262._crit_edge

233:                                              ; preds = %228
  %234 = load ptr, ptr @analysisList, align 8, !tbaa !11
  %235 = getelementptr inbounds i8, ptr %234, i64 20
  %236 = load i32, ptr %235, align 4, !tbaa !5
  %.not230 = icmp eq i32 %236, 0
  br i1 %.not230, label %.lr.ph262._crit_edge, label %237

237:                                              ; preds = %233
  %238 = load ptr, ptr @atom, align 8, !tbaa !11
  %239 = getelementptr inbounds %struct.AtomStr, ptr %238, i64 %indvars.iv.next316
  %240 = load ptr, ptr %239, align 8, !tbaa !46
  %241 = getelementptr inbounds i8, ptr %240, i64 108
  %242 = load i32, ptr %241, align 4, !tbaa !50
  %243 = add nsw i32 %242, -1
  %244 = sext i32 %243 to i64
  %245 = getelementptr inbounds ptr, ptr %.0210, i64 %244
  %246 = load ptr, ptr %245, align 8, !tbaa !11
  %247 = getelementptr inbounds i8, ptr %240, i64 40
  %248 = call i32 @FindAANum(ptr noundef nonnull %247)
  %249 = sext i32 %248 to i64
  %250 = getelementptr inbounds ptr, ptr %246, i64 %249
  %251 = load ptr, ptr %250, align 8, !tbaa !11
  %252 = load double, ptr %2, align 8, !tbaa !9
  %253 = load double, ptr %3, align 8, !tbaa !9
  %254 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %251, ptr noundef nonnull @.str.38, double noundef %252, double noundef %253) #8
  br label %.lr.ph262._crit_edge

.lr.ph262._crit_edge:                             ; preds = %.lr.ph262, %228, %233, %237
  %255 = call i32 @CheckHBConnection(i32 noundef %227)
  %256 = icmp sgt i32 %255, 0
  br i1 %256, label %257, label %.thread

257:                                              ; preds = %.lr.ph262._crit_edge
  %258 = zext nneg i32 %255 to i64
  %259 = icmp slt i64 %indvars.iv.next316, %258
  %.pre341 = load ptr, ptr @atom, align 8, !tbaa !11
  br i1 %259, label %260, label %._crit_edge342

._crit_edge342:                                   ; preds = %257
  %.phi.trans.insert = getelementptr inbounds %struct.AtomStr, ptr %.pre341, i64 %indvars.iv.next316
  %.pre343 = load ptr, ptr %.phi.trans.insert, align 8, !tbaa !46
  %.phi.trans.insert344 = getelementptr inbounds i8, ptr %.pre343, i64 52
  %.pre345 = load i32, ptr %.phi.trans.insert344, align 4, !tbaa !47
  br label %278

260:                                              ; preds = %257
  %261 = load i32, ptr getelementptr inbounds (i8, ptr @HBSum, i64 24), align 4, !tbaa !51
  %262 = add nsw i32 %261, 1
  store i32 %262, ptr getelementptr inbounds (i8, ptr @HBSum, i64 24), align 4, !tbaa !51
  %263 = getelementptr inbounds %struct.AtomStr, ptr %.pre341, i64 %indvars.iv.next316
  %264 = load ptr, ptr %263, align 8, !tbaa !46
  %265 = getelementptr inbounds i8, ptr %264, i64 52
  %266 = load i32, ptr %265, align 4, !tbaa !47
  %267 = icmp eq i32 %266, 31
  br i1 %267, label %268, label %278

268:                                              ; preds = %260
  %269 = zext nneg i32 %255 to i64
  %270 = getelementptr inbounds %struct.AtomStr, ptr %.pre341, i64 %269
  %271 = load ptr, ptr %270, align 8, !tbaa !46
  %272 = getelementptr inbounds i8, ptr %271, i64 52
  %273 = load i32, ptr %272, align 4, !tbaa !47
  %274 = icmp eq i32 %273, 31
  br i1 %274, label %275, label %.thread

275:                                              ; preds = %268
  %276 = load i32, ptr getelementptr inbounds (i8, ptr @HBSum, i64 16), align 4, !tbaa !53
  %277 = add nsw i32 %276, 1
  store i32 %277, ptr getelementptr inbounds (i8, ptr @HBSum, i64 16), align 4, !tbaa !53
  br label %.thread

278:                                              ; preds = %._crit_edge342, %260
  %279 = phi i32 [ %.pre345, %._crit_edge342 ], [ %266, %260 ]
  switch i32 %279, label %.thread [
    i32 2, label %280
    i32 4, label %280
  ]

280:                                              ; preds = %278, %278
  %281 = load double, ptr %2, align 8, !tbaa !9
  %282 = load double, ptr %3, align 8, !tbaa !9
  call void @CheckHelixHB(i32 noundef %227, i32 noundef %255, double noundef %281, double noundef %282)
  %283 = load double, ptr %2, align 8, !tbaa !9
  %284 = load double, ptr %3, align 8, !tbaa !9
  call void @CheckBetaHB(i32 noundef %227, i32 noundef %255, double noundef %283, double noundef %284)
  %285 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %286 = icmp eq i32 %285, 1
  br i1 %286, label %287, label %.thread

287:                                              ; preds = %280
  %288 = load i32, ptr @HBSum, align 4, !tbaa !54
  %.not231 = icmp eq i32 %.0203259, %288
  %289 = load i32, ptr getelementptr inbounds (i8, ptr @HBSum, i64 12), align 4
  %.not232 = icmp eq i32 %.0204258, %289
  %or.cond235 = select i1 %.not231, i1 %.not232, i1 false
  br i1 %or.cond235, label %.thread, label %290

290:                                              ; preds = %287
  %291 = load ptr, ptr @atom, align 8, !tbaa !11
  %292 = getelementptr inbounds %struct.AtomStr, ptr %291, i64 %indvars.iv.next316
  %293 = load ptr, ptr %292, align 8, !tbaa !46
  %294 = getelementptr inbounds i8, ptr %293, i64 112
  %295 = load i32, ptr %294, align 8, !tbaa !55
  %296 = sext i32 %295 to i64
  %297 = getelementptr inbounds ptr, ptr %.0213, i64 %296
  %298 = load ptr, ptr %297, align 8, !tbaa !11
  br i1 %.not231, label %312, label %299

299:                                              ; preds = %290
  %300 = load i64, ptr %298, align 8, !tbaa !43
  %301 = add nsw i64 %300, 1
  store i64 %301, ptr %298, align 8, !tbaa !43
  %302 = zext nneg i32 %255 to i64
  %303 = getelementptr inbounds %struct.AtomStr, ptr %291, i64 %302
  %304 = load ptr, ptr %303, align 8, !tbaa !46
  %305 = getelementptr inbounds i8, ptr %304, i64 112
  %306 = load i32, ptr %305, align 8, !tbaa !55
  %307 = sext i32 %306 to i64
  %308 = getelementptr inbounds ptr, ptr %.0213, i64 %307
  %309 = load ptr, ptr %308, align 8, !tbaa !11
  %310 = load i64, ptr %309, align 8, !tbaa !43
  %311 = add nsw i64 %310, 1
  store i64 %311, ptr %309, align 8, !tbaa !43
  br label %.thread

312:                                              ; preds = %290
  %313 = getelementptr inbounds i8, ptr %298, i64 8
  %314 = load i64, ptr %313, align 8, !tbaa !43
  %315 = add nsw i64 %314, 1
  store i64 %315, ptr %313, align 8, !tbaa !43
  %316 = zext nneg i32 %255 to i64
  %317 = getelementptr inbounds %struct.AtomStr, ptr %291, i64 %316
  %318 = load ptr, ptr %317, align 8, !tbaa !46
  %319 = getelementptr inbounds i8, ptr %318, i64 112
  %320 = load i32, ptr %319, align 8, !tbaa !55
  %321 = sext i32 %320 to i64
  %322 = getelementptr inbounds ptr, ptr %.0213, i64 %321
  %323 = load ptr, ptr %322, align 8, !tbaa !11
  %324 = getelementptr inbounds i8, ptr %323, i64 8
  %325 = load i64, ptr %324, align 8, !tbaa !43
  %326 = add nsw i64 %325, 1
  store i64 %326, ptr %324, align 8, !tbaa !43
  br label %.thread

.thread:                                          ; preds = %275, %268, %299, %312, %287, %278, %280, %.lr.ph262._crit_edge
  %.1205 = phi i32 [ %.0204258, %280 ], [ %.0204258, %.lr.ph262._crit_edge ], [ %.0204258, %278 ], [ %.0204258, %287 ], [ %289, %312 ], [ %289, %299 ], [ %.0204258, %268 ], [ %.0204258, %275 ]
  %.1 = phi i32 [ %.0203259, %280 ], [ %.0203259, %.lr.ph262._crit_edge ], [ %.0203259, %278 ], [ %.0203259, %287 ], [ %.0203259, %312 ], [ %288, %299 ], [ %.0203259, %268 ], [ %.0203259, %275 ]
  %327 = load ptr, ptr @analysisList, align 8, !tbaa !11
  %328 = getelementptr inbounds i8, ptr %327, i64 24
  %329 = load i32, ptr %328, align 4, !tbaa !5
  %.not234 = icmp eq i32 %329, 0
  br i1 %.not234, label %366, label %330

330:                                              ; preds = %.thread
  %331 = load ptr, ptr @atom, align 8, !tbaa !11
  %332 = getelementptr inbounds %struct.AtomStr, ptr %331, i64 %indvars.iv.next316
  %333 = load ptr, ptr %332, align 8, !tbaa !46
  %334 = getelementptr inbounds i8, ptr %333, i64 108
  %335 = load i32, ptr %334, align 4, !tbaa !50
  %336 = sext i32 %255 to i64
  %337 = getelementptr inbounds %struct.AtomStr, ptr %331, i64 %336
  %338 = load ptr, ptr %337, align 8, !tbaa !46
  %339 = getelementptr inbounds i8, ptr %338, i64 108
  %340 = load i32, ptr %339, align 4, !tbaa !50
  %341 = icmp eq i32 %335, %340
  br i1 %341, label %342, label %366

342:                                              ; preds = %330
  %343 = add nsw i32 %335, -1
  %344 = sext i32 %343 to i64
  %345 = getelementptr inbounds ptr, ptr %.0207, i64 %344
  %346 = load ptr, ptr %345, align 8, !tbaa !11
  %347 = getelementptr inbounds i8, ptr %333, i64 40
  %348 = getelementptr inbounds i8, ptr %338, i64 40
  %349 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %346, ptr noundef nonnull @.str.39, i32 noundef %227, i32 noundef %255, ptr noundef nonnull %347, ptr noundef nonnull %348) #8
  %350 = load ptr, ptr @atom, align 8, !tbaa !11
  %351 = getelementptr inbounds %struct.AtomStr, ptr %350, i64 %indvars.iv.next316
  %352 = load ptr, ptr %351, align 8, !tbaa !46
  %353 = getelementptr inbounds i8, ptr %352, i64 108
  %354 = load i32, ptr %353, align 4, !tbaa !50
  %355 = add nsw i32 %354, -1
  %356 = sext i32 %355 to i64
  %357 = getelementptr inbounds ptr, ptr %.0206, i64 %356
  %358 = load ptr, ptr %357, align 8, !tbaa !11
  %359 = getelementptr inbounds i8, ptr %352, i64 112
  %360 = load i32, ptr %359, align 8, !tbaa !55
  %361 = getelementptr inbounds %struct.AtomStr, ptr %350, i64 %336
  %362 = load ptr, ptr %361, align 8, !tbaa !46
  %363 = getelementptr inbounds i8, ptr %362, i64 112
  %364 = load i32, ptr %363, align 8, !tbaa !55
  %365 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %358, ptr noundef nonnull @.str.40, i32 noundef %360, i32 noundef %364) #8
  br label %366

366:                                              ; preds = %.thread, %330, %342
  %.not229.not = icmp slt i64 %indvars.iv.next316, %142
  br i1 %.not229.not, label %.lr.ph262, label %._crit_edge263, !llvm.loop !56

._crit_edge266:                                   ; preds = %._crit_edge263, %193, %.lr.ph265, %176
  %367 = call i32 @fclose(ptr noundef nonnull %167)
  %368 = load ptr, ptr @fileList, align 8, !tbaa !11
  %369 = getelementptr inbounds %struct.FileListStr, ptr %368, i64 %26
  %370 = load i32, ptr %369, align 4, !tbaa !27
  %371 = sext i32 %370 to i64
  %372 = icmp slt i64 %indvars.iv.next319, %371
  br i1 %372, label %159, label %._crit_edge271, !llvm.loop !57

.lr.ph275:                                        ; preds = %.preheader238, %.lr.ph275
  %indvars.iv321 = phi i64 [ %indvars.iv.next322, %.lr.ph275 ], [ 1, %.preheader238 ]
  %373 = getelementptr inbounds ptr, ptr %.0213, i64 %indvars.iv321
  %374 = load ptr, ptr %373, align 8, !tbaa !11
  %375 = load i64, ptr %374, align 8, !tbaa !43
  %376 = getelementptr inbounds i8, ptr %374, i64 8
  %377 = load i64, ptr %376, align 8, !tbaa !43
  %378 = trunc nuw nsw i64 %indvars.iv321 to i32
  %379 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %.0208, ptr noundef nonnull @.str.41, i32 noundef %378, i64 noundef %375, i64 noundef %377) #8
  %indvars.iv.next322 = add nuw nsw i64 %indvars.iv321, 1
  %380 = load ptr, ptr @protein, align 8, !tbaa !11
  %381 = getelementptr inbounds i8, ptr %380, i64 36
  %382 = load i32, ptr %381, align 4, !tbaa !16
  %383 = getelementptr inbounds i8, ptr %380, i64 32
  %384 = load i32, ptr %383, align 8, !tbaa !17
  %385 = add i32 %382, 1
  %386 = sub i32 %385, %384
  %387 = sext i32 %386 to i64
  %.not223.not = icmp slt i64 %indvars.iv321, %387
  br i1 %.not223.not, label %.lr.ph275, label %.loopexit, !llvm.loop !58

.loopexit:                                        ; preds = %.lr.ph275, %.preheader238, %._crit_edge271
  %388 = call i32 @fclose(ptr noundef nonnull %132)
  %389 = call i32 @fclose(ptr noundef %29)
  %390 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %391 = icmp eq i32 %390, 1
  br i1 %391, label %392, label %395

392:                                              ; preds = %.loopexit
  %393 = call i32 @fclose(ptr noundef %.0208)
  %394 = load ptr, ptr %.0213, align 8, !tbaa !11
  call void @free(ptr noundef %394) #8
  call void @free(ptr noundef %.0213) #8
  br label %395

395:                                              ; preds = %392, %.loopexit
  %396 = load ptr, ptr @analysisList, align 8, !tbaa !11
  %397 = getelementptr inbounds i8, ptr %396, i64 20
  %398 = load i32, ptr %397, align 4, !tbaa !5
  %.not224 = icmp eq i32 %398, 0
  br i1 %.not224, label %493, label %399

399:                                              ; preds = %395
  %.not289 = icmp sgt i32 %.0209, %.0211
  br i1 %.not289, label %.preheader, label %.preheader237.preheader

.preheader237.preheader:                          ; preds = %399
  %400 = add i32 %.0209, -1
  %401 = sext i32 %400 to i64
  br label %.preheader237

.preheader237:                                    ; preds = %.preheader237.preheader, %.preheader237
  %indvars.iv328 = phi i64 [ %401, %.preheader237.preheader ], [ %indvars.iv.next329, %.preheader237 ]
  %402 = getelementptr inbounds ptr, ptr %.0210, i64 %indvars.iv328
  %403 = load ptr, ptr %402, align 8, !tbaa !11
  %404 = load ptr, ptr %403, align 8, !tbaa !11
  %405 = call i32 @fclose(ptr noundef %404)
  %406 = load ptr, ptr %402, align 8, !tbaa !11
  %407 = getelementptr inbounds i8, ptr %406, i64 8
  %408 = load ptr, ptr %407, align 8, !tbaa !11
  %409 = call i32 @fclose(ptr noundef %408)
  %410 = load ptr, ptr %402, align 8, !tbaa !11
  %411 = getelementptr inbounds i8, ptr %410, i64 16
  %412 = load ptr, ptr %411, align 8, !tbaa !11
  %413 = call i32 @fclose(ptr noundef %412)
  %414 = load ptr, ptr %402, align 8, !tbaa !11
  %415 = getelementptr inbounds i8, ptr %414, i64 24
  %416 = load ptr, ptr %415, align 8, !tbaa !11
  %417 = call i32 @fclose(ptr noundef %416)
  %418 = load ptr, ptr %402, align 8, !tbaa !11
  %419 = getelementptr inbounds i8, ptr %418, i64 32
  %420 = load ptr, ptr %419, align 8, !tbaa !11
  %421 = call i32 @fclose(ptr noundef %420)
  %422 = load ptr, ptr %402, align 8, !tbaa !11
  %423 = getelementptr inbounds i8, ptr %422, i64 40
  %424 = load ptr, ptr %423, align 8, !tbaa !11
  %425 = call i32 @fclose(ptr noundef %424)
  %426 = load ptr, ptr %402, align 8, !tbaa !11
  %427 = getelementptr inbounds i8, ptr %426, i64 48
  %428 = load ptr, ptr %427, align 8, !tbaa !11
  %429 = call i32 @fclose(ptr noundef %428)
  %430 = load ptr, ptr %402, align 8, !tbaa !11
  %431 = getelementptr inbounds i8, ptr %430, i64 56
  %432 = load ptr, ptr %431, align 8, !tbaa !11
  %433 = call i32 @fclose(ptr noundef %432)
  %434 = load ptr, ptr %402, align 8, !tbaa !11
  %435 = getelementptr inbounds i8, ptr %434, i64 64
  %436 = load ptr, ptr %435, align 8, !tbaa !11
  %437 = call i32 @fclose(ptr noundef %436)
  %438 = load ptr, ptr %402, align 8, !tbaa !11
  %439 = getelementptr inbounds i8, ptr %438, i64 72
  %440 = load ptr, ptr %439, align 8, !tbaa !11
  %441 = call i32 @fclose(ptr noundef %440)
  %442 = load ptr, ptr %402, align 8, !tbaa !11
  %443 = getelementptr inbounds i8, ptr %442, i64 80
  %444 = load ptr, ptr %443, align 8, !tbaa !11
  %445 = call i32 @fclose(ptr noundef %444)
  %446 = load ptr, ptr %402, align 8, !tbaa !11
  %447 = getelementptr inbounds i8, ptr %446, i64 88
  %448 = load ptr, ptr %447, align 8, !tbaa !11
  %449 = call i32 @fclose(ptr noundef %448)
  %450 = load ptr, ptr %402, align 8, !tbaa !11
  %451 = getelementptr inbounds i8, ptr %450, i64 96
  %452 = load ptr, ptr %451, align 8, !tbaa !11
  %453 = call i32 @fclose(ptr noundef %452)
  %454 = load ptr, ptr %402, align 8, !tbaa !11
  %455 = getelementptr inbounds i8, ptr %454, i64 104
  %456 = load ptr, ptr %455, align 8, !tbaa !11
  %457 = call i32 @fclose(ptr noundef %456)
  %458 = load ptr, ptr %402, align 8, !tbaa !11
  %459 = getelementptr inbounds i8, ptr %458, i64 112
  %460 = load ptr, ptr %459, align 8, !tbaa !11
  %461 = call i32 @fclose(ptr noundef %460)
  %462 = load ptr, ptr %402, align 8, !tbaa !11
  %463 = getelementptr inbounds i8, ptr %462, i64 120
  %464 = load ptr, ptr %463, align 8, !tbaa !11
  %465 = call i32 @fclose(ptr noundef %464)
  %466 = load ptr, ptr %402, align 8, !tbaa !11
  %467 = getelementptr inbounds i8, ptr %466, i64 128
  %468 = load ptr, ptr %467, align 8, !tbaa !11
  %469 = call i32 @fclose(ptr noundef %468)
  %470 = load ptr, ptr %402, align 8, !tbaa !11
  %471 = getelementptr inbounds i8, ptr %470, i64 136
  %472 = load ptr, ptr %471, align 8, !tbaa !11
  %473 = call i32 @fclose(ptr noundef %472)
  %474 = load ptr, ptr %402, align 8, !tbaa !11
  %475 = getelementptr inbounds i8, ptr %474, i64 144
  %476 = load ptr, ptr %475, align 8, !tbaa !11
  %477 = call i32 @fclose(ptr noundef %476)
  %478 = load ptr, ptr %402, align 8, !tbaa !11
  %479 = getelementptr inbounds i8, ptr %478, i64 152
  %480 = load ptr, ptr %479, align 8, !tbaa !11
  %481 = call i32 @fclose(ptr noundef %480)
  %482 = load ptr, ptr %402, align 8, !tbaa !11
  %483 = getelementptr inbounds i8, ptr %482, i64 160
  %484 = load ptr, ptr %483, align 8, !tbaa !11
  %485 = call i32 @fclose(ptr noundef %484)
  %indvars.iv.next329 = add nsw i64 %indvars.iv328, 1
  %lftr.wideiv331 = trunc i64 %indvars.iv.next329 to i32
  %exitcond332.not = icmp eq i32 %.0211, %lftr.wideiv331
  br i1 %exitcond332.not, label %.preheader, label %.preheader237, !llvm.loop !59

.preheader:                                       ; preds = %.preheader237, %399
  %486 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %487 = icmp sgt i32 %486, 0
  br i1 %487, label %.lr.ph279, label %._crit_edge280

._crit_edge280:                                   ; preds = %.lr.ph279, %.preheader
  call void @free(ptr noundef %.0210) #8
  %.pre346 = load ptr, ptr @analysisList, align 8, !tbaa !11
  br label %493

.lr.ph279:                                        ; preds = %.preheader, %.lr.ph279
  %indvars.iv333 = phi i64 [ %indvars.iv.next334, %.lr.ph279 ], [ 0, %.preheader ]
  %488 = getelementptr inbounds ptr, ptr %.0210, i64 %indvars.iv333
  %489 = load ptr, ptr %488, align 8, !tbaa !11
  call void @free(ptr noundef %489) #8
  %indvars.iv.next334 = add nuw nsw i64 %indvars.iv333, 1
  %490 = load i32, ptr @numofprotein, align 4, !tbaa !5
  %491 = sext i32 %490 to i64
  %492 = icmp slt i64 %indvars.iv.next334, %491
  br i1 %492, label %.lr.ph279, label %._crit_edge280, !llvm.loop !60

493:                                              ; preds = %._crit_edge280, %395
  %494 = phi ptr [ %.pre346, %._crit_edge280 ], [ %396, %395 ]
  %495 = getelementptr inbounds i8, ptr %494, i64 24
  %496 = load i32, ptr %495, align 4, !tbaa !5
  %.not225 = icmp eq i32 %496, 0
  br i1 %.not225, label %506, label %497

497:                                              ; preds = %493
  %.not290 = icmp sgt i32 %.0209, %.0211
  br i1 %.not290, label %._crit_edge284, label %.lr.ph283.preheader

.lr.ph283.preheader:                              ; preds = %497
  %498 = add i32 %.0209, -1
  %499 = sext i32 %498 to i64
  br label %.lr.ph283

._crit_edge284:                                   ; preds = %.lr.ph283, %497
  call void @free(ptr noundef %.0207) #8
  call void @free(ptr noundef %.0206) #8
  br label %506

.lr.ph283:                                        ; preds = %.lr.ph283.preheader, %.lr.ph283
  %indvars.iv336 = phi i64 [ %499, %.lr.ph283.preheader ], [ %indvars.iv.next337, %.lr.ph283 ]
  %500 = getelementptr inbounds ptr, ptr %.0207, i64 %indvars.iv336
  %501 = load ptr, ptr %500, align 8, !tbaa !11
  %502 = call i32 @fclose(ptr noundef %501)
  %503 = getelementptr inbounds ptr, ptr %.0206, i64 %indvars.iv336
  %504 = load ptr, ptr %503, align 8, !tbaa !11
  %505 = call i32 @fclose(ptr noundef %504)
  %indvars.iv.next337 = add nsw i64 %indvars.iv336, 1
  %lftr.wideiv339 = trunc i64 %indvars.iv.next337 to i32
  %exitcond340.not = icmp eq i32 %.0211, %lftr.wideiv339
  br i1 %exitcond340.not, label %._crit_edge284, label %.lr.ph283, !llvm.loop !61

506:                                              ; preds = %._crit_edge284, %493
  %507 = call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.42)
  %508 = load ptr, ptr @stdout, align 8, !tbaa !11
  %509 = call i32 @fflush(ptr noundef %508)
  call void @llvm.lifetime.end.p0(i64 1024, ptr nonnull %5) #8
  call void @llvm.lifetime.end.p0(i64 1024, ptr nonnull %4) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %3) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr nonnull %2) #8
  ret void
}

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

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

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

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

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

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

; 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 #3

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

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

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

declare void @FindTargetFile(ptr noundef, ptr noundef, ptr noundef) local_unnamed_addr #6

declare i32 @ReadGro(ptr noundef) local_unnamed_addr #6

; Function Attrs: nounwind uwtable
declare dso_local i32 @ReadConnectionMap(ptr noundef) local_unnamed_addr #0

declare void @PrintProcess(i64 noundef) local_unnamed_addr #6

; Function Attrs: nounwind uwtable
declare hidden void @ResetHBNum() local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare hidden void @RamachandranPlot(i32 noundef, ptr noundef, ptr noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare hidden i32 @FindAANum(ptr noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare dso_local i32 @CheckHBConnection(i32 noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare hidden void @CheckHelixHB(i32 noundef, i32 noundef, double noundef, double noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare hidden void @CheckBetaHB(i32 noundef, i32 noundef, double noundef, double noundef) local_unnamed_addr #0

; Function Attrs: nounwind uwtable
declare hidden void @SaveHBInfo(ptr noundef, ptr noundef) local_unnamed_addr #0

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

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"int", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !10, i64 0}
!10 = !{!"double", !7, i64 0}
!11 = !{!12, !12, i64 0}
!12 = !{!"any pointer", !7, i64 0}
!13 = !{!14, !6, i64 4}
!14 = !{!"PepStr", !6, i64 0, !6, i64 4, !6, i64 8, !6, i64 12, !10, i64 16}
!15 = !{!14, !6, i64 0}
!16 = !{!14, !6, i64 12}
!17 = !{!14, !6, i64 8}
!18 = distinct !{!18, !19, !20, !21}
!19 = !{!"llvm.loop.mustprogress"}
!20 = !{!"llvm.loop.isvectorized", i32 1}
!21 = !{!"llvm.loop.unroll.runtime.disable"}
!22 = distinct !{!22, !19, !21, !20}
!23 = distinct !{!23, !19}
!24 = distinct !{!24, !19}
!25 = distinct !{!25, !19}
!26 = distinct !{!26, !19}
!27 = !{!28, !6, i64 0}
!28 = !{!"FileListStr", !6, i64 0, !7, i64 4}
!29 = !{!30, !10, i64 8}
!30 = !{!"SectionStr", !31, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !7, i64 40, !32, i64 64, !34, i64 120, !35, i64 208, !36, i64 240, !37, i64 288}
!31 = !{!"long", !7, i64 0}
!32 = !{!"WallStr", !7, i64 0, !7, i64 20, !33, i64 40}
!33 = !{!"AtomStr", !12, i64 0, !12, i64 8}
!34 = !{!"DynamicWallStr", !7, i64 0, !6, i64 16, !6, i64 20, !10, i64 24, !10, i64 32, !10, i64 40, !10, i64 48, !7, i64 56}
!35 = !{!"ObstructionStr", !6, i64 0, !6, i64 4, !12, i64 8, !12, i64 16, !12, i64 24}
!36 = !{!"TunnelStr", !6, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !33, i64 32}
!37 = !{!"FlowStr", !6, i64 0, !38, i64 8, !39, i64 40, !40, i64 88}
!38 = !{!"ConstVStr", !7, i64 0}
!39 = !{!"ForceStr", !7, i64 0, !12, i64 32, !12, i64 40}
!40 = !{!"ChargeStr", !6, i64 0, !6, i64 4, !12, i64 8, !12, i64 16, !12, i64 24, !12, i64 32}
!41 = !{!30, !31, i64 0}
!42 = !{!30, !10, i64 32}
!43 = !{!31, !31, i64 0}
!44 = distinct !{!44, !19}
!45 = distinct !{!45, !19}
!46 = !{!33, !12, i64 0}
!47 = !{!48, !6, i64 52}
!48 = !{!"PropertyStr", !7, i64 0, !7, i64 8, !7, i64 40, !6, i64 48, !6, i64 52, !6, i64 56, !10, i64 64, !10, i64 72, !7, i64 80, !49, i64 104, !12, i64 120, !12, i64 128}
!49 = !{!"AtomSeqStr", !6, i64 0, !6, i64 4, !6, i64 8}
!50 = !{!48, !6, i64 108}
!51 = !{!52, !6, i64 24}
!52 = !{!"HBType", !6, i64 0, !6, i64 4, !6, i64 8, !6, i64 12, !6, i64 16, !6, i64 20, !6, i64 24}
!53 = !{!52, !6, i64 16}
!54 = !{!52, !6, i64 0}
!55 = !{!48, !6, i64 112}
!56 = distinct !{!56, !19}
!57 = distinct !{!57, !19}
!58 = distinct !{!58, !19}
!59 = distinct !{!59, !19}
!60 = distinct !{!60, !19}
!61 = distinct !{!61, !19}


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