// Layer Declaration header
//
// This file is auto-generated by cmake, don't edit it.

#include "layer/absval.h"
namespace ncnn {
class AbsVal_final : virtual public AbsVal
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = AbsVal::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = AbsVal::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(AbsVal_final)
} // namespace ncnn

#include "layer/batchnorm.h"
#include "layer/x86/batchnorm_x86.h"
namespace ncnn {
class BatchNorm_final : virtual public BatchNorm, virtual public BatchNorm_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = BatchNorm::create_pipeline(opt); if (ret) return ret; }
        { int ret = BatchNorm_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = BatchNorm_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = BatchNorm::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(BatchNorm_final)
} // namespace ncnn

#include "layer/batchnorm.h"
#include "layer/x86/batchnorm_x86_avx2.h"
namespace ncnn {
class BatchNorm_final_avx2 : virtual public BatchNorm, virtual public BatchNorm_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = BatchNorm::create_pipeline(opt); if (ret) return ret; }
        { int ret = BatchNorm_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = BatchNorm_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = BatchNorm::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(BatchNorm_final_avx2)
} // namespace ncnn

#include "layer/bias.h"
#include "layer/x86/bias_x86.h"
namespace ncnn {
class Bias_final : virtual public Bias, virtual public Bias_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Bias::create_pipeline(opt); if (ret) return ret; }
        { int ret = Bias_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Bias_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Bias::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Bias_final)
} // namespace ncnn

#include "layer/bias.h"
#include "layer/x86/bias_x86_avx2.h"
namespace ncnn {
class Bias_final_avx2 : virtual public Bias, virtual public Bias_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Bias::create_pipeline(opt); if (ret) return ret; }
        { int ret = Bias_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Bias_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Bias::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Bias_final_avx2)
} // namespace ncnn

#include "layer/bnll.h"
namespace ncnn {
class BNLL_final : virtual public BNLL
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = BNLL::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = BNLL::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(BNLL_final)
} // namespace ncnn

#include "layer/concat.h"
#include "layer/x86/concat_x86.h"
namespace ncnn {
class Concat_final : virtual public Concat, virtual public Concat_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Concat::create_pipeline(opt); if (ret) return ret; }
        { int ret = Concat_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Concat_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Concat::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Concat_final)
} // namespace ncnn

#include "layer/concat.h"
#include "layer/x86/concat_x86_avx2.h"
namespace ncnn {
class Concat_final_avx2 : virtual public Concat, virtual public Concat_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Concat::create_pipeline(opt); if (ret) return ret; }
        { int ret = Concat_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Concat_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Concat::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Concat_final_avx2)
} // namespace ncnn

#include "layer/convolution.h"
#include "layer/x86/convolution_x86.h"
namespace ncnn {
class Convolution_final : virtual public Convolution, virtual public Convolution_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Convolution::create_pipeline(opt); if (ret) return ret; }
        { int ret = Convolution_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Convolution_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Convolution::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Convolution_final)
} // namespace ncnn

#include "layer/convolution.h"
#include "layer/x86/convolution_x86_avx2.h"
namespace ncnn {
class Convolution_final_avx2 : virtual public Convolution, virtual public Convolution_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Convolution::create_pipeline(opt); if (ret) return ret; }
        { int ret = Convolution_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Convolution_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Convolution::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Convolution_final_avx2)
} // namespace ncnn

#include "layer/crop.h"
#include "layer/x86/crop_x86.h"
namespace ncnn {
class Crop_final : virtual public Crop, virtual public Crop_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Crop::create_pipeline(opt); if (ret) return ret; }
        { int ret = Crop_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Crop_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Crop::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Crop_final)
} // namespace ncnn

#include "layer/crop.h"
#include "layer/x86/crop_x86_avx2.h"
namespace ncnn {
class Crop_final_avx2 : virtual public Crop, virtual public Crop_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Crop::create_pipeline(opt); if (ret) return ret; }
        { int ret = Crop_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Crop_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Crop::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Crop_final_avx2)
} // namespace ncnn

#include "layer/deconvolution.h"
namespace ncnn {
class Deconvolution_final : virtual public Deconvolution
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Deconvolution::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Deconvolution::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Deconvolution_final)
} // namespace ncnn

