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

; Unoptimized IR (clang -disable-llvm-passes):
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%struct.AtomStr = type { ptr, ptr }
%struct.PropertyStr = type { [8 x i8], [2 x [16 x i8]], [8 x i8], i32, i32, i32, double, double, [3 x double], %struct.AtomSeqStr, ptr, ptr }
%struct.AtomSeqStr = type { i32, i32, i32 }
%struct.PepStr = type { i32, i32, i32, i32, double }
%struct.AAStr = type { [5 x i8], i32, i32, i32, i32, double }
%struct.DynamicStr = type { [4 x i32], [4 x double], [4 x double], %struct.HBStr, %struct.HBNeighborStr, %struct.InteractionEventStr }
%struct.HBStr = type { i32, i32, i8, i32 }
%struct.HBNeighborStr = type { [5 x i32], i32, i32 }
%struct.InteractionEventStr = type { i32, i64, i64, double, double, i32, i32 }

@.str.2 = external hidden unnamed_addr constant [71 x i8], align 1
@atom = external global ptr, align 8
@protein = external global ptr, align 8
@aminoacid = external global ptr, align 8
@.str.129 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.161 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.184 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.185 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.186 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.187 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.188 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.189 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.190 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.191 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.192 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.193 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.194 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.195 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.196 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.197 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.198 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.199 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.200 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.201 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.202 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.203 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.204 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.205 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.206 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.207 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.208 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.209 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.210 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.211 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.212 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.213 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.214 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.215 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.216 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.217 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.218 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.219 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.220 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.221 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.222 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.223 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.224 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.225 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.226 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.227 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.228 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.229 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.230 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.231 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.232 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.233 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.234 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.235 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.236 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.237 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.238 = external hidden unnamed_addr constant [55 x i8], align 1

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

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

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @HBNeighborAssign(i32 noundef %0) #4 {
  %2 = alloca i32, align 4
  %3 = alloca i32, align 4
  store i32 %0, ptr %2, align 4, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 4, ptr %3) #5
  %4 = load ptr, ptr @aminoacid, align 8, !tbaa !9
  %5 = load ptr, ptr @protein, align 8, !tbaa !9
  %6 = load ptr, ptr @atom, align 8, !tbaa !9
  %7 = load i32, ptr %2, align 4, !tbaa !5
  %8 = sext i32 %7 to i64
  %9 = getelementptr inbounds %struct.AtomStr, ptr %6, i64 %8
  %10 = getelementptr inbounds %struct.AtomStr, ptr %9, i32 0, i32 0
  %11 = load ptr, ptr %10, align 8, !tbaa !11
  %12 = getelementptr inbounds %struct.PropertyStr, ptr %11, i32 0, i32 9
  %13 = getelementptr inbounds %struct.AtomSeqStr, ptr %12, i32 0, i32 1
  %14 = load i32, ptr %13, align 4, !tbaa !13
  %15 = sub nsw i32 %14, 1
  %16 = sext i32 %15 to i64
  %17 = getelementptr inbounds %struct.PepStr, ptr %5, i64 %16
  %18 = getelementptr inbounds %struct.PepStr, ptr %17, i32 0, i32 3
  %19 = load i32, ptr %18, align 4, !tbaa !17
  %20 = load ptr, ptr @atom, align 8, !tbaa !9
  %21 = load i32, ptr %2, align 4, !tbaa !5
  %22 = sext i32 %21 to i64
  %23 = getelementptr inbounds %struct.AtomStr, ptr %20, i64 %22
  %24 = getelementptr inbounds %struct.AtomStr, ptr %23, i32 0, i32 0
  %25 = load ptr, ptr %24, align 8, !tbaa !11
  %26 = getelementptr inbounds %struct.PropertyStr, ptr %25, i32 0, i32 9
  %27 = getelementptr inbounds %struct.AtomSeqStr, ptr %26, i32 0, i32 2
  %28 = load i32, ptr %27, align 8, !tbaa !19
  %29 = add nsw i32 %19, %28
  %30 = sext i32 %29 to i64
  %31 = getelementptr inbounds %struct.AAStr, ptr %4, i64 %30
  %32 = getelementptr inbounds %struct.AAStr, ptr %31, i32 0, i32 3
  %33 = load i32, ptr %32, align 8, !tbaa !20
  %34 = add nsw i32 %33, 1
  store i32 %34, ptr %3, align 4, !tbaa !5
  %35 = load ptr, ptr @atom, align 8, !tbaa !9
  %36 = load i32, ptr %2, align 4, !tbaa !5
  %37 = sext i32 %36 to i64
  %38 = getelementptr inbounds %struct.AtomStr, ptr %35, i64 %37
  %39 = getelementptr inbounds %struct.AtomStr, ptr %38, i32 0, i32 0
  %40 = load ptr, ptr %39, align 8, !tbaa !11
  %41 = getelementptr inbounds %struct.PropertyStr, ptr %40, i32 0, i32 4
  %42 = load i32, ptr %41, align 4, !tbaa !22
  %43 = icmp eq i32 %42, 2
  br i1 %43, label %44, label %75

44:                                               ; preds = %1
  br label %45

45:                                               ; preds = %56, %44
  %46 = load ptr, ptr @atom, align 8, !tbaa !9
  %47 = load i32, ptr %3, align 4, !tbaa !5
  %48 = add nsw i32 %47, -1
  store i32 %48, ptr %3, align 4, !tbaa !5
  %49 = sext i32 %48 to i64
  %50 = getelementptr inbounds %struct.AtomStr, ptr %46, i64 %49
  %51 = getelementptr inbounds %struct.AtomStr, ptr %50, i32 0, i32 0
  %52 = load ptr, ptr %51, align 8, !tbaa !11
  %53 = getelementptr inbounds %struct.PropertyStr, ptr %52, i32 0, i32 4
  %54 = load i32, ptr %53, align 4, !tbaa !22
  %55 = icmp ne i32 %54, 18
  br i1 %55, label %56, label %57

56:                                               ; preds = %45
  br label %45, !llvm.loop !23

57:                                               ; preds = %45
  %58 = load i32, ptr %3, align 4, !tbaa !5
  %59 = load ptr, ptr @atom, align 8, !tbaa !9
  %60 = load i32, ptr %2, align 4, !tbaa !5
  %61 = sext i32 %60 to i64
  %62 = getelementptr inbounds %struct.AtomStr, ptr %59, i64 %61
  %63 = getelementptr inbounds %struct.AtomStr, ptr %62, i32 0, i32 1
  %64 = load ptr, ptr %63, align 8, !tbaa !25
  %65 = getelementptr inbounds %struct.DynamicStr, ptr %64, i32 0, i32 3
  %66 = getelementptr inbounds %struct.HBStr, ptr %65, i32 0, i32 1
  store i32 %58, ptr %66, align 4, !tbaa !26
  %67 = load ptr, ptr @atom, align 8, !tbaa !9
  %68 = load i32, ptr %2, align 4, !tbaa !5
  %69 = sext i32 %68 to i64
  %70 = getelementptr inbounds %struct.AtomStr, ptr %67, i64 %69
  %71 = getelementptr inbounds %struct.AtomStr, ptr %70, i32 0, i32 1
  %72 = load ptr, ptr %71, align 8, !tbaa !25
  %73 = getelementptr inbounds %struct.DynamicStr, ptr %72, i32 0, i32 3
  %74 = getelementptr inbounds %struct.HBStr, ptr %73, i32 0, i32 2
  store i8 68, ptr %74, align 8, !tbaa !32
  br label %1377

75:                                               ; preds = %1
  %76 = load ptr, ptr @atom, align 8, !tbaa !9
  %77 = load i32, ptr %2, align 4, !tbaa !5
  %78 = sext i32 %77 to i64
  %79 = getelementptr inbounds %struct.AtomStr, ptr %76, i64 %78
  %80 = getelementptr inbounds %struct.AtomStr, ptr %79, i32 0, i32 0
  %81 = load ptr, ptr %80, align 8, !tbaa !11
  %82 = getelementptr inbounds %struct.PropertyStr, ptr %81, i32 0, i32 4
  %83 = load i32, ptr %82, align 4, !tbaa !22
  %84 = icmp eq i32 %83, 26
  br i1 %84, label %85, label %116

85:                                               ; preds = %75
  br label %86

86:                                               ; preds = %97, %85
  %87 = load ptr, ptr @atom, align 8, !tbaa !9
  %88 = load i32, ptr %3, align 4, !tbaa !5
  %89 = add nsw i32 %88, -1
  store i32 %89, ptr %3, align 4, !tbaa !5
  %90 = sext i32 %89 to i64
  %91 = getelementptr inbounds %struct.AtomStr, ptr %87, i64 %90
  %92 = getelementptr inbounds %struct.AtomStr, ptr %91, i32 0, i32 0
  %93 = load ptr, ptr %92, align 8, !tbaa !11
  %94 = getelementptr inbounds %struct.PropertyStr, ptr %93, i32 0, i32 4
  %95 = load i32, ptr %94, align 4, !tbaa !22
  %96 = icmp ne i32 %95, 6
  br i1 %96, label %97, label %98

97:                                               ; preds = %86
  br label %86, !llvm.loop !33

98:                                               ; preds = %86
  %99 = load i32, ptr %3, align 4, !tbaa !5
  %100 = load ptr, ptr @atom, align 8, !tbaa !9
  %101 = load i32, ptr %2, align 4, !tbaa !5
  %102 = sext i32 %101 to i64
  %103 = getelementptr inbounds %struct.AtomStr, ptr %100, i64 %102
  %104 = getelementptr inbounds %struct.AtomStr, ptr %103, i32 0, i32 1
  %105 = load ptr, ptr %104, align 8, !tbaa !25
  %106 = getelementptr inbounds %struct.DynamicStr, ptr %105, i32 0, i32 3
  %107 = getelementptr inbounds %struct.HBStr, ptr %106, i32 0, i32 1
  store i32 %99, ptr %107, align 4, !tbaa !26
  %108 = load ptr, ptr @atom, align 8, !tbaa !9
  %109 = load i32, ptr %2, align 4, !tbaa !5
  %110 = sext i32 %109 to i64
  %111 = getelementptr inbounds %struct.AtomStr, ptr %108, i64 %110
  %112 = getelementptr inbounds %struct.AtomStr, ptr %111, i32 0, i32 1
  %113 = load ptr, ptr %112, align 8, !tbaa !25
  %114 = getelementptr inbounds %struct.DynamicStr, ptr %113, i32 0, i32 3
  %115 = getelementptr inbounds %struct.HBStr, ptr %114, i32 0, i32 2
  store i8 65, ptr %115, align 8, !tbaa !32
  br label %1376

116:                                              ; preds = %75
  %117 = load ptr, ptr @atom, align 8, !tbaa !9
  %118 = load i32, ptr %2, align 4, !tbaa !5
  %119 = sext i32 %118 to i64
  %120 = getelementptr inbounds %struct.AtomStr, ptr %117, i64 %119
  %121 = getelementptr inbounds %struct.AtomStr, ptr %120, i32 0, i32 0
  %122 = load ptr, ptr %121, align 8, !tbaa !11
  %123 = getelementptr inbounds %struct.PropertyStr, ptr %122, i32 0, i32 2
  %124 = getelementptr inbounds [8 x i8], ptr %123, i64 0, i64 0
  %125 = call i32 @strcmp(ptr noundef %124, ptr noundef @.str.184) #6
  %126 = icmp eq i32 %125, 0
  br i1 %126, label %127, label %259

127:                                              ; preds = %116
  %128 = load ptr, ptr @atom, align 8, !tbaa !9
  %129 = load i32, ptr %2, align 4, !tbaa !5
  %130 = sext i32 %129 to i64
  %131 = getelementptr inbounds %struct.AtomStr, ptr %128, i64 %130
  %132 = getelementptr inbounds %struct.AtomStr, ptr %131, i32 0, i32 0
  %133 = load ptr, ptr %132, align 8, !tbaa !11
  %134 = getelementptr inbounds %struct.PropertyStr, ptr %133, i32 0, i32 0
  %135 = getelementptr inbounds [8 x i8], ptr %134, i64 0, i64 0
  %136 = call i32 @strcmp(ptr noundef %135, ptr noundef @.str.185) #6
  %137 = icmp eq i32 %136, 0
  br i1 %137, label %138, label %170

138:                                              ; preds = %127
  br label %139

139:                                              ; preds = %151, %138
  %140 = load ptr, ptr @atom, align 8, !tbaa !9
  %141 = load i32, ptr %3, align 4, !tbaa !5
  %142 = add nsw i32 %141, -1
  store i32 %142, ptr %3, align 4, !tbaa !5
  %143 = sext i32 %142 to i64
  %144 = getelementptr inbounds %struct.AtomStr, ptr %140, i64 %143
  %145 = getelementptr inbounds %struct.AtomStr, ptr %144, i32 0, i32 0
  %146 = load ptr, ptr %145, align 8, !tbaa !11
  %147 = getelementptr inbounds %struct.PropertyStr, ptr %146, i32 0, i32 0
  %148 = getelementptr inbounds [8 x i8], ptr %147, i64 0, i64 0
  %149 = call i32 @strcmp(ptr noundef %148, ptr noundef @.str.186) #6
  %150 = icmp ne i32 %149, 0
  br i1 %150, label %151, label %152

151:                                              ; preds = %139
  br label %139, !llvm.loop !34

152:                                              ; preds = %139
  %153 = load i32, ptr %3, align 4, !tbaa !5
  %154 = load ptr, ptr @atom, align 8, !tbaa !9
  %155 = load i32, ptr %2, align 4, !tbaa !5
  %156 = sext i32 %155 to i64
  %157 = getelementptr inbounds %struct.AtomStr, ptr %154, i64 %156
  %158 = getelementptr inbounds %struct.AtomStr, ptr %157, i32 0, i32 1
  %159 = load ptr, ptr %158, align 8, !tbaa !25
  %160 = getelementptr inbounds %struct.DynamicStr, ptr %159, i32 0, i32 3
  %161 = getelementptr inbounds %struct.HBStr, ptr %160, i32 0, i32 1
  store i32 %153, ptr %161, align 4, !tbaa !26
  %162 = load ptr, ptr @atom, align 8, !tbaa !9
  %163 = load i32, ptr %2, align 4, !tbaa !5
  %164 = sext i32 %163 to i64
  %165 = getelementptr inbounds %struct.AtomStr, ptr %162, i64 %164
  %166 = getelementptr inbounds %struct.AtomStr, ptr %165, i32 0, i32 1
  %167 = load ptr, ptr %166, align 8, !tbaa !25
  %168 = getelementptr inbounds %struct.DynamicStr, ptr %167, i32 0, i32 3
  %169 = getelementptr inbounds %struct.HBStr, ptr %168, i32 0, i32 2
  store i8 68, ptr %169, align 8, !tbaa !32
  br label %258

170:                                              ; preds = %127
  %171 = load ptr, ptr @atom, align 8, !tbaa !9
  %172 = load i32, ptr %2, align 4, !tbaa !5
  %173 = sext i32 %172 to i64
  %174 = getelementptr inbounds %struct.AtomStr, ptr %171, i64 %173
  %175 = getelementptr inbounds %struct.AtomStr, ptr %174, i32 0, i32 0
  %176 = load ptr, ptr %175, align 8, !tbaa !11
  %177 = getelementptr inbounds %struct.PropertyStr, ptr %176, i32 0, i32 0
  %178 = getelementptr inbounds [8 x i8], ptr %177, i64 0, i64 0
  %179 = call i32 @strcmp(ptr noundef %178, ptr noundef @.str.187) #6
  %180 = icmp eq i32 %179, 0
  br i1 %180, label %181, label %213

181:                                              ; preds = %170
  br label %182

182:                                              ; preds = %194, %181
  %183 = load ptr, ptr @atom, align 8, !tbaa !9
  %184 = load i32, ptr %3, align 4, !tbaa !5
  %185 = add nsw i32 %184, -1
  store i32 %185, ptr %3, align 4, !tbaa !5
  %186 = sext i32 %185 to i64
  %187 = getelementptr inbounds %struct.AtomStr, ptr %183, i64 %186
  %188 = getelementptr inbounds %struct.AtomStr, ptr %187, i32 0, i32 0
  %189 = load ptr, ptr %188, align 8, !tbaa !11
  %190 = getelementptr inbounds %struct.PropertyStr, ptr %189, i32 0, i32 0
  %191 = getelementptr inbounds [8 x i8], ptr %190, i64 0, i64 0
  %192 = call i32 @strcmp(ptr noundef %191, ptr noundef @.str.188) #6
  %193 = icmp ne i32 %192, 0
  br i1 %193, label %194, label %195

194:                                              ; preds = %182
  br label %182, !llvm.loop !35

195:                                              ; preds = %182
  %196 = load i32, ptr %3, align 4, !tbaa !5
  %197 = load ptr, ptr @atom, align 8, !tbaa !9
  %198 = load i32, ptr %2, align 4, !tbaa !5
  %199 = sext i32 %198 to i64
  %200 = getelementptr inbounds %struct.AtomStr, ptr %197, i64 %199
  %201 = getelementptr inbounds %struct.AtomStr, ptr %200, i32 0, i32 1
  %202 = load ptr, ptr %201, align 8, !tbaa !25
  %203 = getelementptr inbounds %struct.DynamicStr, ptr %202, i32 0, i32 3
  %204 = getelementptr inbounds %struct.HBStr, ptr %203, i32 0, i32 1
  store i32 %196, ptr %204, align 4, !tbaa !26
  %205 = load ptr, ptr @atom, align 8, !tbaa !9
  %206 = load i32, ptr %2, align 4, !tbaa !5
  %207 = sext i32 %206 to i64
  %208 = getelementptr inbounds %struct.AtomStr, ptr %205, i64 %207
  %209 = getelementptr inbounds %struct.AtomStr, ptr %208, i32 0, i32 1
  %210 = load ptr, ptr %209, align 8, !tbaa !25
  %211 = getelementptr inbounds %struct.DynamicStr, ptr %210, i32 0, i32 3
  %212 = getelementptr inbounds %struct.HBStr, ptr %211, i32 0, i32 2
  store i8 68, ptr %212, align 8, !tbaa !32
  br label %257

213:                                              ; preds = %170
  %214 = load ptr, ptr @atom, align 8, !tbaa !9
  %215 = load i32, ptr %2, align 4, !tbaa !5
  %216 = sext i32 %215 to i64
  %217 = getelementptr inbounds %struct.AtomStr, ptr %214, i64 %216
  %218 = getelementptr inbounds %struct.AtomStr, ptr %217, i32 0, i32 0
  %219 = load ptr, ptr %218, align 8, !tbaa !11
  %220 = getelementptr inbounds %struct.PropertyStr, ptr %219, i32 0, i32 0
  %221 = getelementptr inbounds [8 x i8], ptr %220, i64 0, i64 0
  %222 = call i32 @strcmp(ptr noundef %221, ptr noundef @.str.188) #6
  %223 = icmp eq i32 %222, 0
  br i1 %223, label %224, label %256

224:                                              ; preds = %213
  br label %225

