; LLVM IR from Dynmi/AlexNet :: src (alexnet)

; 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.network = type { ptr, ptr, i16, %struct.conv_op, %struct.batch_norm_op, %struct.nonlinear_op, %struct.max_pooling_op, %struct.conv_op, %struct.batch_norm_op, %struct.nonlinear_op, %struct.max_pooling_op, %struct.conv_op, %struct.batch_norm_op, %struct.nonlinear_op, %struct.conv_op, %struct.batch_norm_op, %struct.nonlinear_op, %struct.conv_op, %struct.batch_norm_op, %struct.nonlinear_op, %struct.max_pooling_op, %struct.fc_op, %struct.nonlinear_op, %struct.fc_op, %struct.nonlinear_op, %struct.fc_op }
%struct.conv_op = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i16 }
%struct.batch_norm_op = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, i32, i16, ptr, ptr, ptr }
%struct.max_pooling_op = type { ptr, ptr, ptr, ptr, i32, i32, i32, i32, i32, i32, i32, i32, i32, i16 }
%struct.nonlinear_op = type { ptr, ptr, ptr, ptr, i32, i16 }
%struct.fc_op = type { ptr, ptr, ptr, ptr, ptr, ptr, ptr, ptr, i32, i32, i16 }

@.str.2 = external hidden unnamed_addr constant [64 x i8], align 1

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

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

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