#include "layer/dropout.h"
#include "layer/x86/dropout_x86.h"
namespace ncnn {
class Dropout_final : virtual public Dropout, virtual public Dropout_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Dropout::create_pipeline(opt); if (ret) return ret; }
        { int ret = Dropout_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Dropout_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Dropout::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Dropout_final)
} // namespace ncnn

#include "layer/dropout.h"
#include "layer/x86/dropout_x86_avx2.h"
namespace ncnn {
class Dropout_final_avx2 : virtual public Dropout, virtual public Dropout_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Dropout::create_pipeline(opt); if (ret) return ret; }
        { int ret = Dropout_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Dropout_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Dropout::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Dropout_final_avx2)
} // namespace ncnn

#include "layer/eltwise.h"
#include "layer/x86/eltwise_x86.h"
namespace ncnn {
class Eltwise_final : virtual public Eltwise, virtual public Eltwise_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Eltwise::create_pipeline(opt); if (ret) return ret; }
        { int ret = Eltwise_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Eltwise_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Eltwise::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Eltwise_final)
} // namespace ncnn

#include "layer/eltwise.h"
#include "layer/x86/eltwise_x86_avx2.h"
namespace ncnn {
class Eltwise_final_avx2 : virtual public Eltwise, virtual public Eltwise_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Eltwise::create_pipeline(opt); if (ret) return ret; }
        { int ret = Eltwise_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Eltwise_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Eltwise::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Eltwise_final_avx2)
} // namespace ncnn

#include "layer/elu.h"
namespace ncnn {
class ELU_final : virtual public ELU
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = ELU::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = ELU::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(ELU_final)
} // namespace ncnn

#include "layer/embed.h"
namespace ncnn {
class Embed_final : virtual public Embed
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Embed::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Embed::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Embed_final)
} // namespace ncnn

#include "layer/exp.h"
namespace ncnn {
class Exp_final : virtual public Exp
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Exp::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Exp::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Exp_final)
} // namespace ncnn

#include "layer/flatten.h"
#include "layer/x86/flatten_x86.h"
namespace ncnn {
class Flatten_final : virtual public Flatten, virtual public Flatten_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Flatten::create_pipeline(opt); if (ret) return ret; }
        { int ret = Flatten_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Flatten_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Flatten::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Flatten_final)
} // namespace ncnn

#include "layer/flatten.h"
#include "layer/x86/flatten_x86_avx2.h"
namespace ncnn {
class Flatten_final_avx2 : virtual public Flatten, virtual public Flatten_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Flatten::create_pipeline(opt); if (ret) return ret; }
        { int ret = Flatten_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Flatten_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Flatten::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Flatten_final_avx2)
} // namespace ncnn

#include "layer/innerproduct.h"
#include "layer/x86/innerproduct_x86.h"
namespace ncnn {
class InnerProduct_final : virtual public InnerProduct, virtual public InnerProduct_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = InnerProduct::create_pipeline(opt); if (ret) return ret; }
        { int ret = InnerProduct_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = InnerProduct_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = InnerProduct::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(InnerProduct_final)
} // namespace ncnn

#include "layer/innerproduct.h"
#include "layer/x86/innerproduct_x86_avx2.h"
namespace ncnn {
class InnerProduct_final_avx2 : virtual public InnerProduct, virtual public InnerProduct_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = InnerProduct::create_pipeline(opt); if (ret) return ret; }
        { int ret = InnerProduct_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = InnerProduct_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = InnerProduct::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(InnerProduct_final_avx2)
} // namespace ncnn

#include "layer/input.h"
namespace ncnn {
class Input_final : virtual public Input
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Input::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Input::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Input_final)
} // namespace ncnn

#include "layer/log.h"
namespace ncnn {
class Log_final : virtual public Log
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Log::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Log::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Log_final)
} // namespace ncnn

#include "layer/lrn.h"
#include "layer/x86/lrn_x86.h"
namespace ncnn {
class LRN_final : virtual public LRN, virtual public LRN_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = LRN::create_pipeline(opt); if (ret) return ret; }
        { int ret = LRN_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = LRN_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = LRN::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(LRN_final)
} // namespace ncnn

#include "layer/lrn.h"
#include "layer/x86/lrn_x86_avx2.h"
namespace ncnn {
class LRN_final_avx2 : virtual public LRN, virtual public LRN_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = LRN::create_pipeline(opt); if (ret) return ret; }
        { int ret = LRN_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = LRN_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = LRN::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(LRN_final_avx2)
} // namespace ncnn