225:                                              ; preds = %237, %224
  %226 = load ptr, ptr @atom, align 8, !tbaa !9
  %227 = load i32, ptr %3, align 4, !tbaa !5
  %228 = add nsw i32 %227, -1
  store i32 %228, ptr %3, align 4, !tbaa !5
  %229 = sext i32 %228 to i64
  %230 = getelementptr inbounds %struct.AtomStr, ptr %226, i64 %229
  %231 = getelementptr inbounds %struct.AtomStr, ptr %230, i32 0, i32 0
  %232 = load ptr, ptr %231, align 8, !tbaa !11
  %233 = getelementptr inbounds %struct.PropertyStr, ptr %232, i32 0, i32 0
  %234 = getelementptr inbounds [8 x i8], ptr %233, i64 0, i64 0
  %235 = call i32 @strcmp(ptr noundef %234, ptr noundef @.str.189) #6
  %236 = icmp ne i32 %235, 0
  br i1 %236, label %237, label %238

237:                                              ; preds = %225
  br label %225, !llvm.loop !36

238:                                              ; preds = %225
  %239 = load i32, ptr %3, align 4, !tbaa !5
  %240 = load ptr, ptr @atom, align 8, !tbaa !9
  %241 = load i32, ptr %2, align 4, !tbaa !5
  %242 = sext i32 %241 to i64
  %243 = getelementptr inbounds %struct.AtomStr, ptr %240, i64 %242
  %244 = getelementptr inbounds %struct.AtomStr, ptr %243, i32 0, i32 1
  %245 = load ptr, ptr %244, align 8, !tbaa !25
  %246 = getelementptr inbounds %struct.DynamicStr, ptr %245, i32 0, i32 3
  %247 = getelementptr inbounds %struct.HBStr, ptr %246, i32 0, i32 1
  store i32 %239, ptr %247, align 4, !tbaa !26
  %248 = load ptr, ptr @atom, align 8, !tbaa !9
  %249 = load i32, ptr %2, align 4, !tbaa !5
  %250 = sext i32 %249 to i64
  %251 = getelementptr inbounds %struct.AtomStr, ptr %248, i64 %250
  %252 = getelementptr inbounds %struct.AtomStr, ptr %251, i32 0, i32 1
  %253 = load ptr, ptr %252, align 8, !tbaa !25
  %254 = getelementptr inbounds %struct.DynamicStr, ptr %253, i32 0, i32 3
  %255 = getelementptr inbounds %struct.HBStr, ptr %254, i32 0, i32 2
  store i8 65, ptr %255, align 8, !tbaa !32
  br label %256

256:                                              ; preds = %238, %213
  br label %257

257:                                              ; preds = %256, %195
  br label %258

258:                                              ; preds = %257, %152
  br label %1375

259:                                              ; preds = %116
  %260 = load ptr, ptr @atom, align 8, !tbaa !9
  %261 = load i32, ptr %2, align 4, !tbaa !5
  %262 = sext i32 %261 to i64
  %263 = getelementptr inbounds %struct.AtomStr, ptr %260, i64 %262
  %264 = getelementptr inbounds %struct.AtomStr, ptr %263, i32 0, i32 0
  %265 = load ptr, ptr %264, align 8, !tbaa !11
  %266 = getelementptr inbounds %struct.PropertyStr, ptr %265, i32 0, i32 2
  %267 = getelementptr inbounds [8 x i8], ptr %266, i64 0, i64 0
  %268 = call i32 @strcmp(ptr noundef %267, ptr noundef @.str.190) #6
  %269 = icmp eq i32 %268, 0
  br i1 %269, label %270, label %358

270:                                              ; preds = %259
  %271 = load ptr, ptr @atom, align 8, !tbaa !9
  %272 = load i32, ptr %2, align 4, !tbaa !5
  %273 = sext i32 %272 to i64
  %274 = getelementptr inbounds %struct.AtomStr, ptr %271, i64 %273
  %275 = getelementptr inbounds %struct.AtomStr, ptr %274, i32 0, i32 0
  %276 = load ptr, ptr %275, align 8, !tbaa !11
  %277 = getelementptr inbounds %struct.PropertyStr, ptr %276, i32 0, i32 0
  %278 = getelementptr inbounds [8 x i8], ptr %277, i64 0, i64 0
  %279 = call i32 @strcmp(ptr noundef %278, ptr noundef @.str.191) #6
  %280 = icmp eq i32 %279, 0
  br i1 %280, label %281, label %313

281:                                              ; preds = %270
  br label %282

282:                                              ; preds = %294, %281
  %283 = load ptr, ptr @atom, align 8, !tbaa !9
  %284 = load i32, ptr %3, align 4, !tbaa !5
  %285 = add nsw i32 %284, -1
  store i32 %285, ptr %3, align 4, !tbaa !5
  %286 = sext i32 %285 to i64
  %287 = getelementptr inbounds %struct.AtomStr, ptr %283, i64 %286
  %288 = getelementptr inbounds %struct.AtomStr, ptr %287, i32 0, i32 0
  %289 = load ptr, ptr %288, align 8, !tbaa !11
  %290 = getelementptr inbounds %struct.PropertyStr, ptr %289, i32 0, i32 0
  %291 = getelementptr inbounds [8 x i8], ptr %290, i64 0, i64 0
  %292 = call i32 @strcmp(ptr noundef %291, ptr noundef @.str.192) #6
  %293 = icmp ne i32 %292, 0
  br i1 %293, label %294, label %295

294:                                              ; preds = %282
  br label %282, !llvm.loop !37

295:                                              ; preds = %282
  %296 = load i32, ptr %3, align 4, !tbaa !5
  %297 = load ptr, ptr @atom, align 8, !tbaa !9
  %298 = load i32, ptr %2, align 4, !tbaa !5
  %299 = sext i32 %298 to i64
  %300 = getelementptr inbounds %struct.AtomStr, ptr %297, i64 %299
  %301 = getelementptr inbounds %struct.AtomStr, ptr %300, i32 0, i32 1
  %302 = load ptr, ptr %301, align 8, !tbaa !25
  %303 = getelementptr inbounds %struct.DynamicStr, ptr %302, i32 0, i32 3
  %304 = getelementptr inbounds %struct.HBStr, ptr %303, i32 0, i32 1
  store i32 %296, ptr %304, align 4, !tbaa !26
  %305 = load ptr, ptr @atom, align 8, !tbaa !9
  %306 = load i32, ptr %2, align 4, !tbaa !5
  %307 = sext i32 %306 to i64
  %308 = getelementptr inbounds %struct.AtomStr, ptr %305, i64 %307
  %309 = getelementptr inbounds %struct.AtomStr, ptr %308, i32 0, i32 1
  %310 = load ptr, ptr %309, align 8, !tbaa !25
  %311 = getelementptr inbounds %struct.DynamicStr, ptr %310, i32 0, i32 3
  %312 = getelementptr inbounds %struct.HBStr, ptr %311, i32 0, i32 2
  store i8 68, ptr %312, align 8, !tbaa !32
  br label %357

313:                                              ; preds = %270
  %314 = load ptr, ptr @atom, align 8, !tbaa !9
  %315 = load i32, ptr %2, align 4, !tbaa !5
  %316 = sext i32 %315 to i64
  %317 = getelementptr inbounds %struct.AtomStr, ptr %314, i64 %316
  %318 = getelementptr inbounds %struct.AtomStr, ptr %317, i32 0, i32 0
  %319 = load ptr, ptr %318, align 8, !tbaa !11
  %320 = getelementptr inbounds %struct.PropertyStr, ptr %319, i32 0, i32 0
  %321 = getelementptr inbounds [8 x i8], ptr %320, i64 0, i64 0
  %322 = call i32 @strcmp(ptr noundef %321, ptr noundef @.str.192) #6
  %323 = icmp eq i32 %322, 0
  br i1 %323, label %324, label %356

324:                                              ; preds = %313
  br label %325

325:                                              ; preds = %337, %324
  %326 = load ptr, ptr @atom, align 8, !tbaa !9
  %327 = load i32, ptr %3, align 4, !tbaa !5
  %328 = add nsw i32 %327, -1
  store i32 %328, ptr %3, align 4, !tbaa !5
  %329 = sext i32 %328 to i64
  %330 = getelementptr inbounds %struct.AtomStr, ptr %326, i64 %329
  %331 = getelementptr inbounds %struct.AtomStr, ptr %330, i32 0, i32 0
  %332 = load ptr, ptr %331, align 8, !tbaa !11
  %333 = getelementptr inbounds %struct.PropertyStr, ptr %332, i32 0, i32 0
  %334 = getelementptr inbounds [8 x i8], ptr %333, i64 0, i64 0
  %335 = call i32 @strcmp(ptr noundef %334, ptr noundef @.str.193) #6
  %336 = icmp ne i32 %335, 0
  br i1 %336, label %337, label %338

337:                                              ; preds = %325
  br label %325, !llvm.loop !38

338:                                              ; preds = %325
  %339 = load i32, ptr %3, align 4, !tbaa !5
  %340 = load ptr, ptr @atom, align 8, !tbaa !9
  %341 = load i32, ptr %2, align 4, !tbaa !5
  %342 = sext i32 %341 to i64
  %343 = getelementptr inbounds %struct.AtomStr, ptr %340, i64 %342
  %344 = getelementptr inbounds %struct.AtomStr, ptr %343, i32 0, i32 1
  %345 = load ptr, ptr %344, align 8, !tbaa !25
  %346 = getelementptr inbounds %struct.DynamicStr, ptr %345, i32 0, i32 3
  %347 = getelementptr inbounds %struct.HBStr, ptr %346, i32 0, i32 1
  store i32 %339, ptr %347, align 4, !tbaa !26
  %348 = load ptr, ptr @atom, align 8, !tbaa !9
  %349 = load i32, ptr %2, align 4, !tbaa !5
  %350 = sext i32 %349 to i64
  %351 = getelementptr inbounds %struct.AtomStr, ptr %348, i64 %350
  %352 = getelementptr inbounds %struct.AtomStr, ptr %351, i32 0, i32 1
  %353 = load ptr, ptr %352, align 8, !tbaa !25
  %354 = getelementptr inbounds %struct.DynamicStr, ptr %353, i32 0, i32 3
  %355 = getelementptr inbounds %struct.HBStr, ptr %354, i32 0, i32 2
  store i8 65, ptr %355, align 8, !tbaa !32
  br label %356

356:                                              ; preds = %338, %313
  br label %357

357:                                              ; preds = %356, %295
  br label %1374

358:                                              ; preds = %259
  %359 = load ptr, ptr @atom, align 8, !tbaa !9
  %360 = load i32, ptr %2, align 4, !tbaa !5
  %361 = sext i32 %360 to i64
  %362 = getelementptr inbounds %struct.AtomStr, ptr %359, i64 %361
  %363 = getelementptr inbounds %struct.AtomStr, ptr %362, i32 0, i32 0
  %364 = load ptr, ptr %363, align 8, !tbaa !11
  %365 = getelementptr inbounds %struct.PropertyStr, ptr %364, i32 0, i32 2
  %366 = getelementptr inbounds [8 x i8], ptr %365, i64 0, i64 0
  %367 = call i32 @strcmp(ptr noundef %366, ptr noundef @.str.194) #6
  %368 = icmp eq i32 %367, 0
  br i1 %368, label %369, label %413

369:                                              ; preds = %358
  %370 = load ptr, ptr @atom, align 8, !tbaa !9
  %371 = load i32, ptr %2, align 4, !tbaa !5
  %372 = sext i32 %371 to i64
  %373 = getelementptr inbounds %struct.AtomStr, ptr %370, i64 %372
  %374 = getelementptr inbounds %struct.AtomStr, ptr %373, i32 0, i32 0
  %375 = load ptr, ptr %374, align 8, !tbaa !11
  %376 = getelementptr inbounds %struct.PropertyStr, ptr %375, i32 0, i32 0
  %377 = getelementptr inbounds [8 x i8], ptr %376, i64 0, i64 0
  %378 = call i32 @strcmp(ptr noundef %377, ptr noundef @.str.195) #6
  %379 = icmp eq i32 %378, 0
  br i1 %379, label %380, label %412

380:                                              ; preds = %369
  br label %381

381:                                              ; preds = %393, %380
  %382 = load ptr, ptr @atom, align 8, !tbaa !9
  %383 = load i32, ptr %3, align 4, !tbaa !5
  %384 = add nsw i32 %383, -1
  store i32 %384, ptr %3, align 4, !tbaa !5
  %385 = sext i32 %384 to i64
  %386 = getelementptr inbounds %struct.AtomStr, ptr %382, i64 %385
  %387 = getelementptr inbounds %struct.AtomStr, ptr %386, i32 0, i32 0
  %388 = load ptr, ptr %387, align 8, !tbaa !11
  %389 = getelementptr inbounds %struct.PropertyStr, ptr %388, i32 0, i32 0
  %390 = getelementptr inbounds [8 x i8], ptr %389, i64 0, i64 0
  %391 = call i32 @strcmp(ptr noundef %390, ptr noundef @.str.196) #6
  %392 = icmp ne i32 %391, 0
  br i1 %392, label %393, label %394

393:                                              ; preds = %381
  br label %381, !llvm.loop !39

394:                                              ; preds = %381
  %395 = load i32, ptr %3, align 4, !tbaa !5
  %396 = load ptr, ptr @atom, align 8, !tbaa !9
  %397 = load i32, ptr %2, align 4, !tbaa !5
  %398 = sext i32 %397 to i64
  %399 = getelementptr inbounds %struct.AtomStr, ptr %396, i64 %398
  %400 = getelementptr inbounds %struct.AtomStr, ptr %399, i32 0, i32 1
  %401 = load ptr, ptr %400, align 8, !tbaa !25
  %402 = getelementptr inbounds %struct.DynamicStr, ptr %401, i32 0, i32 3
  %403 = getelementptr inbounds %struct.HBStr, ptr %402, i32 0, i32 1
  store i32 %395, ptr %403, align 4, !tbaa !26
  %404 = load ptr, ptr @atom, align 8, !tbaa !9
  %405 = load i32, ptr %2, align 4, !tbaa !5
  %406 = sext i32 %405 to i64
  %407 = getelementptr inbounds %struct.AtomStr, ptr %404, i64 %406
  %408 = getelementptr inbounds %struct.AtomStr, ptr %407, i32 0, i32 1
  %409 = load ptr, ptr %408, align 8, !tbaa !25
  %410 = getelementptr inbounds %struct.DynamicStr, ptr %409, i32 0, i32 3
  %411 = getelementptr inbounds %struct.HBStr, ptr %410, i32 0, i32 2
  store i8 68, ptr %411, align 8, !tbaa !32
  br label %412

412:                                              ; preds = %394, %369
  br label %1373

413:                                              ; preds = %358
  %414 = load ptr, ptr @atom, align 8, !tbaa !9
  %415 = load i32, ptr %2, align 4, !tbaa !5
  %416 = sext i32 %415 to i64
  %417 = getelementptr inbounds %struct.AtomStr, ptr %414, i64 %416
  %418 = getelementptr inbounds %struct.AtomStr, ptr %417, i32 0, i32 0
  %419 = load ptr, ptr %418, align 8, !tbaa !11
  %420 = getelementptr inbounds %struct.PropertyStr, ptr %419, i32 0, i32 2
  %421 = getelementptr inbounds [8 x i8], ptr %420, i64 0, i64 0
  %422 = call i32 @strcmp(ptr noundef %421, ptr noundef @.str.197) #6
  %423 = icmp eq i32 %422, 0
  br i1 %423, label %424, label %512

424:                                              ; preds = %413
  %425 = load ptr, ptr @atom, align 8, !tbaa !9
  %426 = load i32, ptr %2, align 4, !tbaa !5
  %427 = sext i32 %426 to i64
  %428 = getelementptr inbounds %struct.AtomStr, ptr %425, i64 %427
  %429 = getelementptr inbounds %struct.AtomStr, ptr %428, i32 0, i32 0
  %430 = load ptr, ptr %429, align 8, !tbaa !11
  %431 = getelementptr inbounds %struct.PropertyStr, ptr %430, i32 0, i32 0
  %432 = getelementptr inbounds [8 x i8], ptr %431, i64 0, i64 0
  %433 = call i32 @strcmp(ptr noundef %432, ptr noundef @.str.198) #6
  %434 = icmp eq i32 %433, 0
  br i1 %434, label %435, label %467

435:                                              ; preds = %424
  br label %436

436:                                              ; preds = %448, %435
  %437 = load ptr, ptr @atom, align 8, !tbaa !9
  %438 = load i32, ptr %3, align 4, !tbaa !5
  %439 = add nsw i32 %438, -1
  store i32 %439, ptr %3, align 4, !tbaa !5
  %440 = sext i32 %439 to i64
  %441 = getelementptr inbounds %struct.AtomStr, ptr %437, i64 %440
  %442 = getelementptr inbounds %struct.AtomStr, ptr %441, i32 0, i32 0
  %443 = load ptr, ptr %442, align 8, !tbaa !11
  %444 = getelementptr inbounds %struct.PropertyStr, ptr %443, i32 0, i32 0
  %445 = getelementptr inbounds [8 x i8], ptr %444, i64 0, i64 0
  %446 = call i32 @strcmp(ptr noundef %445, ptr noundef @.str.199) #6
  %447 = icmp ne i32 %446, 0
  br i1 %447, label %448, label %449

448:                                              ; preds = %436
  br label %436, !llvm.loop !40

449:                                              ; preds = %436
  %450 = load i32, ptr %3, align 4, !tbaa !5
  %451 = load ptr, ptr @atom, align 8, !tbaa !9
  %452 = load i32, ptr %2, align 4, !tbaa !5
  %453 = sext i32 %452 to i64
  %454 = getelementptr inbounds %struct.AtomStr, ptr %451, i64 %453
  %455 = getelementptr inbounds %struct.AtomStr, ptr %454, i32 0, i32 1
  %456 = load ptr, ptr %455, align 8, !tbaa !25
  %457 = getelementptr inbounds %struct.DynamicStr, ptr %456, i32 0, i32 3
  %458 = getelementptr inbounds %struct.HBStr, ptr %457, i32 0, i32 1
  store i32 %450, ptr %458, align 4, !tbaa !26
  %459 = load ptr, ptr @atom, align 8, !tbaa !9
  %460 = load i32, ptr %2, align 4, !tbaa !5
  %461 = sext i32 %460 to i64
  %462 = getelementptr inbounds %struct.AtomStr, ptr %459, i64 %461
  %463 = getelementptr inbounds %struct.AtomStr, ptr %462, i32 0, i32 1
  %464 = load ptr, ptr %463, align 8, !tbaa !25
  %465 = getelementptr inbounds %struct.DynamicStr, ptr %464, i32 0, i32 3
  %466 = getelementptr inbounds %struct.HBStr, ptr %465, i32 0, i32 2
  store i8 68, ptr %466, align 8, !tbaa !32
  br label %511

