MegEngine/dnn/atlas-stub/src/libatlas-wrap_1.1.0.h

// generated by wraplib.py
// --- begin functions to be implemented
#ifndef _WRAPLIB_API_CALL
#define _WRAPLIB_API_CALL
#endif
#ifndef _WRAPLIB_CALLBACK
#define _WRAPLIB_CALLBACK
#endif
#ifndef ON_ENTRY
#define ON_ENTRY(x)
#endif
static void* get_library_handle();
static void* resolve_library_func(void* , const char*);
namespace {
template<typename T> T on_init_failed(int func_idx);
}
// --- end functions to be implemented
#include <mutex>
#include <cstddef>
static void load_library();
static float _WRAPLIB_API_CALL aclFloat16ToFloat_init(aclFloat16 arg0) {
    load_library();
    return aclFloat16ToFloat(arg0);
}
static float _WRAPLIB_API_CALL aclFloat16ToFloat_error(aclFloat16) {
    return on_init_failed<float >(0);
}
static aclFloat16 _WRAPLIB_API_CALL aclFloatToFloat16_init(float arg0) {
    load_library();
    return aclFloatToFloat16(arg0);
}
static aclFloat16 _WRAPLIB_API_CALL aclFloatToFloat16_error(float) {
    return on_init_failed<aclFloat16 >(1);
}
static aclDataBuffer _WRAPLIB_API_CALL *aclCreateDataBuffer_init(void *arg0, size_t arg1) {
    load_library();
    return aclCreateDataBuffer(arg0, arg1);
}
static aclDataBuffer _WRAPLIB_API_CALL *aclCreateDataBuffer_error(void *, size_t) {
    return on_init_failed<aclDataBuffer *>(2);
}
static aclError _WRAPLIB_API_CALL aclDestroyDataBuffer_init(const aclDataBuffer *arg0) {
    load_library();
    return aclDestroyDataBuffer(arg0);
}
static aclError _WRAPLIB_API_CALL aclDestroyDataBuffer_error(const aclDataBuffer *) {
    return on_init_failed<aclError >(3);
}
static aclError _WRAPLIB_API_CALL aclUpdateDataBuffer_init(aclDataBuffer *arg0, void *arg1, size_t arg2) {
    load_library();
    return aclUpdateDataBuffer(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclUpdateDataBuffer_error(aclDataBuffer *, void *, size_t) {
    return on_init_failed<aclError >(4);
}
static void _WRAPLIB_API_CALL *aclGetDataBufferAddr_init(const aclDataBuffer *arg0) {
    load_library();
    return aclGetDataBufferAddr(arg0);
}
static void _WRAPLIB_API_CALL *aclGetDataBufferAddr_error(const aclDataBuffer *) {
    return on_init_failed<void *>(5);
}
static uint32_t _WRAPLIB_API_CALL aclGetDataBufferSize_init(const aclDataBuffer *arg0) {
    load_library();
    return aclGetDataBufferSize(arg0);
}
static uint32_t _WRAPLIB_API_CALL aclGetDataBufferSize_error(const aclDataBuffer *) {
    return on_init_failed<uint32_t >(6);
}
static size_t _WRAPLIB_API_CALL aclGetDataBufferSizeV2_init(const aclDataBuffer *arg0) {
    load_library();
    return aclGetDataBufferSizeV2(arg0);
}
static size_t _WRAPLIB_API_CALL aclGetDataBufferSizeV2_error(const aclDataBuffer *) {
    return on_init_failed<size_t >(7);
}
static size_t _WRAPLIB_API_CALL aclDataTypeSize_init(aclDataType arg0) {
    load_library();
    return aclDataTypeSize(arg0);
}
static size_t _WRAPLIB_API_CALL aclDataTypeSize_error(aclDataType) {
    return on_init_failed<size_t >(8);
}
static aclTensorDesc _WRAPLIB_API_CALL *aclCreateTensorDesc_init(aclDataType arg0, int arg1, const int64_t *arg2, aclFormat arg3) {
    load_library();
    return aclCreateTensorDesc(arg0, arg1, arg2, arg3);
}
static aclTensorDesc _WRAPLIB_API_CALL *aclCreateTensorDesc_error(aclDataType, int, const int64_t *, aclFormat) {
    return on_init_failed<aclTensorDesc *>(9);
}
static void _WRAPLIB_API_CALL aclDestroyTensorDesc_init(const aclTensorDesc *arg0) {
    load_library();
    return aclDestroyTensorDesc(arg0);
}
static void _WRAPLIB_API_CALL aclDestroyTensorDesc_error(const aclTensorDesc *) {
    return on_init_failed<void >(10);
}
static aclError _WRAPLIB_API_CALL aclSetTensorShapeRange_init(aclTensorDesc *arg0, size_t arg1, int64_t arg2[][2]) {
    load_library();
    return aclSetTensorShapeRange(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclSetTensorShapeRange_error(aclTensorDesc *, size_t, int64_t [][2]) {
    return on_init_failed<aclError >(11);
}
static aclError _WRAPLIB_API_CALL aclSetTensorValueRange_init(aclTensorDesc *arg0, size_t arg1, int64_t arg2[][2]) {
    load_library();
    return aclSetTensorValueRange(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclSetTensorValueRange_error(aclTensorDesc *, size_t, int64_t [][2]) {
    return on_init_failed<aclError >(12);
}
static aclDataType _WRAPLIB_API_CALL aclGetTensorDescType_init(const aclTensorDesc *arg0) {
    load_library();
    return aclGetTensorDescType(arg0);
}
static aclDataType _WRAPLIB_API_CALL aclGetTensorDescType_error(const aclTensorDesc *) {
    return on_init_failed<aclDataType >(13);
}
static aclFormat _WRAPLIB_API_CALL aclGetTensorDescFormat_init(const aclTensorDesc *arg0) {
    load_library();
    return aclGetTensorDescFormat(arg0);
}
static aclFormat _WRAPLIB_API_CALL aclGetTensorDescFormat_error(const aclTensorDesc *) {
    return on_init_failed<aclFormat >(14);
}
static size_t _WRAPLIB_API_CALL aclGetTensorDescSize_init(const aclTensorDesc *arg0) {
    load_library();
    return aclGetTensorDescSize(arg0);
}
static size_t _WRAPLIB_API_CALL aclGetTensorDescSize_error(const aclTensorDesc *) {
    return on_init_failed<size_t >(15);
}
static size_t _WRAPLIB_API_CALL aclGetTensorDescElementCount_init(const aclTensorDesc *arg0) {
    load_library();
    return aclGetTensorDescElementCount(arg0);
}
static size_t _WRAPLIB_API_CALL aclGetTensorDescElementCount_error(const aclTensorDesc *) {
    return on_init_failed<size_t >(16);
}
static size_t _WRAPLIB_API_CALL aclGetTensorDescNumDims_init(const aclTensorDesc *arg0) {
    load_library();
    return aclGetTensorDescNumDims(arg0);
}
static size_t _WRAPLIB_API_CALL aclGetTensorDescNumDims_error(const aclTensorDesc *) {
    return on_init_failed<size_t >(17);
}
static int64_t _WRAPLIB_API_CALL aclGetTensorDescDim_init(const aclTensorDesc *arg0, size_t arg1) {
    load_library();
    return aclGetTensorDescDim(arg0, arg1);
}
static int64_t _WRAPLIB_API_CALL aclGetTensorDescDim_error(const aclTensorDesc *, size_t) {
    return on_init_failed<int64_t >(18);
}
static aclError _WRAPLIB_API_CALL aclGetTensorDescDimV2_init(const aclTensorDesc *arg0, size_t arg1, int64_t *arg2) {
    load_library();
    return aclGetTensorDescDimV2(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclGetTensorDescDimV2_error(const aclTensorDesc *, size_t, int64_t *) {
    return on_init_failed<aclError >(19);
}
static aclError _WRAPLIB_API_CALL aclGetTensorDescDimRange_init(const aclTensorDesc *arg0, size_t arg1, size_t arg2, int64_t *arg3) {
    load_library();
    return aclGetTensorDescDimRange(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclGetTensorDescDimRange_error(const aclTensorDesc *, size_t, size_t, int64_t *) {
    return on_init_failed<aclError >(20);
}
static void _WRAPLIB_API_CALL aclSetTensorDescName_init(aclTensorDesc *arg0, const char *arg1) {
    load_library();
    return aclSetTensorDescName(arg0, arg1);
}
static void _WRAPLIB_API_CALL aclSetTensorDescName_error(aclTensorDesc *, const char *) {
    return on_init_failed<void >(21);
}
static const char _WRAPLIB_API_CALL *aclGetTensorDescName_init(aclTensorDesc *arg0) {
    load_library();
    return aclGetTensorDescName(arg0);
}
static const char _WRAPLIB_API_CALL *aclGetTensorDescName_error(aclTensorDesc *) {
    return on_init_failed<const char *>(22);
}
static aclError _WRAPLIB_API_CALL aclTransTensorDescFormat_init(const aclTensorDesc *arg0, aclFormat arg1, aclTensorDesc **arg2) {
    load_library();
    return aclTransTensorDescFormat(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclTransTensorDescFormat_error(const aclTensorDesc *, aclFormat, aclTensorDesc **) {
    return on_init_failed<aclError >(23);
}
static aclError _WRAPLIB_API_CALL aclSetTensorStorageFormat_init(aclTensorDesc *arg0, aclFormat arg1) {
    load_library();
    return aclSetTensorStorageFormat(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclSetTensorStorageFormat_error(aclTensorDesc *, aclFormat) {
    return on_init_failed<aclError >(24);
}
static aclError _WRAPLIB_API_CALL aclSetTensorStorageShape_init(aclTensorDesc *arg0, int arg1, const int64_t *arg2) {
    load_library();
    return aclSetTensorStorageShape(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclSetTensorStorageShape_error(aclTensorDesc *, int, const int64_t *) {
    return on_init_failed<aclError >(25);
}
static aclError _WRAPLIB_API_CALL aclSetTensorFormat_init(aclTensorDesc *arg0, aclFormat arg1) {
    load_library();
    return aclSetTensorFormat(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclSetTensorFormat_error(aclTensorDesc *, aclFormat) {
    return on_init_failed<aclError >(26);
}
static aclError _WRAPLIB_API_CALL aclSetTensorShape_init(aclTensorDesc *arg0, int arg1, const int64_t *arg2) {
    load_library();
    return aclSetTensorShape(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclSetTensorShape_error(aclTensorDesc *, int, const int64_t *) {
    return on_init_failed<aclError >(27);
}
static aclError _WRAPLIB_API_CALL aclSetTensorOriginFormat_init(aclTensorDesc *arg0, aclFormat arg1) {
    load_library();
    return aclSetTensorOriginFormat(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclSetTensorOriginFormat_error(aclTensorDesc *, aclFormat) {
    return on_init_failed<aclError >(28);
}
static aclError _WRAPLIB_API_CALL aclSetTensorOriginShape_init(aclTensorDesc *arg0, int arg1, const int64_t *arg2) {
    load_library();
    return aclSetTensorOriginShape(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclSetTensorOriginShape_error(aclTensorDesc *, int, const int64_t *) {
    return on_init_failed<aclError >(29);
}
static aclTensorDesc _WRAPLIB_API_CALL *aclGetTensorDescByIndex_init(aclTensorDesc *arg0, size_t arg1) {
    load_library();
    return aclGetTensorDescByIndex(arg0, arg1);
}
static aclTensorDesc _WRAPLIB_API_CALL *aclGetTensorDescByIndex_error(aclTensorDesc *, size_t) {
    return on_init_failed<aclTensorDesc *>(30);
}
static void _WRAPLIB_API_CALL *aclGetTensorDescAddress_init(const aclTensorDesc *arg0) {
    load_library();
    return aclGetTensorDescAddress(arg0);
}
static void _WRAPLIB_API_CALL *aclGetTensorDescAddress_error(const aclTensorDesc *) {
    return on_init_failed<void *>(31);
}
static aclError _WRAPLIB_API_CALL aclSetTensorDynamicInput_init(aclTensorDesc *arg0, const char *arg1) {
    load_library();
    return aclSetTensorDynamicInput(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclSetTensorDynamicInput_error(aclTensorDesc *, const char *) {
    return on_init_failed<aclError >(32);
}
static aclError _WRAPLIB_API_CALL aclSetTensorConst_init(aclTensorDesc *arg0, void *arg1, size_t arg2) {
    load_library();
    return aclSetTensorConst(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclSetTensorConst_error(aclTensorDesc *, void *, size_t) {
    return on_init_failed<aclError >(33);
}
static aclError _WRAPLIB_API_CALL aclSetTensorPlaceMent_init(aclTensorDesc *arg0, aclMemType arg1) {
    load_library();
    return aclSetTensorPlaceMent(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclSetTensorPlaceMent_error(aclTensorDesc *, aclMemType) {
    return on_init_failed<aclError >(34);
}
static const char _WRAPLIB_API_CALL *aclrtGetSocName_init() {
    load_library();
    return aclrtGetSocName();
}
static const char _WRAPLIB_API_CALL *aclrtGetSocName_error() {
    return on_init_failed<const char *>(35);
}
static aclError _WRAPLIB_API_CALL aclrtSetExceptionInfoCallback_init(aclrtExceptionInfoCallback arg0) {
    load_library();
    return aclrtSetExceptionInfoCallback(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtSetExceptionInfoCallback_error(aclrtExceptionInfoCallback) {
    return on_init_failed<aclError >(36);
}
static uint32_t _WRAPLIB_API_CALL aclrtGetTaskIdFromExceptionInfo_init(const aclrtExceptionInfo *arg0) {
    load_library();
    return aclrtGetTaskIdFromExceptionInfo(arg0);
}
static uint32_t _WRAPLIB_API_CALL aclrtGetTaskIdFromExceptionInfo_error(const aclrtExceptionInfo *) {
    return on_init_failed<uint32_t >(37);
}
static uint32_t _WRAPLIB_API_CALL aclrtGetStreamIdFromExceptionInfo_init(const aclrtExceptionInfo *arg0) {
    load_library();
    return aclrtGetStreamIdFromExceptionInfo(arg0);
}
static uint32_t _WRAPLIB_API_CALL aclrtGetStreamIdFromExceptionInfo_error(const aclrtExceptionInfo *) {
    return on_init_failed<uint32_t >(38);
}
static uint32_t _WRAPLIB_API_CALL aclrtGetThreadIdFromExceptionInfo_init(const aclrtExceptionInfo *arg0) {
    load_library();
    return aclrtGetThreadIdFromExceptionInfo(arg0);
}
static uint32_t _WRAPLIB_API_CALL aclrtGetThreadIdFromExceptionInfo_error(const aclrtExceptionInfo *) {
    return on_init_failed<uint32_t >(39);
}
static uint32_t _WRAPLIB_API_CALL aclrtGetDeviceIdFromExceptionInfo_init(const aclrtExceptionInfo *arg0) {
    load_library();
    return aclrtGetDeviceIdFromExceptionInfo(arg0);
}
static uint32_t _WRAPLIB_API_CALL aclrtGetDeviceIdFromExceptionInfo_error(const aclrtExceptionInfo *) {
    return on_init_failed<uint32_t >(40);
}
static aclError _WRAPLIB_API_CALL aclrtSubscribeReport_init(uint64_t arg0, aclrtStream arg1) {
    load_library();
    return aclrtSubscribeReport(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtSubscribeReport_error(uint64_t, aclrtStream) {
    return on_init_failed<aclError >(41);
}
static aclError _WRAPLIB_API_CALL aclrtLaunchCallback_init(aclrtCallback arg0, void *arg1, aclrtCallbackBlockType arg2, aclrtStream arg3) {
    load_library();
    return aclrtLaunchCallback(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclrtLaunchCallback_error(aclrtCallback, void *, aclrtCallbackBlockType, aclrtStream) {
    return on_init_failed<aclError >(42);
}
static aclError _WRAPLIB_API_CALL aclrtProcessReport_init(int32_t arg0) {
    load_library();
    return aclrtProcessReport(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtProcessReport_error(int32_t) {
    return on_init_failed<aclError >(43);
}
static aclError _WRAPLIB_API_CALL aclrtUnSubscribeReport_init(uint64_t arg0, aclrtStream arg1) {
    load_library();
    return aclrtUnSubscribeReport(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtUnSubscribeReport_error(uint64_t, aclrtStream) {
    return on_init_failed<aclError >(44);
}
static aclError _WRAPLIB_API_CALL aclrtCreateContext_init(aclrtContext *arg0, int32_t arg1) {
    load_library();
    return aclrtCreateContext(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtCreateContext_error(aclrtContext *, int32_t) {
    return on_init_failed<aclError >(45);
}
static aclError _WRAPLIB_API_CALL aclrtDestroyContext_init(aclrtContext arg0) {
    load_library();
    return aclrtDestroyContext(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtDestroyContext_error(aclrtContext) {
    return on_init_failed<aclError >(46);
}
static aclError _WRAPLIB_API_CALL aclrtSetCurrentContext_init(aclrtContext arg0) {
    load_library();
    return aclrtSetCurrentContext(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtSetCurrentContext_error(aclrtContext) {
    return on_init_failed<aclError >(47);
}
static aclError _WRAPLIB_API_CALL aclrtGetCurrentContext_init(aclrtContext *arg0) {
    load_library();
    return aclrtGetCurrentContext(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtGetCurrentContext_error(aclrtContext *) {
    return on_init_failed<aclError >(48);
}
static aclError _WRAPLIB_API_CALL aclrtSetDevice_init(int32_t arg0) {
    load_library();
    return aclrtSetDevice(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtSetDevice_error(int32_t) {
    return on_init_failed<aclError >(49);
}
static aclError _WRAPLIB_API_CALL aclrtResetDevice_init(int32_t arg0) {
    load_library();
    return aclrtResetDevice(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtResetDevice_error(int32_t) {
    return on_init_failed<aclError >(50);
}
static aclError _WRAPLIB_API_CALL aclrtGetDevice_init(int32_t *arg0) {
    load_library();
    return aclrtGetDevice(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtGetDevice_error(int32_t *) {
    return on_init_failed<aclError >(51);
}
static aclError _WRAPLIB_API_CALL aclrtGetRunMode_init(aclrtRunMode *arg0) {
    load_library();
    return aclrtGetRunMode(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtGetRunMode_error(aclrtRunMode *) {
    return on_init_failed<aclError >(52);
}
static aclError _WRAPLIB_API_CALL aclrtSynchronizeDevice_init() {
    load_library();
    return aclrtSynchronizeDevice();
}
static aclError _WRAPLIB_API_CALL aclrtSynchronizeDevice_error() {
    return on_init_failed<aclError >(53);
}
static aclError _WRAPLIB_API_CALL aclrtSetTsDevice_init(aclrtTsId arg0) {
    load_library();
    return aclrtSetTsDevice(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtSetTsDevice_error(aclrtTsId) {
    return on_init_failed<aclError >(54);
}
static aclError _WRAPLIB_API_CALL aclrtGetDeviceCount_init(uint32_t *arg0) {
    load_library();
    return aclrtGetDeviceCount(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtGetDeviceCount_error(uint32_t *) {
    return on_init_failed<aclError >(55);
}
static aclError _WRAPLIB_API_CALL aclrtCreateEvent_init(aclrtEvent *arg0) {
    load_library();
    return aclrtCreateEvent(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtCreateEvent_error(aclrtEvent *) {
    return on_init_failed<aclError >(56);
}
static aclError _WRAPLIB_API_CALL aclrtCreateEventWithFlag_init(aclrtEvent *arg0, uint32_t arg1) {
    load_library();
    return aclrtCreateEventWithFlag(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtCreateEventWithFlag_error(aclrtEvent *, uint32_t) {
    return on_init_failed<aclError >(57);
}
static aclError _WRAPLIB_API_CALL aclrtDestroyEvent_init(aclrtEvent arg0) {
    load_library();
    return aclrtDestroyEvent(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtDestroyEvent_error(aclrtEvent) {
    return on_init_failed<aclError >(58);
}
static aclError _WRAPLIB_API_CALL aclrtRecordEvent_init(aclrtEvent arg0, aclrtStream arg1) {
    load_library();
    return aclrtRecordEvent(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtRecordEvent_error(aclrtEvent, aclrtStream) {
    return on_init_failed<aclError >(59);
}
static aclError _WRAPLIB_API_CALL aclrtResetEvent_init(aclrtEvent arg0, aclrtStream arg1) {
    load_library();
    return aclrtResetEvent(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtResetEvent_error(aclrtEvent, aclrtStream) {
    return on_init_failed<aclError >(60);
}
static aclError _WRAPLIB_API_CALL aclrtQueryEvent_init(aclrtEvent arg0, aclrtEventStatus *arg1) {
    load_library();
    return aclrtQueryEvent(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtQueryEvent_error(aclrtEvent, aclrtEventStatus *) {
    return on_init_failed<aclError >(61);
}
static aclError _WRAPLIB_API_CALL aclrtQueryEventStatus_init(aclrtEvent arg0, aclrtEventRecordedStatus *arg1) {
    load_library();
    return aclrtQueryEventStatus(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtQueryEventStatus_error(aclrtEvent, aclrtEventRecordedStatus *) {
    return on_init_failed<aclError >(62);
}
static aclError _WRAPLIB_API_CALL aclrtQueryEventWaitStatus_init(aclrtEvent arg0, aclrtEventWaitStatus *arg1) {
    load_library();
    return aclrtQueryEventWaitStatus(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtQueryEventWaitStatus_error(aclrtEvent, aclrtEventWaitStatus *) {
    return on_init_failed<aclError >(63);
}
static aclError _WRAPLIB_API_CALL aclrtSynchronizeEvent_init(aclrtEvent arg0) {
    load_library();
    return aclrtSynchronizeEvent(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtSynchronizeEvent_error(aclrtEvent) {
    return on_init_failed<aclError >(64);
}
static aclError _WRAPLIB_API_CALL aclrtEventElapsedTime_init(float *arg0, aclrtEvent arg1, aclrtEvent arg2) {
    load_library();
    return aclrtEventElapsedTime(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclrtEventElapsedTime_error(float *, aclrtEvent, aclrtEvent) {
    return on_init_failed<aclError >(65);
}
static aclError _WRAPLIB_API_CALL aclrtMalloc_init(void **arg0, size_t arg1, aclrtMemMallocPolicy arg2) {
    load_library();
    return aclrtMalloc(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclrtMalloc_error(void **, size_t, aclrtMemMallocPolicy) {
    return on_init_failed<aclError >(66);
}
static aclError _WRAPLIB_API_CALL aclrtMallocCached_init(void **arg0, size_t arg1, aclrtMemMallocPolicy arg2) {
    load_library();
    return aclrtMallocCached(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclrtMallocCached_error(void **, size_t, aclrtMemMallocPolicy) {
    return on_init_failed<aclError >(67);
}
static aclError _WRAPLIB_API_CALL aclrtMemFlush_init(void *arg0, size_t arg1) {
    load_library();
    return aclrtMemFlush(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtMemFlush_error(void *, size_t) {
    return on_init_failed<aclError >(68);
}
static aclError _WRAPLIB_API_CALL aclrtMemInvalidate_init(void *arg0, size_t arg1) {
    load_library();
    return aclrtMemInvalidate(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtMemInvalidate_error(void *, size_t) {
    return on_init_failed<aclError >(69);
}
static aclError _WRAPLIB_API_CALL aclrtFree_init(void *arg0) {
    load_library();
    return aclrtFree(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtFree_error(void *) {
    return on_init_failed<aclError >(70);
}
static aclError _WRAPLIB_API_CALL aclrtMallocHost_init(void **arg0, size_t arg1) {
    load_library();
    return aclrtMallocHost(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtMallocHost_error(void **, size_t) {
    return on_init_failed<aclError >(71);
}
static aclError _WRAPLIB_API_CALL aclrtFreeHost_init(void *arg0) {
    load_library();
    return aclrtFreeHost(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtFreeHost_error(void *) {
    return on_init_failed<aclError >(72);
}
static aclError _WRAPLIB_API_CALL aclrtMemcpy_init(void *arg0, size_t arg1, const void *arg2, size_t arg3, aclrtMemcpyKind arg4) {
    load_library();
    return aclrtMemcpy(arg0, arg1, arg2, arg3, arg4);
}
static aclError _WRAPLIB_API_CALL aclrtMemcpy_error(void *, size_t, const void *, size_t, aclrtMemcpyKind) {
    return on_init_failed<aclError >(73);
}
static aclError _WRAPLIB_API_CALL aclrtMemset_init(void *arg0, size_t arg1, int32_t arg2, size_t arg3) {
    load_library();
    return aclrtMemset(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclrtMemset_error(void *, size_t, int32_t, size_t) {
    return on_init_failed<aclError >(74);
}
static aclError _WRAPLIB_API_CALL aclrtMemcpyAsync_init(void *arg0, size_t arg1, const void *arg2, size_t arg3, aclrtMemcpyKind arg4, aclrtStream arg5) {
    load_library();
    return aclrtMemcpyAsync(arg0, arg1, arg2, arg3, arg4, arg5);
}
static aclError _WRAPLIB_API_CALL aclrtMemcpyAsync_error(void *, size_t, const void *, size_t, aclrtMemcpyKind, aclrtStream) {
    return on_init_failed<aclError >(75);
}
static aclError _WRAPLIB_API_CALL aclrtMemcpy2d_init(void *arg0, size_t arg1, const void *arg2, size_t arg3, size_t arg4, size_t arg5, aclrtMemcpyKind arg6) {
    load_library();
    return aclrtMemcpy2d(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static aclError _WRAPLIB_API_CALL aclrtMemcpy2d_error(void *, size_t, const void *, size_t, size_t, size_t, aclrtMemcpyKind) {
    return on_init_failed<aclError >(76);
}
static aclError _WRAPLIB_API_CALL aclrtMemcpy2dAsync_init(void *arg0, size_t arg1, const void *arg2, size_t arg3, size_t arg4, size_t arg5, aclrtMemcpyKind arg6, aclrtStream arg7) {
    load_library();
    return aclrtMemcpy2dAsync(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
static aclError _WRAPLIB_API_CALL aclrtMemcpy2dAsync_error(void *, size_t, const void *, size_t, size_t, size_t, aclrtMemcpyKind, aclrtStream) {
    return on_init_failed<aclError >(77);
}
static aclError _WRAPLIB_API_CALL aclrtMemsetAsync_init(void *arg0, size_t arg1, int32_t arg2, size_t arg3, aclrtStream arg4) {
    load_library();
    return aclrtMemsetAsync(arg0, arg1, arg2, arg3, arg4);
}
static aclError _WRAPLIB_API_CALL aclrtMemsetAsync_error(void *, size_t, int32_t, size_t, aclrtStream) {
    return on_init_failed<aclError >(78);
}
static aclError _WRAPLIB_API_CALL aclrtCreateStream_init(aclrtStream *arg0) {
    load_library();
    return aclrtCreateStream(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtCreateStream_error(aclrtStream *) {
    return on_init_failed<aclError >(79);
}
static aclError _WRAPLIB_API_CALL aclrtDestroyStream_init(aclrtStream arg0) {
    load_library();
    return aclrtDestroyStream(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtDestroyStream_error(aclrtStream) {
    return on_init_failed<aclError >(80);
}
static aclError _WRAPLIB_API_CALL aclrtSynchronizeStream_init(aclrtStream arg0) {
    load_library();
    return aclrtSynchronizeStream(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtSynchronizeStream_error(aclrtStream) {
    return on_init_failed<aclError >(81);
}
static aclError _WRAPLIB_API_CALL aclrtStreamWaitEvent_init(aclrtStream arg0, aclrtEvent arg1) {
    load_library();
    return aclrtStreamWaitEvent(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtStreamWaitEvent_error(aclrtStream, aclrtEvent) {
    return on_init_failed<aclError >(82);
}
static aclError _WRAPLIB_API_CALL aclrtSetGroup_init(int32_t arg0) {
    load_library();
    return aclrtSetGroup(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtSetGroup_error(int32_t) {
    return on_init_failed<aclError >(83);
}
static aclError _WRAPLIB_API_CALL aclrtGetGroupCount_init(uint32_t *arg0) {
    load_library();
    return aclrtGetGroupCount(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtGetGroupCount_error(uint32_t *) {
    return on_init_failed<aclError >(84);
}
static aclrtGroupInfo _WRAPLIB_API_CALL *aclrtCreateGroupInfo_init() {
    load_library();
    return aclrtCreateGroupInfo();
}
static aclrtGroupInfo _WRAPLIB_API_CALL *aclrtCreateGroupInfo_error() {
    return on_init_failed<aclrtGroupInfo *>(85);
}
static aclError _WRAPLIB_API_CALL aclrtDestroyGroupInfo_init(aclrtGroupInfo *arg0) {
    load_library();
    return aclrtDestroyGroupInfo(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtDestroyGroupInfo_error(aclrtGroupInfo *) {
    return on_init_failed<aclError >(86);
}
static aclError _WRAPLIB_API_CALL aclrtGetAllGroupInfo_init(aclrtGroupInfo *arg0) {
    load_library();
    return aclrtGetAllGroupInfo(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtGetAllGroupInfo_error(aclrtGroupInfo *) {
    return on_init_failed<aclError >(87);
}
static aclError _WRAPLIB_API_CALL aclrtGetGroupInfoDetail_init(const aclrtGroupInfo *arg0, int32_t arg1, aclrtGroupAttr arg2, void *arg3, size_t arg4, size_t *arg5) {
    load_library();
    return aclrtGetGroupInfoDetail(arg0, arg1, arg2, arg3, arg4, arg5);
}
static aclError _WRAPLIB_API_CALL aclrtGetGroupInfoDetail_error(const aclrtGroupInfo *, int32_t, aclrtGroupAttr, void *, size_t, size_t *) {
    return on_init_failed<aclError >(88);
}
static aclError _WRAPLIB_API_CALL aclrtDeviceCanAccessPeer_init(int32_t *arg0, int32_t arg1, int32_t arg2) {
    load_library();
    return aclrtDeviceCanAccessPeer(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclrtDeviceCanAccessPeer_error(int32_t *, int32_t, int32_t) {
    return on_init_failed<aclError >(89);
}
static aclError _WRAPLIB_API_CALL aclrtDeviceEnablePeerAccess_init(int32_t arg0, uint32_t arg1) {
    load_library();
    return aclrtDeviceEnablePeerAccess(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclrtDeviceEnablePeerAccess_error(int32_t, uint32_t) {
    return on_init_failed<aclError >(90);
}
static aclError _WRAPLIB_API_CALL aclrtDeviceDisablePeerAccess_init(int32_t arg0) {
    load_library();
    return aclrtDeviceDisablePeerAccess(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtDeviceDisablePeerAccess_error(int32_t) {
    return on_init_failed<aclError >(91);
}
static aclError _WRAPLIB_API_CALL aclrtGetMemInfo_init(aclrtMemAttr arg0, size_t *arg1, size_t *arg2) {
    load_library();
    return aclrtGetMemInfo(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclrtGetMemInfo_error(aclrtMemAttr, size_t *, size_t *) {
    return on_init_failed<aclError >(92);
}
static aclError _WRAPLIB_API_CALL aclrtSetOpWaitTimeout_init(uint32_t arg0) {
    load_library();
    return aclrtSetOpWaitTimeout(arg0);
}
static aclError _WRAPLIB_API_CALL aclrtSetOpWaitTimeout_error(uint32_t) {
    return on_init_failed<aclError >(93);
}
static aclError _WRAPLIB_API_CALL aclopSetModelDir_init(const char *arg0) {
    load_library();
    return aclopSetModelDir(arg0);
}
static aclError _WRAPLIB_API_CALL aclopSetModelDir_error(const char *) {
    return on_init_failed<aclError >(94);
}
static aclError _WRAPLIB_API_CALL aclopLoad_init(const void *arg0, size_t arg1) {
    load_library();
    return aclopLoad(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclopLoad_error(const void *, size_t) {
    return on_init_failed<aclError >(95);
}
static aclopAttr _WRAPLIB_API_CALL *aclopCreateAttr_init() {
    load_library();
    return aclopCreateAttr();
}
static aclopAttr _WRAPLIB_API_CALL *aclopCreateAttr_error() {
    return on_init_failed<aclopAttr *>(96);
}
static void _WRAPLIB_API_CALL aclopDestroyAttr_init(const aclopAttr *arg0) {
    load_library();
    return aclopDestroyAttr(arg0);
}
static void _WRAPLIB_API_CALL aclopDestroyAttr_error(const aclopAttr *) {
    return on_init_failed<void >(97);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrBool_init(aclopAttr *arg0, const char *arg1, uint8_t arg2) {
    load_library();
    return aclopSetAttrBool(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrBool_error(aclopAttr *, const char *, uint8_t) {
    return on_init_failed<aclError >(98);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrInt_init(aclopAttr *arg0, const char *arg1, int64_t arg2) {
    load_library();
    return aclopSetAttrInt(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrInt_error(aclopAttr *, const char *, int64_t) {
    return on_init_failed<aclError >(99);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrFloat_init(aclopAttr *arg0, const char *arg1, float arg2) {
    load_library();
    return aclopSetAttrFloat(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrFloat_error(aclopAttr *, const char *, float) {
    return on_init_failed<aclError >(100);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrString_init(aclopAttr *arg0, const char *arg1, const char *arg2) {
    load_library();
    return aclopSetAttrString(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrString_error(aclopAttr *, const char *, const char *) {
    return on_init_failed<aclError >(101);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrDataType_init(aclopAttr *arg0, const char *arg1, aclDataType arg2) {
    load_library();
    return aclopSetAttrDataType(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrDataType_error(aclopAttr *, const char *, aclDataType) {
    return on_init_failed<aclError >(102);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListDataType_init(aclopAttr *arg0, const char *arg1, int arg2, const aclDataType arg3[]) {
    load_library();
    return aclopSetAttrListDataType(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListDataType_error(aclopAttr *, const char *, int, const aclDataType []) {
    return on_init_failed<aclError >(103);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListBool_init(aclopAttr *arg0, const char *arg1, int arg2, const uint8_t *arg3) {
    load_library();
    return aclopSetAttrListBool(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListBool_error(aclopAttr *, const char *, int, const uint8_t *) {
    return on_init_failed<aclError >(104);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListInt_init(aclopAttr *arg0, const char *arg1, int arg2, const int64_t *arg3) {
    load_library();
    return aclopSetAttrListInt(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListInt_error(aclopAttr *, const char *, int, const int64_t *) {
    return on_init_failed<aclError >(105);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListFloat_init(aclopAttr *arg0, const char *arg1, int arg2, const float *arg3) {
    load_library();
    return aclopSetAttrListFloat(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListFloat_error(aclopAttr *, const char *, int, const float *) {
    return on_init_failed<aclError >(106);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListString_init(aclopAttr *arg0, const char *arg1, int arg2, const char **arg3) {
    load_library();
    return aclopSetAttrListString(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListString_error(aclopAttr *, const char *, int, const char **) {
    return on_init_failed<aclError >(107);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListListInt_init(aclopAttr *arg0, const char *arg1, int arg2, const int *arg3, const int64_t * const arg4[]) {
    load_library();
    return aclopSetAttrListListInt(arg0, arg1, arg2, arg3, arg4);
}
static aclError _WRAPLIB_API_CALL aclopSetAttrListListInt_error(aclopAttr *, const char *, int, const int *, const int64_t * const []) {
    return on_init_failed<aclError >(108);
}
static aclError _WRAPLIB_API_CALL aclopExecute_init(const char *arg0, int arg1, const aclTensorDesc * const arg2[], const aclDataBuffer * const arg3[], int arg4, const aclTensorDesc * const arg5[], aclDataBuffer * const arg6[], const aclopAttr *arg7, aclrtStream arg8) {
    load_library();
    return aclopExecute(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
static aclError _WRAPLIB_API_CALL aclopExecute_error(const char *, int, const aclTensorDesc * const [], const aclDataBuffer * const [], int, const aclTensorDesc * const [], aclDataBuffer * const [], const aclopAttr *, aclrtStream) {
    return on_init_failed<aclError >(109);
}
static aclError _WRAPLIB_API_CALL aclopExecuteV2_init(const char *arg0, int arg1, aclTensorDesc *arg2[], aclDataBuffer *arg3[], int arg4, aclTensorDesc *arg5[], aclDataBuffer *arg6[], aclopAttr *arg7, aclrtStream arg8) {
    load_library();
    return aclopExecuteV2(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
static aclError _WRAPLIB_API_CALL aclopExecuteV2_error(const char *, int, aclTensorDesc *[], aclDataBuffer *[], int, aclTensorDesc *[], aclDataBuffer *[], aclopAttr *, aclrtStream) {
    return on_init_failed<aclError >(110);
}
static aclError _WRAPLIB_API_CALL aclopCreateHandle_init(const char *arg0, int arg1, const aclTensorDesc * const arg2[], int arg3, const aclTensorDesc * const arg4[], const aclopAttr *arg5, aclopHandle **arg6) {
    load_library();
    return aclopCreateHandle(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static aclError _WRAPLIB_API_CALL aclopCreateHandle_error(const char *, int, const aclTensorDesc * const [], int, const aclTensorDesc * const [], const aclopAttr *, aclopHandle **) {
    return on_init_failed<aclError >(111);
}
static void _WRAPLIB_API_CALL aclopDestroyHandle_init(aclopHandle *arg0) {
    load_library();
    return aclopDestroyHandle(arg0);
}
static void _WRAPLIB_API_CALL aclopDestroyHandle_error(aclopHandle *) {
    return on_init_failed<void >(112);
}
static aclError _WRAPLIB_API_CALL aclopExecWithHandle_init(aclopHandle *arg0, int arg1, const aclDataBuffer * const arg2[], int arg3, aclDataBuffer * const arg4[], aclrtStream arg5) {
    load_library();
    return aclopExecWithHandle(arg0, arg1, arg2, arg3, arg4, arg5);
}
static aclError _WRAPLIB_API_CALL aclopExecWithHandle_error(aclopHandle *, int, const aclDataBuffer * const [], int, aclDataBuffer * const [], aclrtStream) {
    return on_init_failed<aclError >(113);
}
static aclError _WRAPLIB_API_CALL aclopCast_init(const aclTensorDesc *arg0, const aclDataBuffer *arg1, const aclTensorDesc *arg2, aclDataBuffer *arg3, uint8_t arg4, aclrtStream arg5) {
    load_library();
    return aclopCast(arg0, arg1, arg2, arg3, arg4, arg5);
}
static aclError _WRAPLIB_API_CALL aclopCast_error(const aclTensorDesc *, const aclDataBuffer *, const aclTensorDesc *, aclDataBuffer *, uint8_t, aclrtStream) {
    return on_init_failed<aclError >(114);
}
static aclError _WRAPLIB_API_CALL aclopCreateHandleForCast_init(aclTensorDesc *arg0, aclTensorDesc *arg1, uint8_t arg2, aclopHandle **arg3) {
    load_library();
    return aclopCreateHandleForCast(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclopCreateHandleForCast_error(aclTensorDesc *, aclTensorDesc *, uint8_t, aclopHandle **) {
    return on_init_failed<aclError >(115);
}
static aclError _WRAPLIB_API_CALL aclopCreateKernel_init(const char *arg0, const char *arg1, const char *arg2, void *arg3, int arg4, aclopEngineType arg5, aclDataDeallocator arg6) {
    load_library();
    return aclopCreateKernel(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static aclError _WRAPLIB_API_CALL aclopCreateKernel_error(const char *, const char *, const char *, void *, int, aclopEngineType, aclDataDeallocator) {
    return on_init_failed<aclError >(116);
}
static aclError _WRAPLIB_API_CALL aclopRegisterCompileFunc_init(const char *arg0, aclopCompileFunc arg1) {
    load_library();
    return aclopRegisterCompileFunc(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclopRegisterCompileFunc_error(const char *, aclopCompileFunc) {
    return on_init_failed<aclError >(117);
}
static aclError _WRAPLIB_API_CALL aclopUnregisterCompileFunc_init(const char *arg0) {
    load_library();
    return aclopUnregisterCompileFunc(arg0);
}
static aclError _WRAPLIB_API_CALL aclopUnregisterCompileFunc_error(const char *) {
    return on_init_failed<aclError >(118);
}
static aclError _WRAPLIB_API_CALL aclopSetKernelArgs_init(aclopKernelDesc *arg0, const char *arg1, uint32_t arg2, const void *arg3, uint32_t arg4) {
    load_library();
    return aclopSetKernelArgs(arg0, arg1, arg2, arg3, arg4);
}
static aclError _WRAPLIB_API_CALL aclopSetKernelArgs_error(aclopKernelDesc *, const char *, uint32_t, const void *, uint32_t) {
    return on_init_failed<aclError >(119);
}
static aclError _WRAPLIB_API_CALL aclopSetKernelWorkspaceSizes_init(aclopKernelDesc *arg0, int arg1, size_t *arg2) {
    load_library();
    return aclopSetKernelWorkspaceSizes(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclopSetKernelWorkspaceSizes_error(aclopKernelDesc *, int, size_t *) {
    return on_init_failed<aclError >(120);
}
static aclError _WRAPLIB_API_CALL aclopUpdateParams_init(const char *arg0, int arg1, const aclTensorDesc * const arg2[], int arg3, const aclTensorDesc * const arg4[], const aclopAttr *arg5) {
    load_library();
    return aclopUpdateParams(arg0, arg1, arg2, arg3, arg4, arg5);
}
static aclError _WRAPLIB_API_CALL aclopUpdateParams_error(const char *, int, const aclTensorDesc * const [], int, const aclTensorDesc * const [], const aclopAttr *) {
    return on_init_failed<aclError >(121);
}
static aclError _WRAPLIB_API_CALL aclopInferShape_init(const char *arg0, int arg1, aclTensorDesc *arg2[], aclDataBuffer *arg3[], int arg4, aclTensorDesc *arg5[], aclopAttr *arg6) {
    load_library();
    return aclopInferShape(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static aclError _WRAPLIB_API_CALL aclopInferShape_error(const char *, int, aclTensorDesc *[], aclDataBuffer *[], int, aclTensorDesc *[], aclopAttr *) {
    return on_init_failed<aclError >(122);
}
static aclmdlDesc _WRAPLIB_API_CALL *aclmdlCreateDesc_init() {
    load_library();
    return aclmdlCreateDesc();
}
static aclmdlDesc _WRAPLIB_API_CALL *aclmdlCreateDesc_error() {
    return on_init_failed<aclmdlDesc *>(123);
}
static aclError _WRAPLIB_API_CALL aclmdlDestroyDesc_init(aclmdlDesc *arg0) {
    load_library();
    return aclmdlDestroyDesc(arg0);
}
static aclError _WRAPLIB_API_CALL aclmdlDestroyDesc_error(aclmdlDesc *) {
    return on_init_failed<aclError >(124);
}
static aclError _WRAPLIB_API_CALL aclmdlGetDesc_init(aclmdlDesc *arg0, uint32_t arg1) {
    load_library();
    return aclmdlGetDesc(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclmdlGetDesc_error(aclmdlDesc *, uint32_t) {
    return on_init_failed<aclError >(125);
}
static size_t _WRAPLIB_API_CALL aclmdlGetNumInputs_init(aclmdlDesc *arg0) {
    load_library();
    return aclmdlGetNumInputs(arg0);
}
static size_t _WRAPLIB_API_CALL aclmdlGetNumInputs_error(aclmdlDesc *) {
    return on_init_failed<size_t >(126);
}
static size_t _WRAPLIB_API_CALL aclmdlGetNumOutputs_init(aclmdlDesc *arg0) {
    load_library();
    return aclmdlGetNumOutputs(arg0);
}
static size_t _WRAPLIB_API_CALL aclmdlGetNumOutputs_error(aclmdlDesc *) {
    return on_init_failed<size_t >(127);
}
static size_t _WRAPLIB_API_CALL aclmdlGetInputSizeByIndex_init(aclmdlDesc *arg0, size_t arg1) {
    load_library();
    return aclmdlGetInputSizeByIndex(arg0, arg1);
}
static size_t _WRAPLIB_API_CALL aclmdlGetInputSizeByIndex_error(aclmdlDesc *, size_t) {
    return on_init_failed<size_t >(128);
}
static size_t _WRAPLIB_API_CALL aclmdlGetOutputSizeByIndex_init(aclmdlDesc *arg0, size_t arg1) {
    load_library();
    return aclmdlGetOutputSizeByIndex(arg0, arg1);
}
static size_t _WRAPLIB_API_CALL aclmdlGetOutputSizeByIndex_error(aclmdlDesc *, size_t) {
    return on_init_failed<size_t >(129);
}
static aclmdlDataset _WRAPLIB_API_CALL *aclmdlCreateDataset_init() {
    load_library();
    return aclmdlCreateDataset();
}
static aclmdlDataset _WRAPLIB_API_CALL *aclmdlCreateDataset_error() {
    return on_init_failed<aclmdlDataset *>(130);
}
static aclError _WRAPLIB_API_CALL aclmdlDestroyDataset_init(const aclmdlDataset *arg0) {
    load_library();
    return aclmdlDestroyDataset(arg0);
}
static aclError _WRAPLIB_API_CALL aclmdlDestroyDataset_error(const aclmdlDataset *) {
    return on_init_failed<aclError >(131);
}
static aclError _WRAPLIB_API_CALL aclmdlAddDatasetBuffer_init(aclmdlDataset *arg0, aclDataBuffer *arg1) {
    load_library();
    return aclmdlAddDatasetBuffer(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclmdlAddDatasetBuffer_error(aclmdlDataset *, aclDataBuffer *) {
    return on_init_failed<aclError >(132);
}
static aclError _WRAPLIB_API_CALL aclmdlSetDatasetTensorDesc_init(aclmdlDataset *arg0, aclTensorDesc *arg1, size_t arg2) {
    load_library();
    return aclmdlSetDatasetTensorDesc(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlSetDatasetTensorDesc_error(aclmdlDataset *, aclTensorDesc *, size_t) {
    return on_init_failed<aclError >(133);
}
static aclTensorDesc _WRAPLIB_API_CALL *aclmdlGetDatasetTensorDesc_init(const aclmdlDataset *arg0, size_t arg1) {
    load_library();
    return aclmdlGetDatasetTensorDesc(arg0, arg1);
}
static aclTensorDesc _WRAPLIB_API_CALL *aclmdlGetDatasetTensorDesc_error(const aclmdlDataset *, size_t) {
    return on_init_failed<aclTensorDesc *>(134);
}
static size_t _WRAPLIB_API_CALL aclmdlGetDatasetNumBuffers_init(const aclmdlDataset *arg0) {
    load_library();
    return aclmdlGetDatasetNumBuffers(arg0);
}
static size_t _WRAPLIB_API_CALL aclmdlGetDatasetNumBuffers_error(const aclmdlDataset *) {
    return on_init_failed<size_t >(135);
}
static aclDataBuffer _WRAPLIB_API_CALL *aclmdlGetDatasetBuffer_init(const aclmdlDataset *arg0, size_t arg1) {
    load_library();
    return aclmdlGetDatasetBuffer(arg0, arg1);
}
static aclDataBuffer _WRAPLIB_API_CALL *aclmdlGetDatasetBuffer_error(const aclmdlDataset *, size_t) {
    return on_init_failed<aclDataBuffer *>(136);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromFile_init(const char *arg0, uint32_t *arg1) {
    load_library();
    return aclmdlLoadFromFile(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromFile_error(const char *, uint32_t *) {
    return on_init_failed<aclError >(137);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromMem_init(const void *arg0, size_t arg1, uint32_t *arg2) {
    load_library();
    return aclmdlLoadFromMem(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromMem_error(const void *, size_t, uint32_t *) {
    return on_init_failed<aclError >(138);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromFileWithMem_init(const char *arg0, uint32_t *arg1, void *arg2, size_t arg3, void *arg4, size_t arg5) {
    load_library();
    return aclmdlLoadFromFileWithMem(arg0, arg1, arg2, arg3, arg4, arg5);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromFileWithMem_error(const char *, uint32_t *, void *, size_t, void *, size_t) {
    return on_init_failed<aclError >(139);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromMemWithMem_init(const void *arg0, size_t arg1, uint32_t *arg2, void *arg3, size_t arg4, void *arg5, size_t arg6) {
    load_library();
    return aclmdlLoadFromMemWithMem(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromMemWithMem_error(const void *, size_t, uint32_t *, void *, size_t, void *, size_t) {
    return on_init_failed<aclError >(140);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromFileWithQ_init(const char *arg0, uint32_t *arg1, const uint32_t *arg2, size_t arg3, const uint32_t *arg4, size_t arg5) {
    load_library();
    return aclmdlLoadFromFileWithQ(arg0, arg1, arg2, arg3, arg4, arg5);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromFileWithQ_error(const char *, uint32_t *, const uint32_t *, size_t, const uint32_t *, size_t) {
    return on_init_failed<aclError >(141);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromMemWithQ_init(const void *arg0, size_t arg1, uint32_t *arg2, const uint32_t *arg3, size_t arg4, const uint32_t *arg5, size_t arg6) {
    load_library();
    return aclmdlLoadFromMemWithQ(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadFromMemWithQ_error(const void *, size_t, uint32_t *, const uint32_t *, size_t, const uint32_t *, size_t) {
    return on_init_failed<aclError >(142);
}
static aclError _WRAPLIB_API_CALL aclmdlExecute_init(uint32_t arg0, const aclmdlDataset *arg1, aclmdlDataset *arg2) {
    load_library();
    return aclmdlExecute(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlExecute_error(uint32_t, const aclmdlDataset *, aclmdlDataset *) {
    return on_init_failed<aclError >(143);
}
static aclError _WRAPLIB_API_CALL aclmdlExecuteAsync_init(uint32_t arg0, const aclmdlDataset *arg1, aclmdlDataset *arg2, aclrtStream arg3) {
    load_library();
    return aclmdlExecuteAsync(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclmdlExecuteAsync_error(uint32_t, const aclmdlDataset *, aclmdlDataset *, aclrtStream) {
    return on_init_failed<aclError >(144);
}
static aclError _WRAPLIB_API_CALL aclmdlUnload_init(uint32_t arg0) {
    load_library();
    return aclmdlUnload(arg0);
}
static aclError _WRAPLIB_API_CALL aclmdlUnload_error(uint32_t) {
    return on_init_failed<aclError >(145);
}
static aclError _WRAPLIB_API_CALL aclmdlQuerySize_init(const char *arg0, size_t *arg1, size_t *arg2) {
    load_library();
    return aclmdlQuerySize(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlQuerySize_error(const char *, size_t *, size_t *) {
    return on_init_failed<aclError >(146);
}
static aclError _WRAPLIB_API_CALL aclmdlQuerySizeFromMem_init(const void *arg0, size_t arg1, size_t *arg2, size_t *arg3) {
    load_library();
    return aclmdlQuerySizeFromMem(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclmdlQuerySizeFromMem_error(const void *, size_t, size_t *, size_t *) {
    return on_init_failed<aclError >(147);
}
static aclError _WRAPLIB_API_CALL aclmdlSetDynamicBatchSize_init(uint32_t arg0, aclmdlDataset *arg1, size_t arg2, uint64_t arg3) {
    load_library();
    return aclmdlSetDynamicBatchSize(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclmdlSetDynamicBatchSize_error(uint32_t, aclmdlDataset *, size_t, uint64_t) {
    return on_init_failed<aclError >(148);
}
static aclError _WRAPLIB_API_CALL aclmdlSetDynamicHWSize_init(uint32_t arg0, aclmdlDataset *arg1, size_t arg2, uint64_t arg3, uint64_t arg4) {
    load_library();
    return aclmdlSetDynamicHWSize(arg0, arg1, arg2, arg3, arg4);
}
static aclError _WRAPLIB_API_CALL aclmdlSetDynamicHWSize_error(uint32_t, aclmdlDataset *, size_t, uint64_t, uint64_t) {
    return on_init_failed<aclError >(149);
}
static aclError _WRAPLIB_API_CALL aclmdlSetInputDynamicDims_init(uint32_t arg0, aclmdlDataset *arg1, size_t arg2, const aclmdlIODims *arg3) {
    load_library();
    return aclmdlSetInputDynamicDims(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclmdlSetInputDynamicDims_error(uint32_t, aclmdlDataset *, size_t, const aclmdlIODims *) {
    return on_init_failed<aclError >(150);
}
static aclError _WRAPLIB_API_CALL aclmdlGetInputDims_init(const aclmdlDesc *arg0, size_t arg1, aclmdlIODims *arg2) {
    load_library();
    return aclmdlGetInputDims(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlGetInputDims_error(const aclmdlDesc *, size_t, aclmdlIODims *) {
    return on_init_failed<aclError >(151);
}
static aclError _WRAPLIB_API_CALL aclmdlGetInputDimsV2_init(const aclmdlDesc *arg0, size_t arg1, aclmdlIODims *arg2) {
    load_library();
    return aclmdlGetInputDimsV2(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlGetInputDimsV2_error(const aclmdlDesc *, size_t, aclmdlIODims *) {
    return on_init_failed<aclError >(152);
}
static aclError _WRAPLIB_API_CALL aclmdlGetOutputDims_init(const aclmdlDesc *arg0, size_t arg1, aclmdlIODims *arg2) {
    load_library();
    return aclmdlGetOutputDims(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlGetOutputDims_error(const aclmdlDesc *, size_t, aclmdlIODims *) {
    return on_init_failed<aclError >(153);
}
static aclError _WRAPLIB_API_CALL aclmdlGetCurOutputDims_init(const aclmdlDesc *arg0, size_t arg1, aclmdlIODims *arg2) {
    load_library();
    return aclmdlGetCurOutputDims(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlGetCurOutputDims_error(const aclmdlDesc *, size_t, aclmdlIODims *) {
    return on_init_failed<aclError >(154);
}
static const char _WRAPLIB_API_CALL *aclmdlGetOpAttr_init(aclmdlDesc *arg0, const char *arg1, const char *arg2) {
    load_library();
    return aclmdlGetOpAttr(arg0, arg1, arg2);
}
static const char _WRAPLIB_API_CALL *aclmdlGetOpAttr_error(aclmdlDesc *, const char *, const char *) {
    return on_init_failed<const char *>(155);
}
static const char _WRAPLIB_API_CALL *aclmdlGetInputNameByIndex_init(const aclmdlDesc *arg0, size_t arg1) {
    load_library();
    return aclmdlGetInputNameByIndex(arg0, arg1);
}
static const char _WRAPLIB_API_CALL *aclmdlGetInputNameByIndex_error(const aclmdlDesc *, size_t) {
    return on_init_failed<const char *>(156);
}
static const char _WRAPLIB_API_CALL *aclmdlGetOutputNameByIndex_init(const aclmdlDesc *arg0, size_t arg1) {
    load_library();
    return aclmdlGetOutputNameByIndex(arg0, arg1);
}
static const char _WRAPLIB_API_CALL *aclmdlGetOutputNameByIndex_error(const aclmdlDesc *, size_t) {
    return on_init_failed<const char *>(157);
}
static aclFormat _WRAPLIB_API_CALL aclmdlGetInputFormat_init(const aclmdlDesc *arg0, size_t arg1) {
    load_library();
    return aclmdlGetInputFormat(arg0, arg1);
}
static aclFormat _WRAPLIB_API_CALL aclmdlGetInputFormat_error(const aclmdlDesc *, size_t) {
    return on_init_failed<aclFormat >(158);
}
static aclFormat _WRAPLIB_API_CALL aclmdlGetOutputFormat_init(const aclmdlDesc *arg0, size_t arg1) {
    load_library();
    return aclmdlGetOutputFormat(arg0, arg1);
}
static aclFormat _WRAPLIB_API_CALL aclmdlGetOutputFormat_error(const aclmdlDesc *, size_t) {
    return on_init_failed<aclFormat >(159);
}
static aclDataType _WRAPLIB_API_CALL aclmdlGetInputDataType_init(const aclmdlDesc *arg0, size_t arg1) {
    load_library();
    return aclmdlGetInputDataType(arg0, arg1);
}
static aclDataType _WRAPLIB_API_CALL aclmdlGetInputDataType_error(const aclmdlDesc *, size_t) {
    return on_init_failed<aclDataType >(160);
}
static aclDataType _WRAPLIB_API_CALL aclmdlGetOutputDataType_init(const aclmdlDesc *arg0, size_t arg1) {
    load_library();
    return aclmdlGetOutputDataType(arg0, arg1);
}
static aclDataType _WRAPLIB_API_CALL aclmdlGetOutputDataType_error(const aclmdlDesc *, size_t) {
    return on_init_failed<aclDataType >(161);
}
static aclError _WRAPLIB_API_CALL aclmdlGetInputIndexByName_init(const aclmdlDesc *arg0, const char *arg1, size_t *arg2) {
    load_library();
    return aclmdlGetInputIndexByName(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlGetInputIndexByName_error(const aclmdlDesc *, const char *, size_t *) {
    return on_init_failed<aclError >(162);
}
static aclError _WRAPLIB_API_CALL aclmdlGetOutputIndexByName_init(const aclmdlDesc *arg0, const char *arg1, size_t *arg2) {
    load_library();
    return aclmdlGetOutputIndexByName(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlGetOutputIndexByName_error(const aclmdlDesc *, const char *, size_t *) {
    return on_init_failed<aclError >(163);
}
static aclError _WRAPLIB_API_CALL aclmdlGetDynamicBatch_init(const aclmdlDesc *arg0, aclmdlBatch *arg1) {
    load_library();
    return aclmdlGetDynamicBatch(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclmdlGetDynamicBatch_error(const aclmdlDesc *, aclmdlBatch *) {
    return on_init_failed<aclError >(164);
}
static aclError _WRAPLIB_API_CALL aclmdlGetDynamicHW_init(const aclmdlDesc *arg0, size_t arg1, aclmdlHW *arg2) {
    load_library();
    return aclmdlGetDynamicHW(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlGetDynamicHW_error(const aclmdlDesc *, size_t, aclmdlHW *) {
    return on_init_failed<aclError >(165);
}
static aclError _WRAPLIB_API_CALL aclmdlGetInputDynamicGearCount_init(const aclmdlDesc *arg0, size_t arg1, size_t *arg2) {
    load_library();
    return aclmdlGetInputDynamicGearCount(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlGetInputDynamicGearCount_error(const aclmdlDesc *, size_t, size_t *) {
    return on_init_failed<aclError >(166);
}
static aclError _WRAPLIB_API_CALL aclmdlGetInputDynamicDims_init(const aclmdlDesc *arg0, size_t arg1, aclmdlIODims *arg2, size_t arg3) {
    load_library();
    return aclmdlGetInputDynamicDims(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclmdlGetInputDynamicDims_error(const aclmdlDesc *, size_t, aclmdlIODims *, size_t) {
    return on_init_failed<aclError >(167);
}
static aclmdlAIPP _WRAPLIB_API_CALL *aclmdlCreateAIPP_init(uint64_t arg0) {
    load_library();
    return aclmdlCreateAIPP(arg0);
}
static aclmdlAIPP _WRAPLIB_API_CALL *aclmdlCreateAIPP_error(uint64_t) {
    return on_init_failed<aclmdlAIPP *>(168);
}
static aclError _WRAPLIB_API_CALL aclmdlDestroyAIPP_init(const aclmdlAIPP *arg0) {
    load_library();
    return aclmdlDestroyAIPP(arg0);
}
static aclError _WRAPLIB_API_CALL aclmdlDestroyAIPP_error(const aclmdlAIPP *) {
    return on_init_failed<aclError >(169);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPInputFormat_init(aclmdlAIPP *arg0, aclAippInputFormat arg1) {
    load_library();
    return aclmdlSetAIPPInputFormat(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPInputFormat_error(aclmdlAIPP *, aclAippInputFormat) {
    return on_init_failed<aclError >(170);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPCscParams_init(aclmdlAIPP *arg0, int8_t arg1, int16_t arg2, int16_t arg3, int16_t arg4, int16_t arg5, int16_t arg6, int16_t arg7, int16_t arg8, int16_t arg9, int16_t arg10, uint8_t arg11, uint8_t arg12, uint8_t arg13, uint8_t arg14, uint8_t arg15, uint8_t arg16) {
    load_library();
    return aclmdlSetAIPPCscParams(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPCscParams_error(aclmdlAIPP *, int8_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t) {
    return on_init_failed<aclError >(171);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPRbuvSwapSwitch_init(aclmdlAIPP *arg0, int8_t arg1) {
    load_library();
    return aclmdlSetAIPPRbuvSwapSwitch(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPRbuvSwapSwitch_error(aclmdlAIPP *, int8_t) {
    return on_init_failed<aclError >(172);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPAxSwapSwitch_init(aclmdlAIPP *arg0, int8_t arg1) {
    load_library();
    return aclmdlSetAIPPAxSwapSwitch(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPAxSwapSwitch_error(aclmdlAIPP *, int8_t) {
    return on_init_failed<aclError >(173);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPSrcImageSize_init(aclmdlAIPP *arg0, int32_t arg1, int32_t arg2) {
    load_library();
    return aclmdlSetAIPPSrcImageSize(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPSrcImageSize_error(aclmdlAIPP *, int32_t, int32_t) {
    return on_init_failed<aclError >(174);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPScfParams_init(aclmdlAIPP *arg0, int8_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5, uint64_t arg6) {
    load_library();
    return aclmdlSetAIPPScfParams(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPScfParams_error(aclmdlAIPP *, int8_t, int32_t, int32_t, int32_t, int32_t, uint64_t) {
    return on_init_failed<aclError >(175);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPCropParams_init(aclmdlAIPP *arg0, int8_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5, uint64_t arg6) {
    load_library();
    return aclmdlSetAIPPCropParams(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPCropParams_error(aclmdlAIPP *, int8_t, int32_t, int32_t, int32_t, int32_t, uint64_t) {
    return on_init_failed<aclError >(176);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPPaddingParams_init(aclmdlAIPP *arg0, int8_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5, uint64_t arg6) {
    load_library();
    return aclmdlSetAIPPPaddingParams(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPPaddingParams_error(aclmdlAIPP *, int8_t, int32_t, int32_t, int32_t, int32_t, uint64_t) {
    return on_init_failed<aclError >(177);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPDtcPixelMean_init(aclmdlAIPP *arg0, int16_t arg1, int16_t arg2, int16_t arg3, int16_t arg4, uint64_t arg5) {
    load_library();
    return aclmdlSetAIPPDtcPixelMean(arg0, arg1, arg2, arg3, arg4, arg5);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPDtcPixelMean_error(aclmdlAIPP *, int16_t, int16_t, int16_t, int16_t, uint64_t) {
    return on_init_failed<aclError >(178);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPDtcPixelMin_init(aclmdlAIPP *arg0, float arg1, float arg2, float arg3, float arg4, uint64_t arg5) {
    load_library();
    return aclmdlSetAIPPDtcPixelMin(arg0, arg1, arg2, arg3, arg4, arg5);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPDtcPixelMin_error(aclmdlAIPP *, float, float, float, float, uint64_t) {
    return on_init_failed<aclError >(179);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPPixelVarReci_init(aclmdlAIPP *arg0, float arg1, float arg2, float arg3, float arg4, uint64_t arg5) {
    load_library();
    return aclmdlSetAIPPPixelVarReci(arg0, arg1, arg2, arg3, arg4, arg5);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPPixelVarReci_error(aclmdlAIPP *, float, float, float, float, uint64_t) {
    return on_init_failed<aclError >(180);
}
static aclError _WRAPLIB_API_CALL aclmdlSetInputAIPP_init(uint32_t arg0, aclmdlDataset *arg1, size_t arg2, const aclmdlAIPP *arg3) {
    load_library();
    return aclmdlSetInputAIPP(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclmdlSetInputAIPP_error(uint32_t, aclmdlDataset *, size_t, const aclmdlAIPP *) {
    return on_init_failed<aclError >(181);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPByInputIndex_init(uint32_t arg0, aclmdlDataset *arg1, size_t arg2, const aclmdlAIPP *arg3) {
    load_library();
    return aclmdlSetAIPPByInputIndex(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclmdlSetAIPPByInputIndex_error(uint32_t, aclmdlDataset *, size_t, const aclmdlAIPP *) {
    return on_init_failed<aclError >(182);
}
static aclError _WRAPLIB_API_CALL aclmdlGetAippType_init(uint32_t arg0, size_t arg1, aclmdlInputAippType *arg2, size_t *arg3) {
    load_library();
    return aclmdlGetAippType(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclmdlGetAippType_error(uint32_t, size_t, aclmdlInputAippType *, size_t *) {
    return on_init_failed<aclError >(183);
}
static aclError _WRAPLIB_API_CALL aclmdlGetFirstAippInfo_init(uint32_t arg0, size_t arg1, aclAippInfo *arg2) {
    load_library();
    return aclmdlGetFirstAippInfo(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclmdlGetFirstAippInfo_error(uint32_t, size_t, aclAippInfo *) {
    return on_init_failed<aclError >(184);
}
static aclError _WRAPLIB_API_CALL aclmdlCreateAndGetOpDesc_init(uint32_t arg0, uint32_t arg1, uint32_t arg2, char *arg3, size_t arg4, aclTensorDesc **arg5, size_t *arg6, aclTensorDesc **arg7, size_t *arg8) {
    load_library();
    return aclmdlCreateAndGetOpDesc(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
static aclError _WRAPLIB_API_CALL aclmdlCreateAndGetOpDesc_error(uint32_t, uint32_t, uint32_t, char *, size_t, aclTensorDesc **, size_t *, aclTensorDesc **, size_t *) {
    return on_init_failed<aclError >(185);
}
static aclError _WRAPLIB_API_CALL aclmdlInitDump_init() {
    load_library();
    return aclmdlInitDump();
}
static aclError _WRAPLIB_API_CALL aclmdlInitDump_error() {
    return on_init_failed<aclError >(186);
}
static aclError _WRAPLIB_API_CALL aclmdlSetDump_init(const char *arg0) {
    load_library();
    return aclmdlSetDump(arg0);
}
static aclError _WRAPLIB_API_CALL aclmdlSetDump_error(const char *) {
    return on_init_failed<aclError >(187);
}
static aclError _WRAPLIB_API_CALL aclmdlFinalizeDump_init() {
    load_library();
    return aclmdlFinalizeDump();
}
static aclError _WRAPLIB_API_CALL aclmdlFinalizeDump_error() {
    return on_init_failed<aclError >(188);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadWithConfig_init(const aclmdlConfigHandle *arg0, uint32_t *arg1) {
    load_library();
    return aclmdlLoadWithConfig(arg0, arg1);
}
static aclError _WRAPLIB_API_CALL aclmdlLoadWithConfig_error(const aclmdlConfigHandle *, uint32_t *) {
    return on_init_failed<aclError >(189);
}
static aclmdlConfigHandle _WRAPLIB_API_CALL *aclmdlCreateConfigHandle_init() {
    load_library();
    return aclmdlCreateConfigHandle();
}
static aclmdlConfigHandle _WRAPLIB_API_CALL *aclmdlCreateConfigHandle_error() {
    return on_init_failed<aclmdlConfigHandle *>(190);
}
static aclError _WRAPLIB_API_CALL aclmdlDestroyConfigHandle_init(aclmdlConfigHandle *arg0) {
    load_library();
    return aclmdlDestroyConfigHandle(arg0);
}
static aclError _WRAPLIB_API_CALL aclmdlDestroyConfigHandle_error(aclmdlConfigHandle *) {
    return on_init_failed<aclError >(191);
}
static aclError _WRAPLIB_API_CALL aclmdlSetConfigOpt_init(aclmdlConfigHandle *arg0, aclmdlConfigAttr arg1, const void *arg2, size_t arg3) {
    load_library();
    return aclmdlSetConfigOpt(arg0, arg1, arg2, arg3);
}
static aclError _WRAPLIB_API_CALL aclmdlSetConfigOpt_error(aclmdlConfigHandle *, aclmdlConfigAttr, const void *, size_t) {
    return on_init_failed<aclError >(192);
}
static const char _WRAPLIB_API_CALL *aclmdlGetTensorRealName_init(const aclmdlDesc *arg0, const char *arg1) {
    load_library();
    return aclmdlGetTensorRealName(arg0, arg1);
}
static const char _WRAPLIB_API_CALL *aclmdlGetTensorRealName_error(const aclmdlDesc *, const char *) {
    return on_init_failed<const char *>(193);
}
static aclError _WRAPLIB_API_CALL aclInit_init(const char *arg0) {
    load_library();
    return aclInit(arg0);
}
static aclError _WRAPLIB_API_CALL aclInit_error(const char *) {
    return on_init_failed<aclError >(194);
}
static aclError _WRAPLIB_API_CALL aclFinalize_init() {
    load_library();
    return aclFinalize();
}
static aclError _WRAPLIB_API_CALL aclFinalize_error() {
    return on_init_failed<aclError >(195);
}
static aclError _WRAPLIB_API_CALL aclrtGetVersion_init(int32_t *arg0, int32_t *arg1, int32_t *arg2) {
    load_library();
    return aclrtGetVersion(arg0, arg1, arg2);
}
static aclError _WRAPLIB_API_CALL aclrtGetVersion_error(int32_t *, int32_t *, int32_t *) {
    return on_init_failed<aclError >(196);
}
static const char _WRAPLIB_API_CALL *aclGetRecentErrMsg_init() {
    load_library();
    return aclGetRecentErrMsg();
}
static const char _WRAPLIB_API_CALL *aclGetRecentErrMsg_error() {
    return on_init_failed<const char *>(197);
}
static constexpr size_t NR_FUNC = 198;
static void* g_func_table[NR_FUNC] = {(void*)(&aclFloat16ToFloat_init),
    (void*)(&aclFloatToFloat16_init),
    (void*)(&aclCreateDataBuffer_init),
    (void*)(&aclDestroyDataBuffer_init),
    (void*)(&aclUpdateDataBuffer_init),
    (void*)(&aclGetDataBufferAddr_init),
    (void*)(&aclGetDataBufferSize_init),
    (void*)(&aclGetDataBufferSizeV2_init),
    (void*)(&aclDataTypeSize_init),
    (void*)(&aclCreateTensorDesc_init),
    (void*)(&aclDestroyTensorDesc_init),
    (void*)(&aclSetTensorShapeRange_init),
    (void*)(&aclSetTensorValueRange_init),
    (void*)(&aclGetTensorDescType_init),
    (void*)(&aclGetTensorDescFormat_init),
    (void*)(&aclGetTensorDescSize_init),
    (void*)(&aclGetTensorDescElementCount_init),
    (void*)(&aclGetTensorDescNumDims_init),
    (void*)(&aclGetTensorDescDim_init),
    (void*)(&aclGetTensorDescDimV2_init),
    (void*)(&aclGetTensorDescDimRange_init),
    (void*)(&aclSetTensorDescName_init),
    (void*)(&aclGetTensorDescName_init),
    (void*)(&aclTransTensorDescFormat_init),
    (void*)(&aclSetTensorStorageFormat_init),
    (void*)(&aclSetTensorStorageShape_init),
    (void*)(&aclSetTensorFormat_init),
    (void*)(&aclSetTensorShape_init),
    (void*)(&aclSetTensorOriginFormat_init),
    (void*)(&aclSetTensorOriginShape_init),
    (void*)(&aclGetTensorDescByIndex_init),
    (void*)(&aclGetTensorDescAddress_init),
    (void*)(&aclSetTensorDynamicInput_init),
    (void*)(&aclSetTensorConst_init),
    (void*)(&aclSetTensorPlaceMent_init),
    (void*)(&aclrtGetSocName_init),
    (void*)(&aclrtSetExceptionInfoCallback_init),
    (void*)(&aclrtGetTaskIdFromExceptionInfo_init),
    (void*)(&aclrtGetStreamIdFromExceptionInfo_init),
    (void*)(&aclrtGetThreadIdFromExceptionInfo_init),
    (void*)(&aclrtGetDeviceIdFromExceptionInfo_init),
    (void*)(&aclrtSubscribeReport_init),
    (void*)(&aclrtLaunchCallback_init),
    (void*)(&aclrtProcessReport_init),
    (void*)(&aclrtUnSubscribeReport_init),
    (void*)(&aclrtCreateContext_init),
    (void*)(&aclrtDestroyContext_init),
    (void*)(&aclrtSetCurrentContext_init),
    (void*)(&aclrtGetCurrentContext_init),
    (void*)(&aclrtSetDevice_init),
    (void*)(&aclrtResetDevice_init),
    (void*)(&aclrtGetDevice_init),
    (void*)(&aclrtGetRunMode_init),
    (void*)(&aclrtSynchronizeDevice_init),
    (void*)(&aclrtSetTsDevice_init),
    (void*)(&aclrtGetDeviceCount_init),
    (void*)(&aclrtCreateEvent_init),
    (void*)(&aclrtCreateEventWithFlag_init),
    (void*)(&aclrtDestroyEvent_init),
    (void*)(&aclrtRecordEvent_init),
    (void*)(&aclrtResetEvent_init),
    (void*)(&aclrtQueryEvent_init),
    (void*)(&aclrtQueryEventStatus_init),
    (void*)(&aclrtQueryEventWaitStatus_init),
    (void*)(&aclrtSynchronizeEvent_init),
    (void*)(&aclrtEventElapsedTime_init),
    (void*)(&aclrtMalloc_init),
    (void*)(&aclrtMallocCached_init),
    (void*)(&aclrtMemFlush_init),
    (void*)(&aclrtMemInvalidate_init),
    (void*)(&aclrtFree_init),
    (void*)(&aclrtMallocHost_init),
    (void*)(&aclrtFreeHost_init),
    (void*)(&aclrtMemcpy_init),
    (void*)(&aclrtMemset_init),
    (void*)(&aclrtMemcpyAsync_init),
    (void*)(&aclrtMemcpy2d_init),
    (void*)(&aclrtMemcpy2dAsync_init),
    (void*)(&aclrtMemsetAsync_init),
    (void*)(&aclrtCreateStream_init),
    (void*)(&aclrtDestroyStream_init),
    (void*)(&aclrtSynchronizeStream_init),
    (void*)(&aclrtStreamWaitEvent_init),
    (void*)(&aclrtSetGroup_init),
    (void*)(&aclrtGetGroupCount_init),
    (void*)(&aclrtCreateGroupInfo_init),
    (void*)(&aclrtDestroyGroupInfo_init),
    (void*)(&aclrtGetAllGroupInfo_init),
    (void*)(&aclrtGetGroupInfoDetail_init),
    (void*)(&aclrtDeviceCanAccessPeer_init),
    (void*)(&aclrtDeviceEnablePeerAccess_init),
    (void*)(&aclrtDeviceDisablePeerAccess_init),
    (void*)(&aclrtGetMemInfo_init),
    (void*)(&aclrtSetOpWaitTimeout_init),
    (void*)(&aclopSetModelDir_init),
    (void*)(&aclopLoad_init),
    (void*)(&aclopCreateAttr_init),
    (void*)(&aclopDestroyAttr_init),
    (void*)(&aclopSetAttrBool_init),
    (void*)(&aclopSetAttrInt_init),
    (void*)(&aclopSetAttrFloat_init),
    (void*)(&aclopSetAttrString_init),
    (void*)(&aclopSetAttrDataType_init),
    (void*)(&aclopSetAttrListDataType_init),
    (void*)(&aclopSetAttrListBool_init),
    (void*)(&aclopSetAttrListInt_init),
    (void*)(&aclopSetAttrListFloat_init),
    (void*)(&aclopSetAttrListString_init),
    (void*)(&aclopSetAttrListListInt_init),
    (void*)(&aclopExecute_init),
    (void*)(&aclopExecuteV2_init),
    (void*)(&aclopCreateHandle_init),
    (void*)(&aclopDestroyHandle_init),
    (void*)(&aclopExecWithHandle_init),
    (void*)(&aclopCast_init),
    (void*)(&aclopCreateHandleForCast_init),
    (void*)(&aclopCreateKernel_init),
    (void*)(&aclopRegisterCompileFunc_init),
    (void*)(&aclopUnregisterCompileFunc_init),
    (void*)(&aclopSetKernelArgs_init),
    (void*)(&aclopSetKernelWorkspaceSizes_init),
    (void*)(&aclopUpdateParams_init),
    (void*)(&aclopInferShape_init),
    (void*)(&aclmdlCreateDesc_init),
    (void*)(&aclmdlDestroyDesc_init),
    (void*)(&aclmdlGetDesc_init),
    (void*)(&aclmdlGetNumInputs_init),
    (void*)(&aclmdlGetNumOutputs_init),
    (void*)(&aclmdlGetInputSizeByIndex_init),
    (void*)(&aclmdlGetOutputSizeByIndex_init),
    (void*)(&aclmdlCreateDataset_init),
    (void*)(&aclmdlDestroyDataset_init),
    (void*)(&aclmdlAddDatasetBuffer_init),
    (void*)(&aclmdlSetDatasetTensorDesc_init),
    (void*)(&aclmdlGetDatasetTensorDesc_init),
    (void*)(&aclmdlGetDatasetNumBuffers_init),
    (void*)(&aclmdlGetDatasetBuffer_init),
    (void*)(&aclmdlLoadFromFile_init),
    (void*)(&aclmdlLoadFromMem_init),
    (void*)(&aclmdlLoadFromFileWithMem_init),
    (void*)(&aclmdlLoadFromMemWithMem_init),
    (void*)(&aclmdlLoadFromFileWithQ_init),
    (void*)(&aclmdlLoadFromMemWithQ_init),
    (void*)(&aclmdlExecute_init),
    (void*)(&aclmdlExecuteAsync_init),
    (void*)(&aclmdlUnload_init),
    (void*)(&aclmdlQuerySize_init),
    (void*)(&aclmdlQuerySizeFromMem_init),
    (void*)(&aclmdlSetDynamicBatchSize_init),
    (void*)(&aclmdlSetDynamicHWSize_init),
    (void*)(&aclmdlSetInputDynamicDims_init),
    (void*)(&aclmdlGetInputDims_init),
    (void*)(&aclmdlGetInputDimsV2_init),
    (void*)(&aclmdlGetOutputDims_init),
    (void*)(&aclmdlGetCurOutputDims_init),
    (void*)(&aclmdlGetOpAttr_init),
    (void*)(&aclmdlGetInputNameByIndex_init),
    (void*)(&aclmdlGetOutputNameByIndex_init),
    (void*)(&aclmdlGetInputFormat_init),
    (void*)(&aclmdlGetOutputFormat_init),
    (void*)(&aclmdlGetInputDataType_init),
    (void*)(&aclmdlGetOutputDataType_init),
    (void*)(&aclmdlGetInputIndexByName_init),
    (void*)(&aclmdlGetOutputIndexByName_init),
    (void*)(&aclmdlGetDynamicBatch_init),
    (void*)(&aclmdlGetDynamicHW_init),
    (void*)(&aclmdlGetInputDynamicGearCount_init),
    (void*)(&aclmdlGetInputDynamicDims_init),
    (void*)(&aclmdlCreateAIPP_init),
    (void*)(&aclmdlDestroyAIPP_init),
    (void*)(&aclmdlSetAIPPInputFormat_init),
    (void*)(&aclmdlSetAIPPCscParams_init),
    (void*)(&aclmdlSetAIPPRbuvSwapSwitch_init),
    (void*)(&aclmdlSetAIPPAxSwapSwitch_init),
    (void*)(&aclmdlSetAIPPSrcImageSize_init),
    (void*)(&aclmdlSetAIPPScfParams_init),
    (void*)(&aclmdlSetAIPPCropParams_init),
    (void*)(&aclmdlSetAIPPPaddingParams_init),
    (void*)(&aclmdlSetAIPPDtcPixelMean_init),
    (void*)(&aclmdlSetAIPPDtcPixelMin_init),
    (void*)(&aclmdlSetAIPPPixelVarReci_init),
    (void*)(&aclmdlSetInputAIPP_init),
    (void*)(&aclmdlSetAIPPByInputIndex_init),
    (void*)(&aclmdlGetAippType_init),
    (void*)(&aclmdlGetFirstAippInfo_init),
    (void*)(&aclmdlCreateAndGetOpDesc_init),
    (void*)(&aclmdlInitDump_init),
    (void*)(&aclmdlSetDump_init),
    (void*)(&aclmdlFinalizeDump_init),
    (void*)(&aclmdlLoadWithConfig_init),
    (void*)(&aclmdlCreateConfigHandle_init),
    (void*)(&aclmdlDestroyConfigHandle_init),
    (void*)(&aclmdlSetConfigOpt_init),
    (void*)(&aclmdlGetTensorRealName_init),
    (void*)(&aclInit_init),
    (void*)(&aclFinalize_init),
    (void*)(&aclrtGetVersion_init),
    (void*)(&aclGetRecentErrMsg_init)};
static void* g_func_table_error[NR_FUNC] = {(void*)(&aclFloat16ToFloat_error),
    (void*)(&aclFloatToFloat16_error),
    (void*)(&aclCreateDataBuffer_error),
    (void*)(&aclDestroyDataBuffer_error),
    (void*)(&aclUpdateDataBuffer_error),
    (void*)(&aclGetDataBufferAddr_error),
    (void*)(&aclGetDataBufferSize_error),
    (void*)(&aclGetDataBufferSizeV2_error),
    (void*)(&aclDataTypeSize_error),
    (void*)(&aclCreateTensorDesc_error),
    (void*)(&aclDestroyTensorDesc_error),
    (void*)(&aclSetTensorShapeRange_error),
    (void*)(&aclSetTensorValueRange_error),
    (void*)(&aclGetTensorDescType_error),
    (void*)(&aclGetTensorDescFormat_error),
    (void*)(&aclGetTensorDescSize_error),
    (void*)(&aclGetTensorDescElementCount_error),
    (void*)(&aclGetTensorDescNumDims_error),
    (void*)(&aclGetTensorDescDim_error),
    (void*)(&aclGetTensorDescDimV2_error),
    (void*)(&aclGetTensorDescDimRange_error),
    (void*)(&aclSetTensorDescName_error),
    (void*)(&aclGetTensorDescName_error),
    (void*)(&aclTransTensorDescFormat_error),
    (void*)(&aclSetTensorStorageFormat_error),
    (void*)(&aclSetTensorStorageShape_error),
    (void*)(&aclSetTensorFormat_error),
    (void*)(&aclSetTensorShape_error),
    (void*)(&aclSetTensorOriginFormat_error),
    (void*)(&aclSetTensorOriginShape_error),
    (void*)(&aclGetTensorDescByIndex_error),
    (void*)(&aclGetTensorDescAddress_error),
    (void*)(&aclSetTensorDynamicInput_error),
    (void*)(&aclSetTensorConst_error),
    (void*)(&aclSetTensorPlaceMent_error),
    (void*)(&aclrtGetSocName_error),
    (void*)(&aclrtSetExceptionInfoCallback_error),
    (void*)(&aclrtGetTaskIdFromExceptionInfo_error),
    (void*)(&aclrtGetStreamIdFromExceptionInfo_error),
    (void*)(&aclrtGetThreadIdFromExceptionInfo_error),
    (void*)(&aclrtGetDeviceIdFromExceptionInfo_error),
    (void*)(&aclrtSubscribeReport_error),
    (void*)(&aclrtLaunchCallback_error),
    (void*)(&aclrtProcessReport_error),
    (void*)(&aclrtUnSubscribeReport_error),
    (void*)(&aclrtCreateContext_error),
    (void*)(&aclrtDestroyContext_error),
    (void*)(&aclrtSetCurrentContext_error),
    (void*)(&aclrtGetCurrentContext_error),
    (void*)(&aclrtSetDevice_error),
    (void*)(&aclrtResetDevice_error),
    (void*)(&aclrtGetDevice_error),
    (void*)(&aclrtGetRunMode_error),
    (void*)(&aclrtSynchronizeDevice_error),
    (void*)(&aclrtSetTsDevice_error),
    (void*)(&aclrtGetDeviceCount_error),
    (void*)(&aclrtCreateEvent_error),
    (void*)(&aclrtCreateEventWithFlag_error),
    (void*)(&aclrtDestroyEvent_error),
    (void*)(&aclrtRecordEvent_error),
    (void*)(&aclrtResetEvent_error),
    (void*)(&aclrtQueryEvent_error),
    (void*)(&aclrtQueryEventStatus_error),
    (void*)(&aclrtQueryEventWaitStatus_error),
    (void*)(&aclrtSynchronizeEvent_error),
    (void*)(&aclrtEventElapsedTime_error),
    (void*)(&aclrtMalloc_error),
    (void*)(&aclrtMallocCached_error),
    (void*)(&aclrtMemFlush_error),
    (void*)(&aclrtMemInvalidate_error),
    (void*)(&aclrtFree_error),
    (void*)(&aclrtMallocHost_error),
    (void*)(&aclrtFreeHost_error),
    (void*)(&aclrtMemcpy_error),
    (void*)(&aclrtMemset_error),
    (void*)(&aclrtMemcpyAsync_error),
    (void*)(&aclrtMemcpy2d_error),
    (void*)(&aclrtMemcpy2dAsync_error),
    (void*)(&aclrtMemsetAsync_error),
    (void*)(&aclrtCreateStream_error),
    (void*)(&aclrtDestroyStream_error),
    (void*)(&aclrtSynchronizeStream_error),
    (void*)(&aclrtStreamWaitEvent_error),
    (void*)(&aclrtSetGroup_error),
    (void*)(&aclrtGetGroupCount_error),
    (void*)(&aclrtCreateGroupInfo_error),
    (void*)(&aclrtDestroyGroupInfo_error),
    (void*)(&aclrtGetAllGroupInfo_error),
    (void*)(&aclrtGetGroupInfoDetail_error),
    (void*)(&aclrtDeviceCanAccessPeer_error),
    (void*)(&aclrtDeviceEnablePeerAccess_error),
    (void*)(&aclrtDeviceDisablePeerAccess_error),
    (void*)(&aclrtGetMemInfo_error),
    (void*)(&aclrtSetOpWaitTimeout_error),
    (void*)(&aclopSetModelDir_error),
    (void*)(&aclopLoad_error),
    (void*)(&aclopCreateAttr_error),
    (void*)(&aclopDestroyAttr_error),
    (void*)(&aclopSetAttrBool_error),
    (void*)(&aclopSetAttrInt_error),
    (void*)(&aclopSetAttrFloat_error),
    (void*)(&aclopSetAttrString_error),
    (void*)(&aclopSetAttrDataType_error),
    (void*)(&aclopSetAttrListDataType_error),
    (void*)(&aclopSetAttrListBool_error),
    (void*)(&aclopSetAttrListInt_error),
    (void*)(&aclopSetAttrListFloat_error),
    (void*)(&aclopSetAttrListString_error),
    (void*)(&aclopSetAttrListListInt_error),
    (void*)(&aclopExecute_error),
    (void*)(&aclopExecuteV2_error),
    (void*)(&aclopCreateHandle_error),
    (void*)(&aclopDestroyHandle_error),
    (void*)(&aclopExecWithHandle_error),
    (void*)(&aclopCast_error),
    (void*)(&aclopCreateHandleForCast_error),
    (void*)(&aclopCreateKernel_error),
    (void*)(&aclopRegisterCompileFunc_error),
    (void*)(&aclopUnregisterCompileFunc_error),
    (void*)(&aclopSetKernelArgs_error),
    (void*)(&aclopSetKernelWorkspaceSizes_error),
    (void*)(&aclopUpdateParams_error),
    (void*)(&aclopInferShape_error),
    (void*)(&aclmdlCreateDesc_error),
    (void*)(&aclmdlDestroyDesc_error),
    (void*)(&aclmdlGetDesc_error),
    (void*)(&aclmdlGetNumInputs_error),
    (void*)(&aclmdlGetNumOutputs_error),
    (void*)(&aclmdlGetInputSizeByIndex_error),
    (void*)(&aclmdlGetOutputSizeByIndex_error),
    (void*)(&aclmdlCreateDataset_error),
    (void*)(&aclmdlDestroyDataset_error),
    (void*)(&aclmdlAddDatasetBuffer_error),
    (void*)(&aclmdlSetDatasetTensorDesc_error),
    (void*)(&aclmdlGetDatasetTensorDesc_error),
    (void*)(&aclmdlGetDatasetNumBuffers_error),
    (void*)(&aclmdlGetDatasetBuffer_error),
    (void*)(&aclmdlLoadFromFile_error),
    (void*)(&aclmdlLoadFromMem_error),
    (void*)(&aclmdlLoadFromFileWithMem_error),
    (void*)(&aclmdlLoadFromMemWithMem_error),
    (void*)(&aclmdlLoadFromFileWithQ_error),
    (void*)(&aclmdlLoadFromMemWithQ_error),
    (void*)(&aclmdlExecute_error),
    (void*)(&aclmdlExecuteAsync_error),
    (void*)(&aclmdlUnload_error),
    (void*)(&aclmdlQuerySize_error),
    (void*)(&aclmdlQuerySizeFromMem_error),
    (void*)(&aclmdlSetDynamicBatchSize_error),
    (void*)(&aclmdlSetDynamicHWSize_error),
    (void*)(&aclmdlSetInputDynamicDims_error),
    (void*)(&aclmdlGetInputDims_error),
    (void*)(&aclmdlGetInputDimsV2_error),
    (void*)(&aclmdlGetOutputDims_error),
    (void*)(&aclmdlGetCurOutputDims_error),
    (void*)(&aclmdlGetOpAttr_error),
    (void*)(&aclmdlGetInputNameByIndex_error),
    (void*)(&aclmdlGetOutputNameByIndex_error),
    (void*)(&aclmdlGetInputFormat_error),
    (void*)(&aclmdlGetOutputFormat_error),
    (void*)(&aclmdlGetInputDataType_error),
    (void*)(&aclmdlGetOutputDataType_error),
    (void*)(&aclmdlGetInputIndexByName_error),
    (void*)(&aclmdlGetOutputIndexByName_error),
    (void*)(&aclmdlGetDynamicBatch_error),
    (void*)(&aclmdlGetDynamicHW_error),
    (void*)(&aclmdlGetInputDynamicGearCount_error),
    (void*)(&aclmdlGetInputDynamicDims_error),
    (void*)(&aclmdlCreateAIPP_error),
    (void*)(&aclmdlDestroyAIPP_error),
    (void*)(&aclmdlSetAIPPInputFormat_error),
    (void*)(&aclmdlSetAIPPCscParams_error),
    (void*)(&aclmdlSetAIPPRbuvSwapSwitch_error),
    (void*)(&aclmdlSetAIPPAxSwapSwitch_error),
    (void*)(&aclmdlSetAIPPSrcImageSize_error),
    (void*)(&aclmdlSetAIPPScfParams_error),
    (void*)(&aclmdlSetAIPPCropParams_error),
    (void*)(&aclmdlSetAIPPPaddingParams_error),
    (void*)(&aclmdlSetAIPPDtcPixelMean_error),
    (void*)(&aclmdlSetAIPPDtcPixelMin_error),
    (void*)(&aclmdlSetAIPPPixelVarReci_error),
    (void*)(&aclmdlSetInputAIPP_error),
    (void*)(&aclmdlSetAIPPByInputIndex_error),
    (void*)(&aclmdlGetAippType_error),
    (void*)(&aclmdlGetFirstAippInfo_error),
    (void*)(&aclmdlCreateAndGetOpDesc_error),
    (void*)(&aclmdlInitDump_error),
    (void*)(&aclmdlSetDump_error),
    (void*)(&aclmdlFinalizeDump_error),
    (void*)(&aclmdlLoadWithConfig_error),
    (void*)(&aclmdlCreateConfigHandle_error),
    (void*)(&aclmdlDestroyConfigHandle_error),
    (void*)(&aclmdlSetConfigOpt_error),
    (void*)(&aclmdlGetTensorRealName_error),
    (void*)(&aclInit_error),
    (void*)(&aclFinalize_error),
    (void*)(&aclrtGetVersion_error),
    (void*)(&aclGetRecentErrMsg_error)};
static const char* const g_func_name[NR_FUNC] = {"aclFloat16ToFloat",
    "aclFloatToFloat16",
    "aclCreateDataBuffer",
    "aclDestroyDataBuffer",
    "aclUpdateDataBuffer",
    "aclGetDataBufferAddr",
    "aclGetDataBufferSize",
    "aclGetDataBufferSizeV2",
    "aclDataTypeSize",
    "aclCreateTensorDesc",
    "aclDestroyTensorDesc",
    "aclSetTensorShapeRange",
    "aclSetTensorValueRange",
    "aclGetTensorDescType",
    "aclGetTensorDescFormat",
    "aclGetTensorDescSize",
    "aclGetTensorDescElementCount",
    "aclGetTensorDescNumDims",
    "aclGetTensorDescDim",
    "aclGetTensorDescDimV2",
    "aclGetTensorDescDimRange",
    "aclSetTensorDescName",
    "aclGetTensorDescName",
    "aclTransTensorDescFormat",
    "aclSetTensorStorageFormat",
    "aclSetTensorStorageShape",
    "aclSetTensorFormat",
    "aclSetTensorShape",
    "aclSetTensorOriginFormat",
    "aclSetTensorOriginShape",
    "aclGetTensorDescByIndex",
    "aclGetTensorDescAddress",
    "aclSetTensorDynamicInput",
    "aclSetTensorConst",
    "aclSetTensorPlaceMent",
    "aclrtGetSocName",
    "aclrtSetExceptionInfoCallback",
    "aclrtGetTaskIdFromExceptionInfo",
    "aclrtGetStreamIdFromExceptionInfo",
    "aclrtGetThreadIdFromExceptionInfo",
    "aclrtGetDeviceIdFromExceptionInfo",
    "aclrtSubscribeReport",
    "aclrtLaunchCallback",
    "aclrtProcessReport",
    "aclrtUnSubscribeReport",
    "aclrtCreateContext",
    "aclrtDestroyContext",
    "aclrtSetCurrentContext",
    "aclrtGetCurrentContext",
    "aclrtSetDevice",
    "aclrtResetDevice",
    "aclrtGetDevice",
    "aclrtGetRunMode",
    "aclrtSynchronizeDevice",
    "aclrtSetTsDevice",
    "aclrtGetDeviceCount",
    "aclrtCreateEvent",
    "aclrtCreateEventWithFlag",
    "aclrtDestroyEvent",
    "aclrtRecordEvent",
    "aclrtResetEvent",
    "aclrtQueryEvent",
    "aclrtQueryEventStatus",
    "aclrtQueryEventWaitStatus",
    "aclrtSynchronizeEvent",
    "aclrtEventElapsedTime",
    "aclrtMalloc",
    "aclrtMallocCached",
    "aclrtMemFlush",
    "aclrtMemInvalidate",
    "aclrtFree",
    "aclrtMallocHost",
    "aclrtFreeHost",
    "aclrtMemcpy",
    "aclrtMemset",
    "aclrtMemcpyAsync",
    "aclrtMemcpy2d",
    "aclrtMemcpy2dAsync",
    "aclrtMemsetAsync",
    "aclrtCreateStream",
    "aclrtDestroyStream",
    "aclrtSynchronizeStream",
    "aclrtStreamWaitEvent",
    "aclrtSetGroup",
    "aclrtGetGroupCount",
    "aclrtCreateGroupInfo",
    "aclrtDestroyGroupInfo",
    "aclrtGetAllGroupInfo",
    "aclrtGetGroupInfoDetail",
    "aclrtDeviceCanAccessPeer",
    "aclrtDeviceEnablePeerAccess",
    "aclrtDeviceDisablePeerAccess",
    "aclrtGetMemInfo",
    "aclrtSetOpWaitTimeout",
    "aclopSetModelDir",
    "aclopLoad",
    "aclopCreateAttr",
    "aclopDestroyAttr",
    "aclopSetAttrBool",
    "aclopSetAttrInt",
    "aclopSetAttrFloat",
    "aclopSetAttrString",
    "aclopSetAttrDataType",
    "aclopSetAttrListDataType",
    "aclopSetAttrListBool",
    "aclopSetAttrListInt",
    "aclopSetAttrListFloat",
    "aclopSetAttrListString",
    "aclopSetAttrListListInt",
    "aclopExecute",
    "aclopExecuteV2",
    "aclopCreateHandle",
    "aclopDestroyHandle",
    "aclopExecWithHandle",
    "aclopCast",
    "aclopCreateHandleForCast",
    "aclopCreateKernel",
    "aclopRegisterCompileFunc",
    "aclopUnregisterCompileFunc",
    "aclopSetKernelArgs",
    "aclopSetKernelWorkspaceSizes",
    "aclopUpdateParams",
    "aclopInferShape",
    "aclmdlCreateDesc",
    "aclmdlDestroyDesc",
    "aclmdlGetDesc",
    "aclmdlGetNumInputs",
    "aclmdlGetNumOutputs",
    "aclmdlGetInputSizeByIndex",
    "aclmdlGetOutputSizeByIndex",
    "aclmdlCreateDataset",
    "aclmdlDestroyDataset",
    "aclmdlAddDatasetBuffer",
    "aclmdlSetDatasetTensorDesc",
    "aclmdlGetDatasetTensorDesc",
    "aclmdlGetDatasetNumBuffers",
    "aclmdlGetDatasetBuffer",
    "aclmdlLoadFromFile",
    "aclmdlLoadFromMem",
    "aclmdlLoadFromFileWithMem",
    "aclmdlLoadFromMemWithMem",
    "aclmdlLoadFromFileWithQ",
    "aclmdlLoadFromMemWithQ",
    "aclmdlExecute",
    "aclmdlExecuteAsync",
    "aclmdlUnload",
    "aclmdlQuerySize",
    "aclmdlQuerySizeFromMem",
    "aclmdlSetDynamicBatchSize",
    "aclmdlSetDynamicHWSize",
    "aclmdlSetInputDynamicDims",
    "aclmdlGetInputDims",
    "aclmdlGetInputDimsV2",
    "aclmdlGetOutputDims",
    "aclmdlGetCurOutputDims",
    "aclmdlGetOpAttr",
    "aclmdlGetInputNameByIndex",
    "aclmdlGetOutputNameByIndex",
    "aclmdlGetInputFormat",
    "aclmdlGetOutputFormat",
    "aclmdlGetInputDataType",
    "aclmdlGetOutputDataType",
    "aclmdlGetInputIndexByName",
    "aclmdlGetOutputIndexByName",
    "aclmdlGetDynamicBatch",
    "aclmdlGetDynamicHW",
    "aclmdlGetInputDynamicGearCount",
    "aclmdlGetInputDynamicDims",
    "aclmdlCreateAIPP",
    "aclmdlDestroyAIPP",
    "aclmdlSetAIPPInputFormat",
    "aclmdlSetAIPPCscParams",
    "aclmdlSetAIPPRbuvSwapSwitch",
    "aclmdlSetAIPPAxSwapSwitch",
    "aclmdlSetAIPPSrcImageSize",
    "aclmdlSetAIPPScfParams",
    "aclmdlSetAIPPCropParams",
    "aclmdlSetAIPPPaddingParams",
    "aclmdlSetAIPPDtcPixelMean",
    "aclmdlSetAIPPDtcPixelMin",
    "aclmdlSetAIPPPixelVarReci",
    "aclmdlSetInputAIPP",
    "aclmdlSetAIPPByInputIndex",
    "aclmdlGetAippType",
    "aclmdlGetFirstAippInfo",
    "aclmdlCreateAndGetOpDesc",
    "aclmdlInitDump",
    "aclmdlSetDump",
    "aclmdlFinalizeDump",
    "aclmdlLoadWithConfig",
    "aclmdlCreateConfigHandle",
    "aclmdlDestroyConfigHandle",
    "aclmdlSetConfigOpt",
    "aclmdlGetTensorRealName",
    "aclInit",
    "aclFinalize",
    "aclrtGetVersion",
    "aclGetRecentErrMsg"};

static void load_library() {
    static bool done = false;
    static std::mutex mtx;
    std::lock_guard<std::mutex> lg{mtx};

    if (done)
        return;

    void* handle = get_library_handle();
    for (size_t i = 0; i < NR_FUNC; ++i) {
        void* func;
        if (!handle) {
            func = nullptr;
        } else {
            func = resolve_library_func(handle, g_func_name[i]);
        }
        if (!func) {
            func = g_func_table_error[i];
        }
        __atomic_store_n(g_func_table + i, func, __ATOMIC_RELAXED);
    }
    done = true;
}

float _WRAPLIB_API_CALL aclFloat16ToFloat(aclFloat16 arg0) {
    typedef float (_WRAPLIB_API_CALL *f_ptr_t)(aclFloat16);
    ON_ENTRY(aclFloat16ToFloat);
    f_ptr_t f = (f_ptr_t)(g_func_table[0]);
    return f(arg0);
}
aclFloat16 _WRAPLIB_API_CALL aclFloatToFloat16(float arg0) {
    typedef aclFloat16 (_WRAPLIB_API_CALL *f_ptr_t)(float);
    ON_ENTRY(aclFloatToFloat16);
    f_ptr_t f = (f_ptr_t)(g_func_table[1]);
    return f(arg0);
}
aclDataBuffer _WRAPLIB_API_CALL *aclCreateDataBuffer(void *arg0, size_t arg1) {
    typedef aclDataBuffer *(_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t);
    ON_ENTRY(aclCreateDataBuffer);
    f_ptr_t f = (f_ptr_t)(g_func_table[2]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclDestroyDataBuffer(const aclDataBuffer *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclDataBuffer *);
    ON_ENTRY(aclDestroyDataBuffer);
    f_ptr_t f = (f_ptr_t)(g_func_table[3]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclUpdateDataBuffer(aclDataBuffer *arg0, void *arg1, size_t arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclDataBuffer *, void *, size_t);
    ON_ENTRY(aclUpdateDataBuffer);
    f_ptr_t f = (f_ptr_t)(g_func_table[4]);
    return f(arg0, arg1, arg2);
}
void _WRAPLIB_API_CALL *aclGetDataBufferAddr(const aclDataBuffer *arg0) {
    typedef void *(_WRAPLIB_API_CALL *f_ptr_t)(const aclDataBuffer *);
    ON_ENTRY(aclGetDataBufferAddr);
    f_ptr_t f = (f_ptr_t)(g_func_table[5]);
    return f(arg0);
}
uint32_t _WRAPLIB_API_CALL aclGetDataBufferSize(const aclDataBuffer *arg0) {
    typedef uint32_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclDataBuffer *);
    ON_ENTRY(aclGetDataBufferSize);
    f_ptr_t f = (f_ptr_t)(g_func_table[6]);
    return f(arg0);
}
size_t _WRAPLIB_API_CALL aclGetDataBufferSizeV2(const aclDataBuffer *arg0) {
    typedef size_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclDataBuffer *);
    ON_ENTRY(aclGetDataBufferSizeV2);
    f_ptr_t f = (f_ptr_t)(g_func_table[7]);
    return f(arg0);
}
size_t _WRAPLIB_API_CALL aclDataTypeSize(aclDataType arg0) {
    typedef size_t (_WRAPLIB_API_CALL *f_ptr_t)(aclDataType);
    ON_ENTRY(aclDataTypeSize);
    f_ptr_t f = (f_ptr_t)(g_func_table[8]);
    return f(arg0);
}
aclTensorDesc _WRAPLIB_API_CALL *aclCreateTensorDesc(aclDataType arg0, int arg1, const int64_t *arg2, aclFormat arg3) {
    typedef aclTensorDesc *(_WRAPLIB_API_CALL *f_ptr_t)(aclDataType, int, const int64_t *, aclFormat);
    ON_ENTRY(aclCreateTensorDesc);
    f_ptr_t f = (f_ptr_t)(g_func_table[9]);
    return f(arg0, arg1, arg2, arg3);
}
void _WRAPLIB_API_CALL aclDestroyTensorDesc(const aclTensorDesc *arg0) {
    typedef void (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *);
    ON_ENTRY(aclDestroyTensorDesc);
    f_ptr_t f = (f_ptr_t)(g_func_table[10]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclSetTensorShapeRange(aclTensorDesc *arg0, size_t arg1, int64_t arg2[][2]) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, size_t, int64_t [][2]);
    ON_ENTRY(aclSetTensorShapeRange);
    f_ptr_t f = (f_ptr_t)(g_func_table[11]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclSetTensorValueRange(aclTensorDesc *arg0, size_t arg1, int64_t arg2[][2]) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, size_t, int64_t [][2]);
    ON_ENTRY(aclSetTensorValueRange);
    f_ptr_t f = (f_ptr_t)(g_func_table[12]);
    return f(arg0, arg1, arg2);
}
aclDataType _WRAPLIB_API_CALL aclGetTensorDescType(const aclTensorDesc *arg0) {
    typedef aclDataType (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *);
    ON_ENTRY(aclGetTensorDescType);
    f_ptr_t f = (f_ptr_t)(g_func_table[13]);
    return f(arg0);
}
aclFormat _WRAPLIB_API_CALL aclGetTensorDescFormat(const aclTensorDesc *arg0) {
    typedef aclFormat (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *);
    ON_ENTRY(aclGetTensorDescFormat);
    f_ptr_t f = (f_ptr_t)(g_func_table[14]);
    return f(arg0);
}
size_t _WRAPLIB_API_CALL aclGetTensorDescSize(const aclTensorDesc *arg0) {
    typedef size_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *);
    ON_ENTRY(aclGetTensorDescSize);
    f_ptr_t f = (f_ptr_t)(g_func_table[15]);
    return f(arg0);
}
size_t _WRAPLIB_API_CALL aclGetTensorDescElementCount(const aclTensorDesc *arg0) {
    typedef size_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *);
    ON_ENTRY(aclGetTensorDescElementCount);
    f_ptr_t f = (f_ptr_t)(g_func_table[16]);
    return f(arg0);
}
size_t _WRAPLIB_API_CALL aclGetTensorDescNumDims(const aclTensorDesc *arg0) {
    typedef size_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *);
    ON_ENTRY(aclGetTensorDescNumDims);
    f_ptr_t f = (f_ptr_t)(g_func_table[17]);
    return f(arg0);
}
int64_t _WRAPLIB_API_CALL aclGetTensorDescDim(const aclTensorDesc *arg0, size_t arg1) {
    typedef int64_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *, size_t);
    ON_ENTRY(aclGetTensorDescDim);
    f_ptr_t f = (f_ptr_t)(g_func_table[18]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclGetTensorDescDimV2(const aclTensorDesc *arg0, size_t arg1, int64_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *, size_t, int64_t *);
    ON_ENTRY(aclGetTensorDescDimV2);
    f_ptr_t f = (f_ptr_t)(g_func_table[19]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclGetTensorDescDimRange(const aclTensorDesc *arg0, size_t arg1, size_t arg2, int64_t *arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *, size_t, size_t, int64_t *);
    ON_ENTRY(aclGetTensorDescDimRange);
    f_ptr_t f = (f_ptr_t)(g_func_table[20]);
    return f(arg0, arg1, arg2, arg3);
}
void _WRAPLIB_API_CALL aclSetTensorDescName(aclTensorDesc *arg0, const char *arg1) {
    typedef void (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, const char *);
    ON_ENTRY(aclSetTensorDescName);
    f_ptr_t f = (f_ptr_t)(g_func_table[21]);
    return f(arg0, arg1);
}
const char _WRAPLIB_API_CALL *aclGetTensorDescName(aclTensorDesc *arg0) {
    typedef const char *(_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *);
    ON_ENTRY(aclGetTensorDescName);
    f_ptr_t f = (f_ptr_t)(g_func_table[22]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclTransTensorDescFormat(const aclTensorDesc *arg0, aclFormat arg1, aclTensorDesc **arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *, aclFormat, aclTensorDesc **);
    ON_ENTRY(aclTransTensorDescFormat);
    f_ptr_t f = (f_ptr_t)(g_func_table[23]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclSetTensorStorageFormat(aclTensorDesc *arg0, aclFormat arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, aclFormat);
    ON_ENTRY(aclSetTensorStorageFormat);
    f_ptr_t f = (f_ptr_t)(g_func_table[24]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclSetTensorStorageShape(aclTensorDesc *arg0, int arg1, const int64_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, int, const int64_t *);
    ON_ENTRY(aclSetTensorStorageShape);
    f_ptr_t f = (f_ptr_t)(g_func_table[25]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclSetTensorFormat(aclTensorDesc *arg0, aclFormat arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, aclFormat);
    ON_ENTRY(aclSetTensorFormat);
    f_ptr_t f = (f_ptr_t)(g_func_table[26]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclSetTensorShape(aclTensorDesc *arg0, int arg1, const int64_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, int, const int64_t *);
    ON_ENTRY(aclSetTensorShape);
    f_ptr_t f = (f_ptr_t)(g_func_table[27]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclSetTensorOriginFormat(aclTensorDesc *arg0, aclFormat arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, aclFormat);
    ON_ENTRY(aclSetTensorOriginFormat);
    f_ptr_t f = (f_ptr_t)(g_func_table[28]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclSetTensorOriginShape(aclTensorDesc *arg0, int arg1, const int64_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, int, const int64_t *);
    ON_ENTRY(aclSetTensorOriginShape);
    f_ptr_t f = (f_ptr_t)(g_func_table[29]);
    return f(arg0, arg1, arg2);
}
aclTensorDesc _WRAPLIB_API_CALL *aclGetTensorDescByIndex(aclTensorDesc *arg0, size_t arg1) {
    typedef aclTensorDesc *(_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, size_t);
    ON_ENTRY(aclGetTensorDescByIndex);
    f_ptr_t f = (f_ptr_t)(g_func_table[30]);
    return f(arg0, arg1);
}
void _WRAPLIB_API_CALL *aclGetTensorDescAddress(const aclTensorDesc *arg0) {
    typedef void *(_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *);
    ON_ENTRY(aclGetTensorDescAddress);
    f_ptr_t f = (f_ptr_t)(g_func_table[31]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclSetTensorDynamicInput(aclTensorDesc *arg0, const char *arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, const char *);
    ON_ENTRY(aclSetTensorDynamicInput);
    f_ptr_t f = (f_ptr_t)(g_func_table[32]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclSetTensorConst(aclTensorDesc *arg0, void *arg1, size_t arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, void *, size_t);
    ON_ENTRY(aclSetTensorConst);
    f_ptr_t f = (f_ptr_t)(g_func_table[33]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclSetTensorPlaceMent(aclTensorDesc *arg0, aclMemType arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, aclMemType);
    ON_ENTRY(aclSetTensorPlaceMent);
    f_ptr_t f = (f_ptr_t)(g_func_table[34]);
    return f(arg0, arg1);
}
const char _WRAPLIB_API_CALL *aclrtGetSocName() {
    typedef const char *(_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclrtGetSocName);
    f_ptr_t f = (f_ptr_t)(g_func_table[35]);
    return f();
}
aclError _WRAPLIB_API_CALL aclrtSetExceptionInfoCallback(aclrtExceptionInfoCallback arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtExceptionInfoCallback);
    ON_ENTRY(aclrtSetExceptionInfoCallback);
    f_ptr_t f = (f_ptr_t)(g_func_table[36]);
    return f(arg0);
}
uint32_t _WRAPLIB_API_CALL aclrtGetTaskIdFromExceptionInfo(const aclrtExceptionInfo *arg0) {
    typedef uint32_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclrtExceptionInfo *);
    ON_ENTRY(aclrtGetTaskIdFromExceptionInfo);
    f_ptr_t f = (f_ptr_t)(g_func_table[37]);
    return f(arg0);
}
uint32_t _WRAPLIB_API_CALL aclrtGetStreamIdFromExceptionInfo(const aclrtExceptionInfo *arg0) {
    typedef uint32_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclrtExceptionInfo *);
    ON_ENTRY(aclrtGetStreamIdFromExceptionInfo);
    f_ptr_t f = (f_ptr_t)(g_func_table[38]);
    return f(arg0);
}
uint32_t _WRAPLIB_API_CALL aclrtGetThreadIdFromExceptionInfo(const aclrtExceptionInfo *arg0) {
    typedef uint32_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclrtExceptionInfo *);
    ON_ENTRY(aclrtGetThreadIdFromExceptionInfo);
    f_ptr_t f = (f_ptr_t)(g_func_table[39]);
    return f(arg0);
}
uint32_t _WRAPLIB_API_CALL aclrtGetDeviceIdFromExceptionInfo(const aclrtExceptionInfo *arg0) {
    typedef uint32_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclrtExceptionInfo *);
    ON_ENTRY(aclrtGetDeviceIdFromExceptionInfo);
    f_ptr_t f = (f_ptr_t)(g_func_table[40]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtSubscribeReport(uint64_t arg0, aclrtStream arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint64_t, aclrtStream);
    ON_ENTRY(aclrtSubscribeReport);
    f_ptr_t f = (f_ptr_t)(g_func_table[41]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtLaunchCallback(aclrtCallback arg0, void *arg1, aclrtCallbackBlockType arg2, aclrtStream arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtCallback, void *, aclrtCallbackBlockType, aclrtStream);
    ON_ENTRY(aclrtLaunchCallback);
    f_ptr_t f = (f_ptr_t)(g_func_table[42]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclrtProcessReport(int32_t arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(int32_t);
    ON_ENTRY(aclrtProcessReport);
    f_ptr_t f = (f_ptr_t)(g_func_table[43]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtUnSubscribeReport(uint64_t arg0, aclrtStream arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint64_t, aclrtStream);
    ON_ENTRY(aclrtUnSubscribeReport);
    f_ptr_t f = (f_ptr_t)(g_func_table[44]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtCreateContext(aclrtContext *arg0, int32_t arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtContext *, int32_t);
    ON_ENTRY(aclrtCreateContext);
    f_ptr_t f = (f_ptr_t)(g_func_table[45]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtDestroyContext(aclrtContext arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtContext);
    ON_ENTRY(aclrtDestroyContext);
    f_ptr_t f = (f_ptr_t)(g_func_table[46]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtSetCurrentContext(aclrtContext arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtContext);
    ON_ENTRY(aclrtSetCurrentContext);
    f_ptr_t f = (f_ptr_t)(g_func_table[47]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtGetCurrentContext(aclrtContext *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtContext *);
    ON_ENTRY(aclrtGetCurrentContext);
    f_ptr_t f = (f_ptr_t)(g_func_table[48]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtSetDevice(int32_t arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(int32_t);
    ON_ENTRY(aclrtSetDevice);
    f_ptr_t f = (f_ptr_t)(g_func_table[49]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtResetDevice(int32_t arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(int32_t);
    ON_ENTRY(aclrtResetDevice);
    f_ptr_t f = (f_ptr_t)(g_func_table[50]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtGetDevice(int32_t *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(int32_t *);
    ON_ENTRY(aclrtGetDevice);
    f_ptr_t f = (f_ptr_t)(g_func_table[51]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtGetRunMode(aclrtRunMode *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtRunMode *);
    ON_ENTRY(aclrtGetRunMode);
    f_ptr_t f = (f_ptr_t)(g_func_table[52]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtSynchronizeDevice() {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclrtSynchronizeDevice);
    f_ptr_t f = (f_ptr_t)(g_func_table[53]);
    return f();
}
aclError _WRAPLIB_API_CALL aclrtSetTsDevice(aclrtTsId arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtTsId);
    ON_ENTRY(aclrtSetTsDevice);
    f_ptr_t f = (f_ptr_t)(g_func_table[54]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtGetDeviceCount(uint32_t *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t *);
    ON_ENTRY(aclrtGetDeviceCount);
    f_ptr_t f = (f_ptr_t)(g_func_table[55]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtCreateEvent(aclrtEvent *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtEvent *);
    ON_ENTRY(aclrtCreateEvent);
    f_ptr_t f = (f_ptr_t)(g_func_table[56]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtCreateEventWithFlag(aclrtEvent *arg0, uint32_t arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtEvent *, uint32_t);
    ON_ENTRY(aclrtCreateEventWithFlag);
    f_ptr_t f = (f_ptr_t)(g_func_table[57]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtDestroyEvent(aclrtEvent arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtEvent);
    ON_ENTRY(aclrtDestroyEvent);
    f_ptr_t f = (f_ptr_t)(g_func_table[58]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtRecordEvent(aclrtEvent arg0, aclrtStream arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtEvent, aclrtStream);
    ON_ENTRY(aclrtRecordEvent);
    f_ptr_t f = (f_ptr_t)(g_func_table[59]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtResetEvent(aclrtEvent arg0, aclrtStream arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtEvent, aclrtStream);
    ON_ENTRY(aclrtResetEvent);
    f_ptr_t f = (f_ptr_t)(g_func_table[60]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtQueryEvent(aclrtEvent arg0, aclrtEventStatus *arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtEvent, aclrtEventStatus *);
    ON_ENTRY(aclrtQueryEvent);
    f_ptr_t f = (f_ptr_t)(g_func_table[61]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtQueryEventStatus(aclrtEvent arg0, aclrtEventRecordedStatus *arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtEvent, aclrtEventRecordedStatus *);
    ON_ENTRY(aclrtQueryEventStatus);
    f_ptr_t f = (f_ptr_t)(g_func_table[62]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtQueryEventWaitStatus(aclrtEvent arg0, aclrtEventWaitStatus *arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtEvent, aclrtEventWaitStatus *);
    ON_ENTRY(aclrtQueryEventWaitStatus);
    f_ptr_t f = (f_ptr_t)(g_func_table[63]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtSynchronizeEvent(aclrtEvent arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtEvent);
    ON_ENTRY(aclrtSynchronizeEvent);
    f_ptr_t f = (f_ptr_t)(g_func_table[64]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtEventElapsedTime(float *arg0, aclrtEvent arg1, aclrtEvent arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(float *, aclrtEvent, aclrtEvent);
    ON_ENTRY(aclrtEventElapsedTime);
    f_ptr_t f = (f_ptr_t)(g_func_table[65]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclrtMalloc(void **arg0, size_t arg1, aclrtMemMallocPolicy arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t, aclrtMemMallocPolicy);
    ON_ENTRY(aclrtMalloc);
    f_ptr_t f = (f_ptr_t)(g_func_table[66]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclrtMallocCached(void **arg0, size_t arg1, aclrtMemMallocPolicy arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t, aclrtMemMallocPolicy);
    ON_ENTRY(aclrtMallocCached);
    f_ptr_t f = (f_ptr_t)(g_func_table[67]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclrtMemFlush(void *arg0, size_t arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t);
    ON_ENTRY(aclrtMemFlush);
    f_ptr_t f = (f_ptr_t)(g_func_table[68]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtMemInvalidate(void *arg0, size_t arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t);
    ON_ENTRY(aclrtMemInvalidate);
    f_ptr_t f = (f_ptr_t)(g_func_table[69]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtFree(void *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void *);
    ON_ENTRY(aclrtFree);
    f_ptr_t f = (f_ptr_t)(g_func_table[70]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtMallocHost(void **arg0, size_t arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void **, size_t);
    ON_ENTRY(aclrtMallocHost);
    f_ptr_t f = (f_ptr_t)(g_func_table[71]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtFreeHost(void *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void *);
    ON_ENTRY(aclrtFreeHost);
    f_ptr_t f = (f_ptr_t)(g_func_table[72]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtMemcpy(void *arg0, size_t arg1, const void *arg2, size_t arg3, aclrtMemcpyKind arg4) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, const void *, size_t, aclrtMemcpyKind);
    ON_ENTRY(aclrtMemcpy);
    f_ptr_t f = (f_ptr_t)(g_func_table[73]);
    return f(arg0, arg1, arg2, arg3, arg4);
}
aclError _WRAPLIB_API_CALL aclrtMemset(void *arg0, size_t arg1, int32_t arg2, size_t arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, int32_t, size_t);
    ON_ENTRY(aclrtMemset);
    f_ptr_t f = (f_ptr_t)(g_func_table[74]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclrtMemcpyAsync(void *arg0, size_t arg1, const void *arg2, size_t arg3, aclrtMemcpyKind arg4, aclrtStream arg5) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, const void *, size_t, aclrtMemcpyKind, aclrtStream);
    ON_ENTRY(aclrtMemcpyAsync);
    f_ptr_t f = (f_ptr_t)(g_func_table[75]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
aclError _WRAPLIB_API_CALL aclrtMemcpy2d(void *arg0, size_t arg1, const void *arg2, size_t arg3, size_t arg4, size_t arg5, aclrtMemcpyKind arg6) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, const void *, size_t, size_t, size_t, aclrtMemcpyKind);
    ON_ENTRY(aclrtMemcpy2d);
    f_ptr_t f = (f_ptr_t)(g_func_table[76]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
aclError _WRAPLIB_API_CALL aclrtMemcpy2dAsync(void *arg0, size_t arg1, const void *arg2, size_t arg3, size_t arg4, size_t arg5, aclrtMemcpyKind arg6, aclrtStream arg7) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, const void *, size_t, size_t, size_t, aclrtMemcpyKind, aclrtStream);
    ON_ENTRY(aclrtMemcpy2dAsync);
    f_ptr_t f = (f_ptr_t)(g_func_table[77]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}
aclError _WRAPLIB_API_CALL aclrtMemsetAsync(void *arg0, size_t arg1, int32_t arg2, size_t arg3, aclrtStream arg4) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(void *, size_t, int32_t, size_t, aclrtStream);
    ON_ENTRY(aclrtMemsetAsync);
    f_ptr_t f = (f_ptr_t)(g_func_table[78]);
    return f(arg0, arg1, arg2, arg3, arg4);
}
aclError _WRAPLIB_API_CALL aclrtCreateStream(aclrtStream *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtStream *);
    ON_ENTRY(aclrtCreateStream);
    f_ptr_t f = (f_ptr_t)(g_func_table[79]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtDestroyStream(aclrtStream arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtStream);
    ON_ENTRY(aclrtDestroyStream);
    f_ptr_t f = (f_ptr_t)(g_func_table[80]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtSynchronizeStream(aclrtStream arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtStream);
    ON_ENTRY(aclrtSynchronizeStream);
    f_ptr_t f = (f_ptr_t)(g_func_table[81]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtStreamWaitEvent(aclrtStream arg0, aclrtEvent arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtStream, aclrtEvent);
    ON_ENTRY(aclrtStreamWaitEvent);
    f_ptr_t f = (f_ptr_t)(g_func_table[82]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtSetGroup(int32_t arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(int32_t);
    ON_ENTRY(aclrtSetGroup);
    f_ptr_t f = (f_ptr_t)(g_func_table[83]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtGetGroupCount(uint32_t *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t *);
    ON_ENTRY(aclrtGetGroupCount);
    f_ptr_t f = (f_ptr_t)(g_func_table[84]);
    return f(arg0);
}
aclrtGroupInfo _WRAPLIB_API_CALL *aclrtCreateGroupInfo() {
    typedef aclrtGroupInfo *(_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclrtCreateGroupInfo);
    f_ptr_t f = (f_ptr_t)(g_func_table[85]);
    return f();
}
aclError _WRAPLIB_API_CALL aclrtDestroyGroupInfo(aclrtGroupInfo *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtGroupInfo *);
    ON_ENTRY(aclrtDestroyGroupInfo);
    f_ptr_t f = (f_ptr_t)(g_func_table[86]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtGetAllGroupInfo(aclrtGroupInfo *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtGroupInfo *);
    ON_ENTRY(aclrtGetAllGroupInfo);
    f_ptr_t f = (f_ptr_t)(g_func_table[87]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtGetGroupInfoDetail(const aclrtGroupInfo *arg0, int32_t arg1, aclrtGroupAttr arg2, void *arg3, size_t arg4, size_t *arg5) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclrtGroupInfo *, int32_t, aclrtGroupAttr, void *, size_t, size_t *);
    ON_ENTRY(aclrtGetGroupInfoDetail);
    f_ptr_t f = (f_ptr_t)(g_func_table[88]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
aclError _WRAPLIB_API_CALL aclrtDeviceCanAccessPeer(int32_t *arg0, int32_t arg1, int32_t arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(int32_t *, int32_t, int32_t);
    ON_ENTRY(aclrtDeviceCanAccessPeer);
    f_ptr_t f = (f_ptr_t)(g_func_table[89]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclrtDeviceEnablePeerAccess(int32_t arg0, uint32_t arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(int32_t, uint32_t);
    ON_ENTRY(aclrtDeviceEnablePeerAccess);
    f_ptr_t f = (f_ptr_t)(g_func_table[90]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclrtDeviceDisablePeerAccess(int32_t arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(int32_t);
    ON_ENTRY(aclrtDeviceDisablePeerAccess);
    f_ptr_t f = (f_ptr_t)(g_func_table[91]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclrtGetMemInfo(aclrtMemAttr arg0, size_t *arg1, size_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclrtMemAttr, size_t *, size_t *);
    ON_ENTRY(aclrtGetMemInfo);
    f_ptr_t f = (f_ptr_t)(g_func_table[92]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclrtSetOpWaitTimeout(uint32_t arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t);
    ON_ENTRY(aclrtSetOpWaitTimeout);
    f_ptr_t f = (f_ptr_t)(g_func_table[93]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclopSetModelDir(const char *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *);
    ON_ENTRY(aclopSetModelDir);
    f_ptr_t f = (f_ptr_t)(g_func_table[94]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclopLoad(const void *arg0, size_t arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const void *, size_t);
    ON_ENTRY(aclopLoad);
    f_ptr_t f = (f_ptr_t)(g_func_table[95]);
    return f(arg0, arg1);
}
aclopAttr _WRAPLIB_API_CALL *aclopCreateAttr() {
    typedef aclopAttr *(_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclopCreateAttr);
    f_ptr_t f = (f_ptr_t)(g_func_table[96]);
    return f();
}
void _WRAPLIB_API_CALL aclopDestroyAttr(const aclopAttr *arg0) {
    typedef void (_WRAPLIB_API_CALL *f_ptr_t)(const aclopAttr *);
    ON_ENTRY(aclopDestroyAttr);
    f_ptr_t f = (f_ptr_t)(g_func_table[97]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclopSetAttrBool(aclopAttr *arg0, const char *arg1, uint8_t arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, uint8_t);
    ON_ENTRY(aclopSetAttrBool);
    f_ptr_t f = (f_ptr_t)(g_func_table[98]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclopSetAttrInt(aclopAttr *arg0, const char *arg1, int64_t arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, int64_t);
    ON_ENTRY(aclopSetAttrInt);
    f_ptr_t f = (f_ptr_t)(g_func_table[99]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclopSetAttrFloat(aclopAttr *arg0, const char *arg1, float arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, float);
    ON_ENTRY(aclopSetAttrFloat);
    f_ptr_t f = (f_ptr_t)(g_func_table[100]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclopSetAttrString(aclopAttr *arg0, const char *arg1, const char *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, const char *);
    ON_ENTRY(aclopSetAttrString);
    f_ptr_t f = (f_ptr_t)(g_func_table[101]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclopSetAttrDataType(aclopAttr *arg0, const char *arg1, aclDataType arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, aclDataType);
    ON_ENTRY(aclopSetAttrDataType);
    f_ptr_t f = (f_ptr_t)(g_func_table[102]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclopSetAttrListDataType(aclopAttr *arg0, const char *arg1, int arg2, const aclDataType arg3[]) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, int, const aclDataType []);
    ON_ENTRY(aclopSetAttrListDataType);
    f_ptr_t f = (f_ptr_t)(g_func_table[103]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclopSetAttrListBool(aclopAttr *arg0, const char *arg1, int arg2, const uint8_t *arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, int, const uint8_t *);
    ON_ENTRY(aclopSetAttrListBool);
    f_ptr_t f = (f_ptr_t)(g_func_table[104]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclopSetAttrListInt(aclopAttr *arg0, const char *arg1, int arg2, const int64_t *arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, int, const int64_t *);
    ON_ENTRY(aclopSetAttrListInt);
    f_ptr_t f = (f_ptr_t)(g_func_table[105]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclopSetAttrListFloat(aclopAttr *arg0, const char *arg1, int arg2, const float *arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, int, const float *);
    ON_ENTRY(aclopSetAttrListFloat);
    f_ptr_t f = (f_ptr_t)(g_func_table[106]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclopSetAttrListString(aclopAttr *arg0, const char *arg1, int arg2, const char **arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, int, const char **);
    ON_ENTRY(aclopSetAttrListString);
    f_ptr_t f = (f_ptr_t)(g_func_table[107]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclopSetAttrListListInt(aclopAttr *arg0, const char *arg1, int arg2, const int *arg3, const int64_t * const arg4[]) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopAttr *, const char *, int, const int *, const int64_t * const []);
    ON_ENTRY(aclopSetAttrListListInt);
    f_ptr_t f = (f_ptr_t)(g_func_table[108]);
    return f(arg0, arg1, arg2, arg3, arg4);
}
aclError _WRAPLIB_API_CALL aclopExecute(const char *arg0, int arg1, const aclTensorDesc * const arg2[], const aclDataBuffer * const arg3[], int arg4, const aclTensorDesc * const arg5[], aclDataBuffer * const arg6[], const aclopAttr *arg7, aclrtStream arg8) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, int, const aclTensorDesc * const [], const aclDataBuffer * const [], int, const aclTensorDesc * const [], aclDataBuffer * const [], const aclopAttr *, aclrtStream);
    ON_ENTRY(aclopExecute);
    f_ptr_t f = (f_ptr_t)(g_func_table[109]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
aclError _WRAPLIB_API_CALL aclopExecuteV2(const char *arg0, int arg1, aclTensorDesc *arg2[], aclDataBuffer *arg3[], int arg4, aclTensorDesc *arg5[], aclDataBuffer *arg6[], aclopAttr *arg7, aclrtStream arg8) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, int, aclTensorDesc *[], aclDataBuffer *[], int, aclTensorDesc *[], aclDataBuffer *[], aclopAttr *, aclrtStream);
    ON_ENTRY(aclopExecuteV2);
    f_ptr_t f = (f_ptr_t)(g_func_table[110]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
aclError _WRAPLIB_API_CALL aclopCreateHandle(const char *arg0, int arg1, const aclTensorDesc * const arg2[], int arg3, const aclTensorDesc * const arg4[], const aclopAttr *arg5, aclopHandle **arg6) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, int, const aclTensorDesc * const [], int, const aclTensorDesc * const [], const aclopAttr *, aclopHandle **);
    ON_ENTRY(aclopCreateHandle);
    f_ptr_t f = (f_ptr_t)(g_func_table[111]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
void _WRAPLIB_API_CALL aclopDestroyHandle(aclopHandle *arg0) {
    typedef void (_WRAPLIB_API_CALL *f_ptr_t)(aclopHandle *);
    ON_ENTRY(aclopDestroyHandle);
    f_ptr_t f = (f_ptr_t)(g_func_table[112]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclopExecWithHandle(aclopHandle *arg0, int arg1, const aclDataBuffer * const arg2[], int arg3, aclDataBuffer * const arg4[], aclrtStream arg5) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopHandle *, int, const aclDataBuffer * const [], int, aclDataBuffer * const [], aclrtStream);
    ON_ENTRY(aclopExecWithHandle);
    f_ptr_t f = (f_ptr_t)(g_func_table[113]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
aclError _WRAPLIB_API_CALL aclopCast(const aclTensorDesc *arg0, const aclDataBuffer *arg1, const aclTensorDesc *arg2, aclDataBuffer *arg3, uint8_t arg4, aclrtStream arg5) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclTensorDesc *, const aclDataBuffer *, const aclTensorDesc *, aclDataBuffer *, uint8_t, aclrtStream);
    ON_ENTRY(aclopCast);
    f_ptr_t f = (f_ptr_t)(g_func_table[114]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
aclError _WRAPLIB_API_CALL aclopCreateHandleForCast(aclTensorDesc *arg0, aclTensorDesc *arg1, uint8_t arg2, aclopHandle **arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclTensorDesc *, aclTensorDesc *, uint8_t, aclopHandle **);
    ON_ENTRY(aclopCreateHandleForCast);
    f_ptr_t f = (f_ptr_t)(g_func_table[115]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclopCreateKernel(const char *arg0, const char *arg1, const char *arg2, void *arg3, int arg4, aclopEngineType arg5, aclDataDeallocator arg6) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, const char *, const char *, void *, int, aclopEngineType, aclDataDeallocator);
    ON_ENTRY(aclopCreateKernel);
    f_ptr_t f = (f_ptr_t)(g_func_table[116]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
aclError _WRAPLIB_API_CALL aclopRegisterCompileFunc(const char *arg0, aclopCompileFunc arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, aclopCompileFunc);
    ON_ENTRY(aclopRegisterCompileFunc);
    f_ptr_t f = (f_ptr_t)(g_func_table[117]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclopUnregisterCompileFunc(const char *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *);
    ON_ENTRY(aclopUnregisterCompileFunc);
    f_ptr_t f = (f_ptr_t)(g_func_table[118]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclopSetKernelArgs(aclopKernelDesc *arg0, const char *arg1, uint32_t arg2, const void *arg3, uint32_t arg4) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopKernelDesc *, const char *, uint32_t, const void *, uint32_t);
    ON_ENTRY(aclopSetKernelArgs);
    f_ptr_t f = (f_ptr_t)(g_func_table[119]);
    return f(arg0, arg1, arg2, arg3, arg4);
}
aclError _WRAPLIB_API_CALL aclopSetKernelWorkspaceSizes(aclopKernelDesc *arg0, int arg1, size_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclopKernelDesc *, int, size_t *);
    ON_ENTRY(aclopSetKernelWorkspaceSizes);
    f_ptr_t f = (f_ptr_t)(g_func_table[120]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclopUpdateParams(const char *arg0, int arg1, const aclTensorDesc * const arg2[], int arg3, const aclTensorDesc * const arg4[], const aclopAttr *arg5) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, int, const aclTensorDesc * const [], int, const aclTensorDesc * const [], const aclopAttr *);
    ON_ENTRY(aclopUpdateParams);
    f_ptr_t f = (f_ptr_t)(g_func_table[121]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
aclError _WRAPLIB_API_CALL aclopInferShape(const char *arg0, int arg1, aclTensorDesc *arg2[], aclDataBuffer *arg3[], int arg4, aclTensorDesc *arg5[], aclopAttr *arg6) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, int, aclTensorDesc *[], aclDataBuffer *[], int, aclTensorDesc *[], aclopAttr *);
    ON_ENTRY(aclopInferShape);
    f_ptr_t f = (f_ptr_t)(g_func_table[122]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
aclmdlDesc _WRAPLIB_API_CALL *aclmdlCreateDesc() {
    typedef aclmdlDesc *(_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclmdlCreateDesc);
    f_ptr_t f = (f_ptr_t)(g_func_table[123]);
    return f();
}
aclError _WRAPLIB_API_CALL aclmdlDestroyDesc(aclmdlDesc *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlDesc *);
    ON_ENTRY(aclmdlDestroyDesc);
    f_ptr_t f = (f_ptr_t)(g_func_table[124]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclmdlGetDesc(aclmdlDesc *arg0, uint32_t arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlDesc *, uint32_t);
    ON_ENTRY(aclmdlGetDesc);
    f_ptr_t f = (f_ptr_t)(g_func_table[125]);
    return f(arg0, arg1);
}
size_t _WRAPLIB_API_CALL aclmdlGetNumInputs(aclmdlDesc *arg0) {
    typedef size_t (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlDesc *);
    ON_ENTRY(aclmdlGetNumInputs);
    f_ptr_t f = (f_ptr_t)(g_func_table[126]);
    return f(arg0);
}
size_t _WRAPLIB_API_CALL aclmdlGetNumOutputs(aclmdlDesc *arg0) {
    typedef size_t (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlDesc *);
    ON_ENTRY(aclmdlGetNumOutputs);
    f_ptr_t f = (f_ptr_t)(g_func_table[127]);
    return f(arg0);
}
size_t _WRAPLIB_API_CALL aclmdlGetInputSizeByIndex(aclmdlDesc *arg0, size_t arg1) {
    typedef size_t (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlDesc *, size_t);
    ON_ENTRY(aclmdlGetInputSizeByIndex);
    f_ptr_t f = (f_ptr_t)(g_func_table[128]);
    return f(arg0, arg1);
}
size_t _WRAPLIB_API_CALL aclmdlGetOutputSizeByIndex(aclmdlDesc *arg0, size_t arg1) {
    typedef size_t (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlDesc *, size_t);
    ON_ENTRY(aclmdlGetOutputSizeByIndex);
    f_ptr_t f = (f_ptr_t)(g_func_table[129]);
    return f(arg0, arg1);
}
aclmdlDataset _WRAPLIB_API_CALL *aclmdlCreateDataset() {
    typedef aclmdlDataset *(_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclmdlCreateDataset);
    f_ptr_t f = (f_ptr_t)(g_func_table[130]);
    return f();
}
aclError _WRAPLIB_API_CALL aclmdlDestroyDataset(const aclmdlDataset *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDataset *);
    ON_ENTRY(aclmdlDestroyDataset);
    f_ptr_t f = (f_ptr_t)(g_func_table[131]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclmdlAddDatasetBuffer(aclmdlDataset *arg0, aclDataBuffer *arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlDataset *, aclDataBuffer *);
    ON_ENTRY(aclmdlAddDatasetBuffer);
    f_ptr_t f = (f_ptr_t)(g_func_table[132]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclmdlSetDatasetTensorDesc(aclmdlDataset *arg0, aclTensorDesc *arg1, size_t arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlDataset *, aclTensorDesc *, size_t);
    ON_ENTRY(aclmdlSetDatasetTensorDesc);
    f_ptr_t f = (f_ptr_t)(g_func_table[133]);
    return f(arg0, arg1, arg2);
}
aclTensorDesc _WRAPLIB_API_CALL *aclmdlGetDatasetTensorDesc(const aclmdlDataset *arg0, size_t arg1) {
    typedef aclTensorDesc *(_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDataset *, size_t);
    ON_ENTRY(aclmdlGetDatasetTensorDesc);
    f_ptr_t f = (f_ptr_t)(g_func_table[134]);
    return f(arg0, arg1);
}
size_t _WRAPLIB_API_CALL aclmdlGetDatasetNumBuffers(const aclmdlDataset *arg0) {
    typedef size_t (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDataset *);
    ON_ENTRY(aclmdlGetDatasetNumBuffers);
    f_ptr_t f = (f_ptr_t)(g_func_table[135]);
    return f(arg0);
}
aclDataBuffer _WRAPLIB_API_CALL *aclmdlGetDatasetBuffer(const aclmdlDataset *arg0, size_t arg1) {
    typedef aclDataBuffer *(_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDataset *, size_t);
    ON_ENTRY(aclmdlGetDatasetBuffer);
    f_ptr_t f = (f_ptr_t)(g_func_table[136]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclmdlLoadFromFile(const char *arg0, uint32_t *arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, uint32_t *);
    ON_ENTRY(aclmdlLoadFromFile);
    f_ptr_t f = (f_ptr_t)(g_func_table[137]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclmdlLoadFromMem(const void *arg0, size_t arg1, uint32_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const void *, size_t, uint32_t *);
    ON_ENTRY(aclmdlLoadFromMem);
    f_ptr_t f = (f_ptr_t)(g_func_table[138]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlLoadFromFileWithMem(const char *arg0, uint32_t *arg1, void *arg2, size_t arg3, void *arg4, size_t arg5) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, uint32_t *, void *, size_t, void *, size_t);
    ON_ENTRY(aclmdlLoadFromFileWithMem);
    f_ptr_t f = (f_ptr_t)(g_func_table[139]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
aclError _WRAPLIB_API_CALL aclmdlLoadFromMemWithMem(const void *arg0, size_t arg1, uint32_t *arg2, void *arg3, size_t arg4, void *arg5, size_t arg6) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const void *, size_t, uint32_t *, void *, size_t, void *, size_t);
    ON_ENTRY(aclmdlLoadFromMemWithMem);
    f_ptr_t f = (f_ptr_t)(g_func_table[140]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
aclError _WRAPLIB_API_CALL aclmdlLoadFromFileWithQ(const char *arg0, uint32_t *arg1, const uint32_t *arg2, size_t arg3, const uint32_t *arg4, size_t arg5) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, uint32_t *, const uint32_t *, size_t, const uint32_t *, size_t);
    ON_ENTRY(aclmdlLoadFromFileWithQ);
    f_ptr_t f = (f_ptr_t)(g_func_table[141]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
aclError _WRAPLIB_API_CALL aclmdlLoadFromMemWithQ(const void *arg0, size_t arg1, uint32_t *arg2, const uint32_t *arg3, size_t arg4, const uint32_t *arg5, size_t arg6) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const void *, size_t, uint32_t *, const uint32_t *, size_t, const uint32_t *, size_t);
    ON_ENTRY(aclmdlLoadFromMemWithQ);
    f_ptr_t f = (f_ptr_t)(g_func_table[142]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
aclError _WRAPLIB_API_CALL aclmdlExecute(uint32_t arg0, const aclmdlDataset *arg1, aclmdlDataset *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t, const aclmdlDataset *, aclmdlDataset *);
    ON_ENTRY(aclmdlExecute);
    f_ptr_t f = (f_ptr_t)(g_func_table[143]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlExecuteAsync(uint32_t arg0, const aclmdlDataset *arg1, aclmdlDataset *arg2, aclrtStream arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t, const aclmdlDataset *, aclmdlDataset *, aclrtStream);
    ON_ENTRY(aclmdlExecuteAsync);
    f_ptr_t f = (f_ptr_t)(g_func_table[144]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclmdlUnload(uint32_t arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t);
    ON_ENTRY(aclmdlUnload);
    f_ptr_t f = (f_ptr_t)(g_func_table[145]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclmdlQuerySize(const char *arg0, size_t *arg1, size_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *, size_t *, size_t *);
    ON_ENTRY(aclmdlQuerySize);
    f_ptr_t f = (f_ptr_t)(g_func_table[146]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlQuerySizeFromMem(const void *arg0, size_t arg1, size_t *arg2, size_t *arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const void *, size_t, size_t *, size_t *);
    ON_ENTRY(aclmdlQuerySizeFromMem);
    f_ptr_t f = (f_ptr_t)(g_func_table[147]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclmdlSetDynamicBatchSize(uint32_t arg0, aclmdlDataset *arg1, size_t arg2, uint64_t arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t, aclmdlDataset *, size_t, uint64_t);
    ON_ENTRY(aclmdlSetDynamicBatchSize);
    f_ptr_t f = (f_ptr_t)(g_func_table[148]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclmdlSetDynamicHWSize(uint32_t arg0, aclmdlDataset *arg1, size_t arg2, uint64_t arg3, uint64_t arg4) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t, aclmdlDataset *, size_t, uint64_t, uint64_t);
    ON_ENTRY(aclmdlSetDynamicHWSize);
    f_ptr_t f = (f_ptr_t)(g_func_table[149]);
    return f(arg0, arg1, arg2, arg3, arg4);
}
aclError _WRAPLIB_API_CALL aclmdlSetInputDynamicDims(uint32_t arg0, aclmdlDataset *arg1, size_t arg2, const aclmdlIODims *arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t, aclmdlDataset *, size_t, const aclmdlIODims *);
    ON_ENTRY(aclmdlSetInputDynamicDims);
    f_ptr_t f = (f_ptr_t)(g_func_table[150]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclmdlGetInputDims(const aclmdlDesc *arg0, size_t arg1, aclmdlIODims *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t, aclmdlIODims *);
    ON_ENTRY(aclmdlGetInputDims);
    f_ptr_t f = (f_ptr_t)(g_func_table[151]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlGetInputDimsV2(const aclmdlDesc *arg0, size_t arg1, aclmdlIODims *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t, aclmdlIODims *);
    ON_ENTRY(aclmdlGetInputDimsV2);
    f_ptr_t f = (f_ptr_t)(g_func_table[152]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlGetOutputDims(const aclmdlDesc *arg0, size_t arg1, aclmdlIODims *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t, aclmdlIODims *);
    ON_ENTRY(aclmdlGetOutputDims);
    f_ptr_t f = (f_ptr_t)(g_func_table[153]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlGetCurOutputDims(const aclmdlDesc *arg0, size_t arg1, aclmdlIODims *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t, aclmdlIODims *);
    ON_ENTRY(aclmdlGetCurOutputDims);
    f_ptr_t f = (f_ptr_t)(g_func_table[154]);
    return f(arg0, arg1, arg2);
}
const char _WRAPLIB_API_CALL *aclmdlGetOpAttr(aclmdlDesc *arg0, const char *arg1, const char *arg2) {
    typedef const char *(_WRAPLIB_API_CALL *f_ptr_t)(aclmdlDesc *, const char *, const char *);
    ON_ENTRY(aclmdlGetOpAttr);
    f_ptr_t f = (f_ptr_t)(g_func_table[155]);
    return f(arg0, arg1, arg2);
}
const char _WRAPLIB_API_CALL *aclmdlGetInputNameByIndex(const aclmdlDesc *arg0, size_t arg1) {
    typedef const char *(_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t);
    ON_ENTRY(aclmdlGetInputNameByIndex);
    f_ptr_t f = (f_ptr_t)(g_func_table[156]);
    return f(arg0, arg1);
}
const char _WRAPLIB_API_CALL *aclmdlGetOutputNameByIndex(const aclmdlDesc *arg0, size_t arg1) {
    typedef const char *(_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t);
    ON_ENTRY(aclmdlGetOutputNameByIndex);
    f_ptr_t f = (f_ptr_t)(g_func_table[157]);
    return f(arg0, arg1);
}
aclFormat _WRAPLIB_API_CALL aclmdlGetInputFormat(const aclmdlDesc *arg0, size_t arg1) {
    typedef aclFormat (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t);
    ON_ENTRY(aclmdlGetInputFormat);
    f_ptr_t f = (f_ptr_t)(g_func_table[158]);
    return f(arg0, arg1);
}
aclFormat _WRAPLIB_API_CALL aclmdlGetOutputFormat(const aclmdlDesc *arg0, size_t arg1) {
    typedef aclFormat (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t);
    ON_ENTRY(aclmdlGetOutputFormat);
    f_ptr_t f = (f_ptr_t)(g_func_table[159]);
    return f(arg0, arg1);
}
aclDataType _WRAPLIB_API_CALL aclmdlGetInputDataType(const aclmdlDesc *arg0, size_t arg1) {
    typedef aclDataType (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t);
    ON_ENTRY(aclmdlGetInputDataType);
    f_ptr_t f = (f_ptr_t)(g_func_table[160]);
    return f(arg0, arg1);
}
aclDataType _WRAPLIB_API_CALL aclmdlGetOutputDataType(const aclmdlDesc *arg0, size_t arg1) {
    typedef aclDataType (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t);
    ON_ENTRY(aclmdlGetOutputDataType);
    f_ptr_t f = (f_ptr_t)(g_func_table[161]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclmdlGetInputIndexByName(const aclmdlDesc *arg0, const char *arg1, size_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, const char *, size_t *);
    ON_ENTRY(aclmdlGetInputIndexByName);
    f_ptr_t f = (f_ptr_t)(g_func_table[162]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlGetOutputIndexByName(const aclmdlDesc *arg0, const char *arg1, size_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, const char *, size_t *);
    ON_ENTRY(aclmdlGetOutputIndexByName);
    f_ptr_t f = (f_ptr_t)(g_func_table[163]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlGetDynamicBatch(const aclmdlDesc *arg0, aclmdlBatch *arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, aclmdlBatch *);
    ON_ENTRY(aclmdlGetDynamicBatch);
    f_ptr_t f = (f_ptr_t)(g_func_table[164]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclmdlGetDynamicHW(const aclmdlDesc *arg0, size_t arg1, aclmdlHW *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t, aclmdlHW *);
    ON_ENTRY(aclmdlGetDynamicHW);
    f_ptr_t f = (f_ptr_t)(g_func_table[165]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlGetInputDynamicGearCount(const aclmdlDesc *arg0, size_t arg1, size_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t, size_t *);
    ON_ENTRY(aclmdlGetInputDynamicGearCount);
    f_ptr_t f = (f_ptr_t)(g_func_table[166]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlGetInputDynamicDims(const aclmdlDesc *arg0, size_t arg1, aclmdlIODims *arg2, size_t arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, size_t, aclmdlIODims *, size_t);
    ON_ENTRY(aclmdlGetInputDynamicDims);
    f_ptr_t f = (f_ptr_t)(g_func_table[167]);
    return f(arg0, arg1, arg2, arg3);
}
aclmdlAIPP _WRAPLIB_API_CALL *aclmdlCreateAIPP(uint64_t arg0) {
    typedef aclmdlAIPP *(_WRAPLIB_API_CALL *f_ptr_t)(uint64_t);
    ON_ENTRY(aclmdlCreateAIPP);
    f_ptr_t f = (f_ptr_t)(g_func_table[168]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclmdlDestroyAIPP(const aclmdlAIPP *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlAIPP *);
    ON_ENTRY(aclmdlDestroyAIPP);
    f_ptr_t f = (f_ptr_t)(g_func_table[169]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPInputFormat(aclmdlAIPP *arg0, aclAippInputFormat arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, aclAippInputFormat);
    ON_ENTRY(aclmdlSetAIPPInputFormat);
    f_ptr_t f = (f_ptr_t)(g_func_table[170]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPCscParams(aclmdlAIPP *arg0, int8_t arg1, int16_t arg2, int16_t arg3, int16_t arg4, int16_t arg5, int16_t arg6, int16_t arg7, int16_t arg8, int16_t arg9, int16_t arg10, uint8_t arg11, uint8_t arg12, uint8_t arg13, uint8_t arg14, uint8_t arg15, uint8_t arg16) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, int8_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t, uint8_t);
    ON_ENTRY(aclmdlSetAIPPCscParams);
    f_ptr_t f = (f_ptr_t)(g_func_table[171]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPRbuvSwapSwitch(aclmdlAIPP *arg0, int8_t arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, int8_t);
    ON_ENTRY(aclmdlSetAIPPRbuvSwapSwitch);
    f_ptr_t f = (f_ptr_t)(g_func_table[172]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPAxSwapSwitch(aclmdlAIPP *arg0, int8_t arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, int8_t);
    ON_ENTRY(aclmdlSetAIPPAxSwapSwitch);
    f_ptr_t f = (f_ptr_t)(g_func_table[173]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPSrcImageSize(aclmdlAIPP *arg0, int32_t arg1, int32_t arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, int32_t, int32_t);
    ON_ENTRY(aclmdlSetAIPPSrcImageSize);
    f_ptr_t f = (f_ptr_t)(g_func_table[174]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPScfParams(aclmdlAIPP *arg0, int8_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5, uint64_t arg6) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, int8_t, int32_t, int32_t, int32_t, int32_t, uint64_t);
    ON_ENTRY(aclmdlSetAIPPScfParams);
    f_ptr_t f = (f_ptr_t)(g_func_table[175]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPCropParams(aclmdlAIPP *arg0, int8_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5, uint64_t arg6) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, int8_t, int32_t, int32_t, int32_t, int32_t, uint64_t);
    ON_ENTRY(aclmdlSetAIPPCropParams);
    f_ptr_t f = (f_ptr_t)(g_func_table[176]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPPaddingParams(aclmdlAIPP *arg0, int8_t arg1, int32_t arg2, int32_t arg3, int32_t arg4, int32_t arg5, uint64_t arg6) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, int8_t, int32_t, int32_t, int32_t, int32_t, uint64_t);
    ON_ENTRY(aclmdlSetAIPPPaddingParams);
    f_ptr_t f = (f_ptr_t)(g_func_table[177]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPDtcPixelMean(aclmdlAIPP *arg0, int16_t arg1, int16_t arg2, int16_t arg3, int16_t arg4, uint64_t arg5) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, int16_t, int16_t, int16_t, int16_t, uint64_t);
    ON_ENTRY(aclmdlSetAIPPDtcPixelMean);
    f_ptr_t f = (f_ptr_t)(g_func_table[178]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPDtcPixelMin(aclmdlAIPP *arg0, float arg1, float arg2, float arg3, float arg4, uint64_t arg5) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, float, float, float, float, uint64_t);
    ON_ENTRY(aclmdlSetAIPPDtcPixelMin);
    f_ptr_t f = (f_ptr_t)(g_func_table[179]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPPixelVarReci(aclmdlAIPP *arg0, float arg1, float arg2, float arg3, float arg4, uint64_t arg5) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlAIPP *, float, float, float, float, uint64_t);
    ON_ENTRY(aclmdlSetAIPPPixelVarReci);
    f_ptr_t f = (f_ptr_t)(g_func_table[180]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
aclError _WRAPLIB_API_CALL aclmdlSetInputAIPP(uint32_t arg0, aclmdlDataset *arg1, size_t arg2, const aclmdlAIPP *arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t, aclmdlDataset *, size_t, const aclmdlAIPP *);
    ON_ENTRY(aclmdlSetInputAIPP);
    f_ptr_t f = (f_ptr_t)(g_func_table[181]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclmdlSetAIPPByInputIndex(uint32_t arg0, aclmdlDataset *arg1, size_t arg2, const aclmdlAIPP *arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t, aclmdlDataset *, size_t, const aclmdlAIPP *);
    ON_ENTRY(aclmdlSetAIPPByInputIndex);
    f_ptr_t f = (f_ptr_t)(g_func_table[182]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclmdlGetAippType(uint32_t arg0, size_t arg1, aclmdlInputAippType *arg2, size_t *arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t, size_t, aclmdlInputAippType *, size_t *);
    ON_ENTRY(aclmdlGetAippType);
    f_ptr_t f = (f_ptr_t)(g_func_table[183]);
    return f(arg0, arg1, arg2, arg3);
}
aclError _WRAPLIB_API_CALL aclmdlGetFirstAippInfo(uint32_t arg0, size_t arg1, aclAippInfo *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t, size_t, aclAippInfo *);
    ON_ENTRY(aclmdlGetFirstAippInfo);
    f_ptr_t f = (f_ptr_t)(g_func_table[184]);
    return f(arg0, arg1, arg2);
}
aclError _WRAPLIB_API_CALL aclmdlCreateAndGetOpDesc(uint32_t arg0, uint32_t arg1, uint32_t arg2, char *arg3, size_t arg4, aclTensorDesc **arg5, size_t *arg6, aclTensorDesc **arg7, size_t *arg8) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(uint32_t, uint32_t, uint32_t, char *, size_t, aclTensorDesc **, size_t *, aclTensorDesc **, size_t *);
    ON_ENTRY(aclmdlCreateAndGetOpDesc);
    f_ptr_t f = (f_ptr_t)(g_func_table[185]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}
aclError _WRAPLIB_API_CALL aclmdlInitDump() {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclmdlInitDump);
    f_ptr_t f = (f_ptr_t)(g_func_table[186]);
    return f();
}
aclError _WRAPLIB_API_CALL aclmdlSetDump(const char *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *);
    ON_ENTRY(aclmdlSetDump);
    f_ptr_t f = (f_ptr_t)(g_func_table[187]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclmdlFinalizeDump() {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclmdlFinalizeDump);
    f_ptr_t f = (f_ptr_t)(g_func_table[188]);
    return f();
}
aclError _WRAPLIB_API_CALL aclmdlLoadWithConfig(const aclmdlConfigHandle *arg0, uint32_t *arg1) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlConfigHandle *, uint32_t *);
    ON_ENTRY(aclmdlLoadWithConfig);
    f_ptr_t f = (f_ptr_t)(g_func_table[189]);
    return f(arg0, arg1);
}
aclmdlConfigHandle _WRAPLIB_API_CALL *aclmdlCreateConfigHandle() {
    typedef aclmdlConfigHandle *(_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclmdlCreateConfigHandle);
    f_ptr_t f = (f_ptr_t)(g_func_table[190]);
    return f();
}
aclError _WRAPLIB_API_CALL aclmdlDestroyConfigHandle(aclmdlConfigHandle *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlConfigHandle *);
    ON_ENTRY(aclmdlDestroyConfigHandle);
    f_ptr_t f = (f_ptr_t)(g_func_table[191]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclmdlSetConfigOpt(aclmdlConfigHandle *arg0, aclmdlConfigAttr arg1, const void *arg2, size_t arg3) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(aclmdlConfigHandle *, aclmdlConfigAttr, const void *, size_t);
    ON_ENTRY(aclmdlSetConfigOpt);
    f_ptr_t f = (f_ptr_t)(g_func_table[192]);
    return f(arg0, arg1, arg2, arg3);
}
const char _WRAPLIB_API_CALL *aclmdlGetTensorRealName(const aclmdlDesc *arg0, const char *arg1) {
    typedef const char *(_WRAPLIB_API_CALL *f_ptr_t)(const aclmdlDesc *, const char *);
    ON_ENTRY(aclmdlGetTensorRealName);
    f_ptr_t f = (f_ptr_t)(g_func_table[193]);
    return f(arg0, arg1);
}
aclError _WRAPLIB_API_CALL aclInit(const char *arg0) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(const char *);
    ON_ENTRY(aclInit);
    f_ptr_t f = (f_ptr_t)(g_func_table[194]);
    return f(arg0);
}
aclError _WRAPLIB_API_CALL aclFinalize() {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclFinalize);
    f_ptr_t f = (f_ptr_t)(g_func_table[195]);
    return f();
}
aclError _WRAPLIB_API_CALL aclrtGetVersion(int32_t *arg0, int32_t *arg1, int32_t *arg2) {
    typedef aclError (_WRAPLIB_API_CALL *f_ptr_t)(int32_t *, int32_t *, int32_t *);
    ON_ENTRY(aclrtGetVersion);
    f_ptr_t f = (f_ptr_t)(g_func_table[196]);
    return f(arg0, arg1, arg2);
}
const char _WRAPLIB_API_CALL *aclGetRecentErrMsg() {
    typedef const char *(_WRAPLIB_API_CALL *f_ptr_t)();
    ON_ENTRY(aclGetRecentErrMsg);
    f_ptr_t f = (f_ptr_t)(g_func_table[197]);
    return f();
}