#include "layer/memorydata.h"
namespace ncnn {
class MemoryData_final : virtual public MemoryData
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = MemoryData::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = MemoryData::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(MemoryData_final)
} // namespace ncnn

#include "layer/mvn.h"
namespace ncnn {
class MVN_final : virtual public MVN
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = MVN::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = MVN::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(MVN_final)
} // namespace ncnn

#include "layer/pooling.h"
#include "layer/x86/pooling_x86.h"
namespace ncnn {
class Pooling_final : virtual public Pooling, virtual public Pooling_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Pooling::create_pipeline(opt); if (ret) return ret; }
        { int ret = Pooling_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Pooling_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Pooling::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Pooling_final)
} // namespace ncnn

#include "layer/pooling.h"
#include "layer/x86/pooling_x86_avx2.h"
namespace ncnn {
class Pooling_final_avx2 : virtual public Pooling, virtual public Pooling_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Pooling::create_pipeline(opt); if (ret) return ret; }
        { int ret = Pooling_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Pooling_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Pooling::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Pooling_final_avx2)
} // namespace ncnn

#include "layer/power.h"
namespace ncnn {
class Power_final : virtual public Power
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Power::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Power::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Power_final)
} // namespace ncnn

#include "layer/prelu.h"
#include "layer/x86/prelu_x86.h"
namespace ncnn {
class PReLU_final : virtual public PReLU, virtual public PReLU_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = PReLU::create_pipeline(opt); if (ret) return ret; }
        { int ret = PReLU_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = PReLU_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = PReLU::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(PReLU_final)
} // namespace ncnn

#include "layer/prelu.h"
#include "layer/x86/prelu_x86_avx2.h"
namespace ncnn {
class PReLU_final_avx2 : virtual public PReLU, virtual public PReLU_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = PReLU::create_pipeline(opt); if (ret) return ret; }
        { int ret = PReLU_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = PReLU_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = PReLU::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(PReLU_final_avx2)
} // namespace ncnn

#include "layer/proposal.h"
namespace ncnn {
class Proposal_final : virtual public Proposal
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Proposal::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Proposal::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Proposal_final)
} // namespace ncnn

#include "layer/reduction.h"
namespace ncnn {
class Reduction_final : virtual public Reduction
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Reduction::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Reduction::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Reduction_final)
} // namespace ncnn

#include "layer/relu.h"
#include "layer/x86/relu_x86.h"
namespace ncnn {
class ReLU_final : virtual public ReLU, virtual public ReLU_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = ReLU::create_pipeline(opt); if (ret) return ret; }
        { int ret = ReLU_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = ReLU_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = ReLU::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(ReLU_final)
} // namespace ncnn

#include "layer/relu.h"
#include "layer/x86/relu_x86_avx2.h"
namespace ncnn {
class ReLU_final_avx2 : virtual public ReLU, virtual public ReLU_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = ReLU::create_pipeline(opt); if (ret) return ret; }
        { int ret = ReLU_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = ReLU_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = ReLU::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(ReLU_final_avx2)
} // namespace ncnn

#include "layer/reshape.h"
#include "layer/x86/reshape_x86.h"
namespace ncnn {
class Reshape_final : virtual public Reshape, virtual public Reshape_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Reshape::create_pipeline(opt); if (ret) return ret; }
        { int ret = Reshape_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Reshape_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Reshape::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Reshape_final)
} // namespace ncnn

#include "layer/reshape.h"
#include "layer/x86/reshape_x86_avx2.h"
namespace ncnn {
class Reshape_final_avx2 : virtual public Reshape, virtual public Reshape_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Reshape::create_pipeline(opt); if (ret) return ret; }
        { int ret = Reshape_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Reshape_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Reshape::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Reshape_final_avx2)
} // namespace ncnn

#include "layer/roipooling.h"
namespace ncnn {
class ROIPooling_final : virtual public ROIPooling
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = ROIPooling::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = ROIPooling::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(ROIPooling_final)
} // namespace ncnn

#include "layer/scale.h"
#include "layer/x86/scale_x86.h"
namespace ncnn {
class Scale_final : virtual public Scale, virtual public Scale_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Scale::create_pipeline(opt); if (ret) return ret; }
        { int ret = Scale_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Scale_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Scale::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Scale_final)
} // namespace ncnn