467:                                              ; preds = %424
  %468 = load ptr, ptr @atom, align 8, !tbaa !9
  %469 = load i32, ptr %2, align 4, !tbaa !5
  %470 = sext i32 %469 to i64
  %471 = getelementptr inbounds %struct.AtomStr, ptr %468, i64 %470
  %472 = getelementptr inbounds %struct.AtomStr, ptr %471, i32 0, i32 0
  %473 = load ptr, ptr %472, align 8, !tbaa !11
  %474 = getelementptr inbounds %struct.PropertyStr, ptr %473, i32 0, i32 0
  %475 = getelementptr inbounds [8 x i8], ptr %474, i64 0, i64 0
  %476 = call i32 @strcmp(ptr noundef %475, ptr noundef @.str.199) #6
  %477 = icmp eq i32 %476, 0
  br i1 %477, label %478, label %510

478:                                              ; preds = %467
  br label %479

479:                                              ; preds = %491, %478
  %480 = load ptr, ptr @atom, align 8, !tbaa !9
  %481 = load i32, ptr %3, align 4, !tbaa !5
  %482 = add nsw i32 %481, -1
  store i32 %482, ptr %3, align 4, !tbaa !5
  %483 = sext i32 %482 to i64
  %484 = getelementptr inbounds %struct.AtomStr, ptr %480, i64 %483
  %485 = getelementptr inbounds %struct.AtomStr, ptr %484, i32 0, i32 0
  %486 = load ptr, ptr %485, align 8, !tbaa !11
  %487 = getelementptr inbounds %struct.PropertyStr, ptr %486, i32 0, i32 0
  %488 = getelementptr inbounds [8 x i8], ptr %487, i64 0, i64 0
  %489 = call i32 @strcmp(ptr noundef %488, ptr noundef @.str.161) #6
  %490 = icmp ne i32 %489, 0
  br i1 %490, label %491, label %492

491:                                              ; preds = %479
  br label %479, !llvm.loop !41

492:                                              ; preds = %479
  %493 = load i32, ptr %3, align 4, !tbaa !5
  %494 = load ptr, ptr @atom, align 8, !tbaa !9
  %495 = load i32, ptr %2, align 4, !tbaa !5
  %496 = sext i32 %495 to i64
  %497 = getelementptr inbounds %struct.AtomStr, ptr %494, i64 %496
  %498 = getelementptr inbounds %struct.AtomStr, ptr %497, i32 0, i32 1
  %499 = load ptr, ptr %498, align 8, !tbaa !25
  %500 = getelementptr inbounds %struct.DynamicStr, ptr %499, i32 0, i32 3
  %501 = getelementptr inbounds %struct.HBStr, ptr %500, i32 0, i32 1
  store i32 %493, ptr %501, align 4, !tbaa !26
  %502 = load ptr, ptr @atom, align 8, !tbaa !9
  %503 = load i32, ptr %2, align 4, !tbaa !5
  %504 = sext i32 %503 to i64
  %505 = getelementptr inbounds %struct.AtomStr, ptr %502, i64 %504
  %506 = getelementptr inbounds %struct.AtomStr, ptr %505, i32 0, i32 1
  %507 = load ptr, ptr %506, align 8, !tbaa !25
  %508 = getelementptr inbounds %struct.DynamicStr, ptr %507, i32 0, i32 3
  %509 = getelementptr inbounds %struct.HBStr, ptr %508, i32 0, i32 2
  store i8 65, ptr %509, align 8, !tbaa !32
  br label %510

510:                                              ; preds = %492, %467
  br label %511

511:                                              ; preds = %510, %449
  br label %1372

512:                                              ; preds = %413
  %513 = load ptr, ptr @atom, align 8, !tbaa !9
  %514 = load i32, ptr %2, align 4, !tbaa !5
  %515 = sext i32 %514 to i64
  %516 = getelementptr inbounds %struct.AtomStr, ptr %513, i64 %515
  %517 = getelementptr inbounds %struct.AtomStr, ptr %516, i32 0, i32 0
  %518 = load ptr, ptr %517, align 8, !tbaa !11
  %519 = getelementptr inbounds %struct.PropertyStr, ptr %518, i32 0, i32 2
  %520 = getelementptr inbounds [8 x i8], ptr %519, i64 0, i64 0
  %521 = call i32 @strcmp(ptr noundef %520, ptr noundef @.str.200) #6
  %522 = icmp eq i32 %521, 0
  br i1 %522, label %523, label %611

523:                                              ; preds = %512
  %524 = load ptr, ptr @atom, align 8, !tbaa !9
  %525 = load i32, ptr %2, align 4, !tbaa !5
  %526 = sext i32 %525 to i64
  %527 = getelementptr inbounds %struct.AtomStr, ptr %524, i64 %526
  %528 = getelementptr inbounds %struct.AtomStr, ptr %527, i32 0, i32 0
  %529 = load ptr, ptr %528, align 8, !tbaa !11
  %530 = getelementptr inbounds %struct.PropertyStr, ptr %529, i32 0, i32 0
  %531 = getelementptr inbounds [8 x i8], ptr %530, i64 0, i64 0
  %532 = call i32 @strcmp(ptr noundef %531, ptr noundef @.str.201) #6
  %533 = icmp eq i32 %532, 0
  br i1 %533, label %534, label %566

534:                                              ; preds = %523
  br label %535

535:                                              ; preds = %547, %534
  %536 = load ptr, ptr @atom, align 8, !tbaa !9
  %537 = load i32, ptr %3, align 4, !tbaa !5
  %538 = add nsw i32 %537, -1
  store i32 %538, ptr %3, align 4, !tbaa !5
  %539 = sext i32 %538 to i64
  %540 = getelementptr inbounds %struct.AtomStr, ptr %536, i64 %539
  %541 = getelementptr inbounds %struct.AtomStr, ptr %540, i32 0, i32 0
  %542 = load ptr, ptr %541, align 8, !tbaa !11
  %543 = getelementptr inbounds %struct.PropertyStr, ptr %542, i32 0, i32 0
  %544 = getelementptr inbounds [8 x i8], ptr %543, i64 0, i64 0
  %545 = call i32 @strcmp(ptr noundef %544, ptr noundef @.str.202) #6
  %546 = icmp ne i32 %545, 0
  br i1 %546, label %547, label %548

547:                                              ; preds = %535
  br label %535, !llvm.loop !42

548:                                              ; preds = %535
  %549 = load i32, ptr %3, align 4, !tbaa !5
  %550 = load ptr, ptr @atom, align 8, !tbaa !9
  %551 = load i32, ptr %2, align 4, !tbaa !5
  %552 = sext i32 %551 to i64
  %553 = getelementptr inbounds %struct.AtomStr, ptr %550, i64 %552
  %554 = getelementptr inbounds %struct.AtomStr, ptr %553, i32 0, i32 1
  %555 = load ptr, ptr %554, align 8, !tbaa !25
  %556 = getelementptr inbounds %struct.DynamicStr, ptr %555, i32 0, i32 3
  %557 = getelementptr inbounds %struct.HBStr, ptr %556, i32 0, i32 1
  store i32 %549, ptr %557, align 4, !tbaa !26
  %558 = load ptr, ptr @atom, align 8, !tbaa !9
  %559 = load i32, ptr %2, align 4, !tbaa !5
  %560 = sext i32 %559 to i64
  %561 = getelementptr inbounds %struct.AtomStr, ptr %558, i64 %560
  %562 = getelementptr inbounds %struct.AtomStr, ptr %561, i32 0, i32 1
  %563 = load ptr, ptr %562, align 8, !tbaa !25
  %564 = getelementptr inbounds %struct.DynamicStr, ptr %563, i32 0, i32 3
  %565 = getelementptr inbounds %struct.HBStr, ptr %564, i32 0, i32 2
  store i8 68, ptr %565, align 8, !tbaa !32
  br label %610

566:                                              ; preds = %523
  %567 = load ptr, ptr @atom, align 8, !tbaa !9
  %568 = load i32, ptr %2, align 4, !tbaa !5
  %569 = sext i32 %568 to i64
  %570 = getelementptr inbounds %struct.AtomStr, ptr %567, i64 %569
  %571 = getelementptr inbounds %struct.AtomStr, ptr %570, i32 0, i32 0
  %572 = load ptr, ptr %571, align 8, !tbaa !11
  %573 = getelementptr inbounds %struct.PropertyStr, ptr %572, i32 0, i32 0
  %574 = getelementptr inbounds [8 x i8], ptr %573, i64 0, i64 0
  %575 = call i32 @strcmp(ptr noundef %574, ptr noundef @.str.202) #6
  %576 = icmp eq i32 %575, 0
  br i1 %576, label %577, label %609

577:                                              ; preds = %566
  br label %578

578:                                              ; preds = %590, %577
  %579 = load ptr, ptr @atom, align 8, !tbaa !9
  %580 = load i32, ptr %3, align 4, !tbaa !5
  %581 = add nsw i32 %580, -1
  store i32 %581, ptr %3, align 4, !tbaa !5
  %582 = sext i32 %581 to i64
  %583 = getelementptr inbounds %struct.AtomStr, ptr %579, i64 %582
  %584 = getelementptr inbounds %struct.AtomStr, ptr %583, i32 0, i32 0
  %585 = load ptr, ptr %584, align 8, !tbaa !11
  %586 = getelementptr inbounds %struct.PropertyStr, ptr %585, i32 0, i32 0
  %587 = getelementptr inbounds [8 x i8], ptr %586, i64 0, i64 0
  %588 = call i32 @strcmp(ptr noundef %587, ptr noundef @.str.161) #6
  %589 = icmp ne i32 %588, 0
  br i1 %589, label %590, label %591

590:                                              ; preds = %578
  br label %578, !llvm.loop !43

591:                                              ; preds = %578
  %592 = load i32, ptr %3, align 4, !tbaa !5
  %593 = load ptr, ptr @atom, align 8, !tbaa !9
  %594 = load i32, ptr %2, align 4, !tbaa !5
  %595 = sext i32 %594 to i64
  %596 = getelementptr inbounds %struct.AtomStr, ptr %593, i64 %595
  %597 = getelementptr inbounds %struct.AtomStr, ptr %596, i32 0, i32 1
  %598 = load ptr, ptr %597, align 8, !tbaa !25
  %599 = getelementptr inbounds %struct.DynamicStr, ptr %598, i32 0, i32 3
  %600 = getelementptr inbounds %struct.HBStr, ptr %599, i32 0, i32 1
  store i32 %592, ptr %600, align 4, !tbaa !26
  %601 = load ptr, ptr @atom, align 8, !tbaa !9
  %602 = load i32, ptr %2, align 4, !tbaa !5
  %603 = sext i32 %602 to i64
  %604 = getelementptr inbounds %struct.AtomStr, ptr %601, i64 %603
  %605 = getelementptr inbounds %struct.AtomStr, ptr %604, i32 0, i32 1
  %606 = load ptr, ptr %605, align 8, !tbaa !25
  %607 = getelementptr inbounds %struct.DynamicStr, ptr %606, i32 0, i32 3
  %608 = getelementptr inbounds %struct.HBStr, ptr %607, i32 0, i32 2
  store i8 65, ptr %608, align 8, !tbaa !32
  br label %609

609:                                              ; preds = %591, %566
  br label %610

610:                                              ; preds = %609, %548
  br label %1371

611:                                              ; preds = %512
  %612 = load ptr, ptr @atom, align 8, !tbaa !9
  %613 = load i32, ptr %2, align 4, !tbaa !5
  %614 = sext i32 %613 to i64
  %615 = getelementptr inbounds %struct.AtomStr, ptr %612, i64 %614
  %616 = getelementptr inbounds %struct.AtomStr, ptr %615, i32 0, i32 0
  %617 = load ptr, ptr %616, align 8, !tbaa !11
  %618 = getelementptr inbounds %struct.PropertyStr, ptr %617, i32 0, i32 2
  %619 = getelementptr inbounds [8 x i8], ptr %618, i64 0, i64 0
  %620 = call i32 @strcmp(ptr noundef %619, ptr noundef @.str.203) #6
  %621 = icmp eq i32 %620, 0
  br i1 %621, label %622, label %721

622:                                              ; preds = %611
  %623 = load ptr, ptr @atom, align 8, !tbaa !9
  %624 = load i32, ptr %2, align 4, !tbaa !5
  %625 = sext i32 %624 to i64
  %626 = getelementptr inbounds %struct.AtomStr, ptr %623, i64 %625
  %627 = getelementptr inbounds %struct.AtomStr, ptr %626, i32 0, i32 0
  %628 = load ptr, ptr %627, align 8, !tbaa !11
  %629 = getelementptr inbounds %struct.PropertyStr, ptr %628, i32 0, i32 0
  %630 = getelementptr inbounds [8 x i8], ptr %629, i64 0, i64 0
  %631 = call i32 @strcmp(ptr noundef %630, ptr noundef @.str.204) #6
  %632 = icmp eq i32 %631, 0
  br i1 %632, label %644, label %633

633:                                              ; preds = %622
  %634 = load ptr, ptr @atom, align 8, !tbaa !9
  %635 = load i32, ptr %2, align 4, !tbaa !5
  %636 = sext i32 %635 to i64
  %637 = getelementptr inbounds %struct.AtomStr, ptr %634, i64 %636
  %638 = getelementptr inbounds %struct.AtomStr, ptr %637, i32 0, i32 0
  %639 = load ptr, ptr %638, align 8, !tbaa !11
  %640 = getelementptr inbounds %struct.PropertyStr, ptr %639, i32 0, i32 0
  %641 = getelementptr inbounds [8 x i8], ptr %640, i64 0, i64 0
  %642 = call i32 @strcmp(ptr noundef %641, ptr noundef @.str.205) #6
  %643 = icmp eq i32 %642, 0
  br i1 %643, label %644, label %676

644:                                              ; preds = %633, %622
  br label %645

645:                                              ; preds = %657, %644
  %646 = load ptr, ptr @atom, align 8, !tbaa !9
  %647 = load i32, ptr %3, align 4, !tbaa !5
  %648 = add nsw i32 %647, -1
  store i32 %648, ptr %3, align 4, !tbaa !5
  %649 = sext i32 %648 to i64
  %650 = getelementptr inbounds %struct.AtomStr, ptr %646, i64 %649
  %651 = getelementptr inbounds %struct.AtomStr, ptr %650, i32 0, i32 0
  %652 = load ptr, ptr %651, align 8, !tbaa !11
  %653 = getelementptr inbounds %struct.PropertyStr, ptr %652, i32 0, i32 0
  %654 = getelementptr inbounds [8 x i8], ptr %653, i64 0, i64 0
  %655 = call i32 @strcmp(ptr noundef %654, ptr noundef @.str.206) #6
  %656 = icmp ne i32 %655, 0
  br i1 %656, label %657, label %658

657:                                              ; preds = %645
  br label %645, !llvm.loop !44

658:                                              ; preds = %645
  %659 = load i32, ptr %3, align 4, !tbaa !5
  %660 = load ptr, ptr @atom, align 8, !tbaa !9
  %661 = load i32, ptr %2, align 4, !tbaa !5
  %662 = sext i32 %661 to i64
  %663 = getelementptr inbounds %struct.AtomStr, ptr %660, i64 %662
  %664 = getelementptr inbounds %struct.AtomStr, ptr %663, i32 0, i32 1
  %665 = load ptr, ptr %664, align 8, !tbaa !25
  %666 = getelementptr inbounds %struct.DynamicStr, ptr %665, i32 0, i32 3
  %667 = getelementptr inbounds %struct.HBStr, ptr %666, i32 0, i32 1
  store i32 %659, ptr %667, align 4, !tbaa !26
  %668 = load ptr, ptr @atom, align 8, !tbaa !9
  %669 = load i32, ptr %2, align 4, !tbaa !5
  %670 = sext i32 %669 to i64
  %671 = getelementptr inbounds %struct.AtomStr, ptr %668, i64 %670
  %672 = getelementptr inbounds %struct.AtomStr, ptr %671, i32 0, i32 1
  %673 = load ptr, ptr %672, align 8, !tbaa !25
  %674 = getelementptr inbounds %struct.DynamicStr, ptr %673, i32 0, i32 3
  %675 = getelementptr inbounds %struct.HBStr, ptr %674, i32 0, i32 2
  store i8 68, ptr %675, align 8, !tbaa !32
  br label %720

676:                                              ; preds = %633
  %677 = load ptr, ptr @atom, align 8, !tbaa !9
  %678 = load i32, ptr %2, align 4, !tbaa !5
  %679 = sext i32 %678 to i64
  %680 = getelementptr inbounds %struct.AtomStr, ptr %677, i64 %679
  %681 = getelementptr inbounds %struct.AtomStr, ptr %680, i32 0, i32 0
  %682 = load ptr, ptr %681, align 8, !tbaa !11
  %683 = getelementptr inbounds %struct.PropertyStr, ptr %682, i32 0, i32 0
  %684 = getelementptr inbounds [8 x i8], ptr %683, i64 0, i64 0
  %685 = call i32 @strcmp(ptr noundef %684, ptr noundef @.str.207) #6
  %686 = icmp eq i32 %685, 0
  br i1 %686, label %687, label %719

687:                                              ; preds = %676
  br label %688

688:                                              ; preds = %700, %687
  %689 = load ptr, ptr @atom, align 8, !tbaa !9
  %690 = load i32, ptr %3, align 4, !tbaa !5
  %691 = add nsw i32 %690, -1
  store i32 %691, ptr %3, align 4, !tbaa !5
  %692 = sext i32 %691 to i64
  %693 = getelementptr inbounds %struct.AtomStr, ptr %689, i64 %692
  %694 = getelementptr inbounds %struct.AtomStr, ptr %693, i32 0, i32 0
  %695 = load ptr, ptr %694, align 8, !tbaa !11
  %696 = getelementptr inbounds %struct.PropertyStr, ptr %695, i32 0, i32 0
  %697 = getelementptr inbounds [8 x i8], ptr %696, i64 0, i64 0
  %698 = call i32 @strcmp(ptr noundef %697, ptr noundef @.str.208) #6
  %699 = icmp ne i32 %698, 0
  br i1 %699, label %700, label %701

700:                                              ; preds = %688
  br label %688, !llvm.loop !45

701:                                              ; preds = %688
  %702 = load i32, ptr %3, align 4, !tbaa !5
  %703 = load ptr, ptr @atom, align 8, !tbaa !9
  %704 = load i32, ptr %2, align 4, !tbaa !5
  %705 = sext i32 %704 to i64
  %706 = getelementptr inbounds %struct.AtomStr, ptr %703, i64 %705
  %707 = getelementptr inbounds %struct.AtomStr, ptr %706, i32 0, i32 1
  %708 = load ptr, ptr %707, align 8, !tbaa !25
  %709 = getelementptr inbounds %struct.DynamicStr, ptr %708, i32 0, i32 3
  %710 = getelementptr inbounds %struct.HBStr, ptr %709, i32 0, i32 1
  store i32 %702, ptr %710, align 4, !tbaa !26
  %711 = load ptr, ptr @atom, align 8, !tbaa !9
  %712 = load i32, ptr %2, align 4, !tbaa !5
  %713 = sext i32 %712 to i64
  %714 = getelementptr inbounds %struct.AtomStr, ptr %711, i64 %713
  %715 = getelementptr inbounds %struct.AtomStr, ptr %714, i32 0, i32 1
  %716 = load ptr, ptr %715, align 8, !tbaa !25
  %717 = getelementptr inbounds %struct.DynamicStr, ptr %716, i32 0, i32 3
  %718 = getelementptr inbounds %struct.HBStr, ptr %717, i32 0, i32 2
  store i8 65, ptr %718, align 8, !tbaa !32
  br label %719

