; LLVM IR from oservo/aiFi :: mlpLayer (mlpLayerAppend)

; 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.mlp = type { i32, i32, i32, i32, i32, double, double, ptr, i32, i32, i32, i32, i32, i32, ptr, ptr, ptr, ptr, ptr, ptr, ptr }
%struct.mlpLayer = type { i32, i32, i32, i32, double, double, i32, i32, i32, double, double, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr }

@stderr = external global ptr, align 8
@.str = external hidden unnamed_addr constant [83 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [56 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [14 x i8], align 1
@__PRETTY_FUNCTION__.mlpLayerAppend = external hidden unnamed_addr constant [126 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [70 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [57 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [96 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [58 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [73 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [53 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [70 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [45 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.17 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [41 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [54 x i8], align 1
@.str.20 = external hidden unnamed_addr constant [62 x i8], align 1
@.str.21 = external hidden unnamed_addr constant [55 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [34 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [47 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [39 x i8], align 1
@.str.28 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.29 = external hidden unnamed_addr constant [48 x i8], align 1

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

; Function Attrs: nounwind uwtable
define dso_local ptr @mlpLayerAppend(ptr noundef %0, i32 noundef %1, i32 noundef %2, i32 noundef %3, i32 noundef %4, i32 noundef %5, i32 noundef %6) #1 {
  %8 = alloca ptr, align 8
  %9 = alloca i32, align 4
  %10 = alloca i32, align 4
  %11 = alloca i32, align 4
  %12 = alloca i32, align 4
  %13 = alloca i32, align 4
  %14 = alloca i32, align 4
  %15 = alloca ptr, align 8
  %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
  store ptr %0, ptr %8, align 8, !tbaa !5
  store i32 %1, ptr %9, align 4, !tbaa !9
  store i32 %2, ptr %10, align 4, !tbaa !9
  store i32 %3, ptr %11, align 4, !tbaa !9
  store i32 %4, ptr %12, align 4, !tbaa !9
  store i32 %5, ptr %13, align 4, !tbaa !9
  store i32 %6, ptr %14, align 4, !tbaa !9
  call void @llvm.lifetime.start.p0(i64 8, ptr %15) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %16) #8
  call void @llvm.lifetime.start.p0(i64 4, ptr %17) #8
  %21 = load ptr, ptr %8, align 8, !tbaa !5
  %22 = getelementptr inbounds %struct.mlp, ptr %21, i32 0, i32 1
  %23 = load i32, ptr %22, align 4, !tbaa !11
  store i32 %23, ptr %17, align 4, !tbaa !9
  %24 = load i32, ptr %9, align 4, !tbaa !9
  %25 = icmp sgt i32 %24, 0
  br i1 %25, label %45, label %26

26:                                               ; preds = %7
  %27 = load ptr, ptr @stderr, align 8, !tbaa !5
  %28 = call ptr @__errno_location() #9
  %29 = load i32, ptr %28, align 4, !tbaa !9
  %30 = icmp eq i32 %29, 0
  br i1 %30, label %31, label %32

31:                                               ; preds = %26
  br label %36

32:                                               ; preds = %26
  %33 = call ptr @__errno_location() #9
  %34 = load i32, ptr %33, align 4, !tbaa !9
  %35 = call ptr @strerror(i32 noundef %34) #8
  br label %36

36:                                               ; preds = %32, %31
  %37 = phi ptr [ @.str.2, %31 ], [ %35, %32 ]
  %38 = load i32, ptr %17, align 4, !tbaa !9
  %39 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %27, ptr noundef @.str, ptr noundef @.str.1, i32 noundef 47, ptr noundef %37, i32 noundef %38) #8
  %40 = load i32, ptr %9, align 4, !tbaa !9
  %41 = icmp sgt i32 %40, 0
  br i1 %41, label %42, label %43

42:                                               ; preds = %36
  br label %44

43:                                               ; preds = %36
  call void @__assert_fail(ptr noundef @.str.3, ptr noundef @.str.1, i32 noundef 47, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

44:                                               ; preds = %42
  br label %45

45:                                               ; preds = %44, %7
  %46 = load i32, ptr %17, align 4, !tbaa !9
  %47 = icmp sgt i32 %46, 0
  br i1 %47, label %48, label %59

48:                                               ; preds = %45
  %49 = load ptr, ptr %8, align 8, !tbaa !5
  %50 = getelementptr inbounds %struct.mlp, ptr %49, i32 0, i32 7
  %51 = load ptr, ptr %50, align 8, !tbaa !14
  %52 = load i32, ptr %17, align 4, !tbaa !9
  %53 = sub nsw i32 %52, 1
  %54 = sext i32 %53 to i64
  %55 = getelementptr inbounds ptr, ptr %51, i64 %54
  %56 = load ptr, ptr %55, align 8, !tbaa !5
  %57 = getelementptr inbounds %struct.mlpLayer, ptr %56, i32 0, i32 1
  %58 = load i32, ptr %57, align 4, !tbaa !15
  store i32 %58, ptr %16, align 4, !tbaa !9
  br label %60

59:                                               ; preds = %45
  store i32 1, ptr %16, align 4, !tbaa !9
  br label %60

60:                                               ; preds = %59, %48
  %61 = load i32, ptr %10, align 4, !tbaa !9
  switch i32 %61, label %194 [
    i32 0, label %62
    i32 1, label %106
    i32 2, label %150
  ]

62:                                               ; preds = %60
  %63 = load ptr, ptr %8, align 8, !tbaa !5
  %64 = getelementptr inbounds %struct.mlp, ptr %63, i32 0, i32 2
  %65 = load i32, ptr %64, align 8, !tbaa !17
  %66 = icmp eq i32 %65, 0
  br i1 %66, label %67, label %72

67:                                               ; preds = %62
  %68 = load ptr, ptr %8, align 8, !tbaa !5
  %69 = getelementptr inbounds %struct.mlp, ptr %68, i32 0, i32 1
  %70 = load i32, ptr %69, align 4, !tbaa !11
  %71 = icmp eq i32 %70, 0
  br i1 %71, label %97, label %72

72:                                               ; preds = %67, %62
  %73 = load ptr, ptr @stderr, align 8, !tbaa !5
  %74 = call ptr @__errno_location() #9
  %75 = load i32, ptr %74, align 4, !tbaa !9
  %76 = icmp eq i32 %75, 0
  br i1 %76, label %77, label %78

77:                                               ; preds = %72
  br label %82

78:                                               ; preds = %72
  %79 = call ptr @__errno_location() #9
  %80 = load i32, ptr %79, align 4, !tbaa !9
  %81 = call ptr @strerror(i32 noundef %80) #8
  br label %82

82:                                               ; preds = %78, %77
  %83 = phi ptr [ @.str.2, %77 ], [ %81, %78 ]
  %84 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %73, ptr noundef @.str.4, ptr noundef @.str.1, i32 noundef 58, ptr noundef %83) #8
  %85 = load ptr, ptr %8, align 8, !tbaa !5
  %86 = getelementptr inbounds %struct.mlp, ptr %85, i32 0, i32 2
  %87 = load i32, ptr %86, align 8, !tbaa !17
  %88 = icmp eq i32 %87, 0
  br i1 %88, label %89, label %95

89:                                               ; preds = %82
  %90 = load ptr, ptr %8, align 8, !tbaa !5
  %91 = getelementptr inbounds %struct.mlp, ptr %90, i32 0, i32 1
  %92 = load i32, ptr %91, align 4, !tbaa !11
  %93 = icmp eq i32 %92, 0
  br i1 %93, label %94, label %95

94:                                               ; preds = %89
  br label %96

95:                                               ; preds = %89, %82
  call void @__assert_fail(ptr noundef @.str.5, ptr noundef @.str.1, i32 noundef 58, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

96:                                               ; preds = %94
  br label %97

97:                                               ; preds = %96, %67
  %98 = load ptr, ptr %8, align 8, !tbaa !5
  %99 = getelementptr inbounds %struct.mlp, ptr %98, i32 0, i32 2
  %100 = load i32, ptr %99, align 8, !tbaa !17
  %101 = add nsw i32 %100, 1
  store i32 %101, ptr %99, align 8, !tbaa !17
  %102 = load ptr, ptr %8, align 8, !tbaa !5
  %103 = getelementptr inbounds %struct.mlp, ptr %102, i32 0, i32 1
  %104 = load i32, ptr %103, align 4, !tbaa !11
  %105 = add nsw i32 %104, 1
  store i32 %105, ptr %103, align 4, !tbaa !11
  br label %194

106:                                              ; preds = %60
  %107 = load ptr, ptr %8, align 8, !tbaa !5
  %108 = getelementptr inbounds %struct.mlp, ptr %107, i32 0, i32 2
  %109 = load i32, ptr %108, align 8, !tbaa !17
  %110 = icmp eq i32 %109, 1
  br i1 %110, label %111, label %116

111:                                              ; preds = %106
  %112 = load ptr, ptr %8, align 8, !tbaa !5
  %113 = getelementptr inbounds %struct.mlp, ptr %112, i32 0, i32 4
  %114 = load i32, ptr %113, align 8, !tbaa !18
  %115 = icmp eq i32 %114, 0
  br i1 %115, label %141, label %116

116:                                              ; preds = %111, %106
  %117 = load ptr, ptr @stderr, align 8, !tbaa !5
  %118 = call ptr @__errno_location() #9
  %119 = load i32, ptr %118, align 4, !tbaa !9
  %120 = icmp eq i32 %119, 0
  br i1 %120, label %121, label %122

121:                                              ; preds = %116
  br label %126

122:                                              ; preds = %116
  %123 = call ptr @__errno_location() #9
  %124 = load i32, ptr %123, align 4, !tbaa !9
  %125 = call ptr @strerror(i32 noundef %124) #8
  br label %126

126:                                              ; preds = %122, %121
  %127 = phi ptr [ @.str.2, %121 ], [ %125, %122 ]
  %128 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %117, ptr noundef @.str.6, ptr noundef @.str.1, i32 noundef 64, ptr noundef %127) #8
  %129 = load ptr, ptr %8, align 8, !tbaa !5
  %130 = getelementptr inbounds %struct.mlp, ptr %129, i32 0, i32 2
  %131 = load i32, ptr %130, align 8, !tbaa !17
  %132 = icmp eq i32 %131, 1
  br i1 %132, label %133, label %139

133:                                              ; preds = %126
  %134 = load ptr, ptr %8, align 8, !tbaa !5
  %135 = getelementptr inbounds %struct.mlp, ptr %134, i32 0, i32 4
  %136 = load i32, ptr %135, align 8, !tbaa !18
  %137 = icmp eq i32 %136, 0
  br i1 %137, label %138, label %139

138:                                              ; preds = %133
  br label %140

139:                                              ; preds = %133, %126
  call void @__assert_fail(ptr noundef @.str.7, ptr noundef @.str.1, i32 noundef 64, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

140:                                              ; preds = %138
  br label %141

141:                                              ; preds = %140, %111
  %142 = load ptr, ptr %8, align 8, !tbaa !5
  %143 = getelementptr inbounds %struct.mlp, ptr %142, i32 0, i32 3
  %144 = load i32, ptr %143, align 4, !tbaa !19
  %145 = add nsw i32 %144, 1
  store i32 %145, ptr %143, align 4, !tbaa !19
  %146 = load ptr, ptr %8, align 8, !tbaa !5
  %147 = getelementptr inbounds %struct.mlp, ptr %146, i32 0, i32 1
  %148 = load i32, ptr %147, align 4, !tbaa !11
  %149 = add nsw i32 %148, 1
  store i32 %149, ptr %147, align 4, !tbaa !11
  br label %194

150:                                              ; preds = %60
  %151 = load ptr, ptr %8, align 8, !tbaa !5
  %152 = getelementptr inbounds %struct.mlp, ptr %151, i32 0, i32 2
  %153 = load i32, ptr %152, align 8, !tbaa !17
  %154 = icmp eq i32 %153, 1
  br i1 %154, label %155, label %160

155:                                              ; preds = %150
  %156 = load ptr, ptr %8, align 8, !tbaa !5
  %157 = getelementptr inbounds %struct.mlp, ptr %156, i32 0, i32 4
  %158 = load i32, ptr %157, align 8, !tbaa !18
  %159 = icmp eq i32 %158, 0
  br i1 %159, label %185, label %160

160:                                              ; preds = %155, %150
  %161 = load ptr, ptr @stderr, align 8, !tbaa !5
  %162 = call ptr @__errno_location() #9
  %163 = load i32, ptr %162, align 4, !tbaa !9
  %164 = icmp eq i32 %163, 0
  br i1 %164, label %165, label %166

165:                                              ; preds = %160
  br label %170

166:                                              ; preds = %160
  %167 = call ptr @__errno_location() #9
  %168 = load i32, ptr %167, align 4, !tbaa !9
  %169 = call ptr @strerror(i32 noundef %168) #8
  br label %170

170:                                              ; preds = %166, %165
  %171 = phi ptr [ @.str.2, %165 ], [ %169, %166 ]
  %172 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %161, ptr noundef @.str.8, ptr noundef @.str.1, i32 noundef 70, ptr noundef %171) #8
  %173 = load ptr, ptr %8, align 8, !tbaa !5
  %174 = getelementptr inbounds %struct.mlp, ptr %173, i32 0, i32 2
  %175 = load i32, ptr %174, align 8, !tbaa !17
  %176 = icmp eq i32 %175, 1
  br i1 %176, label %177, label %183

177:                                              ; preds = %170
  %178 = load ptr, ptr %8, align 8, !tbaa !5
  %179 = getelementptr inbounds %struct.mlp, ptr %178, i32 0, i32 4
  %180 = load i32, ptr %179, align 8, !tbaa !18
  %181 = icmp eq i32 %180, 0
  br i1 %181, label %182, label %183

182:                                              ; preds = %177
  br label %184

183:                                              ; preds = %177, %170
  call void @__assert_fail(ptr noundef @.str.7, ptr noundef @.str.1, i32 noundef 70, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

184:                                              ; preds = %182
  br label %185

185:                                              ; preds = %184, %155
  %186 = load ptr, ptr %8, align 8, !tbaa !5
  %187 = getelementptr inbounds %struct.mlp, ptr %186, i32 0, i32 4
  %188 = load i32, ptr %187, align 8, !tbaa !18
  %189 = add nsw i32 %188, 1
  store i32 %189, ptr %187, align 8, !tbaa !18
  %190 = load ptr, ptr %8, align 8, !tbaa !5
  %191 = getelementptr inbounds %struct.mlp, ptr %190, i32 0, i32 1
  %192 = load i32, ptr %191, align 4, !tbaa !11
  %193 = add nsw i32 %192, 1
  store i32 %193, ptr %191, align 4, !tbaa !11
  br label %194

194:                                              ; preds = %185, %141, %97, %60
  %195 = load ptr, ptr %8, align 8, !tbaa !5
  %196 = getelementptr inbounds %struct.mlp, ptr %195, i32 0, i32 1
  %197 = load i32, ptr %196, align 4, !tbaa !11
  %198 = icmp eq i32 %197, 1
  br i1 %198, label %199, label %208

199:                                              ; preds = %194
  %200 = load ptr, ptr %8, align 8, !tbaa !5
  %201 = getelementptr inbounds %struct.mlp, ptr %200, i32 0, i32 1
  %202 = load i32, ptr %201, align 4, !tbaa !11
  %203 = sext i32 %202 to i64
  %204 = mul i64 %203, 8
  %205 = call noalias ptr @malloc(i64 noundef %204) #11
  %206 = load ptr, ptr %8, align 8, !tbaa !5
  %207 = getelementptr inbounds %struct.mlp, ptr %206, i32 0, i32 7
  store ptr %205, ptr %207, align 8, !tbaa !14
  br label %220

208:                                              ; preds = %194
  %209 = load ptr, ptr %8, align 8, !tbaa !5
  %210 = getelementptr inbounds %struct.mlp, ptr %209, i32 0, i32 7
  %211 = load ptr, ptr %210, align 8, !tbaa !14
  %212 = load ptr, ptr %8, align 8, !tbaa !5
  %213 = getelementptr inbounds %struct.mlp, ptr %212, i32 0, i32 1
  %214 = load i32, ptr %213, align 4, !tbaa !11
  %215 = sext i32 %214 to i64
  %216 = mul i64 %215, 8
  %217 = call ptr @realloc(ptr noundef %211, i64 noundef %216) #12
  %218 = load ptr, ptr %8, align 8, !tbaa !5
  %219 = getelementptr inbounds %struct.mlp, ptr %218, i32 0, i32 7
  store ptr %217, ptr %219, align 8, !tbaa !14
  br label %220

220:                                              ; preds = %208, %199
  %221 = load ptr, ptr %8, align 8, !tbaa !5
  %222 = getelementptr inbounds %struct.mlp, ptr %221, i32 0, i32 7
  %223 = load ptr, ptr %222, align 8, !tbaa !14
  %224 = icmp ne ptr %223, null
  br i1 %224, label %245, label %225

225:                                              ; preds = %220
  %226 = load ptr, ptr @stderr, align 8, !tbaa !5
  %227 = call ptr @__errno_location() #9
  %228 = load i32, ptr %227, align 4, !tbaa !9
  %229 = icmp eq i32 %228, 0
  br i1 %229, label %230, label %231

230:                                              ; preds = %225
  br label %235

231:                                              ; preds = %225
  %232 = call ptr @__errno_location() #9
  %233 = load i32, ptr %232, align 4, !tbaa !9
  %234 = call ptr @strerror(i32 noundef %233) #8
  br label %235

235:                                              ; preds = %231, %230
  %236 = phi ptr [ @.str.2, %230 ], [ %234, %231 ]
  %237 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %226, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 83, ptr noundef %236) #8
  %238 = load ptr, ptr %8, align 8, !tbaa !5
  %239 = getelementptr inbounds %struct.mlp, ptr %238, i32 0, i32 7
  %240 = load ptr, ptr %239, align 8, !tbaa !14
  %241 = icmp ne ptr %240, null
  br i1 %241, label %242, label %243

242:                                              ; preds = %235
  br label %244

243:                                              ; preds = %235
  call void @__assert_fail(ptr noundef @.str.10, ptr noundef @.str.1, i32 noundef 83, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

244:                                              ; preds = %242
  br label %245

245:                                              ; preds = %244, %220
  %246 = call noalias ptr @malloc(i64 noundef 176) #11
  store ptr %246, ptr %15, align 8, !tbaa !5
  %247 = load ptr, ptr %15, align 8, !tbaa !5
  %248 = icmp ne ptr %247, null
  br i1 %248, label %268, label %249

249:                                              ; preds = %245
  %250 = load ptr, ptr @stderr, align 8, !tbaa !5
  %251 = call ptr @__errno_location() #9
  %252 = load i32, ptr %251, align 4, !tbaa !9
  %253 = icmp eq i32 %252, 0
  br i1 %253, label %254, label %255

254:                                              ; preds = %249
  br label %259

255:                                              ; preds = %249
  %256 = call ptr @__errno_location() #9
  %257 = load i32, ptr %256, align 4, !tbaa !9
  %258 = call ptr @strerror(i32 noundef %257) #8
  br label %259

259:                                              ; preds = %255, %254
  %260 = phi ptr [ @.str.2, %254 ], [ %258, %255 ]
  %261 = load i32, ptr %17, align 4, !tbaa !9
  %262 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %250, ptr noundef @.str.11, ptr noundef @.str.1, i32 noundef 86, ptr noundef %260, i32 noundef %261) #8
  %263 = load ptr, ptr %15, align 8, !tbaa !5
  %264 = icmp ne ptr %263, null
  br i1 %264, label %265, label %266

265:                                              ; preds = %259
  br label %267

266:                                              ; preds = %259
  call void @__assert_fail(ptr noundef @.str.12, ptr noundef @.str.1, i32 noundef 86, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

267:                                              ; preds = %265
  br label %268

268:                                              ; preds = %267, %245
  %269 = load i32, ptr %17, align 4, !tbaa !9
  %270 = load ptr, ptr %15, align 8, !tbaa !5
  %271 = getelementptr inbounds %struct.mlpLayer, ptr %270, i32 0, i32 0
  store i32 %269, ptr %271, align 8, !tbaa !20
  %272 = load i32, ptr %9, align 4, !tbaa !9
  %273 = load ptr, ptr %15, align 8, !tbaa !5
  %274 = getelementptr inbounds %struct.mlpLayer, ptr %273, i32 0, i32 1
  store i32 %272, ptr %274, align 4, !tbaa !15
  %275 = load i32, ptr %10, align 4, !tbaa !9
  %276 = load ptr, ptr %15, align 8, !tbaa !5
  %277 = getelementptr inbounds %struct.mlpLayer, ptr %276, i32 0, i32 2
  store i32 %275, ptr %277, align 8, !tbaa !21
  %278 = load i32, ptr %11, align 4, !tbaa !9
  %279 = load ptr, ptr %15, align 8, !tbaa !5
  %280 = getelementptr inbounds %struct.mlpLayer, ptr %279, i32 0, i32 3
  store i32 %278, ptr %280, align 4, !tbaa !22
  %281 = load ptr, ptr %15, align 8, !tbaa !5
  %282 = getelementptr inbounds %struct.mlpLayer, ptr %281, i32 0, i32 4
  store double 0.000000e+00, ptr %282, align 8, !tbaa !23
  %283 = load ptr, ptr %15, align 8, !tbaa !5
  %284 = getelementptr inbounds %struct.mlpLayer, ptr %283, i32 0, i32 5
  store double 0.000000e+00, ptr %284, align 8, !tbaa !24
  %285 = load i32, ptr %12, align 4, !tbaa !9
  %286 = load ptr, ptr %15, align 8, !tbaa !5
  %287 = getelementptr inbounds %struct.mlpLayer, ptr %286, i32 0, i32 6
  store i32 %285, ptr %287, align 8, !tbaa !25
  %288 = load i32, ptr %13, align 4, !tbaa !9
  %289 = load ptr, ptr %15, align 8, !tbaa !5
  %290 = getelementptr inbounds %struct.mlpLayer, ptr %289, i32 0, i32 7
  store i32 %288, ptr %290, align 4, !tbaa !26
  %291 = load i32, ptr %14, align 4, !tbaa !9
  %292 = load ptr, ptr %15, align 8, !tbaa !5
  %293 = getelementptr inbounds %struct.mlpLayer, ptr %292, i32 0, i32 8
  store i32 %291, ptr %293, align 8, !tbaa !27
  %294 = load ptr, ptr %15, align 8, !tbaa !5
  %295 = getelementptr inbounds %struct.mlpLayer, ptr %294, i32 0, i32 9
  store double 0.000000e+00, ptr %295, align 8, !tbaa !28
  %296 = load ptr, ptr %15, align 8, !tbaa !5
  %297 = getelementptr inbounds %struct.mlpLayer, ptr %296, i32 0, i32 10
  store double 0.000000e+00, ptr %297, align 8, !tbaa !29
  %298 = load i32, ptr %9, align 4, !tbaa !9
  %299 = sext i32 %298 to i64
  %300 = mul i64 %299, 4
  %301 = call noalias ptr @malloc(i64 noundef %300) #11
  %302 = load ptr, ptr %15, align 8, !tbaa !5
  %303 = getelementptr inbounds %struct.mlpLayer, ptr %302, i32 0, i32 11
  store ptr %301, ptr %303, align 8, !tbaa !30
  %304 = load ptr, ptr %15, align 8, !tbaa !5
  %305 = getelementptr inbounds %struct.mlpLayer, ptr %304, i32 0, i32 11
  %306 = load ptr, ptr %305, align 8, !tbaa !30
  %307 = icmp ne ptr %306, null
  br i1 %307, label %328, label %308

308:                                              ; preds = %268
  %309 = load ptr, ptr @stderr, align 8, !tbaa !5
  %310 = call ptr @__errno_location() #9
  %311 = load i32, ptr %310, align 4, !tbaa !9
  %312 = icmp eq i32 %311, 0
  br i1 %312, label %313, label %314

313:                                              ; preds = %308
  br label %318

314:                                              ; preds = %308
  %315 = call ptr @__errno_location() #9
  %316 = load i32, ptr %315, align 4, !tbaa !9
  %317 = call ptr @strerror(i32 noundef %316) #8
  br label %318

318:                                              ; preds = %314, %313
  %319 = phi ptr [ @.str.2, %313 ], [ %317, %314 ]
  %320 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %309, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 104, ptr noundef %319) #8
  %321 = load ptr, ptr %15, align 8, !tbaa !5
  %322 = getelementptr inbounds %struct.mlpLayer, ptr %321, i32 0, i32 11
  %323 = load ptr, ptr %322, align 8, !tbaa !30
  %324 = icmp ne ptr %323, null
  br i1 %324, label %325, label %326

325:                                              ; preds = %318
  br label %327

326:                                              ; preds = %318
  call void @__assert_fail(ptr noundef @.str.13, ptr noundef @.str.1, i32 noundef 104, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

327:                                              ; preds = %325
  br label %328

328:                                              ; preds = %327, %268
  %329 = load i32, ptr %9, align 4, !tbaa !9
  %330 = sext i32 %329 to i64
  %331 = mul i64 %330, 8
  %332 = call noalias ptr @malloc(i64 noundef %331) #11
  %333 = load ptr, ptr %15, align 8, !tbaa !5
  %334 = getelementptr inbounds %struct.mlpLayer, ptr %333, i32 0, i32 12
  store ptr %332, ptr %334, align 8, !tbaa !31
  %335 = load ptr, ptr %15, align 8, !tbaa !5
  %336 = getelementptr inbounds %struct.mlpLayer, ptr %335, i32 0, i32 12
  %337 = load ptr, ptr %336, align 8, !tbaa !31
  %338 = icmp ne ptr %337, null
  br i1 %338, label %359, label %339

339:                                              ; preds = %328
  %340 = load ptr, ptr @stderr, align 8, !tbaa !5
  %341 = call ptr @__errno_location() #9
  %342 = load i32, ptr %341, align 4, !tbaa !9
  %343 = icmp eq i32 %342, 0
  br i1 %343, label %344, label %345

344:                                              ; preds = %339
  br label %349

345:                                              ; preds = %339
  %346 = call ptr @__errno_location() #9
  %347 = load i32, ptr %346, align 4, !tbaa !9
  %348 = call ptr @strerror(i32 noundef %347) #8
  br label %349

349:                                              ; preds = %345, %344
  %350 = phi ptr [ @.str.2, %344 ], [ %348, %345 ]
  %351 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %340, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 107, ptr noundef %350) #8
  %352 = load ptr, ptr %15, align 8, !tbaa !5
  %353 = getelementptr inbounds %struct.mlpLayer, ptr %352, i32 0, i32 12
  %354 = load ptr, ptr %353, align 8, !tbaa !31
  %355 = icmp ne ptr %354, null
  br i1 %355, label %356, label %357

356:                                              ; preds = %349
  br label %358

357:                                              ; preds = %349
  call void @__assert_fail(ptr noundef @.str.14, ptr noundef @.str.1, i32 noundef 107, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

358:                                              ; preds = %356
  br label %359

359:                                              ; preds = %358, %328
  %360 = load i32, ptr %9, align 4, !tbaa !9
  %361 = sext i32 %360 to i64
  %362 = mul i64 %361, 8
  %363 = call noalias ptr @malloc(i64 noundef %362) #11
  %364 = load ptr, ptr %15, align 8, !tbaa !5
  %365 = getelementptr inbounds %struct.mlpLayer, ptr %364, i32 0, i32 13
  store ptr %363, ptr %365, align 8, !tbaa !32
  %366 = load ptr, ptr %15, align 8, !tbaa !5
  %367 = getelementptr inbounds %struct.mlpLayer, ptr %366, i32 0, i32 13
  %368 = load ptr, ptr %367, align 8, !tbaa !32
  %369 = icmp ne ptr %368, null
  br i1 %369, label %390, label %370

370:                                              ; preds = %359
  %371 = load ptr, ptr @stderr, align 8, !tbaa !5
  %372 = call ptr @__errno_location() #9
  %373 = load i32, ptr %372, align 4, !tbaa !9
  %374 = icmp eq i32 %373, 0
  br i1 %374, label %375, label %376

375:                                              ; preds = %370
  br label %380

376:                                              ; preds = %370
  %377 = call ptr @__errno_location() #9
  %378 = load i32, ptr %377, align 4, !tbaa !9
  %379 = call ptr @strerror(i32 noundef %378) #8
  br label %380

380:                                              ; preds = %376, %375
  %381 = phi ptr [ @.str.2, %375 ], [ %379, %376 ]
  %382 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %371, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 110, ptr noundef %381) #8
  %383 = load ptr, ptr %15, align 8, !tbaa !5
  %384 = getelementptr inbounds %struct.mlpLayer, ptr %383, i32 0, i32 13
  %385 = load ptr, ptr %384, align 8, !tbaa !32
  %386 = icmp ne ptr %385, null
  br i1 %386, label %387, label %388

387:                                              ; preds = %380
  br label %389

388:                                              ; preds = %380
  call void @__assert_fail(ptr noundef @.str.15, ptr noundef @.str.1, i32 noundef 110, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

389:                                              ; preds = %387
  br label %390

390:                                              ; preds = %389, %359
  %391 = load i32, ptr %9, align 4, !tbaa !9
  %392 = sext i32 %391 to i64
  %393 = mul i64 %392, 8
  %394 = call noalias ptr @malloc(i64 noundef %393) #11
  %395 = load ptr, ptr %15, align 8, !tbaa !5
  %396 = getelementptr inbounds %struct.mlpLayer, ptr %395, i32 0, i32 14
  store ptr %394, ptr %396, align 8, !tbaa !33
  %397 = load ptr, ptr %15, align 8, !tbaa !5
  %398 = getelementptr inbounds %struct.mlpLayer, ptr %397, i32 0, i32 14
  %399 = load ptr, ptr %398, align 8, !tbaa !33
  %400 = icmp ne ptr %399, null
  br i1 %400, label %421, label %401

401:                                              ; preds = %390
  %402 = load ptr, ptr @stderr, align 8, !tbaa !5
  %403 = call ptr @__errno_location() #9
  %404 = load i32, ptr %403, align 4, !tbaa !9
  %405 = icmp eq i32 %404, 0
  br i1 %405, label %406, label %407

406:                                              ; preds = %401
  br label %411

407:                                              ; preds = %401
  %408 = call ptr @__errno_location() #9
  %409 = load i32, ptr %408, align 4, !tbaa !9
  %410 = call ptr @strerror(i32 noundef %409) #8
  br label %411

411:                                              ; preds = %407, %406
  %412 = phi ptr [ @.str.2, %406 ], [ %410, %407 ]
  %413 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %402, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 113, ptr noundef %412) #8
  %414 = load ptr, ptr %15, align 8, !tbaa !5
  %415 = getelementptr inbounds %struct.mlpLayer, ptr %414, i32 0, i32 14
  %416 = load ptr, ptr %415, align 8, !tbaa !33
  %417 = icmp ne ptr %416, null
  br i1 %417, label %418, label %419

418:                                              ; preds = %411
  br label %420

419:                                              ; preds = %411
  call void @__assert_fail(ptr noundef @.str.16, ptr noundef @.str.1, i32 noundef 113, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

420:                                              ; preds = %418
  br label %421

421:                                              ; preds = %420, %390
  %422 = load i32, ptr %9, align 4, !tbaa !9
  %423 = sext i32 %422 to i64
  %424 = mul i64 %423, 8
  %425 = call noalias ptr @malloc(i64 noundef %424) #11
  %426 = load ptr, ptr %15, align 8, !tbaa !5
  %427 = getelementptr inbounds %struct.mlpLayer, ptr %426, i32 0, i32 15
  store ptr %425, ptr %427, align 8, !tbaa !34
  %428 = load ptr, ptr %15, align 8, !tbaa !5
  %429 = getelementptr inbounds %struct.mlpLayer, ptr %428, i32 0, i32 15
  %430 = load ptr, ptr %429, align 8, !tbaa !34
  %431 = icmp ne ptr %430, null
  br i1 %431, label %452, label %432

432:                                              ; preds = %421
  %433 = load ptr, ptr @stderr, align 8, !tbaa !5
  %434 = call ptr @__errno_location() #9
  %435 = load i32, ptr %434, align 4, !tbaa !9
  %436 = icmp eq i32 %435, 0
  br i1 %436, label %437, label %438

437:                                              ; preds = %432
  br label %442

438:                                              ; preds = %432
  %439 = call ptr @__errno_location() #9
  %440 = load i32, ptr %439, align 4, !tbaa !9
  %441 = call ptr @strerror(i32 noundef %440) #8
  br label %442

442:                                              ; preds = %438, %437
  %443 = phi ptr [ @.str.2, %437 ], [ %441, %438 ]
  %444 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %433, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 116, ptr noundef %443) #8
  %445 = load ptr, ptr %15, align 8, !tbaa !5
  %446 = getelementptr inbounds %struct.mlpLayer, ptr %445, i32 0, i32 15
  %447 = load ptr, ptr %446, align 8, !tbaa !34
  %448 = icmp ne ptr %447, null
  br i1 %448, label %449, label %450

449:                                              ; preds = %442
  br label %451

450:                                              ; preds = %442
  call void @__assert_fail(ptr noundef @.str.17, ptr noundef @.str.1, i32 noundef 116, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

451:                                              ; preds = %449
  br label %452

452:                                              ; preds = %451, %421
  %453 = load i32, ptr %9, align 4, !tbaa !9
  %454 = sext i32 %453 to i64
  %455 = mul i64 %454, 8
  %456 = call noalias ptr @malloc(i64 noundef %455) #11
  %457 = load ptr, ptr %15, align 8, !tbaa !5
  %458 = getelementptr inbounds %struct.mlpLayer, ptr %457, i32 0, i32 16
  store ptr %456, ptr %458, align 8, !tbaa !35
  %459 = load ptr, ptr %15, align 8, !tbaa !5
  %460 = getelementptr inbounds %struct.mlpLayer, ptr %459, i32 0, i32 16
  %461 = load ptr, ptr %460, align 8, !tbaa !35
  %462 = icmp ne ptr %461, null
  br i1 %462, label %483, label %463

463:                                              ; preds = %452
  %464 = load ptr, ptr @stderr, align 8, !tbaa !5
  %465 = call ptr @__errno_location() #9
  %466 = load i32, ptr %465, align 4, !tbaa !9
  %467 = icmp eq i32 %466, 0
  br i1 %467, label %468, label %469

468:                                              ; preds = %463
  br label %473

469:                                              ; preds = %463
  %470 = call ptr @__errno_location() #9
  %471 = load i32, ptr %470, align 4, !tbaa !9
  %472 = call ptr @strerror(i32 noundef %471) #8
  br label %473

473:                                              ; preds = %469, %468
  %474 = phi ptr [ @.str.2, %468 ], [ %472, %469 ]
  %475 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %464, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 119, ptr noundef %474) #8
  %476 = load ptr, ptr %15, align 8, !tbaa !5
  %477 = getelementptr inbounds %struct.mlpLayer, ptr %476, i32 0, i32 16
  %478 = load ptr, ptr %477, align 8, !tbaa !35
  %479 = icmp ne ptr %478, null
  br i1 %479, label %480, label %481

480:                                              ; preds = %473
  br label %482

481:                                              ; preds = %473
  call void @__assert_fail(ptr noundef @.str.18, ptr noundef @.str.1, i32 noundef 119, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

482:                                              ; preds = %480
  br label %483

483:                                              ; preds = %482, %452
  %484 = load i32, ptr %9, align 4, !tbaa !9
  %485 = sext i32 %484 to i64
  %486 = mul i64 %485, 8
  %487 = call noalias ptr @malloc(i64 noundef %486) #11
  %488 = load ptr, ptr %15, align 8, !tbaa !5
  %489 = getelementptr inbounds %struct.mlpLayer, ptr %488, i32 0, i32 17
  store ptr %487, ptr %489, align 8, !tbaa !36
  %490 = load ptr, ptr %15, align 8, !tbaa !5
  %491 = getelementptr inbounds %struct.mlpLayer, ptr %490, i32 0, i32 17
  %492 = load ptr, ptr %491, align 8, !tbaa !36
  %493 = icmp ne ptr %492, null
  br i1 %493, label %514, label %494

494:                                              ; preds = %483
  %495 = load ptr, ptr @stderr, align 8, !tbaa !5
  %496 = call ptr @__errno_location() #9
  %497 = load i32, ptr %496, align 4, !tbaa !9
  %498 = icmp eq i32 %497, 0
  br i1 %498, label %499, label %500

499:                                              ; preds = %494
  br label %504

500:                                              ; preds = %494
  %501 = call ptr @__errno_location() #9
  %502 = load i32, ptr %501, align 4, !tbaa !9
  %503 = call ptr @strerror(i32 noundef %502) #8
  br label %504

504:                                              ; preds = %500, %499
  %505 = phi ptr [ @.str.2, %499 ], [ %503, %500 ]
  %506 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %495, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 122, ptr noundef %505) #8
  %507 = load ptr, ptr %15, align 8, !tbaa !5
  %508 = getelementptr inbounds %struct.mlpLayer, ptr %507, i32 0, i32 17
  %509 = load ptr, ptr %508, align 8, !tbaa !36
  %510 = icmp ne ptr %509, null
  br i1 %510, label %511, label %512

511:                                              ; preds = %504
  br label %513

512:                                              ; preds = %504
  call void @__assert_fail(ptr noundef @.str.19, ptr noundef @.str.1, i32 noundef 122, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

513:                                              ; preds = %511
  br label %514

514:                                              ; preds = %513, %483
  %515 = load i32, ptr %9, align 4, !tbaa !9
  %516 = sext i32 %515 to i64
  %517 = mul i64 %516, 8
  %518 = call noalias ptr @malloc(i64 noundef %517) #11
  %519 = load ptr, ptr %15, align 8, !tbaa !5
  %520 = getelementptr inbounds %struct.mlpLayer, ptr %519, i32 0, i32 18
  store ptr %518, ptr %520, align 8, !tbaa !37
  %521 = load ptr, ptr %15, align 8, !tbaa !5
  %522 = getelementptr inbounds %struct.mlpLayer, ptr %521, i32 0, i32 18
  %523 = load ptr, ptr %522, align 8, !tbaa !37
  %524 = icmp ne ptr %523, null
  br i1 %524, label %545, label %525

525:                                              ; preds = %514
  %526 = load ptr, ptr @stderr, align 8, !tbaa !5
  %527 = call ptr @__errno_location() #9
  %528 = load i32, ptr %527, align 4, !tbaa !9
  %529 = icmp eq i32 %528, 0
  br i1 %529, label %530, label %531

530:                                              ; preds = %525
  br label %535

531:                                              ; preds = %525
  %532 = call ptr @__errno_location() #9
  %533 = load i32, ptr %532, align 4, !tbaa !9
  %534 = call ptr @strerror(i32 noundef %533) #8
  br label %535

535:                                              ; preds = %531, %530
  %536 = phi ptr [ @.str.2, %530 ], [ %534, %531 ]
  %537 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %526, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 125, ptr noundef %536) #8
  %538 = load ptr, ptr %15, align 8, !tbaa !5
  %539 = getelementptr inbounds %struct.mlpLayer, ptr %538, i32 0, i32 18
  %540 = load ptr, ptr %539, align 8, !tbaa !37
  %541 = icmp ne ptr %540, null
  br i1 %541, label %542, label %543

542:                                              ; preds = %535
  br label %544

543:                                              ; preds = %535
  call void @__assert_fail(ptr noundef @.str.20, ptr noundef @.str.1, i32 noundef 125, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

544:                                              ; preds = %542
  br label %545

545:                                              ; preds = %544, %514
  %546 = load i32, ptr %9, align 4, !tbaa !9
  %547 = sext i32 %546 to i64
  %548 = mul i64 %547, 8
  %549 = call noalias ptr @malloc(i64 noundef %548) #11
  %550 = load ptr, ptr %15, align 8, !tbaa !5
  %551 = getelementptr inbounds %struct.mlpLayer, ptr %550, i32 0, i32 21
  store ptr %549, ptr %551, align 8, !tbaa !38
  %552 = load ptr, ptr %15, align 8, !tbaa !5
  %553 = getelementptr inbounds %struct.mlpLayer, ptr %552, i32 0, i32 21
  %554 = load ptr, ptr %553, align 8, !tbaa !38
  %555 = icmp ne ptr %554, null
  br i1 %555, label %576, label %556

556:                                              ; preds = %545
  %557 = load ptr, ptr @stderr, align 8, !tbaa !5
  %558 = call ptr @__errno_location() #9
  %559 = load i32, ptr %558, align 4, !tbaa !9
  %560 = icmp eq i32 %559, 0
  br i1 %560, label %561, label %562

561:                                              ; preds = %556
  br label %566

562:                                              ; preds = %556
  %563 = call ptr @__errno_location() #9
  %564 = load i32, ptr %563, align 4, !tbaa !9
  %565 = call ptr @strerror(i32 noundef %564) #8
  br label %566

566:                                              ; preds = %562, %561
  %567 = phi ptr [ @.str.2, %561 ], [ %565, %562 ]
  %568 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %557, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 128, ptr noundef %567) #8
  %569 = load ptr, ptr %15, align 8, !tbaa !5
  %570 = getelementptr inbounds %struct.mlpLayer, ptr %569, i32 0, i32 21
  %571 = load ptr, ptr %570, align 8, !tbaa !38
  %572 = icmp ne ptr %571, null
  br i1 %572, label %573, label %574

573:                                              ; preds = %566
  br label %575

574:                                              ; preds = %566
  call void @__assert_fail(ptr noundef @.str.21, ptr noundef @.str.1, i32 noundef 128, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

575:                                              ; preds = %573
  br label %576

576:                                              ; preds = %575, %545
  %577 = load i32, ptr %9, align 4, !tbaa !9
  %578 = sext i32 %577 to i64
  %579 = mul i64 %578, 8
  %580 = call noalias ptr @malloc(i64 noundef %579) #11
  %581 = load ptr, ptr %15, align 8, !tbaa !5
  %582 = getelementptr inbounds %struct.mlpLayer, ptr %581, i32 0, i32 19
  store ptr %580, ptr %582, align 8, !tbaa !39
  %583 = load ptr, ptr %15, align 8, !tbaa !5
  %584 = getelementptr inbounds %struct.mlpLayer, ptr %583, i32 0, i32 19
  %585 = load ptr, ptr %584, align 8, !tbaa !39
  %586 = icmp ne ptr %585, null
  br i1 %586, label %607, label %587

587:                                              ; preds = %576
  %588 = load ptr, ptr @stderr, align 8, !tbaa !5
  %589 = call ptr @__errno_location() #9
  %590 = load i32, ptr %589, align 4, !tbaa !9
  %591 = icmp eq i32 %590, 0
  br i1 %591, label %592, label %593

592:                                              ; preds = %587
  br label %597

593:                                              ; preds = %587
  %594 = call ptr @__errno_location() #9
  %595 = load i32, ptr %594, align 4, !tbaa !9
  %596 = call ptr @strerror(i32 noundef %595) #8
  br label %597

597:                                              ; preds = %593, %592
  %598 = phi ptr [ @.str.2, %592 ], [ %596, %593 ]
  %599 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %588, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 131, ptr noundef %598) #8
  %600 = load ptr, ptr %15, align 8, !tbaa !5
  %601 = getelementptr inbounds %struct.mlpLayer, ptr %600, i32 0, i32 19
  %602 = load ptr, ptr %601, align 8, !tbaa !39
  %603 = icmp ne ptr %602, null
  br i1 %603, label %604, label %605

604:                                              ; preds = %597
  br label %606

605:                                              ; preds = %597
  call void @__assert_fail(ptr noundef @.str.22, ptr noundef @.str.1, i32 noundef 131, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

606:                                              ; preds = %604
  br label %607

607:                                              ; preds = %606, %576
  %608 = load i32, ptr %9, align 4, !tbaa !9
  %609 = sext i32 %608 to i64
  %610 = mul i64 %609, 8
  %611 = call noalias ptr @malloc(i64 noundef %610) #11
  %612 = load ptr, ptr %15, align 8, !tbaa !5
  %613 = getelementptr inbounds %struct.mlpLayer, ptr %612, i32 0, i32 20
  store ptr %611, ptr %613, align 8, !tbaa !40
  %614 = load ptr, ptr %15, align 8, !tbaa !5
  %615 = getelementptr inbounds %struct.mlpLayer, ptr %614, i32 0, i32 20
  %616 = load ptr, ptr %615, align 8, !tbaa !40
  %617 = icmp ne ptr %616, null
  br i1 %617, label %638, label %618

618:                                              ; preds = %607
  %619 = load ptr, ptr @stderr, align 8, !tbaa !5
  %620 = call ptr @__errno_location() #9
  %621 = load i32, ptr %620, align 4, !tbaa !9
  %622 = icmp eq i32 %621, 0
  br i1 %622, label %623, label %624

623:                                              ; preds = %618
  br label %628

624:                                              ; preds = %618
  %625 = call ptr @__errno_location() #9
  %626 = load i32, ptr %625, align 4, !tbaa !9
  %627 = call ptr @strerror(i32 noundef %626) #8
  br label %628

628:                                              ; preds = %624, %623
  %629 = phi ptr [ @.str.2, %623 ], [ %627, %624 ]
  %630 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %619, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 134, ptr noundef %629) #8
  %631 = load ptr, ptr %15, align 8, !tbaa !5
  %632 = getelementptr inbounds %struct.mlpLayer, ptr %631, i32 0, i32 20
  %633 = load ptr, ptr %632, align 8, !tbaa !40
  %634 = icmp ne ptr %633, null
  br i1 %634, label %635, label %636

635:                                              ; preds = %628
  br label %637

636:                                              ; preds = %628
  call void @__assert_fail(ptr noundef @.str.23, ptr noundef @.str.1, i32 noundef 134, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

637:                                              ; preds = %635
  br label %638

638:                                              ; preds = %637, %607
  %639 = load i32, ptr %9, align 4, !tbaa !9
  %640 = sext i32 %639 to i64
  %641 = mul i64 %640, 8
  %642 = call noalias ptr @malloc(i64 noundef %641) #11
  %643 = load ptr, ptr %15, align 8, !tbaa !5
  %644 = getelementptr inbounds %struct.mlpLayer, ptr %643, i32 0, i32 22
  store ptr %642, ptr %644, align 8, !tbaa !41
  %645 = load ptr, ptr %15, align 8, !tbaa !5
  %646 = getelementptr inbounds %struct.mlpLayer, ptr %645, i32 0, i32 22
  %647 = load ptr, ptr %646, align 8, !tbaa !41
  %648 = icmp ne ptr %647, null
  br i1 %648, label %669, label %649

649:                                              ; preds = %638
  %650 = load ptr, ptr @stderr, align 8, !tbaa !5
  %651 = call ptr @__errno_location() #9
  %652 = load i32, ptr %651, align 4, !tbaa !9
  %653 = icmp eq i32 %652, 0
  br i1 %653, label %654, label %655

654:                                              ; preds = %649
  br label %659

655:                                              ; preds = %649
  %656 = call ptr @__errno_location() #9
  %657 = load i32, ptr %656, align 4, !tbaa !9
  %658 = call ptr @strerror(i32 noundef %657) #8
  br label %659

659:                                              ; preds = %655, %654
  %660 = phi ptr [ @.str.2, %654 ], [ %658, %655 ]
  %661 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %650, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 137, ptr noundef %660) #8
  %662 = load ptr, ptr %15, align 8, !tbaa !5
  %663 = getelementptr inbounds %struct.mlpLayer, ptr %662, i32 0, i32 22
  %664 = load ptr, ptr %663, align 8, !tbaa !41
  %665 = icmp ne ptr %664, null
  br i1 %665, label %666, label %667

666:                                              ; preds = %659
  br label %668

667:                                              ; preds = %659
  call void @__assert_fail(ptr noundef @.str.24, ptr noundef @.str.1, i32 noundef 137, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

668:                                              ; preds = %666
  br label %669

669:                                              ; preds = %668, %638
  %670 = load i32, ptr %9, align 4, !tbaa !9
  %671 = sext i32 %670 to i64
  %672 = mul i64 %671, 8
  %673 = call noalias ptr @malloc(i64 noundef %672) #11
  %674 = load ptr, ptr %15, align 8, !tbaa !5
  %675 = getelementptr inbounds %struct.mlpLayer, ptr %674, i32 0, i32 23
  store ptr %673, ptr %675, align 8, !tbaa !42
  %676 = load ptr, ptr %15, align 8, !tbaa !5
  %677 = getelementptr inbounds %struct.mlpLayer, ptr %676, i32 0, i32 23
  %678 = load ptr, ptr %677, align 8, !tbaa !42
  %679 = icmp ne ptr %678, null
  br i1 %679, label %700, label %680

680:                                              ; preds = %669
  %681 = load ptr, ptr @stderr, align 8, !tbaa !5
  %682 = call ptr @__errno_location() #9
  %683 = load i32, ptr %682, align 4, !tbaa !9
  %684 = icmp eq i32 %683, 0
  br i1 %684, label %685, label %686

685:                                              ; preds = %680
  br label %690

686:                                              ; preds = %680
  %687 = call ptr @__errno_location() #9
  %688 = load i32, ptr %687, align 4, !tbaa !9
  %689 = call ptr @strerror(i32 noundef %688) #8
  br label %690

690:                                              ; preds = %686, %685
  %691 = phi ptr [ @.str.2, %685 ], [ %689, %686 ]
  %692 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %681, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 140, ptr noundef %691) #8
  %693 = load ptr, ptr %15, align 8, !tbaa !5
  %694 = getelementptr inbounds %struct.mlpLayer, ptr %693, i32 0, i32 23
  %695 = load ptr, ptr %694, align 8, !tbaa !42
  %696 = icmp ne ptr %695, null
  br i1 %696, label %697, label %698

697:                                              ; preds = %690
  br label %699

698:                                              ; preds = %690
  call void @__assert_fail(ptr noundef @.str.25, ptr noundef @.str.1, i32 noundef 140, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

699:                                              ; preds = %697
  br label %700

700:                                              ; preds = %699, %669
  %701 = load i32, ptr %9, align 4, !tbaa !9
  %702 = sext i32 %701 to i64
  %703 = mul i64 %702, 8
  %704 = call noalias ptr @malloc(i64 noundef %703) #11
  %705 = load ptr, ptr %15, align 8, !tbaa !5
  %706 = getelementptr inbounds %struct.mlpLayer, ptr %705, i32 0, i32 24
  store ptr %704, ptr %706, align 8, !tbaa !43
  %707 = load ptr, ptr %15, align 8, !tbaa !5
  %708 = getelementptr inbounds %struct.mlpLayer, ptr %707, i32 0, i32 24
  %709 = load ptr, ptr %708, align 8, !tbaa !43
  %710 = icmp ne ptr %709, null
  br i1 %710, label %731, label %711

711:                                              ; preds = %700
  %712 = load ptr, ptr @stderr, align 8, !tbaa !5
  %713 = call ptr @__errno_location() #9
  %714 = load i32, ptr %713, align 4, !tbaa !9
  %715 = icmp eq i32 %714, 0
  br i1 %715, label %716, label %717

716:                                              ; preds = %711
  br label %721

717:                                              ; preds = %711
  %718 = call ptr @__errno_location() #9
  %719 = load i32, ptr %718, align 4, !tbaa !9
  %720 = call ptr @strerror(i32 noundef %719) #8
  br label %721

721:                                              ; preds = %717, %716
  %722 = phi ptr [ @.str.2, %716 ], [ %720, %717 ]
  %723 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %712, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 143, ptr noundef %722) #8
  %724 = load ptr, ptr %15, align 8, !tbaa !5
  %725 = getelementptr inbounds %struct.mlpLayer, ptr %724, i32 0, i32 24
  %726 = load ptr, ptr %725, align 8, !tbaa !43
  %727 = icmp ne ptr %726, null
  br i1 %727, label %728, label %729

728:                                              ; preds = %721
  br label %730

729:                                              ; preds = %721
  call void @__assert_fail(ptr noundef @.str.26, ptr noundef @.str.1, i32 noundef 143, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

730:                                              ; preds = %728
  br label %731

731:                                              ; preds = %730, %700
  call void @llvm.lifetime.start.p0(i64 4, ptr %18) #8
  store i32 0, ptr %18, align 4, !tbaa !9
  br label %732

732:                                              ; preds = %935, %731
  %733 = load i32, ptr %18, align 4, !tbaa !9
  %734 = load i32, ptr %9, align 4, !tbaa !9
  %735 = icmp slt i32 %733, %734
  br i1 %735, label %737, label %736

736:                                              ; preds = %732
  store i32 3, ptr %19, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %18) #8
  br label %938

737:                                              ; preds = %732
  %738 = load i32, ptr %16, align 4, !tbaa !9
  %739 = load ptr, ptr %15, align 8, !tbaa !5
  %740 = getelementptr inbounds %struct.mlpLayer, ptr %739, i32 0, i32 11
  %741 = load ptr, ptr %740, align 8, !tbaa !30
  %742 = load i32, ptr %18, align 4, !tbaa !9
  %743 = sext i32 %742 to i64
  %744 = getelementptr inbounds i32, ptr %741, i64 %743
  store i32 %738, ptr %744, align 4, !tbaa !9
  %745 = load ptr, ptr %15, align 8, !tbaa !5
  %746 = getelementptr inbounds %struct.mlpLayer, ptr %745, i32 0, i32 14
  %747 = load ptr, ptr %746, align 8, !tbaa !33
  %748 = load i32, ptr %18, align 4, !tbaa !9
  %749 = sext i32 %748 to i64
  %750 = getelementptr inbounds double, ptr %747, i64 %749
  store double 0.000000e+00, ptr %750, align 8, !tbaa !44
  %751 = load ptr, ptr %15, align 8, !tbaa !5
  %752 = getelementptr inbounds %struct.mlpLayer, ptr %751, i32 0, i32 15
  %753 = load ptr, ptr %752, align 8, !tbaa !34
  %754 = load i32, ptr %18, align 4, !tbaa !9
  %755 = sext i32 %754 to i64
  %756 = getelementptr inbounds double, ptr %753, i64 %755
  store double 0.000000e+00, ptr %756, align 8, !tbaa !44
  %757 = load ptr, ptr %15, align 8, !tbaa !5
  %758 = getelementptr inbounds %struct.mlpLayer, ptr %757, i32 0, i32 16
  %759 = load ptr, ptr %758, align 8, !tbaa !35
  %760 = load i32, ptr %18, align 4, !tbaa !9
  %761 = sext i32 %760 to i64
  %762 = getelementptr inbounds double, ptr %759, i64 %761
  store double 0.000000e+00, ptr %762, align 8, !tbaa !44
  %763 = load ptr, ptr %15, align 8, !tbaa !5
  %764 = getelementptr inbounds %struct.mlpLayer, ptr %763, i32 0, i32 17
  %765 = load ptr, ptr %764, align 8, !tbaa !36
  %766 = load i32, ptr %18, align 4, !tbaa !9
  %767 = sext i32 %766 to i64
  %768 = getelementptr inbounds double, ptr %765, i64 %767
  store double 0.000000e+00, ptr %768, align 8, !tbaa !44
  %769 = load ptr, ptr %15, align 8, !tbaa !5
  %770 = getelementptr inbounds %struct.mlpLayer, ptr %769, i32 0, i32 18
  %771 = load ptr, ptr %770, align 8, !tbaa !37
  %772 = load i32, ptr %18, align 4, !tbaa !9
  %773 = sext i32 %772 to i64
  %774 = getelementptr inbounds double, ptr %771, i64 %773
  store double 0.000000e+00, ptr %774, align 8, !tbaa !44
  %775 = call double (...) @annRandomizer()
  %776 = load ptr, ptr %15, align 8, !tbaa !5
  %777 = getelementptr inbounds %struct.mlpLayer, ptr %776, i32 0, i32 19
  %778 = load ptr, ptr %777, align 8, !tbaa !39
  %779 = load i32, ptr %18, align 4, !tbaa !9
  %780 = sext i32 %779 to i64
  %781 = getelementptr inbounds double, ptr %778, i64 %780
  store double %775, ptr %781, align 8, !tbaa !44
  %782 = load ptr, ptr %15, align 8, !tbaa !5
  %783 = getelementptr inbounds %struct.mlpLayer, ptr %782, i32 0, i32 20
  %784 = load ptr, ptr %783, align 8, !tbaa !40
  %785 = load i32, ptr %18, align 4, !tbaa !9
  %786 = sext i32 %785 to i64
  %787 = getelementptr inbounds double, ptr %784, i64 %786
  store double 0.000000e+00, ptr %787, align 8, !tbaa !44
  %788 = load i32, ptr %12, align 4, !tbaa !9
  %789 = call ptr @activationNew(i32 noundef %788)
  %790 = load ptr, ptr %15, align 8, !tbaa !5
  %791 = getelementptr inbounds %struct.mlpLayer, ptr %790, i32 0, i32 22
  %792 = load ptr, ptr %791, align 8, !tbaa !41
  %793 = load i32, ptr %18, align 4, !tbaa !9
  %794 = sext i32 %793 to i64
  %795 = getelementptr inbounds ptr, ptr %792, i64 %794
  store ptr %789, ptr %795, align 8, !tbaa !5
  %796 = load i32, ptr %13, align 4, !tbaa !9
  %797 = call ptr @lossNew(i32 noundef %796)
  %798 = load ptr, ptr %15, align 8, !tbaa !5
  %799 = getelementptr inbounds %struct.mlpLayer, ptr %798, i32 0, i32 23
  %800 = load ptr, ptr %799, align 8, !tbaa !42
  %801 = load i32, ptr %18, align 4, !tbaa !9
  %802 = sext i32 %801 to i64
  %803 = getelementptr inbounds ptr, ptr %800, i64 %802
  store ptr %797, ptr %803, align 8, !tbaa !5
  %804 = load i32, ptr %14, align 4, !tbaa !9
  %805 = call ptr @optimizationNew(i32 noundef %804)
  %806 = load ptr, ptr %15, align 8, !tbaa !5
  %807 = getelementptr inbounds %struct.mlpLayer, ptr %806, i32 0, i32 24
  %808 = load ptr, ptr %807, align 8, !tbaa !43
  %809 = load i32, ptr %18, align 4, !tbaa !9
  %810 = sext i32 %809 to i64
  %811 = getelementptr inbounds ptr, ptr %808, i64 %810
  store ptr %805, ptr %811, align 8, !tbaa !5
  %812 = load i32, ptr %16, align 4, !tbaa !9
  %813 = sext i32 %812 to i64
  %814 = mul i64 %813, 8
  %815 = call noalias ptr @malloc(i64 noundef %814) #11
  %816 = load ptr, ptr %15, align 8, !tbaa !5
  %817 = getelementptr inbounds %struct.mlpLayer, ptr %816, i32 0, i32 12
  %818 = load ptr, ptr %817, align 8, !tbaa !31
  %819 = load i32, ptr %18, align 4, !tbaa !9
  %820 = sext i32 %819 to i64
  %821 = getelementptr inbounds ptr, ptr %818, i64 %820
  store ptr %815, ptr %821, align 8, !tbaa !5
  %822 = load ptr, ptr %15, align 8, !tbaa !5
  %823 = getelementptr inbounds %struct.mlpLayer, ptr %822, i32 0, i32 12
  %824 = load ptr, ptr %823, align 8, !tbaa !31
  %825 = load i32, ptr %18, align 4, !tbaa !9
  %826 = sext i32 %825 to i64
  %827 = getelementptr inbounds ptr, ptr %824, i64 %826
  %828 = load ptr, ptr %827, align 8, !tbaa !5
  %829 = icmp ne ptr %828, null
  br i1 %829, label %854, label %830

830:                                              ; preds = %737
  %831 = load ptr, ptr @stderr, align 8, !tbaa !5
  %832 = call ptr @__errno_location() #9
  %833 = load i32, ptr %832, align 4, !tbaa !9
  %834 = icmp eq i32 %833, 0
  br i1 %834, label %835, label %836

835:                                              ; preds = %830
  br label %840

836:                                              ; preds = %830
  %837 = call ptr @__errno_location() #9
  %838 = load i32, ptr %837, align 4, !tbaa !9
  %839 = call ptr @strerror(i32 noundef %838) #8
  br label %840

840:                                              ; preds = %836, %835
  %841 = phi ptr [ @.str.2, %835 ], [ %839, %836 ]
  %842 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %831, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 163, ptr noundef %841) #8
  %843 = load ptr, ptr %15, align 8, !tbaa !5
  %844 = getelementptr inbounds %struct.mlpLayer, ptr %843, i32 0, i32 12
  %845 = load ptr, ptr %844, align 8, !tbaa !31
  %846 = load i32, ptr %18, align 4, !tbaa !9
  %847 = sext i32 %846 to i64
  %848 = getelementptr inbounds ptr, ptr %845, i64 %847
  %849 = load ptr, ptr %848, align 8, !tbaa !5
  %850 = icmp ne ptr %849, null
  br i1 %850, label %851, label %852

851:                                              ; preds = %840
  br label %853

852:                                              ; preds = %840
  call void @__assert_fail(ptr noundef @.str.27, ptr noundef @.str.1, i32 noundef 163, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

853:                                              ; preds = %851
  br label %854

854:                                              ; preds = %853, %737
  %855 = load i32, ptr %16, align 4, !tbaa !9
  %856 = sext i32 %855 to i64
  %857 = mul i64 %856, 8
  %858 = call noalias ptr @malloc(i64 noundef %857) #11
  %859 = load ptr, ptr %15, align 8, !tbaa !5
  %860 = getelementptr inbounds %struct.mlpLayer, ptr %859, i32 0, i32 13
  %861 = load ptr, ptr %860, align 8, !tbaa !32
  %862 = load i32, ptr %18, align 4, !tbaa !9
  %863 = sext i32 %862 to i64
  %864 = getelementptr inbounds ptr, ptr %861, i64 %863
  store ptr %858, ptr %864, align 8, !tbaa !5
  %865 = load ptr, ptr %15, align 8, !tbaa !5
  %866 = getelementptr inbounds %struct.mlpLayer, ptr %865, i32 0, i32 13
  %867 = load ptr, ptr %866, align 8, !tbaa !32
  %868 = load i32, ptr %18, align 4, !tbaa !9
  %869 = sext i32 %868 to i64
  %870 = getelementptr inbounds ptr, ptr %867, i64 %869
  %871 = load ptr, ptr %870, align 8, !tbaa !5
  %872 = icmp ne ptr %871, null
  br i1 %872, label %897, label %873

873:                                              ; preds = %854
  %874 = load ptr, ptr @stderr, align 8, !tbaa !5
  %875 = call ptr @__errno_location() #9
  %876 = load i32, ptr %875, align 4, !tbaa !9
  %877 = icmp eq i32 %876, 0
  br i1 %877, label %878, label %879

878:                                              ; preds = %873
  br label %883

879:                                              ; preds = %873
  %880 = call ptr @__errno_location() #9
  %881 = load i32, ptr %880, align 4, !tbaa !9
  %882 = call ptr @strerror(i32 noundef %881) #8
  br label %883

883:                                              ; preds = %879, %878
  %884 = phi ptr [ @.str.2, %878 ], [ %882, %879 ]
  %885 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %874, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 166, ptr noundef %884) #8
  %886 = load ptr, ptr %15, align 8, !tbaa !5
  %887 = getelementptr inbounds %struct.mlpLayer, ptr %886, i32 0, i32 13
  %888 = load ptr, ptr %887, align 8, !tbaa !32
  %889 = load i32, ptr %18, align 4, !tbaa !9
  %890 = sext i32 %889 to i64
  %891 = getelementptr inbounds ptr, ptr %888, i64 %890
  %892 = load ptr, ptr %891, align 8, !tbaa !5
  %893 = icmp ne ptr %892, null
  br i1 %893, label %894, label %895

894:                                              ; preds = %883
  br label %896

895:                                              ; preds = %883
  call void @__assert_fail(ptr noundef @.str.28, ptr noundef @.str.1, i32 noundef 166, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

896:                                              ; preds = %894
  br label %897

897:                                              ; preds = %896, %854
  call void @llvm.lifetime.start.p0(i64 4, ptr %20) #8
  store i32 0, ptr %20, align 4, !tbaa !9
  br label %898

898:                                              ; preds = %931, %897
  %899 = load i32, ptr %20, align 4, !tbaa !9
  %900 = load ptr, ptr %15, align 8, !tbaa !5
  %901 = getelementptr inbounds %struct.mlpLayer, ptr %900, i32 0, i32 11
  %902 = load ptr, ptr %901, align 8, !tbaa !30
  %903 = load i32, ptr %18, align 4, !tbaa !9
  %904 = sext i32 %903 to i64
  %905 = getelementptr inbounds i32, ptr %902, i64 %904
  %906 = load i32, ptr %905, align 4, !tbaa !9
  %907 = icmp slt i32 %899, %906
  br i1 %907, label %909, label %908

908:                                              ; preds = %898
  store i32 6, ptr %19, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %20) #8
  br label %934

909:                                              ; preds = %898
  %910 = load ptr, ptr %15, align 8, !tbaa !5
  %911 = getelementptr inbounds %struct.mlpLayer, ptr %910, i32 0, i32 12
  %912 = load ptr, ptr %911, align 8, !tbaa !31
  %913 = load i32, ptr %18, align 4, !tbaa !9
  %914 = sext i32 %913 to i64
  %915 = getelementptr inbounds ptr, ptr %912, i64 %914
  %916 = load ptr, ptr %915, align 8, !tbaa !5
  %917 = load i32, ptr %20, align 4, !tbaa !9
  %918 = sext i32 %917 to i64
  %919 = getelementptr inbounds double, ptr %916, i64 %918
  store double 0.000000e+00, ptr %919, align 8, !tbaa !44
  %920 = call double (...) @annRandomizer()
  %921 = load ptr, ptr %15, align 8, !tbaa !5
  %922 = getelementptr inbounds %struct.mlpLayer, ptr %921, i32 0, i32 13
  %923 = load ptr, ptr %922, align 8, !tbaa !32
  %924 = load i32, ptr %18, align 4, !tbaa !9
  %925 = sext i32 %924 to i64
  %926 = getelementptr inbounds ptr, ptr %923, i64 %925
  %927 = load ptr, ptr %926, align 8, !tbaa !5
  %928 = load i32, ptr %20, align 4, !tbaa !9
  %929 = sext i32 %928 to i64
  %930 = getelementptr inbounds double, ptr %927, i64 %929
  store double %920, ptr %930, align 8, !tbaa !44
  br label %931

931:                                              ; preds = %909
  %932 = load i32, ptr %20, align 4, !tbaa !9
  %933 = add nsw i32 %932, 1
  store i32 %933, ptr %20, align 4, !tbaa !9
  br label %898, !llvm.loop !45

934:                                              ; preds = %908
  br label %935

935:                                              ; preds = %934
  %936 = load i32, ptr %18, align 4, !tbaa !9
  %937 = add nsw i32 %936, 1
  store i32 %937, ptr %18, align 4, !tbaa !9
  br label %732, !llvm.loop !47

938:                                              ; preds = %736
  %939 = call noalias ptr @malloc(i64 noundef 176) #11
  %940 = load ptr, ptr %8, align 8, !tbaa !5
  %941 = getelementptr inbounds %struct.mlp, ptr %940, i32 0, i32 7
  %942 = load ptr, ptr %941, align 8, !tbaa !14
  %943 = load i32, ptr %17, align 4, !tbaa !9
  %944 = sext i32 %943 to i64
  %945 = getelementptr inbounds ptr, ptr %942, i64 %944
  store ptr %939, ptr %945, align 8, !tbaa !5
  %946 = load ptr, ptr %8, align 8, !tbaa !5
  %947 = getelementptr inbounds %struct.mlp, ptr %946, i32 0, i32 7
  %948 = load ptr, ptr %947, align 8, !tbaa !14
  %949 = load i32, ptr %17, align 4, !tbaa !9
  %950 = sext i32 %949 to i64
  %951 = getelementptr inbounds ptr, ptr %948, i64 %950
  %952 = load ptr, ptr %951, align 8, !tbaa !5
  %953 = icmp ne ptr %952, null
  br i1 %953, label %978, label %954

954:                                              ; preds = %938
  %955 = load ptr, ptr @stderr, align 8, !tbaa !5
  %956 = call ptr @__errno_location() #9
  %957 = load i32, ptr %956, align 4, !tbaa !9
  %958 = icmp eq i32 %957, 0
  br i1 %958, label %959, label %960

959:                                              ; preds = %954
  br label %964

960:                                              ; preds = %954
  %961 = call ptr @__errno_location() #9
  %962 = load i32, ptr %961, align 4, !tbaa !9
  %963 = call ptr @strerror(i32 noundef %962) #8
  br label %964

964:                                              ; preds = %960, %959
  %965 = phi ptr [ @.str.2, %959 ], [ %963, %960 ]
  %966 = call i32 (ptr, ptr, ...) @fprintf(ptr noundef %955, ptr noundef @.str.9, ptr noundef @.str.1, i32 noundef 174, ptr noundef %965) #8
  %967 = load ptr, ptr %8, align 8, !tbaa !5
  %968 = getelementptr inbounds %struct.mlp, ptr %967, i32 0, i32 7
  %969 = load ptr, ptr %968, align 8, !tbaa !14
  %970 = load i32, ptr %17, align 4, !tbaa !9
  %971 = sext i32 %970 to i64
  %972 = getelementptr inbounds ptr, ptr %969, i64 %971
  %973 = load ptr, ptr %972, align 8, !tbaa !5
  %974 = icmp ne ptr %973, null
  br i1 %974, label %975, label %976

975:                                              ; preds = %964
  br label %977

976:                                              ; preds = %964
  call void @__assert_fail(ptr noundef @.str.29, ptr noundef @.str.1, i32 noundef 174, ptr noundef @__PRETTY_FUNCTION__.mlpLayerAppend) #10
  unreachable

977:                                              ; preds = %975
  br label %978

978:                                              ; preds = %977, %938
  %979 = load ptr, ptr %15, align 8, !tbaa !5
  %980 = load ptr, ptr %8, align 8, !tbaa !5
  %981 = getelementptr inbounds %struct.mlp, ptr %980, i32 0, i32 7
  %982 = load ptr, ptr %981, align 8, !tbaa !14
  %983 = load i32, ptr %17, align 4, !tbaa !9
  %984 = sext i32 %983 to i64
  %985 = getelementptr inbounds ptr, ptr %982, i64 %984
  store ptr %979, ptr %985, align 8, !tbaa !5
  %986 = load ptr, ptr %15, align 8, !tbaa !5
  store i32 1, ptr %19, align 4
  call void @llvm.lifetime.end.p0(i64 4, ptr %17) #8
  call void @llvm.lifetime.end.p0(i64 4, ptr %16) #8
  call void @llvm.lifetime.end.p0(i64 8, ptr %15) #8
  ret ptr %986
}

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

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

; Function Attrs: nounwind willreturn memory(none)
declare ptr @__errno_location() #4

; Function Attrs: nounwind
declare ptr @strerror(i32 noundef) #3

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) #5

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

declare double @annRandomizer(...) #7

declare ptr @activationNew(i32 noundef) #7

declare ptr @lossNew(i32 noundef) #7

declare ptr @optimizationNew(i32 noundef) #7

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

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

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

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


; 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"

@stderr = external local_unnamed_addr global ptr, align 8
@.str = external hidden unnamed_addr constant [83 x i8], align 1
@.str.1 = external hidden unnamed_addr constant [56 x i8], align 1
@.str.2 = external hidden unnamed_addr constant [5 x i8], align 1
@.str.3 = external hidden unnamed_addr constant [14 x i8], align 1
@__PRETTY_FUNCTION__.mlpLayerAppend = external hidden unnamed_addr constant [126 x i8], align 1
@.str.4 = external hidden unnamed_addr constant [70 x i8], align 1
@.str.5 = external hidden unnamed_addr constant [57 x i8], align 1
@.str.6 = external hidden unnamed_addr constant [96 x i8], align 1
@.str.7 = external hidden unnamed_addr constant [58 x i8], align 1
@.str.8 = external hidden unnamed_addr constant [73 x i8], align 1
@.str.9 = external hidden unnamed_addr constant [53 x i8], align 1
@.str.10 = external hidden unnamed_addr constant [28 x i8], align 1
@.str.11 = external hidden unnamed_addr constant [70 x i8], align 1
@.str.12 = external hidden unnamed_addr constant [24 x i8], align 1
@.str.13 = external hidden unnamed_addr constant [45 x i8], align 1
@.str.14 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.15 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.16 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.17 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.18 = external hidden unnamed_addr constant [41 x i8], align 1
@.str.19 = external hidden unnamed_addr constant [54 x i8], align 1
@.str.20 = external hidden unnamed_addr constant [62 x i8], align 1
@.str.21 = external hidden unnamed_addr constant [55 x i8], align 1
@.str.22 = external hidden unnamed_addr constant [34 x i8], align 1
@.str.23 = external hidden unnamed_addr constant [47 x i8], align 1
@.str.24 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.25 = external hidden unnamed_addr constant [36 x i8], align 1
@.str.26 = external hidden unnamed_addr constant [35 x i8], align 1
@.str.27 = external hidden unnamed_addr constant [39 x i8], align 1
@.str.28 = external hidden unnamed_addr constant [40 x i8], align 1
@.str.29 = external hidden unnamed_addr constant [48 x i8], align 1

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

; Function Attrs: nounwind uwtable
define dso_local noundef ptr @mlpLayerAppend(ptr nocapture noundef %0, i32 noundef %1, i32 noundef %2, i32 noundef %3, i32 noundef %4, i32 noundef %5, i32 noundef %6) local_unnamed_addr #1 {
  %8 = getelementptr inbounds i8, ptr %0, i64 4
  %9 = load i32, ptr %8, align 4, !tbaa !5
  %10 = icmp sgt i32 %1, 0
  br i1 %10, label %21, label %11

11:                                               ; preds = %7
  %12 = load ptr, ptr @stderr, align 8, !tbaa !12
  %13 = tail call ptr @__errno_location() #9
  %14 = load i32, ptr %13, align 4, !tbaa !13
  %15 = icmp eq i32 %14, 0
  br i1 %15, label %18, label %16

16:                                               ; preds = %11
  %17 = tail call ptr @strerror(i32 noundef %14) #10
  br label %18

18:                                               ; preds = %11, %16
  %19 = phi ptr [ %17, %16 ], [ @.str.2, %11 ]
  %20 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %12, ptr noundef nonnull @.str, ptr noundef nonnull @.str.1, i32 noundef 47, ptr noundef %19, i32 noundef %9) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.3, ptr noundef nonnull @.str.1, i32 noundef 47, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

21:                                               ; preds = %7
  %22 = icmp sgt i32 %9, 0
  br i1 %22, label %23, label %32

23:                                               ; preds = %21
  %24 = getelementptr inbounds i8, ptr %0, i64 40
  %25 = load ptr, ptr %24, align 8, !tbaa !14
  %26 = zext nneg i32 %9 to i64
  %27 = getelementptr ptr, ptr %25, i64 %26
  %28 = getelementptr i8, ptr %27, i64 -8
  %29 = load ptr, ptr %28, align 8, !tbaa !12
  %30 = getelementptr inbounds i8, ptr %29, i64 4
  %31 = load i32, ptr %30, align 4, !tbaa !15
  br label %32

32:                                               ; preds = %21, %23
  %.0174 = phi i32 [ %31, %23 ], [ 1, %21 ]
  switch i32 %2, label %thread-pre-split [
    i32 0, label %33
    i32 1, label %54
    i32 2, label %84
  ]

33:                                               ; preds = %32
  %34 = getelementptr inbounds i8, ptr %0, i64 8
  %35 = load i32, ptr %34, align 8, !tbaa !17
  %36 = icmp eq i32 %35, 0
  %37 = icmp eq i32 %9, 0
  %or.cond = select i1 %36, i1 %37, i1 false
  br i1 %or.cond, label %thread-pre-split.thread, label %38

38:                                               ; preds = %33
  %39 = load ptr, ptr @stderr, align 8, !tbaa !12
  %40 = tail call ptr @__errno_location() #9
  %41 = load i32, ptr %40, align 4, !tbaa !13
  %42 = icmp eq i32 %41, 0
  br i1 %42, label %45, label %43

43:                                               ; preds = %38
  %44 = tail call ptr @strerror(i32 noundef %41) #10
  br label %45

45:                                               ; preds = %38, %43
  %46 = phi ptr [ %44, %43 ], [ @.str.2, %38 ]
  %47 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %39, ptr noundef nonnull @.str.4, ptr noundef nonnull @.str.1, i32 noundef 58, ptr noundef %46) #11
  %48 = load i32, ptr %34, align 8, !tbaa !17
  %49 = icmp eq i32 %48, 0
  br i1 %49, label %50, label %53

50:                                               ; preds = %45
  %51 = load i32, ptr %8, align 4, !tbaa !5
  %52 = icmp eq i32 %51, 0
  br i1 %52, label %thread-pre-split.thread, label %53

53:                                               ; preds = %50, %45
  tail call void @__assert_fail(ptr noundef nonnull @.str.5, ptr noundef nonnull @.str.1, i32 noundef 58, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

thread-pre-split.thread:                          ; preds = %50, %33
  store i32 1, ptr %34, align 8, !tbaa !17
  store i32 1, ptr %8, align 4, !tbaa !5
  br label %115

54:                                               ; preds = %32
  %55 = getelementptr inbounds i8, ptr %0, i64 8
  %56 = load i32, ptr %55, align 8, !tbaa !17
  %57 = icmp eq i32 %56, 1
  br i1 %57, label %58, label %62

58:                                               ; preds = %54
  %59 = getelementptr inbounds i8, ptr %0, i64 16
  %60 = load i32, ptr %59, align 8, !tbaa !18
  %61 = icmp eq i32 %60, 0
  br i1 %61, label %79, label %62

62:                                               ; preds = %58, %54
  %63 = load ptr, ptr @stderr, align 8, !tbaa !12
  %64 = tail call ptr @__errno_location() #9
  %65 = load i32, ptr %64, align 4, !tbaa !13
  %66 = icmp eq i32 %65, 0
  br i1 %66, label %69, label %67

67:                                               ; preds = %62
  %68 = tail call ptr @strerror(i32 noundef %65) #10
  br label %69

69:                                               ; preds = %62, %67
  %70 = phi ptr [ %68, %67 ], [ @.str.2, %62 ]
  %71 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %63, ptr noundef nonnull @.str.6, ptr noundef nonnull @.str.1, i32 noundef 64, ptr noundef %70) #11
  %72 = load i32, ptr %55, align 8, !tbaa !17
  %73 = icmp eq i32 %72, 1
  br i1 %73, label %74, label %78

74:                                               ; preds = %69
  %75 = getelementptr inbounds i8, ptr %0, i64 16
  %76 = load i32, ptr %75, align 8, !tbaa !18
  %77 = icmp eq i32 %76, 0
  br i1 %77, label %._crit_edge246, label %78

._crit_edge246:                                   ; preds = %74
  %.pre247 = load i32, ptr %8, align 4, !tbaa !5
  br label %79

78:                                               ; preds = %74, %69
  tail call void @__assert_fail(ptr noundef nonnull @.str.7, ptr noundef nonnull @.str.1, i32 noundef 64, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

79:                                               ; preds = %._crit_edge246, %58
  %80 = phi i32 [ %.pre247, %._crit_edge246 ], [ %9, %58 ]
  %81 = getelementptr inbounds i8, ptr %0, i64 12
  %82 = load i32, ptr %81, align 4, !tbaa !19
  %83 = add nsw i32 %82, 1
  store i32 %83, ptr %81, align 4, !tbaa !19
  br label %thread-pre-split.sink.split

84:                                               ; preds = %32
  %85 = getelementptr inbounds i8, ptr %0, i64 8
  %86 = load i32, ptr %85, align 8, !tbaa !17
  %87 = icmp eq i32 %86, 1
  br i1 %87, label %88, label %92

88:                                               ; preds = %84
  %89 = getelementptr inbounds i8, ptr %0, i64 16
  %90 = load i32, ptr %89, align 8, !tbaa !18
  %91 = icmp eq i32 %90, 0
  br i1 %91, label %109, label %92

92:                                               ; preds = %88, %84
  %93 = load ptr, ptr @stderr, align 8, !tbaa !12
  %94 = tail call ptr @__errno_location() #9
  %95 = load i32, ptr %94, align 4, !tbaa !13
  %96 = icmp eq i32 %95, 0
  br i1 %96, label %99, label %97

97:                                               ; preds = %92
  %98 = tail call ptr @strerror(i32 noundef %95) #10
  br label %99

99:                                               ; preds = %92, %97
  %100 = phi ptr [ %98, %97 ], [ @.str.2, %92 ]
  %101 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %93, ptr noundef nonnull @.str.8, ptr noundef nonnull @.str.1, i32 noundef 70, ptr noundef %100) #11
  %102 = load i32, ptr %85, align 8, !tbaa !17
  %103 = icmp eq i32 %102, 1
  br i1 %103, label %104, label %108

104:                                              ; preds = %99
  %105 = getelementptr inbounds i8, ptr %0, i64 16
  %106 = load i32, ptr %105, align 8, !tbaa !18
  %107 = icmp eq i32 %106, 0
  br i1 %107, label %._crit_edge245, label %108

._crit_edge245:                                   ; preds = %104
  %.pre = load i32, ptr %8, align 4, !tbaa !5
  br label %109

108:                                              ; preds = %104, %99
  tail call void @__assert_fail(ptr noundef nonnull @.str.7, ptr noundef nonnull @.str.1, i32 noundef 70, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

109:                                              ; preds = %._crit_edge245, %88
  %110 = phi i32 [ %.pre, %._crit_edge245 ], [ %9, %88 ]
  %111 = getelementptr inbounds i8, ptr %0, i64 16
  store i32 1, ptr %111, align 8, !tbaa !18
  br label %thread-pre-split.sink.split

thread-pre-split.sink.split:                      ; preds = %79, %109
  %.sink262 = phi i32 [ %110, %109 ], [ %80, %79 ]
  %112 = add nsw i32 %.sink262, 1
  store i32 %112, ptr %8, align 4, !tbaa !5
  br label %thread-pre-split

thread-pre-split:                                 ; preds = %thread-pre-split.sink.split, %32
  %113 = phi i32 [ %9, %32 ], [ %112, %thread-pre-split.sink.split ]
  %114 = icmp eq i32 %113, 1
  br i1 %114, label %115, label %118

115:                                              ; preds = %thread-pre-split.thread, %thread-pre-split
  %116 = tail call noalias dereferenceable_or_null(8) ptr @malloc(i64 noundef 8) #13
  %117 = getelementptr inbounds i8, ptr %0, i64 40
  store ptr %116, ptr %117, align 8, !tbaa !14
  br label %124

118:                                              ; preds = %thread-pre-split
  %119 = getelementptr inbounds i8, ptr %0, i64 40
  %120 = load ptr, ptr %119, align 8, !tbaa !14
  %121 = sext i32 %113 to i64
  %122 = shl nsw i64 %121, 3
  %123 = tail call ptr @realloc(ptr noundef %120, i64 noundef %122) #14
  store ptr %123, ptr %119, align 8, !tbaa !14
  br label %124

124:                                              ; preds = %118, %115
  %125 = phi ptr [ %123, %118 ], [ %116, %115 ]
  %126 = getelementptr inbounds i8, ptr %0, i64 40
  %.not = icmp eq ptr %125, null
  br i1 %.not, label %127, label %139

127:                                              ; preds = %124
  %128 = load ptr, ptr @stderr, align 8, !tbaa !12
  %129 = tail call ptr @__errno_location() #9
  %130 = load i32, ptr %129, align 4, !tbaa !13
  %131 = icmp eq i32 %130, 0
  br i1 %131, label %134, label %132

132:                                              ; preds = %127
  %133 = tail call ptr @strerror(i32 noundef %130) #10
  br label %134

134:                                              ; preds = %127, %132
  %135 = phi ptr [ %133, %132 ], [ @.str.2, %127 ]
  %136 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %128, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 83, ptr noundef %135) #11
  %137 = load ptr, ptr %126, align 8, !tbaa !14
  %.not200 = icmp eq ptr %137, null
  br i1 %.not200, label %138, label %139

138:                                              ; preds = %134
  tail call void @__assert_fail(ptr noundef nonnull @.str.10, ptr noundef nonnull @.str.1, i32 noundef 83, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

139:                                              ; preds = %134, %124
  %140 = tail call noalias dereferenceable_or_null(176) ptr @malloc(i64 noundef 176) #13
  %.not201 = icmp eq ptr %140, null
  br i1 %.not201, label %141, label %151

141:                                              ; preds = %139
  %142 = load ptr, ptr @stderr, align 8, !tbaa !12
  %143 = tail call ptr @__errno_location() #9
  %144 = load i32, ptr %143, align 4, !tbaa !13
  %145 = icmp eq i32 %144, 0
  br i1 %145, label %148, label %146

146:                                              ; preds = %141
  %147 = tail call ptr @strerror(i32 noundef %144) #10
  br label %148

148:                                              ; preds = %141, %146
  %149 = phi ptr [ %147, %146 ], [ @.str.2, %141 ]
  %150 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %142, ptr noundef nonnull @.str.11, ptr noundef nonnull @.str.1, i32 noundef 86, ptr noundef %149, i32 noundef %9) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.12, ptr noundef nonnull @.str.1, i32 noundef 86, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

151:                                              ; preds = %139
  store i32 %9, ptr %140, align 8, !tbaa !20
  %152 = getelementptr inbounds i8, ptr %140, i64 4
  store i32 %1, ptr %152, align 4, !tbaa !15
  %153 = getelementptr inbounds i8, ptr %140, i64 8
  store i32 %2, ptr %153, align 8, !tbaa !21
  %154 = getelementptr inbounds i8, ptr %140, i64 12
  store i32 %3, ptr %154, align 4, !tbaa !22
  %155 = getelementptr inbounds i8, ptr %140, i64 16
  %156 = getelementptr inbounds i8, ptr %140, i64 32
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %155, i8 0, i64 16, i1 false)
  store i32 %4, ptr %156, align 8, !tbaa !23
  %157 = getelementptr inbounds i8, ptr %140, i64 36
  store i32 %5, ptr %157, align 4, !tbaa !24
  %158 = getelementptr inbounds i8, ptr %140, i64 40
  store i32 %6, ptr %158, align 8, !tbaa !25
  %159 = getelementptr inbounds i8, ptr %140, i64 48
  %160 = zext nneg i32 %1 to i64
  %161 = shl nuw nsw i64 %160, 2
  %162 = tail call noalias ptr @malloc(i64 noundef %161) #13
  %163 = getelementptr inbounds i8, ptr %140, i64 64
  tail call void @llvm.memset.p0.i64(ptr noundef nonnull align 8 dereferenceable(16) %159, i8 0, i64 16, i1 false)
  store ptr %162, ptr %163, align 8, !tbaa !26
  %.not202 = icmp eq ptr %162, null
  br i1 %.not202, label %164, label %174

164:                                              ; preds = %151
  %165 = load ptr, ptr @stderr, align 8, !tbaa !12
  %166 = tail call ptr @__errno_location() #9
  %167 = load i32, ptr %166, align 4, !tbaa !13
  %168 = icmp eq i32 %167, 0
  br i1 %168, label %171, label %169

169:                                              ; preds = %164
  %170 = tail call ptr @strerror(i32 noundef %167) #10
  br label %171

171:                                              ; preds = %169, %164
  %172 = phi ptr [ %170, %169 ], [ @.str.2, %164 ]
  %173 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %165, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 104, ptr noundef %172) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.13, ptr noundef nonnull @.str.1, i32 noundef 104, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

174:                                              ; preds = %151
  %175 = shl nuw nsw i64 %160, 3
  %176 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %177 = getelementptr inbounds i8, ptr %140, i64 72
  store ptr %176, ptr %177, align 8, !tbaa !27
  %.not204 = icmp eq ptr %176, null
  br i1 %.not204, label %178, label %188

178:                                              ; preds = %174
  %179 = load ptr, ptr @stderr, align 8, !tbaa !12
  %180 = tail call ptr @__errno_location() #9
  %181 = load i32, ptr %180, align 4, !tbaa !13
  %182 = icmp eq i32 %181, 0
  br i1 %182, label %185, label %183

183:                                              ; preds = %178
  %184 = tail call ptr @strerror(i32 noundef %181) #10
  br label %185

185:                                              ; preds = %183, %178
  %186 = phi ptr [ %184, %183 ], [ @.str.2, %178 ]
  %187 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %179, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 107, ptr noundef %186) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.14, ptr noundef nonnull @.str.1, i32 noundef 107, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

188:                                              ; preds = %174
  %189 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %190 = getelementptr inbounds i8, ptr %140, i64 80
  store ptr %189, ptr %190, align 8, !tbaa !28
  %.not206 = icmp eq ptr %189, null
  br i1 %.not206, label %191, label %201

191:                                              ; preds = %188
  %192 = load ptr, ptr @stderr, align 8, !tbaa !12
  %193 = tail call ptr @__errno_location() #9
  %194 = load i32, ptr %193, align 4, !tbaa !13
  %195 = icmp eq i32 %194, 0
  br i1 %195, label %198, label %196

196:                                              ; preds = %191
  %197 = tail call ptr @strerror(i32 noundef %194) #10
  br label %198

198:                                              ; preds = %196, %191
  %199 = phi ptr [ %197, %196 ], [ @.str.2, %191 ]
  %200 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %192, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 110, ptr noundef %199) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.15, ptr noundef nonnull @.str.1, i32 noundef 110, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

201:                                              ; preds = %188
  %202 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %203 = getelementptr inbounds i8, ptr %140, i64 88
  store ptr %202, ptr %203, align 8, !tbaa !29
  %.not208 = icmp eq ptr %202, null
  br i1 %.not208, label %204, label %214

204:                                              ; preds = %201
  %205 = load ptr, ptr @stderr, align 8, !tbaa !12
  %206 = tail call ptr @__errno_location() #9
  %207 = load i32, ptr %206, align 4, !tbaa !13
  %208 = icmp eq i32 %207, 0
  br i1 %208, label %211, label %209

209:                                              ; preds = %204
  %210 = tail call ptr @strerror(i32 noundef %207) #10
  br label %211

211:                                              ; preds = %209, %204
  %212 = phi ptr [ %210, %209 ], [ @.str.2, %204 ]
  %213 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %205, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 113, ptr noundef %212) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.16, ptr noundef nonnull @.str.1, i32 noundef 113, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

214:                                              ; preds = %201
  %215 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %216 = getelementptr inbounds i8, ptr %140, i64 96
  store ptr %215, ptr %216, align 8, !tbaa !30
  %.not210 = icmp eq ptr %215, null
  br i1 %.not210, label %217, label %227

217:                                              ; preds = %214
  %218 = load ptr, ptr @stderr, align 8, !tbaa !12
  %219 = tail call ptr @__errno_location() #9
  %220 = load i32, ptr %219, align 4, !tbaa !13
  %221 = icmp eq i32 %220, 0
  br i1 %221, label %224, label %222

222:                                              ; preds = %217
  %223 = tail call ptr @strerror(i32 noundef %220) #10
  br label %224

224:                                              ; preds = %222, %217
  %225 = phi ptr [ %223, %222 ], [ @.str.2, %217 ]
  %226 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %218, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 116, ptr noundef %225) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.17, ptr noundef nonnull @.str.1, i32 noundef 116, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

227:                                              ; preds = %214
  %228 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %229 = getelementptr inbounds i8, ptr %140, i64 104
  store ptr %228, ptr %229, align 8, !tbaa !31
  %.not212 = icmp eq ptr %228, null
  br i1 %.not212, label %230, label %240

230:                                              ; preds = %227
  %231 = load ptr, ptr @stderr, align 8, !tbaa !12
  %232 = tail call ptr @__errno_location() #9
  %233 = load i32, ptr %232, align 4, !tbaa !13
  %234 = icmp eq i32 %233, 0
  br i1 %234, label %237, label %235

235:                                              ; preds = %230
  %236 = tail call ptr @strerror(i32 noundef %233) #10
  br label %237

237:                                              ; preds = %235, %230
  %238 = phi ptr [ %236, %235 ], [ @.str.2, %230 ]
  %239 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %231, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 119, ptr noundef %238) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.18, ptr noundef nonnull @.str.1, i32 noundef 119, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

240:                                              ; preds = %227
  %241 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %242 = getelementptr inbounds i8, ptr %140, i64 112
  store ptr %241, ptr %242, align 8, !tbaa !32
  %.not214 = icmp eq ptr %241, null
  br i1 %.not214, label %243, label %253

243:                                              ; preds = %240
  %244 = load ptr, ptr @stderr, align 8, !tbaa !12
  %245 = tail call ptr @__errno_location() #9
  %246 = load i32, ptr %245, align 4, !tbaa !13
  %247 = icmp eq i32 %246, 0
  br i1 %247, label %250, label %248

248:                                              ; preds = %243
  %249 = tail call ptr @strerror(i32 noundef %246) #10
  br label %250

250:                                              ; preds = %248, %243
  %251 = phi ptr [ %249, %248 ], [ @.str.2, %243 ]
  %252 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %244, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 122, ptr noundef %251) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.19, ptr noundef nonnull @.str.1, i32 noundef 122, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