#include "layer/scale.h"
#include "layer/x86/scale_x86_avx2.h"
namespace ncnn {
class Scale_final_avx2 : virtual public Scale, virtual public Scale_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Scale::create_pipeline(opt); if (ret) return ret; }
        { int ret = Scale_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Scale_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Scale::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Scale_final_avx2)
} // namespace ncnn

#include "layer/sigmoid.h"
#include "layer/x86/sigmoid_x86.h"
namespace ncnn {
class Sigmoid_final : virtual public Sigmoid, virtual public Sigmoid_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Sigmoid::create_pipeline(opt); if (ret) return ret; }
        { int ret = Sigmoid_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Sigmoid_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Sigmoid::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Sigmoid_final)
} // namespace ncnn

#include "layer/sigmoid.h"
#include "layer/x86/sigmoid_x86_avx2.h"
namespace ncnn {
class Sigmoid_final_avx2 : virtual public Sigmoid, virtual public Sigmoid_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Sigmoid::create_pipeline(opt); if (ret) return ret; }
        { int ret = Sigmoid_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Sigmoid_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Sigmoid::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Sigmoid_final_avx2)
} // namespace ncnn

#include "layer/slice.h"
#include "layer/x86/slice_x86.h"
namespace ncnn {
class Slice_final : virtual public Slice, virtual public Slice_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Slice::create_pipeline(opt); if (ret) return ret; }
        { int ret = Slice_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Slice_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Slice::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Slice_final)
} // namespace ncnn

#include "layer/slice.h"
#include "layer/x86/slice_x86_avx2.h"
namespace ncnn {
class Slice_final_avx2 : virtual public Slice, virtual public Slice_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Slice::create_pipeline(opt); if (ret) return ret; }
        { int ret = Slice_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Slice_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Slice::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Slice_final_avx2)
} // namespace ncnn

#include "layer/softmax.h"
namespace ncnn {
class Softmax_final : virtual public Softmax
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Softmax::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Softmax::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Softmax_final)
} // namespace ncnn

#include "layer/split.h"
namespace ncnn {
class Split_final : virtual public Split
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Split::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Split::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Split_final)
} // namespace ncnn

#include "layer/tanh.h"
#include "layer/x86/tanh_x86.h"
namespace ncnn {
class TanH_final : virtual public TanH, virtual public TanH_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = TanH::create_pipeline(opt); if (ret) return ret; }
        { int ret = TanH_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = TanH_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = TanH::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(TanH_final)
} // namespace ncnn

#include "layer/tanh.h"
#include "layer/x86/tanh_x86_avx2.h"
namespace ncnn {
class TanH_final_avx2 : virtual public TanH, virtual public TanH_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = TanH::create_pipeline(opt); if (ret) return ret; }
        { int ret = TanH_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = TanH_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = TanH::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(TanH_final_avx2)
} // namespace ncnn

#include "layer/threshold.h"
namespace ncnn {
class Threshold_final : virtual public Threshold
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Threshold::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Threshold::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Threshold_final)
} // namespace ncnn

#include "layer/rnn.h"
namespace ncnn {
class RNN_final : virtual public RNN
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = RNN::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = RNN::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(RNN_final)
} // namespace ncnn

#include "layer/lstm.h"
#include "layer/x86/lstm_x86.h"
namespace ncnn {
class LSTM_final : virtual public LSTM, virtual public LSTM_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = LSTM::create_pipeline(opt); if (ret) return ret; }
        { int ret = LSTM_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = LSTM_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = LSTM::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(LSTM_final)
} // namespace ncnn

#include "layer/lstm.h"
#include "layer/x86/lstm_x86_avx2.h"
namespace ncnn {
class LSTM_final_avx2 : virtual public LSTM, virtual public LSTM_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = LSTM::create_pipeline(opt); if (ret) return ret; }
        { int ret = LSTM_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = LSTM_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = LSTM::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(LSTM_final_avx2)
} // namespace ncnn

#include "layer/binaryop.h"
#include "layer/x86/binaryop_x86.h"
namespace ncnn {
class BinaryOp_final : virtual public BinaryOp, virtual public BinaryOp_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = BinaryOp::create_pipeline(opt); if (ret) return ret; }
        { int ret = BinaryOp_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = BinaryOp_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = BinaryOp::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(BinaryOp_final)
} // namespace ncnn

