; LLVM IR from jingweizhanghuai/Morn :: src/deep_learning (morn_tensor_data)

; 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.MHandle = type { i32, i32, ptr, ptr }
%struct.HandleTrainData = type { ptr, ptr, ptr, ptr, ptr, ptr, i32, i32, i32, i32, i32 }
%struct.MList = type { i32, ptr }
%struct.MLayer = type { [32 x i8], i32, ptr, ptr, ptr, i32 }
%struct.MTensor = type { i32, i32, i32, i32, ptr, i32 }
%struct.MVector = type { i32, ptr }

@.str = external hidden unnamed_addr constant [92 x i8], align 1
@morn_datafunc = external dso_local global ptr, align 8
@.str.4 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [13 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [8 x i8], align 1
@__FUNCTION__.mTrainData = external hidden unnamed_addr constant [11 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [19 x i8], align 1
@.str.17 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [18 x i8], align 1

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

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

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

declare void @m_Exception(i32 noundef, i32 noundef, ptr noundef, i32 noundef, ptr noundef, ptr noundef, ...) #2

declare ptr @GetHandle(ptr noundef, i32 noundef, i32 noundef, ptr noundef) #2

declare ptr @ListCreate(i32 noundef, ptr noundef) #2

declare i32 @m_Rand(i32 noundef, i32 noundef) #2

; Function Attrs: nounwind uwtable
declare dso_local void @endTrainData(ptr noundef) #1

declare void @mVectorRelease(ptr noundef) #2

declare void @m_Free(ptr noundef) #2

; Function Attrs: nounwind uwtable
define dso_local void @mTrainData(ptr noundef %0) #1 {
  %2 = alloca ptr, align 8
  %3 = alloca ptr, align 8
  %4 = alloca ptr, align 8
  %5 = alloca ptr, align 8
  %6 = alloca float, align 4
  %7 = alloca float, align 4
  %8 = alloca i32, align 4
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca ptr, align 8
  %12 = alloca i32, align 4
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca i32, align 4
  %16 = alloca i32, align 4
  %17 = alloca i32, align 4
  %18 = alloca i32, align 4
  %19 = alloca i32, align 4
  %20 = alloca i32, align 4
  %21 = alloca ptr, align 8
  %22 = alloca ptr, align 8
  %23 = alloca i32, align 4
  %24 = alloca i32, align 4
  %25 = alloca i32, align 4
  %26 = alloca ptr, align 8
  %27 = alloca i32, align 4
  %28 = alloca i32, align 4
  %29 = alloca ptr, align 8
  %30 = alloca i32, align 4
  %31 = alloca i32, align 4
  %32 = alloca i32, align 4
  %33 = alloca ptr, align 8
  %34 = alloca ptr, align 8
  %35 = alloca ptr, align 8
  store ptr %0, ptr %2, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %3) #4
  %36 = load ptr, ptr %2, align 8, !tbaa !5
  %37 = call ptr @GetHandle(ptr noundef %36, i32 noundef 72, i32 noundef -286066283, ptr noundef @endTrainData)
  store ptr %37, ptr %3, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %4) #4
  %38 = load ptr, ptr %3, align 8, !tbaa !5
  %39 = getelementptr inbounds %struct.MHandle, ptr %38, i32 0, i32 3
  %40 = load ptr, ptr %39, align 8, !tbaa !9
  store ptr %40, ptr %4, align 8, !tbaa !5
  %41 = load ptr, ptr %3, align 8, !tbaa !5
  %42 = getelementptr inbounds %struct.MHandle, ptr %41, i32 0, i32 1
  %43 = load volatile i32, ptr %42, align 4, !tbaa !12
  %44 = icmp eq i32 %43, 0
  br i1 %44, label %45, label %586

45:                                               ; preds = %1
  %46 = load ptr, ptr %4, align 8, !tbaa !5
  %47 = getelementptr inbounds %struct.HandleTrainData, ptr %46, i32 0, i32 0
  %48 = load ptr, ptr %47, align 8, !tbaa !13
  %49 = icmp eq ptr %48, null
  br i1 %49, label %50, label %55

50:                                               ; preds = %45
  %51 = load ptr, ptr %2, align 8, !tbaa !5
  %52 = call ptr @mNetworkGenerate(ptr noundef %51)
  %53 = load ptr, ptr %4, align 8, !tbaa !5
  %54 = getelementptr inbounds %struct.HandleTrainData, ptr %53, i32 0, i32 0
  store ptr %52, ptr %54, align 8, !tbaa !13
  br label %55

55:                                               ; preds = %50, %45
  call void @llvm.lifetime.start.p0(i64 8, ptr %5) #4
  %56 = load ptr, ptr %4, align 8, !tbaa !5
  %57 = getelementptr inbounds %struct.HandleTrainData, ptr %56, i32 0, i32 6
  store i32 1, ptr %57, align 8, !tbaa !15
  %58 = load ptr, ptr %2, align 8, !tbaa !5
  %59 = call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %58, i64 noundef ptrtoint (ptr @.str.4 to i64), i64 noundef ptrtoint (ptr @.str.5 to i64), ptr noundef inttoptr (i64 -1 to ptr), i32 noundef -1)
  store ptr %59, ptr %5, align 8, !tbaa !5
  %60 = load ptr, ptr %5, align 8, !tbaa !5
  %61 = icmp ne ptr %60, null
  br i1 %61, label %62, label %67

62:                                               ; preds = %55
  %63 = load ptr, ptr %5, align 8, !tbaa !5
  %64 = call i32 @atoi(ptr noundef %63) #5
  %65 = load ptr, ptr %4, align 8, !tbaa !5
  %66 = getelementptr inbounds %struct.HandleTrainData, ptr %65, i32 0, i32 6
  store i32 %64, ptr %66, align 8, !tbaa !15
  br label %67

67:                                               ; preds = %62, %55
  call void @llvm.lifetime.start.p0(i64 4, ptr %6) #4
  store float 5.000000e-01, ptr %6, align 4, !tbaa !16
  %68 = load ptr, ptr %2, align 8, !tbaa !5
  %69 = call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %68, i64 noundef ptrtoint (ptr @.str.4 to i64), i64 noundef ptrtoint (ptr @.str.6 to i64), ptr noundef inttoptr (i64 -1 to ptr), i32 noundef -1)
  store ptr %69, ptr %5, align 8, !tbaa !5
  %70 = load ptr, ptr %5, align 8, !tbaa !5
  %71 = icmp ne ptr %70, null
  br i1 %71, label %72, label %76

72:                                               ; preds = %67
  %73 = load ptr, ptr %5, align 8, !tbaa !5
  %74 = call double @atof(ptr noundef %73) #5
  %75 = fptrunc double %74 to float
  store float %75, ptr %6, align 4, !tbaa !16
  br label %76

76:                                               ; preds = %72, %67
  %77 = load float, ptr %6, align 4, !tbaa !16
  %78 = fcmp olt float %77, 1.000000e+00
  br i1 %78, label %79, label %82

79:                                               ; preds = %76
  %80 = load float, ptr %6, align 4, !tbaa !16
  %81 = fdiv float 1.000000e+00, %80
  store float %81, ptr %6, align 4, !tbaa !16
  br label %82

82:                                               ; preds = %79, %76
  call void @llvm.lifetime.start.p0(i64 4, ptr %7) #4
  %83 = load ptr, ptr %4, align 8, !tbaa !5
  %84 = getelementptr inbounds %struct.HandleTrainData, ptr %83, i32 0, i32 6
  %85 = load i32, ptr %84, align 8, !tbaa !15
  %86 = sitofp i32 %85 to float
  %87 = fdiv float 2.000000e+00, %86
  store float %87, ptr %7, align 4, !tbaa !16
  %88 = load ptr, ptr %2, align 8, !tbaa !5
  %89 = call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %88, i64 noundef ptrtoint (ptr @.str.4 to i64), i64 noundef ptrtoint (ptr @.str.7 to i64), ptr noundef inttoptr (i64 -1 to ptr), i32 noundef -1)
  store ptr %89, ptr %5, align 8, !tbaa !5
  %90 = load ptr, ptr %5, align 8, !tbaa !5
  %91 = icmp ne ptr %90, null
  br i1 %91, label %92, label %96

92:                                               ; preds = %82
  %93 = load ptr, ptr %5, align 8, !tbaa !5
  %94 = call double @atof(ptr noundef %93) #5
  %95 = fptrunc double %94 to float
  store float %95, ptr %7, align 4, !tbaa !16
  br label %96

96:                                               ; preds = %92, %82
  %97 = load float, ptr %7, align 4, !tbaa !16
  %98 = fcmp ogt float %97, 1.000000e+00
  br i1 %98, label %99, label %104

99:                                               ; preds = %96
  %100 = load float, ptr %7, align 4, !tbaa !16
  %101 = fpext float %100 to double
  %102 = fdiv double 1.000000e+00, %101
  %103 = fptrunc double %102 to float
  store float %103, ptr %7, align 4, !tbaa !16
  br label %104

104:                                              ; preds = %99, %96
  %105 = load float, ptr %7, align 4, !tbaa !16
  %106 = fcmp olt float %105, 1.000000e+00
  br i1 %106, label %107, label %121

107:                                              ; preds = %104
  %108 = load float, ptr %6, align 4, !tbaa !16
  %109 = load float, ptr %7, align 4, !tbaa !16
  %110 = fsub float 1.000000e+00, %109
  %111 = fdiv float 1.000000e+00, %110
  %112 = fcmp ogt float %108, %111
  br i1 %112, label %113, label %115

113:                                              ; preds = %107
  %114 = load float, ptr %6, align 4, !tbaa !16
  br label %119

115:                                              ; preds = %107
  %116 = load float, ptr %7, align 4, !tbaa !16
  %117 = fsub float 1.000000e+00, %116
  %118 = fdiv float 1.000000e+00, %117
  br label %119

119:                                              ; preds = %115, %113
  %120 = phi float [ %114, %113 ], [ %118, %115 ]
  store float %120, ptr %6, align 4, !tbaa !16
  br label %121

121:                                              ; preds = %119, %104
  %122 = load ptr, ptr %4, align 8, !tbaa !5
  %123 = getelementptr inbounds %struct.HandleTrainData, ptr %122, i32 0, i32 6
  %124 = load i32, ptr %123, align 8, !tbaa !15
  %125 = sitofp i32 %124 to float
  %126 = load float, ptr %6, align 4, !tbaa !16
  %127 = fmul float %125, %126
  %128 = fpext float %127 to double
  %129 = fadd double %128, 5.000000e-01
  %130 = fptosi double %129 to i32
  %131 = load ptr, ptr %4, align 8, !tbaa !5
  %132 = getelementptr inbounds %struct.HandleTrainData, ptr %131, i32 0, i32 7
  store i32 %130, ptr %132, align 4, !tbaa !18
  %133 = load ptr, ptr %4, align 8, !tbaa !5
  %134 = getelementptr inbounds %struct.HandleTrainData, ptr %133, i32 0, i32 7
  %135 = load i32, ptr %134, align 4, !tbaa !18
  %136 = sitofp i32 %135 to float
  %137 = load float, ptr %7, align 4, !tbaa !16
  %138 = fmul float %136, %137
  %139 = fpext float %138 to double
  %140 = fadd double %139, 5.000000e-01
  %141 = fptosi double %140 to i32
  %142 = load ptr, ptr %4, align 8, !tbaa !5
  %143 = getelementptr inbounds %struct.HandleTrainData, ptr %142, i32 0, i32 8
  store i32 %141, ptr %143, align 8, !tbaa !19
  %144 = load ptr, ptr %4, align 8, !tbaa !5
  %145 = getelementptr inbounds %struct.HandleTrainData, ptr %144, i32 0, i32 8
  %146 = load i32, ptr %145, align 8, !tbaa !19
  %147 = icmp slt i32 %146, 1
  br i1 %147, label %148, label %151

148:                                              ; preds = %121
  %149 = load ptr, ptr %4, align 8, !tbaa !5
  %150 = getelementptr inbounds %struct.HandleTrainData, ptr %149, i32 0, i32 8
  store i32 1, ptr %150, align 8, !tbaa !19
  br label %151

151:                                              ; preds = %148, %121
  %152 = call i32 @mTensorRegisterIndex(ptr noundef @.str.8)
  %153 = load ptr, ptr %4, align 8, !tbaa !5
  %154 = getelementptr inbounds %struct.HandleTrainData, ptr %153, i32 0, i32 9
  store i32 %152, ptr %154, align 4, !tbaa !20
  %155 = call i32 @mTensorRegisterIndex(ptr noundef @.str.9)
  %156 = load ptr, ptr %4, align 8, !tbaa !5
  %157 = getelementptr inbounds %struct.HandleTrainData, ptr %156, i32 0, i32 10
  store i32 %155, ptr %157, align 8, !tbaa !21
  %158 = load ptr, ptr %4, align 8, !tbaa !5
  %159 = getelementptr inbounds %struct.HandleTrainData, ptr %158, i32 0, i32 4
  %160 = load ptr, ptr %159, align 8, !tbaa !22
  %161 = icmp eq ptr %160, null
  br i1 %161, label %162, label %166