; Function Attrs: nounwind uwtable
define dso_local void @forward_alexnet(ptr noundef %0) #2 {
  %2 = alloca ptr, align 8
  %3 = alloca i32, align 4
  %4 = alloca i32, align 4
  store ptr %0, ptr %2, align 8, !tbaa !5
  %5 = load ptr, ptr %2, align 8, !tbaa !5
  %6 = getelementptr inbounds %struct.network, ptr %5, i32 0, i32 0
  %7 = load ptr, ptr %6, align 8, !tbaa !9
  %8 = load ptr, ptr %2, align 8, !tbaa !5
  %9 = getelementptr inbounds %struct.network, ptr %8, i32 0, i32 3
  %10 = getelementptr inbounds %struct.conv_op, ptr %9, i32 0, i32 0
  store ptr %7, ptr %10, align 8, !tbaa !18
  %11 = load ptr, ptr %2, align 8, !tbaa !5
  %12 = getelementptr inbounds %struct.network, ptr %11, i32 0, i32 2
  %13 = load i16, ptr %12, align 8, !tbaa !19
  %14 = sext i16 %13 to i32
  %15 = load ptr, ptr %2, align 8, !tbaa !5
  %16 = getelementptr inbounds %struct.network, ptr %15, i32 0, i32 3
  %17 = getelementptr inbounds %struct.conv_op, ptr %16, i32 0, i32 19
  %18 = load i32, ptr %17, align 8, !tbaa !20
  %19 = mul nsw i32 %14, %18
  %20 = sext i32 %19 to i64
  %21 = call noalias ptr @calloc(i64 noundef %20, i64 noundef 4) #5
  %22 = load ptr, ptr %2, align 8, !tbaa !5
  %23 = getelementptr inbounds %struct.network, ptr %22, i32 0, i32 3
  %24 = getelementptr inbounds %struct.conv_op, ptr %23, i32 0, i32 2
  store ptr %21, ptr %24, align 8, !tbaa !21
  %25 = load ptr, ptr %2, align 8, !tbaa !5
  %26 = getelementptr inbounds %struct.network, ptr %25, i32 0, i32 3
  call void @conv_op_forward(ptr noundef %26)
  %27 = load ptr, ptr %2, align 8, !tbaa !5
  %28 = getelementptr inbounds %struct.network, ptr %27, i32 0, i32 2
  %29 = load i16, ptr %28, align 8, !tbaa !19
  %30 = sext i16 %29 to i64
  %31 = mul i64 %30, 4
  %32 = load ptr, ptr %2, align 8, !tbaa !5
  %33 = getelementptr inbounds %struct.network, ptr %32, i32 0, i32 4
  %34 = getelementptr inbounds %struct.batch_norm_op, ptr %33, i32 0, i32 8
  %35 = load i32, ptr %34, align 8, !tbaa !22
  %36 = sext i32 %35 to i64
  %37 = mul i64 %31, %36
  %38 = call noalias ptr @malloc(i64 noundef %37) #6
  %39 = load ptr, ptr %2, align 8, !tbaa !5
  %40 = getelementptr inbounds %struct.network, ptr %39, i32 0, i32 4
  %41 = getelementptr inbounds %struct.batch_norm_op, ptr %40, i32 0, i32 2
  store ptr %38, ptr %41, align 8, !tbaa !23
  %42 = load ptr, ptr %2, align 8, !tbaa !5
  %43 = getelementptr inbounds %struct.network, ptr %42, i32 0, i32 3
  %44 = getelementptr inbounds %struct.conv_op, ptr %43, i32 0, i32 2
  %45 = load ptr, ptr %44, align 8, !tbaa !21
  %46 = load ptr, ptr %2, align 8, !tbaa !5
  %47 = getelementptr inbounds %struct.network, ptr %46, i32 0, i32 4
  %48 = getelementptr inbounds %struct.batch_norm_op, ptr %47, i32 0, i32 0
  store ptr %45, ptr %48, align 8, !tbaa !24
  %49 = load ptr, ptr %2, align 8, !tbaa !5
  %50 = getelementptr inbounds %struct.network, ptr %49, i32 0, i32 4
  call void @batch_norm_op_forward(ptr noundef %50)
  %51 = load ptr, ptr %2, align 8, !tbaa !5
  %52 = getelementptr inbounds %struct.network, ptr %51, i32 0, i32 2
  %53 = load i16, ptr %52, align 8, !tbaa !19
  %54 = sext i16 %53 to i64
  %55 = mul i64 %54, 4
  %56 = load ptr, ptr %2, align 8, !tbaa !5
  %57 = getelementptr inbounds %struct.network, ptr %56, i32 0, i32 5
  %58 = getelementptr inbounds %struct.nonlinear_op, ptr %57, i32 0, i32 4
  %59 = load i32, ptr %58, align 8, !tbaa !25
  %60 = sext i32 %59 to i64
  %61 = mul i64 %55, %60
  %62 = call noalias ptr @malloc(i64 noundef %61) #6
  %63 = load ptr, ptr %2, align 8, !tbaa !5
  %64 = getelementptr inbounds %struct.network, ptr %63, i32 0, i32 5
  %65 = getelementptr inbounds %struct.nonlinear_op, ptr %64, i32 0, i32 2
  store ptr %62, ptr %65, align 8, !tbaa !26
  %66 = load ptr, ptr %2, align 8, !tbaa !5
  %67 = getelementptr inbounds %struct.network, ptr %66, i32 0, i32 4
  %68 = getelementptr inbounds %struct.batch_norm_op, ptr %67, i32 0, i32 2
  %69 = load ptr, ptr %68, align 8, !tbaa !23
  %70 = load ptr, ptr %2, align 8, !tbaa !5
  %71 = getelementptr inbounds %struct.network, ptr %70, i32 0, i32 5
  %72 = getelementptr inbounds %struct.nonlinear_op, ptr %71, i32 0, i32 0
  store ptr %69, ptr %72, align 8, !tbaa !27
  %73 = load ptr, ptr %2, align 8, !tbaa !5
  %74 = getelementptr inbounds %struct.network, ptr %73, i32 0, i32 5
  call void @relu_op_forward(ptr noundef %74)
  %75 = load ptr, ptr %2, align 8, !tbaa !5
  %76 = getelementptr inbounds %struct.network, ptr %75, i32 0, i32 2
  %77 = load i16, ptr %76, align 8, !tbaa !19
  %78 = sext i16 %77 to i64
  %79 = mul i64 %78, 4
  %80 = load ptr, ptr %2, align 8, !tbaa !5
  %81 = getelementptr inbounds %struct.network, ptr %80, i32 0, i32 6
  %82 = getelementptr inbounds %struct.max_pooling_op, ptr %81, i32 0, i32 12
  %83 = load i32, ptr %82, align 8, !tbaa !28
  %84 = sext i32 %83 to i64
  %85 = mul i64 %79, %84
  %86 = call noalias ptr @malloc(i64 noundef %85) #6
  %87 = load ptr, ptr %2, align 8, !tbaa !5
  %88 = getelementptr inbounds %struct.network, ptr %87, i32 0, i32 6
  %89 = getelementptr inbounds %struct.max_pooling_op, ptr %88, i32 0, i32 2
  store ptr %86, ptr %89, align 8, !tbaa !29
  %90 = load ptr, ptr %2, align 8, !tbaa !5
  %91 = getelementptr inbounds %struct.network, ptr %90, i32 0, i32 5
  %92 = getelementptr inbounds %struct.nonlinear_op, ptr %91, i32 0, i32 2
  %93 = load ptr, ptr %92, align 8, !tbaa !26
  %94 = load ptr, ptr %2, align 8, !tbaa !5
  %95 = getelementptr inbounds %struct.network, ptr %94, i32 0, i32 6
  %96 = getelementptr inbounds %struct.max_pooling_op, ptr %95, i32 0, i32 0
  store ptr %93, ptr %96, align 8, !tbaa !30
  %97 = load ptr, ptr %2, align 8, !tbaa !5
  %98 = getelementptr inbounds %struct.network, ptr %97, i32 0, i32 6
  call void @max_pooling_op_forward(ptr noundef %98)
  %99 = load ptr, ptr %2, align 8, !tbaa !5
  %100 = getelementptr inbounds %struct.network, ptr %99, i32 0, i32 2
  %101 = load i16, ptr %100, align 8, !tbaa !19
  %102 = sext i16 %101 to i32
  %103 = load ptr, ptr %2, align 8, !tbaa !5
  %104 = getelementptr inbounds %struct.network, ptr %103, i32 0, i32 7
  %105 = getelementptr inbounds %struct.conv_op, ptr %104, i32 0, i32 19
  %106 = load i32, ptr %105, align 8, !tbaa !31
  %107 = mul nsw i32 %102, %106
  %108 = sext i32 %107 to i64
  %109 = call noalias ptr @calloc(i64 noundef %108, i64 noundef 4) #5
  %110 = load ptr, ptr %2, align 8, !tbaa !5
  %111 = getelementptr inbounds %struct.network, ptr %110, i32 0, i32 7
  %112 = getelementptr inbounds %struct.conv_op, ptr %111, i32 0, i32 2
  store ptr %109, ptr %112, align 8, !tbaa !32
  %113 = load ptr, ptr %2, align 8, !tbaa !5
  %114 = getelementptr inbounds %struct.network, ptr %113, i32 0, i32 6
  %115 = getelementptr inbounds %struct.max_pooling_op, ptr %114, i32 0, i32 2
  %116 = load ptr, ptr %115, align 8, !tbaa !29
  %117 = load ptr, ptr %2, align 8, !tbaa !5
  %118 = getelementptr inbounds %struct.network, ptr %117, i32 0, i32 7
  %119 = getelementptr inbounds %struct.conv_op, ptr %118, i32 0, i32 0
  store ptr %116, ptr %119, align 8, !tbaa !33
  %120 = load ptr, ptr %2, align 8, !tbaa !5
  %121 = getelementptr inbounds %struct.network, ptr %120, i32 0, i32 7
  call void @conv_op_forward(ptr noundef %121)
  %122 = load ptr, ptr %2, align 8, !tbaa !5
  %123 = getelementptr inbounds %struct.network, ptr %122, i32 0, i32 2
  %124 = load i16, ptr %123, align 8, !tbaa !19
  %125 = sext i16 %124 to i64
  %126 = mul i64 %125, 4
  %127 = load ptr, ptr %2, align 8, !tbaa !5
  %128 = getelementptr inbounds %struct.network, ptr %127, i32 0, i32 8
  %129 = getelementptr inbounds %struct.batch_norm_op, ptr %128, i32 0, i32 8
  %130 = load i32, ptr %129, align 8, !tbaa !34
  %131 = sext i32 %130 to i64
  %132 = mul i64 %126, %131
  %133 = call noalias ptr @malloc(i64 noundef %132) #6
  %134 = load ptr, ptr %2, align 8, !tbaa !5
  %135 = getelementptr inbounds %struct.network, ptr %134, i32 0, i32 8
  %136 = getelementptr inbounds %struct.batch_norm_op, ptr %135, i32 0, i32 2
  store ptr %133, ptr %136, align 8, !tbaa !35
  %137 = load ptr, ptr %2, align 8, !tbaa !5
  %138 = getelementptr inbounds %struct.network, ptr %137, i32 0, i32 7
  %139 = getelementptr inbounds %struct.conv_op, ptr %138, i32 0, i32 2
  %140 = load ptr, ptr %139, align 8, !tbaa !32
  %141 = load ptr, ptr %2, align 8, !tbaa !5
  %142 = getelementptr inbounds %struct.network, ptr %141, i32 0, i32 8
  %143 = getelementptr inbounds %struct.batch_norm_op, ptr %142, i32 0, i32 0
  store ptr %140, ptr %143, align 8, !tbaa !36
  %144 = load ptr, ptr %2, align 8, !tbaa !5
  %145 = getelementptr inbounds %struct.network, ptr %144, i32 0, i32 8
  call void @batch_norm_op_forward(ptr noundef %145)
  %146 = load ptr, ptr %2, align 8, !tbaa !5
  %147 = getelementptr inbounds %struct.network, ptr %146, i32 0, i32 2
  %148 = load i16, ptr %147, align 8, !tbaa !19
  %149 = sext i16 %148 to i64
  %150 = mul i64 %149, 4
  %151 = load ptr, ptr %2, align 8, !tbaa !5
  %152 = getelementptr inbounds %struct.network, ptr %151, i32 0, i32 9
  %153 = getelementptr inbounds %struct.nonlinear_op, ptr %152, i32 0, i32 4
  %154 = load i32, ptr %153, align 8, !tbaa !37
  %155 = sext i32 %154 to i64
  %156 = mul i64 %150, %155
  %157 = call noalias ptr @malloc(i64 noundef %156) #6
  %158 = load ptr, ptr %2, align 8, !tbaa !5
  %159 = getelementptr inbounds %struct.network, ptr %158, i32 0, i32 9
  %160 = getelementptr inbounds %struct.nonlinear_op, ptr %159, i32 0, i32 2
  store ptr %157, ptr %160, align 8, !tbaa !38
  %161 = load ptr, ptr %2, align 8, !tbaa !5
  %162 = getelementptr inbounds %struct.network, ptr %161, i32 0, i32 8
  %163 = getelementptr inbounds %struct.batch_norm_op, ptr %162, i32 0, i32 2
  %164 = load ptr, ptr %163, align 8, !tbaa !35
  %165 = load ptr, ptr %2, align 8, !tbaa !5
  %166 = getelementptr inbounds %struct.network, ptr %165, i32 0, i32 9
  %167 = getelementptr inbounds %struct.nonlinear_op, ptr %166, i32 0, i32 0
  store ptr %164, ptr %167, align 8, !tbaa !39
  %168 = load ptr, ptr %2, align 8, !tbaa !5
  %169 = getelementptr inbounds %struct.network, ptr %168, i32 0, i32 9
  call void @relu_op_forward(ptr noundef %169)
  %170 = load ptr, ptr %2, align 8, !tbaa !5
  %171 = getelementptr inbounds %struct.network, ptr %170, i32 0, i32 2
  %172 = load i16, ptr %171, align 8, !tbaa !19
  %173 = sext i16 %172 to i64
  %174 = mul i64 %173, 4
  %175 = load ptr, ptr %2, align 8, !tbaa !5
  %176 = getelementptr inbounds %struct.network, ptr %175, i32 0, i32 10
  %177 = getelementptr inbounds %struct.max_pooling_op, ptr %176, i32 0, i32 12
  %178 = load i32, ptr %177, align 8, !tbaa !40
  %179 = sext i32 %178 to i64
  %180 = mul i64 %174, %179
  %181 = call noalias ptr @malloc(i64 noundef %180) #6
  %182 = load ptr, ptr %2, align 8, !tbaa !5
  %183 = getelementptr inbounds %struct.network, ptr %182, i32 0, i32 10
  %184 = getelementptr inbounds %struct.max_pooling_op, ptr %183, i32 0, i32 2
  store ptr %181, ptr %184, align 8, !tbaa !41
  %185 = load ptr, ptr %2, align 8, !tbaa !5
  %186 = getelementptr inbounds %struct.network, ptr %185, i32 0, i32 9
  %187 = getelementptr inbounds %struct.nonlinear_op, ptr %186, i32 0, i32 2
  %188 = load ptr, ptr %187, align 8, !tbaa !38
  %189 = load ptr, ptr %2, align 8, !tbaa !5
  %190 = getelementptr inbounds %struct.network, ptr %189, i32 0, i32 10
  %191 = getelementptr inbounds %struct.max_pooling_op, ptr %190, i32 0, i32 0
  store ptr %188, ptr %191, align 8, !tbaa !42
  %192 = load ptr, ptr %2, align 8, !tbaa !5
  %193 = getelementptr inbounds %struct.network, ptr %192, i32 0, i32 10
  call void @max_pooling_op_forward(ptr noundef %193)
  %194 = load ptr, ptr %2, align 8, !tbaa !5
  %195 = getelementptr inbounds %struct.network, ptr %194, i32 0, i32 2
  %196 = load i16, ptr %195, align 8, !tbaa !19
  %197 = sext i16 %196 to i32
  %198 = load ptr, ptr %2, align 8, !tbaa !5
  %199 = getelementptr inbounds %struct.network, ptr %198, i32 0, i32 11
  %200 = getelementptr inbounds %struct.conv_op, ptr %199, i32 0, i32 19
  %201 = load i32, ptr %200, align 8, !tbaa !43
  %202 = mul nsw i32 %197, %201
  %203 = sext i32 %202 to i64
  %204 = call noalias ptr @calloc(i64 noundef %203, i64 noundef 4) #5
  %205 = load ptr, ptr %2, align 8, !tbaa !5
  %206 = getelementptr inbounds %struct.network, ptr %205, i32 0, i32 11
  %207 = getelementptr inbounds %struct.conv_op, ptr %206, i32 0, i32 2
  store ptr %204, ptr %207, align 8, !tbaa !44
  %208 = load ptr, ptr %2, align 8, !tbaa !5
  %209 = getelementptr inbounds %struct.network, ptr %208, i32 0, i32 10
  %210 = getelementptr inbounds %struct.max_pooling_op, ptr %209, i32 0, i32 2
  %211 = load ptr, ptr %210, align 8, !tbaa !41
  %212 = load ptr, ptr %2, align 8, !tbaa !5
  %213 = getelementptr inbounds %struct.network, ptr %212, i32 0, i32 11
  %214 = getelementptr inbounds %struct.conv_op, ptr %213, i32 0, i32 0
  store ptr %211, ptr %214, align 8, !tbaa !45
  %215 = load ptr, ptr %2, align 8, !tbaa !5
  %216 = getelementptr inbounds %struct.network, ptr %215, i32 0, i32 11
  call void @conv_op_forward(ptr noundef %216)
  %217 = load ptr, ptr %2, align 8, !tbaa !5
  %218 = getelementptr inbounds %struct.network, ptr %217, i32 0, i32 2
  %219 = load i16, ptr %218, align 8, !tbaa !19
  %220 = sext i16 %219 to i64
  %221 = mul i64 %220, 4
  %222 = load ptr, ptr %2, align 8, !tbaa !5
  %223 = getelementptr inbounds %struct.network, ptr %222, i32 0, i32 12
  %224 = getelementptr inbounds %struct.batch_norm_op, ptr %223, i32 0, i32 8
  %225 = load i32, ptr %224, align 8, !tbaa !46
  %226 = sext i32 %225 to i64
  %227 = mul i64 %221, %226
  %228 = call noalias ptr @malloc(i64 noundef %227) #6
  %229 = load ptr, ptr %2, align 8, !tbaa !5
  %230 = getelementptr inbounds %struct.network, ptr %229, i32 0, i32 12
  %231 = getelementptr inbounds %struct.batch_norm_op, ptr %230, i32 0, i32 2
  store ptr %228, ptr %231, align 8, !tbaa !47
  %232 = load ptr, ptr %2, align 8, !tbaa !5
  %233 = getelementptr inbounds %struct.network, ptr %232, i32 0, i32 11
  %234 = getelementptr inbounds %struct.conv_op, ptr %233, i32 0, i32 2
  %235 = load ptr, ptr %234, align 8, !tbaa !44
  %236 = load ptr, ptr %2, align 8, !tbaa !5
  %237 = getelementptr inbounds %struct.network, ptr %236, i32 0, i32 12
  %238 = getelementptr inbounds %struct.batch_norm_op, ptr %237, i32 0, i32 0
  store ptr %235, ptr %238, align 8, !tbaa !48
  %239 = load ptr, ptr %2, align 8, !tbaa !5
  %240 = getelementptr inbounds %struct.network, ptr %239, i32 0, i32 12
  call void @batch_norm_op_forward(ptr noundef %240)
  %241 = load ptr, ptr %2, align 8, !tbaa !5
  %242 = getelementptr inbounds %struct.network, ptr %241, i32 0, i32 2
  %243 = load i16, ptr %242, align 8, !tbaa !19
  %244 = sext i16 %243 to i64
  %245 = mul i64 %244, 4
  %246 = load ptr, ptr %2, align 8, !tbaa !5
  %247 = getelementptr inbounds %struct.network, ptr %246, i32 0, i32 13
  %248 = getelementptr inbounds %struct.nonlinear_op, ptr %247, i32 0, i32 4
  %249 = load i32, ptr %248, align 8, !tbaa !49
  %250 = sext i32 %249 to i64
  %251 = mul i64 %245, %250
  %252 = call noalias ptr @malloc(i64 noundef %251) #6
  %253 = load ptr, ptr %2, align 8, !tbaa !5
  %254 = getelementptr inbounds %struct.network, ptr %253, i32 0, i32 13
  %255 = getelementptr inbounds %struct.nonlinear_op, ptr %254, i32 0, i32 2
  store ptr %252, ptr %255, align 8, !tbaa !50
  %256 = load ptr, ptr %2, align 8, !tbaa !5
  %257 = getelementptr inbounds %struct.network, ptr %256, i32 0, i32 12
  %258 = getelementptr inbounds %struct.batch_norm_op, ptr %257, i32 0, i32 2
  %259 = load ptr, ptr %258, align 8, !tbaa !47
  %260 = load ptr, ptr %2, align 8, !tbaa !5
  %261 = getelementptr inbounds %struct.network, ptr %260, i32 0, i32 13
  %262 = getelementptr inbounds %struct.nonlinear_op, ptr %261, i32 0, i32 0
  store ptr %259, ptr %262, align 8, !tbaa !51
  %263 = load ptr, ptr %2, align 8, !tbaa !5
  %264 = getelementptr inbounds %struct.network, ptr %263, i32 0, i32 13
  call void @relu_op_forward(ptr noundef %264)
  %265 = load ptr, ptr %2, align 8, !tbaa !5
  %266 = getelementptr inbounds %struct.network, ptr %265, i32 0, i32 2
  %267 = load i16, ptr %266, align 8, !tbaa !19
  %268 = sext i16 %267 to i32
  %269 = load ptr, ptr %2, align 8, !tbaa !5
  %270 = getelementptr inbounds %struct.network, ptr %269, i32 0, i32 14
  %271 = getelementptr inbounds %struct.conv_op, ptr %270, i32 0, i32 19
  %272 = load i32, ptr %271, align 8, !tbaa !52
  %273 = mul nsw i32 %268, %272
  %274 = sext i32 %273 to i64
  %275 = call noalias ptr @calloc(i64 noundef %274, i64 noundef 4) #5
  %276 = load ptr, ptr %2, align 8, !tbaa !5
  %277 = getelementptr inbounds %struct.network, ptr %276, i32 0, i32 14
  %278 = getelementptr inbounds %struct.conv_op, ptr %277, i32 0, i32 2
  store ptr %275, ptr %278, align 8, !tbaa !53
  %279 = load ptr, ptr %2, align 8, !tbaa !5
  %280 = getelementptr inbounds %struct.network, ptr %279, i32 0, i32 13
  %281 = getelementptr inbounds %struct.nonlinear_op, ptr %280, i32 0, i32 2
  %282 = load ptr, ptr %281, align 8, !tbaa !50
  %283 = load ptr, ptr %2, align 8, !tbaa !5
  %284 = getelementptr inbounds %struct.network, ptr %283, i32 0, i32 14
  %285 = getelementptr inbounds %struct.conv_op, ptr %284, i32 0, i32 0
  store ptr %282, ptr %285, align 8, !tbaa !54
  %286 = load ptr, ptr %2, align 8, !tbaa !5
  %287 = getelementptr inbounds %struct.network, ptr %286, i32 0, i32 14
  call void @conv_op_forward(ptr noundef %287)
  %288 = load ptr, ptr %2, align 8, !tbaa !5
  %289 = getelementptr inbounds %struct.network, ptr %288, i32 0, i32 2
  %290 = load i16, ptr %289, align 8, !tbaa !19
  %291 = sext i16 %290 to i64
  %292 = mul i64 %291, 4
  %293 = load ptr, ptr %2, align 8, !tbaa !5
  %294 = getelementptr inbounds %struct.network, ptr %293, i32 0, i32 15
  %295 = getelementptr inbounds %struct.batch_norm_op, ptr %294, i32 0, i32 8
  %296 = load i32, ptr %295, align 8, !tbaa !55
  %297 = sext i32 %296 to i64
  %298 = mul i64 %292, %297
  %299 = call noalias ptr @malloc(i64 noundef %298) #6
  %300 = load ptr, ptr %2, align 8, !tbaa !5
  %301 = getelementptr inbounds %struct.network, ptr %300, i32 0, i32 15
  %302 = getelementptr inbounds %struct.batch_norm_op, ptr %301, i32 0, i32 2
  store ptr %299, ptr %302, align 8, !tbaa !56
  %303 = load ptr, ptr %2, align 8, !tbaa !5
  %304 = getelementptr inbounds %struct.network, ptr %303, i32 0, i32 14
  %305 = getelementptr inbounds %struct.conv_op, ptr %304, i32 0, i32 2
  %306 = load ptr, ptr %305, align 8, !tbaa !53
  %307 = load ptr, ptr %2, align 8, !tbaa !5
  %308 = getelementptr inbounds %struct.network, ptr %307, i32 0, i32 15
  %309 = getelementptr inbounds %struct.batch_norm_op, ptr %308, i32 0, i32 0
  store ptr %306, ptr %309, align 8, !tbaa !57
  %310 = load ptr, ptr %2, align 8, !tbaa !5
  %311 = getelementptr inbounds %struct.network, ptr %310, i32 0, i32 15
  call void @batch_norm_op_forward(ptr noundef %311)
  %312 = load ptr, ptr %2, align 8, !tbaa !5
  %313 = getelementptr inbounds %struct.network, ptr %312, i32 0, i32 2
  %314 = load i16, ptr %313, align 8, !tbaa !19
  %315 = sext i16 %314 to i64
  %316 = mul i64 %315, 4
  %317 = load ptr, ptr %2, align 8, !tbaa !5
  %318 = getelementptr inbounds %struct.network, ptr %317, i32 0, i32 16
  %319 = getelementptr inbounds %struct.nonlinear_op, ptr %318, i32 0, i32 4
  %320 = load i32, ptr %319, align 8, !tbaa !58
  %321 = sext i32 %320 to i64
  %322 = mul i64 %316, %321
  %323 = call noalias ptr @malloc(i64 noundef %322) #6
  %324 = load ptr, ptr %2, align 8, !tbaa !5
  %325 = getelementptr inbounds %struct.network, ptr %324, i32 0, i32 16
  %326 = getelementptr inbounds %struct.nonlinear_op, ptr %325, i32 0, i32 2
  store ptr %323, ptr %326, align 8, !tbaa !59
  %327 = load ptr, ptr %2, align 8, !tbaa !5
  %328 = getelementptr inbounds %struct.network, ptr %327, i32 0, i32 15
  %329 = getelementptr inbounds %struct.batch_norm_op, ptr %328, i32 0, i32 2
  %330 = load ptr, ptr %329, align 8, !tbaa !56
  %331 = load ptr, ptr %2, align 8, !tbaa !5
  %332 = getelementptr inbounds %struct.network, ptr %331, i32 0, i32 16
  %333 = getelementptr inbounds %struct.nonlinear_op, ptr %332, i32 0, i32 0
  store ptr %330, ptr %333, align 8, !tbaa !60
  %334 = load ptr, ptr %2, align 8, !tbaa !5
  %335 = getelementptr inbounds %struct.network, ptr %334, i32 0, i32 16
  call void @relu_op_forward(ptr noundef %335)
  %336 = load ptr, ptr %2, align 8, !tbaa !5
  %337 = getelementptr inbounds %struct.network, ptr %336, i32 0, i32 2
  %338 = load i16, ptr %337, align 8, !tbaa !19
  %339 = sext i16 %338 to i32
  %340 = load ptr, ptr %2, align 8, !tbaa !5
  %341 = getelementptr inbounds %struct.network, ptr %340, i32 0, i32 17
  %342 = getelementptr inbounds %struct.conv_op, ptr %341, i32 0, i32 19
  %343 = load i32, ptr %342, align 8, !tbaa !61
  %344 = mul nsw i32 %339, %343
  %345 = sext i32 %344 to i64
  %346 = call noalias ptr @calloc(i64 noundef %345, i64 noundef 4) #5
  %347 = load ptr, ptr %2, align 8, !tbaa !5
  %348 = getelementptr inbounds %struct.network, ptr %347, i32 0, i32 17
  %349 = getelementptr inbounds %struct.conv_op, ptr %348, i32 0, i32 2
  store ptr %346, ptr %349, align 8, !tbaa !62
  %350 = load ptr, ptr %2, align 8, !tbaa !5
  %351 = getelementptr inbounds %struct.network, ptr %350, i32 0, i32 16
  %352 = getelementptr inbounds %struct.nonlinear_op, ptr %351, i32 0, i32 2
  %353 = load ptr, ptr %352, align 8, !tbaa !59
  %354 = load ptr, ptr %2, align 8, !tbaa !5
  %355 = getelementptr inbounds %struct.network, ptr %354, i32 0, i32 17
  %356 = getelementptr inbounds %struct.conv_op, ptr %355, i32 0, i32 0
  store ptr %353, ptr %356, align 8, !tbaa !63
  %357 = load ptr, ptr %2, align 8, !tbaa !5
  %358 = getelementptr inbounds %struct.network, ptr %357, i32 0, i32 17
  call void @conv_op_forward(ptr noundef %358)
  %359 = load ptr, ptr %2, align 8, !tbaa !5
  %360 = getelementptr inbounds %struct.network, ptr %359, i32 0, i32 2
  %361 = load i16, ptr %360, align 8, !tbaa !19
  %362 = sext i16 %361 to i64
  %363 = mul i64 %362, 4
  %364 = load ptr, ptr %2, align 8, !tbaa !5
  %365 = getelementptr inbounds %struct.network, ptr %364, i32 0, i32 18
  %366 = getelementptr inbounds %struct.batch_norm_op, ptr %365, i32 0, i32 8
  %367 = load i32, ptr %366, align 8, !tbaa !64
  %368 = sext i32 %367 to i64
  %369 = mul i64 %363, %368
  %370 = call noalias ptr @malloc(i64 noundef %369) #6
  %371 = load ptr, ptr %2, align 8, !tbaa !5
  %372 = getelementptr inbounds %struct.network, ptr %371, i32 0, i32 18
  %373 = getelementptr inbounds %struct.batch_norm_op, ptr %372, i32 0, i32 2
  store ptr %370, ptr %373, align 8, !tbaa !65
  %374 = load ptr, ptr %2, align 8, !tbaa !5
  %375 = getelementptr inbounds %struct.network, ptr %374, i32 0, i32 17
  %376 = getelementptr inbounds %struct.conv_op, ptr %375, i32 0, i32 2
  %377 = load ptr, ptr %376, align 8, !tbaa !62
  %378 = load ptr, ptr %2, align 8, !tbaa !5
  %379 = getelementptr inbounds %struct.network, ptr %378, i32 0, i32 18
  %380 = getelementptr inbounds %struct.batch_norm_op, ptr %379, i32 0, i32 0
  store ptr %377, ptr %380, align 8, !tbaa !66
  %381 = load ptr, ptr %2, align 8, !tbaa !5
  %382 = getelementptr inbounds %struct.network, ptr %381, i32 0, i32 18
  call void @batch_norm_op_forward(ptr noundef %382)
  %383 = load ptr, ptr %2, align 8, !tbaa !5
  %384 = getelementptr inbounds %struct.network, ptr %383, i32 0, i32 2
  %385 = load i16, ptr %384, align 8, !tbaa !19
  %386 = sext i16 %385 to i64
  %387 = mul i64 %386, 4
  %388 = load ptr, ptr %2, align 8, !tbaa !5
  %389 = getelementptr inbounds %struct.network, ptr %388, i32 0, i32 19
  %390 = getelementptr inbounds %struct.nonlinear_op, ptr %389, i32 0, i32 4
  %391 = load i32, ptr %390, align 8, !tbaa !67
  %392 = sext i32 %391 to i64
  %393 = mul i64 %387, %392
  %394 = call noalias ptr @malloc(i64 noundef %393) #6
  %395 = load ptr, ptr %2, align 8, !tbaa !5
  %396 = getelementptr inbounds %struct.network, ptr %395, i32 0, i32 19
  %397 = getelementptr inbounds %struct.nonlinear_op, ptr %396, i32 0, i32 2
  store ptr %394, ptr %397, align 8, !tbaa !68
  %398 = load ptr, ptr %2, align 8, !tbaa !5
  %399 = getelementptr inbounds %struct.network, ptr %398, i32 0, i32 18
  %400 = getelementptr inbounds %struct.batch_norm_op, ptr %399, i32 0, i32 2
  %401 = load ptr, ptr %400, align 8, !tbaa !65
  %402 = load ptr, ptr %2, align 8, !tbaa !5
  %403 = getelementptr inbounds %struct.network, ptr %402, i32 0, i32 19
  %404 = getelementptr inbounds %struct.nonlinear_op, ptr %403, i32 0, i32 0
  store ptr %401, ptr %404, align 8, !tbaa !69
  %405 = load ptr, ptr %2, align 8, !tbaa !5
  %406 = getelementptr inbounds %struct.network, ptr %405, i32 0, i32 19
  call void @relu_op_forward(ptr noundef %406)
  %407 = load ptr, ptr %2, align 8, !tbaa !5
  %408 = getelementptr inbounds %struct.network, ptr %407, i32 0, i32 2
  %409 = load i16, ptr %408, align 8, !tbaa !19
  %410 = sext i16 %409 to i64
  %411 = mul i64 %410, 4
  %412 = load ptr, ptr %2, align 8, !tbaa !5
  %413 = getelementptr inbounds %struct.network, ptr %412, i32 0, i32 20
  %414 = getelementptr inbounds %struct.max_pooling_op, ptr %413, i32 0, i32 12
  %415 = load i32, ptr %414, align 8, !tbaa !70
  %416 = sext i32 %415 to i64
  %417 = mul i64 %411, %416
  %418 = call noalias ptr @malloc(i64 noundef %417) #6
  %419 = load ptr, ptr %2, align 8, !tbaa !5
  %420 = getelementptr inbounds %struct.network, ptr %419, i32 0, i32 20
  %421 = getelementptr inbounds %struct.max_pooling_op, ptr %420, i32 0, i32 2
  store ptr %418, ptr %421, align 8, !tbaa !71
  %422 = load ptr, ptr %2, align 8, !tbaa !5
  %423 = getelementptr inbounds %struct.network, ptr %422, i32 0, i32 19
  %424 = getelementptr inbounds %struct.nonlinear_op, ptr %423, i32 0, i32 2
  %425 = load ptr, ptr %424, align 8, !tbaa !68
  %426 = load ptr, ptr %2, align 8, !tbaa !5
  %427 = getelementptr inbounds %struct.network, ptr %426, i32 0, i32 20
  %428 = getelementptr inbounds %struct.max_pooling_op, ptr %427, i32 0, i32 0
  store ptr %425, ptr %428, align 8, !tbaa !72
  %429 = load ptr, ptr %2, align 8, !tbaa !5
  %430 = getelementptr inbounds %struct.network, ptr %429, i32 0, i32 20
  call void @max_pooling_op_forward(ptr noundef %430)
  %431 = load ptr, ptr %2, align 8, !tbaa !5
  %432 = getelementptr inbounds %struct.network, ptr %431, i32 0, i32 20
  %433 = getelementptr inbounds %struct.max_pooling_op, ptr %432, i32 0, i32 2
  %434 = load ptr, ptr %433, align 8, !tbaa !71
  %435 = load ptr, ptr %2, align 8, !tbaa !5
  %436 = getelementptr inbounds %struct.network, ptr %435, i32 0, i32 20
  %437 = getelementptr inbounds %struct.max_pooling_op, ptr %436, i32 0, i32 13
  %438 = load i16, ptr %437, align 4, !tbaa !73
  %439 = sext i16 %438 to i32
  %440 = load ptr, ptr %2, align 8, !tbaa !5
  %441 = getelementptr inbounds %struct.network, ptr %440, i32 0, i32 20
  %442 = getelementptr inbounds %struct.max_pooling_op, ptr %441, i32 0, i32 12
  %443 = load i32, ptr %442, align 8, !tbaa !70
  %444 = mul nsw i32 %439, %443
  call void @dropout(ptr noundef %434, float noundef 0x3FD99999A0000000, i32 noundef %444)
  %445 = load ptr, ptr %2, align 8, !tbaa !5
  %446 = getelementptr inbounds %struct.network, ptr %445, i32 0, i32 2
  %447 = load i16, ptr %446, align 8, !tbaa !19
  %448 = sext i16 %447 to i32
  %449 = load ptr, ptr %2, align 8, !tbaa !5
  %450 = getelementptr inbounds %struct.network, ptr %449, i32 0, i32 21
  %451 = getelementptr inbounds %struct.fc_op, ptr %450, i32 0, i32 9
  %452 = load i32, ptr %451, align 4, !tbaa !74
  %453 = mul nsw i32 %448, %452
  %454 = sext i32 %453 to i64
  %455 = call noalias ptr @calloc(i64 noundef %454, i64 noundef 4) #5
  %456 = load ptr, ptr %2, align 8, !tbaa !5
  %457 = getelementptr inbounds %struct.network, ptr %456, i32 0, i32 21
  %458 = getelementptr inbounds %struct.fc_op, ptr %457, i32 0, i32 2
  store ptr %455, ptr %458, align 8, !tbaa !75
  %459 = load ptr, ptr %2, align 8, !tbaa !5
  %460 = getelementptr inbounds %struct.network, ptr %459, i32 0, i32 20
  %461 = getelementptr inbounds %struct.max_pooling_op, ptr %460, i32 0, i32 2
  %462 = load ptr, ptr %461, align 8, !tbaa !71
  %463 = load ptr, ptr %2, align 8, !tbaa !5
  %464 = getelementptr inbounds %struct.network, ptr %463, i32 0, i32 21
  %465 = getelementptr inbounds %struct.fc_op, ptr %464, i32 0, i32 0
  store ptr %462, ptr %465, align 8, !tbaa !76
  %466 = load ptr, ptr %2, align 8, !tbaa !5
  %467 = getelementptr inbounds %struct.network, ptr %466, i32 0, i32 21
  call void @fc_op_forward(ptr noundef %467)
  %468 = load ptr, ptr %2, align 8, !tbaa !5
  %469 = getelementptr inbounds %struct.network, ptr %468, i32 0, i32 2
  %470 = load i16, ptr %469, align 8, !tbaa !19
  %471 = sext i16 %470 to i64
  %472 = mul i64 %471, 4
  %473 = load ptr, ptr %2, align 8, !tbaa !5
  %474 = getelementptr inbounds %struct.network, ptr %473, i32 0, i32 22
  %475 = getelementptr inbounds %struct.nonlinear_op, ptr %474, i32 0, i32 4
  %476 = load i32, ptr %475, align 8, !tbaa !77
  %477 = sext i32 %476 to i64
  %478 = mul i64 %472, %477
  %479 = call noalias ptr @malloc(i64 noundef %478) #6
  %480 = load ptr, ptr %2, align 8, !tbaa !5
  %481 = getelementptr inbounds %struct.network, ptr %480, i32 0, i32 22
  %482 = getelementptr inbounds %struct.nonlinear_op, ptr %481, i32 0, i32 2
  store ptr %479, ptr %482, align 8, !tbaa !78
  %483 = load ptr, ptr %2, align 8, !tbaa !5
  %484 = getelementptr inbounds %struct.network, ptr %483, i32 0, i32 21
  %485 = getelementptr inbounds %struct.fc_op, ptr %484, i32 0, i32 2
  %486 = load ptr, ptr %485, align 8, !tbaa !75
  %487 = load ptr, ptr %2, align 8, !tbaa !5
  %488 = getelementptr inbounds %struct.network, ptr %487, i32 0, i32 22
  %489 = getelementptr inbounds %struct.nonlinear_op, ptr %488, i32 0, i32 0
  store ptr %486, ptr %489, align 8, !tbaa !79
  %490 = load ptr, ptr %2, align 8, !tbaa !5
  %491 = getelementptr inbounds %struct.network, ptr %490, i32 0, i32 22
  call void @relu_op_forward(ptr noundef %491)
  %492 = load ptr, ptr %2, align 8, !tbaa !5
  %493 = getelementptr inbounds %struct.network, ptr %492, i32 0, i32 22
  %494 = getelementptr inbounds %struct.nonlinear_op, ptr %493, i32 0, i32 2
  %495 = load ptr, ptr %494, align 8, !tbaa !78
  %496 = load ptr, ptr %2, align 8, !tbaa !5
  %497 = getelementptr inbounds %struct.network, ptr %496, i32 0, i32 22
  %498 = getelementptr inbounds %struct.nonlinear_op, ptr %497, i32 0, i32 5
  %499 = load i16, ptr %498, align 4, !tbaa !80
  %500 = sext i16 %499 to i32
  %501 = load ptr, ptr %2, align 8, !tbaa !5
  %502 = getelementptr inbounds %struct.network, ptr %501, i32 0, i32 22
  %503 = getelementptr inbounds %struct.nonlinear_op, ptr %502, i32 0, i32 4
  %504 = load i32, ptr %503, align 8, !tbaa !77
  %505 = mul nsw i32 %500, %504
  call void @dropout(ptr noundef %495, float noundef 0x3FD99999A0000000, i32 noundef %505)
  %506 = load ptr, ptr %2, align 8, !tbaa !5
  %507 = getelementptr inbounds %struct.network, ptr %506, i32 0, i32 2
  %508 = load i16, ptr %507, align 8, !tbaa !19
  %509 = sext i16 %508 to i32
  %510 = load ptr, ptr %2, align 8, !tbaa !5
  %511 = getelementptr inbounds %struct.network, ptr %510, i32 0, i32 23
  %512 = getelementptr inbounds %struct.fc_op, ptr %511, i32 0, i32 9
  %513 = load i32, ptr %512, align 4, !tbaa !81
  %514 = mul nsw i32 %509, %513
  %515 = sext i32 %514 to i64
  %516 = call noalias ptr @calloc(i64 noundef %515, i64 noundef 4) #5
  %517 = load ptr, ptr %2, align 8, !tbaa !5
  %518 = getelementptr inbounds %struct.network, ptr %517, i32 0, i32 23
  %519 = getelementptr inbounds %struct.fc_op, ptr %518, i32 0, i32 2
  store ptr %516, ptr %519, align 8, !tbaa !82
  %520 = load ptr, ptr %2, align 8, !tbaa !5
  %521 = getelementptr inbounds %struct.network, ptr %520, i32 0, i32 21
  %522 = getelementptr inbounds %struct.fc_op, ptr %521, i32 0, i32 2
  %523 = load ptr, ptr %522, align 8, !tbaa !75
  %524 = load ptr, ptr %2, align 8, !tbaa !5
  %525 = getelementptr inbounds %struct.network, ptr %524, i32 0, i32 23
  %526 = getelementptr inbounds %struct.fc_op, ptr %525, i32 0, i32 0
  store ptr %523, ptr %526, align 8, !tbaa !83
  %527 = load ptr, ptr %2, align 8, !tbaa !5
  %528 = getelementptr inbounds %struct.network, ptr %527, i32 0, i32 23
  call void @fc_op_forward(ptr noundef %528)
  call void @llvm.lifetime.start.p0(i64 4, ptr %3) #7
  store i32 0, ptr %3, align 4, !tbaa !84
  br label %529