719:                                              ; preds = %701, %676
  br label %720

720:                                              ; preds = %719, %658
  br label %1370

721:                                              ; preds = %611
  %722 = load ptr, ptr @atom, align 8, !tbaa !9
  %723 = load i32, ptr %2, align 4, !tbaa !5
  %724 = sext i32 %723 to i64
  %725 = getelementptr inbounds %struct.AtomStr, ptr %722, i64 %724
  %726 = getelementptr inbounds %struct.AtomStr, ptr %725, i32 0, i32 0
  %727 = load ptr, ptr %726, align 8, !tbaa !11
  %728 = getelementptr inbounds %struct.PropertyStr, ptr %727, i32 0, i32 2
  %729 = getelementptr inbounds [8 x i8], ptr %728, i64 0, i64 0
  %730 = call i32 @strcmp(ptr noundef %729, ptr noundef @.str.209) #6
  %731 = icmp eq i32 %730, 0
  br i1 %731, label %732, label %831

732:                                              ; preds = %721
  %733 = load ptr, ptr @atom, align 8, !tbaa !9
  %734 = load i32, ptr %2, align 4, !tbaa !5
  %735 = sext i32 %734 to i64
  %736 = getelementptr inbounds %struct.AtomStr, ptr %733, i64 %735
  %737 = getelementptr inbounds %struct.AtomStr, ptr %736, i32 0, i32 0
  %738 = load ptr, ptr %737, align 8, !tbaa !11
  %739 = getelementptr inbounds %struct.PropertyStr, ptr %738, i32 0, i32 0
  %740 = getelementptr inbounds [8 x i8], ptr %739, i64 0, i64 0
  %741 = call i32 @strcmp(ptr noundef %740, ptr noundef @.str.210) #6
  %742 = icmp eq i32 %741, 0
  br i1 %742, label %754, label %743

743:                                              ; preds = %732
  %744 = load ptr, ptr @atom, align 8, !tbaa !9
  %745 = load i32, ptr %2, align 4, !tbaa !5
  %746 = sext i32 %745 to i64
  %747 = getelementptr inbounds %struct.AtomStr, ptr %744, i64 %746
  %748 = getelementptr inbounds %struct.AtomStr, ptr %747, i32 0, i32 0
  %749 = load ptr, ptr %748, align 8, !tbaa !11
  %750 = getelementptr inbounds %struct.PropertyStr, ptr %749, i32 0, i32 0
  %751 = getelementptr inbounds [8 x i8], ptr %750, i64 0, i64 0
  %752 = call i32 @strcmp(ptr noundef %751, ptr noundef @.str.211) #6
  %753 = icmp eq i32 %752, 0
  br i1 %753, label %754, label %786

754:                                              ; preds = %743, %732
  br label %755

755:                                              ; preds = %767, %754
  %756 = load ptr, ptr @atom, align 8, !tbaa !9
  %757 = load i32, ptr %3, align 4, !tbaa !5
  %758 = add nsw i32 %757, -1
  store i32 %758, ptr %3, align 4, !tbaa !5
  %759 = sext i32 %758 to i64
  %760 = getelementptr inbounds %struct.AtomStr, ptr %756, i64 %759
  %761 = getelementptr inbounds %struct.AtomStr, ptr %760, i32 0, i32 0
  %762 = load ptr, ptr %761, align 8, !tbaa !11
  %763 = getelementptr inbounds %struct.PropertyStr, ptr %762, i32 0, i32 0
  %764 = getelementptr inbounds [8 x i8], ptr %763, i64 0, i64 0
  %765 = call i32 @strcmp(ptr noundef %764, ptr noundef @.str.188) #6
  %766 = icmp ne i32 %765, 0
  br i1 %766, label %767, label %768

767:                                              ; preds = %755
  br label %755, !llvm.loop !46

768:                                              ; preds = %755
  %769 = load i32, ptr %3, align 4, !tbaa !5
  %770 = load ptr, ptr @atom, align 8, !tbaa !9
  %771 = load i32, ptr %2, align 4, !tbaa !5
  %772 = sext i32 %771 to i64
  %773 = getelementptr inbounds %struct.AtomStr, ptr %770, i64 %772
  %774 = getelementptr inbounds %struct.AtomStr, ptr %773, i32 0, i32 1
  %775 = load ptr, ptr %774, align 8, !tbaa !25
  %776 = getelementptr inbounds %struct.DynamicStr, ptr %775, i32 0, i32 3
  %777 = getelementptr inbounds %struct.HBStr, ptr %776, i32 0, i32 1
  store i32 %769, ptr %777, align 4, !tbaa !26
  %778 = load ptr, ptr @atom, align 8, !tbaa !9
  %779 = load i32, ptr %2, align 4, !tbaa !5
  %780 = sext i32 %779 to i64
  %781 = getelementptr inbounds %struct.AtomStr, ptr %778, i64 %780
  %782 = getelementptr inbounds %struct.AtomStr, ptr %781, i32 0, i32 1
  %783 = load ptr, ptr %782, align 8, !tbaa !25
  %784 = getelementptr inbounds %struct.DynamicStr, ptr %783, i32 0, i32 3
  %785 = getelementptr inbounds %struct.HBStr, ptr %784, i32 0, i32 2
  store i8 68, ptr %785, align 8, !tbaa !32
  br label %830

786:                                              ; preds = %743
  %787 = load ptr, ptr @atom, align 8, !tbaa !9
  %788 = load i32, ptr %2, align 4, !tbaa !5
  %789 = sext i32 %788 to i64
  %790 = getelementptr inbounds %struct.AtomStr, ptr %787, i64 %789
  %791 = getelementptr inbounds %struct.AtomStr, ptr %790, i32 0, i32 0
  %792 = load ptr, ptr %791, align 8, !tbaa !11
  %793 = getelementptr inbounds %struct.PropertyStr, ptr %792, i32 0, i32 0
  %794 = getelementptr inbounds [8 x i8], ptr %793, i64 0, i64 0
  %795 = call i32 @strcmp(ptr noundef %794, ptr noundef @.str.212) #6
  %796 = icmp eq i32 %795, 0
  br i1 %796, label %797, label %829

797:                                              ; preds = %786
  br label %798

798:                                              ; preds = %810, %797
  %799 = load ptr, ptr @atom, align 8, !tbaa !9
  %800 = load i32, ptr %3, align 4, !tbaa !5
  %801 = add nsw i32 %800, -1
  store i32 %801, ptr %3, align 4, !tbaa !5
  %802 = sext i32 %801 to i64
  %803 = getelementptr inbounds %struct.AtomStr, ptr %799, i64 %802
  %804 = getelementptr inbounds %struct.AtomStr, ptr %803, i32 0, i32 0
  %805 = load ptr, ptr %804, align 8, !tbaa !11
  %806 = getelementptr inbounds %struct.PropertyStr, ptr %805, i32 0, i32 0
  %807 = getelementptr inbounds [8 x i8], ptr %806, i64 0, i64 0
  %808 = call i32 @strcmp(ptr noundef %807, ptr noundef @.str.213) #6
  %809 = icmp ne i32 %808, 0
  br i1 %809, label %810, label %811

810:                                              ; preds = %798
  br label %798, !llvm.loop !47

811:                                              ; preds = %798
  %812 = load i32, ptr %3, align 4, !tbaa !5
  %813 = load ptr, ptr @atom, align 8, !tbaa !9
  %814 = load i32, ptr %2, align 4, !tbaa !5
  %815 = sext i32 %814 to i64
  %816 = getelementptr inbounds %struct.AtomStr, ptr %813, i64 %815
  %817 = getelementptr inbounds %struct.AtomStr, ptr %816, i32 0, i32 1
  %818 = load ptr, ptr %817, align 8, !tbaa !25
  %819 = getelementptr inbounds %struct.DynamicStr, ptr %818, i32 0, i32 3
  %820 = getelementptr inbounds %struct.HBStr, ptr %819, i32 0, i32 1
  store i32 %812, ptr %820, align 4, !tbaa !26
  %821 = load ptr, ptr @atom, align 8, !tbaa !9
  %822 = load i32, ptr %2, align 4, !tbaa !5
  %823 = sext i32 %822 to i64
  %824 = getelementptr inbounds %struct.AtomStr, ptr %821, i64 %823
  %825 = getelementptr inbounds %struct.AtomStr, ptr %824, i32 0, i32 1
  %826 = load ptr, ptr %825, align 8, !tbaa !25
  %827 = getelementptr inbounds %struct.DynamicStr, ptr %826, i32 0, i32 3
  %828 = getelementptr inbounds %struct.HBStr, ptr %827, i32 0, i32 2
  store i8 65, ptr %828, align 8, !tbaa !32
  br label %829

829:                                              ; preds = %811, %786
  br label %830

830:                                              ; preds = %829, %768
  br label %1369

831:                                              ; preds = %721
  %832 = load ptr, ptr @atom, align 8, !tbaa !9
  %833 = load i32, ptr %2, 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 !11
  %838 = getelementptr inbounds %struct.PropertyStr, ptr %837, i32 0, i32 2
  %839 = getelementptr inbounds [8 x i8], ptr %838, i64 0, i64 0
  %840 = call i32 @strcmp(ptr noundef %839, ptr noundef @.str.214) #6
  %841 = icmp eq i32 %840, 0
  br i1 %841, label %842, label %908

842:                                              ; preds = %831
  %843 = load ptr, ptr @atom, align 8, !tbaa !9
  %844 = load i32, ptr %2, align 4, !tbaa !5
  %845 = sext i32 %844 to i64
  %846 = getelementptr inbounds %struct.AtomStr, ptr %843, i64 %845
  %847 = getelementptr inbounds %struct.AtomStr, ptr %846, i32 0, i32 0
  %848 = load ptr, ptr %847, align 8, !tbaa !11
  %849 = getelementptr inbounds %struct.PropertyStr, ptr %848, i32 0, i32 0
  %850 = getelementptr inbounds [8 x i8], ptr %849, i64 0, i64 0
  %851 = call i32 @strcmp(ptr noundef %850, ptr noundef @.str.215) #6
  %852 = icmp eq i32 %851, 0
  br i1 %852, label %875, label %853

853:                                              ; preds = %842
  %854 = load ptr, ptr @atom, align 8, !tbaa !9
  %855 = load i32, ptr %2, align 4, !tbaa !5
  %856 = sext i32 %855 to i64
  %857 = getelementptr inbounds %struct.AtomStr, ptr %854, i64 %856
  %858 = getelementptr inbounds %struct.AtomStr, ptr %857, i32 0, i32 0
  %859 = load ptr, ptr %858, align 8, !tbaa !11
  %860 = getelementptr inbounds %struct.PropertyStr, ptr %859, i32 0, i32 0
  %861 = getelementptr inbounds [8 x i8], ptr %860, i64 0, i64 0
  %862 = call i32 @strcmp(ptr noundef %861, ptr noundef @.str.216) #6
  %863 = icmp eq i32 %862, 0
  br i1 %863, label %875, label %864

864:                                              ; preds = %853
  %865 = load ptr, ptr @atom, align 8, !tbaa !9
  %866 = load i32, ptr %2, align 4, !tbaa !5
  %867 = sext i32 %866 to i64
  %868 = getelementptr inbounds %struct.AtomStr, ptr %865, i64 %867
  %869 = getelementptr inbounds %struct.AtomStr, ptr %868, i32 0, i32 0
  %870 = load ptr, ptr %869, align 8, !tbaa !11
  %871 = getelementptr inbounds %struct.PropertyStr, ptr %870, i32 0, i32 0
  %872 = getelementptr inbounds [8 x i8], ptr %871, i64 0, i64 0
  %873 = call i32 @strcmp(ptr noundef %872, ptr noundef @.str.217) #6
  %874 = icmp eq i32 %873, 0
  br i1 %874, label %875, label %907

875:                                              ; preds = %864, %853, %842
  br label %876

876:                                              ; preds = %888, %875
  %877 = load ptr, ptr @atom, align 8, !tbaa !9
  %878 = load i32, ptr %3, align 4, !tbaa !5
  %879 = add nsw i32 %878, -1
  store i32 %879, ptr %3, align 4, !tbaa !5
  %880 = sext i32 %879 to i64
  %881 = getelementptr inbounds %struct.AtomStr, ptr %877, i64 %880
  %882 = getelementptr inbounds %struct.AtomStr, ptr %881, i32 0, i32 0
  %883 = load ptr, ptr %882, align 8, !tbaa !11
  %884 = getelementptr inbounds %struct.PropertyStr, ptr %883, i32 0, i32 0
  %885 = getelementptr inbounds [8 x i8], ptr %884, i64 0, i64 0
  %886 = call i32 @strcmp(ptr noundef %885, ptr noundef @.str.218) #6
  %887 = icmp ne i32 %886, 0
  br i1 %887, label %888, label %889

888:                                              ; preds = %876
  br label %876, !llvm.loop !48

889:                                              ; preds = %876
  %890 = load i32, ptr %3, align 4, !tbaa !5
  %891 = load ptr, ptr @atom, align 8, !tbaa !9
  %892 = load i32, ptr %2, align 4, !tbaa !5
  %893 = sext i32 %892 to i64
  %894 = getelementptr inbounds %struct.AtomStr, ptr %891, i64 %893
  %895 = getelementptr inbounds %struct.AtomStr, ptr %894, i32 0, i32 1
  %896 = load ptr, ptr %895, align 8, !tbaa !25
  %897 = getelementptr inbounds %struct.DynamicStr, ptr %896, i32 0, i32 3
  %898 = getelementptr inbounds %struct.HBStr, ptr %897, i32 0, i32 1
  store i32 %890, ptr %898, align 4, !tbaa !26
  %899 = load ptr, ptr @atom, align 8, !tbaa !9
  %900 = load i32, ptr %2, align 4, !tbaa !5
  %901 = sext i32 %900 to i64
  %902 = getelementptr inbounds %struct.AtomStr, ptr %899, i64 %901
  %903 = getelementptr inbounds %struct.AtomStr, ptr %902, i32 0, i32 1
  %904 = load ptr, ptr %903, align 8, !tbaa !25
  %905 = getelementptr inbounds %struct.DynamicStr, ptr %904, i32 0, i32 3
  %906 = getelementptr inbounds %struct.HBStr, ptr %905, i32 0, i32 2
  store i8 68, ptr %906, align 8, !tbaa !32
  br label %907

907:                                              ; preds = %889, %864
  br label %1368

908:                                              ; preds = %831
  %909 = load ptr, ptr @atom, align 8, !tbaa !9
  %910 = load i32, ptr %2, align 4, !tbaa !5
  %911 = sext i32 %910 to i64
  %912 = getelementptr inbounds %struct.AtomStr, ptr %909, i64 %911
  %913 = getelementptr inbounds %struct.AtomStr, ptr %912, i32 0, i32 0
  %914 = load ptr, ptr %913, align 8, !tbaa !11
  %915 = getelementptr inbounds %struct.PropertyStr, ptr %914, i32 0, i32 2
  %916 = getelementptr inbounds [8 x i8], ptr %915, i64 0, i64 0
  %917 = call i32 @strcmp(ptr noundef %916, ptr noundef @.str.219) #6
  %918 = icmp eq i32 %917, 0
  br i1 %918, label %919, label %1073

919:                                              ; preds = %908
  %920 = load ptr, ptr @atom, align 8, !tbaa !9
  %921 = load i32, ptr %2, align 4, !tbaa !5
  %922 = sext i32 %921 to i64
  %923 = getelementptr inbounds %struct.AtomStr, ptr %920, i64 %922
  %924 = getelementptr inbounds %struct.AtomStr, ptr %923, i32 0, i32 0
  %925 = load ptr, ptr %924, align 8, !tbaa !11
  %926 = getelementptr inbounds %struct.PropertyStr, ptr %925, i32 0, i32 0
  %927 = getelementptr inbounds [8 x i8], ptr %926, i64 0, i64 0
  %928 = call i32 @strcmp(ptr noundef %927, ptr noundef @.str.220) #6
  %929 = icmp eq i32 %928, 0
  br i1 %929, label %930, label %962

930:                                              ; preds = %919
  br label %931

931:                                              ; preds = %943, %930
  %932 = load ptr, ptr @atom, align 8, !tbaa !9
  %933 = load i32, ptr %3, align 4, !tbaa !5
  %934 = add nsw i32 %933, -1
  store i32 %934, ptr %3, align 4, !tbaa !5
  %935 = sext i32 %934 to i64
  %936 = getelementptr inbounds %struct.AtomStr, ptr %932, i64 %935
  %937 = getelementptr inbounds %struct.AtomStr, ptr %936, i32 0, i32 0
  %938 = load ptr, ptr %937, align 8, !tbaa !11
  %939 = getelementptr inbounds %struct.PropertyStr, ptr %938, i32 0, i32 0
  %940 = getelementptr inbounds [8 x i8], ptr %939, i64 0, i64 0
  %941 = call i32 @strcmp(ptr noundef %940, ptr noundef @.str.221) #6
  %942 = icmp ne i32 %941, 0
  br i1 %942, label %943, label %944

943:                                              ; preds = %931
  br label %931, !llvm.loop !49

944:                                              ; preds = %931
  %945 = load i32, ptr %3, align 4, !tbaa !5
  %946 = load ptr, ptr @atom, align 8, !tbaa !9
  %947 = load i32, ptr %2, align 4, !tbaa !5
  %948 = sext i32 %947 to i64
  %949 = getelementptr inbounds %struct.AtomStr, ptr %946, i64 %948
  %950 = getelementptr inbounds %struct.AtomStr, ptr %949, i32 0, i32 1
  %951 = load ptr, ptr %950, align 8, !tbaa !25
  %952 = getelementptr inbounds %struct.DynamicStr, ptr %951, i32 0, i32 3
  %953 = getelementptr inbounds %struct.HBStr, ptr %952, i32 0, i32 1
  store i32 %945, ptr %953, align 4, !tbaa !26
  %954 = load ptr, ptr @atom, align 8, !tbaa !9
  %955 = load i32, ptr %2, align 4, !tbaa !5
  %956 = sext i32 %955 to i64
  %957 = getelementptr inbounds %struct.AtomStr, ptr %954, i64 %956
  %958 = getelementptr inbounds %struct.AtomStr, ptr %957, i32 0, i32 1
  %959 = load ptr, ptr %958, align 8, !tbaa !25
  %960 = getelementptr inbounds %struct.DynamicStr, ptr %959, i32 0, i32 3
  %961 = getelementptr inbounds %struct.HBStr, ptr %960, i32 0, i32 2
  store i8 68, ptr %961, align 8, !tbaa !32
  br label %1072

962:                                              ; preds = %919
  %963 = load ptr, ptr @atom, align 8, !tbaa !9
  %964 = load i32, ptr %2, align 4, !tbaa !5
  %965 = sext i32 %964 to i64
  %966 = getelementptr inbounds %struct.AtomStr, ptr %963, i64 %965
  %967 = getelementptr inbounds %struct.AtomStr, ptr %966, i32 0, i32 0
  %968 = load ptr, ptr %967, align 8, !tbaa !11
  %969 = getelementptr inbounds %struct.PropertyStr, ptr %968, i32 0, i32 0
  %970 = getelementptr inbounds [8 x i8], ptr %969, i64 0, i64 0
  %971 = call i32 @strcmp(ptr noundef %970, ptr noundef @.str.222) #6
  %972 = icmp eq i32 %971, 0
  br i1 %972, label %984, label %973

