/****************************************************************************
*   Generated by ACUITY 6.6.0
*   Match timvx 1.1.30
*
*   Neural Network appliction network definition source file
****************************************************************************/
#include "vx_resnet50.h"

#include <iostream>
#include <fstream>
#include <vector>

namespace
{

char *get_const_data(const char *data_file_name)
{
    std::ifstream fin(data_file_name, std::ios::in | std::ios::binary);
    if (fin)
    {
        fin.seekg(0, std::ios::end);
        int size = fin.tellg();
        fin.seekg(0, std::ios::beg);
        char *buffer = new char [size];
        std::cout<<"File "<<data_file_name <<" size:"<<size<<std::endl;
        fin.read(buffer, size);
        fin.close();
        return buffer;
    }
    else
    {
        std::cout<<"Load file "<<data_file_name <<" failed"<<std::endl;
        return NULL;
    }
}

}  // namespace

namespace acuitylite
{

std::vector<std::vector<uint32_t>> resnet50::input_size_list = {{224 , 224 , 3 , 1}};
std::vector<uint32_t> resnet50::input_bytes_list = {224 * 224 * 3 * 1 * sizeof(input_0_type)};
std::vector<std::vector<uint32_t>> resnet50::output_size_list = {{1000 , 1}};
std::vector<std::shared_ptr<tim::vx::Tensor>> resnet50::inputs_tensor;
std::vector<std::shared_ptr<tim::vx::Tensor>> resnet50::outputs_tensor;

void resnet50::construct_graph
    (
    std::shared_ptr<tim::vx::Graph> graph,
    const char *data_file_name
    )
{
    char *coef_data_ptr = get_const_data(data_file_name);

    tim::vx::Quantization convolution_1_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06513651460409164, 0);
    tim::vx::TensorSpec convolution_1_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_1_out0_quant);
    auto convolution_1_out0 = graph->CreateTensor(convolution_1_out0_spec);

    tim::vx::ShapeType convolution_1_weight_shape({7,7,3,64});
    tim::vx::Quantization convolution_1_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0001737833663355559, 133);
    tim::vx::TensorSpec convolution_1_weight_spec(tim::vx::DataType::UINT8, convolution_1_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_1_weight_quant);
    auto convolution_1_weight = graph->CreateTensor(convolution_1_weight_spec, coef_data_ptr + 256);

    tim::vx::ShapeType convolution_1_bias_shape({64});
    tim::vx::Quantization convolution_1_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0001737833663355559, 0);
    tim::vx::TensorSpec convolution_1_bias_spec(tim::vx::DataType::INT32, convolution_1_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_1_bias_quant);
    auto convolution_1_bias = graph->CreateTensor(convolution_1_bias_spec, coef_data_ptr + 0);

    tim::vx::Quantization relu_4_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06513651460409164, 0);
    tim::vx::TensorSpec relu_4_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_4_out0_quant);
    auto relu_4_out0 = graph->CreateTensor(relu_4_out0_spec);

    tim::vx::Quantization pooling_5_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06513651460409164, 0);
    tim::vx::TensorSpec pooling_5_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, pooling_5_out0_quant);
    auto pooling_5_out0 = graph->CreateTensor(pooling_5_out0_spec);

    tim::vx::Quantization convolution_9_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.036857619881629944, 0);
    tim::vx::TensorSpec convolution_9_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_9_out0_quant);
    auto convolution_9_out0 = graph->CreateTensor(convolution_9_out0_spec);

    tim::vx::ShapeType convolution_9_weight_shape({1,1,64,64});
    tim::vx::Quantization convolution_9_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.004803352523595095, 175);
    tim::vx::TensorSpec convolution_9_weight_spec(tim::vx::DataType::UINT8, convolution_9_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_9_weight_quant);
    auto convolution_9_weight = graph->CreateTensor(convolution_9_weight_spec, coef_data_ptr + 2095712);

    tim::vx::ShapeType convolution_9_bias_shape({64});
    tim::vx::Quantization convolution_9_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00031287362799048424, 0);
    tim::vx::TensorSpec convolution_9_bias_spec(tim::vx::DataType::INT32, convolution_9_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_9_bias_quant);
    auto convolution_9_bias = graph->CreateTensor(convolution_9_bias_spec, coef_data_ptr + 2095456);

    tim::vx::Quantization relu_12_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.036857619881629944, 0);
    tim::vx::TensorSpec relu_12_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_12_out0_quant);
    auto relu_12_out0 = graph->CreateTensor(relu_12_out0_spec);

    tim::vx::Quantization convolution_13_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06513651460409164, 0);
    tim::vx::TensorSpec convolution_13_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_13_out0_quant);
    auto convolution_13_out0 = graph->CreateTensor(convolution_13_out0_spec);

    tim::vx::ShapeType convolution_13_weight_shape({3,3,64,64});
    tim::vx::Quantization convolution_13_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0022254411596804857, 118);
    tim::vx::TensorSpec convolution_13_weight_spec(tim::vx::DataType::UINT8, convolution_13_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_13_weight_quant);
    auto convolution_13_weight = graph->CreateTensor(convolution_13_weight_spec, coef_data_ptr + 2100064);

    tim::vx::ShapeType convolution_13_bias_shape({64});
    tim::vx::Quantization convolution_13_bias_quant(tim::vx::QuantType::ASYMMETRIC, 8.202446770155802e-05, 0);
    tim::vx::TensorSpec convolution_13_bias_spec(tim::vx::DataType::INT32, convolution_13_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_13_bias_quant);
    auto convolution_13_bias = graph->CreateTensor(convolution_13_bias_spec, coef_data_ptr + 2099808);

    tim::vx::Quantization relu_16_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06513651460409164, 0);
    tim::vx::TensorSpec relu_16_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_16_out0_quant);
    auto relu_16_out0 = graph->CreateTensor(relu_16_out0_spec);

    tim::vx::Quantization concat_231_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06513651460409164, 0);
    tim::vx::TensorSpec concat_231_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, concat_231_out0_quant);
    auto concat_231_out0 = graph->CreateTensor(concat_231_out0_spec);

    tim::vx::Quantization convolution_232_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05724356323480606, 0);
    tim::vx::TensorSpec convolution_232_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_232_out0_quant);
    auto convolution_232_out0 = graph->CreateTensor(convolution_232_out0_spec);

    tim::vx::ShapeType convolution_232_weight_shape({1,1,128,256});
    tim::vx::Quantization convolution_232_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.013699613511562347, 128);
    tim::vx::TensorSpec convolution_232_weight_spec(tim::vx::DataType::UINT8, convolution_232_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_232_weight_quant);
    auto convolution_232_weight = graph->CreateTensor(convolution_232_weight_spec, coef_data_ptr + 2062688);

    tim::vx::ShapeType convolution_232_bias_shape({256});
    tim::vx::Quantization convolution_232_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0008923450950533152, 0);
    tim::vx::TensorSpec convolution_232_bias_spec(tim::vx::DataType::INT32, convolution_232_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_232_bias_quant);
    auto convolution_232_bias = graph->CreateTensor(convolution_232_bias_spec, coef_data_ptr + 2061664);

    tim::vx::Quantization relu_21_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05724356323480606, 0);
    tim::vx::TensorSpec relu_21_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_21_out0_quant);
    auto relu_21_out0 = graph->CreateTensor(relu_21_out0_spec);

    tim::vx::Quantization convolution_22_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.041045863181352615, 0);
    tim::vx::TensorSpec convolution_22_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_22_out0_quant);
    auto convolution_22_out0 = graph->CreateTensor(convolution_22_out0_spec);

    tim::vx::ShapeType convolution_22_weight_shape({1,1,256,64});
    tim::vx::Quantization convolution_22_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0044895135797560215, 147);
    tim::vx::TensorSpec convolution_22_weight_spec(tim::vx::DataType::UINT8, convolution_22_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_22_weight_quant);
    auto convolution_22_weight = graph->CreateTensor(convolution_22_weight_spec, coef_data_ptr + 2137184);

    tim::vx::ShapeType convolution_22_bias_shape({64});
    tim::vx::Quantization convolution_22_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0002569957578089088, 0);
    tim::vx::TensorSpec convolution_22_bias_spec(tim::vx::DataType::INT32, convolution_22_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_22_bias_quant);
    auto convolution_22_bias = graph->CreateTensor(convolution_22_bias_spec, coef_data_ptr + 2136928);

    tim::vx::Quantization relu_25_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.041045863181352615, 0);
    tim::vx::TensorSpec relu_25_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_25_out0_quant);
    auto relu_25_out0 = graph->CreateTensor(relu_25_out0_spec);

    tim::vx::Quantization convolution_26_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.033543918281793594, 0);
    tim::vx::TensorSpec convolution_26_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_26_out0_quant);
    auto convolution_26_out0 = graph->CreateTensor(convolution_26_out0_spec);

    tim::vx::ShapeType convolution_26_weight_shape({3,3,64,64});
    tim::vx::Quantization convolution_26_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0041098142974078655, 108);
    tim::vx::TensorSpec convolution_26_weight_spec(tim::vx::DataType::UINT8, convolution_26_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_26_weight_quant);
    auto convolution_26_weight = graph->CreateTensor(convolution_26_weight_spec, coef_data_ptr + 2153824);

    tim::vx::ShapeType convolution_26_bias_shape({64});
    tim::vx::Quantization convolution_26_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00016869087994564325, 0);
    tim::vx::TensorSpec convolution_26_bias_spec(tim::vx::DataType::INT32, convolution_26_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_26_bias_quant);
    auto convolution_26_bias = graph->CreateTensor(convolution_26_bias_spec, coef_data_ptr + 2153568);

    tim::vx::Quantization relu_29_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.033543918281793594, 0);
    tim::vx::TensorSpec relu_29_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_29_out0_quant);
    auto relu_29_out0 = graph->CreateTensor(relu_29_out0_spec);

    tim::vx::Quantization convolution_30_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.09178134053945541, 133);
    tim::vx::TensorSpec convolution_30_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_30_out0_quant);
    auto convolution_30_out0 = graph->CreateTensor(convolution_30_out0_spec);

    tim::vx::ShapeType convolution_30_weight_shape({1,1,64,256});
    tim::vx::Quantization convolution_30_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.01000303216278553, 111);
    tim::vx::TensorSpec convolution_30_weight_spec(tim::vx::DataType::UINT8, convolution_30_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_30_weight_quant);
    auto convolution_30_weight = graph->CreateTensor(convolution_30_weight_spec, coef_data_ptr + 2191712);

    tim::vx::ShapeType convolution_30_bias_shape({256});
    tim::vx::Quantization convolution_30_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00033554088440723717, 0);
    tim::vx::TensorSpec convolution_30_bias_spec(tim::vx::DataType::INT32, convolution_30_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_30_bias_quant);
    auto convolution_30_bias = graph->CreateTensor(convolution_30_bias_spec, coef_data_ptr + 2190688);

    tim::vx::Quantization add_33_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05750435218214989, 0);
    tim::vx::TensorSpec add_33_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_33_out0_quant);
    auto add_33_out0 = graph->CreateTensor(add_33_out0_spec);

    tim::vx::Quantization relu_34_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05750435218214989, 0);
    tim::vx::TensorSpec relu_34_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_34_out0_quant);
    auto relu_34_out0 = graph->CreateTensor(relu_34_out0_spec);

    tim::vx::Quantization convolution_35_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.03251691907644272, 0);
    tim::vx::TensorSpec convolution_35_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_35_out0_quant);
    auto convolution_35_out0 = graph->CreateTensor(convolution_35_out0_spec);

    tim::vx::ShapeType convolution_35_weight_shape({1,1,256,64});
    tim::vx::Quantization convolution_35_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0024991377722471952, 114);
    tim::vx::TensorSpec convolution_35_weight_spec(tim::vx::DataType::UINT8, convolution_35_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_35_weight_quant);
    auto convolution_35_weight = graph->CreateTensor(convolution_35_weight_spec, coef_data_ptr + 2208352);

    tim::vx::ShapeType convolution_35_bias_shape({64});
    tim::vx::Quantization convolution_35_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00014371129509527236, 0);
    tim::vx::TensorSpec convolution_35_bias_spec(tim::vx::DataType::INT32, convolution_35_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_35_bias_quant);
    auto convolution_35_bias = graph->CreateTensor(convolution_35_bias_spec, coef_data_ptr + 2208096);

    tim::vx::Quantization relu_38_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.03251691907644272, 0);
    tim::vx::TensorSpec relu_38_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_38_out0_quant);
    auto relu_38_out0 = graph->CreateTensor(relu_38_out0_spec);

    tim::vx::Quantization convolution_39_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.03924860432744026, 0);
    tim::vx::TensorSpec convolution_39_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_39_out0_quant);
    auto convolution_39_out0 = graph->CreateTensor(convolution_39_out0_spec);

    tim::vx::ShapeType convolution_39_weight_shape({3,3,64,64});
    tim::vx::Quantization convolution_39_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0032176407985389233, 128);
    tim::vx::TensorSpec convolution_39_weight_spec(tim::vx::DataType::UINT8, convolution_39_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_39_weight_quant);
    auto convolution_39_weight = graph->CreateTensor(convolution_39_weight_spec, coef_data_ptr + 2224992);

    tim::vx::ShapeType convolution_39_bias_shape({64});
    tim::vx::Quantization convolution_39_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00010462776845088229, 0);
    tim::vx::TensorSpec convolution_39_bias_spec(tim::vx::DataType::INT32, convolution_39_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_39_bias_quant);
    auto convolution_39_bias = graph->CreateTensor(convolution_39_bias_spec, coef_data_ptr + 2224736);

    tim::vx::Quantization relu_42_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.03924860432744026, 0);
    tim::vx::TensorSpec relu_42_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_42_out0_quant);
    auto relu_42_out0 = graph->CreateTensor(relu_42_out0_spec);

    tim::vx::Quantization convolution_43_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.08585022389888763, 141);
    tim::vx::TensorSpec convolution_43_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_43_out0_quant);
    auto convolution_43_out0 = graph->CreateTensor(convolution_43_out0_spec);

    tim::vx::ShapeType convolution_43_weight_shape({1,1,64,256});
    tim::vx::Quantization convolution_43_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.008329907432198524, 108);
    tim::vx::TensorSpec convolution_43_weight_spec(tim::vx::DataType::UINT8, convolution_43_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_43_weight_quant);
    auto convolution_43_weight = graph->CreateTensor(convolution_43_weight_spec, coef_data_ptr + 2262880);

    tim::vx::ShapeType convolution_43_bias_shape({256});
    tim::vx::Quantization convolution_43_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.000326937239151448, 0);
    tim::vx::TensorSpec convolution_43_bias_spec(tim::vx::DataType::INT32, convolution_43_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_43_bias_quant);
    auto convolution_43_bias = graph->CreateTensor(convolution_43_bias_spec, coef_data_ptr + 2261856);

    tim::vx::Quantization add_46_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05717748776078224, 0);
    tim::vx::TensorSpec add_46_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_46_out0_quant);
    auto add_46_out0 = graph->CreateTensor(add_46_out0_spec);

    tim::vx::Quantization relu_47_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05717748776078224, 0);
    tim::vx::TensorSpec relu_47_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_47_out0_quant);
    auto relu_47_out0 = graph->CreateTensor(relu_47_out0_spec);

    tim::vx::Quantization convolution_48_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.10674899071455002, 117);
    tim::vx::TensorSpec convolution_48_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_48_out0_quant);
    auto convolution_48_out0 = graph->CreateTensor(convolution_48_out0_spec);

    tim::vx::ShapeType convolution_48_weight_shape({1,1,256,512});
    tim::vx::Quantization convolution_48_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.006406530737876892, 147);
    tim::vx::TensorSpec convolution_48_weight_spec(tim::vx::DataType::UINT8, convolution_48_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_48_weight_quant);
    auto convolution_48_weight = graph->CreateTensor(convolution_48_weight_spec, coef_data_ptr + 2281312);

    tim::vx::ShapeType convolution_48_bias_shape({512});
    tim::vx::Quantization convolution_48_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0003663093375507742, 0);
    tim::vx::TensorSpec convolution_48_bias_spec(tim::vx::DataType::INT32, convolution_48_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_48_bias_quant);
    auto convolution_48_bias = graph->CreateTensor(convolution_48_bias_spec, coef_data_ptr + 2279264);

    tim::vx::Quantization convolution_51_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.025104688480496407, 0);
    tim::vx::TensorSpec convolution_51_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_51_out0_quant);
    auto convolution_51_out0 = graph->CreateTensor(convolution_51_out0_spec);

    tim::vx::ShapeType convolution_51_weight_shape({1,1,256,128});
    tim::vx::Quantization convolution_51_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0030040210112929344, 152);
    tim::vx::TensorSpec convolution_51_weight_spec(tim::vx::DataType::UINT8, convolution_51_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_51_weight_quant);
    auto convolution_51_weight = graph->CreateTensor(convolution_51_weight_spec, coef_data_ptr + 2412896);

    tim::vx::ShapeType convolution_51_bias_shape({128});
    tim::vx::Quantization convolution_51_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0001717623817967251, 0);
    tim::vx::TensorSpec convolution_51_bias_spec(tim::vx::DataType::INT32, convolution_51_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_51_bias_quant);
    auto convolution_51_bias = graph->CreateTensor(convolution_51_bias_spec, coef_data_ptr + 2412384);

    tim::vx::Quantization relu_54_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.025104688480496407, 0);
    tim::vx::TensorSpec relu_54_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_54_out0_quant);
    auto relu_54_out0 = graph->CreateTensor(relu_54_out0_spec);

    tim::vx::Quantization convolution_55_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.024383682757616043, 0);
    tim::vx::TensorSpec convolution_55_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_55_out0_quant);
    auto convolution_55_out0 = graph->CreateTensor(convolution_55_out0_spec);

    tim::vx::ShapeType convolution_55_weight_shape({3,3,128,128});
    tim::vx::Quantization convolution_55_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.003081039758399129, 129);
    tim::vx::TensorSpec convolution_55_weight_spec(tim::vx::DataType::UINT8, convolution_55_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_55_weight_quant);
    auto convolution_55_weight = graph->CreateTensor(convolution_55_weight_spec, coef_data_ptr + 2446176);

    tim::vx::ShapeType convolution_55_bias_shape({128});
    tim::vx::Quantization convolution_55_bias_quant(tim::vx::QuantType::ASYMMETRIC, 7.734854443697259e-05, 0);
    tim::vx::TensorSpec convolution_55_bias_spec(tim::vx::DataType::INT32, convolution_55_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_55_bias_quant);
    auto convolution_55_bias = graph->CreateTensor(convolution_55_bias_spec, coef_data_ptr + 2445664);

    tim::vx::Quantization relu_58_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.024383682757616043, 0);
    tim::vx::TensorSpec relu_58_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_58_out0_quant);
    auto relu_58_out0 = graph->CreateTensor(relu_58_out0_spec);

    tim::vx::Quantization convolution_59_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.10206783562898636, 139);
    tim::vx::TensorSpec convolution_59_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_59_out0_quant);
    auto convolution_59_out0 = graph->CreateTensor(convolution_59_out0_spec);

    tim::vx::ShapeType convolution_59_weight_shape({1,1,128,512});
    tim::vx::Quantization convolution_59_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.01444157399237156, 121);
    tim::vx::TensorSpec convolution_59_weight_spec(tim::vx::DataType::UINT8, convolution_59_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_59_weight_quant);
    auto convolution_59_weight = graph->CreateTensor(convolution_59_weight_spec, coef_data_ptr + 2595680);

    tim::vx::ShapeType convolution_59_bias_shape({512});
    tim::vx::Quantization convolution_59_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00035213876981288195, 0);
    tim::vx::TensorSpec convolution_59_bias_spec(tim::vx::DataType::INT32, convolution_59_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_59_bias_quant);
    auto convolution_59_bias = graph->CreateTensor(convolution_59_bias_spec, coef_data_ptr + 2593632);

    tim::vx::Quantization add_62_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.0565003827214241, 0);
    tim::vx::TensorSpec add_62_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_62_out0_quant);
    auto add_62_out0 = graph->CreateTensor(add_62_out0_spec);

    tim::vx::Quantization relu_63_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.0565003827214241, 0);
    tim::vx::TensorSpec relu_63_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_63_out0_quant);
    auto relu_63_out0 = graph->CreateTensor(relu_63_out0_spec);

    tim::vx::Quantization convolution_64_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.034951645880937576, 0);
    tim::vx::TensorSpec convolution_64_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_64_out0_quant);
    auto convolution_64_out0 = graph->CreateTensor(convolution_64_out0_spec);

    tim::vx::ShapeType convolution_64_weight_shape({1,1,512,128});
    tim::vx::Quantization convolution_64_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0016764937900006771, 102);
    tim::vx::TensorSpec convolution_64_weight_spec(tim::vx::DataType::UINT8, convolution_64_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_64_weight_quant);
    auto convolution_64_weight = graph->CreateTensor(convolution_64_weight_spec, coef_data_ptr + 2661728);

    tim::vx::ShapeType convolution_64_bias_shape({128});
    tim::vx::Quantization convolution_64_bias_quant(tim::vx::QuantType::ASYMMETRIC, 9.472254168940708e-05, 0);
    tim::vx::TensorSpec convolution_64_bias_spec(tim::vx::DataType::INT32, convolution_64_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_64_bias_quant);
    auto convolution_64_bias = graph->CreateTensor(convolution_64_bias_spec, coef_data_ptr + 2661216);

    tim::vx::Quantization relu_67_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.034951645880937576, 0);
    tim::vx::TensorSpec relu_67_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_67_out0_quant);
    auto relu_67_out0 = graph->CreateTensor(relu_67_out0_spec);

    tim::vx::Quantization convolution_68_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.03728686273097992, 0);
    tim::vx::TensorSpec convolution_68_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_68_out0_quant);
    auto convolution_68_out0 = graph->CreateTensor(convolution_68_out0_spec);

    tim::vx::ShapeType convolution_68_weight_shape({3,3,128,128});
    tim::vx::Quantization convolution_68_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0028692998457700014, 112);
    tim::vx::TensorSpec convolution_68_weight_spec(tim::vx::DataType::UINT8, convolution_68_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_68_weight_quant);
    auto convolution_68_weight = graph->CreateTensor(convolution_68_weight_spec, coef_data_ptr + 2727776);

    tim::vx::ShapeType convolution_68_bias_shape({128});
    tim::vx::Quantization convolution_68_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0001002867502393201, 0);
    tim::vx::TensorSpec convolution_68_bias_spec(tim::vx::DataType::INT32, convolution_68_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_68_bias_quant);
    auto convolution_68_bias = graph->CreateTensor(convolution_68_bias_spec, coef_data_ptr + 2727264);

    tim::vx::Quantization relu_71_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.03728686273097992, 0);
    tim::vx::TensorSpec relu_71_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_71_out0_quant);
    auto relu_71_out0 = graph->CreateTensor(relu_71_out0_spec);

    tim::vx::Quantization convolution_72_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.0714351087808609, 145);
    tim::vx::TensorSpec convolution_72_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_72_out0_quant);
    auto convolution_72_out0 = graph->CreateTensor(convolution_72_out0_spec);

    tim::vx::ShapeType convolution_72_weight_shape({1,1,128,512});
    tim::vx::Quantization convolution_72_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.014552710577845573, 98);
    tim::vx::TensorSpec convolution_72_weight_spec(tim::vx::DataType::UINT8, convolution_72_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_72_weight_quant);
    auto convolution_72_weight = graph->CreateTensor(convolution_72_weight_spec, coef_data_ptr + 2877280);

    tim::vx::ShapeType convolution_72_bias_shape({512});
    tim::vx::Quantization convolution_72_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0005426249117590487, 0);
    tim::vx::TensorSpec convolution_72_bias_spec(tim::vx::DataType::INT32, convolution_72_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_72_bias_quant);
    auto convolution_72_bias = graph->CreateTensor(convolution_72_bias_spec, coef_data_ptr + 2875232);

    tim::vx::Quantization add_75_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06655561923980713, 0);
    tim::vx::TensorSpec add_75_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_75_out0_quant);
    auto add_75_out0 = graph->CreateTensor(add_75_out0_spec);

    tim::vx::Quantization relu_76_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06655561923980713, 0);
    tim::vx::TensorSpec relu_76_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_76_out0_quant);
    auto relu_76_out0 = graph->CreateTensor(relu_76_out0_spec);

    tim::vx::Quantization convolution_77_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.02692987024784088, 0);
    tim::vx::TensorSpec convolution_77_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_77_out0_quant);
    auto convolution_77_out0 = graph->CreateTensor(convolution_77_out0_spec);

    tim::vx::ShapeType convolution_77_weight_shape({1,1,512,128});
    tim::vx::Quantization convolution_77_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.004116216208785772, 39);
    tim::vx::TensorSpec convolution_77_weight_spec(tim::vx::DataType::UINT8, convolution_77_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_77_weight_quant);
    auto convolution_77_weight = graph->CreateTensor(convolution_77_weight_spec, coef_data_ptr + 2943328);

    tim::vx::ShapeType convolution_77_bias_shape({128});
    tim::vx::Quantization convolution_77_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00027395732467994094, 0);
    tim::vx::TensorSpec convolution_77_bias_spec(tim::vx::DataType::INT32, convolution_77_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_77_bias_quant);
    auto convolution_77_bias = graph->CreateTensor(convolution_77_bias_spec, coef_data_ptr + 2942816);

    tim::vx::Quantization relu_80_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.02692987024784088, 0);
    tim::vx::TensorSpec relu_80_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_80_out0_quant);
    auto relu_80_out0 = graph->CreateTensor(relu_80_out0_spec);

    tim::vx::Quantization convolution_81_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.040409915149211884, 0);
    tim::vx::TensorSpec convolution_81_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_81_out0_quant);
    auto convolution_81_out0 = graph->CreateTensor(convolution_81_out0_spec);

    tim::vx::ShapeType convolution_81_weight_shape({3,3,128,128});
    tim::vx::Quantization convolution_81_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.008588027209043503, 87);
    tim::vx::TensorSpec convolution_81_weight_spec(tim::vx::DataType::UINT8, convolution_81_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_81_weight_quant);
    auto convolution_81_weight = graph->CreateTensor(convolution_81_weight_spec, coef_data_ptr + 3009376);

    tim::vx::ShapeType convolution_81_bias_shape({128});
    tim::vx::Quantization convolution_81_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00023127446183934808, 0);
    tim::vx::TensorSpec convolution_81_bias_spec(tim::vx::DataType::INT32, convolution_81_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_81_bias_quant);
    auto convolution_81_bias = graph->CreateTensor(convolution_81_bias_spec, coef_data_ptr + 3008864);

    tim::vx::Quantization relu_84_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.040409915149211884, 0);
    tim::vx::TensorSpec relu_84_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_84_out0_quant);
    auto relu_84_out0 = graph->CreateTensor(relu_84_out0_spec);

    tim::vx::Quantization convolution_85_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.07892583310604095, 145);
    tim::vx::TensorSpec convolution_85_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_85_out0_quant);
    auto convolution_85_out0 = graph->CreateTensor(convolution_85_out0_spec);

    tim::vx::ShapeType convolution_85_weight_shape({1,1,128,512});
    tim::vx::Quantization convolution_85_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.01371678151190281, 140);
    tim::vx::TensorSpec convolution_85_weight_spec(tim::vx::DataType::UINT8, convolution_85_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_85_weight_quant);
    auto convolution_85_weight = graph->CreateTensor(convolution_85_weight_spec, coef_data_ptr + 3158880);

    tim::vx::ShapeType convolution_85_bias_shape({512});
    tim::vx::Quantization convolution_85_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0005542939761653543, 0);
    tim::vx::TensorSpec convolution_85_bias_spec(tim::vx::DataType::INT32, convolution_85_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_85_bias_quant);
    auto convolution_85_bias = graph->CreateTensor(convolution_85_bias_spec, coef_data_ptr + 3156832);

    tim::vx::Quantization add_88_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06780294328927994, 0);
    tim::vx::TensorSpec add_88_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_88_out0_quant);
    auto add_88_out0 = graph->CreateTensor(add_88_out0_spec);

    tim::vx::Quantization relu_89_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06780294328927994, 0);
    tim::vx::TensorSpec relu_89_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_89_out0_quant);
    auto relu_89_out0 = graph->CreateTensor(relu_89_out0_spec);

    tim::vx::Quantization convolution_90_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.039215199649333954, 0);
    tim::vx::TensorSpec convolution_90_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_90_out0_quant);
    auto convolution_90_out0 = graph->CreateTensor(convolution_90_out0_spec);

    tim::vx::ShapeType convolution_90_weight_shape({1,1,512,128});
    tim::vx::Quantization convolution_90_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.003800247795879841, 116);
    tim::vx::TensorSpec convolution_90_weight_spec(tim::vx::DataType::UINT8, convolution_90_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_90_weight_quant);
    auto convolution_90_weight = graph->CreateTensor(convolution_90_weight_spec, coef_data_ptr + 3224928);

    tim::vx::ShapeType convolution_90_bias_shape({128});
    tim::vx::Quantization convolution_90_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00025766799808479846, 0);
    tim::vx::TensorSpec convolution_90_bias_spec(tim::vx::DataType::INT32, convolution_90_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_90_bias_quant);
    auto convolution_90_bias = graph->CreateTensor(convolution_90_bias_spec, coef_data_ptr + 3224416);

    tim::vx::Quantization relu_93_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.039215199649333954, 0);
    tim::vx::TensorSpec relu_93_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_93_out0_quant);
    auto relu_93_out0 = graph->CreateTensor(relu_93_out0_spec);

    tim::vx::Quantization convolution_94_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.03448693826794624, 0);
    tim::vx::TensorSpec convolution_94_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_94_out0_quant);
    auto convolution_94_out0 = graph->CreateTensor(convolution_94_out0_spec);

    tim::vx::ShapeType convolution_94_weight_shape({3,3,128,128});
    tim::vx::Quantization convolution_94_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.002774078631773591, 109);
    tim::vx::TensorSpec convolution_94_weight_spec(tim::vx::DataType::UINT8, convolution_94_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_94_weight_quant);
    auto convolution_94_weight = graph->CreateTensor(convolution_94_weight_spec, coef_data_ptr + 3290976);

    tim::vx::ShapeType convolution_94_bias_shape({128});
    tim::vx::Quantization convolution_94_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00010878605098696426, 0);
    tim::vx::TensorSpec convolution_94_bias_spec(tim::vx::DataType::INT32, convolution_94_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_94_bias_quant);
    auto convolution_94_bias = graph->CreateTensor(convolution_94_bias_spec, coef_data_ptr + 3290464);

    tim::vx::Quantization relu_97_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.03448693826794624, 0);
    tim::vx::TensorSpec relu_97_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_97_out0_quant);
    auto relu_97_out0 = graph->CreateTensor(relu_97_out0_spec);

    tim::vx::Quantization convolution_98_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.07904094457626343, 120);
    tim::vx::TensorSpec convolution_98_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_98_out0_quant);
    auto convolution_98_out0 = graph->CreateTensor(convolution_98_out0_spec);

    tim::vx::ShapeType convolution_98_weight_shape({1,1,128,512});
    tim::vx::Quantization convolution_98_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.008222552947700024, 119);
    tim::vx::TensorSpec convolution_98_weight_spec(tim::vx::DataType::UINT8, convolution_98_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_98_weight_quant);
    auto convolution_98_weight = graph->CreateTensor(convolution_98_weight_spec, coef_data_ptr + 3440480);

    tim::vx::ShapeType convolution_98_bias_shape({512});
    tim::vx::Quantization convolution_98_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00028357066912576556, 0);
    tim::vx::TensorSpec convolution_98_bias_spec(tim::vx::DataType::INT32, convolution_98_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_98_bias_quant);
    auto convolution_98_bias = graph->CreateTensor(convolution_98_bias_spec, coef_data_ptr + 3438432);

    tim::vx::Quantization add_101_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06775879859924316, 0);
    tim::vx::TensorSpec add_101_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_101_out0_quant);
    auto add_101_out0 = graph->CreateTensor(add_101_out0_spec);

    tim::vx::Quantization relu_102_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06775879859924316, 0);
    tim::vx::TensorSpec relu_102_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_102_out0_quant);
    auto relu_102_out0 = graph->CreateTensor(relu_102_out0_spec);

    tim::vx::Quantization convolution_103_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.09388317167758942, 137);
    tim::vx::TensorSpec convolution_103_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_103_out0_quant);
    auto convolution_103_out0 = graph->CreateTensor(convolution_103_out0_spec);

    tim::vx::ShapeType convolution_103_weight_shape({1,1,512,1024});
    tim::vx::Quantization convolution_103_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.004281576722860336, 116);
    tim::vx::TensorSpec convolution_103_weight_spec(tim::vx::DataType::UINT8, convolution_103_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_103_weight_quant);
    auto convolution_103_weight = graph->CreateTensor(convolution_103_weight_spec, coef_data_ptr + 3510112);

    tim::vx::ShapeType convolution_103_bias_shape({1024});
    tim::vx::Quantization convolution_103_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0002901144907809794, 0);
    tim::vx::TensorSpec convolution_103_bias_spec(tim::vx::DataType::INT32, convolution_103_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_103_bias_quant);
    auto convolution_103_bias = graph->CreateTensor(convolution_103_bias_spec, coef_data_ptr + 3506016);

    tim::vx::Quantization convolution_106_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.035920802503824234, 0);
    tim::vx::TensorSpec convolution_106_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_106_out0_quant);
    auto convolution_106_out0 = graph->CreateTensor(convolution_106_out0_spec);

    tim::vx::ShapeType convolution_106_weight_shape({1,1,512,256});
    tim::vx::Quantization convolution_106_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0029459758661687374, 86);
    tim::vx::TensorSpec convolution_106_weight_spec(tim::vx::DataType::UINT8, convolution_106_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_106_weight_quant);
    auto convolution_106_weight = graph->CreateTensor(convolution_106_weight_spec, coef_data_ptr + 4035424);

    tim::vx::ShapeType convolution_106_bias_shape({256});
    tim::vx::Quantization convolution_106_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00019961578072980046, 0);
    tim::vx::TensorSpec convolution_106_bias_spec(tim::vx::DataType::INT32, convolution_106_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_106_bias_quant);
    auto convolution_106_bias = graph->CreateTensor(convolution_106_bias_spec, coef_data_ptr + 4034400);

    tim::vx::Quantization relu_109_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.035920802503824234, 0);
    tim::vx::TensorSpec relu_109_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_109_out0_quant);
    auto relu_109_out0 = graph->CreateTensor(relu_109_out0_spec);

    tim::vx::Quantization convolution_110_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.029010910540819168, 0);
    tim::vx::TensorSpec convolution_110_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_110_out0_quant);
    auto convolution_110_out0 = graph->CreateTensor(convolution_110_out0_spec);

    tim::vx::ShapeType convolution_110_weight_shape({3,3,256,256});
    tim::vx::Quantization convolution_110_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0018829640466719866, 113);
    tim::vx::TensorSpec convolution_110_weight_spec(tim::vx::DataType::UINT8, convolution_110_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_110_weight_quant);
    auto convolution_110_weight = graph->CreateTensor(convolution_110_weight_spec, coef_data_ptr + 4167520);

    tim::vx::ShapeType convolution_110_bias_shape({256});
    tim::vx::Quantization convolution_110_bias_quant(tim::vx::QuantType::ASYMMETRIC, 6.763757846783847e-05, 0);
    tim::vx::TensorSpec convolution_110_bias_spec(tim::vx::DataType::INT32, convolution_110_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_110_bias_quant);
    auto convolution_110_bias = graph->CreateTensor(convolution_110_bias_spec, coef_data_ptr + 4166496);

    tim::vx::Quantization relu_113_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.029010910540819168, 0);
    tim::vx::TensorSpec relu_113_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_113_out0_quant);
    auto relu_113_out0 = graph->CreateTensor(relu_113_out0_spec);

    tim::vx::Quantization convolution_114_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.0766356959939003, 137);
    tim::vx::TensorSpec convolution_114_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_114_out0_quant);
    auto convolution_114_out0 = graph->CreateTensor(convolution_114_out0_spec);

    tim::vx::ShapeType convolution_114_weight_shape({1,1,256,1024});
    tim::vx::Quantization convolution_114_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.012337024323642254, 136);
    tim::vx::TensorSpec convolution_114_weight_spec(tim::vx::DataType::UINT8, convolution_114_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_114_weight_quant);
    auto convolution_114_weight = graph->CreateTensor(convolution_114_weight_spec, coef_data_ptr + 4761440);

    tim::vx::ShapeType convolution_114_bias_shape({1024});
    tim::vx::Quantization convolution_114_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00035790831316262484, 0);
    tim::vx::TensorSpec convolution_114_bias_spec(tim::vx::DataType::INT32, convolution_114_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_114_bias_quant);
    auto convolution_114_bias = graph->CreateTensor(convolution_114_bias_spec, coef_data_ptr + 4757344);

    tim::vx::Quantization add_117_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05127289146184921, 0);
    tim::vx::TensorSpec add_117_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_117_out0_quant);
    auto add_117_out0 = graph->CreateTensor(add_117_out0_spec);

    tim::vx::Quantization relu_118_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05127289146184921, 0);
    tim::vx::TensorSpec relu_118_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_118_out0_quant);
    auto relu_118_out0 = graph->CreateTensor(relu_118_out0_spec);

    tim::vx::Quantization convolution_119_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.021251065656542778, 0);
    tim::vx::TensorSpec convolution_119_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_119_out0_quant);
    auto convolution_119_out0 = graph->CreateTensor(convolution_119_out0_spec);

    tim::vx::ShapeType convolution_119_weight_shape({1,1,1024,256});
    tim::vx::Quantization convolution_119_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0021608914248645306, 74);
    tim::vx::TensorSpec convolution_119_weight_spec(tim::vx::DataType::UINT8, convolution_119_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_119_weight_quant);
    auto convolution_119_weight = graph->CreateTensor(convolution_119_weight_spec, coef_data_ptr + 5024608);

    tim::vx::ShapeType convolution_119_bias_shape({256});
    tim::vx::Quantization convolution_119_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00011079515388701111, 0);
    tim::vx::TensorSpec convolution_119_bias_spec(tim::vx::DataType::INT32, convolution_119_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_119_bias_quant);
    auto convolution_119_bias = graph->CreateTensor(convolution_119_bias_spec, coef_data_ptr + 5023584);

    tim::vx::Quantization relu_122_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.021251065656542778, 0);
    tim::vx::TensorSpec relu_122_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_122_out0_quant);
    auto relu_122_out0 = graph->CreateTensor(relu_122_out0_spec);

    tim::vx::Quantization convolution_123_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.017823796719312668, 0);
    tim::vx::TensorSpec convolution_123_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_123_out0_quant);
    auto convolution_123_out0 = graph->CreateTensor(convolution_123_out0_spec);

    tim::vx::ShapeType convolution_123_weight_shape({3,3,256,256});
    tim::vx::Quantization convolution_123_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.006218116730451584, 100);
    tim::vx::TensorSpec convolution_123_weight_spec(tim::vx::DataType::UINT8, convolution_123_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_123_weight_quant);
    auto convolution_123_weight = graph->CreateTensor(convolution_123_weight_spec, coef_data_ptr + 5287776);

    tim::vx::ShapeType convolution_123_bias_shape({256});
    tim::vx::Quantization convolution_123_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00013214160571806133, 0);
    tim::vx::TensorSpec convolution_123_bias_spec(tim::vx::DataType::INT32, convolution_123_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_123_bias_quant);
    auto convolution_123_bias = graph->CreateTensor(convolution_123_bias_spec, coef_data_ptr + 5286752);

    tim::vx::Quantization relu_126_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.017823796719312668, 0);
    tim::vx::TensorSpec relu_126_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_126_out0_quant);
    auto relu_126_out0 = graph->CreateTensor(relu_126_out0_spec);

    tim::vx::Quantization convolution_127_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.056391555815935135, 108);
    tim::vx::TensorSpec convolution_127_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_127_out0_quant);
    auto convolution_127_out0 = graph->CreateTensor(convolution_127_out0_spec);

    tim::vx::ShapeType convolution_127_weight_shape({1,1,256,1024});
    tim::vx::Quantization convolution_127_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.013343931175768375, 141);
    tim::vx::TensorSpec convolution_127_weight_spec(tim::vx::DataType::UINT8, convolution_127_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_127_weight_quant);
    auto convolution_127_weight = graph->CreateTensor(convolution_127_weight_spec, coef_data_ptr + 5881696);

    tim::vx::ShapeType convolution_127_bias_shape({1024});
    tim::vx::Quantization convolution_127_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0002378395147388801, 0);
    tim::vx::TensorSpec convolution_127_bias_spec(tim::vx::DataType::INT32, convolution_127_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_127_bias_quant);
    auto convolution_127_bias = graph->CreateTensor(convolution_127_bias_spec, coef_data_ptr + 5877600);

    tim::vx::Quantization add_130_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05008764564990997, 0);
    tim::vx::TensorSpec add_130_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_130_out0_quant);
    auto add_130_out0 = graph->CreateTensor(add_130_out0_spec);

    tim::vx::Quantization relu_131_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05008764564990997, 0);
    tim::vx::TensorSpec relu_131_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_131_out0_quant);
    auto relu_131_out0 = graph->CreateTensor(relu_131_out0_spec);

    tim::vx::Quantization convolution_132_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.020675403997302055, 0);
    tim::vx::TensorSpec convolution_132_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_132_out0_quant);
    auto convolution_132_out0 = graph->CreateTensor(convolution_132_out0_spec);

    tim::vx::ShapeType convolution_132_weight_shape({1,1,1024,256});
    tim::vx::Quantization convolution_132_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.002604473615065217, 132);
    tim::vx::TensorSpec convolution_132_weight_spec(tim::vx::DataType::UINT8, convolution_132_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_132_weight_quant);
    auto convolution_132_weight = graph->CreateTensor(convolution_132_weight_spec, coef_data_ptr + 6144864);

    tim::vx::ShapeType convolution_132_bias_shape({256});
    tim::vx::Quantization convolution_132_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0001304519537370652, 0);
    tim::vx::TensorSpec convolution_132_bias_spec(tim::vx::DataType::INT32, convolution_132_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_132_bias_quant);
    auto convolution_132_bias = graph->CreateTensor(convolution_132_bias_spec, coef_data_ptr + 6143840);

    tim::vx::Quantization relu_135_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.020675403997302055, 0);
    tim::vx::TensorSpec relu_135_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_135_out0_quant);
    auto relu_135_out0 = graph->CreateTensor(relu_135_out0_spec);

    tim::vx::Quantization convolution_136_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.02770310267806053, 0);
    tim::vx::TensorSpec convolution_136_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_136_out0_quant);
    auto convolution_136_out0 = graph->CreateTensor(convolution_136_out0_spec);

    tim::vx::ShapeType convolution_136_weight_shape({3,3,256,256});
    tim::vx::Quantization convolution_136_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.005561390426009893, 91);
    tim::vx::TensorSpec convolution_136_weight_spec(tim::vx::DataType::UINT8, convolution_136_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_136_weight_quant);
    auto convolution_136_weight = graph->CreateTensor(convolution_136_weight_spec, coef_data_ptr + 6408032);

    tim::vx::ShapeType convolution_136_bias_shape({256});
    tim::vx::Quantization convolution_136_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00011498399544507265, 0);
    tim::vx::TensorSpec convolution_136_bias_spec(tim::vx::DataType::INT32, convolution_136_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_136_bias_quant);
    auto convolution_136_bias = graph->CreateTensor(convolution_136_bias_spec, coef_data_ptr + 6407008);

    tim::vx::Quantization relu_139_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.02770310267806053, 0);
    tim::vx::TensorSpec relu_139_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_139_out0_quant);
    auto relu_139_out0 = graph->CreateTensor(relu_139_out0_spec);

    tim::vx::Quantization convolution_140_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.050987932831048965, 122);
    tim::vx::TensorSpec convolution_140_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_140_out0_quant);
    auto convolution_140_out0 = graph->CreateTensor(convolution_140_out0_spec);

    tim::vx::ShapeType convolution_140_weight_shape({1,1,256,1024});
    tim::vx::Quantization convolution_140_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.009768206626176834, 86);
    tim::vx::TensorSpec convolution_140_weight_spec(tim::vx::DataType::UINT8, convolution_140_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_140_weight_quant);
    auto convolution_140_weight = graph->CreateTensor(convolution_140_weight_spec, coef_data_ptr + 7001952);

    tim::vx::ShapeType convolution_140_bias_shape({1024});
    tim::vx::Quantization convolution_140_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0002706096274778247, 0);
    tim::vx::TensorSpec convolution_140_bias_spec(tim::vx::DataType::INT32, convolution_140_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_140_bias_quant);
    auto convolution_140_bias = graph->CreateTensor(convolution_140_bias_spec, coef_data_ptr + 6997856);

    tim::vx::Quantization add_143_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06169896572828293, 0);
    tim::vx::TensorSpec add_143_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_143_out0_quant);
    auto add_143_out0 = graph->CreateTensor(add_143_out0_spec);

    tim::vx::Quantization relu_144_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.06169896572828293, 0);
    tim::vx::TensorSpec relu_144_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_144_out0_quant);
    auto relu_144_out0 = graph->CreateTensor(relu_144_out0_spec);

    tim::vx::Quantization convolution_145_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.01976320892572403, 0);
    tim::vx::TensorSpec convolution_145_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_145_out0_quant);
    auto convolution_145_out0 = graph->CreateTensor(convolution_145_out0_spec);

    tim::vx::ShapeType convolution_145_weight_shape({1,1,1024,256});
    tim::vx::Quantization convolution_145_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0022279482800513506, 72);
    tim::vx::TensorSpec convolution_145_weight_spec(tim::vx::DataType::UINT8, convolution_145_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_145_weight_quant);
    auto convolution_145_weight = graph->CreateTensor(convolution_145_weight_spec, coef_data_ptr + 7265120);

    tim::vx::ShapeType convolution_145_bias_shape({256});
    tim::vx::Quantization convolution_145_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00013746210606768727, 0);
    tim::vx::TensorSpec convolution_145_bias_spec(tim::vx::DataType::INT32, convolution_145_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_145_bias_quant);
    auto convolution_145_bias = graph->CreateTensor(convolution_145_bias_spec, coef_data_ptr + 7264096);

    tim::vx::Quantization relu_148_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.01976320892572403, 0);
    tim::vx::TensorSpec relu_148_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_148_out0_quant);
    auto relu_148_out0 = graph->CreateTensor(relu_148_out0_spec);

    tim::vx::Quantization convolution_149_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.023187527433037758, 0);
    tim::vx::TensorSpec convolution_149_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_149_out0_quant);
    auto convolution_149_out0 = graph->CreateTensor(convolution_149_out0_spec);

    tim::vx::ShapeType convolution_149_weight_shape({3,3,256,256});
    tim::vx::Quantization convolution_149_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.004769242834299803, 123);
    tim::vx::TensorSpec convolution_149_weight_spec(tim::vx::DataType::UINT8, convolution_149_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_149_weight_quant);
    auto convolution_149_weight = graph->CreateTensor(convolution_149_weight_spec, coef_data_ptr + 7528288);

    tim::vx::ShapeType convolution_149_bias_shape({256});
    tim::vx::Quantization convolution_149_bias_quant(tim::vx::QuantType::ASYMMETRIC, 9.425554162589833e-05, 0);
    tim::vx::TensorSpec convolution_149_bias_spec(tim::vx::DataType::INT32, convolution_149_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_149_bias_quant);
    auto convolution_149_bias = graph->CreateTensor(convolution_149_bias_spec, coef_data_ptr + 7527264);

    tim::vx::Quantization relu_152_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.023187527433037758, 0);
    tim::vx::TensorSpec relu_152_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_152_out0_quant);
    auto relu_152_out0 = graph->CreateTensor(relu_152_out0_spec);

    tim::vx::Quantization convolution_153_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.057725995779037476, 120);
    tim::vx::TensorSpec convolution_153_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_153_out0_quant);
    auto convolution_153_out0 = graph->CreateTensor(convolution_153_out0_spec);

    tim::vx::ShapeType convolution_153_weight_shape({1,1,256,1024});
    tim::vx::Quantization convolution_153_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.01152096502482891, 112);
    tim::vx::TensorSpec convolution_153_weight_spec(tim::vx::DataType::UINT8, convolution_153_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_153_weight_quant);
    auto convolution_153_weight = graph->CreateTensor(convolution_153_weight_spec, coef_data_ptr + 8122208);

    tim::vx::ShapeType convolution_153_bias_shape({1024});
    tim::vx::Quantization convolution_153_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0002671426918823272, 0);
    tim::vx::TensorSpec convolution_153_bias_spec(tim::vx::DataType::INT32, convolution_153_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_153_bias_quant);
    auto convolution_153_bias = graph->CreateTensor(convolution_153_bias_spec, coef_data_ptr + 8118112);

    tim::vx::Quantization add_156_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.0601431243121624, 0);
    tim::vx::TensorSpec add_156_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_156_out0_quant);
    auto add_156_out0 = graph->CreateTensor(add_156_out0_spec);

    tim::vx::Quantization relu_157_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.0601431243121624, 0);
    tim::vx::TensorSpec relu_157_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_157_out0_quant);
    auto relu_157_out0 = graph->CreateTensor(relu_157_out0_spec);

    tim::vx::Quantization convolution_158_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.019502228125929832, 0);
    tim::vx::TensorSpec convolution_158_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_158_out0_quant);
    auto convolution_158_out0 = graph->CreateTensor(convolution_158_out0_spec);

    tim::vx::ShapeType convolution_158_weight_shape({1,1,1024,256});
    tim::vx::Quantization convolution_158_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0024551330134272575, 79);
    tim::vx::TensorSpec convolution_158_weight_spec(tim::vx::DataType::UINT8, convolution_158_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_158_weight_quant);
    auto convolution_158_weight = graph->CreateTensor(convolution_158_weight_spec, coef_data_ptr + 8385376);

    tim::vx::ShapeType convolution_158_bias_shape({256});
    tim::vx::Quantization convolution_158_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00014765937521588057, 0);
    tim::vx::TensorSpec convolution_158_bias_spec(tim::vx::DataType::INT32, convolution_158_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_158_bias_quant);
    auto convolution_158_bias = graph->CreateTensor(convolution_158_bias_spec, coef_data_ptr + 8384352);

    tim::vx::Quantization relu_161_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.019502228125929832, 0);
    tim::vx::TensorSpec relu_161_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_161_out0_quant);
    auto relu_161_out0 = graph->CreateTensor(relu_161_out0_spec);

    tim::vx::Quantization convolution_162_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.019909709692001343, 0);
    tim::vx::TensorSpec convolution_162_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_162_out0_quant);
    auto convolution_162_out0 = graph->CreateTensor(convolution_162_out0_spec);

    tim::vx::ShapeType convolution_162_weight_shape({3,3,256,256});
    tim::vx::Quantization convolution_162_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0050792936235666275, 120);
    tim::vx::TensorSpec convolution_162_weight_spec(tim::vx::DataType::UINT8, convolution_162_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_162_weight_quant);
    auto convolution_162_weight = graph->CreateTensor(convolution_162_weight_spec, coef_data_ptr + 8648544);

    tim::vx::ShapeType convolution_162_bias_shape({256});
    tim::vx::Quantization convolution_162_bias_quant(tim::vx::QuantType::ASYMMETRIC, 9.905754268402234e-05, 0);
    tim::vx::TensorSpec convolution_162_bias_spec(tim::vx::DataType::INT32, convolution_162_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_162_bias_quant);
    auto convolution_162_bias = graph->CreateTensor(convolution_162_bias_spec, coef_data_ptr + 8647520);

    tim::vx::Quantization relu_165_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.019909709692001343, 0);
    tim::vx::TensorSpec relu_165_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_165_out0_quant);
    auto relu_165_out0 = graph->CreateTensor(relu_165_out0_spec);

    tim::vx::Quantization convolution_166_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.04841376096010208, 118);
    tim::vx::TensorSpec convolution_166_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_166_out0_quant);
    auto convolution_166_out0 = graph->CreateTensor(convolution_166_out0_spec);

    tim::vx::ShapeType convolution_166_weight_shape({1,1,256,1024});
    tim::vx::Quantization convolution_166_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.008337733335793018, 101);
    tim::vx::TensorSpec convolution_166_weight_spec(tim::vx::DataType::UINT8, convolution_166_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_166_weight_quant);
    auto convolution_166_weight = graph->CreateTensor(convolution_166_weight_spec, coef_data_ptr + 9242464);

    tim::vx::ShapeType convolution_166_bias_shape({1024});
    tim::vx::Quantization convolution_166_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00016600184608250856, 0);
    tim::vx::TensorSpec convolution_166_bias_spec(tim::vx::DataType::INT32, convolution_166_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_166_bias_quant);
    auto convolution_166_bias = graph->CreateTensor(convolution_166_bias_spec, coef_data_ptr + 9238368);

    tim::vx::Quantization add_169_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05369938164949417, 0);
    tim::vx::TensorSpec add_169_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_169_out0_quant);
    auto add_169_out0 = graph->CreateTensor(add_169_out0_spec);

    tim::vx::Quantization relu_170_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.05369938164949417, 0);
    tim::vx::TensorSpec relu_170_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_170_out0_quant);
    auto relu_170_out0 = graph->CreateTensor(relu_170_out0_spec);

    tim::vx::Quantization convolution_171_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.028263499960303307, 0);
    tim::vx::TensorSpec convolution_171_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_171_out0_quant);
    auto convolution_171_out0 = graph->CreateTensor(convolution_171_out0_spec);

    tim::vx::ShapeType convolution_171_weight_shape({1,1,1024,256});
    tim::vx::Quantization convolution_171_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.002423967467620969, 80);
    tim::vx::TensorSpec convolution_171_weight_spec(tim::vx::DataType::UINT8, convolution_171_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_171_weight_quant);
    auto convolution_171_weight = graph->CreateTensor(convolution_171_weight_spec, coef_data_ptr + 9505632);

    tim::vx::ShapeType convolution_171_bias_shape({256});
    tim::vx::Quantization convolution_171_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0001301655574934557, 0);
    tim::vx::TensorSpec convolution_171_bias_spec(tim::vx::DataType::INT32, convolution_171_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_171_bias_quant);
    auto convolution_171_bias = graph->CreateTensor(convolution_171_bias_spec, coef_data_ptr + 9504608);

    tim::vx::Quantization relu_174_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.028263499960303307, 0);
    tim::vx::TensorSpec relu_174_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_174_out0_quant);
    auto relu_174_out0 = graph->CreateTensor(relu_174_out0_spec);

    tim::vx::Quantization convolution_175_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.08250340074300766, 0);
    tim::vx::TensorSpec convolution_175_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_175_out0_quant);
    auto convolution_175_out0 = graph->CreateTensor(convolution_175_out0_spec);

    tim::vx::ShapeType convolution_175_weight_shape({3,3,256,256});
    tim::vx::Quantization convolution_175_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.004059859085828066, 125);
    tim::vx::TensorSpec convolution_175_weight_spec(tim::vx::DataType::UINT8, convolution_175_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_175_weight_quant);
    auto convolution_175_weight = graph->CreateTensor(convolution_175_weight_spec, coef_data_ptr + 9768800);

    tim::vx::ShapeType convolution_175_bias_shape({256});
    tim::vx::Quantization convolution_175_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00011474582424852997, 0);
    tim::vx::TensorSpec convolution_175_bias_spec(tim::vx::DataType::INT32, convolution_175_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_175_bias_quant);
    auto convolution_175_bias = graph->CreateTensor(convolution_175_bias_spec, coef_data_ptr + 9767776);

    tim::vx::Quantization relu_178_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.08250340074300766, 0);
    tim::vx::TensorSpec relu_178_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_178_out0_quant);
    auto relu_178_out0 = graph->CreateTensor(relu_178_out0_spec);

    tim::vx::Quantization convolution_179_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.09280265122652054, 87);
    tim::vx::TensorSpec convolution_179_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_179_out0_quant);
    auto convolution_179_out0 = graph->CreateTensor(convolution_179_out0_spec);

    tim::vx::ShapeType convolution_179_weight_shape({1,1,256,1024});
    tim::vx::Quantization convolution_179_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.007674170657992363, 78);
    tim::vx::TensorSpec convolution_179_weight_spec(tim::vx::DataType::UINT8, convolution_179_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_179_weight_quant);
    auto convolution_179_weight = graph->CreateTensor(convolution_179_weight_spec, coef_data_ptr + 10362720);

    tim::vx::ShapeType convolution_179_bias_shape({1024});
    tim::vx::Quantization convolution_179_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0006331451586447656, 0);
    tim::vx::TensorSpec convolution_179_bias_spec(tim::vx::DataType::INT32, convolution_179_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_179_bias_quant);
    auto convolution_179_bias = graph->CreateTensor(convolution_179_bias_spec, coef_data_ptr + 10358624);

    tim::vx::Quantization add_182_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.061852194368839264, 0);
    tim::vx::TensorSpec add_182_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_182_out0_quant);
    auto add_182_out0 = graph->CreateTensor(add_182_out0_spec);

    tim::vx::Quantization relu_183_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.061852194368839264, 0);
    tim::vx::TensorSpec relu_183_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_183_out0_quant);
    auto relu_183_out0 = graph->CreateTensor(relu_183_out0_spec);

    tim::vx::Quantization convolution_184_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.1570115089416504, 102);
    tim::vx::TensorSpec convolution_184_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_184_out0_quant);
    auto convolution_184_out0 = graph->CreateTensor(convolution_184_out0_spec);

    tim::vx::ShapeType convolution_184_weight_shape({1,1,1024,2048});
    tim::vx::Quantization convolution_184_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.021532153710722923, 131);
    tim::vx::TensorSpec convolution_184_weight_spec(tim::vx::DataType::UINT8, convolution_184_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_184_weight_quant);
    auto convolution_184_weight = graph->CreateTensor(convolution_184_weight_spec, coef_data_ptr + 10633056);

    tim::vx::ShapeType convolution_184_bias_shape({2048});
    tim::vx::Quantization convolution_184_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.001331810955889523, 0);
    tim::vx::TensorSpec convolution_184_bias_spec(tim::vx::DataType::INT32, convolution_184_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_184_bias_quant);
    auto convolution_184_bias = graph->CreateTensor(convolution_184_bias_spec, coef_data_ptr + 10624864);

    tim::vx::Quantization convolution_187_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.018865292891860008, 0);
    tim::vx::TensorSpec convolution_187_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_187_out0_quant);
    auto convolution_187_out0 = graph->CreateTensor(convolution_187_out0_spec);

    tim::vx::ShapeType convolution_187_weight_shape({1,1,1024,512});
    tim::vx::Quantization convolution_187_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0020486777648329735, 90);
    tim::vx::TensorSpec convolution_187_weight_spec(tim::vx::DataType::UINT8, convolution_187_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_187_weight_quant);
    auto convolution_187_weight = graph->CreateTensor(convolution_187_weight_spec, coef_data_ptr + 12732256);

    tim::vx::ShapeType convolution_187_bias_shape({512});
    tim::vx::Quantization convolution_187_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00012671521108131856, 0);
    tim::vx::TensorSpec convolution_187_bias_spec(tim::vx::DataType::INT32, convolution_187_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_187_bias_quant);
    auto convolution_187_bias = graph->CreateTensor(convolution_187_bias_spec, coef_data_ptr + 12730208);

    tim::vx::Quantization relu_190_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.018865292891860008, 0);
    tim::vx::TensorSpec relu_190_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_190_out0_quant);
    auto relu_190_out0 = graph->CreateTensor(relu_190_out0_spec);

    tim::vx::Quantization convolution_191_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.01558383647352457, 0);
    tim::vx::TensorSpec convolution_191_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_191_out0_quant);
    auto convolution_191_out0 = graph->CreateTensor(convolution_191_out0_spec);

    tim::vx::ShapeType convolution_191_weight_shape({3,3,512,512});
    tim::vx::Quantization convolution_191_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0030953562818467617, 75);
    tim::vx::TensorSpec convolution_191_weight_spec(tim::vx::DataType::UINT8, convolution_191_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_191_weight_quant);
    auto convolution_191_weight = graph->CreateTensor(convolution_191_weight_spec, coef_data_ptr + 13258592);

    tim::vx::ShapeType convolution_191_bias_shape({512});
    tim::vx::Quantization convolution_191_bias_quant(tim::vx::QuantType::ASYMMETRIC, 5.839480218128301e-05, 0);
    tim::vx::TensorSpec convolution_191_bias_spec(tim::vx::DataType::INT32, convolution_191_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_191_bias_quant);
    auto convolution_191_bias = graph->CreateTensor(convolution_191_bias_spec, coef_data_ptr + 13256544);

    tim::vx::Quantization relu_194_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.01558383647352457, 0);
    tim::vx::TensorSpec relu_194_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_194_out0_quant);
    auto relu_194_out0 = graph->CreateTensor(relu_194_out0_spec);

    tim::vx::Quantization convolution_195_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.08450666815042496, 120);
    tim::vx::TensorSpec convolution_195_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_195_out0_quant);
    auto convolution_195_out0 = graph->CreateTensor(convolution_195_out0_spec);

    tim::vx::ShapeType convolution_195_weight_shape({1,1,512,2048});
    tim::vx::Quantization convolution_195_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.02880563586950302, 92);
    tim::vx::TensorSpec convolution_195_weight_spec(tim::vx::DataType::UINT8, convolution_195_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_195_weight_quant);
    auto convolution_195_weight = graph->CreateTensor(convolution_195_weight_spec, coef_data_ptr + 15626080);

    tim::vx::ShapeType convolution_195_bias_shape({2048});
    tim::vx::Quantization convolution_195_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00044890231220051646, 0);
    tim::vx::TensorSpec convolution_195_bias_spec(tim::vx::DataType::INT32, convolution_195_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_195_bias_quant);
    auto convolution_195_bias = graph->CreateTensor(convolution_195_bias_spec, coef_data_ptr + 15617888);

    tim::vx::Quantization add_198_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.10979654639959335, 0);
    tim::vx::TensorSpec add_198_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_198_out0_quant);
    auto add_198_out0 = graph->CreateTensor(add_198_out0_spec);

    tim::vx::Quantization relu_199_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.10979654639959335, 0);
    tim::vx::TensorSpec relu_199_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_199_out0_quant);
    auto relu_199_out0 = graph->CreateTensor(relu_199_out0_spec);

    tim::vx::Quantization convolution_200_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.014015702530741692, 0);
    tim::vx::TensorSpec convolution_200_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_200_out0_quant);
    auto convolution_200_out0 = graph->CreateTensor(convolution_200_out0_spec);

    tim::vx::ShapeType convolution_200_weight_shape({1,1,2048,512});
    tim::vx::Quantization convolution_200_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.000780042028054595, 92);
    tim::vx::TensorSpec convolution_200_weight_spec(tim::vx::DataType::UINT8, convolution_200_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_200_weight_quant);
    auto convolution_200_weight = graph->CreateTensor(convolution_200_weight_spec, coef_data_ptr + 16676704);

    tim::vx::ShapeType convolution_200_bias_shape({512});
    tim::vx::Quantization convolution_200_bias_quant(tim::vx::QuantType::ASYMMETRIC, 8.564592280890793e-05, 0);
    tim::vx::TensorSpec convolution_200_bias_spec(tim::vx::DataType::INT32, convolution_200_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_200_bias_quant);
    auto convolution_200_bias = graph->CreateTensor(convolution_200_bias_spec, coef_data_ptr + 16674656);

    tim::vx::Quantization relu_203_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.014015702530741692, 0);
    tim::vx::TensorSpec relu_203_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_203_out0_quant);
    auto relu_203_out0 = graph->CreateTensor(relu_203_out0_spec);

    tim::vx::Quantization convolution_204_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.013254771009087563, 0);
    tim::vx::TensorSpec convolution_204_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_204_out0_quant);
    auto convolution_204_out0 = graph->CreateTensor(convolution_204_out0_spec);

    tim::vx::ShapeType convolution_204_weight_shape({3,3,512,512});
    tim::vx::Quantization convolution_204_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0051354775205254555, 94);
    tim::vx::TensorSpec convolution_204_weight_spec(tim::vx::DataType::UINT8, convolution_204_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_204_weight_quant);
    auto convolution_204_weight = graph->CreateTensor(convolution_204_weight_spec, coef_data_ptr + 17727328);

    tim::vx::ShapeType convolution_204_bias_shape({512});
    tim::vx::Quantization convolution_204_bias_quant(tim::vx::QuantType::ASYMMETRIC, 7.197732338681817e-05, 0);
    tim::vx::TensorSpec convolution_204_bias_spec(tim::vx::DataType::INT32, convolution_204_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_204_bias_quant);
    auto convolution_204_bias = graph->CreateTensor(convolution_204_bias_spec, coef_data_ptr + 17725280);

    tim::vx::Quantization relu_207_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.013254771009087563, 0);
    tim::vx::TensorSpec relu_207_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_207_out0_quant);
    auto relu_207_out0 = graph->CreateTensor(relu_207_out0_spec);

    tim::vx::Quantization convolution_208_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.09129555523395538, 118);
    tim::vx::TensorSpec convolution_208_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_208_out0_quant);
    auto convolution_208_out0 = graph->CreateTensor(convolution_208_out0_spec);

    tim::vx::ShapeType convolution_208_weight_shape({1,1,512,2048});
    tim::vx::Quantization convolution_208_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.026294764131307602, 118);
    tim::vx::TensorSpec convolution_208_weight_spec(tim::vx::DataType::UINT8, convolution_208_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_208_weight_quant);
    auto convolution_208_weight = graph->CreateTensor(convolution_208_weight_spec, coef_data_ptr + 20094816);

    tim::vx::ShapeType convolution_208_bias_shape({2048});
    tim::vx::Quantization convolution_208_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0003485310880932957, 0);
    tim::vx::TensorSpec convolution_208_bias_spec(tim::vx::DataType::INT32, convolution_208_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_208_bias_quant);
    auto convolution_208_bias = graph->CreateTensor(convolution_208_bias_spec, coef_data_ptr + 20086624);

    tim::vx::Quantization add_211_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.1367546170949936, 0);
    tim::vx::TensorSpec add_211_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_211_out0_quant);
    auto add_211_out0 = graph->CreateTensor(add_211_out0_spec);

    tim::vx::Quantization relu_212_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.1367546170949936, 0);
    tim::vx::TensorSpec relu_212_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_212_out0_quant);
    auto relu_212_out0 = graph->CreateTensor(relu_212_out0_spec);

    tim::vx::Quantization convolution_213_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.02462535724043846, 0);
    tim::vx::TensorSpec convolution_213_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_213_out0_quant);
    auto convolution_213_out0 = graph->CreateTensor(convolution_213_out0_spec);

    tim::vx::ShapeType convolution_213_weight_shape({1,1,2048,512});
    tim::vx::Quantization convolution_213_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0007146087591536343, 80);
    tim::vx::TensorSpec convolution_213_weight_spec(tim::vx::DataType::UINT8, convolution_213_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_213_weight_quant);
    auto convolution_213_weight = graph->CreateTensor(convolution_213_weight_spec, coef_data_ptr + 21145440);

    tim::vx::ShapeType convolution_213_bias_shape({512});
    tim::vx::Quantization convolution_213_bias_quant(tim::vx::QuantType::ASYMMETRIC, 9.772604971658438e-05, 0);
    tim::vx::TensorSpec convolution_213_bias_spec(tim::vx::DataType::INT32, convolution_213_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_213_bias_quant);
    auto convolution_213_bias = graph->CreateTensor(convolution_213_bias_spec, coef_data_ptr + 21143392);

    tim::vx::Quantization relu_216_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.02462535724043846, 0);
    tim::vx::TensorSpec relu_216_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_216_out0_quant);
    auto relu_216_out0 = graph->CreateTensor(relu_216_out0_spec);

    tim::vx::Quantization convolution_217_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.024887174367904663, 0);
    tim::vx::TensorSpec convolution_217_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_217_out0_quant);
    auto convolution_217_out0 = graph->CreateTensor(convolution_217_out0_spec);

    tim::vx::ShapeType convolution_217_weight_shape({3,3,512,512});
    tim::vx::Quantization convolution_217_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.0030633925925940275, 126);
    tim::vx::TensorSpec convolution_217_weight_spec(tim::vx::DataType::UINT8, convolution_217_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_217_weight_quant);
    auto convolution_217_weight = graph->CreateTensor(convolution_217_weight_spec, coef_data_ptr + 22196064);

    tim::vx::ShapeType convolution_217_bias_shape({512});
    tim::vx::Quantization convolution_217_bias_quant(tim::vx::QuantType::ASYMMETRIC, 7.543713581981137e-05, 0);
    tim::vx::TensorSpec convolution_217_bias_spec(tim::vx::DataType::INT32, convolution_217_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_217_bias_quant);
    auto convolution_217_bias = graph->CreateTensor(convolution_217_bias_spec, coef_data_ptr + 22194016);

    tim::vx::Quantization relu_220_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.024887174367904663, 0);
    tim::vx::TensorSpec relu_220_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_220_out0_quant);
    auto relu_220_out0 = graph->CreateTensor(relu_220_out0_spec);

    tim::vx::Quantization convolution_221_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.1402689665555954, 109);
    tim::vx::TensorSpec convolution_221_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, convolution_221_out0_quant);
    auto convolution_221_out0 = graph->CreateTensor(convolution_221_out0_spec);

    tim::vx::ShapeType convolution_221_weight_shape({1,1,512,2048});
    tim::vx::Quantization convolution_221_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.030694643035531044, 77);
    tim::vx::TensorSpec convolution_221_weight_spec(tim::vx::DataType::UINT8, convolution_221_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_221_weight_quant);
    auto convolution_221_weight = graph->CreateTensor(convolution_221_weight_spec, coef_data_ptr + 24563552);

    tim::vx::ShapeType convolution_221_bias_shape({2048});
    tim::vx::Quantization convolution_221_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.0007639029063284397, 0);
    tim::vx::TensorSpec convolution_221_bias_spec(tim::vx::DataType::INT32, convolution_221_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, convolution_221_bias_quant);
    auto convolution_221_bias = graph->CreateTensor(convolution_221_bias_spec, coef_data_ptr + 24555360);

    tim::vx::Quantization add_224_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.16616259515285492, 0);
    tim::vx::TensorSpec add_224_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, add_224_out0_quant);
    auto add_224_out0 = graph->CreateTensor(add_224_out0_spec);

    tim::vx::Quantization relu_225_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.16616259515285492, 0);
    tim::vx::TensorSpec relu_225_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, relu_225_out0_quant);
    auto relu_225_out0 = graph->CreateTensor(relu_225_out0_spec);

    tim::vx::Quantization pooling_226_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.030994946137070656, 0);
    tim::vx::TensorSpec pooling_226_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, pooling_226_out0_quant);
    auto pooling_226_out0 = graph->CreateTensor(pooling_226_out0_spec);

    tim::vx::Quantization fullconnect_227_out0_quant(tim::vx::QuantType::ASYMMETRIC, 0.13894738256931305, 52);
    tim::vx::TensorSpec fullconnect_227_out0_spec(tim::vx::DataType::UINT8, {},
    tim::vx::TensorAttribute::TRANSIENT, fullconnect_227_out0_quant);
    auto fullconnect_227_out0 = graph->CreateTensor(fullconnect_227_out0_spec);

    tim::vx::ShapeType fullconnect_227_weight_shape({2048,1000});
    tim::vx::Quantization fullconnect_227_weight_quant(tim::vx::QuantType::ASYMMETRIC, 0.003711833618581295, 57);
    tim::vx::TensorSpec fullconnect_227_weight_spec(tim::vx::DataType::UINT8, fullconnect_227_weight_shape,
    tim::vx::TensorAttribute::CONSTANT, fullconnect_227_weight_quant);
    auto fullconnect_227_weight = graph->CreateTensor(fullconnect_227_weight_spec, coef_data_ptr + 13664);

    tim::vx::ShapeType fullconnect_227_bias_shape({1000});
    tim::vx::Quantization fullconnect_227_bias_quant(tim::vx::QuantType::ASYMMETRIC, 0.00011504808207973838, 0);
    tim::vx::TensorSpec fullconnect_227_bias_spec(tim::vx::DataType::INT32, fullconnect_227_bias_shape,
    tim::vx::TensorAttribute::CONSTANT, fullconnect_227_bias_quant);
    auto fullconnect_227_bias = graph->CreateTensor(fullconnect_227_bias_spec, coef_data_ptr + 9664);

    tim::vx::ShapeType input_0_shape({224,224,3,1});
    tim::vx::Quantization input_0_quant(tim::vx::QuantType::ASYMMETRIC, 1.0, 0);
    tim::vx::TensorSpec input_0_spec(tim::vx::DataType::UINT8, input_0_shape,
    tim::vx::TensorAttribute::INPUT, input_0_quant);
    auto input_0 = graph->CreateTensor(input_0_spec);

    tim::vx::ShapeType output_229_shape({1000,1});
    tim::vx::TensorSpec output_229_spec(tim::vx::DataType::FLOAT16, output_229_shape,
    tim::vx::TensorAttribute::OUTPUT);
    auto output_229 = graph->CreateTensor(output_229_spec);

    resnet50::inputs_tensor.push_back(input_0);

    resnet50::outputs_tensor.push_back(output_229);

    auto convolution_1 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        64,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({7,7}),    // ksize
        std::array<uint32_t, 2>({2,2}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({3,3,3,3}),    // pad
        0);    // multiplier

    auto relu_4 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto pooling_5 = graph->CreateOperation <tim::vx::ops::Pool2d>(
        tim::vx::PoolType::MAX,    // type
        std::array<uint32_t, 4>({0,1,0,1}),    // pad
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({2,2}),    // stride
        tim::vx::RoundType::CEILING);    // round_type

    auto convolution_9 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        64,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_12 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_13 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        64,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_16 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto concat_231 = graph->CreateOperation <tim::vx::ops::Concat>(
        2,    // axis
        2);    // input_cnt

    auto convolution_232 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_21 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_22 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        64,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_25 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_26 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        64,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_29 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_30 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_33 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_34 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_35 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        64,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_38 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_39 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        64,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_42 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_43 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_46 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_47 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_48 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({2,2}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto convolution_51 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        128,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({2,2}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_54 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_55 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        128,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_58 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_59 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_62 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_63 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_64 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        128,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_67 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_68 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        128,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_71 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_72 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_75 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_76 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_77 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        128,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_80 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_81 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        128,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_84 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_85 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_88 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_89 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_90 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        128,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_93 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_94 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        128,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_97 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_98 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_101 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_102 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_103 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        1024,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({2,2}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto convolution_106 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({2,2}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_109 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_110 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_113 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_114 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        1024,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_117 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_118 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_119 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_122 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_123 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_126 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_127 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        1024,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_130 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_131 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_132 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_135 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_136 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_139 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_140 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        1024,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_143 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_144 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_145 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_148 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_149 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_152 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_153 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        1024,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_156 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_157 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_158 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_161 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_162 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_165 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_166 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        1024,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_169 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_170 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_171 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_174 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_175 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        256,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_178 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_179 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        1024,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_182 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_183 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_184 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        2048,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({2,2}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto convolution_187 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({2,2}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_190 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_191 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_194 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_195 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        2048,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_198 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_199 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_200 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_203 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_204 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_207 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_208 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        2048,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_211 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_212 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_213 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto relu_216 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_217 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        512,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({3,3}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({1,1,1,1}),    // pad
        0);    // multiplier

    auto relu_220 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto convolution_221 = graph->CreateOperation <tim::vx::ops::Conv2d>(
        2048,    // weights
        tim::vx::PadType::NONE,    // padding
        std::array<uint32_t, 2>({1,1}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        std::array<uint32_t, 2>({1,1}),    // dilation
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        0);    // multiplier

    auto add_224 = graph->CreateOperation <tim::vx::ops::Add>();

    auto relu_225 = graph->CreateOperation <tim::vx::ops::Relu>();

    auto pooling_226 = graph->CreateOperation <tim::vx::ops::Pool2d>(
        tim::vx::PoolType::AVG,    // type
        std::array<uint32_t, 4>({0,0,0,0}),    // pad
        std::array<uint32_t, 2>({7,7}),    // ksize
        std::array<uint32_t, 2>({1,1}),    // stride
        tim::vx::RoundType::CEILING);    // round_type

    auto fullconnect_227 = graph->CreateOperation <tim::vx::ops::FullyConnected>(
        2,    // axis
        1000);    // weights

    auto softmax_228 = graph->CreateOperation <tim::vx::ops::Softmax>(
        1.0,    // beta
        0);    // axis

    (*convolution_1)
        .BindInputs({input_0, convolution_1_weight, convolution_1_bias})
        .BindOutputs({convolution_1_out0});

    (*relu_4)
        .BindInputs({convolution_1_out0})
        .BindOutputs({relu_4_out0});

    (*pooling_5)
        .BindInputs({relu_4_out0})
        .BindOutputs({pooling_5_out0});

    (*convolution_9)
        .BindInputs({pooling_5_out0, convolution_9_weight, convolution_9_bias})
        .BindOutputs({convolution_9_out0});

    (*relu_12)
        .BindInputs({convolution_9_out0})
        .BindOutputs({relu_12_out0});

    (*convolution_13)
        .BindInputs({relu_12_out0, convolution_13_weight, convolution_13_bias})
        .BindOutputs({convolution_13_out0});

    (*relu_16)
        .BindInputs({convolution_13_out0})
        .BindOutputs({relu_16_out0});

    (*concat_231)
        .BindInputs({pooling_5_out0,relu_16_out0})
        .BindOutputs({concat_231_out0});

    (*convolution_232)
        .BindInputs({concat_231_out0, convolution_232_weight, convolution_232_bias})
        .BindOutputs({convolution_232_out0});

    (*relu_21)
        .BindInputs({convolution_232_out0})
        .BindOutputs({relu_21_out0});

    (*convolution_22)
        .BindInputs({relu_21_out0, convolution_22_weight, convolution_22_bias})
        .BindOutputs({convolution_22_out0});

    (*relu_25)
        .BindInputs({convolution_22_out0})
        .BindOutputs({relu_25_out0});

    (*convolution_26)
        .BindInputs({relu_25_out0, convolution_26_weight, convolution_26_bias})
        .BindOutputs({convolution_26_out0});

    (*relu_29)
        .BindInputs({convolution_26_out0})
        .BindOutputs({relu_29_out0});

    (*convolution_30)
        .BindInputs({relu_29_out0, convolution_30_weight, convolution_30_bias})
        .BindOutputs({convolution_30_out0});

    (*add_33)
        .BindInputs({relu_21_out0,convolution_30_out0})
        .BindOutputs({add_33_out0});

    (*relu_34)
        .BindInputs({add_33_out0})
        .BindOutputs({relu_34_out0});

    (*convolution_35)
        .BindInputs({relu_34_out0, convolution_35_weight, convolution_35_bias})
        .BindOutputs({convolution_35_out0});

    (*relu_38)
        .BindInputs({convolution_35_out0})
        .BindOutputs({relu_38_out0});

    (*convolution_39)
        .BindInputs({relu_38_out0, convolution_39_weight, convolution_39_bias})
        .BindOutputs({convolution_39_out0});

    (*relu_42)
        .BindInputs({convolution_39_out0})
        .BindOutputs({relu_42_out0});

    (*convolution_43)
        .BindInputs({relu_42_out0, convolution_43_weight, convolution_43_bias})
        .BindOutputs({convolution_43_out0});

    (*add_46)
        .BindInputs({relu_34_out0,convolution_43_out0})
        .BindOutputs({add_46_out0});

    (*relu_47)
        .BindInputs({add_46_out0})
        .BindOutputs({relu_47_out0});

    (*convolution_48)
        .BindInputs({relu_47_out0, convolution_48_weight, convolution_48_bias})
        .BindOutputs({convolution_48_out0});

    (*convolution_51)
        .BindInputs({relu_47_out0, convolution_51_weight, convolution_51_bias})
        .BindOutputs({convolution_51_out0});

    (*relu_54)
        .BindInputs({convolution_51_out0})
        .BindOutputs({relu_54_out0});

    (*convolution_55)
        .BindInputs({relu_54_out0, convolution_55_weight, convolution_55_bias})
        .BindOutputs({convolution_55_out0});

    (*relu_58)
        .BindInputs({convolution_55_out0})
        .BindOutputs({relu_58_out0});

    (*convolution_59)
        .BindInputs({relu_58_out0, convolution_59_weight, convolution_59_bias})
        .BindOutputs({convolution_59_out0});

    (*add_62)
        .BindInputs({convolution_48_out0,convolution_59_out0})
        .BindOutputs({add_62_out0});

    (*relu_63)
        .BindInputs({add_62_out0})
        .BindOutputs({relu_63_out0});

    (*convolution_64)
        .BindInputs({relu_63_out0, convolution_64_weight, convolution_64_bias})
        .BindOutputs({convolution_64_out0});

    (*relu_67)
        .BindInputs({convolution_64_out0})
        .BindOutputs({relu_67_out0});

    (*convolution_68)
        .BindInputs({relu_67_out0, convolution_68_weight, convolution_68_bias})
        .BindOutputs({convolution_68_out0});

    (*relu_71)
        .BindInputs({convolution_68_out0})
        .BindOutputs({relu_71_out0});

    (*convolution_72)
        .BindInputs({relu_71_out0, convolution_72_weight, convolution_72_bias})
        .BindOutputs({convolution_72_out0});

    (*add_75)
        .BindInputs({relu_63_out0,convolution_72_out0})
        .BindOutputs({add_75_out0});

    (*relu_76)
        .BindInputs({add_75_out0})
        .BindOutputs({relu_76_out0});

    (*convolution_77)
        .BindInputs({relu_76_out0, convolution_77_weight, convolution_77_bias})
        .BindOutputs({convolution_77_out0});

    (*relu_80)
        .BindInputs({convolution_77_out0})
        .BindOutputs({relu_80_out0});

    (*convolution_81)
        .BindInputs({relu_80_out0, convolution_81_weight, convolution_81_bias})
        .BindOutputs({convolution_81_out0});

    (*relu_84)
        .BindInputs({convolution_81_out0})
        .BindOutputs({relu_84_out0});

    (*convolution_85)
        .BindInputs({relu_84_out0, convolution_85_weight, convolution_85_bias})
        .BindOutputs({convolution_85_out0});

    (*add_88)
        .BindInputs({relu_76_out0,convolution_85_out0})
        .BindOutputs({add_88_out0});

    (*relu_89)
        .BindInputs({add_88_out0})
        .BindOutputs({relu_89_out0});

    (*convolution_90)
        .BindInputs({relu_89_out0, convolution_90_weight, convolution_90_bias})
        .BindOutputs({convolution_90_out0});

    (*relu_93)
        .BindInputs({convolution_90_out0})
        .BindOutputs({relu_93_out0});

    (*convolution_94)
        .BindInputs({relu_93_out0, convolution_94_weight, convolution_94_bias})
        .BindOutputs({convolution_94_out0});

    (*relu_97)
        .BindInputs({convolution_94_out0})
        .BindOutputs({relu_97_out0});

    (*convolution_98)
        .BindInputs({relu_97_out0, convolution_98_weight, convolution_98_bias})
        .BindOutputs({convolution_98_out0});

    (*add_101)
        .BindInputs({relu_89_out0,convolution_98_out0})
        .BindOutputs({add_101_out0});

    (*relu_102)
        .BindInputs({add_101_out0})
        .BindOutputs({relu_102_out0});

    (*convolution_103)
        .BindInputs({relu_102_out0, convolution_103_weight, convolution_103_bias})
        .BindOutputs({convolution_103_out0});

    (*convolution_106)
        .BindInputs({relu_102_out0, convolution_106_weight, convolution_106_bias})
        .BindOutputs({convolution_106_out0});

    (*relu_109)
        .BindInputs({convolution_106_out0})
        .BindOutputs({relu_109_out0});

    (*convolution_110)
        .BindInputs({relu_109_out0, convolution_110_weight, convolution_110_bias})
        .BindOutputs({convolution_110_out0});

    (*relu_113)
        .BindInputs({convolution_110_out0})
        .BindOutputs({relu_113_out0});

    (*convolution_114)
        .BindInputs({relu_113_out0, convolution_114_weight, convolution_114_bias})
        .BindOutputs({convolution_114_out0});

    (*add_117)
        .BindInputs({convolution_103_out0,convolution_114_out0})
        .BindOutputs({add_117_out0});

    (*relu_118)
        .BindInputs({add_117_out0})
        .BindOutputs({relu_118_out0});

    (*convolution_119)
        .BindInputs({relu_118_out0, convolution_119_weight, convolution_119_bias})
        .BindOutputs({convolution_119_out0});

    (*relu_122)
        .BindInputs({convolution_119_out0})
        .BindOutputs({relu_122_out0});

    (*convolution_123)
        .BindInputs({relu_122_out0, convolution_123_weight, convolution_123_bias})
        .BindOutputs({convolution_123_out0});

    (*relu_126)
        .BindInputs({convolution_123_out0})
        .BindOutputs({relu_126_out0});

    (*convolution_127)
        .BindInputs({relu_126_out0, convolution_127_weight, convolution_127_bias})
        .BindOutputs({convolution_127_out0});

    (*add_130)
        .BindInputs({relu_118_out0,convolution_127_out0})
        .BindOutputs({add_130_out0});

    (*relu_131)
        .BindInputs({add_130_out0})
        .BindOutputs({relu_131_out0});

    (*convolution_132)
        .BindInputs({relu_131_out0, convolution_132_weight, convolution_132_bias})
        .BindOutputs({convolution_132_out0});

    (*relu_135)
        .BindInputs({convolution_132_out0})
        .BindOutputs({relu_135_out0});

    (*convolution_136)
        .BindInputs({relu_135_out0, convolution_136_weight, convolution_136_bias})
        .BindOutputs({convolution_136_out0});

    (*relu_139)
        .BindInputs({convolution_136_out0})
        .BindOutputs({relu_139_out0});

    (*convolution_140)
        .BindInputs({relu_139_out0, convolution_140_weight, convolution_140_bias})
        .BindOutputs({convolution_140_out0});

    (*add_143)
        .BindInputs({relu_131_out0,convolution_140_out0})
        .BindOutputs({add_143_out0});

    (*relu_144)
        .BindInputs({add_143_out0})
        .BindOutputs({relu_144_out0});

    (*convolution_145)
        .BindInputs({relu_144_out0, convolution_145_weight, convolution_145_bias})
        .BindOutputs({convolution_145_out0});

    (*relu_148)
        .BindInputs({convolution_145_out0})
        .BindOutputs({relu_148_out0});

    (*convolution_149)
        .BindInputs({relu_148_out0, convolution_149_weight, convolution_149_bias})
        .BindOutputs({convolution_149_out0});

    (*relu_152)
        .BindInputs({convolution_149_out0})
        .BindOutputs({relu_152_out0});

    (*convolution_153)
        .BindInputs({relu_152_out0, convolution_153_weight, convolution_153_bias})
        .BindOutputs({convolution_153_out0});

    (*add_156)
        .BindInputs({relu_144_out0,convolution_153_out0})
        .BindOutputs({add_156_out0});

    (*relu_157)
        .BindInputs({add_156_out0})
        .BindOutputs({relu_157_out0});

    (*convolution_158)
        .BindInputs({relu_157_out0, convolution_158_weight, convolution_158_bias})
        .BindOutputs({convolution_158_out0});

    (*relu_161)
        .BindInputs({convolution_158_out0})
        .BindOutputs({relu_161_out0});

    (*convolution_162)
        .BindInputs({relu_161_out0, convolution_162_weight, convolution_162_bias})
        .BindOutputs({convolution_162_out0});

    (*relu_165)
        .BindInputs({convolution_162_out0})
        .BindOutputs({relu_165_out0});

    (*convolution_166)
        .BindInputs({relu_165_out0, convolution_166_weight, convolution_166_bias})
        .BindOutputs({convolution_166_out0});

    (*add_169)
        .BindInputs({relu_157_out0,convolution_166_out0})
        .BindOutputs({add_169_out0});

    (*relu_170)
        .BindInputs({add_169_out0})
        .BindOutputs({relu_170_out0});

    (*convolution_171)
        .BindInputs({relu_170_out0, convolution_171_weight, convolution_171_bias})
        .BindOutputs({convolution_171_out0});

    (*relu_174)
        .BindInputs({convolution_171_out0})
        .BindOutputs({relu_174_out0});

    (*convolution_175)
        .BindInputs({relu_174_out0, convolution_175_weight, convolution_175_bias})
        .BindOutputs({convolution_175_out0});

    (*relu_178)
        .BindInputs({convolution_175_out0})
        .BindOutputs({relu_178_out0});

    (*convolution_179)
        .BindInputs({relu_178_out0, convolution_179_weight, convolution_179_bias})
        .BindOutputs({convolution_179_out0});

    (*add_182)
        .BindInputs({relu_170_out0,convolution_179_out0})
        .BindOutputs({add_182_out0});

    (*relu_183)
        .BindInputs({add_182_out0})
        .BindOutputs({relu_183_out0});

    (*convolution_184)
        .BindInputs({relu_183_out0, convolution_184_weight, convolution_184_bias})
        .BindOutputs({convolution_184_out0});

    (*convolution_187)
        .BindInputs({relu_183_out0, convolution_187_weight, convolution_187_bias})
        .BindOutputs({convolution_187_out0});

    (*relu_190)
        .BindInputs({convolution_187_out0})
        .BindOutputs({relu_190_out0});

    (*convolution_191)
        .BindInputs({relu_190_out0, convolution_191_weight, convolution_191_bias})
        .BindOutputs({convolution_191_out0});

    (*relu_194)
        .BindInputs({convolution_191_out0})
        .BindOutputs({relu_194_out0});

    (*convolution_195)
        .BindInputs({relu_194_out0, convolution_195_weight, convolution_195_bias})
        .BindOutputs({convolution_195_out0});

    (*add_198)
        .BindInputs({convolution_184_out0,convolution_195_out0})
        .BindOutputs({add_198_out0});

    (*relu_199)
        .BindInputs({add_198_out0})
        .BindOutputs({relu_199_out0});

    (*convolution_200)
        .BindInputs({relu_199_out0, convolution_200_weight, convolution_200_bias})
        .BindOutputs({convolution_200_out0});

    (*relu_203)
        .BindInputs({convolution_200_out0})
        .BindOutputs({relu_203_out0});

    (*convolution_204)
        .BindInputs({relu_203_out0, convolution_204_weight, convolution_204_bias})
        .BindOutputs({convolution_204_out0});

    (*relu_207)
        .BindInputs({convolution_204_out0})
        .BindOutputs({relu_207_out0});

    (*convolution_208)
        .BindInputs({relu_207_out0, convolution_208_weight, convolution_208_bias})
        .BindOutputs({convolution_208_out0});

    (*add_211)
        .BindInputs({relu_199_out0,convolution_208_out0})
        .BindOutputs({add_211_out0});

    (*relu_212)
        .BindInputs({add_211_out0})
        .BindOutputs({relu_212_out0});

    (*convolution_213)
        .BindInputs({relu_212_out0, convolution_213_weight, convolution_213_bias})
        .BindOutputs({convolution_213_out0});

    (*relu_216)
        .BindInputs({convolution_213_out0})
        .BindOutputs({relu_216_out0});

    (*convolution_217)
        .BindInputs({relu_216_out0, convolution_217_weight, convolution_217_bias})
        .BindOutputs({convolution_217_out0});

    (*relu_220)
        .BindInputs({convolution_217_out0})
        .BindOutputs({relu_220_out0});

    (*convolution_221)
        .BindInputs({relu_220_out0, convolution_221_weight, convolution_221_bias})
        .BindOutputs({convolution_221_out0});

    (*add_224)
        .BindInputs({relu_212_out0,convolution_221_out0})
        .BindOutputs({add_224_out0});

    (*relu_225)
        .BindInputs({add_224_out0})
        .BindOutputs({relu_225_out0});

    (*pooling_226)
        .BindInputs({relu_225_out0})
        .BindOutputs({pooling_226_out0});

    (*fullconnect_227)
        .BindInputs({pooling_226_out0, fullconnect_227_weight, fullconnect_227_bias})
        .BindOutputs({fullconnect_227_out0});

    (*softmax_228)
        .BindInputs({fullconnect_227_out0})
        .BindOutputs({output_229});

    free(coef_data_ptr);
}

}  // namespace acuitylite