#include "layer/binaryop.h"
#include "layer/x86/binaryop_x86_avx2.h"
namespace ncnn {
class BinaryOp_final_avx2 : virtual public BinaryOp, virtual public BinaryOp_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = BinaryOp::create_pipeline(opt); if (ret) return ret; }
        { int ret = BinaryOp_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = BinaryOp_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = BinaryOp::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(BinaryOp_final_avx2)
} // namespace ncnn

#include "layer/unaryop.h"
namespace ncnn {
class UnaryOp_final : virtual public UnaryOp
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = UnaryOp::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = UnaryOp::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(UnaryOp_final)
} // namespace ncnn

#include "layer/convolutiondepthwise.h"
#include "layer/x86/convolutiondepthwise_x86.h"
namespace ncnn {
class ConvolutionDepthWise_final : virtual public ConvolutionDepthWise, virtual public ConvolutionDepthWise_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = ConvolutionDepthWise::create_pipeline(opt); if (ret) return ret; }
        { int ret = ConvolutionDepthWise_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = ConvolutionDepthWise_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = ConvolutionDepthWise::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(ConvolutionDepthWise_final)
} // namespace ncnn

#include "layer/convolutiondepthwise.h"
#include "layer/x86/convolutiondepthwise_x86_avx2.h"
namespace ncnn {
class ConvolutionDepthWise_final_avx2 : virtual public ConvolutionDepthWise, virtual public ConvolutionDepthWise_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = ConvolutionDepthWise::create_pipeline(opt); if (ret) return ret; }
        { int ret = ConvolutionDepthWise_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = ConvolutionDepthWise_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = ConvolutionDepthWise::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(ConvolutionDepthWise_final_avx2)
} // namespace ncnn

#include "layer/padding.h"
#include "layer/x86/padding_x86.h"
namespace ncnn {
class Padding_final : virtual public Padding, virtual public Padding_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Padding::create_pipeline(opt); if (ret) return ret; }
        { int ret = Padding_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Padding_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Padding::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Padding_final)
} // namespace ncnn

#include "layer/padding.h"
#include "layer/x86/padding_x86_avx2.h"
namespace ncnn {
class Padding_final_avx2 : virtual public Padding, virtual public Padding_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Padding::create_pipeline(opt); if (ret) return ret; }
        { int ret = Padding_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Padding_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Padding::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Padding_final_avx2)
} // namespace ncnn

#include "layer/squeeze.h"
namespace ncnn {
class Squeeze_final : virtual public Squeeze
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Squeeze::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Squeeze::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Squeeze_final)
} // namespace ncnn

#include "layer/expanddims.h"
namespace ncnn {
class ExpandDims_final : virtual public ExpandDims
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = ExpandDims::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = ExpandDims::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(ExpandDims_final)
} // namespace ncnn

#include "layer/normalize.h"
namespace ncnn {
class Normalize_final : virtual public Normalize
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Normalize::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Normalize::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Normalize_final)
} // namespace ncnn

#include "layer/permute.h"
namespace ncnn {
class Permute_final : virtual public Permute
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Permute::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Permute::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Permute_final)
} // namespace ncnn

#include "layer/priorbox.h"
namespace ncnn {
class PriorBox_final : virtual public PriorBox
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = PriorBox::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = PriorBox::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(PriorBox_final)
} // namespace ncnn

#include "layer/detectionoutput.h"
namespace ncnn {
class DetectionOutput_final : virtual public DetectionOutput
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = DetectionOutput::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = DetectionOutput::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(DetectionOutput_final)
} // namespace ncnn

#include "layer/interp.h"
namespace ncnn {
class Interp_final : virtual public Interp
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Interp::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Interp::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Interp_final)
} // namespace ncnn

#include "layer/deconvolutiondepthwise.h"
namespace ncnn {
class DeconvolutionDepthWise_final : virtual public DeconvolutionDepthWise
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = DeconvolutionDepthWise::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = DeconvolutionDepthWise::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(DeconvolutionDepthWise_final)
} // namespace ncnn

#include "layer/shufflechannel.h"
namespace ncnn {
class ShuffleChannel_final : virtual public ShuffleChannel
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = ShuffleChannel::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = ShuffleChannel::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(ShuffleChannel_final)
} // namespace ncnn

