// 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 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 *>(4);
}
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 >(5);
}
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 >(6);
}
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 *>(7);
}
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 >(8);
}
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 >(9);
}
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 >(10);
}
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 >(11);
}
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 >(12);
}
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 >(13);
}
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 >(14);
}
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 >(15);
}
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 *>(16);
}
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 >(17);
}
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 >(18);
}
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 >(19);
}
static void _WRAPLIB_API_CALL aclAppLog_init(aclLogLevel arg0, const char *arg1, const char *arg2, uint32_t arg3, const char *arg4, ...) {
    load_library();
    return aclAppLog(arg0, arg1, arg2, arg3, arg4);
}
static void _WRAPLIB_API_CALL aclAppLog_error(aclLogLevel, const char *, const char *, uint32_t, const char *, ...) {
    return on_init_failed<void >(20);
}
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 >(21);
}
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 >(22);
}
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 >(23);
}
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 >(24);
}
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 >(25);
}
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 >(26);
}
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 >(27);
}
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 >(28);
}
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 >(29);
}
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 >(30);
}
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 >(31);
}
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 >(32);
}
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 >(33);
}
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 >(34);
}
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 >(35);
}
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 >(36);
}
static aclError _WRAPLIB_API_CALL aclrtSynchronizeDevice_init() {
    load_library();
    return aclrtSynchronizeDevice();
}
static aclError _WRAPLIB_API_CALL aclrtSynchronizeDevice_error() {
    return on_init_failed<aclError >(37);
}
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 >(38);
}
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 >(39);
}
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 >(40);
}
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 >(41);
}
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 >(42);
}
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 >(43);
}
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 >(44);
}
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 >(45);
}
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 >(46);
}
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 >(47);
}
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 >(48);
}
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 >(49);
}
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 >(50);
}
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 >(51);
}
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 >(52);
}
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 >(53);
}
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 >(54);
}
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 >(55);
}
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 >(56);
}
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 >(57);
}
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 >(58);
}
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 >(59);
}
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 >(60);
}
static aclopAttr _WRAPLIB_API_CALL *aclopCreateAttr_init() {
    load_library();
    return aclopCreateAttr();
}
static aclopAttr _WRAPLIB_API_CALL *aclopCreateAttr_error() {
    return on_init_failed<aclopAttr *>(61);
}
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 >(62);
}
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 >(63);
}
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 >(64);
}
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 >(65);
}
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 >(66);
}
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 >(67);
}
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 >(68);
}
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 >(69);
}
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 >(70);
}
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 >(71);
}
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 >(72);
}
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 >(73);
}
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 >(74);
}
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 >(75);
}
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 >(76);
}
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 >(77);
}
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 >(78);
}
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 >(79);
}
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 >(80);
}
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 >(81);
}
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 >(82);
}
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 >(83);
}
static aclmdlDesc _WRAPLIB_API_CALL *aclmdlCreateDesc_init() {
    load_library();
    return aclmdlCreateDesc();
}
static aclmdlDesc _WRAPLIB_API_CALL *aclmdlCreateDesc_error() {
    return on_init_failed<aclmdlDesc *>(84);
}
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 >(85);
}
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 >(86);
}
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 >(87);
}
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 >(88);
}
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 >(89);
}
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 >(90);
}
static aclmdlDataset _WRAPLIB_API_CALL *aclmdlCreateDataset_init() {
    load_library();
    return aclmdlCreateDataset();
}
static aclmdlDataset _WRAPLIB_API_CALL *aclmdlCreateDataset_error() {
    return on_init_failed<aclmdlDataset *>(91);
}
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 >(92);
}
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 >(93);
}
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 >(94);
}
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 *>(95);
}
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 >(96);
}
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 >(97);
}
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 >(98);
}
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 >(99);
}
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 >(100);
}
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 >(101);
}
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 >(102);
}
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 >(103);
}
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 >(104);
}
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 >(105);
}
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 >(106);
}
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 >(107);
}
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 >(108);
}
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 >(109);
}
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 >(110);
}
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 >(111);
}
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 >(112);
}
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 *>(113);
}
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 *>(114);
}
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 >(115);
}
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 >(116);
}
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 >(117);
}
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 >(118);
}
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 >(119);
}
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 >(120);
}
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 >(121);
}
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 >(122);
}
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 *>(123);
}
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 >(124);
}
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 >(125);
}
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 >(126);
}
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 >(127);
}
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 >(128);
}
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 >(129);
}
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 >(130);
}
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 >(131);
}
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 >(132);
}
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 >(133);
}
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 >(134);
}
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 >(135);
}
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 >(136);
}
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 >(137);
}
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 >(138);
}
static aclError _WRAPLIB_API_CALL aclFinalize_init() {
    load_library();
    return aclFinalize();
}
static aclError _WRAPLIB_API_CALL aclFinalize_error() {
    return on_init_failed<aclError >(139);
}
static constexpr size_t NR_FUNC = 140;
static void* g_func_table[NR_FUNC] = {(void*)(&aclFloat16ToFloat_init),
    (void*)(&aclFloatToFloat16_init),
    (void*)(&aclCreateDataBuffer_init),
    (void*)(&aclDestroyDataBuffer_init),
    (void*)(&aclGetDataBufferAddr_init),
    (void*)(&aclGetDataBufferSize_init),
    (void*)(&aclDataTypeSize_init),
    (void*)(&aclCreateTensorDesc_init),
    (void*)(&aclDestroyTensorDesc_init),
    (void*)(&aclGetTensorDescType_init),
    (void*)(&aclGetTensorDescFormat_init),
    (void*)(&aclGetTensorDescSize_init),
    (void*)(&aclGetTensorDescElementCount_init),
    (void*)(&aclGetTensorDescNumDims_init),
    (void*)(&aclGetTensorDescDim_init),
    (void*)(&aclSetTensorDescName_init),
    (void*)(&aclGetTensorDescName_init),
    (void*)(&aclTransTensorDescFormat_init),
    (void*)(&aclSetTensorStorageFormat_init),
    (void*)(&aclSetTensorStorageShape_init),
    (void*)(&aclAppLog_init),
    (void*)(&aclrtSetExceptionInfoCallback_init),
    (void*)(&aclrtGetTaskIdFromExceptionInfo_init),
    (void*)(&aclrtGetStreamIdFromExceptionInfo_init),
    (void*)(&aclrtGetThreadIdFromExceptionInfo_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*)(&aclrtDestroyEvent_init),
    (void*)(&aclrtRecordEvent_init),
    (void*)(&aclrtResetEvent_init),
    (void*)(&aclrtQueryEvent_init),
    (void*)(&aclrtSynchronizeEvent_init),
    (void*)(&aclrtEventElapsedTime_init),
    (void*)(&aclrtMalloc_init),
    (void*)(&aclrtFree_init),
    (void*)(&aclrtMallocHost_init),
    (void*)(&aclrtFreeHost_init),
    (void*)(&aclrtMemcpy_init),
    (void*)(&aclrtMemset_init),
    (void*)(&aclrtMemcpyAsync_init),
    (void*)(&aclrtMemsetAsync_init),
    (void*)(&aclrtCreateStream_init),
    (void*)(&aclrtDestroyStream_init),
    (void*)(&aclrtSynchronizeStream_init),
    (void*)(&aclrtStreamWaitEvent_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*)(&aclopSetAttrListBool_init),
    (void*)(&aclopSetAttrListInt_init),
    (void*)(&aclopSetAttrListFloat_init),
    (void*)(&aclopSetAttrListString_init),
    (void*)(&aclopSetAttrListListInt_init),
    (void*)(&aclopExecute_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*)(&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*)(&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*)(&aclmdlGetInputDims_init),
    (void*)(&aclmdlGetInputDimsV2_init),
    (void*)(&aclmdlGetOutputDims_init),
    (void*)(&aclmdlGetCurOutputDims_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*)(&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*)(&aclmdlGetFirstAippInfo_init),
    (void*)(&aclInit_init),
    (void*)(&aclFinalize_init)};