529:                                              ; preds = %577, %1
  %530 = load i32, ptr %3, align 4, !tbaa !84
  %531 = load ptr, ptr %2, align 8, !tbaa !5
  %532 = getelementptr inbounds %struct.network, ptr %531, i32 0, i32 23
  %533 = getelementptr inbounds %struct.fc_op, ptr %532, i32 0, i32 9
  %534 = load i32, ptr %533, align 4, !tbaa !81
  %535 = load ptr, ptr %2, align 8, !tbaa !5
  %536 = getelementptr inbounds %struct.network, ptr %535, i32 0, i32 2
  %537 = load i16, ptr %536, align 8, !tbaa !19
  %538 = sext i16 %537 to i32
  %539 = mul nsw i32 %534, %538
  %540 = icmp slt i32 %530, %539
  br i1 %540, label %542, label %541

541:                                              ; preds = %529
  store i32 2, ptr %4, align 4
  br label %580

542:                                              ; preds = %529
  %543 = load ptr, ptr %2, align 8, !tbaa !5
  %544 = getelementptr inbounds %struct.network, ptr %543, i32 0, i32 23
  %545 = getelementptr inbounds %struct.fc_op, ptr %544, i32 0, i32 2
  %546 = load ptr, ptr %545, align 8, !tbaa !82
  %547 = load i32, ptr %3, align 4, !tbaa !84
  %548 = sext i32 %547 to i64
  %549 = getelementptr inbounds float, ptr %546, i64 %548
  %550 = load float, ptr %549, align 4, !tbaa !85
  %551 = fcmp olt float %550, -6.400000e+01
  %552 = zext i1 %551 to i32
  %553 = load ptr, ptr %2, align 8, !tbaa !5
  %554 = getelementptr inbounds %struct.network, ptr %553, i32 0, i32 23
  %555 = getelementptr inbounds %struct.fc_op, ptr %554, i32 0, i32 2
  %556 = load ptr, ptr %555, align 8, !tbaa !82
  %557 = load i32, ptr %3, align 4, !tbaa !84
  %558 = sext i32 %557 to i64
  %559 = getelementptr inbounds float, ptr %556, i64 %558
  %560 = load float, ptr %559, align 4, !tbaa !85
  %561 = fcmp ogt float %560, 6.400000e+01
  %562 = zext i1 %561 to i32
  %563 = or i32 %552, %562
  %564 = icmp ne i32 %563, 0
  br i1 %564, label %565, label %576