162:                                              ; preds = %151
  %163 = call ptr @ListCreate(i32 noundef -1, ptr noundef null)
  %164 = load ptr, ptr %4, align 8, !tbaa !5
  %165 = getelementptr inbounds %struct.HandleTrainData, ptr %164, i32 0, i32 4
  store ptr %163, ptr %165, align 8, !tbaa !22
  br label %200

166:                                              ; preds = %151
  %167 = load ptr, ptr %4, align 8, !tbaa !5
  %168 = getelementptr inbounds %struct.HandleTrainData, ptr %167, i32 0, i32 2
  %169 = load ptr, ptr %168, align 8, !tbaa !23
  %170 = icmp ne ptr %169, null
  br i1 %170, label %171, label %199

171:                                              ; preds = %166
  call void @llvm.lifetime.start.p0(i64 4, ptr %8) #4
  store i32 0, ptr %8, align 4, !tbaa !24
  br label %172

172:                                              ; preds = %189, %171
  %173 = load i32, ptr %8, align 4, !tbaa !24
  %174 = load ptr, ptr %4, align 8, !tbaa !5
  %175 = getelementptr inbounds %struct.HandleTrainData, ptr %174, i32 0, i32 4
  %176 = load ptr, ptr %175, align 8, !tbaa !22
  %177 = getelementptr inbounds %struct.MList, ptr %176, i32 0, i32 0
  %178 = load i32, ptr %177, align 8, !tbaa !25
  %179 = icmp slt i32 %173, %178
  br i1 %179, label %181, label %180

180:                                              ; preds = %172
  call void @llvm.lifetime.end.p0(i64 4, ptr %8) #4
  br label %192

181:                                              ; preds = %172
  %182 = load ptr, ptr %4, align 8, !tbaa !5
  %183 = getelementptr inbounds %struct.HandleTrainData, ptr %182, i32 0, i32 2
  %184 = load ptr, ptr %183, align 8, !tbaa !23
  %185 = load i32, ptr %8, align 4, !tbaa !24
  %186 = sext i32 %185 to i64
  %187 = getelementptr inbounds ptr, ptr %184, i64 %186
  %188 = load ptr, ptr %187, align 8, !tbaa !5
  call void @mVectorRelease(ptr noundef %188)
  br label %189

189:                                              ; preds = %181
  %190 = load i32, ptr %8, align 4, !tbaa !24
  %191 = add nsw i32 %190, 1
  store i32 %191, ptr %8, align 4, !tbaa !24
  br label %172, !llvm.loop !27

192:                                              ; preds = %180
  %193 = load ptr, ptr %4, align 8, !tbaa !5
  %194 = getelementptr inbounds %struct.HandleTrainData, ptr %193, i32 0, i32 2
  %195 = load ptr, ptr %194, align 8, !tbaa !23
  call void @m_Free(ptr noundef %195)
  %196 = load ptr, ptr %4, align 8, !tbaa !5
  %197 = getelementptr inbounds %struct.HandleTrainData, ptr %196, i32 0, i32 3
  %198 = load ptr, ptr %197, align 8, !tbaa !29
  call void @m_Free(ptr noundef %198)
  br label %199

199:                                              ; preds = %192, %166
  br label %200

200:                                              ; preds = %199, %162
  %201 = load ptr, ptr %4, align 8, !tbaa !5
  %202 = getelementptr inbounds %struct.HandleTrainData, ptr %201, i32 0, i32 4
  %203 = load ptr, ptr %202, align 8, !tbaa !22
  call void @mListClear(ptr noundef %203)
  call void @llvm.lifetime.start.p0(i64 4, ptr %9) #4
  store i32 0, ptr %9, align 4, !tbaa !24
  br label %204

204:                                              ; preds = %411, %200
  %205 = load i32, ptr %9, align 4, !tbaa !24
  %206 = load ptr, ptr %4, align 8, !tbaa !5
  %207 = getelementptr inbounds %struct.HandleTrainData, ptr %206, i32 0, i32 0
  %208 = load ptr, ptr %207, align 8, !tbaa !13
  %209 = getelementptr inbounds %struct.MList, ptr %208, i32 0, i32 0
  %210 = load i32, ptr %209, align 8, !tbaa !25
  %211 = icmp slt i32 %205, %210
  br i1 %211, label %213, label %212

212:                                              ; preds = %204
  store i32 5, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %9) #4
  br label %414

213:                                              ; preds = %204
  call void @llvm.lifetime.start.p0(i64 8, ptr %11) #4
  %214 = load ptr, ptr %4, align 8, !tbaa !5
  %215 = getelementptr inbounds %struct.HandleTrainData, ptr %214, i32 0, i32 0
  %216 = load ptr, ptr %215, align 8, !tbaa !13
  %217 = getelementptr inbounds %struct.MList, ptr %216, i32 0, i32 1
  %218 = load ptr, ptr %217, align 8, !tbaa !30
  %219 = load i32, ptr %9, align 4, !tbaa !24
  %220 = sext i32 %219 to i64
  %221 = getelementptr inbounds ptr, ptr %218, i64 %220
  %222 = load ptr, ptr %221, align 8, !tbaa !5
  store ptr %222, ptr %11, align 8, !tbaa !5
  %223 = load ptr, ptr %11, align 8, !tbaa !5
  %224 = getelementptr inbounds %struct.MLayer, ptr %223, i32 0, i32 1
  %225 = load i32, ptr %224, align 8, !tbaa !31
  %226 = load ptr, ptr %4, align 8, !tbaa !5
  %227 = getelementptr inbounds %struct.HandleTrainData, ptr %226, i32 0, i32 9
  %228 = load i32, ptr %227, align 4, !tbaa !20
  %229 = icmp ne i32 %225, %228
  br i1 %229, label %230, label %239

230:                                              ; preds = %213
  %231 = load ptr, ptr %11, align 8, !tbaa !5
  %232 = getelementptr inbounds %struct.MLayer, ptr %231, i32 0, i32 1
  %233 = load i32, ptr %232, align 8, !tbaa !31
  %234 = load ptr, ptr %4, align 8, !tbaa !5
  %235 = getelementptr inbounds %struct.HandleTrainData, ptr %234, i32 0, i32 10
  %236 = load i32, ptr %235, align 8, !tbaa !21
  %237 = icmp ne i32 %233, %236
  br i1 %237, label %238, label %239

238:                                              ; preds = %230
  store i32 7, ptr %10, align 4
  br label %408

239:                                              ; preds = %230, %213
  %240 = load ptr, ptr %2, align 8, !tbaa !5
  %241 = load ptr, ptr %11, align 8, !tbaa !5
  %242 = getelementptr inbounds %struct.MLayer, ptr %241, i32 0, i32 0
  %243 = getelementptr inbounds [32 x i8], ptr %242, i64 0, i64 0
  %244 = ptrtoint ptr %243 to i64
  %245 = call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %240, i64 noundef %244, i64 noundef ptrtoint (ptr @.str.10 to i64), ptr noundef inttoptr (i64 -1 to ptr), i32 noundef -1)
  store ptr %245, ptr %5, align 8, !tbaa !5
  br label %246

246:                                              ; preds = %239
  call void @llvm.lifetime.start.p0(i64 4, ptr %12) #4
  %247 = load ptr, ptr %5, align 8, !tbaa !5
  %248 = icmp eq ptr %247, null
  %249 = zext i1 %248 to i32
  store i32 %249, ptr %12, align 4, !tbaa !24
  %250 = load i32, ptr %12, align 4, !tbaa !24
  %251 = icmp ne i32 %250, 0
  br i1 %251, label %252, label %254

252:                                              ; preds = %246
  %253 = load i32, ptr %12, align 4, !tbaa !24
  call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef %253, i32 noundef -1, ptr noundef @.str, i32 noundef 175, ptr noundef @__FUNCTION__.mTrainData, ptr noundef @.str.11)
  br label %254

254:                                              ; preds = %252, %246
  call void @llvm.lifetime.end.p0(i64 4, ptr %12) #4
  br label %255

255:                                              ; preds = %254
  br label %256

256:                                              ; preds = %255
  call void @llvm.lifetime.start.p0(i64 4, ptr %13) #4
  %257 = load ptr, ptr %5, align 8, !tbaa !5
  %258 = call i32 @atoi(ptr noundef %257) #5
  store i32 %258, ptr %13, align 4, !tbaa !24
  %259 = load ptr, ptr %2, align 8, !tbaa !5
  %260 = load ptr, ptr %11, align 8, !tbaa !5
  %261 = getelementptr inbounds %struct.MLayer, ptr %260, i32 0, i32 0
  %262 = getelementptr inbounds [32 x i8], ptr %261, i64 0, i64 0
  %263 = ptrtoint ptr %262 to i64
  %264 = call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %259, i64 noundef %263, i64 noundef ptrtoint (ptr @.str.12 to i64), ptr noundef inttoptr (i64 -1 to ptr), i32 noundef -1)
  store ptr %264, ptr %5, align 8, !tbaa !5
  br label %265

265:                                              ; preds = %256
  call void @llvm.lifetime.start.p0(i64 4, ptr %14) #4
  %266 = load ptr, ptr %5, align 8, !tbaa !5
  %267 = icmp eq ptr %266, null
  %268 = zext i1 %267 to i32
  store i32 %268, ptr %14, align 4, !tbaa !24
  %269 = load i32, ptr %14, align 4, !tbaa !24
  %270 = icmp ne i32 %269, 0
  br i1 %270, label %271, label %273

271:                                              ; preds = %265
  %272 = load i32, ptr %14, align 4, !tbaa !24
  call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef %272, i32 noundef -1, ptr noundef @.str, i32 noundef 176, ptr noundef @__FUNCTION__.mTrainData, ptr noundef @.str.13)
  br label %273

273:                                              ; preds = %271, %265
  call void @llvm.lifetime.end.p0(i64 4, ptr %14) #4
  br label %274

274:                                              ; preds = %273
  br label %275

275:                                              ; preds = %274
  call void @llvm.lifetime.start.p0(i64 4, ptr %15) #4
  %276 = load ptr, ptr %5, align 8, !tbaa !5
  %277 = call i32 @atoi(ptr noundef %276) #5
  store i32 %277, ptr %15, align 4, !tbaa !24
  %278 = load ptr, ptr %2, align 8, !tbaa !5
  %279 = load ptr, ptr %11, align 8, !tbaa !5
  %280 = getelementptr inbounds %struct.MLayer, ptr %279, i32 0, i32 0
  %281 = getelementptr inbounds [32 x i8], ptr %280, i64 0, i64 0
  %282 = ptrtoint ptr %281 to i64
  %283 = call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %278, i64 noundef %282, i64 noundef ptrtoint (ptr @.str.14 to i64), ptr noundef inttoptr (i64 -1 to ptr), i32 noundef -1)
  store ptr %283, ptr %5, align 8, !tbaa !5
  br label %284

284:                                              ; preds = %275
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #4
  %285 = load ptr, ptr %5, align 8, !tbaa !5
  %286 = icmp eq ptr %285, null
  %287 = zext i1 %286 to i32
  store i32 %287, ptr %16, align 4, !tbaa !24
  %288 = load i32, ptr %16, align 4, !tbaa !24
  %289 = icmp ne i32 %288, 0
  br i1 %289, label %290, label %292

290:                                              ; preds = %284
  %291 = load i32, ptr %16, align 4, !tbaa !24
  call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef %291, i32 noundef -1, ptr noundef @.str, i32 noundef 177, ptr noundef @__FUNCTION__.mTrainData, ptr noundef @.str.15)
  br label %292

292:                                              ; preds = %290, %284
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #4
  br label %293

293:                                              ; preds = %292
  br label %294

294:                                              ; preds = %293
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #4
  %295 = load ptr, ptr %5, align 8, !tbaa !5
  %296 = call i32 @atoi(ptr noundef %295) #5
  store i32 %296, ptr %17, align 4, !tbaa !24
  %297 = load ptr, ptr %11, align 8, !tbaa !5
  %298 = getelementptr inbounds %struct.MLayer, ptr %297, i32 0, i32 2
  %299 = load ptr, ptr %298, align 8, !tbaa !33
  %300 = icmp eq ptr %299, null
  br i1 %300, label %301, label %310

301:                                              ; preds = %294
  %302 = load ptr, ptr %4, align 8, !tbaa !5
  %303 = getelementptr inbounds %struct.HandleTrainData, ptr %302, i32 0, i32 7
  %304 = load i32, ptr %303, align 4, !tbaa !18
  %305 = add nsw i32 %304, 0
  %306 = load i32, ptr %13, align 4, !tbaa !24
  %307 = load i32, ptr %15, align 4, !tbaa !24
  %308 = load i32, ptr %17, align 4, !tbaa !24
  %309 = call ptr @TensorCreate(i32 noundef %305, i32 noundef %306, i32 noundef %307, i32 noundef %308, ptr noundef null, i32 noundef -1)
  br label %395

310:                                              ; preds = %294
  br label %311

