out_vm.txt

type Storage {
  
}

def @main(%data: Tensor[(1, 3, 224, 224), float32], %bn_data_gamma: Tensor[(3), float32], %bn_data_beta: Tensor[(3), float32], %bn_data_moving_mean: Tensor[(3), float32], %bn_data_moving_var: Tensor[(3), float32], %conv0_weight: Tensor[(64, 3, 7, 7), float32], %bn0_gamma: Tensor[(64), float32], %bn0_beta: Tensor[(64), float32], %bn0_moving_mean: Tensor[(64), float32], %bn0_moving_var: Tensor[(64), float32], %stage1_unit1_bn1_gamma: Tensor[(64), float32], %stage1_unit1_bn1_beta: Tensor[(64), float32], %stage1_unit1_bn1_moving_mean: Tensor[(64), float32], %stage1_unit1_bn1_moving_var: Tensor[(64), float32], %stage1_unit1_conv1_weight: Tensor[(64, 64, 1, 1), float32], %stage1_unit1_bn2_gamma: Tensor[(64), float32], %stage1_unit1_bn2_beta: Tensor[(64), float32], %stage1_unit1_bn2_moving_mean: Tensor[(64), float32], %stage1_unit1_bn2_moving_var: Tensor[(64), float32], %stage1_unit1_conv2_weight: Tensor[(64, 64, 3, 3), float32], %stage1_unit1_bn3_gamma: Tensor[(64), float32], %stage1_unit1_bn3_beta: Tensor[(64), float32], %stage1_unit1_bn3_moving_mean: Tensor[(64), float32], %stage1_unit1_bn3_moving_var: Tensor[(64), float32], %stage1_unit1_conv3_weight: Tensor[(256, 64, 1, 1), float32], %stage1_unit1_sc_weight: Tensor[(256, 64, 1, 1), float32], %stage1_unit2_bn1_gamma: Tensor[(256), float32], %stage1_unit2_bn1_beta: Tensor[(256), float32], %stage1_unit2_bn1_moving_mean: Tensor[(256), float32], %stage1_unit2_bn1_moving_var: Tensor[(256), float32], %stage1_unit2_conv1_weight: Tensor[(64, 256, 1, 1), float32], %stage1_unit2_bn2_gamma: Tensor[(64), float32], %stage1_unit2_bn2_beta: Tensor[(64), float32], %stage1_unit2_bn2_moving_mean: Tensor[(64), float32], %stage1_unit2_bn2_moving_var: Tensor[(64), float32], %stage1_unit2_conv2_weight: Tensor[(64, 64, 3, 3), float32], %stage1_unit2_bn3_gamma: Tensor[(64), float32], %stage1_unit2_bn3_beta: Tensor[(64), float32], %stage1_unit2_bn3_moving_mean: Tensor[(64), float32], %stage1_unit2_bn3_moving_var: Tensor[(64), float32], %stage1_unit2_conv3_weight: Tensor[(256, 64, 1, 1), float32], %stage1_unit3_bn1_gamma: Tensor[(256), float32], %stage1_unit3_bn1_beta: Tensor[(256), float32], %stage1_unit3_bn1_moving_mean: Tensor[(256), float32], %stage1_unit3_bn1_moving_var: Tensor[(256), float32], %stage1_unit3_conv1_weight: Tensor[(64, 256, 1, 1), float32], %stage1_unit3_bn2_gamma: Tensor[(64), float32], %stage1_unit3_bn2_beta: Tensor[(64), float32], %stage1_unit3_bn2_moving_mean: Tensor[(64), float32], %stage1_unit3_bn2_moving_var: Tensor[(64), float32], %stage1_unit3_conv2_weight: Tensor[(64, 64, 3, 3), float32], %stage1_unit3_bn3_gamma: Tensor[(64), float32], %stage1_unit3_bn3_beta: Tensor[(64), float32], %stage1_unit3_bn3_moving_mean: Tensor[(64), float32], %stage1_unit3_bn3_moving_var: Tensor[(64), float32], %stage1_unit3_conv3_weight: Tensor[(256, 64, 1, 1), float32], %stage2_unit1_bn1_gamma: Tensor[(256), float32], %stage2_unit1_bn1_beta: Tensor[(256), float32], %stage2_unit1_bn1_moving_mean: Tensor[(256), float32], %stage2_unit1_bn1_moving_var: Tensor[(256), float32], %stage2_unit1_conv1_weight: Tensor[(128, 256, 1, 1), float32], %stage2_unit1_bn2_gamma: Tensor[(128), float32], %stage2_unit1_bn2_beta: Tensor[(128), float32], %stage2_unit1_bn2_moving_mean: Tensor[(128), float32], %stage2_unit1_bn2_moving_var: Tensor[(128), float32], %stage2_unit1_conv2_weight: Tensor[(128, 128, 3, 3), float32], %stage2_unit1_bn3_gamma: Tensor[(128), float32], %stage2_unit1_bn3_beta: Tensor[(128), float32], %stage2_unit1_bn3_moving_mean: Tensor[(128), float32], %stage2_unit1_bn3_moving_var: Tensor[(128), float32], %stage2_unit1_conv3_weight: Tensor[(512, 128, 1, 1), float32], %stage2_unit1_sc_weight: Tensor[(512, 256, 1, 1), float32], %stage2_unit2_bn1_gamma: Tensor[(512), float32], %stage2_unit2_bn1_beta: Tensor[(512), float32], %stage2_unit2_bn1_moving_mean: Tensor[(512), float32], %stage2_unit2_bn1_moving_var: Tensor[(512), float32], %stage2_unit2_conv1_weight: Tensor[(128, 512, 1, 1), float32], %stage2_unit2_bn2_gamma: Tensor[(128), float32], %stage2_unit2_bn2_beta: Tensor[(128), float32], %stage2_unit2_bn2_moving_mean: Tensor[(128), float32], %stage2_unit2_bn2_moving_var: Tensor[(128), float32], %stage2_unit2_conv2_weight: Tensor[(128, 128, 3, 3), float32], %stage2_unit2_bn3_gamma: Tensor[(128), float32], %stage2_unit2_bn3_beta: Tensor[(128), float32], %stage2_unit2_bn3_moving_mean: Tensor[(128), float32], %stage2_unit2_bn3_moving_var: Tensor[(128), float32], %stage2_unit2_conv3_weight: Tensor[(512, 128, 1, 1), float32], %stage2_unit3_bn1_gamma: Tensor[(512), float32], %stage2_unit3_bn1_beta: Tensor[(512), float32], %stage2_unit3_bn1_moving_mean: Tensor[(512), float32], %stage2_unit3_bn1_moving_var: Tensor[(512), float32], %stage2_unit3_conv1_weight: Tensor[(128, 512, 1, 1), float32], %stage2_unit3_bn2_gamma: Tensor[(128), float32], %stage2_unit3_bn2_beta: Tensor[(128), float32], %stage2_unit3_bn2_moving_mean: Tensor[(128), float32], %stage2_unit3_bn2_moving_var: Tensor[(128), float32], %stage2_unit3_conv2_weight: Tensor[(128, 128, 3, 3), float32], %stage2_unit3_bn3_gamma: Tensor[(128), float32], %stage2_unit3_bn3_beta: Tensor[(128), float32], %stage2_unit3_bn3_moving_mean: Tensor[(128), float32], %stage2_unit3_bn3_moving_var: Tensor[(128), float32], %stage2_unit3_conv3_weight: Tensor[(512, 128, 1, 1), float32], %stage2_unit4_bn1_gamma: Tensor[(512), float32], %stage2_unit4_bn1_beta: Tensor[(512), float32], %stage2_unit4_bn1_moving_mean: Tensor[(512), float32], %stage2_unit4_bn1_moving_var: Tensor[(512), float32], %stage2_unit4_conv1_weight: Tensor[(128, 512, 1, 1), float32], %stage2_unit4_bn2_gamma: Tensor[(128), float32], %stage2_unit4_bn2_beta: Tensor[(128), float32], %stage2_unit4_bn2_moving_mean: Tensor[(128), float32], %stage2_unit4_bn2_moving_var: Tensor[(128), float32], %stage2_unit4_conv2_weight: Tensor[(128, 128, 3, 3), float32], %stage2_unit4_bn3_gamma: Tensor[(128), float32], %stage2_unit4_bn3_beta: Tensor[(128), float32], %stage2_unit4_bn3_moving_mean: Tensor[(128), float32], %stage2_unit4_bn3_moving_var: Tensor[(128), float32], %stage2_unit4_conv3_weight: Tensor[(512, 128, 1, 1), float32], %stage3_unit1_bn1_gamma: Tensor[(512), float32], %stage3_unit1_bn1_beta: Tensor[(512), float32], %stage3_unit1_bn1_moving_mean: Tensor[(512), float32], %stage3_unit1_bn1_moving_var: Tensor[(512), float32], %stage3_unit1_conv1_weight: Tensor[(256, 512, 1, 1), float32], %stage3_unit1_bn2_gamma: Tensor[(256), float32], %stage3_unit1_bn2_beta: Tensor[(256), float32], %stage3_unit1_bn2_moving_mean: Tensor[(256), float32], %stage3_unit1_bn2_moving_var: Tensor[(256), float32], %stage3_unit1_conv2_weight: Tensor[(256, 256, 3, 3), float32], %stage3_unit1_bn3_gamma: Tensor[(256), float32], %stage3_unit1_bn3_beta: Tensor[(256), float32], %stage3_unit1_bn3_moving_mean: Tensor[(256), float32], %stage3_unit1_bn3_moving_var: Tensor[(256), float32], %stage3_unit1_conv3_weight: Tensor[(1024, 256, 1, 1), float32], %stage3_unit1_sc_weight: Tensor[(1024, 512, 1, 1), float32], %stage3_unit2_bn1_gamma: Tensor[(1024), float32], %stage3_unit2_bn1_beta: Tensor[(1024), float32], %stage3_unit2_bn1_moving_mean: Tensor[(1024), float32], %stage3_unit2_bn1_moving_var: Tensor[(1024), float32], %stage3_unit2_conv1_weight: Tensor[(256, 1024, 1, 1), float32], %stage3_unit2_bn2_gamma: Tensor[(256), float32], %stage3_unit2_bn2_beta: Tensor[(256), float32], %stage3_unit2_bn2_moving_mean: Tensor[(256), float32], %stage3_unit2_bn2_moving_var: Tensor[(256), float32], %stage3_unit2_conv2_weight: Tensor[(256, 256, 3, 3), float32], %stage3_unit2_bn3_gamma: Tensor[(256), float32], %stage3_unit2_bn3_beta: Tensor[(256), float32], %stage3_unit2_bn3_moving_mean: Tensor[(256), float32], %stage3_unit2_bn3_moving_var: Tensor[(256), float32], %stage3_unit2_conv3_weight: Tensor[(1024, 256, 1, 1), float32], %stage3_unit3_bn1_gamma: Tensor[(1024), float32], %stage3_unit3_bn1_beta: Tensor[(1024), float32], %stage3_unit3_bn1_moving_mean: Tensor[(1024), float32], %stage3_unit3_bn1_moving_var: Tensor[(1024), float32], %stage3_unit3_conv1_weight: Tensor[(256, 1024, 1, 1), float32], %stage3_unit3_bn2_gamma: Tensor[(256), float32], %stage3_unit3_bn2_beta: Tensor[(256), float32], %stage3_unit3_bn2_moving_mean: Tensor[(256), float32], %stage3_unit3_bn2_moving_var: Tensor[(256), float32], %stage3_unit3_conv2_weight: Tensor[(256, 256, 3, 3), float32], %stage3_unit3_bn3_gamma: Tensor[(256), float32], %stage3_unit3_bn3_beta: Tensor[(256), float32], %stage3_unit3_bn3_moving_mean: Tensor[(256), float32], %stage3_unit3_bn3_moving_var: Tensor[(256), float32], %stage3_unit3_conv3_weight: Tensor[(1024, 256, 1, 1), float32], %stage3_unit4_bn1_gamma: Tensor[(1024), float32], %stage3_unit4_bn1_beta: Tensor[(1024), float32], %stage3_unit4_bn1_moving_mean: Tensor[(1024), float32], %stage3_unit4_bn1_moving_var: Tensor[(1024), float32], %stage3_unit4_conv1_weight: Tensor[(256, 1024, 1, 1), float32], %stage3_unit4_bn2_gamma: Tensor[(256), float32], %stage3_unit4_bn2_beta: Tensor[(256), float32], %stage3_unit4_bn2_moving_mean: Tensor[(256), float32], %stage3_unit4_bn2_moving_var: Tensor[(256), float32], %stage3_unit4_conv2_weight: Tensor[(256, 256, 3, 3), float32], %stage3_unit4_bn3_gamma: Tensor[(256), float32], %stage3_unit4_bn3_beta: Tensor[(256), float32], %stage3_unit4_bn3_moving_mean: Tensor[(256), float32], %stage3_unit4_bn3_moving_var: Tensor[(256), float32], %stage3_unit4_conv3_weight: Tensor[(1024, 256, 1, 1), float32], %stage3_unit5_bn1_gamma: Tensor[(1024), float32], %stage3_unit5_bn1_beta: Tensor[(1024), float32], %stage3_unit5_bn1_moving_mean: Tensor[(1024), float32], %stage3_unit5_bn1_moving_var: Tensor[(1024), float32], %stage3_unit5_conv1_weight: Tensor[(256, 1024, 1, 1), float32], %stage3_unit5_bn2_gamma: Tensor[(256), float32], %stage3_unit5_bn2_beta: Tensor[(256), float32], %stage3_unit5_bn2_moving_mean: Tensor[(256), float32], %stage3_unit5_bn2_moving_var: Tensor[(256), float32], %stage3_unit5_conv2_weight: Tensor[(256, 256, 3, 3), float32], %stage3_unit5_bn3_gamma: Tensor[(256), float32], %stage3_unit5_bn3_beta: Tensor[(256), float32], %stage3_unit5_bn3_moving_mean: Tensor[(256), float32], %stage3_unit5_bn3_moving_var: Tensor[(256), float32], %stage3_unit5_conv3_weight: Tensor[(1024, 256, 1, 1), float32], %stage3_unit6_bn1_gamma: Tensor[(1024), float32], %stage3_unit6_bn1_beta: Tensor[(1024), float32], %stage3_unit6_bn1_moving_mean: Tensor[(1024), float32], %stage3_unit6_bn1_moving_var: Tensor[(1024), float32], %stage3_unit6_conv1_weight: Tensor[(256, 1024, 1, 1), float32], %stage3_unit6_bn2_gamma: Tensor[(256), float32], %stage3_unit6_bn2_beta: Tensor[(256), float32], %stage3_unit6_bn2_moving_mean: Tensor[(256), float32], %stage3_unit6_bn2_moving_var: Tensor[(256), float32], %stage3_unit6_conv2_weight: Tensor[(256, 256, 3, 3), float32], %stage3_unit6_bn3_gamma: Tensor[(256), float32], %stage3_unit6_bn3_beta: Tensor[(256), float32], %stage3_unit6_bn3_moving_mean: Tensor[(256), float32], %stage3_unit6_bn3_moving_var: Tensor[(256), float32], %stage3_unit6_conv3_weight: Tensor[(1024, 256, 1, 1), float32], %stage4_unit1_bn1_gamma: Tensor[(1024), float32], %stage4_unit1_bn1_beta: Tensor[(1024), float32], %stage4_unit1_bn1_moving_mean: Tensor[(1024), float32], %stage4_unit1_bn1_moving_var: Tensor[(1024), float32], %stage4_unit1_conv1_weight: Tensor[(512, 1024, 1, 1), float32], %stage4_unit1_bn2_gamma: Tensor[(512), float32], %stage4_unit1_bn2_beta: Tensor[(512), float32], %stage4_unit1_bn2_moving_mean: Tensor[(512), float32], %stage4_unit1_bn2_moving_var: Tensor[(512), float32], %stage4_unit1_conv2_weight: Tensor[(512, 512, 3, 3), float32], %stage4_unit1_bn3_gamma: Tensor[(512), float32], %stage4_unit1_bn3_beta: Tensor[(512), float32], %stage4_unit1_bn3_moving_mean: Tensor[(512), float32], %stage4_unit1_bn3_moving_var: Tensor[(512), float32], %stage4_unit1_conv3_weight: Tensor[(2048, 512, 1, 1), float32], %stage4_unit1_sc_weight: Tensor[(2048, 1024, 1, 1), float32], %stage4_unit2_bn1_gamma: Tensor[(2048), float32], %stage4_unit2_bn1_beta: Tensor[(2048), float32], %stage4_unit2_bn1_moving_mean: Tensor[(2048), float32], %stage4_unit2_bn1_moving_var: Tensor[(2048), float32], %stage4_unit2_conv1_weight: Tensor[(512, 2048, 1, 1), float32], %stage4_unit2_bn2_gamma: Tensor[(512), float32], %stage4_unit2_bn2_beta: Tensor[(512), float32], %stage4_unit2_bn2_moving_mean: Tensor[(512), float32], %stage4_unit2_bn2_moving_var: Tensor[(512), float32], %stage4_unit2_conv2_weight: Tensor[(512, 512, 3, 3), float32], %stage4_unit2_bn3_gamma: Tensor[(512), float32], %stage4_unit2_bn3_beta: Tensor[(512), float32], %stage4_unit2_bn3_moving_mean: Tensor[(512), float32], %stage4_unit2_bn3_moving_var: Tensor[(512), float32], %stage4_unit2_conv3_weight: Tensor[(2048, 512, 1, 1), float32], %stage4_unit3_bn1_gamma: Tensor[(2048), float32], %stage4_unit3_bn1_beta: Tensor[(2048), float32], %stage4_unit3_bn1_moving_mean: Tensor[(2048), float32], %stage4_unit3_bn1_moving_var: Tensor[(2048), float32], %stage4_unit3_conv1_weight: Tensor[(512, 2048, 1, 1), float32], %stage4_unit3_bn2_gamma: Tensor[(512), float32], %stage4_unit3_bn2_beta: Tensor[(512), float32], %stage4_unit3_bn2_moving_mean: Tensor[(512), float32], %stage4_unit3_bn2_moving_var: Tensor[(512), float32], %stage4_unit3_conv2_weight: Tensor[(512, 512, 3, 3), float32], %stage4_unit3_bn3_gamma: Tensor[(512), float32], %stage4_unit3_bn3_beta: Tensor[(512), float32], %stage4_unit3_bn3_moving_mean: Tensor[(512), float32], %stage4_unit3_bn3_moving_var: Tensor[(512), float32], %stage4_unit3_conv3_weight: Tensor[(2048, 512, 1, 1), float32], %bn1_gamma: Tensor[(2048), float32], %bn1_beta: Tensor[(2048), float32], %bn1_moving_mean: Tensor[(2048), float32], %bn1_moving_var: Tensor[(2048), float32], %fc1_weight: Tensor[(1000, 2048), float32], %fc1_bias: Tensor[(1000), float32]) -> Tensor[(1, 1000), float32] {
  let %storage_0: Storage[] = memory.alloc_storage(602112 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][0]) /* ty=Storage[] */;
  let %tensor_0: Tensor[(1, 224, 224, 3), float32] = memory.alloc_tensor(%storage_0, 0 /* ty=int64 */, meta[relay.Constant][0] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][0]) /* ty=Tensor[(1, 224, 224, 3), float32] */;
  %10 = fn (%p0: Tensor[(3), float32], %p1: Tensor[(1, 3, 224, 224), float32], %p2: Tensor[(3), float32], %p3: Tensor[(3), float32], Primitive=1) -> Tensor[(1, 224, 224, 3), float32] {
    %0 = add(%p0, 2e-05f /* ty=float32 */) /* ty=Tensor[(3), float32] */;
    %1 = sqrt(%0) /* ty=Tensor[(3), float32] */;
    %2 = divide(1f /* ty=float32 */, %1) /* ty=Tensor[(3), float32] */;
    %3 = expand_dims(%2, axis=1, num_newaxis=2) /* ty=Tensor[(3, 1, 1), float32] */;
    %4 = multiply(%p1, %3) /* ty=Tensor[(1, 3, 224, 224), float32] */;
    %5 = negative(%p2) /* ty=Tensor[(3), float32] */;
    %6 = multiply(%5, %2) /* ty=Tensor[(3), float32] */;
    %7 = add(%6, %p3) /* ty=Tensor[(3), float32] */;
    %8 = expand_dims(%7, axis=1, num_newaxis=2) /* ty=Tensor[(3, 1, 1), float32] */;
    %9 = add(%4, %8) /* ty=Tensor[(1, 3, 224, 224), float32] */;
    layout_transform(%9, src_layout="NCHW", dst_layout="NHWC") /* ty=Tensor[(1, 224, 224, 3), float32] */
  };
  %11 = (%bn_data_moving_var, %data, %bn_data_moving_mean, %bn_data_beta);
  %12 = (%tensor_0,);
  let %x: () = vm.invoke_tvm_op(%10, %11, %12) /* ty=() */;
  let %x1: Tensor[(1, 224, 224, 3), float32] = %tensor_0;
  let %storage_01: Storage[] = memory.alloc_storage(256 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][1]) /* ty=Storage[] */;
  let %tensor_01: Tensor[(64), float32] = memory.alloc_tensor(%storage_01, 0 /* ty=int64 */, meta[relay.Constant][1] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][1]) /* ty=Tensor[(64), float32] */;
  %16 = fn (%p01: Tensor[(64), float32], %p11: Tensor[(64), float32], Primitive=1) -> Tensor[(64), float32] {
    %13 = add(%p01, 2e-05f /* ty=float32 */) /* ty=Tensor[(64), float32] */;
    %14 = sqrt(%13) /* ty=Tensor[(64), float32] */;
    %15 = divide(1f /* ty=float32 */, %14) /* ty=Tensor[(64), float32] */;
    multiply(%15, %p11) /* ty=Tensor[(64), float32] */
  };
  %17 = (%bn0_moving_var, %bn0_gamma);
  %18 = (%tensor_01,);
  let %x2: () = vm.invoke_tvm_op(%16, %17, %18) /* ty=() */;
  let %x3: Tensor[(64), float32] = %tensor_01;
  let %storage_02: Storage[] = memory.alloc_storage(37632 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][2]) /* ty=Storage[] */;
  let %tensor_02: Tensor[(7, 7, 3, 64), float32] = memory.alloc_tensor(%storage_02, 0 /* ty=int64 */, meta[relay.Constant][2] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][2]) /* ty=Tensor[(7, 7, 3, 64), float32] */;
  %20 = fn (%p02: Tensor[(64, 3, 7, 7), float32], %p12: Tensor[(64), float32], Primitive=1) -> Tensor[(7, 7, 3, 64), float32] {
    %19 = layout_transform(%p02, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(7, 7, 3, 64), float32] */;
    multiply(%19, %p12) /* ty=Tensor[(7, 7, 3, 64), float32] */
  };
  %21 = (%conv0_weight, %x3);
  %22 = (%tensor_02,);
  let %x4: () = vm.invoke_tvm_op(%20, %21, %22) /* ty=() */;
  let %x5: Tensor[(7, 7, 3, 64), float32] = %tensor_02;
  let %storage_03: Storage[] = memory.alloc_storage(3211264 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][3]) /* ty=Storage[] */;
  let %tensor_03: Tensor[(1, 112, 112, 64), float32] = memory.alloc_tensor(%storage_03, 0 /* ty=int64 */, meta[relay.Constant][3] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][3]) /* ty=Tensor[(1, 112, 112, 64), float32] */;
  %29 = fn (%p03: Tensor[(1, 224, 224, 3), float32], %p13: Tensor[(7, 7, 3, 64), float32], %p21: Tensor[(64), float32], %p31: Tensor[(64), float32], %p4: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 112, 112, 64), float32] {
    %23 = nn.conv2d(%p03, %p13, strides=[2, 2], padding=[3, 3, 3, 3], channels=64, kernel_size=[7, 7], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 112, 112, 64), float32] */;
    %24 = negative(%p21) /* ty=Tensor[(64), float32] */;
    %25 = multiply(%24, %p31) /* ty=Tensor[(64), float32] */;
    %26 = add(%25, %p4) /* ty=Tensor[(64), float32] */;
    %27 = expand_dims(%26, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 64), float32] */;
    %28 = add(%23, %27) /* ty=Tensor[(1, 112, 112, 64), float32] */;
    nn.relu(%28) /* ty=Tensor[(1, 112, 112, 64), float32] */
  };
  %30 = (%x1, %x5, %bn0_moving_mean, %x3, %bn0_beta);
  %31 = (%tensor_03,);
  let %x6: () = vm.invoke_tvm_op(%29, %30, %31) /* ty=() */;
  let %x7: Tensor[(1, 112, 112, 64), float32] = %tensor_03;
  let %storage_04: Storage[] = memory.alloc_storage(256 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][4]) /* ty=Storage[] */;
  let %tensor_04: Tensor[(64), float32] = memory.alloc_tensor(%storage_04, 0 /* ty=int64 */, meta[relay.Constant][4] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][4]) /* ty=Tensor[(64), float32] */;
  %35 = fn (%p04: Tensor[(64), float32], %p14: Tensor[(64), float32], Primitive=1) -> Tensor[(64), float32] {
    %32 = add(%p04, 2e-05f /* ty=float32 */) /* ty=Tensor[(64), float32] */;
    %33 = sqrt(%32) /* ty=Tensor[(64), float32] */;
    %34 = divide(1f /* ty=float32 */, %33) /* ty=Tensor[(64), float32] */;
    multiply(%34, %p14) /* ty=Tensor[(64), float32] */
  };
  %36 = (%stage1_unit1_bn1_moving_var, %stage1_unit1_bn1_gamma);
  %37 = (%tensor_04,);
  let %x8: () = vm.invoke_tvm_op(%35, %36, %37) /* ty=() */;
  let %x9: Tensor[(64), float32] = %tensor_04;
  let %storage_05: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][5]) /* ty=Storage[] */;
  let %tensor_05: Tensor[(1, 56, 56, 64), float32] = memory.alloc_tensor(%storage_05, 0 /* ty=int64 */, meta[relay.Constant][5] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][5]) /* ty=Tensor[(1, 56, 56, 64), float32] */;
  %46 = fn (%p05: Tensor[(1, 112, 112, 64), float32], %p15: Tensor[(64), float32], %p22: Tensor[(64), float32], %p32: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 56, 56, 64), float32] {
    %38 = nn.max_pool2d(%p05, pool_size=[3, 3], strides=[2, 2], padding=[1, 1, 1, 1], layout="NHWC") /* ty=Tensor[(1, 56, 56, 64), float32] */;
    %39 = expand_dims(%p15, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 64), float32] */;
    %40 = multiply(%38, %39) /* ty=Tensor[(1, 56, 56, 64), float32] */;
    %41 = negative(%p22) /* ty=Tensor[(64), float32] */;
    %42 = multiply(%41, %p15) /* ty=Tensor[(64), float32] */;
    %43 = add(%42, %p32) /* ty=Tensor[(64), float32] */;
    %44 = expand_dims(%43, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 64), float32] */;
    %45 = add(%40, %44) /* ty=Tensor[(1, 56, 56, 64), float32] */;
    nn.relu(%45) /* ty=Tensor[(1, 56, 56, 64), float32] */
  };
  %47 = (%x7, %x9, %stage1_unit1_bn1_moving_mean, %stage1_unit1_bn1_beta);
  %48 = (%tensor_05,);
  let %x10: () = vm.invoke_tvm_op(%46, %47, %48) /* ty=() */;
  let %x11: Tensor[(1, 56, 56, 64), float32] = %tensor_05;
  let %storage_06: Storage[] = memory.alloc_storage(256 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][6]) /* ty=Storage[] */;
  let %tensor_06: Tensor[(64), float32] = memory.alloc_tensor(%storage_06, 0 /* ty=int64 */, meta[relay.Constant][6] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][6]) /* ty=Tensor[(64), float32] */;
  %52 = fn (%p06: Tensor[(64), float32], %p16: Tensor[(64), float32], Primitive=1) -> Tensor[(64), float32] {
    %49 = add(%p06, 2e-05f /* ty=float32 */) /* ty=Tensor[(64), float32] */;
    %50 = sqrt(%49) /* ty=Tensor[(64), float32] */;
    %51 = divide(1f /* ty=float32 */, %50) /* ty=Tensor[(64), float32] */;
    multiply(%51, %p16) /* ty=Tensor[(64), float32] */
  };
  %53 = (%stage1_unit1_bn2_moving_var, %stage1_unit1_bn2_gamma);
  %54 = (%tensor_06,);
  let %x12: () = vm.invoke_tvm_op(%52, %53, %54) /* ty=() */;
  let %x13: Tensor[(64), float32] = %tensor_06;
  let %storage_07: Storage[] = memory.alloc_storage(16384 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][7]) /* ty=Storage[] */;
  let %tensor_07: Tensor[(1, 1, 64, 64), float32] = memory.alloc_tensor(%storage_07, 0 /* ty=int64 */, meta[relay.Constant][7] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][7]) /* ty=Tensor[(1, 1, 64, 64), float32] */;
  %56 = fn (%p07: Tensor[(64, 64, 1, 1), float32], %p17: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 1, 64, 64), float32] {
    %55 = layout_transform(%p07, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 64, 64), float32] */;
    multiply(%55, %p17) /* ty=Tensor[(1, 1, 64, 64), float32] */
  };
  %57 = (%stage1_unit1_conv1_weight, %x13);
  %58 = (%tensor_07,);
  let %x14: () = vm.invoke_tvm_op(%56, %57, %58) /* ty=() */;
  let %x15: Tensor[(1, 1, 64, 64), float32] = %tensor_07;
  let %storage_08: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][8]) /* ty=Storage[] */;
  let %tensor_08: Tensor[(1, 56, 56, 64), float32] = memory.alloc_tensor(%storage_08, 0 /* ty=int64 */, meta[relay.Constant][8] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][8]) /* ty=Tensor[(1, 56, 56, 64), float32] */;
  %65 = fn (%p08: Tensor[(1, 56, 56, 64), float32], %p18: Tensor[(1, 1, 64, 64), float32], %p23: Tensor[(64), float32], %p33: Tensor[(64), float32], %p41: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 56, 56, 64), float32] {
    %59 = nn.conv2d(%p08, %p18, padding=[0, 0, 0, 0], channels=64, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 56, 56, 64), float32] */;
    %60 = negative(%p23) /* ty=Tensor[(64), float32] */;
    %61 = multiply(%60, %p33) /* ty=Tensor[(64), float32] */;
    %62 = add(%61, %p41) /* ty=Tensor[(64), float32] */;
    %63 = expand_dims(%62, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 64), float32] */;
    %64 = add(%59, %63) /* ty=Tensor[(1, 56, 56, 64), float32] */;
    nn.relu(%64) /* ty=Tensor[(1, 56, 56, 64), float32] */
  };
  %66 = (%x11, %x15, %stage1_unit1_bn2_moving_mean, %x13, %stage1_unit1_bn2_beta);
  %67 = (%tensor_08,);
  let %x16: () = vm.invoke_tvm_op(%65, %66, %67) /* ty=() */;
  let %x17: Tensor[(1, 56, 56, 64), float32] = %tensor_08;
  let %storage_09: Storage[] = memory.alloc_storage(256 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][9]) /* ty=Storage[] */;
  let %tensor_09: Tensor[(64), float32] = memory.alloc_tensor(%storage_09, 0 /* ty=int64 */, meta[relay.Constant][9] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][9]) /* ty=Tensor[(64), float32] */;
  %71 = fn (%p09: Tensor[(64), float32], %p19: Tensor[(64), float32], Primitive=1) -> Tensor[(64), float32] {
    %68 = add(%p09, 2e-05f /* ty=float32 */) /* ty=Tensor[(64), float32] */;
    %69 = sqrt(%68) /* ty=Tensor[(64), float32] */;
    %70 = divide(1f /* ty=float32 */, %69) /* ty=Tensor[(64), float32] */;
    multiply(%70, %p19) /* ty=Tensor[(64), float32] */
  };
  %72 = (%stage1_unit1_bn3_moving_var, %stage1_unit1_bn3_gamma);
  %73 = (%tensor_09,);
  let %x18: () = vm.invoke_tvm_op(%71, %72, %73) /* ty=() */;
  let %x19: Tensor[(64), float32] = %tensor_09;
  let %storage_010: Storage[] = memory.alloc_storage(147456 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][10]) /* ty=Storage[] */;
  let %tensor_010: Tensor[(3, 3, 64, 64), float32] = memory.alloc_tensor(%storage_010, 0 /* ty=int64 */, meta[relay.Constant][10] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][10]) /* ty=Tensor[(3, 3, 64, 64), float32] */;
  %75 = fn (%p010: Tensor[(64, 64, 3, 3), float32], %p110: Tensor[(64), float32], Primitive=1) -> Tensor[(3, 3, 64, 64), float32] {
    %74 = layout_transform(%p010, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 64, 64), float32] */;
    multiply(%74, %p110) /* ty=Tensor[(3, 3, 64, 64), float32] */
  };
  %76 = (%stage1_unit1_conv2_weight, %x19);
  %77 = (%tensor_010,);
  let %x20: () = vm.invoke_tvm_op(%75, %76, %77) /* ty=() */;
  let %x21: Tensor[(3, 3, 64, 64), float32] = %tensor_010;
  let %storage_011: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][11]) /* ty=Storage[] */;
  let %tensor_011: Tensor[(1, 56, 56, 64), float32] = memory.alloc_tensor(%storage_011, 0 /* ty=int64 */, meta[relay.Constant][11] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][11]) /* ty=Tensor[(1, 56, 56, 64), float32] */;
  %84 = fn (%p011: Tensor[(1, 56, 56, 64), float32], %p111: Tensor[(3, 3, 64, 64), float32], %p24: Tensor[(64), float32], %p34: Tensor[(64), float32], %p42: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 56, 56, 64), float32] {
    %78 = nn.conv2d(%p011, %p111, padding=[1, 1, 1, 1], channels=64, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 56, 56, 64), float32] */;
    %79 = negative(%p24) /* ty=Tensor[(64), float32] */;
    %80 = multiply(%79, %p34) /* ty=Tensor[(64), float32] */;
    %81 = add(%80, %p42) /* ty=Tensor[(64), float32] */;
    %82 = expand_dims(%81, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 64), float32] */;
    %83 = add(%78, %82) /* ty=Tensor[(1, 56, 56, 64), float32] */;
    nn.relu(%83) /* ty=Tensor[(1, 56, 56, 64), float32] */
  };
  %85 = (%x17, %x21, %stage1_unit1_bn3_moving_mean, %x19, %stage1_unit1_bn3_beta);
  %86 = (%tensor_011,);
  let %x22: () = vm.invoke_tvm_op(%84, %85, %86) /* ty=() */;
  let %x23: Tensor[(1, 56, 56, 64), float32] = %tensor_011;
  let %storage_012: Storage[] = memory.alloc_storage(65536 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][12]) /* ty=Storage[] */;
  let %tensor_012: Tensor[(1, 1, 64, 256), float32] = memory.alloc_tensor(%storage_012, 0 /* ty=int64 */, meta[relay.Constant][12] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][12]) /* ty=Tensor[(1, 1, 64, 256), float32] */;
  %87 = fn (%p012: Tensor[(256, 64, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 64, 256), float32] {
    layout_transform(%p012, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 64, 256), float32] */
  };
  %88 = (%stage1_unit1_conv3_weight,);
  %89 = (%tensor_012,);
  let %x24: () = vm.invoke_tvm_op(%87, %88, %89) /* ty=() */;
  let %x25: Tensor[(1, 1, 64, 256), float32] = %tensor_012;
  let %storage_013: Storage[] = memory.alloc_storage(65536 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][13]) /* ty=Storage[] */;
  let %tensor_013: Tensor[(1, 1, 64, 256), float32] = memory.alloc_tensor(%storage_013, 0 /* ty=int64 */, meta[relay.Constant][13] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][13]) /* ty=Tensor[(1, 1, 64, 256), float32] */;
  %90 = fn (%p013: Tensor[(256, 64, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 64, 256), float32] {
    layout_transform(%p013, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 64, 256), float32] */
  };
  %91 = (%stage1_unit1_sc_weight,);
  %92 = (%tensor_013,);
  let %x26: () = vm.invoke_tvm_op(%90, %91, %92) /* ty=() */;
  let %x27: Tensor[(1, 1, 64, 256), float32] = %tensor_013;
  let %storage_014: Storage[] = memory.alloc_storage(3211264 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][14]) /* ty=Storage[] */;
  let %tensor_014: Tensor[(1, 56, 56, 256), float32] = memory.alloc_tensor(%storage_014, 0 /* ty=int64 */, meta[relay.Constant][14] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][14]) /* ty=Tensor[(1, 56, 56, 256), float32] */;
  %93 = fn (%p014: Tensor[(1, 56, 56, 64), float32], %p112: Tensor[(1, 1, 64, 256), float32], Primitive=1) -> Tensor[(1, 56, 56, 256), float32] {
    nn.conv2d(%p014, %p112, padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 56, 56, 256), float32] */
  };
  %94 = (%x11, %x27);
  %95 = (%tensor_014,);
  let %x28: () = vm.invoke_tvm_op(%93, %94, %95) /* ty=() */;
  let %x29: Tensor[(1, 56, 56, 256), float32] = %tensor_014;
  let %storage_015: Storage[] = memory.alloc_storage(3211264 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][15]) /* ty=Storage[] */;
  let %tensor_015: Tensor[(1, 56, 56, 256), float32] = memory.alloc_tensor(%storage_015, 0 /* ty=int64 */, meta[relay.Constant][15] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][15]) /* ty=Tensor[(1, 56, 56, 256), float32] */;
  %97 = fn (%p015: Tensor[(1, 56, 56, 64), float32], %p113: Tensor[(1, 1, 64, 256), float32], %p25: Tensor[(1, 56, 56, 256), float32], Primitive=1) -> Tensor[(1, 56, 56, 256), float32] {
    %96 = nn.conv2d(%p015, %p113, padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 56, 56, 256), float32] */;
    add(%96, %p25) /* ty=Tensor[(1, 56, 56, 256), float32] */
  };
  %98 = (%x23, %x25, %x29);
  %99 = (%tensor_015,);
  let %x30: () = vm.invoke_tvm_op(%97, %98, %99) /* ty=() */;
  let %x31: Tensor[(1, 56, 56, 256), float32] = %tensor_015;
  let %storage_016: Storage[] = memory.alloc_storage(3211264 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][16]) /* ty=Storage[] */;
  let %tensor_016: Tensor[(1, 56, 56, 256), float32] = memory.alloc_tensor(%storage_016, 0 /* ty=int64 */, meta[relay.Constant][16] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][16]) /* ty=Tensor[(1, 56, 56, 256), float32] */;
  %111 = fn (%p016: Tensor[(256), float32], %p114: Tensor[(256), float32], %p26: Tensor[(1, 56, 56, 256), float32], %p35: Tensor[(256), float32], %p43: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 56, 56, 256), float32] {
    %100 = add(%p016, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %101 = sqrt(%100) /* ty=Tensor[(256), float32] */;
    %102 = divide(1f /* ty=float32 */, %101) /* ty=Tensor[(256), float32] */;
    %103 = multiply(%102, %p114) /* ty=Tensor[(256), float32] */;
    %104 = expand_dims(%103, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %105 = multiply(%p26, %104) /* ty=Tensor[(1, 56, 56, 256), float32] */;
    %106 = negative(%p35) /* ty=Tensor[(256), float32] */;
    %107 = multiply(%106, %103) /* ty=Tensor[(256), float32] */;
    %108 = add(%107, %p43) /* ty=Tensor[(256), float32] */;
    %109 = expand_dims(%108, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %110 = add(%105, %109) /* ty=Tensor[(1, 56, 56, 256), float32] */;
    nn.relu(%110) /* ty=Tensor[(1, 56, 56, 256), float32] */
  };
  %112 = (%stage1_unit2_bn1_moving_var, %stage1_unit2_bn1_gamma, %x31, %stage1_unit2_bn1_moving_mean, %stage1_unit2_bn1_beta);
  %113 = (%tensor_016,);
  let %x32: () = vm.invoke_tvm_op(%111, %112, %113) /* ty=() */;
  let %x33: Tensor[(1, 56, 56, 256), float32] = %tensor_016;
  let %storage_017: Storage[] = memory.alloc_storage(256 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][17]) /* ty=Storage[] */;
  let %tensor_017: Tensor[(64), float32] = memory.alloc_tensor(%storage_017, 0 /* ty=int64 */, meta[relay.Constant][17] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][17]) /* ty=Tensor[(64), float32] */;
  %117 = fn (%p017: Tensor[(64), float32], %p115: Tensor[(64), float32], Primitive=1) -> Tensor[(64), float32] {
    %114 = add(%p017, 2e-05f /* ty=float32 */) /* ty=Tensor[(64), float32] */;
    %115 = sqrt(%114) /* ty=Tensor[(64), float32] */;
    %116 = divide(1f /* ty=float32 */, %115) /* ty=Tensor[(64), float32] */;
    multiply(%116, %p115) /* ty=Tensor[(64), float32] */
  };
  %118 = (%stage1_unit2_bn2_moving_var, %stage1_unit2_bn2_gamma);
  %119 = (%tensor_017,);
  let %x34: () = vm.invoke_tvm_op(%117, %118, %119) /* ty=() */;
  let %x35: Tensor[(64), float32] = %tensor_017;
  let %storage_018: Storage[] = memory.alloc_storage(65536 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][18]) /* ty=Storage[] */;
  let %tensor_018: Tensor[(1, 1, 256, 64), float32] = memory.alloc_tensor(%storage_018, 0 /* ty=int64 */, meta[relay.Constant][18] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][18]) /* ty=Tensor[(1, 1, 256, 64), float32] */;
  %121 = fn (%p018: Tensor[(64, 256, 1, 1), float32], %p116: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 1, 256, 64), float32] {
    %120 = layout_transform(%p018, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 256, 64), float32] */;
    multiply(%120, %p116) /* ty=Tensor[(1, 1, 256, 64), float32] */
  };
  %122 = (%stage1_unit2_conv1_weight, %x35);
  %123 = (%tensor_018,);
  let %x36: () = vm.invoke_tvm_op(%121, %122, %123) /* ty=() */;
  let %x37: Tensor[(1, 1, 256, 64), float32] = %tensor_018;
  let %storage_019: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][19]) /* ty=Storage[] */;
  let %tensor_019: Tensor[(1, 56, 56, 64), float32] = memory.alloc_tensor(%storage_019, 0 /* ty=int64 */, meta[relay.Constant][19] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][19]) /* ty=Tensor[(1, 56, 56, 64), float32] */;
  %130 = fn (%p019: Tensor[(1, 56, 56, 256), float32], %p117: Tensor[(1, 1, 256, 64), float32], %p27: Tensor[(64), float32], %p36: Tensor[(64), float32], %p44: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 56, 56, 64), float32] {
    %124 = nn.conv2d(%p019, %p117, padding=[0, 0, 0, 0], channels=64, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 56, 56, 64), float32] */;
    %125 = negative(%p27) /* ty=Tensor[(64), float32] */;
    %126 = multiply(%125, %p36) /* ty=Tensor[(64), float32] */;
    %127 = add(%126, %p44) /* ty=Tensor[(64), float32] */;
    %128 = expand_dims(%127, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 64), float32] */;
    %129 = add(%124, %128) /* ty=Tensor[(1, 56, 56, 64), float32] */;
    nn.relu(%129) /* ty=Tensor[(1, 56, 56, 64), float32] */
  };
  %131 = (%x33, %x37, %stage1_unit2_bn2_moving_mean, %x35, %stage1_unit2_bn2_beta);
  %132 = (%tensor_019,);
  let %x38: () = vm.invoke_tvm_op(%130, %131, %132) /* ty=() */;
  let %x39: Tensor[(1, 56, 56, 64), float32] = %tensor_019;
  let %storage_020: Storage[] = memory.alloc_storage(256 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][20]) /* ty=Storage[] */;
  let %tensor_020: Tensor[(64), float32] = memory.alloc_tensor(%storage_020, 0 /* ty=int64 */, meta[relay.Constant][20] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][20]) /* ty=Tensor[(64), float32] */;
  %136 = fn (%p020: Tensor[(64), float32], %p118: Tensor[(64), float32], Primitive=1) -> Tensor[(64), float32] {
    %133 = add(%p020, 2e-05f /* ty=float32 */) /* ty=Tensor[(64), float32] */;
    %134 = sqrt(%133) /* ty=Tensor[(64), float32] */;
    %135 = divide(1f /* ty=float32 */, %134) /* ty=Tensor[(64), float32] */;
    multiply(%135, %p118) /* ty=Tensor[(64), float32] */
  };
  %137 = (%stage1_unit2_bn3_moving_var, %stage1_unit2_bn3_gamma);
  %138 = (%tensor_020,);
  let %x40: () = vm.invoke_tvm_op(%136, %137, %138) /* ty=() */;
  let %x41: Tensor[(64), float32] = %tensor_020;
  let %storage_021: Storage[] = memory.alloc_storage(147456 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][21]) /* ty=Storage[] */;
  let %tensor_021: Tensor[(3, 3, 64, 64), float32] = memory.alloc_tensor(%storage_021, 0 /* ty=int64 */, meta[relay.Constant][21] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][21]) /* ty=Tensor[(3, 3, 64, 64), float32] */;
  %140 = fn (%p021: Tensor[(64, 64, 3, 3), float32], %p119: Tensor[(64), float32], Primitive=1) -> Tensor[(3, 3, 64, 64), float32] {
    %139 = layout_transform(%p021, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 64, 64), float32] */;
    multiply(%139, %p119) /* ty=Tensor[(3, 3, 64, 64), float32] */
  };
  %141 = (%stage1_unit2_conv2_weight, %x41);
  %142 = (%tensor_021,);
  let %x42: () = vm.invoke_tvm_op(%140, %141, %142) /* ty=() */;
  let %x43: Tensor[(3, 3, 64, 64), float32] = %tensor_021;
  let %storage_022: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][22]) /* ty=Storage[] */;
  let %tensor_022: Tensor[(1, 56, 56, 64), float32] = memory.alloc_tensor(%storage_022, 0 /* ty=int64 */, meta[relay.Constant][22] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][22]) /* ty=Tensor[(1, 56, 56, 64), float32] */;
  %149 = fn (%p022: Tensor[(1, 56, 56, 64), float32], %p120: Tensor[(3, 3, 64, 64), float32], %p28: Tensor[(64), float32], %p37: Tensor[(64), float32], %p45: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 56, 56, 64), float32] {
    %143 = nn.conv2d(%p022, %p120, padding=[1, 1, 1, 1], channels=64, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 56, 56, 64), float32] */;
    %144 = negative(%p28) /* ty=Tensor[(64), float32] */;
    %145 = multiply(%144, %p37) /* ty=Tensor[(64), float32] */;
    %146 = add(%145, %p45) /* ty=Tensor[(64), float32] */;
    %147 = expand_dims(%146, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 64), float32] */;
    %148 = add(%143, %147) /* ty=Tensor[(1, 56, 56, 64), float32] */;
    nn.relu(%148) /* ty=Tensor[(1, 56, 56, 64), float32] */
  };
  %150 = (%x39, %x43, %stage1_unit2_bn3_moving_mean, %x41, %stage1_unit2_bn3_beta);
  %151 = (%tensor_022,);
  let %x44: () = vm.invoke_tvm_op(%149, %150, %151) /* ty=() */;
  let %x45: Tensor[(1, 56, 56, 64), float32] = %tensor_022;
  let %storage_023: Storage[] = memory.alloc_storage(65536 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][23]) /* ty=Storage[] */;
  let %tensor_023: Tensor[(1, 1, 64, 256), float32] = memory.alloc_tensor(%storage_023, 0 /* ty=int64 */, meta[relay.Constant][23] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][23]) /* ty=Tensor[(1, 1, 64, 256), float32] */;
  %152 = fn (%p023: Tensor[(256, 64, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 64, 256), float32] {
    layout_transform(%p023, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 64, 256), float32] */
  };
  %153 = (%stage1_unit2_conv3_weight,);
  %154 = (%tensor_023,);
  let %x46: () = vm.invoke_tvm_op(%152, %153, %154) /* ty=() */;
  let %x47: Tensor[(1, 1, 64, 256), float32] = %tensor_023;
  let %storage_024: Storage[] = memory.alloc_storage(3211264 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][24]) /* ty=Storage[] */;
  let %tensor_024: Tensor[(1, 56, 56, 256), float32] = memory.alloc_tensor(%storage_024, 0 /* ty=int64 */, meta[relay.Constant][24] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][24]) /* ty=Tensor[(1, 56, 56, 256), float32] */;
  %156 = fn (%p024: Tensor[(1, 56, 56, 64), float32], %p121: Tensor[(1, 1, 64, 256), float32], %p29: Tensor[(1, 56, 56, 256), float32], Primitive=1) -> Tensor[(1, 56, 56, 256), float32] {
    %155 = nn.conv2d(%p024, %p121, padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 56, 56, 256), float32] */;
    add(%155, %p29) /* ty=Tensor[(1, 56, 56, 256), float32] */
  };
  %157 = (%x45, %x47, %x31);
  %158 = (%tensor_024,);
  let %x48: () = vm.invoke_tvm_op(%156, %157, %158) /* ty=() */;
  let %x49: Tensor[(1, 56, 56, 256), float32] = %tensor_024;
  let %storage_025: Storage[] = memory.alloc_storage(3211264 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][25]) /* ty=Storage[] */;
  let %tensor_025: Tensor[(1, 56, 56, 256), float32] = memory.alloc_tensor(%storage_025, 0 /* ty=int64 */, meta[relay.Constant][25] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][25]) /* ty=Tensor[(1, 56, 56, 256), float32] */;
  %170 = fn (%p025: Tensor[(256), float32], %p122: Tensor[(256), float32], %p210: Tensor[(1, 56, 56, 256), float32], %p38: Tensor[(256), float32], %p46: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 56, 56, 256), float32] {
    %159 = add(%p025, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %160 = sqrt(%159) /* ty=Tensor[(256), float32] */;
    %161 = divide(1f /* ty=float32 */, %160) /* ty=Tensor[(256), float32] */;
    %162 = multiply(%161, %p122) /* ty=Tensor[(256), float32] */;
    %163 = expand_dims(%162, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %164 = multiply(%p210, %163) /* ty=Tensor[(1, 56, 56, 256), float32] */;
    %165 = negative(%p38) /* ty=Tensor[(256), float32] */;
    %166 = multiply(%165, %162) /* ty=Tensor[(256), float32] */;
    %167 = add(%166, %p46) /* ty=Tensor[(256), float32] */;
    %168 = expand_dims(%167, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %169 = add(%164, %168) /* ty=Tensor[(1, 56, 56, 256), float32] */;
    nn.relu(%169) /* ty=Tensor[(1, 56, 56, 256), float32] */
  };
  %171 = (%stage1_unit3_bn1_moving_var, %stage1_unit3_bn1_gamma, %x49, %stage1_unit3_bn1_moving_mean, %stage1_unit3_bn1_beta);
  %172 = (%tensor_025,);
  let %x50: () = vm.invoke_tvm_op(%170, %171, %172) /* ty=() */;
  let %x51: Tensor[(1, 56, 56, 256), float32] = %tensor_025;
  let %storage_026: Storage[] = memory.alloc_storage(256 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][26]) /* ty=Storage[] */;
  let %tensor_026: Tensor[(64), float32] = memory.alloc_tensor(%storage_026, 0 /* ty=int64 */, meta[relay.Constant][26] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][26]) /* ty=Tensor[(64), float32] */;
  %176 = fn (%p026: Tensor[(64), float32], %p123: Tensor[(64), float32], Primitive=1) -> Tensor[(64), float32] {
    %173 = add(%p026, 2e-05f /* ty=float32 */) /* ty=Tensor[(64), float32] */;
    %174 = sqrt(%173) /* ty=Tensor[(64), float32] */;
    %175 = divide(1f /* ty=float32 */, %174) /* ty=Tensor[(64), float32] */;
    multiply(%175, %p123) /* ty=Tensor[(64), float32] */
  };
  %177 = (%stage1_unit3_bn2_moving_var, %stage1_unit3_bn2_gamma);
  %178 = (%tensor_026,);
  let %x52: () = vm.invoke_tvm_op(%176, %177, %178) /* ty=() */;
  let %x53: Tensor[(64), float32] = %tensor_026;
  let %storage_027: Storage[] = memory.alloc_storage(65536 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][27]) /* ty=Storage[] */;
  let %tensor_027: Tensor[(1, 1, 256, 64), float32] = memory.alloc_tensor(%storage_027, 0 /* ty=int64 */, meta[relay.Constant][27] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][27]) /* ty=Tensor[(1, 1, 256, 64), float32] */;
  %180 = fn (%p027: Tensor[(64, 256, 1, 1), float32], %p124: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 1, 256, 64), float32] {
    %179 = layout_transform(%p027, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 256, 64), float32] */;
    multiply(%179, %p124) /* ty=Tensor[(1, 1, 256, 64), float32] */
  };
  %181 = (%stage1_unit3_conv1_weight, %x53);
  %182 = (%tensor_027,);
  let %x54: () = vm.invoke_tvm_op(%180, %181, %182) /* ty=() */;
  let %x55: Tensor[(1, 1, 256, 64), float32] = %tensor_027;
  let %storage_028: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][28]) /* ty=Storage[] */;
  let %tensor_028: Tensor[(1, 56, 56, 64), float32] = memory.alloc_tensor(%storage_028, 0 /* ty=int64 */, meta[relay.Constant][28] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][28]) /* ty=Tensor[(1, 56, 56, 64), float32] */;
  %189 = fn (%p028: Tensor[(1, 56, 56, 256), float32], %p125: Tensor[(1, 1, 256, 64), float32], %p211: Tensor[(64), float32], %p39: Tensor[(64), float32], %p47: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 56, 56, 64), float32] {
    %183 = nn.conv2d(%p028, %p125, padding=[0, 0, 0, 0], channels=64, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 56, 56, 64), float32] */;
    %184 = negative(%p211) /* ty=Tensor[(64), float32] */;
    %185 = multiply(%184, %p39) /* ty=Tensor[(64), float32] */;
    %186 = add(%185, %p47) /* ty=Tensor[(64), float32] */;
    %187 = expand_dims(%186, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 64), float32] */;
    %188 = add(%183, %187) /* ty=Tensor[(1, 56, 56, 64), float32] */;
    nn.relu(%188) /* ty=Tensor[(1, 56, 56, 64), float32] */
  };
  %190 = (%x51, %x55, %stage1_unit3_bn2_moving_mean, %x53, %stage1_unit3_bn2_beta);
  %191 = (%tensor_028,);
  let %x56: () = vm.invoke_tvm_op(%189, %190, %191) /* ty=() */;
  let %x57: Tensor[(1, 56, 56, 64), float32] = %tensor_028;
  let %storage_029: Storage[] = memory.alloc_storage(256 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][29]) /* ty=Storage[] */;
  let %tensor_029: Tensor[(64), float32] = memory.alloc_tensor(%storage_029, 0 /* ty=int64 */, meta[relay.Constant][29] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][29]) /* ty=Tensor[(64), float32] */;
  %195 = fn (%p029: Tensor[(64), float32], %p126: Tensor[(64), float32], Primitive=1) -> Tensor[(64), float32] {
    %192 = add(%p029, 2e-05f /* ty=float32 */) /* ty=Tensor[(64), float32] */;
    %193 = sqrt(%192) /* ty=Tensor[(64), float32] */;
    %194 = divide(1f /* ty=float32 */, %193) /* ty=Tensor[(64), float32] */;
    multiply(%194, %p126) /* ty=Tensor[(64), float32] */
  };
  %196 = (%stage1_unit3_bn3_moving_var, %stage1_unit3_bn3_gamma);
  %197 = (%tensor_029,);
  let %x58: () = vm.invoke_tvm_op(%195, %196, %197) /* ty=() */;
  let %x59: Tensor[(64), float32] = %tensor_029;
  let %storage_030: Storage[] = memory.alloc_storage(147456 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][30]) /* ty=Storage[] */;
  let %tensor_030: Tensor[(3, 3, 64, 64), float32] = memory.alloc_tensor(%storage_030, 0 /* ty=int64 */, meta[relay.Constant][30] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][30]) /* ty=Tensor[(3, 3, 64, 64), float32] */;
  %199 = fn (%p030: Tensor[(64, 64, 3, 3), float32], %p127: Tensor[(64), float32], Primitive=1) -> Tensor[(3, 3, 64, 64), float32] {
    %198 = layout_transform(%p030, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 64, 64), float32] */;
    multiply(%198, %p127) /* ty=Tensor[(3, 3, 64, 64), float32] */
  };
  %200 = (%stage1_unit3_conv2_weight, %x59);
  %201 = (%tensor_030,);
  let %x60: () = vm.invoke_tvm_op(%199, %200, %201) /* ty=() */;
  let %x61: Tensor[(3, 3, 64, 64), float32] = %tensor_030;
  let %storage_031: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][31]) /* ty=Storage[] */;
  let %tensor_031: Tensor[(1, 56, 56, 64), float32] = memory.alloc_tensor(%storage_031, 0 /* ty=int64 */, meta[relay.Constant][31] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][31]) /* ty=Tensor[(1, 56, 56, 64), float32] */;
  %208 = fn (%p031: Tensor[(1, 56, 56, 64), float32], %p128: Tensor[(3, 3, 64, 64), float32], %p212: Tensor[(64), float32], %p310: Tensor[(64), float32], %p48: Tensor[(64), float32], Primitive=1) -> Tensor[(1, 56, 56, 64), float32] {
    %202 = nn.conv2d(%p031, %p128, padding=[1, 1, 1, 1], channels=64, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 56, 56, 64), float32] */;
    %203 = negative(%p212) /* ty=Tensor[(64), float32] */;
    %204 = multiply(%203, %p310) /* ty=Tensor[(64), float32] */;
    %205 = add(%204, %p48) /* ty=Tensor[(64), float32] */;
    %206 = expand_dims(%205, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 64), float32] */;
    %207 = add(%202, %206) /* ty=Tensor[(1, 56, 56, 64), float32] */;
    nn.relu(%207) /* ty=Tensor[(1, 56, 56, 64), float32] */
  };
  %209 = (%x57, %x61, %stage1_unit3_bn3_moving_mean, %x59, %stage1_unit3_bn3_beta);
  %210 = (%tensor_031,);
  let %x62: () = vm.invoke_tvm_op(%208, %209, %210) /* ty=() */;
  let %x63: Tensor[(1, 56, 56, 64), float32] = %tensor_031;
  let %storage_032: Storage[] = memory.alloc_storage(65536 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][32]) /* ty=Storage[] */;
  let %tensor_032: Tensor[(1, 1, 64, 256), float32] = memory.alloc_tensor(%storage_032, 0 /* ty=int64 */, meta[relay.Constant][32] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][32]) /* ty=Tensor[(1, 1, 64, 256), float32] */;
  %211 = fn (%p032: Tensor[(256, 64, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 64, 256), float32] {
    layout_transform(%p032, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 64, 256), float32] */
  };
  %212 = (%stage1_unit3_conv3_weight,);
  %213 = (%tensor_032,);
  let %x64: () = vm.invoke_tvm_op(%211, %212, %213) /* ty=() */;
  let %x65: Tensor[(1, 1, 64, 256), float32] = %tensor_032;
  let %storage_033: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][33]) /* ty=Storage[] */;
  let %tensor_033: Tensor[(256), float32] = memory.alloc_tensor(%storage_033, 0 /* ty=int64 */, meta[relay.Constant][33] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][33]) /* ty=Tensor[(256), float32] */;
  %217 = fn (%p033: Tensor[(256), float32], %p129: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %214 = add(%p033, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %215 = sqrt(%214) /* ty=Tensor[(256), float32] */;
    %216 = divide(1f /* ty=float32 */, %215) /* ty=Tensor[(256), float32] */;
    multiply(%216, %p129) /* ty=Tensor[(256), float32] */
  };
  %218 = (%stage2_unit1_bn1_moving_var, %stage2_unit1_bn1_gamma);
  %219 = (%tensor_033,);
  let %x66: () = vm.invoke_tvm_op(%217, %218, %219) /* ty=() */;
  let %x67: Tensor[(256), float32] = %tensor_033;
  let %storage_034: Storage[] = memory.alloc_storage(3211264 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][34]) /* ty=Storage[] */;
  let %tensor_034: Tensor[(1, 56, 56, 256), float32] = memory.alloc_tensor(%storage_034, 0 /* ty=int64 */, meta[relay.Constant][34] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][34]) /* ty=Tensor[(1, 56, 56, 256), float32] */;
  %229 = fn (%p034: Tensor[(1, 56, 56, 64), float32], %p130: Tensor[(1, 1, 64, 256), float32], %p213: Tensor[(1, 56, 56, 256), float32], %p311: Tensor[(256), float32], %p49: Tensor[(256), float32], %p5: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 56, 56, 256), float32] {
    %220 = nn.conv2d(%p034, %p130, padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 56, 56, 256), float32] */;
    %221 = add(%220, %p213) /* ty=Tensor[(1, 56, 56, 256), float32] */;
    %222 = expand_dims(%p311, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %223 = multiply(%221, %222) /* ty=Tensor[(1, 56, 56, 256), float32] */;
    %224 = negative(%p49) /* ty=Tensor[(256), float32] */;
    %225 = multiply(%224, %p311) /* ty=Tensor[(256), float32] */;
    %226 = add(%225, %p5) /* ty=Tensor[(256), float32] */;
    %227 = expand_dims(%226, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %228 = add(%223, %227) /* ty=Tensor[(1, 56, 56, 256), float32] */;
    nn.relu(%228) /* ty=Tensor[(1, 56, 56, 256), float32] */
  };
  %230 = (%x63, %x65, %x49, %x67, %stage2_unit1_bn1_moving_mean, %stage2_unit1_bn1_beta);
  %231 = (%tensor_034,);
  let %x68: () = vm.invoke_tvm_op(%229, %230, %231) /* ty=() */;
  let %x69: Tensor[(1, 56, 56, 256), float32] = %tensor_034;
  let %storage_035: Storage[] = memory.alloc_storage(512 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][35]) /* ty=Storage[] */;
  let %tensor_035: Tensor[(128), float32] = memory.alloc_tensor(%storage_035, 0 /* ty=int64 */, meta[relay.Constant][35] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][35]) /* ty=Tensor[(128), float32] */;
  %235 = fn (%p035: Tensor[(128), float32], %p131: Tensor[(128), float32], Primitive=1) -> Tensor[(128), float32] {
    %232 = add(%p035, 2e-05f /* ty=float32 */) /* ty=Tensor[(128), float32] */;
    %233 = sqrt(%232) /* ty=Tensor[(128), float32] */;
    %234 = divide(1f /* ty=float32 */, %233) /* ty=Tensor[(128), float32] */;
    multiply(%234, %p131) /* ty=Tensor[(128), float32] */
  };
  %236 = (%stage2_unit1_bn2_moving_var, %stage2_unit1_bn2_gamma);
  %237 = (%tensor_035,);
  let %x70: () = vm.invoke_tvm_op(%235, %236, %237) /* ty=() */;
  let %x71: Tensor[(128), float32] = %tensor_035;
  let %storage_036: Storage[] = memory.alloc_storage(131072 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][36]) /* ty=Storage[] */;
  let %tensor_036: Tensor[(1, 1, 256, 128), float32] = memory.alloc_tensor(%storage_036, 0 /* ty=int64 */, meta[relay.Constant][36] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][36]) /* ty=Tensor[(1, 1, 256, 128), float32] */;
  %239 = fn (%p036: Tensor[(128, 256, 1, 1), float32], %p132: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 1, 256, 128), float32] {
    %238 = layout_transform(%p036, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 256, 128), float32] */;
    multiply(%238, %p132) /* ty=Tensor[(1, 1, 256, 128), float32] */
  };
  %240 = (%stage2_unit1_conv1_weight, %x71);
  %241 = (%tensor_036,);
  let %x72: () = vm.invoke_tvm_op(%239, %240, %241) /* ty=() */;
  let %x73: Tensor[(1, 1, 256, 128), float32] = %tensor_036;
  let %storage_037: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][37]) /* ty=Storage[] */;
  let %tensor_037: Tensor[(1, 28, 28, 128), float32] = memory.alloc_tensor(%storage_037, 0 /* ty=int64 */, meta[relay.Constant][37] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][37]) /* ty=Tensor[(1, 28, 28, 128), float32] */;
  %248 = fn (%p037: Tensor[(1, 56, 56, 256), float32], %p133: Tensor[(1, 1, 256, 128), float32], %p214: Tensor[(128), float32], %p312: Tensor[(128), float32], %p410: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 28, 28, 128), float32] {
    %242 = nn.conv2d(%p037, %p133, strides=[2, 2], padding=[0, 0, 0, 0], channels=128, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 128), float32] */;
    %243 = negative(%p214) /* ty=Tensor[(128), float32] */;
    %244 = multiply(%243, %p312) /* ty=Tensor[(128), float32] */;
    %245 = add(%244, %p410) /* ty=Tensor[(128), float32] */;
    %246 = expand_dims(%245, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 128), float32] */;
    %247 = add(%242, %246) /* ty=Tensor[(1, 28, 28, 128), float32] */;
    nn.relu(%247) /* ty=Tensor[(1, 28, 28, 128), float32] */
  };
  %249 = (%x69, %x73, %stage2_unit1_bn2_moving_mean, %x71, %stage2_unit1_bn2_beta);
  %250 = (%tensor_037,);
  let %x74: () = vm.invoke_tvm_op(%248, %249, %250) /* ty=() */;
  let %x75: Tensor[(1, 28, 28, 128), float32] = %tensor_037;
  let %storage_038: Storage[] = memory.alloc_storage(512 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][38]) /* ty=Storage[] */;
  let %tensor_038: Tensor[(128), float32] = memory.alloc_tensor(%storage_038, 0 /* ty=int64 */, meta[relay.Constant][38] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][38]) /* ty=Tensor[(128), float32] */;
  %254 = fn (%p038: Tensor[(128), float32], %p134: Tensor[(128), float32], Primitive=1) -> Tensor[(128), float32] {
    %251 = add(%p038, 2e-05f /* ty=float32 */) /* ty=Tensor[(128), float32] */;
    %252 = sqrt(%251) /* ty=Tensor[(128), float32] */;
    %253 = divide(1f /* ty=float32 */, %252) /* ty=Tensor[(128), float32] */;
    multiply(%253, %p134) /* ty=Tensor[(128), float32] */
  };
  %255 = (%stage2_unit1_bn3_moving_var, %stage2_unit1_bn3_gamma);
  %256 = (%tensor_038,);
  let %x76: () = vm.invoke_tvm_op(%254, %255, %256) /* ty=() */;
  let %x77: Tensor[(128), float32] = %tensor_038;
  let %storage_039: Storage[] = memory.alloc_storage(589824 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][39]) /* ty=Storage[] */;
  let %tensor_039: Tensor[(3, 3, 128, 128), float32] = memory.alloc_tensor(%storage_039, 0 /* ty=int64 */, meta[relay.Constant][39] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][39]) /* ty=Tensor[(3, 3, 128, 128), float32] */;
  %258 = fn (%p039: Tensor[(128, 128, 3, 3), float32], %p135: Tensor[(128), float32], Primitive=1) -> Tensor[(3, 3, 128, 128), float32] {
    %257 = layout_transform(%p039, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 128, 128), float32] */;
    multiply(%257, %p135) /* ty=Tensor[(3, 3, 128, 128), float32] */
  };
  %259 = (%stage2_unit1_conv2_weight, %x77);
  %260 = (%tensor_039,);
  let %x78: () = vm.invoke_tvm_op(%258, %259, %260) /* ty=() */;
  let %x79: Tensor[(3, 3, 128, 128), float32] = %tensor_039;
  let %storage_040: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][40]) /* ty=Storage[] */;
  let %tensor_040: Tensor[(1, 28, 28, 128), float32] = memory.alloc_tensor(%storage_040, 0 /* ty=int64 */, meta[relay.Constant][40] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][40]) /* ty=Tensor[(1, 28, 28, 128), float32] */;
  %267 = fn (%p040: Tensor[(1, 28, 28, 128), float32], %p136: Tensor[(3, 3, 128, 128), float32], %p215: Tensor[(128), float32], %p313: Tensor[(128), float32], %p411: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 28, 28, 128), float32] {
    %261 = nn.conv2d(%p040, %p136, padding=[1, 1, 1, 1], channels=128, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 128), float32] */;
    %262 = negative(%p215) /* ty=Tensor[(128), float32] */;
    %263 = multiply(%262, %p313) /* ty=Tensor[(128), float32] */;
    %264 = add(%263, %p411) /* ty=Tensor[(128), float32] */;
    %265 = expand_dims(%264, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 128), float32] */;
    %266 = add(%261, %265) /* ty=Tensor[(1, 28, 28, 128), float32] */;
    nn.relu(%266) /* ty=Tensor[(1, 28, 28, 128), float32] */
  };
  %268 = (%x75, %x79, %stage2_unit1_bn3_moving_mean, %x77, %stage2_unit1_bn3_beta);
  %269 = (%tensor_040,);
  let %x80: () = vm.invoke_tvm_op(%267, %268, %269) /* ty=() */;
  let %x81: Tensor[(1, 28, 28, 128), float32] = %tensor_040;
  let %storage_041: Storage[] = memory.alloc_storage(262144 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][41]) /* ty=Storage[] */;
  let %tensor_041: Tensor[(1, 1, 128, 512), float32] = memory.alloc_tensor(%storage_041, 0 /* ty=int64 */, meta[relay.Constant][41] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][41]) /* ty=Tensor[(1, 1, 128, 512), float32] */;
  %270 = fn (%p041: Tensor[(512, 128, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 128, 512), float32] {
    layout_transform(%p041, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 128, 512), float32] */
  };
  %271 = (%stage2_unit1_conv3_weight,);
  %272 = (%tensor_041,);
  let %x82: () = vm.invoke_tvm_op(%270, %271, %272) /* ty=() */;
  let %x83: Tensor[(1, 1, 128, 512), float32] = %tensor_041;
  let %storage_042: Storage[] = memory.alloc_storage(524288 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][42]) /* ty=Storage[] */;
  let %tensor_042: Tensor[(1, 1, 256, 512), float32] = memory.alloc_tensor(%storage_042, 0 /* ty=int64 */, meta[relay.Constant][42] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][42]) /* ty=Tensor[(1, 1, 256, 512), float32] */;
  %273 = fn (%p042: Tensor[(512, 256, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 256, 512), float32] {
    layout_transform(%p042, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 256, 512), float32] */
  };
  %274 = (%stage2_unit1_sc_weight,);
  %275 = (%tensor_042,);
  let %x84: () = vm.invoke_tvm_op(%273, %274, %275) /* ty=() */;
  let %x85: Tensor[(1, 1, 256, 512), float32] = %tensor_042;
  let %storage_043: Storage[] = memory.alloc_storage(1605632 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][43]) /* ty=Storage[] */;
  let %tensor_043: Tensor[(1, 28, 28, 512), float32] = memory.alloc_tensor(%storage_043, 0 /* ty=int64 */, meta[relay.Constant][43] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][43]) /* ty=Tensor[(1, 28, 28, 512), float32] */;
  %276 = fn (%p043: Tensor[(1, 56, 56, 256), float32], %p137: Tensor[(1, 1, 256, 512), float32], Primitive=1) -> Tensor[(1, 28, 28, 512), float32] {
    nn.conv2d(%p043, %p137, strides=[2, 2], padding=[0, 0, 0, 0], channels=512, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 512), float32] */
  };
  %277 = (%x69, %x85);
  %278 = (%tensor_043,);
  let %x86: () = vm.invoke_tvm_op(%276, %277, %278) /* ty=() */;
  let %x87: Tensor[(1, 28, 28, 512), float32] = %tensor_043;
  let %storage_044: Storage[] = memory.alloc_storage(1605632 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][44]) /* ty=Storage[] */;
  let %tensor_044: Tensor[(1, 28, 28, 512), float32] = memory.alloc_tensor(%storage_044, 0 /* ty=int64 */, meta[relay.Constant][44] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][44]) /* ty=Tensor[(1, 28, 28, 512), float32] */;
  %280 = fn (%p044: Tensor[(1, 28, 28, 128), float32], %p138: Tensor[(1, 1, 128, 512), float32], %p216: Tensor[(1, 28, 28, 512), float32], Primitive=1) -> Tensor[(1, 28, 28, 512), float32] {
    %279 = nn.conv2d(%p044, %p138, padding=[0, 0, 0, 0], channels=512, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 512), float32] */;
    add(%279, %p216) /* ty=Tensor[(1, 28, 28, 512), float32] */
  };
  %281 = (%x81, %x83, %x87);
  %282 = (%tensor_044,);
  let %x88: () = vm.invoke_tvm_op(%280, %281, %282) /* ty=() */;
  let %x89: Tensor[(1, 28, 28, 512), float32] = %tensor_044;
  let %storage_045: Storage[] = memory.alloc_storage(1605632 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][45]) /* ty=Storage[] */;
  let %tensor_045: Tensor[(1, 28, 28, 512), float32] = memory.alloc_tensor(%storage_045, 0 /* ty=int64 */, meta[relay.Constant][45] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][45]) /* ty=Tensor[(1, 28, 28, 512), float32] */;
  %294 = fn (%p045: Tensor[(512), float32], %p139: Tensor[(512), float32], %p217: Tensor[(1, 28, 28, 512), float32], %p314: Tensor[(512), float32], %p412: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 28, 28, 512), float32] {
    %283 = add(%p045, 2e-05f /* ty=float32 */) /* ty=Tensor[(512), float32] */;
    %284 = sqrt(%283) /* ty=Tensor[(512), float32] */;
    %285 = divide(1f /* ty=float32 */, %284) /* ty=Tensor[(512), float32] */;
    %286 = multiply(%285, %p139) /* ty=Tensor[(512), float32] */;
    %287 = expand_dims(%286, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %288 = multiply(%p217, %287) /* ty=Tensor[(1, 28, 28, 512), float32] */;
    %289 = negative(%p314) /* ty=Tensor[(512), float32] */;
    %290 = multiply(%289, %286) /* ty=Tensor[(512), float32] */;
    %291 = add(%290, %p412) /* ty=Tensor[(512), float32] */;
    %292 = expand_dims(%291, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %293 = add(%288, %292) /* ty=Tensor[(1, 28, 28, 512), float32] */;
    nn.relu(%293) /* ty=Tensor[(1, 28, 28, 512), float32] */
  };
  %295 = (%stage2_unit2_bn1_moving_var, %stage2_unit2_bn1_gamma, %x89, %stage2_unit2_bn1_moving_mean, %stage2_unit2_bn1_beta);
  %296 = (%tensor_045,);
  let %x90: () = vm.invoke_tvm_op(%294, %295, %296) /* ty=() */;
  let %x91: Tensor[(1, 28, 28, 512), float32] = %tensor_045;
  let %storage_046: Storage[] = memory.alloc_storage(512 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][46]) /* ty=Storage[] */;
  let %tensor_046: Tensor[(128), float32] = memory.alloc_tensor(%storage_046, 0 /* ty=int64 */, meta[relay.Constant][46] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][46]) /* ty=Tensor[(128), float32] */;
  %300 = fn (%p046: Tensor[(128), float32], %p140: Tensor[(128), float32], Primitive=1) -> Tensor[(128), float32] {
    %297 = add(%p046, 2e-05f /* ty=float32 */) /* ty=Tensor[(128), float32] */;
    %298 = sqrt(%297) /* ty=Tensor[(128), float32] */;
    %299 = divide(1f /* ty=float32 */, %298) /* ty=Tensor[(128), float32] */;
    multiply(%299, %p140) /* ty=Tensor[(128), float32] */
  };
  %301 = (%stage2_unit2_bn2_moving_var, %stage2_unit2_bn2_gamma);
  %302 = (%tensor_046,);
  let %x92: () = vm.invoke_tvm_op(%300, %301, %302) /* ty=() */;
  let %x93: Tensor[(128), float32] = %tensor_046;
  let %storage_047: Storage[] = memory.alloc_storage(262144 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][47]) /* ty=Storage[] */;
  let %tensor_047: Tensor[(1, 1, 512, 128), float32] = memory.alloc_tensor(%storage_047, 0 /* ty=int64 */, meta[relay.Constant][47] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][47]) /* ty=Tensor[(1, 1, 512, 128), float32] */;
  %304 = fn (%p047: Tensor[(128, 512, 1, 1), float32], %p141: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 1, 512, 128), float32] {
    %303 = layout_transform(%p047, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 512, 128), float32] */;
    multiply(%303, %p141) /* ty=Tensor[(1, 1, 512, 128), float32] */
  };
  %305 = (%stage2_unit2_conv1_weight, %x93);
  %306 = (%tensor_047,);
  let %x94: () = vm.invoke_tvm_op(%304, %305, %306) /* ty=() */;
  let %x95: Tensor[(1, 1, 512, 128), float32] = %tensor_047;
  let %storage_048: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][48]) /* ty=Storage[] */;
  let %tensor_048: Tensor[(1, 28, 28, 128), float32] = memory.alloc_tensor(%storage_048, 0 /* ty=int64 */, meta[relay.Constant][48] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][48]) /* ty=Tensor[(1, 28, 28, 128), float32] */;
  %313 = fn (%p048: Tensor[(1, 28, 28, 512), float32], %p142: Tensor[(1, 1, 512, 128), float32], %p218: Tensor[(128), float32], %p315: Tensor[(128), float32], %p413: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 28, 28, 128), float32] {
    %307 = nn.conv2d(%p048, %p142, padding=[0, 0, 0, 0], channels=128, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 128), float32] */;
    %308 = negative(%p218) /* ty=Tensor[(128), float32] */;
    %309 = multiply(%308, %p315) /* ty=Tensor[(128), float32] */;
    %310 = add(%309, %p413) /* ty=Tensor[(128), float32] */;
    %311 = expand_dims(%310, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 128), float32] */;
    %312 = add(%307, %311) /* ty=Tensor[(1, 28, 28, 128), float32] */;
    nn.relu(%312) /* ty=Tensor[(1, 28, 28, 128), float32] */
  };
  %314 = (%x91, %x95, %stage2_unit2_bn2_moving_mean, %x93, %stage2_unit2_bn2_beta);
  %315 = (%tensor_048,);
  let %x96: () = vm.invoke_tvm_op(%313, %314, %315) /* ty=() */;
  let %x97: Tensor[(1, 28, 28, 128), float32] = %tensor_048;
  let %storage_049: Storage[] = memory.alloc_storage(512 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][49]) /* ty=Storage[] */;
  let %tensor_049: Tensor[(128), float32] = memory.alloc_tensor(%storage_049, 0 /* ty=int64 */, meta[relay.Constant][49] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][49]) /* ty=Tensor[(128), float32] */;
  %319 = fn (%p049: Tensor[(128), float32], %p143: Tensor[(128), float32], Primitive=1) -> Tensor[(128), float32] {
    %316 = add(%p049, 2e-05f /* ty=float32 */) /* ty=Tensor[(128), float32] */;
    %317 = sqrt(%316) /* ty=Tensor[(128), float32] */;
    %318 = divide(1f /* ty=float32 */, %317) /* ty=Tensor[(128), float32] */;
    multiply(%318, %p143) /* ty=Tensor[(128), float32] */
  };
  %320 = (%stage2_unit2_bn3_moving_var, %stage2_unit2_bn3_gamma);
  %321 = (%tensor_049,);
  let %x98: () = vm.invoke_tvm_op(%319, %320, %321) /* ty=() */;
  let %x99: Tensor[(128), float32] = %tensor_049;
  let %storage_050: Storage[] = memory.alloc_storage(589824 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][50]) /* ty=Storage[] */;
  let %tensor_050: Tensor[(3, 3, 128, 128), float32] = memory.alloc_tensor(%storage_050, 0 /* ty=int64 */, meta[relay.Constant][50] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][50]) /* ty=Tensor[(3, 3, 128, 128), float32] */;
  %323 = fn (%p050: Tensor[(128, 128, 3, 3), float32], %p144: Tensor[(128), float32], Primitive=1) -> Tensor[(3, 3, 128, 128), float32] {
    %322 = layout_transform(%p050, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 128, 128), float32] */;
    multiply(%322, %p144) /* ty=Tensor[(3, 3, 128, 128), float32] */
  };
  %324 = (%stage2_unit2_conv2_weight, %x99);
  %325 = (%tensor_050,);
  let %x100: () = vm.invoke_tvm_op(%323, %324, %325) /* ty=() */;
  let %x101: Tensor[(3, 3, 128, 128), float32] = %tensor_050;
  let %storage_051: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][51]) /* ty=Storage[] */;
  let %tensor_051: Tensor[(1, 28, 28, 128), float32] = memory.alloc_tensor(%storage_051, 0 /* ty=int64 */, meta[relay.Constant][51] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][51]) /* ty=Tensor[(1, 28, 28, 128), float32] */;
  %332 = fn (%p051: Tensor[(1, 28, 28, 128), float32], %p145: Tensor[(3, 3, 128, 128), float32], %p219: Tensor[(128), float32], %p316: Tensor[(128), float32], %p414: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 28, 28, 128), float32] {
    %326 = nn.conv2d(%p051, %p145, padding=[1, 1, 1, 1], channels=128, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 128), float32] */;
    %327 = negative(%p219) /* ty=Tensor[(128), float32] */;
    %328 = multiply(%327, %p316) /* ty=Tensor[(128), float32] */;
    %329 = add(%328, %p414) /* ty=Tensor[(128), float32] */;
    %330 = expand_dims(%329, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 128), float32] */;
    %331 = add(%326, %330) /* ty=Tensor[(1, 28, 28, 128), float32] */;
    nn.relu(%331) /* ty=Tensor[(1, 28, 28, 128), float32] */
  };
  %333 = (%x97, %x101, %stage2_unit2_bn3_moving_mean, %x99, %stage2_unit2_bn3_beta);
  %334 = (%tensor_051,);
  let %x102: () = vm.invoke_tvm_op(%332, %333, %334) /* ty=() */;
  let %x103: Tensor[(1, 28, 28, 128), float32] = %tensor_051;
  let %storage_052: Storage[] = memory.alloc_storage(262144 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][52]) /* ty=Storage[] */;
  let %tensor_052: Tensor[(1, 1, 128, 512), float32] = memory.alloc_tensor(%storage_052, 0 /* ty=int64 */, meta[relay.Constant][52] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][52]) /* ty=Tensor[(1, 1, 128, 512), float32] */;
  %335 = fn (%p052: Tensor[(512, 128, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 128, 512), float32] {
    layout_transform(%p052, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 128, 512), float32] */
  };
  %336 = (%stage2_unit2_conv3_weight,);
  %337 = (%tensor_052,);
  let %x104: () = vm.invoke_tvm_op(%335, %336, %337) /* ty=() */;
  let %x105: Tensor[(1, 1, 128, 512), float32] = %tensor_052;
  let %storage_053: Storage[] = memory.alloc_storage(1605632 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][53]) /* ty=Storage[] */;
  let %tensor_053: Tensor[(1, 28, 28, 512), float32] = memory.alloc_tensor(%storage_053, 0 /* ty=int64 */, meta[relay.Constant][53] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][53]) /* ty=Tensor[(1, 28, 28, 512), float32] */;
  %339 = fn (%p053: Tensor[(1, 28, 28, 128), float32], %p146: Tensor[(1, 1, 128, 512), float32], %p220: Tensor[(1, 28, 28, 512), float32], Primitive=1) -> Tensor[(1, 28, 28, 512), float32] {
    %338 = nn.conv2d(%p053, %p146, padding=[0, 0, 0, 0], channels=512, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 512), float32] */;
    add(%338, %p220) /* ty=Tensor[(1, 28, 28, 512), float32] */
  };
  %340 = (%x103, %x105, %x89);
  %341 = (%tensor_053,);
  let %x106: () = vm.invoke_tvm_op(%339, %340, %341) /* ty=() */;
  let %x107: Tensor[(1, 28, 28, 512), float32] = %tensor_053;
  let %storage_054: Storage[] = memory.alloc_storage(1605632 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][54]) /* ty=Storage[] */;
  let %tensor_054: Tensor[(1, 28, 28, 512), float32] = memory.alloc_tensor(%storage_054, 0 /* ty=int64 */, meta[relay.Constant][54] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][54]) /* ty=Tensor[(1, 28, 28, 512), float32] */;
  %353 = fn (%p054: Tensor[(512), float32], %p147: Tensor[(512), float32], %p221: Tensor[(1, 28, 28, 512), float32], %p317: Tensor[(512), float32], %p415: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 28, 28, 512), float32] {
    %342 = add(%p054, 2e-05f /* ty=float32 */) /* ty=Tensor[(512), float32] */;
    %343 = sqrt(%342) /* ty=Tensor[(512), float32] */;
    %344 = divide(1f /* ty=float32 */, %343) /* ty=Tensor[(512), float32] */;
    %345 = multiply(%344, %p147) /* ty=Tensor[(512), float32] */;
    %346 = expand_dims(%345, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %347 = multiply(%p221, %346) /* ty=Tensor[(1, 28, 28, 512), float32] */;
    %348 = negative(%p317) /* ty=Tensor[(512), float32] */;
    %349 = multiply(%348, %345) /* ty=Tensor[(512), float32] */;
    %350 = add(%349, %p415) /* ty=Tensor[(512), float32] */;
    %351 = expand_dims(%350, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %352 = add(%347, %351) /* ty=Tensor[(1, 28, 28, 512), float32] */;
    nn.relu(%352) /* ty=Tensor[(1, 28, 28, 512), float32] */
  };
  %354 = (%stage2_unit3_bn1_moving_var, %stage2_unit3_bn1_gamma, %x107, %stage2_unit3_bn1_moving_mean, %stage2_unit3_bn1_beta);
  %355 = (%tensor_054,);
  let %x108: () = vm.invoke_tvm_op(%353, %354, %355) /* ty=() */;
  let %x109: Tensor[(1, 28, 28, 512), float32] = %tensor_054;
  let %storage_055: Storage[] = memory.alloc_storage(512 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][55]) /* ty=Storage[] */;
  let %tensor_055: Tensor[(128), float32] = memory.alloc_tensor(%storage_055, 0 /* ty=int64 */, meta[relay.Constant][55] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][55]) /* ty=Tensor[(128), float32] */;
  %359 = fn (%p055: Tensor[(128), float32], %p148: Tensor[(128), float32], Primitive=1) -> Tensor[(128), float32] {
    %356 = add(%p055, 2e-05f /* ty=float32 */) /* ty=Tensor[(128), float32] */;
    %357 = sqrt(%356) /* ty=Tensor[(128), float32] */;
    %358 = divide(1f /* ty=float32 */, %357) /* ty=Tensor[(128), float32] */;
    multiply(%358, %p148) /* ty=Tensor[(128), float32] */
  };
  %360 = (%stage2_unit3_bn2_moving_var, %stage2_unit3_bn2_gamma);
  %361 = (%tensor_055,);
  let %x110: () = vm.invoke_tvm_op(%359, %360, %361) /* ty=() */;
  let %x111: Tensor[(128), float32] = %tensor_055;
  let %storage_056: Storage[] = memory.alloc_storage(262144 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][56]) /* ty=Storage[] */;
  let %tensor_056: Tensor[(1, 1, 512, 128), float32] = memory.alloc_tensor(%storage_056, 0 /* ty=int64 */, meta[relay.Constant][56] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][56]) /* ty=Tensor[(1, 1, 512, 128), float32] */;
  %363 = fn (%p056: Tensor[(128, 512, 1, 1), float32], %p149: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 1, 512, 128), float32] {
    %362 = layout_transform(%p056, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 512, 128), float32] */;
    multiply(%362, %p149) /* ty=Tensor[(1, 1, 512, 128), float32] */
  };
  %364 = (%stage2_unit3_conv1_weight, %x111);
  %365 = (%tensor_056,);
  let %x112: () = vm.invoke_tvm_op(%363, %364, %365) /* ty=() */;
  let %x113: Tensor[(1, 1, 512, 128), float32] = %tensor_056;
  let %storage_057: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][57]) /* ty=Storage[] */;
  let %tensor_057: Tensor[(1, 28, 28, 128), float32] = memory.alloc_tensor(%storage_057, 0 /* ty=int64 */, meta[relay.Constant][57] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][57]) /* ty=Tensor[(1, 28, 28, 128), float32] */;
  %372 = fn (%p057: Tensor[(1, 28, 28, 512), float32], %p150: Tensor[(1, 1, 512, 128), float32], %p222: Tensor[(128), float32], %p318: Tensor[(128), float32], %p416: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 28, 28, 128), float32] {
    %366 = nn.conv2d(%p057, %p150, padding=[0, 0, 0, 0], channels=128, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 128), float32] */;
    %367 = negative(%p222) /* ty=Tensor[(128), float32] */;
    %368 = multiply(%367, %p318) /* ty=Tensor[(128), float32] */;
    %369 = add(%368, %p416) /* ty=Tensor[(128), float32] */;
    %370 = expand_dims(%369, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 128), float32] */;
    %371 = add(%366, %370) /* ty=Tensor[(1, 28, 28, 128), float32] */;
    nn.relu(%371) /* ty=Tensor[(1, 28, 28, 128), float32] */
  };
  %373 = (%x109, %x113, %stage2_unit3_bn2_moving_mean, %x111, %stage2_unit3_bn2_beta);
  %374 = (%tensor_057,);
  let %x114: () = vm.invoke_tvm_op(%372, %373, %374) /* ty=() */;
  let %x115: Tensor[(1, 28, 28, 128), float32] = %tensor_057;
  let %storage_058: Storage[] = memory.alloc_storage(512 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][58]) /* ty=Storage[] */;
  let %tensor_058: Tensor[(128), float32] = memory.alloc_tensor(%storage_058, 0 /* ty=int64 */, meta[relay.Constant][58] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][58]) /* ty=Tensor[(128), float32] */;
  %378 = fn (%p058: Tensor[(128), float32], %p151: Tensor[(128), float32], Primitive=1) -> Tensor[(128), float32] {
    %375 = add(%p058, 2e-05f /* ty=float32 */) /* ty=Tensor[(128), float32] */;
    %376 = sqrt(%375) /* ty=Tensor[(128), float32] */;
    %377 = divide(1f /* ty=float32 */, %376) /* ty=Tensor[(128), float32] */;
    multiply(%377, %p151) /* ty=Tensor[(128), float32] */
  };
  %379 = (%stage2_unit3_bn3_moving_var, %stage2_unit3_bn3_gamma);
  %380 = (%tensor_058,);
  let %x116: () = vm.invoke_tvm_op(%378, %379, %380) /* ty=() */;
  let %x117: Tensor[(128), float32] = %tensor_058;
  let %storage_059: Storage[] = memory.alloc_storage(589824 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][59]) /* ty=Storage[] */;
  let %tensor_059: Tensor[(3, 3, 128, 128), float32] = memory.alloc_tensor(%storage_059, 0 /* ty=int64 */, meta[relay.Constant][59] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][59]) /* ty=Tensor[(3, 3, 128, 128), float32] */;
  %382 = fn (%p059: Tensor[(128, 128, 3, 3), float32], %p152: Tensor[(128), float32], Primitive=1) -> Tensor[(3, 3, 128, 128), float32] {
    %381 = layout_transform(%p059, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 128, 128), float32] */;
    multiply(%381, %p152) /* ty=Tensor[(3, 3, 128, 128), float32] */
  };
  %383 = (%stage2_unit3_conv2_weight, %x117);
  %384 = (%tensor_059,);
  let %x118: () = vm.invoke_tvm_op(%382, %383, %384) /* ty=() */;
  let %x119: Tensor[(3, 3, 128, 128), float32] = %tensor_059;
  let %storage_060: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][60]) /* ty=Storage[] */;
  let %tensor_060: Tensor[(1, 28, 28, 128), float32] = memory.alloc_tensor(%storage_060, 0 /* ty=int64 */, meta[relay.Constant][60] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][60]) /* ty=Tensor[(1, 28, 28, 128), float32] */;
  %391 = fn (%p060: Tensor[(1, 28, 28, 128), float32], %p153: Tensor[(3, 3, 128, 128), float32], %p223: Tensor[(128), float32], %p319: Tensor[(128), float32], %p417: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 28, 28, 128), float32] {
    %385 = nn.conv2d(%p060, %p153, padding=[1, 1, 1, 1], channels=128, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 128), float32] */;
    %386 = negative(%p223) /* ty=Tensor[(128), float32] */;
    %387 = multiply(%386, %p319) /* ty=Tensor[(128), float32] */;
    %388 = add(%387, %p417) /* ty=Tensor[(128), float32] */;
    %389 = expand_dims(%388, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 128), float32] */;
    %390 = add(%385, %389) /* ty=Tensor[(1, 28, 28, 128), float32] */;
    nn.relu(%390) /* ty=Tensor[(1, 28, 28, 128), float32] */
  };
  %392 = (%x115, %x119, %stage2_unit3_bn3_moving_mean, %x117, %stage2_unit3_bn3_beta);
  %393 = (%tensor_060,);
  let %x120: () = vm.invoke_tvm_op(%391, %392, %393) /* ty=() */;
  let %x121: Tensor[(1, 28, 28, 128), float32] = %tensor_060;
  let %storage_061: Storage[] = memory.alloc_storage(262144 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][61]) /* ty=Storage[] */;
  let %tensor_061: Tensor[(1, 1, 128, 512), float32] = memory.alloc_tensor(%storage_061, 0 /* ty=int64 */, meta[relay.Constant][61] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][61]) /* ty=Tensor[(1, 1, 128, 512), float32] */;
  %394 = fn (%p061: Tensor[(512, 128, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 128, 512), float32] {
    layout_transform(%p061, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 128, 512), float32] */
  };
  %395 = (%stage2_unit3_conv3_weight,);
  %396 = (%tensor_061,);
  let %x122: () = vm.invoke_tvm_op(%394, %395, %396) /* ty=() */;
  let %x123: Tensor[(1, 1, 128, 512), float32] = %tensor_061;
  let %storage_062: Storage[] = memory.alloc_storage(1605632 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][62]) /* ty=Storage[] */;
  let %tensor_062: Tensor[(1, 28, 28, 512), float32] = memory.alloc_tensor(%storage_062, 0 /* ty=int64 */, meta[relay.Constant][62] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][62]) /* ty=Tensor[(1, 28, 28, 512), float32] */;
  %398 = fn (%p062: Tensor[(1, 28, 28, 128), float32], %p154: Tensor[(1, 1, 128, 512), float32], %p224: Tensor[(1, 28, 28, 512), float32], Primitive=1) -> Tensor[(1, 28, 28, 512), float32] {
    %397 = nn.conv2d(%p062, %p154, padding=[0, 0, 0, 0], channels=512, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 512), float32] */;
    add(%397, %p224) /* ty=Tensor[(1, 28, 28, 512), float32] */
  };
  %399 = (%x121, %x123, %x107);
  %400 = (%tensor_062,);
  let %x124: () = vm.invoke_tvm_op(%398, %399, %400) /* ty=() */;
  let %x125: Tensor[(1, 28, 28, 512), float32] = %tensor_062;
  let %storage_063: Storage[] = memory.alloc_storage(1605632 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][63]) /* ty=Storage[] */;
  let %tensor_063: Tensor[(1, 28, 28, 512), float32] = memory.alloc_tensor(%storage_063, 0 /* ty=int64 */, meta[relay.Constant][63] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][63]) /* ty=Tensor[(1, 28, 28, 512), float32] */;
  %412 = fn (%p063: Tensor[(512), float32], %p155: Tensor[(512), float32], %p225: Tensor[(1, 28, 28, 512), float32], %p320: Tensor[(512), float32], %p418: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 28, 28, 512), float32] {
    %401 = add(%p063, 2e-05f /* ty=float32 */) /* ty=Tensor[(512), float32] */;
    %402 = sqrt(%401) /* ty=Tensor[(512), float32] */;
    %403 = divide(1f /* ty=float32 */, %402) /* ty=Tensor[(512), float32] */;
    %404 = multiply(%403, %p155) /* ty=Tensor[(512), float32] */;
    %405 = expand_dims(%404, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %406 = multiply(%p225, %405) /* ty=Tensor[(1, 28, 28, 512), float32] */;
    %407 = negative(%p320) /* ty=Tensor[(512), float32] */;
    %408 = multiply(%407, %404) /* ty=Tensor[(512), float32] */;
    %409 = add(%408, %p418) /* ty=Tensor[(512), float32] */;
    %410 = expand_dims(%409, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %411 = add(%406, %410) /* ty=Tensor[(1, 28, 28, 512), float32] */;
    nn.relu(%411) /* ty=Tensor[(1, 28, 28, 512), float32] */
  };
  %413 = (%stage2_unit4_bn1_moving_var, %stage2_unit4_bn1_gamma, %x125, %stage2_unit4_bn1_moving_mean, %stage2_unit4_bn1_beta);
  %414 = (%tensor_063,);
  let %x126: () = vm.invoke_tvm_op(%412, %413, %414) /* ty=() */;
  let %x127: Tensor[(1, 28, 28, 512), float32] = %tensor_063;
  let %storage_064: Storage[] = memory.alloc_storage(512 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][64]) /* ty=Storage[] */;
  let %tensor_064: Tensor[(128), float32] = memory.alloc_tensor(%storage_064, 0 /* ty=int64 */, meta[relay.Constant][64] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][64]) /* ty=Tensor[(128), float32] */;
  %418 = fn (%p064: Tensor[(128), float32], %p156: Tensor[(128), float32], Primitive=1) -> Tensor[(128), float32] {
    %415 = add(%p064, 2e-05f /* ty=float32 */) /* ty=Tensor[(128), float32] */;
    %416 = sqrt(%415) /* ty=Tensor[(128), float32] */;
    %417 = divide(1f /* ty=float32 */, %416) /* ty=Tensor[(128), float32] */;
    multiply(%417, %p156) /* ty=Tensor[(128), float32] */
  };
  %419 = (%stage2_unit4_bn2_moving_var, %stage2_unit4_bn2_gamma);
  %420 = (%tensor_064,);
  let %x128: () = vm.invoke_tvm_op(%418, %419, %420) /* ty=() */;
  let %x129: Tensor[(128), float32] = %tensor_064;
  let %storage_065: Storage[] = memory.alloc_storage(262144 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][65]) /* ty=Storage[] */;
  let %tensor_065: Tensor[(1, 1, 512, 128), float32] = memory.alloc_tensor(%storage_065, 0 /* ty=int64 */, meta[relay.Constant][65] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][65]) /* ty=Tensor[(1, 1, 512, 128), float32] */;
  %422 = fn (%p065: Tensor[(128, 512, 1, 1), float32], %p157: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 1, 512, 128), float32] {
    %421 = layout_transform(%p065, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 512, 128), float32] */;
    multiply(%421, %p157) /* ty=Tensor[(1, 1, 512, 128), float32] */
  };
  %423 = (%stage2_unit4_conv1_weight, %x129);
  %424 = (%tensor_065,);
  let %x130: () = vm.invoke_tvm_op(%422, %423, %424) /* ty=() */;
  let %x131: Tensor[(1, 1, 512, 128), float32] = %tensor_065;
  let %storage_066: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][66]) /* ty=Storage[] */;
  let %tensor_066: Tensor[(1, 28, 28, 128), float32] = memory.alloc_tensor(%storage_066, 0 /* ty=int64 */, meta[relay.Constant][66] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][66]) /* ty=Tensor[(1, 28, 28, 128), float32] */;
  %431 = fn (%p066: Tensor[(1, 28, 28, 512), float32], %p158: Tensor[(1, 1, 512, 128), float32], %p226: Tensor[(128), float32], %p321: Tensor[(128), float32], %p419: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 28, 28, 128), float32] {
    %425 = nn.conv2d(%p066, %p158, padding=[0, 0, 0, 0], channels=128, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 128), float32] */;
    %426 = negative(%p226) /* ty=Tensor[(128), float32] */;
    %427 = multiply(%426, %p321) /* ty=Tensor[(128), float32] */;
    %428 = add(%427, %p419) /* ty=Tensor[(128), float32] */;
    %429 = expand_dims(%428, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 128), float32] */;
    %430 = add(%425, %429) /* ty=Tensor[(1, 28, 28, 128), float32] */;
    nn.relu(%430) /* ty=Tensor[(1, 28, 28, 128), float32] */
  };
  %432 = (%x127, %x131, %stage2_unit4_bn2_moving_mean, %x129, %stage2_unit4_bn2_beta);
  %433 = (%tensor_066,);
  let %x132: () = vm.invoke_tvm_op(%431, %432, %433) /* ty=() */;
  let %x133: Tensor[(1, 28, 28, 128), float32] = %tensor_066;
  let %storage_067: Storage[] = memory.alloc_storage(512 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][67]) /* ty=Storage[] */;
  let %tensor_067: Tensor[(128), float32] = memory.alloc_tensor(%storage_067, 0 /* ty=int64 */, meta[relay.Constant][67] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][67]) /* ty=Tensor[(128), float32] */;
  %437 = fn (%p067: Tensor[(128), float32], %p159: Tensor[(128), float32], Primitive=1) -> Tensor[(128), float32] {
    %434 = add(%p067, 2e-05f /* ty=float32 */) /* ty=Tensor[(128), float32] */;
    %435 = sqrt(%434) /* ty=Tensor[(128), float32] */;
    %436 = divide(1f /* ty=float32 */, %435) /* ty=Tensor[(128), float32] */;
    multiply(%436, %p159) /* ty=Tensor[(128), float32] */
  };
  %438 = (%stage2_unit4_bn3_moving_var, %stage2_unit4_bn3_gamma);
  %439 = (%tensor_067,);
  let %x134: () = vm.invoke_tvm_op(%437, %438, %439) /* ty=() */;
  let %x135: Tensor[(128), float32] = %tensor_067;
  let %storage_068: Storage[] = memory.alloc_storage(589824 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][68]) /* ty=Storage[] */;
  let %tensor_068: Tensor[(3, 3, 128, 128), float32] = memory.alloc_tensor(%storage_068, 0 /* ty=int64 */, meta[relay.Constant][68] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][68]) /* ty=Tensor[(3, 3, 128, 128), float32] */;
  %441 = fn (%p068: Tensor[(128, 128, 3, 3), float32], %p160: Tensor[(128), float32], Primitive=1) -> Tensor[(3, 3, 128, 128), float32] {
    %440 = layout_transform(%p068, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 128, 128), float32] */;
    multiply(%440, %p160) /* ty=Tensor[(3, 3, 128, 128), float32] */
  };
  %442 = (%stage2_unit4_conv2_weight, %x135);
  %443 = (%tensor_068,);
  let %x136: () = vm.invoke_tvm_op(%441, %442, %443) /* ty=() */;
  let %x137: Tensor[(3, 3, 128, 128), float32] = %tensor_068;
  let %storage_069: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][69]) /* ty=Storage[] */;
  let %tensor_069: Tensor[(1, 28, 28, 128), float32] = memory.alloc_tensor(%storage_069, 0 /* ty=int64 */, meta[relay.Constant][69] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][69]) /* ty=Tensor[(1, 28, 28, 128), float32] */;
  %450 = fn (%p069: Tensor[(1, 28, 28, 128), float32], %p161: Tensor[(3, 3, 128, 128), float32], %p227: Tensor[(128), float32], %p322: Tensor[(128), float32], %p420: Tensor[(128), float32], Primitive=1) -> Tensor[(1, 28, 28, 128), float32] {
    %444 = nn.conv2d(%p069, %p161, padding=[1, 1, 1, 1], channels=128, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 128), float32] */;
    %445 = negative(%p227) /* ty=Tensor[(128), float32] */;
    %446 = multiply(%445, %p322) /* ty=Tensor[(128), float32] */;
    %447 = add(%446, %p420) /* ty=Tensor[(128), float32] */;
    %448 = expand_dims(%447, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 128), float32] */;
    %449 = add(%444, %448) /* ty=Tensor[(1, 28, 28, 128), float32] */;
    nn.relu(%449) /* ty=Tensor[(1, 28, 28, 128), float32] */
  };
  %451 = (%x133, %x137, %stage2_unit4_bn3_moving_mean, %x135, %stage2_unit4_bn3_beta);
  %452 = (%tensor_069,);
  let %x138: () = vm.invoke_tvm_op(%450, %451, %452) /* ty=() */;
  let %x139: Tensor[(1, 28, 28, 128), float32] = %tensor_069;
  let %storage_070: Storage[] = memory.alloc_storage(262144 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][70]) /* ty=Storage[] */;
  let %tensor_070: Tensor[(1, 1, 128, 512), float32] = memory.alloc_tensor(%storage_070, 0 /* ty=int64 */, meta[relay.Constant][70] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][70]) /* ty=Tensor[(1, 1, 128, 512), float32] */;
  %453 = fn (%p070: Tensor[(512, 128, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 128, 512), float32] {
    layout_transform(%p070, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 128, 512), float32] */
  };
  %454 = (%stage2_unit4_conv3_weight,);
  %455 = (%tensor_070,);
  let %x140: () = vm.invoke_tvm_op(%453, %454, %455) /* ty=() */;
  let %x141: Tensor[(1, 1, 128, 512), float32] = %tensor_070;
  let %storage_071: Storage[] = memory.alloc_storage(2048 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][71]) /* ty=Storage[] */;
  let %tensor_071: Tensor[(512), float32] = memory.alloc_tensor(%storage_071, 0 /* ty=int64 */, meta[relay.Constant][71] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][71]) /* ty=Tensor[(512), float32] */;
  %459 = fn (%p071: Tensor[(512), float32], %p162: Tensor[(512), float32], Primitive=1) -> Tensor[(512), float32] {
    %456 = add(%p071, 2e-05f /* ty=float32 */) /* ty=Tensor[(512), float32] */;
    %457 = sqrt(%456) /* ty=Tensor[(512), float32] */;
    %458 = divide(1f /* ty=float32 */, %457) /* ty=Tensor[(512), float32] */;
    multiply(%458, %p162) /* ty=Tensor[(512), float32] */
  };
  %460 = (%stage3_unit1_bn1_moving_var, %stage3_unit1_bn1_gamma);
  %461 = (%tensor_071,);
  let %x142: () = vm.invoke_tvm_op(%459, %460, %461) /* ty=() */;
  let %x143: Tensor[(512), float32] = %tensor_071;
  let %storage_072: Storage[] = memory.alloc_storage(1605632 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][72]) /* ty=Storage[] */;
  let %tensor_072: Tensor[(1, 28, 28, 512), float32] = memory.alloc_tensor(%storage_072, 0 /* ty=int64 */, meta[relay.Constant][72] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][72]) /* ty=Tensor[(1, 28, 28, 512), float32] */;
  %471 = fn (%p072: Tensor[(1, 28, 28, 128), float32], %p163: Tensor[(1, 1, 128, 512), float32], %p228: Tensor[(1, 28, 28, 512), float32], %p323: Tensor[(512), float32], %p421: Tensor[(512), float32], %p51: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 28, 28, 512), float32] {
    %462 = nn.conv2d(%p072, %p163, padding=[0, 0, 0, 0], channels=512, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 28, 28, 512), float32] */;
    %463 = add(%462, %p228) /* ty=Tensor[(1, 28, 28, 512), float32] */;
    %464 = expand_dims(%p323, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %465 = multiply(%463, %464) /* ty=Tensor[(1, 28, 28, 512), float32] */;
    %466 = negative(%p421) /* ty=Tensor[(512), float32] */;
    %467 = multiply(%466, %p323) /* ty=Tensor[(512), float32] */;
    %468 = add(%467, %p51) /* ty=Tensor[(512), float32] */;
    %469 = expand_dims(%468, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %470 = add(%465, %469) /* ty=Tensor[(1, 28, 28, 512), float32] */;
    nn.relu(%470) /* ty=Tensor[(1, 28, 28, 512), float32] */
  };
  %472 = (%x139, %x141, %x125, %x143, %stage3_unit1_bn1_moving_mean, %stage3_unit1_bn1_beta);
  %473 = (%tensor_072,);
  let %x144: () = vm.invoke_tvm_op(%471, %472, %473) /* ty=() */;
  let %x145: Tensor[(1, 28, 28, 512), float32] = %tensor_072;
  let %storage_073: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][73]) /* ty=Storage[] */;
  let %tensor_073: Tensor[(256), float32] = memory.alloc_tensor(%storage_073, 0 /* ty=int64 */, meta[relay.Constant][73] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][73]) /* ty=Tensor[(256), float32] */;
  %477 = fn (%p073: Tensor[(256), float32], %p164: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %474 = add(%p073, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %475 = sqrt(%474) /* ty=Tensor[(256), float32] */;
    %476 = divide(1f /* ty=float32 */, %475) /* ty=Tensor[(256), float32] */;
    multiply(%476, %p164) /* ty=Tensor[(256), float32] */
  };
  %478 = (%stage3_unit1_bn2_moving_var, %stage3_unit1_bn2_gamma);
  %479 = (%tensor_073,);
  let %x146: () = vm.invoke_tvm_op(%477, %478, %479) /* ty=() */;
  let %x147: Tensor[(256), float32] = %tensor_073;
  let %storage_074: Storage[] = memory.alloc_storage(524288 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][74]) /* ty=Storage[] */;
  let %tensor_074: Tensor[(1, 1, 512, 256), float32] = memory.alloc_tensor(%storage_074, 0 /* ty=int64 */, meta[relay.Constant][74] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][74]) /* ty=Tensor[(1, 1, 512, 256), float32] */;
  %481 = fn (%p074: Tensor[(256, 512, 1, 1), float32], %p165: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 1, 512, 256), float32] {
    %480 = layout_transform(%p074, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 512, 256), float32] */;
    multiply(%480, %p165) /* ty=Tensor[(1, 1, 512, 256), float32] */
  };
  %482 = (%stage3_unit1_conv1_weight, %x147);
  %483 = (%tensor_074,);
  let %x148: () = vm.invoke_tvm_op(%481, %482, %483) /* ty=() */;
  let %x149: Tensor[(1, 1, 512, 256), float32] = %tensor_074;
  let %storage_075: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][75]) /* ty=Storage[] */;
  let %tensor_075: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_075, 0 /* ty=int64 */, meta[relay.Constant][75] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][75]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %490 = fn (%p075: Tensor[(1, 28, 28, 512), float32], %p166: Tensor[(1, 1, 512, 256), float32], %p229: Tensor[(256), float32], %p324: Tensor[(256), float32], %p422: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %484 = nn.conv2d(%p075, %p166, strides=[2, 2], padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %485 = negative(%p229) /* ty=Tensor[(256), float32] */;
    %486 = multiply(%485, %p324) /* ty=Tensor[(256), float32] */;
    %487 = add(%486, %p422) /* ty=Tensor[(256), float32] */;
    %488 = expand_dims(%487, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %489 = add(%484, %488) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%489) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %491 = (%x145, %x149, %stage3_unit1_bn2_moving_mean, %x147, %stage3_unit1_bn2_beta);
  %492 = (%tensor_075,);
  let %x150: () = vm.invoke_tvm_op(%490, %491, %492) /* ty=() */;
  let %x151: Tensor[(1, 14, 14, 256), float32] = %tensor_075;
  let %storage_076: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][76]) /* ty=Storage[] */;
  let %tensor_076: Tensor[(256), float32] = memory.alloc_tensor(%storage_076, 0 /* ty=int64 */, meta[relay.Constant][76] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][76]) /* ty=Tensor[(256), float32] */;
  %496 = fn (%p076: Tensor[(256), float32], %p167: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %493 = add(%p076, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %494 = sqrt(%493) /* ty=Tensor[(256), float32] */;
    %495 = divide(1f /* ty=float32 */, %494) /* ty=Tensor[(256), float32] */;
    multiply(%495, %p167) /* ty=Tensor[(256), float32] */
  };
  %497 = (%stage3_unit1_bn3_moving_var, %stage3_unit1_bn3_gamma);
  %498 = (%tensor_076,);
  let %x152: () = vm.invoke_tvm_op(%496, %497, %498) /* ty=() */;
  let %x153: Tensor[(256), float32] = %tensor_076;
  let %storage_077: Storage[] = memory.alloc_storage(2359296 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][77]) /* ty=Storage[] */;
  let %tensor_077: Tensor[(3, 3, 256, 256), float32] = memory.alloc_tensor(%storage_077, 0 /* ty=int64 */, meta[relay.Constant][77] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][77]) /* ty=Tensor[(3, 3, 256, 256), float32] */;
  %500 = fn (%p077: Tensor[(256, 256, 3, 3), float32], %p168: Tensor[(256), float32], Primitive=1) -> Tensor[(3, 3, 256, 256), float32] {
    %499 = layout_transform(%p077, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 256, 256), float32] */;
    multiply(%499, %p168) /* ty=Tensor[(3, 3, 256, 256), float32] */
  };
  %501 = (%stage3_unit1_conv2_weight, %x153);
  %502 = (%tensor_077,);
  let %x154: () = vm.invoke_tvm_op(%500, %501, %502) /* ty=() */;
  let %x155: Tensor[(3, 3, 256, 256), float32] = %tensor_077;
  let %storage_078: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][78]) /* ty=Storage[] */;
  let %tensor_078: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_078, 0 /* ty=int64 */, meta[relay.Constant][78] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][78]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %509 = fn (%p078: Tensor[(1, 14, 14, 256), float32], %p169: Tensor[(3, 3, 256, 256), float32], %p230: Tensor[(256), float32], %p325: Tensor[(256), float32], %p423: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %503 = nn.conv2d(%p078, %p169, padding=[1, 1, 1, 1], channels=256, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %504 = negative(%p230) /* ty=Tensor[(256), float32] */;
    %505 = multiply(%504, %p325) /* ty=Tensor[(256), float32] */;
    %506 = add(%505, %p423) /* ty=Tensor[(256), float32] */;
    %507 = expand_dims(%506, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %508 = add(%503, %507) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%508) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %510 = (%x151, %x155, %stage3_unit1_bn3_moving_mean, %x153, %stage3_unit1_bn3_beta);
  %511 = (%tensor_078,);
  let %x156: () = vm.invoke_tvm_op(%509, %510, %511) /* ty=() */;
  let %x157: Tensor[(1, 14, 14, 256), float32] = %tensor_078;
  let %storage_079: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][79]) /* ty=Storage[] */;
  let %tensor_079: Tensor[(1, 1, 256, 1024), float32] = memory.alloc_tensor(%storage_079, 0 /* ty=int64 */, meta[relay.Constant][79] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][79]) /* ty=Tensor[(1, 1, 256, 1024), float32] */;
  %512 = fn (%p079: Tensor[(1024, 256, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 256, 1024), float32] {
    layout_transform(%p079, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 256, 1024), float32] */
  };
  %513 = (%stage3_unit1_conv3_weight,);
  %514 = (%tensor_079,);
  let %x158: () = vm.invoke_tvm_op(%512, %513, %514) /* ty=() */;
  let %x159: Tensor[(1, 1, 256, 1024), float32] = %tensor_079;
  let %storage_080: Storage[] = memory.alloc_storage(2097152 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][80]) /* ty=Storage[] */;
  let %tensor_080: Tensor[(1, 1, 512, 1024), float32] = memory.alloc_tensor(%storage_080, 0 /* ty=int64 */, meta[relay.Constant][80] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][80]) /* ty=Tensor[(1, 1, 512, 1024), float32] */;
  %515 = fn (%p080: Tensor[(1024, 512, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 512, 1024), float32] {
    layout_transform(%p080, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 512, 1024), float32] */
  };
  %516 = (%stage3_unit1_sc_weight,);
  %517 = (%tensor_080,);
  let %x160: () = vm.invoke_tvm_op(%515, %516, %517) /* ty=() */;
  let %x161: Tensor[(1, 1, 512, 1024), float32] = %tensor_080;
  let %storage_081: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][81]) /* ty=Storage[] */;
  let %tensor_081: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_081, 0 /* ty=int64 */, meta[relay.Constant][81] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][81]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %518 = fn (%p081: Tensor[(1, 28, 28, 512), float32], %p170: Tensor[(1, 1, 512, 1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    nn.conv2d(%p081, %p170, strides=[2, 2], padding=[0, 0, 0, 0], channels=1024, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %519 = (%x145, %x161);
  %520 = (%tensor_081,);
  let %x162: () = vm.invoke_tvm_op(%518, %519, %520) /* ty=() */;
  let %x163: Tensor[(1, 14, 14, 1024), float32] = %tensor_081;
  let %storage_082: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][82]) /* ty=Storage[] */;
  let %tensor_082: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_082, 0 /* ty=int64 */, meta[relay.Constant][82] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][82]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %522 = fn (%p082: Tensor[(1, 14, 14, 256), float32], %p171: Tensor[(1, 1, 256, 1024), float32], %p231: Tensor[(1, 14, 14, 1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %521 = nn.conv2d(%p082, %p171, padding=[0, 0, 0, 0], channels=1024, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    add(%521, %p231) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %523 = (%x157, %x159, %x163);
  %524 = (%tensor_082,);
  let %x164: () = vm.invoke_tvm_op(%522, %523, %524) /* ty=() */;
  let %x165: Tensor[(1, 14, 14, 1024), float32] = %tensor_082;
  let %storage_083: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][83]) /* ty=Storage[] */;
  let %tensor_083: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_083, 0 /* ty=int64 */, meta[relay.Constant][83] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][83]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %536 = fn (%p083: Tensor[(1024), float32], %p172: Tensor[(1024), float32], %p232: Tensor[(1, 14, 14, 1024), float32], %p326: Tensor[(1024), float32], %p424: Tensor[(1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %525 = add(%p083, 2e-05f /* ty=float32 */) /* ty=Tensor[(1024), float32] */;
    %526 = sqrt(%525) /* ty=Tensor[(1024), float32] */;
    %527 = divide(1f /* ty=float32 */, %526) /* ty=Tensor[(1024), float32] */;
    %528 = multiply(%527, %p172) /* ty=Tensor[(1024), float32] */;
    %529 = expand_dims(%528, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %530 = multiply(%p232, %529) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    %531 = negative(%p326) /* ty=Tensor[(1024), float32] */;
    %532 = multiply(%531, %528) /* ty=Tensor[(1024), float32] */;
    %533 = add(%532, %p424) /* ty=Tensor[(1024), float32] */;
    %534 = expand_dims(%533, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %535 = add(%530, %534) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    nn.relu(%535) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %537 = (%stage3_unit2_bn1_moving_var, %stage3_unit2_bn1_gamma, %x165, %stage3_unit2_bn1_moving_mean, %stage3_unit2_bn1_beta);
  %538 = (%tensor_083,);
  let %x166: () = vm.invoke_tvm_op(%536, %537, %538) /* ty=() */;
  let %x167: Tensor[(1, 14, 14, 1024), float32] = %tensor_083;
  let %storage_084: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][84]) /* ty=Storage[] */;
  let %tensor_084: Tensor[(256), float32] = memory.alloc_tensor(%storage_084, 0 /* ty=int64 */, meta[relay.Constant][84] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][84]) /* ty=Tensor[(256), float32] */;
  %542 = fn (%p084: Tensor[(256), float32], %p173: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %539 = add(%p084, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %540 = sqrt(%539) /* ty=Tensor[(256), float32] */;
    %541 = divide(1f /* ty=float32 */, %540) /* ty=Tensor[(256), float32] */;
    multiply(%541, %p173) /* ty=Tensor[(256), float32] */
  };
  %543 = (%stage3_unit2_bn2_moving_var, %stage3_unit2_bn2_gamma);
  %544 = (%tensor_084,);
  let %x168: () = vm.invoke_tvm_op(%542, %543, %544) /* ty=() */;
  let %x169: Tensor[(256), float32] = %tensor_084;
  let %storage_085: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][85]) /* ty=Storage[] */;
  let %tensor_085: Tensor[(1, 1, 1024, 256), float32] = memory.alloc_tensor(%storage_085, 0 /* ty=int64 */, meta[relay.Constant][85] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][85]) /* ty=Tensor[(1, 1, 1024, 256), float32] */;
  %546 = fn (%p085: Tensor[(256, 1024, 1, 1), float32], %p174: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 1, 1024, 256), float32] {
    %545 = layout_transform(%p085, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 1024, 256), float32] */;
    multiply(%545, %p174) /* ty=Tensor[(1, 1, 1024, 256), float32] */
  };
  %547 = (%stage3_unit2_conv1_weight, %x169);
  %548 = (%tensor_085,);
  let %x170: () = vm.invoke_tvm_op(%546, %547, %548) /* ty=() */;
  let %x171: Tensor[(1, 1, 1024, 256), float32] = %tensor_085;
  let %storage_086: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][86]) /* ty=Storage[] */;
  let %tensor_086: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_086, 0 /* ty=int64 */, meta[relay.Constant][86] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][86]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %555 = fn (%p086: Tensor[(1, 14, 14, 1024), float32], %p175: Tensor[(1, 1, 1024, 256), float32], %p233: Tensor[(256), float32], %p327: Tensor[(256), float32], %p425: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %549 = nn.conv2d(%p086, %p175, padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %550 = negative(%p233) /* ty=Tensor[(256), float32] */;
    %551 = multiply(%550, %p327) /* ty=Tensor[(256), float32] */;
    %552 = add(%551, %p425) /* ty=Tensor[(256), float32] */;
    %553 = expand_dims(%552, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %554 = add(%549, %553) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%554) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %556 = (%x167, %x171, %stage3_unit2_bn2_moving_mean, %x169, %stage3_unit2_bn2_beta);
  %557 = (%tensor_086,);
  let %x172: () = vm.invoke_tvm_op(%555, %556, %557) /* ty=() */;
  let %x173: Tensor[(1, 14, 14, 256), float32] = %tensor_086;
  let %storage_087: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][87]) /* ty=Storage[] */;
  let %tensor_087: Tensor[(256), float32] = memory.alloc_tensor(%storage_087, 0 /* ty=int64 */, meta[relay.Constant][87] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][87]) /* ty=Tensor[(256), float32] */;
  %561 = fn (%p087: Tensor[(256), float32], %p176: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %558 = add(%p087, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %559 = sqrt(%558) /* ty=Tensor[(256), float32] */;
    %560 = divide(1f /* ty=float32 */, %559) /* ty=Tensor[(256), float32] */;
    multiply(%560, %p176) /* ty=Tensor[(256), float32] */
  };
  %562 = (%stage3_unit2_bn3_moving_var, %stage3_unit2_bn3_gamma);
  %563 = (%tensor_087,);
  let %x174: () = vm.invoke_tvm_op(%561, %562, %563) /* ty=() */;
  let %x175: Tensor[(256), float32] = %tensor_087;
  let %storage_088: Storage[] = memory.alloc_storage(2359296 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][88]) /* ty=Storage[] */;
  let %tensor_088: Tensor[(3, 3, 256, 256), float32] = memory.alloc_tensor(%storage_088, 0 /* ty=int64 */, meta[relay.Constant][88] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][88]) /* ty=Tensor[(3, 3, 256, 256), float32] */;
  %565 = fn (%p088: Tensor[(256, 256, 3, 3), float32], %p177: Tensor[(256), float32], Primitive=1) -> Tensor[(3, 3, 256, 256), float32] {
    %564 = layout_transform(%p088, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 256, 256), float32] */;
    multiply(%564, %p177) /* ty=Tensor[(3, 3, 256, 256), float32] */
  };
  %566 = (%stage3_unit2_conv2_weight, %x175);
  %567 = (%tensor_088,);
  let %x176: () = vm.invoke_tvm_op(%565, %566, %567) /* ty=() */;
  let %x177: Tensor[(3, 3, 256, 256), float32] = %tensor_088;
  let %storage_089: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][89]) /* ty=Storage[] */;
  let %tensor_089: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_089, 0 /* ty=int64 */, meta[relay.Constant][89] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][89]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %574 = fn (%p089: Tensor[(1, 14, 14, 256), float32], %p178: Tensor[(3, 3, 256, 256), float32], %p234: Tensor[(256), float32], %p328: Tensor[(256), float32], %p426: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %568 = nn.conv2d(%p089, %p178, padding=[1, 1, 1, 1], channels=256, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %569 = negative(%p234) /* ty=Tensor[(256), float32] */;
    %570 = multiply(%569, %p328) /* ty=Tensor[(256), float32] */;
    %571 = add(%570, %p426) /* ty=Tensor[(256), float32] */;
    %572 = expand_dims(%571, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %573 = add(%568, %572) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%573) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %575 = (%x173, %x177, %stage3_unit2_bn3_moving_mean, %x175, %stage3_unit2_bn3_beta);
  %576 = (%tensor_089,);
  let %x178: () = vm.invoke_tvm_op(%574, %575, %576) /* ty=() */;
  let %x179: Tensor[(1, 14, 14, 256), float32] = %tensor_089;
  let %storage_090: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][90]) /* ty=Storage[] */;
  let %tensor_090: Tensor[(1, 1, 256, 1024), float32] = memory.alloc_tensor(%storage_090, 0 /* ty=int64 */, meta[relay.Constant][90] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][90]) /* ty=Tensor[(1, 1, 256, 1024), float32] */;
  %577 = fn (%p090: Tensor[(1024, 256, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 256, 1024), float32] {
    layout_transform(%p090, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 256, 1024), float32] */
  };
  %578 = (%stage3_unit2_conv3_weight,);
  %579 = (%tensor_090,);
  let %x180: () = vm.invoke_tvm_op(%577, %578, %579) /* ty=() */;
  let %x181: Tensor[(1, 1, 256, 1024), float32] = %tensor_090;
  let %storage_091: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][91]) /* ty=Storage[] */;
  let %tensor_091: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_091, 0 /* ty=int64 */, meta[relay.Constant][91] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][91]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %581 = fn (%p091: Tensor[(1, 14, 14, 256), float32], %p179: Tensor[(1, 1, 256, 1024), float32], %p235: Tensor[(1, 14, 14, 1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %580 = nn.conv2d(%p091, %p179, padding=[0, 0, 0, 0], channels=1024, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    add(%580, %p235) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %582 = (%x179, %x181, %x165);
  %583 = (%tensor_091,);
  let %x182: () = vm.invoke_tvm_op(%581, %582, %583) /* ty=() */;
  let %x183: Tensor[(1, 14, 14, 1024), float32] = %tensor_091;
  let %storage_092: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][92]) /* ty=Storage[] */;
  let %tensor_092: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_092, 0 /* ty=int64 */, meta[relay.Constant][92] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][92]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %595 = fn (%p092: Tensor[(1024), float32], %p180: Tensor[(1024), float32], %p236: Tensor[(1, 14, 14, 1024), float32], %p329: Tensor[(1024), float32], %p427: Tensor[(1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %584 = add(%p092, 2e-05f /* ty=float32 */) /* ty=Tensor[(1024), float32] */;
    %585 = sqrt(%584) /* ty=Tensor[(1024), float32] */;
    %586 = divide(1f /* ty=float32 */, %585) /* ty=Tensor[(1024), float32] */;
    %587 = multiply(%586, %p180) /* ty=Tensor[(1024), float32] */;
    %588 = expand_dims(%587, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %589 = multiply(%p236, %588) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    %590 = negative(%p329) /* ty=Tensor[(1024), float32] */;
    %591 = multiply(%590, %587) /* ty=Tensor[(1024), float32] */;
    %592 = add(%591, %p427) /* ty=Tensor[(1024), float32] */;
    %593 = expand_dims(%592, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %594 = add(%589, %593) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    nn.relu(%594) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %596 = (%stage3_unit3_bn1_moving_var, %stage3_unit3_bn1_gamma, %x183, %stage3_unit3_bn1_moving_mean, %stage3_unit3_bn1_beta);
  %597 = (%tensor_092,);
  let %x184: () = vm.invoke_tvm_op(%595, %596, %597) /* ty=() */;
  let %x185: Tensor[(1, 14, 14, 1024), float32] = %tensor_092;
  let %storage_093: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][93]) /* ty=Storage[] */;
  let %tensor_093: Tensor[(256), float32] = memory.alloc_tensor(%storage_093, 0 /* ty=int64 */, meta[relay.Constant][93] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][93]) /* ty=Tensor[(256), float32] */;
  %601 = fn (%p093: Tensor[(256), float32], %p181: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %598 = add(%p093, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %599 = sqrt(%598) /* ty=Tensor[(256), float32] */;
    %600 = divide(1f /* ty=float32 */, %599) /* ty=Tensor[(256), float32] */;
    multiply(%600, %p181) /* ty=Tensor[(256), float32] */
  };
  %602 = (%stage3_unit3_bn2_moving_var, %stage3_unit3_bn2_gamma);
  %603 = (%tensor_093,);
  let %x186: () = vm.invoke_tvm_op(%601, %602, %603) /* ty=() */;
  let %x187: Tensor[(256), float32] = %tensor_093;
  let %storage_094: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][94]) /* ty=Storage[] */;
  let %tensor_094: Tensor[(1, 1, 1024, 256), float32] = memory.alloc_tensor(%storage_094, 0 /* ty=int64 */, meta[relay.Constant][94] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][94]) /* ty=Tensor[(1, 1, 1024, 256), float32] */;
  %605 = fn (%p094: Tensor[(256, 1024, 1, 1), float32], %p182: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 1, 1024, 256), float32] {
    %604 = layout_transform(%p094, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 1024, 256), float32] */;
    multiply(%604, %p182) /* ty=Tensor[(1, 1, 1024, 256), float32] */
  };
  %606 = (%stage3_unit3_conv1_weight, %x187);
  %607 = (%tensor_094,);
  let %x188: () = vm.invoke_tvm_op(%605, %606, %607) /* ty=() */;
  let %x189: Tensor[(1, 1, 1024, 256), float32] = %tensor_094;
  let %storage_095: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][95]) /* ty=Storage[] */;
  let %tensor_095: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_095, 0 /* ty=int64 */, meta[relay.Constant][95] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][95]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %614 = fn (%p095: Tensor[(1, 14, 14, 1024), float32], %p183: Tensor[(1, 1, 1024, 256), float32], %p237: Tensor[(256), float32], %p330: Tensor[(256), float32], %p428: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %608 = nn.conv2d(%p095, %p183, padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %609 = negative(%p237) /* ty=Tensor[(256), float32] */;
    %610 = multiply(%609, %p330) /* ty=Tensor[(256), float32] */;
    %611 = add(%610, %p428) /* ty=Tensor[(256), float32] */;
    %612 = expand_dims(%611, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %613 = add(%608, %612) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%613) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %615 = (%x185, %x189, %stage3_unit3_bn2_moving_mean, %x187, %stage3_unit3_bn2_beta);
  %616 = (%tensor_095,);
  let %x190: () = vm.invoke_tvm_op(%614, %615, %616) /* ty=() */;
  let %x191: Tensor[(1, 14, 14, 256), float32] = %tensor_095;
  let %storage_096: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][96]) /* ty=Storage[] */;
  let %tensor_096: Tensor[(256), float32] = memory.alloc_tensor(%storage_096, 0 /* ty=int64 */, meta[relay.Constant][96] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][96]) /* ty=Tensor[(256), float32] */;
  %620 = fn (%p096: Tensor[(256), float32], %p184: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %617 = add(%p096, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %618 = sqrt(%617) /* ty=Tensor[(256), float32] */;
    %619 = divide(1f /* ty=float32 */, %618) /* ty=Tensor[(256), float32] */;
    multiply(%619, %p184) /* ty=Tensor[(256), float32] */
  };
  %621 = (%stage3_unit3_bn3_moving_var, %stage3_unit3_bn3_gamma);
  %622 = (%tensor_096,);
  let %x192: () = vm.invoke_tvm_op(%620, %621, %622) /* ty=() */;
  let %x193: Tensor[(256), float32] = %tensor_096;
  let %storage_097: Storage[] = memory.alloc_storage(2359296 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][97]) /* ty=Storage[] */;
  let %tensor_097: Tensor[(3, 3, 256, 256), float32] = memory.alloc_tensor(%storage_097, 0 /* ty=int64 */, meta[relay.Constant][97] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][97]) /* ty=Tensor[(3, 3, 256, 256), float32] */;
  %624 = fn (%p097: Tensor[(256, 256, 3, 3), float32], %p185: Tensor[(256), float32], Primitive=1) -> Tensor[(3, 3, 256, 256), float32] {
    %623 = layout_transform(%p097, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 256, 256), float32] */;
    multiply(%623, %p185) /* ty=Tensor[(3, 3, 256, 256), float32] */
  };
  %625 = (%stage3_unit3_conv2_weight, %x193);
  %626 = (%tensor_097,);
  let %x194: () = vm.invoke_tvm_op(%624, %625, %626) /* ty=() */;
  let %x195: Tensor[(3, 3, 256, 256), float32] = %tensor_097;
  let %storage_098: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][98]) /* ty=Storage[] */;
  let %tensor_098: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_098, 0 /* ty=int64 */, meta[relay.Constant][98] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][98]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %633 = fn (%p098: Tensor[(1, 14, 14, 256), float32], %p186: Tensor[(3, 3, 256, 256), float32], %p238: Tensor[(256), float32], %p331: Tensor[(256), float32], %p429: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %627 = nn.conv2d(%p098, %p186, padding=[1, 1, 1, 1], channels=256, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %628 = negative(%p238) /* ty=Tensor[(256), float32] */;
    %629 = multiply(%628, %p331) /* ty=Tensor[(256), float32] */;
    %630 = add(%629, %p429) /* ty=Tensor[(256), float32] */;
    %631 = expand_dims(%630, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %632 = add(%627, %631) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%632) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %634 = (%x191, %x195, %stage3_unit3_bn3_moving_mean, %x193, %stage3_unit3_bn3_beta);
  %635 = (%tensor_098,);
  let %x196: () = vm.invoke_tvm_op(%633, %634, %635) /* ty=() */;
  let %x197: Tensor[(1, 14, 14, 256), float32] = %tensor_098;
  let %storage_099: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][99]) /* ty=Storage[] */;
  let %tensor_099: Tensor[(1, 1, 256, 1024), float32] = memory.alloc_tensor(%storage_099, 0 /* ty=int64 */, meta[relay.Constant][99] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][99]) /* ty=Tensor[(1, 1, 256, 1024), float32] */;
  %636 = fn (%p099: Tensor[(1024, 256, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 256, 1024), float32] {
    layout_transform(%p099, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 256, 1024), float32] */
  };
  %637 = (%stage3_unit3_conv3_weight,);
  %638 = (%tensor_099,);
  let %x198: () = vm.invoke_tvm_op(%636, %637, %638) /* ty=() */;
  let %x199: Tensor[(1, 1, 256, 1024), float32] = %tensor_099;
  let %storage_0100: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][100]) /* ty=Storage[] */;
  let %tensor_0100: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_0100, 0 /* ty=int64 */, meta[relay.Constant][100] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][100]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %640 = fn (%p0100: Tensor[(1, 14, 14, 256), float32], %p187: Tensor[(1, 1, 256, 1024), float32], %p239: Tensor[(1, 14, 14, 1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %639 = nn.conv2d(%p0100, %p187, padding=[0, 0, 0, 0], channels=1024, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    add(%639, %p239) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %641 = (%x197, %x199, %x183);
  %642 = (%tensor_0100,);
  let %x200: () = vm.invoke_tvm_op(%640, %641, %642) /* ty=() */;
  let %x201: Tensor[(1, 14, 14, 1024), float32] = %tensor_0100;
  let %storage_0101: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][101]) /* ty=Storage[] */;
  let %tensor_0101: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_0101, 0 /* ty=int64 */, meta[relay.Constant][101] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][101]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %654 = fn (%p0101: Tensor[(1024), float32], %p188: Tensor[(1024), float32], %p240: Tensor[(1, 14, 14, 1024), float32], %p332: Tensor[(1024), float32], %p430: Tensor[(1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %643 = add(%p0101, 2e-05f /* ty=float32 */) /* ty=Tensor[(1024), float32] */;
    %644 = sqrt(%643) /* ty=Tensor[(1024), float32] */;
    %645 = divide(1f /* ty=float32 */, %644) /* ty=Tensor[(1024), float32] */;
    %646 = multiply(%645, %p188) /* ty=Tensor[(1024), float32] */;
    %647 = expand_dims(%646, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %648 = multiply(%p240, %647) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    %649 = negative(%p332) /* ty=Tensor[(1024), float32] */;
    %650 = multiply(%649, %646) /* ty=Tensor[(1024), float32] */;
    %651 = add(%650, %p430) /* ty=Tensor[(1024), float32] */;
    %652 = expand_dims(%651, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %653 = add(%648, %652) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    nn.relu(%653) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %655 = (%stage3_unit4_bn1_moving_var, %stage3_unit4_bn1_gamma, %x201, %stage3_unit4_bn1_moving_mean, %stage3_unit4_bn1_beta);
  %656 = (%tensor_0101,);
  let %x202: () = vm.invoke_tvm_op(%654, %655, %656) /* ty=() */;
  let %x203: Tensor[(1, 14, 14, 1024), float32] = %tensor_0101;
  let %storage_0102: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][102]) /* ty=Storage[] */;
  let %tensor_0102: Tensor[(256), float32] = memory.alloc_tensor(%storage_0102, 0 /* ty=int64 */, meta[relay.Constant][102] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][102]) /* ty=Tensor[(256), float32] */;
  %660 = fn (%p0102: Tensor[(256), float32], %p189: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %657 = add(%p0102, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %658 = sqrt(%657) /* ty=Tensor[(256), float32] */;
    %659 = divide(1f /* ty=float32 */, %658) /* ty=Tensor[(256), float32] */;
    multiply(%659, %p189) /* ty=Tensor[(256), float32] */
  };
  %661 = (%stage3_unit4_bn2_moving_var, %stage3_unit4_bn2_gamma);
  %662 = (%tensor_0102,);
  let %x204: () = vm.invoke_tvm_op(%660, %661, %662) /* ty=() */;
  let %x205: Tensor[(256), float32] = %tensor_0102;
  let %storage_0103: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][103]) /* ty=Storage[] */;
  let %tensor_0103: Tensor[(1, 1, 1024, 256), float32] = memory.alloc_tensor(%storage_0103, 0 /* ty=int64 */, meta[relay.Constant][103] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][103]) /* ty=Tensor[(1, 1, 1024, 256), float32] */;
  %664 = fn (%p0103: Tensor[(256, 1024, 1, 1), float32], %p190: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 1, 1024, 256), float32] {
    %663 = layout_transform(%p0103, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 1024, 256), float32] */;
    multiply(%663, %p190) /* ty=Tensor[(1, 1, 1024, 256), float32] */
  };
  %665 = (%stage3_unit4_conv1_weight, %x205);
  %666 = (%tensor_0103,);
  let %x206: () = vm.invoke_tvm_op(%664, %665, %666) /* ty=() */;
  let %x207: Tensor[(1, 1, 1024, 256), float32] = %tensor_0103;
  let %storage_0104: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][104]) /* ty=Storage[] */;
  let %tensor_0104: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_0104, 0 /* ty=int64 */, meta[relay.Constant][104] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][104]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %673 = fn (%p0104: Tensor[(1, 14, 14, 1024), float32], %p191: Tensor[(1, 1, 1024, 256), float32], %p241: Tensor[(256), float32], %p333: Tensor[(256), float32], %p431: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %667 = nn.conv2d(%p0104, %p191, padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %668 = negative(%p241) /* ty=Tensor[(256), float32] */;
    %669 = multiply(%668, %p333) /* ty=Tensor[(256), float32] */;
    %670 = add(%669, %p431) /* ty=Tensor[(256), float32] */;
    %671 = expand_dims(%670, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %672 = add(%667, %671) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%672) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %674 = (%x203, %x207, %stage3_unit4_bn2_moving_mean, %x205, %stage3_unit4_bn2_beta);
  %675 = (%tensor_0104,);
  let %x208: () = vm.invoke_tvm_op(%673, %674, %675) /* ty=() */;
  let %x209: Tensor[(1, 14, 14, 256), float32] = %tensor_0104;
  let %storage_0105: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][105]) /* ty=Storage[] */;
  let %tensor_0105: Tensor[(256), float32] = memory.alloc_tensor(%storage_0105, 0 /* ty=int64 */, meta[relay.Constant][105] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][105]) /* ty=Tensor[(256), float32] */;
  %679 = fn (%p0105: Tensor[(256), float32], %p192: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %676 = add(%p0105, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %677 = sqrt(%676) /* ty=Tensor[(256), float32] */;
    %678 = divide(1f /* ty=float32 */, %677) /* ty=Tensor[(256), float32] */;
    multiply(%678, %p192) /* ty=Tensor[(256), float32] */
  };
  %680 = (%stage3_unit4_bn3_moving_var, %stage3_unit4_bn3_gamma);
  %681 = (%tensor_0105,);
  let %x210: () = vm.invoke_tvm_op(%679, %680, %681) /* ty=() */;
  let %x211: Tensor[(256), float32] = %tensor_0105;
  let %storage_0106: Storage[] = memory.alloc_storage(2359296 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][106]) /* ty=Storage[] */;
  let %tensor_0106: Tensor[(3, 3, 256, 256), float32] = memory.alloc_tensor(%storage_0106, 0 /* ty=int64 */, meta[relay.Constant][106] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][106]) /* ty=Tensor[(3, 3, 256, 256), float32] */;
  %683 = fn (%p0106: Tensor[(256, 256, 3, 3), float32], %p193: Tensor[(256), float32], Primitive=1) -> Tensor[(3, 3, 256, 256), float32] {
    %682 = layout_transform(%p0106, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 256, 256), float32] */;
    multiply(%682, %p193) /* ty=Tensor[(3, 3, 256, 256), float32] */
  };
  %684 = (%stage3_unit4_conv2_weight, %x211);
  %685 = (%tensor_0106,);
  let %x212: () = vm.invoke_tvm_op(%683, %684, %685) /* ty=() */;
  let %x213: Tensor[(3, 3, 256, 256), float32] = %tensor_0106;
  let %storage_0107: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][107]) /* ty=Storage[] */;
  let %tensor_0107: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_0107, 0 /* ty=int64 */, meta[relay.Constant][107] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][107]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %692 = fn (%p0107: Tensor[(1, 14, 14, 256), float32], %p194: Tensor[(3, 3, 256, 256), float32], %p242: Tensor[(256), float32], %p334: Tensor[(256), float32], %p432: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %686 = nn.conv2d(%p0107, %p194, padding=[1, 1, 1, 1], channels=256, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %687 = negative(%p242) /* ty=Tensor[(256), float32] */;
    %688 = multiply(%687, %p334) /* ty=Tensor[(256), float32] */;
    %689 = add(%688, %p432) /* ty=Tensor[(256), float32] */;
    %690 = expand_dims(%689, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %691 = add(%686, %690) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%691) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %693 = (%x209, %x213, %stage3_unit4_bn3_moving_mean, %x211, %stage3_unit4_bn3_beta);
  %694 = (%tensor_0107,);
  let %x214: () = vm.invoke_tvm_op(%692, %693, %694) /* ty=() */;
  let %x215: Tensor[(1, 14, 14, 256), float32] = %tensor_0107;
  let %storage_0108: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][108]) /* ty=Storage[] */;
  let %tensor_0108: Tensor[(1, 1, 256, 1024), float32] = memory.alloc_tensor(%storage_0108, 0 /* ty=int64 */, meta[relay.Constant][108] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][108]) /* ty=Tensor[(1, 1, 256, 1024), float32] */;
  %695 = fn (%p0108: Tensor[(1024, 256, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 256, 1024), float32] {
    layout_transform(%p0108, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 256, 1024), float32] */
  };
  %696 = (%stage3_unit4_conv3_weight,);
  %697 = (%tensor_0108,);
  let %x216: () = vm.invoke_tvm_op(%695, %696, %697) /* ty=() */;
  let %x217: Tensor[(1, 1, 256, 1024), float32] = %tensor_0108;
  let %storage_0109: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][109]) /* ty=Storage[] */;
  let %tensor_0109: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_0109, 0 /* ty=int64 */, meta[relay.Constant][109] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][109]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %699 = fn (%p0109: Tensor[(1, 14, 14, 256), float32], %p195: Tensor[(1, 1, 256, 1024), float32], %p243: Tensor[(1, 14, 14, 1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %698 = nn.conv2d(%p0109, %p195, padding=[0, 0, 0, 0], channels=1024, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    add(%698, %p243) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %700 = (%x215, %x217, %x201);
  %701 = (%tensor_0109,);
  let %x218: () = vm.invoke_tvm_op(%699, %700, %701) /* ty=() */;
  let %x219: Tensor[(1, 14, 14, 1024), float32] = %tensor_0109;
  let %storage_0110: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][110]) /* ty=Storage[] */;
  let %tensor_0110: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_0110, 0 /* ty=int64 */, meta[relay.Constant][110] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][110]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %713 = fn (%p0110: Tensor[(1024), float32], %p196: Tensor[(1024), float32], %p244: Tensor[(1, 14, 14, 1024), float32], %p335: Tensor[(1024), float32], %p433: Tensor[(1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %702 = add(%p0110, 2e-05f /* ty=float32 */) /* ty=Tensor[(1024), float32] */;
    %703 = sqrt(%702) /* ty=Tensor[(1024), float32] */;
    %704 = divide(1f /* ty=float32 */, %703) /* ty=Tensor[(1024), float32] */;
    %705 = multiply(%704, %p196) /* ty=Tensor[(1024), float32] */;
    %706 = expand_dims(%705, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %707 = multiply(%p244, %706) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    %708 = negative(%p335) /* ty=Tensor[(1024), float32] */;
    %709 = multiply(%708, %705) /* ty=Tensor[(1024), float32] */;
    %710 = add(%709, %p433) /* ty=Tensor[(1024), float32] */;
    %711 = expand_dims(%710, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %712 = add(%707, %711) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    nn.relu(%712) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %714 = (%stage3_unit5_bn1_moving_var, %stage3_unit5_bn1_gamma, %x219, %stage3_unit5_bn1_moving_mean, %stage3_unit5_bn1_beta);
  %715 = (%tensor_0110,);
  let %x220: () = vm.invoke_tvm_op(%713, %714, %715) /* ty=() */;
  let %x221: Tensor[(1, 14, 14, 1024), float32] = %tensor_0110;
  let %storage_0111: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][111]) /* ty=Storage[] */;
  let %tensor_0111: Tensor[(256), float32] = memory.alloc_tensor(%storage_0111, 0 /* ty=int64 */, meta[relay.Constant][111] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][111]) /* ty=Tensor[(256), float32] */;
  %719 = fn (%p0111: Tensor[(256), float32], %p197: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %716 = add(%p0111, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %717 = sqrt(%716) /* ty=Tensor[(256), float32] */;
    %718 = divide(1f /* ty=float32 */, %717) /* ty=Tensor[(256), float32] */;
    multiply(%718, %p197) /* ty=Tensor[(256), float32] */
  };
  %720 = (%stage3_unit5_bn2_moving_var, %stage3_unit5_bn2_gamma);
  %721 = (%tensor_0111,);
  let %x222: () = vm.invoke_tvm_op(%719, %720, %721) /* ty=() */;
  let %x223: Tensor[(256), float32] = %tensor_0111;
  let %storage_0112: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][112]) /* ty=Storage[] */;
  let %tensor_0112: Tensor[(1, 1, 1024, 256), float32] = memory.alloc_tensor(%storage_0112, 0 /* ty=int64 */, meta[relay.Constant][112] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][112]) /* ty=Tensor[(1, 1, 1024, 256), float32] */;
  %723 = fn (%p0112: Tensor[(256, 1024, 1, 1), float32], %p198: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 1, 1024, 256), float32] {
    %722 = layout_transform(%p0112, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 1024, 256), float32] */;
    multiply(%722, %p198) /* ty=Tensor[(1, 1, 1024, 256), float32] */
  };
  %724 = (%stage3_unit5_conv1_weight, %x223);
  %725 = (%tensor_0112,);
  let %x224: () = vm.invoke_tvm_op(%723, %724, %725) /* ty=() */;
  let %x225: Tensor[(1, 1, 1024, 256), float32] = %tensor_0112;
  let %storage_0113: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][113]) /* ty=Storage[] */;
  let %tensor_0113: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_0113, 0 /* ty=int64 */, meta[relay.Constant][113] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][113]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %732 = fn (%p0113: Tensor[(1, 14, 14, 1024), float32], %p199: Tensor[(1, 1, 1024, 256), float32], %p245: Tensor[(256), float32], %p336: Tensor[(256), float32], %p434: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %726 = nn.conv2d(%p0113, %p199, padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %727 = negative(%p245) /* ty=Tensor[(256), float32] */;
    %728 = multiply(%727, %p336) /* ty=Tensor[(256), float32] */;
    %729 = add(%728, %p434) /* ty=Tensor[(256), float32] */;
    %730 = expand_dims(%729, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %731 = add(%726, %730) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%731) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %733 = (%x221, %x225, %stage3_unit5_bn2_moving_mean, %x223, %stage3_unit5_bn2_beta);
  %734 = (%tensor_0113,);
  let %x226: () = vm.invoke_tvm_op(%732, %733, %734) /* ty=() */;
  let %x227: Tensor[(1, 14, 14, 256), float32] = %tensor_0113;
  let %storage_0114: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][114]) /* ty=Storage[] */;
  let %tensor_0114: Tensor[(256), float32] = memory.alloc_tensor(%storage_0114, 0 /* ty=int64 */, meta[relay.Constant][114] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][114]) /* ty=Tensor[(256), float32] */;
  %738 = fn (%p0114: Tensor[(256), float32], %p1100: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %735 = add(%p0114, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %736 = sqrt(%735) /* ty=Tensor[(256), float32] */;
    %737 = divide(1f /* ty=float32 */, %736) /* ty=Tensor[(256), float32] */;
    multiply(%737, %p1100) /* ty=Tensor[(256), float32] */
  };
  %739 = (%stage3_unit5_bn3_moving_var, %stage3_unit5_bn3_gamma);
  %740 = (%tensor_0114,);
  let %x228: () = vm.invoke_tvm_op(%738, %739, %740) /* ty=() */;
  let %x229: Tensor[(256), float32] = %tensor_0114;
  let %storage_0115: Storage[] = memory.alloc_storage(2359296 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][115]) /* ty=Storage[] */;
  let %tensor_0115: Tensor[(3, 3, 256, 256), float32] = memory.alloc_tensor(%storage_0115, 0 /* ty=int64 */, meta[relay.Constant][115] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][115]) /* ty=Tensor[(3, 3, 256, 256), float32] */;
  %742 = fn (%p0115: Tensor[(256, 256, 3, 3), float32], %p1101: Tensor[(256), float32], Primitive=1) -> Tensor[(3, 3, 256, 256), float32] {
    %741 = layout_transform(%p0115, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 256, 256), float32] */;
    multiply(%741, %p1101) /* ty=Tensor[(3, 3, 256, 256), float32] */
  };
  %743 = (%stage3_unit5_conv2_weight, %x229);
  %744 = (%tensor_0115,);
  let %x230: () = vm.invoke_tvm_op(%742, %743, %744) /* ty=() */;
  let %x231: Tensor[(3, 3, 256, 256), float32] = %tensor_0115;
  let %storage_0116: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][116]) /* ty=Storage[] */;
  let %tensor_0116: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_0116, 0 /* ty=int64 */, meta[relay.Constant][116] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][116]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %751 = fn (%p0116: Tensor[(1, 14, 14, 256), float32], %p1102: Tensor[(3, 3, 256, 256), float32], %p246: Tensor[(256), float32], %p337: Tensor[(256), float32], %p435: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %745 = nn.conv2d(%p0116, %p1102, padding=[1, 1, 1, 1], channels=256, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %746 = negative(%p246) /* ty=Tensor[(256), float32] */;
    %747 = multiply(%746, %p337) /* ty=Tensor[(256), float32] */;
    %748 = add(%747, %p435) /* ty=Tensor[(256), float32] */;
    %749 = expand_dims(%748, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %750 = add(%745, %749) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%750) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %752 = (%x227, %x231, %stage3_unit5_bn3_moving_mean, %x229, %stage3_unit5_bn3_beta);
  %753 = (%tensor_0116,);
  let %x232: () = vm.invoke_tvm_op(%751, %752, %753) /* ty=() */;
  let %x233: Tensor[(1, 14, 14, 256), float32] = %tensor_0116;
  let %storage_0117: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][117]) /* ty=Storage[] */;
  let %tensor_0117: Tensor[(1, 1, 256, 1024), float32] = memory.alloc_tensor(%storage_0117, 0 /* ty=int64 */, meta[relay.Constant][117] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][117]) /* ty=Tensor[(1, 1, 256, 1024), float32] */;
  %754 = fn (%p0117: Tensor[(1024, 256, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 256, 1024), float32] {
    layout_transform(%p0117, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 256, 1024), float32] */
  };
  %755 = (%stage3_unit5_conv3_weight,);
  %756 = (%tensor_0117,);
  let %x234: () = vm.invoke_tvm_op(%754, %755, %756) /* ty=() */;
  let %x235: Tensor[(1, 1, 256, 1024), float32] = %tensor_0117;
  let %storage_0118: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][118]) /* ty=Storage[] */;
  let %tensor_0118: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_0118, 0 /* ty=int64 */, meta[relay.Constant][118] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][118]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %758 = fn (%p0118: Tensor[(1, 14, 14, 256), float32], %p1103: Tensor[(1, 1, 256, 1024), float32], %p247: Tensor[(1, 14, 14, 1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %757 = nn.conv2d(%p0118, %p1103, padding=[0, 0, 0, 0], channels=1024, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    add(%757, %p247) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %759 = (%x233, %x235, %x219);
  %760 = (%tensor_0118,);
  let %x236: () = vm.invoke_tvm_op(%758, %759, %760) /* ty=() */;
  let %x237: Tensor[(1, 14, 14, 1024), float32] = %tensor_0118;
  let %storage_0119: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][119]) /* ty=Storage[] */;
  let %tensor_0119: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_0119, 0 /* ty=int64 */, meta[relay.Constant][119] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][119]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %772 = fn (%p0119: Tensor[(1024), float32], %p1104: Tensor[(1024), float32], %p248: Tensor[(1, 14, 14, 1024), float32], %p338: Tensor[(1024), float32], %p436: Tensor[(1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %761 = add(%p0119, 2e-05f /* ty=float32 */) /* ty=Tensor[(1024), float32] */;
    %762 = sqrt(%761) /* ty=Tensor[(1024), float32] */;
    %763 = divide(1f /* ty=float32 */, %762) /* ty=Tensor[(1024), float32] */;
    %764 = multiply(%763, %p1104) /* ty=Tensor[(1024), float32] */;
    %765 = expand_dims(%764, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %766 = multiply(%p248, %765) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    %767 = negative(%p338) /* ty=Tensor[(1024), float32] */;
    %768 = multiply(%767, %764) /* ty=Tensor[(1024), float32] */;
    %769 = add(%768, %p436) /* ty=Tensor[(1024), float32] */;
    %770 = expand_dims(%769, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %771 = add(%766, %770) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    nn.relu(%771) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %773 = (%stage3_unit6_bn1_moving_var, %stage3_unit6_bn1_gamma, %x237, %stage3_unit6_bn1_moving_mean, %stage3_unit6_bn1_beta);
  %774 = (%tensor_0119,);
  let %x238: () = vm.invoke_tvm_op(%772, %773, %774) /* ty=() */;
  let %x239: Tensor[(1, 14, 14, 1024), float32] = %tensor_0119;
  let %storage_0120: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][120]) /* ty=Storage[] */;
  let %tensor_0120: Tensor[(256), float32] = memory.alloc_tensor(%storage_0120, 0 /* ty=int64 */, meta[relay.Constant][120] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][120]) /* ty=Tensor[(256), float32] */;
  %778 = fn (%p0120: Tensor[(256), float32], %p1105: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %775 = add(%p0120, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %776 = sqrt(%775) /* ty=Tensor[(256), float32] */;
    %777 = divide(1f /* ty=float32 */, %776) /* ty=Tensor[(256), float32] */;
    multiply(%777, %p1105) /* ty=Tensor[(256), float32] */
  };
  %779 = (%stage3_unit6_bn2_moving_var, %stage3_unit6_bn2_gamma);
  %780 = (%tensor_0120,);
  let %x240: () = vm.invoke_tvm_op(%778, %779, %780) /* ty=() */;
  let %x241: Tensor[(256), float32] = %tensor_0120;
  let %storage_0121: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][121]) /* ty=Storage[] */;
  let %tensor_0121: Tensor[(1, 1, 1024, 256), float32] = memory.alloc_tensor(%storage_0121, 0 /* ty=int64 */, meta[relay.Constant][121] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][121]) /* ty=Tensor[(1, 1, 1024, 256), float32] */;
  %782 = fn (%p0121: Tensor[(256, 1024, 1, 1), float32], %p1106: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 1, 1024, 256), float32] {
    %781 = layout_transform(%p0121, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 1024, 256), float32] */;
    multiply(%781, %p1106) /* ty=Tensor[(1, 1, 1024, 256), float32] */
  };
  %783 = (%stage3_unit6_conv1_weight, %x241);
  %784 = (%tensor_0121,);
  let %x242: () = vm.invoke_tvm_op(%782, %783, %784) /* ty=() */;
  let %x243: Tensor[(1, 1, 1024, 256), float32] = %tensor_0121;
  let %storage_0122: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][122]) /* ty=Storage[] */;
  let %tensor_0122: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_0122, 0 /* ty=int64 */, meta[relay.Constant][122] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][122]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %791 = fn (%p0122: Tensor[(1, 14, 14, 1024), float32], %p1107: Tensor[(1, 1, 1024, 256), float32], %p249: Tensor[(256), float32], %p339: Tensor[(256), float32], %p437: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %785 = nn.conv2d(%p0122, %p1107, padding=[0, 0, 0, 0], channels=256, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %786 = negative(%p249) /* ty=Tensor[(256), float32] */;
    %787 = multiply(%786, %p339) /* ty=Tensor[(256), float32] */;
    %788 = add(%787, %p437) /* ty=Tensor[(256), float32] */;
    %789 = expand_dims(%788, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %790 = add(%785, %789) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%790) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %792 = (%x239, %x243, %stage3_unit6_bn2_moving_mean, %x241, %stage3_unit6_bn2_beta);
  %793 = (%tensor_0122,);
  let %x244: () = vm.invoke_tvm_op(%791, %792, %793) /* ty=() */;
  let %x245: Tensor[(1, 14, 14, 256), float32] = %tensor_0122;
  let %storage_0123: Storage[] = memory.alloc_storage(1024 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][123]) /* ty=Storage[] */;
  let %tensor_0123: Tensor[(256), float32] = memory.alloc_tensor(%storage_0123, 0 /* ty=int64 */, meta[relay.Constant][123] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][123]) /* ty=Tensor[(256), float32] */;
  %797 = fn (%p0123: Tensor[(256), float32], %p1108: Tensor[(256), float32], Primitive=1) -> Tensor[(256), float32] {
    %794 = add(%p0123, 2e-05f /* ty=float32 */) /* ty=Tensor[(256), float32] */;
    %795 = sqrt(%794) /* ty=Tensor[(256), float32] */;
    %796 = divide(1f /* ty=float32 */, %795) /* ty=Tensor[(256), float32] */;
    multiply(%796, %p1108) /* ty=Tensor[(256), float32] */
  };
  %798 = (%stage3_unit6_bn3_moving_var, %stage3_unit6_bn3_gamma);
  %799 = (%tensor_0123,);
  let %x246: () = vm.invoke_tvm_op(%797, %798, %799) /* ty=() */;
  let %x247: Tensor[(256), float32] = %tensor_0123;
  let %storage_0124: Storage[] = memory.alloc_storage(2359296 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][124]) /* ty=Storage[] */;
  let %tensor_0124: Tensor[(3, 3, 256, 256), float32] = memory.alloc_tensor(%storage_0124, 0 /* ty=int64 */, meta[relay.Constant][124] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][124]) /* ty=Tensor[(3, 3, 256, 256), float32] */;
  %801 = fn (%p0124: Tensor[(256, 256, 3, 3), float32], %p1109: Tensor[(256), float32], Primitive=1) -> Tensor[(3, 3, 256, 256), float32] {
    %800 = layout_transform(%p0124, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 256, 256), float32] */;
    multiply(%800, %p1109) /* ty=Tensor[(3, 3, 256, 256), float32] */
  };
  %802 = (%stage3_unit6_conv2_weight, %x247);
  %803 = (%tensor_0124,);
  let %x248: () = vm.invoke_tvm_op(%801, %802, %803) /* ty=() */;
  let %x249: Tensor[(3, 3, 256, 256), float32] = %tensor_0124;
  let %storage_0125: Storage[] = memory.alloc_storage(200704 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][125]) /* ty=Storage[] */;
  let %tensor_0125: Tensor[(1, 14, 14, 256), float32] = memory.alloc_tensor(%storage_0125, 0 /* ty=int64 */, meta[relay.Constant][125] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][125]) /* ty=Tensor[(1, 14, 14, 256), float32] */;
  %810 = fn (%p0125: Tensor[(1, 14, 14, 256), float32], %p1110: Tensor[(3, 3, 256, 256), float32], %p250: Tensor[(256), float32], %p340: Tensor[(256), float32], %p438: Tensor[(256), float32], Primitive=1) -> Tensor[(1, 14, 14, 256), float32] {
    %804 = nn.conv2d(%p0125, %p1110, padding=[1, 1, 1, 1], channels=256, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 256), float32] */;
    %805 = negative(%p250) /* ty=Tensor[(256), float32] */;
    %806 = multiply(%805, %p340) /* ty=Tensor[(256), float32] */;
    %807 = add(%806, %p438) /* ty=Tensor[(256), float32] */;
    %808 = expand_dims(%807, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 256), float32] */;
    %809 = add(%804, %808) /* ty=Tensor[(1, 14, 14, 256), float32] */;
    nn.relu(%809) /* ty=Tensor[(1, 14, 14, 256), float32] */
  };
  %811 = (%x245, %x249, %stage3_unit6_bn3_moving_mean, %x247, %stage3_unit6_bn3_beta);
  %812 = (%tensor_0125,);
  let %x250: () = vm.invoke_tvm_op(%810, %811, %812) /* ty=() */;
  let %x251: Tensor[(1, 14, 14, 256), float32] = %tensor_0125;
  let %storage_0126: Storage[] = memory.alloc_storage(1048576 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][126]) /* ty=Storage[] */;
  let %tensor_0126: Tensor[(1, 1, 256, 1024), float32] = memory.alloc_tensor(%storage_0126, 0 /* ty=int64 */, meta[relay.Constant][126] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][126]) /* ty=Tensor[(1, 1, 256, 1024), float32] */;
  %813 = fn (%p0126: Tensor[(1024, 256, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 256, 1024), float32] {
    layout_transform(%p0126, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 256, 1024), float32] */
  };
  %814 = (%stage3_unit6_conv3_weight,);
  %815 = (%tensor_0126,);
  let %x252: () = vm.invoke_tvm_op(%813, %814, %815) /* ty=() */;
  let %x253: Tensor[(1, 1, 256, 1024), float32] = %tensor_0126;
  let %storage_0127: Storage[] = memory.alloc_storage(4096 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][127]) /* ty=Storage[] */;
  let %tensor_0127: Tensor[(1024), float32] = memory.alloc_tensor(%storage_0127, 0 /* ty=int64 */, meta[relay.Constant][127] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][127]) /* ty=Tensor[(1024), float32] */;
  %819 = fn (%p0127: Tensor[(1024), float32], %p1111: Tensor[(1024), float32], Primitive=1) -> Tensor[(1024), float32] {
    %816 = add(%p0127, 2e-05f /* ty=float32 */) /* ty=Tensor[(1024), float32] */;
    %817 = sqrt(%816) /* ty=Tensor[(1024), float32] */;
    %818 = divide(1f /* ty=float32 */, %817) /* ty=Tensor[(1024), float32] */;
    multiply(%818, %p1111) /* ty=Tensor[(1024), float32] */
  };
  %820 = (%stage4_unit1_bn1_moving_var, %stage4_unit1_bn1_gamma);
  %821 = (%tensor_0127,);
  let %x254: () = vm.invoke_tvm_op(%819, %820, %821) /* ty=() */;
  let %x255: Tensor[(1024), float32] = %tensor_0127;
  let %storage_0128: Storage[] = memory.alloc_storage(802816 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][128]) /* ty=Storage[] */;
  let %tensor_0128: Tensor[(1, 14, 14, 1024), float32] = memory.alloc_tensor(%storage_0128, 0 /* ty=int64 */, meta[relay.Constant][128] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][128]) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
  %831 = fn (%p0128: Tensor[(1, 14, 14, 256), float32], %p1112: Tensor[(1, 1, 256, 1024), float32], %p251: Tensor[(1, 14, 14, 1024), float32], %p341: Tensor[(1024), float32], %p439: Tensor[(1024), float32], %p52: Tensor[(1024), float32], Primitive=1) -> Tensor[(1, 14, 14, 1024), float32] {
    %822 = nn.conv2d(%p0128, %p1112, padding=[0, 0, 0, 0], channels=1024, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    %823 = add(%822, %p251) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    %824 = expand_dims(%p341, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %825 = multiply(%823, %824) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    %826 = negative(%p439) /* ty=Tensor[(1024), float32] */;
    %827 = multiply(%826, %p341) /* ty=Tensor[(1024), float32] */;
    %828 = add(%827, %p52) /* ty=Tensor[(1024), float32] */;
    %829 = expand_dims(%828, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 1024), float32] */;
    %830 = add(%825, %829) /* ty=Tensor[(1, 14, 14, 1024), float32] */;
    nn.relu(%830) /* ty=Tensor[(1, 14, 14, 1024), float32] */
  };
  %832 = (%x251, %x253, %x237, %x255, %stage4_unit1_bn1_moving_mean, %stage4_unit1_bn1_beta);
  %833 = (%tensor_0128,);
  let %x256: () = vm.invoke_tvm_op(%831, %832, %833) /* ty=() */;
  let %x257: Tensor[(1, 14, 14, 1024), float32] = %tensor_0128;
  let %storage_0129: Storage[] = memory.alloc_storage(2048 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][129]) /* ty=Storage[] */;
  let %tensor_0129: Tensor[(512), float32] = memory.alloc_tensor(%storage_0129, 0 /* ty=int64 */, meta[relay.Constant][129] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][129]) /* ty=Tensor[(512), float32] */;
  %837 = fn (%p0129: Tensor[(512), float32], %p1113: Tensor[(512), float32], Primitive=1) -> Tensor[(512), float32] {
    %834 = add(%p0129, 2e-05f /* ty=float32 */) /* ty=Tensor[(512), float32] */;
    %835 = sqrt(%834) /* ty=Tensor[(512), float32] */;
    %836 = divide(1f /* ty=float32 */, %835) /* ty=Tensor[(512), float32] */;
    multiply(%836, %p1113) /* ty=Tensor[(512), float32] */
  };
  %838 = (%stage4_unit1_bn2_moving_var, %stage4_unit1_bn2_gamma);
  %839 = (%tensor_0129,);
  let %x258: () = vm.invoke_tvm_op(%837, %838, %839) /* ty=() */;
  let %x259: Tensor[(512), float32] = %tensor_0129;
  let %storage_0130: Storage[] = memory.alloc_storage(2097152 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][130]) /* ty=Storage[] */;
  let %tensor_0130: Tensor[(1, 1, 1024, 512), float32] = memory.alloc_tensor(%storage_0130, 0 /* ty=int64 */, meta[relay.Constant][130] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][130]) /* ty=Tensor[(1, 1, 1024, 512), float32] */;
  %841 = fn (%p0130: Tensor[(512, 1024, 1, 1), float32], %p1114: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 1, 1024, 512), float32] {
    %840 = layout_transform(%p0130, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 1024, 512), float32] */;
    multiply(%840, %p1114) /* ty=Tensor[(1, 1, 1024, 512), float32] */
  };
  %842 = (%stage4_unit1_conv1_weight, %x259);
  %843 = (%tensor_0130,);
  let %x260: () = vm.invoke_tvm_op(%841, %842, %843) /* ty=() */;
  let %x261: Tensor[(1, 1, 1024, 512), float32] = %tensor_0130;
  let %storage_0131: Storage[] = memory.alloc_storage(100352 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][131]) /* ty=Storage[] */;
  let %tensor_0131: Tensor[(1, 7, 7, 512), float32] = memory.alloc_tensor(%storage_0131, 0 /* ty=int64 */, meta[relay.Constant][131] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][131]) /* ty=Tensor[(1, 7, 7, 512), float32] */;
  %850 = fn (%p0131: Tensor[(1, 14, 14, 1024), float32], %p1115: Tensor[(1, 1, 1024, 512), float32], %p252: Tensor[(512), float32], %p342: Tensor[(512), float32], %p440: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 7, 7, 512), float32] {
    %844 = nn.conv2d(%p0131, %p1115, strides=[2, 2], padding=[0, 0, 0, 0], channels=512, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 7, 7, 512), float32] */;
    %845 = negative(%p252) /* ty=Tensor[(512), float32] */;
    %846 = multiply(%845, %p342) /* ty=Tensor[(512), float32] */;
    %847 = add(%846, %p440) /* ty=Tensor[(512), float32] */;
    %848 = expand_dims(%847, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %849 = add(%844, %848) /* ty=Tensor[(1, 7, 7, 512), float32] */;
    nn.relu(%849) /* ty=Tensor[(1, 7, 7, 512), float32] */
  };
  %851 = (%x257, %x261, %stage4_unit1_bn2_moving_mean, %x259, %stage4_unit1_bn2_beta);
  %852 = (%tensor_0131,);
  let %x262: () = vm.invoke_tvm_op(%850, %851, %852) /* ty=() */;
  let %x263: Tensor[(1, 7, 7, 512), float32] = %tensor_0131;
  let %storage_0132: Storage[] = memory.alloc_storage(2048 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][132]) /* ty=Storage[] */;
  let %tensor_0132: Tensor[(512), float32] = memory.alloc_tensor(%storage_0132, 0 /* ty=int64 */, meta[relay.Constant][132] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][132]) /* ty=Tensor[(512), float32] */;
  %856 = fn (%p0132: Tensor[(512), float32], %p1116: Tensor[(512), float32], Primitive=1) -> Tensor[(512), float32] {
    %853 = add(%p0132, 2e-05f /* ty=float32 */) /* ty=Tensor[(512), float32] */;
    %854 = sqrt(%853) /* ty=Tensor[(512), float32] */;
    %855 = divide(1f /* ty=float32 */, %854) /* ty=Tensor[(512), float32] */;
    multiply(%855, %p1116) /* ty=Tensor[(512), float32] */
  };
  %857 = (%stage4_unit1_bn3_moving_var, %stage4_unit1_bn3_gamma);
  %858 = (%tensor_0132,);
  let %x264: () = vm.invoke_tvm_op(%856, %857, %858) /* ty=() */;
  let %x265: Tensor[(512), float32] = %tensor_0132;
  let %storage_0133: Storage[] = memory.alloc_storage(9437184 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][133]) /* ty=Storage[] */;
  let %tensor_0133: Tensor[(3, 3, 512, 512), float32] = memory.alloc_tensor(%storage_0133, 0 /* ty=int64 */, meta[relay.Constant][133] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][133]) /* ty=Tensor[(3, 3, 512, 512), float32] */;
  %860 = fn (%p0133: Tensor[(512, 512, 3, 3), float32], %p1117: Tensor[(512), float32], Primitive=1) -> Tensor[(3, 3, 512, 512), float32] {
    %859 = layout_transform(%p0133, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 512, 512), float32] */;
    multiply(%859, %p1117) /* ty=Tensor[(3, 3, 512, 512), float32] */
  };
  %861 = (%stage4_unit1_conv2_weight, %x265);
  %862 = (%tensor_0133,);
  let %x266: () = vm.invoke_tvm_op(%860, %861, %862) /* ty=() */;
  let %x267: Tensor[(3, 3, 512, 512), float32] = %tensor_0133;
  let %storage_0134: Storage[] = memory.alloc_storage(100352 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][134]) /* ty=Storage[] */;
  let %tensor_0134: Tensor[(1, 7, 7, 512), float32] = memory.alloc_tensor(%storage_0134, 0 /* ty=int64 */, meta[relay.Constant][134] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][134]) /* ty=Tensor[(1, 7, 7, 512), float32] */;
  %869 = fn (%p0134: Tensor[(1, 7, 7, 512), float32], %p1118: Tensor[(3, 3, 512, 512), float32], %p253: Tensor[(512), float32], %p343: Tensor[(512), float32], %p441: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 7, 7, 512), float32] {
    %863 = nn.conv2d(%p0134, %p1118, padding=[1, 1, 1, 1], channels=512, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 7, 7, 512), float32] */;
    %864 = negative(%p253) /* ty=Tensor[(512), float32] */;
    %865 = multiply(%864, %p343) /* ty=Tensor[(512), float32] */;
    %866 = add(%865, %p441) /* ty=Tensor[(512), float32] */;
    %867 = expand_dims(%866, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %868 = add(%863, %867) /* ty=Tensor[(1, 7, 7, 512), float32] */;
    nn.relu(%868) /* ty=Tensor[(1, 7, 7, 512), float32] */
  };
  %870 = (%x263, %x267, %stage4_unit1_bn3_moving_mean, %x265, %stage4_unit1_bn3_beta);
  %871 = (%tensor_0134,);
  let %x268: () = vm.invoke_tvm_op(%869, %870, %871) /* ty=() */;
  let %x269: Tensor[(1, 7, 7, 512), float32] = %tensor_0134;
  let %storage_0135: Storage[] = memory.alloc_storage(4194304 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][135]) /* ty=Storage[] */;
  let %tensor_0135: Tensor[(1, 1, 512, 2048), float32] = memory.alloc_tensor(%storage_0135, 0 /* ty=int64 */, meta[relay.Constant][135] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][135]) /* ty=Tensor[(1, 1, 512, 2048), float32] */;
  %872 = fn (%p0135: Tensor[(2048, 512, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 512, 2048), float32] {
    layout_transform(%p0135, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 512, 2048), float32] */
  };
  %873 = (%stage4_unit1_conv3_weight,);
  %874 = (%tensor_0135,);
  let %x270: () = vm.invoke_tvm_op(%872, %873, %874) /* ty=() */;
  let %x271: Tensor[(1, 1, 512, 2048), float32] = %tensor_0135;
  let %storage_0136: Storage[] = memory.alloc_storage(8388608 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][136]) /* ty=Storage[] */;
  let %tensor_0136: Tensor[(1, 1, 1024, 2048), float32] = memory.alloc_tensor(%storage_0136, 0 /* ty=int64 */, meta[relay.Constant][136] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][136]) /* ty=Tensor[(1, 1, 1024, 2048), float32] */;
  %875 = fn (%p0136: Tensor[(2048, 1024, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 1024, 2048), float32] {
    layout_transform(%p0136, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 1024, 2048), float32] */
  };
  %876 = (%stage4_unit1_sc_weight,);
  %877 = (%tensor_0136,);
  let %x272: () = vm.invoke_tvm_op(%875, %876, %877) /* ty=() */;
  let %x273: Tensor[(1, 1, 1024, 2048), float32] = %tensor_0136;
  let %storage_0137: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][137]) /* ty=Storage[] */;
  let %tensor_0137: Tensor[(1, 7, 7, 2048), float32] = memory.alloc_tensor(%storage_0137, 0 /* ty=int64 */, meta[relay.Constant][137] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][137]) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
  %878 = fn (%p0137: Tensor[(1, 14, 14, 1024), float32], %p1119: Tensor[(1, 1, 1024, 2048), float32], Primitive=1) -> Tensor[(1, 7, 7, 2048), float32] {
    nn.conv2d(%p0137, %p1119, strides=[2, 2], padding=[0, 0, 0, 0], channels=2048, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 7, 7, 2048), float32] */
  };
  %879 = (%x257, %x273);
  %880 = (%tensor_0137,);
  let %x274: () = vm.invoke_tvm_op(%878, %879, %880) /* ty=() */;
  let %x275: Tensor[(1, 7, 7, 2048), float32] = %tensor_0137;
  let %storage_0138: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][138]) /* ty=Storage[] */;
  let %tensor_0138: Tensor[(1, 7, 7, 2048), float32] = memory.alloc_tensor(%storage_0138, 0 /* ty=int64 */, meta[relay.Constant][138] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][138]) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
  %882 = fn (%p0138: Tensor[(1, 7, 7, 512), float32], %p1120: Tensor[(1, 1, 512, 2048), float32], %p254: Tensor[(1, 7, 7, 2048), float32], Primitive=1) -> Tensor[(1, 7, 7, 2048), float32] {
    %881 = nn.conv2d(%p0138, %p1120, padding=[0, 0, 0, 0], channels=2048, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 7, 7, 2048), float32] */;
    add(%881, %p254) /* ty=Tensor[(1, 7, 7, 2048), float32] */
  };
  %883 = (%x269, %x271, %x275);
  %884 = (%tensor_0138,);
  let %x276: () = vm.invoke_tvm_op(%882, %883, %884) /* ty=() */;
  let %x277: Tensor[(1, 7, 7, 2048), float32] = %tensor_0138;
  let %storage_0139: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][139]) /* ty=Storage[] */;
  let %tensor_0139: Tensor[(1, 7, 7, 2048), float32] = memory.alloc_tensor(%storage_0139, 0 /* ty=int64 */, meta[relay.Constant][139] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][139]) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
  %896 = fn (%p0139: Tensor[(2048), float32], %p1121: Tensor[(2048), float32], %p255: Tensor[(1, 7, 7, 2048), float32], %p344: Tensor[(2048), float32], %p442: Tensor[(2048), float32], Primitive=1) -> Tensor[(1, 7, 7, 2048), float32] {
    %885 = add(%p0139, 2e-05f /* ty=float32 */) /* ty=Tensor[(2048), float32] */;
    %886 = sqrt(%885) /* ty=Tensor[(2048), float32] */;
    %887 = divide(1f /* ty=float32 */, %886) /* ty=Tensor[(2048), float32] */;
    %888 = multiply(%887, %p1121) /* ty=Tensor[(2048), float32] */;
    %889 = expand_dims(%888, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 2048), float32] */;
    %890 = multiply(%p255, %889) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
    %891 = negative(%p344) /* ty=Tensor[(2048), float32] */;
    %892 = multiply(%891, %888) /* ty=Tensor[(2048), float32] */;
    %893 = add(%892, %p442) /* ty=Tensor[(2048), float32] */;
    %894 = expand_dims(%893, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 2048), float32] */;
    %895 = add(%890, %894) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
    nn.relu(%895) /* ty=Tensor[(1, 7, 7, 2048), float32] */
  };
  %897 = (%stage4_unit2_bn1_moving_var, %stage4_unit2_bn1_gamma, %x277, %stage4_unit2_bn1_moving_mean, %stage4_unit2_bn1_beta);
  %898 = (%tensor_0139,);
  let %x278: () = vm.invoke_tvm_op(%896, %897, %898) /* ty=() */;
  let %x279: Tensor[(1, 7, 7, 2048), float32] = %tensor_0139;
  let %storage_0140: Storage[] = memory.alloc_storage(2048 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][140]) /* ty=Storage[] */;
  let %tensor_0140: Tensor[(512), float32] = memory.alloc_tensor(%storage_0140, 0 /* ty=int64 */, meta[relay.Constant][140] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][140]) /* ty=Tensor[(512), float32] */;
  %902 = fn (%p0140: Tensor[(512), float32], %p1122: Tensor[(512), float32], Primitive=1) -> Tensor[(512), float32] {
    %899 = add(%p0140, 2e-05f /* ty=float32 */) /* ty=Tensor[(512), float32] */;
    %900 = sqrt(%899) /* ty=Tensor[(512), float32] */;
    %901 = divide(1f /* ty=float32 */, %900) /* ty=Tensor[(512), float32] */;
    multiply(%901, %p1122) /* ty=Tensor[(512), float32] */
  };
  %903 = (%stage4_unit2_bn2_moving_var, %stage4_unit2_bn2_gamma);
  %904 = (%tensor_0140,);
  let %x280: () = vm.invoke_tvm_op(%902, %903, %904) /* ty=() */;
  let %x281: Tensor[(512), float32] = %tensor_0140;
  let %storage_0141: Storage[] = memory.alloc_storage(4194304 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][141]) /* ty=Storage[] */;
  let %tensor_0141: Tensor[(1, 1, 2048, 512), float32] = memory.alloc_tensor(%storage_0141, 0 /* ty=int64 */, meta[relay.Constant][141] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][141]) /* ty=Tensor[(1, 1, 2048, 512), float32] */;
  %906 = fn (%p0141: Tensor[(512, 2048, 1, 1), float32], %p1123: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 1, 2048, 512), float32] {
    %905 = layout_transform(%p0141, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 2048, 512), float32] */;
    multiply(%905, %p1123) /* ty=Tensor[(1, 1, 2048, 512), float32] */
  };
  %907 = (%stage4_unit2_conv1_weight, %x281);
  %908 = (%tensor_0141,);
  let %x282: () = vm.invoke_tvm_op(%906, %907, %908) /* ty=() */;
  let %x283: Tensor[(1, 1, 2048, 512), float32] = %tensor_0141;
  let %storage_0142: Storage[] = memory.alloc_storage(100352 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][142]) /* ty=Storage[] */;
  let %tensor_0142: Tensor[(1, 7, 7, 512), float32] = memory.alloc_tensor(%storage_0142, 0 /* ty=int64 */, meta[relay.Constant][142] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][142]) /* ty=Tensor[(1, 7, 7, 512), float32] */;
  %915 = fn (%p0142: Tensor[(1, 7, 7, 2048), float32], %p1124: Tensor[(1, 1, 2048, 512), float32], %p256: Tensor[(512), float32], %p345: Tensor[(512), float32], %p443: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 7, 7, 512), float32] {
    %909 = nn.conv2d(%p0142, %p1124, padding=[0, 0, 0, 0], channels=512, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 7, 7, 512), float32] */;
    %910 = negative(%p256) /* ty=Tensor[(512), float32] */;
    %911 = multiply(%910, %p345) /* ty=Tensor[(512), float32] */;
    %912 = add(%911, %p443) /* ty=Tensor[(512), float32] */;
    %913 = expand_dims(%912, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %914 = add(%909, %913) /* ty=Tensor[(1, 7, 7, 512), float32] */;
    nn.relu(%914) /* ty=Tensor[(1, 7, 7, 512), float32] */
  };
  %916 = (%x279, %x283, %stage4_unit2_bn2_moving_mean, %x281, %stage4_unit2_bn2_beta);
  %917 = (%tensor_0142,);
  let %x284: () = vm.invoke_tvm_op(%915, %916, %917) /* ty=() */;
  let %x285: Tensor[(1, 7, 7, 512), float32] = %tensor_0142;
  let %storage_0143: Storage[] = memory.alloc_storage(2048 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][143]) /* ty=Storage[] */;
  let %tensor_0143: Tensor[(512), float32] = memory.alloc_tensor(%storage_0143, 0 /* ty=int64 */, meta[relay.Constant][143] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][143]) /* ty=Tensor[(512), float32] */;
  %921 = fn (%p0143: Tensor[(512), float32], %p1125: Tensor[(512), float32], Primitive=1) -> Tensor[(512), float32] {
    %918 = add(%p0143, 2e-05f /* ty=float32 */) /* ty=Tensor[(512), float32] */;
    %919 = sqrt(%918) /* ty=Tensor[(512), float32] */;
    %920 = divide(1f /* ty=float32 */, %919) /* ty=Tensor[(512), float32] */;
    multiply(%920, %p1125) /* ty=Tensor[(512), float32] */
  };
  %922 = (%stage4_unit2_bn3_moving_var, %stage4_unit2_bn3_gamma);
  %923 = (%tensor_0143,);
  let %x286: () = vm.invoke_tvm_op(%921, %922, %923) /* ty=() */;
  let %x287: Tensor[(512), float32] = %tensor_0143;
  let %storage_0144: Storage[] = memory.alloc_storage(9437184 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][144]) /* ty=Storage[] */;
  let %tensor_0144: Tensor[(3, 3, 512, 512), float32] = memory.alloc_tensor(%storage_0144, 0 /* ty=int64 */, meta[relay.Constant][144] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][144]) /* ty=Tensor[(3, 3, 512, 512), float32] */;
  %925 = fn (%p0144: Tensor[(512, 512, 3, 3), float32], %p1126: Tensor[(512), float32], Primitive=1) -> Tensor[(3, 3, 512, 512), float32] {
    %924 = layout_transform(%p0144, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 512, 512), float32] */;
    multiply(%924, %p1126) /* ty=Tensor[(3, 3, 512, 512), float32] */
  };
  %926 = (%stage4_unit2_conv2_weight, %x287);
  %927 = (%tensor_0144,);
  let %x288: () = vm.invoke_tvm_op(%925, %926, %927) /* ty=() */;
  let %x289: Tensor[(3, 3, 512, 512), float32] = %tensor_0144;
  let %storage_0145: Storage[] = memory.alloc_storage(100352 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][145]) /* ty=Storage[] */;
  let %tensor_0145: Tensor[(1, 7, 7, 512), float32] = memory.alloc_tensor(%storage_0145, 0 /* ty=int64 */, meta[relay.Constant][145] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][145]) /* ty=Tensor[(1, 7, 7, 512), float32] */;
  %934 = fn (%p0145: Tensor[(1, 7, 7, 512), float32], %p1127: Tensor[(3, 3, 512, 512), float32], %p257: Tensor[(512), float32], %p346: Tensor[(512), float32], %p444: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 7, 7, 512), float32] {
    %928 = nn.conv2d(%p0145, %p1127, padding=[1, 1, 1, 1], channels=512, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 7, 7, 512), float32] */;
    %929 = negative(%p257) /* ty=Tensor[(512), float32] */;
    %930 = multiply(%929, %p346) /* ty=Tensor[(512), float32] */;
    %931 = add(%930, %p444) /* ty=Tensor[(512), float32] */;
    %932 = expand_dims(%931, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %933 = add(%928, %932) /* ty=Tensor[(1, 7, 7, 512), float32] */;
    nn.relu(%933) /* ty=Tensor[(1, 7, 7, 512), float32] */
  };
  %935 = (%x285, %x289, %stage4_unit2_bn3_moving_mean, %x287, %stage4_unit2_bn3_beta);
  %936 = (%tensor_0145,);
  let %x290: () = vm.invoke_tvm_op(%934, %935, %936) /* ty=() */;
  let %x291: Tensor[(1, 7, 7, 512), float32] = %tensor_0145;
  let %storage_0146: Storage[] = memory.alloc_storage(4194304 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][146]) /* ty=Storage[] */;
  let %tensor_0146: Tensor[(1, 1, 512, 2048), float32] = memory.alloc_tensor(%storage_0146, 0 /* ty=int64 */, meta[relay.Constant][146] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][146]) /* ty=Tensor[(1, 1, 512, 2048), float32] */;
  %937 = fn (%p0146: Tensor[(2048, 512, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 512, 2048), float32] {
    layout_transform(%p0146, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 512, 2048), float32] */
  };
  %938 = (%stage4_unit2_conv3_weight,);
  %939 = (%tensor_0146,);
  let %x292: () = vm.invoke_tvm_op(%937, %938, %939) /* ty=() */;
  let %x293: Tensor[(1, 1, 512, 2048), float32] = %tensor_0146;
  let %storage_0147: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][147]) /* ty=Storage[] */;
  let %tensor_0147: Tensor[(1, 7, 7, 2048), float32] = memory.alloc_tensor(%storage_0147, 0 /* ty=int64 */, meta[relay.Constant][147] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][147]) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
  %941 = fn (%p0147: Tensor[(1, 7, 7, 512), float32], %p1128: Tensor[(1, 1, 512, 2048), float32], %p258: Tensor[(1, 7, 7, 2048), float32], Primitive=1) -> Tensor[(1, 7, 7, 2048), float32] {
    %940 = nn.conv2d(%p0147, %p1128, padding=[0, 0, 0, 0], channels=2048, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 7, 7, 2048), float32] */;
    add(%940, %p258) /* ty=Tensor[(1, 7, 7, 2048), float32] */
  };
  %942 = (%x291, %x293, %x277);
  %943 = (%tensor_0147,);
  let %x294: () = vm.invoke_tvm_op(%941, %942, %943) /* ty=() */;
  let %x295: Tensor[(1, 7, 7, 2048), float32] = %tensor_0147;
  let %storage_0148: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][148]) /* ty=Storage[] */;
  let %tensor_0148: Tensor[(1, 7, 7, 2048), float32] = memory.alloc_tensor(%storage_0148, 0 /* ty=int64 */, meta[relay.Constant][148] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][148]) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
  %955 = fn (%p0148: Tensor[(2048), float32], %p1129: Tensor[(2048), float32], %p259: Tensor[(1, 7, 7, 2048), float32], %p347: Tensor[(2048), float32], %p445: Tensor[(2048), float32], Primitive=1) -> Tensor[(1, 7, 7, 2048), float32] {
    %944 = add(%p0148, 2e-05f /* ty=float32 */) /* ty=Tensor[(2048), float32] */;
    %945 = sqrt(%944) /* ty=Tensor[(2048), float32] */;
    %946 = divide(1f /* ty=float32 */, %945) /* ty=Tensor[(2048), float32] */;
    %947 = multiply(%946, %p1129) /* ty=Tensor[(2048), float32] */;
    %948 = expand_dims(%947, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 2048), float32] */;
    %949 = multiply(%p259, %948) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
    %950 = negative(%p347) /* ty=Tensor[(2048), float32] */;
    %951 = multiply(%950, %947) /* ty=Tensor[(2048), float32] */;
    %952 = add(%951, %p445) /* ty=Tensor[(2048), float32] */;
    %953 = expand_dims(%952, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 2048), float32] */;
    %954 = add(%949, %953) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
    nn.relu(%954) /* ty=Tensor[(1, 7, 7, 2048), float32] */
  };
  %956 = (%stage4_unit3_bn1_moving_var, %stage4_unit3_bn1_gamma, %x295, %stage4_unit3_bn1_moving_mean, %stage4_unit3_bn1_beta);
  %957 = (%tensor_0148,);
  let %x296: () = vm.invoke_tvm_op(%955, %956, %957) /* ty=() */;
  let %x297: Tensor[(1, 7, 7, 2048), float32] = %tensor_0148;
  let %storage_0149: Storage[] = memory.alloc_storage(2048 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][149]) /* ty=Storage[] */;
  let %tensor_0149: Tensor[(512), float32] = memory.alloc_tensor(%storage_0149, 0 /* ty=int64 */, meta[relay.Constant][149] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][149]) /* ty=Tensor[(512), float32] */;
  %961 = fn (%p0149: Tensor[(512), float32], %p1130: Tensor[(512), float32], Primitive=1) -> Tensor[(512), float32] {
    %958 = add(%p0149, 2e-05f /* ty=float32 */) /* ty=Tensor[(512), float32] */;
    %959 = sqrt(%958) /* ty=Tensor[(512), float32] */;
    %960 = divide(1f /* ty=float32 */, %959) /* ty=Tensor[(512), float32] */;
    multiply(%960, %p1130) /* ty=Tensor[(512), float32] */
  };
  %962 = (%stage4_unit3_bn2_moving_var, %stage4_unit3_bn2_gamma);
  %963 = (%tensor_0149,);
  let %x298: () = vm.invoke_tvm_op(%961, %962, %963) /* ty=() */;
  let %x299: Tensor[(512), float32] = %tensor_0149;
  let %storage_0150: Storage[] = memory.alloc_storage(4194304 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][150]) /* ty=Storage[] */;
  let %tensor_0150: Tensor[(1, 1, 2048, 512), float32] = memory.alloc_tensor(%storage_0150, 0 /* ty=int64 */, meta[relay.Constant][150] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][150]) /* ty=Tensor[(1, 1, 2048, 512), float32] */;
  %965 = fn (%p0150: Tensor[(512, 2048, 1, 1), float32], %p1131: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 1, 2048, 512), float32] {
    %964 = layout_transform(%p0150, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 2048, 512), float32] */;
    multiply(%964, %p1131) /* ty=Tensor[(1, 1, 2048, 512), float32] */
  };
  %966 = (%stage4_unit3_conv1_weight, %x299);
  %967 = (%tensor_0150,);
  let %x300: () = vm.invoke_tvm_op(%965, %966, %967) /* ty=() */;
  let %x301: Tensor[(1, 1, 2048, 512), float32] = %tensor_0150;
  let %storage_0151: Storage[] = memory.alloc_storage(100352 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][151]) /* ty=Storage[] */;
  let %tensor_0151: Tensor[(1, 7, 7, 512), float32] = memory.alloc_tensor(%storage_0151, 0 /* ty=int64 */, meta[relay.Constant][151] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][151]) /* ty=Tensor[(1, 7, 7, 512), float32] */;
  %974 = fn (%p0151: Tensor[(1, 7, 7, 2048), float32], %p1132: Tensor[(1, 1, 2048, 512), float32], %p260: Tensor[(512), float32], %p348: Tensor[(512), float32], %p446: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 7, 7, 512), float32] {
    %968 = nn.conv2d(%p0151, %p1132, padding=[0, 0, 0, 0], channels=512, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 7, 7, 512), float32] */;
    %969 = negative(%p260) /* ty=Tensor[(512), float32] */;
    %970 = multiply(%969, %p348) /* ty=Tensor[(512), float32] */;
    %971 = add(%970, %p446) /* ty=Tensor[(512), float32] */;
    %972 = expand_dims(%971, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %973 = add(%968, %972) /* ty=Tensor[(1, 7, 7, 512), float32] */;
    nn.relu(%973) /* ty=Tensor[(1, 7, 7, 512), float32] */
  };
  %975 = (%x297, %x301, %stage4_unit3_bn2_moving_mean, %x299, %stage4_unit3_bn2_beta);
  %976 = (%tensor_0151,);
  let %x302: () = vm.invoke_tvm_op(%974, %975, %976) /* ty=() */;
  let %x303: Tensor[(1, 7, 7, 512), float32] = %tensor_0151;
  let %storage_0152: Storage[] = memory.alloc_storage(2048 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][152]) /* ty=Storage[] */;
  let %tensor_0152: Tensor[(512), float32] = memory.alloc_tensor(%storage_0152, 0 /* ty=int64 */, meta[relay.Constant][152] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][152]) /* ty=Tensor[(512), float32] */;
  %980 = fn (%p0152: Tensor[(512), float32], %p1133: Tensor[(512), float32], Primitive=1) -> Tensor[(512), float32] {
    %977 = add(%p0152, 2e-05f /* ty=float32 */) /* ty=Tensor[(512), float32] */;
    %978 = sqrt(%977) /* ty=Tensor[(512), float32] */;
    %979 = divide(1f /* ty=float32 */, %978) /* ty=Tensor[(512), float32] */;
    multiply(%979, %p1133) /* ty=Tensor[(512), float32] */
  };
  %981 = (%stage4_unit3_bn3_moving_var, %stage4_unit3_bn3_gamma);
  %982 = (%tensor_0152,);
  let %x304: () = vm.invoke_tvm_op(%980, %981, %982) /* ty=() */;
  let %x305: Tensor[(512), float32] = %tensor_0152;
  let %storage_0153: Storage[] = memory.alloc_storage(9437184 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][153]) /* ty=Storage[] */;
  let %tensor_0153: Tensor[(3, 3, 512, 512), float32] = memory.alloc_tensor(%storage_0153, 0 /* ty=int64 */, meta[relay.Constant][153] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][153]) /* ty=Tensor[(3, 3, 512, 512), float32] */;
  %984 = fn (%p0153: Tensor[(512, 512, 3, 3), float32], %p1134: Tensor[(512), float32], Primitive=1) -> Tensor[(3, 3, 512, 512), float32] {
    %983 = layout_transform(%p0153, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(3, 3, 512, 512), float32] */;
    multiply(%983, %p1134) /* ty=Tensor[(3, 3, 512, 512), float32] */
  };
  %985 = (%stage4_unit3_conv2_weight, %x305);
  %986 = (%tensor_0153,);
  let %x306: () = vm.invoke_tvm_op(%984, %985, %986) /* ty=() */;
  let %x307: Tensor[(3, 3, 512, 512), float32] = %tensor_0153;
  let %storage_0154: Storage[] = memory.alloc_storage(100352 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][154]) /* ty=Storage[] */;
  let %tensor_0154: Tensor[(1, 7, 7, 512), float32] = memory.alloc_tensor(%storage_0154, 0 /* ty=int64 */, meta[relay.Constant][154] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][154]) /* ty=Tensor[(1, 7, 7, 512), float32] */;
  %993 = fn (%p0154: Tensor[(1, 7, 7, 512), float32], %p1135: Tensor[(3, 3, 512, 512), float32], %p261: Tensor[(512), float32], %p349: Tensor[(512), float32], %p447: Tensor[(512), float32], Primitive=1) -> Tensor[(1, 7, 7, 512), float32] {
    %987 = nn.conv2d(%p0154, %p1135, padding=[1, 1, 1, 1], channels=512, kernel_size=[3, 3], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 7, 7, 512), float32] */;
    %988 = negative(%p261) /* ty=Tensor[(512), float32] */;
    %989 = multiply(%988, %p349) /* ty=Tensor[(512), float32] */;
    %990 = add(%989, %p447) /* ty=Tensor[(512), float32] */;
    %991 = expand_dims(%990, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 512), float32] */;
    %992 = add(%987, %991) /* ty=Tensor[(1, 7, 7, 512), float32] */;
    nn.relu(%992) /* ty=Tensor[(1, 7, 7, 512), float32] */
  };
  %994 = (%x303, %x307, %stage4_unit3_bn3_moving_mean, %x305, %stage4_unit3_bn3_beta);
  %995 = (%tensor_0154,);
  let %x308: () = vm.invoke_tvm_op(%993, %994, %995) /* ty=() */;
  let %x309: Tensor[(1, 7, 7, 512), float32] = %tensor_0154;
  let %storage_0155: Storage[] = memory.alloc_storage(4194304 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][155]) /* ty=Storage[] */;
  let %tensor_0155: Tensor[(1, 1, 512, 2048), float32] = memory.alloc_tensor(%storage_0155, 0 /* ty=int64 */, meta[relay.Constant][155] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][155]) /* ty=Tensor[(1, 1, 512, 2048), float32] */;
  %996 = fn (%p0155: Tensor[(2048, 512, 1, 1), float32], Primitive=1) -> Tensor[(1, 1, 512, 2048), float32] {
    layout_transform(%p0155, src_layout="OIHW", dst_layout="HWIO") /* ty=Tensor[(1, 1, 512, 2048), float32] */
  };
  %997 = (%stage4_unit3_conv3_weight,);
  %998 = (%tensor_0155,);
  let %x310: () = vm.invoke_tvm_op(%996, %997, %998) /* ty=() */;
  let %x311: Tensor[(1, 1, 512, 2048), float32] = %tensor_0155;
  let %storage_0156: Storage[] = memory.alloc_storage(8192 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][156]) /* ty=Storage[] */;
  let %tensor_0156: Tensor[(2048), float32] = memory.alloc_tensor(%storage_0156, 0 /* ty=int64 */, meta[relay.Constant][156] /* ty=Tensor[(1), int64] */, meta[relay.attrs.AllocTensorAttrs][156]) /* ty=Tensor[(2048), float32] */;
  %1002 = fn (%p0156: Tensor[(2048), float32], %p1136: Tensor[(2048), float32], Primitive=1) -> Tensor[(2048), float32] {
    %999 = add(%p0156, 2e-05f /* ty=float32 */) /* ty=Tensor[(2048), float32] */;
    %1000 = sqrt(%999) /* ty=Tensor[(2048), float32] */;
    %1001 = divide(1f /* ty=float32 */, %1000) /* ty=Tensor[(2048), float32] */;
    multiply(%1001, %p1136) /* ty=Tensor[(2048), float32] */
  };
  %1003 = (%bn1_moving_var, %bn1_gamma);
  %1004 = (%tensor_0156,);
  let %x312: () = vm.invoke_tvm_op(%1002, %1003, %1004) /* ty=() */;
  let %x313: Tensor[(2048), float32] = %tensor_0156;
  let %storage_0157: Storage[] = memory.alloc_storage(401408 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][157]) /* ty=Storage[] */;
  let %tensor_0157: Tensor[(1, 7, 7, 2048), float32] = memory.alloc_tensor(%storage_0157, 0 /* ty=int64 */, meta[relay.Constant][157] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][157]) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
  %1014 = fn (%p0157: Tensor[(1, 7, 7, 512), float32], %p1137: Tensor[(1, 1, 512, 2048), float32], %p262: Tensor[(1, 7, 7, 2048), float32], %p350: Tensor[(2048), float32], %p448: Tensor[(2048), float32], %p53: Tensor[(2048), float32], Primitive=1) -> Tensor[(1, 7, 7, 2048), float32] {
    %1005 = nn.conv2d(%p0157, %p1137, padding=[0, 0, 0, 0], channels=2048, kernel_size=[1, 1], data_layout="NHWC", kernel_layout="HWIO") /* ty=Tensor[(1, 7, 7, 2048), float32] */;
    %1006 = add(%1005, %p262) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
    %1007 = expand_dims(%p350, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 2048), float32] */;
    %1008 = multiply(%1006, %1007) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
    %1009 = negative(%p448) /* ty=Tensor[(2048), float32] */;
    %1010 = multiply(%1009, %p350) /* ty=Tensor[(2048), float32] */;
    %1011 = add(%1010, %p53) /* ty=Tensor[(2048), float32] */;
    %1012 = expand_dims(%1011, axis=0, num_newaxis=3) /* ty=Tensor[(1, 1, 1, 2048), float32] */;
    %1013 = add(%1008, %1012) /* ty=Tensor[(1, 7, 7, 2048), float32] */;
    nn.relu(%1013) /* ty=Tensor[(1, 7, 7, 2048), float32] */
  };
  %1015 = (%x309, %x311, %x295, %x313, %bn1_moving_mean, %bn1_beta);
  %1016 = (%tensor_0157,);
  let %x314: () = vm.invoke_tvm_op(%1014, %1015, %1016) /* ty=() */;
  let %x315: Tensor[(1, 7, 7, 2048), float32] = %tensor_0157;
  let %storage_0158: Storage[] = memory.alloc_storage(8192 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][158]) /* ty=Storage[] */;
  let %tensor_0158: Tensor[(1, 1, 1, 2048), float32] = memory.alloc_tensor(%storage_0158, 0 /* ty=int64 */, meta[relay.Constant][158] /* ty=Tensor[(4), int64] */, meta[relay.attrs.AllocTensorAttrs][158]) /* ty=Tensor[(1, 1, 1, 2048), float32] */;
  %1017 = fn (%p0158: Tensor[(1, 7, 7, 2048), float32], Primitive=1) -> Tensor[(1, 1, 1, 2048), float32] {
    nn.global_avg_pool2d(%p0158, layout="NHWC") /* ty=Tensor[(1, 1, 1, 2048), float32] */
  };
  %1018 = (%x315,);
  %1019 = (%tensor_0158,);
  let %x316: () = vm.invoke_tvm_op(%1017, %1018, %1019) /* ty=() */;
  let %x317: Tensor[(1, 1, 1, 2048), float32] = %tensor_0158;
  let %storage_0159: Storage[] = memory.alloc_storage(8192 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][159]) /* ty=Storage[] */;
  let %tensor_0159: Tensor[(1, 2048), float32] = memory.alloc_tensor(%storage_0159, 0 /* ty=int64 */, meta[relay.Constant][159] /* ty=Tensor[(2), int64] */, meta[relay.attrs.AllocTensorAttrs][159]) /* ty=Tensor[(1, 2048), float32] */;
  %1021 = fn (%p0159: Tensor[(1, 1, 1, 2048), float32], Primitive=1) -> Tensor[(1, 2048), float32] {
    %1020 = layout_transform(%p0159, src_layout="NHWC", dst_layout="NCHW") /* ty=Tensor[(1, 2048, 1, 1), float32] */;
    nn.batch_flatten(%1020) /* ty=Tensor[(1, 2048), float32] */
  };
  %1022 = (%x317,);
  %1023 = (%tensor_0159,);
  let %x318: () = vm.invoke_tvm_op(%1021, %1022, %1023) /* ty=() */;
  let %x319: Tensor[(1, 2048), float32] = %tensor_0159;
  let %storage_0160: Storage[] = memory.alloc_storage(8192000 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][160]) /* ty=Storage[] */;
  let %tensor_0160: Tensor[(100, 2048, 10), float32] = memory.alloc_tensor(%storage_0160, 0 /* ty=int64 */, meta[relay.Constant][160] /* ty=Tensor[(3), int64] */, meta[relay.attrs.AllocTensorAttrs][160]) /* ty=Tensor[(100, 2048, 10), float32] */;
  %1024 = fn (%p0160: Tensor[(1000, 2048), float32], Primitive=1) -> Tensor[(100, 2048, 10), float32] {
    layout_transform(%p0160, src_layout="NK", dst_layout="NK10n") /* ty=Tensor[(100, 2048, 10), float32] */
  };
  %1025 = (%fc1_weight,);
  %1026 = (%tensor_0160,);
  let %x320: () = vm.invoke_tvm_op(%1024, %1025, %1026) /* ty=() */;
  let %x321: Tensor[(100, 2048, 10), float32] = %tensor_0160;
  let %storage_0161: Storage[] = memory.alloc_storage(4000 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][161]) /* ty=Storage[] */;
  let %tensor_0161: Tensor[(1, 1000), float32] = memory.alloc_tensor(%storage_0161, 0 /* ty=int64 */, meta[relay.Constant][161] /* ty=Tensor[(2), int64] */, meta[relay.attrs.AllocTensorAttrs][161]) /* ty=Tensor[(1, 1000), float32] */;
  %1028 = fn (%p0161: Tensor[(1, 2048), float32], %p1138: Tensor[(100, 2048, 10), float32], %p263: Tensor[(1000), float32], Primitive=1) -> Tensor[(1, 1000), float32] {
    %1027 = nn.contrib_dense_pack(%p0161, %p1138, units=None, out_dtype="float32") /* ty=Tensor[(1, 1000), float32] */;
    add(%1027, %p263) /* ty=Tensor[(1, 1000), float32] */
  };
  %1029 = (%x319, %x321, %fc1_bias);
  %1030 = (%tensor_0161,);
  let %x322: () = vm.invoke_tvm_op(%1028, %1029, %1030) /* ty=() */;
  let %x323: Tensor[(1, 1000), float32] = %tensor_0161;
  let %storage_0162: Storage[] = memory.alloc_storage(4000 /* ty=int64 */, 64 /* ty=int64 */, meta[relay.attrs.AllocStorageAttrs][162]) /* ty=Storage[] */;
  let %tensor_0162: Tensor[(1, 1000), float32] = memory.alloc_tensor(%storage_0162, 0 /* ty=int64 */, meta[relay.Constant][162] /* ty=Tensor[(2), int64] */, meta[relay.attrs.AllocTensorAttrs][162]) /* ty=Tensor[(1, 1000), float32] */;
  %1031 = fn (%p0162: Tensor[(1, 1000), float32], Primitive=1) -> Tensor[(1, 1000), float32] {
    nn.softmax(%p0162) /* ty=Tensor[(1, 1000), float32] */
  };
  %1032 = (%x323,);
  %1033 = (%tensor_0162,);
  let %x324: () = vm.invoke_tvm_op(%1031, %1032, %1033) /* ty=() */;
  let %x325: Tensor[(1, 1000), float32] = %tensor_0162;
  %x325
}