253:                                              ; preds = %240
  %254 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %255 = getelementptr inbounds i8, ptr %140, i64 120
  store ptr %254, ptr %255, align 8, !tbaa !33
  %.not216 = icmp eq ptr %254, null
  br i1 %.not216, label %256, label %266

256:                                              ; preds = %253
  %257 = load ptr, ptr @stderr, align 8, !tbaa !12
  %258 = tail call ptr @__errno_location() #9
  %259 = load i32, ptr %258, align 4, !tbaa !13
  %260 = icmp eq i32 %259, 0
  br i1 %260, label %263, label %261

261:                                              ; preds = %256
  %262 = tail call ptr @strerror(i32 noundef %259) #10
  br label %263

263:                                              ; preds = %261, %256
  %264 = phi ptr [ %262, %261 ], [ @.str.2, %256 ]
  %265 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %257, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 125, ptr noundef %264) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.20, ptr noundef nonnull @.str.1, i32 noundef 125, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

266:                                              ; preds = %253
  %267 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %268 = getelementptr inbounds i8, ptr %140, i64 144
  store ptr %267, ptr %268, align 8, !tbaa !34
  %.not218 = icmp eq ptr %267, null
  br i1 %.not218, label %269, label %279

269:                                              ; preds = %266
  %270 = load ptr, ptr @stderr, align 8, !tbaa !12
  %271 = tail call ptr @__errno_location() #9
  %272 = load i32, ptr %271, align 4, !tbaa !13
  %273 = icmp eq i32 %272, 0
  br i1 %273, label %276, label %274