static void* g_func_table_error[NR_FUNC] = {(void*)(&aclFloat16ToFloat_error),
    (void*)(&aclFloatToFloat16_error),
    (void*)(&aclCreateDataBuffer_error),
    (void*)(&aclDestroyDataBuffer_error),
    (void*)(&aclGetDataBufferAddr_error),
    (void*)(&aclGetDataBufferSize_error),
    (void*)(&aclDataTypeSize_error),
    (void*)(&aclCreateTensorDesc_error),
    (void*)(&aclDestroyTensorDesc_error),
    (void*)(&aclGetTensorDescType_error),
    (void*)(&aclGetTensorDescFormat_error),
    (void*)(&aclGetTensorDescSize_error),
    (void*)(&aclGetTensorDescElementCount_error),
    (void*)(&aclGetTensorDescNumDims_error),
    (void*)(&aclGetTensorDescDim_error),
    (void*)(&aclSetTensorDescName_error),
    (void*)(&aclGetTensorDescName_error),
    (void*)(&aclTransTensorDescFormat_error),
    (void*)(&aclSetTensorStorageFormat_error),
    (void*)(&aclSetTensorStorageShape_error),
    (void*)(&aclAppLog_error),
    (void*)(&aclrtSetExceptionInfoCallback_error),
    (void*)(&aclrtGetTaskIdFromExceptionInfo_error),
    (void*)(&aclrtGetStreamIdFromExceptionInfo_error),
    (void*)(&aclrtGetThreadIdFromExceptionInfo_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*)(&aclrtDestroyEvent_error),
    (void*)(&aclrtRecordEvent_error),
    (void*)(&aclrtResetEvent_error),
    (void*)(&aclrtQueryEvent_error),
    (void*)(&aclrtSynchronizeEvent_error),
    (void*)(&aclrtEventElapsedTime_error),
    (void*)(&aclrtMalloc_error),
    (void*)(&aclrtFree_error),
    (void*)(&aclrtMallocHost_error),
    (void*)(&aclrtFreeHost_error),
    (void*)(&aclrtMemcpy_error),
    (void*)(&aclrtMemset_error),
    (void*)(&aclrtMemcpyAsync_error),
    (void*)(&aclrtMemsetAsync_error),
    (void*)(&aclrtCreateStream_error),
    (void*)(&aclrtDestroyStream_error),
    (void*)(&aclrtSynchronizeStream_error),
    (void*)(&aclrtStreamWaitEvent_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*)(&aclopSetAttrListBool_error),
    (void*)(&aclopSetAttrListInt_error),
    (void*)(&aclopSetAttrListFloat_error),
    (void*)(&aclopSetAttrListString_error),
    (void*)(&aclopSetAttrListListInt_error),
    (void*)(&aclopExecute_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*)(&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*)(&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*)(&aclmdlGetInputDims_error),
    (void*)(&aclmdlGetInputDimsV2_error),
    (void*)(&aclmdlGetOutputDims_error),
    (void*)(&aclmdlGetCurOutputDims_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*)(&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*)(&aclmdlGetFirstAippInfo_error),
    (void*)(&aclInit_error),
    (void*)(&aclFinalize_error)};