311:                                              ; preds = %310
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #4
  store i32 5, ptr %18, align 4, !tbaa !24
  %312 = load i32, ptr %18, align 4, !tbaa !24
  %313 = icmp eq i32 %312, 0
  br i1 %313, label %314, label %323

314:                                              ; preds = %311
  %315 = load ptr, ptr %11, align 8, !tbaa !5
  %316 = getelementptr inbounds %struct.MLayer, ptr %315, i32 0, i32 2
  %317 = load ptr, ptr %316, align 8, !tbaa !33
  %318 = load ptr, ptr %11, align 8, !tbaa !5
  %319 = getelementptr inbounds %struct.MLayer, ptr %318, i32 0, i32 2
  %320 = load ptr, ptr %319, align 8, !tbaa !33
  %321 = getelementptr inbounds %struct.MTensor, ptr %320, i32 0, i32 4
  %322 = load ptr, ptr %321, align 8, !tbaa !34
  call void @TensorRedefine(ptr noundef %317, i32 noundef -1, i32 noundef -1, i32 noundef -1, i32 noundef -1, ptr noundef %322, i32 noundef -1)
  br label %392

323:                                              ; preds = %311
  %324 = load i32, ptr %18, align 4, !tbaa !24
  %325 = icmp eq i32 %324, 4
  br i1 %325, label %326, label %342

326:                                              ; preds = %323
  %327 = load ptr, ptr %11, align 8, !tbaa !5
  %328 = getelementptr inbounds %struct.MLayer, ptr %327, i32 0, i32 2
  %329 = load ptr, ptr %328, align 8, !tbaa !33
  %330 = load ptr, ptr %4, align 8, !tbaa !5
  %331 = getelementptr inbounds %struct.HandleTrainData, ptr %330, i32 0, i32 7
  %332 = load i32, ptr %331, align 4, !tbaa !18
  %333 = add nsw i32 %332, 0
  %334 = load i32, ptr %13, align 4, !tbaa !24
  %335 = load i32, ptr %15, align 4, !tbaa !24
  %336 = load i32, ptr %17, align 4, !tbaa !24
  %337 = load ptr, ptr %11, align 8, !tbaa !5
  %338 = getelementptr inbounds %struct.MLayer, ptr %337, i32 0, i32 2
  %339 = load ptr, ptr %338, align 8, !tbaa !33
  %340 = getelementptr inbounds %struct.MTensor, ptr %339, i32 0, i32 4
  %341 = load ptr, ptr %340, align 8, !tbaa !34
  call void @TensorRedefine(ptr noundef %329, i32 noundef %333, i32 noundef %334, i32 noundef %335, i32 noundef %336, ptr noundef %341, i32 noundef -1)
  br label %391

342:                                              ; preds = %323
  %343 = load i32, ptr %18, align 4, !tbaa !24
  %344 = icmp eq i32 %343, 5
  br i1 %344, label %345, label %361

345:                                              ; preds = %342
  %346 = load ptr, ptr %11, align 8, !tbaa !5
  %347 = getelementptr inbounds %struct.MLayer, ptr %346, i32 0, i32 2
  %348 = load ptr, ptr %347, align 8, !tbaa !33
  %349 = load ptr, ptr %4, align 8, !tbaa !5
  %350 = getelementptr inbounds %struct.HandleTrainData, ptr %349, i32 0, i32 7
  %351 = load i32, ptr %350, align 4, !tbaa !18
  %352 = add nsw i32 %351, 0
  %353 = load i32, ptr %13, align 4, !tbaa !24
  %354 = load i32, ptr %15, align 4, !tbaa !24
  %355 = load i32, ptr %17, align 4, !tbaa !24
  %356 = load ptr, ptr %11, align 8, !tbaa !5
  %357 = getelementptr inbounds %struct.MLayer, ptr %356, i32 0, i32 2
  %358 = load ptr, ptr %357, align 8, !tbaa !33
  %359 = getelementptr inbounds %struct.MTensor, ptr %358, i32 0, i32 4
  %360 = load ptr, ptr %359, align 8, !tbaa !34
  call void @TensorRedefine(ptr noundef %348, i32 noundef %352, i32 noundef %353, i32 noundef %354, i32 noundef %355, ptr noundef %360, i32 noundef -1)
  br label %390

361:                                              ; preds = %342
  %362 = load i32, ptr %18, align 4, !tbaa !24
  %363 = icmp eq i32 %362, 6
  br i1 %363, label %364, label %380

364:                                              ; preds = %361
  %365 = load ptr, ptr %11, align 8, !tbaa !5
  %366 = getelementptr inbounds %struct.MLayer, ptr %365, i32 0, i32 2
  %367 = load ptr, ptr %366, align 8, !tbaa !33
  %368 = load ptr, ptr %4, align 8, !tbaa !5
  %369 = getelementptr inbounds %struct.HandleTrainData, ptr %368, i32 0, i32 7
  %370 = load i32, ptr %369, align 4, !tbaa !18
  %371 = add nsw i32 %370, 0
  %372 = load i32, ptr %13, align 4, !tbaa !24
  %373 = load i32, ptr %15, align 4, !tbaa !24
  %374 = load i32, ptr %17, align 4, !tbaa !24
  %375 = load ptr, ptr %11, align 8, !tbaa !5
  %376 = getelementptr inbounds %struct.MLayer, ptr %375, i32 0, i32 2
  %377 = load ptr, ptr %376, align 8, !tbaa !33
  %378 = getelementptr inbounds %struct.MTensor, ptr %377, i32 0, i32 4
  %379 = load ptr, ptr %378, align 8, !tbaa !34
  call void @TensorRedefine(ptr noundef %367, i32 noundef %371, i32 noundef %372, i32 noundef %373, i32 noundef %374, ptr noundef %379, i32 noundef -1)
  br label %389

380:                                              ; preds = %361
  br label %381

381:                                              ; preds = %380
  call void @llvm.lifetime.start.p0(i64 4, ptr %19) #4
  store i32 1, ptr %19, align 4, !tbaa !24
  %382 = load i32, ptr %19, align 4, !tbaa !24
  %383 = icmp ne i32 %382, 0
  br i1 %383, label %384, label %386

384:                                              ; preds = %381
  %385 = load i32, ptr %19, align 4, !tbaa !24
  call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef %385, i32 noundef -1, ptr noundef @.str, i32 noundef 181, ptr noundef @__FUNCTION__.mTrainData, ptr noundef @.str.16)
  br label %386

386:                                              ; preds = %384, %381
  call void @llvm.lifetime.end.p0(i64 4, ptr %19) #4
  br label %387

387:                                              ; preds = %386
  br label %388

388:                                              ; preds = %387
  br label %389

389:                                              ; preds = %388, %364
  br label %390

390:                                              ; preds = %389, %345
  br label %391

391:                                              ; preds = %390, %326
  br label %392

392:                                              ; preds = %391, %314
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #4
  br label %393

393:                                              ; preds = %392
  br label %394

394:                                              ; preds = %393
  br label %395

395:                                              ; preds = %394, %301
  %396 = load ptr, ptr %4, align 8, !tbaa !5
  %397 = getelementptr inbounds %struct.HandleTrainData, ptr %396, i32 0, i32 6
  %398 = load i32, ptr %397, align 8, !tbaa !15
  %399 = load ptr, ptr %11, align 8, !tbaa !5
  %400 = getelementptr inbounds %struct.MLayer, ptr %399, i32 0, i32 2
  %401 = load ptr, ptr %400, align 8, !tbaa !33
  %402 = getelementptr inbounds %struct.MTensor, ptr %401, i32 0, i32 0
  store i32 %398, ptr %402, align 8, !tbaa !36
  %403 = load ptr, ptr %4, align 8, !tbaa !5
  %404 = getelementptr inbounds %struct.HandleTrainData, ptr %403, i32 0, i32 4
  %405 = load ptr, ptr %404, align 8, !tbaa !22
  %406 = load ptr, ptr %11, align 8, !tbaa !5
  %407 = call ptr @mListWrite(ptr noundef %405, i32 noundef -1, ptr noundef %406, i32 noundef 72)
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %15) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %13) #4
  store i32 0, ptr %10, align 4
  br label %408

408:                                              ; preds = %395, %238
  call void @llvm.lifetime.end.p0(i64 8, ptr %11) #4
  %409 = load i32, ptr %10, align 4
  switch i32 %409, label %729 [
    i32 0, label %410
    i32 7, label %411
  ]

410:                                              ; preds = %408
  br label %411

411:                                              ; preds = %410, %408
  %412 = load i32, ptr %9, align 4, !tbaa !24
  %413 = add nsw i32 %412, 1
  store i32 %413, ptr %9, align 4, !tbaa !24
  br label %204, !llvm.loop !37

414:                                              ; preds = %212
  %415 = load ptr, ptr @morn_datafunc, align 8, !tbaa !5
  %416 = icmp eq ptr %415, null
  br i1 %416, label %417, label %418

417:                                              ; preds = %414
  store ptr @MORNTensor, ptr @morn_datafunc, align 8, !tbaa !5
  br label %418

418:                                              ; preds = %417, %414
  %419 = load ptr, ptr %4, align 8, !tbaa !5
  %420 = getelementptr inbounds %struct.HandleTrainData, ptr %419, i32 0, i32 4
  %421 = load ptr, ptr %420, align 8, !tbaa !22
  %422 = getelementptr inbounds %struct.MList, ptr %421, i32 0, i32 0
  %423 = load i32, ptr %422, align 8, !tbaa !25
  %424 = sext i32 %423 to i64
  %425 = mul i64 %424, 8
  %426 = trunc i64 %425 to i32
  %427 = call ptr @m_Malloc(i32 noundef %426)
  %428 = load ptr, ptr %4, align 8, !tbaa !5
  %429 = getelementptr inbounds %struct.HandleTrainData, ptr %428, i32 0, i32 2
  store ptr %427, ptr %429, align 8, !tbaa !23
  %430 = load ptr, ptr %4, align 8, !tbaa !5
  %431 = getelementptr inbounds %struct.HandleTrainData, ptr %430, i32 0, i32 4
  %432 = load ptr, ptr %431, align 8, !tbaa !22
  %433 = getelementptr inbounds %struct.MList, ptr %432, i32 0, i32 0
  %434 = load i32, ptr %433, align 8, !tbaa !25
  %435 = sext i32 %434 to i64
  %436 = mul i64 %435, 8
  %437 = trunc i64 %436 to i32
  %438 = call ptr @m_Malloc(i32 noundef %437)
  %439 = load ptr, ptr %4, align 8, !tbaa !5
  %440 = getelementptr inbounds %struct.HandleTrainData, ptr %439, i32 0, i32 3
  store ptr %438, ptr %440, align 8, !tbaa !29
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #4
  store i32 0, ptr %20, align 4, !tbaa !24
  br label %441

441:                                              ; preds = %496, %418
  %442 = load i32, ptr %20, align 4, !tbaa !24
  %443 = load ptr, ptr %4, align 8, !tbaa !5
  %444 = getelementptr inbounds %struct.HandleTrainData, ptr %443, i32 0, i32 4
  %445 = load ptr, ptr %444, align 8, !tbaa !22
  %446 = getelementptr inbounds %struct.MList, ptr %445, i32 0, i32 0
  %447 = load i32, ptr %446, align 8, !tbaa !25
  %448 = icmp slt i32 %442, %447
  br i1 %448, label %450, label %449

449:                                              ; preds = %441
  store i32 18, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #4
  br label %499