274:                                              ; preds = %269
  %275 = tail call ptr @strerror(i32 noundef %272) #10
  br label %276

276:                                              ; preds = %274, %269
  %277 = phi ptr [ %275, %274 ], [ @.str.2, %269 ]
  %278 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %270, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 128, ptr noundef %277) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.21, ptr noundef nonnull @.str.1, i32 noundef 128, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

279:                                              ; preds = %266
  %280 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %281 = getelementptr inbounds i8, ptr %140, i64 128
  store ptr %280, ptr %281, align 8, !tbaa !35
  %.not220 = icmp eq ptr %280, null
  br i1 %.not220, label %282, label %292

282:                                              ; preds = %279
  %283 = load ptr, ptr @stderr, align 8, !tbaa !12
  %284 = tail call ptr @__errno_location() #9
  %285 = load i32, ptr %284, align 4, !tbaa !13
  %286 = icmp eq i32 %285, 0
  br i1 %286, label %289, label %287

287:                                              ; preds = %282
  %288 = tail call ptr @strerror(i32 noundef %285) #10
  br label %289

289:                                              ; preds = %287, %282
  %290 = phi ptr [ %288, %287 ], [ @.str.2, %282 ]
  %291 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %283, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 131, ptr noundef %290) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.22, ptr noundef nonnull @.str.1, i32 noundef 131, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