#include "layer/instancenorm.h"
namespace ncnn {
class InstanceNorm_final : virtual public InstanceNorm
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = InstanceNorm::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = InstanceNorm::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(InstanceNorm_final)
} // namespace ncnn

#include "layer/clip.h"
#include "layer/x86/clip_x86.h"
namespace ncnn {
class Clip_final : virtual public Clip, virtual public Clip_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Clip::create_pipeline(opt); if (ret) return ret; }
        { int ret = Clip_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Clip_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Clip::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Clip_final)
} // namespace ncnn

#include "layer/clip.h"
#include "layer/x86/clip_x86_avx2.h"
namespace ncnn {
class Clip_final_avx2 : virtual public Clip, virtual public Clip_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Clip::create_pipeline(opt); if (ret) return ret; }
        { int ret = Clip_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Clip_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Clip::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Clip_final_avx2)
} // namespace ncnn

#include "layer/reorg.h"
namespace ncnn {
class Reorg_final : virtual public Reorg
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Reorg::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Reorg::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Reorg_final)
} // namespace ncnn

#include "layer/yolodetectionoutput.h"
namespace ncnn {
class YoloDetectionOutput_final : virtual public YoloDetectionOutput
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = YoloDetectionOutput::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = YoloDetectionOutput::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(YoloDetectionOutput_final)
} // namespace ncnn

#include "layer/quantize.h"
#include "layer/x86/quantize_x86.h"
namespace ncnn {
class Quantize_final : virtual public Quantize, virtual public Quantize_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Quantize::create_pipeline(opt); if (ret) return ret; }
        { int ret = Quantize_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Quantize_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Quantize::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Quantize_final)
} // namespace ncnn

#include "layer/quantize.h"
#include "layer/x86/quantize_x86_avx2.h"
namespace ncnn {
class Quantize_final_avx2 : virtual public Quantize, virtual public Quantize_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Quantize::create_pipeline(opt); if (ret) return ret; }
        { int ret = Quantize_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Quantize_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Quantize::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Quantize_final_avx2)
} // namespace ncnn

#include "layer/dequantize.h"
#include "layer/x86/dequantize_x86.h"
namespace ncnn {
class Dequantize_final : virtual public Dequantize, virtual public Dequantize_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Dequantize::create_pipeline(opt); if (ret) return ret; }
        { int ret = Dequantize_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Dequantize_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Dequantize::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Dequantize_final)
} // namespace ncnn

#include "layer/dequantize.h"
#include "layer/x86/dequantize_x86_avx2.h"
namespace ncnn {
class Dequantize_final_avx2 : virtual public Dequantize, virtual public Dequantize_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Dequantize::create_pipeline(opt); if (ret) return ret; }
        { int ret = Dequantize_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Dequantize_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Dequantize::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Dequantize_final_avx2)
} // namespace ncnn

#include "layer/yolov3detectionoutput.h"
#include "layer/x86/yolov3detectionoutput_x86.h"
namespace ncnn {
class Yolov3DetectionOutput_final : virtual public Yolov3DetectionOutput, virtual public Yolov3DetectionOutput_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Yolov3DetectionOutput::create_pipeline(opt); if (ret) return ret; }
        { int ret = Yolov3DetectionOutput_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Yolov3DetectionOutput_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Yolov3DetectionOutput::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Yolov3DetectionOutput_final)
} // namespace ncnn

#include "layer/yolov3detectionoutput.h"
#include "layer/x86/yolov3detectionoutput_x86_avx2.h"
namespace ncnn {
class Yolov3DetectionOutput_final_avx2 : virtual public Yolov3DetectionOutput, virtual public Yolov3DetectionOutput_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Yolov3DetectionOutput::create_pipeline(opt); if (ret) return ret; }
        { int ret = Yolov3DetectionOutput_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Yolov3DetectionOutput_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Yolov3DetectionOutput::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Yolov3DetectionOutput_final_avx2)
} // namespace ncnn

#include "layer/psroipooling.h"
namespace ncnn {
class PSROIPooling_final : virtual public PSROIPooling
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = PSROIPooling::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = PSROIPooling::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(PSROIPooling_final)
} // namespace ncnn