450:                                              ; preds = %441
  call void @llvm.lifetime.start.p0(i64 8, ptr %21) #4
  %451 = load ptr, ptr %4, align 8, !tbaa !5
  %452 = getelementptr inbounds %struct.HandleTrainData, ptr %451, i32 0, i32 4
  %453 = load ptr, ptr %452, align 8, !tbaa !22
  %454 = getelementptr inbounds %struct.MList, ptr %453, i32 0, i32 1
  %455 = load ptr, ptr %454, align 8, !tbaa !30
  %456 = load i32, ptr %20, align 4, !tbaa !24
  %457 = sext i32 %456 to i64
  %458 = getelementptr inbounds ptr, ptr %455, i64 %457
  %459 = load ptr, ptr %458, align 8, !tbaa !5
  store ptr %459, ptr %21, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %22) #4
  %460 = load ptr, ptr %21, align 8, !tbaa !5
  %461 = getelementptr inbounds %struct.MLayer, ptr %460, i32 0, i32 2
  %462 = load ptr, ptr %461, align 8, !tbaa !33
  store ptr %462, ptr %22, align 8, !tbaa !5
  %463 = load ptr, ptr %22, align 8, !tbaa !5
  %464 = getelementptr inbounds %struct.MTensor, ptr %463, i32 0, i32 1
  %465 = load i32, ptr %464, align 4, !tbaa !38
  %466 = load ptr, ptr %22, align 8, !tbaa !5
  %467 = getelementptr inbounds %struct.MTensor, ptr %466, i32 0, i32 2
  %468 = load i32, ptr %467, align 8, !tbaa !39
  %469 = mul nsw i32 %465, %468
  %470 = load ptr, ptr %22, align 8, !tbaa !5
  %471 = getelementptr inbounds %struct.MTensor, ptr %470, i32 0, i32 3
  %472 = load i32, ptr %471, align 4, !tbaa !40
  %473 = mul nsw i32 %469, %472
  %474 = add nsw i32 %473, 0
  %475 = load ptr, ptr %22, align 8, !tbaa !5
  %476 = getelementptr inbounds %struct.MTensor, ptr %475, i32 0, i32 4
  %477 = load ptr, ptr %476, align 8, !tbaa !34
  %478 = getelementptr inbounds ptr, ptr %477, i64 0
  %479 = load ptr, ptr %478, align 8, !tbaa !5
  %480 = call ptr @VectorCreate(i32 noundef %474, ptr noundef %479)
  %481 = load ptr, ptr %4, align 8, !tbaa !5
  %482 = getelementptr inbounds %struct.HandleTrainData, ptr %481, i32 0, i32 2
  %483 = load ptr, ptr %482, align 8, !tbaa !23
  %484 = load i32, ptr %20, align 4, !tbaa !24
  %485 = sext i32 %484 to i64
  %486 = getelementptr inbounds ptr, ptr %483, i64 %485
  store ptr %480, ptr %486, align 8, !tbaa !5
  %487 = load ptr, ptr %21, align 8, !tbaa !5
  %488 = getelementptr inbounds %struct.MLayer, ptr %487, i32 0, i32 0
  %489 = getelementptr inbounds [32 x i8], ptr %488, i64 0, i64 0
  %490 = load ptr, ptr %4, align 8, !tbaa !5
  %491 = getelementptr inbounds %struct.HandleTrainData, ptr %490, i32 0, i32 3
  %492 = load ptr, ptr %491, align 8, !tbaa !29
  %493 = load i32, ptr %20, align 4, !tbaa !24
  %494 = sext i32 %493 to i64
  %495 = getelementptr inbounds ptr, ptr %492, i64 %494
  store ptr %489, ptr %495, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 8, ptr %22) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %21) #4
  br label %496

496:                                              ; preds = %450
  %497 = load i32, ptr %20, align 4, !tbaa !24
  %498 = add nsw i32 %497, 1
  store i32 %498, ptr %20, align 4, !tbaa !24
  br label %441, !llvm.loop !41

499:                                              ; preds = %449
  %500 = load ptr, ptr %2, align 8, !tbaa !5
  %501 = call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %500, i64 noundef ptrtoint (ptr @.str.4 to i64), i64 noundef ptrtoint (ptr @.str.17 to i64), ptr noundef inttoptr (i64 -1 to ptr), i32 noundef -1)
  %502 = load ptr, ptr %4, align 8, !tbaa !5
  %503 = getelementptr inbounds %struct.HandleTrainData, ptr %502, i32 0, i32 1
  store ptr %501, ptr %503, align 8, !tbaa !42
  br label %504

504:                                              ; preds = %499
  call void @llvm.lifetime.start.p0(i64 4, ptr %23) #4
  %505 = load ptr, ptr %4, align 8, !tbaa !5
  %506 = getelementptr inbounds %struct.HandleTrainData, ptr %505, i32 0, i32 1
  %507 = load ptr, ptr %506, align 8, !tbaa !42
  %508 = icmp eq ptr %507, null
  %509 = zext i1 %508 to i32
  store i32 %509, ptr %23, align 4, !tbaa !24
  %510 = load i32, ptr %23, align 4, !tbaa !24
  %511 = icmp ne i32 %510, 0
  br i1 %511, label %512, label %514

512:                                              ; preds = %504
  %513 = load i32, ptr %23, align 4, !tbaa !24
  call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef %513, i32 noundef -1, ptr noundef @.str, i32 noundef 201, ptr noundef @__FUNCTION__.mTrainData, ptr noundef @.str.18)
  br label %514

514:                                              ; preds = %512, %504
  call void @llvm.lifetime.end.p0(i64 4, ptr %23) #4
  br label %515

515:                                              ; preds = %514
  br label %516

516:                                              ; preds = %515
  call void @llvm.lifetime.start.p0(i64 4, ptr %24) #4
  store i32 0, ptr %24, align 4, !tbaa !24
  br label %517

517:                                              ; preds = %580, %516
  %518 = load i32, ptr %24, align 4, !tbaa !24
  %519 = load ptr, ptr %4, align 8, !tbaa !5
  %520 = getelementptr inbounds %struct.HandleTrainData, ptr %519, i32 0, i32 7
  %521 = load i32, ptr %520, align 4, !tbaa !18
  %522 = icmp slt i32 %518, %521
  br i1 %522, label %524, label %523

523:                                              ; preds = %517
  store i32 23, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %24) #4
  br label %583

524:                                              ; preds = %517
  call void @llvm.lifetime.start.p0(i64 4, ptr %25) #4
  store i32 0, ptr %25, align 4, !tbaa !24
  br label %525

525:                                              ; preds = %561, %524
  %526 = load i32, ptr %25, align 4, !tbaa !24
  %527 = load ptr, ptr %4, align 8, !tbaa !5
  %528 = getelementptr inbounds %struct.HandleTrainData, ptr %527, i32 0, i32 4
  %529 = load ptr, ptr %528, align 8, !tbaa !22
  %530 = getelementptr inbounds %struct.MList, ptr %529, i32 0, i32 0
  %531 = load i32, ptr %530, align 8, !tbaa !25
  %532 = icmp slt i32 %526, %531
  br i1 %532, label %534, label %533

533:                                              ; preds = %525
  store i32 26, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %25) #4
  br label %564

534:                                              ; preds = %525
  call void @llvm.lifetime.start.p0(i64 8, ptr %26) #4
  %535 = load ptr, ptr %4, align 8, !tbaa !5
  %536 = getelementptr inbounds %struct.HandleTrainData, ptr %535, i32 0, i32 4
  %537 = load ptr, ptr %536, align 8, !tbaa !22
  %538 = getelementptr inbounds %struct.MList, ptr %537, i32 0, i32 1
  %539 = load ptr, ptr %538, align 8, !tbaa !30
  %540 = load i32, ptr %25, align 4, !tbaa !24
  %541 = sext i32 %540 to i64
  %542 = getelementptr inbounds ptr, ptr %539, i64 %541
  %543 = load ptr, ptr %542, align 8, !tbaa !5
  store ptr %543, ptr %26, align 8, !tbaa !5
  %544 = load ptr, ptr %26, align 8, !tbaa !5
  %545 = getelementptr inbounds %struct.MLayer, ptr %544, i32 0, i32 2
  %546 = load ptr, ptr %545, align 8, !tbaa !33
  %547 = getelementptr inbounds %struct.MTensor, ptr %546, i32 0, i32 4
  %548 = load ptr, ptr %547, align 8, !tbaa !34
  %549 = load i32, ptr %24, align 4, !tbaa !24
  %550 = sext i32 %549 to i64
  %551 = getelementptr inbounds ptr, ptr %548, i64 %550
  %552 = load ptr, ptr %551, align 8, !tbaa !5
  %553 = load ptr, ptr %4, align 8, !tbaa !5
  %554 = getelementptr inbounds %struct.HandleTrainData, ptr %553, i32 0, i32 2
  %555 = load ptr, ptr %554, align 8, !tbaa !23
  %556 = load i32, ptr %25, align 4, !tbaa !24
  %557 = sext i32 %556 to i64
  %558 = getelementptr inbounds ptr, ptr %555, i64 %557
  %559 = load ptr, ptr %558, align 8, !tbaa !5
  %560 = getelementptr inbounds %struct.MVector, ptr %559, i32 0, i32 1
  store ptr %552, ptr %560, align 8, !tbaa !43
  call void @llvm.lifetime.end.p0(i64 8, ptr %26) #4
  br label %561

561:                                              ; preds = %534
  %562 = load i32, ptr %25, align 4, !tbaa !24
  %563 = add nsw i32 %562, 1
  store i32 %563, ptr %25, align 4, !tbaa !24
  br label %525, !llvm.loop !45

564:                                              ; preds = %533
  %565 = load ptr, ptr @morn_datafunc, align 8, !tbaa !5
  %566 = load ptr, ptr %4, align 8, !tbaa !5
  %567 = getelementptr inbounds %struct.HandleTrainData, ptr %566, i32 0, i32 2
  %568 = load ptr, ptr %567, align 8, !tbaa !23
  %569 = load ptr, ptr %4, align 8, !tbaa !5
  %570 = getelementptr inbounds %struct.HandleTrainData, ptr %569, i32 0, i32 3
  %571 = load ptr, ptr %570, align 8, !tbaa !29
  %572 = load ptr, ptr %4, align 8, !tbaa !5
  %573 = getelementptr inbounds %struct.HandleTrainData, ptr %572, i32 0, i32 4
  %574 = load ptr, ptr %573, align 8, !tbaa !22
  %575 = getelementptr inbounds %struct.MList, ptr %574, i32 0, i32 0
  %576 = load i32, ptr %575, align 8, !tbaa !25
  %577 = load ptr, ptr %4, align 8, !tbaa !5
  %578 = getelementptr inbounds %struct.HandleTrainData, ptr %577, i32 0, i32 1
  %579 = load ptr, ptr %578, align 8, !tbaa !42
  call void %565(ptr noundef %568, ptr noundef %571, i32 noundef %576, ptr noundef %579)
  br label %580

580:                                              ; preds = %564
  %581 = load i32, ptr %24, align 4, !tbaa !24
  %582 = add nsw i32 %581, 1
  store i32 %582, ptr %24, align 4, !tbaa !24
  br label %517, !llvm.loop !46

583:                                              ; preds = %523
  %584 = load ptr, ptr %3, align 8, !tbaa !5
  %585 = getelementptr inbounds %struct.MHandle, ptr %584, i32 0, i32 1
  store volatile i32 1, ptr %585, align 4, !tbaa !12
  store i32 1, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %7) #4
  call void @llvm.lifetime.end.p0(i64 4, ptr %6) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %5) #4
  br label %726

586:                                              ; preds = %1
  call void @llvm.lifetime.start.p0(i64 4, ptr %27) #4
  store i32 0, ptr %27, align 4, !tbaa !24
  br label %587

587:                                              ; preds = %650, %586
  %588 = load i32, ptr %27, align 4, !tbaa !24
  %589 = load ptr, ptr %4, align 8, !tbaa !5
  %590 = getelementptr inbounds %struct.HandleTrainData, ptr %589, i32 0, i32 8
  %591 = load i32, ptr %590, align 8, !tbaa !19
  %592 = icmp slt i32 %588, %591
  br i1 %592, label %594, label %593

593:                                              ; preds = %587
  store i32 29, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %27) #4
  br label %653

594:                                              ; preds = %587
  call void @llvm.lifetime.start.p0(i64 4, ptr %28) #4
  store i32 0, ptr %28, align 4, !tbaa !24
  br label %595

595:                                              ; preds = %631, %594
  %596 = load i32, ptr %28, align 4, !tbaa !24
  %597 = load ptr, ptr %4, align 8, !tbaa !5
  %598 = getelementptr inbounds %struct.HandleTrainData, ptr %597, i32 0, i32 4
  %599 = load ptr, ptr %598, align 8, !tbaa !22
  %600 = getelementptr inbounds %struct.MList, ptr %599, i32 0, i32 0
  %601 = load i32, ptr %600, align 8, !tbaa !25
  %602 = icmp slt i32 %596, %601
  br i1 %602, label %604, label %603

603:                                              ; preds = %595
  store i32 32, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %28) #4
  br label %634

604:                                              ; preds = %595
  call void @llvm.lifetime.start.p0(i64 8, ptr %29) #4
  %605 = load ptr, ptr %4, align 8, !tbaa !5
  %606 = getelementptr inbounds %struct.HandleTrainData, ptr %605, i32 0, i32 4
  %607 = load ptr, ptr %606, align 8, !tbaa !22
  %608 = getelementptr inbounds %struct.MList, ptr %607, i32 0, i32 1
  %609 = load ptr, ptr %608, align 8, !tbaa !30
  %610 = load i32, ptr %28, align 4, !tbaa !24
  %611 = sext i32 %610 to i64
  %612 = getelementptr inbounds ptr, ptr %609, i64 %611
  %613 = load ptr, ptr %612, align 8, !tbaa !5
  store ptr %613, ptr %29, align 8, !tbaa !5
  %614 = load ptr, ptr %29, align 8, !tbaa !5
  %615 = getelementptr inbounds %struct.MLayer, ptr %614, i32 0, i32 2
  %616 = load ptr, ptr %615, align 8, !tbaa !33
  %617 = getelementptr inbounds %struct.MTensor, ptr %616, i32 0, i32 4
  %618 = load ptr, ptr %617, align 8, !tbaa !34
  %619 = load i32, ptr %27, align 4, !tbaa !24
  %620 = sext i32 %619 to i64
  %621 = getelementptr inbounds ptr, ptr %618, i64 %620
  %622 = load ptr, ptr %621, align 8, !tbaa !5
  %623 = load ptr, ptr %4, align 8, !tbaa !5
  %624 = getelementptr inbounds %struct.HandleTrainData, ptr %623, i32 0, i32 2
  %625 = load ptr, ptr %624, align 8, !tbaa !23
  %626 = load i32, ptr %28, align 4, !tbaa !24
  %627 = sext i32 %626 to i64
  %628 = getelementptr inbounds ptr, ptr %625, i64 %627
  %629 = load ptr, ptr %628, align 8, !tbaa !5
  %630 = getelementptr inbounds %struct.MVector, ptr %629, i32 0, i32 1
  store ptr %622, ptr %630, align 8, !tbaa !43
  call void @llvm.lifetime.end.p0(i64 8, ptr %29) #4
  br label %631

