Adams autoscheduler stalling on subset of resnet18

[ivangarcia44]

The Adams autoscheduler is stalling on the resnet18 subset Halide generator code below. I tried a few AMD machines. My personal AMD machine died twice running it. Others kept running for hours, and for the cases it completed it returned "Killed" without additional clues.

The resnet18 subset Halide code below was automatically generated from Simulink deep learning layer blocks (https://www.mathworks.com/help/deeplearning/ug/list-of-deep-learning-layer-blocks.html) and Halide code generation (https://www.mathworks.com/help/ecoder/ug/speed-up-generated-code-execution-with-halide.html). We are trying to leverage automatically generated Halide code with the Adams autoscheduler for convolutional neural networks. This issue is a major blocker for us. What could be going wrong in this case?

Below are the full reproduction steps, you should be able to try in your machine.

commands:

export HALIDE_FOLDER=<Your Halide path goes here, I used Halide version 16.0.0>
mkdir bin1
g++ resnet18Subset.cpp -std=c++17 -g -I $HALIDE_FOLDER/include/ -L $HALIDE_FOLDER/bin/ -lHalide -lpthread -ldl -rdynamic -fno-rtti -Wl,-rpath,$HALIDE_FOLDER/bin/ $HALIDE_FOLDER/tools/GenGen.cpp -o bin1/resnet18SubsetLib
./bin1/resnet18SubsetLib -f resnet18SubsetFun -g resnet18SubsetGenerator -e static_library,h,assembly,bitcode,cpp,html,cpp_stub,stmt,o,schedule target=host-enable_llvm_loop_opt autoscheduler.parallelism=4 autoscheduler=Adams2019 -p $HALIDE_FOLDER/bin/libautoschedule_adams2019.so target=host -o bin1

Halide generator code:

#include "Halide.h"
#include <stdio.h>
#include <climits>
using namespace Halide;
class resnet18Subset : public Halide::Generator <resnet18Subset> {

    public:
        Input<Buffer<float>> rtb_MatrixConcatenate_in{"rtb_MatrixConcatenate_in", 3};
        Input<Buffer<float>> Weights_Value_in{"Weights_Value_in", 4};
        Input<Buffer<float>> pooled5_in{"pooled5_in", 1};
        Input<float> Selector_in{"Selector_in"};
        Input<float> Selector1_in{"Selector1_in"};
        Input<Buffer<float>> Weights_Value_m_in{"Weights_Value_m_in", 4};
        Input<float> Selector_h0_in{"Selector_h0_in"};
        Input<float> Selector1_jp_in{"Selector1_jp_in"};
        Input<Buffer<float>> Weights_Value_c_in{"Weights_Value_c_in", 4};
        Input<float> Selector_g_in{"Selector_g_in"};
        Input<float> Selector1_nd_in{"Selector1_nd_in"};
        Input<Buffer<float>> Weights_Value_n_in{"Weights_Value_n_in", 4};
        Input<float> Selector_nb_in{"Selector_nb_in"};
        Input<float> Selector1_b4_in{"Selector1_b4_in"};
        Input<Buffer<float>> Weights_Value_f_in{"Weights_Value_f_in", 4};
        Input<float> Selector_ha_in{"Selector_ha_in"};
        Input<float> Selector1_ni_in{"Selector1_ni_in"};
        Input<Buffer<float>> Weights_Value_i_in{"Weights_Value_i_in", 4};
        Input<Buffer<float>> pooled7_in{"pooled7_in", 1};
        Input<float> Selector_by_in{"Selector_by_in"};
        Input<float> Selector1_d_in{"Selector1_d_in"};
        Input<Buffer<float>> Weights_Value_p_in{"Weights_Value_p_in", 4};
        Input<float> Selector_nv_in{"Selector_nv_in"};
        Input<float> Selector1_j_in{"Selector1_j_in"};
        Input<Buffer<float>> Weights_Value_c1_in{"Weights_Value_c1_in", 4};
        Input<float> Selector_d_in{"Selector_d_in"};
        Input<float> Selector1_i_in{"Selector1_i_in"};
        Input<Buffer<float>> Weights_Value_m1_in{"Weights_Value_m1_in", 4};
        Input<float> Selector_n_in{"Selector_n_in"};
        Input<float> Selector1_mp_in{"Selector1_mp_in"};
        Input<Buffer<float>> Weights_Value_ne_in{"Weights_Value_ne_in", 4};
        Input<float> Selector_o4_in{"Selector_o4_in"};
        Input<float> Selector1_cf_in{"Selector1_cf_in"};
        Input<Buffer<float>> Weights_Value_h_in{"Weights_Value_h_in", 4};
        Input<Buffer<float>> pooled8_in{"pooled8_in", 1};
        Input<float> Selector_ih_in{"Selector_ih_in"};
        Input<float> Selector1_m_in{"Selector1_m_in"};
        Input<Buffer<float>> Weights_Value_l_in{"Weights_Value_l_in", 4};
        Input<float> Selector_og_in{"Selector_og_in"};
        Input<float> Selector1_ae_in{"Selector1_ae_in"};
        Input<Buffer<float>> Weights_Value_b_in{"Weights_Value_b_in", 4};
        Input<float> Selector_oa_in{"Selector_oa_in"};
        Input<float> Selector1_f_in{"Selector1_f_in"};
        Input<Buffer<float>> Weights_Value_k_in{"Weights_Value_k_in", 4};
        Input<float> Selector_a_in{"Selector_a_in"};
        Input<float> Selector1_l_in{"Selector1_l_in"};
        Input<Buffer<float>> Weights_Value_e_in{"Weights_Value_e_in", 4};
        Input<float> Selector_i_in{"Selector_i_in"};
        Input<float> Selector1_k_in{"Selector1_k_in"};
        Input<Buffer<float>> Weights_Value_j_in{"Weights_Value_j_in", 4};
        Input<Buffer<float>> pooled9_in{"pooled9_in", 1};
        Input<float> Selector_h_in{"Selector_h_in"};
        Input<float> Selector1_c_in{"Selector1_c_in"};
        Input<Buffer<float>> Weights_Value_kd_in{"Weights_Value_kd_in", 4};
        Input<float> Selector_be_in{"Selector_be_in"};
        Input<float> Selector1_b5_in{"Selector1_b5_in"};
        Input<Buffer<float>> Weights_Value_cp_in{"Weights_Value_cp_in", 4};
        Input<float> Selector_hi_in{"Selector_hi_in"};
        Input<float> Selector1_a_in{"Selector1_a_in"};
        Input<Buffer<float>> Weights_Value_fc_in{"Weights_Value_fc_in", 4};
        Input<float> Selector_o_in{"Selector_o_in"};
        Input<float> Selector1_n_in{"Selector1_n_in"};
        Input<Buffer<float>> Weights_Value_li_in{"Weights_Value_li_in", 4};
        Input<float> Selector_b_in{"Selector_b_in"};
        Input<float> Selector1_b_in{"Selector1_b_in"};
        Output<Buffer<float>> rtb_ImpAsg_InsertedFor_Out1_at_fcn{"rtb_ImpAsg_InsertedFor_Out1_at_fcn", 3};

        void generate() {
            rtb_MatrixConcatenate_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_MatrixConcatenate_in, 0)(d1, d2, d3);
            RDom r(0, 7, 0, 7, 0, 3);
            rtb_ImpAsg_InsertedFor_Outpu_lq_func(d1, d2, d3) = sum(rtb_MatrixConcatenate_clamped(2*d1+r.x-3, 2*d2+r.y-3, r.z) * Weights_Value_in(r.x, r.y, r.z, d3))+pooled5_in(d3);
            rtb_ImpAsg_InsertedFor_Out_at_i_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_lq_func(d1, d2, d3) * Selector_in + Selector1_in;
            rtb_ImpAsg_InsertedFor_Out1__ph_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out_at_i_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1__ph_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1__ph_func, cast<float>(Expr(-340282346638528897590636046441678635008.000000)), {{0, 112}, {0, 112}, {0, 64}})(d1, d2, d3);
            RDom r1(0, 3, 0, 3);
            rtb_ImpAsg_InsertedFor_Out1_a_n_func(d1, d2, d3) = maximum(rtb_ImpAsg_InsertedFor_Out1__ph_clamped(2*d1+r1.x-1, 2*d2+r1.y-1, d3));
            rtb_ImpAsg_InsertedFor_Out1_a_n_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_n_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r2(0, 3, 0, 3, 0, 64);
            rtb_ImpAsg_InsertedFor_Output_d_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_n_clamped(d1+r2.x-1, d2+r2.y-1, r2.z) * Weights_Value_m_in(r2.x, r2.y, r2.z, d3))+pooled5_in(d3);
            rtb_ImpAsg_InsertedFor_Out_a_fm_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_d_func(d1, d2, d3) * Selector_h0_in + Selector1_jp_in;
            rtb_ImpAsg_InsertedFor_Out1_a_h_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out_a_fm_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_a_h_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_h_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r3(0, 3, 0, 3, 0, 64);
            rtb_ImpAsg_InsertedFor_Outpu_go_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_h_clamped(d1+r3.x-1, d2+r3.y-1, r3.z) * Weights_Value_c_in(r3.x, r3.y, r3.z, d3))+pooled5_in(d3);
            rtb_ImpAsg_InsertedFor_Out_at_f_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_go_func(d1, d2, d3) * Selector_g_in + Selector1_nd_in;
            rtb_ImpAsg_InsertedFor_Out1__kq_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Out_at_f_func(d1, d2, d3) + rtb_ImpAsg_InsertedFor_Out1_a_n_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFor_Out1__dk_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out1__kq_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1__dk_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1__dk_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r4(0, 3, 0, 3, 0, 64);
            rtb_ImpAsg_InsertedFor_Outpu_gz_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1__dk_clamped(d1+r4.x-1, d2+r4.y-1, r4.z) * Weights_Value_n_in(r4.x, r4.y, r4.z, d3))+pooled5_in(d3);
            rtb_ImpAsg_InsertedFor_Out_at_o_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_gz_func(d1, d2, d3) * Selector_nb_in + Selector1_b4_in;
            rtb_ImpAsg_InsertedFor_Out1__fn_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out_at_o_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1__fn_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1__fn_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r5(0, 3, 0, 3, 0, 64);
            rtb_ImpAsg_InsertedFor_Output_l_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1__fn_clamped(d1+r5.x-1, d2+r5.y-1, r5.z) * Weights_Value_f_in(r5.x, r5.y, r5.z, d3))+pooled5_in(d3);
            rtb_ImpAsg_InsertedFor_Out_at_b_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_l_func(d1, d2, d3) * Selector_ha_in + Selector1_ni_in;
            rtb_ImpAsg_InsertedFor_Out1_a_a_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Out_at_b_func(d1, d2, d3) + rtb_ImpAsg_InsertedFor_Out1__dk_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFor_Out1_a_d_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out1_a_a_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_a_d_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_d_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r6(0, 3, 0, 3, 0, 64);
            rtb_ImpAsg_InsertedFor_Output_h_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_d_clamped(2*d1+r6.x-1, 2*d2+r6.y-1, r6.z) * Weights_Value_i_in(r6.x, r6.y, r6.z, d3))+pooled7_in(d3);
            rtb_ImpAsg_Inser_ge3aidxxc3fepd_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_h_func(d1, d2, d3) * Selector_by_in + Selector1_d_in;
            rtb_ImpAsg_InsertedFor_Out1_a_f_func(d1, d2, d3) = max(rtb_ImpAsg_Inser_ge3aidxxc3fepd_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_a_f_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_f_func, 0, {{0, 28}, {0, 28}, {0, 128}})(d1, d2, d3);
            RDom r7(0, 3, 0, 3, 0, 128);
            rtb_ImpAsg_InsertedFor_Outpu_i0_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_f_clamped(d1+r7.x-1, d2+r7.y-1, r7.z) * Weights_Value_p_in(r7.x, r7.y, r7.z, d3))+pooled7_in(d3);
            rtb_ImpAsg_Insert_ge3aidxxc3fep_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_i0_func(d1, d2, d3) * Selector_nv_in + Selector1_j_in;
            rtb_ImpAsg_InsertedFor_Out1_a_d_clamped_1(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_d_func, 0, {{0, 56}, {0, 56}, {0, 64}})(d1, d2, d3);
            RDom r8(0, 64);
            rtb_ImpAsg_InsertedFor_Outpu_im_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_d_clamped_1(2*d1, 2*d2, r8) * Weights_Value_c1_in(0, 0, r8, d3))+pooled7_in(d3);
            rtb_ImpAsg_Inse_ge3aidxxc3fepdc_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_im_func(d1, d2, d3) * Selector_d_in + Selector1_i_in;
            rtb_ImpAsg_InsertedFor_Out1_a_p_func(d1, d2, d3) = rtb_ImpAsg_Insert_ge3aidxxc3fep_func(d1, d2, d3) + rtb_ImpAsg_Inse_ge3aidxxc3fepdc_func(d1, d2, d3);
            rtb_ImpAsg_Inse_ke3scgxilhaxevx_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out1_a_p_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_Inse_ke3scgxilhaxevx_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_Inse_ke3scgxilhaxevx_func, 0, {{0, 28}, {0, 28}, {0, 128}})(d1, d2, d3);
            RDom r9(0, 3, 0, 3, 0, 128);
            rtb_ImpAsg_InsertedFor_Output_b_func(d1, d2, d3) = sum(rtb_ImpAsg_Inse_ke3scgxilhaxevx_clamped(d1+r9.x-1, d2+r9.y-1, r9.z) * Weights_Value_m1_in(r9.x, r9.y, r9.z, d3))+pooled7_in(d3);
            rtb_ImpAsg_Inserte_ge3aidxxc3fe_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_b_func(d1, d2, d3) * Selector_n_in + Selector1_mp_in;
            rtb_ImpAsg_Insert_ke3scgxilhaxe_func(d1, d2, d3) = max(rtb_ImpAsg_Inserte_ge3aidxxc3fe_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_Insert_ke3scgxilhaxe_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_Insert_ke3scgxilhaxe_func, 0, {{0, 28}, {0, 28}, {0, 128}})(d1, d2, d3);
            RDom r10(0, 3, 0, 3, 0, 128);
            rtb_ImpAsg_InsertedFor_Output_g_func(d1, d2, d3) = sum(rtb_ImpAsg_Insert_ke3scgxilhaxe_clamped(d1+r10.x-1, d2+r10.y-1, r10.z) * Weights_Value_ne_in(r10.x, r10.y, r10.z, d3))+pooled7_in(d3);
            rtb_ImpAsg_Inserted_ge3aidxxc3f_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_g_func(d1, d2, d3) * Selector_o4_in + Selector1_cf_in;
            rtb_ImpAsg_Inser_ke3scgxilhaxev_func(d1, d2, d3) = rtb_ImpAsg_Inserted_ge3aidxxc3f_func(d1, d2, d3) + rtb_ImpAsg_Inse_ke3scgxilhaxevx_func(d1, d2, d3);
            rtb_ImpAsg_Inserte_ke3scgxilhax_func(d1, d2, d3) = max(rtb_ImpAsg_Inser_ke3scgxilhaxev_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_Inserte_ke3scgxilhax_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_Inserte_ke3scgxilhax_func, 0, {{0, 28}, {0, 28}, {0, 128}})(d1, d2, d3);
            RDom r11(0, 3, 0, 3, 0, 128);
            rtb_ImpAsg_InsertedFor_Output_c_func(d1, d2, d3) = sum(rtb_ImpAsg_Inserte_ke3scgxilhax_clamped(2*d1+r11.x-1, 2*d2+r11.y-1, r11.z) * Weights_Value_h_in(r11.x, r11.y, r11.z, d3))+pooled8_in(d3);
            rtb_ImpAsg_InsertedFo_ge3aidxxc_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_c_func(d1, d2, d3) * Selector_ih_in + Selector1_m_in;
            rtb_ImpAsg_InsertedF_ke3scgxilh_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFo_ge3aidxxc_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedF_ke3scgxilh_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedF_ke3scgxilh_func, 0, {{0, 14}, {0, 14}, {0, 256}})(d1, d2, d3);
            RDom r12(0, 3, 0, 3, 0, 256);
            rtb_ImpAsg_InsertedFor_Output_p_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedF_ke3scgxilh_clamped(d1+r12.x-1, d2+r12.y-1, r12.z) * Weights_Value_l_in(r12.x, r12.y, r12.z, d3))+pooled8_in(d3);
            rtb_ImpAsg_InsertedFor_ge3aidxx_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_p_func(d1, d2, d3) * Selector_og_in + Selector1_ae_in;
            rtb_ImpAsg_Inserte_ke3scgxilhax_clamped_1(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_Inserte_ke3scgxilhax_func, 0, {{0, 28}, {0, 28}, {0, 128}})(d1, d2, d3);
            RDom r13(0, 128);
            rtb_ImpAsg_InsertedFor_Output_m_func(d1, d2, d3) = sum(rtb_ImpAsg_Inserte_ke3scgxilhax_clamped_1(2*d1, 2*d2, r13) * Weights_Value_b_in(0, 0, r13, d3))+pooled8_in(d3);
            rtb_ImpAsg_InsertedF_ge3aidxxc3_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_m_func(d1, d2, d3) * Selector_oa_in + Selector1_f_in;
            rtb_ImpAsg_Inserted_ke3scgxilha_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_ge3aidxx_func(d1, d2, d3) + rtb_ImpAsg_InsertedF_ge3aidxxc3_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFo_ke3scgxil_func(d1, d2, d3) = max(rtb_ImpAsg_Inserted_ke3scgxilha_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFo_ke3scgxil_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFo_ke3scgxil_func, 0, {{0, 14}, {0, 14}, {0, 256}})(d1, d2, d3);
            RDom r14(0, 3, 0, 3, 0, 256);
            rtb_ImpAsg_InsertedFor_Outpu_oo_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFo_ke3scgxil_clamped(d1+r14.x-1, d2+r14.y-1, r14.z) * Weights_Value_k_in(r14.x, r14.y, r14.z, d3))+pooled8_in(d3);
            rtb_ImpAsg_InsertedFor__ge3aidx_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_oo_func(d1, d2, d3) * Selector_a_in + Selector1_l_in;
            rtb_ImpAsg_InsertedFor__ke3scgx_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor__ge3aidx_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor__ke3scgx_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor__ke3scgx_func, 0, {{0, 14}, {0, 14}, {0, 256}})(d1, d2, d3);
            RDom r15(0, 3, 0, 3, 0, 256);
            rtb_ImpAsg_InsertedFor_Output_f_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor__ke3scgx_clamped(d1+r15.x-1, d2+r15.y-1, r15.z) * Weights_Value_e_in(r15.x, r15.y, r15.z, d3))+pooled8_in(d3);
            rtb_ImpAsg_InsertedFor_O_ge3aid_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_f_func(d1, d2, d3) * Selector_i_in + Selector1_k_in;
            rtb_ImpAsg_InsertedFor_ke3scgxi_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_O_ge3aid_func(d1, d2, d3) + rtb_ImpAsg_InsertedFo_ke3scgxil_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFor_O_ke3scg_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_ke3scgxi_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_O_ke3scg_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_O_ke3scg_func, 0, {{0, 14}, {0, 14}, {0, 256}})(d1, d2, d3);
            RDom r16(0, 3, 0, 3, 0, 256);
            rtb_ImpAsg_InsertedFor_Outpu_i1_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_O_ke3scg_clamped(2*d1+r16.x-1, 2*d2+r16.y-1, r16.z) * Weights_Value_j_in(r16.x, r16.y, r16.z, d3))+pooled9_in(d3);
            rtb_ImpAsg_InsertedFor_Out_ge3a_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_i1_func(d1, d2, d3) * Selector_h_in + Selector1_c_in;
            rtb_ImpAsg_InsertedFor_Out_ke3s_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out_ge3a_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out_ke3s_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out_ke3s_func, 0, {{0, 7}, {0, 7}, {0, 512}})(d1, d2, d3);
            RDom r17(0, 3, 0, 3, 0, 512);
            rtb_ImpAsg_InsertedFor_Outpu_ox_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out_ke3s_clamped(d1+r17.x-1, d2+r17.y-1, r17.z) * Weights_Value_kd_in(r17.x, r17.y, r17.z, d3))+pooled9_in(d3);
            rtb_ImpAsg_InsertedFor_Out__ge3_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Outpu_ox_func(d1, d2, d3) * Selector_be_in + Selector1_b5_in;
            rtb_ImpAsg_InsertedFor_O_ke3scg_clamped_1(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_O_ke3scg_func, 0, {{0, 14}, {0, 14}, {0, 256}})(d1, d2, d3);
            RDom r18(0, 256);
            rtb_ImpAsg_InsertedFor_Output_n_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_O_ke3scg_clamped_1(2*d1, 2*d2, r18) * Weights_Value_cp_in(0, 0, r18, d3))+pooled9_in(d3);
            rtb_ImpAsg_InsertedFor_Ou_ge3ai_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_n_func(d1, d2, d3) * Selector_hi_in + Selector1_a_in;
            rtb_ImpAsg_InsertedFor_Ou_ke3sc_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Out__ge3_func(d1, d2, d3) + rtb_ImpAsg_InsertedFor_Ou_ge3ai_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFor_Out1_ke3_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Ou_ke3sc_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_ke3_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_ke3_func, 0, {{0, 7}, {0, 7}, {0, 512}})(d1, d2, d3);
            RDom r19(0, 3, 0, 3, 0, 512);
            rtb_ImpAsg_InsertedFor_Output_o_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_ke3_clamped(d1+r19.x-1, d2+r19.y-1, r19.z) * Weights_Value_fc_in(r19.x, r19.y, r19.z, d3))+pooled9_in(d3);
            rtb_ImpAsg_InsertedFor_Out_a_ge_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_o_func(d1, d2, d3) * Selector_o_in + Selector1_n_in;
            rtb_ImpAsg_InsertedFor_Out1_a_k_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out_a_ge_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_a_k_clamped(d1, d2, d3) = BoundaryConditions::constant_exterior(rtb_ImpAsg_InsertedFor_Out1_a_k_func, 0, {{0, 7}, {0, 7}, {0, 512}})(d1, d2, d3);
            RDom r20(0, 3, 0, 3, 0, 512);
            rtb_ImpAsg_InsertedFor_Output_i_func(d1, d2, d3) = sum(rtb_ImpAsg_InsertedFor_Out1_a_k_clamped(d1+r20.x-1, d2+r20.y-1, r20.z) * Weights_Value_li_in(r20.x, r20.y, r20.z, d3))+pooled9_in(d3);
            rtb_ImpAsg_InsertedFor_Out_at_g_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Output_i_func(d1, d2, d3) * Selector_b_in + Selector1_b_in;
            rtb_ImpAsg_InsertedFor_Out1__ke_func(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Out_at_g_func(d1, d2, d3) + rtb_ImpAsg_InsertedFor_Out1_ke3_func(d1, d2, d3);
            rtb_ImpAsg_InsertedFor_Out1_at_func(d1, d2, d3) = max(rtb_ImpAsg_InsertedFor_Out1__ke_func(d1, d2, d3),0.000000000f);
            rtb_ImpAsg_InsertedFor_Out1_at_fcn(d1, d2, d3) = rtb_ImpAsg_InsertedFor_Out1_at_func(d1, d2, d3);
        }

        void schedule() {
        // Schedule is determined by autoscheduler. Need to set estimate on buffer
            if(using_autoscheduler()) {
                rtb_MatrixConcatenate_in.dim(2).set_estimate(0, 3);
                rtb_MatrixConcatenate_in.dim(1).set_estimate(0, 224);
                rtb_MatrixConcatenate_in.dim(0).set_estimate(0, 224);
                Weights_Value_in.dim(3).set_estimate(0, 64);
                Weights_Value_in.dim(2).set_estimate(0, 3);
                Weights_Value_in.dim(1).set_estimate(0, 7);
                Weights_Value_in.dim(0).set_estimate(0, 7);
                pooled5_in.dim(0).set_estimate(0, 64);
                Selector_in.set_estimate(1.0f);
                Selector1_in.set_estimate(1.0f);
                Weights_Value_m_in.dim(3).set_estimate(0, 64);
                Weights_Value_m_in.dim(2).set_estimate(0, 64);
                Weights_Value_m_in.dim(1).set_estimate(0, 3);
                Weights_Value_m_in.dim(0).set_estimate(0, 3);
                Selector_h0_in.set_estimate(1.0f);
                Selector1_jp_in.set_estimate(1.0f);
                Weights_Value_c_in.dim(3).set_estimate(0, 64);
                Weights_Value_c_in.dim(2).set_estimate(0, 64);
                Weights_Value_c_in.dim(1).set_estimate(0, 3);
                Weights_Value_c_in.dim(0).set_estimate(0, 3);
                Selector_g_in.set_estimate(1.0f);
                Selector1_nd_in.set_estimate(1.0f);
                Weights_Value_n_in.dim(3).set_estimate(0, 64);
                Weights_Value_n_in.dim(2).set_estimate(0, 64);
                Weights_Value_n_in.dim(1).set_estimate(0, 3);
                Weights_Value_n_in.dim(0).set_estimate(0, 3);
                Selector_nb_in.set_estimate(1.0f);
                Selector1_b4_in.set_estimate(1.0f);
                Weights_Value_f_in.dim(3).set_estimate(0, 64);
                Weights_Value_f_in.dim(2).set_estimate(0, 64);
                Weights_Value_f_in.dim(1).set_estimate(0, 3);
                Weights_Value_f_in.dim(0).set_estimate(0, 3);
                Selector_ha_in.set_estimate(1.0f);
                Selector1_ni_in.set_estimate(1.0f);
                Weights_Value_i_in.dim(3).set_estimate(0, 128);
                Weights_Value_i_in.dim(2).set_estimate(0, 64);
                Weights_Value_i_in.dim(1).set_estimate(0, 3);
                Weights_Value_i_in.dim(0).set_estimate(0, 3);
                pooled7_in.dim(0).set_estimate(0, 128);
                Selector_by_in.set_estimate(1.0f);
                Selector1_d_in.set_estimate(1.0f);
                Weights_Value_p_in.dim(3).set_estimate(0, 128);
                Weights_Value_p_in.dim(2).set_estimate(0, 128);
                Weights_Value_p_in.dim(1).set_estimate(0, 3);
                Weights_Value_p_in.dim(0).set_estimate(0, 3);
                Selector_nv_in.set_estimate(1.0f);
                Selector1_j_in.set_estimate(1.0f);
                Weights_Value_c1_in.dim(3).set_estimate(0, 128);
                Weights_Value_c1_in.dim(2).set_estimate(0, 64);
                Weights_Value_c1_in.dim(1).set_estimate(0, 1);
                Weights_Value_c1_in.dim(0).set_estimate(0, 1);
                Selector_d_in.set_estimate(1.0f);
                Selector1_i_in.set_estimate(1.0f);
                Weights_Value_m1_in.dim(3).set_estimate(0, 128);
                Weights_Value_m1_in.dim(2).set_estimate(0, 128);
                Weights_Value_m1_in.dim(1).set_estimate(0, 3);
                Weights_Value_m1_in.dim(0).set_estimate(0, 3);
                Selector_n_in.set_estimate(1.0f);
                Selector1_mp_in.set_estimate(1.0f);
                Weights_Value_ne_in.dim(3).set_estimate(0, 128);
                Weights_Value_ne_in.dim(2).set_estimate(0, 128);
                Weights_Value_ne_in.dim(1).set_estimate(0, 3);
                Weights_Value_ne_in.dim(0).set_estimate(0, 3);
                Selector_o4_in.set_estimate(1.0f);
                Selector1_cf_in.set_estimate(1.0f);
                Weights_Value_h_in.dim(3).set_estimate(0, 256);
                Weights_Value_h_in.dim(2).set_estimate(0, 128);
                Weights_Value_h_in.dim(1).set_estimate(0, 3);
                Weights_Value_h_in.dim(0).set_estimate(0, 3);
                pooled8_in.dim(0).set_estimate(0, 256);
                Selector_ih_in.set_estimate(1.0f);
                Selector1_m_in.set_estimate(1.0f);
                Weights_Value_l_in.dim(3).set_estimate(0, 256);
                Weights_Value_l_in.dim(2).set_estimate(0, 256);
                Weights_Value_l_in.dim(1).set_estimate(0, 3);
                Weights_Value_l_in.dim(0).set_estimate(0, 3);
                Selector_og_in.set_estimate(1.0f);
                Selector1_ae_in.set_estimate(1.0f);
                Weights_Value_b_in.dim(3).set_estimate(0, 256);
                Weights_Value_b_in.dim(2).set_estimate(0, 128);
                Weights_Value_b_in.dim(1).set_estimate(0, 1);
                Weights_Value_b_in.dim(0).set_estimate(0, 1);
                Selector_oa_in.set_estimate(1.0f);
                Selector1_f_in.set_estimate(1.0f);
                Weights_Value_k_in.dim(3).set_estimate(0, 256);
                Weights_Value_k_in.dim(2).set_estimate(0, 256);
                Weights_Value_k_in.dim(1).set_estimate(0, 3);
                Weights_Value_k_in.dim(0).set_estimate(0, 3);
                Selector_a_in.set_estimate(1.0f);
                Selector1_l_in.set_estimate(1.0f);
                Weights_Value_e_in.dim(3).set_estimate(0, 256);
                Weights_Value_e_in.dim(2).set_estimate(0, 256);
                Weights_Value_e_in.dim(1).set_estimate(0, 3);
                Weights_Value_e_in.dim(0).set_estimate(0, 3);
                Selector_i_in.set_estimate(1.0f);
                Selector1_k_in.set_estimate(1.0f);
                Weights_Value_j_in.dim(3).set_estimate(0, 512);
                Weights_Value_j_in.dim(2).set_estimate(0, 256);
                Weights_Value_j_in.dim(1).set_estimate(0, 3);
                Weights_Value_j_in.dim(0).set_estimate(0, 3);
                pooled9_in.dim(0).set_estimate(0, 512);
                Selector_h_in.set_estimate(1.0f);
                Selector1_c_in.set_estimate(1.0f);
                Weights_Value_kd_in.dim(3).set_estimate(0, 512);
                Weights_Value_kd_in.dim(2).set_estimate(0, 512);
                Weights_Value_kd_in.dim(1).set_estimate(0, 3);
                Weights_Value_kd_in.dim(0).set_estimate(0, 3);
                Selector_be_in.set_estimate(1.0f);
                Selector1_b5_in.set_estimate(1.0f);
                Weights_Value_cp_in.dim(3).set_estimate(0, 512);
                Weights_Value_cp_in.dim(2).set_estimate(0, 256);
                Weights_Value_cp_in.dim(1).set_estimate(0, 1);
                Weights_Value_cp_in.dim(0).set_estimate(0, 1);
                Selector_hi_in.set_estimate(1.0f);
                Selector1_a_in.set_estimate(1.0f);
                Weights_Value_fc_in.dim(3).set_estimate(0, 512);
                Weights_Value_fc_in.dim(2).set_estimate(0, 512);
                Weights_Value_fc_in.dim(1).set_estimate(0, 3);
                Weights_Value_fc_in.dim(0).set_estimate(0, 3);
                Selector_o_in.set_estimate(1.0f);
                Selector1_n_in.set_estimate(1.0f);
                Weights_Value_li_in.dim(3).set_estimate(0, 512);
                Weights_Value_li_in.dim(2).set_estimate(0, 512);
                Weights_Value_li_in.dim(1).set_estimate(0, 3);
                Weights_Value_li_in.dim(0).set_estimate(0, 3);
                Selector_b_in.set_estimate(1.0f);
                Selector1_b_in.set_estimate(1.0f);
                rtb_ImpAsg_InsertedFor_Out1_at_fcn.set_estimate(d1, 0, 7).set_estimate(d2, 0, 7).set_estimate(d3, 0, 512);
            }  else {
                // Default schedule
            }
        }

    private:
        Var d1{"d1"};
        Var d2{"d2"};
        Var d3{"d3"};
        Var d4{"d4"};
        Func rtb_MatrixConcatenate_clamped{"rtb_MatrixConcatenate_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_lq_func{"rtb_ImpAsg_InsertedFor_Outpu_lq_func"};
        Func rtb_ImpAsg_InsertedFor_Out_at_i_func{"rtb_ImpAsg_InsertedFor_Out_at_i_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__ph_func{"rtb_ImpAsg_InsertedFor_Out1__ph_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__ph_clamped{"rtb_ImpAsg_InsertedFor_Out1__ph_clamped"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_n_func{"rtb_ImpAsg_InsertedFor_Out1_a_n_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_n_clamped{"rtb_ImpAsg_InsertedFor_Out1_a_n_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_d_func{"rtb_ImpAsg_InsertedFor_Output_d_func"};
        Func rtb_ImpAsg_InsertedFor_Out_a_fm_func{"rtb_ImpAsg_InsertedFor_Out_a_fm_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_h_func{"rtb_ImpAsg_InsertedFor_Out1_a_h_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_h_clamped{"rtb_ImpAsg_InsertedFor_Out1_a_h_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_go_func{"rtb_ImpAsg_InsertedFor_Outpu_go_func"};
        Func rtb_ImpAsg_InsertedFor_Out_at_f_func{"rtb_ImpAsg_InsertedFor_Out_at_f_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__kq_func{"rtb_ImpAsg_InsertedFor_Out1__kq_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__dk_func{"rtb_ImpAsg_InsertedFor_Out1__dk_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__dk_clamped{"rtb_ImpAsg_InsertedFor_Out1__dk_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_gz_func{"rtb_ImpAsg_InsertedFor_Outpu_gz_func"};
        Func rtb_ImpAsg_InsertedFor_Out_at_o_func{"rtb_ImpAsg_InsertedFor_Out_at_o_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__fn_func{"rtb_ImpAsg_InsertedFor_Out1__fn_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__fn_clamped{"rtb_ImpAsg_InsertedFor_Out1__fn_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_l_func{"rtb_ImpAsg_InsertedFor_Output_l_func"};
        Func rtb_ImpAsg_InsertedFor_Out_at_b_func{"rtb_ImpAsg_InsertedFor_Out_at_b_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_a_func{"rtb_ImpAsg_InsertedFor_Out1_a_a_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_d_func{"rtb_ImpAsg_InsertedFor_Out1_a_d_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_d_clamped{"rtb_ImpAsg_InsertedFor_Out1_a_d_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_h_func{"rtb_ImpAsg_InsertedFor_Output_h_func"};
        Func rtb_ImpAsg_Inser_ge3aidxxc3fepd_func{"rtb_ImpAsg_Inser_ge3aidxxc3fepd_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_f_func{"rtb_ImpAsg_InsertedFor_Out1_a_f_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_f_clamped{"rtb_ImpAsg_InsertedFor_Out1_a_f_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_i0_func{"rtb_ImpAsg_InsertedFor_Outpu_i0_func"};
        Func rtb_ImpAsg_Insert_ge3aidxxc3fep_func{"rtb_ImpAsg_Insert_ge3aidxxc3fep_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_d_clamped_1{"rtb_ImpAsg_InsertedFor_Out1_a_d_clamped_1"};
        Func rtb_ImpAsg_InsertedFor_Outpu_im_func{"rtb_ImpAsg_InsertedFor_Outpu_im_func"};
        Func rtb_ImpAsg_Inse_ge3aidxxc3fepdc_func{"rtb_ImpAsg_Inse_ge3aidxxc3fepdc_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_p_func{"rtb_ImpAsg_InsertedFor_Out1_a_p_func"};
        Func rtb_ImpAsg_Inse_ke3scgxilhaxevx_func{"rtb_ImpAsg_Inse_ke3scgxilhaxevx_func"};
        Func rtb_ImpAsg_Inse_ke3scgxilhaxevx_clamped{"rtb_ImpAsg_Inse_ke3scgxilhaxevx_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_b_func{"rtb_ImpAsg_InsertedFor_Output_b_func"};
        Func rtb_ImpAsg_Inserte_ge3aidxxc3fe_func{"rtb_ImpAsg_Inserte_ge3aidxxc3fe_func"};
        Func rtb_ImpAsg_Insert_ke3scgxilhaxe_func{"rtb_ImpAsg_Insert_ke3scgxilhaxe_func"};
        Func rtb_ImpAsg_Insert_ke3scgxilhaxe_clamped{"rtb_ImpAsg_Insert_ke3scgxilhaxe_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_g_func{"rtb_ImpAsg_InsertedFor_Output_g_func"};
        Func rtb_ImpAsg_Inserted_ge3aidxxc3f_func{"rtb_ImpAsg_Inserted_ge3aidxxc3f_func"};
        Func rtb_ImpAsg_Inser_ke3scgxilhaxev_func{"rtb_ImpAsg_Inser_ke3scgxilhaxev_func"};
        Func rtb_ImpAsg_Inserte_ke3scgxilhax_func{"rtb_ImpAsg_Inserte_ke3scgxilhax_func"};
        Func rtb_ImpAsg_Inserte_ke3scgxilhax_clamped{"rtb_ImpAsg_Inserte_ke3scgxilhax_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_c_func{"rtb_ImpAsg_InsertedFor_Output_c_func"};
        Func rtb_ImpAsg_InsertedFo_ge3aidxxc_func{"rtb_ImpAsg_InsertedFo_ge3aidxxc_func"};
        Func rtb_ImpAsg_InsertedF_ke3scgxilh_func{"rtb_ImpAsg_InsertedF_ke3scgxilh_func"};
        Func rtb_ImpAsg_InsertedF_ke3scgxilh_clamped{"rtb_ImpAsg_InsertedF_ke3scgxilh_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_p_func{"rtb_ImpAsg_InsertedFor_Output_p_func"};
        Func rtb_ImpAsg_InsertedFor_ge3aidxx_func{"rtb_ImpAsg_InsertedFor_ge3aidxx_func"};
        Func rtb_ImpAsg_Inserte_ke3scgxilhax_clamped_1{"rtb_ImpAsg_Inserte_ke3scgxilhax_clamped_1"};
        Func rtb_ImpAsg_InsertedFor_Output_m_func{"rtb_ImpAsg_InsertedFor_Output_m_func"};
        Func rtb_ImpAsg_InsertedF_ge3aidxxc3_func{"rtb_ImpAsg_InsertedF_ge3aidxxc3_func"};
        Func rtb_ImpAsg_Inserted_ke3scgxilha_func{"rtb_ImpAsg_Inserted_ke3scgxilha_func"};
        Func rtb_ImpAsg_InsertedFo_ke3scgxil_func{"rtb_ImpAsg_InsertedFo_ke3scgxil_func"};
        Func rtb_ImpAsg_InsertedFo_ke3scgxil_clamped{"rtb_ImpAsg_InsertedFo_ke3scgxil_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_oo_func{"rtb_ImpAsg_InsertedFor_Outpu_oo_func"};
        Func rtb_ImpAsg_InsertedFor__ge3aidx_func{"rtb_ImpAsg_InsertedFor__ge3aidx_func"};
        Func rtb_ImpAsg_InsertedFor__ke3scgx_func{"rtb_ImpAsg_InsertedFor__ke3scgx_func"};
        Func rtb_ImpAsg_InsertedFor__ke3scgx_clamped{"rtb_ImpAsg_InsertedFor__ke3scgx_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_f_func{"rtb_ImpAsg_InsertedFor_Output_f_func"};
        Func rtb_ImpAsg_InsertedFor_O_ge3aid_func{"rtb_ImpAsg_InsertedFor_O_ge3aid_func"};
        Func rtb_ImpAsg_InsertedFor_ke3scgxi_func{"rtb_ImpAsg_InsertedFor_ke3scgxi_func"};
        Func rtb_ImpAsg_InsertedFor_O_ke3scg_func{"rtb_ImpAsg_InsertedFor_O_ke3scg_func"};
        Func rtb_ImpAsg_InsertedFor_O_ke3scg_clamped{"rtb_ImpAsg_InsertedFor_O_ke3scg_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_i1_func{"rtb_ImpAsg_InsertedFor_Outpu_i1_func"};
        Func rtb_ImpAsg_InsertedFor_Out_ge3a_func{"rtb_ImpAsg_InsertedFor_Out_ge3a_func"};
        Func rtb_ImpAsg_InsertedFor_Out_ke3s_func{"rtb_ImpAsg_InsertedFor_Out_ke3s_func"};
        Func rtb_ImpAsg_InsertedFor_Out_ke3s_clamped{"rtb_ImpAsg_InsertedFor_Out_ke3s_clamped"};
        Func rtb_ImpAsg_InsertedFor_Outpu_ox_func{"rtb_ImpAsg_InsertedFor_Outpu_ox_func"};
        Func rtb_ImpAsg_InsertedFor_Out__ge3_func{"rtb_ImpAsg_InsertedFor_Out__ge3_func"};
        Func rtb_ImpAsg_InsertedFor_O_ke3scg_clamped_1{"rtb_ImpAsg_InsertedFor_O_ke3scg_clamped_1"};
        Func rtb_ImpAsg_InsertedFor_Output_n_func{"rtb_ImpAsg_InsertedFor_Output_n_func"};
        Func rtb_ImpAsg_InsertedFor_Ou_ge3ai_func{"rtb_ImpAsg_InsertedFor_Ou_ge3ai_func"};
        Func rtb_ImpAsg_InsertedFor_Ou_ke3sc_func{"rtb_ImpAsg_InsertedFor_Ou_ke3sc_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_ke3_func{"rtb_ImpAsg_InsertedFor_Out1_ke3_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_ke3_clamped{"rtb_ImpAsg_InsertedFor_Out1_ke3_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_o_func{"rtb_ImpAsg_InsertedFor_Output_o_func"};
        Func rtb_ImpAsg_InsertedFor_Out_a_ge_func{"rtb_ImpAsg_InsertedFor_Out_a_ge_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_k_func{"rtb_ImpAsg_InsertedFor_Out1_a_k_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_a_k_clamped{"rtb_ImpAsg_InsertedFor_Out1_a_k_clamped"};
        Func rtb_ImpAsg_InsertedFor_Output_i_func{"rtb_ImpAsg_InsertedFor_Output_i_func"};
        Func rtb_ImpAsg_InsertedFor_Out_at_g_func{"rtb_ImpAsg_InsertedFor_Out_at_g_func"};
        Func rtb_ImpAsg_InsertedFor_Out1__ke_func{"rtb_ImpAsg_InsertedFor_Out1__ke_func"};
        Func rtb_ImpAsg_InsertedFor_Out1_at_func{"rtb_ImpAsg_InsertedFor_Out1_at_func"};
};
HALIDE_REGISTER_GENERATOR(resnet18Subset, resnet18SubsetGenerator)