#include "layer/roialign.h"
#include "layer/x86/roialign_x86.h"
namespace ncnn {
class ROIAlign_final : virtual public ROIAlign, virtual public ROIAlign_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = ROIAlign::create_pipeline(opt); if (ret) return ret; }
        { int ret = ROIAlign_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = ROIAlign_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = ROIAlign::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(ROIAlign_final)
} // namespace ncnn

#include "layer/roialign.h"
#include "layer/x86/roialign_x86_avx2.h"
namespace ncnn {
class ROIAlign_final_avx2 : virtual public ROIAlign, virtual public ROIAlign_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = ROIAlign::create_pipeline(opt); if (ret) return ret; }
        { int ret = ROIAlign_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = ROIAlign_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = ROIAlign::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(ROIAlign_final_avx2)
} // namespace ncnn

#include "layer/packing.h"
#include "layer/x86/packing_x86.h"
namespace ncnn {
class Packing_final : virtual public Packing, virtual public Packing_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Packing::create_pipeline(opt); if (ret) return ret; }
        { int ret = Packing_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Packing_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Packing::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Packing_final)
} // namespace ncnn

#include "layer/packing.h"
#include "layer/x86/packing_x86_avx2.h"
namespace ncnn {
class Packing_final_avx2 : virtual public Packing, virtual public Packing_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Packing::create_pipeline(opt); if (ret) return ret; }
        { int ret = Packing_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Packing_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Packing::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Packing_final_avx2)
} // namespace ncnn

#include "layer/requantize.h"
#include "layer/x86/requantize_x86.h"
namespace ncnn {
class Requantize_final : virtual public Requantize, virtual public Requantize_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Requantize::create_pipeline(opt); if (ret) return ret; }
        { int ret = Requantize_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Requantize_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Requantize::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Requantize_final)
} // namespace ncnn

#include "layer/requantize.h"
#include "layer/x86/requantize_x86_avx2.h"
namespace ncnn {
class Requantize_final_avx2 : virtual public Requantize, virtual public Requantize_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Requantize::create_pipeline(opt); if (ret) return ret; }
        { int ret = Requantize_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Requantize_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Requantize::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Requantize_final_avx2)
} // namespace ncnn

#include "layer/cast.h"
#include "layer/x86/cast_x86.h"
namespace ncnn {
class Cast_final : virtual public Cast, virtual public Cast_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Cast::create_pipeline(opt); if (ret) return ret; }
        { int ret = Cast_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Cast_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Cast::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Cast_final)
} // namespace ncnn

#include "layer/cast.h"
#include "layer/x86/cast_x86_avx2.h"
namespace ncnn {
class Cast_final_avx2 : virtual public Cast, virtual public Cast_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Cast::create_pipeline(opt); if (ret) return ret; }
        { int ret = Cast_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Cast_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Cast::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Cast_final_avx2)
} // namespace ncnn

#include "layer/hardsigmoid.h"
#include "layer/x86/hardsigmoid_x86.h"
namespace ncnn {
class HardSigmoid_final : virtual public HardSigmoid, virtual public HardSigmoid_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = HardSigmoid::create_pipeline(opt); if (ret) return ret; }
        { int ret = HardSigmoid_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = HardSigmoid_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = HardSigmoid::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(HardSigmoid_final)
} // namespace ncnn

#include "layer/hardsigmoid.h"
#include "layer/x86/hardsigmoid_x86_avx2.h"
namespace ncnn {
class HardSigmoid_final_avx2 : virtual public HardSigmoid, virtual public HardSigmoid_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = HardSigmoid::create_pipeline(opt); if (ret) return ret; }
        { int ret = HardSigmoid_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = HardSigmoid_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = HardSigmoid::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(HardSigmoid_final_avx2)
} // namespace ncnn

#include "layer/selu.h"
namespace ncnn {
class SELU_final : virtual public SELU
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = SELU::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = SELU::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(SELU_final)
} // namespace ncnn

#include "layer/hardswish.h"
#include "layer/x86/hardswish_x86.h"
namespace ncnn {
class HardSwish_final : virtual public HardSwish, virtual public HardSwish_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = HardSwish::create_pipeline(opt); if (ret) return ret; }
        { int ret = HardSwish_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = HardSwish_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = HardSwish::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(HardSwish_final)
} // namespace ncnn

