hpm_math.h

Go to the documentation of this file.

/*
 * Copyright (c) 2022,2024 HPMicro
 *
 * SPDX-License-Identifier: BSD-3-Clause
 *
 */
 
#ifndef __HPM_MATH_H__
#define __HPM_MATH_H__
 
#include <stddef.h>
#define HPM_DSP_HW_NDS32 1 /* andes hardware dsp */
 
#ifdef CONFIG_HPM_MATH_HAS_EXTRA_CONFIG
#include CONFIG_HPM_MATH_HAS_EXTRA_CONFIG
#else
 
/* Enable Compute Cell Library*/
/* #define HPM_EN_MATH_FFA_LIB */
/* #define HPM_EN_MATH_DSP_LIB */
/* #define HPM_EN_MATH_NN_LIB */
 
#define HPM_MATH_DSP_STATISTICS 1
#define HPM_MATH_DSP_BASIC 1
#define HPM_MATH_DSP_COMPLEX 1
#define HPM_MATH_DSP_CONTROLLER 1
#define HPM_MATH_DSP_DISTANCE 1
#define HPM_MATH_DSP_FILTERING 1
#define HPM_MATH_DSP_MATRIX 1
#define HPM_MATH_DSP_SVM 1
#define HPM_MATH_DSP_TRANSFORM 1
#define HPM_MATH_DSP_UTILS 1
#define HPM_MATH_DSP_SORT 1
 
#define HPM_MATH_NN_ACTIVATION 1
#define HPM_MATH_NN_TINYENGINE 1
#define HPM_MATH_NN_BASIC  1
#define HPM_MATH_NN_CONCATENATION 1
#define HPM_MATH_NN_CONVOLUTION 1
#define HPM_MATH_NN_CONNECTED 1
#define HPM_MATH_NN_POOLING 1
#define HPM_MATH_NN_SOFTMAX 1
#define HPM_MATH_NN_UTIL 1
 
#define HPM_DSP_CORE HPM_DSP_HW_NDS32 /* DSP core selection */
 
#define HPM_MATH_PI (3.14159265358979323846)
 
#define HPM_MATH_SW_FFT_CHECKLIST
 
#endif
 