292:                                              ; preds = %279
  %293 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %294 = getelementptr inbounds i8, ptr %140, i64 136
  store ptr %293, ptr %294, align 8, !tbaa !36
  %.not222 = icmp eq ptr %293, null
  br i1 %.not222, label %295, label %305

295:                                              ; preds = %292
  %296 = load ptr, ptr @stderr, align 8, !tbaa !12
  %297 = tail call ptr @__errno_location() #9
  %298 = load i32, ptr %297, align 4, !tbaa !13
  %299 = icmp eq i32 %298, 0
  br i1 %299, label %302, label %300

300:                                              ; preds = %295
  %301 = tail call ptr @strerror(i32 noundef %298) #10
  br label %302

302:                                              ; preds = %300, %295
  %303 = phi ptr [ %301, %300 ], [ @.str.2, %295 ]
  %304 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %296, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 134, ptr noundef %303) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.23, ptr noundef nonnull @.str.1, i32 noundef 134, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

305:                                              ; preds = %292
  %306 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %307 = getelementptr inbounds i8, ptr %140, i64 152
  store ptr %306, ptr %307, align 8, !tbaa !37
  %.not224 = icmp eq ptr %306, null
  br i1 %.not224, label %308, label %318

308:                                              ; preds = %305
  %309 = load ptr, ptr @stderr, align 8, !tbaa !12
  %310 = tail call ptr @__errno_location() #9
  %311 = load i32, ptr %310, align 4, !tbaa !13
  %312 = icmp eq i32 %311, 0
  br i1 %312, label %315, label %313