631:                                              ; preds = %604
  %632 = load i32, ptr %28, align 4, !tbaa !24
  %633 = add nsw i32 %632, 1
  store i32 %633, ptr %28, align 4, !tbaa !24
  br label %595, !llvm.loop !47

634:                                              ; preds = %603
  %635 = load ptr, ptr @morn_datafunc, align 8, !tbaa !5
  %636 = load ptr, ptr %4, align 8, !tbaa !5
  %637 = getelementptr inbounds %struct.HandleTrainData, ptr %636, i32 0, i32 2
  %638 = load ptr, ptr %637, align 8, !tbaa !23
  %639 = load ptr, ptr %4, align 8, !tbaa !5
  %640 = getelementptr inbounds %struct.HandleTrainData, ptr %639, i32 0, i32 3
  %641 = load ptr, ptr %640, align 8, !tbaa !29
  %642 = load ptr, ptr %4, align 8, !tbaa !5
  %643 = getelementptr inbounds %struct.HandleTrainData, ptr %642, i32 0, i32 4
  %644 = load ptr, ptr %643, align 8, !tbaa !22
  %645 = getelementptr inbounds %struct.MList, ptr %644, i32 0, i32 0
  %646 = load i32, ptr %645, align 8, !tbaa !25
  %647 = load ptr, ptr %4, align 8, !tbaa !5
  %648 = getelementptr inbounds %struct.HandleTrainData, ptr %647, i32 0, i32 1
  %649 = load ptr, ptr %648, align 8, !tbaa !42
  call void %635(ptr noundef %638, ptr noundef %641, i32 noundef %646, ptr noundef %649)
  br label %650

650:                                              ; preds = %634
  %651 = load i32, ptr %27, align 4, !tbaa !24
  %652 = add nsw i32 %651, 1
  store i32 %652, ptr %27, align 4, !tbaa !24
  br label %587, !llvm.loop !48

653:                                              ; preds = %593
  call void @llvm.lifetime.start.p0(i64 4, ptr %30) #4
  store i32 0, ptr %30, align 4, !tbaa !24
  br label %654

654:                                              ; preds = %722, %653
  %655 = load i32, ptr %30, align 4, !tbaa !24
  %656 = load ptr, ptr %4, align 8, !tbaa !5
  %657 = getelementptr inbounds %struct.HandleTrainData, ptr %656, i32 0, i32 6
  %658 = load i32, ptr %657, align 8, !tbaa !15
  %659 = icmp slt i32 %655, %658
  br i1 %659, label %661, label %660

660:                                              ; preds = %654
  store i32 35, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %30) #4
  br label %725

661:                                              ; preds = %654
  call void @llvm.lifetime.start.p0(i64 4, ptr %31) #4
  %662 = load i32, ptr %30, align 4, !tbaa !24
  %663 = add nsw i32 %662, 1
  %664 = add nsw i32 %663, 0
  %665 = load ptr, ptr %4, align 8, !tbaa !5
  %666 = getelementptr inbounds %struct.HandleTrainData, ptr %665, i32 0, i32 7
  %667 = load i32, ptr %666, align 4, !tbaa !18
  %668 = call i32 @m_Rand(i32 noundef %664, i32 noundef %667)
  store i32 %668, ptr %31, align 4, !tbaa !24
  call void @llvm.lifetime.start.p0(i64 4, ptr %32) #4
  store i32 0, ptr %32, align 4, !tbaa !24
  br label %669

669:                                              ; preds = %718, %661
  %670 = load i32, ptr %32, align 4, !tbaa !24
  %671 = load ptr, ptr %4, align 8, !tbaa !5
  %672 = getelementptr inbounds %struct.HandleTrainData, ptr %671, i32 0, i32 4
  %673 = load ptr, ptr %672, align 8, !tbaa !22
  %674 = getelementptr inbounds %struct.MList, ptr %673, i32 0, i32 0
  %675 = load i32, ptr %674, align 8, !tbaa !25
  %676 = icmp slt i32 %670, %675
  br i1 %676, label %678, label %677

677:                                              ; preds = %669
  store i32 38, ptr %10, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %32) #4
  br label %721

678:                                              ; preds = %669
  call void @llvm.lifetime.start.p0(i64 8, ptr %33) #4
  %679 = load ptr, ptr %4, align 8, !tbaa !5
  %680 = getelementptr inbounds %struct.HandleTrainData, ptr %679, i32 0, i32 4
  %681 = load ptr, ptr %680, align 8, !tbaa !22
  %682 = getelementptr inbounds %struct.MList, ptr %681, i32 0, i32 1
  %683 = load ptr, ptr %682, align 8, !tbaa !30
  %684 = load i32, ptr %32, align 4, !tbaa !24
  %685 = sext i32 %684 to i64
  %686 = getelementptr inbounds ptr, ptr %683, i64 %685
  %687 = load ptr, ptr %686, align 8, !tbaa !5
  store ptr %687, ptr %33, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %34) #4
  %688 = load ptr, ptr %33, align 8, !tbaa !5
  %689 = getelementptr inbounds %struct.MLayer, ptr %688, i32 0, i32 2
  %690 = load ptr, ptr %689, align 8, !tbaa !33
  store ptr %690, ptr %34, align 8, !tbaa !5
  call void @llvm.lifetime.start.p0(i64 8, ptr %35) #4
  %691 = load ptr, ptr %34, align 8, !tbaa !5
  %692 = getelementptr inbounds %struct.MTensor, ptr %691, i32 0, i32 4
  %693 = load ptr, ptr %692, align 8, !tbaa !34
  %694 = load i32, ptr %30, align 4, !tbaa !24
  %695 = sext i32 %694 to i64
  %696 = getelementptr inbounds ptr, ptr %693, i64 %695
  %697 = load ptr, ptr %696, align 8, !tbaa !5
  store ptr %697, ptr %35, align 8, !tbaa !5
  %698 = load ptr, ptr %34, align 8, !tbaa !5
  %699 = getelementptr inbounds %struct.MTensor, ptr %698, i32 0, i32 4
  %700 = load ptr, ptr %699, align 8, !tbaa !34
  %701 = load i32, ptr %31, align 4, !tbaa !24
  %702 = sext i32 %701 to i64
  %703 = getelementptr inbounds ptr, ptr %700, i64 %702
  %704 = load ptr, ptr %703, align 8, !tbaa !5
  %705 = load ptr, ptr %34, align 8, !tbaa !5
  %706 = getelementptr inbounds %struct.MTensor, ptr %705, i32 0, i32 4
  %707 = load ptr, ptr %706, align 8, !tbaa !34
  %708 = load i32, ptr %30, align 4, !tbaa !24
  %709 = sext i32 %708 to i64
  %710 = getelementptr inbounds ptr, ptr %707, i64 %709
  store ptr %704, ptr %710, align 8, !tbaa !5
  %711 = load ptr, ptr %35, align 8, !tbaa !5
  %712 = load ptr, ptr %34, align 8, !tbaa !5
  %713 = getelementptr inbounds %struct.MTensor, ptr %712, i32 0, i32 4
  %714 = load ptr, ptr %713, align 8, !tbaa !34
  %715 = load i32, ptr %31, align 4, !tbaa !24
  %716 = sext i32 %715 to i64
  %717 = getelementptr inbounds ptr, ptr %714, i64 %716
  store ptr %711, ptr %717, align 8, !tbaa !5
  call void @llvm.lifetime.end.p0(i64 8, ptr %35) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %34) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %33) #4
  br label %718

718:                                              ; preds = %678
  %719 = load i32, ptr %32, align 4, !tbaa !24
  %720 = add nsw i32 %719, 1
  store i32 %720, ptr %32, align 4, !tbaa !24
  br label %669, !llvm.loop !49

721:                                              ; preds = %677
  call void @llvm.lifetime.end.p0(i64 4, ptr %31) #4
  br label %722

722:                                              ; preds = %721
  %723 = load i32, ptr %30, align 4, !tbaa !24
  %724 = add nsw i32 %723, 1
  store i32 %724, ptr %30, align 4, !tbaa !24
  br label %654, !llvm.loop !50

725:                                              ; preds = %660
  store i32 0, ptr %10, align 4
  br label %726

726:                                              ; preds = %725, %583
  call void @llvm.lifetime.end.p0(i64 8, ptr %4) #4
  call void @llvm.lifetime.end.p0(i64 8, ptr %3) #4
  %727 = load i32, ptr %10, align 4
  switch i32 %727, label %729 [
    i32 0, label %728
    i32 1, label %728
  ]

728:                                              ; preds = %726, %726
  ret void

729:                                              ; preds = %726, %408
  unreachable
}

declare ptr @mNetworkGenerate(ptr noundef) #2

declare ptr @m_INIRead(ptr noundef, i64 noundef, i64 noundef, ptr noundef, ...) #2

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare i32 @atoi(ptr noundef nonnull) #3

; Function Attrs: inlinehint nounwind willreturn memory(read) uwtable
declare double @atof(ptr noundef nonnull) #3

declare i32 @mTensorRegisterIndex(ptr noundef) #2

declare void @mListClear(ptr noundef) #2

declare ptr @TensorCreate(i32 noundef, i32 noundef, i32 noundef, i32 noundef, ptr noundef, i32 noundef) #2

declare void @TensorRedefine(ptr noundef, i32 noundef, i32 noundef, i32 noundef, i32 noundef, ptr noundef, i32 noundef) #2

declare ptr @mListWrite(ptr noundef, i32 noundef, ptr noundef, i32 noundef) #2

declare ptr @m_Malloc(i32 noundef) #2

declare ptr @VectorCreate(i32 noundef, ptr noundef) #2

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !6, i64 16}
!10 = !{!"MHandle", !11, i64 0, !11, i64 4, !6, i64 8, !6, i64 16}
!11 = !{!"int", !7, i64 0}
!12 = !{!10, !11, i64 4}
!13 = !{!14, !6, i64 0}
!14 = !{!"HandleTrainData", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !11, i64 48, !11, i64 52, !11, i64 56, !11, i64 60, !11, i64 64}
!15 = !{!14, !11, i64 48}
!16 = !{!17, !17, i64 0}
!17 = !{!"float", !7, i64 0}
!18 = !{!14, !11, i64 52}
!19 = !{!14, !11, i64 56}
!20 = !{!14, !11, i64 60}
!21 = !{!14, !11, i64 64}
!22 = !{!14, !6, i64 32}
!23 = !{!14, !6, i64 16}
!24 = !{!11, !11, i64 0}
!25 = !{!26, !11, i64 0}
!26 = !{!"MList", !11, i64 0, !6, i64 8}
!27 = distinct !{!27, !28}
!28 = !{!"llvm.loop.mustprogress"}
!29 = !{!14, !6, i64 24}
!30 = !{!26, !6, i64 8}
!31 = !{!32, !11, i64 32}
!32 = !{!"MLayer", !7, i64 0, !11, i64 32, !6, i64 40, !6, i64 48, !6, i64 56, !11, i64 64}
!33 = !{!32, !6, i64 40}
!34 = !{!35, !6, i64 16}
!35 = !{!"MTensor", !11, i64 0, !11, i64 4, !11, i64 8, !11, i64 12, !6, i64 16, !11, i64 24}
!36 = !{!35, !11, i64 0}
!37 = distinct !{!37, !28}
!38 = !{!35, !11, i64 4}
!39 = !{!35, !11, i64 8}
!40 = !{!35, !11, i64 12}
!41 = distinct !{!41, !28}
!42 = !{!14, !6, i64 8}
!43 = !{!44, !6, i64 8}
!44 = !{!"MVector", !11, i64 0, !6, i64 8}
!45 = distinct !{!45, !28}
!46 = distinct !{!46, !28}
!47 = distinct !{!47, !28}
!48 = distinct !{!48, !28}
!49 = distinct !{!49, !28}
!50 = distinct !{!50, !28}


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

