//! RISC-V 封装的 SIMD 内部函数; 共享部分。
//!
//! RV64 只有部分放在 riscv64 文件夹中。
use crate::arch::asm;

/// 添加包装的 16 位有符号数，丢弃溢出位
#[inline]
pub fn add16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x20, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将包装的 16 位有符号数的总和减半，丢弃最少位
#[inline]
pub fn radd16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x00, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将包装的 16 位无符号数的总和减半，丢弃最少位
#[inline]
pub fn uradd16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x10, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 添加包装的 16 位有符号数字，在数字边界处饱和
#[inline]
pub fn kadd16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x08, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 添加包装的 16 位无符号数字，在数字边界处饱和
#[inline]
pub fn ukadd16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x18, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 减去包装的 16 位有符号数，丢弃溢出位
#[inline]
pub fn sub16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x21, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将包装的 16 位有符号数的减法结果减半，丢弃最少位
#[inline]
pub fn rsub16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x01, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将包装的 16 位无符号数的减法结果减半，丢弃最少位
#[inline]
pub fn ursub16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x11, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 减去包装的 16 位有符号数，在数字边界处饱和
#[inline]
pub fn ksub16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x09, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 减去包装的 16 位无符号数，在数字边界处饱和
#[inline]
pub fn uksub16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x19, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 交叉加减包装的 16 位有符号数，丢弃溢出位
#[inline]
pub fn cras16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x22, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 交叉一半的加法和减法包装的 16 位有符号数，丢弃最少位
#[inline]
pub fn rcras16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x02, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 交叉一半的加法和减法包装的 16 位无符号数，丢弃最少位
#[inline]
pub fn urcras16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x12, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 交叉加减包装的 16 位有符号数字，在数字边界处饱和
#[inline]
pub fn kcras16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x0A, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 交叉加减包装的 16 位无符号数，在数字边界处饱和
#[inline]
pub fn ukcras16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x1A, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 交叉减法和加法包装的 16 位有符号数，丢弃溢出位
#[inline]
pub fn crsa16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x23, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 交叉减半和加包装的 16 位有符号数，丢弃最少位
#[inline]
pub fn rcrsa16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x03, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 交叉减半和加包装的 16 位无符号数，丢弃最少位
#[inline]
pub fn urcrsa16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x13, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 交叉减法和加法包装的 16 位有符号数，在数字边界处饱和
#[inline]
pub fn kcrsa16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x0B, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 交叉减法和加法包装的 16 位无符号数，在数值边界处饱和
#[inline]
pub fn ukcrsa16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x1B, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 直接加减包装的 16 位有符号数，丢弃溢出位
#[inline]
pub fn stas16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x7A, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 16 位有符号数的加减法，丢弃最少位
#[inline]
pub fn rstas16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x5A, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 直接加减包装的 16 位无符号数的一半，丢弃最少位
#[inline]
pub fn urstas16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x6A, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 直接加减包装的 16 位有符号数字，在数字边界处饱和
#[inline]
pub fn kstas16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x62, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 直接加减包装的 16 位无符号数字，在数字边界处饱和
#[inline]
pub fn ukstas16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x72, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 直接减去和添加包装的 16 位有符号数，丢弃溢出位
#[inline]
pub fn stsa16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x7B, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 减法和加法的直接一半包装的 16 位有符号数，丢弃最少位
#[inline]
pub fn rstsa16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x5B, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 直接减半和加包装的 16 位无符号数，丢弃最少位
#[inline]
pub fn urstsa16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x6B, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 直接减去和添加包装的 16 位有符号数字，在数字边界处饱和
#[inline]
pub fn kstsa16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x63, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 直接减去和添加包装的 16 位无符号数，在数字边界处饱和
#[inline]
pub fn ukstsa16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x73, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 添加包装的 8 位有符号数，丢弃溢出位
#[inline]
pub fn add8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x24, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将包装的 8 位有符号数的总和减半，丢弃最少位
#[inline]
pub fn radd8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x04, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将包装的 8 位无符号数的总和减半，丢弃最少位
#[inline]
pub fn uradd8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x14, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 添加包装的 8 位有符号数字，在数字边界处饱和
#[inline]
pub fn kadd8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x0C, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 添加包装的 8 位无符号数字，在数字边界处饱和
#[inline]
pub fn ukadd8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x1C, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 减去包装的 8 位有符号数，丢弃溢出位
#[inline]
pub fn sub8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x25, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将包装的 8 位有符号数的减法结果减半，丢弃最少位
#[inline]
pub fn rsub8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x05, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将包装的 8 位无符号数的减法结果减半，丢弃最少位
#[inline]
pub fn ursub8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x15, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 减去包装的 8 位有符号数，在数字边界处饱和
#[inline]
pub fn ksub8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x0D, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 减去包装的 8 位无符号数字，在数字边界处饱和
#[inline]
pub fn uksub8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x1D, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 算术右移封装的 16 位元素，不四舍五入
#[inline]
pub fn sra16(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x28, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 算术右移包装的 16 位元素与四舍五入
#[inline]
pub fn sra16u(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x30, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 逻辑右移包装的 16 位元素，不进行四舍五入
#[inline]
pub fn srl16(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x29, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 带舍入的逻辑右移包装的 16 位元素
#[inline]
pub fn srl16u(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x31, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 逻辑左移封装的 16 位元素，丢弃溢出位
#[inline]
pub fn sll16(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x2A, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 逻辑左移包装的 16 位元素，在数字边界处饱和
#[inline]
pub fn ksll16(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x32, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 逻辑饱和左移然后算术右移包装的 16 位元素
#[inline]
pub fn kslra16(a: usize, b: i32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x2B, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 逻辑饱和左移然后算术右移包装的 16 位元素
#[inline]
pub fn kslra16u(a: usize, b: i32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x33, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 算术右移封装的 8 位元素，不四舍五入
#[inline]
pub fn sra8(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x2C, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 算术右移包装的 8 位元素与四舍五入
#[inline]
pub fn sra8u(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x34, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 不四舍五入的逻辑右移包装的 8 位元素
#[inline]
pub fn srl8(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x2D, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 带舍入的逻辑右移包装的 8 位元素
#[inline]
pub fn srl8u(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x35, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 逻辑左移封装的 8 位元素，丢弃溢出位
#[inline]
pub fn sll8(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x2E, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 逻辑左移包装的 8 位元素，在数字边界处饱和
#[inline]
pub fn ksll8(a: usize, b: u32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x36, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 逻辑饱和左移然后算术右移封装的 8 位元素
#[inline]
pub fn kslra8(a: usize, b: i32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x2F, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 逻辑饱和左移然后算术右移封装的 8 位元素
#[inline]
pub fn kslra8u(a: usize, b: i32) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x37, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 比较包装的 16 位元素的相等性
#[inline]
pub fn cmpeq16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x26, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 比较 16 位封装的有符号整数是否小于其他
#[inline]
pub fn scmplt16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x06, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 比较 16 位封装的有符号整数是否小于或等于其他整数
#[inline]
pub fn scmple16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x0E, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 比较 16 位封装的无符号整数是否小于其他整数
#[inline]
pub fn ucmplt16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x16, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 比较 16 位封装的无符号整数是否小于或等于其他整数
#[inline]
pub fn ucmple16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x1E, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 比较包装的 8 位元素的相等性
#[inline]
pub fn cmpeq8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x27, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 比较 8 位封装的有符号整数是否小于其他
#[inline]
pub fn scmplt8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x07, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 比较 8 位封装的有符号整数是否小于或等于其他整数
#[inline]
pub fn scmple8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x0F, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 比较 8 位封装的无符号整数是否小于其他整数
#[inline]
pub fn ucmplt8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x17, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 比较 8 位封装的无符号整数是否小于或等于其他整数
#[inline]
pub fn ucmple8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x1F, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 从 16 位封装的有符号整数中获取最小值
#[inline]
pub fn smin16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x40, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 从 16 位封装的无符号整数中获取最小值
#[inline]
pub fn umin16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x48, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 从 16 位封装的有符号整数中获取最大值
#[inline]
pub fn smax16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x41, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 从 16 位封装的无符号整数中获取最大值
#[inline]
pub fn umax16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x49, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/* todo: sclip16, uclip16 */

/// 计算包装的 16 位有符号整数的绝对值
#[inline]
pub fn kabs16(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAD1", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 计算包装的 16 位元素的冗余符号位数
#[inline]
pub fn clrs16(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAE8", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 计算包装的 16 位元素的前导零位的数量
#[inline]
pub fn clz16(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAE9", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 在寄存器的每个 32 位字中交换 16 位半字
#[inline]
pub fn swap16(a: usize) -> usize {
    let value: usize;
    // 该指令是 `pkbt rd, rs1, rs1` 的别名。
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x0F, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 从 8 位封装的有符号整数中获取最小值
#[inline]
pub fn smin8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x44, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 从 8 位封装的无符号整数中获取最小值
#[inline]
pub fn umin8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x4C, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 从 8 位封装的有符号整数中获取最大值
#[inline]
pub fn smax8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x45, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 从 8 位封装的无符号整数中获取最大值
#[inline]
pub fn umax8(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x4D, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/* todo: sclip8, uclip8 */

/// 计算包装的 8 位有符号整数的绝对值
#[inline]
pub fn kabs8(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAD0", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 计算包装的 8 位元素的冗余符号位数
#[inline]
pub fn clrs8(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAE0", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 计算包装的 8 位元素的前导零位的数量
#[inline]
pub fn clz8(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAE1", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 在寄存器的每个 16 位半字内交换 8 位字节。
#[inline]
pub fn swap8(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAD8", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 将第一个和第零个解包成每个 32 位块中的两个 16 位有符号半字
#[inline]
pub fn sunpkd810(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAC8", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 将第二个和第零个解包成每个 32 位块中的两个 16 位有符号半字
#[inline]
pub fn sunpkd820(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAC9", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 将第三个和第零个解包成每个 32 位块中的两个 16 位有符号半字
#[inline]
pub fn sunpkd830(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xACA", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 将第三个和第一个解包成每个 32 位块中的两个 16 位有符号半字
#[inline]
pub fn sunpkd831(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xACB", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 将第三个和第二个解包成每个 32 位块中的两个 16 位有符号半字
#[inline]
pub fn sunpkd832(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAD3", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 解包 first 和 zeroth 成每个 32 位块中的两个 16 位无符号半字
#[inline]
pub fn zunpkd810(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xACC", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 解包第二个和第零个在每个 32 位块中分成两个 16 位无符号半字
#[inline]
pub fn zunpkd820(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xACD", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 将第三个和第零个解包成两个 16 位无符号半字在每个 32 位块中
#[inline]
pub fn zunpkd830(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xACE", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 解包第三个和第一个成每个 32 位块中的两个 16 位无符号半字
#[inline]
pub fn zunpkd831(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xACF", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 将第三个和第二个解包成每个 32 位块中的两个 16 位无符号半字
#[inline]
pub fn zunpkd832(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAD7", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

// todo: pkbb16, pktt16

/// 从 32 位块的底部和顶部打包两个 16 位数据
#[inline]
pub fn pkbt16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x1, 0x0F, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 从 32 位块的上半部分和下半部分打包两个 16 位数据
#[inline]
pub fn pktb16(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x1, 0x1F, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 计算包装的 32 位元素的冗余符号位数
#[inline]
pub fn clrs32(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAF8", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 计算包装的 32 位元素的前导零位的数量
#[inline]
pub fn clz32(a: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn i 0x77, 0x0, {}, {}, 0xAF9", lateout(reg) value, in(reg) a, options(pure, nomem, nostack))
    }
    value
}

/// 计算无符号 8 位数据元素的绝对差之和
#[inline]
pub fn pbsad(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x7E, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 计算并累加无符号 8 位数据元素的绝对差之和
#[inline]
pub fn pbsada(t: usize, a: usize, b: usize) -> usize {
    let mut value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x7F, {}, {}, {}", inlateout(reg) t => value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将带符号的 8 位元素相乘并在结果中添加 16 位元素以用于包装的 32 位块
#[inline]
pub fn smaqa(t: usize, a: usize, b: usize) -> usize {
    let mut value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x64, {}, {}, {}", inlateout(reg) t => value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将无符号 8 位元素相乘并在结果中添加 16 位元素以用于包装的 32 位块
#[inline]
pub fn umaqa(t: usize, a: usize, b: usize) -> usize {
    let mut value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x66, {}, {}, {}", inlateout(reg) t => value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 将有符号乘以无符号 8 位并在包装的 32 位块的结果上添加 16 位元素
#[inline]
pub fn smaqasu(t: usize, a: usize, b: usize) -> usize {
    let mut value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x0, 0x65, {}, {}, {}", inlateout(reg) t => value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 添加具有 Q15 饱和度的两个寄存器的有符号低 16 位内容
#[inline]
pub fn kaddh(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x1, 0x02, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 用 Q15 饱和减去两个寄存器的有符号低 16 位内容
#[inline]
pub fn ksubh(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x1, 0x03, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 添加具有 U16 饱和度的两个寄存器的有符号低 16 位内容
#[inline]
pub fn ukaddh(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x1, 0x0A, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}

/// 用 U16 饱和减去两个寄存器的有符号低 16 位内容
#[inline]
pub fn uksubh(a: usize, b: usize) -> usize {
    let value: usize;
    unsafe {
        asm!(".insn r 0x77, 0x1, 0x0B, {}, {}, {}", lateout(reg) value, in(reg) a, in(reg) b, options(pure, nomem, nostack))
    }
    value
}