313:                                              ; preds = %308
  %314 = tail call ptr @strerror(i32 noundef %311) #10
  br label %315

315:                                              ; preds = %313, %308
  %316 = phi ptr [ %314, %313 ], [ @.str.2, %308 ]
  %317 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %309, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 137, ptr noundef %316) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.24, ptr noundef nonnull @.str.1, i32 noundef 137, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

318:                                              ; preds = %305
  %319 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %320 = getelementptr inbounds i8, ptr %140, i64 160
  store ptr %319, ptr %320, align 8, !tbaa !38
  %.not226 = icmp eq ptr %319, null
  br i1 %.not226, label %321, label %331

321:                                              ; preds = %318
  %322 = load ptr, ptr @stderr, align 8, !tbaa !12
  %323 = tail call ptr @__errno_location() #9
  %324 = load i32, ptr %323, align 4, !tbaa !13
  %325 = icmp eq i32 %324, 0
  br i1 %325, label %328, label %326

326:                                              ; preds = %321
  %327 = tail call ptr @strerror(i32 noundef %324) #10
  br label %328

328:                                              ; preds = %326, %321
  %329 = phi ptr [ %327, %326 ], [ @.str.2, %321 ]
  %330 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %322, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 140, ptr noundef %329) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.25, ptr noundef nonnull @.str.1, i32 noundef 140, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