973:                                              ; preds = %962
  %974 = load ptr, ptr @atom, align 8, !tbaa !9
  %975 = load i32, ptr %2, align 4, !tbaa !5
  %976 = sext i32 %975 to i64
  %977 = getelementptr inbounds %struct.AtomStr, ptr %974, i64 %976
  %978 = getelementptr inbounds %struct.AtomStr, ptr %977, i32 0, i32 0
  %979 = load ptr, ptr %978, align 8, !tbaa !11
  %980 = getelementptr inbounds %struct.PropertyStr, ptr %979, i32 0, i32 0
  %981 = getelementptr inbounds [8 x i8], ptr %980, i64 0, i64 0
  %982 = call i32 @strcmp(ptr noundef %981, ptr noundef @.str.223) #6
  %983 = icmp eq i32 %982, 0
  br i1 %983, label %984, label %1016

984:                                              ; preds = %973, %962
  br label %985

985:                                              ; preds = %997, %984
  %986 = load ptr, ptr @atom, align 8, !tbaa !9
  %987 = load i32, ptr %3, align 4, !tbaa !5
  %988 = add nsw i32 %987, -1
  store i32 %988, ptr %3, align 4, !tbaa !5
  %989 = sext i32 %988 to i64
  %990 = getelementptr inbounds %struct.AtomStr, ptr %986, i64 %989
  %991 = getelementptr inbounds %struct.AtomStr, ptr %990, i32 0, i32 0
  %992 = load ptr, ptr %991, align 8, !tbaa !11
  %993 = getelementptr inbounds %struct.PropertyStr, ptr %992, i32 0, i32 0
  %994 = getelementptr inbounds [8 x i8], ptr %993, i64 0, i64 0
  %995 = call i32 @strcmp(ptr noundef %994, ptr noundef @.str.224) #6
  %996 = icmp ne i32 %995, 0
  br i1 %996, label %997, label %998

997:                                              ; preds = %985
  br label %985, !llvm.loop !50

998:                                              ; preds = %985
  %999 = load i32, ptr %3, align 4, !tbaa !5
  %1000 = load ptr, ptr @atom, align 8, !tbaa !9
  %1001 = load i32, ptr %2, align 4, !tbaa !5
  %1002 = sext i32 %1001 to i64
  %1003 = getelementptr inbounds %struct.AtomStr, ptr %1000, i64 %1002
  %1004 = getelementptr inbounds %struct.AtomStr, ptr %1003, i32 0, i32 1
  %1005 = load ptr, ptr %1004, align 8, !tbaa !25
  %1006 = getelementptr inbounds %struct.DynamicStr, ptr %1005, i32 0, i32 3
  %1007 = getelementptr inbounds %struct.HBStr, ptr %1006, i32 0, i32 1
  store i32 %999, ptr %1007, align 4, !tbaa !26
  %1008 = load ptr, ptr @atom, align 8, !tbaa !9
  %1009 = load i32, ptr %2, align 4, !tbaa !5
  %1010 = sext i32 %1009 to i64
  %1011 = getelementptr inbounds %struct.AtomStr, ptr %1008, i64 %1010
  %1012 = getelementptr inbounds %struct.AtomStr, ptr %1011, i32 0, i32 1
  %1013 = load ptr, ptr %1012, align 8, !tbaa !25
  %1014 = getelementptr inbounds %struct.DynamicStr, ptr %1013, i32 0, i32 3
  %1015 = getelementptr inbounds %struct.HBStr, ptr %1014, i32 0, i32 2
  store i8 68, ptr %1015, align 8, !tbaa !32
  br label %1071

1016:                                             ; preds = %973
  %1017 = load ptr, ptr @atom, align 8, !tbaa !9
  %1018 = load i32, ptr %2, align 4, !tbaa !5
  %1019 = sext i32 %1018 to i64
  %1020 = getelementptr inbounds %struct.AtomStr, ptr %1017, i64 %1019
  %1021 = getelementptr inbounds %struct.AtomStr, ptr %1020, i32 0, i32 0
  %1022 = load ptr, ptr %1021, align 8, !tbaa !11
  %1023 = getelementptr inbounds %struct.PropertyStr, ptr %1022, i32 0, i32 0
  %1024 = getelementptr inbounds [8 x i8], ptr %1023, i64 0, i64 0
  %1025 = call i32 @strcmp(ptr noundef %1024, ptr noundef @.str.225) #6
  %1026 = icmp eq i32 %1025, 0
  br i1 %1026, label %1038, label %1027

1027:                                             ; preds = %1016
  %1028 = load ptr, ptr @atom, align 8, !tbaa !9
  %1029 = load i32, ptr %2, align 4, !tbaa !5
  %1030 = sext i32 %1029 to i64
  %1031 = getelementptr inbounds %struct.AtomStr, ptr %1028, i64 %1030
  %1032 = getelementptr inbounds %struct.AtomStr, ptr %1031, i32 0, i32 0
  %1033 = load ptr, ptr %1032, align 8, !tbaa !11
  %1034 = getelementptr inbounds %struct.PropertyStr, ptr %1033, i32 0, i32 0
  %1035 = getelementptr inbounds [8 x i8], ptr %1034, i64 0, i64 0
  %1036 = call i32 @strcmp(ptr noundef %1035, ptr noundef @.str.226) #6
  %1037 = icmp eq i32 %1036, 0
  br i1 %1037, label %1038, label %1070

1038:                                             ; preds = %1027, %1016
  br label %1039

1039:                                             ; preds = %1051, %1038
  %1040 = load ptr, ptr @atom, align 8, !tbaa !9
  %1041 = load i32, ptr %3, align 4, !tbaa !5
  %1042 = add nsw i32 %1041, -1
  store i32 %1042, ptr %3, align 4, !tbaa !5
  %1043 = sext i32 %1042 to i64
  %1044 = getelementptr inbounds %struct.AtomStr, ptr %1040, i64 %1043
  %1045 = getelementptr inbounds %struct.AtomStr, ptr %1044, i32 0, i32 0
  %1046 = load ptr, ptr %1045, align 8, !tbaa !11
  %1047 = getelementptr inbounds %struct.PropertyStr, ptr %1046, i32 0, i32 0
  %1048 = getelementptr inbounds [8 x i8], ptr %1047, i64 0, i64 0
  %1049 = call i32 @strcmp(ptr noundef %1048, ptr noundef @.str.227) #6
  %1050 = icmp ne i32 %1049, 0
  br i1 %1050, label %1051, label %1052

1051:                                             ; preds = %1039
  br label %1039, !llvm.loop !51

1052:                                             ; preds = %1039
  %1053 = load i32, ptr %3, align 4, !tbaa !5
  %1054 = load ptr, ptr @atom, align 8, !tbaa !9
  %1055 = load i32, ptr %2, align 4, !tbaa !5
  %1056 = sext i32 %1055 to i64
  %1057 = getelementptr inbounds %struct.AtomStr, ptr %1054, i64 %1056
  %1058 = getelementptr inbounds %struct.AtomStr, ptr %1057, i32 0, i32 1
  %1059 = load ptr, ptr %1058, align 8, !tbaa !25
  %1060 = getelementptr inbounds %struct.DynamicStr, ptr %1059, i32 0, i32 3
  %1061 = getelementptr inbounds %struct.HBStr, ptr %1060, i32 0, i32 1
  store i32 %1053, ptr %1061, align 4, !tbaa !26
  %1062 = load ptr, ptr @atom, align 8, !tbaa !9
  %1063 = load i32, ptr %2, align 4, !tbaa !5
  %1064 = sext i32 %1063 to i64
  %1065 = getelementptr inbounds %struct.AtomStr, ptr %1062, i64 %1064
  %1066 = getelementptr inbounds %struct.AtomStr, ptr %1065, i32 0, i32 1
  %1067 = load ptr, ptr %1066, align 8, !tbaa !25
  %1068 = getelementptr inbounds %struct.DynamicStr, ptr %1067, i32 0, i32 3
  %1069 = getelementptr inbounds %struct.HBStr, ptr %1068, i32 0, i32 2
  store i8 68, ptr %1069, align 8, !tbaa !32
  br label %1070

1070:                                             ; preds = %1052, %1027
  br label %1071

1071:                                             ; preds = %1070, %998
  br label %1072

1072:                                             ; preds = %1071, %944
  br label %1367

1073:                                             ; preds = %908
  %1074 = load ptr, ptr @atom, align 8, !tbaa !9
  %1075 = load i32, ptr %2, align 4, !tbaa !5
  %1076 = sext i32 %1075 to i64
  %1077 = getelementptr inbounds %struct.AtomStr, ptr %1074, i64 %1076
  %1078 = getelementptr inbounds %struct.AtomStr, ptr %1077, i32 0, i32 0
  %1079 = load ptr, ptr %1078, align 8, !tbaa !11
  %1080 = getelementptr inbounds %struct.PropertyStr, ptr %1079, i32 0, i32 2
  %1081 = getelementptr inbounds [8 x i8], ptr %1080, i64 0, i64 0
  %1082 = call i32 @strcmp(ptr noundef %1081, ptr noundef @.str.228) #6
  %1083 = icmp eq i32 %1082, 0
  br i1 %1083, label %1084, label %1139

1084:                                             ; preds = %1073
  %1085 = load ptr, ptr @atom, align 8, !tbaa !9
  %1086 = load i32, ptr %2, align 4, !tbaa !5
  %1087 = sext i32 %1086 to i64
  %1088 = getelementptr inbounds %struct.AtomStr, ptr %1085, i64 %1087
  %1089 = getelementptr inbounds %struct.AtomStr, ptr %1088, i32 0, i32 0
  %1090 = load ptr, ptr %1089, align 8, !tbaa !11
  %1091 = getelementptr inbounds %struct.PropertyStr, ptr %1090, i32 0, i32 0
  %1092 = getelementptr inbounds [8 x i8], ptr %1091, i64 0, i64 0
  %1093 = call i32 @strcmp(ptr noundef %1092, ptr noundef @.str.207) #6
  %1094 = icmp eq i32 %1093, 0
  br i1 %1094, label %1106, label %1095

1095:                                             ; preds = %1084
  %1096 = load ptr, ptr @atom, align 8, !tbaa !9
  %1097 = load i32, ptr %2, align 4, !tbaa !5
  %1098 = sext i32 %1097 to i64
  %1099 = getelementptr inbounds %struct.AtomStr, ptr %1096, i64 %1098
  %1100 = getelementptr inbounds %struct.AtomStr, ptr %1099, i32 0, i32 0
  %1101 = load ptr, ptr %1100, align 8, !tbaa !11
  %1102 = getelementptr inbounds %struct.PropertyStr, ptr %1101, i32 0, i32 0
  %1103 = getelementptr inbounds [8 x i8], ptr %1102, i64 0, i64 0
  %1104 = call i32 @strcmp(ptr noundef %1103, ptr noundef @.str.229) #6
  %1105 = icmp eq i32 %1104, 0
  br i1 %1105, label %1106, label %1138

1106:                                             ; preds = %1095, %1084
  br label %1107

1107:                                             ; preds = %1119, %1106
  %1108 = load ptr, ptr @atom, align 8, !tbaa !9
  %1109 = load i32, ptr %3, align 4, !tbaa !5
  %1110 = add nsw i32 %1109, -1
  store i32 %1110, ptr %3, align 4, !tbaa !5
  %1111 = sext i32 %1110 to i64
  %1112 = getelementptr inbounds %struct.AtomStr, ptr %1108, i64 %1111
  %1113 = getelementptr inbounds %struct.AtomStr, ptr %1112, i32 0, i32 0
  %1114 = load ptr, ptr %1113, align 8, !tbaa !11
  %1115 = getelementptr inbounds %struct.PropertyStr, ptr %1114, i32 0, i32 0
  %1116 = getelementptr inbounds [8 x i8], ptr %1115, i64 0, i64 0
  %1117 = call i32 @strcmp(ptr noundef %1116, ptr noundef @.str.208) #6
  %1118 = icmp ne i32 %1117, 0
  br i1 %1118, label %1119, label %1120

1119:                                             ; preds = %1107
  br label %1107, !llvm.loop !52

1120:                                             ; preds = %1107
  %1121 = load i32, ptr %3, align 4, !tbaa !5
  %1122 = load ptr, ptr @atom, align 8, !tbaa !9
  %1123 = load i32, ptr %2, align 4, !tbaa !5
  %1124 = sext i32 %1123 to i64
  %1125 = getelementptr inbounds %struct.AtomStr, ptr %1122, i64 %1124
  %1126 = getelementptr inbounds %struct.AtomStr, ptr %1125, i32 0, i32 1
  %1127 = load ptr, ptr %1126, align 8, !tbaa !25
  %1128 = getelementptr inbounds %struct.DynamicStr, ptr %1127, i32 0, i32 3
  %1129 = getelementptr inbounds %struct.HBStr, ptr %1128, i32 0, i32 1
  store i32 %1121, ptr %1129, align 4, !tbaa !26
  %1130 = load ptr, ptr @atom, align 8, !tbaa !9
  %1131 = load i32, ptr %2, align 4, !tbaa !5
  %1132 = sext i32 %1131 to i64
  %1133 = getelementptr inbounds %struct.AtomStr, ptr %1130, i64 %1132
  %1134 = getelementptr inbounds %struct.AtomStr, ptr %1133, i32 0, i32 1
  %1135 = load ptr, ptr %1134, align 8, !tbaa !25
  %1136 = getelementptr inbounds %struct.DynamicStr, ptr %1135, i32 0, i32 3
  %1137 = getelementptr inbounds %struct.HBStr, ptr %1136, i32 0, i32 2
  store i8 65, ptr %1137, align 8, !tbaa !32
  br label %1138

1138:                                             ; preds = %1120, %1095
  br label %1366

1139:                                             ; preds = %1073
  %1140 = load ptr, ptr @atom, align 8, !tbaa !9
  %1141 = load i32, ptr %2, align 4, !tbaa !5
  %1142 = sext i32 %1141 to i64
  %1143 = getelementptr inbounds %struct.AtomStr, ptr %1140, i64 %1142
  %1144 = getelementptr inbounds %struct.AtomStr, ptr %1143, i32 0, i32 0
  %1145 = load ptr, ptr %1144, align 8, !tbaa !11
  %1146 = getelementptr inbounds %struct.PropertyStr, ptr %1145, i32 0, i32 2
  %1147 = getelementptr inbounds [8 x i8], ptr %1146, i64 0, i64 0
  %1148 = call i32 @strcmp(ptr noundef %1147, ptr noundef @.str.230) #6
  %1149 = icmp eq i32 %1148, 0
  br i1 %1149, label %1150, label %1205

1150:                                             ; preds = %1139
  %1151 = load ptr, ptr @atom, align 8, !tbaa !9
  %1152 = load i32, ptr %2, align 4, !tbaa !5
  %1153 = sext i32 %1152 to i64
  %1154 = getelementptr inbounds %struct.AtomStr, ptr %1151, i64 %1153
  %1155 = getelementptr inbounds %struct.AtomStr, ptr %1154, i32 0, i32 0
  %1156 = load ptr, ptr %1155, align 8, !tbaa !11
  %1157 = getelementptr inbounds %struct.PropertyStr, ptr %1156, i32 0, i32 0
  %1158 = getelementptr inbounds [8 x i8], ptr %1157, i64 0, i64 0
  %1159 = call i32 @strcmp(ptr noundef %1158, ptr noundef @.str.212) #6
  %1160 = icmp eq i32 %1159, 0
  br i1 %1160, label %1172, label %1161

1161:                                             ; preds = %1150
  %1162 = load ptr, ptr @atom, align 8, !tbaa !9
  %1163 = load i32, ptr %2, align 4, !tbaa !5
  %1164 = sext i32 %1163 to i64
  %1165 = getelementptr inbounds %struct.AtomStr, ptr %1162, i64 %1164
  %1166 = getelementptr inbounds %struct.AtomStr, ptr %1165, i32 0, i32 0
  %1167 = load ptr, ptr %1166, align 8, !tbaa !11
  %1168 = getelementptr inbounds %struct.PropertyStr, ptr %1167, i32 0, i32 0
  %1169 = getelementptr inbounds [8 x i8], ptr %1168, i64 0, i64 0
  %1170 = call i32 @strcmp(ptr noundef %1169, ptr noundef @.str.231) #6
  %1171 = icmp eq i32 %1170, 0
  br i1 %1171, label %1172, label %1204

1172:                                             ; preds = %1161, %1150
  br label %1173

1173:                                             ; preds = %1185, %1172
  %1174 = load ptr, ptr @atom, align 8, !tbaa !9
  %1175 = load i32, ptr %3, align 4, !tbaa !5
  %1176 = add nsw i32 %1175, -1
  store i32 %1176, ptr %3, align 4, !tbaa !5
  %1177 = sext i32 %1176 to i64
  %1178 = getelementptr inbounds %struct.AtomStr, ptr %1174, i64 %1177
  %1179 = getelementptr inbounds %struct.AtomStr, ptr %1178, i32 0, i32 0
  %1180 = load ptr, ptr %1179, align 8, !tbaa !11
  %1181 = getelementptr inbounds %struct.PropertyStr, ptr %1180, i32 0, i32 0
  %1182 = getelementptr inbounds [8 x i8], ptr %1181, i64 0, i64 0
  %1183 = call i32 @strcmp(ptr noundef %1182, ptr noundef @.str.213) #6
  %1184 = icmp ne i32 %1183, 0
  br i1 %1184, label %1185, label %1186

1185:                                             ; preds = %1173
  br label %1173, !llvm.loop !53

1186:                                             ; preds = %1173
  %1187 = load i32, ptr %3, align 4, !tbaa !5
  %1188 = load ptr, ptr @atom, align 8, !tbaa !9
  %1189 = load i32, ptr %2, align 4, !tbaa !5
  %1190 = sext i32 %1189 to i64
  %1191 = getelementptr inbounds %struct.AtomStr, ptr %1188, i64 %1190
  %1192 = getelementptr inbounds %struct.AtomStr, ptr %1191, i32 0, i32 1
  %1193 = load ptr, ptr %1192, align 8, !tbaa !25
  %1194 = getelementptr inbounds %struct.DynamicStr, ptr %1193, i32 0, i32 3
  %1195 = getelementptr inbounds %struct.HBStr, ptr %1194, i32 0, i32 1
  store i32 %1187, ptr %1195, align 4, !tbaa !26
  %1196 = load ptr, ptr @atom, align 8, !tbaa !9
  %1197 = load i32, ptr %2, align 4, !tbaa !5
  %1198 = sext i32 %1197 to i64
  %1199 = getelementptr inbounds %struct.AtomStr, ptr %1196, i64 %1198
  %1200 = getelementptr inbounds %struct.AtomStr, ptr %1199, i32 0, i32 1
  %1201 = load ptr, ptr %1200, align 8, !tbaa !25
  %1202 = getelementptr inbounds %struct.DynamicStr, ptr %1201, i32 0, i32 3
  %1203 = getelementptr inbounds %struct.HBStr, ptr %1202, i32 0, i32 2
  store i8 65, ptr %1203, align 8, !tbaa !32
  br label %1204