static const char* const g_func_name[NR_FUNC] = {"aclFloat16ToFloat",
    "aclFloatToFloat16",
    "aclCreateDataBuffer",
    "aclDestroyDataBuffer",
    "aclGetDataBufferAddr",
    "aclGetDataBufferSize",
    "aclDataTypeSize",
    "aclCreateTensorDesc",
    "aclDestroyTensorDesc",
    "aclGetTensorDescType",
    "aclGetTensorDescFormat",
    "aclGetTensorDescSize",
    "aclGetTensorDescElementCount",
    "aclGetTensorDescNumDims",
    "aclGetTensorDescDim",
    "aclSetTensorDescName",
    "aclGetTensorDescName",
    "aclTransTensorDescFormat",
    "aclSetTensorStorageFormat",
    "aclSetTensorStorageShape",
    "aclAppLog",
    "aclrtSetExceptionInfoCallback",
    "aclrtGetTaskIdFromExceptionInfo",
    "aclrtGetStreamIdFromExceptionInfo",
    "aclrtGetThreadIdFromExceptionInfo",
    "aclrtSubscribeReport",
    "aclrtLaunchCallback",
    "aclrtProcessReport",
    "aclrtUnSubscribeReport",
    "aclrtCreateContext",
    "aclrtDestroyContext",
    "aclrtSetCurrentContext",
    "aclrtGetCurrentContext",
    "aclrtSetDevice",
    "aclrtResetDevice",
    "aclrtGetDevice",
    "aclrtGetRunMode",
    "aclrtSynchronizeDevice",
    "aclrtSetTsDevice",
    "aclrtGetDeviceCount",
    "aclrtCreateEvent",
    "aclrtDestroyEvent",
    "aclrtRecordEvent",
    "aclrtResetEvent",
    "aclrtQueryEvent",
    "aclrtSynchronizeEvent",
    "aclrtEventElapsedTime",
    "aclrtMalloc",
    "aclrtFree",
    "aclrtMallocHost",
    "aclrtFreeHost",
    "aclrtMemcpy",
    "aclrtMemset",
    "aclrtMemcpyAsync",
    "aclrtMemsetAsync",
    "aclrtCreateStream",
    "aclrtDestroyStream",
    "aclrtSynchronizeStream",
    "aclrtStreamWaitEvent",
    "aclopSetModelDir",
    "aclopLoad",
    "aclopCreateAttr",
    "aclopDestroyAttr",
    "aclopSetAttrBool",
    "aclopSetAttrInt",
    "aclopSetAttrFloat",
    "aclopSetAttrString",
    "aclopSetAttrListBool",
    "aclopSetAttrListInt",
    "aclopSetAttrListFloat",
    "aclopSetAttrListString",
    "aclopSetAttrListListInt",
    "aclopExecute",
    "aclopCreateHandle",
    "aclopDestroyHandle",
    "aclopExecWithHandle",
    "aclopCast",
    "aclopCreateHandleForCast",
    "aclopCreateKernel",
    "aclopRegisterCompileFunc",
    "aclopUnregisterCompileFunc",
    "aclopSetKernelArgs",
    "aclopSetKernelWorkspaceSizes",
    "aclopUpdateParams",
    "aclmdlCreateDesc",
    "aclmdlDestroyDesc",
    "aclmdlGetDesc",
    "aclmdlGetNumInputs",
    "aclmdlGetNumOutputs",
    "aclmdlGetInputSizeByIndex",
    "aclmdlGetOutputSizeByIndex",
    "aclmdlCreateDataset",
    "aclmdlDestroyDataset",
    "aclmdlAddDatasetBuffer",
    "aclmdlGetDatasetNumBuffers",
    "aclmdlGetDatasetBuffer",
    "aclmdlLoadFromFile",
    "aclmdlLoadFromMem",
    "aclmdlLoadFromFileWithMem",
    "aclmdlLoadFromMemWithMem",
    "aclmdlLoadFromFileWithQ",
    "aclmdlLoadFromMemWithQ",
    "aclmdlExecute",
    "aclmdlExecuteAsync",
    "aclmdlUnload",
    "aclmdlQuerySize",
    "aclmdlQuerySizeFromMem",
    "aclmdlSetDynamicBatchSize",
    "aclmdlSetDynamicHWSize",
    "aclmdlGetInputDims",
    "aclmdlGetInputDimsV2",
    "aclmdlGetOutputDims",
    "aclmdlGetCurOutputDims",
    "aclmdlGetInputNameByIndex",
    "aclmdlGetOutputNameByIndex",
    "aclmdlGetInputFormat",
    "aclmdlGetOutputFormat",
    "aclmdlGetInputDataType",
    "aclmdlGetOutputDataType",
    "aclmdlGetInputIndexByName",
    "aclmdlGetOutputIndexByName",
    "aclmdlGetDynamicBatch",
    "aclmdlGetDynamicHW",
    "aclmdlCreateAIPP",
    "aclmdlDestroyAIPP",
    "aclmdlSetAIPPInputFormat",
    "aclmdlSetAIPPCscParams",
    "aclmdlSetAIPPRbuvSwapSwitch",
    "aclmdlSetAIPPAxSwapSwitch",
    "aclmdlSetAIPPSrcImageSize",
    "aclmdlSetAIPPScfParams",
    "aclmdlSetAIPPCropParams",
    "aclmdlSetAIPPPaddingParams",
    "aclmdlSetAIPPDtcPixelMean",
    "aclmdlSetAIPPDtcPixelMin",
    "aclmdlSetAIPPPixelVarReci",
    "aclmdlSetInputAIPP",
    "aclmdlGetFirstAippInfo",
    "aclInit",
    "aclFinalize"};

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);
}
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[4]);
    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[5]);
    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[6]);
    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[7]);
    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[8]);
    return f(arg0);
}
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[9]);
    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[10]);
    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[11]);
    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[12]);
    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[13]);
    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[14]);
    return f(arg0, arg1);
}
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[15]);
    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[16]);
    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[17]);
    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[18]);
    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[19]);
    return f(arg0, arg1, arg2);
}
void _WRAPLIB_API_CALL aclAppLog(aclLogLevel arg0, const char *arg1, const char *arg2, uint32_t arg3, const char *arg4, ...) {
    typedef void (_WRAPLIB_API_CALL *f_ptr_t)(aclLogLevel, const char *, const char *, uint32_t, const char *, ...);
    ON_ENTRY(aclAppLog);
    f_ptr_t f = (f_ptr_t)(g_func_table[20]);
    return f(arg0, arg1, arg2, arg3, arg4);
}
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[21]);
    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[22]);
    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[23]);
    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[24]);
    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[25]);
    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[26]);
    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[27]);
    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[28]);
    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[29]);
    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[30]);
    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[31]);
    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[32]);
    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[33]);
    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[34]);
    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[35]);
    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[36]);
    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[37]);
    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[38]);
    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[39]);
    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[40]);
    return f(arg0);
}
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[41]);
    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[42]);
    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[43]);
    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[44]);
    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[45]);
    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[46]);
    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[47]);
    return f(arg0, arg1, arg2);
}
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[48]);
    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[49]);
    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[50]);
    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[51]);
    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[52]);
    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[53]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
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[54]);
    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[55]);
    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[56]);
    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[57]);
    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[58]);
    return f(arg0, arg1);
}
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[59]);
    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[60]);
    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[61]);
    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[62]);
    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[63]);
    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[64]);
    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[65]);
    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[66]);
    return f(arg0, arg1, arg2);
}
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[67]);
    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[68]);
    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[69]);
    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[70]);
    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[71]);
    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[72]);
    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[73]);
    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[74]);
    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[75]);
    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[76]);
    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[77]);
    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[78]);
    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[79]);
    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[80]);
    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[81]);
    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[82]);
    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[83]);
    return f(arg0, arg1, arg2, arg3, arg4, arg5);
}
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[84]);
    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[85]);
    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[86]);
    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[87]);
    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[88]);
    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[89]);
    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[90]);
    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[91]);
    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[92]);
    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[93]);
    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[94]);
    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[95]);
    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[96]);
    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[97]);
    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[98]);
    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[99]);
    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[100]);
    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[101]);
    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[102]);
    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[103]);
    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[104]);
    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[105]);
    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[106]);
    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[107]);
    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[108]);
    return f(arg0, arg1, arg2, arg3, arg4);
}
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[109]);
    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[110]);
    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[111]);
    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[112]);
    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[113]);
    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[114]);
    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[115]);
    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[116]);
    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[117]);
    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[118]);
    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[119]);
    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[120]);
    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[121]);
    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[122]);
    return f(arg0, arg1, arg2);
}
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[123]);
    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[124]);
    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[125]);
    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[126]);
    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[127]);
    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[128]);
    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[129]);
    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[130]);
    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[131]);
    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[132]);
    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[133]);
    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[134]);
    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[135]);
    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[136]);
    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[137]);
    return f(arg0, arg1, arg2);
}
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[138]);
    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[139]);
    return f();
}