565:                                              ; preds = %542
  %566 = load ptr, ptr %2, align 8, !tbaa !5
  %567 = getelementptr inbounds %struct.network, ptr %566, i32 0, i32 23
  %568 = getelementptr inbounds %struct.fc_op, ptr %567, i32 0, i32 2
  %569 = load ptr, ptr %568, align 8, !tbaa !82
  %570 = load i32, ptr %3, align 4, !tbaa !84
  %571 = sext i32 %570 to i64
  %572 = getelementptr inbounds float, ptr %569, i64 %571
  %573 = load float, ptr %572, align 4, !tbaa !85
  %574 = fpext float %573 to double
  %575 = call i32 (ptr, ...) @printf(ptr noundef @.str.2, double noundef %574)
  store i32 2, ptr %4, align 4
  br label %580

576:                                              ; preds = %542
  br label %577

577:                                              ; preds = %576
  %578 = load i32, ptr %3, align 4, !tbaa !84
  %579 = add nsw i32 %578, 1
  store i32 %579, ptr %3, align 4, !tbaa !84
  br label %529, !llvm.loop !87

580:                                              ; preds = %565, %541
  call void @llvm.lifetime.end.p0(i64 4, ptr %3) #7
  br label %581

581:                                              ; preds = %580
  %582 = load ptr, ptr %2, align 8, !tbaa !5
  %583 = getelementptr inbounds %struct.network, ptr %582, i32 0, i32 2
  %584 = load i16, ptr %583, align 8, !tbaa !19
  %585 = sext i16 %584 to i64
  %586 = mul i64 %585, 4
  %587 = load ptr, ptr %2, align 8, !tbaa !5
  %588 = getelementptr inbounds %struct.network, ptr %587, i32 0, i32 24
  %589 = getelementptr inbounds %struct.nonlinear_op, ptr %588, i32 0, i32 4
  %590 = load i32, ptr %589, align 8, !tbaa !89
  %591 = sext i32 %590 to i64
  %592 = mul i64 %586, %591
  %593 = call noalias ptr @malloc(i64 noundef %592) #6
  %594 = load ptr, ptr %2, align 8, !tbaa !5
  %595 = getelementptr inbounds %struct.network, ptr %594, i32 0, i32 24
  %596 = getelementptr inbounds %struct.nonlinear_op, ptr %595, i32 0, i32 2
  store ptr %593, ptr %596, align 8, !tbaa !90
  %597 = load ptr, ptr %2, align 8, !tbaa !5
  %598 = getelementptr inbounds %struct.network, ptr %597, i32 0, i32 23
  %599 = getelementptr inbounds %struct.fc_op, ptr %598, i32 0, i32 2
  %600 = load ptr, ptr %599, align 8, !tbaa !82
  %601 = load ptr, ptr %2, align 8, !tbaa !5
  %602 = getelementptr inbounds %struct.network, ptr %601, i32 0, i32 24
  %603 = getelementptr inbounds %struct.nonlinear_op, ptr %602, i32 0, i32 0
  store ptr %600, ptr %603, align 8, !tbaa !91
  %604 = load ptr, ptr %2, align 8, !tbaa !5
  %605 = getelementptr inbounds %struct.network, ptr %604, i32 0, i32 24
  call void @relu_op_forward(ptr noundef %605)
  %606 = load ptr, ptr %2, align 8, !tbaa !5
  %607 = getelementptr inbounds %struct.network, ptr %606, i32 0, i32 2
  %608 = load i16, ptr %607, align 8, !tbaa !19
  %609 = sext i16 %608 to i32
  %610 = load ptr, ptr %2, align 8, !tbaa !5
  %611 = getelementptr inbounds %struct.network, ptr %610, i32 0, i32 25
  %612 = getelementptr inbounds %struct.fc_op, ptr %611, i32 0, i32 9
  %613 = load i32, ptr %612, align 4, !tbaa !92
  %614 = mul nsw i32 %609, %613
  %615 = sext i32 %614 to i64
  %616 = call noalias ptr @calloc(i64 noundef %615, i64 noundef 4) #5
  %617 = load ptr, ptr %2, align 8, !tbaa !5
  %618 = getelementptr inbounds %struct.network, ptr %617, i32 0, i32 25
  %619 = getelementptr inbounds %struct.fc_op, ptr %618, i32 0, i32 2
  store ptr %616, ptr %619, align 8, !tbaa !93
  %620 = load ptr, ptr %2, align 8, !tbaa !5
  %621 = getelementptr inbounds %struct.network, ptr %620, i32 0, i32 23
  %622 = getelementptr inbounds %struct.fc_op, ptr %621, i32 0, i32 2
  %623 = load ptr, ptr %622, align 8, !tbaa !82
  %624 = load ptr, ptr %2, align 8, !tbaa !5
  %625 = getelementptr inbounds %struct.network, ptr %624, i32 0, i32 25
  %626 = getelementptr inbounds %struct.fc_op, ptr %625, i32 0, i32 0
  store ptr %623, ptr %626, align 8, !tbaa !94
  %627 = load ptr, ptr %2, align 8, !tbaa !5
  %628 = getelementptr inbounds %struct.network, ptr %627, i32 0, i32 25
  call void @fc_op_forward(ptr noundef %628)
  %629 = load ptr, ptr %2, align 8, !tbaa !5
  %630 = getelementptr inbounds %struct.network, ptr %629, i32 0, i32 25
  %631 = getelementptr inbounds %struct.fc_op, ptr %630, i32 0, i32 2
  %632 = load ptr, ptr %631, align 8, !tbaa !93
  %633 = load ptr, ptr %2, align 8, !tbaa !5
  %634 = getelementptr inbounds %struct.network, ptr %633, i32 0, i32 1
  store ptr %632, ptr %634, align 8, !tbaa !95
  ret void
}

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