1204:                                             ; preds = %1186, %1161
  br label %1365

1205:                                             ; preds = %1139
  %1206 = load ptr, ptr @atom, align 8, !tbaa !9
  %1207 = load i32, ptr %2, align 4, !tbaa !5
  %1208 = sext i32 %1207 to i64
  %1209 = getelementptr inbounds %struct.AtomStr, ptr %1206, i64 %1208
  %1210 = getelementptr inbounds %struct.AtomStr, ptr %1209, i32 0, i32 0
  %1211 = load ptr, ptr %1210, align 8, !tbaa !11
  %1212 = getelementptr inbounds %struct.PropertyStr, ptr %1211, i32 0, i32 2
  %1213 = getelementptr inbounds [8 x i8], ptr %1212, i64 0, i64 0
  %1214 = call i32 @strcmp(ptr noundef %1213, ptr noundef @.str.232) #6
  %1215 = icmp eq i32 %1214, 0
  br i1 %1215, label %1216, label %1260

1216:                                             ; preds = %1205
  %1217 = load ptr, ptr @atom, align 8, !tbaa !9
  %1218 = load i32, ptr %2, align 4, !tbaa !5
  %1219 = sext i32 %1218 to i64
  %1220 = getelementptr inbounds %struct.AtomStr, ptr %1217, i64 %1219
  %1221 = getelementptr inbounds %struct.AtomStr, ptr %1220, i32 0, i32 0
  %1222 = load ptr, ptr %1221, align 8, !tbaa !11
  %1223 = getelementptr inbounds %struct.PropertyStr, ptr %1222, i32 0, i32 0
  %1224 = getelementptr inbounds [8 x i8], ptr %1223, i64 0, i64 0
  %1225 = call i32 @strcmp(ptr noundef %1224, ptr noundef @.str.233) #6
  %1226 = icmp eq i32 %1225, 0
  br i1 %1226, label %1227, label %1259

1227:                                             ; preds = %1216
  br label %1228

1228:                                             ; preds = %1240, %1227
  %1229 = load ptr, ptr @atom, align 8, !tbaa !9
  %1230 = load i32, ptr %3, align 4, !tbaa !5
  %1231 = add nsw i32 %1230, -1
  store i32 %1231, ptr %3, align 4, !tbaa !5
  %1232 = sext i32 %1231 to i64
  %1233 = getelementptr inbounds %struct.AtomStr, ptr %1229, i64 %1232
  %1234 = getelementptr inbounds %struct.AtomStr, ptr %1233, i32 0, i32 0
  %1235 = load ptr, ptr %1234, align 8, !tbaa !11
  %1236 = getelementptr inbounds %struct.PropertyStr, ptr %1235, i32 0, i32 0
  %1237 = getelementptr inbounds [8 x i8], ptr %1236, i64 0, i64 0
  %1238 = call i32 @strcmp(ptr noundef %1237, ptr noundef @.str.161) #6
  %1239 = icmp ne i32 %1238, 0
  br i1 %1239, label %1240, label %1241

1240:                                             ; preds = %1228
  br label %1228, !llvm.loop !54

1241:                                             ; preds = %1228
  %1242 = load i32, ptr %3, align 4, !tbaa !5
  %1243 = load ptr, ptr @atom, align 8, !tbaa !9
  %1244 = load i32, ptr %2, align 4, !tbaa !5
  %1245 = sext i32 %1244 to i64
  %1246 = getelementptr inbounds %struct.AtomStr, ptr %1243, i64 %1245
  %1247 = getelementptr inbounds %struct.AtomStr, ptr %1246, i32 0, i32 1
  %1248 = load ptr, ptr %1247, align 8, !tbaa !25
  %1249 = getelementptr inbounds %struct.DynamicStr, ptr %1248, i32 0, i32 3
  %1250 = getelementptr inbounds %struct.HBStr, ptr %1249, i32 0, i32 1
  store i32 %1242, ptr %1250, align 4, !tbaa !26
  %1251 = load ptr, ptr @atom, align 8, !tbaa !9
  %1252 = load i32, ptr %2, align 4, !tbaa !5
  %1253 = sext i32 %1252 to i64
  %1254 = getelementptr inbounds %struct.AtomStr, ptr %1251, i64 %1253
  %1255 = getelementptr inbounds %struct.AtomStr, ptr %1254, i32 0, i32 1
  %1256 = load ptr, ptr %1255, align 8, !tbaa !25
  %1257 = getelementptr inbounds %struct.DynamicStr, ptr %1256, i32 0, i32 3
  %1258 = getelementptr inbounds %struct.HBStr, ptr %1257, i32 0, i32 2
  store i8 83, ptr %1258, align 8, !tbaa !32
  br label %1259

1259:                                             ; preds = %1241, %1216
  br label %1364

1260:                                             ; preds = %1205
  %1261 = load ptr, ptr @atom, align 8, !tbaa !9
  %1262 = load i32, ptr %2, align 4, !tbaa !5
  %1263 = sext i32 %1262 to i64
  %1264 = getelementptr inbounds %struct.AtomStr, ptr %1261, i64 %1263
  %1265 = getelementptr inbounds %struct.AtomStr, ptr %1264, i32 0, i32 0
  %1266 = load ptr, ptr %1265, align 8, !tbaa !11
  %1267 = getelementptr inbounds %struct.PropertyStr, ptr %1266, i32 0, i32 2
  %1268 = getelementptr inbounds [8 x i8], ptr %1267, i64 0, i64 0
  %1269 = call i32 @strcmp(ptr noundef %1268, ptr noundef @.str.234) #6
  %1270 = icmp eq i32 %1269, 0
  br i1 %1270, label %1271, label %1363

1271:                                             ; preds = %1260
  %1272 = load ptr, ptr @atom, align 8, !tbaa !9
  %1273 = load i32, ptr %2, align 4, !tbaa !5
  %1274 = sext i32 %1273 to i64
  %1275 = getelementptr inbounds %struct.AtomStr, ptr %1272, i64 %1274
  %1276 = getelementptr inbounds %struct.AtomStr, ptr %1275, i32 0, i32 0
  %1277 = load ptr, ptr %1276, align 8, !tbaa !11
  %1278 = getelementptr inbounds %struct.PropertyStr, ptr %1277, i32 0, i32 0
  %1279 = getelementptr inbounds [8 x i8], ptr %1278, i64 0, i64 0
  %1280 = call i32 @strcmp(ptr noundef %1279, ptr noundef @.str.235) #6
  %1281 = icmp eq i32 %1280, 0
  br i1 %1281, label %1282, label %1300

1282:                                             ; preds = %1271
  %1283 = load i32, ptr %2, align 4, !tbaa !5
  %1284 = load ptr, ptr @atom, align 8, !tbaa !9
  %1285 = load i32, ptr %2, align 4, !tbaa !5
  %1286 = sext i32 %1285 to i64
  %1287 = getelementptr inbounds %struct.AtomStr, ptr %1284, i64 %1286
  %1288 = getelementptr inbounds %struct.AtomStr, ptr %1287, i32 0, i32 1
  %1289 = load ptr, ptr %1288, align 8, !tbaa !25
  %1290 = getelementptr inbounds %struct.DynamicStr, ptr %1289, i32 0, i32 3
  %1291 = getelementptr inbounds %struct.HBStr, ptr %1290, i32 0, i32 1
  store i32 %1283, ptr %1291, align 4, !tbaa !26
  %1292 = load ptr, ptr @atom, align 8, !tbaa !9
  %1293 = load i32, ptr %2, align 4, !tbaa !5
  %1294 = sext i32 %1293 to i64
  %1295 = getelementptr inbounds %struct.AtomStr, ptr %1292, i64 %1294
  %1296 = getelementptr inbounds %struct.AtomStr, ptr %1295, i32 0, i32 1
  %1297 = load ptr, ptr %1296, align 8, !tbaa !25
  %1298 = getelementptr inbounds %struct.DynamicStr, ptr %1297, i32 0, i32 3
  %1299 = getelementptr inbounds %struct.HBStr, ptr %1298, i32 0, i32 2
  store i8 65, ptr %1299, align 8, !tbaa !32
  br label %1362

1300:                                             ; preds = %1271
  %1301 = load ptr, ptr @atom, align 8, !tbaa !9
  %1302 = load i32, ptr %2, align 4, !tbaa !5
  %1303 = sext i32 %1302 to i64
  %1304 = getelementptr inbounds %struct.AtomStr, ptr %1301, i64 %1303
  %1305 = getelementptr inbounds %struct.AtomStr, ptr %1304, i32 0, i32 0
  %1306 = load ptr, ptr %1305, align 8, !tbaa !11
  %1307 = getelementptr inbounds %struct.PropertyStr, ptr %1306, i32 0, i32 0
  %1308 = getelementptr inbounds [8 x i8], ptr %1307, i64 0, i64 0
  %1309 = call i32 @strcmp(ptr noundef %1308, ptr noundef @.str.236) #6
  %1310 = icmp eq i32 %1309, 0
  br i1 %1310, label %1311, label %1330

1311:                                             ; preds = %1300
  %1312 = load i32, ptr %2, align 4, !tbaa !5
  %1313 = sub nsw i32 %1312, 1
  %1314 = load ptr, ptr @atom, align 8, !tbaa !9
  %1315 = load i32, ptr %2, align 4, !tbaa !5
  %1316 = sext i32 %1315 to i64
  %1317 = getelementptr inbounds %struct.AtomStr, ptr %1314, i64 %1316
  %1318 = getelementptr inbounds %struct.AtomStr, ptr %1317, i32 0, i32 1
  %1319 = load ptr, ptr %1318, align 8, !tbaa !25
  %1320 = getelementptr inbounds %struct.DynamicStr, ptr %1319, i32 0, i32 3
  %1321 = getelementptr inbounds %struct.HBStr, ptr %1320, i32 0, i32 1
  store i32 %1313, ptr %1321, align 4, !tbaa !26
  %1322 = load ptr, ptr @atom, align 8, !tbaa !9
  %1323 = load i32, ptr %2, align 4, !tbaa !5
  %1324 = sext i32 %1323 to i64
  %1325 = getelementptr inbounds %struct.AtomStr, ptr %1322, i64 %1324
  %1326 = getelementptr inbounds %struct.AtomStr, ptr %1325, i32 0, i32 1
  %1327 = load ptr, ptr %1326, align 8, !tbaa !25
  %1328 = getelementptr inbounds %struct.DynamicStr, ptr %1327, i32 0, i32 3
  %1329 = getelementptr inbounds %struct.HBStr, ptr %1328, i32 0, i32 2
  store i8 68, ptr %1329, align 8, !tbaa !32
  br label %1361

1330:                                             ; preds = %1300
  %1331 = load ptr, ptr @atom, align 8, !tbaa !9
  %1332 = load i32, ptr %2, align 4, !tbaa !5
  %1333 = sext i32 %1332 to i64
  %1334 = getelementptr inbounds %struct.AtomStr, ptr %1331, i64 %1333
  %1335 = getelementptr inbounds %struct.AtomStr, ptr %1334, i32 0, i32 0
  %1336 = load ptr, ptr %1335, align 8, !tbaa !11
  %1337 = getelementptr inbounds %struct.PropertyStr, ptr %1336, i32 0, i32 0
  %1338 = getelementptr inbounds [8 x i8], ptr %1337, i64 0, i64 0
  %1339 = call i32 @strcmp(ptr noundef %1338, ptr noundef @.str.237) #6
  %1340 = icmp eq i32 %1339, 0
  br i1 %1340, label %1341, label %1360

1341:                                             ; preds = %1330
  %1342 = load i32, ptr %2, align 4, !tbaa !5
  %1343 = sub nsw i32 %1342, 2
  %1344 = load ptr, ptr @atom, align 8, !tbaa !9
  %1345 = load i32, ptr %2, align 4, !tbaa !5
  %1346 = sext i32 %1345 to i64
  %1347 = getelementptr inbounds %struct.AtomStr, ptr %1344, i64 %1346
  %1348 = getelementptr inbounds %struct.AtomStr, ptr %1347, i32 0, i32 1
  %1349 = load ptr, ptr %1348, align 8, !tbaa !25
  %1350 = getelementptr inbounds %struct.DynamicStr, ptr %1349, i32 0, i32 3
  %1351 = getelementptr inbounds %struct.HBStr, ptr %1350, i32 0, i32 1
  store i32 %1343, ptr %1351, align 4, !tbaa !26
  %1352 = load ptr, ptr @atom, align 8, !tbaa !9
  %1353 = load i32, ptr %2, align 4, !tbaa !5
  %1354 = sext i32 %1353 to i64
  %1355 = getelementptr inbounds %struct.AtomStr, ptr %1352, i64 %1354
  %1356 = getelementptr inbounds %struct.AtomStr, ptr %1355, i32 0, i32 1
  %1357 = load ptr, ptr %1356, align 8, !tbaa !25
  %1358 = getelementptr inbounds %struct.DynamicStr, ptr %1357, i32 0, i32 3
  %1359 = getelementptr inbounds %struct.HBStr, ptr %1358, i32 0, i32 2
  store i8 68, ptr %1359, align 8, !tbaa !32
  br label %1360

1360:                                             ; preds = %1341, %1330
  br label %1361

1361:                                             ; preds = %1360, %1311
  br label %1362

1362:                                             ; preds = %1361, %1282
  br label %1363

1363:                                             ; preds = %1362, %1260
  br label %1364

1364:                                             ; preds = %1363, %1259
  br label %1365

1365:                                             ; preds = %1364, %1204
  br label %1366

1366:                                             ; preds = %1365, %1138
  br label %1367

1367:                                             ; preds = %1366, %1072
  br label %1368

1368:                                             ; preds = %1367, %907
  br label %1369

1369:                                             ; preds = %1368, %830
  br label %1370

1370:                                             ; preds = %1369, %720
  br label %1371

1371:                                             ; preds = %1370, %610
  br label %1372

1372:                                             ; preds = %1371, %511
  br label %1373

1373:                                             ; preds = %1372, %412
  br label %1374

1374:                                             ; preds = %1373, %357
  br label %1375

1375:                                             ; preds = %1374, %258
  br label %1376

1376:                                             ; preds = %1375, %98
  br label %1377

1377:                                             ; preds = %1376, %57
  %1378 = load i32, ptr %3, align 4, !tbaa !5
  %1379 = load ptr, ptr @aminoacid, align 8, !tbaa !9
  %1380 = load ptr, ptr @atom, align 8, !tbaa !9
  %1381 = load i32, ptr %2, align 4, !tbaa !5
  %1382 = sext i32 %1381 to i64
  %1383 = getelementptr inbounds %struct.AtomStr, ptr %1380, i64 %1382
  %1384 = getelementptr inbounds %struct.AtomStr, ptr %1383, i32 0, i32 0
  %1385 = load ptr, ptr %1384, align 8, !tbaa !11
  %1386 = getelementptr inbounds %struct.PropertyStr, ptr %1385, i32 0, i32 9
  %1387 = getelementptr inbounds %struct.AtomSeqStr, ptr %1386, i32 0, i32 2
  %1388 = load i32, ptr %1387, align 8, !tbaa !19
  %1389 = sext i32 %1388 to i64
  %1390 = getelementptr inbounds %struct.AAStr, ptr %1379, i64 %1389
  %1391 = getelementptr inbounds %struct.AAStr, ptr %1390, i32 0, i32 2
  %1392 = load i32, ptr %1391, align 4, !tbaa !55
  %1393 = icmp slt i32 %1378, %1392
  br i1 %1393, label %1394, label %1415

1394:                                             ; preds = %1377
  %1395 = load i32, ptr %2, align 4, !tbaa !5
  %1396 = load ptr, ptr @atom, align 8, !tbaa !9
  %1397 = load i32, ptr %2, align 4, !tbaa !5
  %1398 = sext i32 %1397 to i64
  %1399 = getelementptr inbounds %struct.AtomStr, ptr %1396, i64 %1398
  %1400 = getelementptr inbounds %struct.AtomStr, ptr %1399, i32 0, i32 0
  %1401 = load ptr, ptr %1400, align 8, !tbaa !11
  %1402 = getelementptr inbounds %struct.PropertyStr, ptr %1401, i32 0, i32 9
  %1403 = getelementptr inbounds %struct.AtomSeqStr, ptr %1402, i32 0, i32 2
  %1404 = load i32, ptr %1403, align 8, !tbaa !19
  %1405 = load ptr, ptr @atom, align 8, !tbaa !9
  %1406 = load i32, ptr %2, align 4, !tbaa !5
  %1407 = sext i32 %1406 to i64
  %1408 = getelementptr inbounds %struct.AtomStr, ptr %1405, i64 %1407
  %1409 = getelementptr inbounds %struct.AtomStr, ptr %1408, i32 0, i32 0
  %1410 = load ptr, ptr %1409, align 8, !tbaa !11
  %1411 = getelementptr inbounds %struct.PropertyStr, ptr %1410, i32 0, i32 0
  %1412 = getelementptr inbounds [8 x i8], ptr %1411, i64 0, i64 0
  %1413 = call i32 (ptr, ...) @printf(ptr noundef @.str.238, i32 noundef %1395, i32 noundef %1404, ptr noundef %1412)
  %1414 = call i32 (ptr, ...) @printf(ptr noundef @.str.129, ptr noundef @.str.2, i32 noundef 1844)
  call void @exit(i32 noundef 1) #7
  unreachable

1415:                                             ; preds = %1377
  call void @llvm.lifetime.end.p0(i64 4, ptr %3) #5
  ret void
}