@.str = external hidden unnamed_addr constant [92 x i8], align 1
@morn_datafunc = external dso_local local_unnamed_addr global ptr, align 8
@.str.4 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [12 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [13 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [8 x i8], align 1
@__FUNCTION__.mTrainData = external hidden unnamed_addr constant [11 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [17 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [7 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [16 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [6 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [15 x i8], align 1
@.str.17 = external hidden unnamed_addr constant [9 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [18 x i8], align 1

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

declare void @m_Exception(i32 noundef, i32 noundef, ptr noundef, i32 noundef, ptr noundef, ptr noundef, ...) local_unnamed_addr #1

declare ptr @GetHandle(ptr noundef, i32 noundef, i32 noundef, ptr noundef) local_unnamed_addr #1

declare ptr @ListCreate(i32 noundef, ptr noundef) local_unnamed_addr #1

declare i32 @m_Rand(i32 noundef, i32 noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
declare dso_local void @endTrainData(ptr noundef) #0

declare void @mVectorRelease(ptr noundef) local_unnamed_addr #1

declare void @m_Free(ptr noundef) local_unnamed_addr #1

; Function Attrs: nounwind uwtable
define dso_local void @mTrainData(ptr noundef %0) local_unnamed_addr #0 {
  %2 = tail call ptr @GetHandle(ptr noundef %0, i32 noundef 72, i32 noundef -286066283, ptr noundef nonnull @endTrainData) #4
  %3 = getelementptr inbounds i8, ptr %2, i64 16
  %4 = load ptr, ptr %3, align 8, !tbaa !5
  %5 = getelementptr inbounds i8, ptr %2, i64 4
  %6 = load volatile i32, ptr %5, align 4, !tbaa !11
  %7 = icmp eq i32 %6, 0
  br i1 %7, label %15, label %.preheader213

.preheader213:                                    ; preds = %1
  %8 = getelementptr inbounds i8, ptr %4, i64 56
  %9 = load i32, ptr %8, align 8, !tbaa !12
  %10 = icmp sgt i32 %9, 0
  br i1 %10, label %.preheader212.lr.ph, label %.preheader210

.preheader212.lr.ph:                              ; preds = %.preheader213
  %11 = getelementptr inbounds i8, ptr %4, i64 32
  %12 = getelementptr inbounds i8, ptr %4, i64 16
  %13 = getelementptr inbounds i8, ptr %4, i64 24
  %14 = getelementptr inbounds i8, ptr %4, i64 8
  br label %.preheader212

15:                                               ; preds = %1
  %16 = load ptr, ptr %4, align 8, !tbaa !14
  %17 = icmp eq ptr %16, null
  br i1 %17, label %18, label %20

18:                                               ; preds = %15
  %19 = tail call ptr @mNetworkGenerate(ptr noundef %0) #4
  store ptr %19, ptr %4, align 8, !tbaa !14
  br label %20

20:                                               ; preds = %18, %15
  %21 = getelementptr inbounds i8, ptr %4, i64 48
  store i32 1, ptr %21, align 8, !tbaa !15
  %22 = tail call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %0, i64 noundef ptrtoint (ptr @.str.4 to i64), i64 noundef ptrtoint (ptr @.str.5 to i64), ptr noundef nonnull inttoptr (i64 -1 to ptr), i32 noundef -1) #4
  %.not = icmp eq ptr %22, null
  br i1 %.not, label %25, label %23

23:                                               ; preds = %20
  %24 = tail call i32 @atoi(ptr nocapture noundef %22) #5
  store i32 %24, ptr %21, align 8, !tbaa !15
  br label %25

25:                                               ; preds = %23, %20
  %26 = tail call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %0, i64 noundef ptrtoint (ptr @.str.4 to i64), i64 noundef ptrtoint (ptr @.str.6 to i64), ptr noundef nonnull inttoptr (i64 -1 to ptr), i32 noundef -1) #4
  %.not204 = icmp eq ptr %26, null
  br i1 %.not204, label %30, label %27

27:                                               ; preds = %25
  %28 = tail call double @atof(ptr noundef %26) #5
  %29 = fptrunc double %28 to float
  br label %30

30:                                               ; preds = %27, %25
  %.0 = phi float [ %29, %27 ], [ 5.000000e-01, %25 ]
  %31 = fcmp olt float %.0, 1.000000e+00
  %32 = fdiv float 1.000000e+00, %.0
  %.1 = select i1 %31, float %32, float %.0
  %33 = load i32, ptr %21, align 8, !tbaa !15
  %34 = sitofp i32 %33 to float
  %35 = fdiv float 2.000000e+00, %34
  %36 = tail call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %0, i64 noundef ptrtoint (ptr @.str.4 to i64), i64 noundef ptrtoint (ptr @.str.7 to i64), ptr noundef nonnull inttoptr (i64 -1 to ptr), i32 noundef -1) #4
  %.not205 = icmp eq ptr %36, null
  br i1 %.not205, label %40, label %37

37:                                               ; preds = %30
  %38 = tail call double @atof(ptr noundef %36) #5
  %39 = fptrunc double %38 to float
  br label %40

40:                                               ; preds = %37, %30
  %.0186 = phi float [ %39, %37 ], [ %35, %30 ]
  %41 = fcmp ogt float %.0186, 1.000000e+00
  %42 = fdiv float 1.000000e+00, %.0186
  %.1187 = select i1 %41, float %42, float %.0186
  %43 = fcmp olt float %.1187, 1.000000e+00
  br i1 %43, label %44, label %49

44:                                               ; preds = %40
  %45 = fsub float 1.000000e+00, %.1187
  %46 = fdiv float 1.000000e+00, %45
  %47 = fcmp ogt float %.1, %46
  %48 = select i1 %47, float %.1, float %46
  br label %49

49:                                               ; preds = %44, %40
  %.2 = phi float [ %48, %44 ], [ %.1, %40 ]
  %50 = load i32, ptr %21, align 8, !tbaa !15
  %51 = sitofp i32 %50 to float
  %52 = fmul float %.2, %51
  %53 = fpext float %52 to double
  %54 = fadd double %53, 5.000000e-01
  %55 = fptosi double %54 to i32
  %56 = getelementptr inbounds i8, ptr %4, i64 52
  store i32 %55, ptr %56, align 4, !tbaa !16
  %57 = sitofp i32 %55 to float
  %58 = fmul float %.1187, %57
  %59 = fpext float %58 to double
  %60 = fadd double %59, 5.000000e-01
  %61 = fptosi double %60 to i32
  %62 = getelementptr inbounds i8, ptr %4, i64 56
  %spec.select = tail call i32 @llvm.smax.i32(i32 %61, i32 1)
  store i32 %spec.select, ptr %62, align 8, !tbaa !12
  %63 = tail call i32 @mTensorRegisterIndex(ptr noundef nonnull @.str.8) #4
  %64 = getelementptr inbounds i8, ptr %4, i64 60
  store i32 %63, ptr %64, align 4, !tbaa !17
  %65 = tail call i32 @mTensorRegisterIndex(ptr noundef nonnull @.str.9) #4
  %66 = getelementptr inbounds i8, ptr %4, i64 64
  store i32 %65, ptr %66, align 8, !tbaa !18
  %67 = getelementptr inbounds i8, ptr %4, i64 32
  %68 = load ptr, ptr %67, align 8, !tbaa !19
  %69 = icmp eq ptr %68, null
  br i1 %69, label %70, label %72

70:                                               ; preds = %49
  %71 = tail call ptr @ListCreate(i32 noundef -1, ptr noundef null) #4
  store ptr %71, ptr %67, align 8, !tbaa !19
  br label %87

72:                                               ; preds = %49
  %73 = getelementptr inbounds i8, ptr %4, i64 16
  %74 = load ptr, ptr %73, align 8, !tbaa !20
  %.not206 = icmp eq ptr %74, null
  br i1 %.not206, label %87, label %.preheader209

.preheader209:                                    ; preds = %72
  %75 = load i32, ptr %68, align 8, !tbaa !21
  %76 = icmp sgt i32 %75, 0
  br i1 %76, label %.lr.ph223, label %._crit_edge224

._crit_edge224.loopexit:                          ; preds = %.lr.ph223
  %.pre265 = load ptr, ptr %73, align 8, !tbaa !20
  br label %._crit_edge224

._crit_edge224:                                   ; preds = %._crit_edge224.loopexit, %.preheader209
  %77 = phi ptr [ %.pre265, %._crit_edge224.loopexit ], [ %74, %.preheader209 ]
  tail call void @m_Free(ptr noundef %77) #4
  %78 = getelementptr inbounds i8, ptr %4, i64 24
  %79 = load ptr, ptr %78, align 8, !tbaa !23
  tail call void @m_Free(ptr noundef %79) #4
  %.pre266 = load ptr, ptr %67, align 8, !tbaa !19
  br label %87

.lr.ph223:                                        ; preds = %.preheader209, %.lr.ph223
  %indvars.iv248 = phi i64 [ %indvars.iv.next249, %.lr.ph223 ], [ 0, %.preheader209 ]
  %80 = load ptr, ptr %73, align 8, !tbaa !20
  %81 = getelementptr inbounds ptr, ptr %80, i64 %indvars.iv248
  %82 = load ptr, ptr %81, align 8, !tbaa !24
  tail call void @mVectorRelease(ptr noundef %82) #4
  %indvars.iv.next249 = add nuw nsw i64 %indvars.iv248, 1
  %83 = load ptr, ptr %67, align 8, !tbaa !19
  %84 = load i32, ptr %83, align 8, !tbaa !21
  %85 = sext i32 %84 to i64
  %86 = icmp slt i64 %indvars.iv.next249, %85
  br i1 %86, label %.lr.ph223, label %._crit_edge224.loopexit, !llvm.loop !25

87:                                               ; preds = %72, %._crit_edge224, %70
  %88 = phi ptr [ %68, %72 ], [ %.pre266, %._crit_edge224 ], [ %71, %70 ]
  tail call void @mListClear(ptr noundef %88) #4
  %89 = load ptr, ptr %4, align 8, !tbaa !14
  %90 = load i32, ptr %89, align 8, !tbaa !21
  %91 = icmp sgt i32 %90, 0
  br i1 %91, label %.lr.ph227, label %._crit_edge228

._crit_edge228:                                   ; preds = %136, %87
  %92 = load ptr, ptr @morn_datafunc, align 8, !tbaa !24
  %93 = icmp eq ptr %92, null
  br i1 %93, label %141, label %142

.lr.ph227:                                        ; preds = %87, %136
  %94 = phi i32 [ %137, %136 ], [ %90, %87 ]
  %95 = phi ptr [ %138, %136 ], [ %89, %87 ]
  %indvars.iv251 = phi i64 [ %indvars.iv.next252, %136 ], [ 0, %87 ]
  %96 = getelementptr inbounds i8, ptr %95, i64 8
  %97 = load ptr, ptr %96, align 8, !tbaa !27
  %98 = getelementptr inbounds ptr, ptr %97, i64 %indvars.iv251
  %99 = load ptr, ptr %98, align 8, !tbaa !24
  %100 = getelementptr inbounds i8, ptr %99, i64 32
  %101 = load i32, ptr %100, align 8, !tbaa !28
  %102 = load i32, ptr %64, align 4, !tbaa !17
  %.not207 = icmp eq i32 %101, %102
  br i1 %.not207, label %105, label %103

103:                                              ; preds = %.lr.ph227
  %104 = load i32, ptr %66, align 8, !tbaa !18
  %.not208 = icmp eq i32 %101, %104
  br i1 %.not208, label %105, label %136

105:                                              ; preds = %103, %.lr.ph227
  %106 = ptrtoint ptr %99 to i64
  %107 = tail call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %0, i64 noundef %106, i64 noundef ptrtoint (ptr @.str.10 to i64), ptr noundef nonnull inttoptr (i64 -1 to ptr), i32 noundef -1) #4
  %108 = icmp eq ptr %107, null
  br i1 %108, label %109, label %110

109:                                              ; preds = %105
  tail call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef 1, i32 noundef -1, ptr noundef nonnull @.str, i32 noundef 175, ptr noundef nonnull @__FUNCTION__.mTrainData, ptr noundef nonnull @.str.11) #4
  br label %110

110:                                              ; preds = %109, %105
  %111 = tail call i32 @atoi(ptr nocapture noundef %107) #5
  %112 = tail call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %0, i64 noundef %106, i64 noundef ptrtoint (ptr @.str.12 to i64), ptr noundef nonnull inttoptr (i64 -1 to ptr), i32 noundef -1) #4
  %113 = icmp eq ptr %112, null
  br i1 %113, label %114, label %115

114:                                              ; preds = %110
  tail call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef 1, i32 noundef -1, ptr noundef nonnull @.str, i32 noundef 176, ptr noundef nonnull @__FUNCTION__.mTrainData, ptr noundef nonnull @.str.13) #4
  br label %115

115:                                              ; preds = %114, %110
  %116 = tail call i32 @atoi(ptr nocapture noundef %112) #5
  %117 = tail call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %0, i64 noundef %106, i64 noundef ptrtoint (ptr @.str.14 to i64), ptr noundef nonnull inttoptr (i64 -1 to ptr), i32 noundef -1) #4
  %118 = icmp eq ptr %117, null
  br i1 %118, label %119, label %120

119:                                              ; preds = %115
  tail call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef 1, i32 noundef -1, ptr noundef nonnull @.str, i32 noundef 177, ptr noundef nonnull @__FUNCTION__.mTrainData, ptr noundef nonnull @.str.15) #4
  br label %120