declare void @conv_op_forward(ptr noundef) #4

declare void @batch_norm_op_forward(ptr noundef) #4

declare void @relu_op_forward(ptr noundef) #4

declare void @max_pooling_op_forward(ptr noundef) #4

declare void @dropout(ptr noundef, float noundef, i32 noundef) #4

declare void @fc_op_forward(ptr noundef) #4

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

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

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

!0 = !{i32 1, !"wchar_size", i32 4}
!1 = !{i32 8, !"PIC Level", i32 2}
!2 = !{i32 7, !"PIE Level", i32 2}
!3 = !{i32 7, !"uwtable", i32 2}
!4 = !{!"clang version 19.1.0 (git@github.com:llvm/llvm-project.git a4bf6cd7cfb1a1421ba92bca9d017b49936c55e4)"}
!5 = !{!6, !6, i64 0}
!6 = !{!"any pointer", !7, i64 0}
!7 = !{!"omnipotent char", !8, i64 0}
!8 = !{!"Simple C/C++ TBAA"}
!9 = !{!10, !6, i64 0}
!10 = !{!"network", !6, i64 0, !6, i64 8, !11, i64 16, !12, i64 24, !14, i64 144, !15, i64 240, !16, i64 280, !12, i64 352, !14, i64 472, !15, i64 568, !16, i64 608, !12, i64 680, !14, i64 800, !15, i64 896, !12, i64 936, !14, i64 1056, !15, i64 1152, !12, i64 1192, !14, i64 1312, !15, i64 1408, !16, i64 1448, !17, i64 1520, !15, i64 1600, !17, i64 1640, !15, i64 1720, !17, i64 1760}
!11 = !{!"short", !7, i64 0}
!12 = !{!"conv_op", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !6, i64 48, !6, i64 56, !6, i64 64, !13, i64 72, !13, i64 76, !13, i64 80, !13, i64 84, !13, i64 88, !13, i64 92, !13, i64 96, !13, i64 100, !13, i64 104, !13, i64 108, !13, i64 112, !11, i64 116}
!13 = !{!"int", !7, i64 0}
!14 = !{!"batch_norm_op", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !6, i64 48, !6, i64 56, !13, i64 64, !11, i64 68, !6, i64 72, !6, i64 80, !6, i64 88}
!15 = !{!"nonlinear_op", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !13, i64 32, !11, i64 36}
!16 = !{!"max_pooling_op", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !13, i64 32, !13, i64 36, !13, i64 40, !13, i64 44, !13, i64 48, !13, i64 52, !13, i64 56, !13, i64 60, !13, i64 64, !11, i64 68}
!17 = !{!"fc_op", !6, i64 0, !6, i64 8, !6, i64 16, !6, i64 24, !6, i64 32, !6, i64 40, !6, i64 48, !6, i64 56, !13, i64 64, !13, i64 68, !11, i64 72}
!18 = !{!10, !6, i64 24}
!19 = !{!10, !11, i64 16}
!20 = !{!10, !13, i64 136}
!21 = !{!10, !6, i64 40}
!22 = !{!10, !13, i64 208}
!23 = !{!10, !6, i64 160}
!24 = !{!10, !6, i64 144}
!25 = !{!10, !13, i64 272}
!26 = !{!10, !6, i64 256}
!27 = !{!10, !6, i64 240}
!28 = !{!10, !13, i64 344}
!29 = !{!10, !6, i64 296}
!30 = !{!10, !6, i64 280}
!31 = !{!10, !13, i64 464}
!32 = !{!10, !6, i64 368}
!33 = !{!10, !6, i64 352}
!34 = !{!10, !13, i64 536}
!35 = !{!10, !6, i64 488}
!36 = !{!10, !6, i64 472}
!37 = !{!10, !13, i64 600}
!38 = !{!10, !6, i64 584}
!39 = !{!10, !6, i64 568}
!40 = !{!10, !13, i64 672}
!41 = !{!10, !6, i64 624}
!42 = !{!10, !6, i64 608}
!43 = !{!10, !13, i64 792}
!44 = !{!10, !6, i64 696}
!45 = !{!10, !6, i64 680}
!46 = !{!10, !13, i64 864}
!47 = !{!10, !6, i64 816}
!48 = !{!10, !6, i64 800}
!49 = !{!10, !13, i64 928}
!50 = !{!10, !6, i64 912}
!51 = !{!10, !6, i64 896}
!52 = !{!10, !13, i64 1048}
!53 = !{!10, !6, i64 952}
!54 = !{!10, !6, i64 936}
!55 = !{!10, !13, i64 1120}
!56 = !{!10, !6, i64 1072}
!57 = !{!10, !6, i64 1056}
!58 = !{!10, !13, i64 1184}
!59 = !{!10, !6, i64 1168}
!60 = !{!10, !6, i64 1152}
!61 = !{!10, !13, i64 1304}
!62 = !{!10, !6, i64 1208}
!63 = !{!10, !6, i64 1192}
!64 = !{!10, !13, i64 1376}
!65 = !{!10, !6, i64 1328}
!66 = !{!10, !6, i64 1312}
!67 = !{!10, !13, i64 1440}
!68 = !{!10, !6, i64 1424}
!69 = !{!10, !6, i64 1408}
!70 = !{!10, !13, i64 1512}
!71 = !{!10, !6, i64 1464}
!72 = !{!10, !6, i64 1448}
!73 = !{!10, !11, i64 1516}
!74 = !{!10, !13, i64 1588}
!75 = !{!10, !6, i64 1536}
!76 = !{!10, !6, i64 1520}
!77 = !{!10, !13, i64 1632}
!78 = !{!10, !6, i64 1616}
!79 = !{!10, !6, i64 1600}
!80 = !{!10, !11, i64 1636}
!81 = !{!10, !13, i64 1708}
!82 = !{!10, !6, i64 1656}
!83 = !{!10, !6, i64 1640}
!84 = !{!13, !13, i64 0}
!85 = !{!86, !86, i64 0}
!86 = !{!"float", !7, i64 0}
!87 = distinct !{!87, !88}
!88 = !{!"llvm.loop.mustprogress"}
!89 = !{!10, !13, i64 1752}
!90 = !{!10, !6, i64 1736}
!91 = !{!10, !6, i64 1720}
!92 = !{!10, !13, i64 1828}
!93 = !{!10, !6, i64 1776}
!94 = !{!10, !6, i64 1760}
!95 = !{!10, !6, i64 8}


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