331:                                              ; preds = %318
  %332 = tail call noalias ptr @malloc(i64 noundef %175) #13
  %333 = getelementptr inbounds i8, ptr %140, i64 168
  store ptr %332, ptr %333, align 8, !tbaa !39
  %.not228 = icmp eq ptr %332, null
  br i1 %.not228, label %334, label %.lr.ph239

334:                                              ; preds = %331
  %335 = load ptr, ptr @stderr, align 8, !tbaa !12
  %336 = tail call ptr @__errno_location() #9
  %337 = load i32, ptr %336, align 4, !tbaa !13
  %338 = icmp eq i32 %337, 0
  br i1 %338, label %341, label %339

339:                                              ; preds = %334
  %340 = tail call ptr @strerror(i32 noundef %337) #10
  br label %341

341:                                              ; preds = %339, %334
  %342 = phi ptr [ %340, %339 ], [ @.str.2, %334 ]
  %343 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %335, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 143, ptr noundef %342) #11
  tail call void @__assert_fail(ptr noundef nonnull @.str.26, ptr noundef nonnull @.str.1, i32 noundef 143, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

.lr.ph239:                                        ; preds = %331
  %344 = sext i32 %.0174 to i64
  %345 = shl nsw i64 %344, 3
  %wide.trip.count = zext nneg i32 %1 to i64
  br label %353

._crit_edge240:                                   ; preds = %._crit_edge
  %346 = tail call noalias dereferenceable_or_null(176) ptr @malloc(i64 noundef 176) #13
  %347 = load ptr, ptr %126, align 8, !tbaa !14
  %348 = sext i32 %9 to i64
  %349 = getelementptr inbounds ptr, ptr %347, i64 %348
  store ptr %346, ptr %349, align 8, !tbaa !12
  %350 = load ptr, ptr %126, align 8, !tbaa !14
  %351 = getelementptr inbounds ptr, ptr %350, i64 %348
  %352 = load ptr, ptr %351, align 8, !tbaa !12
  %.not230 = icmp eq ptr %352, null
  br i1 %.not230, label %417, label %431

353:                                              ; preds = %.lr.ph239, %._crit_edge
  %354 = phi ptr [ %176, %.lr.ph239 ], [ %373, %._crit_edge ]
  %355 = phi ptr [ %162, %.lr.ph239 ], [ %405, %._crit_edge ]
  %indvars.iv242 = phi i64 [ 0, %.lr.ph239 ], [ %indvars.iv.next243, %._crit_edge ]
  %356 = getelementptr inbounds i32, ptr %355, i64 %indvars.iv242
  store i32 %.0174, ptr %356, align 4, !tbaa !13
  %357 = getelementptr inbounds double, ptr %202, i64 %indvars.iv242
  store double 0.000000e+00, ptr %357, align 8, !tbaa !40
  %358 = getelementptr inbounds double, ptr %215, i64 %indvars.iv242
  store double 0.000000e+00, ptr %358, align 8, !tbaa !40
  %359 = getelementptr inbounds double, ptr %228, i64 %indvars.iv242
  store double 0.000000e+00, ptr %359, align 8, !tbaa !40
  %360 = getelementptr inbounds double, ptr %241, i64 %indvars.iv242
  store double 0.000000e+00, ptr %360, align 8, !tbaa !40
  %361 = getelementptr inbounds double, ptr %254, i64 %indvars.iv242
  store double 0.000000e+00, ptr %361, align 8, !tbaa !40
  %362 = tail call double (...) @annRandomizer() #10
  %363 = getelementptr inbounds double, ptr %280, i64 %indvars.iv242
  store double %362, ptr %363, align 8, !tbaa !40
  %364 = getelementptr inbounds double, ptr %293, i64 %indvars.iv242
  store double 0.000000e+00, ptr %364, align 8, !tbaa !40
  %365 = tail call ptr @activationNew(i32 noundef %4) #10
  %366 = getelementptr inbounds ptr, ptr %306, i64 %indvars.iv242
  store ptr %365, ptr %366, align 8, !tbaa !12
  %367 = tail call ptr @lossNew(i32 noundef %5) #10
  %368 = getelementptr inbounds ptr, ptr %319, i64 %indvars.iv242
  store ptr %367, ptr %368, align 8, !tbaa !12
  %369 = tail call ptr @optimizationNew(i32 noundef %6) #10
  %370 = getelementptr inbounds ptr, ptr %332, i64 %indvars.iv242
  store ptr %369, ptr %370, align 8, !tbaa !12
  %371 = tail call noalias ptr @malloc(i64 noundef %345) #13
  %372 = getelementptr inbounds ptr, ptr %354, i64 %indvars.iv242
  store ptr %371, ptr %372, align 8, !tbaa !12
  %373 = load ptr, ptr %177, align 8, !tbaa !27
  %374 = getelementptr inbounds ptr, ptr %373, i64 %indvars.iv242
  %375 = load ptr, ptr %374, align 8, !tbaa !12
  %.not232 = icmp eq ptr %375, null
  br i1 %.not232, label %376, label %388

376:                                              ; preds = %353
  %377 = load ptr, ptr @stderr, align 8, !tbaa !12
  %378 = tail call ptr @__errno_location() #9
  %379 = load i32, ptr %378, align 4, !tbaa !13
  %380 = icmp eq i32 %379, 0
  br i1 %380, label %383, label %381

381:                                              ; preds = %376
  %382 = tail call ptr @strerror(i32 noundef %379) #10
  br label %383

383:                                              ; preds = %376, %381
  %384 = phi ptr [ %382, %381 ], [ @.str.2, %376 ]
  %385 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %377, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 163, ptr noundef %384) #11
  %386 = load ptr, ptr %374, align 8, !tbaa !12
  %.not233 = icmp eq ptr %386, null
  br i1 %.not233, label %387, label %388