attributes #0 = { nocallback nofree nosync nounwind willreturn memory(argmem: readwrite) }
attributes #1 = { nounwind willreturn memory(read) "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #2 = { "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #3 = { noreturn nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #4 = { nounwind 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 #5 = { nounwind }
attributes #6 = { nounwind willreturn memory(read) }
attributes #7 = { 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, !10, i64 0}
!12 = !{!"AtomStr", !10, i64 0, !10, i64 8}
!13 = !{!14, !6, i64 108}
!14 = !{!"PropertyStr", !7, i64 0, !7, i64 8, !7, i64 40, !6, i64 48, !6, i64 52, !6, i64 56, !15, i64 64, !15, i64 72, !7, i64 80, !16, i64 104, !10, i64 120, !10, i64 128}
!15 = !{!"double", !7, i64 0}
!16 = !{!"AtomSeqStr", !6, i64 0, !6, i64 4, !6, i64 8}
!17 = !{!18, !6, i64 12}
!18 = !{!"PepStr", !6, i64 0, !6, i64 4, !6, i64 8, !6, i64 12, !15, i64 16}
!19 = !{!14, !6, i64 112}
!20 = !{!21, !6, i64 16}
!21 = !{!"AAStr", !7, i64 0, !6, i64 8, !6, i64 12, !6, i64 16, !6, i64 20, !15, i64 24}
!22 = !{!14, !6, i64 52}
!23 = distinct !{!23, !24}
!24 = !{!"llvm.loop.mustprogress"}
!25 = !{!12, !10, i64 8}
!26 = !{!27, !6, i64 84}
!27 = !{!"DynamicStr", !7, i64 0, !7, i64 16, !7, i64 48, !28, i64 80, !29, i64 96, !30, i64 128}
!28 = !{!"HBStr", !6, i64 0, !6, i64 4, !7, i64 8, !6, i64 12}
!29 = !{!"HBNeighborStr", !7, i64 0, !6, i64 20, !6, i64 24}
!30 = !{!"InteractionEventStr", !6, i64 0, !31, i64 8, !31, i64 16, !15, i64 24, !15, i64 32, !6, i64 40, !6, i64 44}
!31 = !{!"long", !7, i64 0}
!32 = !{!27, !7, i64 88}
!33 = distinct !{!33, !24}
!34 = distinct !{!34, !24}
!35 = distinct !{!35, !24}
!36 = distinct !{!36, !24}
!37 = distinct !{!37, !24}
!38 = distinct !{!38, !24}
!39 = distinct !{!39, !24}
!40 = distinct !{!40, !24}
!41 = distinct !{!41, !24}
!42 = distinct !{!42, !24}
!43 = distinct !{!43, !24}
!44 = distinct !{!44, !24}
!45 = distinct !{!45, !24}
!46 = distinct !{!46, !24}
!47 = distinct !{!47, !24}
!48 = distinct !{!48, !24}
!49 = distinct !{!49, !24}
!50 = distinct !{!50, !24}
!51 = distinct !{!51, !24}
!52 = distinct !{!52, !24}
!53 = distinct !{!53, !24}
!54 = distinct !{!54, !24}
!55 = !{!21, !6, i64 12}


; 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.AtomStr = type { ptr, ptr }
%struct.PepStr = type { i32, i32, i32, i32, double }
%struct.AAStr = type { [5 x i8], i32, i32, i32, i32, double }

@.str.2 = external hidden unnamed_addr constant [71 x i8], align 1
@atom = external local_unnamed_addr global ptr, align 8
@protein = external local_unnamed_addr global ptr, align 8
@aminoacid = external local_unnamed_addr global ptr, align 8
@.str.129 = external hidden unnamed_addr constant [18 x i8], align 1
@.str.161 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.184 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.185 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.186 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.187 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.188 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.189 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.190 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.191 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.192 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.193 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.194 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.195 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.196 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.197 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.198 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.199 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.200 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.201 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.202 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.203 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.204 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.205 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.206 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.207 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.208 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.209 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.210 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.211 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.212 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.213 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.214 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.215 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.216 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.217 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.218 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.219 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.220 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.221 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.222 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.223 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.224 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.225 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.226 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.227 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.228 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.229 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.230 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.231 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.232 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.233 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.234 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.235 = external hidden unnamed_addr constant [3 x i8], align 1
@.str.236 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.237 = external hidden unnamed_addr constant [4 x i8], align 1
@.str.238 = external hidden unnamed_addr constant [55 x i8], align 1

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @HBNeighborAssign(i32 noundef %0) local_unnamed_addr #3 {
  %2 = load ptr, ptr @aminoacid, align 8, !tbaa !5
  %3 = load ptr, ptr @protein, align 8, !tbaa !5
  %4 = load ptr, ptr @atom, align 8, !tbaa !5
  %5 = sext i32 %0 to i64
  %6 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5
  %7 = load ptr, ptr %6, align 8, !tbaa !9
  %8 = getelementptr inbounds i8, ptr %7, i64 108
  %9 = load i32, ptr %8, align 4, !tbaa !11
  %10 = sext i32 %9 to i64
  %11 = getelementptr %struct.PepStr, ptr %3, i64 %10
  %12 = getelementptr i8, ptr %11, i64 -12
  %13 = load i32, ptr %12, align 4, !tbaa !16
  %14 = getelementptr inbounds i8, ptr %7, i64 112
  %15 = load i32, ptr %14, align 8, !tbaa !18
  %16 = add nsw i32 %15, %13
  %17 = sext i32 %16 to i64
  %18 = getelementptr inbounds %struct.AAStr, ptr %2, i64 %17, i32 3
  %19 = load i32, ptr %18, align 8, !tbaa !19
  %20 = add i32 %19, 1
  %21 = getelementptr inbounds i8, ptr %7, i64 52
  %22 = load i32, ptr %21, align 4, !tbaa !21
  switch i32 %22, label %39 [
    i32 2, label %.preheader191.preheader
    i32 26, label %.preheader192.preheader
  ]

.preheader192.preheader:                          ; preds = %1
  %23 = sext i32 %20 to i64
  br label %.preheader192

.preheader191.preheader:                          ; preds = %1
  %24 = sext i32 %20 to i64
  br label %.preheader191

.preheader191:                                    ; preds = %.preheader191.preheader, %.preheader191
  %indvars.iv238 = phi i64 [ %24, %.preheader191.preheader ], [ %indvars.iv.next239, %.preheader191 ]
  %indvars.iv.next239 = add nsw i64 %indvars.iv238, -1
  %25 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next239
  %26 = load ptr, ptr %25, align 8, !tbaa !9
  %27 = getelementptr inbounds i8, ptr %26, i64 52
  %28 = load i32, ptr %27, align 4, !tbaa !21
  %.not177 = icmp eq i32 %28, 18
  br i1 %.not177, label %29, label %.preheader191, !llvm.loop !22

29:                                               ; preds = %.preheader191
  %30 = trunc nsw i64 %indvars.iv.next239 to i32
  %31 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

.preheader192:                                    ; preds = %.preheader192.preheader, %.preheader192
  %indvars.iv = phi i64 [ %23, %.preheader192.preheader ], [ %indvars.iv.next, %.preheader192 ]
  %indvars.iv.next = add nsw i64 %indvars.iv, -1
  %32 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next
  %33 = load ptr, ptr %32, align 8, !tbaa !9
  %34 = getelementptr inbounds i8, ptr %33, i64 52
  %35 = load i32, ptr %34, align 4, !tbaa !21
  %.not176 = icmp eq i32 %35, 6
  br i1 %.not176, label %36, label %.preheader192, !llvm.loop !24

36:                                               ; preds = %.preheader192
  %37 = trunc nsw i64 %indvars.iv.next to i32
  %38 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

39:                                               ; preds = %1
  %40 = getelementptr inbounds i8, ptr %7, i64 40
  %41 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.184) #4
  %42 = icmp eq i32 %41, 0
  br i1 %42, label %43, label %73

43:                                               ; preds = %39
  %44 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.185) #4
  %45 = icmp eq i32 %44, 0
  br i1 %45, label %.preheader.preheader, label %53

.preheader.preheader:                             ; preds = %43
  %46 = sext i32 %20 to i64
  br label %.preheader

.preheader:                                       ; preds = %.preheader.preheader, %.preheader
  %indvars.iv301 = phi i64 [ %46, %.preheader.preheader ], [ %indvars.iv.next302, %.preheader ]
  %indvars.iv.next302 = add nsw i64 %indvars.iv301, -1
  %47 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next302
  %48 = load ptr, ptr %47, align 8, !tbaa !9
  %49 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %48, ptr noundef nonnull dereferenceable(1) @.str.186) #4
  %.not175 = icmp eq i32 %49, 0
  br i1 %.not175, label %50, label %.preheader, !llvm.loop !25

50:                                               ; preds = %.preheader
  %51 = trunc nsw i64 %indvars.iv.next302 to i32
  %52 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

53:                                               ; preds = %43
  %54 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.187) #4
  %55 = icmp eq i32 %54, 0
  br i1 %55, label %.preheader178.preheader, label %63

.preheader178.preheader:                          ; preds = %53
  %56 = sext i32 %20 to i64
  br label %.preheader178

.preheader178:                                    ; preds = %.preheader178.preheader, %.preheader178
  %indvars.iv298 = phi i64 [ %56, %.preheader178.preheader ], [ %indvars.iv.next299, %.preheader178 ]
  %indvars.iv.next299 = add nsw i64 %indvars.iv298, -1
  %57 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next299
  %58 = load ptr, ptr %57, align 8, !tbaa !9
  %59 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %58, ptr noundef nonnull dereferenceable(1) @.str.188) #4
  %.not174 = icmp eq i32 %59, 0
  br i1 %.not174, label %60, label %.preheader178, !llvm.loop !26

60:                                               ; preds = %.preheader178
  %61 = trunc nsw i64 %indvars.iv.next299 to i32
  %62 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

63:                                               ; preds = %53
  %64 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.188) #4
  %65 = icmp eq i32 %64, 0
  br i1 %65, label %.preheader179.preheader, label %347

.preheader179.preheader:                          ; preds = %63
  %66 = sext i32 %20 to i64
  br label %.preheader179

.preheader179:                                    ; preds = %.preheader179.preheader, %.preheader179
  %indvars.iv295 = phi i64 [ %66, %.preheader179.preheader ], [ %indvars.iv.next296, %.preheader179 ]
  %indvars.iv.next296 = add nsw i64 %indvars.iv295, -1
  %67 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next296
  %68 = load ptr, ptr %67, align 8, !tbaa !9
  %69 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %68, ptr noundef nonnull dereferenceable(1) @.str.189) #4
  %.not173 = icmp eq i32 %69, 0
  br i1 %.not173, label %70, label %.preheader179, !llvm.loop !27

70:                                               ; preds = %.preheader179
  %71 = trunc nsw i64 %indvars.iv.next296 to i32
  %72 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

73:                                               ; preds = %39
  %74 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.190) #4
  %75 = icmp eq i32 %74, 0
  br i1 %75, label %76, label %96

76:                                               ; preds = %73
  %77 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.191) #4
  %78 = icmp eq i32 %77, 0
  br i1 %78, label %.preheader180.preheader, label %86

.preheader180.preheader:                          ; preds = %76
  %79 = sext i32 %20 to i64
  br label %.preheader180

.preheader180:                                    ; preds = %.preheader180.preheader, %.preheader180
  %indvars.iv292 = phi i64 [ %79, %.preheader180.preheader ], [ %indvars.iv.next293, %.preheader180 ]
  %indvars.iv.next293 = add nsw i64 %indvars.iv292, -1
  %80 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next293
  %81 = load ptr, ptr %80, align 8, !tbaa !9
  %82 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %81, ptr noundef nonnull dereferenceable(1) @.str.192) #4
  %.not172 = icmp eq i32 %82, 0
  br i1 %.not172, label %83, label %.preheader180, !llvm.loop !28

83:                                               ; preds = %.preheader180
  %84 = trunc nsw i64 %indvars.iv.next293 to i32
  %85 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

86:                                               ; preds = %76
  %87 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.192) #4
  %88 = icmp eq i32 %87, 0
  br i1 %88, label %.preheader181.preheader, label %347

.preheader181.preheader:                          ; preds = %86
  %89 = sext i32 %20 to i64
  br label %.preheader181

.preheader181:                                    ; preds = %.preheader181.preheader, %.preheader181
  %indvars.iv289 = phi i64 [ %89, %.preheader181.preheader ], [ %indvars.iv.next290, %.preheader181 ]
  %indvars.iv.next290 = add nsw i64 %indvars.iv289, -1
  %90 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next290
  %91 = load ptr, ptr %90, align 8, !tbaa !9
  %92 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %91, ptr noundef nonnull dereferenceable(1) @.str.193) #4
  %.not171 = icmp eq i32 %92, 0
  br i1 %.not171, label %93, label %.preheader181, !llvm.loop !29

93:                                               ; preds = %.preheader181
  %94 = trunc nsw i64 %indvars.iv.next290 to i32
  %95 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

96:                                               ; preds = %73
  %97 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.194) #4
  %98 = icmp eq i32 %97, 0
  br i1 %98, label %99, label %109

99:                                               ; preds = %96
  %100 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.195) #4
  %101 = icmp eq i32 %100, 0
  br i1 %101, label %.preheader182.preheader, label %347

.preheader182.preheader:                          ; preds = %99
  %102 = sext i32 %20 to i64
  br label %.preheader182

.preheader182:                                    ; preds = %.preheader182.preheader, %.preheader182
  %indvars.iv286 = phi i64 [ %102, %.preheader182.preheader ], [ %indvars.iv.next287, %.preheader182 ]
  %indvars.iv.next287 = add nsw i64 %indvars.iv286, -1
  %103 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next287
  %104 = load ptr, ptr %103, align 8, !tbaa !9
  %105 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %104, ptr noundef nonnull dereferenceable(1) @.str.196) #4
  %.not170 = icmp eq i32 %105, 0
  br i1 %.not170, label %106, label %.preheader182, !llvm.loop !30

106:                                              ; preds = %.preheader182
  %107 = trunc nsw i64 %indvars.iv.next287 to i32
  %108 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

109:                                              ; preds = %96
  %110 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.197) #4
  %111 = icmp eq i32 %110, 0
  br i1 %111, label %112, label %132

112:                                              ; preds = %109
  %113 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.198) #4
  %114 = icmp eq i32 %113, 0
  br i1 %114, label %.preheader183.preheader, label %122

.preheader183.preheader:                          ; preds = %112
  %115 = sext i32 %20 to i64
  br label %.preheader183

.preheader183:                                    ; preds = %.preheader183.preheader, %.preheader183
  %indvars.iv283 = phi i64 [ %115, %.preheader183.preheader ], [ %indvars.iv.next284, %.preheader183 ]
  %indvars.iv.next284 = add nsw i64 %indvars.iv283, -1
  %116 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next284
  %117 = load ptr, ptr %116, align 8, !tbaa !9
  %118 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %117, ptr noundef nonnull dereferenceable(1) @.str.199) #4
  %.not169 = icmp eq i32 %118, 0
  br i1 %.not169, label %119, label %.preheader183, !llvm.loop !31

119:                                              ; preds = %.preheader183
  %120 = trunc nsw i64 %indvars.iv.next284 to i32
  %121 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

122:                                              ; preds = %112
  %123 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.199) #4
  %124 = icmp eq i32 %123, 0
  br i1 %124, label %.preheader184.preheader, label %347

.preheader184.preheader:                          ; preds = %122
  %125 = sext i32 %20 to i64
  br label %.preheader184

.preheader184:                                    ; preds = %.preheader184.preheader, %.preheader184
  %indvars.iv280 = phi i64 [ %125, %.preheader184.preheader ], [ %indvars.iv.next281, %.preheader184 ]
  %indvars.iv.next281 = add nsw i64 %indvars.iv280, -1
  %126 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next281
  %127 = load ptr, ptr %126, align 8, !tbaa !9
  %128 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %127, ptr noundef nonnull dereferenceable(1) @.str.161) #4
  %.not168 = icmp eq i32 %128, 0
  br i1 %.not168, label %129, label %.preheader184, !llvm.loop !32

129:                                              ; preds = %.preheader184
  %130 = trunc nsw i64 %indvars.iv.next281 to i32
  %131 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

132:                                              ; preds = %109
  %133 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.200) #4
  %134 = icmp eq i32 %133, 0
  br i1 %134, label %135, label %155

135:                                              ; preds = %132
  %136 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.201) #4
  %137 = icmp eq i32 %136, 0
  br i1 %137, label %.preheader185.preheader, label %145

.preheader185.preheader:                          ; preds = %135
  %138 = sext i32 %20 to i64
  br label %.preheader185

.preheader185:                                    ; preds = %.preheader185.preheader, %.preheader185
  %indvars.iv277 = phi i64 [ %138, %.preheader185.preheader ], [ %indvars.iv.next278, %.preheader185 ]
  %indvars.iv.next278 = add nsw i64 %indvars.iv277, -1
  %139 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next278
  %140 = load ptr, ptr %139, align 8, !tbaa !9
  %141 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %140, ptr noundef nonnull dereferenceable(1) @.str.202) #4
  %.not167 = icmp eq i32 %141, 0
  br i1 %.not167, label %142, label %.preheader185, !llvm.loop !33

142:                                              ; preds = %.preheader185
  %143 = trunc nsw i64 %indvars.iv.next278 to i32
  %144 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

145:                                              ; preds = %135
  %146 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.202) #4
  %147 = icmp eq i32 %146, 0
  br i1 %147, label %.preheader186.preheader, label %347

.preheader186.preheader:                          ; preds = %145
  %148 = sext i32 %20 to i64
  br label %.preheader186

.preheader186:                                    ; preds = %.preheader186.preheader, %.preheader186
  %indvars.iv274 = phi i64 [ %148, %.preheader186.preheader ], [ %indvars.iv.next275, %.preheader186 ]
  %indvars.iv.next275 = add nsw i64 %indvars.iv274, -1
  %149 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next275
  %150 = load ptr, ptr %149, align 8, !tbaa !9
  %151 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %150, ptr noundef nonnull dereferenceable(1) @.str.161) #4
  %.not166 = icmp eq i32 %151, 0
  br i1 %.not166, label %152, label %.preheader186, !llvm.loop !34

152:                                              ; preds = %.preheader186
  %153 = trunc nsw i64 %indvars.iv.next275 to i32
  %154 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

155:                                              ; preds = %132
  %156 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.203) #4
  %157 = icmp eq i32 %156, 0
  br i1 %157, label %158, label %183

158:                                              ; preds = %155
  %159 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.204) #4
  %160 = icmp eq i32 %159, 0
  br i1 %160, label %164, label %161

161:                                              ; preds = %158
  %162 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.205) #4
  %163 = icmp eq i32 %162, 0
  br i1 %163, label %164, label %173

164:                                              ; preds = %161, %158
  %165 = sext i32 %20 to i64
  br label %166

166:                                              ; preds = %166, %164
  %indvars.iv271 = phi i64 [ %indvars.iv.next272, %166 ], [ %165, %164 ]
  %indvars.iv.next272 = add nsw i64 %indvars.iv271, -1
  %167 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next272
  %168 = load ptr, ptr %167, align 8, !tbaa !9
  %169 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %168, ptr noundef nonnull dereferenceable(1) @.str.206) #4
  %.not165 = icmp eq i32 %169, 0
  br i1 %.not165, label %170, label %166, !llvm.loop !35

170:                                              ; preds = %166
  %171 = trunc nsw i64 %indvars.iv.next272 to i32
  %172 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

173:                                              ; preds = %161
  %174 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.207) #4
  %175 = icmp eq i32 %174, 0
  br i1 %175, label %.preheader187.preheader, label %347

.preheader187.preheader:                          ; preds = %173
  %176 = sext i32 %20 to i64
  br label %.preheader187

.preheader187:                                    ; preds = %.preheader187.preheader, %.preheader187
  %indvars.iv268 = phi i64 [ %176, %.preheader187.preheader ], [ %indvars.iv.next269, %.preheader187 ]
  %indvars.iv.next269 = add nsw i64 %indvars.iv268, -1
  %177 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next269
  %178 = load ptr, ptr %177, align 8, !tbaa !9
  %179 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %178, ptr noundef nonnull dereferenceable(1) @.str.208) #4
  %.not164 = icmp eq i32 %179, 0
  br i1 %.not164, label %180, label %.preheader187, !llvm.loop !36

180:                                              ; preds = %.preheader187
  %181 = trunc nsw i64 %indvars.iv.next269 to i32
  %182 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

183:                                              ; preds = %155
  %184 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.209) #4
  %185 = icmp eq i32 %184, 0
  br i1 %185, label %186, label %211