120:                                              ; preds = %119, %115
  %121 = tail call i32 @atoi(ptr nocapture noundef %117) #5
  %122 = getelementptr inbounds i8, ptr %99, i64 40
  %123 = load ptr, ptr %122, align 8, !tbaa !30
  %124 = icmp eq ptr %123, null
  %125 = load i32, ptr %56, align 4, !tbaa !16
  br i1 %124, label %126, label %128

126:                                              ; preds = %120
  %127 = tail call ptr @TensorCreate(i32 noundef %125, i32 noundef %111, i32 noundef %116, i32 noundef %121, ptr noundef null, i32 noundef -1) #4
  br label %131

128:                                              ; preds = %120
  %129 = getelementptr inbounds i8, ptr %123, i64 16
  %130 = load ptr, ptr %129, align 8, !tbaa !31
  tail call void @TensorRedefine(ptr noundef nonnull %123, i32 noundef %125, i32 noundef %111, i32 noundef %116, i32 noundef %121, ptr noundef %130, i32 noundef -1) #4
  br label %131

131:                                              ; preds = %128, %126
  %132 = load i32, ptr %21, align 8, !tbaa !15
  %133 = load ptr, ptr %122, align 8, !tbaa !30
  store i32 %132, ptr %133, align 8, !tbaa !33
  %134 = load ptr, ptr %67, align 8, !tbaa !19
  %135 = tail call ptr @mListWrite(ptr noundef %134, i32 noundef -1, ptr noundef nonnull %99, i32 noundef 72) #4
  %.pre267 = load ptr, ptr %4, align 8, !tbaa !14
  %.pre268 = load i32, ptr %.pre267, align 8, !tbaa !21
  br label %136

136:                                              ; preds = %103, %131
  %137 = phi i32 [ %94, %103 ], [ %.pre268, %131 ]
  %138 = phi ptr [ %95, %103 ], [ %.pre267, %131 ]
  %indvars.iv.next252 = add nuw nsw i64 %indvars.iv251, 1
  %139 = sext i32 %137 to i64
  %140 = icmp slt i64 %indvars.iv.next252, %139
  br i1 %140, label %.lr.ph227, label %._crit_edge228, !llvm.loop !34

141:                                              ; preds = %._crit_edge228
  store ptr @MORNTensor, ptr @morn_datafunc, align 8, !tbaa !24
  br label %142

142:                                              ; preds = %141, %._crit_edge228
  %143 = load ptr, ptr %67, align 8, !tbaa !19
  %144 = load i32, ptr %143, align 8, !tbaa !21
  %145 = shl i32 %144, 3
  %146 = tail call ptr @m_Malloc(i32 noundef %145) #4
  %147 = getelementptr inbounds i8, ptr %4, i64 16
  store ptr %146, ptr %147, align 8, !tbaa !20
  %148 = load ptr, ptr %67, align 8, !tbaa !19
  %149 = load i32, ptr %148, align 8, !tbaa !21
  %150 = shl i32 %149, 3
  %151 = tail call ptr @m_Malloc(i32 noundef %150) #4
  %152 = getelementptr inbounds i8, ptr %4, i64 24
  store ptr %151, ptr %152, align 8, !tbaa !23
  %153 = load ptr, ptr %67, align 8, !tbaa !19
  %154 = load i32, ptr %153, align 8, !tbaa !21
  %155 = icmp sgt i32 %154, 0
  br i1 %155, label %.lr.ph231, label %._crit_edge232

._crit_edge232:                                   ; preds = %.lr.ph231, %142
  %156 = tail call ptr (ptr, i64, i64, ptr, ...) @m_INIRead(ptr noundef %0, i64 noundef ptrtoint (ptr @.str.4 to i64), i64 noundef ptrtoint (ptr @.str.17 to i64), ptr noundef nonnull inttoptr (i64 -1 to ptr), i32 noundef -1) #4
  %157 = getelementptr inbounds i8, ptr %4, i64 8
  store ptr %156, ptr %157, align 8, !tbaa !35
  %158 = icmp eq ptr %156, null
  br i1 %158, label %186, label %187

.lr.ph231:                                        ; preds = %142, %.lr.ph231
  %indvars.iv254 = phi i64 [ %indvars.iv.next255, %.lr.ph231 ], [ 0, %142 ]
  %159 = phi ptr [ %182, %.lr.ph231 ], [ %153, %142 ]
  %160 = getelementptr inbounds i8, ptr %159, i64 8
  %161 = load ptr, ptr %160, align 8, !tbaa !27
  %162 = getelementptr inbounds ptr, ptr %161, i64 %indvars.iv254
  %163 = load ptr, ptr %162, align 8, !tbaa !24
  %164 = getelementptr inbounds i8, ptr %163, i64 40
  %165 = load ptr, ptr %164, align 8, !tbaa !30
  %166 = getelementptr inbounds i8, ptr %165, i64 4
  %167 = load i32, ptr %166, align 4, !tbaa !36
  %168 = getelementptr inbounds i8, ptr %165, i64 8
  %169 = load i32, ptr %168, align 8, !tbaa !37
  %170 = mul nsw i32 %169, %167
  %171 = getelementptr inbounds i8, ptr %165, i64 12
  %172 = load i32, ptr %171, align 4, !tbaa !38
  %173 = mul nsw i32 %170, %172
  %174 = getelementptr inbounds i8, ptr %165, i64 16
  %175 = load ptr, ptr %174, align 8, !tbaa !31
  %176 = load ptr, ptr %175, align 8, !tbaa !24
  %177 = tail call ptr @VectorCreate(i32 noundef %173, ptr noundef %176) #4
  %178 = load ptr, ptr %147, align 8, !tbaa !20
  %179 = getelementptr inbounds ptr, ptr %178, i64 %indvars.iv254
  store ptr %177, ptr %179, align 8, !tbaa !24
  %180 = load ptr, ptr %152, align 8, !tbaa !23
  %181 = getelementptr inbounds ptr, ptr %180, i64 %indvars.iv254
  store ptr %163, ptr %181, align 8, !tbaa !24
  %indvars.iv.next255 = add nuw nsw i64 %indvars.iv254, 1
  %182 = load ptr, ptr %67, align 8, !tbaa !19
  %183 = load i32, ptr %182, align 8, !tbaa !21
  %184 = sext i32 %183 to i64
  %185 = icmp slt i64 %indvars.iv.next255, %184
  br i1 %185, label %.lr.ph231, label %._crit_edge232, !llvm.loop !39

186:                                              ; preds = %._crit_edge232
  tail call void (i32, i32, ptr, i32, ptr, ptr, ...) @m_Exception(i32 noundef 1, i32 noundef -1, ptr noundef nonnull @.str, i32 noundef 201, ptr noundef nonnull @__FUNCTION__.mTrainData, ptr noundef nonnull @.str.18) #4
  br label %187

187:                                              ; preds = %186, %._crit_edge232
  %188 = load i32, ptr %56, align 4, !tbaa !16
  %189 = icmp sgt i32 %188, 0
  br i1 %189, label %.preheader, label %._crit_edge237

.preheader:                                       ; preds = %187, %._crit_edge235
  %indvars.iv262 = phi i64 [ %indvars.iv.next263, %._crit_edge235 ], [ 0, %187 ]
  %190 = load ptr, ptr %67, align 8, !tbaa !19
  %191 = load i32, ptr %190, align 8, !tbaa !21
  %192 = icmp sgt i32 %191, 0
  %.pre269 = load ptr, ptr %147, align 8, !tbaa !20
  br i1 %192, label %.lr.ph234, label %._crit_edge235

.lr.ph234:                                        ; preds = %.preheader
  %193 = getelementptr inbounds i8, ptr %190, i64 8
  %194 = load ptr, ptr %193, align 8, !tbaa !27
  %wide.trip.count260 = zext nneg i32 %191 to i64
  %xtraiter271 = and i64 %wide.trip.count260, 1
  %195 = icmp eq i32 %191, 1
  br i1 %195, label %._crit_edge235.loopexit.unr-lcssa, label %.lr.ph234.new

.lr.ph234.new:                                    ; preds = %.lr.ph234
  %unroll_iter273 = and i64 %wide.trip.count260, 2147483646
  br label %213

._crit_edge237:                                   ; preds = %._crit_edge235, %187
  store volatile i32 1, ptr %5, align 4, !tbaa !11
  br label %.loopexit211

._crit_edge235.loopexit.unr-lcssa:                ; preds = %213, %.lr.ph234
  %indvars.iv257.unr = phi i64 [ 0, %.lr.ph234 ], [ %indvars.iv.next258.1, %213 ]
  %lcmp.mod272.not = icmp eq i64 %xtraiter271, 0
  br i1 %lcmp.mod272.not, label %._crit_edge235, label %._crit_edge235.loopexit.epilog-lcssa

._crit_edge235.loopexit.epilog-lcssa:             ; preds = %._crit_edge235.loopexit.unr-lcssa
  %196 = getelementptr inbounds ptr, ptr %194, i64 %indvars.iv257.unr
  %197 = load ptr, ptr %196, align 8, !tbaa !24
  %198 = getelementptr inbounds i8, ptr %197, i64 40
  %199 = load ptr, ptr %198, align 8, !tbaa !30
  %200 = getelementptr inbounds i8, ptr %199, i64 16
  %201 = load ptr, ptr %200, align 8, !tbaa !31
  %202 = getelementptr inbounds ptr, ptr %201, i64 %indvars.iv262
  %203 = load ptr, ptr %202, align 8, !tbaa !24
  %204 = getelementptr inbounds ptr, ptr %.pre269, i64 %indvars.iv257.unr
  %205 = load ptr, ptr %204, align 8, !tbaa !24
  %206 = getelementptr inbounds i8, ptr %205, i64 8
  store ptr %203, ptr %206, align 8, !tbaa !40
  br label %._crit_edge235

._crit_edge235:                                   ; preds = %._crit_edge235.loopexit.epilog-lcssa, %._crit_edge235.loopexit.unr-lcssa, %.preheader
  %207 = load ptr, ptr @morn_datafunc, align 8, !tbaa !24
  %208 = load ptr, ptr %152, align 8, !tbaa !23
  %209 = load ptr, ptr %157, align 8, !tbaa !35
  tail call void %207(ptr noundef %.pre269, ptr noundef %208, i32 noundef %191, ptr noundef %209) #4
  %indvars.iv.next263 = add nuw nsw i64 %indvars.iv262, 1
  %210 = load i32, ptr %56, align 4, !tbaa !16
  %211 = sext i32 %210 to i64
  %212 = icmp slt i64 %indvars.iv.next263, %211
  br i1 %212, label %.preheader, label %._crit_edge237, !llvm.loop !42

213:                                              ; preds = %213, %.lr.ph234.new
  %indvars.iv257 = phi i64 [ 0, %.lr.ph234.new ], [ %indvars.iv.next258.1, %213 ]
  %niter274 = phi i64 [ 0, %.lr.ph234.new ], [ %niter274.next.1, %213 ]
  %214 = getelementptr inbounds ptr, ptr %194, i64 %indvars.iv257
  %215 = load ptr, ptr %214, align 8, !tbaa !24
  %216 = getelementptr inbounds i8, ptr %215, i64 40
  %217 = load ptr, ptr %216, align 8, !tbaa !30
  %218 = getelementptr inbounds i8, ptr %217, i64 16
  %219 = load ptr, ptr %218, align 8, !tbaa !31
  %220 = getelementptr inbounds ptr, ptr %219, i64 %indvars.iv262
  %221 = load ptr, ptr %220, align 8, !tbaa !24
  %222 = getelementptr inbounds ptr, ptr %.pre269, i64 %indvars.iv257
  %223 = load ptr, ptr %222, align 8, !tbaa !24
  %224 = getelementptr inbounds i8, ptr %223, i64 8
  store ptr %221, ptr %224, align 8, !tbaa !40
  %indvars.iv.next258 = or disjoint i64 %indvars.iv257, 1
  %225 = getelementptr inbounds ptr, ptr %194, i64 %indvars.iv.next258
  %226 = load ptr, ptr %225, align 8, !tbaa !24
  %227 = getelementptr inbounds i8, ptr %226, i64 40
  %228 = load ptr, ptr %227, align 8, !tbaa !30
  %229 = getelementptr inbounds i8, ptr %228, i64 16
  %230 = load ptr, ptr %229, align 8, !tbaa !31
  %231 = getelementptr inbounds ptr, ptr %230, i64 %indvars.iv262
  %232 = load ptr, ptr %231, align 8, !tbaa !24
  %233 = getelementptr inbounds ptr, ptr %.pre269, i64 %indvars.iv.next258
  %234 = load ptr, ptr %233, align 8, !tbaa !24
  %235 = getelementptr inbounds i8, ptr %234, i64 8
  store ptr %232, ptr %235, align 8, !tbaa !40
  %indvars.iv.next258.1 = add nuw nsw i64 %indvars.iv257, 2
  %niter274.next.1 = add i64 %niter274, 2
  %niter274.ncmp.1 = icmp eq i64 %niter274.next.1, %unroll_iter273
  br i1 %niter274.ncmp.1, label %._crit_edge235.loopexit.unr-lcssa, label %213, !llvm.loop !43