#include "layer/hardswish.h"
#include "layer/x86/hardswish_x86_avx2.h"
namespace ncnn {
class HardSwish_final_avx2 : virtual public HardSwish, virtual public HardSwish_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = HardSwish::create_pipeline(opt); if (ret) return ret; }
        { int ret = HardSwish_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = HardSwish_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = HardSwish::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(HardSwish_final_avx2)
} // namespace ncnn

#include "layer/noop.h"
namespace ncnn {
class Noop_final : virtual public Noop
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Noop::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Noop::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Noop_final)
} // namespace ncnn

#include "layer/pixelshuffle.h"
namespace ncnn {
class PixelShuffle_final : virtual public PixelShuffle
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = PixelShuffle::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = PixelShuffle::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(PixelShuffle_final)
} // namespace ncnn

#include "layer/deepcopy.h"
namespace ncnn {
class DeepCopy_final : virtual public DeepCopy
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = DeepCopy::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = DeepCopy::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(DeepCopy_final)
} // namespace ncnn

#include "layer/mish.h"
#include "layer/x86/mish_x86.h"
namespace ncnn {
class Mish_final : virtual public Mish, virtual public Mish_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Mish::create_pipeline(opt); if (ret) return ret; }
        { int ret = Mish_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Mish_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Mish::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Mish_final)
} // namespace ncnn

#include "layer/mish.h"
#include "layer/x86/mish_x86_avx2.h"
namespace ncnn {
class Mish_final_avx2 : virtual public Mish, virtual public Mish_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Mish::create_pipeline(opt); if (ret) return ret; }
        { int ret = Mish_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Mish_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Mish::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Mish_final_avx2)
} // namespace ncnn

#include "layer/statisticspooling.h"
namespace ncnn {
class StatisticsPooling_final : virtual public StatisticsPooling
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = StatisticsPooling::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = StatisticsPooling::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(StatisticsPooling_final)
} // namespace ncnn

#include "layer/swish.h"
#include "layer/x86/swish_x86.h"
namespace ncnn {
class Swish_final : virtual public Swish, virtual public Swish_x86
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Swish::create_pipeline(opt); if (ret) return ret; }
        { int ret = Swish_x86::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Swish_x86::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Swish::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Swish_final)
} // namespace ncnn

#include "layer/swish.h"
#include "layer/x86/swish_x86_avx2.h"
namespace ncnn {
class Swish_final_avx2 : virtual public Swish, virtual public Swish_x86_avx2
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Swish::create_pipeline(opt); if (ret) return ret; }
        { int ret = Swish_x86_avx2::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Swish_x86_avx2::destroy_pipeline(opt); if (ret) return ret; }
        { int ret = Swish::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Swish_final_avx2)
} // namespace ncnn

#include "layer/gemm.h"
namespace ncnn {
class Gemm_final : virtual public Gemm
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Gemm::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Gemm::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Gemm_final)
} // namespace ncnn

#include "layer/groupnorm.h"
namespace ncnn {
class GroupNorm_final : virtual public GroupNorm
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = GroupNorm::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = GroupNorm::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(GroupNorm_final)
} // namespace ncnn

#include "layer/layernorm.h"
namespace ncnn {
class LayerNorm_final : virtual public LayerNorm
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = LayerNorm::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = LayerNorm::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(LayerNorm_final)
} // namespace ncnn

#include "layer/softplus.h"
namespace ncnn {
class Softplus_final : virtual public Softplus
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = Softplus::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = Softplus::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(Softplus_final)
} // namespace ncnn

#include "layer/gru.h"
namespace ncnn {
class GRU_final : virtual public GRU
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = GRU::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = GRU::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(GRU_final)
} // namespace ncnn

#include "layer/multiheadattention.h"
namespace ncnn {
class MultiHeadAttention_final : virtual public MultiHeadAttention
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = MultiHeadAttention::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = MultiHeadAttention::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(MultiHeadAttention_final)
} // namespace ncnn

#include "layer/gelu.h"
namespace ncnn {
class GELU_final : virtual public GELU
{
public:
    virtual int create_pipeline(const Option& opt) {
        { int ret = GELU::create_pipeline(opt); if (ret) return ret; }
        return 0;
    }
    virtual int destroy_pipeline(const Option& opt) {
        { int ret = GELU::destroy_pipeline(opt); if (ret) return ret; }
        return 0;
    }
};
DEFINE_LAYER_CREATOR(GELU_final)
} // namespace ncnn