@.str.2 = external hidden unnamed_addr constant [64 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 void @forward_alexnet(ptr noundef %0) local_unnamed_addr #1 {
  %2 = load ptr, ptr %0, align 8, !tbaa !5
  %3 = getelementptr inbounds i8, ptr %0, i64 24
  store ptr %2, ptr %3, align 8, !tbaa !17
  %4 = getelementptr inbounds i8, ptr %0, i64 16
  %5 = load i16, ptr %4, align 8, !tbaa !18
  %6 = sext i16 %5 to i32
  %7 = getelementptr inbounds i8, ptr %0, i64 136
  %8 = load i32, ptr %7, align 8, !tbaa !19
  %9 = mul nsw i32 %8, %6
  %10 = sext i32 %9 to i64
  %11 = tail call noalias ptr @calloc(i64 noundef %10, i64 noundef 4) #6
  %12 = getelementptr inbounds i8, ptr %0, i64 40
  store ptr %11, ptr %12, align 8, !tbaa !20
  tail call void @conv_op_forward(ptr noundef nonnull %3) #7
  %13 = load i16, ptr %4, align 8, !tbaa !18
  %14 = sext i16 %13 to i64
  %15 = shl nsw i64 %14, 2
  %16 = getelementptr inbounds i8, ptr %0, i64 144
  %17 = getelementptr inbounds i8, ptr %0, i64 208
  %18 = load i32, ptr %17, align 8, !tbaa !21
  %19 = sext i32 %18 to i64
  %20 = mul nsw i64 %15, %19
  %21 = tail call noalias ptr @malloc(i64 noundef %20) #8
  %22 = getelementptr inbounds i8, ptr %0, i64 160
  store ptr %21, ptr %22, align 8, !tbaa !22
  %23 = load ptr, ptr %12, align 8, !tbaa !20
  store ptr %23, ptr %16, align 8, !tbaa !23
  tail call void @batch_norm_op_forward(ptr noundef nonnull %16) #7
  %24 = load i16, ptr %4, align 8, !tbaa !18
  %25 = sext i16 %24 to i64
  %26 = shl nsw i64 %25, 2
  %27 = getelementptr inbounds i8, ptr %0, i64 240
  %28 = getelementptr inbounds i8, ptr %0, i64 272
  %29 = load i32, ptr %28, align 8, !tbaa !24
  %30 = sext i32 %29 to i64
  %31 = mul nsw i64 %26, %30
  %32 = tail call noalias ptr @malloc(i64 noundef %31) #8
  %33 = getelementptr inbounds i8, ptr %0, i64 256
  store ptr %32, ptr %33, align 8, !tbaa !25
  %34 = load ptr, ptr %22, align 8, !tbaa !22
  store ptr %34, ptr %27, align 8, !tbaa !26
  tail call void @relu_op_forward(ptr noundef nonnull %27) #7
  %35 = load i16, ptr %4, align 8, !tbaa !18
  %36 = sext i16 %35 to i64
  %37 = shl nsw i64 %36, 2
  %38 = getelementptr inbounds i8, ptr %0, i64 280
  %39 = getelementptr inbounds i8, ptr %0, i64 344
  %40 = load i32, ptr %39, align 8, !tbaa !27
  %41 = sext i32 %40 to i64
  %42 = mul nsw i64 %37, %41
  %43 = tail call noalias ptr @malloc(i64 noundef %42) #8
  %44 = getelementptr inbounds i8, ptr %0, i64 296
  store ptr %43, ptr %44, align 8, !tbaa !28
  %45 = load ptr, ptr %33, align 8, !tbaa !25
  store ptr %45, ptr %38, align 8, !tbaa !29
  tail call void @max_pooling_op_forward(ptr noundef nonnull %38) #7
  %46 = load i16, ptr %4, align 8, !tbaa !18
  %47 = sext i16 %46 to i32
  %48 = getelementptr inbounds i8, ptr %0, i64 352
  %49 = getelementptr inbounds i8, ptr %0, i64 464
  %50 = load i32, ptr %49, align 8, !tbaa !30
  %51 = mul nsw i32 %50, %47
  %52 = sext i32 %51 to i64
  %53 = tail call noalias ptr @calloc(i64 noundef %52, i64 noundef 4) #6
  %54 = getelementptr inbounds i8, ptr %0, i64 368
  store ptr %53, ptr %54, align 8, !tbaa !31
  %55 = load ptr, ptr %44, align 8, !tbaa !28
  store ptr %55, ptr %48, align 8, !tbaa !32
  tail call void @conv_op_forward(ptr noundef nonnull %48) #7
  %56 = load i16, ptr %4, align 8, !tbaa !18
  %57 = sext i16 %56 to i64
  %58 = shl nsw i64 %57, 2
  %59 = getelementptr inbounds i8, ptr %0, i64 472
  %60 = getelementptr inbounds i8, ptr %0, i64 536
  %61 = load i32, ptr %60, align 8, !tbaa !33
  %62 = sext i32 %61 to i64
  %63 = mul nsw i64 %58, %62
  %64 = tail call noalias ptr @malloc(i64 noundef %63) #8
  %65 = getelementptr inbounds i8, ptr %0, i64 488
  store ptr %64, ptr %65, align 8, !tbaa !34
  %66 = load ptr, ptr %54, align 8, !tbaa !31
  store ptr %66, ptr %59, align 8, !tbaa !35
  tail call void @batch_norm_op_forward(ptr noundef nonnull %59) #7
  %67 = load i16, ptr %4, align 8, !tbaa !18
  %68 = sext i16 %67 to i64
  %69 = shl nsw i64 %68, 2
  %70 = getelementptr inbounds i8, ptr %0, i64 568
  %71 = getelementptr inbounds i8, ptr %0, i64 600
  %72 = load i32, ptr %71, align 8, !tbaa !36
  %73 = sext i32 %72 to i64
  %74 = mul nsw i64 %69, %73
  %75 = tail call noalias ptr @malloc(i64 noundef %74) #8
  %76 = getelementptr inbounds i8, ptr %0, i64 584
  store ptr %75, ptr %76, align 8, !tbaa !37
  %77 = load ptr, ptr %65, align 8, !tbaa !34
  store ptr %77, ptr %70, align 8, !tbaa !38
  tail call void @relu_op_forward(ptr noundef nonnull %70) #7
  %78 = load i16, ptr %4, align 8, !tbaa !18
  %79 = sext i16 %78 to i64
  %80 = shl nsw i64 %79, 2
  %81 = getelementptr inbounds i8, ptr %0, i64 608
  %82 = getelementptr inbounds i8, ptr %0, i64 672
  %83 = load i32, ptr %82, align 8, !tbaa !39
  %84 = sext i32 %83 to i64
  %85 = mul nsw i64 %80, %84
  %86 = tail call noalias ptr @malloc(i64 noundef %85) #8
  %87 = getelementptr inbounds i8, ptr %0, i64 624
  store ptr %86, ptr %87, align 8, !tbaa !40
  %88 = load ptr, ptr %76, align 8, !tbaa !37
  store ptr %88, ptr %81, align 8, !tbaa !41
  tail call void @max_pooling_op_forward(ptr noundef nonnull %81) #7
  %89 = load i16, ptr %4, align 8, !tbaa !18
  %90 = sext i16 %89 to i32
  %91 = getelementptr inbounds i8, ptr %0, i64 680
  %92 = getelementptr inbounds i8, ptr %0, i64 792
  %93 = load i32, ptr %92, align 8, !tbaa !42
  %94 = mul nsw i32 %93, %90
  %95 = sext i32 %94 to i64
  %96 = tail call noalias ptr @calloc(i64 noundef %95, i64 noundef 4) #6
  %97 = getelementptr inbounds i8, ptr %0, i64 696
  store ptr %96, ptr %97, align 8, !tbaa !43
  %98 = load ptr, ptr %87, align 8, !tbaa !40
  store ptr %98, ptr %91, align 8, !tbaa !44
  tail call void @conv_op_forward(ptr noundef nonnull %91) #7
  %99 = load i16, ptr %4, align 8, !tbaa !18
  %100 = sext i16 %99 to i64
  %101 = shl nsw i64 %100, 2
  %102 = getelementptr inbounds i8, ptr %0, i64 800
  %103 = getelementptr inbounds i8, ptr %0, i64 864
  %104 = load i32, ptr %103, align 8, !tbaa !45
  %105 = sext i32 %104 to i64
  %106 = mul nsw i64 %101, %105
  %107 = tail call noalias ptr @malloc(i64 noundef %106) #8
  %108 = getelementptr inbounds i8, ptr %0, i64 816
  store ptr %107, ptr %108, align 8, !tbaa !46
  %109 = load ptr, ptr %97, align 8, !tbaa !43
  store ptr %109, ptr %102, align 8, !tbaa !47
  tail call void @batch_norm_op_forward(ptr noundef nonnull %102) #7
  %110 = load i16, ptr %4, align 8, !tbaa !18
  %111 = sext i16 %110 to i64
  %112 = shl nsw i64 %111, 2
  %113 = getelementptr inbounds i8, ptr %0, i64 896
  %114 = getelementptr inbounds i8, ptr %0, i64 928
  %115 = load i32, ptr %114, align 8, !tbaa !48
  %116 = sext i32 %115 to i64
  %117 = mul nsw i64 %112, %116
  %118 = tail call noalias ptr @malloc(i64 noundef %117) #8
  %119 = getelementptr inbounds i8, ptr %0, i64 912
  store ptr %118, ptr %119, align 8, !tbaa !49
  %120 = load ptr, ptr %108, align 8, !tbaa !46
  store ptr %120, ptr %113, align 8, !tbaa !50
  tail call void @relu_op_forward(ptr noundef nonnull %113) #7
  %121 = load i16, ptr %4, align 8, !tbaa !18
  %122 = sext i16 %121 to i32
  %123 = getelementptr inbounds i8, ptr %0, i64 936
  %124 = getelementptr inbounds i8, ptr %0, i64 1048
  %125 = load i32, ptr %124, align 8, !tbaa !51
  %126 = mul nsw i32 %125, %122
  %127 = sext i32 %126 to i64
  %128 = tail call noalias ptr @calloc(i64 noundef %127, i64 noundef 4) #6
  %129 = getelementptr inbounds i8, ptr %0, i64 952
  store ptr %128, ptr %129, align 8, !tbaa !52
  %130 = load ptr, ptr %119, align 8, !tbaa !49
  store ptr %130, ptr %123, align 8, !tbaa !53
  tail call void @conv_op_forward(ptr noundef nonnull %123) #7
  %131 = load i16, ptr %4, align 8, !tbaa !18
  %132 = sext i16 %131 to i64
  %133 = shl nsw i64 %132, 2
  %134 = getelementptr inbounds i8, ptr %0, i64 1056
  %135 = getelementptr inbounds i8, ptr %0, i64 1120
  %136 = load i32, ptr %135, align 8, !tbaa !54
  %137 = sext i32 %136 to i64
  %138 = mul nsw i64 %133, %137
  %139 = tail call noalias ptr @malloc(i64 noundef %138) #8
  %140 = getelementptr inbounds i8, ptr %0, i64 1072
  store ptr %139, ptr %140, align 8, !tbaa !55
  %141 = load ptr, ptr %129, align 8, !tbaa !52
  store ptr %141, ptr %134, align 8, !tbaa !56
  tail call void @batch_norm_op_forward(ptr noundef nonnull %134) #7
  %142 = load i16, ptr %4, align 8, !tbaa !18
  %143 = sext i16 %142 to i64
  %144 = shl nsw i64 %143, 2
  %145 = getelementptr inbounds i8, ptr %0, i64 1152
  %146 = getelementptr inbounds i8, ptr %0, i64 1184
  %147 = load i32, ptr %146, align 8, !tbaa !57
  %148 = sext i32 %147 to i64
  %149 = mul nsw i64 %144, %148
  %150 = tail call noalias ptr @malloc(i64 noundef %149) #8
  %151 = getelementptr inbounds i8, ptr %0, i64 1168
  store ptr %150, ptr %151, align 8, !tbaa !58
  %152 = load ptr, ptr %140, align 8, !tbaa !55
  store ptr %152, ptr %145, align 8, !tbaa !59
  tail call void @relu_op_forward(ptr noundef nonnull %145) #7
  %153 = load i16, ptr %4, align 8, !tbaa !18
  %154 = sext i16 %153 to i32
  %155 = getelementptr inbounds i8, ptr %0, i64 1192
  %156 = getelementptr inbounds i8, ptr %0, i64 1304
  %157 = load i32, ptr %156, align 8, !tbaa !60
  %158 = mul nsw i32 %157, %154
  %159 = sext i32 %158 to i64
  %160 = tail call noalias ptr @calloc(i64 noundef %159, i64 noundef 4) #6
  %161 = getelementptr inbounds i8, ptr %0, i64 1208
  store ptr %160, ptr %161, align 8, !tbaa !61
  %162 = load ptr, ptr %151, align 8, !tbaa !58
  store ptr %162, ptr %155, align 8, !tbaa !62
  tail call void @conv_op_forward(ptr noundef nonnull %155) #7
  %163 = load i16, ptr %4, align 8, !tbaa !18
  %164 = sext i16 %163 to i64
  %165 = shl nsw i64 %164, 2
  %166 = getelementptr inbounds i8, ptr %0, i64 1312
  %167 = getelementptr inbounds i8, ptr %0, i64 1376
  %168 = load i32, ptr %167, align 8, !tbaa !63
  %169 = sext i32 %168 to i64
  %170 = mul nsw i64 %165, %169
  %171 = tail call noalias ptr @malloc(i64 noundef %170) #8
  %172 = getelementptr inbounds i8, ptr %0, i64 1328
  store ptr %171, ptr %172, align 8, !tbaa !64
  %173 = load ptr, ptr %161, align 8, !tbaa !61
  store ptr %173, ptr %166, align 8, !tbaa !65
  tail call void @batch_norm_op_forward(ptr noundef nonnull %166) #7
  %174 = load i16, ptr %4, align 8, !tbaa !18
  %175 = sext i16 %174 to i64
  %176 = shl nsw i64 %175, 2
  %177 = getelementptr inbounds i8, ptr %0, i64 1408
  %178 = getelementptr inbounds i8, ptr %0, i64 1440
  %179 = load i32, ptr %178, align 8, !tbaa !66
  %180 = sext i32 %179 to i64
  %181 = mul nsw i64 %176, %180
  %182 = tail call noalias ptr @malloc(i64 noundef %181) #8
  %183 = getelementptr inbounds i8, ptr %0, i64 1424
  store ptr %182, ptr %183, align 8, !tbaa !67
  %184 = load ptr, ptr %172, align 8, !tbaa !64
  store ptr %184, ptr %177, align 8, !tbaa !68
  tail call void @relu_op_forward(ptr noundef nonnull %177) #7
  %185 = load i16, ptr %4, align 8, !tbaa !18
  %186 = sext i16 %185 to i64
  %187 = shl nsw i64 %186, 2
  %188 = getelementptr inbounds i8, ptr %0, i64 1448
  %189 = getelementptr inbounds i8, ptr %0, i64 1512
  %190 = load i32, ptr %189, align 8, !tbaa !69
  %191 = sext i32 %190 to i64
  %192 = mul nsw i64 %187, %191
  %193 = tail call noalias ptr @malloc(i64 noundef %192) #8
  %194 = getelementptr inbounds i8, ptr %0, i64 1464
  store ptr %193, ptr %194, align 8, !tbaa !70
  %195 = load ptr, ptr %183, align 8, !tbaa !67
  store ptr %195, ptr %188, align 8, !tbaa !71
  tail call void @max_pooling_op_forward(ptr noundef nonnull %188) #7
  %196 = load ptr, ptr %194, align 8, !tbaa !70
  %197 = getelementptr inbounds i8, ptr %0, i64 1516
  %198 = load i16, ptr %197, align 4, !tbaa !72
  %199 = sext i16 %198 to i32
  %200 = load i32, ptr %189, align 8, !tbaa !69
  %201 = mul nsw i32 %200, %199
  tail call void @dropout(ptr noundef %196, float noundef 0x3FD99999A0000000, i32 noundef %201) #7
  %202 = load i16, ptr %4, align 8, !tbaa !18
  %203 = sext i16 %202 to i32
  %204 = getelementptr inbounds i8, ptr %0, i64 1520
  %205 = getelementptr inbounds i8, ptr %0, i64 1588
  %206 = load i32, ptr %205, align 4, !tbaa !73
  %207 = mul nsw i32 %206, %203
  %208 = sext i32 %207 to i64
  %209 = tail call noalias ptr @calloc(i64 noundef %208, i64 noundef 4) #6
  %210 = getelementptr inbounds i8, ptr %0, i64 1536
  store ptr %209, ptr %210, align 8, !tbaa !74
  %211 = load ptr, ptr %194, align 8, !tbaa !70
  store ptr %211, ptr %204, align 8, !tbaa !75
  tail call void @fc_op_forward(ptr noundef nonnull %204) #7
  %212 = load i16, ptr %4, align 8, !tbaa !18
  %213 = sext i16 %212 to i64
  %214 = shl nsw i64 %213, 2
  %215 = getelementptr inbounds i8, ptr %0, i64 1600
  %216 = getelementptr inbounds i8, ptr %0, i64 1632
  %217 = load i32, ptr %216, align 8, !tbaa !76
  %218 = sext i32 %217 to i64
  %219 = mul nsw i64 %214, %218
  %220 = tail call noalias ptr @malloc(i64 noundef %219) #8
  %221 = getelementptr inbounds i8, ptr %0, i64 1616
  store ptr %220, ptr %221, align 8, !tbaa !77
  %222 = load ptr, ptr %210, align 8, !tbaa !74
  store ptr %222, ptr %215, align 8, !tbaa !78
  tail call void @relu_op_forward(ptr noundef nonnull %215) #7
  %223 = load ptr, ptr %221, align 8, !tbaa !77
  %224 = getelementptr inbounds i8, ptr %0, i64 1636
  %225 = load i16, ptr %224, align 4, !tbaa !79
  %226 = sext i16 %225 to i32
  %227 = load i32, ptr %216, align 8, !tbaa !76
  %228 = mul nsw i32 %227, %226
  tail call void @dropout(ptr noundef %223, float noundef 0x3FD99999A0000000, i32 noundef %228) #7
  %229 = load i16, ptr %4, align 8, !tbaa !18
  %230 = sext i16 %229 to i32
  %231 = getelementptr inbounds i8, ptr %0, i64 1640
  %232 = getelementptr inbounds i8, ptr %0, i64 1708
  %233 = load i32, ptr %232, align 4, !tbaa !80
  %234 = mul nsw i32 %233, %230
  %235 = sext i32 %234 to i64
  %236 = tail call noalias ptr @calloc(i64 noundef %235, i64 noundef 4) #6
  %237 = getelementptr inbounds i8, ptr %0, i64 1656
  store ptr %236, ptr %237, align 8, !tbaa !81
  %238 = load ptr, ptr %210, align 8, !tbaa !74
  store ptr %238, ptr %231, align 8, !tbaa !82
  tail call void @fc_op_forward(ptr noundef nonnull %231) #7
  %239 = load i32, ptr %232, align 4, !tbaa !80
  %240 = load i16, ptr %4, align 8, !tbaa !18
  %241 = sext i16 %240 to i32
  %242 = mul nsw i32 %239, %241
  %243 = icmp sgt i32 %242, 0
  %.pre159 = load ptr, ptr %237, align 8, !tbaa !81
  br i1 %243, label %.lr.ph, label %.loopexit

.lr.ph:                                           ; preds = %1
  %wide.trip.count = zext nneg i32 %242 to i64
  br label %245

244:                                              ; preds = %245
  %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
  %exitcond.not = icmp eq i64 %indvars.iv.next, %wide.trip.count
  br i1 %exitcond.not, label %.loopexit, label %245, !llvm.loop !83

245:                                              ; preds = %.lr.ph, %244
  %indvars.iv = phi i64 [ 0, %.lr.ph ], [ %indvars.iv.next, %244 ]
  %246 = getelementptr inbounds float, ptr %.pre159, i64 %indvars.iv
  %247 = load float, ptr %246, align 4, !tbaa !85
  %248 = tail call float @llvm.fabs.f32(float %247)
  %249 = fcmp ogt float %248, 6.400000e+01
  br i1 %249, label %250, label %244

250:                                              ; preds = %245
  %251 = fpext float %247 to double
  %252 = tail call i32 (ptr, ...) @printf(ptr noundef nonnull dereferenceable(1) @.str.2, double noundef %251)
  %.pre = load i16, ptr %4, align 8, !tbaa !18
  %.pre158 = load ptr, ptr %237, align 8, !tbaa !81
  br label %.loopexit

.loopexit:                                        ; preds = %244, %1, %250
  %253 = phi ptr [ %.pre159, %1 ], [ %.pre158, %250 ], [ %.pre159, %244 ]
  %254 = phi i16 [ %240, %1 ], [ %.pre, %250 ], [ %240, %244 ]
  %255 = sext i16 %254 to i64
  %256 = shl nsw i64 %255, 2
  %257 = getelementptr inbounds i8, ptr %0, i64 1720
  %258 = getelementptr inbounds i8, ptr %0, i64 1752
  %259 = load i32, ptr %258, align 8, !tbaa !87
  %260 = sext i32 %259 to i64
  %261 = mul nsw i64 %256, %260
  %262 = tail call noalias ptr @malloc(i64 noundef %261) #8
  %263 = getelementptr inbounds i8, ptr %0, i64 1736
  store ptr %262, ptr %263, align 8, !tbaa !88
  store ptr %253, ptr %257, align 8, !tbaa !89
  tail call void @relu_op_forward(ptr noundef nonnull %257) #7
  %264 = load i16, ptr %4, align 8, !tbaa !18
  %265 = sext i16 %264 to i32
  %266 = getelementptr inbounds i8, ptr %0, i64 1760
  %267 = getelementptr inbounds i8, ptr %0, i64 1828
  %268 = load i32, ptr %267, align 4, !tbaa !90
  %269 = mul nsw i32 %268, %265
  %270 = sext i32 %269 to i64
  %271 = tail call noalias ptr @calloc(i64 noundef %270, i64 noundef 4) #6
  %272 = getelementptr inbounds i8, ptr %0, i64 1776
  store ptr %271, ptr %272, align 8, !tbaa !91
  %273 = load ptr, ptr %237, align 8, !tbaa !81
  store ptr %273, ptr %266, align 8, !tbaa !92
  tail call void @fc_op_forward(ptr noundef nonnull %266) #7
  %274 = load ptr, ptr %272, align 8, !tbaa !91
  %275 = getelementptr inbounds i8, ptr %0, i64 8
  store ptr %274, ptr %275, align 8, !tbaa !93
  ret void
}

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