.preheader212:                                    ; preds = %.preheader212.lr.ph, %._crit_edge
  %indvars.iv239 = phi i64 [ 0, %.preheader212.lr.ph ], [ %indvars.iv.next240, %._crit_edge ]
  %236 = load ptr, ptr %11, align 8, !tbaa !19
  %237 = load i32, ptr %236, align 8, !tbaa !21
  %238 = icmp sgt i32 %237, 0
  %.pre = load ptr, ptr %12, align 8, !tbaa !20
  br i1 %238, label %.lr.ph, label %._crit_edge

.lr.ph:                                           ; preds = %.preheader212
  %239 = getelementptr inbounds i8, ptr %236, i64 8
  %240 = load ptr, ptr %239, align 8, !tbaa !27
  %wide.trip.count = zext nneg i32 %237 to i64
  %xtraiter = and i64 %wide.trip.count, 1
  %241 = icmp eq i32 %237, 1
  br i1 %241, label %._crit_edge.loopexit.unr-lcssa, label %.lr.ph.new

.lr.ph.new:                                       ; preds = %.lr.ph
  %unroll_iter = and i64 %wide.trip.count, 2147483646
  br label %264

.preheader210:                                    ; preds = %._crit_edge, %.preheader213
  %242 = getelementptr inbounds i8, ptr %4, i64 48
  %243 = load i32, ptr %242, align 8, !tbaa !15
  %244 = icmp sgt i32 %243, 0
  br i1 %244, label %.lr.ph221, label %.loopexit211

.lr.ph221:                                        ; preds = %.preheader210
  %245 = getelementptr inbounds i8, ptr %4, i64 52
  %246 = getelementptr inbounds i8, ptr %4, i64 32
  br label %290

._crit_edge.loopexit.unr-lcssa:                   ; preds = %264, %.lr.ph
  %indvars.iv.unr = phi i64 [ 0, %.lr.ph ], [ %indvars.iv.next.1, %264 ]
  %lcmp.mod.not = icmp eq i64 %xtraiter, 0
  br i1 %lcmp.mod.not, label %._crit_edge, label %._crit_edge.loopexit.epilog-lcssa

._crit_edge.loopexit.epilog-lcssa:                ; preds = %._crit_edge.loopexit.unr-lcssa
  %247 = getelementptr inbounds ptr, ptr %240, i64 %indvars.iv.unr
  %248 = load ptr, ptr %247, align 8, !tbaa !24
  %249 = getelementptr inbounds i8, ptr %248, i64 40
  %250 = load ptr, ptr %249, align 8, !tbaa !30
  %251 = getelementptr inbounds i8, ptr %250, i64 16
  %252 = load ptr, ptr %251, align 8, !tbaa !31
  %253 = getelementptr inbounds ptr, ptr %252, i64 %indvars.iv239
  %254 = load ptr, ptr %253, align 8, !tbaa !24
  %255 = getelementptr inbounds ptr, ptr %.pre, i64 %indvars.iv.unr
  %256 = load ptr, ptr %255, align 8, !tbaa !24
  %257 = getelementptr inbounds i8, ptr %256, i64 8
  store ptr %254, ptr %257, align 8, !tbaa !40
  br label %._crit_edge

._crit_edge:                                      ; preds = %._crit_edge.loopexit.epilog-lcssa, %._crit_edge.loopexit.unr-lcssa, %.preheader212
  %258 = load ptr, ptr @morn_datafunc, align 8, !tbaa !24
  %259 = load ptr, ptr %13, align 8, !tbaa !23
  %260 = load ptr, ptr %14, align 8, !tbaa !35
  tail call void %258(ptr noundef %.pre, ptr noundef %259, i32 noundef %237, ptr noundef %260) #4
  %indvars.iv.next240 = add nuw nsw i64 %indvars.iv239, 1
  %261 = load i32, ptr %8, align 8, !tbaa !12
  %262 = sext i32 %261 to i64
  %263 = icmp slt i64 %indvars.iv.next240, %262
  br i1 %263, label %.preheader212, label %.preheader210, !llvm.loop !44

264:                                              ; preds = %264, %.lr.ph.new
  %indvars.iv = phi i64 [ 0, %.lr.ph.new ], [ %indvars.iv.next.1, %264 ]
  %niter = phi i64 [ 0, %.lr.ph.new ], [ %niter.next.1, %264 ]
  %265 = getelementptr inbounds ptr, ptr %240, i64 %indvars.iv
  %266 = load ptr, ptr %265, align 8, !tbaa !24
  %267 = getelementptr inbounds i8, ptr %266, i64 40
  %268 = load ptr, ptr %267, align 8, !tbaa !30
  %269 = getelementptr inbounds i8, ptr %268, i64 16
  %270 = load ptr, ptr %269, align 8, !tbaa !31
  %271 = getelementptr inbounds ptr, ptr %270, i64 %indvars.iv239
  %272 = load ptr, ptr %271, align 8, !tbaa !24
  %273 = getelementptr inbounds ptr, ptr %.pre, i64 %indvars.iv
  %274 = load ptr, ptr %273, align 8, !tbaa !24
  %275 = getelementptr inbounds i8, ptr %274, i64 8
  store ptr %272, ptr %275, align 8, !tbaa !40
  %indvars.iv.next = or disjoint i64 %indvars.iv, 1
  %276 = getelementptr inbounds ptr, ptr %240, i64 %indvars.iv.next
  %277 = load ptr, ptr %276, align 8, !tbaa !24
  %278 = getelementptr inbounds i8, ptr %277, i64 40
  %279 = load ptr, ptr %278, align 8, !tbaa !30
  %280 = getelementptr inbounds i8, ptr %279, i64 16
  %281 = load ptr, ptr %280, align 8, !tbaa !31
  %282 = getelementptr inbounds ptr, ptr %281, i64 %indvars.iv239
  %283 = load ptr, ptr %282, align 8, !tbaa !24
  %284 = getelementptr inbounds ptr, ptr %.pre, i64 %indvars.iv.next
  %285 = load ptr, ptr %284, align 8, !tbaa !24
  %286 = getelementptr inbounds i8, ptr %285, i64 8
  store ptr %283, ptr %286, align 8, !tbaa !40
  %indvars.iv.next.1 = add nuw nsw i64 %indvars.iv, 2
  %niter.next.1 = add i64 %niter, 2
  %niter.ncmp.1 = icmp eq i64 %niter.next.1, %unroll_iter
  br i1 %niter.ncmp.1, label %._crit_edge.loopexit.unr-lcssa, label %264, !llvm.loop !45

.loopexit:                                        ; preds = %298, %290
  %287 = load i32, ptr %242, align 8, !tbaa !15
  %288 = sext i32 %287 to i64
  %289 = icmp slt i64 %indvars.iv.next246, %288
  br i1 %289, label %290, label %.loopexit211, !llvm.loop !46

290:                                              ; preds = %.lr.ph221, %.loopexit
  %indvars.iv245 = phi i64 [ 0, %.lr.ph221 ], [ %indvars.iv.next246, %.loopexit ]
  %indvars.iv.next246 = add nuw nsw i64 %indvars.iv245, 1
  %291 = load i32, ptr %245, align 4, !tbaa !16
  %292 = trunc nuw nsw i64 %indvars.iv.next246 to i32
  %293 = tail call i32 @m_Rand(i32 noundef %292, i32 noundef %291) #4
  %294 = load ptr, ptr %246, align 8, !tbaa !19
  %295 = load i32, ptr %294, align 8, !tbaa !21
  %296 = icmp sgt i32 %295, 0
  br i1 %296, label %.lr.ph219, label %.loopexit

.lr.ph219:                                        ; preds = %290
  %297 = sext i32 %293 to i64
  br label %298

298:                                              ; preds = %.lr.ph219, %298
  %indvars.iv242 = phi i64 [ 0, %.lr.ph219 ], [ %indvars.iv.next243, %298 ]
  %299 = phi ptr [ %294, %.lr.ph219 ], [ %314, %298 ]
  %300 = getelementptr inbounds i8, ptr %299, i64 8
  %301 = load ptr, ptr %300, align 8, !tbaa !27
  %302 = getelementptr inbounds ptr, ptr %301, i64 %indvars.iv242
  %303 = load ptr, ptr %302, align 8, !tbaa !24
  %304 = getelementptr inbounds i8, ptr %303, i64 40
  %305 = load ptr, ptr %304, align 8, !tbaa !30
  %306 = getelementptr inbounds i8, ptr %305, i64 16
  %307 = load ptr, ptr %306, align 8, !tbaa !31
  %308 = getelementptr inbounds ptr, ptr %307, i64 %indvars.iv245
  %309 = load ptr, ptr %308, align 8, !tbaa !24
  %310 = getelementptr inbounds ptr, ptr %307, i64 %297
  %311 = load ptr, ptr %310, align 8, !tbaa !24
  store ptr %311, ptr %308, align 8, !tbaa !24
  %312 = load ptr, ptr %306, align 8, !tbaa !31
  %313 = getelementptr inbounds ptr, ptr %312, i64 %297
  store ptr %309, ptr %313, align 8, !tbaa !24
  %indvars.iv.next243 = add nuw nsw i64 %indvars.iv242, 1
  %314 = load ptr, ptr %246, align 8, !tbaa !19
  %315 = load i32, ptr %314, align 8, !tbaa !21
  %316 = sext i32 %315 to i64
  %317 = icmp slt i64 %indvars.iv.next243, %316
  br i1 %317, label %298, label %.loopexit, !llvm.loop !47

.loopexit211:                                     ; preds = %.loopexit, %.preheader210, %._crit_edge237
  ret void
}

declare ptr @mNetworkGenerate(ptr noundef) local_unnamed_addr #1

declare ptr @m_INIRead(ptr noundef, i64 noundef, i64 noundef, ptr noundef, ...) local_unnamed_addr #1

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare i32 @atoi(ptr nocapture noundef nonnull) local_unnamed_addr #2

; Function Attrs: inlinehint mustprogress nofree nounwind willreturn memory(read) uwtable
declare double @atof(ptr nocapture noundef nonnull) local_unnamed_addr #2

declare i32 @mTensorRegisterIndex(ptr noundef) local_unnamed_addr #1

declare void @mListClear(ptr noundef) local_unnamed_addr #1

declare ptr @TensorCreate(i32 noundef, i32 noundef, i32 noundef, i32 noundef, ptr noundef, i32 noundef) local_unnamed_addr #1

declare void @TensorRedefine(ptr noundef, i32 noundef, i32 noundef, i32 noundef, i32 noundef, ptr noundef, i32 noundef) local_unnamed_addr #1

declare ptr @mListWrite(ptr noundef, i32 noundef, ptr noundef, i32 noundef) local_unnamed_addr #1

declare ptr @m_Malloc(i32 noundef) local_unnamed_addr #1

declare ptr @VectorCreate(i32 noundef, ptr noundef) local_unnamed_addr #1

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !10, i64 16}
!6 = !{!"MHandle", !7, i64 0, !7, i64 4, !10, i64 8, !10, i64 16}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"any pointer", !8, i64 0}
!11 = !{!6, !7, i64 4}
!12 = !{!13, !7, i64 56}
!13 = !{!"HandleTrainData", !10, i64 0, !10, i64 8, !10, i64 16, !10, i64 24, !10, i64 32, !10, i64 40, !7, i64 48, !7, i64 52, !7, i64 56, !7, i64 60, !7, i64 64}
!14 = !{!13, !10, i64 0}
!15 = !{!13, !7, i64 48}
!16 = !{!13, !7, i64 52}
!17 = !{!13, !7, i64 60}
!18 = !{!13, !7, i64 64}
!19 = !{!13, !10, i64 32}
!20 = !{!13, !10, i64 16}
!21 = !{!22, !7, i64 0}
!22 = !{!"MList", !7, i64 0, !10, i64 8}
!23 = !{!13, !10, i64 24}
!24 = !{!10, !10, i64 0}
!25 = distinct !{!25, !26}
!26 = !{!"llvm.loop.mustprogress"}
!27 = !{!22, !10, i64 8}
!28 = !{!29, !7, i64 32}
!29 = !{!"MLayer", !8, i64 0, !7, i64 32, !10, i64 40, !10, i64 48, !10, i64 56, !7, i64 64}
!30 = !{!29, !10, i64 40}
!31 = !{!32, !10, i64 16}
!32 = !{!"MTensor", !7, i64 0, !7, i64 4, !7, i64 8, !7, i64 12, !10, i64 16, !7, i64 24}
!33 = !{!32, !7, i64 0}
!34 = distinct !{!34, !26}
!35 = !{!13, !10, i64 8}
!36 = !{!32, !7, i64 4}
!37 = !{!32, !7, i64 8}
!38 = !{!32, !7, i64 12}
!39 = distinct !{!39, !26}
!40 = !{!41, !10, i64 8}
!41 = !{!"MVector", !7, i64 0, !10, i64 8}
!42 = distinct !{!42, !26}
!43 = distinct !{!43, !26}
!44 = distinct !{!44, !26}
!45 = distinct !{!45, !26}
!46 = distinct !{!46, !26}
!47 = distinct !{!47, !26}


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