387:                                              ; preds = %383
  tail call void @__assert_fail(ptr noundef nonnull @.str.27, ptr noundef nonnull @.str.1, i32 noundef 163, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

388:                                              ; preds = %383, %353
  %389 = tail call noalias ptr @malloc(i64 noundef %345) #13
  %390 = load ptr, ptr %190, align 8, !tbaa !28
  %391 = getelementptr inbounds ptr, ptr %390, i64 %indvars.iv242
  store ptr %389, ptr %391, align 8, !tbaa !12
  %.not234 = icmp eq ptr %389, null
  br i1 %.not234, label %392, label %404

392:                                              ; preds = %388
  %393 = load ptr, ptr @stderr, align 8, !tbaa !12
  %394 = tail call ptr @__errno_location() #9
  %395 = load i32, ptr %394, align 4, !tbaa !13
  %396 = icmp eq i32 %395, 0
  br i1 %396, label %399, label %397

397:                                              ; preds = %392
  %398 = tail call ptr @strerror(i32 noundef %395) #10
  br label %399

399:                                              ; preds = %392, %397
  %400 = phi ptr [ %398, %397 ], [ @.str.2, %392 ]
  %401 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %393, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 166, ptr noundef %400) #11
  %402 = load ptr, ptr %391, align 8, !tbaa !12
  %.not235 = icmp eq ptr %402, null
  br i1 %.not235, label %403, label %404