declare void @conv_op_forward(ptr noundef) local_unnamed_addr #3

declare void @batch_norm_op_forward(ptr noundef) local_unnamed_addr #3

declare void @relu_op_forward(ptr noundef) local_unnamed_addr #3

declare void @max_pooling_op_forward(ptr noundef) local_unnamed_addr #3

declare void @dropout(ptr noundef, float noundef, i32 noundef) local_unnamed_addr #3

declare void @fc_op_forward(ptr noundef) local_unnamed_addr #3

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

; Function Attrs: nocallback nofree nosync nounwind speculatable willreturn memory(none)
declare float @llvm.fabs.f32(float) #5

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

!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 0}
!6 = !{!"network", !7, i64 0, !7, i64 8, !10, i64 16, !11, i64 24, !13, i64 144, !14, i64 240, !15, i64 280, !11, i64 352, !13, i64 472, !14, i64 568, !15, i64 608, !11, i64 680, !13, i64 800, !14, i64 896, !11, i64 936, !13, i64 1056, !14, i64 1152, !11, i64 1192, !13, i64 1312, !14, i64 1408, !15, i64 1448, !16, i64 1520, !14, i64 1600, !16, i64 1640, !14, i64 1720, !16, i64 1760}
!7 = !{!"any pointer", !8, i64 0}
!8 = !{!"omnipotent char", !9, i64 0}
!9 = !{!"Simple C/C++ TBAA"}
!10 = !{!"short", !8, i64 0}
!11 = !{!"conv_op", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !7, i64 32, !7, i64 40, !7, i64 48, !7, i64 56, !7, i64 64, !12, i64 72, !12, i64 76, !12, i64 80, !12, i64 84, !12, i64 88, !12, i64 92, !12, i64 96, !12, i64 100, !12, i64 104, !12, i64 108, !12, i64 112, !10, i64 116}
!12 = !{!"int", !8, i64 0}
!13 = !{!"batch_norm_op", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !7, i64 32, !7, i64 40, !7, i64 48, !7, i64 56, !12, i64 64, !10, i64 68, !7, i64 72, !7, i64 80, !7, i64 88}
!14 = !{!"nonlinear_op", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !12, i64 32, !10, i64 36}
!15 = !{!"max_pooling_op", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !12, i64 32, !12, i64 36, !12, i64 40, !12, i64 44, !12, i64 48, !12, i64 52, !12, i64 56, !12, i64 60, !12, i64 64, !10, i64 68}
!16 = !{!"fc_op", !7, i64 0, !7, i64 8, !7, i64 16, !7, i64 24, !7, i64 32, !7, i64 40, !7, i64 48, !7, i64 56, !12, i64 64, !12, i64 68, !10, i64 72}
!17 = !{!6, !7, i64 24}
!18 = !{!6, !10, i64 16}
!19 = !{!6, !12, i64 136}
!20 = !{!6, !7, i64 40}
!21 = !{!6, !12, i64 208}
!22 = !{!6, !7, i64 160}
!23 = !{!6, !7, i64 144}
!24 = !{!6, !12, i64 272}
!25 = !{!6, !7, i64 256}
!26 = !{!6, !7, i64 240}
!27 = !{!6, !12, i64 344}
!28 = !{!6, !7, i64 296}
!29 = !{!6, !7, i64 280}
!30 = !{!6, !12, i64 464}
!31 = !{!6, !7, i64 368}
!32 = !{!6, !7, i64 352}
!33 = !{!6, !12, i64 536}
!34 = !{!6, !7, i64 488}
!35 = !{!6, !7, i64 472}
!36 = !{!6, !12, i64 600}
!37 = !{!6, !7, i64 584}
!38 = !{!6, !7, i64 568}
!39 = !{!6, !12, i64 672}
!40 = !{!6, !7, i64 624}
!41 = !{!6, !7, i64 608}
!42 = !{!6, !12, i64 792}
!43 = !{!6, !7, i64 696}
!44 = !{!6, !7, i64 680}
!45 = !{!6, !12, i64 864}
!46 = !{!6, !7, i64 816}
!47 = !{!6, !7, i64 800}
!48 = !{!6, !12, i64 928}
!49 = !{!6, !7, i64 912}
!50 = !{!6, !7, i64 896}
!51 = !{!6, !12, i64 1048}
!52 = !{!6, !7, i64 952}
!53 = !{!6, !7, i64 936}
!54 = !{!6, !12, i64 1120}
!55 = !{!6, !7, i64 1072}
!56 = !{!6, !7, i64 1056}
!57 = !{!6, !12, i64 1184}
!58 = !{!6, !7, i64 1168}
!59 = !{!6, !7, i64 1152}
!60 = !{!6, !12, i64 1304}
!61 = !{!6, !7, i64 1208}
!62 = !{!6, !7, i64 1192}
!63 = !{!6, !12, i64 1376}
!64 = !{!6, !7, i64 1328}
!65 = !{!6, !7, i64 1312}
!66 = !{!6, !12, i64 1440}
!67 = !{!6, !7, i64 1424}
!68 = !{!6, !7, i64 1408}
!69 = !{!6, !12, i64 1512}
!70 = !{!6, !7, i64 1464}
!71 = !{!6, !7, i64 1448}
!72 = !{!6, !10, i64 1516}
!73 = !{!6, !12, i64 1588}
!74 = !{!6, !7, i64 1536}
!75 = !{!6, !7, i64 1520}
!76 = !{!6, !12, i64 1632}
!77 = !{!6, !7, i64 1616}
!78 = !{!6, !7, i64 1600}
!79 = !{!6, !10, i64 1636}
!80 = !{!6, !12, i64 1708}
!81 = !{!6, !7, i64 1656}
!82 = !{!6, !7, i64 1640}
!83 = distinct !{!83, !84}
!84 = !{!"llvm.loop.mustprogress"}
!85 = !{!86, !86, i64 0}
!86 = !{!"float", !8, i64 0}
!87 = !{!6, !12, i64 1752}
!88 = !{!6, !7, i64 1736}
!89 = !{!6, !7, i64 1720}
!90 = !{!6, !12, i64 1828}
!91 = !{!6, !7, i64 1776}
!92 = !{!6, !7, i64 1760}
!93 = !{!6, !7, i64 8}


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