#ifdef  __cplusplus
extern "C"
{
#endif
 
#ifdef HPM_MATH_DSP_STATISTICS
 
#ifdef HPM_EN_MATH_DSP_LIB
 
#ifdef __zcc__
#include "tpt_math.h"
#endif
 
#include "riscv_dsp_statistics_math.h"
 
// Maximum
static inline float32_t hpm_dsp_max_f32(const float32_t *src, uint32_t size, uint32_t *index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    f32_t res;
    tpt_max_f32(&res, index, src, size);
    return res;
#else
    return riscv_dsp_max_f32(src, size, index);
#endif
#endif
}
static inline float32_t hpm_dsp_max_val_f32(const float32_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_max_val_f32(src, size);
#endif
}
static inline q15_t hpm_dsp_max_q15(const q15_t *src, uint32_t size, uint32_t *index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q15_t res;
    tpt_max_q15(&res, index, src, size);
    return res;
#else
    return riscv_dsp_max_q15(src, size, index);
#endif
#endif
}
 
static inline q31_t hpm_dsp_max_q31(const q31_t *src, uint32_t size, uint32_t *index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
 #ifdef __zcc__
    q31_t res;
    tpt_max_q31(&res, index, src, size);
    return res;
#else
    return riscv_dsp_max_q31(src, size, index);
#endif
#endif
}
 
static inline q7_t hpm_dsp_max_q7(const q7_t *src, uint32_t size, uint32_t *index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q7_t res;
    tpt_max_q7(&res, index, src, size);
    return res;
#else
    return riscv_dsp_max_q7(src, size, index);
#endif
#endif
}
 
static inline uint8_t hpm_dsp_max_u8(const uint8_t *src, uint32_t size, uint32_t *index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_max_u8(src, size, index);
#endif
}
 
// Minimum
static inline float32_t hpm_dsp_min_f32(const float32_t *src, uint32_t size, uint32_t *index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    f32_t res;
    tpt_min_f32(&res, index, src, size);
    return res;
#else
    return riscv_dsp_min_f32(src, size, index);
#endif
#endif
}
 
static inline q15_t hpm_dsp_min_q15(const q15_t *src, uint32_t size, uint32_t *index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q15_t res;
    tpt_min_q15(&res, index, src, size);
    return res;
#else
    return riscv_dsp_min_q15(src, size, index);
#endif
#endif
}
 
static inline q31_t hpm_dsp_min_q31(const q31_t *src, uint32_t size, uint32_t *index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q31_t res;
    tpt_min_q31(&res, index, src, size);
    return res;
#else
    return riscv_dsp_min_q31(src, size, index);
#endif
#endif
}
 
static inline q7_t hpm_dsp_min_q7(const q7_t *src, uint32_t size, uint32_t *index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q7_t res;
    tpt_min_q7(&res, index, src, size);
    return res;
#else
    return riscv_dsp_min_q7(src, size, index);
#endif
#endif
}
 
static inline uint8_t hpm_dsp_min_u8(const uint8_t *src, uint32_t size, uint32_t *index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_min_u8(src, size, index);
#endif
}
 
// Mean
static inline float32_t hpm_dsp_mean_f32(const float32_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    f32_t res;
    tpt_mean_f32(&res, src, size);
    return res;
#else
    return riscv_dsp_mean_f32(src, size);
#endif
#endif
}
 
static inline q15_t hpm_dsp_mean_q15(const q15_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q15_t res;
    tpt_mean_q15(&res, src, size);
    return res;
#else
    return riscv_dsp_mean_q15(src, size);
#endif
#endif
}
 
static inline q31_t hpm_dsp_mean_q31(const q31_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q31_t res;
    tpt_mean_q31(&res, src, size);
    return res;
#else
    return riscv_dsp_mean_q31(src, size);
#endif
#endif
}
 
static inline q7_t hpm_dsp_mean_q7(const q7_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q7_t res;
    tpt_mean_q7(&res, src, size);
    return res;
#else
    return riscv_dsp_mean_q7(src, size);
#endif
#endif
}
 
static inline uint8_t hpm_dsp_mean_u8(const uint8_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_mean_u8(src, size);
#endif
}
 
// Sun of the Squares
static inline float32_t hpm_dsp_pwr_f32(const float32_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    f32_t res;
    tpt_power_f32(&res, src, size);
    return res;
#else
    return riscv_dsp_pwr_f32(src, size);
#endif
#endif
}
 
static inline q63_t hpm_dsp_pwr_q15(const q15_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q63_t res;
    tpt_power_q15(&res, src, size);
    return res;
#else
    return riscv_dsp_pwr_q15(src, size);
#endif
#endif
}
 
static inline q63_t hpm_dsp_pwr_q31(const q31_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q63_t res;
    tpt_power_q31(&res, src, size);
    return res;
#else
    return riscv_dsp_pwr_q31(src, size);
#endif
#endif
}
 
static inline q31_t hpm_dsp_pwr_q7(const q7_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q31_t res;
    tpt_power_q7(&res, src, size);
    return res;
#else
    return riscv_dsp_pwr_q7(src, size);
#endif
#endif
}
 
// Root Mean Square
static inline float32_t hpm_dsp_rms_f32(const float32_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    f32_t res;
    tpt_rms_f32(&res, src, size);
    return res;
#else
    return riscv_dsp_rms_f32(src, size);
#endif
#endif
}
 
static inline q15_t hpm_dsp_rms_q15(const q15_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q15_t res;
    tpt_rms_q15(&res, src, size);
    return res;
#else
    return riscv_dsp_rms_q15(src, size);
#endif
#endif
}
 
static inline q31_t hpm_dsp_rms_q31(const q31_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q31_t res;
    tpt_rms_q31(&res, src, size);
    return res;
#else
    return riscv_dsp_rms_q31(src, size);
#endif
#endif
}
 
// Standard deviation
static inline float32_t hpm_dsp_std_f32(const float32_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    f32_t res;
    tpt_std_f32(&res, src, size);
    return res;
#else
    return riscv_dsp_std_f32(src, size);
#endif
#endif
}
 
static inline q15_t hpm_dsp_std_q15(const q15_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q15_t res;
    tpt_std_q15(&res, src, size);
    return res;
#else
    return riscv_dsp_std_q15(src, size);
#endif
#endif
}
 
static inline q31_t hpm_dsp_std_q31(const q31_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q31_t res;
    tpt_std_q31(&res, src, size);
    return res;
#else
    return riscv_dsp_std_q31(src, size);
#endif
#endif
}
 
static inline q15_t hpm_dsp_std_u8(const uint8_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_std_u8(src, size);
#endif
}
 
// Variance
static inline float32_t hpm_dsp_var_f32(const float32_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    f32_t res;
    tpt_var_f32(&res, src, size);
    return res;
#else
    return riscv_dsp_var_f32(src, size);
#endif
#endif
}
 
static inline q31_t hpm_dsp_var_q15(const q15_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q15_t res;
    tpt_var_q15(&res, src, size);
    return res;
#else
    return riscv_dsp_var_q15(src, size);
#endif
#endif
}
 
static inline q63_t hpm_dsp_var_q31(const q31_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q31_t res;
    tpt_var_q31(&res, src, size);
    return res;
#else
    return riscv_dsp_var_q31(src, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_entropy_f32(const float32_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_entropy_f32(src, size);
#else
    return riscv_dsp_entropy_f32(src, size);
#endif
#endif
}
 
 
static inline float32_t hpm_dsp_relative_entropy_f32(const float32_t *src1, const float32_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_relative_entropy_f32(src1, src2, size);
#else
    return riscv_dsp_relative_entropy_f32(src1, src2, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_lse_f32(const float32_t *src, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_lse_f32(src, size);
#else
    return riscv_dsp_lse_f32(src, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_lse_dprod_f32(const float32_t *src1, const float32_t *src2, uint32_t size, float32_t *buffer)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_lse_dprod_f32(src1, src2, size, buffer);
#else
    return riscv_dsp_lse_dprod_f32(src1, src2, size, buffer);
#endif
#endif
}
 
static inline uint32_t hpm_dsp_gaussian_naive_bayes_est_f32(const riscv_dsp_gaussian_naivebayes_f32_t *instance, const float32_t * src, float32_t *buf)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_gaussian_naive_bayes_est_f32(instance, src, buf);
#endif
}
 
static inline float32_t hpm_dsp_absmax_f32(const float32_t* src, uint32_t size, uint32_t* index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_absmax_f32(src, size, index);
#endif
}
 
static inline q15_t hpm_dsp_absmax_q15(const q15_t* src, uint32_t size, uint32_t* index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_absmax_q15(src, size, index);
#endif
}
 
static inline q31_t hpm_dsp_absmax_q31(const q31_t* src, uint32_t size, uint32_t* index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_absmax_q31(src, size, index);
#endif
}
 
static inline q7_t hpm_dsp_absmax_q7(const q7_t* src, uint32_t size, uint32_t* index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_absmax_q7(src, size, index);
#endif
}
 
static inline float32_t hpm_dsp_absmin_f32(const float32_t* src, uint32_t size, uint32_t* index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_absmin_f32(src, size, index);
#endif
}
 
static inline q31_t hpm_dsp_absmin_q31(const q31_t* src, uint32_t size, uint32_t* index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_absmin_q31(src, size, index);
#endif
}
 
static inline q15_t hpm_dsp_absmin_q15(const q15_t* src, uint32_t size, uint32_t* index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_absmin_q15(src, size, index);
#endif
}
 
static inline q7_t hpm_dsp_absmin_q7(const q7_t* src, uint32_t size, uint32_t* index)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_absmin_q7(src, size, index);
#endif
}
 
#endif
#endif
 
#ifdef HPM_MATH_DSP_BASIC
 
#ifdef HPM_EN_MATH_DSP_LIB
 
#ifdef __zcc__
#include "tpt_math.h"
#endif
 
#include "riscv_dsp_basic_math.h"
 
// Absolute value
static inline void hpm_dsp_abs_f32(float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_abs_f32(dst, src, size);
#else
    riscv_dsp_abs_f32(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_abs_q31(q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_abs_q31(dst, src, size);
#else
    riscv_dsp_abs_q31(src, dst, size);
#endif
 
#endif
}
 
static inline void hpm_dsp_abs_q15(q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_abs_q15(dst, src, size);
#else
    riscv_dsp_abs_q15(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_abs_q7(q7_t *src, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_abs_q7(dst, src, size);
#else
    riscv_dsp_abs_q7(src, dst, size);
#endif
#endif
}
 
// Addition
static inline void hpm_dsp_add_f32(float32_t *src1, float32_t *src2, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_add_f32(dst, src1, src2, size);
#else
    riscv_dsp_add_f32(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_add_q31(q31_t *src1, q31_t *src2, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_add_q31(dst, src1, src2, size);
#else
    riscv_dsp_add_q31(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_add_q15(q15_t *src1, q15_t *src2, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_add_q15(dst, src1, src2, size);
#else
    riscv_dsp_add_q15(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_add_q7(q7_t *src1, q7_t *src2, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_add_q7(dst, src1, src2, size);
#else
    riscv_dsp_add_q7(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_add_u8_u16(uint8_t *src1, uint8_t *src2, uint16_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_add_u8_u16(dst, src1, src2, size);
#else
    riscv_dsp_add_u8_u16(src1, src2, dst, size);
#endif
#endif
}
 
// Subtraction
static inline void hpm_dsp_sub_f32(float32_t *src1, float32_t *src2, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_sub_f32(dst, src1, src2, size);
#else
    riscv_dsp_sub_f32(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_sub_q31(q31_t *src1, q31_t *src2, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_sub_q31(dst, src1, src2, size);
#else
    riscv_dsp_sub_q31(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_sub_q15(q15_t *src1, q15_t *src2, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_sub_q15(dst, src1, src2, size);
#else
    riscv_dsp_sub_q15(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_sub_q7(q7_t *src1, q7_t *src2, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_sub_q7(dst, src1, src2, size);
#else
    riscv_dsp_sub_q7(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_sub_u8_q7(uint8_t *src1, uint8_t *src2, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_sub_u8_q7(src1, src2, dst, size);
#endif
}
 
// Multiplication
static inline void hpm_dsp_mul_f32(float32_t *src1, float32_t *src2, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mult_f32(dst, src1, src2, size);
#else
    riscv_dsp_mul_f32(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_mul_q31(q31_t *src1, q31_t *src2, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mult_q31(dst, src1, src2, size);
#else
    riscv_dsp_mul_q31(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_mul_q15(q15_t *src1, q15_t *src2, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mult_q15(dst, src1, src2, size);
#else
    riscv_dsp_mul_q15(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_mul_q7(q7_t *src1, q7_t *src2, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mult_q7(dst, src1, src2, size);
#else
    riscv_dsp_mul_q7(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_mul_u8_u16(uint8_t *src1, uint8_t *src2, uint16_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_mul_u8_u16(src1, src2, dst, size);
#endif
}
 
// Division
static inline void hpm_dsp_div_f32(float32_t *src1, float32_t *src2, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_div_f32(dst, src1, src2, size);
#else
    riscv_dsp_div_f32(src1, src2, dst, size);
#endif
#endif
}
 
static inline q31_t hpm_dsp_div_q31(q31_t src1, q31_t src2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_div_q31(src1, src2);
#else
    return riscv_dsp_div_q31(src1, src2);
#endif
#endif
}
 
static inline q31_t hpm_dsp_div_s64_u32(q63_t src1, uint32_t src2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_div_s64_u32(src1, src2);
#else
    return riscv_dsp_div_s64_u32(src1, src2);
#endif
#endif
}
 
static inline q31_t hpm_dsp_div_u64_u32(uint64_t src1, uint32_t src2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_div_u64_u32(src1, src2);
#else
    return riscv_dsp_div_u64_u32(src1, src2);
#endif
#endif
}
 
// Negation
static inline void hpm_dsp_neg_f32(float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_negate_f32(dst, src, size);
#else
    riscv_dsp_neg_f32(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_neg_q31(q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_negate_q31(dst, src, size);
#else
    riscv_dsp_neg_q31(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_neg_q15(q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_negate_q15(dst, src, size);
#else
    riscv_dsp_neg_q15(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_neg_q7(q7_t *src, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_negate_q7(dst, src, size);
#else
    riscv_dsp_neg_q7(src, dst, size);
#endif
#endif
}
 
// Dot Production
static inline float32_t hpm_dsp_dprod_f32(float32_t *src1, float32_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    f32_t res;
    tpt_dot_prod_f32(&res, src1, src2, size);
    return res;
#else
    return riscv_dsp_dprod_f32(src1, src2, size);
#endif
#endif
}
 
static inline q63_t hpm_dsp_dprod_q31(q31_t *src1, q31_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q63_t res;
    tpt_dot_prod_q31(&res, src1, src2, size);
    return res;
#else
    return riscv_dsp_dprod_q31(src1, src2, size);
#endif
#endif
}
 
static inline q63_t hpm_dsp_dprod_q15(q15_t *src1, q15_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q63_t res;
    tpt_dot_prod_q15(&res, src1, src2, size);
    return res;
#else
    return riscv_dsp_dprod_q15(src1, src2, size);
#endif
#endif
}
 
static inline q31_t hpm_dsp_dprod_u8xq15(uint8_t *src1, q15_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_dprod_u8xq15(src1, src2, size);
#endif
}
 
 
static inline q31_t hpm_dsp_dprod_q7(q7_t *src1, q7_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    q31_t res;
    tpt_dot_prod_q7(&res, src1, src2, size);
    return res;
#else
    return riscv_dsp_dprod_q7(src1, src2, size);
#endif
#endif
}
 
static inline q31_t hpm_dsp_dprod_q7xq15(q7_t *src1, q15_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_dprod_q7xq15(src1, src2, size);
#endif
}
 
static inline uint32_t hpm_dsp_dprod_u8(uint8_t *src1, uint8_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_dprod_u8(src1, src2, size);
#endif
}
 
// Offset
static inline void hpm_dsp_offset_f32(float32_t *src, float32_t offset, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_offset_f32(dst, src, offset, size);
#else
    riscv_dsp_offset_f32(src, offset, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_offset_q31(q31_t *src, q31_t offset, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_offset_q31(dst, src, offset, size);
#else
    riscv_dsp_offset_q31(src, offset, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_offset_q15(q15_t *src, q15_t offset, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_offset_q15(dst, src, offset, size);
#else
    riscv_dsp_offset_q15(src, offset, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_offset_q7(q7_t *src, q7_t offset, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_offset_q7(dst, src, offset, size);
#else
    riscv_dsp_offset_q7(src, offset, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_offset_u8(uint8_t *src, q7_t offset, uint8_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_offset_u8(src, offset, dst, size);
#endif
}
 
// Scale
static inline void hpm_dsp_scale_f32(float32_t *src, float32_t scale, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_scale_f32(dst, src, scale, size);
#else
    riscv_dsp_scale_f32(src, scale, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_scale_q31(q31_t *src, q31_t scalefract, int8_t shift, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_scale_q31(dst, src, scalefract, shift, size);
#else
    riscv_dsp_scale_q31(src, scalefract, shift, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_scale_q15(q15_t *src, q15_t scalefract, int8_t shift, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_scale_q15(dst, src, scalefract, shift, size);
#else
    riscv_dsp_scale_q15(src, scalefract, shift, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_scale_q7(q7_t *src, q7_t scalefract, int8_t shift, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_scale_q7(dst, src, scalefract, shift, size);
#else
    riscv_dsp_scale_q7(src, scalefract, shift, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_scale_u8(uint8_t *src, q7_t scalefract, int8_t shift, uint8_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_scale_u8(src, scalefract, shift, dst, size);
#endif
}
 
// Shift
static inline void hpm_dsp_shift_q15(q15_t *src, int8_t shift, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_shift_q15(dst, src, shift, size);
#else
    riscv_dsp_shift_q15(src, shift, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_shift_q31(q31_t *src, int8_t shift, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_shift_q31(dst, src, shift, size);
#else
    riscv_dsp_shift_q31(src, shift, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_shift_q7(q7_t *src, int8_t shift, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_shift_q7(dst, src, shift, size);
#else
    riscv_dsp_shift_q7(src, shift, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_shift_u8(uint8_t *src, int8_t shift, uint8_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_shift_u8(src, shift, dst, size);
#endif
}
 
static inline void hpm_dsp_clip_f32(float32_t *src, float32_t *dst, float32_t low, float32_t high, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_clip_f32(dst, src, low, high, size);
#else
    riscv_dsp_clip_f32(src, dst, low, high, size);
#endif
#endif
}
static inline void hpm_dsp_clip_q31(q31_t *src, q31_t *dst, q31_t low, q31_t high, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_clip_q31(dst, src, low, high, size);
#else
    riscv_dsp_clip_q31(src, dst, low, high, size);
#endif
#endif
}
static inline void hpm_dsp_clip_q15(q15_t *src, q15_t *dst, q15_t low, q15_t high, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_clip_q15(dst, src, low, high, size);
#else
    riscv_dsp_clip_q15(src, dst, low, high, size);
#endif
#endif
}
static inline void hpm_dsp_clip_q7(q7_t *src, q7_t *dst, q7_t low, q7_t high, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_clip_q7(dst, src, low, high, size);
#else
    riscv_dsp_clip_q7(src, dst, low, high, size);
#endif
#endif
}
// AND
static inline void hpm_dsp_and_u32(u32_t *src1, u32_t *src2, u32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_and_32bit(dst, src1, src2, size);
#else
    riscv_dsp_and_u32(src1, src2, dst, size);
#endif
#endif
}
static inline void hpm_dsp_and_u8(u8_t *src1, u8_t *src2, u8_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_and_8bit(dst, src1, src2, size);
#else
    riscv_dsp_and_u8(src1, src2, dst, size);
#endif
#endif
}
// OR
static inline void hpm_dsp_or_u32(u32_t *src1, u32_t *src2, u32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_or_32bit(dst, src1, src2, size);
#else
    riscv_dsp_or_u32(src1, src2, dst, size);
#endif
#endif
}
static inline void hpm_dsp_or_u16(u16_t *src1, u16_t *src2, u16_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_or_16bit(dst, src1, src2, size);
#else
    riscv_dsp_or_u16(src1, src2, dst, size);
#endif
#endif
}
static inline void hpm_dsp_or_u8(u8_t *src1, u8_t *src2, u8_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_or_8bit(dst, src1, src2, size);
#else
    riscv_dsp_or_u8(src1, src2, dst, size);
#endif
#endif
}
// XOR
static inline void hpm_dsp_xor_u32(u32_t *src1, u32_t *src2, u32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_xor_32bit(dst, src1, src2, size);
#else
    riscv_dsp_xor_u32(src1, src2, dst, size);
#endif
#endif
}
static inline void hpm_dsp_xor_u16(u16_t *src1, u16_t *src2, u16_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_xor_16bit(dst, src1, src2, size);
#else
    riscv_dsp_xor_u16(src1, src2, dst, size);
#endif
#endif
}
static inline void hpm_dsp_xor_u8(u8_t *src1, u8_t *src2, u8_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_xor_8bit(dst, src1, src2, size);
#else
    riscv_dsp_xor_u8(src1, src2, dst, size);
#endif
#endif
}
// Not
static inline void hpm_dsp_not_u32(u32_t *src, u32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_not_32bit(dst, src, size);
#else
    riscv_dsp_not_u32(src, dst, size);
#endif
#endif
}
static inline void hpm_dsp_not_u16(u16_t *src, u16_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_not_16bit(dst, src, size);
#else
    riscv_dsp_not_u16(src, dst, size);
#endif
#endif
}
static inline void hpm_dsp_not_u8(u8_t *src, u8_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_not_8bit(dst, src, size);
#else
    riscv_dsp_not_u8(src, dst, size);
#endif
#endif
}
#endif
 
#include <stdint.h>
 
uint8_t hpm_math_sw_reverse_bit8_lsb_to_msb(uint8_t lsb);
 
uint8_t hpm_math_sw_reverse_bit8_msb_to_lsb(uint8_t msb);
 
uint32_t hpm_math_sw_reverse_bit32_lsb_to_msb(uint32_t lsb);
 
uint32_t hpm_math_sw_reverse_bit32_msb_to_lsb(uint32_t msb);
 
#endif
 
#ifdef HPM_MATH_DSP_COMPLEX
 
#ifdef HPM_EN_MATH_DSP_LIB
 
#ifdef __zcc__
#include "tpt_math.h"
#endif
 
#include "riscv_dsp_complex_math.h"
 
// Complex Conjugate
static inline void hpm_dsp_cconj_f32(const float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_conj_f32(dst, src, size);
#else
    riscv_dsp_cconj_f32(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_cconj_q15(const q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_conj_q15(dst, src, size);
#else
    riscv_dsp_cconj_q15(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_cconj_q31(const q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_conj_q31(dst, src, size);
#else
    riscv_dsp_cconj_q31(src, dst, size);
#endif
#endif
}
 
// Complex Dot Product
static inline void hpm_dsp_cdprod_f32(const float32_t *src1, const float32_t *src2, uint32_t size, float32_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_cdprod_f32(src1, src2, size, dst);
#endif
}
 
static inline void hpm_dsp_cdprod_typ2_f32(const float32_t *src1, const float32_t *src2, uint32_t size, float32_t *rout, float32_t *iout)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_dot_prod_f32(rout, iout, src1, src2, size);
#else
    riscv_dsp_cdprod_typ2_f32(src1, src2, size, rout, iout);
#endif
#endif
}
 
static inline void hpm_dsp_cdprod_q15(const q15_t *src1, const q15_t *src2, uint32_t size, q15_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_cdprod_q15(src1, src2, size, dst);
#endif
}
 
static inline void hpm_dsp_cdprod_typ2_q15(const q15_t *src1, const q15_t *src2, uint32_t size, q31_t *rout, q31_t *iout)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_cdprod_typ2_q15(src1, src2, size, rout, iout);
#endif
}
 
static inline void hpm_dsp_cdprod_q31(const q31_t *src1, const q31_t *src2, uint32_t size, q31_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_cdprod_q31(src1, src2, size, dst);
#endif
}
 
 
static inline void hpm_dsp_cdprod_typ2_q31(const q31_t *src1, const q31_t *src2, uint32_t size, q63_t *rout, q63_t *iout)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_dot_prod_q31(rout, iout, src1, src2, size);
#else
    riscv_dsp_cdprod_typ2_q31(src1, src2, size, rout, iout);
#endif
#endif
}
 
// Complex Magnitude
static inline void hpm_dsp_cmag_f32(const float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mag_f32(dst, src, size);
#else
    riscv_dsp_cmag_f32(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_cmag_q15(const q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mag_q15(dst, src, size);
#else
    riscv_dsp_cmag_q15(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_cmag_q31(const q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mag_q31(dst, src, size);
#else
    riscv_dsp_cmag_q31(src, dst, size);
#endif
#endif
}
 
// Complex Magnitude Squared
static inline void hpm_dsp_cmag_sqr_f32(const float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mag_squared_f32(dst, src, size);
#else
    riscv_dsp_cmag_sqr_f32(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_cmag_sqr_q15(const q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mag_squared_q15(dst, src, size);
#else
    riscv_dsp_cmag_sqr_q15(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_cmag_sqr_q31(const q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mag_squared_q31(dst, src, size);
#else
    riscv_dsp_cmag_sqr_q31(src, dst, size);
#endif
#endif
}
 
// Complex Multiplication
static inline void hpm_dsp_cmul_f32(const float32_t *src1, const float32_t *src2, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mult_cmplx_f32(dst, src1, src2, size);
#else
    riscv_dsp_cmul_f32(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_cmul_q15(const q15_t *src1, const q15_t *src2, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mult_cmplx_q15(dst, src1, src2, size);
#else
    riscv_dsp_cmul_q15(src1, src2, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_cmul_q31(const q31_t *src1, const q31_t *src2, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mult_cmplx_q31(dst, src1, src2, size);
#else
    riscv_dsp_cmul_q31(src1, src2, dst, size);
#endif
#endif
}
 
// Complex-by-Real Multiplication
static inline void hpm_dsp_cmul_real_f32(const float32_t *src, const float32_t *real, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mult_real_f32(dst, src, real, size);
#else
    riscv_dsp_cmul_real_f32(src, real, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_cmul_real_q15(const q15_t *src, const q15_t *real, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mult_real_q15(dst, src, real, size);
#else
    riscv_dsp_cmul_real_q15(src, real, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_cmul_real_q31(const q31_t *src, const q31_t *real, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cmplx_mult_real_q31(dst, src, real, size);
#else
    riscv_dsp_cmul_real_q31(src, real, dst, size);
#endif
#endif
}
#endif
#endif
 
#ifdef HPM_MATH_DSP_CONTROLLER
 
#ifdef HPM_EN_MATH_DSP_LIB
 
#include "riscv_dsp_controller_math.h"
 
// Clarke Transform
static inline void hpm_dsp_clarke_f32(float32_t a, float32_t b, float32_t *alpha, float32_t *beta)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_clarke_f32(a, b, alpha, beta);
#endif
}
static inline void hpm_dsp_clarke_q31(q31_t a, q31_t b, q31_t *alpha, q31_t *beta)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_clarke_q31(a, b, alpha, beta);
#endif
}
 
// Inverse Clarke Transform
static inline void hpm_dsp_inv_clarke_f32(float32_t alpha, float32_t beta, float32_t *a, float32_t *b)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_inv_clarke_f32(alpha, beta, a, b);
#endif
}
static inline void hpm_dsp_inv_clarke_q31(q31_t alpha, q31_t beta, q31_t *a, q31_t *b)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_inv_clarke_q31(alpha, beta, a, b);
#endif
}
 
// Park Transform
static inline void hpm_dsp_park_f32(float32_t alpha, float32_t beta, float32_t *a, float32_t *b, float32_t sin, float32_t cos)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_park_f32(alpha, beta, a, b, sin, cos);
#endif
}
 
static inline void hpm_dsp_park_q31(q31_t alpha, q31_t beta, q31_t *a, q31_t *b, q31_t sin, q31_t cos)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_park_q31(alpha, beta, a, b, sin, cos);
#endif
}
 
// Inverse Park Transform
static inline void hpm_dsp_inv_park_f32(float32_t a, float32_t b, float32_t *alpha, float32_t *beta, float32_t sin, float32_t cos)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_inv_park_f32(a, b, alpha, beta, sin, cos);
#endif
}
static inline void hpm_dsp_inv_park_q31(q31_t a, q31_t b, q31_t *alpha, q31_t *beta, q31_t sin, q31_t cos)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_inv_park_q31(a, b, alpha, beta, sin, cos);
#endif
}
static inline float32_t hpm_dsp_pid_f32(riscv_dsp_pid_f32_t *instance, float32_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_pid_f32(instance, src);
#endif
}
static inline void hpm_dsp_init_pid_f32(riscv_dsp_pid_f32_t *instance, int32_t set)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_init_pid_f32(instance, set);
#endif
}
 
static inline q31_t hpm_dsp_pid_q31(riscv_dsp_pid_q31_t *instance, q31_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_pid_q31(instance, src);
#endif
}
 
static inline void hpm_dsp_init_pid_q31(riscv_dsp_pid_q31_t *instance, int32_t set)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_init_pid_q31(instance, set);
#endif
}
 
static inline q15_t hpm_dsp_pid_q15(riscv_dsp_pid_q15_t *instance, q15_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_pid_q15(instance, src);
#endif
}
static inline void hpm_dsp_init_pid_q15(riscv_dsp_pid_q15_t *instance, int32_t set)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_init_pid_q15(instance, set);
#endif
}
#endif
#endif
 
#ifdef HPM_MATH_DSP_DISTANCE
 
#ifdef HPM_EN_MATH_DSP_LIB
#ifdef __zcc__
#include "tpt_math.h"
#endif
#include "riscv_dsp_distance_math.h"
 
 
static inline float32_t hpm_dsp_dist_bray_curtis_f32(const float32_t *src1, const float32_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_braycurtis_distance_f32(src1, src2, size);
#else
    return riscv_dsp_dist_bray_curtis_f32(src1, src2, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_dist_canberra_f32(const float32_t *src1, const float32_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_canberra_distance_f32(src1, src2, size);
#else
    return riscv_dsp_dist_canberra_f32(src1, src2, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_dist_chebyshev_f32(const float32_t *src1, const float32_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_chebyshev_distance_f32(src1, src2, size);
#else
    return riscv_dsp_dist_chebyshev_f32(src1, src2, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_dist_city_block_f32(const float32_t *src1, const float32_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cityblock_distance_f32(src1, src2, size);
#else
    return riscv_dsp_dist_city_block_f32(src1, src2, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_dist_corr_f32(const float32_t *src1, const float32_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_correlation_distance_f32(src1, src2, size);
#else
    return riscv_dsp_dist_corr_f32(src1, src2, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_dist_cos_f32(const float32_t *src1, const float32_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cosine_distance_f32(src1, src2, size);
#else
    return riscv_dsp_dist_cos_f32(src1, src2, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_dist_euclidean_f32(const float32_t *src1, const float32_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_euclidean_distance_f32(src1, src2, size);
#else
    return riscv_dsp_dist_euclidean_f32(src1, src2, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_dist_jensen_shannon_f32(const float32_t *src1, const float32_t *src2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_jensenshannon_distance_f32(src1, src2, size);
#else
    return riscv_dsp_dist_jensen_shannon_f32(src1, src2, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_dist_minkowski_f32(const float32_t *src1, const float32_t *src2, int32_t order, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_minkowski_distance_f32(src1, src2, order, size);
#else
    return riscv_dsp_dist_minkowski_f32(src1, src2, order, size);
#endif
#endif
}
 
static inline float32_t hpm_dsp_bdist_dice_u32_f32(const uint32_t *src1, const uint32_t *src2, uint32_t numofbool)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_dice_distance(src1, src2, numofbool);
#else
    return riscv_dsp_bdist_dice_u32_f32(src1, src2, numofbool);
#endif
#endif
}
 
static inline float32_t hpm_dsp_bdist_hamming_u32_f32(const uint32_t *src1, const uint32_t *src2, uint32_t numofbool)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_hamming_distance(src1, src2, numofbool);
#else
    return riscv_dsp_bdist_hamming_u32_f32(src1, src2, numofbool);
#endif
#endif
}
 
static inline float32_t hpm_dsp_bdist_jaccard_u32_f32(const uint32_t *src1, const uint32_t *src2, uint32_t numofbool)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_jaccard_distance(src1, src2, numofbool);
#else
    return riscv_dsp_bdist_jaccard_u32_f32(src1, src2, numofbool);
#endif
#endif
}
 
static inline float32_t hpm_dsp_bdist_kulsinski_u32_f32(const uint32_t *src1, const uint32_t *src2, uint32_t numofbool)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_kulsinski_distance(src1, src2, numofbool);
#else
    return riscv_dsp_bdist_kulsinski_u32_f32(src1, src2, numofbool);
#endif
#endif
}
 
static inline float32_t hpm_dsp_bdist_sokal_michener_u32_f32(const uint32_t *src1, const uint32_t *src2, uint32_t numofbool)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_sokalmichener_distance(src1, src2, numofbool);
#else
    return riscv_dsp_bdist_sokal_michener_u32_f32(src1, src2, numofbool);
#endif
#endif
}
 
static inline float32_t hpm_dsp_bdist_sokal_sneath_u32_f32(const uint32_t *src1, const uint32_t *src2, uint32_t numofbool)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_sokalsneath_distance(src1, src2, numofbool);
#else
    return riscv_dsp_bdist_sokal_sneath_u32_f32(src1, src2, numofbool);
#endif
#endif
}
 
static inline float32_t hpm_dsp_bdist_rogers_tanimoto_u32_f32(const uint32_t *src1, const uint32_t *src2, uint32_t numofbool)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_rogerstanimoto_distance(src1, src2, numofbool);
#else
    return riscv_dsp_bdist_rogers_tanimoto_u32_f32(src1, src2, numofbool);
#endif
#endif
}
 
static inline float32_t hpm_dsp_bdist_yule_u32_f32(const uint32_t *src1, const uint32_t *src2, uint32_t numofbool)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_yule_distance(src1, src2, numofbool);
#else
    return riscv_dsp_bdist_yule_u32_f32(src1, src2, numofbool);
#endif
#endif
}
 
static inline float32_t hpm_dsp_bdist_russell_rao_u32_f32(const uint32_t *src1, const uint32_t *src2, uint32_t numofbool)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_russellrao_distance(src1, src2, numofbool);
#else
    return riscv_dsp_bdist_russell_rao_u32_f32(src1, src2, numofbool);
#endif
#endif
}
#endif
#endif
 
#ifdef HPM_MATH_DSP_FILTERING
 
#ifdef HPM_EN_MATH_DSP_LIB
 
#ifdef __zcc__
#include "tpt_math.h"
#endif
 
#include "riscv_dsp_filtering_math.h"
 
static inline void hpm_dsp_fir_f32(const riscv_dsp_fir_f32_t *instance, float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_fir_f32(instance, src, dst, size);
#endif
}
 
static inline void hpm_dsp_fir_q31(const riscv_dsp_fir_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_fir_q31(instance, src, dst, size);
#endif
}
 
static inline void hpm_dsp_fir_fast_q31(const riscv_dsp_fir_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_fir_fast_q31(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_fir_q15(const riscv_dsp_fir_q15_t *instance, q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_fir_q15(instance, src, dst, size);
#endif
}
 
static inline void hpm_dsp_fir_fast_q15(const riscv_dsp_fir_q15_t *instance, q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_fir_fast_q15(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_fir_q7(const riscv_dsp_fir_q7_t *instance, q7_t *src, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_fir_q7(instance, src, dst, size);
#endif
}
 
static inline void hpm_dsp_lfir_f32(const riscv_dsp_lfir_f32_t *instance, float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_lfir_f32(instance, src, dst, size);
#endif
}
 
static inline void hpm_dsp_lfir_q15(const riscv_dsp_lfir_q15_t *instance, q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_lfir_q15(instance, src, dst, size);
#endif
}
 
static inline void hpm_dsp_lfir_q31(const riscv_dsp_lfir_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_lfir_q31(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_dcmfir_f32(const riscv_dsp_dcmfir_f32_t *instance, float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dcmfir_f32(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_dcmfir_q15(const riscv_dsp_dcmfir_q15_t *instance, q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dcmfir_q15(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_dcmfir_q31(const riscv_dsp_dcmfir_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dcmfir_q31(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_dcmfir_fast_q31(const riscv_dsp_dcmfir_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dcmfir_fast_q31(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_dcmfir_fast_q15(const riscv_dsp_dcmfir_q15_t *instance, q15_t *src,  q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dcmfir_fast_q15(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_upsplfir_f32(const riscv_dsp_upsplfir_f32_t *instance, float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_upsplfir_f32(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_upsplfir_q15(const riscv_dsp_upsplfir_q15_t *instance, q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_upsplfir_q15(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_upsplfir_q31(const riscv_dsp_upsplfir_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_upsplfir_q31(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_spafir_f32(riscv_dsp_spafir_f32_t *instance, float32_t *src, float32_t *dst, float32_t *buf, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_spafir_f32(instance, src, dst, buf, size);
#endif
}
static inline void hpm_dsp_spafir_q15(riscv_dsp_spafir_q15_t *instance, q15_t *src, q15_t *dst, q15_t *buf1, q31_t *buf2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_spafir_q15(instance, src, dst, buf1, buf2, size);
#endif
}
static inline void hpm_dsp_spafir_q31(riscv_dsp_spafir_q31_t *instance, q31_t *src, q31_t *dst, q31_t *buf, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_spafir_q31(instance, src, dst, buf, size);
#endif
}
static inline void hpm_dsp_spafir_q7(riscv_dsp_spafir_q7_t *instance, q7_t *src, q7_t *dst, q7_t *buf1, q31_t *buf2, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_spafir_q7(instance, src, dst, buf1, buf2, size);
#endif
}
 
// Standard LMS filte
static inline void hpm_dsp_lms_f32(const riscv_dsp_lms_f32_t *instance, float32_t *src, float32_t *ref, float32_t *dst, float32_t *err, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_lms_f32(instance, src, ref, dst, err, size);
#endif
}
 
static inline void hpm_dsp_lms_q31(const riscv_dsp_lms_q31_t *instance, q31_t *src, q31_t *ref, q31_t *dst, q31_t *err, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_lms_q31(instance, src, ref, dst, err, size);
#endif
}
 
static inline void hpm_dsp_lms_q15(const riscv_dsp_lms_q15_t *instance, q15_t *src, q15_t *ref, q15_t *dst, q15_t *err, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_lms_q15(instance, src, ref, dst, err, size);
#endif
}
 
static inline void hpm_dsp_nlms_f32(riscv_dsp_nlms_f32_t *instance, float32_t *src, float32_t *ref, float32_t *dst, float32_t *err, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_nlms_f32(instance, src, ref, dst, err, size);
#endif
}
 
 
static inline void hpm_dsp_nlms_q31(riscv_dsp_nlms_q31_t *instance, q31_t *src, q31_t *ref, q31_t *dst, q31_t *err, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_nlms_q31(instance, src, ref, dst, err, size);
#endif
}
 
 
static inline void hpm_dsp_nlms_q15(riscv_dsp_nlms_q15_t *instance, q15_t *src, q15_t *ref, q15_t *dst, q15_t *err, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_nlms_q15(instance, src, ref, dst, err, size);
#endif
}
 
 
// Convolution
static inline void hpm_dsp_conv_f32(float32_t *src1, uint32_t len1, float32_t *src2, uint32_t len2, float32_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_conv_f32(dst, src1, len1, src2, len2);
#else
    riscv_dsp_conv_f32(src1, len1, src2, len2, dst);
#endif
#endif
}
 
static inline void hpm_dsp_conv_q15(q15_t *src1, uint32_t len1, q15_t *src2, uint32_t len2, q15_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_conv_q15(dst, src1, len1, src2, len2);
#else
    riscv_dsp_conv_q15(src1, len1, src2, len2, dst);
#endif
#endif
}
 
static inline void hpm_dsp_conv_q31(q31_t *src1, uint32_t len1, q31_t *src2, uint32_t len2, q31_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_conv_q31(dst, src1, len1, src2, len2);
#else
    riscv_dsp_conv_q31(src1, len1, src2, len2, dst);
#endif
#endif
}
 
static inline void hpm_dsp_conv_q7(q7_t *src1, uint32_t len1, q7_t *src2, uint32_t len2, q7_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_conv_q7(dst, src1, len1, src2, len2);
#else
    riscv_dsp_conv_q7(src1, len1, src2, len2, dst);
#endif
#endif
}
 
static inline int32_t hpm_dsp_conv_partial_f32(float32_t *src1, uint32_t len1, float32_t *src2, uint32_t len2, float32_t *dst, uint32_t startindex, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_conv_partial_f32(dst, src1, len1, src2, len2, startindex, size);
#else
    return riscv_dsp_conv_partial_f32(src1, len1, src2, len2, dst, startindex,
                                    size);
#endif
#endif
}
 
static inline int32_t hpm_dsp_conv_partial_q15(q15_t *src1, uint32_t len1, q15_t *src2, uint32_t len2, q15_t *dst, uint32_t startindex, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_conv_partial_q15(dst, src1, len1, src2, len2, startindex, size);
#else
    return riscv_dsp_conv_partial_q15(src1, len1, src2, len2, dst, startindex,
                                    size);
#endif
#endif
}
 
static inline int32_t hpm_dsp_conv_partial_q31(q31_t *src1, uint32_t len1, q31_t *src2, uint32_t len2, q31_t *dst, uint32_t startindex, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_conv_partial_q31(dst, src1, len1, src2, len2, startindex, size);
#else
    return riscv_dsp_conv_partial_q31(src1, len1, src2, len2, dst, startindex,
                                    size);
#endif
#endif
}
 
static inline int32_t hpm_dsp_conv_partial_q7(q7_t *src1, uint32_t len1, q7_t *src2, uint32_t len2, q7_t *dst, uint32_t startindex, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_conv_partial_q7(dst, src1, len1, src2, len2, startindex, size);
#else
    return riscv_dsp_conv_partial_q7(src1, len1, src2, len2, dst, startindex,
                                   size);
#endif
#endif
}
 
 
// Correlation
static inline void hpm_dsp_corr_f32(float32_t *src1, uint32_t len1, float32_t *src2, uint32_t len2, float32_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_correlate_f32(dst, src1, len1, src2, len2);
#else
    riscv_dsp_corr_f32(src1, len1, src2, len2, dst);
#endif
#endif
}
 
static inline void hpm_dsp_corr_q15(q15_t *src1, uint32_t len1, q15_t *src2, uint32_t len2, q15_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_correlate_q15(dst, src1, len1, src2, len2);
#else
    riscv_dsp_corr_q15(src1, len1, src2, len2, dst);
#endif
#endif
}
 
static inline void hpm_dsp_corr_q31(q31_t *src1, uint32_t len1, q31_t *src2, uint32_t len2, q31_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_correlate_q31(dst, src1, len1, src2, len2);
#else
    riscv_dsp_corr_q31(src1, len1, src2, len2, dst);
#endif
#endif
}
 
static inline void hpm_dsp_corr_q7(q7_t *src1, uint32_t len1, q7_t *src2, uint32_t len2, q7_t *dst)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_correlate_q7(dst, src1, len1, src2, len2);
#else
    riscv_dsp_corr_q7(src1, len1, src2, len2, dst);
#endif
#endif
}
static inline void hpm_dsp_bq_df1_f32(const riscv_dsp_bq_df1_f32_t *instance, float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_bq_df1_f32(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_bq_df1_q15(const riscv_dsp_bq_df1_q15_t *instance, q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_bq_df1_q15(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_bq_df1_fast_q15(const riscv_dsp_bq_df1_q15_t *instance, q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_bq_df1_fast_q15(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_bq_df1_q31(const riscv_dsp_bq_df1_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_bq_df1_q31(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_bq_df1_fast_q31(const riscv_dsp_bq_df1_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_bq_df1_fast_q31(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_bq_df1_32x64_q31(const riscv_dsp_bq_df1_32x64_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_bq_df1_32x64_q31(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_bq_df2T_f32(const riscv_dsp_bq_df2T_f32_t *instance, float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_bq_df2T_f32(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_bq_df2T_f64(const riscv_dsp_bq_df2T_f64_t *instance, float64_t *src, float64_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_bq_df2T_f64(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_bq_stereo_df2T_f32(const riscv_dsp_bq_stereo_df2T_f32_t *instance, float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_bq_stereo_df2T_f32(instance, src, dst, size);
#endif
}
 
static inline void hpm_dsp_liir_f32(const riscv_dsp_liir_f32_t *instance, float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_liir_f32(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_liir_q31(const riscv_dsp_liir_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_liir_q31(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_liir_fast_q31(const riscv_dsp_liir_q31_t *instance, q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_liir_fast_q31(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_liir_q15(const riscv_dsp_liir_q15_t *instance, q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_liir_q15(instance, src, dst, size);
#endif
}
static inline void hpm_dsp_liir_fast_q15(const riscv_dsp_liir_q15_t *instance, q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_liir_fast_q15(instance, src, dst, size);
#endif
}
#endif
#endif
 
#ifdef HPM_MATH_DSP_MATRIX
 
#ifdef HPM_EN_MATH_DSP_LIB
#ifdef __zcc__
#include "tpt_math.h"
#endif
#include "riscv_dsp_matrix_math.h"
 
// Matrix Addition
static inline void hpm_dsp_mat_add_f32(const float32_t *src1, const float32_t *src2, float32_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_add_f32(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_add_f32(src1, src2, dst, row, col);
#endif
#endif
}
 
static inline void hpm_dsp_mat_add_q15(const q15_t *src1, const q15_t *src2, q15_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_add_q15(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_add_q15(src1, src2, dst, row, col);
#endif
#endif
}
 
static inline void hpm_dsp_mat_add_q31(const q31_t *src1, const q31_t *src2, q31_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_add_q31(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_add_q31(src1, src2, dst, row, col);
#endif
#endif
}
 
// Matrix Inverse
static inline int32_t hpm_dsp_mat_inv_f32(float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_inverse_f32(dst, src, size);
#else
    return riscv_dsp_mat_inv_f32(src, dst, size);
#endif
#endif
}
static inline int32_t hpm_dsp_mat_inv_f64(float64_t *src, float64_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_inverse_f64(dst, src, size);
#else
    return riscv_dsp_mat_inv_f64(src, dst, size);
#endif
#endif
}
 
// Matrix Multiplication
static inline void hpm_dsp_mat_mul_f32(const float32_t *src1, const float32_t *src2, float32_t *dst, uint32_t row, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_mult_f32(dst, src1, src2, row, col, col2);
#else
    riscv_dsp_mat_mul_f32(src1, src2, dst, row, col, col2);
#endif
#endif
}
 
static inline void hpm_dsp_mat_mul_f64(const float64_t *src1, const float64_t *src2, float64_t *dst, uint32_t row, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_mult_f64(dst, src1, src2, row, col, col2);
#else
    riscv_dsp_mat_mul_f64(src1, src2, dst, row, col, col2);
#endif
#endif
}
 
static inline void hpm_dsp_cmat_mul_f32(const float32_t *src1, const float32_t *src2, float32_t *dst, uint32_t row, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_cmplx_mult_f32(dst, src1, src2, row, col, col2);
#else
    riscv_dsp_cmat_mul_f32(src1, src2, dst, row, col, col2);
#endif
#endif
}
 
static inline void hpm_dsp_mat_mul_q15(const q15_t *src1, const q15_t *src2, q15_t *dst, uint32_t row, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_mult_q15(dst, src1, src2, row, col, col2);
#else
    riscv_dsp_mat_mul_q15(src1, src2, dst, row, col, col2);
#endif
#endif
}
static inline void hpm_dsp_mat_mul_fast_q15(const q15_t *src1, const q15_t *src2, q15_t *dst, uint32_t row, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_mult_q15(dst, src1, src2, row, col, col2);
#else
    riscv_dsp_mat_mul_fast_q15(src1, src2, dst, row, col, col2);
#endif
#endif
}
 
static inline void hpm_dsp_cmat_mul_q15(const q15_t *src1, const q15_t *src2, q15_t *dst, uint32_t row, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_cmplx_mult_q15(dst, src1, src2, row, col, col2);
#else
    riscv_dsp_cmat_mul_q15(src1, src2, dst, row, col, col2);
#endif
#endif
}
 
static inline void hpm_dsp_mat_mul_q31(const q31_t *src1, const q31_t *src2, q31_t *dst, uint32_t row, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_mult_q31(dst, src1, src2, row, col, col2);
#else
    riscv_dsp_mat_mul_q31(src1, src2, dst, row, col, col2);
#endif
#endif
}
static inline void hpm_dsp_mat_mul_fast_q31(const q31_t *src1, const q31_t *src2, q31_t *dst, uint32_t row, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_mult_q31(dst, src1, src2, row, col, col2);
#else
    riscv_dsp_mat_mul_fast_q31(src1, src2, dst, row, col, col2);
#endif
#endif
}
 
static inline void hpm_dsp_cmat_mul_q31(const q31_t *src1, const q31_t *src2, q31_t *dst, uint32_t row, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_mat_cmplx_mult_q31(dst, src1, src2, row, col, col2);
#else
    riscv_dsp_cmat_mul_q31(src1, src2, dst, row, col, col2);
#endif
#endif
}
 
static inline void hpm_dsp_mat_mul_q7(const q7_t *src1, const q7_t *src2, q7_t *dst, uint32_t row, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_mat_mul_q7(src1, src2, dst, row, col, col2);
#endif
}
 
static inline void hpm_dsp_mat_mul_vxm_q7(const q7_t * src1, const q7_t * src2, q7_t * dst, uint32_t col, uint32_t col2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_mul_mxv_q7(dst, src1, src2, col, col2);
#else
    riscv_dsp_mat_mul_vxm_q7(src1, src2, dst, col, col2);
#endif
#endif
}
 
// Matrix Power 2 Function
//
// The input is a square matrix for riscv_dsp_mat_pow2_cache_f64.
static inline int32_t hpm_dsp_mat_pwr2_cache_f64(const float64_t *src, float64_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_mat_pwr2_cache_f64(src, dst, size);
#endif
}
 
// Matrix Scale
static inline void hpm_dsp_mat_scale_f32(const float32_t *src, float32_t scale, float32_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_scale_f32(dst, src, row, col, scale);
#else
    riscv_dsp_mat_scale_f32(src, scale, dst, row, col);
#endif
#endif
}
 
static inline void hpm_dsp_mat_scale_q15(const q15_t *src, q15_t scale_fract, int32_t shift, q15_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_scale_q15(dst, src, row, col, scale_fract, shift);
#else
    riscv_dsp_mat_scale_q15(src, scale_fract, shift, dst, row, col);
#endif
#endif
}
 
static inline void hpm_dsp_mat_scale_q31(const q31_t *src, q31_t scale_fract, int32_t shift, q31_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_scale_q31(dst, src, row, col, scale_fract, shift);
#else
    riscv_dsp_mat_scale_q31(src, scale_fract, shift, dst, row, col);
#endif
#endif
}
 
// Matrix Subtraction
 
static inline void hpm_dsp_mat_sub_f64(const float64_t *src1, const float64_t *src2,
                       float64_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_sub_f64(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_sub_f64(src1, src2, dst, row, col);
#endif
#endif
}
 
static inline void hpm_dsp_mat_sub_f32(const float32_t *src1, const float32_t *src2, float32_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_sub_f32(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_sub_f32(src1, src2, dst, row, col);
#endif
#endif
}
 
static inline void hpm_dsp_mat_sub_q15(const q15_t *src1, const q15_t *src2, q15_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_sub_q15(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_sub_q15(src1, src2, dst, row, col);
#endif
#endif
}
 
static inline void hpm_dsp_mat_sub_q31(const q31_t *src1, const q31_t *src2, q31_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_sub_q31(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_sub_q31(src1, src2, dst, row, col);
#endif
#endif
}
 
// Matrix Transpose
 
static inline void hpm_dsp_mat_trans_f64(const float64_t *src, float64_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_trans_f64(dst, src, row, col);
#else
    riscv_dsp_mat_trans_f64(src, dst, row, col);
#endif
#endif
}
 
static inline void hpm_dsp_mat_trans_f32(const float32_t *src, float32_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_mat_trans_f32(src, dst, row, col);
#endif
}
 
static inline void hpm_dsp_mat_trans_q15(const q15_t *src, q15_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_trans_q15(dst, src, row, col);
#else
    riscv_dsp_mat_trans_q15(src, dst, row, col);
#endif
#endif
}
 
static inline void hpm_dsp_mat_trans_q31(const q31_t *src, q31_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_trans_q31(dst, src, row, col);
#else
    riscv_dsp_mat_trans_q31(src, dst, row, col);
#endif
#endif
}
 
static inline void hpm_dsp_mat_trans_u8(const uint8_t *src, uint8_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_mat_trans_u8(src, dst, row, col);
#endif
}
 
static inline void hpm_dsp_mat_trans_q7(const q7_t *src, q7_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_mat_trans_q7(src, dst, row, col);
#endif
}
 
static inline void hpm_dsp_mat_oprod_q31(const q31_t * src1, const q31_t * src2,
                       q31_t * dst, uint32_t size1, uint32_t size2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_oprod_q31(dst, src1, src2, size1, size2);
#else
    riscv_dsp_mat_oprod_q31(src1, src2, dst, size1, size2);
#endif
#endif
}
 
static inline void hpm_dsp_mat_mul_mxv_f32(const float32_t *src1, const float32_t *src2,
                       float32_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_mul_mxv_f32(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_mul_mxv_f32(src1, src2, dst, row, col);
#endif
#endif
}
static inline void hpm_dsp_mat_mul_mxv_q15(const q15_t *src1, const q15_t *src2,
                       q15_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_mul_mxv_q15(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_mul_mxv_q15(src1, src2, dst, row, col);
#endif
#endif
}
static inline void hpm_dsp_mat_mul_mxv_q31(const q31_t *src1, const q31_t *src2,
                       q31_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_mul_mxv_q31(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_mul_mxv_q31(src1, src2, dst, row, col);
#endif
#endif
}
static inline void hpm_dsp_mat_mul_mxv_q7(const q7_t *src1, const q7_t *src2,
                       q7_t *dst, uint32_t row, uint32_t col)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_mat_mul_mxv_q7(dst, src1, src2, row, col);
#else
    riscv_dsp_mat_mul_mxv_q7(src1, src2, dst, row, col);
#endif
#endif
}
 
#endif
#endif
 
#ifdef HPM_MATH_DSP_SVM
 
#ifdef HPM_EN_MATH_DSP_LIB
#ifdef __zcc__
#include "tpt_math.h"
#endif
#include "riscv_dsp_svm_math.h"
static inline void hpm_dsp_svm_linear_est_f32(const riscv_dsp_svm_linear_f32_t *instance, const float32_t *src, int32_t *result)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_svm_linear_est_f32(instance, src, result);
#endif
}
 
static inline void hpm_dsp_svm_sigmoid_est_f32(const riscv_dsp_svm_sigmoid_f32_t *instance, const float32_t *src, int32_t *result)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_svm_sigmoid_est_f32(instance, src, result);
#endif
}
 
static inline void hpm_dsp_svm_rbf_est_f32(const riscv_dsp_svm_rbf_f32_t *instance, const float32_t *src, int32_t *result)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_svm_rbf_est_f32(instance, src, result);
#endif
}
 
static inline void hpm_dsp_svm_poly_est_f32(const riscv_dsp_svm_poly_f32_t *instance, const float32_t *src, int32_t *result)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_svm_poly_est_f32(instance, src, result);
#endif
}
 
#endif
#endif
 
#ifdef HPM_MATH_DSP_TRANSFORM
 
#ifdef HPM_EN_MATH_DSP_LIB
#ifdef __zcc__
#include "tpt_math.h"
#endif
#include "riscv_dsp_transform_math.h"
static inline int32_t hpm_dsp_cfft_rd2_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_f32(src, m, false);
#else
    return riscv_dsp_cfft_rd2_f32(src, m);
#endif
#endif
}
 
static inline int32_t hpm_dsp_cifft_rd2_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_f32(src, m, true);
#else
    return riscv_dsp_cifft_rd2_f32(src, m);
#endif
 
#endif
}
 
static inline int32_t hpm_dsp_cfft_rd2_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_q15(src, m, false);
#else
    return riscv_dsp_cfft_rd2_q15(src, m);
#endif
#endif
}
 
static inline int32_t hpm_dsp_cifft_rd2_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_q15(src, m, true);
#else
    return riscv_dsp_cifft_rd2_q15(src, m);
#endif
#endif
}
 
static inline int32_t hpm_dsp_cfft_rd2_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_q31(src, m, false);
#else
    return riscv_dsp_cfft_rd2_q31(src, m);
#endif
 
#endif
}
 
static inline int32_t hpm_dsp_cifft_rd2_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_q31(src, m, true);
#else
    return riscv_dsp_cifft_rd2_q31(src, m);
#endif
 
#endif
}
 
static inline int32_t hpm_dsp_cfft_rd4_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_f32(src, m, false);
#else
    return riscv_dsp_cfft_rd4_f32(src, m);
#endif
 
#endif
}
 
static inline int32_t hpm_dsp_cifft_rd4_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_f32(src, m, true);
#else
    return riscv_dsp_cifft_rd4_f32(src, m);
#endif
#endif
}
 
static inline int32_t hpm_dsp_cfft_rd4_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_q15(src, m, false);
#else
    return riscv_dsp_cfft_rd4_q15(src, m);
#endif
#endif
}
 
static inline int32_t hpm_dsp_cifft_rd4_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_q15(src, m, true);
#else
    return riscv_dsp_cifft_rd4_q15(src, m);
#endif
#endif
}
 
static inline int32_t hpm_dsp_cfft_rd4_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_q31(src, m, false);
#else
    return riscv_dsp_cfft_rd4_q31(src, m);
#endif
#endif
}
 
static inline int32_t hpm_dsp_cifft_rd4_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_cfft_q31(src, m, true);
#else
    return riscv_dsp_cifft_rd4_q31(src, m);
#endif
#endif
}
 
static inline void hpm_dsp_cfft_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cfft_f32(src, m, false);
#else
    riscv_dsp_cfft_f32(src, m);
#endif
#endif
}
 
static inline void hpm_dsp_cfft_f64(float64_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cfft_f64(src, m, false);
#else
    riscv_dsp_cfft_f64(src, m);
#endif
#endif
}
 
static inline void hpm_dsp_cifft_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cfft_f32(src, m, true);
#else
    riscv_dsp_cifft_f32(src, m);
#endif
#endif
}
 
static inline void hpm_dsp_cifft_f64(float64_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cfft_f64(src, m, true);
#else
    riscv_dsp_cifft_f64(src, m);
#endif
#endif
}
 
 
static inline void hpm_dsp_cfft_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cfft_q15(src, m, false);
#else
    riscv_dsp_cfft_q15(src, m);
#endif
#endif
}
 
static inline void hpm_dsp_cifft_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cfft_q15(src, m, true);
#else
    riscv_dsp_cifft_q15(src, m);
#endif
#endif
}
 
static inline void hpm_dsp_cfft_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cfft_q31(src, m, false);
#else
    riscv_dsp_cfft_q31(src, m);
#endif
#endif
}
 
static inline void hpm_dsp_cifft_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_cfft_q31(src, m, true);
#else
    riscv_dsp_cifft_q31(src, m);
#endif
#endif
}
 
static inline int32_t hpm_dsp_rfft_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    return tpt_rfft_f32(src, src, m, false);
#else
    return riscv_dsp_rfft_f32(src, m);
#endif
#endif
}
 
static inline int32_t hpm_dsp_rfft_f64(float64_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_rfft_f64(src, m);
#endif
}
 
static inline int32_t hpm_dsp_rifft_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_rifft_f32(src, m);
#endif
}
 
static inline int32_t hpm_dsp_rifft_f64(float64_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_rifft_f64(src, m);
#endif
}
 
static inline int32_t hpm_dsp_rfft_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_rfft_q15(src, m);
#endif
}
 
static inline int32_t hpm_dsp_rifft_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_rifft_q15(src, m);
#endif
}
 
static inline int32_t hpm_dsp_rfft_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_rfft_q31(src, m);
#endif
}
 
static inline int32_t hpm_dsp_rifft_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_rifft_q31(src, m);
#endif
}
 
static inline void hpm_dsp_dct_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dct_f32(src, m);
#endif
}
 
static inline void hpm_dsp_idct_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_idct_f32(src, m);
#endif
}
 
static inline void hpm_dsp_dct_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dct_q15(src, m);
#endif
}
 
static inline void hpm_dsp_idct_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_idct_q15(src, m);
#endif
}
 
static inline void hpm_dsp_dct_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dct_q31(src, m);
#endif
}
 
static inline void hpm_dsp_idct_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_idct_q31(src, m);
#endif
}
 
static inline void hpm_dsp_dct4_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dct4_f32(src, m);
#endif
}
 
static inline void hpm_dsp_idct4_f32(float32_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_idct4_f32(src, m);
#endif
}
 
static inline void hpm_dsp_dct4_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dct4_q15(src, m);
#endif
}
 
static inline void hpm_dsp_idct4_q15(q15_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_idct4_q15(src, m);
#endif
}
 
static inline void hpm_dsp_dct4_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dct4_q31(src, m);
#endif
}
 
static inline void hpm_dsp_idct4_q31(q31_t *src, uint32_t m)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_idct4_q31(src, m);
#endif
}
 
void hpm_software_cfft_float(float *src, uint32_t m);
 
#endif
 
#if defined(HPMSOC_HAS_HPMSDK_FFA) && defined(HPM_EN_MATH_DSP_LIB)
 
#include "hpm_ffa_drv.h"
#include "hpm_soc.h"
static inline void hpm_ffa_cfft_q15(q15_t *src, uint32_t m)
{
    fft_xfer_t xfer = { 0 };
    xfer.num_points = 1 << m;
    xfer.src = src;
    xfer.dst = src;
    xfer.is_ifft = false;
    xfer.src_data_type = FFA_DATA_TYPE_COMPLEX_Q15;
    xfer.dst_data_type = FFA_DATA_TYPE_COMPLEX_Q15;
    ffa_calculate_fft_blocking(HPM_FFA, &xfer);
}
static inline void hpm_ffa_cfft_q31(q31_t *src, uint32_t m)
{
    fft_xfer_t xfer = { 0 };
    xfer.num_points = 1 << m;
    xfer.src = src;
    xfer.dst = src;
    xfer.is_ifft = false;
    xfer.src_data_type = FFA_DATA_TYPE_COMPLEX_Q31;
    xfer.dst_data_type = FFA_DATA_TYPE_COMPLEX_Q31;
    ffa_calculate_fft_blocking(HPM_FFA, &xfer);
}
 
#if defined(HPM_IP_FEATURE_FFA_FP32) && HPM_IP_FEATURE_FFA_FP32
static inline void hpm_ffa_cfft_f32(float *src, uint32_t m)
{
    fft_xfer_t xfer = { 0 };
    xfer.num_points = 1 << m;
    xfer.src = src;
    xfer.dst = src;
    xfer.is_ifft = false;
    xfer.src_data_type = FFA_DATA_TYPE_COMPLEX_FP32;
    xfer.dst_data_type = FFA_DATA_TYPE_COMPLEX_FP32;
    ffa_enable_fp_bias(HPM_FFA);
    ffa_set_coef_max_index(HPM_FFA, 0);
    ffa_set_output_max_index(HPM_FFA, 20);
    ffa_set_input_max_index(HPM_FFA, 20 -  m);
    ffa_calculate_fft_blocking(HPM_FFA, &xfer);
}
#endif
static inline void hpm_ffa_cifft_q15(q15_t *src, uint32_t m)
{
    fft_xfer_t xfer = { 0 };
    xfer.num_points = 1 << m;
    xfer.src = src;
    xfer.dst = src;
    xfer.is_ifft = true;
    xfer.src_data_type = FFA_DATA_TYPE_COMPLEX_Q15;
    xfer.dst_data_type = FFA_DATA_TYPE_COMPLEX_Q15;
    ffa_calculate_fft_blocking(HPM_FFA, &xfer);
}
 
static inline void hpm_ffa_cifft_q31(q31_t *src, uint32_t m)
{
    fft_xfer_t xfer = { 0 };
    xfer.num_points = 1 << m;
    xfer.src = src;
    xfer.dst = src;
    xfer.is_ifft = true;
    xfer.src_data_type = FFA_DATA_TYPE_COMPLEX_Q31;
    xfer.dst_data_type = FFA_DATA_TYPE_COMPLEX_Q31;
    ffa_calculate_fft_blocking(HPM_FFA, &xfer);
}
 
#if defined(HPM_IP_FEATURE_FFA_FP32) && HPM_IP_FEATURE_FFA_FP32
static inline void hpm_ffa_cifft_f32(float *src, uint32_t m)
{
    fft_xfer_t xfer = { 0 };
    xfer.num_points = 1 << m;
    xfer.src = src;
    xfer.dst = src;
    xfer.is_ifft = true;
    xfer.src_data_type = FFA_DATA_TYPE_COMPLEX_FP32;
    xfer.dst_data_type = FFA_DATA_TYPE_COMPLEX_FP32;
    ffa_enable_fp_bias(HPM_FFA);
    ffa_set_coef_max_index(HPM_FFA, 0x0);
    ffa_set_output_max_index(HPM_FFA, 10);
    ffa_set_input_max_index(HPM_FFA, 20);
    ffa_calculate_fft_blocking(HPM_FFA, &xfer);
}
#endif
 
#endif
 
#endif
 
#ifdef HPM_MATH_DSP_UTILS
 
#ifdef HPM_EN_MATH_DSP_LIB
#ifdef __zcc__
#include <tpt_math.h>
#endif
#include "riscv_dsp_utils_math.h"
// Cosine and Sine
static inline float32_t hpm_dsp_cos_f32(float32_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_cos_f32(src);
#endif
}
static inline q31_t hpm_dsp_cos_q31(q31_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_cos_q31(src);
#endif
}
static inline q15_t hpm_dsp_cos_q15(q15_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_cos_q15(src);
#endif
}
 
static inline float32_t hpm_dsp_sin_f32(float32_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_sin_f32(src);
#endif
}
 
#if defined (__riscv_zfh)
static inline float16_t hpm_dsp_sin_f16(float16_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_sin_f16(src);
#endif
}
#endif
 
static inline q31_t hpm_dsp_sin_q31(q31_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_sin_q31(src);
#endif
}
static inline q15_t hpm_dsp_sin_q15(q15_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_sin_q15(src);
#endif
}
 
// Arc tangent
static inline float32_t hpm_dsp_atan_f32(float32_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_atan_f32(src);
#endif
}
static inline q31_t hpm_dsp_atan_q31(q31_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_atan_q31(src);
#endif
}
static inline q15_t hpm_dsp_atan_q15(q15_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_atan_q15(src);
#endif
}
static inline float32_t hpm_dsp_atan2_f32(float32_t srcy, float32_t src2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_atan2_f32(srcy, src2);
#endif
}
static inline q15_t hpm_dsp_atan2_q15(q15_t srcy, q15_t src2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_atan2_q15(srcy, src2);
#endif
}
static inline q31_t hpm_dsp_atan2_q31(q31_t srcy, q31_t src2)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_atan2_q31(srcy, src2);
#endif
}
 
// Square Root
static inline float32_t hpm_dsp_sqrt_f32(float32_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_sqrt_f32(src);
#endif
}
 
static inline q31_t hpm_dsp_sqrt_q31(q31_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_sqrt_q31(src);
#endif
}
 
static inline q15_t hpm_dsp_sqrt_q15(q15_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_sqrt_q15(src);
#endif
}
 
// Convert function
static inline void hpm_dsp_convert_f32_q15(float32_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_convert_f32_q15(src, dst, size);
#endif
}
 
static inline void hpm_dsp_convert_f32_q31(float32_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_f32_to_q31(dst, src, size);
#else
    riscv_dsp_convert_f32_q31(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_convert_f32_q7(float32_t *src, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_convert_f32_q7(src, dst, size);
#endif
}
 
static inline void hpm_dsp_convert_q15_f32(q15_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_convert_q15_f32(src, dst, size);
#endif
}
 
static inline void hpm_dsp_convert_q15_q31(q15_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_convert_q15_q31(src, dst, size);
#endif
}
 
static inline void hpm_dsp_convert_q15_q7(q15_t *src, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_convert_q15_q7(src, dst, size);
#endif
}
 
static inline void hpm_dsp_convert_q31_f32(q31_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
#ifdef __zcc__
    tpt_q31_to_f32(dst, src, size);
#else
    riscv_dsp_convert_q31_f32(src, dst, size);
#endif
#endif
}
 
static inline void hpm_dsp_convert_q31_q15(q31_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_convert_q31_q15(src, dst, size);
#endif
}
 
static inline void hpm_dsp_convert_q31_q7(q31_t *src, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_convert_q31_q7(src, dst, size);
#endif
}
 
static inline void hpm_dsp_convert_q7_f32(q7_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_convert_q7_f32(src, dst, size);
#endif
}
 
static inline void hpm_dsp_convert_q7_q15(q7_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_convert_q7_q15(src, dst, size);
#endif
}
 
static inline void hpm_dsp_convert_q7_q31(q7_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_convert_q7_q31(src, dst, size);
#endif
}
 
// Duplicate function
static inline void hpm_dsp_dup_f32(float32_t *src, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dup_f32(src, dst, size);
#endif
}
 
static inline void hpm_dsp_dup_q15(q15_t *src, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dup_q15(src, dst, size);
#endif
}
 
static inline void hpm_dsp_dup_q31(q31_t *src, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dup_q31(src, dst, size);
#endif
}
 
static inline void hpm_dsp_dup_q7(q7_t *src, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_dup_q7(src, dst, size);
#endif
}
 
// Set function
static inline void hpm_dsp_set_f32(float32_t val, float32_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_set_f32(val, dst, size);
#endif
}
 
static inline void hpm_dsp_set_q15(q15_t val, q15_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_set_q15(val, dst, size);
#endif
}
 
static inline void hpm_dsp_set_q31(q31_t val, q31_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_set_q31(val, dst, size);
#endif
}
 
static inline void hpm_dsp_set_q7(q7_t val, q7_t *dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_set_q7(val, dst, size);
#endif
}
 
static inline float32_t hpm_dsp_weighted_sum_f32(const float32_t *src, const float32_t *weight, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_weighted_sum_f32(src, weight, size);
#endif
}
 
static inline void hpm_dsp_barycenter_f32(const float32_t *src, const float32_t *weights, float32_t *out, uint32_t numofvec, uint32_t dimofvec)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_barycenter_f32(src, weights, out, numofvec, dimofvec);
#endif
}
 
static inline float32_t hpm_dsp_exp_f32(float32_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_exp_f32(src);
#endif
}
 
#if defined (__riscv_zfh)
static inline float16_t hpm_dsp_exp_f16(float16_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_exp_f16(src);
#endif
}
#endif
 
static inline float32_t hpm_dsp_sigmoid_f32(float32_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_sigmoid_f32(src);
#endif
}
 
#if defined (__riscv_zfh)
static inline float16_t hpm_dsp_sigmoid_f16(float16_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_sigmoid_f16(src);
#endif
}
#endif
 
static inline float32_t hpm_dsp_log_f32(float32_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_log_f32(src);
#endif
}
 
#if defined (__riscv_zfh)
static inline float16_t hpm_dsp_log_f16(float16_t src)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    return riscv_dsp_log_f16(src);
#endif
}
#endif
 
#endif
#endif
 
#ifdef HPM_MATH_DSP_SORT
 
#ifdef HPM_EN_MATH_DSP_LIB
#include "riscv_dsp_sort_math.h"
static inline void hpm_dsp_sort_init_f32(riscv_dsp_sort_f32_t * instance, riscv_dsp_sort_alg alg, riscv_dsp_sort_order order)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_sort_init_f32(instance, alg, order);
#endif
}
 
static inline void hpm_dsp_sort_f32(const riscv_dsp_sort_f32_t * instance,float32_t * src, float32_t * dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_sort_f32(instance, src, dst, size);
#endif
}
 
static inline void hpm_dsp_sort_merge_init_f32(riscv_dsp_sort_merge_f32_t * instance, riscv_dsp_sort_order order, float32_t * buf)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_sort_merge_init_f32(instance, order, buf);
#endif
}
 
static inline void hpm_dsp_sort_merge_f32(const riscv_dsp_sort_merge_f32_t * instance, float32_t * src, float32_t * dst, uint32_t size)
{
#if HPM_DSP_CORE == HPM_DSP_HW_NDS32
    riscv_dsp_sort_merge_f32(instance, src, dst, size);
#endif
}
 
#endif
#endif
 
#ifdef HPM_MATH_NN_TINYENGINE
#ifdef HPM_EN_MATH_DSP_LIB
 
#include "riscv_math_types.h"
#include <string.h>
#include "riscv_simd_convert.h"
 
#define LEFT_SHIFT(_shift)  (_shift > 0 ? _shift : 0)
#define RIGHT_SHIFT(_shift) (_shift > 0 ? 0 : -_shift)
#define Q31_MAX ((q31_t)(0x7FFFFFFFL))
#define Q31_MIN ((q31_t)(0x80000000L))
 
static inline void write_q15x2_ia(
    q15_t **pQ15,
    q31_t   value)
{
    q31_t val = value;
    (*pQ15)[0] = (val & 0x0FFFF);
    (*pQ15)[1] = (val >> 16) & 0x0FFFF;
    *pQ15 += 2;
}
 
__STATIC_FORCEINLINE q31_t hpm_nn_read_q15x2_ia(const q15_t **in_q15)
{
    q31_t val;
 
    val = *(q31_t *)(*in_q15);
    *in_q15 += 2;
 
    return val;
}
 
__STATIC_FORCEINLINE q31_t hpm_nn_sat_doubling_high_mult(const q31_t m1, const q31_t m2)
{
    q31_t result = 0;
    q63_t mult = 1 << 30;
 
    if ((m1 < 0) ^ (m2 < 0)) {
        mult = 1 - mult;
    }
    mult = mult + (q63_t)m1 * m2;
    result = mult / (1UL << 31);
 
    if ((m1 == m2) && (m1 == (int32_t)Q31_MIN)) {
        result = Q31_MAX;
    }
    return result;
}
 
__STATIC_FORCEINLINE q31_t hpm_nn_divide_by_power_of_two(const q31_t dividend, const q31_t exponent)
{
    q31_t result = 0;
 
    const q31_t remainder_mask = (1l << exponent) - 1;
    int32_t remainder = remainder_mask & dividend;
 
    result = dividend >> exponent;
    q31_t threshold = remainder_mask >> 1;
    if (result < 0) {
        threshold++;
    }
    if (remainder > threshold) {
        result++;
    }
 
    return result;
}
 
__STATIC_FORCEINLINE q31_t hpm_nn_requantize(const q31_t val, const q31_t multiplier, const q31_t shift)
{
    return hpm_nn_divide_by_power_of_two(hpm_nn_sat_doubling_high_mult(val * (1 << LEFT_SHIFT(shift)), multiplier),
                                       RIGHT_SHIFT(shift));
}
 
__STATIC_FORCEINLINE q31_t hpm_nn_read_q7x4_ia(const q7_t **in_q7)
{
    q31_t val;
 
    val = *(q31_t *)(*in_q7);
    *in_q7 += 4;
 
    return val;
}
 
__STATIC_FORCEINLINE const q7_t *read_and_pad_reordered(const q7_t *source, q31_t *out1, q31_t *out2)
{
    q31_t     inA = hpm_nn_read_q7x4_ia(&source);
 
    *out2 = __SXTB16_ROR(inA, 8);
    *out1 = __SXTB16(inA);
 
    return source;
}
 
__STATIC_FORCEINLINE const q7_t *read_and_pad(const q7_t *source, q31_t *out1, q31_t *out2)
{
    q31_t     inA = hpm_nn_read_q7x4_ia(&source);
    q31_t     inAbuf1 = __SXTB16_ROR(inA, 8);
    q31_t     inAbuf2 = __SXTB16(inA);
 
    *out2 = __PKHTB(inAbuf1, inAbuf2, 16);
    *out1 = __PKHBT(inAbuf2, inAbuf1, 16);
 
    return source;
}
 
__STATIC_FORCEINLINE int32_t hpm_nn_read_s8x4_ia(const int8_t **in_s8)
{
    int32_t val;
 
    val = *(int32_t *)(*in_s8);
    *in_s8 += 4;
 
    return val;
}
 
__STATIC_FORCEINLINE void hpm_nn_q7_to_q15_with_offset(const int8_t *src, int16_t *dst, int32_t block_size, int16_t offset)
{
    int32_t block_cnt;
 
    /* Run the below code for cores that support SIMD instructions  */
    int32_t in_q7x4;
    int32_t in_q15x2_1;
    int32_t in_q15x2_2;
    int32_t out_q15x2_1;
    int32_t out_q15x2_2;
 
    /*loop unrolling */
    block_cnt = block_size >> 2;
 
    /* First part of the processing with loop unrolling.  Compute 4 outputs at a time. */
    const int32_t offset_q15x2 = __PKHBT(offset, offset, 16);
    while (block_cnt > 0) {
        /* convert from s8 to s16 and then store the results in the destination buffer */
        in_q7x4 = hpm_nn_read_s8x4_ia(&src);
 
        /* Extract and sign extend each of the four s8 values to s16 */
        in_q15x2_1 = __SXTAB16(offset_q15x2, __ROR(in_q7x4, 8));
        in_q15x2_2 = __SXTAB16(offset_q15x2, in_q7x4);
 
        out_q15x2_2 = __PKHTB(in_q15x2_1, in_q15x2_2, 16);
        out_q15x2_1 = __PKHBT(in_q15x2_2, in_q15x2_1, 16);
 
        write_q15x2_ia(&dst, out_q15x2_1);
        write_q15x2_ia(&dst, out_q15x2_2);
 
        block_cnt--;
    }
    /* Handle left over samples */
    block_cnt = block_size % 0x4;
 
    while (block_cnt > 0) {
        *dst++ = (int16_t)*src++ + offset;
 
        /* Decrement the loop counter */
        block_cnt--;
    }
}
 
#endif
#endif
 
#ifdef HPM_MATH_NN_ACTIVATION
#ifdef HPM_EN_MATH_NN_LIB
#if defined(__zcc__)
#include "tpt_nn_activation.h"
#else
#include "riscv_nn_activation.h"
#endif
static inline void hpm_nn_activate_s8(q7_t *in_out,
                        uint32_t size,
                        uint16_t int_bits,
                        riscv_nn_activation_fun act_fun)
{
#if defined(__zcc__)
    tpt_nn_activate_s8(in_out, size, int_bits, act_fun);
#else
    riscv_nn_activate_s8(in_out, size, int_bits, act_fun);
#endif
}
 
static inline void hpm_nn_activate_s16(q15_t *in_out,
                        uint32_t size,
                        uint16_t int_bits,
                        riscv_nn_activation_fun act_fun)
{
#if defined(__zcc__)
    tpt_nn_activate_s16(in_out, size, int_bits, act_fun);
#else
    riscv_nn_activate_s16(in_out, size, int_bits, act_fun);
#endif
}
 
static inline void hpm_nn_leaky_relu_s8(q7_t *in_out,
                        uint32_t size,
                        q15_t slope)
#if defined(__zcc__)
    tpt_nn_leaky_relu_q7(in_out, in_out, size, slope);
#else
    riscv_nn_leaky_relu_s8(in_out, size, slope);
#endif
}
 
static inline void hpm_nn_relu_any_s8(q7_t *data, uint16_t size, q7_t max_val)
{
#if defined(__zcc__)
    tpt_nn_relu_any_q7(data, size, max_val);
#else
    riscv_nn_relu_any_s8(data, size, max_val);
#endif
}
 
static inline void hpm_nn_relu_s8(q7_t *in_out, uint32_t size)
{
#if defined(__zcc__)
    tpt_nn_relu_q7(in_out, size);
#else
    riscv_nn_relu_s8(in_out, size);
#endif
}
 
static inline void hpm_nn_relu_s16(q15_t *in_out, uint32_t size)
{
#if defined(__zcc__)
    tpt_nn_relu_q15(in_out, size);
#else
    riscv_nn_relu_s16(in_out, size);
#endif
}
 
#ifdef __riscv_zfh
static inline int32_t hpm_nn_sigmoid_f16(const float16_t *in_vec,
                            uint32_t size,
                            float16_t *out_vec)
{
#if defined(__zcc__)
    return tpt_nn_sigmoid_f16(in_vec, size, out_vec);
#else
    return riscv_nn_sigmoid_f16(in_vec, size, out_vec);
#endif
}
 
static inline int32_t hpm_nn_tanh_f16(const float16_t *in_vec,
                        uint32_t size,
                        float16_t *out_vec)
{
#if defined(__zcc__)
    return tpt_nn_tanh_f16(in_vec, size, out_vec);
#else
    return riscv_nn_tanh_f16(in_vec, size, out_vec);
#endif
}
#endif
 
#endif
#endif
 
#ifdef HPM_MATH_NN_BASIC
#ifdef HPM_EN_MATH_NN_LIB
#if defined(__zcc__)
#include "tpt_nn_basic.h"
#else
#include "riscv_nn_basic.h"
#endif
static inline void hpm_nn_add_s8_sym(const q7_t *in_tensor1,
                        const q7_t *in_tensor2,
                        const int16_t *scale1,
                        const int16_t *scale2,
                        const uint32_t size,
                        const uint16_t pre_rshift,
                        const uint16_t out_scale,
                        const uint16_t post_rshift,
                        q7_t *out)
{
#if defined(__zcc__)
    tpt_nn_add_s8_sym(in_tensor1, in_tensor2, scale1, scale2, size, pre_rshift,
                    out_scale, post_rshift, out);
#else
    riscv_nn_add_s8_sym(in_tensor1, in_tensor2, scale1, scale2, size, pre_rshift,
                      out_scale, post_rshift, out);
#endif
}
 
static inline void hpm_nn_add_s8_sym_round(const q7_t *in_tensor1,
                            const q7_t *in_tensor2,
                            const uint32_t scale1,
                            const uint32_t scale2,
                            const uint32_t size,
                            const uint16_t pre_rshift,
                            const uint16_t out_scale,
                            const uint16_t post_rshift,
                            q7_t *out)
{
#if defined(__zcc__)
    tpt_nn_add_s8_sym_round(in_tensor1, in_tensor2, scale1, scale2, size,
                          pre_rshift, out_scale, post_rshift, out);
#else
    riscv_nn_add_s8_sym_round(in_tensor1, in_tensor2, scale1, scale2, size,
                            pre_rshift, out_scale, post_rshift, out);
#endif
}
 
static inline int hpm_nn_ew_add_s8_asym(const int8_t *in_tensor1,
                            const int8_t *in_tensor2,
                            const int32_t in_offset1,
                            const int32_t in_scale1,
                            const int32_t in_rshift1,
                            const int32_t in_offset2,
                            const int32_t in_scale2,
                            const int32_t in_rshift2,
                            const int32_t lshift,
                            int8_t *out,
                            const int32_t out_offset,
                            const int32_t out_scale,
                            const int32_t out_rshift,
                            const int32_t act_min,
                            const int32_t act_max,
                            const uint32_t size)
{
#if defined(__zcc__)
    return tpt_nn_ew_add_s8_asym(in_tensor1, in_tensor2, in_offset1, in_scale1,
                               in_rshift1, in_offset2, in_scale2, in_rshift2,
                               lshift, out, out_offset, out_scale, out_rshift,
                               act_min, act_max, size);
#else
    return riscv_nn_ew_add_s8_asym(in_tensor1, in_tensor2, in_offset1, in_scale1,
                                 in_rshift1, in_offset2, in_scale2, in_rshift2,
                                 lshift, out, out_offset, out_scale, out_rshift,
                                 act_min, act_max, size);
#endif
}
 
static inline int hpm_nn_ew_mul_s8_asym(const int8_t *in_tensor1,
                            const int8_t *in_tensor2,
                            const int32_t in_offset1,
                            const int32_t in_offset2,
                            int8_t *out,
                            const int32_t out_offset,
                            const int32_t out_scale,
                            const int32_t out_shift,
                            const int32_t act_min,
                            const int32_t act_max,
                            const uint32_t size)
{
#if defined(__zcc__)
    return tpt_nn_ew_mul_s8_asym(in_tensor1, in_tensor2, in_offset1, in_offset2,
                               out, out_offset, out_scale, out_shift, act_min,
                               act_max, size);
#else
    return riscv_nn_ew_mul_s8_asym(in_tensor1, in_tensor2, in_offset1, in_offset2,
                                 out, out_offset, out_scale, out_shift, act_min,
                                 act_max, size);
#endif
}
 
#endif
 
#ifdef HPM_EN_MATH_NN_RVP32_LIB
#if defined(__zcc__)
#include "tpt_nn_basic.h"
#else
#include "riscv_nn_basic.h"
#endif
 
static inline int hpm_nn_ew_add_s8_asym(const int8_t *in_tensor1,
                            const int8_t *in_tensor2,
                            const int32_t in_offset1,
                            const int32_t in_scale1,
                            const int32_t in_rshift1,
                            const int32_t in_offset2,
                            const int32_t in_scale2,
                            const int32_t in_rshift2,
                            const int32_t lshift,
                            int8_t *out,
                            const int32_t out_offset,
                            const int32_t out_scale,
                            const int32_t out_rshift,
                            const int32_t act_min,
                            const int32_t act_max,
                            const uint32_t size)
{
#if defined(__zcc__)
    return tpt_elementwise_add_s8(out, out_offset, out_scale, -out_rshift, act_min,
                               act_max, in_tensor1, in_tensor2, in_offset1, in_scale1,
                               in_rshift1, in_offset2, in_scale2, in_rshift2,
                               lshift, size);
#else
    return riscv_nn_ew_add_s8_asym(in_tensor1, in_tensor2, in_offset1, in_scale1,
                                 in_rshift1, in_offset2, in_scale2, in_rshift2,
                                 lshift, out, out_offset, out_scale, out_rshift,
                                 act_min, act_max, size);
#endif
}
 
#endif
 
#endif
 
#ifdef HPM_MATH_NN_CONCATENATION
#ifdef HPM_EN_MATH_NN_LIB
#if defined(__zcc__)
#include "tpt_nn_concatenation.h"
#else
#include "riscv_nn_concatenation.h"
#endif
 
static inline void hpm_nn_concate_s8_w(const int8_t *in_tensor,
                        const uint16_t in_tensor_x,
                        const uint16_t in_tensor_y,
                        const uint16_t in_tensor_z,
                        const uint16_t in_tensor_w,
                        int8_t *out_tensor,
                        const uint32_t out_offset_w)
{
#if defined(__zcc__)
    tpt_concatenation_s8_w(out_tensor, in_tensor, in_tensor_x, in_tensor_y, in_tensor_z,
                      in_tensor_w, out_offset_w);
#else
    riscv_nn_concate_s8_w(in_tensor, in_tensor_x, in_tensor_y, in_tensor_z,
                        in_tensor_w, out_tensor, out_offset_w);
#endif
}
 
static inline void hpm_nn_concate_s8_x(const int8_t *in_tensor,
                        const uint16_t in_tensor_x,
                        const uint16_t in_tensor_y,
                        const uint16_t in_tensor_z,
                        const uint16_t in_tensor_w,
                        int8_t *out_tensor,
                        const uint16_t out_tensor_x,
                        const uint32_t out_offset_x)
{
#if defined(__zcc__)
    tpt_nn_concate_s8_x(in_tensor, in_tensor_x, in_tensor_y, in_tensor_z,
                      in_tensor_w, out_tensor, out_tensor_x, out_offset_x);
#else
    riscv_nn_concate_s8_x(in_tensor, in_tensor_x, in_tensor_y, in_tensor_z,
                        in_tensor_w, out_tensor, out_tensor_x, out_offset_x);
#endif
}
 
static inline void hpm_nn_concate_s8_y(const int8_t *in_tensor,
                        const uint16_t in_tensor_x,
                        const uint16_t in_tensor_y,
                        const uint16_t in_tensor_z,
                        const uint16_t in_tensor_w,
                        int8_t *out_tensor,
                        const uint16_t out_tensor_y,
                        const uint32_t out_offset_y)
{
#if defined(__zcc__)
    tpt_nn_concate_s8_y(in_tensor, in_tensor_x, in_tensor_y, in_tensor_z,
                      in_tensor_w, out_tensor, out_tensor_y, out_offset_y);
#else
    riscv_nn_concate_s8_y(in_tensor, in_tensor_x, in_tensor_y, in_tensor_z,
                        in_tensor_w, out_tensor, out_tensor_y, out_offset_y);
#endif
}
 
static inline void hpm_nn_concate_s8_z(const int8_t *in_tensor,
                        const uint16_t in_tensor_x,
                        const uint16_t in_tensor_y,
                        const uint16_t in_tensor_z,
                        const uint16_t in_tensor_w,
                        int8_t *out_tensor,
                        const uint16_t out_tensor_z,
                        const uint32_t out_offset_z)
{
#if defined(__zcc__)
    tpt_nn_concate_s8_z(in_tensor, in_tensor_x, in_tensor_y, in_tensor_z,
                      in_tensor_w, out_tensor, out_tensor_z, out_offset_z);
#else
    riscv_nn_concate_s8_z(in_tensor, in_tensor_x, in_tensor_y, in_tensor_z,
                        in_tensor_w, out_tensor, out_tensor_z, out_offset_z);
#endif
}
 
#endif
#endif
 
#ifdef HPM_MATH_NN_CONVOLUTION
#ifdef HPM_EN_MATH_NN_LIB
#if defined(__zcc__)
#include "tpt_nn_convolution.h"
#else
#include "riscv_nn_convolution.h"
#endif
 
static inline int32_t hpm_nn_conv_1x1_HWC_s8_s8_s8_sft_bias_fast_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q7_t *bias,
                                                const uint16_t bias_lshift,
                                                const uint16_t out_rshift,
                                                q7_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf,
                                                q7_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_s8_s8_s8_sft_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_s8_s8_s8_sft_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_RGB_sft_bias(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim,
                                                const uint16_t pad,
                                                const uint16_t stride,
                                                const q7_t *bias,
                                                const uint16_t bias_lshift,
                                                const uint16_t out_rshift,
                                                q7_t *out_tensor,
                                                const uint16_t out_tensor_dim,
                                                q15_t *in_tmp_buf,
                                                q7_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_RGB_sft_bias(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim, in_tmp_buf,
      tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_RGB_sft_bias(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim, in_tmp_buf,
      tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_RGB_sft_bias_fast(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim,
                                                const uint16_t pad,
                                                const uint16_t stride,
                                                const q7_t *bias,
                                                const uint16_t bias_lshift,
                                                const uint16_t out_rshift,
                                                q7_t *out_tensor,
                                                const uint16_t out_tensor_dim,
                                                q15_t *in_tmp_buf,
                                                q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_RGB_sft_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim, in_tmp_buf,
      wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_RGB_sft_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim, in_tmp_buf,
      wt_tmp_buf);
#endif
}
 
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_sft_bias(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const q7_t *bias,
                                            const uint16_t bias_lshift,
                                            const uint16_t out_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf,
                                            q7_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_sft_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, bias_lshift, out_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf, tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_sft_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, bias_lshift, out_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf, tmp_buf);
#endif
}
 
static inline void hpm_nn_conv_HWC_s8_s8_s8_sft_bias_any(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const q7_t *bias,
                                            const uint16_t bias_lshift,
                                            const uint16_t out_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf,
                                            q7_t *tmp_buf)
{
#if defined(__zcc__)
    tpt_nn_conv_HWC_s8_s8_s8_sft_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, tmp_buf);
#else
    riscv_nn_conv_HWC_s8_s8_s8_sft_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_sft_bias_fast(const q7_t *in_tensor,
                                const uint16_t in_tensor_dim,
                                const uint16_t in_tensor_ch,
                                const q7_t *ker_weight,
                                const uint16_t out_tensor_ch,
                                const uint16_t ker_dim,
                                const uint16_t pad,
                                const uint16_t stride,
                                const q7_t *bias,
                                const uint16_t bias_lshift,
                                const uint16_t out_rshift,
                                q7_t *out_tensor,
                                const uint16_t out_tensor_dim,
                                q15_t *in_tmp_buf,
                                q7_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_sft_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, bias_lshift, out_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf, tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_sft_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, bias_lshift, out_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_sft_bias_fast_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q7_t *bias,
                                                const uint16_t bias_lshift,
                                                const uint16_t out_rshift,
                                                q7_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf,
                                                q7_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_sft_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_sft_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, tmp_buf);
#endif
}
 
 
static inline int32_t hpm_nn_conv_HWC_s16_s16_s16_sft_bias(const q15_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const uint16_t in_tensor_ch,
                                            const q15_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const q15_t *bias,
                                            const uint16_t bias_lshift,
                                            const uint16_t out_rshift,
                                            q15_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf,
                                            q7_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s16_s16_s16_sft_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, bias_lshift, out_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf, tmp_buf);
#else
    return riscv_nn_conv_HWC_s16_s16_s16_sft_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, bias_lshift, out_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s16_s16_s16_sft_bias_fast(const q15_t *in_tensor,
                                                const uint16_t in_tensor_dim,
                                                const uint16_t in_tensor_ch,
                                                const q15_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim,
                                                const uint16_t pad,
                                                const uint16_t stride,
                                                const q15_t *bias,
                                                const uint16_t bias_lshift,
                                                const uint16_t out_rshift,
                                                q15_t *out_tensor,
                                                const uint16_t out_tensor_dim,
                                                q15_t *in_tmp_buf,
                                                q7_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s16_s16_s16_sft_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, bias_lshift, out_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf, tmp_buf);
#else
    return riscv_nn_conv_HWC_s16_s16_s16_sft_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, bias_lshift, out_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s16_s16_s16_sft_bias_fast_any(const q15_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q15_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q15_t *bias,
                                                const uint16_t bias_lshift,
                                                const uint16_t out_rshift,
                                                q15_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf,
                                                q7_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s16_s16_s16_sft_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, tmp_buf);
#else
    return riscv_nn_conv_HWC_s16_s16_s16_sft_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_sft_bias(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const q7_t *bias,
                                            const uint16_t bias_lshift,
                                            const uint16_t out_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf,
                                            q7_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_s8_s8_s8_sft_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, bias_lshift, out_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf, tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_sft_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, bias_lshift, out_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_sft_bias_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q7_t *bias,
                                                const uint16_t bias_lshift,
                                                const uint16_t out_rshift,
                                                q7_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf,
                                                q7_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_s8_s8_s8_sft_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_sft_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, bias_lshift, out_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_s8_s8_s8_sym_bias_fast_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q31_t *bias,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q7_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
 
tpt_nn_conv_1x1_sym_params S1 = {stride_x, stride_y, pad_x, pad_y, pre_rshift, out_scale, post_rshift};
tpt_nn_1x1_sym_dims S2 = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_dim_x, ker_dim_y,
                          out_tensor_dim_x, out_tensor_dim_y, out_tensor_ch};
    return tpt_nn_conv_1x1_HWC_s8_s8_s8_sym_bias_fast_any(
      out_tensor_ch, in_tensor,  ker_weight, bias, &S1, &S2, in_tmp_buf);
 
#else
    return riscv_nn_conv_1x1_HWC_s8_s8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_s8_s16_s8_sym_bias_fast_any(const q7_t *in_tensor,
                                                    const uint16_t in_tensor_dim_x,
                                                    const uint16_t in_tensor_dim_y,
                                                    const uint16_t in_tensor_ch,
                                                    const q7_t *ker_weight,
                                                    const uint16_t out_tensor_ch,
                                                    const uint16_t ker_dim_x,
                                                    const uint16_t ker_dim_y,
                                                    const uint16_t pad_x,
                                                    const uint16_t pad_y,
                                                    const uint16_t stride_x,
                                                    const uint16_t stride_y,
                                                    const q31_t *bias,
                                                    const uint16_t pre_rshift,
                                                    const uint16_t out_scale,
                                                    const uint16_t post_rshift,
                                                    q15_t *out_tensor,
                                                    const uint16_t out_tensor_dim_x,
                                                    const uint16_t out_tensor_dim_y,
                                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_s8_s16_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_s8_s16_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_u8_u8_s8_sym_bias_fast_any(const u8_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q31_t *bias,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                u8_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_u8_u8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_u8_u8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_u8_s8_s8_sym_bias_fast_any(const u8_t *in_tensor,
                                                    const uint16_t in_tensor_dim_x,
                                                    const uint16_t in_tensor_dim_y,
                                                    const uint16_t in_tensor_ch,
                                                    const q7_t *ker_weight,
                                                    const uint16_t out_tensor_ch,
                                                    const uint16_t ker_dim_x,
                                                    const uint16_t ker_dim_y,
                                                    const uint16_t pad_x,
                                                    const uint16_t pad_y,
                                                    const uint16_t stride_x,
                                                    const uint16_t stride_y,
                                                    const q31_t *bias,
                                                    const uint16_t pre_rshift,
                                                    const uint16_t out_scale,
                                                    const uint16_t post_rshift,
                                                    q7_t *out_tensor,
                                                    const uint16_t out_tensor_dim_x,
                                                    const uint16_t out_tensor_dim_y,
                                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_u8_s8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_u8_s8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_u8_s16_s8_sym_bias_fast_any(const u8_t *in_tensor,
                                                    const uint16_t in_tensor_dim_x,
                                                    const uint16_t in_tensor_dim_y,
                                                    const uint16_t in_tensor_ch,
                                                    const q7_t *ker_weight,
                                                    const uint16_t out_tensor_ch,
                                                    const uint16_t ker_dim_x,
                                                    const uint16_t ker_dim_y,
                                                    const uint16_t pad_x,
                                                    const uint16_t pad_y,
                                                    const uint16_t stride_x,
                                                    const uint16_t stride_y,
                                                    const q31_t *bias,
                                                    const uint16_t pre_rshift,
                                                    const uint16_t out_scale,
                                                    const uint16_t post_rshift,
                                                    q15_t *out_tensor,
                                                    const uint16_t out_tensor_dim_x,
                                                    const uint16_t out_tensor_dim_y,
                                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_u8_s16_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_u8_s16_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_s8_s8_s8_sym_fast_any(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_s8_s8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_s8_s8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_s8_s16_s8_sym_fast_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q15_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_s8_s16_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_s8_s16_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_u8_u8_s8_sym_fast_any(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            u8_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_u8_u8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_u8_u8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_u8_s8_s8_sym_fast_any(const u8_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q7_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_u8_s8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_u8_s8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_u8_s16_s8_sym_fast_any(const u8_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q15_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_u8_s16_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_u8_s16_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_RGB_sym_bias_fast(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf,
                                            q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_RGB_sym_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_RGB_sym_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s16_s8_RGB_sym_bias_fast(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim,
                                                const uint16_t pad,
                                                const uint16_t stride,
                                                const q31_t *bias,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q15_t *out_tensor,
                                                const uint16_t out_tensor_dim,
                                                q15_t *in_tmp_buf,
                                                q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s16_s8_RGB_sym_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s16_s8_RGB_sym_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_u8_s8_RGB_sym_bias_fast(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            u8_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf,
                                            q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_u8_s8_RGB_sym_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_u8_s8_RGB_sym_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s8_s8_RGB_sym_bias_fast(const u8_t *in_tensor,
                                                const uint16_t in_tensor_dim,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim,
                                                const uint16_t pad,
                                                const uint16_t stride,
                                                const q31_t *bias,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q7_t *out_tensor,
                                                const uint16_t out_tensor_dim,
                                                q15_t *in_tmp_buf,
                                                q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s8_s8_RGB_sym_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s8_s8_RGB_sym_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s16_s8_RGB_sym_bias_fast(const u8_t *in_tensor,
                                                const uint16_t in_tensor_dim,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim,
                                                const uint16_t pad,
                                                const uint16_t stride,
                                                const q31_t *bias,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q15_t *out_tensor,
                                                const uint16_t out_tensor_dim,
                                                q15_t *in_tmp_buf,
                                                q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s16_s8_RGB_sym_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s16_s8_RGB_sym_bias_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_RGB_sym_fast(const q7_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q7_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        q15_t *in_tmp_buf,
                                        q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_RGB_sym_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_RGB_sym_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s16_s8_RGB_sym_fast(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q15_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf,
                                            q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s16_s8_RGB_sym_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s16_s8_RGB_sym_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_u8_s8_RGB_sym_fast(const u8_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        u8_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        q15_t *in_tmp_buf,
                                        q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_u8_s8_RGB_sym_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_u8_s8_RGB_sym_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s8_s8_RGB_sym_fast(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf,
                                            q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s8_s8_RGB_sym_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s8_s8_RGB_sym_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s16_s8_RGB_sym_fast(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q15_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf,
                                            q15_t *wt_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s16_s8_RGB_sym_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s16_s8_RGB_sym_fast(
      in_tensor, in_tensor_dim, ker_weight, out_tensor_ch, ker_dim, pad, stride,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim,
      in_tmp_buf, wt_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_sym_bias_fast(const q7_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const q31_t *bias,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q7_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_sym_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_sym_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s16_s8_sym_bias_fast(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q15_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s16_s8_sym_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s16_s8_sym_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_u8_s8_sym_bias_fast(const u8_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const q31_t *bias,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        u8_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_u8_s8_sym_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_u8_s8_sym_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s8_s8_sym_bias_fast(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s8_s8_sym_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s8_s8_sym_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s16_s8_sym_bias_fast(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q15_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s16_s8_sym_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s16_s8_sym_bias_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_sym_fast(const q7_t *in_tensor,
                                    const uint16_t in_tensor_dim,
                                    const uint16_t in_tensor_ch,
                                    const q7_t *ker_weight,
                                    const uint16_t out_tensor_ch,
                                    const uint16_t ker_dim,
                                    const uint16_t pad,
                                    const uint16_t stride,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    q7_t *out_tensor,
                                    const uint16_t out_tensor_dim,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_sym_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_sym_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s16_s8_sym_fast(const q7_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q15_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s16_s8_sym_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s16_s8_sym_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_u8_s8_sym_fast(const u8_t *in_tensor,
                                    const uint16_t in_tensor_dim,
                                    const uint16_t in_tensor_ch,
                                    const q7_t *ker_weight,
                                    const uint16_t out_tensor_ch,
                                    const uint16_t ker_dim,
                                    const uint16_t pad,
                                    const uint16_t stride,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    u8_t *out_tensor,
                                    const uint16_t out_tensor_dim,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_u8_s8_sym_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_u8_s8_sym_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s8_s8_sym_fast(const u8_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q7_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s8_s8_sym_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s8_s8_sym_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s16_s8_sym_fast(const u8_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q15_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s16_s8_sym_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s16_s8_sym_fast(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_sym_bias_fast_any(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s16_s8_sym_bias_fast_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q31_t *bias,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q15_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s16_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s16_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_u8_s8_sym_bias_fast_any(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            u8_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_u8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_u8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s8_s8_sym_bias_fast_any(const u8_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q31_t *bias,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q7_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s8_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s16_s8_sym_bias_fast_any(const u8_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q31_t *bias,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q15_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s16_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s16_s8_sym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_sym_fast_any(const q7_t *in_tensor,
                                        const uint16_t in_tensor_dim_x,
                                        const uint16_t in_tensor_dim_y,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim_x,
                                        const uint16_t ker_dim_y,
                                        const uint16_t pad_x,
                                        const uint16_t pad_y,
                                        const uint16_t stride_x,
                                        const uint16_t stride_y,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q7_t *out_tensor,
                                        const uint16_t out_tensor_dim_x,
                                        const uint16_t out_tensor_dim_y,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s16_s8_sym_fast_any(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q15_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s16_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_s8_s16_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_u8_s8_sym_fast_any(const u8_t *in_tensor,
                                        const uint16_t in_tensor_dim_x,
                                        const uint16_t in_tensor_dim_y,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim_x,
                                        const uint16_t ker_dim_y,
                                        const uint16_t pad_x,
                                        const uint16_t pad_y,
                                        const uint16_t stride_x,
                                        const uint16_t stride_y,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        u8_t *out_tensor,
                                        const uint16_t out_tensor_dim_x,
                                        const uint16_t out_tensor_dim_y,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_u8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_u8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s8_s8_sym_fast_any(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s8_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_u8_s16_s8_sym_fast_any(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q15_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_u8_s16_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_HWC_u8_s16_s8_sym_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_sym_bias(const q7_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const q31_t *bias,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q7_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_s8_s8_s8_sym_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_sym_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s16_s8_sym_bias(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q15_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_s8_s16_s8_sym_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_s8_s16_s8_sym_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_u8_s8_sym_bias(const u8_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const q31_t *bias,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        u8_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_u8_s8_sym_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_u8_s8_sym_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_s8_s8_sym_bias(const u8_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const q31_t *bias,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q7_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_s8_s8_sym_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_s8_s8_sym_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_s16_s8_sym_bias(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q15_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_s16_s8_sym_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_s16_s8_sym_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, pre_rshift, out_scale, post_rshift,
      out_tensor, out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_sym(const q7_t *in_tensor,
                                const uint16_t in_tensor_dim,
                                const uint16_t in_tensor_ch,
                                const q7_t *ker_weight,
                                const uint16_t out_tensor_ch,
                                const uint16_t ker_dim,
                                const uint16_t pad,
                                const uint16_t stride,
                                const uint16_t pre_rshift,
                                const uint16_t out_scale,
                                const uint16_t post_rshift,
                                q7_t *out_tensor,
                                const uint16_t out_tensor_dim,
                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_s8_s8_s8_sym(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_sym(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s16_s8_sym(const q7_t *in_tensor,
                                    const uint16_t in_tensor_dim,
                                    const uint16_t in_tensor_ch,
                                    const q7_t *ker_weight,
                                    const uint16_t out_tensor_ch,
                                    const uint16_t ker_dim,
                                    const uint16_t pad,
                                    const uint16_t stride,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    q15_t *out_tensor,
                                    const uint16_t out_tensor_dim,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_s8_s16_s8_sym(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_s8_s16_s8_sym(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_u8_s8_sym(const u8_t *in_tensor,
                                const uint16_t in_tensor_dim,
                                const uint16_t in_tensor_ch,
                                const q7_t *ker_weight,
                                const uint16_t out_tensor_ch,
                                const uint16_t ker_dim,
                                const uint16_t pad,
                                const uint16_t stride,
                                const uint16_t pre_rshift,
                                const uint16_t out_scale,
                                const uint16_t post_rshift,
                                u8_t *out_tensor,
                                const uint16_t out_tensor_dim,
                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_u8_s8_sym(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_u8_s8_sym(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_s8_s8_sym(const u8_t *in_tensor,
                                    const uint16_t in_tensor_dim,
                                    const uint16_t in_tensor_ch,
                                    const q7_t *ker_weight,
                                    const uint16_t out_tensor_ch,
                                    const uint16_t ker_dim,
                                    const uint16_t pad,
                                    const uint16_t stride,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    q7_t *out_tensor,
                                    const uint16_t out_tensor_dim,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_s8_s8_sym(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_s8_s8_sym(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_s16_s8_sym(const u8_t *in_tensor,
                                    const uint16_t in_tensor_dim,
                                    const uint16_t in_tensor_ch,
                                    const q7_t *ker_weight,
                                    const uint16_t out_tensor_ch,
                                    const uint16_t ker_dim,
                                    const uint16_t pad,
                                    const uint16_t stride,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    q15_t *out_tensor,
                                    const uint16_t out_tensor_dim,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_s16_s8_sym(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_s16_s8_sym(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, pre_rshift, out_scale, post_rshift, out_tensor,
      out_tensor_dim, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_sym_bias_any(const q7_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_s8_s8_s8_sym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_sym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s16_s8_sym_bias_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q31_t *bias,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q15_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_s8_s16_s8_sym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_s8_s16_s8_sym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_u8_s8_sym_bias_any(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            u8_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_u8_s8_sym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_u8_s8_sym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_s8_s8_sym_bias_any(const u8_t *in_tensor,
                                            const uint16_t in_tensor_dim_x,
                                            const uint16_t in_tensor_dim_y,
                                            const uint16_t in_tensor_ch,
                                            const q7_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim_x,
                                            const uint16_t ker_dim_y,
                                            const uint16_t pad_x,
                                            const uint16_t pad_y,
                                            const uint16_t stride_x,
                                            const uint16_t stride_y,
                                            const q31_t *bias,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            q7_t *out_tensor,
                                            const uint16_t out_tensor_dim_x,
                                            const uint16_t out_tensor_dim_y,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_s8_s8_sym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_s8_s8_sym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_s16_s8_sym_bias_any(const u8_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const q31_t *bias,
                                                const uint16_t pre_rshift,
                                                const uint16_t out_scale,
                                                const uint16_t post_rshift,
                                                q15_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_s16_s8_sym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_s16_s8_sym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_sym_any(const q7_t *in_tensor,
                                    const uint16_t in_tensor_dim_x,
                                    const uint16_t in_tensor_dim_y,
                                    const uint16_t in_tensor_ch,
                                    const q7_t *ker_weight,
                                    const uint16_t out_tensor_ch,
                                    const uint16_t ker_dim_x,
                                    const uint16_t ker_dim_y,
                                    const uint16_t pad_x,
                                    const uint16_t pad_y,
                                    const uint16_t stride_x,
                                    const uint16_t stride_y,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    q7_t *out_tensor,
                                    const uint16_t out_tensor_dim_x,
                                    const uint16_t out_tensor_dim_y,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_s8_s8_s8_sym_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_sym_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s16_s8_sym_any(const q7_t *in_tensor,
                                        const uint16_t in_tensor_dim_x,
                                        const uint16_t in_tensor_dim_y,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim_x,
                                        const uint16_t ker_dim_y,
                                        const uint16_t pad_x,
                                        const uint16_t pad_y,
                                        const uint16_t stride_x,
                                        const uint16_t stride_y,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q15_t *out_tensor,
                                        const uint16_t out_tensor_dim_x,
                                        const uint16_t out_tensor_dim_y,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_s8_s16_s8_sym_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_s8_s16_s8_sym_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_u8_s8_sym_any(const u8_t *in_tensor,
                                    const uint16_t in_tensor_dim_x,
                                    const uint16_t in_tensor_dim_y,
                                    const uint16_t in_tensor_ch,
                                    const q7_t *ker_weight,
                                    const uint16_t out_tensor_ch,
                                    const uint16_t ker_dim_x,
                                    const uint16_t ker_dim_y,
                                    const uint16_t pad_x,
                                    const uint16_t pad_y,
                                    const uint16_t stride_x,
                                    const uint16_t stride_y,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    u8_t *out_tensor,
                                    const uint16_t out_tensor_dim_x,
                                    const uint16_t out_tensor_dim_y,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_u8_s8_sym_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_u8_s8_sym_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_s8_s8_sym_any(const u8_t *in_tensor,
                                        const uint16_t in_tensor_dim_x,
                                        const uint16_t in_tensor_dim_y,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim_x,
                                        const uint16_t ker_dim_y,
                                        const uint16_t pad_x,
                                        const uint16_t pad_y,
                                        const uint16_t stride_x,
                                        const uint16_t stride_y,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q7_t *out_tensor,
                                        const uint16_t out_tensor_dim_x,
                                        const uint16_t out_tensor_dim_y,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_s8_s8_sym_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_s8_s8_sym_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_s16_s8_sym_any(const u8_t *in_tensor,
                                        const uint16_t in_tensor_dim_x,
                                        const uint16_t in_tensor_dim_y,
                                        const uint16_t in_tensor_ch,
                                        const q7_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim_x,
                                        const uint16_t ker_dim_y,
                                        const uint16_t pad_x,
                                        const uint16_t pad_y,
                                        const uint16_t stride_x,
                                        const uint16_t stride_y,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        q15_t *out_tensor,
                                        const uint16_t out_tensor_dim_x,
                                        const uint16_t out_tensor_dim_y,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_s16_s8_sym_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_u8_s16_s8_sym_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      pre_rshift, out_scale, post_rshift, out_tensor, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_s8_s8_s8_asym_bias_fast_any(const q7_t *in_tensor,
                                    const uint16_t in_tensor_dim_x,
                                    const uint16_t in_tensor_dim_y,
                                    const uint16_t in_tensor_ch,
                                    const uint16_t in_tensor_group,
                                    const q7_t *ker_weight,
                                    const uint16_t out_tensor_ch,
                                    const uint16_t pad_x,
                                    const uint16_t pad_y,
                                    const uint16_t stride_x,
                                    const uint16_t stride_y,
                                    const int32_t *bias,
                                    q7_t *out_tensor,
                                    const int32_t *out_shift,
                                    const int32_t *out_scale,
                                    const int32_t out_offset,
                                    const int32_t in_offset,
                                    const int32_t act_min,
                                    const int32_t act_max,
                                    const uint16_t out_tensor_dim_x,
                                    const uint16_t out_tensor_dim_y,
                                    q15_t *tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_conv_1x1_asym_params aConv_params = {in_offset, out_offset, stride_x,
      stride_y, pad_x, pad_y, act_min, act_max};
 
    tpt_nn_per_channel_quant_params aQuant_params = {out_scale, out_shift};
 
    tpt_nn_1x1_asym_dims aConv_dims = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      in_tensor_group, out_tensor_ch};
 
    return tpt_convolve_1x1_s8_s8_s8_asym_bias_any(out_tensor, in_tensor, ker_weight,
      bias, &aConv_params, &aQuant_params, &aConv_dims, tmp_buf);
 
#else
    return riscv_nn_conv_1x1_HWC_s8_s8_s8_asym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      in_tensor_group, ker_weight, out_tensor_ch, pad_x, pad_y, stride_x,
      stride_y, bias, out_tensor, out_shift, out_scale, out_offset, in_offset,
      act_min, act_max, out_tensor_dim_x, out_tensor_dim_y, tmp_buf);
#endif
}
 
static inline int32_t
hpm_nn_conv_1x1_HWC_s8_s8_s8_asym_bias_fast_any_get_buffer_size(
    const uint16_t in_tensor_ch) {
#if defined(__zcc__)convol
    return tpt_convolve_1x1_s8_s8_s8_asym_bias_any_get_buf_size(
      in_tensor_ch);
#else
    return riscv_nn_conv_1x1_HWC_s8_s8_s8_asym_bias_fast_any_get_buffer_size(
      in_tensor_ch);
#endif
}
 
static inline int hpm_nn_conv_1xn_HWC_s8_s8_s8_asym_bias_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_ch,
                                                const uint16_t in_tensor_group,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t pad_x,
                                                const uint16_t stride_x,
                                                const int32_t *bias,
                                                q7_t *out_tensor,
                                                const int32_t *out_shift,
                                                const int32_t *out_scale,
                                                const int32_t out_offset,
                                                const int32_t in_offset,
                                                const int32_t act_min,
                                                const int32_t act_max,
                                                const uint16_t out_tensor_dim_x,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_conv_1xn_asym_params aConv_params = {in_offset, out_offset, stride_x, pad_x,
      act_min, act_max};
 
    tpt_nn_per_channel_quant_params aQuant_params = {out_scale, out_shift};
 
    tpt_nn_1xn_asym_dims aConv_dims = {in_tensor_dim_x, in_tensor_ch, in_tensor_group,
      ker_dim_x, out_tensor_dim_x, out_tensor_ch};
 
    return tpt_convolve_1xn_s8_s8_s8_asym_bias_any(out_tensor, in_tensor, ker_weight,
      bias, &aConv_params, &aQuant_params, &aConv_dims, in_tmp_buf);
 
#else
    return riscv_nn_conv_1xn_HWC_s8_s8_s8_asym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_ch, in_tensor_group, ker_weight,
      out_tensor_ch, ker_dim_x, pad_x, stride_x, bias, out_tensor, out_shift,
      out_scale, out_offset, in_offset, act_min, act_max, out_tensor_dim_x,
      in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1xn_HWC_s8_s8_s8_asym_bias_any_get_buffer_size(const uint16_t in_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y)
{
#if defined(__zcc__)
    return tpt_convolve_1xn_s8_s8_s8_asym_bias_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#else
    return riscv_nn_conv_1xn_HWC_s8_s8_s8_asym_bias_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_asym_bias_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const uint16_t in_tensor_group,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const int32_t *bias,
                                                q7_t *out_tensor,
                                                const int32_t *out_shift,
                                                const int32_t *out_scale,
                                                const int32_t out_offset,
                                                const int32_t in_offset,
                                                const int32_t act_min,
                                                const int32_t act_max,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_conv_asym_params aConv_params = {stride_x, stride_y, pad_x, pad_y,
      in_offset, out_offset,  act_min, act_max};
 
    tpt_nn_per_channel_quant_params aQuant_params = {out_scale, out_shift};
 
    tpt_nn_asym_dims aConv_dims = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      in_tensor_group, ker_dim_x, ker_dim_y, out_tensor_dim_x, out_tensor_dim_y,
      out_tensor_ch};
 
    return tpt_convolve_s8_s8_s8_asym_bias_any(out_tensor, in_tensor, ker_weight,
      bias, &aConv_params, &aQuant_params, &aConv_dims, in_tmp_buf);
 
#else
    return riscv_nn_conv_HWC_s8_s8_s8_asym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      in_tensor_group, ker_weight, out_tensor_ch, ker_dim_x, ker_dim_y, pad_x,
      pad_y, stride_x, stride_y, bias, out_tensor, out_shift, out_scale,
      out_offset, in_offset, act_min, act_max, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_asym_bias_any_get_buffer_size(const uint16_t in_tensor_ch,
                                        const uint16_t ker_dim_x,
                                        const uint16_t ker_dim_y)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_asym_bias_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_asym_bias_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_3x3_s8_s8_s8_asym_bias_any(const int8_t *in_tensor,
                                                const int32_t in_tensor_dim_x,
                                                const int32_t in_tensor_dim_y,
                                                const int32_t in_tensor_ch,
                                                const int8_t *ker_weight,
                                                const int32_t out_tensor_ch,
                                                const int32_t pad_x,
                                                const int32_t pad_y,
                                                const int32_t stride_x,
                                                const int32_t stride_y,
                                                const int32_t *bias,
                                                int8_t *out_tensor,
                                                const int32_t *out_shift,
                                                const int32_t *out_scale,
                                                const int32_t out_tensor_dim_x,
                                                const int32_t out_tensor_dim_y,
                                                const int32_t out_offset,
                                                const int32_t in_offset,
                                                const int32_t act_min,
                                                const int32_t act_max,
                                                const int32_t dilation_x,
                                                const int32_t dilation_y,
                                                int16_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_3x3_s8_s8_s8_asym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, pad_x, pad_y, stride_x, stride_y, bias, out_tensor,
      out_shift, out_scale, out_tensor_dim_x, out_tensor_dim_y, out_offset,
      in_offset, act_min, act_max, dilation_x, dilation_y, tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_3x3_s8_s8_s8_asym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, pad_x, pad_y, stride_x, stride_y, bias, out_tensor,
      out_shift, out_scale, out_tensor_dim_x, out_tensor_dim_y, out_offset,
      in_offset, act_min, act_max, dilation_x, dilation_y, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_asym_bias_any(const q7_t *in_tensor,
                                const uint16_t in_tensor_dim_x,
                                const uint16_t in_tensor_dim_y,
                                const uint16_t in_tensor_ch,
                                const q7_t *ker_weight,
                                const uint16_t out_tensor_ch,
                                const uint16_t ch_mult,
                                const uint16_t ker_dim_x,
                                const uint16_t ker_dim_y,
                                const uint16_t pad_x,
                                const uint16_t pad_y,
                                const uint16_t stride_x,
                                const uint16_t stride_y,
                                const int32_t *bias,
                                q7_t *out_tensor,
                                const int32_t *out_shift,
                                const int32_t *out_scale,
                                const uint16_t out_tensor_dim_x,
                                const uint16_t out_tensor_dim_y,
                                const int32_t out_offset,
                                const int32_t in_offset,
                                const int32_t act_min,
                                const int32_t act_max,
                                const uint16_t dilation_x,
                                const uint16_t dilation_y,
                                q15_t *tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_dw_conv_asym_params aConv_params = {in_offset, out_offset, ch_mult,
      stride_x, stride_y, pad_x, pad_y, dilation_x, dilation_y, act_min, act_max};
 
    tpt_nn_per_channel_quant_params aQuant_params = {out_scale, out_shift};
 
    tpt_nn_dw_conv_asym_dims aConv_dims = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      ker_dim_x, ker_dim_y, out_tensor_dim_x, out_tensor_dim_y, out_tensor_ch};
 
    return tpt_depthwise_conv_s8_s8_s8_asym_bias_any(out_tensor, in_tensor, ker_weight,
      bias, &aConv_params, &aQuant_params, &aConv_dims, tmp_buf);
 
 
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_asym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ch_mult, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x,
      stride_y, bias, out_tensor, out_shift, out_scale, out_tensor_dim_x,
      out_tensor_dim_y, out_offset, in_offset, act_min, act_max, dilation_x,
      dilation_y, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_asym_bias_fast_any(const q7_t *in_tensor,
                                     const uint16_t in_tensor_dim_x,
                                     const uint16_t in_tensor_dim_y,
                                     const uint16_t in_tensor_ch,
                                     const q7_t *ker_weight,
                                     const uint16_t out_tensor_ch,
                                     const uint16_t ker_dim_x,
                                     const uint16_t ker_dim_y,
                                     const uint16_t pad_x,
                                     const uint16_t pad_y,
                                     const uint16_t stride_x,
                                     const uint16_t stride_y,
                                     const int32_t *bias,
                                     q7_t *out_tensor,
                                     const int32_t *out_shift,
                                     const int32_t *out_scale,
                                     const uint16_t out_tensor_dim_x,
                                     const uint16_t out_tensor_dim_y,
                                     const int32_t out_offset,
                                     const int32_t in_offset,
                                     const int32_t act_min,
                                     const int32_t act_max,
                                     const uint16_t dilation_x,
                                     const uint16_t dilation_y,
                                     q15_t *in_tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_dw_conv_asym_fast_params aConv_params = {in_offset, out_offset,
      stride_x, stride_y, pad_x, pad_y, dilation_x, dilation_y, act_min, act_max};
 
    tpt_nn_per_channel_quant_params aQuant_params = {out_scale, out_shift};
 
    tpt_nn_dw_conv_asym_dims aConv_dims = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      ker_dim_x, ker_dim_y, out_tensor_dim_x, out_tensor_dim_y, out_tensor_ch};
 
    return tpt_depthwise_conv_s8_s8_s8_asym_bias_fast_any(out_tensor, in_tensor, ker_weight,
      bias, &aConv_params, &aQuant_params, &aConv_dims, in_tmp_buf);
 
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_asym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, out_tensor, out_shift, out_scale, out_tensor_dim_x,
      out_tensor_dim_y, out_offset, in_offset, act_min, act_max, dilation_x,
      dilation_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_asym_bias_fast_any_get_buffer_size(const uint16_t in_tensor_ch,
                                                  const uint16_t ker_dim_x,
                                                  const uint16_t ker_dim_y)
{
#if defined(__zcc__)
    return tpt_depthwise_conv_s8_s8_s8_asym_bias_fast_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_asym_bias_fast_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_u8_u8_u8_asym_bias_any(const uint8_t *in_tensor,
                                    const uint16_t in_tensor_dim_x,
                                    const uint16_t in_tensor_dim_y,
                                    const uint16_t in_tensor_ch,
                                    const uint8_t *ker_weight,
                                    const uint16_t ker_dim_x,
                                    const uint16_t ker_dim_y,
                                    const int16_t ch_mult,
                                    const int16_t pad_x,
                                    const int16_t pad_y,
                                    const int16_t stride_x,
                                    const int16_t stride_y,
                                    const int16_t dilation_x,
                                    const int16_t dilation_y,
                                    const int32_t *bias,
                                    const int32_t in_offset,
                                    const int32_t ker_offset,
                                    const int32_t out_offset,
                                    uint8_t *out_tensor,
                                    const uint16_t out_tensor_dim_x,
                                    const uint16_t out_tensor_dim_y,
                                    const int32_t act_min,
                                    const int32_t act_max,
                                    const int32_t out_shift,
                                    const int32_t out_scale)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_u8_u8_u8_asym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      ker_dim_x, ker_dim_y, ch_mult, pad_x, pad_y, stride_x, stride_y,
      dilation_x, dilation_y, bias, in_offset, ker_offset, out_offset,
      out_tensor, out_tensor_dim_x, out_tensor_dim_y, act_min, act_max,
      out_shift, out_scale);
#else
    return riscv_nn_conv_dw_HWC_u8_u8_u8_asym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      ker_dim_x, ker_dim_y, ch_mult, pad_x, pad_y, stride_x, stride_y,
      dilation_x, dilation_y, bias, in_offset, ker_offset, out_offset,
      out_tensor, out_tensor_dim_x, out_tensor_dim_y, act_min, act_max,
      out_shift, out_scale);
#endif
}
 
#ifdef __riscv_zfh
static inline int32_t hpm_nn_conv_1x1_HWC_f16_f16_f16_bias_any(const float16_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const float16_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const float16_t *bias,
                                                float16_t *out_tensor,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                float16_t *in_tmp_buf,
                                                float16_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_1x1_HWC_f16_f16_f16_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, out_tensor, out_tensor_dim_x, out_tensor_dim_y, in_tmp_buf,
      tmp_buf);
#else
    return riscv_nn_conv_1x1_HWC_f16_f16_f16_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, out_tensor, out_tensor_dim_x, out_tensor_dim_y, in_tmp_buf,
      tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_f16_f16_f16_bias(const float16_t *in_tensor,
                                        const uint16_t in_tensor_dim,
                                        const uint16_t in_tensor_ch,
                                        const float16_t *ker_weight,
                                        const uint16_t out_tensor_ch,
                                        const uint16_t ker_dim,
                                        const uint16_t pad,
                                        const uint16_t stride,
                                        const float16_t *bias,
                                        float16_t *out_tensor,
                                        const uint16_t out_tensor_dim,
                                        float16_t *in_tmp_buf,
                                        float16_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_f16_f16_f16_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, out_tensor, out_tensor_dim, in_tmp_buf,
      tmp_buf);
#else
    return riscv_nn_conv_HWC_f16_f16_f16_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, out_tensor, out_tensor_dim, in_tmp_buf,
      tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_f16_f16_f16_bias(const float16_t *in_tensor,
                                            const uint16_t in_tensor_dim,
                                            const uint16_t in_tensor_ch,
                                            const float16_t *ker_weight,
                                            const uint16_t out_tensor_ch,
                                            const uint16_t ker_dim,
                                            const uint16_t pad,
                                            const uint16_t stride,
                                            const float16_t *bias,
                                            float16_t *out_tensor,
                                            const uint16_t out_tensor_dim,
                                            float16_t *in_tmp_buf,
                                            float16_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_conv_dw_HWC_f16_f16_f16_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, out_tensor, out_tensor_dim, in_tmp_buf,
      tmp_buf);
#else
    return riscv_nn_conv_dw_HWC_f16_f16_f16_bias(
      in_tensor, in_tensor_dim, in_tensor_ch, ker_weight, out_tensor_ch,
      ker_dim, pad, stride, bias, out_tensor, out_tensor_dim, in_tmp_buf,
      tmp_buf);
#endif
}
#endif
 
#endif
 
#ifdef HPM_EN_MATH_NN_RVP32_LIB
#if defined(__zcc__)
#include "tpt_nn_convolution.h"
#else
#include "riscv_nn_convolution.h"
#endif
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_asym_bias_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_dim_y,
                                                const uint16_t in_tensor_ch,
                                                const uint16_t in_tensor_group,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y,
                                                const uint16_t pad_x,
                                                const uint16_t pad_y,
                                                const uint16_t stride_x,
                                                const uint16_t stride_y,
                                                const int32_t *bias,
                                                q7_t *out_tensor,
                                                const int32_t *out_shift,
                                                const int32_t *out_scale,
                                                const int32_t out_offset,
                                                const int32_t in_offset,
                                                const int32_t act_min,
                                                const int32_t act_max,
                                                const uint16_t out_tensor_dim_x,
                                                const uint16_t out_tensor_dim_y,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_conv_asym_params aConv_params = {stride_x, stride_y, pad_x, pad_y,
      in_offset, out_offset,  act_min, act_max};
 
    tpt_nn_per_channel_quant_params aQuant_params = {out_scale, out_shift};
 
    tpt_nn_asym_dims aConv_dims = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      in_tensor_group, ker_dim_x, ker_dim_y, out_tensor_dim_x, out_tensor_dim_y,
      out_tensor_ch};
 
    return tpt_convolve_s8_s8_s8_asym_bias_any(out_tensor, in_tensor, ker_weight,
      bias, &aConv_params, &aQuant_params, &aConv_dims, in_tmp_buf);
 
#else
    return riscv_nn_conv_HWC_s8_s8_s8_asym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      in_tensor_group, ker_weight, out_tensor_ch, ker_dim_x, ker_dim_y, pad_x,
      pad_y, stride_x, stride_y, bias, out_tensor, out_shift, out_scale,
      out_offset, in_offset, act_min, act_max, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_s8_s8_s8_asym_bias_fast_any(const q7_t *in_tensor,
                                    const uint16_t in_tensor_dim_x,
                                    const uint16_t in_tensor_dim_y,
                                    const uint16_t in_tensor_ch,
                                    const uint16_t in_tensor_group,
                                    const q7_t *ker_weight,
                                    const uint16_t out_tensor_ch,
                                    const uint16_t pad_x,
                                    const uint16_t pad_y,
                                    const uint16_t stride_x,
                                    const uint16_t stride_y,
                                    const int32_t *bias,
                                    q7_t *out_tensor,
                                    const int32_t *out_shift,
                                    const int32_t *out_scale,
                                    const int32_t out_offset,
                                    const int32_t in_offset,
                                    const int32_t act_min,
                                    const int32_t act_max,
                                    const uint16_t out_tensor_dim_x,
                                    const uint16_t out_tensor_dim_y,
                                    q15_t *tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_conv_1x1_asym_params aConv_params = {in_offset, out_offset, stride_x,
      stride_y, pad_x, pad_y, act_min, act_max};
 
    tpt_nn_per_channel_quant_params aQuant_params = {out_scale, out_shift};
 
    tpt_nn_1x1_asym_dims aConv_dims = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      in_tensor_group, out_tensor_ch};
 
    return tpt_convolve_1x1_s8_s8_s8_asym_bias_any(out_tensor, in_tensor, ker_weight,
      bias, &aConv_params, &aQuant_params, &aConv_dims, tmp_buf);
 
#else
    return riscv_nn_conv_1x1_HWC_s8_s8_s8_asym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      in_tensor_group, ker_weight, out_tensor_ch, pad_x, pad_y, stride_x,
      stride_y, bias, out_tensor, out_shift, out_scale, out_offset, in_offset,
      act_min, act_max, out_tensor_dim_x, out_tensor_dim_y, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_asym_bias_any(const q7_t *in_tensor,
                                const uint16_t in_tensor_dim_x,
                                const uint16_t in_tensor_dim_y,
                                const uint16_t in_tensor_ch,
                                const q7_t *ker_weight,
                                const uint16_t out_tensor_ch,
                                const uint16_t ch_mult,
                                const uint16_t ker_dim_x,
                                const uint16_t ker_dim_y,
                                const uint16_t pad_x,
                                const uint16_t pad_y,
                                const uint16_t stride_x,
                                const uint16_t stride_y,
                                const int32_t *bias,
                                q7_t *out_tensor,
                                const int32_t *out_shift,
                                const int32_t *out_scale,
                                const uint16_t out_tensor_dim_x,
                                const uint16_t out_tensor_dim_y,
                                const int32_t out_offset,
                                const int32_t in_offset,
                                const int32_t act_min,
                                const int32_t act_max,
                                const uint16_t dilation_x,
                                const uint16_t dilation_y,
                                q15_t *tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_dw_conv_asym_params aConv_params = {in_offset, out_offset, ch_mult,
      stride_x, stride_y, pad_x, pad_y, dilation_x, dilation_y, act_min, act_max};
 
    tpt_nn_per_channel_quant_params aQuant_params = {out_scale, out_shift};
 
    tpt_nn_dw_conv_asym_dims aConv_dims = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      ker_dim_x, ker_dim_y, out_tensor_dim_x, out_tensor_dim_y, out_tensor_ch};
 
    return tpt_depthwise_conv_s8_s8_s8_asym_bias_any(out_tensor, in_tensor, ker_weight,
      bias, &aConv_params, &aQuant_params, &aConv_dims, tmp_buf);
 
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_asym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ch_mult, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x,
      stride_y, bias, out_tensor, out_shift, out_scale, out_tensor_dim_x,
      out_tensor_dim_y, out_offset, in_offset, act_min, act_max, dilation_x,
      dilation_y, tmp_buf);
#endif
}
 
static inline int hpm_nn_conv_1xn_HWC_s8_s8_s8_asym_bias_any(const q7_t *in_tensor,
                                                const uint16_t in_tensor_dim_x,
                                                const uint16_t in_tensor_ch,
                                                const uint16_t in_tensor_group,
                                                const q7_t *ker_weight,
                                                const uint16_t out_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t pad_x,
                                                const uint16_t stride_x,
                                                const int32_t *bias,
                                                q7_t *out_tensor,
                                                const int32_t *out_shift,
                                                const int32_t *out_scale,
                                                const int32_t out_offset,
                                                const int32_t in_offset,
                                                const int32_t act_min,
                                                const int32_t act_max,
                                                const uint16_t out_tensor_dim_x,
                                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_conv_1xn_asym_params aConv_params = {in_offset, out_offset, stride_x, pad_x,
      act_min, act_max};
 
    tpt_nn_per_channel_quant_params aQuant_params = {out_scale, out_shift};
 
    tpt_nn_1xn_asym_dims aConv_dims = {in_tensor_dim_x, in_tensor_ch, in_tensor_group,
      ker_dim_x, out_tensor_dim_x, out_tensor_ch};
 
    return tpt_convolve_1xn_s8_s8_s8_asym_bias_any(out_tensor, in_tensor, ker_weight,
      bias, &aConv_params, &aQuant_params, &aConv_dims, in_tmp_buf);
 
#else
    return riscv_nn_conv_1xn_HWC_s8_s8_s8_asym_bias_any(
      in_tensor, in_tensor_dim_x, in_tensor_ch, in_tensor_group, ker_weight,
      out_tensor_ch, ker_dim_x, pad_x, stride_x, bias, out_tensor, out_shift,
      out_scale, out_offset, in_offset, act_min, act_max, out_tensor_dim_x,
      in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_asym_bias_fast_any(const q7_t *in_tensor,
                                     const uint16_t in_tensor_dim_x,
                                     const uint16_t in_tensor_dim_y,
                                     const uint16_t in_tensor_ch,
                                     const q7_t *ker_weight,
                                     const uint16_t out_tensor_ch,
                                     const uint16_t ker_dim_x,
                                     const uint16_t ker_dim_y,
                                     const uint16_t pad_x,
                                     const uint16_t pad_y,
                                     const uint16_t stride_x,
                                     const uint16_t stride_y,
                                     const int32_t *bias,
                                     q7_t *out_tensor,
                                     const int32_t *out_shift,
                                     const int32_t *out_scale,
                                     const uint16_t out_tensor_dim_x,
                                     const uint16_t out_tensor_dim_y,
                                     const int32_t out_offset,
                                     const int32_t in_offset,
                                     const int32_t act_min,
                                     const int32_t act_max,
                                     const uint16_t dilation_x,
                                     const uint16_t dilation_y,
                                     q15_t *in_tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_dw_conv_asym_fast_params aConv_params = {in_offset, out_offset,
      stride_x, stride_y, pad_x, pad_y, dilation_x, dilation_y, act_min, act_max};
 
    tpt_nn_per_channel_quant_params aQuant_params = {out_scale, out_shift};
 
    tpt_nn_dw_conv_asym_dims aConv_dims = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
      ker_dim_x, ker_dim_y, out_tensor_dim_x, out_tensor_dim_y, out_tensor_ch};
 
    return tpt_depthwise_conv_s8_s8_s8_asym_bias_fast_any(out_tensor, in_tensor, ker_weight,
      bias, &aConv_params, &aQuant_params, &aConv_dims, in_tmp_buf);
 
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_asym_bias_fast_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_weight,
      out_tensor_ch, ker_dim_x, ker_dim_y, pad_x, pad_y, stride_x, stride_y,
      bias, out_tensor, out_shift, out_scale, out_tensor_dim_x,
      out_tensor_dim_y, out_offset, in_offset, act_min, act_max, dilation_x,
      dilation_y, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_conv_1x1_HWC_s8_s8_s8_asym_bias_fast_any_get_buffer_size(const uint16_t in_tensor_ch)
{
#if defined(__zcc__)
    return tpt_convolve_1x1_s8_s8_s8_asym_bias_any_get_buf_size(
      in_tensor_ch);
#else
    return riscv_nn_conv_1x1_HWC_s8_s8_s8_asym_bias_fast_any_get_buffer_size(
      in_tensor_ch);
#endif
}
 
static inline int32_t hpm_nn_conv_dw_HWC_s8_s8_s8_asym_bias_fast_any_get_buffer_size(const uint16_t in_tensor_ch,
                                                  const uint16_t ker_dim_x,
                                                  const uint16_t ker_dim_y)
{
#if defined(__zcc__)
    return tpt_depthwise_conv_s8_s8_s8_asym_bias_fast_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#else
    return riscv_nn_conv_dw_HWC_s8_s8_s8_asym_bias_fast_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#endif
}
 
static inline int32_t hpm_nn_conv_1xn_HWC_s8_s8_s8_asym_bias_any_get_buffer_size(const uint16_t in_tensor_ch,
                                                const uint16_t ker_dim_x,
                                                const uint16_t ker_dim_y)
{
#if defined(__zcc__)
    return tpt_convolve_1xn_s8_s8_s8_asym_bias_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#else
    return riscv_nn_conv_1xn_HWC_s8_s8_s8_asym_bias_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#endif
}
 
static inline int32_t hpm_nn_conv_HWC_s8_s8_s8_asym_bias_any_get_buffer_size(const uint16_t in_tensor_ch,
                                        const uint16_t ker_dim_x,
                                        const uint16_t ker_dim_y)
 
{
#if defined(__zcc__)
    return tpt_nn_conv_HWC_s8_s8_s8_asym_bias_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#else
    return riscv_nn_conv_HWC_s8_s8_s8_asym_bias_any_get_buffer_size(
      in_tensor_ch, ker_dim_x, ker_dim_y);
#endif
}
 
#endif
 
#endif
 
#ifdef HPM_MATH_NN_CONNECTED
#ifdef HPM_EN_MATH_NN_LIB
#if defined(__zcc__)
#include "tpt_nn_fully_connected.h"
#else
#include "riscv_nn_fully_connected.h"
#endif
 
static inline int32_t hpm_nn_fc_s8_s8_s8_sft_bias(const q7_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t bias_lshift,
                                    const uint16_t out_rshift,
                                    const q7_t *bias,
                                    q7_t *out_vec,
                                    q15_t *in_tmp_buf)
#if defined(__zcc__)
    return tpt_nn_fc_s8_s8_s8_sft_bias(in_vec, wt_mat, size, wt_row_num,
                                     bias_lshift, out_rshift, bias, out_vec,
                                     in_tmp_buf);
#else
    return riscv_nn_fc_s8_s8_s8_sft_bias(in_vec, wt_mat, size, wt_row_num,
                                       bias_lshift, out_rshift, bias, out_vec,
                                       in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s8_s8_sft_bias_fast(const q7_t *in_vec,
                                        const q7_t *wt_mat,
                                        const uint16_t size,
                                        const uint16_t wt_row_num,
                                        const uint16_t bias_lshift,
                                        const uint16_t out_rshift,
                                        const q7_t *bias,
                                        q7_t *out_vec,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s8_s8_sft_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                          bias_lshift, out_rshift, bias,
                                          out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_s8_s8_s8_sft_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                            bias_lshift, out_rshift, bias,
                                            out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s16_s16_s16_sft_bias(const q15_t *in_vec,
                                        const q15_t *wt_mat,
                                        const uint16_t size,
                                        const uint16_t wt_row_num,
                                        const uint16_t bias_lshift,
                                        const uint16_t out_rshift,
                                        const q15_t *bias,
                                        q15_t *out_vec,
                                        q15_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s16_s16_s16_sft_bias(in_vec, wt_mat, size, wt_row_num,
                                        bias_lshift, out_rshift, bias, out_vec,
                                        tmp_buf);
#else
    return riscv_nn_fc_s16_s16_s16_sft_bias(in_vec, wt_mat, size, wt_row_num,
                                          bias_lshift, out_rshift, bias,
                                          out_vec, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s16_s16_s16_sft_bias_fast(const q15_t *in_vec,
                                            const q15_t *wt_mat,
                                            const uint16_t size,
                                            const uint16_t wt_row_num,
                                            const uint16_t bias_lshift,
                                            const uint16_t out_rshift,
                                            const q15_t *bias,
                                            q15_t *out_vec,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s16_s16_s16_sft_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                             bias_lshift, out_rshift, bias,
                                             out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_s16_s16_s16_sft_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                               bias_lshift, out_rshift, bias,
                                               out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_mat_vec_s16_s16_s8_sft_bias(const q15_t *in_vec,
                                                const q7_t *wt_mat,
                                                const uint16_t size,
                                                const uint16_t wt_row_num,
                                                const uint16_t bias_lshift,
                                                const uint16_t out_rshift,
                                                const q7_t *bias,
                                                q15_t *out_vec,
                                                q15_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_mat_vec_s16_s16_s8_sft_bias(in_vec, wt_mat, size, wt_row_num,
                                               bias_lshift, out_rshift, bias,
                                               out_vec, tmp_buf);
#else
    return riscv_nn_fc_mat_vec_s16_s16_s8_sft_bias(
      in_vec, wt_mat, size, wt_row_num, bias_lshift, out_rshift, bias, out_vec,
      tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_mat_vec_s16_s16_s8_sft_bias_fast(const q15_t *in_vec,
                                                    const q7_t *wt_mat,
                                                    const uint16_t size,
                                                    const uint16_t wt_row_num,
                                                    const uint16_t bias_lshift,
                                                    const uint16_t out_rshift,
                                                    const q7_t *bias,
                                                    q15_t *out_vec,
                                                    q15_t *tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_mat_vec_s16_s16_s8_sft_bias_fast(
      in_vec, wt_mat, size, wt_row_num, bias_lshift, out_rshift, bias, out_vec,
      tmp_buf);
#else
    return riscv_nn_fc_mat_vec_s16_s16_s8_sft_bias_fast(
      in_vec, wt_mat, size, wt_row_num, bias_lshift, out_rshift, bias, out_vec,
      tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s8_s8_sym_bias(const q7_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    const q31_t *bias,
                                    q7_t *out_vec,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s8_s8_sym_bias(in_vec, wt_mat, size, wt_row_num,
                                     pre_rshift, out_scale, post_rshift, bias,
                                     out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_s8_s8_s8_sym_bias(in_vec, wt_mat, size, wt_row_num,
                                       pre_rshift, out_scale, post_rshift, bias,
                                       out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s16_s8_sym_bias(const q7_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    const q31_t *bias,
                                    q15_t *out_vec,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s16_s8_sym_bias(in_vec, wt_mat, size, wt_row_num,
                                      pre_rshift, out_scale, post_rshift, bias,
                                      out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_s8_s16_s8_sym_bias(in_vec, wt_mat, size, wt_row_num,
                                        pre_rshift, out_scale, post_rshift,
                                        bias, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_u8_s8_sym_bias(const u8_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    const q31_t *bias,
                                    u8_t *out_vec,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_u8_s8_sym_bias(in_vec, wt_mat, size, wt_row_num,
                                     pre_rshift, out_scale, post_rshift, bias,
                                     out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_u8_s8_sym_bias(in_vec, wt_mat, size, wt_row_num,
                                       pre_rshift, out_scale, post_rshift, bias,
                                       out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_s8_s8_sym_bias(const u8_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    const q31_t *bias,
                                    q7_t *out_vec,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_s8_s8_sym_bias(in_vec, wt_mat, size, wt_row_num,
                                     pre_rshift, out_scale, post_rshift, bias,
                                     out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_s8_s8_sym_bias(in_vec, wt_mat, size, wt_row_num,
                                       pre_rshift, out_scale, post_rshift, bias,
                                       out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_s16_s8_sym_bias(const u8_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    const q31_t *bias,
                                    q15_t *out_vec,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_s16_s8_sym_bias(in_vec, wt_mat, size, wt_row_num,
                                      pre_rshift, out_scale, post_rshift, bias,
                                      out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_s16_s8_sym_bias(in_vec, wt_mat, size, wt_row_num,
                                        pre_rshift, out_scale, post_rshift,
                                        bias, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s8_s8_sym(const q7_t *in_vec,
                                const q7_t *wt_mat,
                                const uint16_t size,
                                const uint16_t wt_row_num,
                                const uint16_t pre_rshift,
                                const uint16_t out_scale,
                                const uint16_t post_rshift,
                                q7_t *out_vec,
                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s8_s8_sym(in_vec, wt_mat, size, wt_row_num, pre_rshift,
                                out_scale, post_rshift, out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_s8_s8_s8_sym(in_vec, wt_mat, size, wt_row_num, pre_rshift,
                                  out_scale, post_rshift, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s16_s8_sym(const q7_t *in_vec,
                                const q7_t *wt_mat,
                                const uint16_t size,
                                const uint16_t wt_row_num,
                                const uint16_t pre_rshift,
                                const uint16_t out_scale,
                                const uint16_t post_rshift,
                                q15_t *out_vec,
                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s16_s8_sym(in_vec, wt_mat, size, wt_row_num, pre_rshift,
                                 out_scale, post_rshift, out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_s8_s16_s8_sym(in_vec, wt_mat, size, wt_row_num, pre_rshift,
                                   out_scale, post_rshift, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_u8_s8_sym(const u8_t *in_vec,
                                const q7_t *wt_mat,
                                const uint16_t size,
                                const uint16_t wt_row_num,
                                const uint16_t pre_rshift,
                                const uint16_t out_scale,
                                const uint16_t post_rshift,
                                u8_t *out_vec,
                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_u8_s8_sym(in_vec, wt_mat, size, wt_row_num, pre_rshift,
                                out_scale, post_rshift, out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_u8_s8_sym(in_vec, wt_mat, size, wt_row_num, pre_rshift,
                                  out_scale, post_rshift, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_s8_s8_sym(const u8_t *in_vec,
                                const q7_t *wt_mat,
                                const uint16_t size,
                                const uint16_t wt_row_num,
                                const uint16_t pre_rshift,
                                const uint16_t out_scale,
                                const uint16_t post_rshift,
                                q7_t *out_vec,
                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_s8_s8_sym(in_vec, wt_mat, size, wt_row_num, pre_rshift,
                                out_scale, post_rshift, out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_s8_s8_sym(in_vec, wt_mat, size, wt_row_num, pre_rshift,
                                  out_scale, post_rshift, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_s16_s8_sym(const u8_t *in_vec,
                                const q7_t *wt_mat,
                                const uint16_t size,
                                const uint16_t wt_row_num,
                                const uint16_t pre_rshift,
                                const uint16_t out_scale,
                                const uint16_t post_rshift,
                                q15_t *out_vec,
                                q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_s16_s8_sym(in_vec, wt_mat, size, wt_row_num, pre_rshift,
                                 out_scale, post_rshift, out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_s16_s8_sym(in_vec, wt_mat, size, wt_row_num, pre_rshift,
                                   out_scale, post_rshift, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s8_s8_sym_bias_fast(const q7_t *in_vec,
                                        const q7_t *wt_mat,
                                        const uint16_t size,
                                        const uint16_t wt_row_num,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        const q31_t *bias,
                                        q7_t *out_vec,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s8_s8_sym_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                          pre_rshift, out_scale, post_rshift,
                                          bias, out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_s8_s8_s8_sym_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                            pre_rshift, out_scale, post_rshift,
                                            bias, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s16_s8_sym_bias_fast(const q7_t *in_vec,
                                            const q7_t *wt_mat,
                                            const uint16_t size,
                                            const uint16_t wt_row_num,
                                            const uint16_t pre_rshift,
                                            const uint16_t out_scale,
                                            const uint16_t post_rshift,
                                            const q31_t *bias,
                                            q15_t *out_vec,
                                            q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s16_s8_sym_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                           pre_rshift, out_scale, post_rshift,
                                           bias, out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_s8_s16_s8_sym_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                             pre_rshift, out_scale, post_rshift,
                                             bias, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_u8_s8_sym_bias_fast(const u8_t *in_vec,
                                        const q7_t *wt_mat,
                                        const uint16_t size,
                                        const uint16_t wt_row_num,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        const q31_t *bias,
                                        u8_t *out_vec,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_u8_s8_sym_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                          pre_rshift, out_scale, post_rshift,
                                          bias, out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_u8_s8_sym_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                            pre_rshift, out_scale, post_rshift,
                                            bias, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_s8_s8_sym_bias_fast(const u8_t *in_vec,
                                        const q7_t *wt_mat,
                                        const uint16_t size,
                                        const uint16_t wt_row_num,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        const q31_t *bias,
                                        q7_t *out_vec,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_s8_s8_sym_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                          pre_rshift, out_scale, post_rshift,
                                          bias, out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_s8_s8_sym_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                            pre_rshift, out_scale, post_rshift,
                                            bias, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_s16_s8_sym_bias_fast(const u8_t *in_vec,
                                        const q7_t *wt_mat,
                                        const uint16_t size,
                                        const uint16_t wt_row_num,
                                        const uint16_t pre_rshift,
                                        const uint16_t out_scale,
                                        const uint16_t post_rshift,
                                        const q31_t *bias,
                                        q15_t *out_vec,
                                        q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_s16_s8_sym_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                           pre_rshift, out_scale, post_rshift,
                                           bias, out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_s16_s8_sym_bias_fast(in_vec, wt_mat, size, wt_row_num,
                                             pre_rshift, out_scale, post_rshift,
                                             bias, out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s8_s8_sym_fast(const q7_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    q7_t *out_vec,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s8_s8_sym_fast(in_vec, wt_mat, size, wt_row_num,
                                     pre_rshift, out_scale, post_rshift,
                                     out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_s8_s8_s8_sym_fast(in_vec, wt_mat, size, wt_row_num,
                                       pre_rshift, out_scale, post_rshift,
                                       out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s16_s8_sym_fast(const q7_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    q15_t *out_vec,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s16_s8_sym_fast(in_vec, wt_mat, size, wt_row_num,
                                      pre_rshift, out_scale, post_rshift,
                                      out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_s8_s16_s8_sym_fast(in_vec, wt_mat, size, wt_row_num,
                                        pre_rshift, out_scale, post_rshift,
                                        out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_u8_s8_sym_fast(const u8_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    u8_t *out_vec,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_u8_s8_sym_fast(in_vec, wt_mat, size, wt_row_num,
                                     pre_rshift, out_scale, post_rshift,
                                     out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_u8_s8_sym_fast(in_vec, wt_mat, size, wt_row_num,
                                       pre_rshift, out_scale, post_rshift,
                                       out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_s8_s8_sym_fast(const u8_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    q7_t *out_vec,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_s8_s8_sym_fast(in_vec, wt_mat, size, wt_row_num,
                                     pre_rshift, out_scale, post_rshift,
                                     out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_s8_s8_sym_fast(in_vec, wt_mat, size, wt_row_num,
                                       pre_rshift, out_scale, post_rshift,
                                       out_vec, in_tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_u8_s16_s8_sym_fast(const u8_t *in_vec,
                                    const q7_t *wt_mat,
                                    const uint16_t size,
                                    const uint16_t wt_row_num,
                                    const uint16_t pre_rshift,
                                    const uint16_t out_scale,
                                    const uint16_t post_rshift,
                                    q15_t *out_vec,
                                    q15_t *in_tmp_buf)
{
#if defined(__zcc__)
    return tpt_nn_fc_u8_s16_s8_sym_fast(in_vec, wt_mat, size, wt_row_num,
                                      pre_rshift, out_scale, post_rshift,
                                      out_vec, in_tmp_buf);
#else
    return riscv_nn_fc_u8_s16_s8_sym_fast(in_vec, wt_mat, size, wt_row_num,
                                        pre_rshift, out_scale, post_rshift,
                                        out_vec, in_tmp_buf);
#endif
}
 
static inline void hpm_nn_fc_s8_wt_converter(const q7_t *wt_mat,
                                const uint32_t size,
                                const uint32_t wt_row_num,
                                q7_t *wt_mat_out)
{
#if defined(__zcc__)
    tpt_nn_fc_s8_wt_converter(wt_mat, size, wt_row_num, wt_mat_out);
#else
    riscv_nn_fc_s8_wt_converter(wt_mat, size, wt_row_num, wt_mat_out);
#endif
}
 
static inline void hpm_nn_fc_s16_wt_converter(const q15_t *wt_mat,
                                const uint32_t size,
                                const uint32_t wt_row_num,
                                q15_t *wt_mat_out)
{
#if defined(__zcc__)
    tpt_nn_fc_s16_wt_converter(wt_mat, size, wt_row_num, wt_mat_out);
#else
    riscv_nn_fc_s16_wt_converter(wt_mat, size, wt_row_num, wt_mat_out);
#endif
}
 
static inline void hpm_nn_fc_mat_vec_s8_wt_converter(const q7_t *wt_mat,
                                        const uint32_t size,
                                        const uint32_t wt_row_num,
                                        q7_t *wt_mat_out)
{
#if defined(__zcc__)
    tpt_nn_fc_mat_vec_s8_wt_converter(wt_mat, size, wt_row_num, wt_mat_out);
#else
    riscv_nn_fc_mat_vec_s8_wt_converter(wt_mat, size, wt_row_num, wt_mat_out);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s8_s8_asym_bias(const int8_t *in_vec,
                                    const int8_t *wt_mat,
                                    const uint16_t in_vec_col,
                                    const uint16_t wt_mat_row,
                                    const uint16_t in_vec_group,
                                    const int32_t in_offset,
                                    const int32_t wt_offset,
                                    const int32_t out_scale,
                                    const int32_t out_shift,
                                    const int32_t out_offset,
                                    const int32_t *bias,
                                    int8_t *out_vec,
                                    const int32_t act_min,
                                    const int32_t act_max,
                                    q15_t *tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_fc_params_asym_s8 aFc_params = {in_offset, wt_offset, out_offset, out_scale,
                                         out_shift, act_min, act_max};
    tpt_nn_fc_dims_asym_s8 aFC_dims = {in_vec_col, in_vec_group, wt_mat_row};
 
    return tpt_fully_connected_s8(out_vec, in_vec, wt_mat, bias, &aFc_params,
                                &aFC_dims, tmp_buf);
#else
    return riscv_nn_fc_s8_s8_s8_asym_bias(in_vec, wt_mat, in_vec_col, wt_mat_row,
                                        in_vec_group, in_offset, wt_offset,
                                        out_scale, out_shift, out_offset, bias,
                                        out_vec, act_min, act_max, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s8_s8_asym_bias_get_buffer_size(const uint16_t in_vec_col)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s8_s8_asym_bias_get_buffer_size(in_vec_col);
#else
    return riscv_nn_fc_s8_s8_s8_asym_bias_get_buffer_size(in_vec_col);
#endif
}
 
#endif
 
#ifdef HPM_EN_MATH_NN_RVP32_LIB
#if defined(__zcc__)
#include "tpt_nn_fully_connected.h"
#else
#include "riscv_nn_fully_connected.h"
#endif
 
static inline int32_t hpm_nn_fc_s8_s8_s8_asym_bias(const int8_t *in_vec,
                                    const int8_t *wt_mat,
                                    const uint16_t in_vec_col,
                                    const uint16_t wt_mat_row,
                                    const uint16_t in_vec_group,
                                    const int32_t in_offset,
                                    const int32_t wt_offset,
                                    const int32_t out_scale,
                                    const int32_t out_shift,
                                    const int32_t out_offset,
                                    const int32_t *bias,
                                    int8_t *out_vec,
                                    const int32_t act_min,
                                    const int32_t act_max,
                                    q15_t *tmp_buf)
{
#if defined(__zcc__)
 
    tpt_nn_fc_params_asym_s8 aFc_params = {in_offset, wt_offset, out_offset, out_scale,
                                         out_shift, act_min, act_max};
    tpt_nn_fc_dims_asym_s8 aFC_dims = {in_vec_col, in_vec_group, wt_mat_row};
 
    return tpt_fully_connected_s8(out_vec, in_vec, wt_mat, bias, &aFc_params,
                                &aFC_dims, tmp_buf);
#else
    return riscv_nn_fc_s8_s8_s8_asym_bias(in_vec, wt_mat, in_vec_col, wt_mat_row,
                                        in_vec_group, in_offset, wt_offset,
                                        out_scale, out_shift, out_offset, bias,
                                        out_vec, act_min, act_max, tmp_buf);
#endif
}
 
static inline int32_t hpm_nn_fc_s8_s8_s8_asym_bias_get_buffer_size(const uint16_t in_vec_col)
{
#if defined(__zcc__)
    return tpt_nn_fc_s8_s8_s8_asym_bias_get_buffer_size(in_vec_col);
#else
    return riscv_nn_fc_s8_s8_s8_asym_bias_get_buffer_size(in_vec_col);
#endif
}
 
#endif /* HPM_EN_MATH_NN_RVP32_LIB */
 
#endif
 
#ifdef HPM_MATH_NN_POOLING
#ifdef HPM_EN_MATH_NN_LIB
#if defined(__zcc__)
#include "tpt_nn_pooling.h"
#else
#include "riscv_nn_pooling.h"
#endif
 
static inline void hpm_nn_avepool_HWC_s8(q7_t *in_tensor,
                           const uint16_t in_tensor_dim,
                           const uint16_t in_tensor_ch,
                           const uint16_t ker_dim,
                           const uint16_t pad,
                           const uint16_t stride,
                           const uint16_t out_tensor_dim,
                           q7_t *in_tmp_buf,
                           q7_t *out_tensor)
{
#if defined(__zcc__)
    tpt_nn_avepool_HWC_s8(in_tensor, in_tensor_dim, in_tensor_ch, ker_dim, pad,
                        stride, out_tensor_dim, in_tmp_buf, out_tensor);
#else
    riscv_nn_avepool_HWC_s8(in_tensor, in_tensor_dim, in_tensor_ch, ker_dim, pad,
                          stride, out_tensor_dim, in_tmp_buf, out_tensor);
#endif
}
 
static inline void hpm_nn_avepool_HWC_s8_any(q7_t *in_tensor,
                               const uint16_t in_tensor_dim_x,
                               const uint16_t in_tensor_dim_y,
                               const uint16_t in_tensor_ch,
                               const uint16_t ker_dim_x,
                               const uint16_t ker_dim_y,
                               const uint16_t pad_x,
                               const uint16_t pad_y,
                               const uint16_t stride_x,
                               const uint16_t stride_y,
                               const uint16_t out_tensor_dim_x,
                               const uint16_t out_tensor_dim_y,
                               q7_t *in_tmp_buf,
                               q7_t *out_tensor,
                               const uint16_t out_lshift)
{
#if defined(__zcc__)
    tpt_nn_avepool_HWC_s8_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_dim_x,
      ker_dim_y, pad_x, pad_y, stride_x, stride_y, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, out_tensor, out_lshift);
#else
    riscv_nn_avepool_HWC_s8_any(
      in_tensor, in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch, ker_dim_x,
      ker_dim_y, pad_x, pad_y, stride_x, stride_y, out_tensor_dim_x,
      out_tensor_dim_y, in_tmp_buf, out_tensor, out_lshift);
#endif
}
 
static inline int32_t hpm_nn_avepool_HWC_s8_any_act(const int in_tensor_dim_y,
                                const int in_tensor_dim_x,
                                const int out_tensor_dim_y,
                                const int out_tensor_dim_x,
                                const int stride_y,
                                const int stride_x,
                                const int ker_dim_y,
                                const int ker_dim_x,
                                const int pad_y,
                                const int pad_x,
                                const int act_min,
                                const int act_max,
                                const int in_tensor_ch,
                                int8_t *in_tensor,
                                int16_t *in_tmp_buf,
                                int8_t *out_tensor)
{
#if defined(__zcc__)
 
    tpt_nn_avgpool_params_act_s8 aPool_params = {stride_x, stride_y, pad_x, pad_y,
                                            act_min, act_max};
    tpt_nn_avgpool_dims_act_s8 aPool_dims = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
                                        ker_dim_x, ker_dim_y, out_tensor_dim_x, out_tensor_dim_y};
 
    return tpt_avgpool_s8_any_act(out_tensor, in_tensor, &aPool_params, &aPool_dims, in_tmp_buf);
 
#else
    return riscv_nn_avepool_HWC_s8_any_act(
      in_tensor_dim_y, in_tensor_dim_x, out_tensor_dim_y, out_tensor_dim_x,
      stride_y, stride_x, ker_dim_y, ker_dim_x, pad_y, pad_x, act_min, act_max,
      in_tensor_ch, in_tensor, in_tmp_buf, out_tensor);
#endif
}
 
static inline int32_t hpm_nn_avepool_HWC_s8_any_act_get_buffer_size(const int out_tensor_dim_x, const int in_tensor_ch)
{
#if defined(__zcc__)
    return tpt_nn_avepool_HWC_s8_any_act_get_buffer_size(out_tensor_dim_x,
                                                       in_tensor_ch);
#else
    return riscv_nn_avepool_HWC_s8_any_act_get_buffer_size(out_tensor_dim_x,
                                                         in_tensor_ch);
#endif
}
 
 static inline void hpm_nn_maxpool_HWC_s8(q7_t *in_tensor,
                            const uint16_t in_tensor_dim,
                            const uint16_t in_tensor_ch,
                            const uint16_t ker_dim,
                            const uint16_t pad,
                            const uint16_t stride,
                            const uint16_t out_tensor_dim,
                            q7_t *in_tmp_buf,
                            q7_t *out_tensor)
{
#if defined(__zcc__)
    tpt_nn_maxpool_HWC_s8(in_tensor, in_tensor_dim, in_tensor_ch, ker_dim, pad,
                        stride, out_tensor_dim, in_tmp_buf, out_tensor);
#else
    riscv_nn_maxpool_HWC_s8(in_tensor, in_tensor_dim, in_tensor_ch, ker_dim, pad,
                          stride, out_tensor_dim, in_tmp_buf, out_tensor);
#endif
}
 
static inline int32_t hpm_nn_maxpool_HWC_s8_any_act(const uint16_t in_tensor_dim_y,
                                        const uint16_t in_tensor_dim_x,
                                        const uint16_t out_tensor_dim_y,
                                        const uint16_t out_tensor_dim_x,
                                        const uint16_t stride_y,
                                        const uint16_t stride_x,
                                        const uint16_t ker_dim_y,
                                        const uint16_t ker_dim_x,
                                        const uint16_t pad_y,
                                        const uint16_t pad_x,
                                        const int8_t act_min,
                                        const int8_t act_max,
                                        const uint16_t in_tensor_ch,
                                        int8_t *in_tensor,
                                        int16_t *tmp_buffer,
                                        int8_t *out_tensor)
{
#if defined(__zcc__)
    return tpt_nn_maxpool_HWC_s8_any_act(
      in_tensor_dim_y, in_tensor_dim_x, out_tensor_dim_y, out_tensor_dim_x,
      stride_y, stride_x, ker_dim_y, ker_dim_x, pad_y, pad_x, act_min, act_max,
      in_tensor_ch, in_tensor, tmp_buffer, out_tensor);
#else
    return riscv_nn_maxpool_HWC_s8_any_act(
      in_tensor_dim_y, in_tensor_dim_x, out_tensor_dim_y, out_tensor_dim_x,
      stride_y, stride_x, ker_dim_y, ker_dim_x, pad_y, pad_x, act_min, act_max,
      in_tensor_ch, in_tensor, tmp_buffer, out_tensor);
#endif
}
 
#endif
 
#ifdef HPM_EN_MATH_NN_RVP32_LIB
#if defined(__zcc__)
#include "tpt_nn_pooling.h"
#else
#include "riscv_nn_pooling.h"
#endif
 
static inline int32_t hpm_nn_avepool_HWC_s8_any_act(const int in_tensor_dim_y,
                                const int in_tensor_dim_x,
                                const int out_tensor_dim_y,
                                const int out_tensor_dim_x,
                                const int stride_y,
                                const int stride_x,
                                const int ker_dim_y,
                                const int ker_dim_x,
                                const int pad_y,
                                const int pad_x,
                                const int act_min,
                                const int act_max,
                                const int in_tensor_ch,
                                int8_t *in_tensor,
                                int16_t *in_tmp_buf,
                                int8_t *out_tensor)
{
#if defined(__zcc__)
 
    tpt_nn_avgpool_params_act_s8 aPool_params = {stride_x, stride_y, pad_x, pad_y,
                                            act_min, act_max};
    tpt_nn_avgpool_dims_act_s8 aPool_dims = {in_tensor_dim_x, in_tensor_dim_y, in_tensor_ch,
                                        ker_dim_x, ker_dim_y, out_tensor_dim_x, out_tensor_dim_y};
 
    return tpt_avgpool_s8_any_act(out_tensor, in_tensor, &aPool_params, &aPool_dims, in_tmp_buf);
 
#else
    return riscv_nn_avepool_HWC_s8_any_act(
      in_tensor_dim_y, in_tensor_dim_x, out_tensor_dim_y, out_tensor_dim_x,
      stride_y, stride_x, ker_dim_y, ker_dim_x, pad_y, pad_x, act_min, act_max,
      in_tensor_ch, in_tensor, in_tmp_buf, out_tensor);
#endif
}
 
static inline int32_t hpm_nn_avepool_HWC_s8_any_act_get_buffer_size(const int out_tensor_dim_x, const int in_tensor_ch)
{
#if defined(__zcc__)
    return tpt_nn_avepool_HWC_s8_any_act_get_buffer_size(out_tensor_dim_x,
                                                       in_tensor_ch);
#else
    return riscv_nn_avepool_HWC_s8_any_act_get_buffer_size(out_tensor_dim_x,
                                                         in_tensor_ch);
#endif
}
 
#endif
#endif
 
#ifdef HPM_MATH_NN_SOFTMAX
#ifdef HPM_EN_MATH_NN_LIB
#if defined(__zcc__)
#include "tpt_nn_softmax.h"
#else
#include "riscv_nn_softmax.h"
#endif
 
static inline void hpm_nn_softmax_s8_fast(const q7_t *in_vec,
                            const uint16_t size,
                            q7_t *out_vec)
{
#if defined(__zcc__)
    tpt_nn_softmax_s8_fast(in_vec, size, out_vec);
#else
    riscv_nn_softmax_s8_fast(in_vec, size, out_vec);
#endif
}
 
static inline void hpm_nn_softmax_s16_fast(const q15_t *in_vec,
                            const uint16_t size,
                            q15_t *out_vec)
{
#if defined(__zcc__)
    tpt_nn_softmax_s16_fast(in_vec, size, out_vec);
#else
    riscv_nn_softmax_s16_fast(in_vec, size, out_vec);
#endif
}
 
static inline void hpm_nn_softmax_s8_hp(const int8_t *in_tensor,
                            const int32_t in_tensor_row,
                            const int32_t in_tensor_col,
                            const int32_t scale,
                            const int32_t lshift,
                            const int32_t diff_min,
                            int8_t *out_tensor)
{
#if defined(__zcc__)
    tpt_softmax_s8_hp(out_tensor, in_tensor, in_tensor_row, in_tensor_col, scale, lshift,
                       diff_min);
#else
    riscv_nn_softmax_s8_hp(in_tensor, in_tensor_row, in_tensor_col, scale, lshift,
                         diff_min, out_tensor);
#endif
}
 
static inline void hpm_nn_softmax_u8_hp(const uint8_t *in_tensor,
                            const int32_t in_tensor_row,
                            const int32_t in_tensor_col,
                            const int32_t scale,
                            const int32_t lshift,
                            const int32_t diff_min,
                            uint8_t *out_tensor)
{
#if defined(__zcc__)
    tpt_nn_softmax_u8_hp(in_tensor, in_tensor_row, in_tensor_col, scale, lshift,
                       diff_min, out_tensor);
#else
    riscv_nn_softmax_u8_hp(in_tensor, in_tensor_row, in_tensor_col, scale, lshift,
                         diff_min, out_tensor);
#endif
}
 
#endif
 
#ifdef HPM_EN_MATH_NN_RVP32_LIB
#if defined(__zcc__)
#include "tpt_nn_softmax.h"
#else
#include "riscv_nn_softmax.h"
#endif
 
static inline void hpm_nn_softmax_s8_hp(const int8_t *in_tensor,
                            const int32_t in_tensor_row,
                            const int32_t in_tensor_col,
                            const int32_t scale,
                            const int32_t lshift,
                            const int32_t diff_min,
                            int8_t *out_tensor)
{
#if defined(__zcc__)
    tpt_softmax_s8_hp(out_tensor, in_tensor, in_tensor_row, in_tensor_col, scale, lshift,
                       diff_min);
#else
    riscv_nn_softmax_s8_hp(in_tensor, in_tensor_row, in_tensor_col, scale, lshift,
                         diff_min, out_tensor);
#endif
}
#endif
 
#endif
 
#ifdef HPM_MATH_NN_UTIL
#ifdef HPM_EN_MATH_NN_LIB
#if defined(__zcc__)
#include "tpt_nn_util.h"
#else
#include "riscv_nn_util.h"
#endif
 
#ifdef __riscv_zfh
static inline int32_t hpm_nn_exp_f16(const float16_t *in_vec,
                        const uint32_t size,
                        float16_t *out_vec)
{
#if defined(__zcc__)
    return tpt_nn_exp_f16(in_vec, size, out_vec);
#else
    return riscv_nn_exp_f16(in_vec, size, out_vec);
#endif
}
#endif
 
static inline void hpm_nn_reshape_s8(const int8_t *in_tensor,
                        int8_t *out_tensor,
                        const uint32_t size)
{
#if defined(__zcc__)
    tpt_reshape_s8(out_tensor, in_tensor, size);
#else
    riscv_nn_reshape_s8(in_tensor, out_tensor, size);
#endif
}
 
static inline int32_t hpm_nn_top_k_s8(q7_t *in_vec,
                        uint32_t size,
                        uint32_t k,
                        q7_t *val,
                        uint32_t *idx)
{
#if defined(__zcc__)
    return tpt_nn_top_k_s8(in_vec, size, k, val, idx);
#else
    return riscv_nn_top_k_s8(in_vec, size, k, val, idx);
#endif
}
 
#ifdef __riscv_zfh
static inline int32_t hpm_nn_top_k_f16(float16_t *in_vec,
                        uint32_t size,
                        uint32_t k,
                        float16_t *val,
                        uint32_t *idx)
{
#if defined(__zcc__)
    return tpt_nn_top_k_f16(in_vec, size, k, val, idx);
#else
    return riscv_nn_top_k_f16(in_vec, size, k, val, idx);
#endif
}
#endif
 
#endif
 
#ifdef HPM_EN_MATH_NN_RVP32_LIB
#if defined(__zcc__)
#include "tpt_nn_util.h"
#else
#include "riscv_nn_util.h"
#endif
 
static inline void hpm_nn_reshape_s8(const int8_t *in_tensor,
                        int8_t *out_tensor,
                        const uint32_t size)
{
#if defined(__zcc__)
    tpt_reshape_s8(out_tensor, in_tensor, size);
#else
    riscv_nn_reshape_s8(in_tensor, out_tensor, size);
#endif
}
 
#endif
 
#endif
 
#ifdef  __cplusplus
}
#endif
#endif