186:                                              ; preds = %183
  %187 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.210) #4
  %188 = icmp eq i32 %187, 0
  br i1 %188, label %192, label %189

189:                                              ; preds = %186
  %190 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.211) #4
  %191 = icmp eq i32 %190, 0
  br i1 %191, label %192, label %201

192:                                              ; preds = %189, %186
  %193 = sext i32 %20 to i64
  br label %194

194:                                              ; preds = %194, %192
  %indvars.iv265 = phi i64 [ %indvars.iv.next266, %194 ], [ %193, %192 ]
  %indvars.iv.next266 = add nsw i64 %indvars.iv265, -1
  %195 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next266
  %196 = load ptr, ptr %195, align 8, !tbaa !9
  %197 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %196, ptr noundef nonnull dereferenceable(1) @.str.188) #4
  %.not163 = icmp eq i32 %197, 0
  br i1 %.not163, label %198, label %194, !llvm.loop !37

198:                                              ; preds = %194
  %199 = trunc nsw i64 %indvars.iv.next266 to i32
  %200 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

201:                                              ; preds = %189
  %202 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.212) #4
  %203 = icmp eq i32 %202, 0
  br i1 %203, label %.preheader188.preheader, label %347

.preheader188.preheader:                          ; preds = %201
  %204 = sext i32 %20 to i64
  br label %.preheader188

.preheader188:                                    ; preds = %.preheader188.preheader, %.preheader188
  %indvars.iv262 = phi i64 [ %204, %.preheader188.preheader ], [ %indvars.iv.next263, %.preheader188 ]
  %indvars.iv.next263 = add nsw i64 %indvars.iv262, -1
  %205 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next263
  %206 = load ptr, ptr %205, align 8, !tbaa !9
  %207 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %206, ptr noundef nonnull dereferenceable(1) @.str.213) #4
  %.not162 = icmp eq i32 %207, 0
  br i1 %.not162, label %208, label %.preheader188, !llvm.loop !38

208:                                              ; preds = %.preheader188
  %209 = trunc nsw i64 %indvars.iv.next263 to i32
  %210 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

211:                                              ; preds = %183
  %212 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.214) #4
  %213 = icmp eq i32 %212, 0
  br i1 %213, label %214, label %232

214:                                              ; preds = %211
  %215 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.215) #4
  %216 = icmp eq i32 %215, 0
  br i1 %216, label %223, label %217

217:                                              ; preds = %214
  %218 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.216) #4
  %219 = icmp eq i32 %218, 0
  br i1 %219, label %223, label %220

220:                                              ; preds = %217
  %221 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.217) #4
  %222 = icmp eq i32 %221, 0
  br i1 %222, label %223, label %347

223:                                              ; preds = %220, %217, %214
  %224 = sext i32 %20 to i64
  br label %225

225:                                              ; preds = %225, %223
  %indvars.iv259 = phi i64 [ %indvars.iv.next260, %225 ], [ %224, %223 ]
  %indvars.iv.next260 = add nsw i64 %indvars.iv259, -1
  %226 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next260
  %227 = load ptr, ptr %226, align 8, !tbaa !9
  %228 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %227, ptr noundef nonnull dereferenceable(1) @.str.218) #4
  %.not161 = icmp eq i32 %228, 0
  br i1 %.not161, label %229, label %225, !llvm.loop !39

229:                                              ; preds = %225
  %230 = trunc nsw i64 %indvars.iv.next260 to i32
  %231 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

232:                                              ; preds = %211
  %233 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.219) #4
  %234 = icmp eq i32 %233, 0
  br i1 %234, label %235, label %275

235:                                              ; preds = %232
  %236 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.220) #4
  %237 = icmp eq i32 %236, 0
  br i1 %237, label %.preheader189.preheader, label %245

.preheader189.preheader:                          ; preds = %235
  %238 = sext i32 %20 to i64
  br label %.preheader189

.preheader189:                                    ; preds = %.preheader189.preheader, %.preheader189
  %indvars.iv256 = phi i64 [ %238, %.preheader189.preheader ], [ %indvars.iv.next257, %.preheader189 ]
  %indvars.iv.next257 = add nsw i64 %indvars.iv256, -1
  %239 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next257
  %240 = load ptr, ptr %239, align 8, !tbaa !9
  %241 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %240, ptr noundef nonnull dereferenceable(1) @.str.221) #4
  %.not160 = icmp eq i32 %241, 0
  br i1 %.not160, label %242, label %.preheader189, !llvm.loop !40

242:                                              ; preds = %.preheader189
  %243 = trunc nsw i64 %indvars.iv.next257 to i32
  %244 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

245:                                              ; preds = %235
  %246 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.222) #4
  %247 = icmp eq i32 %246, 0
  br i1 %247, label %251, label %248

248:                                              ; preds = %245
  %249 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.223) #4
  %250 = icmp eq i32 %249, 0
  br i1 %250, label %251, label %260

251:                                              ; preds = %248, %245
  %252 = sext i32 %20 to i64
  br label %253

253:                                              ; preds = %253, %251
  %indvars.iv253 = phi i64 [ %indvars.iv.next254, %253 ], [ %252, %251 ]
  %indvars.iv.next254 = add nsw i64 %indvars.iv253, -1
  %254 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next254
  %255 = load ptr, ptr %254, align 8, !tbaa !9
  %256 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %255, ptr noundef nonnull dereferenceable(1) @.str.224) #4
  %.not159 = icmp eq i32 %256, 0
  br i1 %.not159, label %257, label %253, !llvm.loop !41

257:                                              ; preds = %253
  %258 = trunc nsw i64 %indvars.iv.next254 to i32
  %259 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

260:                                              ; preds = %248
  %261 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.225) #4
  %262 = icmp eq i32 %261, 0
  br i1 %262, label %266, label %263

263:                                              ; preds = %260
  %264 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.226) #4
  %265 = icmp eq i32 %264, 0
  br i1 %265, label %266, label %347

266:                                              ; preds = %263, %260
  %267 = sext i32 %20 to i64
  br label %268

268:                                              ; preds = %268, %266
  %indvars.iv250 = phi i64 [ %indvars.iv.next251, %268 ], [ %267, %266 ]
  %indvars.iv.next251 = add nsw i64 %indvars.iv250, -1
  %269 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next251
  %270 = load ptr, ptr %269, align 8, !tbaa !9
  %271 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %270, ptr noundef nonnull dereferenceable(1) @.str.227) #4
  %.not158 = icmp eq i32 %271, 0
  br i1 %.not158, label %272, label %268, !llvm.loop !42

272:                                              ; preds = %268
  %273 = trunc nsw i64 %indvars.iv.next251 to i32
  %274 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

275:                                              ; preds = %232
  %276 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.228) #4
  %277 = icmp eq i32 %276, 0
  br i1 %277, label %278, label %293

278:                                              ; preds = %275
  %279 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.207) #4
  %280 = icmp eq i32 %279, 0
  br i1 %280, label %284, label %281

281:                                              ; preds = %278
  %282 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.229) #4
  %283 = icmp eq i32 %282, 0
  br i1 %283, label %284, label %347

284:                                              ; preds = %281, %278
  %285 = sext i32 %20 to i64
  br label %286

286:                                              ; preds = %286, %284
  %indvars.iv247 = phi i64 [ %indvars.iv.next248, %286 ], [ %285, %284 ]
  %indvars.iv.next248 = add nsw i64 %indvars.iv247, -1
  %287 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next248
  %288 = load ptr, ptr %287, align 8, !tbaa !9
  %289 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %288, ptr noundef nonnull dereferenceable(1) @.str.208) #4
  %.not157 = icmp eq i32 %289, 0
  br i1 %.not157, label %290, label %286, !llvm.loop !43

290:                                              ; preds = %286
  %291 = trunc nsw i64 %indvars.iv.next248 to i32
  %292 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

293:                                              ; preds = %275
  %294 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.230) #4
  %295 = icmp eq i32 %294, 0
  br i1 %295, label %296, label %311

296:                                              ; preds = %293
  %297 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.212) #4
  %298 = icmp eq i32 %297, 0
  br i1 %298, label %302, label %299

299:                                              ; preds = %296
  %300 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.231) #4
  %301 = icmp eq i32 %300, 0
  br i1 %301, label %302, label %347

302:                                              ; preds = %299, %296
  %303 = sext i32 %20 to i64
  br label %304

304:                                              ; preds = %304, %302
  %indvars.iv244 = phi i64 [ %indvars.iv.next245, %304 ], [ %303, %302 ]
  %indvars.iv.next245 = add nsw i64 %indvars.iv244, -1
  %305 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next245
  %306 = load ptr, ptr %305, align 8, !tbaa !9
  %307 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %306, ptr noundef nonnull dereferenceable(1) @.str.213) #4
  %.not156 = icmp eq i32 %307, 0
  br i1 %.not156, label %308, label %304, !llvm.loop !44

308:                                              ; preds = %304
  %309 = trunc nsw i64 %indvars.iv.next245 to i32
  %310 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

311:                                              ; preds = %293
  %312 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.232) #4
  %313 = icmp eq i32 %312, 0
  br i1 %313, label %314, label %324

314:                                              ; preds = %311
  %315 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.233) #4
  %316 = icmp eq i32 %315, 0
  br i1 %316, label %.preheader190.preheader, label %347

.preheader190.preheader:                          ; preds = %314
  %317 = sext i32 %20 to i64
  br label %.preheader190

.preheader190:                                    ; preds = %.preheader190.preheader, %.preheader190
  %indvars.iv241 = phi i64 [ %317, %.preheader190.preheader ], [ %indvars.iv.next242, %.preheader190 ]
  %indvars.iv.next242 = add nsw i64 %indvars.iv241, -1
  %318 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %indvars.iv.next242
  %319 = load ptr, ptr %318, align 8, !tbaa !9
  %320 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %319, ptr noundef nonnull dereferenceable(1) @.str.161) #4
  %.not = icmp eq i32 %320, 0
  br i1 %.not, label %321, label %.preheader190, !llvm.loop !45

321:                                              ; preds = %.preheader190
  %322 = trunc nsw i64 %indvars.iv.next242 to i32
  %323 = getelementptr inbounds %struct.AtomStr, ptr %4, i64 %5, i32 1
  br label %.sink.split

324:                                              ; preds = %311
  %325 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %40, ptr noundef nonnull dereferenceable(1) @.str.234) #4
  %326 = icmp eq i32 %325, 0
  br i1 %326, label %327, label %347

327:                                              ; preds = %324
  %328 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.235) #4
  %329 = icmp eq i32 %328, 0
  br i1 %329, label %330, label %332

330:                                              ; preds = %327
  %331 = getelementptr inbounds i8, ptr %6, i64 8
  br label %.sink.split

332:                                              ; preds = %327
  %333 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.236) #4
  %334 = icmp eq i32 %333, 0
  br i1 %334, label %335, label %338

335:                                              ; preds = %332
  %336 = add nsw i32 %0, -1
  %337 = getelementptr inbounds i8, ptr %6, i64 8
  br label %.sink.split

338:                                              ; preds = %332
  %339 = tail call i32 @strcmp(ptr noundef nonnull dereferenceable(1) %7, ptr noundef nonnull dereferenceable(1) @.str.237) #4
  %340 = icmp eq i32 %339, 0
  br i1 %340, label %341, label %347

341:                                              ; preds = %338
  %342 = add nsw i32 %0, -2
  %343 = getelementptr inbounds i8, ptr %6, i64 8
  br label %.sink.split

.sink.split:                                      ; preds = %29, %60, %70, %50, %106, %152, %142, %208, %198, %257, %272, %242, %308, %335, %341, %330, %321, %290, %229, %170, %180, %119, %129, %83, %93, %36
  %.sink309 = phi ptr [ %38, %36 ], [ %95, %93 ], [ %85, %83 ], [ %131, %129 ], [ %121, %119 ], [ %182, %180 ], [ %172, %170 ], [ %231, %229 ], [ %292, %290 ], [ %323, %321 ], [ %331, %330 ], [ %343, %341 ], [ %337, %335 ], [ %310, %308 ], [ %244, %242 ], [ %274, %272 ], [ %259, %257 ], [ %200, %198 ], [ %210, %208 ], [ %144, %142 ], [ %154, %152 ], [ %108, %106 ], [ %52, %50 ], [ %72, %70 ], [ %62, %60 ], [ %31, %29 ]
  %.sink306 = phi i32 [ %37, %36 ], [ %94, %93 ], [ %84, %83 ], [ %130, %129 ], [ %120, %119 ], [ %181, %180 ], [ %171, %170 ], [ %230, %229 ], [ %291, %290 ], [ %322, %321 ], [ %0, %330 ], [ %342, %341 ], [ %336, %335 ], [ %309, %308 ], [ %243, %242 ], [ %273, %272 ], [ %258, %257 ], [ %199, %198 ], [ %209, %208 ], [ %143, %142 ], [ %153, %152 ], [ %107, %106 ], [ %51, %50 ], [ %71, %70 ], [ %61, %60 ], [ %30, %29 ]
  %.sink = phi i8 [ 65, %36 ], [ 65, %93 ], [ 68, %83 ], [ 65, %129 ], [ 68, %119 ], [ 65, %180 ], [ 68, %170 ], [ 68, %229 ], [ 65, %290 ], [ 83, %321 ], [ 65, %330 ], [ 68, %341 ], [ 68, %335 ], [ 65, %308 ], [ 68, %242 ], [ 68, %272 ], [ 68, %257 ], [ 68, %198 ], [ 65, %208 ], [ 68, %142 ], [ 65, %152 ], [ 68, %106 ], [ 68, %50 ], [ 65, %70 ], [ 68, %60 ], [ 68, %29 ]
  %.23.ph = phi i32 [ %37, %36 ], [ %94, %93 ], [ %84, %83 ], [ %130, %129 ], [ %120, %119 ], [ %181, %180 ], [ %171, %170 ], [ %230, %229 ], [ %291, %290 ], [ %322, %321 ], [ %20, %330 ], [ %20, %341 ], [ %20, %335 ], [ %309, %308 ], [ %243, %242 ], [ %273, %272 ], [ %258, %257 ], [ %199, %198 ], [ %209, %208 ], [ %143, %142 ], [ %153, %152 ], [ %107, %106 ], [ %51, %50 ], [ %71, %70 ], [ %61, %60 ], [ %30, %29 ]
  %344 = load ptr, ptr %.sink309, align 8, !tbaa !46
  %345 = getelementptr inbounds i8, ptr %344, i64 84
  store i32 %.sink306, ptr %345, align 4, !tbaa !47
  %346 = getelementptr inbounds i8, ptr %344, i64 88
  store i8 %.sink, ptr %346, align 8, !tbaa !53
  br label %347

347:                                              ; preds = %.sink.split, %86, %122, %173, %220, %281, %314, %338, %324, %299, %263, %201, %145, %99, %63
  %.23 = phi i32 [ %20, %63 ], [ %20, %86 ], [ %20, %99 ], [ %20, %122 ], [ %20, %145 ], [ %20, %173 ], [ %20, %201 ], [ %20, %220 ], [ %20, %263 ], [ %20, %281 ], [ %20, %299 ], [ %20, %314 ], [ %20, %338 ], [ %20, %324 ], [ %.23.ph, %.sink.split ]
  %348 = sext i32 %15 to i64
  %349 = getelementptr inbounds %struct.AAStr, ptr %2, i64 %348, i32 2
  %350 = load i32, ptr %349, align 4, !tbaa !54
  %351 = icmp slt i32 %.23, %350
  br i1 %351, label %352, label %355

352:                                              ; preds = %347
  %353 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.238, i32 noundef %0, i32 noundef %15, ptr noundef %7)
  %354 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.129, ptr noundef nonnull @.str.2, i32 noundef 1844)
  tail call void @exit(i32 noundef 1) #5
  unreachable

355:                                              ; preds = %347
  ret void
}

attributes #0 = { mustprogress nofree nounwind willreturn memory(argmem: read) "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cmov,+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
attributes #1 = { 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 #2 = { 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 #3 = { 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 #4 = { nounwind willreturn memory(read) }
attributes #5 = { 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 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !6, i64 0}
!10 = !{!"AtomStr", !6, i64 0, !6, i64 8}
!11 = !{!12, !13, i64 108}
!12 = !{!"PropertyStr", !7, i64 0, !7, i64 8, !7, i64 40, !13, i64 48, !13, i64 52, !13, i64 56, !14, i64 64, !14, i64 72, !7, i64 80, !15, i64 104, !6, i64 120, !6, i64 128}
!13 = !{!"int", !7, i64 0}
!14 = !{!"double", !7, i64 0}
!15 = !{!"AtomSeqStr", !13, i64 0, !13, i64 4, !13, i64 8}
!16 = !{!17, !13, i64 12}
!17 = !{!"PepStr", !13, i64 0, !13, i64 4, !13, i64 8, !13, i64 12, !14, i64 16}
!18 = !{!12, !13, i64 112}
!19 = !{!20, !13, i64 16}
!20 = !{!"AAStr", !7, i64 0, !13, i64 8, !13, i64 12, !13, i64 16, !13, i64 20, !14, i64 24}
!21 = !{!12, !13, i64 52}
!22 = distinct !{!22, !23}
!23 = !{!"llvm.loop.mustprogress"}
!24 = distinct !{!24, !23}
!25 = distinct !{!25, !23}
!26 = distinct !{!26, !23}
!27 = distinct !{!27, !23}
!28 = distinct !{!28, !23}
!29 = distinct !{!29, !23}
!30 = distinct !{!30, !23}
!31 = distinct !{!31, !23}
!32 = distinct !{!32, !23}
!33 = distinct !{!33, !23}
!34 = distinct !{!34, !23}
!35 = distinct !{!35, !23}
!36 = distinct !{!36, !23}
!37 = distinct !{!37, !23}
!38 = distinct !{!38, !23}
!39 = distinct !{!39, !23}
!40 = distinct !{!40, !23}
!41 = distinct !{!41, !23}
!42 = distinct !{!42, !23}
!43 = distinct !{!43, !23}
!44 = distinct !{!44, !23}
!45 = distinct !{!45, !23}
!46 = !{!10, !6, i64 8}
!47 = !{!48, !13, i64 84}
!48 = !{!"DynamicStr", !7, i64 0, !7, i64 16, !7, i64 48, !49, i64 80, !50, i64 96, !51, i64 128}
!49 = !{!"HBStr", !13, i64 0, !13, i64 4, !7, i64 8, !13, i64 12}
!50 = !{!"HBNeighborStr", !7, i64 0, !13, i64 20, !13, i64 24}
!51 = !{!"InteractionEventStr", !13, i64 0, !52, i64 8, !52, i64 16, !14, i64 24, !14, i64 32, !13, i64 40, !13, i64 44}
!52 = !{!"long", !7, i64 0}
!53 = !{!48, !7, i64 88}
!54 = !{!20, !13, i64 12}


; Effective O3 passes: BDCEPass,EarlyCSEPass,GVNPass,GlobalOptPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,InstSimplifyPass,LCSSAPass,LoopSimplifyPass,LoopUnrollPass,ReassociatePass,SROAPass,SimplifyCFGPass,TailCallElimPass