403:                                              ; preds = %399
  tail call void @__assert_fail(ptr noundef nonnull @.str.28, ptr noundef nonnull @.str.1, i32 noundef 166, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

404:                                              ; preds = %399, %388
  %405 = load ptr, ptr %163, align 8, !tbaa !26
  %406 = getelementptr inbounds i32, ptr %405, i64 %indvars.iv242
  %407 = load i32, ptr %406, align 4, !tbaa !13
  %408 = icmp sgt i32 %407, 0
  br i1 %408, label %.lr.ph, label %._crit_edge

._crit_edge:                                      ; preds = %.lr.ph, %404
  %indvars.iv.next243 = add nuw nsw i64 %indvars.iv242, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next243, %wide.trip.count
  br i1 %exitcond.not, label %._crit_edge240, label %353, !llvm.loop !41

.lr.ph:                                           ; preds = %404, %.lr.ph
  %indvars.iv = phi i64 [ %indvars.iv.next, %.lr.ph ], [ 0, %404 ]
  %409 = load ptr, ptr %374, align 8, !tbaa !12
  %410 = getelementptr inbounds double, ptr %409, i64 %indvars.iv
  store double 0.000000e+00, ptr %410, align 8, !tbaa !40
  %411 = tail call double (...) @annRandomizer() #10
  %412 = load ptr, ptr %391, align 8, !tbaa !12
  %413 = getelementptr inbounds double, ptr %412, i64 %indvars.iv
  store double %411, ptr %413, align 8, !tbaa !40
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %414 = load i32, ptr %406, align 4, !tbaa !13
  %415 = sext i32 %414 to i64
  %416 = icmp slt i64 %indvars.iv.next, %415
  br i1 %416, label %.lr.ph, label %._crit_edge, !llvm.loop !43

417:                                              ; preds = %._crit_edge240
  %418 = load ptr, ptr @stderr, align 8, !tbaa !12
  %419 = tail call ptr @__errno_location() #9
  %420 = load i32, ptr %419, align 4, !tbaa !13
  %421 = icmp eq i32 %420, 0
  br i1 %421, label %424, label %422

422:                                              ; preds = %417
  %423 = tail call ptr @strerror(i32 noundef %420) #10
  br label %424

424:                                              ; preds = %417, %422
  %425 = phi ptr [ %423, %422 ], [ @.str.2, %417 ]
  %426 = tail call i32 (ptr, ptr, ...) @fprintf(ptr noundef %418, ptr noundef nonnull @.str.9, ptr noundef nonnull @.str.1, i32 noundef 174, ptr noundef %425) #11
  %427 = load ptr, ptr %126, align 8, !tbaa !14
  %428 = getelementptr inbounds ptr, ptr %427, i64 %348
  %429 = load ptr, ptr %428, align 8, !tbaa !12
  %.not231 = icmp eq ptr %429, null
  br i1 %.not231, label %430, label %431

430:                                              ; preds = %424
  tail call void @__assert_fail(ptr noundef nonnull @.str.29, ptr noundef nonnull @.str.1, i32 noundef 174, ptr noundef nonnull @__PRETTY_FUNCTION__.mlpLayerAppend) #12
  unreachable

431:                                              ; preds = %424, %._crit_edge240
  %432 = phi ptr [ %427, %424 ], [ %350, %._crit_edge240 ]
  %433 = getelementptr inbounds ptr, ptr %432, i64 %348
  store ptr %140, ptr %433, align 8, !tbaa !12
  ret ptr %140
}

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

; Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)
declare ptr @__errno_location() local_unnamed_addr #3

; Function Attrs: nounwind
declare ptr @strerror(i32 noundef) local_unnamed_addr #4

; Function Attrs: noreturn nounwind
declare void @__assert_fail(ptr noundef, ptr noundef, i32 noundef, ptr noundef) local_unnamed_addr #5

; Function Attrs: mustprogress nounwind willreturn allockind("realloc") allocsize(1) memory(argmem: readwrite, inaccessiblemem: readwrite)
declare noalias noundef ptr @realloc(ptr allocptr nocapture noundef, i64 noundef) local_unnamed_addr #6

declare double @annRandomizer(...) local_unnamed_addr #7

declare ptr @activationNew(i32 noundef) local_unnamed_addr #7

declare ptr @lossNew(i32 noundef) local_unnamed_addr #7

declare ptr @optimizationNew(i32 noundef) local_unnamed_addr #7

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !7, i64 4}
!6 = !{!"mlp", !7, i64 0, !7, i64 4, !7, i64 8, !7, i64 12, !7, i64 16, !10, i64 24, !10, i64 32, !11, i64 40, !7, i64 48, !7, i64 52, !7, i64 56, !7, i64 60, !7, i64 64, !7, i64 68, !11, i64 72, !11, i64 80, !11, i64 88, !11, i64 96, !11, i64 104, !11, i64 112, !11, i64 120}
!7 = !{!"int", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"double", !8, i64 0}
!11 = !{!"any pointer", !8, i64 0}
!12 = !{!11, !11, i64 0}
!13 = !{!7, !7, i64 0}
!14 = !{!6, !11, i64 40}
!15 = !{!16, !7, i64 4}
!16 = !{!"mlpLayer", !7, i64 0, !7, i64 4, !7, i64 8, !7, i64 12, !10, i64 16, !10, i64 24, !7, i64 32, !7, i64 36, !7, i64 40, !10, i64 48, !10, i64 56, !11, i64 64, !11, i64 72, !11, i64 80, !11, i64 88, !11, i64 96, !11, i64 104, !11, i64 112, !11, i64 120, !11, i64 128, !11, i64 136, !11, i64 144, !11, i64 152, !11, i64 160, !11, i64 168}
!17 = !{!6, !7, i64 8}
!18 = !{!6, !7, i64 16}
!19 = !{!6, !7, i64 12}
!20 = !{!16, !7, i64 0}
!21 = !{!16, !7, i64 8}
!22 = !{!16, !7, i64 12}
!23 = !{!16, !7, i64 32}
!24 = !{!16, !7, i64 36}
!25 = !{!16, !7, i64 40}
!26 = !{!16, !11, i64 64}
!27 = !{!16, !11, i64 72}
!28 = !{!16, !11, i64 80}
!29 = !{!16, !11, i64 88}
!30 = !{!16, !11, i64 96}
!31 = !{!16, !11, i64 104}
!32 = !{!16, !11, i64 112}
!33 = !{!16, !11, i64 120}
!34 = !{!16, !11, i64 144}
!35 = !{!16, !11, i64 128}
!36 = !{!16, !11, i64 136}
!37 = !{!16, !11, i64 152}
!38 = !{!16, !11, i64 160}
!39 = !{!16, !11, i64 168}
!40 = !{!10, !10, i64 0}
!41 = distinct !{!41, !42}
!42 = !{!"llvm.loop.mustprogress"}
!43 = distinct !{!43, !42}


; Effective O3 passes: CorrelatedValuePropagationPass,EarlyCSEPass,GVNPass,GlobalOptPass,IPSCCPPass,IndVarSimplifyPass,InferFunctionAttrsPass,InstCombinePass,JumpThreadingPass,LICMPass,LoopRotatePass,LoopSimplifyPass,LoopUnrollPass,MemCpyOptPass,PostOrderFunctionAttrsPass,SCCPPass,SROAPass,SimplifyCFGPass,TailCallElimPass